Added simple form of concept composition

tests/test_LexerNodeEvaluator.py

@@ -0,0 +1,115 @@
+import ast
+
+import pytest
+
+from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
+from core.concept import Concept, ConceptParts, DoNotResolve
+from core.sheerka import Sheerka, ExecutionContext
+from evaluators.LexerNodeEvaluator import LexerNodeEvaluator
+from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, StrMatch, UnrecognizedTokensNode, SourceCodeNode
+from parsers.PythonParser import PythonNode
+from sdp.sheerkaDataProvider import Event
+
+
+def get_context():
+    sheerka = Sheerka(skip_builtins_in_db=True)
+    sheerka.initialize("mem://")
+    return ExecutionContext("test", Event(), sheerka)
+
+
+def from_parsing(context, grammar, expression):
+    parser = ConceptLexerParser()
+    parser.initialize(context, grammar)
+
+    ret_val = parser.parse(context, expression)
+    assert ret_val.status
+    return ret_val
+
+
+def from_fragments(*fragments):
+    nodes = []
+    for fragment in fragments:
+        if isinstance(fragment, str):
+            node = PythonNode(fragment, ast.parse(fragment.strip(), mode="eval"))
+            nodes.append(SourceCodeNode(node, 0, 0, [], fragment))
+        else:
+            nodes.append(ConceptNode(fragment, 0, 0, [], fragment.name))
+
+    return ReturnValueConcept("somme_name", True, ParserResultConcept(value=nodes))
+
+
+def init(concept, grammar, text):
+    context = 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 = 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),
+    (ReturnValueConcept("some_name", True, ParserResultConcept(value=[SourceCodeNode(0, 0, [])])), True),
+    (ReturnValueConcept("some_name", True, ParserResultConcept(value=SourceCodeNode(0, 0, []))), True),
+    (ReturnValueConcept("some_name", True, ParserResultConcept(value=[UnrecognizedTokensNode(0, 0, [])])), False),
+    (ReturnValueConcept("some_name", True, ParserResultConcept(value=UnrecognizedTokensNode(0, 0, []))), False),
+    (ReturnValueConcept("some_name", False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])), False),
+    (ReturnValueConcept("some_name", False, ParserResultConcept(value=ConceptNode(Concept(), 0, 0))), False),
+    (ReturnValueConcept("some_name", False, ParserResultConcept(value=[SourceCodeNode(0, 0, [])])), False),
+    (ReturnValueConcept("some_name", False, ParserResultConcept(value=SourceCodeNode(0, 0, []))), False),
+    (ReturnValueConcept("some_name", True, ParserResultConcept(value="Not a concept node")), False),
+    (ReturnValueConcept("some_name", True, ParserResultConcept(value=["Not a concept node"])), False),
+    (ReturnValueConcept("some_name", True, [ConceptNode(Concept(), 0, 0)]), False),
+    (ReturnValueConcept("some_name", True, ConceptNode(Concept(), 0, 0)), False),
+])
+def test_i_can_match(ret_val, expected):
+    context = get_context()
+    assert LexerNodeEvaluator().matches(context, ret_val) == expected
+
+
+def test_concept_is_returned_when_only_one_in_the_list():
+    foo = Concept("foo")
+    context = get_context()
+    context.sheerka.add_in_cache(foo)
+
+    ret_val = from_parsing(context, {foo: StrMatch("foo")}, "foo")
+
+    evaluator = LexerNodeEvaluator()
+    result = evaluator.eval(context, ret_val)
+    wrapper = result.body
+    return_value = result.body.body
+
+    assert result.who == evaluator.name
+    assert result.status
+    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.cached_asts[ConceptParts.BODY] == DoNotResolve("foo")
+    assert result.parents == [ret_val]
+
+
+def test_concept_python_node_is_returned_when_source_code():
+    context = get_context()
+    foo = Concept("foo")
+    ret_val = from_fragments(foo, " + 1")
+
+    evaluator = LexerNodeEvaluator()
+    result = evaluator.eval(context, ret_val)
+    wrapper = result.body
+    return_value = result.body.body
+
+    assert result.who == evaluator.name
+    assert result.status
+    assert context.sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
+    assert wrapper.parser == evaluator
+    assert wrapper.source == "foo + 1"
+
+    assert return_value == PythonNode('foo + 1', ast.parse("__C__foo__C__ + 1", mode="eval"))
+    assert return_value.concepts == {"__C__foo__C__": foo}
+    assert result.parents == [ret_val]