How to use the mwparserfromhell.utils.parse_anything function in mwparserfromhell

To help you get started, we’ve selected a few mwparserfromhell examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github earwig / mwparserfromhell / tests / test_utils.py View on Github external
tests = [
            (wraptext("foobar"), wraptext("foobar")),
            (Template(wraptext("spam")), wrap([Template(wraptext("spam"))])),
            ("fóóbar", wraptext("fóóbar")),
            (b"foob\xc3\xa1r", wraptext("foobár")),
            (123, wraptext("123")),
            (True, wraptext("True")),
            (None, wrap([])),
            ([Text("foo"), Text("bar"), Text("baz")],
             wraptext("foo", "bar", "baz")),
            ([wraptext("foo"), Text("bar"), "baz", 123, 456],
             wraptext("foo", "bar", "baz", "123", "456")),
            ([[[([[((("foo",),),)], "bar"],)]]], wraptext("foo", "bar"))
        ]
        for test, valid in tests:
            self.assertWikicodeEqual(valid, parse_anything(test))
github earwig / mwparserfromhell / mwparserfromhell / wikicode.py View on Github external
This follows the same rules as :meth:`_do_strong_search` with some
        differences. *obj* is treated as a string that might represent any
        :class:`.Node`, :class:`.Wikicode`, or combination of the two present
        in the node list. Thus, matching is weak (using string comparisons)
        rather than strong (using ``is``). Because multiple nodes can match
        *obj*, the result is a list of tuples instead of just one (however,
        :exc:`ValueError` is still raised if nothing is found). Individual
        matches will never overlap.

        The tuples contain a new first element, *exact*, which is ``True`` if
        we were able to match *obj* exactly to one or more adjacent nodes, or
        ``False`` if we found *obj* inside a node or incompletely spanning
        multiple nodes.
        """
        obj = parse_anything(obj)
        if not obj or obj not in self:
            raise ValueError(obj)
        results = []
        contexts = [self]
        while contexts:
            context = contexts.pop()
            i = len(context.nodes) - 1
            while i >= 0:
                node = context.get(i)
                if obj.get(-1) == node:
                    for j in range(-len(obj.nodes), -1):
                        if obj.get(j) != context.get(i + j + 1):
                            break
                    else:
                        i -= len(obj.nodes) - 1
                        index = slice(i, i + len(obj.nodes))
github earwig / mwparserfromhell / mwparserfromhell / wikicode.py View on Github external
def _slice_replace(code, index, old, new):
        """Replace the string *old* with *new* across *index* in *code*."""
        nodes = [str(node) for node in code.get(index)]
        substring = "".join(nodes).replace(old, new)
        code.nodes[index] = parse_anything(substring).nodes
github earwig / mwparserfromhell / mwparserfromhell / nodes / template.py View on Github external
def name(self, value):
        self._name = parse_anything(value)
github earwig / mwparserfromhell / mwparserfromhell / nodes / tag.py View on Github external
def add(self, name, value=None, quotes='"', pad_first=" ",
            pad_before_eq="", pad_after_eq=""):
        """Add an attribute with the given *name* and *value*.

        *name* and *value* can be anything parsable by
        :func:`.utils.parse_anything`; *value* can be omitted if the attribute
        is valueless. If *quotes* is not ``None``, it should be a string
        (either ``"`` or ``'``) that *value* will be wrapped in (this is
        recommended). ``None`` is only legal if *value* contains no spacing.

        *pad_first*, *pad_before_eq*, and *pad_after_eq* are whitespace used as
        padding before the name, before the equal sign (or after the name if no
        value), and after the equal sign (ignored if no value), respectively.
        """
        if value is not None:
            value = parse_anything(value)
        quotes = Attribute.coerce_quotes(quotes)
        attr = Attribute(parse_anything(name), value, quotes)
        attr.pad_first = pad_first
        attr.pad_before_eq = pad_before_eq
        attr.pad_after_eq = pad_after_eq
        self.attributes.append(attr)
        return attr
github earwig / mwparserfromhell / mwparserfromhell / wikicode.py View on Github external
def matches(self, other):
        """Do a loose equivalency test suitable for comparing page names.

        *other* can be any string-like object, including :class:`.Wikicode`, or
        an iterable of these. This operation is symmetric; both sides are
        adjusted. Specifically, whitespace and markup is stripped and the first
        letter's case is normalized. Typical usage is
        ``if template.name.matches("stub"): ...``.
        """
        normalize = lambda s: (s[0].upper() + s[1:]).replace("_", " ") if s else s
        this = normalize(self.strip_code().strip())

        if isinstance(other, (str, bytes, Wikicode, Node)):
            that = parse_anything(other).strip_code().strip()
            return this == normalize(that)

        for obj in other:
            that = parse_anything(obj).strip_code().strip()
            if this == normalize(that):
                return True
        return False