def load_strings_for_request(lang_code, cfg, accept_language_hdr):
header_locales = accept_language_hdr.split(',')
for l in header_locales:
lang_tag = l.split(';', 1)[0] # drop weight, if any
lang = l.split('-', 1)[0] # en-GB -> en
lang_tag_matches_config = (lang == lang_code
or lang_tag in cfg.accept_language
or lang in cfg.accept_language)
if not lang_tag_matches_config:
continue
# Do we have strings for the full tag?
strings = chstrings.get_localized_strings(cfg, lang_tag)
if strings:
return lang_tag, strings
# Maybe just the lang?
strings = chstrings.get_localized_strings(cfg, lang)
if strings:
return lang, strings
fallback = lang_code
if cfg.accept_language:
fallback = cfg.accept_language[-1]
return fallback, chstrings.get_localized_strings(cfg, fallback)
def load_strings_for_request(lang_code, cfg, accept_language_hdr):
header_locales = accept_language_hdr.split(',')
for l in header_locales:
lang_tag = l.split(';', 1)[0] # drop weight, if any
lang = l.split('-', 1)[0] # en-GB -> en
lang_tag_matches_config = (
lang == lang_code or
lang_tag in cfg.accept_language or
lang in cfg.accept_language
)
if not lang_tag_matches_config:
continue
# Do we have strings for the full tag?
strings = chstrings.get_localized_strings(cfg, lang_tag)
if strings:
return lang_tag, strings
# Maybe just the lang?
strings = chstrings.get_localized_strings(cfg, lang)
if strings:
return lang, strings
fallback = lang_code
if cfg.accept_language:
fallback = cfg.accept_language[-1]
return fallback, chstrings.get_localized_strings(cfg, fallback)
def wrapper(lang_code = '', *args, **kwds):
accept_language = parse_accept_language_header(
flask.request.headers.get('Accept-Language', ''))
lang_code = lang_code.lower()
if not lang_code:
return redirect_to_lang_code(
find_default_lang_code_for_request(accept_language))
flask.g._lang_code = lang_code
if lang_code not in config.LANG_CODES_TO_LANG_NAMES:
return redirect_to_lang_code('en')
flask.g._cfg = config.get_localized_config(lang_code, api = False)
if flask.current_app.debug and 'locale' in flask.request.args:
flask.g._strings = chstrings.get_localized_strings(
flask.g._cfg, flask.request.args['locale'])
else:
flask.g._lang_tag, flask.g._strings = load_strings_for_request(
lang_code, flask.g._cfg, accept_language)
if not flask.g._strings:
# Shouldn't really happen, this means we have a misconfigured
# language that has a config entry but no locales in the translation
# files.
return redirect_to_lang_code('en')
return handler(lang_code, *args, **kwds)
def get_localized_config(lang_code=None):
if lang_code is None:
lang_code = os.getenv('CH_LANG')
cfg = Config(lang_code=lang_code,
**dict(global_config, **lang_code_to_config[lang_code]))
cfg.strings = chstrings.get_localized_strings(cfg, lang_code)
cfg.lang_code_to_config = lang_code_to_config
return cfg
def get_localized_config(lang_code = None):
if lang_code is None:
lang_code = os.getenv('CH_LANG')
cfg = Config(lang_code = lang_code,
**dict(global_config, **lang_code_to_config[lang_code]))
cfg.strings = chstrings.get_localized_strings(cfg, lang_code)
cfg.lang_code_to_config = lang_code_to_config
return cfg
def test(self):
# We just want to see if this will blow up. Use the fallback
# lang_tag across all tests.
lang_tag = cfg.lang_code
if cfg.accept_language:
lang_tag = cfg.accept_language[-1]
self.assertNotEqual({},
chstrings.get_localized_strings(cfg, lang_tag))
def get_localized_config(lang_code=None):
if lang_code is None:
lang_code = os.getenv('CH_LANG')
lang_config = _LANG_CODE_TO_CONFIG[lang_code]
cfg = Config(lang_code=lang_code,
**reduce(_inherit,
[_GLOBAL_CONFIG, _BASE_LANG_CONFIG, lang_config]))
cfg.strings = chstrings.get_localized_strings(cfg, lang_code)
cfg.lang_codes_to_lang_names = LANG_CODES_TO_LANG_NAMES
return cfg
def load_strings_for_request(lang_code, cfg, accept_language):
for al in accept_language:
lang_tag_matches_config = (
al.base_tag == lang_code or
al.lang_tag in cfg.accept_language or
al.base_tag in cfg.accept_language
)
if not lang_tag_matches_config:
continue
# Do we have strings for the full tag?
strings = chstrings.get_localized_strings(cfg, al.lang_tag)
if strings:
return al.lang_tag, strings
# Maybe just the base tag?
strings = chstrings.get_localized_strings(cfg, al.base_tag)
if strings:
return al.base_tag, strings
fallback = lang_code
if cfg.accept_language:
fallback = cfg.accept_language[-1]
return fallback, chstrings.get_localized_strings(cfg, fallback)
def test_fallback_lang_tag(self):
gcfg = config.get_global_config()
cfg = config.get_localized_config(gcfg.fallback_lang_tag, api=False)
fallback_strings = chstrings.get_localized_strings(
cfg, gcfg.fallback_lang_tag)
original = chstrings._load_strings_for_lang_tag(gcfg.fallback_lang_tag)
with mock.patch('chstrings._load_strings_for_lang_tag') as m:
# Simulate an incomplete strings file.
def _load_strings_side_effect(lang_tag):
if lang_tag == 'fake':
return {'tooltitle': 'Test Citation Hunt'}
elif lang_tag == gcfg.fallback_lang_tag:
return original
raise ValueError
m.side_effect = _load_strings_side_effect
# The incomplete strings must have been merged with the fallback
# ones.
strings = chstrings.get_localized_strings(cfg, 'fake')
self.assertEqual('Test Citation Hunt', strings['tooltitle'])
self.assertEqual(fallback_strings['instructions_goal'],
strings['instructions_goal'])
def page_not_found(e):
if hasattr(flask.g, '_cfg'):
cfg = flask.g._cfg
else:
cfg = config.get_localized_config('en')
if hasattr(flask.g, '_strings'):
lang_tag = flask.g._lang_tag
strings = flask.g._strings
else:
lang_tag = 'en'
strings = chstrings.get_localized_strings(cfg, 'en')
return flask.render_template(
'404.html', config = cfg,
lang_tag = lang_tag,
lang_dir = cfg.lang_dir, strings = strings), 404
def page_not_found(e):
if hasattr(flask.g, '_cfg'):
cfg = flask.g._cfg
else:
cfg = config.get_localized_config('en')
if hasattr(flask.g, '_strings'):
lang_tag = flask.g._lang_tag
strings = flask.g._strings
else:
lang_tag = 'en'
strings = chstrings.get_localized_strings(cfg, 'en')
return flask.render_template('404.html',
config=cfg,
lang_tag=lang_tag,
lang_dir=cfg.lang_dir,
strings=strings), 404
def wrapper(lang_code = '', *args, **kwds):
accept_language_hdr = flask.request.headers.get('Accept-Language', '')
if not lang_code:
return redirect_to_lang_code(
find_default_lang_code_for_request(accept_language_hdr))
flask.g._lang_code = lang_code
if lang_code not in config.LANG_CODES_TO_LANG_NAMES:
return redirect_to_lang_code('en')
flask.g._cfg = config.get_localized_config(lang_code)
if flask.current_app.debug and 'locale' in flask.request.args:
flask.g._strings = chstrings.get_localized_strings(
flask.g._cfg, flask.request.args['locale'])
else:
flask.g._lang_tag, flask.g._strings = load_strings_for_request(
lang_code, flask.g._cfg, accept_language_hdr)
if not flask.g._strings:
# Shouldn't really happen, this means we have a misconfigured
# language that has a config entry but no locales in the translation
# files.
return redirect_to_lang_code('en')
return handler(lang_code, *args, **kwds)
def test_missing_lang_tag_has_no_fallback(self):
# We must only apply the fallback strings if there is an incomplete
# strings file (test_fallback_lang_tag exercises that behavior).
# If the file does not exist at all, we must return {} rather than just
# the fallback strings.
self.assertEqual(chstrings.get_localized_strings(cfg, 'fake'), {})