diff --git a/django/contrib/gis/templates/gis/google/google-map.js b/django/contrib/gis/templates/gis/google/google-map.js index 06f11e3..a8bcba5 100644 --- a/django/contrib/gis/templates/gis/google/google-map.js +++ b/django/contrib/gis/templates/gis/google/google-map.js @@ -1,4 +1,5 @@ {% autoescape off %} +{% localize off %} {% block vars %}var geodjango = {};{% for icon in icons %} var {{ icon.varname }} = new GIcon(G_DEFAULT_ICON); {% if icon.image %}{{ icon.varname }}.image = "{{ icon.image }}";{% endif %} @@ -32,4 +33,4 @@ var {{ icon.varname }} = new GIcon(G_DEFAULT_ICON); alert("Sorry, the Google Maps API is not compatible with this browser."); } } -{% endblock load %}{% endblock functions %}{% endautoescape %} +{% endblock load %}{% endblock functions %}{% endlocalize %}{% endautoescape %} diff --git a/django/template/__init__.py b/django/template/__init__.py index c316786..ac8f117 100644 --- a/django/template/__init__.py +++ b/django/template/__init__.py @@ -789,11 +789,11 @@ class NodeList(list): # extend_nodelist(). contains_nontext = False - def render(self, context): + def render(self, context, localization=None): bits = [] for node in self: if isinstance(node, Node): - bits.append(self.render_node(node, context)) + bits.append(self.render_node(node, context, localization)) else: bits.append(node) return mark_safe(''.join([force_unicode(b) for b in bits])) @@ -805,7 +805,9 @@ class NodeList(list): nodes.extend(node.get_nodes_by_type(nodetype)) return nodes - def render_node(self, node, context): + def render_node(self, node, context, localization=None): + if isinstance(node, VariableNode): + return node.render(context, localization) return node.render(context) class TextNode(Node): @@ -819,13 +821,13 @@ class TextNode(Node): def render(self, context): return self.s -def _render_value_in_context(value, context): +def _render_value_in_context(value, context, localization=None): """ Converts any value to a string to become part of a rendered template. This means escaping, if required, and conversion to a unicode object. If value is a string, it is expected to have already been translated. """ - value = localize(value) + value = localize(value, localization) value = force_unicode(value) if (context.autoescape and not isinstance(value, SafeData)) or isinstance(value, EscapeData): return escape(value) @@ -839,14 +841,14 @@ class VariableNode(Node): def __repr__(self): return "" % self.filter_expression - def render(self, context): + def render(self, context, localization): try: output = self.filter_expression.resolve(context) except UnicodeDecodeError: # Unicode conversion can fail sometimes for reasons out of our # control (e.g. exception rendering). In that case, we fail quietly. return '' - return _render_value_in_context(output, context) + return _render_value_in_context(output, context, localization) def generic_tag_compiler(params, defaults, name, node_class, parser, token): "Returns a template.Node subclass." diff --git a/django/template/debug.py b/django/template/debug.py index c21fb50..be2f3e4 100644 --- a/django/template/debug.py +++ b/django/template/debug.py @@ -84,10 +84,10 @@ class DebugNodeList(NodeList): return result class DebugVariableNode(VariableNode): - def render(self, context): + def render(self, context, localization=None): try: output = self.filter_expression.resolve(context) - output = localize(output) + output = localize(value, context, localization) output = force_unicode(output) except TemplateSyntaxError, e: if not hasattr(e, 'source'): diff --git a/django/template/defaultfilters.py b/django/template/defaultfilters.py index 1500a05..44e71b7 100644 --- a/django/template/defaultfilters.py +++ b/django/template/defaultfilters.py @@ -434,6 +434,17 @@ linebreaksbr.is_safe = True linebreaksbr.needs_autoescape = True linebreaksbr = stringfilter(linebreaksbr) +def localize(value, localization='on'): + """ + Localizes (or prevents localization) of a value, not respecting + ``settings.USE_L10N``. + """ + if localization not in ('on', 'off'): + return value + localization = localization == 'on' + return force_unicode(formats.localize(value, localization)) +localize.is_safe = False + def safe(value): """ Marks the value as a string that should not be auto-escaped. @@ -922,6 +933,7 @@ register.filter(linebreaks) register.filter(linebreaksbr) register.filter(linenumbers) register.filter(ljust) +register.filter(localize) register.filter(lower) register.filter(make_list) register.filter(phone2numeric) diff --git a/django/template/defaulttags.py b/django/template/defaulttags.py index 1b07413..d0f654d 100644 --- a/django/template/defaulttags.py +++ b/django/template/defaulttags.py @@ -433,6 +433,17 @@ class WithNode(Node): context.pop() return output +class LocalizeNode(Node): + def __init__(self, nodelist, localization): + self.nodelist = nodelist + self.localization = localization + + def __repr__(self): + return "" + + def render(self, context): + return self.nodelist.render(context, self.localization) + #@register.tag def autoescape(parser, token): """ @@ -929,6 +940,30 @@ def load(parser, token): return LoadNode() load = register.tag(load) +@register.tag +def localize(parser, token): + """ + Forces or prevents localization without respect to `settings.USE_L10N`. + + Sample usage:: + + {% localize off %} + var pi = {{ 3.1415 }}; + {% endlocalize %} + + """ + localization = None + bits = list(token.split_contents()) + if len(bits) == 1: + localization = True + elif len(bits) > 2 or bits[1] not in ('on', 'off'): + raise TemplateSyntaxError("%r argument should be 'on' or 'off'" % bits[0]) + else: + localization = bits[1] == 'on' + nodelist = parser.parse(('endlocalize',)) + parser.delete_first_token() + return LocalizeNode(nodelist, localization) + #@register.tag def now(parser, token): """ diff --git a/django/utils/formats.py b/django/utils/formats.py index e64cc4e..9ace738 100644 --- a/django/utils/formats.py +++ b/django/utils/formats.py @@ -41,14 +41,14 @@ def get_format_modules(reverse=False): modules.reverse() return modules -def get_format(format_type, lang=None): +def get_format(format_type, lang=None, localization=None): """ For a specific format type, returns the format for the current language (locale), defaults to the format in the settings. format_type is the name of the format, e.g. 'DATE_FORMAT' """ format_type = smart_str(format_type) - if settings.USE_L10N: + if (localization is None and settings.USE_L10N) or localization: if lang is None: lang = get_language() cache_key = (format_type, lang) @@ -65,48 +65,52 @@ def get_format(format_type, lang=None): _format_cache[cache_key] = None return getattr(settings, format_type) -def date_format(value, format=None): +def date_format(value, format=None, localization=None): """ Formats a datetime.date or datetime.datetime object using a localizable format """ - return dateformat.format(value, get_format(format or 'DATE_FORMAT')) + return dateformat.format(value, get_format(format or 'DATE_FORMAT', localization=localization)) -def time_format(value, format=None): +def time_format(value, format=None, localization=None): """ Formats a datetime.time object using a localizable format """ - return dateformat.time_format(value, get_format(format or 'TIME_FORMAT')) + return dateformat.time_format(value, get_format(format or 'TIME_FORMAT', localization=localization)) -def number_format(value, decimal_pos=None): +def number_format(value, decimal_pos=None, localization=None): """ Formats a numeric value using localization settings """ - if settings.USE_L10N: + if (localization is None and settings.USE_L10N) or localization: lang = get_language() else: lang = None return numberformat.format( value, - get_format('DECIMAL_SEPARATOR', lang), + get_format('DECIMAL_SEPARATOR', lang, localization), decimal_pos, - get_format('NUMBER_GROUPING', lang), - get_format('THOUSAND_SEPARATOR', lang), + get_format('NUMBER_GROUPING', lang, localization), + get_format('THOUSAND_SEPARATOR', lang, localization), ) -def localize(value): +def localize(value, localization=None): """ Checks if value is a localizable type (date, number...) and returns it - formatted as a string using current locale format + formatted as a string using current locale format. + If the value of `localization` is True or False, localization is enabled or + disabled without respect to `settings.USE_L10N`. """ + if localization is False: # can't use truth value, None has special meaning + return value if isinstance(value, (decimal.Decimal, float, int, long)): - return number_format(value) + return number_format(value, localization=localization) elif isinstance(value, datetime.datetime): - return date_format(value, 'DATETIME_FORMAT') + return date_format(value, 'DATETIME_FORMAT', localization) elif isinstance(value, datetime.date): - return date_format(value) + return date_format(value, localization=localization) elif isinstance(value, datetime.time): - return time_format(value, 'TIME_FORMAT') + return time_format(value, 'TIME_FORMAT', localization) else: return value diff --git a/docs/ref/templates/builtins.txt b/docs/ref/templates/builtins.txt index 70f0ffd..9e86ee3 100644 --- a/docs/ref/templates/builtins.txt +++ b/docs/ref/templates/builtins.txt @@ -639,6 +639,35 @@ Load a custom template tag set. See :doc:`Custom tag and filter libraries ` for more information. +.. templatetag:: localize + +localize +~~~~~~~~ + +.. versionadded:: 1.3 + +Enables or disables localization for contained block. + +This tag allows a more fine grained control of localization than +:setting:`USE_L10N`. + +To activate or deactivate localization for a template block, use:: + + {% localize on %} + {{ value }} + {% endlocalize %} + + {% localize off %} + {{ value }} + {% endlocalize %} + +.. note:: + + The value of :setting:`USE_L10N` is not respected inside of a + `{% localize %}` block. + +See :tfilter:`localize` for the analog template filter. + .. templatetag:: now now @@ -1561,6 +1590,31 @@ For example:: If ``value`` is ``Django``, the output will be ``"Django "``. +.. templatefilter:: localize + +localize +~~~~~~~~ + +.. versionadded:: 1.3 + +Localizes (or prevents localization) of a value. + +**Argument:** "on" or "off" + +To prevent a value to be localized when :setting:`USE_L10N` is ``True``:: + + {{ value|localize:"off" }} + +To force localization of a value:: + + {{ value|localize:"on" }} + +or a shorthand:: + + {{ value|localize }} + +See :ttag:`localize` for the analog template tag. + .. templatefilter:: lower lower diff --git a/tests/regressiontests/i18n/tests.py b/tests/regressiontests/i18n/tests.py index 4aa52b6..6f8c3de 100644 --- a/tests/regressiontests/i18n/tests.py +++ b/tests/regressiontests/i18n/tests.py @@ -453,6 +453,33 @@ class FormattingTests(TestCase): settings.FORMAT_MODULE_PATH = old_format_module_path deactivate() + def test_localize_templatetag_and_filter(self): + """ + Tests the {% localize %} templatetag + """ + context = Context({'value': 3.14 }) + template1 = Template("{% localize %}{{ value }}{% endlocalize %};{% localize on %}{{ value }}{% endlocalize %}") + template2 = Template("{{ value }};{% localize off %}{{ value }};{% endlocalize %}{{ value }}") + template3 = Template('{{ value }};{{ value|localize:"off" }}') + template4 = Template('{{ value }};{{ value|localize }};{{ value|localize:"on" }}') + output1 = '3,14;3,14' + output2 = '3,14;3.14;3,14' + output3 = '3,14;3.14' + output4 = '3.14;3,14;3,14' + old_localize = settings.USE_L10N + try: + activate('de') + settings.USE_L10N = False + self.assertEqual(template1.render(context), output1) + self.assertEqual(template4.render(context), output4) + settings.USE_L10N = True + self.assertEqual(template1.render(context), output1) + self.assertEqual(template2.render(context), output2) + self.assertEqual(template3.render(context), output3) + finally: + deactivate() + settings.USE_L10N = old_localize + class MiscTests(TestCase): def test_parse_spec_http_header(self):