Merge pull request #462 from Sanjays2402/fix/markdown-renderer-escape-emphasis

Author: lepture

docs/changes.rst

@@ -3,6 +3,12 @@ Changelog
 
 Here is the full history of mistune v3.
 
+Unreleased
+----------
+
+* Escape literal ``*``/``_`` emphasis markers in the Markdown renderer so
+  round-tripping escaped text does not re-introduce emphasis.
+
 Version 3.3.2
 -------------
 

src/mistune/renderers/markdown.py

@@ -40,9 +40,18 @@ def render_children(self, token: Dict[str, Any], state: BlockState) -> str:
         return self.render_tokens(children, state)
 
     def text(self, token: Dict[str, Any], state: BlockState) -> str:
+        raw = cast(str, token["raw"])
+        # a text token that is made up entirely of "*"/"_" is a literal
+        # emphasis delimiter -- either an escaped marker from the source
+        # (``\*``) or an unmatched leftover -- so every character must stay
+        # escaped, or it would re-parse as emphasis on the round-trip. Prose
+        # punctuation such as ``2 * 3`` or ``snake_case`` arrives mixed with
+        # other characters and is left untouched.
+        if raw and all(c in "*_" for c in raw):
+            return "".join("\\" + c for c in raw)
         # a backtick always opens a code span, so it must stay escaped to
         # survive a re-parse as literal text.
-        return cast(str, token["raw"]).replace("`", "\\`")
+        return raw.replace("`", "\\`")
 
     def emphasis(self, token: Dict[str, Any], state: BlockState) -> str:
         return "*" + self.render_children(token, state) + "*"

tests/test_renderers.py

@@ -46,6 +46,35 @@ def test_escaped_marker_inside_list_item(self):
     def test_escaped_backtick(self):
         self.assert_round_trip(r"\`not code\`" + "\n")
 
+    def test_escaped_emphasis_markers(self):
+        # an escaped "*"/"_" is a literal delimiter, not emphasis; re-emitting
+        # it unescaped would turn plain text back into <em>/<strong>
+        for text in (
+            r"\*not emphasis\*" + "\n",
+            r"\_not emphasis\_" + "\n",
+            r"\*\*not strong\*\*" + "\n",
+            r"\_\_not strong\_\_" + "\n",
+            r"a word\_with\_underscores" + "\n",
+            r"2 \* 3 \* 4" + "\n",
+            r"trailing star\*" + "\n",
+            r"\*leading star" + "\n",
+        ):
+            self.assert_round_trip(text)
+
+    def test_real_emphasis_not_over_escaped(self):
+        # genuine emphasis must survive untouched, and prose punctuation with
+        # spaces around a "*"/"_" must not gain stray backslashes
+        for text in (
+            "*emphasis*\n",
+            "**strong**\n",
+            "***both***\n",
+            "_under_ and __strong__\n",
+            "a *b* and _c_ mixed\n",
+            "2 * 3 = 6 and 4 * 5\n",
+            "snake_case_variable\n",
+        ):
+            self.assert_round_trip(text)
+
     def test_codespan_containing_backticks(self):
         # the delimiter must grow past any backtick run inside the code span,
         # and pad away a leading/trailing backtick, or the re-parse breaks