Esempio n. 1
0
    def evaluate(self, rulez: ExplicitRules, navigator: Navigator) -> ExplicitEvaluation:
        logging.debug("evaluate atomic")

        for i, entry in enumerate(self.tokens):
            result = entry.evaluate(rulez, navigator)

            if not result.result:
                return ExplicitEvaluation(False, dict(), [navigator.get_absolute_index() - 1])

            if i < len(self.tokens) - 1:
                navigator.__next__()

        return ExplicitEvaluation(True, dict(), [navigator.get_absolute_index() - 1])
Esempio n. 2
0
    def evaluate(self, rulez: ExplicitRules,
                 navigator: Navigator) -> ExplicitEvaluation:
        logging.debug("evaluate regex")

        tuples: List[RegexUnit] = [
            RegexUnit(navigator.get_absolute_index() - 1, navigator.get_curr())
        ]

        pattern = re.compile(self.pattern)
        entries: Dict[str, str] = dict()

        text = "".join(map(lambda x: x.token, tuples))
        result = re.search(pattern, text)

        if result:
            entries["group"] = result.group()
            return ExplicitEvaluation(True, entries,
                                      [navigator.get_absolute_index() - 1])

        while navigator.has_next():
            navigator.__next__()
            tuples.append(
                RegexUnit(navigator.get_absolute_index() - 1,
                          navigator.get_curr()))

            text = "".join(map(lambda x: x.token, tuples))
            result = re.search(pattern, text)

            if result:
                for i in reversed(range(len(tuples))):
                    substr = "".join(map(lambda x: x.token, tuples[i:]))
                    result = re.search(pattern, text)

                    if result:
                        if result.pos == 0 and substr[result.pos - 1] == ' ':
                            entries["group"] = result.group()
                            return ExplicitEvaluation(
                                True, entries,
                                list(map(lambda x: x.index, tuples[i:])))

        return ExplicitEvaluation(False, entries, [])