Example #1
0
    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())
Example #2
0
    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()
Example #3
0
    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())
Example #4
0
    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
Example #5
0
    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)
Example #6
0
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()
Example #7
0
 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
Example #8
0
 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')
Example #9
0
    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())
Example #10
0
    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())
Example #11
0
    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())
Example #12
0
    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())
Example #13
0
    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())
Example #14
0
    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())
Example #15
0
    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())
Example #16
0
    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
Example #17
0
    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())
Example #18
0
    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]))
Example #19
0
    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())
Example #20
0
    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())
Example #21
0
 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)
Example #22
0
 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)
Example #23
0
    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"')
Example #24
0
    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'))
Example #25
0
 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#
Example #26
0
 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 == []
Example #28
0
 def test_extract_no_tags(self):
     buf = BytesIO(b'nothing')
     messages = list(extract_django(buf, default_keys, [], {}))
     self.assertEqual([], messages)
Example #29
0
 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)
Example #30
0
 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)
Example #31
0
 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)
Example #32
0
 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)
Example #33
0
 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)
Example #34
0
 def test_extract_var_other(self):
     buf = BytesIO(b'{{ book }}')
     messages = list(extract_django(buf, default_keys, [], {}))
     self.assertEqual([], messages)
Example #35
0
def test_parse_future(source, result):
    fp = BytesIO(source.encode('latin-1'))
    flags = parse_future_flags(fp)
    assert flags == result
Example #36
0
 def test_more_plural_forms(self):
     catalog2 = Catalog(locale='ru_RU')
     catalog2.add(('Fuzz', 'Fuzzes'), ('', '', ''))
     buf = BytesIO()
     mofile.write_mo(buf, catalog2)
Example #37
0
 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)
Example #38
0
    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)
Example #39
0
 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)
Example #40
0
 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 "翻訳後テキスト"
"""
Example #42
0
 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)
Example #43
0
 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Æ^ĸŁ', [])]
Example #45
0
 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', [])]
Example #47
0
 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', [])]
Example #49
0
 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', [])])
Example #51
0
 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)
Example #52
0
 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)
Example #53
0
 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)
Example #54
0
    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', [
Example #55
0
 def test_extract_constant_block(self):
     buf = BytesIO(b'{% _("constant") %}')
     messages = list(extract_django(buf, default_keys, [], {}))
     self.assertEqual([(1, None, u'"constant"', [])], messages)