Ticket #35533: changes.patch

django/utils/html.py

@@ -11 +11 @@
 from django.utils.encoding import punycode
 from django.utils.functional import Promise, keep_lazy, keep_lazy_text
 from django.utils.http import RFC3986_GENDELIMS, RFC3986_SUBDELIMS
+from django.utils.markdown import find_closing_markdown_bracket, has_markdown_link
 from django.utils.regex_helper import _lazy_re_compile
 from django.utils.safestring import SafeData, SafeString, mark_safe
 from django.utils.text import normalize_newlines
@@ -278 +279 @@
 
     mailto_template = "mailto:{local}@{domain}"
     url_template = '<a href="{href}"{attrs}>{url}</a>'
+    markdown_url_template = '[{text}](<a href="{url}"{attrs}>{trimmed_url}</a>)'
 
     def __call__(self, text, trim_url_limit=None, nofollow=False, autoescape=False):
         """
@@ -291 +293 @@
         """
         safe_input = isinstance(text, SafeData)
 
-        words = self.word_split_re.split(str(text))
+        text = str(text)
+        if has_markdown_link(text):
+            return self.handle_markdown_link(
+                text,
+                safe_input=safe_input,
+                trim_url_limit=trim_url_limit,
+                nofollow=nofollow,
+                autoescape=autoescape,
+            )
+
+        words = self.word_split_re.split(text)
         return "".join(
             [
                 self.handle_word(
@@ -305 +317 @@
             ]
         )
 
+    def handle_markdown_link(
+        self,
+        text,
+        *,
+        safe_input,
+        trim_url_limit=None,
+        nofollow=False,
+        autoescape=False,
+    ):
+        nofollow_attr = ' rel="nofollow"' if nofollow else ""
+
+        def find_and_replace_link(text):
+            i = 0
+            result = []
+            while i < len(text):
+                if text[i] == "\\":
+                    result.append(text[i : i + 2])
+                    i += 2
+                    continue
+                if text[i] == "[":
+                    start = i
+                    close_bracket = find_closing_markdown_bracket(text, i + 1)
+                    if (
+                        close_bracket != -1
+                        and close_bracket + 1 < len(text)
+                        and text[close_bracket + 1] == "("
+                    ):
+                        j = close_bracket + 2
+                        paren_depth = 1
+                        while j < len(text):
+                            if text[j] == "\\":
+                                j += 2
+                                continue
+                            if text[j] == "(":
+                                paren_depth += 1
+                            elif text[j] == ")":
+                                paren_depth -= 1
+                                if paren_depth == 0:
+                                    link_text = text[start + 1 : close_bracket]
+                                    link_url = text[close_bracket + 2 : j]
+                                    trimmed_url = self.trim_url(
+                                        link_url, limit=trim_url_limit
+                                    )
+
+                                    if autoescape and not safe_input:
+                                        link_text = escape(link_text)
+                                        link_url = escape(link_url)
+                                        trimmed_url = escape(trimmed_url)
+
+                                    result.append(
+                                        self.markdown_url_template.format(
+                                            text=link_text,
+                                            url=link_url,
+                                            attrs=nofollow_attr,
+                                            trimmed_url=trimmed_url,
+                                        )
+                                    )
+                                    i = j + 1
+                                    break
+                            j += 1
+                        else:
+                            result.append(text[i])
+                            i += 1
+                    else:
+                        result.append(text[i])
+                        i = close_bracket + 1 if close_bracket != -1 else i + 1
+                else:
+                    result.append(text[i])
+                    i += 1
+            return "".join(result)
+
+        return find_and_replace_link(text)
+
     def handle_word(
         self,
         word,

new file django/utils/markdown.py

@@ +1 @@
+def find_closing_markdown_bracket(text, start):
+    """
+    Find the closing bracket corresponding to the opening bracket.
+    """
+    depth = 0
+    i = start
+    while i < len(text):
+        if text[i] == "\\":
+            i += 2
+            continue
+        if text[i] == "[":
+            depth += 1
+        elif text[i] == "]":
+            if depth == 0:
+                return i
+            depth -= 1
+        i += 1
+    return -1
+
+
+def has_markdown_link(text):
+    """
+    Check if the given text contains any Markdown links.
+    """
+
+    def is_valid_url(start, end):
+        """
+        Check if the URL is valid.
+        """
+        url = text[start:end].strip()
+        return (
+            url.startswith("http://")
+            or url.startswith("https://")
+            or any(c.isalnum() for c in url)
+        )
+
+    i = 0
+    while i < len(text):
+        if text[i] == "\\":
+            i += 2
+            continue
+        if text[i] == "[":
+            close_bracket = find_closing_markdown_bracket(text, i + 1)
+            if (
+                close_bracket != -1
+                and close_bracket + 1 < len(text)
+                and text[close_bracket + 1] == "("
+            ):
+                j = close_bracket + 2
+                paren_depth = 1
+                while j < len(text):
+                    if text[j] == "\\":
+                        j += 2
+                        continue
+                    if text[j] == "(":
+                        paren_depth += 1
+                    elif text[j] == ")":
+                        paren_depth -= 1
+                        if paren_depth == 0:
+                            if is_valid_url(close_bracket + 2, j):
+                                return True
+                            break
+                    j += 1
+            i = close_bracket + 1 if close_bracket != -1 else i + 1
+        else:
+            i += 1
+    return False

tests/template_tests/filter_tests/test_urlize.py

@@ -320 +320 @@
         )
         self.assertEqual(
             urlize("[http://168.192.0.1](http://168.192.0.1)"),
-            '[<a href="http://168.192.0.1](http://168.192.0.1)" rel="nofollow">'
-            "http://168.192.0.1](http://168.192.0.1)</a>",
+            '[http://168.192.0.1](<a href="http://168.192.0.1" rel="nofollow">'
+            "http://168.192.0.1</a>)",
         )
 
     def test_wrapping_characters(self):

tests/utils_tests/test_html.py

@@ -17 +17 @@
     strip_spaces_between_tags,
     strip_tags,
     urlize,
+    urlizer,
 )
 from django.utils.safestring import mark_safe
 
@@ -356 +357 @@
         for value in tests:
             with self.subTest(value=value):
                 self.assertEqual(urlize(value), value)
+
+    def test_handle_markdown_link(self):
+        tests = [
+            {
+                "input": "Here's a [link with [nested] brackets](https://example.com)",
+                "expected": "Here's a [link with [nested] brackets](<a href=\"https://"
+                'example.com">https://example.com</a>)',
+                "params": {
+                    "trim_url_limit": None,
+                    "nofollow": False,
+                    "autoescape": False,
+                },
+            },
+            {
+                "input": "Check out [this link](https://example.com/page(1))",
+                "expected": 'Check out [this link](<a href="https://example.com/'
+                'page(1)">https://example.com/page(1)</a>)',
+                "params": {
+                    "trim_url_limit": None,
+                    "nofollow": False,
+                    "autoescape": False,
+                },
+            },
+            {
+                "input": "Here's a [complex URL](https://example.com/"
+                "path?param1=value1&param2=value2#fragment)",
+                "expected": "Here's a [complex URL](<a href=\"https://example.com/"
+                'path?param1=value1&amp;param2=value2#fragment">'
+                "https://example.com/path?param1=value1&amp;"
+                "param2=value2#fragment</a>)",
+                "params": {
+                    "trim_url_limit": None,
+                    "nofollow": False,
+                    "autoescape": True,
+                },
+            },
+            {
+                "input": "Multiple [link1](https://example1.com) and "
+                "[link2](https://example2.com)",
+                "expected": 'Multiple [link1](<a href="https://example1.com">'
+                "https://example1.com</a>) and [link2]"
+                '(<a href="https://example2.com">https://example2.com</a>)',
+                "params": {
+                    "trim_url_limit": None,
+                    "nofollow": False,
+                    "autoescape": False,
+                },
+            },
+            {
+                "input": "This is a [broken link(https://example.com)",
+                "expected": "This is a [broken link(https://example.com)",
+                "params": {
+                    "trim_url_limit": None,
+                    "nofollow": False,
+                    "autoescape": False,
+                },
+            },
+            {
+                "input": "Here's a [very long URL](https://example.com/"
+                + "x" * 100
+                + ")",
+                "expected": "Here's a [very long URL](<a href=\"https://example.com/"
+                + "x" * 100
+                + '">https://example.com/xxxxxxxxx…</a>)',
+                "params": {
+                    "trim_url_limit": 30,
+                    "nofollow": False,
+                    "autoescape": False,
+                },
+            },
+        ]
+        for test in tests:
+            with self.subTest(test=test):
+                output = urlizer(test["input"], **test["params"])
+                self.assertEqual(output, test["expected"])