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

tests/parsers/test_PythonWithConceptsParser.py

@@ -1,11 +1,13 @@
 import ast
 
 import pytest
+import core.utils
 from core.builtin_concepts import ParserResultConcept, BuiltinConcepts, ReturnValueConcept
 from core.concept import Concept
+from core.rule import Rule
 from core.sheerka.services.SheerkaExecute import ParserInput
 from core.tokenizer import Token, TokenKind, Tokenizer
-from parsers.BaseNodeParser import ConceptNode, UnrecognizedTokensNode
+from parsers.BaseNodeParser import ConceptNode, UnrecognizedTokensNode, RuleNode
 from parsers.PythonParser import PythonNode
 from parsers.PythonWithConceptsParser import PythonWithConceptsParser
 from parsers.UnrecognizedNodeParser import UnrecognizedNodeParser
@@ -23,6 +25,10 @@ def ret_val(*args):
             tokens = [Token(TokenKind.IDENTIFIER, item.name, 0, 0, 0)]
             result.append(ConceptNode(item, index, index, tokens, item.name))
             index += 1
+        elif isinstance(item, Rule):
+            tokens = [Token(TokenKind.RULE, (None, item.id), 0, 0, 0)]
+            result.append(RuleNode(item, index, index, tokens, f"r:|{item.id}:"))
+            index += 1
         else:
             tokens = list(Tokenizer(item))
             result.append(UnrecognizedTokensNode(index, index + len(tokens) - 1, tokens))
@@ -69,7 +75,7 @@ class TestPythonWithConceptsParser(TestUsingMemoryBasedSheerka):
         assert isinstance(return_value, PythonNode)
         assert return_value.source == "foo + 1"
         assert return_value.get_dump(return_value.ast_) == to_str_ast("__C__foo__C__ + 1")
-        assert return_value.concepts["__C__foo__C__"] == foo
+        assert return_value.objects["__C__foo__C__"] == foo
 
     def test_i_can_parse_concepts_and_python_when_concept_is_known(self):
         context = self.get_context()
@@ -89,7 +95,7 @@ class TestPythonWithConceptsParser(TestUsingMemoryBasedSheerka):
         assert isinstance(return_value, PythonNode)
         assert return_value.source == "foo + 1"
         assert return_value.get_dump(return_value.ast_) == to_str_ast("__C__foo__1001__C__ + 1")
-        assert return_value.concepts["__C__foo__1001__C__"] == foo
+        assert return_value.objects["__C__foo__1001__C__"] == foo
 
     def test_i_can_parse_when_concept_name_has_invalid_characters(self):
         context = self.get_context()
@@ -102,7 +108,7 @@ class TestPythonWithConceptsParser(TestUsingMemoryBasedSheerka):
         return_value = result.value.value
 
         assert result.status
-        assert return_value.concepts["__C__foo0et000000__1001__C__"] == foo
+        assert return_value.objects["__C__foo0et000000__1001__C__"] == foo
 
     def test_i_can_parse_when_multiple_concepts(self):
         sheerka, context, foo, bar = self.init_concepts("foo", "bar")
@@ -120,8 +126,42 @@ class TestPythonWithConceptsParser(TestUsingMemoryBasedSheerka):
         assert isinstance(return_value, PythonNode)
         assert return_value.source == "func(foo, bar)"
         assert return_value.get_dump(return_value.ast_) == to_str_ast("func(__C__foo__1001__C__, __C__bar__1002__C__)")
-        assert return_value.concepts["__C__foo__1001__C__"] == foo
-        assert return_value.concepts["__C__bar__1002__C__"] == bar
+        assert return_value.objects["__C__foo__1001__C__"] == foo
+        assert return_value.objects["__C__bar__1002__C__"] == bar
+
+    def test_i_can_parse_when_python_and_rule(self):
+        context = self.get_context()
+        rule = Rule().set_id("rule_id")
+        input_return_value = ret_val(rule, " + 1")
+
+        parser = PythonWithConceptsParser()
+        result = parser.parse(context, input_return_value.body)
+        wrapper = result.value
+        return_value = result.value.value
+
+        assert result.status
+        assert result.who == parser.name
+        assert context.sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
+        assert wrapper.source == "r:|rule_id: + 1"
+        assert isinstance(return_value, PythonNode)
+        assert return_value.source == "r:|rule_id: + 1"
+        assert return_value.get_dump(return_value.ast_) == to_str_ast("__R____rule_id__R__ + 1")
+        assert return_value.objects["__R____rule_id__R__"] == rule
+
+    def test_python_ids_mappings_are_correct_when_rules_with_the_same_id(self):
+        context = self.get_context()
+        rule1 = Rule().set_id("rule_id")
+        rule2 = Rule().set_id("rule_id")
+
+        input_return_value = ret_val(rule1, "+", rule2)
+
+        parser = PythonWithConceptsParser()
+        result = parser.parse(context, input_return_value.body)
+        return_value = result.value.value
+
+        assert result.status
+        assert return_value.objects["__R____rule_id__R__"] == rule1
+        assert return_value.objects["__R____rule_id_1__R__"] == rule2
 
     def test_python_ids_mappings_are_correct_when_concepts_with_the_same_name(self):
         context = self.get_context()
@@ -137,10 +177,10 @@ class TestPythonWithConceptsParser(TestUsingMemoryBasedSheerka):
         return_value = result.value.value
 
         assert result.status
-        assert return_value.concepts["__C__foo__C__"] == foo1
-        assert return_value.concepts["__C__foo_1__C__"] == foo2
-        assert return_value.concepts["__C__foo__1001__C__"] == foo3
-        assert return_value.concepts["__C__foo__1002__C__"] == foo4
+        assert return_value.objects["__C__foo__C__"] == foo1
+        assert return_value.objects["__C__foo_1__C__"] == foo2
+        assert return_value.objects["__C__foo__1001__C__"] == foo3
+        assert return_value.objects["__C__foo__1002__C__"] == foo4
 
     def test_i_cannot_parse_if_syntax_error(self):
         context = self.get_context()