Refactored Caching, Refactored BnfNodeParser, Introduced Sphinx

tests/parsers/test_BnfParser.py

@@ -1,13 +1,12 @@
 import pytest
-
 from core.builtin_concepts import BuiltinConcepts
-from core.concept import Concept
+from core.concept import Concept, DEFINITION_TYPE_BNF
 from core.tokenizer import Tokenizer, TokenKind, LexerError, Token
 from parsers.BaseNodeParser import cnode
 from parsers.BaseParser import UnexpectedTokenErrorNode
-from parsers.BnfParser import BnfParser, UnexpectedEndOfFileError
 from parsers.BnfNodeParser import StrMatch, Optional, ZeroOrMore, OrderedChoice, Sequence, OneOrMore, \
     BnfNodeParser, ConceptExpression
+from parsers.BnfParser import BnfParser, UnexpectedEndOfFileError
 
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
@@ -27,6 +26,12 @@ eof_token = Token(TokenKind.EOF, "", 0, 0, 0)
 
 class TestBnfParser(TestUsingMemoryBasedSheerka):
 
+    def init_parser(self, *concepts):
+        sheerka, context, *updated = self.init_concepts(*concepts, singleton=True)
+        parser = BnfParser()
+
+        return sheerka, context, parser, *updated
+
     @pytest.mark.parametrize("expression, expected", [
         ("'str'", StrMatch("str")),
         ("1", StrMatch("1")),
@@ -80,8 +85,9 @@ class TestBnfParser(TestUsingMemoryBasedSheerka):
             OneOrMore(StrMatch("b"), rule_name="y"), rule_name="z")),
     ])
     def test_i_can_parse_regex(self, expression, expected):
-        parser = BnfParser()
-        res = parser.parse(self.get_context(), Tokenizer(expression))
+        sheerka, context, parser = self.init_parser()
+
+        res = parser.parse(context, Tokenizer(expression))
 
         assert not parser.has_error
         assert res.status
@@ -96,16 +102,11 @@ class TestBnfParser(TestUsingMemoryBasedSheerka):
         ("'str' = var", Sequence(StrMatch("str"), StrMatch("="), c("var"))),
         ("'str''='var", Sequence(StrMatch("str"), StrMatch("="), c("var"))),
         ("foo=f", c("foo", "f")),
+        ("foo=f 'constant'", Sequence(c("foo", "f"), StrMatch("constant"))),
     ])
     def test_i_can_parse_regex_with_concept(self, expression, expected):
-        foo = Concept("foo")
-        bar = Concept("bar")
-        var = Concept("var")
-        context = self.get_context()
+        sheerka, context, parser, foo, bar, var = self.init_parser("foo", "bar", "var")
 
-        for c in (foo, bar, var):
-            context.sheerka.add_in_cache(c)
-        parser = BnfParser()
         res = parser.parse(context, Tokenizer(expression))
 
         assert not parser.has_error
@@ -118,10 +119,9 @@ class TestBnfParser(TestUsingMemoryBasedSheerka):
         ("foo=f", ConceptExpression("foo", rule_name="f")),
     ])
     def test_i_can_parse_regex_with_concept_when_the_concept_is_still_under_definition(self, expression, expected):
-        context = self.get_context()
+        sheerka, context, parser = self.init_parser()
         context.obj = ClassWithName("foo")
 
-        parser = BnfParser()
         res = parser.parse(context, Tokenizer(expression))
 
         assert not parser.has_error
@@ -137,47 +137,43 @@ class TestBnfParser(TestUsingMemoryBasedSheerka):
         ("'name", LexerError("Missing Trailing quote", "'name", 5, 1, 6))
     ])
     def test_i_can_detect_errors(self, expression, error):
-        parser = BnfParser()
-        res = parser.parse(self.get_context(), Tokenizer(expression))
+        sheerka, context, parser = self.init_parser()
+
+        res = parser.parse(context, Tokenizer(expression))
         ret_value = res.value.value
         assert parser.has_error
         assert not res.status
         assert ret_value[0] == error
 
     def test_i_can_use_the_result_of_regex_parsing_to_parse_a_text(self):
-        foo = Concept(name="foo")
-        bar = Concept(name="bar")
-        context = self.get_context()
-        context.sheerka.add_in_cache(foo)
-        context.sheerka.add_in_cache(bar)
+        sheerka, context, regex_parser, foo, bar = self.init_parser("foo", "bar")
 
-        regex_parser = BnfParser()
-        foo_definition = regex_parser.parse(context, "'twenty' | 'thirty'").value.value
-        bar_definition = regex_parser.parse(context, "foo ('one' | 'two')").value.value
+        for concept in [foo, bar]:
+            concept.metadata.definition_type = DEFINITION_TYPE_BNF
 
-        concepts = {bar: bar_definition, foo: foo_definition}
-        concept_parser = BnfNodeParser()
-        concept_parser.initialize(context, concepts)
+        foo.bnf = regex_parser.parse(context, "'twenty' | 'thirty'").value.value
+        bar.bnf = regex_parser.parse(context, "foo ('one' | 'two')").value.value
 
-        res = concept_parser.parse(context, "twenty two")
+        bnf_parser = BnfNodeParser()
+        bnf_parser.init_from_concepts(context, [foo, bar])
+
+        res = bnf_parser.parse(context, "twenty two")
         assert res.status
         assert res.value.body == [cnode("bar", 0, 2, "twenty two")]
 
-        res = concept_parser.parse(context, "thirty one")
+        res = bnf_parser.parse(context, "thirty one")
         assert res.status
         assert res.value.body == [cnode("bar", 0, 2, "thirty one")]
 
-        res = concept_parser.parse(context, "twenty")
+        res = bnf_parser.parse(context, "twenty")
         assert res.status
         assert res.value.body == [cnode("foo", 0, 0, "twenty")]
 
     def test_i_cannot_parse_when_too_many_concepts(self):
-        foo1 = Concept(name="foo", body="1")
-        foo2 = Concept(name="foo", body="2")
-        context = self.get_context()
-        context.sheerka.cache_by_key["foo"] = [foo1, foo2]
+        sheerka, context, regex_parser, foo1, foo2 = self.init_parser(
+            Concept(name="foo", body="1"),
+            Concept(name="foo", body="2"))
 
-        regex_parser = BnfParser()
         res = regex_parser.parse(context, "foo")
 
         assert not res.status
@@ -185,9 +181,7 @@ class TestBnfParser(TestUsingMemoryBasedSheerka):
         assert res.value.body == ('key', 'foo')
 
     def test_i_cannot_parse_when_unknown_concept(self):
-        context = self.get_context()
-
-        regex_parser = BnfParser()
+        sheerka, context, regex_parser = self.init_parser()
         res = regex_parser.parse(self.get_context(), "foo")
 
         assert not res.status