Fixed #131 : Implement ExprToConditions

Fixed #130 : ArithmeticOperatorParser
Fixed #129 : python_wrapper : create_namespace
Fixed #128 : ExpressionParser: Cannot parse func(x) infixed concept 'xxx'

tests/parsers/test_ListParser.py

@@ -14,9 +14,9 @@ or_token = Token(TokenKind.IDENTIFIER, "or", -1, -1, -1)
 
 
 class TestListParser(TestUsingMemoryBasedSheerka):
-    def init_parser(self, sep=None):
+    def init_parser(self, strict=True, sep=None):
         sheerka, context = self.init_concepts()
-        parser = ListParser(sep)
+        parser = ListParser(strict, sep)
         return sheerka, context, parser
 
     @pytest.mark.parametrize("expression, sep, expected", [
@@ -26,12 +26,13 @@ class TestListParser(TestUsingMemoryBasedSheerka):
         ("x", None, L_EXPR(None, None, EXPR("x"))),
         ("[x, foo y, z]", None, L_EXPR("[", "]", EXPR("x"), EXPR("foo y"), EXPR("z"))),
         ("{x, foo y, z}", None, L_EXPR("{", "}", EXPR("x"), EXPR("foo y"), EXPR("z"))),
-        ("(x; y; z)", semi_colon, L_EXPR("(", ")", EXPR("x"), EXPR("y"), EXPR("z"), sep=semi_colon, source="(x; y; z)")),
+        ("(x; y; z)", semi_colon, L_EXPR("(", ")", "x", "y", "z", sep=semi_colon, source="(x; y; z)")),
         ("x; y; z", semi_colon, L_EXPR(None, None, EXPR("x"), EXPR("y"), EXPR("z"), sep=semi_colon, source="x; y; z")),
-        ("x or y or z", or_token, L_EXPR(None, None, EXPR("x"), EXPR("y"), EXPR("z"), sep=or_token, source="x or y or z")),
+        ("x or y or z", or_token,
+         L_EXPR(None, None, EXPR("x"), EXPR("y"), EXPR("z"), sep=or_token, source="x or y or z")),
     ])
     def test_i_can_parse_expression(self, expression, sep, expected):
-        sheerka, context, parser = self.init_parser(sep)
+        sheerka, context, parser = self.init_parser(strict=False, sep=sep)
 
         expected = get_expr_node_from_test_node(expression, expected)
         res = parser.parse(context, ParserInput(expression))
@@ -42,6 +43,24 @@ class TestListParser(TestUsingMemoryBasedSheerka):
         assert sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
         assert expressions == expected
 
+    @pytest.mark.parametrize("expression, expected", [
+        ("()", L_EXPR("(", ")")),
+        ("(a, b)", L_EXPR("(", ")", EXPR("a"), EXPR("b"))),
+        ("a, b", None),
+    ])
+    def test_parenthesis_are_mandatory_when_strict(self, expression, expected):
+        sheerka, context, parser = self.init_parser(strict=True)
+        res = parser.parse(context, ParserInput(expression))
+
+        if expected:
+            expected = get_expr_node_from_test_node(expression, expected)
+            assert res.status
+            assert sheerka.isinstance(res.body, BuiltinConcepts.PARSER_RESULT)
+            assert res.body.body == expected
+        else:
+            assert not res.status
+            assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
+
     @pytest.mark.parametrize("expression, starting", [
         ("(", TokenKind.LPAR),
         ("(x, y", TokenKind.LPAR),