Implemented FunctionParser

tests/evaluators/test_LexerNodeEvaluator.py

@@ -27,7 +27,7 @@ class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):
         for fragment in fragments:
             if isinstance(fragment, str):
                 node = PythonNode(fragment, ast.parse(fragment.strip(), mode="eval"))
-                nodes.append(SourceCodeNode(node, 0, 0, [], fragment))
+                nodes.append(SourceCodeNode(0, 0, [], fragment, node))
             else:
                 nodes.append(ConceptNode(fragment, 0, 0, [], fragment.name))
 
@@ -82,10 +82,9 @@ class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):
         wrapper = result.body
         return_value = result.body.body
 
-        assert result.who == evaluator.name
+        assert result.who == "parsers.PythonWithConcepts"
         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"))

tests/evaluators/test_PythonEvaluator.py

@@ -1,8 +1,12 @@
+import ast
+
 import pytest
 from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
 from core.concept import Concept, CB, NotInit
 from core.sheerka.services.SheerkaExecute import ParserInput
+from core.tokenizer import Tokenizer
 from evaluators.PythonEvaluator import PythonEvaluator, PythonEvalError
+from parsers.BaseNodeParser import SourceCodeNode, SourceCodeWithConceptNode
 from parsers.PythonParser import PythonNode, PythonParser
 
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
@@ -12,10 +16,28 @@ def get_concept_name(concept):
     return concept.name
 
 
+def get_source_code_node(source_code, concepts=None):
+    if source_code:
+        python_node = PythonNode(source_code, ast.parse(source_code, f"<source>", 'eval'))
+    else:
+        python_node = PythonNode("", None)
+
+    if concepts is None:
+        tokens = list(Tokenizer(source_code, yield_eof=False))
+        return SourceCodeNode(0, len(tokens), tokens, python_node=python_node)
+    else:
+        python_node.concepts = concepts
+        scwcn = SourceCodeWithConceptNode(None, None)
+        scwcn.python_node = python_node
+        return scwcn
+
+
 class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
 
     @pytest.mark.parametrize("ret_val, expected", [
         (ReturnValueConcept("some_name", True, ParserResultConcept(value=PythonNode("", None))), True),
+        (ReturnValueConcept("some_name", True, ParserResultConcept(value=get_source_code_node(""))), True),
+        (ReturnValueConcept("some_name", True, ParserResultConcept(value=get_source_code_node("", {}))), True),
         (ReturnValueConcept("some_name", True, ParserResultConcept(value="other thing")), False),
         (ReturnValueConcept("some_name", False, "not relevant"), False),
         (ReturnValueConcept("some_name", True, Concept()), False)
@@ -39,6 +61,19 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         assert evaluated.status
         assert evaluated.value == expected
 
+    @pytest.mark.parametrize("source_code_node, expected", [
+        (get_source_code_node("1 + 1"), 2),
+        (get_source_code_node("one + one", {"one": Concept("one", body="1")}), 2)
+    ])
+    def test_i_can_eval_source_code_node(self, source_code_node, expected):
+        context = self.get_context()
+        return_value = context.sheerka.ret("parsers.??", True, ParserResultConcept(value=source_code_node))
+
+        evaluated = PythonEvaluator().eval(context, return_value)
+
+        assert evaluated.status
+        assert evaluated.value == expected
+
     def test_i_can_eval_using_context(self):
         context = self.get_context()
         parsed = PythonParser().parse(context, ParserInput("test_using_context('value for param1', 10)"))
@@ -239,3 +274,18 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         PythonEvaluator().update_globals_with_context(my_globals, context)
 
         assert my_globals == {"self": foo, "b": "'Initialized!'"}
+
+    def test_i_can_use_sheerka_locals(self):
+        sheerka, context = self.init_concepts()
+
+        def func(i):
+            return i + 1
+
+        sheerka.locals["func"] = func
+
+        parsed = PythonParser().parse(context, ParserInput("func(10)"))
+        python_evaluator = PythonEvaluator()
+        evaluated = python_evaluator.eval(context, parsed)
+
+        assert evaluated.status
+        assert evaluated.value == 11