Fixed #25933 -- Allowed an unprefixed default language in i18n_patterns().

3 files changed, 44 insertions, 28 deletions

diff --git a/django/conf/urls/i18n.py b/django/conf/urls/i18n.py
index 1ddf919132..2813341a61 100644
--- a/django/conf/urls/i18n.py
+++ b/django/conf/urls/i18n.py
@@ -1,10 +1,11 @@
 from django.conf import settings
 from django.conf.urls import url
-from django.urls import LocaleRegexURLResolver
+from django.urls import LocaleRegexURLResolver, get_resolver
+from django.utils import lru_cache
 from django.views.i18n import set_language
 
 
-def i18n_patterns(*urls):
+def i18n_patterns(*urls, **kwargs):
     """
     Adds the language code prefix to every URL pattern within this
     function. This may only be used in the root URLconf, not in an included
@@ -12,7 +13,23 @@ def i18n_patterns(*urls):
     """
     if not settings.USE_I18N:
         return urls
-    return [LocaleRegexURLResolver(list(urls))]
+    prefix_default_language = kwargs.pop('prefix_default_language', True)
+    assert not kwargs, 'Unexpected kwargs for i18n_patterns(): %s' % kwargs
+    return [LocaleRegexURLResolver(list(urls), prefix_default_language=prefix_default_language)]
+
+
+@lru_cache.lru_cache(maxsize=None)
+def is_language_prefix_patterns_used(urlconf):
+    """
+    Return a tuple of two booleans: (
+        `True` if LocaleRegexURLResolver` is used in the `urlconf`,
+        `True` if the default language should be prefixed
+    )
+    """
+    for url_pattern in get_resolver(urlconf).url_patterns:
+        if isinstance(url_pattern, LocaleRegexURLResolver):
+            return True, url_pattern.prefix_default_language
+    return False, False
 
 
 urlpatterns = [
diff --git a/django/middleware/locale.py b/django/middleware/locale.py
index c9db673759..44dec75a54 100644
--- a/django/middleware/locale.py
+++ b/django/middleware/locale.py
@@ -1,11 +1,10 @@
 "This is the locale selecting middleware that will look at accept headers"
 
 from django.conf import settings
+from django.conf.urls.i18n import is_language_prefix_patterns_used
 from django.http import HttpResponseRedirect
-from django.urls import (
-    LocaleRegexURLResolver, get_resolver, get_script_prefix, is_valid_path,
-)
-from django.utils import lru_cache, translation
+from django.urls import get_script_prefix, is_valid_path
+from django.utils import translation
 from django.utils.cache import patch_vary_headers
 
 
@@ -21,9 +20,10 @@ class LocaleMiddleware(object):
 
     def process_request(self, request):
         urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF)
-        language = translation.get_language_from_request(
-            request, check_path=self.is_language_prefix_patterns_used(urlconf)
-        )
+        i18n_patterns_used, prefixed_default_language = is_language_prefix_patterns_used(urlconf)
+        language = translation.get_language_from_request(request, check_path=i18n_patterns_used)
+        if not language and i18n_patterns_used and not prefixed_default_language:
+            language = settings.LANGUAGE_CODE
         translation.activate(language)
         request.LANGUAGE_CODE = translation.get_language()
 
@@ -31,8 +31,12 @@ class LocaleMiddleware(object):
         language = translation.get_language()
         language_from_path = translation.get_language_from_path(request.path_info)
         urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF)
-        if (response.status_code == 404 and not language_from_path
-                and self.is_language_prefix_patterns_used(urlconf)):
+        i18n_patterns_used, prefixed_default_language = is_language_prefix_patterns_used(urlconf)
+
+        if not language_from_path and i18n_patterns_used and not prefixed_default_language:
+            language_from_path = settings.LANGUAGE_CODE
+
+        if response.status_code == 404 and not language_from_path and i18n_patterns_used:
             language_path = '/%s%s' % (language, request.path_info)
             path_valid = is_valid_path(language_path, urlconf)
             path_needs_slash = (
@@ -53,20 +57,8 @@ class LocaleMiddleware(object):
                 )
                 return self.response_redirect_class(language_url)
 
-        if not (self.is_language_prefix_patterns_used(urlconf)
-                and language_from_path):
+        if not (i18n_patterns_used and language_from_path):
             patch_vary_headers(response, ('Accept-Language',))
         if 'Content-Language' not in response:
             response['Content-Language'] = language
         return response
-
-    @lru_cache.lru_cache(maxsize=None)
-    def is_language_prefix_patterns_used(self, urlconf):
-        """
-        Returns `True` if the `LocaleRegexURLResolver` is used
-        at root level of the urlpatterns, else it returns `False`.
-        """
-        for url_pattern in get_resolver(urlconf).url_patterns:
-            if isinstance(url_pattern, LocaleRegexURLResolver):
-                return True
-        return False
diff --git a/django/urls/resolvers.py b/django/urls/resolvers.py
index 78882c1bd4..178d2737d2 100644
--- a/django/urls/resolvers.py
+++ b/django/urls/resolvers.py
@@ -382,15 +382,22 @@ class LocaleRegexURLResolver(RegexURLResolver):
     Rather than taking a regex argument, we just override the ``regex``
     function to always return the active language-code as regex.
     """
-    def __init__(self, urlconf_name, default_kwargs=None, app_name=None, namespace=None):
+    def __init__(
+        self, urlconf_name, default_kwargs=None, app_name=None, namespace=None,
+        prefix_default_language=True,
+    ):
         super(LocaleRegexURLResolver, self).__init__(
             None, urlconf_name, default_kwargs, app_name, namespace,
         )
+        self.prefix_default_language = prefix_default_language
 
     @property
     def regex(self):
         language_code = get_language() or settings.LANGUAGE_CODE
         if language_code not in self._regex_dict:
-            regex_compiled = re.compile('^%s/' % language_code, re.UNICODE)
-            self._regex_dict[language_code] = regex_compiled
+            if language_code == settings.LANGUAGE_CODE and not self.prefix_default_language:
+                regex_string = ''
+            else:
+                regex_string = '^%s/' % language_code
+            self._regex_dict[language_code] = re.compile(regex_string, re.UNICODE)
         return self._regex_dict[language_code]