I can also get concept by name

tests/parsers/test_DefaultParser.py

@@ -2,7 +2,7 @@ import pytest
 import ast
 
 from core.builtin_concepts import ParserResultConcept, BuiltinConcepts, ReturnValueConcept
-from core.concept import Concept
+from core.concept import Concept, DEFINITION_TYPE_BNF, DEFINITION_TYPE_DEF
 from parsers.ConceptLexerParser import OrderedChoice, StrMatch, ConceptExpression
 from parsers.PythonParser import PythonParser, PythonNode
 from core.tokenizer import Keywords, Tokenizer, LexerError
@@ -13,7 +13,7 @@ from parsers.BnfParser import BnfParser
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
 
-def get_def_concept(name, where=None, pre=None, post=None, body=None, definition=None):
+def get_def_concept(name, where=None, pre=None, post=None, body=None, definition=None, bnf_def=None):
     def_concept = DefConceptNode([], name=NameNode(list(Tokenizer(name))))
 
     if body:
@@ -24,11 +24,15 @@ def get_def_concept(name, where=None, pre=None, post=None, body=None, definition
         def_concept.pre = get_concept_part(pre)
     if post:
         def_concept.post = get_concept_part(post)
-    if definition:
+    if bnf_def:
         def_concept.definition = ReturnValueConcept(
             "parsers.Bnf",
             True,
-            definition)
+            bnf_def)
+        def_concept.definition_type = DEFINITION_TYPE_BNF
+    if definition:
+        def_concept.definition = NameNode(list(Tokenizer(definition)))
+        def_concept.definition_type = DEFINITION_TYPE_DEF
 
     return def_concept
 
@@ -237,7 +241,7 @@ def concept add one to a as
         assert not res.status
         assert return_value.value == [SyntaxErrorNode([], "Newline are not allowed in name.")]
 
-    def test_i_can_parse_def_concept_from_regex(self):
+    def test_i_can_parse_def_concept_from_bnf(self):
         context = self.get_context()
         a_concept = Concept("a_concept")
         context.sheerka.add_in_cache(a_concept)
@@ -248,7 +252,7 @@ def concept add one to a as
         node = res.value.value
         definition = OrderedChoice(ConceptExpression(a_concept, rule_name="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)
+        expected = get_def_concept(name="name", body="__definition[0]", bnf_def=parser_result)
 
         assert res.status
         assert res.who == parser.name
@@ -267,8 +271,12 @@ def concept add one to a as
 
         assert not parser.has_error
 
-    def test_i_can_detect_empty_bnf_declaration(self):
-        text = "def concept name from bnf as __definition[0]"
+    @pytest.mark.parametrize("text", [
+        "def concept name from bnf as here is my body",
+        "def concept name from def as here is my body",
+        "def concept name from as here is my body"
+    ])
+    def test_i_can_detect_empty_bnf_declaration(self, text):
 
         parser = DefaultParser()
         res = parser.parse(self.get_context(), text)
@@ -276,6 +284,21 @@ def concept add one to a as
         assert not res.status
         assert res.value.value[0] == SyntaxErrorNode([], "Empty declaration")
 
+    @pytest.mark.parametrize("text", [
+        "def concept addition from a plus b as a + b",
+        "def concept addition from def a plus b as a + b"])
+    def test_i_can_def_concept_from_definition(self, text):
+        parser = DefaultParser()
+        res = parser.parse(self.get_context(), text)
+        expected = get_def_concept("addition", definition="a plus b", body="a + b")
+        node = res.value.value
+
+        assert res.status
+        assert res.who == parser.name
+        assert res.value.source == text
+        assert isinstance(res.value, ParserResultConcept)
+        assert node == expected
+
     def test_i_can_detect_not_for_me(self):
         text = "hello world"
         context = self.get_context()