Mercurial > babel > old > babel-test
annotate babel/messages/tests/pofile.py @ 548:59db0f962e00
test refactoring: clear global babel logger handlers to decrease test interdependencies (follow-up on #227)
author | fschwarz |
---|---|
date | Sat, 19 Mar 2011 21:13:34 +0000 |
parents | afdab04b8527 |
children |
rev | line source |
---|---|
1 | 1 # -*- coding: utf-8 -*- |
2 # | |
530 | 3 # Copyright (C) 2007-2011 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 |
531 | 21 from babel.util import FixedOffsetTimezone |
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 |
545
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
38 def test_applies_specified_encoding_during_read(self): |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
39 buf = StringIO(u''' |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
40 msgid "" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
41 msgstr "" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
42 "Project-Id-Version: 3.15\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
43 "Report-Msgid-Bugs-To: Fliegender Zirkus <fliegender@zirkus.de>\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
44 "POT-Creation-Date: 2007-09-27 11:19+0700\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
45 "PO-Revision-Date: 2007-09-27 21:42-0700\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
46 "Last-Translator: John <cleese@bavaria.de>\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
47 "Language-Team: German Lang <de@babel.org>\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
48 "Plural-Forms: nplurals=2; plural=(n != 1)\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
49 "MIME-Version: 1.0\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
50 "Content-Type: text/plain; charset=iso-8859-1\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
51 "Content-Transfer-Encoding: 8bit\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
52 "Generated-By: Babel 1.0dev-r313\\n" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
53 |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
54 msgid "foo" |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
55 msgstr "bär"'''.encode('iso-8859-1')) |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
56 catalog = pofile.read_po(buf, locale='de_DE') |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
57 self.assertEqual(u'bär', catalog.get('foo').string) |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
58 |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
59 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
|
60 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
|
61 "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
|
62 "includesareallylongwordthatmightbutshouldnt" |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
63 " 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
|
64 "loop\n" |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
65 msgstr ""''') |
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
66 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
|
67 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
|
68 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
|
69 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
|
70 "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
|
71 message.id) |
196
93a922d31eca
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
191
diff
changeset
|
72 |
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
|
73 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
|
74 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
|
75 # 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
|
76 # 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
|
77 # 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
|
78 # 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
|
79 # 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
|
80 # |
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
|
81 #, 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
|
82 ''') |
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
|
83 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
|
84 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
|
85 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
|
86 |
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
|
87 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
|
88 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
|
89 # 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
|
90 # 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
|
91 # 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
|
92 # 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
|
93 # 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
|
94 # |
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
|
95 ''') |
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
|
96 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
|
97 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
|
98 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
|
99 |
291 | 100 def test_header_entry(self): |
101 buf = StringIO(r'''\ | |
102 # SOME DESCRIPTIVE TITLE. | |
103 # Copyright (C) 2007 THE PACKAGE'S COPYRIGHT HOLDER | |
104 # This file is distributed under the same license as the PACKAGE package. | |
105 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. | |
106 # | |
107 #, fuzzy | |
108 msgid "" | |
109 msgstr "" | |
110 "Project-Id-Version: 3.15\n" | |
111 "Report-Msgid-Bugs-To: Fliegender Zirkus <fliegender@zirkus.de>\n" | |
112 "POT-Creation-Date: 2007-09-27 11:19+0700\n" | |
113 "PO-Revision-Date: 2007-09-27 21:42-0700\n" | |
114 "Last-Translator: John <cleese@bavaria.de>\n" | |
115 "Language-Team: German Lang <de@babel.org>\n" | |
116 "Plural-Forms: nplurals=2; plural=(n != 1)\n" | |
117 "MIME-Version: 1.0\n" | |
118 "Content-Type: text/plain; charset=iso-8859-2\n" | |
119 "Content-Transfer-Encoding: 8bit\n" | |
120 "Generated-By: Babel 1.0dev-r313\n" | |
121 ''') | |
122 catalog = pofile.read_po(buf) | |
123 self.assertEqual(1, len(list(catalog))) | |
124 self.assertEqual(u'3.15', catalog.version) | |
125 self.assertEqual(u'Fliegender Zirkus <fliegender@zirkus.de>', | |
126 catalog.msgid_bugs_address) | |
127 self.assertEqual(datetime(2007, 9, 27, 11, 19, | |
128 tzinfo=FixedOffsetTimezone(7 * 60)), | |
129 catalog.creation_date) | |
130 self.assertEqual(u'John <cleese@bavaria.de>', catalog.last_translator) | |
131 self.assertEqual(u'German Lang <de@babel.org>', catalog.language_team) | |
132 self.assertEqual(u'iso-8859-2', catalog.charset) | |
133 self.assertEqual(True, list(catalog)[0].fuzzy) | |
134 | |
199
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
135 def test_obsolete_message(self): |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
136 buf = StringIO(r'''# This is an obsolete message |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
137 #~ msgid "foo" |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
138 #~ msgstr "Voh" |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
139 |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
140 # This message is not obsolete |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
141 #: main.py:1 |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
142 msgid "bar" |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
143 msgstr "Bahr" |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
144 ''') |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
145 catalog = pofile.read_po(buf) |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
146 self.assertEqual(1, len(catalog)) |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
147 self.assertEqual(1, len(catalog.obsolete)) |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
148 message = catalog.obsolete[u'foo'] |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
149 self.assertEqual(u'foo', message.id) |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
150 self.assertEqual(u'Voh', message.string) |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
151 self.assertEqual(['This is an obsolete message'], message.user_comments) |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
152 |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
153 def test_obsolete_message_ignored(self): |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
154 buf = StringIO(r'''# This is an obsolete message |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
155 #~ msgid "foo" |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
156 #~ msgstr "Voh" |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
157 |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
158 # This message is not obsolete |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
159 #: main.py:1 |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
160 msgid "bar" |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
161 msgstr "Bahr" |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
162 ''') |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
163 catalog = pofile.read_po(buf, ignore_obsolete=True) |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
164 self.assertEqual(1, len(catalog)) |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
165 self.assertEqual(0, len(catalog.obsolete)) |
ace575fff5ac
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
196
diff
changeset
|
166 |
335 | 167 def test_with_context(self): |
168 buf = StringIO(r'''# Some string in the menu | |
169 #: main.py:1 | |
170 msgctxt "Menu" | |
171 msgid "foo" | |
172 msgstr "Voh" | |
173 | |
174 # Another string in the menu | |
175 #: main.py:2 | |
176 msgctxt "Menu" | |
177 msgid "bar" | |
178 msgstr "Bahr" | |
179 ''') | |
180 catalog = pofile.read_po(buf, ignore_obsolete=True) | |
181 self.assertEqual(2, len(catalog)) | |
350 | 182 message = catalog.get('foo', context='Menu') |
335 | 183 self.assertEqual('Menu', message.context) |
350 | 184 message = catalog.get('bar', context='Menu') |
335 | 185 self.assertEqual('Menu', message.context) |
186 | |
421 | 187 # And verify it pass through write_po |
188 out_buf = StringIO() | |
189 pofile.write_po(out_buf, catalog, omit_header=True) | |
190 assert out_buf.getvalue().strip() == buf.getvalue().strip(), \ | |
191 out_buf.getvalue() | |
192 | |
428
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
193 def test_with_context_two(self): |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
194 buf = StringIO(r'''msgctxt "Menu" |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
195 msgid "foo" |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
196 msgstr "Voh" |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
197 |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
198 msgctxt "Mannu" |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
199 msgid "bar" |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
200 msgstr "Bahr" |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
201 ''') |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
202 catalog = pofile.read_po(buf, ignore_obsolete=True) |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
203 self.assertEqual(2, len(catalog)) |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
204 message = catalog.get('foo', context='Menu') |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
205 self.assertEqual('Menu', message.context) |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
206 message = catalog.get('bar', context='Mannu') |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
207 self.assertEqual('Mannu', message.context) |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
208 |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
209 # And verify it pass through write_po |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
210 out_buf = StringIO() |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
211 pofile.write_po(out_buf, catalog, omit_header=True) |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
212 assert out_buf.getvalue().strip() == buf.getvalue().strip(), out_buf.getvalue() |
6a62763f2fc4
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
423
diff
changeset
|
213 |
443 | 214 def test_single_plural_form(self): |
215 buf = StringIO(r'''msgid "foo" | |
446
02a4a0f6e6d0
Actually make the msgid_plural be a plural as per typical use case.
jruigrok
parents:
445
diff
changeset
|
216 msgid_plural "foos" |
443 | 217 msgstr[0] "Voh"''') |
218 catalog = pofile.read_po(buf, locale='ja_JP') | |
219 self.assertEqual(1, len(catalog)) | |
220 self.assertEqual(1, catalog.num_plurals) | |
221 message = catalog['foo'] | |
222 self.assertEqual(1, len(message.string)) | |
223 | |
442 | 224 def test_singular_plural_form(self): |
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
225 buf = StringIO(r'''msgid "foo" |
446
02a4a0f6e6d0
Actually make the msgid_plural be a plural as per typical use case.
jruigrok
parents:
445
diff
changeset
|
226 msgid_plural "foos" |
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
227 msgstr[0] "Voh" |
442 | 228 msgstr[1] "Vohs"''') |
229 catalog = pofile.read_po(buf, locale='nl_NL') | |
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
230 self.assertEqual(1, len(catalog)) |
442 | 231 self.assertEqual(2, 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
|
232 message = catalog['foo'] |
442 | 233 self.assertEqual(2, len(message.string)) |
441
f4c0d8fe8af9
Make sure to only strip on the first occurence of ].
jruigrok
parents:
428
diff
changeset
|
234 |
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
235 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
|
236 buf = StringIO(r'''msgid "foo" |
446
02a4a0f6e6d0
Actually make the msgid_plural be a plural as per typical use case.
jruigrok
parents:
445
diff
changeset
|
237 msgid_plural "foos" |
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
238 msgstr[0] "Voh" |
445
1056b2e7bad2
More than two plural forms work nowadays. Adjust the test.
jruigrok
parents:
444
diff
changeset
|
239 msgstr[1] "Vohs" |
1056b2e7bad2
More than two plural forms work nowadays. Adjust the test.
jruigrok
parents:
444
diff
changeset
|
240 msgstr[2] "Vohss"''') |
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
241 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
|
242 self.assertEqual(1, len(catalog)) |
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
243 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
|
244 message = catalog['foo'] |
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
245 self.assertEqual(3, len(message.string)) |
445
1056b2e7bad2
More than two plural forms work nowadays. Adjust the test.
jruigrok
parents:
444
diff
changeset
|
246 self.assertEqual(u'Vohss', message.string[2]) |
370
6129d2e770bc
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
356
diff
changeset
|
247 |
444
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
248 def test_plural_with_square_brackets(self): |
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
249 buf = StringIO(r'''msgid "foo" |
446
02a4a0f6e6d0
Actually make the msgid_plural be a plural as per typical use case.
jruigrok
parents:
445
diff
changeset
|
250 msgid_plural "foos" |
444
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
251 msgstr[0] "Voh [text]" |
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
252 msgstr[1] "Vohs [text]"''') |
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
253 catalog = pofile.read_po(buf, locale='nb_NO') |
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
254 self.assertEqual(1, len(catalog)) |
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
255 self.assertEqual(2, catalog.num_plurals) |
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
256 message = catalog['foo'] |
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
257 self.assertEqual(2, len(message.string)) |
02c3b114a122
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
443
diff
changeset
|
258 |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
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 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
|
261 |
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
|
262 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
|
263 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
|
264 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
|
265 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
|
266 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
|
267 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
|
268 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
|
269 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
|
270 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
|
271 |
545
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
272 def test_write_po_file_with_specified_charset(self): |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
273 catalog = Catalog(charset='iso-8859-1') |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
274 catalog.add('foo', u'äöü', locations=[('main.py', 1)]) |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
275 buf = StringIO() |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
276 pofile.write_po(buf, catalog, omit_header=False) |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
277 po_file = buf.getvalue().strip() |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
278 assert r'"Content-Type: text/plain; charset=iso-8859-1\n"' in po_file |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
279 assert u'msgstr "äöü"'.encode('iso-8859-1') in po_file |
afdab04b8527
Catalog class should not do decoding of input strings (fixes #256)
fschwarz
parents:
544
diff
changeset
|
280 |
228
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
281 def test_duplicate_comments(self): |
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
282 catalog = Catalog() |
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
283 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
|
284 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
|
285 buf = StringIO() |
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
286 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
|
287 self.assertEqual('''#. A comment |
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
288 msgid "foo" |
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
289 msgstr ""''', buf.getvalue().strip()) |
fd29fabdc986
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
203
diff
changeset
|
290 |
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
|
291 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
|
292 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
|
293 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
|
294 |
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
|
295 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
|
296 |
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
|
297 """ |
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
|
298 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
|
299 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
|
300 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
|
301 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
|
302 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
|
303 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
|
304 "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
|
305 "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
|
306 " 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
|
307 "\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
|
308 "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
|
309 "\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
|
310 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
|
311 |
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
|
312 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
|
313 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
|
314 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
|
315 """ |
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
|
316 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
|
317 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
|
318 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
|
319 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
|
320 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
|
321 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
|
322 "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
|
323 "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
|
324 " 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
|
325 "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
|
326 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
|
327 |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
328 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
|
329 """ |
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
330 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
|
331 """ |
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
|
332 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
|
333 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
|
334 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
|
335 pofile.write_po(buf, catalog) |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
336 self.assertEqual('''\ |
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
337 # Translations template for AReallyReallyLongNameForAProject. |
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
338 # Copyright (C) 2007 ORGANIZATION |
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
339 # 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
|
340 # 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
|
341 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. |
103
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
342 # |
7cdf89eb9007
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
80
diff
changeset
|
343 #, 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
|
344 |
315 | 345 def test_wrap_locations_with_hyphens(self): |
346 catalog = Catalog() | |
347 catalog.add(u'foo', locations=[ | |
348 ('doupy/templates/base/navmenu.inc.html.py', 60) | |
349 ]) | |
350 catalog.add(u'foo', locations=[ | |
351 ('doupy/templates/job-offers/helpers.html', 22) | |
352 ]) | |
353 buf = StringIO() | |
354 pofile.write_po(buf, catalog, omit_header=True) | |
355 self.assertEqual('''#: doupy/templates/base/navmenu.inc.html.py:60 | |
356 #: doupy/templates/job-offers/helpers.html:22 | |
357 msgid "foo" | |
358 msgstr ""''', buf.getvalue().strip()) | |
423
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
359 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
360 def test_no_wrap_and_width_behaviour_on_comments(self): |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
361 catalog = Catalog() |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
362 catalog.add("Pretty dam long message id, which must really be big " |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
363 "to test this wrap behaviour, if not it won't work.", |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
364 locations=[("fake.py", n) for n in range(1, 30)]) |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
365 buf = StringIO() |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
366 pofile.write_po(buf, catalog, width=None, omit_header=True) |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
367 self.assertEqual("""\ |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
368 #: fake.py:1 fake.py:2 fake.py:3 fake.py:4 fake.py:5 fake.py:6 fake.py:7 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
369 #: fake.py:8 fake.py:9 fake.py:10 fake.py:11 fake.py:12 fake.py:13 fake.py:14 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
370 #: fake.py:15 fake.py:16 fake.py:17 fake.py:18 fake.py:19 fake.py:20 fake.py:21 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
371 #: fake.py:22 fake.py:23 fake.py:24 fake.py:25 fake.py:26 fake.py:27 fake.py:28 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
372 #: fake.py:29 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
373 msgid "pretty dam long message id, which must really be big to test this wrap behaviour, if not it won't work." |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
374 msgstr "" |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
375 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
376 """, buf.getvalue().lower()) |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
377 buf = StringIO() |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
378 pofile.write_po(buf, catalog, width=100, omit_header=True) |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
379 self.assertEqual("""\ |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
380 #: 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 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
381 #: 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 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
382 #: 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 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
383 #: fake.py:29 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
384 msgid "" |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
385 "pretty dam long message id, which must really be big to test this wrap behaviour, if not it won't" |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
386 " work." |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
387 msgstr "" |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
388 |
8f91314df0b9
Now, the `--width` option, although with a default value of 76, it's not set to any value initially so that the `--no-wrap` option can be passed without throwing an error. Fixes #145.
palgarvio
parents:
421
diff
changeset
|
389 """, buf.getvalue().lower()) |
315 | 390 |
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
|
391 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
|
392 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
|
393 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
|
394 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
|
395 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
|
396 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
|
397 '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
|
398 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
|
399 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
|
400 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
|
401 #: 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
|
402 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
|
403 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
|
404 |
105
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
405 # Comment About `bar` with |
f744dd56573d
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
104
diff
changeset
|
406 # 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
|
407 #: 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
|
408 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
|
409 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
|
410 |
190
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
411 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
|
412 catalog = Catalog() |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
413 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
|
414 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
|
415 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
|
416 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
|
417 buf = StringIO() |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
418 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
|
419 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
|
420 msgid "foo" |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
421 msgstr "Voh" |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
422 |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
423 # User comment |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
424 #~ msgid "bar" |
9a1acb41e7dd
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
175
diff
changeset
|
425 #~ 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
|
426 |
190
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
427 def test_po_with_multiline_obsolete_message(self): |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
428 catalog = Catalog() |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
429 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
|
430 msgid = r"""Here's a message that covers |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
431 multiple lines, and should still be handled |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
432 correctly. |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
433 """ |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
434 msgstr = r"""Here's a message that covers |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
435 multiple lines, and should still be handled |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
436 correctly. |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
437 """ |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
438 catalog.obsolete[msgid] = Message(msgid, msgstr, |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
439 locations=[('utils.py', 3)]) |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
440 buf = StringIO() |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
441 pofile.write_po(buf, catalog, omit_header=True) |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
442 self.assertEqual(r'''#: main.py:1 |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
443 msgid "foo" |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
444 msgstr "Voh" |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
445 |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
446 #~ msgid "" |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
447 #~ "Here's a message that covers\n" |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
448 #~ "multiple lines, and should still be handled\n" |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
449 #~ "correctly.\n" |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
450 #~ msgstr "" |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
451 #~ "Here's a message that covers\n" |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
452 #~ "multiple lines, and should still be handled\n" |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
453 #~ "correctly.\n"''', buf.getvalue().strip()) |
84193e6612f8
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
181
diff
changeset
|
454 |
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
|
455 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
|
456 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
|
457 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
|
458 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
|
459 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
|
460 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
|
461 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
|
462 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
|
463 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
|
464 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
|
465 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
|
466 |
203 | 467 def test_po_with_previous_msgid(self): |
468 catalog = Catalog() | |
469 catalog.add(u'foo', u'Voh', locations=[('main.py', 1)], | |
470 previous_id=u'fo') | |
471 buf = StringIO() | |
472 pofile.write_po(buf, catalog, omit_header=True, include_previous=True) | |
473 self.assertEqual('''#: main.py:1 | |
474 #| msgid "fo" | |
475 msgid "foo" | |
476 msgstr "Voh"''', buf.getvalue().strip()) | |
477 | |
478 def test_po_with_previous_msgid_plural(self): | |
479 catalog = Catalog() | |
480 catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'), | |
481 locations=[('main.py', 1)], previous_id=(u'fo', u'fos')) | |
482 buf = StringIO() | |
483 pofile.write_po(buf, catalog, omit_header=True, include_previous=True) | |
484 self.assertEqual('''#: main.py:1 | |
485 #| msgid "fo" | |
486 #| msgid_plural "fos" | |
487 msgid "foo" | |
488 msgid_plural "foos" | |
489 msgstr[0] "Voh" | |
490 msgstr[1] "Voeh"''', buf.getvalue().strip()) | |
491 | |
249
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
492 def test_sorted_po(self): |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
493 catalog = Catalog() |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
494 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
|
495 user_comments=['Comment About `bar` with', |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
496 'multiple lines.']) |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
497 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
|
498 locations=[('main.py', 1)]) |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
499 buf = StringIO() |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
500 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
|
501 value = buf.getvalue().strip() |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
502 assert '''\ |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
503 # Comment About `bar` with |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
504 # multiple lines. |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
505 #: utils.py:3 |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
506 msgid "bar" |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
507 msgstr "" |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
508 |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
509 #: main.py:1 |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
510 msgid "foo" |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
511 msgid_plural "foos" |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
512 msgstr[0] "Voh" |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
513 msgstr[1] "Voeh"''' in value |
00960ab0a631
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
228
diff
changeset
|
514 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
|
515 |
356
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
516 def test_silent_location_fallback(self): |
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
517 buf = StringIO('''\ |
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
518 #: broken_file.py |
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
519 msgid "missing line number" |
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
520 msgstr "" |
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
521 |
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
522 #: broken_file.py:broken_line_number |
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
523 msgid "broken line number" |
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
524 msgstr ""''') |
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
525 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
|
526 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
|
527 self.assertEqual(catalog['broken line number'].locations, []) |
356
1d75228aaa33
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
350
diff
changeset
|
528 |
1 | 529 def suite(): |
530 suite = unittest.TestSuite() | |
544
030ddf3f5b13
catalog.add() now returns the message instance (closes #245)
fschwarz
parents:
531
diff
changeset
|
531 suite.addTest(doctest.DocTestSuite(pofile, optionflags=doctest.ELLIPSIS)) |
106
9b22b36066f6
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
105
diff
changeset
|
532 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
|
533 suite.addTest(unittest.makeSuite(WritePoTestCase)) |
1 | 534 return suite |
535 | |
536 if __name__ == '__main__': | |
537 unittest.main(defaultTest='suite') |