Added first version of DebugManager. Implemented draft of the rule engine

tests/parsers/test_FunctionParser.py

@@ -1,8 +1,9 @@
 import pytest
 from core.builtin_concepts import BuiltinConcepts
 from core.concept import Concept
+from core.rule import Rule
 from core.sheerka.services.SheerkaExecute import ParserInput
-from parsers.BaseNodeParser import SCN, SCWC, CN, UTN, CNC
+from parsers.BaseNodeParser import SCN, SCWC, CN, UTN, CNC, RN
 from parsers.FunctionParser import FunctionParser, FN
 
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
@@ -76,6 +77,16 @@ class TestFunctionParser(TestUsingMemoryBasedSheerka):
 
         assert res == expected
 
+    def test_i_can_parse_function_when_rule(self):
+        sheerka, context, parser = self.init_parser()
+
+        parser.reset_parser(context, ParserInput("func(r:|1:)"))
+        parser.parser_input.next_token()
+
+        res = parser.parse_function()
+
+        assert res == FN("func(", ")", ["r:|1:"])
+
     @pytest.mark.parametrize("text, expected", [
         ("func()", SCN("func()")),
         (" func()", SCN("func()")),
@@ -118,6 +129,63 @@ class TestFunctionParser(TestUsingMemoryBasedSheerka):
             assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
             assert expressions == resolved_expected
 
+    def test_i_can_parse_when_the_parameter_is_not_a_concept(self):
+        """
+        It's not a concept, but it can be a valid short term memory object
+        :return:
+        """
+        sheerka, context, parser = self.init_parser()
+        text = "func(unknown_concept)"
+
+        res = parser.parse(context, ParserInput(text))
+
+        assert res.status
+
+    def test_i_cannot_parse_when_the_concept_is_not_found(self):
+        """
+        We do not check yet if it's a valid concept
+        If you find a cheap way to do so, simply remove this test
+        :return:
+        """
+        sheerka, context, parser = self.init_parser()
+        text = "func(c:|xxx:)"
+
+        res = parser.parse(context, ParserInput(text))
+
+        assert res.status
+
+    def test_i_can_parse_when_rules(self):
+        sheerka, context, parser = self.init_parser()
+        text = "func(r:|1:)"
+        expected = SCWC("func(", ")", RN("1"))
+        resolved_expected = compute_expected_array(cmap, text, [expected])[0]
+
+        res = parser.parse(context, ParserInput(text))
+        parser_result = res.body
+        expression = res.body.body
+
+        assert res.status
+        assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
+        assert expression == resolved_expected
+        assert expression.python_node is not None
+        assert expression.return_value is not None
+
+    # def test_i_cannot_parse_when_rule_not_found(self):
+    #     sheerka, context, parser = self.init_parser()
+    #     text = "func(r:|fake:)"
+    #     expected = SCWC("func(", ")", RN("fake"))
+    #     resolved_expected = compute_expected_array(cmap, text, [expected])[0]
+    #
+    #     res = parser.parse(context, ParserInput(text))
+    #     parser_result = res.body
+    #     expression = res.body.body
+    #
+    #     assert not res.status
+    #     assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
+    #     assert expression == resolved_expected
+    #     assert expression.python_node is not None
+    #     assert expression.return_value is not None
+
     @pytest.mark.parametrize("text, expected_error_type", [
         ("one", BuiltinConcepts.NOT_FOR_ME),
         ("$*!", BuiltinConcepts.NOT_FOR_ME),
@@ -138,7 +206,7 @@ class TestFunctionParser(TestUsingMemoryBasedSheerka):
     @pytest.mark.parametrize("text, expected", [
         ("func(one two)", SCWC("func(", ")", "one", "two")),
     ])
-    def test_i_can_detect_non_function(self, text, expected):
+    def test_i_can_detect_none_function(self, text, expected):
         sheerka, context, parser = self.init_parser()
         resolved_expected = compute_expected_array(cmap, text, [expected])[0]
 
@@ -169,11 +237,11 @@ class TestFunctionParser(TestUsingMemoryBasedSheerka):
         concept = res.body.body.nodes[0].concept
 
         assert res.status
-        assert isinstance(concept.compiled["a"], Concept)
+        assert isinstance(concept.get_compiled()["a"], Concept)
 
         # three is not recognized,
         # so it will be transformed into list of ReturnValueConcept that indicate how to recognized it
-        assert isinstance(concept.compiled["b"], list)
-        for item in concept.compiled["b"]:
+        assert isinstance(concept.get_compiled()["b"], list)
+        for item in concept.get_compiled()["b"]:
             assert sheerka.isinstance(item, BuiltinConcepts.RETURN_VALUE)