Added SyaNodeParser (finally, after one month)

tests/evaluators/test_AddConceptEvaluator.py

@@ -2,11 +2,11 @@ import ast
 import pytest
 
 from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
-from core.concept import VARIABLE_PREFIX, Concept
+from core.concept import VARIABLE_PREFIX, Concept, DEFINITION_TYPE_BNF, DEFINITION_TYPE_DEF
 from core.tokenizer import Tokenizer
 from evaluators.AddConceptEvaluator import AddConceptEvaluator
 from parsers.BaseParser import BaseParser
-from parsers.ConceptLexerParser import Sequence, StrMatch, ZeroOrMore, ConceptExpression
+from parsers.BnfNodeParser import Sequence, StrMatch, ZeroOrMore, ConceptExpression
 from parsers.BnfParser import BnfParser
 from parsers.DefaultParser import DefConceptNode, NameNode
 from parsers.PythonParser import PythonNode, PythonParser
@@ -65,10 +65,10 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
             def_concept.post = self.get_concept_part(post)
         if bnf_def:
             def_concept.definition = bnf_def
-            def_concept.definition_type = "bnf"
+            def_concept.definition_type = DEFINITION_TYPE_BNF
         if definition:
             def_concept.definition = NameNode(list(Tokenizer(definition)))
-            def_concept.definition_type = "def"
+            def_concept.definition_type = DEFINITION_TYPE_DEF
 
         return ReturnValueConcept(BaseParser.PREFIX + "some_name", True, ParserResultConcept(value=def_concept))
 

tests/evaluators/test_AddConceptInSetEvaluator.py

@@ -69,12 +69,14 @@ class TestAddConceptInSetEvaluator(TestUsingMemoryBasedSheerka):
     def test_i_can_add_bnf_concept_to_a_set_of_concept(self):
         """
         This test is the reason why I have started the whole eval on demand stuff
-        Sheerka tries to evaluate the body but it can (as a and b are not defined)
+        Sheerka tries to evaluate the body but it can't (as a and b are not defined)
         So 'foo' cannot be put is set
         :return:
         """
-        sheerka, context, foo, bar = self.init_concepts(
-            Concept("foo", definition="a plus b", body="a + b").def_prop("a").def_prop("b"),
+        sheerka, context, one, two, foo, bar = self.init_concepts(
+            "one",
+            "two",
+            Concept("foo", definition="(one|two)=a 'plus' (one|two)=b", body="a + b").def_prop("a").def_prop("b"),
             "bar",
             create_new=True)
 

tests/evaluators/test_LexerNodeEvaluator.py

@@ -4,7 +4,8 @@ import pytest
 from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
 from core.concept import Concept, ConceptParts, DoNotResolve
 from evaluators.LexerNodeEvaluator import LexerNodeEvaluator
-from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, StrMatch, UnrecognizedTokensNode, SourceCodeNode
+from parsers.BaseNodeParser import SourceCodeNode
+from parsers.BnfNodeParser import ConceptNode, BnfNodeParser, StrMatch, UnrecognizedTokensNode
 from parsers.PythonParser import PythonNode
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
@@ -12,7 +13,7 @@ from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):
 
     def from_parsing(self, context, grammar, expression):
-        parser = ConceptLexerParser()
+        parser = BnfNodeParser()
         parser.initialize(context, grammar)
 
         ret_val = parser.parse(context, expression)

tests/evaluators/test_MultipleErrorsEvaluator.py

@@ -0,0 +1,98 @@
+import pytest
+
+from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
+from core.concept import Concept
+from evaluators.BaseEvaluator import BaseEvaluator
+from evaluators.MultipleErrorsEvaluator import MultipleErrorsEvaluator
+from parsers.BaseParser import BaseParser
+
+from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+
+
+def r(value, status=True):
+    return ReturnValueConcept(value, status, value)
+
+
+def eval_false(name):
+    return ReturnValueConcept(BaseEvaluator.PREFIX + name, False, "value")
+
+
+def eval_true(name):
+    return ReturnValueConcept(BaseEvaluator.PREFIX + name, True, "value")
+
+
+def parser_false(name):
+    return ReturnValueConcept(BaseParser.PREFIX + name, False, "value")
+
+
+def parser_true(name):
+    return ReturnValueConcept(BaseParser.PREFIX + name, True, "value")
+
+
+reduce_requested = ReturnValueConcept(
+    "some_name",
+    True,
+    Concept(name=BuiltinConcepts.REDUCE_REQUESTED,  key=BuiltinConcepts.REDUCE_REQUESTED))
+
+
+class TestMultipleErrorsEvaluator(TestUsingMemoryBasedSheerka):
+    @pytest.mark.parametrize("return_values, expected", [
+        ([eval_false("one"), reduce_requested], False),
+        ([eval_false("one"), eval_false("two"), reduce_requested], True),
+        ([eval_false("one"), eval_false("two"), eval_false("three"), reduce_requested], True),
+        ([eval_false("one"), eval_false("two"), parser_false("one"), reduce_requested], True),
+        ([eval_false("one"), eval_false("two"), parser_true("one"), reduce_requested], False),
+        ([eval_false("one"), eval_false("two"), eval_true("three"), reduce_requested], False),
+        ([eval_false("one"), eval_false("two"), r("other concept", False), reduce_requested], True),
+        ([eval_false("one"), eval_false("two"), r("other concept", True), reduce_requested], True),
+        ([eval_false("reduce not required 1"), eval_false("reduce not required 2")], False),
+    ])
+    def test_i_can_match(self, return_values, expected):
+        context = self.get_context()
+        assert MultipleErrorsEvaluator().matches(context, return_values) == expected
+
+    def test_i_can_eval(self):
+        context = self.get_context()
+
+        return_values = [
+            eval_false("one"),
+            eval_false("two"),
+            eval_false("three"),
+            parser_false("one"),
+            parser_false("two"),
+            reduce_requested
+        ]
+
+        evaluator = MultipleErrorsEvaluator()
+        evaluator.matches(context, return_values)
+        res = evaluator.eval(context, return_values)
+
+        assert not res.status
+        assert context.sheerka.isinstance(res.body, BuiltinConcepts.MULTIPLE_ERRORS)
+        assert res.body.body == [eval_false("one"), eval_false("two"), eval_false("three")]
+        assert len(res.parents) == 6
+
+    def test_unwanted_return_values_are_not_eaten(self):
+        context = self.get_context()
+
+        a_successful_concept = r("successful concept")
+        a_concept_in_error = r("concept in error", False)
+        return_values = [
+            eval_false("one"),
+            eval_false("two"),
+            parser_false("one"),
+            a_successful_concept,
+            a_concept_in_error,
+            reduce_requested
+        ]
+
+        evaluator = MultipleErrorsEvaluator()
+        evaluator.matches(context, return_values)
+        res = evaluator.eval(context, return_values)
+
+        assert not res.status
+        assert res.body.body == [eval_false("one"), eval_false("two")]
+        assert len(res.parents) == 4
+
+        assert a_successful_concept not in res.parents
+        assert a_concept_in_error not in res.parents

tests/evaluators/test_OneErrorEvaluator.py

@@ -71,3 +71,4 @@ class TestOneErrorEvaluator(TestUsingMemoryBasedSheerka):
         assert len(res.parents) == 4
 
         assert a_successful_concept not in res.parents
+        assert a_concept_in_error not in res.parents