Dip a toe in the i18n waters.

5 files changed, 312 insertions, 8 deletions

diff --git a/repoze/bfg/configuration.py b/repoze/bfg/configuration.py
index 4673479da..862f8b3a6 100644
--- a/repoze/bfg/configuration.py
+++ b/repoze/bfg/configuration.py
@@ -31,6 +31,7 @@ from repoze.bfg.interfaces import IRoutesMapper
 from repoze.bfg.interfaces import ISecuredView
 from repoze.bfg.interfaces import ISettings
 from repoze.bfg.interfaces import ITemplateRenderer
+from repoze.bfg.interfaces import ITranslatorFactory
 from repoze.bfg.interfaces import ITraverser
 from repoze.bfg.interfaces import IView
 from repoze.bfg.interfaces import IViewClassifier
@@ -135,14 +136,23 @@ class Configurator(object):
     logs to stderr will be used.  If it is passed, it should be an
     instance of the :class:`logging.Logger` (PEP 282) standard library
     class.  The debug logger is used by :mod:`repoze.bfg` itself to
-    log warnings and authorization debugging information.  """
+    log warnings and authorization debugging information.
+
+    If ``translator_factory`` is passed, it should be a
+    :term:`translator factory` object.  A translator factory is an
+    object which accepts a request and which returns a translation
+    function.  The translation function accepts a :term:`translation
+    string` and returns a Unicode object representing the translated
+    string.  The default for ``translator_factory`` is ``None``,
+    meaning that no translation is performed during template
+    rendering.  """
     
     manager = manager # for testing injection
     venusian = venusian # for testing injection
     def __init__(self, registry=None, package=None, settings=None,
                  root_factory=None, authentication_policy=None,
                  authorization_policy=None, renderers=DEFAULT_RENDERERS,
-                 debug_logger=None):
+                 debug_logger=None, translator_factory=None):
         self.package = package or caller_package()
         self.registry = registry
         if registry is None:
@@ -154,7 +164,8 @@ class Configurator(object):
                 authentication_policy=authentication_policy,
                 authorization_policy=authorization_policy,
                 renderers=renderers,
-                debug_logger=debug_logger)
+                debug_logger=debug_logger,
+                translator_factory=translator_factory)
 
     def _set_settings(self, mapping):
         settings = Settings(mapping or {})
@@ -270,7 +281,8 @@ class Configurator(object):
 
     def setup_registry(self, settings=None, root_factory=None,
                        authentication_policy=None, authorization_policy=None,
-                       renderers=DEFAULT_RENDERERS, debug_logger=None):
+                       renderers=DEFAULT_RENDERERS, debug_logger=None,
+                       translator_factory=None):
         """ When you pass a non-``None`` ``registry`` argument to the
         :term:`Configurator` constructor, no initial 'setup' is
         performed against the registry.  This is because the registry
@@ -304,6 +316,8 @@ class Configurator(object):
             self.add_renderer(name, renderer)
         self.set_notfound_view(default_notfound_view)
         self.set_forbidden_view(default_forbidden_view)
+        if translator_factory is not None:
+            self.set_translator_factory(translator_factory)
 
     # getSiteManager is a unit testing dep injection
     def hook_zca(self, getSiteManager=None):
@@ -1225,10 +1239,6 @@ class Configurator(object):
            found via context-finding or ``None`` if no context could
            be found.  The exception causing the registered view to be
            called is however still available as ``request.exception``.
-        .. warning:: This method has been deprecated in
-           :mod:`repoze.bfg` 1.3.  See
-           :ref:`changing_the_forbidden_view` to see how a not found
-           view should be registered in :mod:`repoze.bfg` 1.3+.
 
         The ``view`` argument should be a :term:`view callable`.
 
@@ -1299,6 +1309,11 @@ class Configurator(object):
         return self.add_view(bwcompat_view, context=NotFound,
                              wrapper=wrapper, _info=_info)
 
+    def set_translator_factory(self, factory):
+        """ Set ``factory`` up as the current application
+        :term:`translator factory` (for internationalization)"""
+        self.registry.registerUtility(factory, ITranslatorFactory)
+
     def add_static_view(self, name, path, cache_max_age=3600, _info=u''):
         """ Add a view used to render static resources to the current
         configuration state.
diff --git a/repoze/bfg/i18n.py b/repoze/bfg/i18n.py
new file mode 100644
index 000000000..bc0ae4423
--- /dev/null
+++ b/repoze/bfg/i18n.py
@@ -0,0 +1,87 @@
+from zope.interface import implements
+from zope.interface import classProvides
+
+from repoze.bfg.interfaces import ITranslator
+from repoze.bfg.interfaces import ITranslatorFactory
+from repoze.bfg.threadlocal import get_current_registry
+from repoze.bfg.threadlocal import get_current_request
+
+def get_translator(request):
+    try:
+        reg = request.registry
+    except AttributeError:
+        reg = get_current_registry()
+
+    if reg is None: # pragma: no cover
+        return None # only in insane circumstances
+
+    translator = getattr(request, '_bfg_translator', None)
+
+    if translator is False:
+        return None
+
+    if translator is None:
+        translator_factory = reg.queryUtility(ITranslatorFactory)
+        if translator_factory is None:
+            request_value = False
+        else:
+            translator = translator_factory(request)
+            request_value = translator
+        try:
+            request._bfg_translator = request_value
+        except AttributeError: # pragma: no cover
+            pass # it's only a cache
+
+    return translator
+
+class InterpolationOnlyTranslator(object):
+    classProvides(ITranslatorFactory)
+    implements(ITranslator)
+    def __init__(self, request):
+        self.request = request
+
+    def __call__(self, message):
+        mapping = getattr(message, 'mapping', {}) #should be a TranslationString
+        return message % mapping
+
+class TranslationString(unicode):
+    __slots__ = ('msgid', 'domain', 'mapping')
+    def __new__(cls, text, msgid=None, domain=None, mapping=None):
+        self = unicode.__new__(cls, text)
+        if msgid is None:
+            msgid = unicode(text)
+        self.msgid = msgid
+        self.domain = domain
+        self.mapping = mapping or {}
+        return self
+
+    def __reduce__(self):
+        return self.__class__, self.__getstate__()
+
+    def __getstate__(self):
+        return unicode(self), self.msgid, self.domain, self.mapping
+
+def chameleon_translate(text, domain=None, mapping=None, context=None,
+                        target_language=None, default=None):
+    if text is None:
+        return None
+    translator = None
+    request = get_current_request()
+    if request is not None:
+        request.chameleon_target_language = target_language
+        translator = get_translator(request)
+    if default is None:
+        default = text
+    if mapping is None:
+        mapping = {}
+    if translator is None:
+        return unicode(default) % mapping
+    if not isinstance(text, TranslationString):
+        text = TranslationString(default, msgid=text, domain=domain,
+                                 mapping=mapping)
+    return translator(text)
+        
+    
+    
+    
+    
diff --git a/repoze/bfg/interfaces.py b/repoze/bfg/interfaces.py
index 40d29348c..92003a9f9 100644
--- a/repoze/bfg/interfaces.py
+++ b/repoze/bfg/interfaces.py
@@ -229,3 +229,13 @@ class IPackageOverrides(Interface):
 # VH_ROOT_KEY is an interface; its imported from other packages (e.g.
 # traversalwrapper)
 VH_ROOT_KEY = 'HTTP_X_VHM_ROOT'
+
+class ITranslatorFactory(Interface):
+    """ Internal interface representing an i18n translator factory """
+    def __call__(self, request):
+        """ Return a translator """
+
+class ITranslator(Interface):
+    def __call__(self, tstr):
+        """ Return a translation based on the translation string tstr """
+    
diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py
index 99d564b91..b4f7600f5 100644
--- a/repoze/bfg/tests/test_configuration.py
+++ b/repoze/bfg/tests/test_configuration.py
@@ -265,6 +265,15 @@ class ConfiguratorTests(unittest.TestCase):
         self.assertEqual(reg.getUtility(IRendererFactory, 'yeah'),
                          renderer)
 
+    def test_setup_registry_translator_factory(self):
+        from repoze.bfg.registry import Registry
+        from repoze.bfg.interfaces import ITranslatorFactory
+        factory = object()
+        reg = Registry()
+        config = self._makeOne(reg)
+        config.setup_registry(translator_factory=factory)
+        self.assertEqual(reg.getUtility(ITranslatorFactory), factory)
+
     def test_add_settings_settings_already_registered(self):
         from repoze.bfg.registry import Registry
         from repoze.bfg.interfaces import ISettings
@@ -1727,6 +1736,14 @@ class ConfiguratorTests(unittest.TestCase):
         request = self._makeRequest(config)
         self.assertEqual(wrapped(None, request).__class__, StaticURLParser)
 
+    def test_set_translator_factory(self):
+        from repoze.bfg.interfaces import ITranslatorFactory
+        def factory(): pass
+        config = self._makeOne()
+        config.set_translator_factory(factory)
+        self.assertEqual(config.registry.getUtility(ITranslatorFactory),
+                         factory)
+
     def test_set_notfound_view(self):
         from zope.interface import implementedBy
         from repoze.bfg.interfaces import IRequest
diff --git a/repoze/bfg/tests/test_i18n.py b/repoze/bfg/tests/test_i18n.py
new file mode 100644
index 000000000..603f26a55
--- /dev/null
+++ b/repoze/bfg/tests/test_i18n.py
@@ -0,0 +1,175 @@
+import unittest
+
+class Test_get_translator(unittest.TestCase):
+    def _callFUT(self, request):
+        from repoze.bfg.i18n import get_translator
+        return get_translator(request)
+
+    def test_no_ITranslatorFactory(self):
+        request = DummyRequest()
+        request.registry = DummyRegistry()
+        translator = self._callFUT(request)
+        self.assertEqual(translator, None)
+
+    def test_no_registry_on_request(self):
+        request = DummyRequest()
+        translator = self._callFUT(request)
+        self.assertEqual(translator, None)
+
+    def test_with_ITranslatorFactory_from_registry(self):
+        request = DummyRequest()
+        tfactory = DummyTranslatorFactory()
+        request.registry = DummyRegistry(tfactory)
+        translator = self._callFUT(request)
+        self.assertEqual(translator.request, request)
+
+    def test_with_ITranslatorFactory_from_request_cache(self):
+        request = DummyRequest()
+        request.registry = DummyRegistry()
+        request._bfg_translator = 'abc'
+        translator = self._callFUT(request)
+        self.assertEqual(translator, 'abc')
+
+    def test_with_ITranslatorFactory_from_request_neg_cache(self):
+        request = DummyRequest()
+        request.registry = DummyRegistry()
+        request._bfg_translator = False
+        translator = self._callFUT(request)
+        self.assertEqual(translator, None)
+
+class TestInterpolationOnlyTranslator(unittest.TestCase):
+    def _makeOne(self, request):
+        from repoze.bfg.i18n import InterpolationOnlyTranslator
+        return InterpolationOnlyTranslator(request)
+
+    def test_it(self):
+        message = DummyMessage('text %(a)s', mapping={'a':'1'})
+        translator = self._makeOne(None)
+        result = translator(message)
+        self.assertEqual(result, u'text 1')
+
+class TestTranslationString(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.bfg.i18n import TranslationString
+        return TranslationString
+    
+    def _makeOne(self, text, **kw):
+        return self._getTargetClass()(text, **kw)
+
+    def test_ctor_defaults(self):
+        ts = self._makeOne('text')
+        self.assertEqual(ts, u'text')
+        self.assertEqual(ts.msgid, u'text')
+        self.assertEqual(ts.domain, None)
+        self.assertEqual(ts.mapping, {})
+
+    def test_ctor_nondefaults(self):
+        ts = self._makeOne(
+            'text', msgid='msgid', domain='domain', mapping='mapping')
+        self.assertEqual(ts, u'text')
+        self.assertEqual(ts.msgid, 'msgid')
+        self.assertEqual(ts.domain, 'domain')
+        self.assertEqual(ts.mapping, 'mapping')
+
+    def test___reduce__(self):
+        klass = self._getTargetClass()
+        ts = self._makeOne('text')
+        result = ts.__reduce__()
+        self.assertEqual(result, (klass, (u'text', u'text', None, {})))
+
+    def test___getstate__(self):
+        ts = self._makeOne(
+            'text', msgid='msgid', domain='domain', mapping='mapping')
+        result = ts.__getstate__()
+        self.assertEqual(result, (u'text', 'msgid', 'domain', 'mapping'))
+
+class Test_chameleon_translate(unittest.TestCase):
+    def setUp(self):
+        request = DummyRequest()
+        from repoze.bfg.configuration import Configurator
+        self.config = Configurator()
+        self.config.begin(request=request)
+        self.request = request
+
+    def tearDown(self):
+        self.config.end()
+        
+    def _callFUT(self, text, **kw):
+        from repoze.bfg.i18n import chameleon_translate
+        return chameleon_translate(text, **kw)
+
+    def test_text_None(self):
+        result = self._callFUT(None)
+        self.assertEqual(result, None)
+
+    def test_no_current_request(self):
+        self.config.manager.pop()
+        result = self._callFUT('text')
+        self.assertEqual(result, 'text')
+
+    def test_with_current_request_no_translator(self):
+        result = self._callFUT('text')
+        self.assertEqual(result, 'text')
+        self.assertEqual(self.request.chameleon_target_language, None)
+
+    def test_with_current_request_and_translator(self):
+        from repoze.bfg.interfaces import ITranslatorFactory
+        translator = DummyTranslator()
+        factory = DummyTranslatorFactory(translator)
+        self.config.registry.registerUtility(factory, ITranslatorFactory)
+        result = self._callFUT('text')
+        self.assertEqual(result, 'text')
+        self.assertEqual(self.request.chameleon_target_language, None)
+        self.assertEqual(result.msgid, 'text')
+        self.assertEqual(result.domain, None)
+        self.assertEqual(result.mapping, {})
+
+    def test_with_allargs(self):
+        from repoze.bfg.interfaces import ITranslatorFactory
+        translator = DummyTranslator()
+        factory = DummyTranslatorFactory(translator)
+        self.config.registry.registerUtility(factory, ITranslatorFactory)
+        result = self._callFUT('text', domain='domain', mapping={'a':'1'},
+                               context=None, target_language='lang',
+                               default='default')
+        self.assertEqual(self.request.chameleon_target_language, 'lang')
+        self.assertEqual(result, 'default')
+        self.assertEqual(result.msgid, 'text')
+        self.assertEqual(result.domain, 'domain')
+        self.assertEqual(result.mapping, {'a':'1'})
+
+class DummyMessage(unicode):
+    def __new__(cls, text, msgid=None, domain=None, mapping=None):
+        self = unicode.__new__(cls, text)
+        if msgid is None:
+            msgid = unicode(text)
+        self.msgid = msgid
+        self.domain = domain
+        self.mapping = mapping or {}
+        return self
+    
+class DummyRequest(object):
+    pass
+
+class DummyRegistry(object):
+    def __init__(self, tfactory=None):
+        self.tfactory = tfactory
+
+    def queryUtility(self, iface):
+        return self.tfactory
+
+class DummyTranslator(object):
+    def __call__(self, message):
+        return message
+                    
+class DummyTranslatorFactory(object):
+    def __init__(self, translator=None):
+        self.translator = translator
+
+    def __call__(self, request):
+        self.request = request
+        if self.translator is None:
+            return self
+        return self.translator
+    
+