Ticket #16774: #16774-Backtracking_URL_resolver.2.diff

django/core/handlers/base.py

@@ -96 +96 @@
                     urlresolvers.set_urlconf(urlconf)
                     resolver = urlresolvers.RegexURLResolver(r'^/', urlconf)
 
-                resolver_match = resolver.resolve(request.path_info)
+            # Use resolved to try to resolve matching URL patterns one by one
+            tried = []
+            resolved = {}
+
+            while response is None:
+                resolver_match = resolver.resolve(request.path_info, tried=tried, resolved=resolved)
                 callback, callback_args, callback_kwargs = resolver_match
                 request.resolver_match = resolver_match
 
@@ -108 +158 @@
                     if response:
                         break
 
-            if response is None:
-                wrapped_callback = self.make_view_atomic(callback)
-                try:
-                    response = wrapped_callback(request, *callback_args, **callback_kwargs)
-                except Exception as e:
-                    # If the view raised an exception, run it through exception
-                    # middleware, and if the exception middleware returns a
-                    # response, use that. Otherwise, reraise the exception.
-                    for middleware_method in self._exception_middleware:
-                        response = middleware_method(request, e)
-                        if response:
-                            break
-                    if response is None:
-                        raise
+                if response is None:
+                    wrapped_callback = self.make_view_atomic(callback)
+                    try:
+                        response = wrapped_callback(request, *callback_args, **callback_kwargs)
+                    except urlresolvers.DoesNotResolve:
+                        # Continue resolve URLs if the view raises
+                        # urlresolvers.DoesNotResolve exception to indicate
+                        # the url pattern does not match.
+                        continue
+                    except Exception as e:
+                        # If the view raised an exception, run it through exception
+                        # middleware, and if the exception middleware returns a
+                        # response, use that. Otherwise, reraise the exception.
+                        for middleware_method in self._exception_middleware:
+                            response = middleware_method(request, e)
+                            if response:
+                                break
+                        if response is None:
+                            raise
 
             # Complain if the view returned None (a common error).
             if response is None:

django/core/urlresolvers.py

@@ -73 +73 @@
 class Resolver404(Http404):
     pass
 
+class DoesNotResolve(Http404):
+    pass
+
+
 class NoReverseMatch(Exception):
     # Don't make this raise an error when used in a template.
     silent_variable_failure = True
@@ -205 +210 @@
             return
         self._callback_str = prefix + '.' + self._callback_str
 
-    def resolve(self, path):
+    def resolve(self, path, resolved=None, caller=None):
+        if resolved is not None:
+            if caller not in resolved:
+                resolved[caller] = set()
+            resolved[caller].add(self)
         match = self.regex.search(path)
         if match:
             # If there are any named groups, use those as kwargs, ignoring
@@ -329 +339 @@
             self._populate()
         return self._app_dict[language_code]
 
-    def resolve(self, path):
-        tried = []
+    def resolve(self, path, tried=None, resolved=None, caller=None):
+        if tried is None:
+            tried = []
+        if resolved is None:
+            resolved = {}
+        if caller not in resolved:
+            resolved[caller] = set()
         match = self.regex.search(path)
         if match:
+            if self not in resolved:
+                resolved[self] = set()
             new_path = path[match.end():]
             for pattern in self.url_patterns:
+                if pattern in resolved[self]:
+                    continue
                 try:
-                    sub_match = pattern.resolve(new_path)
+                    sub_match = pattern.resolve(new_path, resolved=resolved, caller=self)
                 except Resolver404 as e:
                     sub_tried = e.args[0].get('tried')
                     if sub_tried is not None:
@@ -355 +372 @@
                         sub_match_dict.update(sub_match.kwargs)
                         return ResolverMatch(sub_match.func, sub_match.args, sub_match_dict, sub_match.url_name, self.app_name or sub_match.app_name, [self.namespace] + sub_match.namespaces)
                     tried.append([pattern])
+                resolved[self].add(pattern)
+            del resolved[self]
+            resolved[caller].add(self)
             raise Resolver404({'tried': tried, 'path': new_path})
+        resolved[caller].add(self)
         raise Resolver404({'path': path})
 
     @property

tests/view_tests/tests/test_specials.py

@@ -36 +36 @@
         """
         response = self.client.get('/permanent_nonascii_redirect/')
         self.assertRedirects(response, self.redirect_target, status_code=301)
+
+    def test_overlapping_urls_reverse(self):
+        from django.core import urlresolvers
+        url = urlresolvers.reverse('overlapping_view1', kwargs={'title': 'sometitle'})
+        self.assertEqual(url, '/overlapping_view/sometitle/')
+        url = urlresolvers.reverse('overlapping_view2', kwargs={'author': 'someauthor'})
+        self.assertEqual(url, '/overlapping_view/someauthor/')
+
+    def test_overlapping_urls_resolve(self):
+        response = self.client.get('/overlapping_view/sometitle/')
+        self.assertContains(response, 'overlapping_view2')
+
+    def test_overlapping_urls_not_resolve(self):
+        response = self.client.get('/no_overlapping_view/sometitle/')
+        self.assertEqual(response.status_code, 404)
+
+    def test_nested_overlapping_urls_reverse(self):
+        from django.core import urlresolvers
+        url = urlresolvers.reverse('nested_overlapping_view1', kwargs={'title': 'sometitle'})
+        self.assertEqual(url, '/nested/overlapping_view/sometitle/')
+        url = urlresolvers.reverse('nested_overlapping_view2', kwargs={'author': 'someauthor'})
+        self.assertEqual(url, '/nested/overlapping_view/someauthor/')
+
+    def test_nested_overlapping_urls_resolve(self):
+        response = self.client.get('/nested/overlapping_view/sometitle/')
+        self.assertContains(response, 'overlapping_view2')
+
+    def test_nested_overlapping_urls_not_resolve(self):
+        response = self.client.get('/nested/no_overlapping_view/sometitle/')
+        self.assertEqual(response.status_code, 404)

tests/view_tests/generic_urls.py

@@ -1 +1 @@
 # -*- coding:utf-8 -*-
 from __future__ import absolute_import, unicode_literals
 
-from django.conf.urls import patterns, url
+from django.conf.urls import patterns, url, include
 from django.views.generic import RedirectView
 
 from . import views
@@ -54 +54 @@
     (r'^shortcuts/render/status/$', 'render_view_with_status'),
     (r'^shortcuts/render/current_app/$', 'render_view_with_current_app'),
     (r'^shortcuts/render/current_app_conflict/$', 'render_view_with_current_app_conflict'),
+    (r'^nested/', include(patterns('view_tests.views',
+        url(r'^overlapping_view/(?P<title>[a-z]+)/$', 'overlapping_view1', name='nested_overlapping_view1'),
+        url(r'^overlapping_view/(?P<author>[a-z]+)/$', 'overlapping_view2', name='nested_overlapping_view2'),
+        url(r'^overlapping_view/(?P<keywords>[a-z]+)/$', 'overlapping_view3', name='nested_overlapping_view3'),
+        url(r'^no_overlapping_view/(?P<keywords>[a-z]+)/$', 'no_overlapping_view', name='nested_no_overlapping_view'),
+    ))),
+    url(r'^overlapping_view/(?P<title>[a-z]+)/$', 'overlapping_view1', name='overlapping_view1'),
+    url(r'^overlapping_view/(?P<author>[a-z]+)/$', 'overlapping_view2', name='overlapping_view2'),
+    url(r'^overlapping_view/(?P<keywords>[a-z]+)/$', 'overlapping_view3', name='overlapping_view3'),
+    url(r'^no_overlapping_view/(?P<keywords>[a-z]+)/$', 'no_overlapping_view', name='no_overlapping_view'),
 )

tests/view_tests/views.py

@@ -6 +6 @@
 import sys
 
 from django.core.exceptions import PermissionDenied, SuspiciousOperation
-from django.core.urlresolvers import get_resolver
+from django.core.urlresolvers import get_resolver, DoesNotResolve
 from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
 from django.shortcuts import render_to_response, render
 from django.template import Context, RequestContext, TemplateDoesNotExist
@@ -273 +273 @@
 def sensitive_method_view(request):
     return Klass().method(request)
 
+def overlapping_view1(request, title=None):
+    raise DoesNotResolve
+
+def overlapping_view2(request, author=None):
+    return HttpResponse("overlapping_view2")
+
+def overlapping_view3(request, keywords=None):
+    return HttpResponse("overlapping_view3")
+
+def no_overlapping_view(request, keywords=None):
+    raise DoesNotResolve
 
 @sensitive_variables('sauce')
 @sensitive_post_parameters('bacon-key', 'sausage-key')