Class BacktickInlineProcessor

markdown/inlinepatterns.py:436–510

Return a ` ` element containing the escaped matching text.

class BacktickInlineProcessor(InlineProcessor):
    """ Return a `<code>` element containing the escaped matching text. """

    def __init__(self, pattern: str):
        InlineProcessor.__init__(self, pattern)
        self.ESCAPED_BSLASH = '{}{}{}'.format(util.STX, ord('\\'), util.ETX)
        self.tag = 'code'
        """ The tag of the rendered element. """

    def find_code_spans(self, start: int, text: str) -> tuple[int, int] | None:
        """Find code spans."""

        last = len(text)

        # Get the maximum starting ticks
        max_ticks = 0
        while start < last and text[start] == '`':
            max_ticks += 1
            start += 1

        if not max_ticks:  # pragma: no cover
            # This is not ever expected to happen.
            return None

        longest_span = 0
        end = 0

        # Find an ending span of backticks that matches our opening
        i = start
        while i < last:
            span_length = 0
            while i < last and text[i] == '`':
                span_length += 1
                i += 1
            if not span_length:
                i += 1
                continue

            # Did we find the end?
            if max_ticks == span_length:
                return start, i - span_length

            # Track the longest span of backticks we find as a fallback.
            if span_length > longest_span:
                longest_span = span_length
                end = i

        # Since we didn't find an exact matching start and end,
        # adjust start to match the largest end we could calculate.
        if longest_span:
            return start - (max_ticks - longest_span), end - longest_span

        # We could not find a suitable pairing
        return None

    def handleMatch(self, m: re.Match[str], data: str) -> tuple[etree.Element | str | None, int | None, int | None]:
        """
        If the match contains `group(3)` of a pattern, then return a `code`