1 from django import http

     2 from django.utils.translation import check_for_language, activate, to_locale, get_language

     3 from django.utils.text import javascript_quote

     4 from django.conf import settings

     5 import os

     6 import gettext as gettext_module

     7 

     8 def set_language(request):

     9     """

    10     Redirect to a given url while setting the chosen language in the

    11     session or cookie. The url and the language code need to be

    12     specified in the request parameters.

    13 

    14     Since this view changes how the user will see the rest of the site, it must

    15     only be accessed as a POST request. If called as a GET request, it will

    16     redirect to the page in the request (the 'next' parameter) without changing

    17     any state.

    18     """

    19     next = request.REQUEST.get('next', None)

    20     if not next:

    21         next = request.META.get('HTTP_REFERER', None)

    22     if not next:

    23         next = '/'

    24     response = http.HttpResponseRedirect(next)

    25     if request.method == 'POST':

    26         lang_code = request.POST.get('language', None)

    27         if lang_code and check_for_language(lang_code):

    28             if hasattr(request, 'session'):

    29                 request.session['django_language'] = lang_code

    30             else:

    31                 response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)

    32     return response

    33 

    34 NullSource = """

    35 /* gettext identity library */

    36 

    37 function gettext(msgid) { return msgid; }

    38 function ngettext(singular, plural, count) { return (count == 1) ? singular : plural; }

    39 function gettext_noop(msgid) { return msgid; }

    40 """

    41 

    42 LibHead = """

    43 /* gettext library */

    44 

    45 var catalog = new Array();

    46 """

    47 

    48 LibFoot = """

    49 

    50 function gettext(msgid) {

    51   var value = catalog[msgid];

    52   if (typeof(value) == 'undefined') {

    53     return msgid;

    54   } else {

    55     return (typeof(value) == 'string') ? value : value[0];

    56   }

    57 }

    58 

    59 function ngettext(singular, plural, count) {

    60   value = catalog[singular];

    61   if (typeof(value) == 'undefined') {

    62     return (count == 1) ? singular : plural;

    63   } else {

    64     return value[pluralidx(count)];

    65   }

    66 }

    67 

    68 function gettext_noop(msgid) { return msgid; }

    69 """

    70 

    71 SimplePlural = """

    72 function pluralidx(count) { return (count == 1) ? 0 : 1; }

    73 """

    74 

    75 InterPolate = r"""

    76 function interpolate(fmt, obj, named) {

    77   if (named) {

    78     return fmt.replace(/%\(\w+\)s/g, function(match){return String(obj[match.slice(2,-2)])});

    79   } else {

    80     return fmt.replace(/%s/g, function(match){return String(obj.shift())});

    81   }

    82 }

    83 """

    84 

    85 PluralIdx = r"""

    86 function pluralidx(n) {

    87   var v=%s;

    88   if (typeof(v) == 'boolean') {

    89     return v ? 1 : 0;

    90   } else {

    91     return v;

    92   }

    93 }

    94 """

    95 

    96 def null_javascript_catalog(request, domain=None, packages=None):

    97     """

    98     Returns "identity" versions of the JavaScript i18n functions -- i.e.,

    99     versions that don't actually do anything.

   100     """

   101     return http.HttpResponse(NullSource + InterPolate, 'text/javascript')

   102 

   103 def javascript_catalog(request, domain='djangojs', packages=None):

   104     """

   105     Returns the selected language catalog as a javascript library.

   106 

   107     Receives the list of packages to check for translations in the

   108     packages parameter either from an infodict or as a +-delimited

   109     string from the request. Default is 'django.conf'.

   110 

   111     Additionally you can override the gettext domain for this view,

   112     but usually you don't want to do that, as JavaScript messages

   113     go to the djangojs domain. But this might be needed if you

   114     deliver your JavaScript source from Django templates.

   115     """

   116     if request.GET:

   117         if 'language' in request.GET:

   118             if check_for_language(request.GET['language']):

   119                 activate(request.GET['language'])

   120     if packages is None:

   121         packages = ['django.conf']

   122     if type(packages) in (str, unicode):

   123         packages = packages.split('+')

   124     packages = [p for p in packages if p == 'django.conf' or p in settings.INSTALLED_APPS]

   125     default_locale = to_locale(settings.LANGUAGE_CODE)

   126     locale = to_locale(get_language())

   127     t = {}

   128     paths = []

   129     # first load all english languages files for defaults

   130     for package in packages:

   131         p = __import__(package, {}, {}, [''])

   132         path = os.path.join(os.path.dirname(p.__file__), 'locale')

   133         paths.append(path)

   134         try:

   135             catalog = gettext_module.translation(domain, path, ['en'])

   136             t.update(catalog._catalog)

   137         except IOError:

   138             # 'en' catalog was missing. This is harmless.

   139             pass

   140     # next load the settings.LANGUAGE_CODE translations if it isn't english

   141     if default_locale != 'en':

   142         for path in paths:

   143             try:

   144                 catalog = gettext_module.translation(domain, path, [default_locale])

   145             except IOError:

   146                 catalog = None

   147             if catalog is not None:

   148                 t.update(catalog._catalog)

   149     # last load the currently selected language, if it isn't identical to the default.

   150     if locale != default_locale:

   151         for path in paths:

   152             try:

   153                 catalog = gettext_module.translation(domain, path, [locale])

   154             except IOError:

   155                 catalog = None

   156             if catalog is not None:

   157                 t.update(catalog._catalog)

   158     src = [LibHead]

   159     plural = None

   160     if '' in t:

   161         for l in t[''].split('\n'):

   162             if l.startswith('Plural-Forms:'):

   163                 plural = l.split(':',1)[1].strip()

   164     if plural is not None:

   165         # this should actually be a compiled function of a typical plural-form:

   166         # Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;

   167         plural = [el.strip() for el in plural.split(';') if el.strip().startswith('plural=')][0].split('=',1)[1]

   168         src.append(PluralIdx % plural)

   169     else:

   170         src.append(SimplePlural)

   171     csrc = []

   172     pdict = {}

   173     for k, v in t.items():

   174         if k == '':

   175             continue

   176         if type(k) in (str, unicode):

   177             csrc.append("catalog['%s'] = '%s';\n" % (javascript_quote(k), javascript_quote(v)))

   178         elif type(k) == tuple:

   179             if k[0] not in pdict:

   180                 pdict[k[0]] = k[1]

   181             else:

   182                 pdict[k[0]] = max(k[1], pdict[k[0]])

   183             csrc.append("catalog['%s'][%d] = '%s';\n" % (javascript_quote(k[0]), k[1], javascript_quote(v)))

   184         else:

   185             raise TypeError, k

   186     csrc.sort()

   187     for k,v in pdict.items():

   188         src.append("catalog['%s'] = [%s];\n" % (javascript_quote(k), ','.join(["''"]*(v+1))))

   189     src.extend(csrc)

   190     src.append(LibFoot)

   191     src.append(InterPolate)

   192     src = ''.join(src)

   193     return http.HttpResponse(src, 'text/javascript')