Ticket #2977: new_reverse_urlresolver.2.patch

django/core/urlresolvers.py

@@ -11 +11 @@
-from django.core.exceptions import ImproperlyConfigured, ViewDoesNotExist
-import re
-
+# Set up these regular expressions outside the function so they only have to
+# be compiled once.
+re_bracket = re.compile(r'(?<!\\)((?:\\\\)*)([()])')  # Open or close bracket not preceeded by a single slash
+re_has_named_group = re.compile(r'(?<!\\)(?:\\\\)*\(\?P')  #  '(?P' not preceeded by a single slash
+re_type = type(re_bracket)
+
+re_unescape = re.compile(r'\\(.)|[$?*+^()]')
+def unescape(value):
+    """ Unescape a regex string """
+    def repl(m):
+        escaped = m.group(1)
+        if escaped and re.match(r'[\ddDsSwW]', escaped):
+            # These cases shouldn't ever come up - no match possible if they do.
+            raise NoReverseMatch(r"Regular expression notation '\%s' was outside of a group so this regex is not reversable" % escaped)
+        if escaped and escaped in 'AZbB':
+            # These cases should just return nothing.
+            return ''
+        # For every other case: if it's the escaped version then return it without
+        # a slash, otherwise return nothing.
+        return escaped or ''
+    return re_unescape.sub(repl, value)
+
-class Resolver404(Http404):
-    pass
-
@@ -42 +64 @@
-
-    Raises NoReverseMatch if the args/kwargs aren't valid for the regex.
-    """
-
-
-
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+class ReverseRegexLookup(object):
+    def __init__(self, text):
+        self.has_named_groups = bool(re_has_named_group.search(text))
+        self.tokens, self.minimum_arguments = tokenize(text)
+
+    def check(self, args=[], kwargs={}):
+        # Note: args and kwargs will be destroyed (using .pop()) so if you need
+        # to keep using them, pass copies.
+        if self.minimum_arguments > len(args) + len(kwargs):
+            raise NoReverseMatch('Not enough arguments passed in')
+        match = []
+        args = list(args)
+        kwargs = kwargs.copy()
+        for token in self.tokens:
+            if isinstance(token, re_type):   # A regex token.
+                value = None
+                # Is it a named argument?
+                if token.groupindex:
+                    try:
+                        value = kwargs.pop(token.groupindex.keys()[0])
+                    except KeyError:
+                        # It was a named group, but the arg was passed in as a
+                        # positional arg or not at all.
+                        pass
+                if value is None:
+                    try:
+                        value = args.pop(0)
+                    except IndexError:
+                        # The arg wasn't passed in.
+                        raise NoReverseMatch('Not enough positional arguments passed in')
+                value = str(value)   # TODO: Unicode?
+                if not token.match(value):
+                    raise NoReverseMatch("Value %r didn't match regular expression %r" % (value, token.pattern))
+                match.append(value)
+            else:    # A string token.
+                match.append(token)
+        match = ''.join(match)
+        # Unescape special characters which could possibly be used in a URL and strip unused regular expression syntax.
+        match = unescape(match)
+        return match
+
-class RegexURLPattern(object):
-    def __init__(self, regex, callback, default_args=None, name=None):
-        # regex is a string representing a regular expression.
@@ -94 +176 @@
-        # which represents the path to a module and a view function name, or a
-        # callable object (view).
-        self.regex = re.compile(regex)
+        self.reverse_regex_lookup = ReverseRegexLookup(regex)
-        if callable(callback):
-            self._callback = callback
-        else:
@@ -150 +233 @@
-        return self.reverse_helper(*args, **kwargs)
-
-    def reverse_helper(self, *args, **kwargs):
-reverse_helper(self.regex, *args, **
+self.reverse_regex_lookup.check(args, 
-
-class RegexURLResolver(object):
-    def __init__(self, regex, urlconf_name, default_kwargs=None):
-        # regex is a string representing a regular expression.
-        # urlconf_name is a string representing the module containing urlconfs.
-        self.regex = re.compile(regex)
+        self.reverse_regex_lookup = ReverseRegexLookup(regex)
-        self.urlconf_name = urlconf_name
-        self.callback = None
-        self.default_kwargs = default_kwargs or {}
@@ -230 +314 @@
-        raise NoReverseMatch
-
-    def reverse_helper(self, lookup_view, *args, **kwargs):
+        result = self.reverse_regex_lookup.check(args, kwargs)
+        # .check() swallows used args, so the resolver is checking both itself
+        # and its children using the one set of arguments.
-        sub_match = self.reverse(lookup_view, *args, **kwargs)
-        result = reverse_helper(self.regex, *args, **kwargs)
-        return result + sub_match
-
-def resolve(path, urlconf=None):

tests/regressiontests/urlpatterns_reverse/tests.py

@@ -23 +23 @@
-    ('^people/(?P<state>\w\w)/(?P<name>\w+)/$', NoReverseMatch, [], {'name': 'adrian'}),
-    ('^people/(?P<state>\w\w)/(\w+)/$', NoReverseMatch, ['il'], {'name': 'adrian'}),
-    ('^people/(?P<state>\w\w)/(\w+)/$', 'people/il/adrian/', ['adrian'], {'state': 'il'}),
+    ('^places?/$', 'places/', [], {}),
+    ('^people/(?:name/)?', 'people/name/', [], {}),
+    (r'^product/(?P<product>\w+)\+\(\$(?P<price>\d+(\.\d+)?)\)/$', 'product/chocolate+($2.00)/', ['2.00'], {'product': 'chocolate'}),
+    (r'^places/(\d+|[a-z_]+)/', 'places/4/', [4], {}),
+    (r'^places/(\d+|[a-z_]+)/', 'places/harlem/', ['harlem'], {}),
+    ('^people/((?P<state>\w\w)/test)?/(\w+)/$', 'people/il/test/adrian/', ['adrian'], {'state': 'il'}),
+    (r'^price/\$(\d+)/$', 'price/$10/', ['10'], {}),
-)
-
-class URLPatternReverse(unittest.TestCase):
-    def test_urlpattern_reverse(self):
-        for regex, expected, args, kwargs in test_data:
-            try:
-.compile(regex)
+gex
-            except NoReverseMatch, e:
-                self.assertEqual(expected, NoReverseMatch)
-            else:
-                self.assertEquals(got, expected)
-
-if __name__ == "__main__":
-run_tests(1
+unittest.main(