def test_po_with_multiline_obsolete_message(self):
catalog = Catalog()
catalog.add(u'foo', u'Voh', locations=[('main.py', 1)])
msgid = r"""Here's a message that covers
multiple lines, and should still be handled
correctly.
"""
msgstr = r"""Here's a message that covers
multiple lines, and should still be handled
correctly.
"""
catalog.obsolete[msgid] = Message(msgid, msgstr,
locations=[('utils.py', 3)])
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=True)
self.assertEqual(b'''#: main.py:1
msgid "foo"
msgstr "Voh"
#~ msgid ""
#~ "Here's a message that covers\\n"
#~ "multiple lines, and should still be handled\\n"
#~ "correctly.\\n"
#~ msgstr ""
#~ "Here's a message that covers\\n"
#~ "multiple lines, and should still be handled\\n"
#~ "correctly.\\n"''', buf.getvalue().strip())
def test_with_context(self):
buf = BytesIO(b'''# Some string in the menu
#: main.py:1
msgctxt "Menu"
msgid "foo"
msgstr "Voh"
# Another string in the menu
#: main.py:2
msgctxt "Menu"
msgid "bar"
msgstr "Bahr"
''')
catalog = pofile.read_po(buf, ignore_obsolete=True)
self.assertEqual(2, len(catalog))
message = catalog.get('foo', context='Menu')
self.assertEqual('Menu', message.context)
message = catalog.get('bar', context='Menu')
self.assertEqual('Menu', message.context)
# And verify it pass through write_po
out_buf = BytesIO()
pofile.write_po(out_buf, catalog, omit_header=True)
assert out_buf.getvalue().strip() == buf.getvalue().strip(), \
out_buf.getvalue()
def test_no_wrap_and_width_behaviour_on_comments(self):
catalog = Catalog()
catalog.add("Pretty dam long message id, which must really be big "
"to test this wrap behaviour, if not it won't work.",
locations=[("fake.py", n) for n in range(1, 30)])
buf = BytesIO()
pofile.write_po(buf, catalog, width=None, omit_header=True)
self.assertEqual(b"""\
#: fake.py:1 fake.py:2 fake.py:3 fake.py:4 fake.py:5 fake.py:6 fake.py:7
#: fake.py:8 fake.py:9 fake.py:10 fake.py:11 fake.py:12 fake.py:13 fake.py:14
#: fake.py:15 fake.py:16 fake.py:17 fake.py:18 fake.py:19 fake.py:20 fake.py:21
#: fake.py:22 fake.py:23 fake.py:24 fake.py:25 fake.py:26 fake.py:27 fake.py:28
#: fake.py:29
msgid "pretty dam long message id, which must really be big to test this wrap behaviour, if not it won't work."
msgstr ""
""", buf.getvalue().lower())
buf = BytesIO()
pofile.write_po(buf, catalog, width=100, omit_header=True)
self.assertEqual(b"""\
#: fake.py:1 fake.py:2 fake.py:3 fake.py:4 fake.py:5 fake.py:6 fake.py:7 fake.py:8 fake.py:9 fake.py:10
#: fake.py:11 fake.py:12 fake.py:13 fake.py:14 fake.py:15 fake.py:16 fake.py:17 fake.py:18 fake.py:19
#: fake.py:20 fake.py:21 fake.py:22 fake.py:23 fake.py:24 fake.py:25 fake.py:26 fake.py:27 fake.py:28
#: fake.py:29
msgid ""
"pretty dam long message id, which must really be big to test this wrap behaviour, if not it won't"
" work."
msgstr ""
""", buf.getvalue().lower())
def test_sorted_po_context(self):
catalog = Catalog()
catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'),
locations=[('main.py', 1)],
context='there')
catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'),
locations=[('main.py', 1)])
catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'),
locations=[('main.py', 1)],
context='here')
buf = BytesIO()
pofile.write_po(buf, catalog, sort_output=True)
value = buf.getvalue().strip()
# We expect the foo without ctx, followed by "here" foo and "there" foo
assert b'''\
#: main.py:1
msgid "foo"
msgid_plural "foos"
msgstr[0] "Voh"
msgstr[1] "Voeh"
#: main.py:1
msgctxt "here"
msgid "foo"
msgid_plural "foos"
msgstr[0] "Voh"
msgstr[1] "Voeh"
#: main.py:1
msgctxt "there"
msgid "foo"
msgid_plural "foos"
msgstr[0] "Voh"
msgstr[1] "Voeh"''' in value
def test_sorting(self):
# Ensure the header is sorted to the first entry so that its charset
# can be applied to all subsequent messages by GNUTranslations
# (ensuring all messages are safely converted to unicode)
catalog = Catalog(locale='en_US')
catalog.add(u'', '''\
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n''')
catalog.add(u'foo', 'Voh')
catalog.add((u'There is', u'There are'), (u'Es gibt', u'Es gibt'))
catalog.add(u'Fizz', '')
catalog.add(('Fuzz', 'Fuzzes'), ('', ''))
buf = BytesIO()
mofile.write_mo(buf, catalog)
buf.seek(0)
translations = Translations(fp=buf)
self.assertEqual(u'Voh', translations.ugettext('foo'))
assert isinstance(translations.ugettext('foo'), text_type)
self.assertEqual(u'Es gibt', translations.ungettext('There is', 'There are', 1))
assert isinstance(translations.ungettext('There is', 'There are', 1), text_type)
self.assertEqual(u'Fizz', translations.ugettext('Fizz'))
assert isinstance(translations.ugettext('Fizz'), text_type)
self.assertEqual(u'Fuzz', translations.ugettext('Fuzz'))
assert isinstance(translations.ugettext('Fuzz'), text_type)
self.assertEqual(u'Fuzzes', translations.ugettext('Fuzzes'))
assert isinstance(translations.ugettext('Fuzzes'), text_type)
def test_unknown_language_write():
catalog = Catalog(locale='sr_SP')
assert catalog.locale_identifier == 'sr_SP'
assert not catalog.locale
buf = BytesIO()
pofile.write_po(buf, catalog)
assert 'sr_SP' in buf.getvalue().decode()
def test_write_po_file_with_specified_charset(self):
catalog = Catalog(charset='iso-8859-1')
catalog.add('foo', u'äöü', locations=[('main.py', 1)])
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=False)
po_file = buf.getvalue().strip()
assert b'"Content-Type: text/plain; charset=iso-8859-1\\n"' in po_file
assert u'msgstr "äöü"'.encode('iso-8859-1') in po_file
def test_file_sorted_po(self):
catalog = Catalog()
catalog.add(u'bar', locations=[('utils.py', 3)])
catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'), locations=[('main.py', 1)])
buf = BytesIO()
pofile.write_po(buf, catalog, sort_by_file=True)
value = buf.getvalue().strip()
assert value.find(b'main.py') < value.find(b'utils.py')
def test_join_locations(self):
catalog = Catalog()
catalog.add(u'foo', locations=[('main.py', 1)])
catalog.add(u'foo', locations=[('utils.py', 3)])
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=True)
self.assertEqual(b'''#: main.py:1 utils.py:3
msgid "foo"
msgstr ""''', buf.getvalue().strip())
def test_duplicate_comments(self):
catalog = Catalog()
catalog.add(u'foo', auto_comments=['A comment'])
catalog.add(u'foo', auto_comments=['A comment'])
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=True)
self.assertEqual(b'''#. A comment
msgid "foo"
msgstr ""''', buf.getvalue().strip())
def test_no_include_lineno(self):
catalog = Catalog()
catalog.add(u'foo', locations=[('main.py', 1)])
catalog.add(u'foo', locations=[('utils.py', 3)])
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=True, include_lineno=False)
self.assertEqual(b'''#: main.py utils.py
msgid "foo"
msgstr ""''', buf.getvalue().strip())
def test_po_with_previous_msgid(self):
catalog = Catalog()
catalog.add(u'foo', u'Voh', locations=[('main.py', 1)],
previous_id=u'fo')
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=True, include_previous=True)
self.assertEqual(b'''#: main.py:1
#| msgid "fo"
msgid "foo"
msgstr "Voh"''', buf.getvalue().strip())
def test_po_with_obsolete_message_ignored(self):
catalog = Catalog()
catalog.add(u'foo', u'Voh', locations=[('main.py', 1)])
catalog.obsolete['bar'] = Message(u'bar', u'Bahr',
locations=[('utils.py', 3)],
user_comments=['User comment'])
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=True, ignore_obsolete=True)
self.assertEqual(b'''#: main.py:1
msgid "foo"
msgstr "Voh"''', buf.getvalue().strip())
def test_po_with_previous_msgid_plural(self):
catalog = Catalog()
catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
locations=[('main.py', 1)], previous_id=('fo', 'fos'))
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=True, include_previous=True)
self.assertEqual(b'''#: main.py:1
#| msgid "fo"
#| msgid_plural "fos"
msgid "foo"
msgid_plural "foos"
msgstr[0] "Voh"
msgstr[1] "Voeh"''', buf.getvalue().strip())
def test_wrap_locations_with_hyphens(self):
catalog = Catalog()
catalog.add(u'foo', locations=[
('doupy/templates/base/navmenu.inc.html.py', 60)
])
catalog.add(u'foo', locations=[
('doupy/templates/job-offers/helpers.html', 22)
])
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=True)
self.assertEqual(b'''#: doupy/templates/base/navmenu.inc.html.py:60
#: doupy/templates/job-offers/helpers.html:22
msgid "foo"
msgstr ""''', buf.getvalue().strip())
def test_file_with_no_lineno(self):
catalog = Catalog()
catalog.add(u'bar', locations=[('utils.py', None)],
user_comments=['Comment About `bar` with',
'multiple lines.'])
buf = BytesIO()
pofile.write_po(buf, catalog, sort_output=True)
value = buf.getvalue().strip()
assert b'''\
# Comment About `bar` with
# multiple lines.
#: utils.py
msgid "bar"
msgstr ""''' in value
def test_wrap_long_lines_with_long_word(self):
text = """Here's some text that
includesareallylongwordthatmightbutshouldnt throw us into an infinite loop
"""
catalog = Catalog()
catalog.add(text, locations=[('main.py', 1)])
buf = BytesIO()
pofile.write_po(buf, catalog, no_location=True, omit_header=True,
width=32)
self.assertEqual(b'''msgid ""
"Here's some text that\\n"
"includesareallylongwordthatmightbutshouldnt"
" throw us into an infinite "
"loop\\n"
msgstr ""''', buf.getvalue().strip())
def test_wrap_long_lines_in_header(self):
"""
Verify that long lines in the header comment are wrapped correctly.
"""
catalog = Catalog(project='AReallyReallyLongNameForAProject',
revision_date=datetime(2007, 4, 1))
buf = BytesIO()
pofile.write_po(buf, catalog)
self.assertEqual(b'''\
# Translations template for AReallyReallyLongNameForAProject.
# Copyright (C) 2007 ORGANIZATION
# This file is distributed under the same license as the
# AReallyReallyLongNameForAProject project.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2007.
#
#, fuzzy''', b'\n'.join(buf.getvalue().splitlines()[:7]))
def test_pot_with_translator_comments(self):
catalog = Catalog()
catalog.add(u'foo', locations=[('main.py', 1)],
auto_comments=['Comment About `foo`'])
catalog.add(u'bar', locations=[('utils.py', 3)],
user_comments=['Comment About `bar` with',
'multiple lines.'])
buf = BytesIO()
pofile.write_po(buf, catalog, omit_header=True)
self.assertEqual(b'''#. Comment About `foo`
#: main.py:1
msgid "foo"
msgstr ""
# Comment About `bar` with
# multiple lines.
#: utils.py:3
msgid "bar"
msgstr ""''', buf.getvalue().strip())
def test_wrap_long_lines(self):
text = """Here's some text where
white space and line breaks matter, and should
not be removed
"""
catalog = Catalog()
catalog.add(text, locations=[('main.py', 1)])
buf = BytesIO()
pofile.write_po(buf, catalog, no_location=True, omit_header=True,
width=42)
self.assertEqual(b'''msgid ""
"Here's some text where\\n"
"white space and line breaks matter, and"
" should\\n"
"\\n"
"not be removed\\n"
"\\n"
msgstr ""''', buf.getvalue().strip())
def setUp(self):
# Use a locale which won't fail to run the tests
os.environ['LANG'] = 'en_US.UTF-8'
messages1 = [
('foo', {'string': 'Voh'}),
('foo', {'string': 'VohCTX', 'context': 'foo'}),
(('foo1', 'foos1'), {'string': ('Voh1', 'Vohs1')}),
(('foo1', 'foos1'), {'string': ('VohCTX1', 'VohsCTX1'), 'context': 'foo'}),
]
messages2 = [
('foo', {'string': 'VohD'}),
('foo', {'string': 'VohCTXD', 'context': 'foo'}),
(('foo1', 'foos1'), {'string': ('VohD1', 'VohsD1')}),
(('foo1', 'foos1'), {'string': ('VohCTXD1', 'VohsCTXD1'), 'context': 'foo'}),
]
catalog1 = Catalog(locale='en_GB', domain='messages')
catalog2 = Catalog(locale='en_GB', domain='messages1')
for ids, kwargs in messages1:
catalog1.add(ids, **kwargs)
for ids, kwargs in messages2:
catalog2.add(ids, **kwargs)
catalog1_fp = BytesIO()
catalog2_fp = BytesIO()
write_mo(catalog1_fp, catalog1)
catalog1_fp.seek(0)
write_mo(catalog2_fp, catalog2)
catalog2_fp.seek(0)
translations1 = support.Translations(catalog1_fp)
translations2 = support.Translations(catalog2_fp, domain='messages1')
self.translations = translations1.add(translations2, merge=False)
def setUp(self):
# Use a locale which won't fail to run the tests
os.environ["LANG"] = "en_US.UTF-8"
messages1 = [
("foo", {"string": "Voh"}),
("foo", {"string": "VohCTX", "context": "foo"}),
(("foo1", "foos1"), {"string": ("Voh1", "Vohs1")}),
(("foo1", "foos1"), {"string": ("VohCTX1", "VohsCTX1"), "context": "foo"}),
]
messages2 = [
("foo", {"string": "VohD"}),
("foo", {"string": "VohCTXD", "context": "foo"}),
(("foo1", "foos1"), {"string": ("VohD1", "VohsD1")}),
(("foo1", "foos1"), {"string": ("VohCTXD1", "VohsCTXD1"), "context": "foo"}),
]
catalog1 = Catalog(locale="en_GB", domain="messages")
catalog2 = Catalog(locale="en_GB", domain="messages1")
for ids, kwargs in messages1:
catalog1.add(ids, **kwargs)
for ids, kwargs in messages2:
catalog2.add(ids, **kwargs)
catalog1_fp = BytesIO()
catalog2_fp = BytesIO()
write_mo(catalog1_fp, catalog1)
catalog1_fp.seek(0)
write_mo(catalog2_fp, catalog2)
catalog2_fp.seek(0)
translations1 = support.Translations(catalog1_fp)
translations2 = support.Translations(catalog2_fp, domain="messages1")
self.translations = translations1.add(translations2, merge=False)
def test_sorted_po(self):
catalog = Catalog()
catalog.add(u'bar', locations=[('utils.py', 3)],
user_comments=['Comment About `bar` with',
'multiple lines.'])
catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'),
locations=[('main.py', 1)])
buf = BytesIO()
pofile.write_po(buf, catalog, sort_output=True)
value = buf.getvalue().strip()
assert b'''\
# Comment About `bar` with
# multiple lines.
#: utils.py:3
msgid "bar"
msgstr ""
#: main.py:1
msgid "foo"
msgid_plural "foos"
msgstr[0] "Voh"
msgstr[1] "Voeh"''' in value
assert value.find(b'msgid ""') < value.find(b'msgid "bar"') < value.find(b'msgid "foo"')
def test_empty_translation_with_fallback(self):
catalog1 = Catalog(locale='fr_FR')
catalog1.add(u'', '''\
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n''')
catalog1.add(u'Fuzz', '')
buf1 = BytesIO()
mofile.write_mo(buf1, catalog1)
buf1.seek(0)
catalog2 = Catalog(locale='fr')
catalog2.add(u'', '''\
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n''')
catalog2.add(u'Fuzz', 'Flou')
buf2 = BytesIO()
mofile.write_mo(buf2, catalog2)
buf2.seek(0)
translations = Translations(fp=buf1)
translations.add_fallback(Translations(fp=buf2))
self.assertEqual(u'Flou', translations.ugettext('Fuzz'))
def test_extract_singular_form_kwargs(self):
buf = BytesIO(b'<%= _("foo") %> <%= _() %> <%= ngettext("foo", "bar", count=42) %>')
messages = list(extract(buf, self.keywords, [], {}))
assert messages == [(1, '_', 'foo', []), (1, '_', (), []), (1, 'ngettext', ('foo', 'bar', None, 'count'), [])] # noqa#
def test_extract_filters_default_translatable_single_quotes(self):
buf = BytesIO(b"{{ book.author|default:_('Unknown') }}")
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'Unknown', [])], messages)
def test_parses_underscore(self):
buf = BytesIO(b'hello: <%= name %>')
messages = list(extract(buf, self.keywords, [], {}))
assert messages == []
def test_extract_no_tags(self):
buf = BytesIO(b'nothing')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([], messages)
def test_extract_var(self):
buf = BytesIO(b'{% blocktrans %}{{ anton }}{% endblocktrans %}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'%(anton)s', [])], messages)
def test_extract_simple_single_quotes(self):
buf = BytesIO(b"{% trans 'Bunny' %}")
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'Bunny', [])], messages)
def test_extract_valid_comment(self):
buf = BytesIO(b'{# ignored comment #6 #}{% trans "Translatable literal #9h" %}{# Translators: valid i18n comment #7 #}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'Translatable literal #9h', [])], messages)
def test_extract_with_interpolation(self):
buf = BytesIO(b'{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'xxx%(anton)sxxx', [])], messages)
def test_trans_blocks_must_not_include_other_block_tags(self):
buf = BytesIO(b'{% blocktrans %}{% other_tag %}{% endblocktrans %}')
gen = extract_django(buf, default_keys, [], {})
with pytest.raises(SyntaxError):
next(gen)
def test_extract_var_other(self):
buf = BytesIO(b'{{ book }}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([], messages)
def test_parse_future(source, result):
fp = BytesIO(source.encode('latin-1'))
flags = parse_future_flags(fp)
assert flags == result
def test_more_plural_forms(self):
catalog2 = Catalog(locale='ru_RU')
catalog2.add(('Fuzz', 'Fuzzes'), ('', '', ''))
buf = BytesIO()
mofile.write_mo(buf, catalog2)
def test_extract_constant_single_quotes(self):
buf = BytesIO(b"{{ _('constant') }}")
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u"'constant'", [])], messages)
def test_2_num_plurals_checkers(self):
# in this testcase we add an extra msgstr[idx], we should be
# disregarding it
for _locale in [p for p in PLURALS if PLURALS[p][0] == 2]:
if _locale in ['nn', 'no']:
_locale = 'nn_NO'
num_plurals = PLURALS[_locale.split('_')[0]][0]
plural_expr = PLURALS[_locale.split('_')[0]][1]
else:
num_plurals = PLURALS[_locale][0]
plural_expr = PLURALS[_locale][1]
try:
locale = Locale(_locale)
date = format_datetime(datetime.now(LOCALTZ),
'yyyy-MM-dd HH:mmZ',
tzinfo=LOCALTZ,
locale=_locale)
except UnknownLocaleError:
# Just an alias? Not what we're testing here, let's continue
continue
po_file = (u"""\
# %(english_name)s translations for TestProject.
# Copyright (C) 2007 FooBar, Inc.
# This file is distributed under the same license as the TestProject
# project.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2007.
#
msgid ""
msgstr ""
"Project-Id-Version: TestProject 0.1\\n"
"Report-Msgid-Bugs-To: [email protected]\\n"
"POT-Creation-Date: 2007-04-01 15:30+0200\\n"
"PO-Revision-Date: %(date)s\\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
"Language-Team: %(locale)s <*****@*****.**>\\n"
"Plural-Forms: nplurals=%(num_plurals)s; plural=%(plural_expr)s\\n"
"MIME-Version: 1.0\\n"
"Content-Type: text/plain; charset=utf-8\\n"
"Content-Transfer-Encoding: 8bit\\n"
"Generated-By: Babel %(version)s\\n"
#. This will be a translator comment,
#. that will include several lines
#: project/file1.py:8
msgid "bar"
msgstr ""
#: project/file2.py:9
msgid "foobar"
msgid_plural "foobars"
msgstr[0] ""
msgstr[1] ""
msgstr[2] ""
""" % dict(locale=_locale,
english_name=locale.english_name,
version=VERSION,
year=time.strftime('%Y'),
date=date,
num_plurals=num_plurals,
plural_expr=plural_expr)).encode('utf-8')
# we should be adding the missing msgstr[0]
# This test will fail for revisions <= 406 because so far
# catalog.num_plurals was neglected
catalog = read_po(BytesIO(po_file), _locale)
message = catalog['foobar']
checkers.num_plurals(catalog, message)
def test_extract_constant_single_quotes(self):
buf = BytesIO(b'{{ _("constant") }}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'"constant"', [])], messages)
def test_extract_unicode_blocktrans(self):
buf = BytesIO(force_bytes('{% blocktrans %}@ſðæ314“ſſ¶ÐĐÞ→SÆ^ĸŁ{% endblocktrans %}'))
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'@ſðæ314“ſſ¶ÐĐÞ→SÆ^ĸŁ', [])], messages)
#(filename, lineno, message, comments, context)
('main.py', 9, 'MSG000', [], None)
('sub.py', 1, 'MSG000', [], None)
('mypackage/mymodule.py', 1, 'Good Luck !', [], None)
"""
#翻訳データ(Catalog)を作成する
import babel.messages.catalog
catalog = babel.messages.catalog.Catalog(locale='ja', domain='hello')
c_list = list(babel.messages.extract.extract_from_dir(dirname='../../src/'))
for c_tpl in c_list:
catalog.add(c_tpl[2], string='翻訳後テキスト', locations=[(c_t[0], c_t[1]) for c_t in c_list if c_tpl[2]==c_t[2]])
#poファイル書き出し
from babel._compat import BytesIO
buf = BytesIO()
import babel.messages.pofile
babel.messages.pofile.write_po(buf, catalog)
#babel.messages.pofile.write_po(buf, catalog, omit_header=True)
print(buf.getvalue().decode("utf8"))
"""
#: main.py:9 sub.py:1
msgid "MSG000"
msgstr "翻訳後テキスト"
#: mypackage/mymodule.py:1
msgid "Good Luck !"
msgstr "翻訳後テキスト"
"""
def test_extract_filter_with_filter(self):
buf = BytesIO(b'{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'%(berta)s', [])], messages)
def test_extract_constant_in_block(self):
buf = BytesIO(b'{% blocktrans foo=_("constant") %}{{ foo }}{% endblocktrans %}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual(
[(1, None, u'"constant"', []), (1, None, u'%(foo)s', [])],
messages)
def test_extract_unicode(self):
buf = BytesIO(
u'<%= gettext("@ſðæ314“ſſ¶ÐĐÞ→SÆ^ĸŁ") %>'.encode('utf-8'))
messages = list(extract(buf, self.keywords, [], {}))
assert messages == [(1, 'gettext', u'@ſðæ314“ſſ¶ÐĐÞ→SÆ^ĸŁ', [])]
def test_extract_ignored_comment2(self):
buf = BytesIO(b'{# Translators: ignored i18n comment #1 #}{% trans "Translatable literal #9a" %}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'Translatable literal #9a', [])], messages)
def test_parses_underscore_gettext(self):
buf = BytesIO(b'hello: <%= gettext("name") %>')
messages = list(extract(buf, self.keywords, [], {}))
assert messages == [(1, 'gettext', u'name', [])]
def test_invalid_extract_method(self):
buf = BytesIO(b'')
self.assertRaises(ValueError, list, extract.extract('spam', buf))
def test_parses_blocktrans(self):
buf = BytesIO(
b'Ignored {% blocktrans %}{{ anton }}{% endblocktrans %}')
messages = list(extract(buf, self.keywords, [], {}))
assert messages == [(1, None, u'%(anton)s', [])]
def test_unicode_string_arg(self):
buf = BytesIO(b"msg = _(u'Foo Bar')")
messages = list(extract.extract_python(buf, ('_', ), [], {}))
self.assertEqual(u'Foo Bar', messages[0][2])
def test_parses_django(self):
buf = BytesIO(b'{% trans "Bunny" %}')
messages = list(extract(buf, self.keywords, [], {}))
assert messages == ([(1, None, u'Bunny', [])])
def setUp(self):
fp = BytesIO()
write_mo(fp, Catalog(locale='de'))
fp.seek(0)
self.translations = support.Translations(fp=fp)
self.null_translations = support.NullTranslations(fp=fp)
def setUp(self):
fp = BytesIO()
write_mo(fp, Catalog(locale='de'))
fp.seek(0)
self.translations = support.Translations(fp=fp)
self.null_translations = support.NullTranslations(fp=fp)
def test_extract_singular_form(self):
buf = BytesIO(b'{% blocktrans count counter=number %}singular{% plural %}{{ counter }} plural{% endblocktrans %}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, 'ngettext', (u'singular', u'%(counter)s plural'), [])], messages)
assert util.pathmatch('./blah.py', 'blah.py')
assert not util.pathmatch('./foo/**.py', 'blah/foo/bar/baz.py')
class FixedOffsetTimezoneTestCase(unittest.TestCase):
def test_zone_negative_offset(self):
self.assertEqual('Etc/GMT-60', util.FixedOffsetTimezone(-60).zone)
def test_zone_zero_offset(self):
self.assertEqual('Etc/GMT+0', util.FixedOffsetTimezone(0).zone)
def test_zone_positive_offset(self):
self.assertEqual('Etc/GMT+330', util.FixedOffsetTimezone(330).zone)
parse_encoding = lambda s: util.parse_encoding(BytesIO(s.encode('utf-8')))
def test_parse_encoding_defined():
assert parse_encoding(u'# coding: utf-8') == 'utf-8'
def test_parse_encoding_undefined():
assert parse_encoding(u'') is None
def test_parse_encoding_non_ascii():
assert parse_encoding(u'K\xf6ln') is None
@pytest.mark.parametrize('source, result', [
def test_extract_constant_block(self):
buf = BytesIO(b'{% _("constant") %}')
messages = list(extract_django(buf, default_keys, [], {}))
self.assertEqual([(1, None, u'"constant"', [])], messages)