Resolved some remaining chicken and egg when parsing BNF nodes

tests/BaseTest.py

@@ -53,13 +53,19 @@ class BaseTest:
                 c = Concept(c)
 
             if c.metadata.definition and c.metadata.definition_type != DEFINITION_TYPE_DEF:
-                bnf_parser = BnfParser()
-                res = bnf_parser.parse(context, c.metadata.definition)
-                if res.status:
-                    c.bnf = res.value.value
-                    c.metadata.definition_type = DEFINITION_TYPE_BNF
-                else:
-                    raise Exception(f"Error in bnf definition '{c.metadata.definition}'", sheerka.get_error(res))
+                desc = f"Resolving BNF {c.metadata.definition}"
+                with context.push(BuiltinConcepts.INIT_BNF,
+                                  c,
+                                  obj=c,
+                                  desc=desc) as sub_context:
+
+                    bnf_parser = BnfParser()
+                    res = bnf_parser.parse(sub_context, c.metadata.definition)
+                    if res.status:
+                        c.bnf = res.value.value
+                        c.metadata.definition_type = DEFINITION_TYPE_BNF
+                    else:
+                        raise Exception(f"Error in bnf definition '{c.metadata.definition}'", sheerka.get_error(res))
 
             if create_new:
                 sheerka.create_new_concept(context, c)

tests/core/test_ExecutionContext.py

@@ -116,11 +116,11 @@ def test_i_can_search():
     assert list(abbb.search(start_with_self=True)) == [abbb, abb, ab, a]
     assert list(abbb.search(lambda ec: ec.obj != "skip")) == [ab, a]
     assert list(abbb.search(lambda ec: ec.obj != "skip", lambda ec: ec.action_context)) == ["ab", "a"]
-    assert list(abbb.search(stop=lambda ec: ec.obj == "skip")) == []
+    assert list(abbb.search(stop=lambda ec: ec.obj == "skip")) == [abb]
     assert list(abbb.search(
         stop=lambda ec: ec.obj == "skip",
         start_with_self=True,
-        get_obj=lambda ec: ec.obj)) == ["obj_abbb"]
+        get_obj=lambda ec: ec.obj)) == ["obj_abbb", "skip"]
 
 
 def test_variables_are_passed_to_children_but_not_to_parents():

tests/core/test_SheerkaCreateNewConcept.py

@@ -182,6 +182,22 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
         assert sheerka.cache_manager.get(sheerka.CONCEPTS_BY_FIRST_KEYWORD_ENTRY, "-") == [bnf_concept.id]
         assert sheerka.cache_manager.get(sheerka.RESOLVED_CONCEPTS_BY_FIRST_KEYWORD_ENTRY, "-") == [bnf_concept.id]
 
+    def test_concept_references_are_updated(self):
+        sheerka, context, one, two, number, twenty, twenties = self.init_concepts(
+            "one",
+            "two",
+            "number",
+            "twenty",
+            Concept("twenties", definition="twenty one | two 'hundred'"),
+            create_new=True
+        )
+
+        assert sheerka.cache_manager.get(sheerka.CONCEPTS_REFERENCES, one.id) == {twenties.id}
+        assert sheerka.cache_manager.get(sheerka.CONCEPTS_REFERENCES, two.id) == {twenties.id}
+        assert sheerka.cache_manager.get(sheerka.CONCEPTS_REFERENCES, number.id) is None
+        assert sheerka.cache_manager.get(sheerka.CONCEPTS_REFERENCES, twenty.id) == {twenties.id}
+        assert sheerka.cache_manager.get(sheerka.CONCEPTS_REFERENCES, twenties.id) is None
+
 
 class TestSheerkaCreateNewConceptFileBased(TestUsingFileBasedSheerka):
     def test_i_can_add_several_concepts(self):

tests/core/test_SheerkaSetsManager.py

@@ -250,6 +250,40 @@ class TestSheerkaSetsManager(TestUsingMemoryBasedSheerka):
         assert sheerka.isa(bar, baz)
         assert sheerka.isa(foo, baz)
 
+    def test_concept_expression_recurse_id_is_updated(self):
+        sheerka, context, one, number, twenties = self.init_concepts(
+            "one",
+            "number",
+            Concept("twenties", definition="'twenty' number").def_var("number"),
+            create_new=True
+        )
+
+        assert twenties.bnf.elements[1].recurse_id is None
+
+        # update number
+        sheerka.set_isa(context, sheerka.new("one"), number)
+
+        assert twenties.bnf.elements[1].recurse_id == "1002#number#1003"
+
+    def test_concepts_in_group_cache_is_updated(self):
+        sheerka, context, one, two, number = self.init_concepts("one", "two", "number")
+
+        sheerka.set_isa(context, sheerka.new("one"), number)
+
+        elements = sheerka.get_set_elements(context, number)
+        assert [c.id for c in elements] == [one.id]
+
+        concepts_in_cache = sheerka.cache_manager.get(SheerkaSetsManager.CONCEPTS_IN_GROUPS_ENTRY, number.id)
+        assert [c.id for c in concepts_in_cache] == [one.id]
+
+        # add another element to number
+        sheerka.set_isa(context, sheerka.new("two"), number)
+        elements = sheerka.get_set_elements(context, number)
+        assert {c.id for c in elements} == {one.id, two.id}
+
+        concepts_in_cache = sheerka.cache_manager.get(SheerkaSetsManager.CONCEPTS_IN_GROUPS_ENTRY, number.id)
+        assert {c.id for c in concepts_in_cache} == {one.id, two.id}
+
 
 class TestSheerkaSetsManagerUsingFileBasedSheerka(TestUsingFileBasedSheerka):
     def test_i_can_add_concept_to_set_and_retrieve_it_in_another_session(self):
@@ -280,7 +314,7 @@ class TestSheerkaSetsManagerUsingFileBasedSheerka(TestUsingFileBasedSheerka):
         foo4 = Concept("foo4")
         for c in [foo3, foo4]:
             sheerka.create_new_concept(context, c)
-        
+
         sets_handler = sheerka.services[SheerkaSetsManager.NAME]
         res = sets_handler.add_concepts_to_set(context, (foo3, foo4), group)
         assert res.status

tests/parsers/test_BnfNodeParser.py

@@ -26,7 +26,7 @@ cmap = {
     "one hundred": Concept("one hundred", body="100"),
     "one_hundred": Concept("'one hundred'", body="100"),
     "hundreds": Concept("hundreds", definition="number=n1 'hundred' 'and' number=n2",
-                        where="n1 < 10 and n2 < 100", body="n1 * 100 + n2"),
+                        where="n1 < 10 and n2 < 100", body="n1 * 100 + n2").def_var("n1").def_var("n2"),
 
     "bnf baz": Concept("bnf baz", definition="'baz'"),  # this one should be chosen
 
@@ -103,6 +103,7 @@ class TestBnfNodeParser(TestUsingMemoryBasedSheerka):
         sheerka.set_isa(context, sheerka.new("forty"), sheerka.new("number"))
         sheerka.set_isa(context, sheerka.new("fifty"), sheerka.new("number"))
         sheerka.set_isa(context, sheerka.new("one hundred"), sheerka.new("number"))
+        sheerka.set_isa(context, sheerka.new("hundreds"), sheerka.new("number"))
 
         # Pay attention. 'twenties (t1 and t2) are not set as number
 
@@ -848,7 +849,7 @@ class TestBnfNodeParser(TestUsingMemoryBasedSheerka):
         parsing_expression = parser.get_parsing_expression(context, my_map["foo"])
         assert sheerka.isinstance(parsing_expression, BuiltinConcepts.CHICKEN_AND_EGG)
         assert sheerka.isinstance(parser.concepts_grammars.get(my_map["foo"].id), BuiltinConcepts.CHICKEN_AND_EGG)
-        assert parser.concepts_grammars.get(my_map["foo"].id).body == {"1001", "1002", "1003", "1004"}
+        assert parser.concepts_grammars.get(my_map["foo"].id).body == ["1001", "1002", "1003", "1004", "1001"]
 
         assert sheerka.isinstance(parser.concepts_grammars.get(my_map["bar"].id), BuiltinConcepts.CHICKEN_AND_EGG)
         assert sheerka.isinstance(parser.concepts_grammars.get(my_map["baz"].id), BuiltinConcepts.CHICKEN_AND_EGG)

tests/parsers/test_BnfParser.py

@@ -214,3 +214,25 @@ class TestBnfParser(TestUsingMemoryBasedSheerka):
         assert not res.status
         assert context.sheerka.isinstance(res.value, BuiltinConcepts.UNKNOWN_CONCEPT)
         assert res.value.body == ('key', 'foo')
+
+    def test_concept_expression_are_correctly_created_when_isa_concept_is_detected(self):
+        sheerka, context, parser, one, two, number, twenties = self.init_parser(
+            "one",
+            "two",
+            "number",
+            "twenties")
+
+        sheerka.set_isa(context, sheerka.new("one"), number)
+        sheerka.set_isa(context, sheerka.new("two"), number)
+        sheerka.set_isa(context, sheerka.new("twenties"), number)
+
+        sub_context = context.push(BuiltinConcepts.INIT_BNF, twenties)
+
+        expression = "'twenty' number=n1"
+        res = parser.parse(sub_context, Tokenizer(expression))
+
+        assert not parser.has_error
+        assert res.status
+        pexpression = res.value.value
+        assert pexpression == Sequence(StrMatch('twenty'), ConceptExpression(number, "n1"))
+        assert pexpression.elements[1].recurse_id == "1003#n1#1004"