pyramid-localize 0.1.0__py2.7.egg

pyramid_localize/subscribers/fake.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Subscribers adding mocked translation methods to render context, and request."""
+
+from pyramid.events import subscriber
+from pyramid.events import BeforeRender
+from pyramid.events import NewRequest
+
+from pyramid_localize.tools import dummy_autotranslate
+
+
+@subscriber(BeforeRender)
+def global_renderer(event):
+    """BeforeRender subscriber, adds fake localizer, and translation methods to context."""
+    request = event['request']
+    try:
+        event['_'] = request._
+    except AttributeError:
+        event['_'] = dummy_autotranslate
+
+
+@subscriber(NewRequest)
+def add_localizer(event):
+    """NewRequest subscriber, adds fake localizer and translation methods to request."""
+    event.request._ = dummy_autotranslate

pyramid_localize/subscribers/i18n.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""i18n subscribers."""
+
+from pyramid.events import subscriber
+from pyramid.events import BeforeRender
+from pyramid.events import NewRequest
+
+from pyramid_localize.tools import set_localizer
+
+
+@subscriber(BeforeRender)
+def global_renderer(event):
+    """BeforeRender subscriber, adds localizer, and translation methods to context."""
+    request = event['request']
+    set_localizer(request)
+
+    event['_'] = request._
+    event['localizer'] = request.localizer
+
+
+@subscriber(NewRequest)
+def add_localizer(event):
+    """NewRequest subscriber, adds localizer and translation methods to request."""
+    set_localizer(event.request)

pyramid_localize/tools.py

@@ -0,0 +1,100 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""methods in this module are tools, thank to which pyramid_localize works most of its magic."""
+
+import sys
+import os
+import logging
+
+from translationstring import _interp_regex
+from pyramid.i18n import make_localizer
+from pyramid.i18n import TranslationString
+from pyramid.asset import resolve_asset_spec
+from pyramid.path import package_path
+from pyramid.interfaces import ILocalizer
+from pyramid.interfaces import ITranslationDirectories
+from pyramid.compat import text_type
+
+logger = logging.getLogger(__name__)
+
+
+def set_localizer(request, reset=False):
+    """
+    Set localizer and auto_translate methods for request.
+
+    :param pyramid.request.Request request: request object
+    :param bool reset: flag that directs resetting localizer within app
+    """
+    if reset:
+
+        for locale in request.registry['config'].localize.locales.available:
+            logger.debug('Resetting {0} localizator'.format(locale))
+            tdirs = request.registry.queryUtility(ITranslationDirectories,
+                                                  default=[])
+            localizer = make_localizer(locale, tdirs)
+            request.registry.registerUtility(localizer, ILocalizer,
+                                             name=locale)
+
+    def auto_translate(*args, **kwargs):
+        # lets pass default domain, so we don't have to determine it with
+        # each _() function in apps.
+        if len(args) <= 1 and 'domain' not in kwargs:
+            kwargs['domain'] = request.registry['config'].localize.domain
+
+        # unlike in examples we use TranslationString, to make sure we always
+        # use appropriate domain
+        return request.localizer.translate(TranslationString(*args, **kwargs))
+
+    request._ = auto_translate
+
+
+def destination_path(request):
+    """
+    Return absolute path of the translation destination.
+
+    :param pyramid.request.Request request: a request object
+
+    :returns: A combined translation destination path
+    :rtype: str
+    """
+    package_name, filename = resolve_asset_spec(
+        request.registry['config'].localize.translation.destination
+    )
+
+    if package_name is None:  # absolute filename
+        directory = filename
+    else:
+        __import__(package_name)
+        package = sys.modules[package_name]
+        directory = os.path.join(package_path(package), filename)
+    return directory
+
+
+def dummy_autotranslate(msgid, domain=None, default=None, mapping=None):
+    """
+    Method that simulate autotranslate.
+
+    :param str msgid: Message or message id
+    :param str domain: Translation domain
+    :param str default: Default message
+    :param dict mapping: Mapping dictionary for message variables
+
+    :returns: *translated* string
+    :rtype: str
+    """
+    # Try to return defaults first:
+    tstr = None
+    if default:
+        tstr = default
+    else:
+        tstr = msgid
+
+    if mapping and tstr:
+        def replace(match):
+            whole, param1, param2 = match.groups()
+            return text_type(mapping.get(param1 or param2, whole))
+        tstr = _interp_regex.sub(replace, tstr)
+
+    return tstr

pyramid_localize/views/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""View submodules."""

pyramid_localize/views/catalogue.py

@@ -0,0 +1,225 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Catalogue view."""
+
+
+import sys
+import os
+import time
+import logging
+import subprocess
+
+
+from pyramid.view import view_config
+from pyramid.view import view_defaults
+from pyramid.asset import resolve_asset_spec
+from pyramid.path import package_path
+from pyramid.httpexceptions import HTTPFound
+
+from pyramid_localize.tools import destination_path
+from pyramid_localize.tools import set_localizer
+
+logger = logging.getLogger(__name__)
+
+
+@view_defaults(permission='manage_translations',
+               renderer='pyramid_localize:resources/templates/index.mako')
+class CatalogueView(object):
+
+    """View class for catalogue manipulation actions."""
+
+    def __init__(self, request):
+        """
+        Assign request.
+
+        :param pyramid.request.Request request:
+        """
+        self.request = request
+
+    def _translation_file(self, language, domain, extension='po'):
+        """
+        Create a translation file path.
+
+        :param str language: two-letter language code
+        :param str domain: translation domain name
+        :param str extension: translation file extension (po/mo)
+        """
+        translation_destination = destination_path(self.request)
+        return os.path.abspath(os.path.join(translation_destination, language,
+                                            'LC_MESSAGES',
+                                            domain + '.' + extension))
+
+    def _translation_template_path(self, spec):
+        """
+        Calculate path to translation template file.
+
+        :param str spec: either full path, or package related path
+        """
+        # resolving possible asset spec to path (pyramid way):
+        package_name, filename = resolve_asset_spec(spec)
+        if package_name is None:  # absolute filename
+            return os.path.abspath(filename)
+        else:
+            __import__(package_name)
+            package = sys.modules[package_name]
+            return os.path.abspath(os.path.join(package_path(package),
+                                                filename))
+
+    @view_config(route_name='localize:index')
+    def index(self):
+        """
+        Simple action listing domains, and its files of files with metadata.
+
+        :returns:
+
+            .. code-block:: python
+
+                {
+                    'language': {
+                        'domain1': {
+                            'po': 'modification time',
+                            'pot': 'modification time',
+                            'mo': 'modification time',
+                            },
+                        # more domains
+                    },
+                    # more languages
+                }
+        """
+        translations = {}
+        translation_sources = self.request.registry['config'].localize.translation.sources
+
+        for language in self.request.registry['config'].localize.locales.available:
+            translations[language] = {}
+            for domain in translation_sources:
+                translations[language][domain] = {
+                    'po': None,
+                    'pot': None,
+                    'mo': None
+                }
+                po_file = self._translation_file(language, domain)
+                if os.path.isfile(po_file):
+                    translations[language][domain]['po'] = time.ctime(os.path.getmtime(po_file))
+
+                pot_file = self._translation_template_path(translation_sources[domain])
+                if os.path.isfile(pot_file):
+                    translations[language][domain]['pot'] = time.ctime(os.path.getmtime(pot_file))
+
+                mo_file = self._translation_file(language, domain, 'mo')
+                if os.path.isfile(mo_file):
+                    translations[language][domain]['mo'] = time.ctime(os.path.getmtime(mo_file))
+
+        return {'translations': translations}
+
+    @view_config(route_name='localize:update')
+    def update_catalogue(self):
+        """
+        Update or initialize translation catalogues.
+
+        Create (.po files) for each language/catalogue from their respective
+        translation templates (.pot). This action is performed for every language
+        defined within `localize.locales.available` config key.
+
+        Redirects itself to **localize:index**.
+        """
+        self.index()
+        translation_sources = self.request.registry['config'].localize.translation.sources
+
+        for domain in translation_sources:
+
+            pot_file = self._translation_template_path(translation_sources[domain])
+            if not os.path.isfile(pot_file):
+                logger.critical('pot file for {domain} does not exists!'.format(domain=domain))
+
+            for language in self.request.registry['config'].localize.locales.available:
+                po_file = self._translation_file(language, domain)
+                if os.path.isfile(po_file):
+                    logger.debug(
+                        'po file for {domain}, {language} exists, proceeding with update'.format(
+                            domain=domain, language=language))
+
+                    if subprocess.call([self.request.registry['config'].localize.pybabel,
+                                        'update',
+                                        '-l', language,
+                                        '-i', pot_file,
+                                        '-o', po_file,
+                                        '--previous']):
+                        logger.error('Error while trying to update {po} file!'.format(po=po_file))
+                else:
+                    logger.debug(
+                        '''po file for {domain}, {language} does not exists,
+                         proceeding with initialize'''.format(domain=domain, language=language))
+                    if subprocess.call([self.request.registry['config'].localize.pybabel,
+                                        'init',
+                                        '-l', language,
+                                        '-i', pot_file,
+                                        '-o', po_file]):
+                        logger.error('Error while trying to update {po} file!'.format(po=po_file))
+
+        return HTTPFound(location=self.request.route_url('localize:index'))
+
+    @view_config(route_name='localize:compile')
+    def compile_catalogue(self):
+        """
+        Compile all translation files.
+
+        For every language defined compile .po files into into .mo file that's used by gettext.
+
+        Redirects to **localize:index**.
+        """
+        self.index()
+        translation_sources = self.request.registry['config'].localize.translation.sources
+
+        for domain in translation_sources:
+
+            for language in self.request.registry['config'].localize.locales.available:
+                po_file = self._translation_file(language, domain)
+                mo_file = self._translation_file(language, domain, 'mo')
+                if os.path.isfile(po_file):
+                    logger.debug(
+                        '''po file for {domain}, {language} exists,
+                        proceeding with compilation'''.format(domain=domain, language=language))
+                    if subprocess.call([self.request.registry['config'].localize.pybabel,
+                                        'compile',
+                                        '-l', language,
+                                        '-i', po_file,
+                                        '-o', mo_file,
+                                        '--use-fuzzy']):
+                        logger.error('Error while trying to compile {po} file!'.format(po=po_file))
+
+        return HTTPFound(location=self.request.route_url('localize:index'))
+
+    @view_config(route_name='localize:reload', xhr='True', renderer='json')
+    @view_config(route_name='localize:reload')
+    def reload_catalogue(self):
+        """
+        Reload translation catalogue for application it's run in.
+
+        .. note::
+
+            To see how is this happening, you might want to see
+            :func:`~pyramid_localize.tools.set_localizer`
+
+        :returns:
+
+            Only for xhr requests:
+
+            .. code-block:: python
+
+                {
+                    'status': True,
+                    'msg': 'Localizators has been reloaded' # translated
+                }
+
+            non xhr requests: Redirects to **localize:index**.
+
+
+        """
+        set_localizer(self.request, True)
+
+        if self.request.is_xhr:
+            return {'status': True, 'msg': self.request._('Localizators has been reloaded')}
+
+        return HTTPFound(location=self.request.route_url('localize:index'))

tests/__init__.py

@@ -0,0 +1 @@
+"""Test suite."""

tests/conftest.py

@@ -0,0 +1,58 @@
+"""Test suite main conftest."""
+import pytest
+from mock import Mock
+from pyramid.decorator import reify
+from pyramid.request import Request
+from pyramid import testing
+
+
+@pytest.fixture
+def web_request():
+    """Mocked web request for views testing."""
+    from pyramid_localize.request import LocalizeRequestMixin
+    from pyramid_localize.request import database_locales
+    from pyramid_localize.request import locale_id
+    from pyramid_localize.request import locales
+
+    class TestRequest(LocalizeRequestMixin, Request):
+
+        @reify
+        def _database_locales(self):
+            return database_locales(self)
+
+        @reify
+        def locale_id(self):
+            return locale_id(self)
+
+        def locales(self, *args, **kwargs):
+            return locales(self, *args, **kwargs)
+
+    request = TestRequest({})
+    config = Mock()
+    config.configure_mock(
+        **{'localize.locales.available': ['en', 'pl', 'de', 'cz']}
+    )
+    configurator = testing.setUp()
+    request.registry = configurator.registry
+    request.registry['config'] = config
+
+    return request
+
+
+@pytest.fixture
+def locale_negotiator_request():
+    """Request for locale_negotiator tests."""
+    request = Mock()
+    mock_configuration = {
+        'cookies': {'_LOCALE_': 'cz'},
+        '_LOCALE_': 'fr',
+        'accept_language.best_match.return_value': 'de',
+        'path': '/pl/page'}
+    request.configure_mock(**mock_configuration)
+    config = Mock()
+    config.configure_mock(**{
+        'localize.locales.available': ['en', 'pl', 'de', 'cz', 'fr'],
+        'localize.locales.default': 'en'
+    })
+    request.registry = {'config': config}
+    return request

tests/test_negotiator.py

@@ -0,0 +1,55 @@
+"""Locale negotiator related tests."""
+from pyramid_localize.negotiator import locale_negotiator
+
+
+def test_negotiate_attr(locale_negotiator_request):
+    """Locale_negotiator - negotiate locale from request attribute."""
+    locale = locale_negotiator(locale_negotiator_request)
+
+    assert locale == 'fr'
+
+
+def test_negotiate_path(locale_negotiator_request):
+    """Locale_negotiator - negotiate locale from path."""
+    locale_negotiator_request._LOCALE_ = None
+    locale = locale_negotiator(locale_negotiator_request)
+
+    assert locale == 'pl'
+
+
+def test_negotiate_cookie(locale_negotiator_request):
+    """locale_negotiator - negotiate locale from cookie."""
+    locale_negotiator_request._LOCALE_ = None
+    locale_negotiator_request.path = '/page'
+    locale = locale_negotiator(locale_negotiator_request)
+
+    assert locale == 'cz'
+
+
+def test_negotiate_headers(locale_negotiator_request):
+    """
+    Locale_negotiator:header.
+
+    Negotiate locale from a header.
+    """
+    locale_negotiator_request._LOCALE_ = None
+    locale_negotiator_request.path = '/page'
+    locale_negotiator_request.cookies = {}
+    locale = locale_negotiator(locale_negotiator_request)
+
+    assert locale == 'de'
+
+
+def test_negotiate_default(locale_negotiator_request):
+    """
+    Locale_negotiator:default.
+
+    Other ways fail, return default locale.
+    """
+    locale_negotiator_request.path = '/page'
+    locale_negotiator_request._LOCALE_ = None
+    locale_negotiator_request.cookies = {}
+    locale_negotiator_request.accept_language = None
+    locale = locale_negotiator(locale_negotiator_request)
+
+    assert locale == 'en'

tests/test_predicates.py

@@ -0,0 +1,23 @@
+"""Route predicate related tests."""
+
+import pytest
+
+from pyramid_localize.routing.predicates import language
+
+
+@pytest.mark.parametrize('match_info, matched', (
+    (
+        {'match': {'_LOCALE_': 'en'}},
+        True
+    ), (
+        {'match': {'_LOCALE_': 'fr'}},
+        False
+    ), (
+        {'match': {}},
+        False
+    )
+))
+def test_predicate(web_request, match_info, matched):
+    """Test matches according to web_request config."""
+    predicate = language('_LOCALE_')
+    assert predicate(match_info, web_request) == matched

tests/test_request.py

@@ -0,0 +1,89 @@
+"""Test request related code."""
+
+import pytest
+
+import transaction
+from pyramid.compat import text_type
+import pyramid_basemodel
+from sqlalchemy import create_engine
+from sqlalchemy.orm import scoped_session, sessionmaker
+from sqlalchemy.pool import NullPool
+from zope.sqlalchemy import ZopeTransactionExtension
+
+from pyramid_localize.models import Language
+
+
+@pytest.mark.parametrize('kwargs, expected_locale', (
+    (  # not filled __LOCALE__ , should return default one
+        {'slug': 'some-slug'},
+        'en'
+    ),
+    (  # filled __LOCALE__ within available, returned exact that
+        {
+            'slug': 'some-slug',
+            '__LOCALE__': 'pl'
+        },
+        'pl'
+    ),
+    (  # filled __LOCALE__ within one not in available, returned default one
+        {
+            'slug': 'some-slug',
+            '__LOCALE__': 'fr'
+        },
+        'en'
+    ),
+))
+def test_request(web_request, kwargs, expected_locale):
+    """Test whether route-parameters gets filled correctly."""
+    route_params = web_request.default_locale(**kwargs)
+    assert '__LOCALE__' in route_params
+    assert route_params['__LOCALE__'] in web_request.registry['config'].localize.locales.available
+    assert route_params['__LOCALE__'] == expected_locale
+
+
+@pytest.fixture
+def db_session(request):
+    """SQLAlchemy session."""
+    from pyramid_localize.models import Base
+
+    engine = create_engine('sqlite:///fullauth.sqlite', echo=False, poolclass=NullPool)
+    pyramid_basemodel.Session = scoped_session(sessionmaker(extension=ZopeTransactionExtension()))
+    pyramid_basemodel.bind_engine(engine, pyramid_basemodel.Session, should_drop=True)
+
+    def destroy():
+        transaction.commit()
+        Base.metadata.drop_all(engine)
+
+    request.addfinalizer(destroy)
+
+    return pyramid_basemodel.Session
+
+
+@pytest.fixture
+def db_locales(db_session):
+    """Add Languages to db_session."""
+    for locale in ['pl', 'cz', 'fr']:
+        locale_object = Language(name=text_type(locale),
+                                 native_name=text_type(locale),
+                                 language_code=text_type(locale))
+        db_session.add(locale_object)
+    transaction.commit()
+
+
+def test_locale_id(db_locales, web_request):
+    """Test for creating, and getting loacel id."""
+    assert isinstance(web_request.locale_id, int)
+
+
+def test_locales(db_locales, web_request):
+    """test return locales list."""
+    assert len(web_request.locales()) == 3
+
+
+def test_locales_config(db_locales, web_request):
+    """
+    test return locales list limited by config.
+
+    There's a new locale, so it should create new Language entry.
+    """
+    assert len(web_request.locales(True)) == 4