Context Navigation

Back to Ticket #580

Ticket #580: msgctxt.3.patch

File msgctxt.3.patch, 43.2 KB (added by hodgestar, 10 years ago)
Update of msgctxt.2.patch to work with trunk (i.e. 0.8.x).

doc/i18n.txt

 localizable strings from templates, as well as a template filter and special
 directives that can apply translations to templates as they get rendered.
 This support is based on `gettext`_ message catalogs and the `gettext Python
+This support is based on `gettext`_ message catalogs and the `gettext Python
 module`_. The extraction process can be used from the API level, or through
 the front-ends implemented by the `Babel`_ project, for which Genshi provides
 a plugin.
 …
 However, this approach results in significant “character noise” in templates,
 making them harder to read and preview.
 The ``genshi.filters.Translator`` filter allows you to get rid of the
+The ``genshi.filters.Translator`` filter allows you to get rid of the
 explicit `gettext`_ function calls, so you can (often) just continue to write:
 .. code-block:: genshi
 …
           corresponding ``gettext`` function in embedded Python expressions.
 You can control which tags should be ignored by this process; for example, it
 doesn't really make sense to translate the content of the HTML
+doesn't really make sense to translate the content of the HTML
 ``<script></script>`` element. Both ``<script>`` and ``<style>`` are excluded
 by default.
 Attribute values can also be automatically translated. The default is to
+Attribute values can also be automatically translated. The default is to
 consider the attributes ``abbr``, ``alt``, ``label``, ``prompt``, ``standby``,
 ``summary``, and ``title``, which is a list that makes sense for HTML
 documents.  Of course, you can tell the translator to use a different set of
 …
   <p xml:lang="en">Hello, world!</p>
 On the other hand, if the value of the ``xml:lang`` attribute contains a Python
 expression, the element contents and attributes are still considered for
+expression, the element contents and attributes are still considered for
 automatic translation:
 .. code-block:: genshi
 …
   </div>
+``i18n.ctxt``
+-------------
+Sometimes a source string can have two different meanings. Without resorting to
+splitting these two occurrences into different domains, gettext provides a
+means to specify a *context* for each translatable string. For instance, the
+word "volunteer" can either mean the noun, one who volunteers, or the verb,
+to volunteer.
+The ``i18n:ctxt`` directive allows you to mark a scope with a particular
+context. Here is a rather contrived example:
+.. code-block:: genshi
+  <p>A <span i18n:ctxt="noun">volunteer</span> can really help their community.
+    Why don't you <span i18n:ctxt="verb">volunteer</span> some time today?
+  </p>
 Extraction
 ==========
 The ``Translator`` class provides a class method called ``extract``, which is
 a generator yielding all localizable strings found in a template or markup
+a generator yielding all localizable strings found in a template or markup
 stream. This includes both literal strings in text nodes and attribute values,
 as well as strings in ``gettext()`` calls in embedded Python code. See the API
 documentation for details on how to use this method directly.
 …
 -----------------
 This functionality is integrated with the message extraction framework provided
 by the `Babel`_ project. Babel provides a command-line interface as well as
 commands that can be used from ``setup.py`` scripts using `Setuptools`_ or
+by the `Babel`_ project. Babel provides a command-line interface as well as
+commands that can be used from ``setup.py`` scripts using `Setuptools`_ or
 `Distutils`_.
 .. _`setuptools`: http://peak.telecommunity.com/DevCenter/setuptools
 .. _`distutils`: http://docs.python.org/dist/dist.html
 The first thing you need to do to make Babel extract messages from Genshi
+The first thing you need to do to make Babel extract messages from Genshi
 templates is to let Babel know which files are Genshi templates. This is done
 using a “mapping configuration”, which can be stored in a configuration file,
 or specified directly in your ``setup.py``.
 …
 ``include_attrs``
 -----------------
 Comma-separated list of attribute names that should be considered to have
+Comma-separated list of attribute names that should be considered to have
 localizable values. Only used for markup templates.
 ``ignore_tags``
 ---------------
 Comma-separated list of tag names that should be ignored. Only used for markup
+Comma-separated list of tag names that should be ignored. Only used for markup
 templates.
 ``extract_text``
 ----------------
 Whether text outside explicit ``gettext`` function calls should be extracted.
 By default, any text nodes not inside ignored tags, and values of attribute in
 the ``include_attrs`` list are extracted. If this option is disabled, only
+the ``include_attrs`` list are extracted. If this option is disabled, only
 strings in ``gettext`` function calls are extracted.
 .. note:: If you disable this option, and do not make use of the
 …
   from genshi.filters import Translator
   from genshi.template import MarkupTemplate
   template = MarkupTemplate("...")
   template.filters.insert(0, Translator(translations.ugettext))
 …
   from genshi.filters import Translator
   from genshi.template import MarkupTemplate
   template = MarkupTemplate("...")
   translator = Translator(translations.ugettext)
   translator.setup(template)
 …
 Related Considerations
 ======================
 If you intend to produce an application that is fully prepared for an
+If you intend to produce an application that is fully prepared for an
 international audience, there are a couple of other things to keep in mind:
 -------
 …
 Use ``unicode`` internally, not encoded bytestrings. Only encode/decode where
 data enters or exits the system. This means that your code works with characters
 and not just with bytes, which is an important distinction for example when
+and not just with bytes, which is an important distinction for example when
 calculating the length of a piece of text. When you need to decode/encode, it's
 probably a good idea to use UTF-8.
 …
 Date and Time
 -------------
 If your application uses datetime information that should be displayed to users
 in different timezones, you should try to work with UTC (universal time)
 internally. Do the conversion from and to "local time" when the data enters or
 exits the system. Make use the Python `datetime`_ module and the third-party
+If your application uses datetime information that should be displayed to users
+in different timezones, you should try to work with UTC (universal time)
+internally. Do the conversion from and to "local time" when the data enters or
+exits the system. Make use the Python `datetime`_ module and the third-party
 `pytz`_ package.
 --------------------------
 Formatting and Locale Data
 --------------------------
 Make sure you check out the functionality provided by the `Babel`_ project for
+Make sure you check out the functionality provided by the `Babel`_ project for
 things like number and date formatting, locale display strings, etc.
 .. _`datetime`: http://docs.python.org/lib/module-datetime.html

genshi/filters/i18n.py

     any
 except NameError:
     from genshi.util import any
+from functools import partial
 from gettext import NullTranslations
 import os
 import re
 from types import FunctionType
+from genshi.core import Attrs, Namespace, QName, START, END, TEXT, \
+                        XML_NAMESPACE, _ensure, StreamEventKind
+from genshi.core import (
+    Attrs, Namespace, QName, START, END, TEXT,
+    XML_NAMESPACE, _ensure, StreamEventKind)
 from genshi.template.eval import _ast
 from genshi.template.base import DirectiveFactory, EXPR, SUB, _apply_directives
 from genshi.template.directives import Directive, StripDirective
 …
     """Simple interface for directives to support messages extraction."""
     def extract(self, translator, stream, gettext_functions=GETTEXT_FUNCTIONS,
                 search_text=True, comment_stack=None):
+                search_text=True, comment_stack=None, context_stack=None):
         raise NotImplementedError
+contexted = {
+    None: 'pgettext',
+    'gettext': 'pgettext',
+    'ngettext': 'pngettext',
+    'dgettext': 'dpgettext',
+    'dngettext': 'dnpgettext'
+}
+def contextify(line, func, msg, comment, context):
+    if context:
+        context = context[0]
+        func = contexted.get(func)
+        if func is None:
+            raise Exception("failure, bogus extraction method")
+        if isinstance(msg, tuple):
+            msg = (context, tuple[0], tuple[1])
+        else:
+            msg = (context, msg)
+    return line, func, msg, comment
 class CommentDirective(I18NDirective):
     """Implementation of the ``i18n:comment`` template directive which adds
     translation comments.
     >>> tmpl = MarkupTemplate('''<html xmlns:i18n="http://genshi.edgewall.org/i18n">
     ...   <p i18n:comment="As in Foo Bar">Foo</p>
     ... </html>''')
 …
 class MsgDirective(ExtractableI18NDirective):
     r"""Implementation of the ``i18n:msg`` directive which marks inner content
     as translatable. Consider the following examples:
     >>> tmpl = MarkupTemplate('''<html xmlns:i18n="http://genshi.edgewall.org/i18n">
     ...   <div i18n:msg="">
     ...     <p>Foo</p>
 …
     ...   </div>
     ...   <p i18n:msg="">Foo <em>bar</em>!</p>
     ... </html>''')
     >>> translator = Translator()
     >>> translator.setup(tmpl)
     >>> list(translator.extract(tmpl.stream))
 …
     def __call__(self, stream, directives, ctxt, **vars):
         gettext = ctxt.get('_i18n.gettext')
+        if ctxt.get('_i18n.domain'):
+        if ctxt.get('_i18n.domain') and ctxt.get('_i18n.context'):
+            dpgettext = ctxt.get('_i18n.dpgettext')
+            assert hasattr(dpgettext, '__call__'), \
+                'No domain/context gettext function passed'
+            gettext = lambda msg: dpgettext(ctxt.get('_i18n.domain'),
+                                            ctxt.get('_i18n.context'),
+                                            msg)
+        elif ctxt.get('_i18n.domain'):
             dgettext = ctxt.get('_i18n.dgettext')
             assert hasattr(dgettext, '__call__'), \
                 'No domain gettext function passed'
             gettext = lambda msg: dgettext(ctxt.get('_i18n.domain'), msg)
+        elif ctxt.get('_i18n.context'):
+            pgettext = ctxt.get('_i18n.pgettext')
+            assert hasattr(pgettext, '__call__'), \
+                'No context gettext function passed'
+            gettext = lambda msg: pgettext(ctxt.get('_i18n.context'), msg)
         def _generate():
             msgbuf = MessageBuffer(self)
 …
         return _apply_directives(_generate(), directives, ctxt, vars)
     def extract(self, translator, stream, gettext_functions=GETTEXT_FUNCTIONS,
                 search_text=True, comment_stack=None):
+                search_text=True, comment_stack=None, context_stack=None):
         msgbuf = MessageBuffer(self)
         strip = False
 …
         if not strip:
             msgbuf.append(*previous)
+        yield self.lineno, None, msgbuf.format(), comment_stack[-1:]
+        yield contextify(
+            self.lineno, None, msgbuf.format(), comment_stack[-1:], context_stack[-1:])
 class ChooseBranchDirective(I18NDirective):
 …
         ctxt['_i18n.choose.%s' % self.tagname] = msgbuf
     def extract(self, translator, stream, gettext_functions=GETTEXT_FUNCTIONS,
+                search_text=True, comment_stack=None, msgbuf=None):
+                search_text=True, comment_stack=None, context_stack=None,
+                msgbuf=None):
         stream = iter(stream)
         previous = stream.next()
 …
 class ChooseDirective(ExtractableI18NDirective):
     """Implementation of the ``i18n:choose`` directive which provides plural
     internationalisation of strings.
     This directive requires at least one parameter, the one which evaluates to
     an integer which will allow to choose the plural/singular form. If you also
     have expressions inside the singular and plural version of the string you
     also need to pass a name for those parameters. Consider the following
     examples:
     >>> tmpl = MarkupTemplate('''<html xmlns:i18n="http://genshi.edgewall.org/i18n">
     ...   <div i18n:choose="num; num">
     ...     <p i18n:singular="">There is $num coin</p>
 …
         ngettext = ctxt.get('_i18n.ngettext')
         assert hasattr(ngettext, '__call__'), 'No ngettext function available'
+        npgettext = ctxt.get('_i18n.npgettext')
+        if not npgettext:
+            npgettext = lambda c, s, p, n: ngettext(s, p, n)
         dngettext = ctxt.get('_i18n.dngettext')
         if not dngettext:
             dngettext = lambda d, s, p, n: ngettext(s, p, n)
+        dnpgettext = ctxt.get('_i18n.dnpgettext')
+        if not dnpgettext:
+            dnpgettext = lambda d, c, s, p, n: dngettext(d, s, p, n)
         new_stream = []
         singular_stream = None
 …
             else:
                 new_stream.append(event)
+        if ctxt.get('_i18n.domain'):
+        if ctxt.get('_i18n.context') and ctxt.get('_i18n.domain'):
+            ngettext = lambda s, p, n: dnpgettext(ctxt.get('_i18n.domain'),
+                                                  ctxt.get('_i18n.context'),
+                                                  s, p, n)
+        elif ctxt.get('_i18n.context'):
+            ngettext = lambda s, p, n: npgettext(ctxt.get('_i18n.context'),
+                                                 s, p, n)
+        elif ctxt.get('_i18n.domain'):
             ngettext = lambda s, p, n: dngettext(ctxt.get('_i18n.domain'),
                                                  s, p, n)
 …
         ctxt.pop()
     def extract(self, translator, stream, gettext_functions=GETTEXT_FUNCTIONS,
                 search_text=True, comment_stack=None):
+                search_text=True, comment_stack=None, context_stack=None):
         strip = False
         stream = iter(stream)
         previous = stream.next()
 …
                     if isinstance(directive, SingularDirective):
                         for message in directive.extract(translator,
                                 substream, gettext_functions, search_text,
                                 comment_stack, msgbuf=singular_msgbuf):
+                                comment_stack, context_stack, msgbuf=singular_msgbuf):
                             yield message
                     elif isinstance(directive, PluralDirective):
                         for message in directive.extract(translator,
                                 substream, gettext_functions, search_text,
                                 comment_stack, msgbuf=plural_msgbuf):
+                                comment_stack, context_stack, msgbuf=plural_msgbuf):
                             yield message
                     elif not isinstance(directive, StripDirective):
                         singular_msgbuf.append(*previous)
 …
             singular_msgbuf.append(*previous)
             plural_msgbuf.append(*previous)
         yield self.lineno, 'ngettext', \
+        yield contextify(self.lineno, 'ngettext', \
             (singular_msgbuf.format(), plural_msgbuf.format()), \
             comment_stack[-1:]
+                         comment_stack[-1:], context_stack[-1:])
     def _is_plural(self, numeral, ngettext):
         # XXX: should we test which form was chosen like this!?!?!?
 …
 class DomainDirective(I18NDirective):
     """Implementation of the ``i18n:domain`` directive which allows choosing
     another i18n domain(catalog) to translate from.
     >>> from genshi.filters.tests.i18n import DummyTranslations
     >>> tmpl = MarkupTemplate('''<html xmlns:i18n="http://genshi.edgewall.org/i18n">
     ...   <p i18n:msg="">Bar</p>
 …
         ctxt.pop()
+class ContextDirective(I18NDirective):
+    __slots__ = ['context']
+    def __init__(self, value, template=None, namespaces=None, lineno=-1,
+                 offset=-1):
+        Directive.__init__(self, None, template, namespaces, lineno, offset)
+        self.context = value
+    @classmethod
+    def attach(cls, template, stream, value, namespaces, pos):
+        if type(value) is dict:
+            value = value.get('name')
+        return super(ContextDirective, cls).attach(template, stream, value,
+                                                   namespaces, pos)
+    def __call__(self, stream, directives, ctxt, **vars):
+        ctxt.push({'_i18n.context': self.context})
+        for event in _apply_directives(stream, directives, ctxt, vars):
+            yield event
+        ctxt.pop()
 class Translator(DirectiveFactory):
     """Can extract and translate localizable strings from markup streams and
     templates.
     For example, assume the following template:
     >>> tmpl = MarkupTemplate('''<html xmlns:py="http://genshi.edgewall.org/">
     ...   <head>
     ...     <title>Example</title>
 …
     ...     <p>${_("Hello, %(name)s") % dict(name=username)}</p>
     ...   </body>
     ... </html>''', filename='example.html')
     For demonstration, we define a dummy ``gettext``-style function with a
     hard-coded translation table, and pass that to the `Translator` initializer:
     >>> def pseudo_gettext(string):
     ...     return {
     ...         'Example': 'Beispiel',
     ...         'Hello, %(name)s': 'Hallo, %(name)s'
     ...     }[string]
     >>> translator = Translator(pseudo_gettext)
     Next, the translator needs to be prepended to any already defined filters
     on the template:
     >>> tmpl.filters.insert(0, translator)
     When generating the template output, our hard-coded translations should be
     applied as expected:
     >>> print(tmpl.generate(username='Hans', _=pseudo_gettext))
     <html>
       <head>
 …
         <p>Hallo, Hans</p>
       </body>
     </html>
     Note that elements defining ``xml:lang`` attributes that do not contain
     variable expressions are ignored by this filter. That can be used to
     exclude specific parts of a template from being extracted and translated.
 …
     directives = [
         ('domain', DomainDirective),
         ('comment', CommentDirective),
+        ('ctxt', ContextDirective),
         ('msg', MsgDirective),
         ('choose', ChooseDirective),
         ('singular', SingularDirective),
 …
     def __init__(self, translate=NullTranslations(), ignore_tags=IGNORE_TAGS,
                  include_attrs=INCLUDE_ATTRS, extract_text=True):
         """Initialize the translator.
         :param translate: the translation function, for example ``gettext`` or
                           ``ugettext``.
         :param ignore_tags: a set of tag names that should not be localized
 …
         :param extract_text: whether the content of text nodes should be
                              extracted, or only text in explicit ``gettext``
                              function calls
         :note: Changed in 0.6: the `translate` parameter can now be either
                a ``gettext``-style function, or an object compatible with the
                ``NullTransalations`` or ``GNUTranslations`` interface
 …
     def __call__(self, stream, ctxt=None, translate_text=True,
                  translate_attrs=True):
         """Translate any localizable strings in the given stream.
         This function shouldn't be called directly. Instead, an instance of
         the `Translator` class should be registered as a filter with the
         `Template` or the `TemplateLoader`, or applied as a regular stream
         filter. If used as a template filter, it should be inserted in front of
         all the default filters.
         :param stream: the markup event stream
         :param ctxt: the template context (not used)
         :param translate_text: whether text nodes should be translated (used
 …
             except AttributeError:
                 dgettext = lambda _, y: gettext(y)
                 dngettext = lambda _, s, p, n: ngettext(s, p, n)
+            try:
+                if IS_PYTHON2:
+                    pgettext = self.translate.upgettext
+                    dpgettext = self.translate.dupgettext
+                    npgettext = self.translate.unpgettext
+                    dnpgettext = self.translate.dunpgettext
+                else:
+                    pgettext = self.translate.pgettext
+                    dpgettext = self.translate.dpgettext
+                    npgettext = self.translate.npgettext
+                    dnpgettext = self.translate.dnpgettext
+            except AttributeError:
+                pgettext = lambda _, y: gettext(y)
+                dpgettext = lambda d, _, y: dgettext(d, y)
+                npgettext = lambda _, s, p, n: ngettext(s, p, n)
+                dnpgettext = lambda d, _, s, p, n: dngettext(d, s, p, n)
             if ctxt:
                 ctxt['_i18n.gettext'] = gettext
                 ctxt['_i18n.ngettext'] = ngettext
                 ctxt['_i18n.dgettext'] = dgettext
                 ctxt['_i18n.dngettext'] = dngettext
+                ctxt['_i18n.pgettext'] = pgettext
+                ctxt['_i18n.npgettext'] = npgettext
+                ctxt['_i18n.dpgettext'] = dpgettext
+                ctxt['_i18n.dnpgettext'] = dnpgettext
         if ctxt and ctxt.get('_i18n.domain'):
             # TODO: This can cause infinite recursion if dgettext is defined
             #       via the AttributeError case above!
             gettext = lambda msg: dgettext(ctxt.get('_i18n.domain'), msg)
+            gettext = partial(dgettext, ctxt.get('_i18n.domain'))
+        if ctxt and ctxt.get('_i18n.context'):
+            if getattr(gettext, 'func', None):
+                gettext = partial(dpgettext,
+                                  ctxt['_i18n.domain'],
+                                  ctxt['_i18n.context'])
+            else:
+                gettext = partial(pgettext, ctxt['_i18n.context'])
         for kind, data, pos in stream:
             # skip chunks that should not be localized
 …
             elif kind is SUB:
                 directives, substream = data
                 current_domain = None
+                current_context = None
                 for idx, directive in enumerate(directives):
                     # Organize directives to make everything work
                     # FIXME: There's got to be a better way to do this!
 …
                         # Put domain directive as the first one in order to
                         # update context before any other directives evaluation
                         directives.insert(0, directives.pop(idx))
+                    if isinstance(directive, ContextDirective):
+                        # Grab current (msg)context and update context
+                        current_context = directive.context
+                        ctxt.push({'_i18n.context': current_context})
+                        # Put context directive either first in the case of
+                        # no domain, or 2nd in the case there is a domain, to
+                        # update context before any other directives evaluation
+                        directives.insert(1 if current_domain else 0,
+                                          directives.pop(idx))
                 # If this is an i18n directive, no need to translate text
                 # nodes here
 …
                     isinstance(d, ExtractableI18NDirective)
                     for d in directives
                 ])
                 substream = list(self(substream, ctxt,
                                       translate_text=not is_i18n_directive,
                                       translate_attrs=translate_attrs))
 …
                 if current_domain:
                     ctxt.pop()
+                if current_context:
+                    ctxt.pop()
             else:
                 yield kind, data, pos
     def extract(self, stream, gettext_functions=GETTEXT_FUNCTIONS,
                 search_text=True, comment_stack=None):
+                search_text=True, comment_stack=None, context_stack=None):
         """Extract localizable strings from the given template stream.
         For every string found, this function yields a ``(lineno, function,
         message, comments)`` tuple, where:
         * ``lineno`` is the number of the line on which the string was found,
         * ``function`` is the name of the ``gettext`` function used (if the
           string was extracted from embedded Python code), and
 …
            arguments).
         *  ``comments`` is a list of comments related to the message, extracted
            from ``i18n:comment`` attributes found in the markup
         >>> tmpl = MarkupTemplate('''<html xmlns:py="http://genshi.edgewall.org/">
         ...   <head>
         ...     <title>Example</title>
 …
 , None, u'Example'
 , '_', u'Hello, %(name)s'
 , 'ngettext', (u'You have %d item', u'You have %d items', None)
         :param stream: the event stream to extract strings from; can be a
                        regular stream or a template stream
         :param gettext_functions: a sequence of function names that should be
 …
                                   functions
         :param search_text: whether the content of text nodes should be
                             extracted (used internally)
         :note: Changed in 0.4.1: For a function with multiple string arguments
                (such as ``ngettext``), a single item with a tuple of strings is
                yielded, instead an item for each string argument.
 …
             search_text = False
         if comment_stack is None:
             comment_stack = []
+        if context_stack is None:
+            context_stack = []
         skip = 0
         xml_lang = XML_NAMESPACE['lang']
 …
             elif not skip and search_text and kind is TEXT:
                 text = data.strip()
                 if text and [ch for ch in text if ch.isalpha()]:
+                    yield pos[1], None, text, comment_stack[-1:]
+                    yield contextify(pos[1], None, text, comment_stack[-1:],
+                                     context_stack[-1:])
             elif kind is EXPR or kind is EXEC:
                 for funcname, strings in extract_from_code(data,
 …
             elif kind is SUB:
                 directives, substream = data
                 in_comment = False
+                in_context = False
                 for idx, directive in enumerate(directives):
                     # Do a first loop to see if there's a comment directive
 …
                             for message in self.extract(
                                     substream, gettext_functions,
                                     search_text=search_text and not skip,
+                                    comment_stack=comment_stack):
+                                    comment_stack=comment_stack,
+                                    context_stack=context_stack):
                                 yield message
                         directives.pop(idx)
+                    elif isinstance(directive, ContextDirective):
+                        in_context = True
+                        context_stack.append(directive.context)
+                        if len(directives) == 1:
+                            for message in self.extract(
+                                    substream, gettext_functions,
+                                    search_text=search_text and not skip,
+                                    comment_stack=comment_stack,
+                                    context_stack=context_stack):
+                                yield message
+                        directives.pop(idx)
                     elif not isinstance(directive, I18NDirective):
                         # Remove all other non i18n directives from the process
                         directives.pop(idx)
                 if not directives and not in_comment:
+                if not directives and not in_comment and not in_context:
                     # Extract content if there's no directives because
                     # strip was pop'ed and not because comment was pop'ed.
                     # Extraction in this case has been taken care of.
 …
                         for message in directive.extract(self,
                                 substream, gettext_functions,
                                 search_text=search_text and not skip,
+                                comment_stack=comment_stack):
+                                comment_stack=comment_stack,
+                                context_stack=context_stack):
                             yield message
                     else:
                         for message in self.extract(
                                 substream, gettext_functions,
                                 search_text=search_text and not skip,
+                                comment_stack=comment_stack):
+                                comment_stack=comment_stack,
+                                context_stack=context_stack):
                             yield message
                 if in_comment:
                     comment_stack.pop()
+                if in_context:
+                    context_stack.pop()
     def get_directive_index(self, dir_cls):
         total = len(self._dir_order)
         if dir_cls in self._dir_order:
 …
     def setup(self, template):
         """Convenience function to register the `Translator` filter and the
         related directives with the given template.
         :param template: a `Template` instance
         """
         template.filters.insert(0, self)
 …
 class MessageBuffer(object):
     """Helper class for managing internationalized mixed content.
     :since: version 0.5
     """
     def __init__(self, directive=None):
         """Initialize the message buffer.
         :param directive: the directive owning the buffer
         :type directive: I18NDirective
         """
 …
     def append(self, kind, data, pos):
         """Append a stream event to the buffer.
         :param kind: the stream event kind
         :param data: the event data
         :param pos: the position of the event in the source
 …
                     params = "(%s)" % params
                 raise IndexError("%d parameters%s given to 'i18n:%s' but "
                                  "%d or more expressions used in '%s', line %s"
                                  % (len(self.orig_params), params,
+                                 % (len(self.orig_params), params,
                                     self.directive.tagname,
                                     len(self.orig_params) + 1,
                                     os.path.basename(pos[0] or
 …
             self._add_event(self.stack[-1], (kind, data, pos))
             self.values[param] = (kind, data, pos)
         else:
             if kind is START:
+            if kind is START:
                 self.string.append('[%d:' % self.order)
                 self.stack.append(self.order)
                 self._add_event(self.stack[-1], (kind, data, pos))
 …
     def translate(self, string, regex=re.compile(r'%\((\w+)\)s')):
         """Interpolate the given message translation with the events in the
         buffer and return the translated stream.
         :param string: the translated message string
         """
         substream = None
 …
 def parse_msg(string, regex=re.compile(r'(?:\[(\d+)\:)|(?<!\\)\]')):
     """Parse a translated message using Genshi mixed content message
     formatting.
     >>> parse_msg("See [1:Help].")
     [(0, 'See '), (1, 'Help'), (0, '.')]
     >>> parse_msg("See [1:our [2:Help] page] for details.")
     [(0, 'See '), (1, 'our '), (2, 'Help'), (1, ' page'), (0, ' for details.')]
     >>> parse_msg("[2:Details] finden Sie in [1:Hilfe].")
     [(2, 'Details'), (0, ' finden Sie in '), (1, 'Hilfe'), (0, '.')]
     >>> parse_msg("[1:] Bilder pro Seite anzeigen.")
     [(1, ''), (0, ' Bilder pro Seite anzeigen.')]
     :param string: the translated message string
     :return: a list of ``(order, string)`` tuples
     :rtype: `list`
 …
 def extract_from_code(code, gettext_functions):
     """Extract strings from Python bytecode.
     >>> from genshi.template.eval import Expression
     >>> expr = Expression('_("Hello")')
     >>> list(extract_from_code(expr, GETTEXT_FUNCTIONS))
     [('_', u'Hello')]
     >>> expr = Expression('ngettext("You have %(num)s item", '
     ...                            '"You have %(num)s items", num)')
     >>> list(extract_from_code(expr, GETTEXT_FUNCTIONS))
     [('ngettext', (u'You have %(num)s item', u'You have %(num)s items', None))]
     :param code: the `Code` object
     :type code: `genshi.template.eval.Code`
     :param gettext_functions: a sequence of function names
 …
 def extract(fileobj, keywords, comment_tags, options):
     """Babel extraction method for Genshi templates.
     :param fileobj: the file-like object the messages should be extracted from
     :param keywords: a list of keywords (i.e. function names) that should be
                      recognized as translation functions

genshi/filters/tests/i18n.py

     if IS_PYTHON2:
         def dungettext(self, domain, singular, plural, numeral):
+            return self._domain_call('ungettext', domain, singular, plural, numeral)
+            return self._domain_call(
+                'ungettext', domain, singular, plural, numeral)
     else:
         def dngettext(self, domain, singular, plural, numeral):
+            return self._domain_call('ngettext', domain, singular, plural, numeral)
+            return self._domain_call(
+                'ngettext', domain, singular, plural, numeral)
+    def upgettext(self, context, message):
+        try:
+            return self._catalog[(context, message)]
+        except KeyError:
+            if self._fallback:
+                return self._fallback.upgettext(context, message)
+            return unicode(message)
+    if not IS_PYTHON2:
+        pgettext = upgettext
+        del upgettext
+    if IS_PYTHON2:
+        def dupgettext(self, domain, context, message):
+            return self._domain_call('upgettext', domain, context, message)
+    else:
+        def dpgettext(self, domain, context, message):
+            return self._domain_call('pgettext', domain, context, message)
+    def unpgettext(self, context, msgid1, msgid2, n):
+        try:
+            return self._catalog[(context, msgid1, self.plural(n))]
+        except KeyError:
+            if self._fallback:
+                return self._fallback.unpgettext(context, msgid1, msgid2, n)
+            if n == 1:
+                return msgid1
+            else:
+                return msgid2
+    if not IS_PYTHON2:
+        npgettext = unpgettext
+        del unpgettext
+    if IS_PYTHON2:
+        def dunpgettext(self, domain, context, msgid1, msgid2, n):
+            return self._domain_call('unpgettext', context, msgid1, msgid2, n)
+    else:
+        def dnpgettext(self, domain, context, msgid1, msgid2, n):
+            return self._domain_call('npgettext', context, msgid1, msgid2, n)
 class TranslatorTestCase(unittest.TestCase):
     def test_translate_included_attribute_text(self):
 …
             <p>Vohs John Doe</p>
           </div>
         </html>""", tmpl.generate(two=2, fname='John', lname='Doe').render())
     def test_translate_i18n_choose_and_singular_with_py_strip(self):
         tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
             xmlns:i18n="http://genshi.edgewall.org/i18n">
 …
           </div>
         </html>""", tmpl.generate(
             one=1, two=2, fname='John',lname='Doe').render())
     def test_translate_i18n_choose_and_plural_with_py_strip(self):
         tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
             xmlns:i18n="http://genshi.edgewall.org/i18n">
 …
             (34, '_', 'Update', [])], messages)
+class ContextDirectiveTestCase(unittest.TestCase):
+    def test_extract_msgcontext(self):
+        buf = StringIO("""<html xmlns:py="http://genshi.edgewall.org/"
+                                xmlns:i18n="http://genshi.edgewall.org/i18n">
+          <p i18n:ctxt="foo">Foo, bar.</p>
+          <p>Foo, bar.</p>
+        </html>""")
+        results = list(extract(buf, ['_'], [], {}))
+        self.assertEqual((3, 'pgettext', ('foo', 'Foo, bar.'), []), results[0])
+        self.assertEqual((4, None, 'Foo, bar.', []), results[1])
+    def test_translate_msgcontext(self):
+        tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
+            xmlns:i18n="http://genshi.edgewall.org/i18n">
+          <p i18n:ctxt="foo">Foo, bar.</p>
+          <p>Foo, bar.</p>
+        </html>""")
+        translations = {
+            ('foo', 'Foo, bar.'): 'Fooo! Barrr!',
+            'Foo, bar.': 'Foo --- bar.'
+        }
+        translator = Translator(DummyTranslations(translations))
+        translator.setup(tmpl)
+        self.assertEqual("""<html>
+          <p>Fooo! Barrr!</p>
+          <p>Foo --- bar.</p>
+        </html>""", tmpl.generate().render())
+    def test_translate_msgcontext_with_domain(self):
+        tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
+            xmlns:i18n="http://genshi.edgewall.org/i18n">
+          <p i18n:domain="bar" i18n:ctxt="foo">Foo, bar. <span>foo</span></p>
+          <p>Foo, bar.</p>
+        </html>""")
+        translations = DummyTranslations({
+            ('foo', 'Foo, bar.'): 'Fooo! Barrr!',
+            'Foo, bar.': 'Foo --- bar.'
+        })
+        translations.add_domain('bar', {
+            ('foo', 'foo'): 'BARRR',
+            ('foo', 'Foo, bar.'): 'Bar, bar.'
+        })
+        translator = Translator(translations)
+        translator.setup(tmpl)
+        self.assertEqual("""<html>
+          <p>Bar, bar. <span>BARRR</span></p>
+          <p>Foo --- bar.</p>
+        </html>""", tmpl.generate().render())
+    def test_translate_msgcontext_with_plurals(self):
+        tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
+            xmlns:i18n="http://genshi.edgewall.org/i18n">
+        <i18n:ctxt name="foo">
+          <p i18n:choose="num; num">
+            <span i18n:singular="">There is ${num} bar</span>
+            <span i18n:plural="">There are ${num} bars</span>
+          </p>
+        </i18n:ctxt>
+        </html>""")
+        translations = DummyTranslations({
+            ('foo', 'There is %(num)s bar', 0): 'Hay %(num)s barre',
+            ('foo', 'There is %(num)s bar', 1): 'Hay %(num)s barres'
+        })
+        translator = Translator(translations)
+        translator.setup(tmpl)
+        self.assertEqual("""<html>
+          <p>
+            <span>Hay 1 barre</span>
+          </p>
+        </html>""", tmpl.generate(num=1).render())
+        self.assertEqual("""<html>
+          <p>
+            <span>Hay 2 barres</span>
+          </p>
+        </html>""", tmpl.generate(num=2).render())
+    def test_translate_context_with_msg(self):
+        tmpl = MarkupTemplate("""<html xmlns:py="http://genshi.edgewall.org/"
+            xmlns:i18n="http://genshi.edgewall.org/i18n">
+        <p i18n:ctxt="foo" i18n:msg="num">
+          Foo <span>There is ${num} bar</span> Bar
+        </p>
+        </html>""")
+        translations = DummyTranslations({
+            ('foo', 'Foo [1:There is %(num)s bar] Bar'):
+            'Voh [1:Hay %(num)s barre] Barre'
+        })
+        translator = Translator(translations)
+        translator.setup(tmpl)
+        self.assertEqual("""<html>
+        <p>Voh <span>Hay 1 barre</span> Barre</p>
+        </html>""", tmpl.generate(num=1).render())
 def suite():
     suite = unittest.TestSuite()
     suite.addTest(doctest.DocTestSuite(Translator.__module__))
 …
     suite.addTest(unittest.makeSuite(ChooseDirectiveTestCase, 'test'))
     suite.addTest(unittest.makeSuite(DomainDirectiveTestCase, 'test'))
     suite.addTest(unittest.makeSuite(ExtractTestCase, 'test'))
+    suite.addTest(unittest.makeSuite(ContextDirectiveTestCase, 'test'))
     return suite
 if __name__ == '__main__':

examples/bench/bigtable.py

 import timeit
 from StringIO import StringIO
 from genshi.builder import tag
+from genshi.filters.i18n import Translator
+from genshi.filters.tests.i18n import DummyTranslations
 from genshi.template import MarkupTemplate, NewTextTemplate
 try:
 …
 </table>
 """)
+genshi_tmpl_i18n = MarkupTemplate("""
+<table xmlns:py="http://genshi.edgewall.org/"
+       xmlns:i18n="http://genshi.edgewall.org/i18n">
+<tr py:for="row in table">
+<td py:for="c in row.values()">${c}</td>
+</tr>
+</table>
+""")
+t = Translator(DummyTranslations())
+t.setup(genshi_tmpl_i18n)
 genshi_tmpl2 = MarkupTemplate("""
 <table xmlns:py="http://genshi.edgewall.org/">$table</table>
 """)
 …
     stream = genshi_tmpl.generate(table=table)
     stream.render('html', strip_whitespace=False)
+def test_genshi_i18n():
+    """Genshi template w/ i18n"""
+    stream = genshi_tmpl_i18n.generate(table=table)
+    stream.render('html', strip_whitespace=False)
 def test_genshi_text():
     """Genshi text template"""
     stream = genshi_text_tmpl.generate(table=table)
 …
         et.tostring(_table)
 if cet:
     def test_cet():
+    def test_cet():
         """cElementTree"""
         _table = cet.Element('table')
         for row in table:
 …
 def run(which=None, number=10):
     tests = ['test_builder', 'test_genshi', 'test_genshi_text',
+    tests = ['test_builder', 'test_genshi', 'test_genshi_i18n', 'test_genshi_text',
              'test_genshi_builder', 'test_mako', 'test_kid', 'test_kid_et',
              'test_et', 'test_cet', 'test_clearsilver', 'test_django']

Download in other formats:

Original Format