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] diff --git a/docs/releases/1.10.txt b/docs/releases/1.10.txt index e19ecf5662..4f10dc1cd9 100644 --- a/docs/releases/1.10.txt +++ b/docs/releases/1.10.txt @@ -248,6 +248,10 @@ Internationalization used in a root URLConf specified using :attr:`request.urlconf `. +* By setting the new ``prefix_default_language`` parameter for + :func:`~django.conf.urls.i18n.i18n_patterns` to ``False``, you can allow + accessing the default language without a URL prefix. + Management Commands ~~~~~~~~~~~~~~~~~~~ diff --git a/docs/topics/i18n/translation.txt b/docs/topics/i18n/translation.txt index 86778859e9..7be20f6d23 100644 --- a/docs/topics/i18n/translation.txt +++ b/docs/topics/i18n/translation.txt @@ -1326,11 +1326,17 @@ Django provides two mechanisms to internationalize URL patterns: Language prefix in URL patterns ------------------------------- -.. function:: i18n_patterns(*pattern_list) +.. function:: i18n_patterns(*urls, prefix_default_language=True) This function can be used in a root URLconf and Django will automatically prepend the current active language code to all url patterns defined within -:func:`~django.conf.urls.i18n.i18n_patterns`. Example URL patterns:: +:func:`~django.conf.urls.i18n.i18n_patterns`. + +Setting ``prefix_default_language`` to ``False`` removes the prefix from the +default language (:setting:`LANGUAGE_CODE`). This can be useful when adding +translations to existing site so that the current URLs won't change. + +Example URL patterns:: from django.conf.urls import include, url from django.conf.urls.i18n import i18n_patterns @@ -1371,6 +1377,21 @@ function. Example:: >>> reverse('news:detail', kwargs={'slug': 'news-slug'}) '/nl/news/news-slug/' +With ``prefix_default_language=False`` and ``LANGUAGE_CODE='en'``, the URLs +will be:: + + >>> activate('en') + >>> reverse('news:index') + '/news/' + + >>> activate('nl') + >>> reverse('news:index') + '/nl/news/' + +.. versionadded:: 1.10 + + The ``prefix_default_language`` parameter was added. + .. warning:: :func:`~django.conf.urls.i18n.i18n_patterns` is only allowed in a root diff --git a/tests/i18n/tests.py b/tests/i18n/tests.py index 05c7828430..ba5127f2ea 100644 --- a/tests/i18n/tests.py +++ b/tests/i18n/tests.py @@ -13,6 +13,7 @@ from unittest import skipUnless from django import forms from django.conf import settings +from django.conf.urls.i18n import i18n_patterns from django.template import Context, Template, TemplateSyntaxError from django.test import ( RequestFactory, SimpleTestCase, TestCase, override_settings, @@ -1781,6 +1782,37 @@ class LocaleMiddlewareTests(TestCase): self.assertNotIn(LANGUAGE_SESSION_KEY, self.client.session) +@override_settings( + USE_I18N=True, + LANGUAGES=[ + ('en', 'English'), + ('fr', 'French'), + ], + MIDDLEWARE_CLASSES=[ + 'django.middleware.locale.LocaleMiddleware', + 'django.middleware.common.CommonMiddleware', + ], + ROOT_URLCONF='i18n.urls_default_unprefixed', + LANGUAGE_CODE='en', +) +class UnprefixedDefaultLanguageTests(SimpleTestCase): + def test_default_lang_without_prefix(self): + """ + With i18n_patterns(..., prefix_default_language=False), the default + language (settings.LANGUAGE_CODE) should be accessible without a prefix. + """ + response = self.client.get('/simple/') + self.assertEqual(response.content, b'Yes') + + def test_other_lang_with_prefix(self): + response = self.client.get('/fr/simple/') + self.assertEqual(response.content, b'Oui') + + def test_unexpected_kwarg_to_i18n_patterns(self): + with self.assertRaisesMessage(AssertionError, "Unexpected kwargs for i18n_patterns(): {'foo':"): + i18n_patterns(object(), foo='bar') + + @override_settings( USE_I18N=True, LANGUAGES=[ diff --git a/tests/i18n/urls_default_unprefixed.py b/tests/i18n/urls_default_unprefixed.py new file mode 100644 index 0000000000..8cadbfaa73 --- /dev/null +++ b/tests/i18n/urls_default_unprefixed.py @@ -0,0 +1,9 @@ +from django.conf.urls import url +from django.conf.urls.i18n import i18n_patterns +from django.http import HttpResponse +from django.utils.translation import ugettext_lazy as _ + +urlpatterns = i18n_patterns( + url(r'^simple/$', lambda r: HttpResponse(_("Yes"))), + prefix_default_language=False, +)