Sourcery refactored xin branch

markdown_it/common/html_re.py

@@ -1,6 +1,7 @@
 """Regexps to match html elements
 """
 
+
 import re
 
 attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*"
@@ -9,11 +10,11 @@
 single_quoted = "'[^']*'"
 double_quoted = '"[^"]*"'
 
-attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")"
+attr_value = f'(?:{unquoted}|{single_quoted}|{double_quoted})'
 
-attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)"
+attribute = f'(?:\\s+{attr_name}(?:\\s*=\\s*{attr_value})?)'
 
-open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>"
+open_tag = f'<[A-Za-z][A-Za-z0-9\\-]*{attribute}*\\s*\\/?>'
 
 close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>"
 comment = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->"
@@ -36,5 +37,5 @@
     + cdata
     + ")"
 )
-HTML_OPEN_CLOSE_TAG_STR = "^(?:" + open_tag + "|" + close_tag + ")"
+HTML_OPEN_CLOSE_TAG_STR = f'^(?:{open_tag}|{close_tag})'
 HTML_OPEN_CLOSE_TAG_RE = re.compile(HTML_OPEN_CLOSE_TAG_STR)

markdown_it/common/normalize_url.py

@@ -39,10 +39,7 @@
 
 
 def unescape_char(s: str) -> str:
-    if s[0] == "\\":
-        return s[1]
-    else:
-        return html.unescape(s)
+    return s[1] if s[0] == "\\" else html.unescape(s)
 
 
 def unescape_string(s: str) -> str:
@@ -76,8 +73,7 @@ def normalizeLink(url: str) -> str:
                 ^^^^^^^^^^^
     """
     (scheme, netloc, path, params, query, fragment) = urlparse(url)
-    if scheme in RECODE_HOSTNAME_FOR:
-        url = urlunparse(
+    return urlunparse(
             (
                 scheme,
                 unescape_normalize_uri(netloc),
@@ -86,11 +82,7 @@ def normalizeLink(url: str) -> str:
                 normalize_uri(query),
                 unescape_normalize_uri(fragment),
             )
-        )
-    else:
-        url = unescape_normalize_uri(url)
-
-    return url
+        ) if scheme in RECODE_HOSTNAME_FOR else unescape_normalize_uri(url)
 
     # TODO the selective encoding below should probably be done here,
     # something like:
@@ -126,8 +118,7 @@ def normalizeLinkText(link: str) -> str:
          ~~~~~~~~~~~
     """
     (scheme, netloc, path, params, query, fragment) = urlparse(link)
-    if scheme in RECODE_HOSTNAME_FOR:
-        url = urlunparse(
+    return urlunparse(
             (
                 scheme,
                 unescape_unquote(netloc),
@@ -136,10 +127,7 @@ def normalizeLinkText(link: str) -> str:
                 unquote(query),
                 unescape_unquote(fragment),
             )
-        )
-    else:
-        url = unescape_unquote(link)
-    return url
+        ) if scheme in RECODE_HOSTNAME_FOR else unescape_unquote(link)
 
     # TODO the selective encoding below should probably be done here,
     # something like:

markdown_it/common/utils.py

@@ -75,7 +75,7 @@ def isValidEntityCode(c: int) -> bool:
     # never used
     if c >= 0xFDD0 and c <= 0xFDEF:
         return False
-    if ((c & 0xFFFF) == 0xFFFF) or ((c & 0xFFFF) == 0xFFFE):
+    if c & 0xFFFF in [0xFFFF, 0xFFFE]:
         return False
     # control codes
     if c >= 0x00 and c <= 0x08:
@@ -150,7 +150,7 @@ def unescapeAll(string: str) -> str:
 
 
 ESCAPABLE = r"""\\!"#$%&'()*+,./:;<=>?@\[\]^`{}|_~-"""
-ESCAPE_CHAR = re.compile(r"\\([" + ESCAPABLE + r"])")
+ESCAPE_CHAR = re.compile(f'\\\\([{ESCAPABLE}])')
 
 
 def stripEscape(string: str) -> str:
@@ -190,8 +190,7 @@ def escapeHtml(raw: str) -> str:
 
 
 def escapeRE(string: str) -> str:
-    string = REGEXP_ESCAPE_RE.sub("\\$&", string)
-    return string
+    return REGEXP_ESCAPE_RE.sub("\\$&", string)
 
 
 # //////////////////////////////////////////////////////////////////////////////

markdown_it/helpers/parse_link_destination.py

@@ -62,12 +62,12 @@ def parseLinkDestination(string: str, pos: int, maximum: int) -> _Result:
             pos += 2
             continue
 
-        if code == 0x28:  # /* ( */)
+        if code == 0x28:
             level += 1
             if level > 32:
                 return result
 
-        if code == 0x29:  # /* ) */)
+        elif code == 0x29:
             if level == 0:
                 break
             level -= 1

markdown_it/helpers/parse_link_label.py

@@ -10,7 +10,6 @@
 
 def parseLinkLabel(state: StateInline, start: int, disableNested: bool = False) -> int:
 
-    labelEnd = -1
     oldPos = state.pos
     found = False
 
@@ -27,17 +26,16 @@ def parseLinkLabel(state: StateInline, start: int, disableNested: bool = False)
 
         prevPos = state.pos
         state.md.inline.skipToken(state)
-        if marker == 0x5B:  # /* [ */)
-            if prevPos == state.pos - 1:
+        if prevPos == state.pos - 1:
+            if marker == 0x5B:
                 # increase level if we find text `[`,
                 # which is not a part of any token
                 level += 1
-            elif disableNested:
+        elif disableNested:
+            if marker == 0x5B:
                 state.pos = oldPos
                 return -1
-    if found:
-        labelEnd = state.pos
-
+    labelEnd = state.pos if found else -1
     # restore old state
     state.pos = oldPos
 

markdown_it/helpers/parse_link_title.py

@@ -27,7 +27,7 @@ def parseLinkTitle(string: str, pos: int, maximum: int) -> _Result:
     marker = charCodeAt(string, pos)
 
     # /* " */  /* ' */  /* ( */
-    if marker != 0x22 and marker != 0x27 and marker != 0x28:
+    if marker not in [0x22, 0x27, 0x28]:
         return result
 
     pos += 1

markdown_it/main.py

@@ -122,11 +122,9 @@ def configure(
 
         if "components" in config:
             for name, component in config["components"].items():
-                rules = component.get("rules", None)
-                if rules:
+                if rules := component.get("rules", None):
                     self[name].ruler.enableOnly(rules)
-                rules2 = component.get("rules2", None)
-                if rules2:
+                if rules2 := component.get("rules2", None):
                     self[name].ruler2.enableOnly(rules2)
 
         return self

markdown_it/renderer.py

@@ -105,15 +105,12 @@ def renderInline(
         :param options: params of parser instance
         :param env: additional data from parsed input (references, for example)
         """
-        result = ""
-
-        for i, token in enumerate(tokens):
-            if token.type in self.rules:
-                result += self.rules[token.type](tokens, i, options, env)
-            else:
-                result += self.renderToken(tokens, i, options, env)
-
-        return result
+        return "".join(
+            self.rules[token.type](tokens, i, options, env)
+            if token.type in self.rules
+            else self.renderToken(tokens, i, options, env)
+            for i, token in enumerate(tokens)
+        )
 
     def renderToken(
         self,
@@ -161,19 +158,18 @@ def renderToken(
         if token.block:
             needLf = True
 
-            if token.nesting == 1:
-                if idx + 1 < len(tokens):
-                    nextToken = tokens[idx + 1]
+            if token.nesting == 1 and idx + 1 < len(tokens):
+                nextToken = tokens[idx + 1]
 
-                    if nextToken.type == "inline" or nextToken.hidden:
-                        # Block-level tag containing an inline tag.
-                        #
-                        needLf = False
+                if nextToken.type == "inline" or nextToken.hidden:
+                    # Block-level tag containing an inline tag.
+                    #
+                    needLf = False
 
-                    elif nextToken.nesting == -1 and nextToken.tag == token.tag:
-                        # Opening tag + closing tag of the same type. E.g. `<li></li>`.
-                        #
-                        needLf = False
+                elif nextToken.nesting == -1 and nextToken.tag == token.tag:
+                    # Opening tag + closing tag of the same type. E.g. `<li></li>`.
+                    #
+                    needLf = False
 
         result += ">\n" if needLf else ">"
 
@@ -182,12 +178,10 @@ def renderToken(
     @staticmethod
     def renderAttrs(token: Token) -> str:
         """Render token attributes to string."""
-        result = ""
-
-        for key, value in token.attrItems():
-            result += " " + escapeHtml(key) + '="' + escapeHtml(str(value)) + '"'
-
-        return result
+        return "".join(
+            f' {escapeHtml(key)}' + '="' + escapeHtml(str(value)) + '"'
+            for key, value in token.attrItems()
+        )
 
     def renderInlineAsText(
         self,
@@ -221,13 +215,9 @@ def renderInlineAsText(
 
     def code_inline(self, tokens: Sequence[Token], idx: int, options, env) -> str:
         token = tokens[idx]
-        return (
-            "<code"
+        return (("<code"
             + self.renderAttrs(token)
-            + ">"
-            + escapeHtml(tokens[idx].content)
-            + "</code>"
-        )
+            + ">" + escapeHtml(token.content)) + "</code>")
 
     def code_block(
         self,
@@ -238,13 +228,9 @@ def code_block(
     ) -> str:
         token = tokens[idx]
 
-        return (
-            "<pre"
+        return (("<pre"
             + self.renderAttrs(token)
-            + "><code>"
-            + escapeHtml(tokens[idx].content)
-            + "</code></pre>\n"
-        )
+            + "><code>" + escapeHtml(token.content)) + "</code></pre>\n")
 
     def fence(
         self,

markdown_it/ruler.py

@@ -76,10 +76,9 @@ def __init__(self):
 
     def __find__(self, name: str) -> int:
         """Find rule index by name"""
-        for i, rule in enumerate(self.__rules__):
-            if rule.name == name:
-                return i
-        return -1
+        return next(
+            (i for i, rule in enumerate(self.__rules__) if rule.name == name), -1
+        )
 
     def __compile__(self) -> None:
         """Build rules lookup cache"""
@@ -176,7 +175,7 @@ def enable(self, names: Union[str, Iterable[str]], ignoreInvalid: bool = False):
             idx = self.__find__(name)
             if (idx < 0) and ignoreInvalid:
                 continue
-            if (idx < 0) and not ignoreInvalid:
+            if idx < 0:
                 raise KeyError(f"Rules manager: invalid rule name {name}")
             self.__rules__[idx].enabled = True
             result.append(name)
@@ -212,7 +211,7 @@ def disable(self, names: Union[str, Iterable[str]], ignoreInvalid: bool = False)
             idx = self.__find__(name)
             if (idx < 0) and ignoreInvalid:
                 continue
-            if (idx < 0) and not ignoreInvalid:
+            if idx < 0:
                 raise KeyError(f"Rules manager: invalid rule name {name}")
             self.__rules__[idx].enabled = False
             result.append(name)

markdown_it/rules_block/blockquote.py

@@ -74,17 +74,16 @@ def blockquote(state: StateBlock, startLine: int, endLine: int, silent: bool):
     while pos < max:
         ch = state.srcCharCode[pos]
 
-        if isSpace(ch):
-            if ch == 0x09:  # / tab /
-                offset += (
-                    4
-                    - (offset + state.bsCount[startLine] + (1 if adjustTab else 0)) % 4
-                )
-            else:
-                offset += 1
+        if not isSpace(ch):
+            break
 
+        if ch == 0x09:  # / tab /
+            offset += (
+                4
+                - (offset + state.bsCount[startLine] + (1 if adjustTab else 0)) % 4
+            )
         else:
-            break
+            offset += 1
 
         pos += 1
 
@@ -188,22 +187,21 @@ def blockquote(state: StateBlock, startLine: int, endLine: int, silent: bool):
             while pos < max:
                 ch = state.srcCharCode[pos]
 
-                if isSpace(ch):
-                    if ch == 0x09:
-                        offset += (
-                            4
-                            - (
-                                offset
-                                + state.bsCount[nextLine]
-                                + (1 if adjustTab else 0)
-                            )
-                            % 4
-                        )
-                    else:
-                        offset += 1
-                else:
+                if not isSpace(ch):
                     break
 
+                if ch == 0x09:
+                    offset += (
+                        4
+                        - (
+                            offset
+                            + state.bsCount[nextLine]
+                            + (1 if adjustTab else 0)
+                        )
+                        % 4
+                    )
+                else:
+                    offset += 1
                 pos += 1
 
             lastLineEmpty = pos >= max
@@ -226,15 +224,10 @@ def blockquote(state: StateBlock, startLine: int, endLine: int, silent: bool):
         if lastLineEmpty:
             break
 
-        # Case 3: another tag found.
-        terminate = False
-
-        for terminatorRule in terminatorRules:
-            if terminatorRule(state, nextLine, endLine, True):
-                terminate = True
-                break
-
-        if terminate:
+        if terminate := any(
+            terminatorRule(state, nextLine, endLine, True)
+            for terminatorRule in terminatorRules
+        ):
             # Quirk to enforce "hard termination mode" for paragraphs;
             # normally if you call `tokenize(state, startLine, nextLine)`,
             # paragraphs will look below nextLine for paragraph continuation,