Added simple form of concept composition

parsers/ConceptsWithConceptsParser.py

@@ -0,0 +1,110 @@
+from core.builtin_concepts import BuiltinConcepts
+from core.tokenizer import TokenKind, Token
+from parsers.BaseParser import BaseParser
+from parsers.ConceptLexerParser import ConceptNode, UnrecognizedTokensNode, SourceCodeNode
+from parsers.MultipleConceptsParser import MultipleConceptsParser
+from core.concept import VARIABLE_PREFIX
+import logging
+
+multiple_concepts_parser = MultipleConceptsParser()
+
+
+class ConceptsWithConceptsParser(BaseParser):
+    def __init__(self, **kwargs):
+        super().__init__("ConceptsWithConcepts", 25)
+
+    @staticmethod
+    def get_tokens(nodes):
+        tokens = []
+
+        for node in nodes:
+            if isinstance(node, ConceptNode):
+                index, line, column = node.tokens[0].index, node.tokens[0].line, node.tokens[0].column
+                tokens.append(Token(TokenKind.CONCEPT, node.concept, index, line, column))
+            else:
+                for token in node.tokens:
+                    if token.type == TokenKind.EOF:
+                        break
+                    elif token.type in (TokenKind.NEWLINE, TokenKind.WHITESPACE):
+                        continue
+                    else:
+                        tokens.append(token)
+
+        return tokens
+
+    @staticmethod
+    def get_key(nodes):
+        key = ""
+        index = 0
+        for node in nodes:
+            if key:
+                key += " "
+
+            if isinstance(node, UnrecognizedTokensNode):
+                key += node.source.strip()
+            else:
+                key += f"{VARIABLE_PREFIX}{index}"
+                index += 1
+
+        return key
+
+    def finalize_concept(self, context, concept, nodes):
+        index = 0
+        for node in nodes:
+
+            if isinstance(node, ConceptNode):
+                prop_name = list(concept.props.keys())[index]
+                concept.cached_asts[prop_name] = node.concept
+                context.log(
+                    self.verbose_log,
+                    f"Setting property '{prop_name}='{node.concept}'.",
+                    self.name)
+                index += 1
+            elif isinstance(node, SourceCodeNode):
+                prop_name = list(concept.props.keys())[index]
+                sheerka = context.sheerka
+                value = sheerka.new(BuiltinConcepts.PARSER_RESULT, parser=self, source=node.source, body=node.node)
+                concept.cached_asts[prop_name] = [context.sheerka.ret(self.name, True, value)]
+                context.log(
+                    self.verbose_log,
+                    f"Setting property '{prop_name}'='Python({node.source})'.",
+                    self.name)
+                index += 1
+
+        return concept
+
+    def parse(self, context, text):
+        sheerka = context.sheerka
+        if not sheerka.isinstance(text, BuiltinConcepts.PARSER_RESULT):
+            return None
+
+        if not text.parser == multiple_concepts_parser:
+            return None
+
+        nodes = text.body
+
+        concept_key = self.get_key(nodes)
+        concept = sheerka.new(concept_key)
+        if sheerka.isinstance(concept, BuiltinConcepts.UNKNOWN_CONCEPT):
+            return sheerka.ret(
+                self.name,
+                False,
+                sheerka.new(BuiltinConcepts.NOT_FOR_ME, body=text.body))
+
+        concepts = concept if hasattr(concept, "__iter__") else [concept]
+        for concept in concepts:
+            self.finalize_concept(context, concept, nodes)
+
+        res = []
+        for concept in concepts:
+            res.append(sheerka.ret(
+                self.name,
+                True,
+                sheerka.new(
+                    BuiltinConcepts.PARSER_RESULT,
+                    parser=self,
+                    source=text.source,
+                    body=concept,
+                    try_parsed=None)))
+
+        return res[0] if len(res) == 1 else res