From f5c6c574ada26ec0b2766f5ca20bb2b5b7393ec5 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Mon, 19 Apr 2010 07:34:46 +0000 Subject: Dip a toe in the i18n waters. --- repoze/bfg/configuration.py | 31 ++++-- repoze/bfg/i18n.py | 87 ++++++++++++++++ repoze/bfg/interfaces.py | 10 ++ repoze/bfg/tests/test_configuration.py | 17 ++++ repoze/bfg/tests/test_i18n.py | 175 +++++++++++++++++++++++++++++++++ 5 files changed, 312 insertions(+), 8 deletions(-) create mode 100644 repoze/bfg/i18n.py create mode 100644 repoze/bfg/tests/test_i18n.py (limited to 'repoze') 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 + + -- cgit v1.2.3