Added SheerkaComparisonManager

tests/parsers/test_AtomsParser.py

@@ -1,22 +1,25 @@
 import pytest
 from core.builtin_concepts import BuiltinConcepts
-from core.concept import Concept
+from core.concept import Concept, DEFINITION_TYPE_DEF
 from parsers.AtomNodeParser import AtomNodeParser
-from parsers.BaseNodeParser import cnode, utnode, CNC, scnode, SCN
+from parsers.BaseNodeParser import cnode, utnode, CNC, SCN
 
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 from tests.parsers.parsers_utils import compute_expected_array
 
 
 class TestAtomsParser(TestUsingMemoryBasedSheerka):
-    def init_parser(self, my_map, create_new=False, singleton=True):
+    def init_parser(self, my_map, create_new=False, singleton=True, use_sheerka=False):
         sheerka, context, *updated_concepts = self.init_concepts(
             *my_map.values(),
             create_new=create_new,
             singleton=singleton)
 
-        parser = AtomNodeParser()
-        parser.init_from_concepts(context, updated_concepts)
+        if use_sheerka:
+            parser = AtomNodeParser(sheerka=sheerka)
+        else:
+            parser = AtomNodeParser()
+            parser.init_from_concepts(context, updated_concepts)
 
         return sheerka, context, parser
 
@@ -32,15 +35,20 @@ class TestAtomsParser(TestUsingMemoryBasedSheerka):
         ("foo", ["foo"]),
         ("foo bar", ["foo", "bar"]),
         ("foo bar twenties", ["foo", "bar", "twenties"]),
+        # ("plus", ["plus"]),
+        # ("++", ["++"]),
+        # ("a++ foo", ["++", "foo"]),
     ])
     def test_i_can_parse_simple_sequences(self, text, expected):
         concepts_map = {
             "foo": Concept("foo"),
             "bar": Concept("bar"),
+            "plus": Concept("a plus b").def_var("a").def_var("b"),
+            "++": Concept("++", definition="a++", definition_type=DEFINITION_TYPE_DEF).def_var("a"),
             "twenties": Concept("twenties", definition="'twenty' ('one'|'two')=unit").def_var("unit"),
         }
 
-        sheerka, context, parser = self.init_parser(concepts_map)
+        sheerka, context, parser = self.init_parser(concepts_map, create_new=True, use_sheerka=True)
         res = parser.parse(context, text)
         wrapper = res.body
         lexer_nodes = res.body.body
@@ -276,3 +284,27 @@ class TestAtomsParser(TestUsingMemoryBasedSheerka):
         expected_array = compute_expected_array(concepts_map, text, expected)
         assert sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
         assert lexer_nodes == expected_array
+
+    @pytest.mark.parametrize("text, expected_is_evaluated", [
+        ("foo",  False),
+        ("bar", False ),
+        ("twenties", True),
+        ("plus", True),
+        # ("plus", ["plus"]),
+        # ("++", ["++"]),
+        # ("a++ foo", ["++", "foo"]),
+    ])
+    def test_concepts_with_variables_must_not_be_evaluated(self, text, expected_is_evaluated):
+        concepts_map = {
+            "foo": Concept("foo"),
+            "bar": Concept("bar", body="'bar'"),
+            "plus": Concept("plus", definition="a plus b", definition_type=DEFINITION_TYPE_DEF).def_var("a").def_var("b"),
+            "twenties": Concept("twenties", definition="'twenty' ('one'|'two')=unit").def_var("unit"),
+        }
+
+        sheerka, context, parser = self.init_parser(concepts_map, create_new=True, use_sheerka=True)
+        res = parser.parse(context, text)
+        lexer_nodes = res.body.body
+
+        assert res.status
+        assert lexer_nodes[0].concept.metadata.is_evaluated == expected_is_evaluated

tests/parsers/test_SyaNodeParser.py

@@ -1,6 +1,7 @@
 import pytest
 from core.builtin_concepts import BuiltinConcepts
 from core.concept import Concept, CC
+from core.sheerka.services.SheerkaComparisonManager import SheerkaComparisonManager
 from core.tokenizer import Tokenizer
 from parsers.BaseNodeParser import utnode, ConceptNode, cnode, short_cnode, UnrecognizedTokensNode, \
     SCWC, CNC, UTN
@@ -48,10 +49,20 @@ class TestSyaNodeParser(TestUsingMemoryBasedSheerka):
             create_new=True,
             init_from_sheerka=True)
 
-        TestSyaNodeParser.sheerka.force_sya_def(context, [
-            (cmap["plus"].id, 5, SyaAssociativity.Right),
-            (cmap["mult"].id, 10, SyaAssociativity.Right),
-            (cmap["minus"].id, 10, SyaAssociativity.Right)])
+        cmap["plus"].set_prop(BuiltinConcepts.ASSOCIATIVITY, "right")
+        cmap["mult"].set_prop(BuiltinConcepts.ASSOCIATIVITY, "right")
+        cmap["minus"].set_prop(BuiltinConcepts.ASSOCIATIVITY, "right")
+        TestSyaNodeParser.sheerka.services[SheerkaComparisonManager.NAME].is_greater_than(context,
+                                                                                          BuiltinConcepts.PRECEDENCE,
+                                                                                          cmap["mult"], cmap["plus"])
+        TestSyaNodeParser.sheerka.services[SheerkaComparisonManager.NAME].is_greater_than(context,
+                                                                                          BuiltinConcepts.PRECEDENCE,
+                                                                                          cmap["mult"], cmap["minus"])
+
+        # TestSyaNodeParser.sheerka.force_sya_def(context, [
+        #     (cmap["plus"].id, 5, SyaAssociativity.Right),
+        #     (cmap["mult"].id, 10, SyaAssociativity.Right),
+        #     (cmap["minus"].id, 5, SyaAssociativity.Right)])
 
     def init_parser(self,
                     my_concepts_map=None,