Concepts bodies are now evaluated on demand

tests/evaluators/test_AddConceptInSetEvaluator.py

@@ -66,6 +66,31 @@ class TestAddConceptInSetEvaluator(TestUsingMemoryBasedSheerka):
         foo_from_sheerka = context.sheerka.get("foo")
         assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == [bar]
 
+    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)
+        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"),
+            "bar",
+            create_new=True)
+
+        ret_val = get_ret_val("foo", "bar")
+        res = AddConceptInSetEvaluator().eval(context, ret_val)
+        foo = sheerka.new("foo")  # reload it
+
+        assert res.status
+        assert context.sheerka.isinstance(res.value, BuiltinConcepts.SUCCESS)
+        assert context.sheerka.isaset(context, bar)
+        assert context.sheerka.isinset(foo, bar)
+        assert context.sheerka.isa(foo, bar)
+
+        foo_from_sheerka = context.sheerka.get("foo")
+        assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == [bar]
+
     def test_i_can_add_concept_with_a_body_to_a_set_of_concept(self):
         context = self.get_context()
         foo = Concept("foo", body="1")

tests/evaluators/test_ConceptEvaluator.py

@@ -20,6 +20,7 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
 
     def test_i_can_evaluate_concept(self):
         context = self.get_context()
+        context.extra_info.append(BuiltinConcepts.CONCEPT_EVAL_REQUESTED)
         concept = Concept(name="foo",
                           where="True",
                           pre="2",
@@ -27,6 +28,7 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
 
         evaluator = ConceptEvaluator()
         item = self.pretval(concept)
+        evaluator.init_evaluator(context, [item])
         result = evaluator.eval(context, item)
 
         assert result.who == evaluator.name
@@ -42,6 +44,7 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
 
     def test_body_is_returned_when_defined_and_requested(self):
         context = self.get_context()
+        context.extra_info.append(BuiltinConcepts.CONCEPT_EVAL_REQUESTED)
         concept = Concept(name="foo",
                           body="'I have a value'",
                           where="True",
@@ -50,6 +53,7 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
 
         evaluator = ConceptEvaluator(return_body=True)
         item = self.pretval(concept)
+        evaluator.init_evaluator(context, [item])
         result = evaluator.eval(context, item)
 
         assert result.who == evaluator.name
@@ -67,6 +71,7 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
 
         evaluator = ConceptEvaluator(return_body=False)  # which is the default behaviour
         item = self.pretval(concept)
+        evaluator.init_evaluator(context, [item])
         result = evaluator.eval(context, item)
 
         assert result.who == evaluator.name
@@ -90,6 +95,7 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
 
     def test_i_cannot_recognize_a_concept_if_one_of_the_prop_is_unknown(self):
         context = self.get_context()
+        context.extra_info.append(BuiltinConcepts.CONCEPT_EVAL_REQUESTED)
         context.sheerka.add_in_cache(Concept(name="one").init_key())
         concept_plus = context.sheerka.add_in_cache(Concept(name="a plus b")
                                                     .def_prop("a", "one")
@@ -97,6 +103,7 @@ class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
 
         evaluator = ConceptEvaluator()
         item = self.pretval(concept_plus)
+        evaluator.init_evaluator(context, [item])
         result = evaluator.eval(context, item)
 
         assert not result.status

tests/evaluators/test_EvalEvaluator.py

@@ -5,7 +5,7 @@ from core.concept import Concept
 from evaluators.EvalEvaluator import EvalEvaluator
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
-eval_requested = ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.CONCEPT_EVAL_REQUESTED))
+value_requested = ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.CONCEPT_VALUE_REQUESTED))
 
 
 def retval(obj, who="who", status=True):
@@ -26,7 +26,7 @@ class TestEvalEvaluator(TestUsingMemoryBasedSheerka):
             ReturnValueConcept("some_name", False, Concept(name="1", body="'not to eval'")),
             to_eval1,
             to_eval2,
-            eval_requested
+            value_requested
         ]
 
         evaluator = EvalEvaluator()
@@ -35,16 +35,16 @@ class TestEvalEvaluator(TestUsingMemoryBasedSheerka):
         evaluated = evaluator.eval(context, return_values)
         assert len(evaluated) == 2
         assert evaluated[0].value == to_eval1.body.body
-        assert evaluated[0].parents == [to_eval1, eval_requested]
+        assert evaluated[0].parents == [to_eval1, value_requested]
 
         assert evaluated[1].value == to_eval2.body.body
-        assert evaluated[1].parents == [to_eval2, eval_requested]
+        assert evaluated[1].parents == [to_eval2, value_requested]
 
     @pytest.mark.parametrize("return_values, expected", [
-        ([retval(Concept("foo", body="bar")), eval_requested], True),
-        ([retval(Concept("status is false", body="bar"), status=False), eval_requested], True),
-        ([retval("string_value"), eval_requested], True),
-        ([retval(Concept("no body")), eval_requested], True),
+        ([retval(Concept("foo", body="bar")), value_requested], True),
+        ([retval(Concept("status is false", body="bar"), status=False), value_requested], True),
+        ([retval("string_value"), value_requested], True),
+        ([retval(Concept("no body")), value_requested], True),
         ([retval(Concept("eval requested missing", body="bar"))], False),
     ])
     def test_i_cannot_match_if_eval_request_is_not_present(self, return_values, expected):
@@ -58,7 +58,7 @@ class TestEvalEvaluator(TestUsingMemoryBasedSheerka):
             ReturnValueConcept("some_name", True, "not to eval"),
             ReturnValueConcept("some_name", True, Concept(name="not to eval")),
             ReturnValueConcept("some_name", False, Concept(name="1", body="not to eval")),
-            eval_requested
+            value_requested
         ]
 
         evaluator = EvalEvaluator()
@@ -68,8 +68,8 @@ class TestEvalEvaluator(TestUsingMemoryBasedSheerka):
         assert evaluated == ReturnValueConcept(
             "evaluators.Eval",
             False,
-            context.sheerka.new(BuiltinConcepts.CONCEPT_EVAL_REQUESTED))
-        assert evaluated.parents == [eval_requested]
+            context.sheerka.new(BuiltinConcepts.CONCEPT_VALUE_REQUESTED))
+        assert evaluated.parents == [value_requested]
 
     def test_i_can_evaluate_sets(self):
         sheerka, context, foo, bar, baz, number = self.init_concepts(
@@ -79,7 +79,7 @@ class TestEvalEvaluator(TestUsingMemoryBasedSheerka):
             Concept("number"))
         sheerka.sets_handler.add_concepts_to_set(context, [foo, bar, baz], number)
 
-        return_values = [retval(number), eval_requested]
+        return_values = [retval(number), value_requested]
 
         evaluator = EvalEvaluator()
         evaluator.matches(context, return_values)

tests/evaluators/test_PrepareEvalEvaluator.py

@@ -46,4 +46,4 @@ class TestPrepareEvalEvaluator(TestUsingMemoryBasedSheerka):
         assert res[0].body.body == expected
 
         assert res[1].status
-        assert sheerka.isinstance(res[1].body, BuiltinConcepts.CONCEPT_EVAL_REQUESTED)
+        assert sheerka.isinstance(res[1].body, BuiltinConcepts.CONCEPT_VALUE_REQUESTED)