Mercurial > babel > old > babel-test
annotate babel/messages/tests/pofile.py @ 421:14bebc7817eb
Include patch from Asheesh Laroia. Fixes #45.
| author | palgarvio |
|---|---|
| date | Thu, 18 Dec 2008 00:19:47 +0000 |
| parents | 6611cc6363b6 |
| children | 8f91314df0b9 |
| rev | line source |
|---|---|
| 1 | 1 # -*- coding: utf-8 -*- |
| 2 # | |
| 335 | 3 # Copyright (C) 2007-2008 Edgewall Software |
| 1 | 4 # All rights reserved. |
| 5 # | |
| 6 # This software is licensed as described in the file COPYING, which | |
| 7 # you should have received as part of this distribution. The terms | |
| 8 # are also available at http://babel.edgewall.org/wiki/License. | |
| 9 # | |
| 10 # This software consists of voluntary contributions made by many | |
| 11 # individuals. For the exact contribution history, see the revision | |
| 12 # history and logs, available at http://babel.edgewall.org/log/. | |
| 13 | |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
14 from datetime import datetime |
| 1 | 15 import doctest |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
16 from StringIO import StringIO |
| 1 | 17 import unittest |
| 18 | |
|
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
19 from babel.messages.catalog import Catalog, Message |
|
54
b3395b285104
Rename the `babel.catalog` package to `babel.messages` for consistency with the other package names.
cmlenz
parents:
51
diff
changeset
|
20 from babel.messages import pofile |
| 291 | 21 from babel.util import FixedOffsetTimezone, LOCALTZ |
| 1 | 22 |
|
17
6aa4c4df8871
Recognize python-format messages also for unnamed parameters.
cmlenz
parents:
12
diff
changeset
|
23 |
|
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
24 class ReadPoTestCase(unittest.TestCase): |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
25 |
|
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
26 def test_preserve_locale(self): |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
27 buf = StringIO(r'''msgid "foo" |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
28 msgstr "Voh"''') |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
29 catalog = pofile.read_po(buf, locale='en_US') |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
30 self.assertEqual('en_US', catalog.locale) |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
31 |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
32 def test_preserve_domain(self): |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
33 buf = StringIO(r'''msgid "foo" |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
34 msgstr "Voh"''') |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
35 catalog = pofile.read_po(buf, domain='mydomain') |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
36 self.assertEqual('mydomain', catalog.domain) |
|
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
37 |
|
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
38 def test_read_multiline(self): |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
39 buf = StringIO(r'''msgid "" |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
40 "Here's some text that\n" |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
41 "includesareallylongwordthatmightbutshouldnt" |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
42 " throw us into an infinite " |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
43 "loop\n" |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
44 msgstr ""''') |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
45 catalog = pofile.read_po(buf) |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
46 self.assertEqual(1, len(catalog)) |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
47 message = list(catalog)[1] |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
48 self.assertEqual("Here's some text that\nincludesareallylongwordthat" |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
49 "mightbutshouldnt throw us into an infinite loop\n", |
|
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
50 message.id) |
|
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
51 |
|
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
52 def test_fuzzy_header(self): |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
53 buf = StringIO(r'''\ |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
54 # Translations template for AReallyReallyLongNameForAProject. |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
55 # Copyright (C) 2007 ORGANIZATION |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
56 # This file is distributed under the same license as the |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
57 # AReallyReallyLongNameForAProject project. |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
58 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
59 # |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
60 #, fuzzy |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
61 ''') |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
62 catalog = pofile.read_po(buf) |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
63 self.assertEqual(1, len(list(catalog))) |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
64 self.assertEqual(True, list(catalog)[0].fuzzy) |
|
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
65 |
|
175
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
66 def test_not_fuzzy_header(self): |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
67 buf = StringIO(r'''\ |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
68 # Translations template for AReallyReallyLongNameForAProject. |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
69 # Copyright (C) 2007 ORGANIZATION |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
70 # This file is distributed under the same license as the |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
71 # AReallyReallyLongNameForAProject project. |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
72 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
73 # |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
74 ''') |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
75 catalog = pofile.read_po(buf) |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
76 self.assertEqual(1, len(list(catalog))) |
|
3c4718fb7435
Changed the `__repr__` output to include the flags(it can be changed back, but it was usefull to implement the fuzzy header parsing).
palgarvio
parents:
106
diff
changeset
|
77 self.assertEqual(False, list(catalog)[0].fuzzy) |
|
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
78 |
| 291 | 79 def test_header_entry(self): |
| 80 buf = StringIO(r'''\ | |
| 81 # SOME DESCRIPTIVE TITLE. | |
| 82 # Copyright (C) 2007 THE PACKAGE'S COPYRIGHT HOLDER | |
| 83 # This file is distributed under the same license as the PACKAGE package. | |
| 84 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. | |
| 85 # | |
| 86 #, fuzzy | |
| 87 msgid "" | |
| 88 msgstr "" | |
| 89 "Project-Id-Version: 3.15\n" | |
| 90 "Report-Msgid-Bugs-To: Fliegender Zirkus <fliegender@zirkus.de>\n" | |
| 91 "POT-Creation-Date: 2007-09-27 11:19+0700\n" | |
| 92 "PO-Revision-Date: 2007-09-27 21:42-0700\n" | |
| 93 "Last-Translator: John <cleese@bavaria.de>\n" | |
| 94 "Language-Team: German Lang <de@babel.org>\n" | |
| 95 "Plural-Forms: nplurals=2; plural=(n != 1)\n" | |
| 96 "MIME-Version: 1.0\n" | |
| 97 "Content-Type: text/plain; charset=iso-8859-2\n" | |
| 98 "Content-Transfer-Encoding: 8bit\n" | |
| 99 "Generated-By: Babel 1.0dev-r313\n" | |
| 100 ''') | |
| 101 catalog = pofile.read_po(buf) | |
| 102 self.assertEqual(1, len(list(catalog))) | |
| 103 self.assertEqual(u'3.15', catalog.version) | |
| 104 self.assertEqual(u'Fliegender Zirkus <fliegender@zirkus.de>', | |
| 105 catalog.msgid_bugs_address) | |
| 106 self.assertEqual(datetime(2007, 9, 27, 11, 19, | |
| 107 tzinfo=FixedOffsetTimezone(7 * 60)), | |
| 108 catalog.creation_date) | |
| 109 self.assertEqual(u'John <cleese@bavaria.de>', catalog.last_translator) | |
| 110 self.assertEqual(u'German Lang <de@babel.org>', catalog.language_team) | |
| 111 self.assertEqual(u'iso-8859-2', catalog.charset) | |
| 112 self.assertEqual(True, list(catalog)[0].fuzzy) | |
| 113 | |
|
199
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
114 def test_obsolete_message(self): |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
115 buf = StringIO(r'''# This is an obsolete message |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
116 #~ msgid "foo" |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
117 #~ msgstr "Voh" |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
118 |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
119 # This message is not obsolete |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
120 #: main.py:1 |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
121 msgid "bar" |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
122 msgstr "Bahr" |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
123 ''') |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
124 catalog = pofile.read_po(buf) |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
125 self.assertEqual(1, len(catalog)) |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
126 self.assertEqual(1, len(catalog.obsolete)) |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
127 message = catalog.obsolete[u'foo'] |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
128 self.assertEqual(u'foo', message.id) |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
129 self.assertEqual(u'Voh', message.string) |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
130 self.assertEqual(['This is an obsolete message'], message.user_comments) |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
131 |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
132 def test_obsolete_message_ignored(self): |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
133 buf = StringIO(r'''# This is an obsolete message |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
134 #~ msgid "foo" |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
135 #~ msgstr "Voh" |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
136 |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
137 # This message is not obsolete |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
138 #: main.py:1 |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
139 msgid "bar" |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
140 msgstr "Bahr" |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
141 ''') |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
142 catalog = pofile.read_po(buf, ignore_obsolete=True) |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
143 self.assertEqual(1, len(catalog)) |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
144 self.assertEqual(0, len(catalog.obsolete)) |
|
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
145 |
| 335 | 146 def test_with_context(self): |
| 147 buf = StringIO(r'''# Some string in the menu | |
| 148 #: main.py:1 | |
| 149 msgctxt "Menu" | |
| 150 msgid "foo" | |
| 151 msgstr "Voh" | |
| 152 | |
| 153 # Another string in the menu | |
| 154 #: main.py:2 | |
| 155 msgctxt "Menu" | |
| 156 msgid "bar" | |
| 157 msgstr "Bahr" | |
| 158 ''') | |
| 159 catalog = pofile.read_po(buf, ignore_obsolete=True) | |
| 160 self.assertEqual(2, len(catalog)) | |
| 350 | 161 message = catalog.get('foo', context='Menu') |
| 335 | 162 self.assertEqual('Menu', message.context) |
| 350 | 163 message = catalog.get('bar', context='Menu') |
| 335 | 164 self.assertEqual('Menu', message.context) |
| 165 | |
| 421 | 166 # And verify it pass through write_po |
| 167 out_buf = StringIO() | |
| 168 pofile.write_po(out_buf, catalog, omit_header=True) | |
| 169 assert out_buf.getvalue().strip() == buf.getvalue().strip(), \ | |
| 170 out_buf.getvalue() | |
| 171 | |
|
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
172 def test_singlular_plural_form(self): |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
173 buf = StringIO(r'''msgid "foo" |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
174 msgid_plural "foo" |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
175 msgstr[0] "Voh" |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
176 msgstr[1] "Vohs"''') # This is a bad po, ja_JP only uses msgstr[0] |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
177 catalog = pofile.read_po(buf, locale='ja_JP') |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
178 self.assertEqual(1, len(catalog)) |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
179 self.assertEqual(1, catalog.num_plurals) |
|
377
6611cc6363b6
Use item access to catalog messages in tests, so that they can be easily ported back to the 0.9.x branch.
cmlenz
parents:
370
diff
changeset
|
180 message = catalog['foo'] |
|
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
181 self.assertEqual(1, len(message.string)) |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
182 |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
183 def test_more_than_two_plural_forms(self): |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
184 buf = StringIO(r'''msgid "foo" |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
185 msgid_plural "foo" |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
186 msgstr[0] "Voh" |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
187 msgstr[1] "Vohs"''') # last translation form is missing |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
188 #msgstr[2] "Vohss"''') |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
189 catalog = pofile.read_po(buf, locale='lv_LV') |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
190 self.assertEqual(1, len(catalog)) |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
191 self.assertEqual(3, catalog.num_plurals) |
|
377
6611cc6363b6
Use item access to catalog messages in tests, so that they can be easily ported back to the 0.9.x branch.
cmlenz
parents:
370
diff
changeset
|
192 message = catalog['foo'] |
|
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
193 self.assertEqual(3, len(message.string)) |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
194 self.assertEqual('', message.string[2]) |
|
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
195 |
|
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
196 |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
197 class WritePoTestCase(unittest.TestCase): |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
198 |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
199 def test_join_locations(self): |
|
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
54
diff
changeset
|
200 catalog = Catalog() |
|
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
54
diff
changeset
|
201 catalog.add(u'foo', locations=[('main.py', 1)]) |
|
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
54
diff
changeset
|
202 catalog.add(u'foo', locations=[('utils.py', 3)]) |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
203 buf = StringIO() |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
204 pofile.write_po(buf, catalog, omit_header=True) |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
205 self.assertEqual('''#: main.py:1 utils.py:3 |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
206 msgid "foo" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
207 msgstr ""''', buf.getvalue().strip()) |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
208 |
|
228
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
209 def test_duplicate_comments(self): |
|
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
210 catalog = Catalog() |
|
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
211 catalog.add(u'foo', auto_comments=['A comment']) |
|
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
212 catalog.add(u'foo', auto_comments=['A comment']) |
|
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
213 buf = StringIO() |
|
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
214 pofile.write_po(buf, catalog, omit_header=True) |
|
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
215 self.assertEqual('''#. A comment |
|
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
216 msgid "foo" |
|
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
217 msgstr ""''', buf.getvalue().strip()) |
|
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
218 |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
219 def test_wrap_long_lines(self): |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
220 text = """Here's some text where |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
221 white space and line breaks matter, and should |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
222 |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
223 not be removed |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
224 |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
225 """ |
|
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
54
diff
changeset
|
226 catalog = Catalog() |
|
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
54
diff
changeset
|
227 catalog.add(text, locations=[('main.py', 1)]) |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
228 buf = StringIO() |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
229 pofile.write_po(buf, catalog, no_location=True, omit_header=True, |
|
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
54
diff
changeset
|
230 width=42) |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
231 self.assertEqual(r'''msgid "" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
232 "Here's some text where \n" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
233 "white space and line breaks matter, and" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
234 " should\n" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
235 "\n" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
236 "not be removed\n" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
237 "\n" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
238 msgstr ""''', buf.getvalue().strip()) |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
239 |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
240 def test_wrap_long_lines_with_long_word(self): |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
241 text = """Here's some text that |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
242 includesareallylongwordthatmightbutshouldnt throw us into an infinite loop |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
243 """ |
|
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
54
diff
changeset
|
244 catalog = Catalog() |
|
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
54
diff
changeset
|
245 catalog.add(text, locations=[('main.py', 1)]) |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
246 buf = StringIO() |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
247 pofile.write_po(buf, catalog, no_location=True, omit_header=True, |
|
56
27fba894d3ca
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
54
diff
changeset
|
248 width=32) |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
249 self.assertEqual(r'''msgid "" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
250 "Here's some text that\n" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
251 "includesareallylongwordthatmightbutshouldnt" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
252 " throw us into an infinite " |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
253 "loop\n" |
|
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
254 msgstr ""''', buf.getvalue().strip()) |
|
80
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
255 |
|
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
256 def test_wrap_long_lines_in_header(self): |
|
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
257 """ |
|
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
258 Verify that long lines in the header comment are wrapped correctly. |
|
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
259 """ |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
260 catalog = Catalog(project='AReallyReallyLongNameForAProject', |
|
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
261 revision_date=datetime(2007, 4, 1)) |
|
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
262 buf = StringIO() |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
263 pofile.write_po(buf, catalog) |
|
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
264 self.assertEqual('''\ |
|
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
265 # Translations template for AReallyReallyLongNameForAProject. |
|
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
266 # Copyright (C) 2007 ORGANIZATION |
|
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
267 # This file is distributed under the same license as the |
|
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
268 # AReallyReallyLongNameForAProject project. |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
269 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. |
|
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
270 # |
|
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
271 #, fuzzy''', '\n'.join(buf.getvalue().splitlines()[:7])) |
|
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
272 |
| 315 | 273 def test_wrap_locations_with_hyphens(self): |
| 274 catalog = Catalog() | |
| 275 catalog.add(u'foo', locations=[ | |
| 276 ('doupy/templates/base/navmenu.inc.html.py', 60) | |
| 277 ]) | |
| 278 catalog.add(u'foo', locations=[ | |
| 279 ('doupy/templates/job-offers/helpers.html', 22) | |
| 280 ]) | |
| 281 buf = StringIO() | |
| 282 pofile.write_po(buf, catalog, omit_header=True) | |
| 283 self.assertEqual('''#: doupy/templates/base/navmenu.inc.html.py:60 | |
| 284 #: doupy/templates/job-offers/helpers.html:22 | |
| 285 msgid "foo" | |
| 286 msgstr ""''', buf.getvalue().strip()) | |
| 287 | |
|
80
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
288 def test_pot_with_translator_comments(self): |
|
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
289 catalog = Catalog() |
|
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
290 catalog.add(u'foo', locations=[('main.py', 1)], |
|
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
291 auto_comments=['Comment About `foo`']) |
|
80
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
292 catalog.add(u'bar', locations=[('utils.py', 3)], |
|
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
293 user_comments=['Comment About `bar` with', |
|
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
294 'multiple lines.']) |
|
80
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
295 buf = StringIO() |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
296 pofile.write_po(buf, catalog, omit_header=True) |
|
80
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
297 self.assertEqual('''#. Comment About `foo` |
|
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
298 #: main.py:1 |
|
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
299 msgid "foo" |
|
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
300 msgstr "" |
|
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
301 |
|
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
302 # Comment About `bar` with |
|
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
303 # multiple lines. |
|
80
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
304 #: utils.py:3 |
|
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
305 msgid "bar" |
|
9c84b9fa5d30
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
56
diff
changeset
|
306 msgstr ""''', buf.getvalue().strip()) |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
307 |
|
190
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
308 def test_po_with_obsolete_message(self): |
|
181
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
309 catalog = Catalog() |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
310 catalog.add(u'foo', u'Voh', locations=[('main.py', 1)]) |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
311 catalog.obsolete['bar'] = Message(u'bar', u'Bahr', |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
312 locations=[('utils.py', 3)], |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
313 user_comments=['User comment']) |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
314 buf = StringIO() |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
315 pofile.write_po(buf, catalog, omit_header=True) |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
316 self.assertEqual('''#: main.py:1 |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
317 msgid "foo" |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
318 msgstr "Voh" |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
319 |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
320 # User comment |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
321 #~ msgid "bar" |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
322 #~ msgstr "Bahr"''', buf.getvalue().strip()) |
|
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
323 |
|
190
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
324 def test_po_with_multiline_obsolete_message(self): |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
325 catalog = Catalog() |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
326 catalog.add(u'foo', u'Voh', locations=[('main.py', 1)]) |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
327 msgid = r"""Here's a message that covers |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
328 multiple lines, and should still be handled |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
329 correctly. |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
330 """ |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
331 msgstr = r"""Here's a message that covers |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
332 multiple lines, and should still be handled |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
333 correctly. |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
334 """ |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
335 catalog.obsolete[msgid] = Message(msgid, msgstr, |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
336 locations=[('utils.py', 3)]) |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
337 buf = StringIO() |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
338 pofile.write_po(buf, catalog, omit_header=True) |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
339 self.assertEqual(r'''#: main.py:1 |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
340 msgid "foo" |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
341 msgstr "Voh" |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
342 |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
343 #~ msgid "" |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
344 #~ "Here's a message that covers\n" |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
345 #~ "multiple lines, and should still be handled\n" |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
346 #~ "correctly.\n" |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
347 #~ msgstr "" |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
348 #~ "Here's a message that covers\n" |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
349 #~ "multiple lines, and should still be handled\n" |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
350 #~ "correctly.\n"''', buf.getvalue().strip()) |
|
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
351 |
|
191
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
352 def test_po_with_obsolete_message_ignored(self): |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
353 catalog = Catalog() |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
354 catalog.add(u'foo', u'Voh', locations=[('main.py', 1)]) |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
355 catalog.obsolete['bar'] = Message(u'bar', u'Bahr', |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
356 locations=[('utils.py', 3)], |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
357 user_comments=['User comment']) |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
358 buf = StringIO() |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
359 pofile.write_po(buf, catalog, omit_header=True, ignore_obsolete=True) |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
360 self.assertEqual('''#: main.py:1 |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
361 msgid "foo" |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
362 msgstr "Voh"''', buf.getvalue().strip()) |
|
cf09490f22b3
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
190
diff
changeset
|
363 |
| 203 | 364 def test_po_with_previous_msgid(self): |
| 365 catalog = Catalog() | |
| 366 catalog.add(u'foo', u'Voh', locations=[('main.py', 1)], | |
| 367 previous_id=u'fo') | |
| 368 buf = StringIO() | |
| 369 pofile.write_po(buf, catalog, omit_header=True, include_previous=True) | |
| 370 self.assertEqual('''#: main.py:1 | |
| 371 #| msgid "fo" | |
| 372 msgid "foo" | |
| 373 msgstr "Voh"''', buf.getvalue().strip()) | |
| 374 | |
| 375 def test_po_with_previous_msgid_plural(self): | |
| 376 catalog = Catalog() | |
| 377 catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'), | |
| 378 locations=[('main.py', 1)], previous_id=(u'fo', u'fos')) | |
| 379 buf = StringIO() | |
| 380 pofile.write_po(buf, catalog, omit_header=True, include_previous=True) | |
| 381 self.assertEqual('''#: main.py:1 | |
| 382 #| msgid "fo" | |
| 383 #| msgid_plural "fos" | |
| 384 msgid "foo" | |
| 385 msgid_plural "foos" | |
| 386 msgstr[0] "Voh" | |
| 387 msgstr[1] "Voeh"''', buf.getvalue().strip()) | |
| 388 | |
|
249
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
389 def test_sorted_po(self): |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
390 catalog = Catalog() |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
391 catalog.add(u'bar', locations=[('utils.py', 3)], |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
392 user_comments=['Comment About `bar` with', |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
393 'multiple lines.']) |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
394 catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'), |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
395 locations=[('main.py', 1)]) |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
396 buf = StringIO() |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
397 pofile.write_po(buf, catalog, sort_output=True) |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
398 value = buf.getvalue().strip() |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
399 assert '''\ |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
400 # Comment About `bar` with |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
401 # multiple lines. |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
402 #: utils.py:3 |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
403 msgid "bar" |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
404 msgstr "" |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
405 |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
406 #: main.py:1 |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
407 msgid "foo" |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
408 msgid_plural "foos" |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
409 msgstr[0] "Voh" |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
410 msgstr[1] "Voeh"''' in value |
|
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
411 assert value.find('msgid ""') < value.find('msgid "bar"') < value.find('msgid "foo"') |
|
24
4fad20ab7cca
Reimplement line wrapping for PO writing (as the `textwrap` module is too destructive with white space) and move it to the `normalize` function (which was already doing some handling of line breaks).
cmlenz
parents:
17
diff
changeset
|
412 |
|
356
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
413 def test_silent_location_fallback(self): |
|
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
414 buf = StringIO('''\ |
|
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
415 #: broken_file.py |
|
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
416 msgid "missing line number" |
|
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
417 msgstr "" |
|
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
418 |
|
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
419 #: broken_file.py:broken_line_number |
|
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
420 msgid "broken line number" |
|
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
421 msgstr ""''') |
|
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
422 catalog = pofile.read_po(buf) |
|
377
6611cc6363b6
Use item access to catalog messages in tests, so that they can be easily ported back to the 0.9.x branch.
cmlenz
parents:
370
diff
changeset
|
423 self.assertEqual(catalog['missing line number'].locations, []) |
|
6611cc6363b6
Use item access to catalog messages in tests, so that they can be easily ported back to the 0.9.x branch.
cmlenz
parents:
370
diff
changeset
|
424 self.assertEqual(catalog['broken line number'].locations, []) |
|
356
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
425 |
| 1 | 426 def suite(): |
| 427 suite = unittest.TestSuite() | |
| 428 suite.addTest(doctest.DocTestSuite(pofile)) | |
|
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
429 suite.addTest(unittest.makeSuite(ReadPoTestCase)) |
|
104
22f222e23b86
Merged `write_pot` and `write_po` functions by moving more functionality to the `Catalog` class. This is certainly not perfect yet, but moves us in the right direction.
cmlenz
parents:
103
diff
changeset
|
430 suite.addTest(unittest.makeSuite(WritePoTestCase)) |
| 1 | 431 return suite |
| 432 | |
| 433 if __name__ == '__main__': | |
| 434 unittest.main(defaultTest='suite') |