source/projects/calf/tests/python/test_parser.py

"""
Tests of calf.parser
"""

import calf.parser as cp
from conftest import parametrize

import pytest


@parametrize("text", [
    '"',
    '"foo bar',
    '"""foo bar',
    '"""foo bar"',
])
def test_bad_strings_raise(text):
    """Tests asserting we won't let obviously bad strings fly."""
    # FIXME (arrdem 2021-03-13):
    #   Can we provide this behavior in the lexer rather than in the parser?
    with pytest.raises(ValueError):
        next(cp.parse_buffer(text))


@parametrize("text", [
    "[1.0",
    "(1.0",
    "{1.0",
])
def test_unterminated_raises(text):
    """Tests asserting that we don't let unterminated collections parse."""
    with pytest.raises(cp.CalfMissingCloseParseError):
        next(cp.parse_buffer(text))


@parametrize("text", [
    "[{]",
    "[(]",
    "({)",
    "([)",
    "{(}",
    "{[}",
])
def test_unbalanced_raises(text):
    """Tests asserting that we don't let missmatched collections parse."""
    with pytest.raises(cp.CalfUnexpectedCloseParseError):
        next(cp.parse_buffer(text))


@parametrize("buff, value", [
    ('"foo"', "foo"),
    ('"foo\tbar"', "foo\tbar"),
    ('"foo\n\rbar"', "foo\n\rbar"),
    ('"foo\\"bar\\""', "foo\"bar\""),
    ('"""foo"""', 'foo'),
    ('"""foo"bar"baz"""', 'foo"bar"baz'),
])
def test_strings_round_trip(buff, value):
    assert next(cp.parse_buffer(buff)) == value

@parametrize('text, element_types', [
    # Integers
    ("(1)", ["INTEGER"]),
    ("( 1 )", ["INTEGER"]),
    ("(,1,)", ["INTEGER"]),
    ("(1\n)", ["INTEGER"]),
    ("(\n1\n)", ["INTEGER"]),
    ("(1, 2, 3, 4)", ["INTEGER", "INTEGER", "INTEGER", "INTEGER"]),

    # Floats
    ("(1.0)", ["FLOAT"]),
    ("(1.0e0)", ["FLOAT"]),
    ("(1e0)", ["FLOAT"]),
    ("(1e0)", ["FLOAT"]),

    # Symbols
    ("(foo)", ["SYMBOL"]),
    ("(+)", ["SYMBOL"]),
    ("(-)", ["SYMBOL"]),
    ("(*)", ["SYMBOL"]),
    ("(foo-bar)", ["SYMBOL"]),
    ("(+foo-bar+)", ["SYMBOL"]),
    ("(+foo-bar+)", ["SYMBOL"]),
    ("( foo bar )", ["SYMBOL", "SYMBOL"]),

    # Keywords
    ("(:foo)", ["KEYWORD"]),
    ("( :foo )", ["KEYWORD"]),
    ("(\n:foo\n)", ["KEYWORD"]),
    ("(,:foo,)", ["KEYWORD"]),
    ("(:foo :bar)", ["KEYWORD", "KEYWORD"]),
    ("(:foo :bar 1)", ["KEYWORD", "KEYWORD", "INTEGER"]),

    # Strings
    ('("foo", "bar", "baz")', ["STRING", "STRING", "STRING"]),

    # Lists
    ('([] [] ())', ["SQLIST", "SQLIST", "LIST"]),
])
def test_parse_list(text, element_types):
    """Test we can parse various lists of contents."""
    l_t = next(cp.parse_buffer(text, discard_whitespace=True))
    assert l_t.type == "LIST"
    assert [t.type for t in l_t] == element_types


@parametrize('text, element_types', [
    # Integers
    ("[1]", ["INTEGER"]),
    ("[ 1 ]", ["INTEGER"]),
    ("[,1,]", ["INTEGER"]),
    ("[1\n]", ["INTEGER"]),
    ("[\n1\n]", ["INTEGER"]),
    ("[1, 2, 3, 4]", ["INTEGER", "INTEGER", "INTEGER", "INTEGER"]),

    # Floats
    ("[1.0]", ["FLOAT"]),
    ("[1.0e0]", ["FLOAT"]),
    ("[1e0]", ["FLOAT"]),
    ("[1e0]", ["FLOAT"]),

    # Symbols
    ("[foo]", ["SYMBOL"]),
    ("[+]", ["SYMBOL"]),
    ("[-]", ["SYMBOL"]),
    ("[*]", ["SYMBOL"]),
    ("[foo-bar]", ["SYMBOL"]),
    ("[+foo-bar+]", ["SYMBOL"]),
    ("[+foo-bar+]", ["SYMBOL"]),
    ("[ foo bar ]", ["SYMBOL", "SYMBOL"]),

    # Keywords
    ("[:foo]", ["KEYWORD"]),
    ("[ :foo ]", ["KEYWORD"]),
    ("[\n:foo\n]", ["KEYWORD"]),
    ("[,:foo,]", ["KEYWORD"]),
    ("[:foo :bar]", ["KEYWORD", "KEYWORD"]),
    ("[:foo :bar 1]", ["KEYWORD", "KEYWORD", "INTEGER"]),

    # Strings
    ('["foo", "bar", "baz"]', ["STRING", "STRING", "STRING"]),

    # Lists
    ('[[] [] ()]', ["SQLIST", "SQLIST", "LIST"]),
])
def test_parse_sqlist(text, element_types):
    """Test we can parse various 'square' lists of contents."""
    l_t = next(cp.parse_buffer(text, discard_whitespace=True))
    assert l_t.type == "SQLIST"
    assert [t.type for t in l_t] == element_types


@parametrize('text, element_pairs', [
    ("{}",
     []),

    ("{:foo 1}",
     [["KEYWORD", "INTEGER"]]),

    ("{:foo 1, :bar 2}",
     [["KEYWORD", "INTEGER"],
      ["KEYWORD", "INTEGER"]]),

    ("{foo 1, bar 2}",
     [["SYMBOL", "INTEGER"],
      ["SYMBOL", "INTEGER"]]),

    ("{foo 1, bar -2}",
     [["SYMBOL", "INTEGER"],
      ["SYMBOL", "INTEGER"]]),

    ("{foo 1, bar -2e0}",
     [["SYMBOL", "INTEGER"],
      ["SYMBOL", "FLOAT"]]),

    ("{foo ()}",
     [["SYMBOL", "LIST"]]),

    ("{foo []}",
     [["SYMBOL", "SQLIST"]]),

    ("{foo {}}",
     [["SYMBOL", "DICT"]]),

    ('{"foo" {}}',
     [["STRING", "DICT"]])
])
def test_parse_dict(text, element_pairs):
    """Test we can parse various mappings."""
    d_t = next(cp.parse_buffer(text, discard_whitespace=True))
    assert d_t.type == "DICT"
    assert [[t.type for t in pair] for pair in d_t.value] == element_pairs


@parametrize("text", [
    "{1}",
    "{1, 2, 3}",
    "{:foo}",
    "{:foo :bar :baz}"
])
def test_parse_bad_dict(text):
    """Assert that dicts with missmatched pairs don't parse."""
    with pytest.raises(Exception):
        next(cp.parse_buffer(text))


@parametrize("text", [
    "()",
    "(1 1.1 1e2 -2 foo :foo foo/bar :foo/bar [{},])",
    "{:foo bar, :baz [:qux]}",
    "'foo",
    "'[foo bar :baz 'qux, {}]",
    "#foo []",
    "^{} bar",
])
def test_examples(text):
    """Shotgun examples showing we can parse some stuff."""

    assert list(cp.parse_buffer(text))