Fixed #28800 -- Added a listurls management command

AUTHORS

@@ -229,6 +229,7 @@ answer newbie questions, and generally made Django that much better:
     Chris Jerdonek
     Chris Jones <chris@brack3t.com>
     Chris Lamb <chris@chris-lamb.co.uk>
+    Chris Rose <https://github.com/offbyone>
     Chris Streeter <chris@chrisstreeter.com>
     Christian Barcenas <christian@cbarcenas.com>
     Christian Metts
@@ -1078,6 +1079,7 @@ answer newbie questions, and generally made Django that much better:
     Tyson Clugg <tyson@clugg.net>
     Tyson Tate <tyson@fallingbullets.com>
     Unai Zalakain <unai@gisa-elkartea.org>
+    Ülgen Sarıkavak <https://github.com/ulgens>
     Valentina Mukhamedzhanova <umirra@gmail.com>
     valtron
     Varun Kasyap Pentamaraju <varunkasyap@hotmail.com>

django/contrib/admindocs/utils.py

@@ -6,7 +6,11 @@
 from inspect import cleandoc
 
 from django.urls import reverse
-from django.utils.regex_helper import _lazy_re_compile
+from django.urls.utils import (  # NOQA: F401
+    extract_views_from_urlpatterns,
+    simplify_regex,
+)
+from django.utils.regex_helper import _lazy_re_compile  # NOQA: F401
 from django.utils.safestring import mark_safe
 
 try:
@@ -173,96 +177,6 @@ def default_reference_role(
     for name, urlbase in ROLES.items():
         create_reference_role(name, urlbase)
 
-# Match the beginning of a named, unnamed, or non-capturing groups.
-named_group_matcher = _lazy_re_compile(r"\(\?P(<\w+>)")
-unnamed_group_matcher = _lazy_re_compile(r"\(")
-non_capturing_group_matcher = _lazy_re_compile(r"\(\?\:")
-
-
-def replace_metacharacters(pattern):
-    """Remove unescaped metacharacters from the pattern."""
-    return re.sub(
-        r"((?:^|(?<!\\))(?:\\\\)*)(\\?)([?*+^$]|\\[bBAZ])",
-        lambda m: m[1] + m[3] if m[2] else m[1],
-        pattern,
-    )
-
-
-def _get_group_start_end(start, end, pattern):
-    # Handle nested parentheses, e.g. '^(?P<a>(x|y))/b' or '^b/((x|y)\w+)$'.
-    unmatched_open_brackets, prev_char = 1, None
-    for idx, val in enumerate(pattern[end:]):
-        # Check for unescaped `(` and `)`. They mark the start and end of a
-        # nested group.
-        if val == "(" and prev_char != "\\":
-            unmatched_open_brackets += 1
-        elif val == ")" and prev_char != "\\":
-            unmatched_open_brackets -= 1
-        prev_char = val
-        # If brackets are balanced, the end of the string for the current named
-        # capture group pattern has been reached.
-        if unmatched_open_brackets == 0:
-            return start, end + idx + 1
-
-
-def _find_groups(pattern, group_matcher):
-    prev_end = None
-    for match in group_matcher.finditer(pattern):
-        if indices := _get_group_start_end(match.start(0), match.end(0), pattern):
-            start, end = indices
-            if prev_end and start > prev_end or not prev_end:
-                yield start, end, match
-            prev_end = end
-
-
-def replace_named_groups(pattern):
-    r"""
-    Find named groups in `pattern` and replace them with the group name. E.g.,
-    1. ^(?P<a>\w+)/b/(\w+)$ ==> ^<a>/b/(\w+)$
-    2. ^(?P<a>\w+)/b/(?P<c>\w+)/$ ==> ^<a>/b/<c>/$
-    3. ^(?P<a>\w+)/b/(\w+) ==> ^<a>/b/(\w+)
-    4. ^(?P<a>\w+)/b/(?P<c>\w+) ==> ^<a>/b/<c>
-    """
-    group_pattern_and_name = [
-        (pattern[start:end], match[1])
-        for start, end, match in _find_groups(pattern, named_group_matcher)
-    ]
-    for group_pattern, group_name in group_pattern_and_name:
-        pattern = pattern.replace(group_pattern, group_name)
-    return pattern
-
-
-def replace_unnamed_groups(pattern):
-    r"""
-    Find unnamed groups in `pattern` and replace them with '<var>'. E.g.,
-    1. ^(?P<a>\w+)/b/(\w+)$ ==> ^(?P<a>\w+)/b/<var>$
-    2. ^(?P<a>\w+)/b/((x|y)\w+)$ ==> ^(?P<a>\w+)/b/<var>$
-    3. ^(?P<a>\w+)/b/(\w+) ==> ^(?P<a>\w+)/b/<var>
-    4. ^(?P<a>\w+)/b/((x|y)\w+) ==> ^(?P<a>\w+)/b/<var>
-    """
-    final_pattern, prev_end = "", None
-    for start, end, _ in _find_groups(pattern, unnamed_group_matcher):
-        if prev_end:
-            final_pattern += pattern[prev_end:start]
-        final_pattern += pattern[:start] + "<var>"
-        prev_end = end
-    return final_pattern + pattern[prev_end:]
-
-
-def remove_non_capturing_groups(pattern):
-    r"""
-    Find non-capturing groups in the given `pattern` and remove them, e.g.
-    1. (?P<a>\w+)/b/(?:\w+)c(?:\w+) => (?P<a>\\w+)/b/c
-    2. ^(?:\w+(?:\w+))a => ^a
-    3. ^a(?:\w+)/b(?:\w+) => ^a/b
-    """
-    group_start_end_indices = _find_groups(pattern, non_capturing_group_matcher)
-    final_pattern, prev_end = "", None
-    for start, end, _ in group_start_end_indices:
-        final_pattern += pattern[prev_end:start]
-        prev_end = end
-    return final_pattern + pattern[prev_end:]
-
 
 def strip_p_tags(value):
     return mark_safe(value.replace("<p>", "").replace("</p>", ""))

django/contrib/admindocs/views.py

@@ -7,22 +7,16 @@
 from django.contrib import admin
 from django.contrib.admin.views.decorators import staff_member_required
 from django.contrib.admindocs import utils
-from django.contrib.admindocs.utils import (
-    remove_non_capturing_groups,
-    replace_metacharacters,
-    replace_named_groups,
-    replace_unnamed_groups,
-)
 from django.contrib.auth import get_permission_codename
 from django.core.exceptions import (
     ImproperlyConfigured,
     PermissionDenied,
-    ViewDoesNotExist,
 )
 from django.db import models
 from django.http import Http404
 from django.template.engine import Engine
 from django.urls import get_mod_func, get_resolver, get_urlconf
+from django.urls.utils import extract_views_from_urlpatterns, simplify_regex
 from django.utils._os import safe_join
 from django.utils.decorators import method_decorator
 from django.utils.functional import cached_property
@@ -475,49 +469,3 @@ def get_readable_field_data_type(field):
     the values of field.__dict__ before being output.
     """
     return field.description % field.__dict__
-
-
-def extract_views_from_urlpatterns(urlpatterns, base="", namespace=None):
-    """
-    Return a list of views from a list of urlpatterns.
-
-    Each object in the returned list is a 4-tuple:
-    (view_func, regex, namespace, name)
-    """
-    views = []
-    for p in urlpatterns:
-        if hasattr(p, "url_patterns"):
-            try:
-                patterns = p.url_patterns
-            except ImportError:
-                continue
-            views.extend(
-                extract_views_from_urlpatterns(
-                    patterns,
-                    base + str(p.pattern),
-                    (namespace or []) + (p.namespace and [p.namespace] or []),
-                )
-            )
-        elif hasattr(p, "callback"):
-            try:
-                views.append((p.callback, base + str(p.pattern), namespace, p.name))
-            except ViewDoesNotExist:
-                continue
-        else:
-            raise TypeError(_("%s does not appear to be a urlpattern object") % p)
-    return views
-
-
-def simplify_regex(pattern):
-    r"""
-    Clean up urlpattern regexes into something more readable by humans. For
-    example, turn "^(?P<sport_slug>\w+)/athletes/(?P<athlete_slug>\w+)/$"
-    into "/<sport_slug>/athletes/<athlete_slug>/".
-    """
-    pattern = remove_non_capturing_groups(pattern)
-    pattern = replace_named_groups(pattern)
-    pattern = replace_unnamed_groups(pattern)
-    pattern = replace_metacharacters(pattern)
-    if not pattern.startswith("/"):
-        pattern = "/" + pattern
-    return pattern

django/core/management/commands/LICENSE.django-extensions

@@ -0,0 +1,19 @@
+Copyright (c) 2007 Michael Trier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.