Improved PythonEvaluator when dealing with concept class

tests/core/test_SheerkaCreateNewConcept.py

@@ -139,6 +139,23 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
 
         assert res.status
 
+    def test_i_can_get_by_name_when_created_with_def_definition(self):
+        sheerka = self.get_sheerka(cache_only=False)
+        context = self.get_context(sheerka)
+        concept = self.def_concept("plus", "a plus b", ["a", "b"])
+
+        res = sheerka.create_new_concept(context, concept)
+
+        assert res.status
+        assert sheerka.get_by_name(concept.name) == concept
+        assert sheerka.get_by_name(concept.metadata.definition) == concept
+
+        concept = Concept(name="foo", definition="foo", definition_type=DEFINITION_TYPE_DEF)
+        res = sheerka.create_new_concept(context, concept)
+
+        assert res.status
+        assert sheerka.get_by_name(concept.name) == concept # it's not a list, ie the entry is not duplicated
+
 
 class TestSheerkaCreateNewConceptFileBased(TestUsingFileBasedSheerka):
     def test_i_can_add_several_concepts(self):

tests/core/test_sheerka.py

@@ -4,6 +4,7 @@ import pytest
 from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, UserInputConcept
 from core.concept import Concept, PROPERTIES_TO_SERIALIZE, ConceptParts
 from core.sheerka.Sheerka import Sheerka, BASE_NODE_PARSER_CLASS
+from core.tokenizer import Token, TokenKind, Tokenizer
 
 from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
@@ -274,6 +275,55 @@ class TestSheerkaUsingMemoryBasedSheerka(TestUsingMemoryBasedSheerka):
         sheerka = self.get_sheerka()
         assert not sheerka.is_success(sheerka.new(BuiltinConcepts.TOO_MANY_SUCCESS))
 
+    @pytest.mark.parametrize("concept, expected", [
+        (None, None),
+        ("foo", ["foo", "foo2"]),
+        ("bar", "bar"),
+        ("1001", "foo"),  # by id take precedence over by name
+        ("plus", "plus"),
+        ("a mult b", "mult"),
+        ("unknown", None),
+
+        # by tuple
+        ((None, None), None),
+        (("foo", None), ["foo", "foo2"]),
+        (("foo", "1002"), "foo2"),
+        ((None, "1001"), "foo"),
+        (("plus", None), "plus"),
+        (("1001", None), "1001"),
+        (("unknown", None), None),
+        ((None, "unknown"), None),
+        #
+        # by token
+        (Token(TokenKind.CONCEPT, (None, None), 0, 0, 0), None),
+        (Token(TokenKind.CONCEPT, ("foo", None), 0, 0, 0), ["foo", "foo2"]),
+
+    ])
+    def test_i_can_resolve_concept(self, concept, expected):
+        sheerka, context, *concepts = self.init_concepts(
+            "foo",
+            Concept("foo", body="another one"),
+            "bar",
+            self.def_concept("plus", "a plus b", ["a", "b"]),
+            Concept("a mult b").def_var("a").def_var("b"),
+            Concept("1001"),
+        )
+
+        cmap = {k: concepts[i] for i, k in enumerate(["foo", "foo2", "bar", "plus", "mult", "1001"])}
+        cmap[None] = None
+
+        if isinstance(expected, list):
+            assert sheerka.resolve(concept) == [cmap[e] for e in expected]
+        else:
+            assert sheerka.resolve(concept) == cmap[expected]
+
+    def test_i_can_resolve_when_searching_by_definition(self):
+        sheerka, context, plus = self.init_concepts(
+            self.def_concept("plus", "a plus b", ["a", "b"]),
+            create_new=True
+        )
+
+        assert sheerka.resolve("a plus b") == plus
 
 class TestSheerkaUsingFileBasedSheerka(TestUsingFileBasedSheerka):
 

tests/core/test_utils.py

@@ -198,7 +198,6 @@ def test_encode_concept_key_id():
     assert core.utils.encode_concept(("key", "id")) == "__C__KEY_key__ID_id__C__"
     assert core.utils.encode_concept((None, "id")) == "__C__KEY_00None00__ID_id__C__"
     assert core.utils.encode_concept(("key", None)) == "__C__KEY_key__ID_00None00__C__"
-    assert core.utils.encode_concept(("key", "id"), True) == "__C__USE_CONCEPT__KEY_key__ID_id__C__"
     assert core.utils.encode_concept(("k + y", "id")) == "__C__KEY_k000y__ID_id__C__"
 
     concept = Concept("foo").init_key()
@@ -209,7 +208,6 @@ def test_encode_concept_key_id():
 
 
 def test_decode_concept_key_id():
-    assert core.utils.decode_concept("__C__KEY_key__ID_id__C__") == ("key", "id", False)
-    assert core.utils.decode_concept("__C__KEY_00None00__ID_id__C__") == (None, "id", False)
-    assert core.utils.decode_concept("__C__KEY_key__ID_00None00__C__") == ("key", None, False)
-    assert core.utils.decode_concept("__C__USE_CONCEPT__KEY_key__ID_id__C__") == ("key", "id", True)
+    assert core.utils.decode_concept("__C__KEY_key__ID_id__C__") == ("key", "id")
+    assert core.utils.decode_concept("__C__KEY_00None00__ID_id__C__") == (None, "id")
+    assert core.utils.decode_concept("__C__KEY_key__ID_00None00__C__") == ("key", None)