| import re |
| |
| from django.template import Node, Variable, VariableNode |
| from django.template import TemplateSyntaxError, TokenParser, Library |
| from django.template import TOKEN_TEXT, TOKEN_VAR |
| from django.utils import translation |
| from django.utils.encoding import force_unicode |
| |
| register = Library() |
| |
| class GetAvailableLanguagesNode(Node): |
| def __init__(self, variable): |
| self.variable = variable |
| |
| def render(self, context): |
| from django.conf import settings |
| context[self.variable] = [(k, translation.ugettext(v)) for k, v in settings.LANGUAGES] |
| return '' |
| |
| class GetCurrentLanguageNode(Node): |
| def __init__(self, variable): |
| self.variable = variable |
| |
| def render(self, context): |
| context[self.variable] = translation.get_language() |
| return '' |
| |
| class GetCurrentLanguageBidiNode(Node): |
| def __init__(self, variable): |
| self.variable = variable |
| |
| def render(self, context): |
| context[self.variable] = translation.get_language_bidi() |
| return '' |
| |
| class TranslateNode(Node): |
| def __init__(self, value, noop): |
| self.value = Variable(value) |
| self.noop = noop |
| |
| def render(self, context): |
| value = self.value.resolve(context) |
| if self.noop: |
| return value |
| else: |
| return translation.ugettext(value) |
| |
| class BlockTranslateNode(Node): |
| def __init__(self, extra_context, singular, plural=None, countervar=None, |
| counter=None): |
| self.extra_context = extra_context |
| self.singular = singular |
| self.plural = plural |
| self.countervar = countervar |
| self.counter = counter |
| |
| def render_token_list(self, tokens): |
| result = [] |
| vars = [] |
| for token in tokens: |
| if token.token_type == TOKEN_TEXT: |
| result.append(token.contents) |
| elif token.token_type == TOKEN_VAR: |
| result.append(u'%%(%s)s' % token.contents) |
| vars.append(token.contents) |
| return ''.join(result), vars |
| |
| def render(self, context): |
| tmp_context = {} |
| for var, val in self.extra_context.items(): |
| tmp_context[var] = val.render(context) |
| # Update() works like a push(), so corresponding context.pop() is at |
| # the end of function |
| context.update(tmp_context) |
| singular, vars = self.render_token_list(self.singular) |
| if self.plural and self.countervar and self.counter: |
| count = self.counter.resolve(context) |
| context[self.countervar] = count |
| plural, vars = self.render_token_list(self.plural) |
| result = translation.ungettext(singular, plural, count) |
| else: |
| result = translation.ugettext(singular) |
| # Escape all isolated '%' before substituting in the context. |
| result = re.sub(u'%(?!\()', u'%%', result) |
| data = dict([(v, force_unicode(context[v])) for v in vars]) |
| context.pop() |
| return result % data |
| |
| def do_get_available_languages(parser, token): |
| """ |
| This will store a list of available languages |
| in the context. |
| |
| Usage:: |
| |
| {% get_available_languages as languages %} |
| {% for language in languages %} |
| ... |
| {% endfor %} |
| |
| This will just pull the LANGUAGES setting from |
| your setting file (or the default settings) and |
| put it into the named variable. |
| """ |
| args = token.contents.split() |
| if len(args) != 3 or args[1] != 'as': |
| raise TemplateSyntaxError, "'get_available_languages' requires 'as variable' (got %r)" % args |
| return GetAvailableLanguagesNode(args[2]) |
| |
| def do_get_current_language(parser, token): |
| """ |
| This will store the current language in the context. |
| |
| Usage:: |
| |
| {% get_current_language as language %} |
| |
| This will fetch the currently active language and |
| put it's value into the ``language`` context |
| variable. |
| """ |
| args = token.contents.split() |
| if len(args) != 3 or args[1] != 'as': |
| raise TemplateSyntaxError, "'get_current_language' requires 'as variable' (got %r)" % args |
| return GetCurrentLanguageNode(args[2]) |
| |
| def do_get_current_language_bidi(parser, token): |
| """ |
| This will store the current language layout in the context. |
| |
| Usage:: |
| |
| {% get_current_language_bidi as bidi %} |
| |
| This will fetch the currently active language's layout and |
| put it's value into the ``bidi`` context variable. |
| True indicates right-to-left layout, otherwise left-to-right |
| """ |
| args = token.contents.split() |
| if len(args) != 3 or args[1] != 'as': |
| raise TemplateSyntaxError, "'get_current_language_bidi' requires 'as variable' (got %r)" % args |
| return GetCurrentLanguageBidiNode(args[2]) |
| |
| def do_translate(parser, token): |
| """ |
| This will mark a string for translation and will |
| translate the string for the current language. |
| |
| Usage:: |
| |
| {% trans "this is a test" %} |
| |
| This will mark the string for translation so it will |
| be pulled out by mark-messages.py into the .po files |
| and will run the string through the translation engine. |
| |
| There is a second form:: |
| |
| {% trans "this is a test" noop %} |
| |
| This will only mark for translation, but will return |
| the string unchanged. Use it when you need to store |
| values into forms that should be translated later on. |
| |
| You can use variables instead of constant strings |
| to translate stuff you marked somewhere else:: |
| |
| {% trans variable %} |
| |
| This will just try to translate the contents of |
| the variable ``variable``. Make sure that the string |
| in there is something that is in the .po file. |
| """ |
| class TranslateParser(TokenParser): |
| def top(self): |
| value = self.value() |
| if self.more(): |
| if self.tag() == 'noop': |
| noop = True |
| else: |
| raise TemplateSyntaxError, "only option for 'trans' is 'noop'" |
| else: |
| noop = False |
| return (value, noop) |
| value, noop = TranslateParser(token.contents).top() |
| return TranslateNode(value, noop) |
| |
| def do_block_translate(parser, token): |
| """ |
| This will translate a block of text with parameters. |
| |
| Usage:: |
| |
| {% blocktrans with foo|filter as bar and baz|filter as boo %} |
| This is {{ bar }} and {{ boo }}. |
| {% endblocktrans %} |
| |
| Additionally, this supports pluralization:: |
| |
| {% blocktrans count var|length as count %} |
| There is {{ count }} object. |
| {% plural %} |
| There are {{ count }} objects. |
| {% endblocktrans %} |
| |
| This is much like ngettext, only in template syntax. |
| """ |
| class BlockTranslateParser(TokenParser): |
| def top(self): |
| countervar = None |
| counter = None |
| extra_context = {} |
| while self.more(): |
| tag = self.tag() |
| if tag == 'with' or tag == 'and': |
| value = self.value() |
| if self.tag() != 'as': |
| raise TemplateSyntaxError, "variable bindings in 'blocktrans' must be 'with value as variable'" |
| extra_context[self.tag()] = VariableNode( |
| parser.compile_filter(value)) |
| elif tag == 'count': |
| counter = parser.compile_filter(self.value()) |
| if self.tag() != 'as': |
| raise TemplateSyntaxError, "counter specification in 'blocktrans' must be 'count value as variable'" |
| countervar = self.tag() |
| else: |
| raise TemplateSyntaxError, "unknown subtag %s for 'blocktrans' found" % tag |
| return (countervar, counter, extra_context) |
| |
| countervar, counter, extra_context = BlockTranslateParser(token.contents).top() |
| |
| singular = [] |
| plural = [] |
| while parser.tokens: |
| token = parser.next_token() |
| if token.token_type in (TOKEN_VAR, TOKEN_TEXT): |
| singular.append(token) |
| else: |
| break |
| if countervar and counter: |
| if token.contents.strip() != 'plural': |
| raise TemplateSyntaxError, "'blocktrans' doesn't allow other block tags inside it" |
| while parser.tokens: |
| token = parser.next_token() |
| if token.token_type in (TOKEN_VAR, TOKEN_TEXT): |
| plural.append(token) |
| else: |
| break |
| if token.contents.strip() != 'endblocktrans': |
| raise TemplateSyntaxError, "'blocktrans' doesn't allow other block tags (seen %r) inside it" % token.contents |
| |
| return BlockTranslateNode(extra_context, singular, plural, countervar, |
| counter) |
| |
| register.tag('get_available_languages', do_get_available_languages) |
| register.tag('get_current_language', do_get_current_language) |
| register.tag('get_current_language_bidi', do_get_current_language_bidi) |
| register.tag('trans', do_translate) |
| register.tag('blocktrans', do_block_translate) |
