Added SyaNodeParser (finally, after one month)

src/parsers/ExactConceptParser.py

@@ -16,26 +16,26 @@ class ExactConceptParser(BaseParser):
     def __init__(self, **kwargs):
         BaseParser.__init__(self, "ExactConcept", 80)
 
-    def parse(self, context, text):
+    def parse(self, context, parser_input):
         """
         text can be string, but text can also be an list of tokens
         :param context:
-        :param text:
+        :param parser_input:
         :return:
         """
 
-        context.log(f"Parsing '{text}'", self.name)
+        context.log(f"Parsing '{parser_input}'", self.name)
         res = []
         sheerka = context.sheerka
         try:
-            words = self.get_words(text)
+            words = self.get_words(parser_input)
         except LexerError as e:
             context.log(f"Error found in tokenizer {e}", self.name)
             return sheerka.ret(self.name, False, sheerka.new(BuiltinConcepts.ERROR, body=e))
 
         if len(words) > self.MAX_WORDS_SIZE:
             context.log(f"Max words reached. Stopping.", self.name)
-            return sheerka.ret(self.name, False, sheerka.new(BuiltinConcepts.CONCEPT_TOO_LONG, body=text))
+            return sheerka.ret(self.name, False, sheerka.new(BuiltinConcepts.CONCEPT_TOO_LONG, body=parser_input))
 
         recognized = False
         for combination in self.combinations(words):
@@ -69,26 +69,25 @@ class ExactConceptParser(BaseParser):
                     context.sheerka.new(
                         BuiltinConcepts.PARSER_RESULT,
                         parser=self,
-                        source=text if isinstance(text, str) else self.get_text_from_tokens(text),
+                        source=parser_input if isinstance(parser_input, str) else self.get_text_from_tokens(parser_input),
                         body=concept,
                         try_parsed=concept)))
                 recognized = True
 
         if recognized:
             if len(res) == 1:
-                self.log_result(context, text, res[0])
+                self.log_result(context, parser_input, res[0])
             else:
-                self.log_multiple_results(context, text, res)
+                self.log_multiple_results(context, parser_input, res)
                 return res
             return res
 
-        ret = sheerka.ret(self.name, False, sheerka.new(BuiltinConcepts.UNKNOWN_CONCEPT, body=text))
-        self.log_result(context, text, ret)
+        ret = sheerka.ret(self.name, False, sheerka.new(BuiltinConcepts.UNKNOWN_CONCEPT, body=parser_input))
+        self.log_result(context, parser_input, ret)
         return ret
 
-    @staticmethod
-    def get_words(text):
-        tokens = iter(Tokenizer(text)) if isinstance(text, str) else text
+    def get_words(self, text):
+        tokens = self.get_input_as_tokens(text)
         res = []
         for t in tokens:
             if t.type == TokenKind.EOF: