Ticket #20757: patch_commit_8a8468f33b16.patch

django/core/urlresolvers.py

@@ -13 +13 @@
 
 from django.http import Http404
 from django.core.exceptions import ImproperlyConfigured, ViewDoesNotExist
-from django.utils.datastructures import MultiValueDict
+from django.utils.datastructures import MultiValueDict, NameIndexedIterable
 from django.utils.encoding import force_str, force_text, iri_to_uri
 from django.utils.functional import memoize, lazy
 from django.utils.http import urlquote
@@ -229 +229 @@
         self._callback = get_callable(self._callback_str)
         return self._callback
 
+
+class URLEntry(NameIndexedIterable):
+    state_class = tuple
+    keys = ('urlbits', 'p_pattern', 'pattern.default')
+
+    def __repr__(self):
+        return "<URLEntry: %s>" % self.state.__repr__()
+
+
+class URLBit(NameIndexedIterable):
+    state_class = tuple
+    keys = ('format', 'argument_names')
+
+    def __repr__(self):
+        return "<URLBit: %s>" % self.state.__repr__()
+
+
 class RegexURLResolver(LocaleRegexProvider):
     def __init__(self, regex, urlconf_name, default_kwargs=None, app_name=None, namespace=None):
         LocaleRegexProvider.__init__(self, regex)
@@ -269 +286 @@
                     if pattern.app_name:
                         apps.setdefault(pattern.app_name, []).append(pattern.namespace)
                 else:
-                    parent = normalize(pattern.regex.pattern)
+                    parent = [URLBit(*p) for p in normalize(pattern.regex.pattern)]
                     for name in pattern.reverse_dict:
                         for matches, pat, defaults in pattern.reverse_dict.getlist(name):
                             new_matches = []
                             for piece, p_args in parent:
-                                new_matches.extend([(piece + suffix, p_args + args) for (suffix, args) in matches])
-                            lookups.appendlist(name, (new_matches, p_pattern + pat, dict(defaults, **pattern.default_kwargs)))
+                                new_matches.extend([URLBit(piece + suffix, p_args + args) for (suffix, args) in matches])
+                            lookups.appendlist(name, URLEntry(new_matches, p_pattern + pat, dict(defaults, **pattern.default_kwargs)))
                     for namespace, (prefix, sub_pattern) in pattern.namespace_dict.items():
                         namespaces[namespace] = (p_pattern + prefix, sub_pattern)
                     for app_name, namespace_list in pattern.app_dict.items():
                         apps.setdefault(app_name, []).extend(namespace_list)
             else:
-                bits = normalize(p_pattern)
-                lookups.appendlist(pattern.callback, (bits, p_pattern, pattern.default_args))
+                bits = [URLBit(*p) for p in normalize(p_pattern)]
+                lookups.appendlist(pattern.callback, URLEntry(bits, p_pattern, pattern.default_args))
                 if pattern.name is not None:
-                    lookups.appendlist(pattern.name, (bits, p_pattern, pattern.default_args))
+                    lookups.appendlist(pattern.name, URLEntry(bits, p_pattern, pattern.default_args))
         self._reverse_dict[language_code] = lookups
         self._namespace_dict[language_code] = namespaces
         self._app_dict[language_code] = apps
@@ -574 +591 @@
         return True
     except Resolver404:
         return False
+
+def get_urlformat(urlname):
+    """
+    Given a URL name, returns the URL as a string suitable for string.format.
+
+    Example::
+
+    urlpatterns = patterns('',
+        url(r'^extra/(?P<extra>\w+)/$', empty_view, name="named-url2"),
+    )
+
+    >>> get_urlformat('named-url2')
+    '/extra/%(extra)s/'
+    """
+    urlconf = get_urlconf()
+    resolver = get_resolver(urlconf)
+    urlbit = resolver.reverse_dict[urlname].urlbits[0]
+    return "%s%s" % (get_script_prefix(), urlbit.format)

django/utils/datastructures.py

@@ -496 +496 @@
         if use_func:
             return self.func(value)
         return value
+
+
+class NameIndexedIterable(object):
+    """
+    An Iterable (most likely a list or tuple), whose indexes can be referred
+    by name.
+    """
+    state_class = list
+    keys = list()
+
+    def __init__(self, *args, **kwargs):
+        updated_args = list(args)
+        for i, keyword in enumerate(self.keys):
+            if keyword in kwargs:
+                updated_args[i] = kwargs[keyword]
+            else:
+                break
+        self.state = self.state_class(updated_args)
+        super(NameIndexedIterable, self).__init__()
+
+    def __getitem__(self, index):
+        if index < len(self.state):
+            return self.state[index]
+        raise IndexError
+
+    def __setitem__(self, index, value):
+        if index < len(self.state):
+            self.state[index] = value
+        raise IndexError
+
+    def __getattr__(self, attr):
+        if attr in self.keys:
+            return self.state[self.keys.index(attr)]
+        return super(NameIndexedIterable, self).__getattr__(attr)
+
+    def __setattr__(self, attr, value):
+        if attr in self.keys:
+            self.state[self.keys.index(attr)] = value
+        return super(NameIndexedIterable, self).__setattr__(attr, value)
+
+    def __repr__(self):
+        return self.state.__repr__()

tests/urlpatterns_reverse/tests.py

@@ -9 +9 @@
 from django.contrib.auth.models import User
 from django.core.exceptions import ImproperlyConfigured, ViewDoesNotExist
 from django.core.urlresolvers import (reverse, resolve, get_callable,
-    get_resolver, NoReverseMatch, Resolver404, ResolverMatch, RegexURLResolver,
-    RegexURLPattern)
+    get_resolver, get_urlformat, NoReverseMatch, Resolver404, ResolverMatch,
+    RegexURLResolver, RegexURLPattern)
 from django.http import HttpRequest, HttpResponseRedirect, HttpResponsePermanentRedirect
 from django.shortcuts import redirect
 from django.test import TestCase
@@ -644 +644 @@
         self.assertRaises(AttributeError, get_callable,
             'urlpatterns_reverse.views_broken.i_am_broken')
 
+
+class URLObjects(TestCase):
+    urls = 'urlpatterns_reverse.named_urls'
+
+    def test_URL_objects(self):
+        format = get_urlformat('named-url2')
+        self.assertEqual(format, '/extra/%(extra)s/')