Renamed ConceptMatch into ConceptExpression and added unit tests

tests/test_AddConceptEvaluator.py

@@ -8,7 +8,7 @@ from core.sheerka import Sheerka, ExecutionContext
 from core.tokenizer import Tokenizer
 from evaluators.AddConceptEvaluator import AddConceptEvaluator
 from parsers.BaseParser import BaseParser
-from parsers.ConceptLexerParser import Sequence, StrMatch, ZeroOrMore, ConceptMatch
+from parsers.ConceptLexerParser import Sequence, StrMatch, ZeroOrMore, ConceptExpression
 from parsers.BnfParser import BnfParser
 from parsers.DefaultParser import DefConceptNode, NameNode
 from parsers.PythonParser import PythonNode, PythonParser
@@ -184,7 +184,7 @@ def test_i_can_get_props_from_another_concept():
 
 
 def test_i_can_get_props_from_definition():
-    parsing_expression = Sequence(ConceptMatch('mult'), ZeroOrMore(Sequence(StrMatch("+"), ConceptMatch("add"))))
+    parsing_expression = Sequence(ConceptExpression('mult'), ZeroOrMore(Sequence(StrMatch("+"), ConceptExpression("add"))))
     ret_val = get_concept_definition("mult (('+'|'-') add)?", parsing_expression)
 
     assert AddConceptEvaluator.get_props(get_context(), ret_val, []) == ["add", "mult"]

tests/test_BnfParser.py

@@ -6,7 +6,7 @@ from core.tokenizer import Tokenizer, TokenKind, LexerError
 from parsers.BaseParser import UnexpectedTokenErrorNode
 from parsers.BnfParser import BnfParser, UnexpectedEndOfFileError
 from parsers.ConceptLexerParser import StrMatch, Optional, ZeroOrMore, OrderedChoice, Sequence, OneOrMore, \
-    ConceptLexerParser, ConceptNode, ConceptMatch, cnode
+    ConceptLexerParser, ConceptNode, ConceptExpression, cnode
 from sdp.sheerkaDataProvider import Event
 
 
@@ -41,12 +41,12 @@ def get_context():
     ("(1|*) +", Sequence(OrderedChoice(StrMatch("1"), StrMatch("*")), StrMatch("+"))),
     ("1, :&", Sequence(StrMatch("1"), StrMatch(","), StrMatch(":"), StrMatch("&"))),
     ("(1 )", StrMatch("1")),
-    ("foo", ConceptMatch("foo")),
-    ("foo*", ZeroOrMore(ConceptMatch("foo"))),
-    ("foo 'and' bar+", Sequence(ConceptMatch("foo"), StrMatch("and"), OneOrMore(ConceptMatch("bar")))),
-    ("foo | bar?", OrderedChoice(ConceptMatch("foo"), Optional(ConceptMatch("bar")))),
-    ("'str' = var", Sequence(StrMatch("str"), StrMatch("="), ConceptMatch("var"))),
-    ("'str''='var", Sequence(StrMatch("str"), StrMatch("="), ConceptMatch("var"))),
+    ("foo", ConceptExpression("foo")),
+    ("foo*", ZeroOrMore(ConceptExpression("foo"))),
+    ("foo 'and' bar+", Sequence(ConceptExpression("foo"), StrMatch("and"), OneOrMore(ConceptExpression("bar")))),
+    ("foo | bar?", OrderedChoice(ConceptExpression("foo"), Optional(ConceptExpression("bar")))),
+    ("'str' = var", Sequence(StrMatch("str"), StrMatch("="), ConceptExpression("var"))),
+    ("'str''='var", Sequence(StrMatch("str"), StrMatch("="), ConceptExpression("var"))),
     ("'str'=var", StrMatch("str", rule_name="var")),
     ("'foo'?=var", Optional(StrMatch("foo"), rule_name="var")),
     ("('foo'?)=var", Optional(StrMatch("foo"), rule_name="var")),

tests/test_ConceptLexerParser.py

@@ -5,7 +5,7 @@ from core.concept import Concept, ConceptParts, DoNotResolve
 from core.sheerka import Sheerka, ExecutionContext
 from core.tokenizer import Tokenizer, TokenKind, Token
 from parsers.ConceptLexerParser import ConceptLexerParser, ConceptNode, Sequence, StrMatch, OrderedChoice, Optional, \
-    ParsingExpressionVisitor, TerminalNode, NonTerminalNode, LexerNode, ConceptMatch, ZeroOrMore, OneOrMore, \
+    ParsingExpressionVisitor, TerminalNode, NonTerminalNode, LexerNode, ConceptExpression, ZeroOrMore, OneOrMore, \
     UnrecognizedTokensNode, cnode, short_cnode
 from sdp.sheerkaDataProvider import Event
 
@@ -14,7 +14,7 @@ class ConceptVisitor(ParsingExpressionVisitor):
     def __init__(self):
         self.concepts = set()
 
-    def visit_ConceptMatch(self, node):
+    def visit_ConceptExpression(self, node):
         self.concepts.add(node.concept)
 
 

tests/test_DefaultParser.py

@@ -3,7 +3,7 @@ import ast
 
 from core.builtin_concepts import ParserResultConcept, BuiltinConcepts, ReturnValueConcept
 from core.sheerka import Sheerka, ExecutionContext
-from parsers.ConceptLexerParser import OrderedChoice, StrMatch, ConceptMatch
+from parsers.ConceptLexerParser import OrderedChoice, StrMatch, ConceptExpression
 from parsers.PythonParser import PythonParser, PythonNode
 from core.tokenizer import Keywords, Tokenizer, LexerError
 from parsers.DefaultParser import DefaultParser, NameNode, SyntaxErrorNode, CannotHandleErrorNode, IsaConceptNode
@@ -259,7 +259,7 @@ def test_i_can_parse_def_concept_from_regex():
     parser = DefaultParser()
     res = parser.parse(get_context(), text)
     node = res.value.value
-    definition = OrderedChoice(ConceptMatch("a_concept"), StrMatch("a_string"))
+    definition = OrderedChoice(ConceptExpression("a_concept"), StrMatch("a_string"))
     parser_result = ParserResultConcept(BnfParser(), "a_concept | 'a_string'", definition, definition)
     expected = get_def_concept(name="name", body="__definition[0]", definition=parser_result)
 

tests/test_sheerka.py

@@ -3,9 +3,11 @@ import os
 from os import path
 import shutil
 
-from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, UserInputConcept, ConceptAlreadyInSet
+from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept, UserInputConcept, ConceptAlreadyInSet, \
+    ParserResultConcept
 from core.concept import Concept, PROPERTIES_TO_SERIALIZE, Property, ConceptParts, DoNotResolve
 from core.sheerka import Sheerka, ExecutionContext
+from parsers.PythonParser import PythonNode
 from sdp.sheerkaDataProvider import SheerkaDataProvider, Event
 
 tests_root = path.abspath("../build/tests")
@@ -709,6 +711,24 @@ def test_i_can_evaluate_when_property_asts_is_a_list():
     assert props[1] == "1"
 
 
+def test_i_can_evaluate_when_compiled_is_set_up_with_return_value():
+    sheerka = get_sheerka()
+
+    python_node = PythonNode("1 +1 ")
+    parser_result = ParserResultConcept(parser="who", value=python_node)
+
+    concept = Concept("to_eval").set_prop("prop")
+    concept.cached_asts["prop"] = [ReturnValueConcept("who", True, parser_result)]
+    evaluated = sheerka.evaluate_concept(get_context(sheerka), concept)
+    assert evaluated.get_prop("prop") == 2
+
+    # also works when only one return value
+    concept = Concept("to_eval").set_prop("prop")
+    concept.cached_asts["prop"] = ReturnValueConcept("who", True, parser_result)
+    evaluated = sheerka.evaluate_concept(get_context(sheerka), concept)
+    assert evaluated.get_prop("prop") == 2
+
+
 def test_i_can_reference_sheerka():
     sheerka = get_sheerka()
 

tests/test_sheerka_non_reg.py

@@ -8,7 +8,7 @@ from core.builtin_concepts import BuiltinConcepts
 from core.concept import Concept, PROPERTIES_TO_SERIALIZE, Property
 from core.sheerka import Sheerka, ExecutionContext
 from evaluators.MutipleSameSuccessEvaluator import MultipleSameSuccessEvaluator
-from parsers.ConceptLexerParser import Sequence, StrMatch, OrderedChoice, Optional, ConceptMatch
+from parsers.ConceptLexerParser import Sequence, StrMatch, OrderedChoice, Optional, ConceptExpression
 from sdp.sheerkaDataProvider import SheerkaDataProvider, Event
 
 tests_root = path.abspath("../build/tests")
@@ -330,8 +330,8 @@ def test_i_can_create_concept_with_bnf_definition():
 
     saved_definitions = sheerka.sdp.get_safe(sheerka.CONCEPTS_DEFINITIONS_ENTRY)
     expected_bnf = Sequence(
-        ConceptMatch("a", rule_name="a"),
-        Optional(Sequence(StrMatch("plus"), ConceptMatch("plus", rule_name="plus"))))
+        ConceptExpression("a", rule_name="a"),
+        Optional(Sequence(StrMatch("plus"), ConceptExpression("plus", rule_name="plus"))))
     assert saved_definitions[saved_concept] == expected_bnf
 
     new_concept = res[0].value.body