Refactored Caching, Refactored BnfNodeParser, Introduced Sphinx

tests/evaluators/test_LexerNodeEvaluator.py

@@ -1,20 +1,21 @@
 import ast
-import pytest
 
+import pytest
 from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
 from core.concept import Concept, ConceptParts, DoNotResolve
 from evaluators.LexerNodeEvaluator import LexerNodeEvaluator
 from parsers.BaseNodeParser import SourceCodeNode
-from parsers.BnfNodeParser import ConceptNode, BnfNodeParser, StrMatch, UnrecognizedTokensNode
+from parsers.BnfNodeParser import ConceptNode, BnfNodeParser, UnrecognizedTokensNode
 from parsers.PythonParser import PythonNode
+
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
 
 class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):
 
-    def from_parsing(self, context, grammar, expression):
+    def init_from_concepts(self, context, concepts, expression):
         parser = BnfNodeParser()
-        parser.initialize(context, grammar)
+        parser.init_from_concepts(context, concepts)
 
         ret_val = parser.parse(context, expression)
         assert ret_val.status
@@ -31,18 +32,6 @@ class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):
 
         return ReturnValueConcept("somme_name", True, ParserResultConcept(value=nodes))
 
-    def init(self, concept, grammar, text):
-        context = self.get_context()
-        if isinstance(concept, list):
-            for c in concept:
-                context.sheerka.add_in_cache(c)
-        else:
-            context.sheerka.add_in_cache(concept)
-        ret_val = self.from_parsing(context, grammar, text)
-        node = ret_val.value.value[0]
-
-        return context, node
-
     @pytest.mark.parametrize("ret_val, expected", [
         (ReturnValueConcept("some_name", True, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])), True),
         (ReturnValueConcept("some_name", True, ParserResultConcept(value=ConceptNode(Concept(), 0, 0))), True),
@@ -60,15 +49,13 @@ class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):
         (ReturnValueConcept("some_name", True, ConceptNode(Concept(), 0, 0)), False),
     ])
     def test_i_can_match(self, ret_val, expected):
-        context = self.get_context()
+        sheerka = self.get_sheerka(singleton=True)
+        context = self.get_context(sheerka)
         assert LexerNodeEvaluator().matches(context, ret_val) == expected
 
     def test_concept_is_returned_when_only_one_in_the_list(self):
-        foo = Concept("foo")
-        context = self.get_context()
-        context.sheerka.add_in_cache(foo)
-
-        ret_val = self.from_parsing(context, {foo: StrMatch("foo")}, "foo")
+        sheerka, context, foo = self.init_concepts(self.bnf_concept("foo"), singleton=True)
+        ret_val = self.init_from_concepts(context, [foo], "foo")
 
         evaluator = LexerNodeEvaluator()
         result = evaluator.eval(context, ret_val)
@@ -80,7 +67,7 @@ class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):
         assert context.sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
         assert wrapper.parser == evaluator
         assert wrapper.source == "foo"
-        assert return_value == Concept("foo").init_key()
+        assert return_value == foo
         assert return_value.compiled[ConceptParts.BODY] == DoNotResolve("foo")
         assert result.parents == [ret_val]