Implemented some enhancement requests

src/evaluators/FormatRuleEvaluator.py

@@ -3,8 +3,7 @@ from core.builtin_concepts import BuiltinConcepts, ParserResultConcept
 from core.rule import Rule
 from core.tokenizer import Keywords
 from evaluators.BaseEvaluator import OneReturnValueEvaluator
-from parsers.BaseParser import BaseParser
-from parsers.FormatRuleParser import FormatRuleNode
+from parsers.DefFormatRuleParser import FormatRuleNode
 
 
 class FormatRuleEvaluator(OneReturnValueEvaluator):

src/evaluators/MultipleErrorsEvaluator.py

@@ -5,7 +5,7 @@ from parsers.BaseParser import BaseParser
 
 class MultipleErrorsEvaluator(AllReturnValuesEvaluator):
     """
-    Use to reduce to evaluator errors
+    Used to reduce to evaluator errors
     All parser error will be discarded
     Cannot match if there is at least one successful evaluator
     """

src/evaluators/MultipleSuccessEvaluator.py

@@ -0,0 +1,67 @@
+from core.builtin_concepts import BuiltinConcepts
+from evaluators.BaseEvaluator import AllReturnValuesEvaluator, BaseEvaluator
+from parsers.BaseParser import BaseParser
+
+
+class MultipleSuccessEvaluator(AllReturnValuesEvaluator):
+    """
+    Used to reduce evaluators
+    It's used when there are multiple successful return values, but their values are not evaluated
+    So we cannot decide whether it's a MultipleSameSuccess or not
+    All parser in error will be discarded
+    Cannot match if there is at least one evaluator in error
+    """
+    NAME = "MultipleSuccess"
+
+    def __init__(self):
+        super().__init__(self.NAME, [BuiltinConcepts.AFTER_EVALUATION], 30)
+        self.successful_return_values = []
+
+    def reset(self):
+        super().reset()
+        self.successful_return_values.clear()
+
+    def matches(self, context, return_values):
+        nb_evaluators_in_success = 0
+        to_process = False
+
+        for ret in return_values:
+            if ret.status and ret.who.startswith(BaseParser.PREFIX):
+                return False
+            elif ret.who.startswith(BaseEvaluator.PREFIX) and not ret.status:
+                return False
+            elif ret.status and context.sheerka.isinstance(ret.body, BuiltinConcepts.REDUCE_REQUESTED):
+                to_process = True
+                self.eaten.append(ret)
+            elif ret.status and ret.who.startswith(BaseEvaluator.PREFIX):
+                if self.already_seen(context, ret):
+                    return False
+                nb_evaluators_in_success += 1
+                self.successful_return_values.append(ret)
+                self.eaten.append(ret)
+            elif not ret.status and ret.who.startswith(BaseParser.PREFIX):
+                self.eaten.append(ret)
+            # else:
+            # other concepts. We do not care if there are successful or not
+            # They won't be part of result nor part of the parent
+            # --> So they will be handled by other evaluators
+
+        return to_process and nb_evaluators_in_success > 1
+
+    def eval(self, context, return_values):
+        context.log(f"{len(self.successful_return_values)} successful return values, {len(self.eaten)} item(s) eaten",
+                    who=self)
+        context.log(f"{self.successful_return_values}", who=self)
+
+        sheerka = context.sheerka
+        return sheerka.ret(
+            self.name,
+            True,
+            sheerka.new(BuiltinConcepts.MULTIPLE_SUCCESS, body=self.successful_return_values.copy()),
+            parents=self.eaten)
+
+    def already_seen(self, context, ret_val):
+        for successful in self.successful_return_values:
+            if context.sheerka.objvalue(successful.value) == context.sheerka.objvalue(ret_val.value):
+                return True
+        return False