Mercurial > babel > old > mirror
annotate babel/messages/tests/pofile.py @ 546:10de195cfb04
catalog.add() now returns the message instance (closes #245)
author | fschwarz |
---|---|
date | Sat, 19 Mar 2011 19:28:59 +0000 |
parents | 1869978e3895 |
children | 274f9a6485d4 |
rev | line source |
---|---|
3 | 1 # -*- coding: utf-8 -*- |
2 # | |
532 | 3 # Copyright (C) 2007-2011 Edgewall Software |
3 | 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 | |
106
2a00e352c986
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:
105
diff
changeset
|
14 from datetime import datetime |
3 | 15 import doctest |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
16 from StringIO import StringIO |
3 | 17 import unittest |
18 | |
183
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
19 from babel.messages.catalog import Catalog, Message |
56
27d55a07c897
Rename the `babel.catalog` package to `babel.messages` for consistency with the other package names.
cmlenz
parents:
53
diff
changeset
|
20 from babel.messages import pofile |
533 | 21 from babel.util import FixedOffsetTimezone |
3 | 22 |
19
762a5de6faae
Recognize python-format messages also for unnamed parameters.
cmlenz
parents:
14
diff
changeset
|
23 |
108
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
24 class ReadPoTestCase(unittest.TestCase): |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
25 |
198
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
26 def test_preserve_locale(self): |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
27 buf = StringIO(r'''msgid "foo" |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
28 msgstr "Voh"''') |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
29 catalog = pofile.read_po(buf, locale='en_US') |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
30 self.assertEqual('en_US', catalog.locale) |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
31 |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
32 def test_preserve_domain(self): |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
33 buf = StringIO(r'''msgid "foo" |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
34 msgstr "Voh"''') |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
35 catalog = pofile.read_po(buf, domain='mydomain') |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
36 self.assertEqual('mydomain', catalog.domain) |
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
37 |
108
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
38 def test_read_multiline(self): |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
39 buf = StringIO(r'''msgid "" |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
40 "Here's some text that\n" |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
41 "includesareallylongwordthatmightbutshouldnt" |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
42 " throw us into an infinite " |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
43 "loop\n" |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
44 msgstr ""''') |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
45 catalog = pofile.read_po(buf) |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
46 self.assertEqual(1, len(catalog)) |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
47 message = list(catalog)[1] |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
48 self.assertEqual("Here's some text that\nincludesareallylongwordthat" |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
49 "mightbutshouldnt throw us into an infinite loop\n", |
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
50 message.id) |
198
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
51 |
177
47f6c31e9a24
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:
108
diff
changeset
|
52 def test_fuzzy_header(self): |
47f6c31e9a24
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:
108
diff
changeset
|
53 buf = StringIO(r'''\ |
47f6c31e9a24
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:
108
diff
changeset
|
54 # Translations template for AReallyReallyLongNameForAProject. |
47f6c31e9a24
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:
108
diff
changeset
|
55 # Copyright (C) 2007 ORGANIZATION |
47f6c31e9a24
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:
108
diff
changeset
|
56 # This file is distributed under the same license as the |
47f6c31e9a24
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:
108
diff
changeset
|
57 # AReallyReallyLongNameForAProject project. |
47f6c31e9a24
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:
108
diff
changeset
|
58 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. |
47f6c31e9a24
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:
108
diff
changeset
|
59 # |
47f6c31e9a24
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:
108
diff
changeset
|
60 #, fuzzy |
47f6c31e9a24
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:
108
diff
changeset
|
61 ''') |
47f6c31e9a24
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:
108
diff
changeset
|
62 catalog = pofile.read_po(buf) |
47f6c31e9a24
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:
108
diff
changeset
|
63 self.assertEqual(1, len(list(catalog))) |
47f6c31e9a24
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:
108
diff
changeset
|
64 self.assertEqual(True, list(catalog)[0].fuzzy) |
198
982d7e704fdc
Fix for #35, and a minor improvement to how we parse the catalog fuzzy bit.
cmlenz
parents:
193
diff
changeset
|
65 |
177
47f6c31e9a24
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:
108
diff
changeset
|
66 def test_not_fuzzy_header(self): |
47f6c31e9a24
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:
108
diff
changeset
|
67 buf = StringIO(r'''\ |
47f6c31e9a24
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:
108
diff
changeset
|
68 # Translations template for AReallyReallyLongNameForAProject. |
47f6c31e9a24
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:
108
diff
changeset
|
69 # Copyright (C) 2007 ORGANIZATION |
47f6c31e9a24
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:
108
diff
changeset
|
70 # This file is distributed under the same license as the |
47f6c31e9a24
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:
108
diff
changeset
|
71 # AReallyReallyLongNameForAProject project. |
47f6c31e9a24
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:
108
diff
changeset
|
72 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. |
47f6c31e9a24
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:
108
diff
changeset
|
73 # |
47f6c31e9a24
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:
108
diff
changeset
|
74 ''') |
47f6c31e9a24
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:
108
diff
changeset
|
75 catalog = pofile.read_po(buf) |
47f6c31e9a24
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:
108
diff
changeset
|
76 self.assertEqual(1, len(list(catalog))) |
47f6c31e9a24
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:
108
diff
changeset
|
77 self.assertEqual(False, list(catalog)[0].fuzzy) |
108
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
78 |
293 | 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 | |
201
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
114 def test_obsolete_message(self): |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
115 buf = StringIO(r'''# This is an obsolete message |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
116 #~ msgid "foo" |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
117 #~ msgstr "Voh" |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
118 |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
119 # This message is not obsolete |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
120 #: main.py:1 |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
121 msgid "bar" |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
122 msgstr "Bahr" |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
123 ''') |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
124 catalog = pofile.read_po(buf) |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
125 self.assertEqual(1, len(catalog)) |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
126 self.assertEqual(1, len(catalog.obsolete)) |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
127 message = catalog.obsolete[u'foo'] |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
128 self.assertEqual(u'foo', message.id) |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
129 self.assertEqual(u'Voh', message.string) |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
130 self.assertEqual(['This is an obsolete message'], message.user_comments) |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
131 |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
132 def test_obsolete_message_ignored(self): |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
133 buf = StringIO(r'''# This is an obsolete message |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
134 #~ msgid "foo" |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
135 #~ msgstr "Voh" |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
136 |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
137 # This message is not obsolete |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
138 #: main.py:1 |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
139 msgid "bar" |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
140 msgstr "Bahr" |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
141 ''') |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
142 catalog = pofile.read_po(buf, ignore_obsolete=True) |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
143 self.assertEqual(1, len(catalog)) |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
144 self.assertEqual(0, len(catalog.obsolete)) |
10e8d072e2d1
Handle obsolete messages when parsing catalogs. Closes #32.
cmlenz
parents:
198
diff
changeset
|
145 |
337 | 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)) | |
352 | 161 message = catalog.get('foo', context='Menu') |
337 | 162 self.assertEqual('Menu', message.context) |
352 | 163 message = catalog.get('bar', context='Menu') |
337 | 164 self.assertEqual('Menu', message.context) |
165 | |
423 | 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 | |
430
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
172 def test_with_context_two(self): |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
173 buf = StringIO(r'''msgctxt "Menu" |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
174 msgid "foo" |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
175 msgstr "Voh" |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
176 |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
177 msgctxt "Mannu" |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
178 msgid "bar" |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
179 msgstr "Bahr" |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
180 ''') |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
181 catalog = pofile.read_po(buf, ignore_obsolete=True) |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
182 self.assertEqual(2, len(catalog)) |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
183 message = catalog.get('foo', context='Menu') |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
184 self.assertEqual('Menu', message.context) |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
185 message = catalog.get('bar', context='Mannu') |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
186 self.assertEqual('Mannu', message.context) |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
187 |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
188 # And verify it pass through write_po |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
189 out_buf = StringIO() |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
190 pofile.write_po(out_buf, catalog, omit_header=True) |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
191 assert out_buf.getvalue().strip() == buf.getvalue().strip(), out_buf.getvalue() |
70f72bc70a93
Fix for msgctxt parsing in PO files. Thanks to Asheesh Laroia for the patch. Closes #159.
cmlenz
parents:
425
diff
changeset
|
192 |
445 | 193 def test_single_plural_form(self): |
194 buf = StringIO(r'''msgid "foo" | |
448
ac3cd0d08e95
Actually make the msgid_plural be a plural as per typical use case.
jruigrok
parents:
447
diff
changeset
|
195 msgid_plural "foos" |
445 | 196 msgstr[0] "Voh"''') |
197 catalog = pofile.read_po(buf, locale='ja_JP') | |
198 self.assertEqual(1, len(catalog)) | |
199 self.assertEqual(1, catalog.num_plurals) | |
200 message = catalog['foo'] | |
201 self.assertEqual(1, len(message.string)) | |
202 | |
444 | 203 def test_singular_plural_form(self): |
372
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
204 buf = StringIO(r'''msgid "foo" |
448
ac3cd0d08e95
Actually make the msgid_plural be a plural as per typical use case.
jruigrok
parents:
447
diff
changeset
|
205 msgid_plural "foos" |
372
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
206 msgstr[0] "Voh" |
444 | 207 msgstr[1] "Vohs"''') |
208 catalog = pofile.read_po(buf, locale='nl_NL') | |
372
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
209 self.assertEqual(1, len(catalog)) |
444 | 210 self.assertEqual(2, catalog.num_plurals) |
379
de824f875d99
Use item access to catalog messages in tests, so that they can be easily ported back to the 0.9.x branch.
cmlenz
parents:
372
diff
changeset
|
211 message = catalog['foo'] |
444 | 212 self.assertEqual(2, len(message.string)) |
443
d2e9aaa7c91c
Make sure to only strip on the first occurence of ].
jruigrok
parents:
430
diff
changeset
|
213 |
372
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
214 def test_more_than_two_plural_forms(self): |
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
215 buf = StringIO(r'''msgid "foo" |
448
ac3cd0d08e95
Actually make the msgid_plural be a plural as per typical use case.
jruigrok
parents:
447
diff
changeset
|
216 msgid_plural "foos" |
372
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
217 msgstr[0] "Voh" |
447
841e5ca971a0
More than two plural forms work nowadays. Adjust the test.
jruigrok
parents:
446
diff
changeset
|
218 msgstr[1] "Vohs" |
841e5ca971a0
More than two plural forms work nowadays. Adjust the test.
jruigrok
parents:
446
diff
changeset
|
219 msgstr[2] "Vohss"''') |
372
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
220 catalog = pofile.read_po(buf, locale='lv_LV') |
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
221 self.assertEqual(1, len(catalog)) |
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
222 self.assertEqual(3, catalog.num_plurals) |
379
de824f875d99
Use item access to catalog messages in tests, so that they can be easily ported back to the 0.9.x branch.
cmlenz
parents:
372
diff
changeset
|
223 message = catalog['foo'] |
372
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
224 self.assertEqual(3, len(message.string)) |
447
841e5ca971a0
More than two plural forms work nowadays. Adjust the test.
jruigrok
parents:
446
diff
changeset
|
225 self.assertEqual(u'Vohss', message.string[2]) |
372
d1a9c618d2d5
We no longer neglect `catalog.plurals`. Added tests for it. Fixes #120.
palgarvio
parents:
358
diff
changeset
|
226 |
446
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
227 def test_plural_with_square_brackets(self): |
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
228 buf = StringIO(r'''msgid "foo" |
448
ac3cd0d08e95
Actually make the msgid_plural be a plural as per typical use case.
jruigrok
parents:
447
diff
changeset
|
229 msgid_plural "foos" |
446
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
230 msgstr[0] "Voh [text]" |
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
231 msgstr[1] "Vohs [text]"''') |
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
232 catalog = pofile.read_po(buf, locale='nb_NO') |
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
233 self.assertEqual(1, len(catalog)) |
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
234 self.assertEqual(2, catalog.num_plurals) |
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
235 message = catalog['foo'] |
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
236 self.assertEqual(2, len(message.string)) |
99f5a4551ba8
Put the square brackets test after all the normal plural tests. It's more
jruigrok
parents:
445
diff
changeset
|
237 |
108
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
238 |
106
2a00e352c986
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:
105
diff
changeset
|
239 class WritePoTestCase(unittest.TestCase): |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
240 |
93eaa2f4a0a2
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:
19
diff
changeset
|
241 def test_join_locations(self): |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
56
diff
changeset
|
242 catalog = Catalog() |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
56
diff
changeset
|
243 catalog.add(u'foo', locations=[('main.py', 1)]) |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
56
diff
changeset
|
244 catalog.add(u'foo', locations=[('utils.py', 3)]) |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
245 buf = StringIO() |
106
2a00e352c986
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:
105
diff
changeset
|
246 pofile.write_po(buf, catalog, omit_header=True) |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
247 self.assertEqual('''#: main.py:1 utils.py:3 |
93eaa2f4a0a2
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:
19
diff
changeset
|
248 msgid "foo" |
93eaa2f4a0a2
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:
19
diff
changeset
|
249 msgstr ""''', buf.getvalue().strip()) |
93eaa2f4a0a2
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:
19
diff
changeset
|
250 |
230
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
251 def test_duplicate_comments(self): |
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
252 catalog = Catalog() |
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
253 catalog.add(u'foo', auto_comments=['A comment']) |
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
254 catalog.add(u'foo', auto_comments=['A comment']) |
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
255 buf = StringIO() |
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
256 pofile.write_po(buf, catalog, omit_header=True) |
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
257 self.assertEqual('''#. A comment |
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
258 msgid "foo" |
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
259 msgstr ""''', buf.getvalue().strip()) |
aaf36f409166
Follow-up to [239]: also combine duplicate comments when writing PO files.
cmlenz
parents:
205
diff
changeset
|
260 |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
261 def test_wrap_long_lines(self): |
93eaa2f4a0a2
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:
19
diff
changeset
|
262 text = """Here's some text where |
93eaa2f4a0a2
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:
19
diff
changeset
|
263 white space and line breaks matter, and should |
93eaa2f4a0a2
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:
19
diff
changeset
|
264 |
93eaa2f4a0a2
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:
19
diff
changeset
|
265 not be removed |
93eaa2f4a0a2
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:
19
diff
changeset
|
266 |
93eaa2f4a0a2
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:
19
diff
changeset
|
267 """ |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
56
diff
changeset
|
268 catalog = Catalog() |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
56
diff
changeset
|
269 catalog.add(text, locations=[('main.py', 1)]) |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
270 buf = StringIO() |
106
2a00e352c986
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:
105
diff
changeset
|
271 pofile.write_po(buf, catalog, no_location=True, omit_header=True, |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
56
diff
changeset
|
272 width=42) |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
273 self.assertEqual(r'''msgid "" |
93eaa2f4a0a2
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:
19
diff
changeset
|
274 "Here's some text where \n" |
93eaa2f4a0a2
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:
19
diff
changeset
|
275 "white space and line breaks matter, and" |
93eaa2f4a0a2
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:
19
diff
changeset
|
276 " should\n" |
93eaa2f4a0a2
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:
19
diff
changeset
|
277 "\n" |
93eaa2f4a0a2
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:
19
diff
changeset
|
278 "not be removed\n" |
93eaa2f4a0a2
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:
19
diff
changeset
|
279 "\n" |
93eaa2f4a0a2
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:
19
diff
changeset
|
280 msgstr ""''', buf.getvalue().strip()) |
93eaa2f4a0a2
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:
19
diff
changeset
|
281 |
93eaa2f4a0a2
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:
19
diff
changeset
|
282 def test_wrap_long_lines_with_long_word(self): |
93eaa2f4a0a2
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:
19
diff
changeset
|
283 text = """Here's some text that |
93eaa2f4a0a2
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:
19
diff
changeset
|
284 includesareallylongwordthatmightbutshouldnt throw us into an infinite loop |
93eaa2f4a0a2
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:
19
diff
changeset
|
285 """ |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
56
diff
changeset
|
286 catalog = Catalog() |
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
56
diff
changeset
|
287 catalog.add(text, locations=[('main.py', 1)]) |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
288 buf = StringIO() |
106
2a00e352c986
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:
105
diff
changeset
|
289 pofile.write_po(buf, catalog, no_location=True, omit_header=True, |
58
068952b4d4c0
Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents:
56
diff
changeset
|
290 width=32) |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
291 self.assertEqual(r'''msgid "" |
93eaa2f4a0a2
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:
19
diff
changeset
|
292 "Here's some text that\n" |
93eaa2f4a0a2
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:
19
diff
changeset
|
293 "includesareallylongwordthatmightbutshouldnt" |
93eaa2f4a0a2
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:
19
diff
changeset
|
294 " throw us into an infinite " |
93eaa2f4a0a2
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:
19
diff
changeset
|
295 "loop\n" |
93eaa2f4a0a2
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:
19
diff
changeset
|
296 msgstr ""''', buf.getvalue().strip()) |
82
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
297 |
105
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
298 def test_wrap_long_lines_in_header(self): |
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
299 """ |
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
300 Verify that long lines in the header comment are wrapped correctly. |
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
301 """ |
106
2a00e352c986
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:
105
diff
changeset
|
302 catalog = Catalog(project='AReallyReallyLongNameForAProject', |
2a00e352c986
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:
105
diff
changeset
|
303 revision_date=datetime(2007, 4, 1)) |
105
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
304 buf = StringIO() |
106
2a00e352c986
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:
105
diff
changeset
|
305 pofile.write_po(buf, catalog) |
105
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
306 self.assertEqual('''\ |
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
307 # Translations template for AReallyReallyLongNameForAProject. |
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
308 # Copyright (C) 2007 ORGANIZATION |
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
309 # This file is distributed under the same license as the |
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
310 # AReallyReallyLongNameForAProject project. |
106
2a00e352c986
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:
105
diff
changeset
|
311 # FIRST AUTHOR <EMAIL@ADDRESS>, 2007. |
105
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
312 # |
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
313 #, fuzzy''', '\n'.join(buf.getvalue().splitlines()[:7])) |
abd3a594dab4
Implement wrapping of header comments in PO(T) output. Related to #14.
cmlenz
parents:
82
diff
changeset
|
314 |
317 | 315 def test_wrap_locations_with_hyphens(self): |
316 catalog = Catalog() | |
317 catalog.add(u'foo', locations=[ | |
318 ('doupy/templates/base/navmenu.inc.html.py', 60) | |
319 ]) | |
320 catalog.add(u'foo', locations=[ | |
321 ('doupy/templates/job-offers/helpers.html', 22) | |
322 ]) | |
323 buf = StringIO() | |
324 pofile.write_po(buf, catalog, omit_header=True) | |
325 self.assertEqual('''#: doupy/templates/base/navmenu.inc.html.py:60 | |
326 #: doupy/templates/job-offers/helpers.html:22 | |
327 msgid "foo" | |
328 msgstr ""''', buf.getvalue().strip()) | |
425
15541acbe8cb
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:
423
diff
changeset
|
329 |
15541acbe8cb
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:
423
diff
changeset
|
330 def test_no_wrap_and_width_behaviour_on_comments(self): |
15541acbe8cb
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:
423
diff
changeset
|
331 catalog = Catalog() |
15541acbe8cb
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:
423
diff
changeset
|
332 catalog.add("Pretty dam long message id, which must really be big " |
15541acbe8cb
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:
423
diff
changeset
|
333 "to test this wrap behaviour, if not it won't work.", |
15541acbe8cb
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:
423
diff
changeset
|
334 locations=[("fake.py", n) for n in range(1, 30)]) |
15541acbe8cb
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:
423
diff
changeset
|
335 buf = StringIO() |
15541acbe8cb
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:
423
diff
changeset
|
336 pofile.write_po(buf, catalog, width=None, omit_header=True) |
15541acbe8cb
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:
423
diff
changeset
|
337 self.assertEqual("""\ |
15541acbe8cb
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:
423
diff
changeset
|
338 #: fake.py:1 fake.py:2 fake.py:3 fake.py:4 fake.py:5 fake.py:6 fake.py:7 |
15541acbe8cb
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:
423
diff
changeset
|
339 #: fake.py:8 fake.py:9 fake.py:10 fake.py:11 fake.py:12 fake.py:13 fake.py:14 |
15541acbe8cb
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:
423
diff
changeset
|
340 #: fake.py:15 fake.py:16 fake.py:17 fake.py:18 fake.py:19 fake.py:20 fake.py:21 |
15541acbe8cb
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:
423
diff
changeset
|
341 #: fake.py:22 fake.py:23 fake.py:24 fake.py:25 fake.py:26 fake.py:27 fake.py:28 |
15541acbe8cb
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:
423
diff
changeset
|
342 #: fake.py:29 |
15541acbe8cb
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:
423
diff
changeset
|
343 msgid "pretty dam long message id, which must really be big to test this wrap behaviour, if not it won't work." |
15541acbe8cb
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:
423
diff
changeset
|
344 msgstr "" |
15541acbe8cb
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:
423
diff
changeset
|
345 |
15541acbe8cb
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:
423
diff
changeset
|
346 """, buf.getvalue().lower()) |
15541acbe8cb
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:
423
diff
changeset
|
347 buf = StringIO() |
15541acbe8cb
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:
423
diff
changeset
|
348 pofile.write_po(buf, catalog, width=100, omit_header=True) |
15541acbe8cb
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:
423
diff
changeset
|
349 self.assertEqual("""\ |
15541acbe8cb
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:
423
diff
changeset
|
350 #: 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 |
15541acbe8cb
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:
423
diff
changeset
|
351 #: 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 |
15541acbe8cb
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:
423
diff
changeset
|
352 #: 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 |
15541acbe8cb
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:
423
diff
changeset
|
353 #: fake.py:29 |
15541acbe8cb
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:
423
diff
changeset
|
354 msgid "" |
15541acbe8cb
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:
423
diff
changeset
|
355 "pretty dam long message id, which must really be big to test this wrap behaviour, if not it won't" |
15541acbe8cb
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:
423
diff
changeset
|
356 " work." |
15541acbe8cb
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:
423
diff
changeset
|
357 msgstr "" |
15541acbe8cb
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:
423
diff
changeset
|
358 |
15541acbe8cb
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:
423
diff
changeset
|
359 """, buf.getvalue().lower()) |
317 | 360 |
82
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
361 def test_pot_with_translator_comments(self): |
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
362 catalog = Catalog() |
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
363 catalog.add(u'foo', locations=[('main.py', 1)], |
107
4b42e23644e5
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
106
diff
changeset
|
364 auto_comments=['Comment About `foo`']) |
82
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
365 catalog.add(u'bar', locations=[('utils.py', 3)], |
107
4b42e23644e5
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
106
diff
changeset
|
366 user_comments=['Comment About `bar` with', |
4b42e23644e5
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
106
diff
changeset
|
367 'multiple lines.']) |
82
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
368 buf = StringIO() |
106
2a00e352c986
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:
105
diff
changeset
|
369 pofile.write_po(buf, catalog, omit_header=True) |
82
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
370 self.assertEqual('''#. Comment About `foo` |
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
371 #: main.py:1 |
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
372 msgid "foo" |
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
373 msgstr "" |
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
374 |
107
4b42e23644e5
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
106
diff
changeset
|
375 # Comment About `bar` with |
4b42e23644e5
`Message`, `read_po` and `write_po` now all handle user/auto comments correctly.
palgarvio
parents:
106
diff
changeset
|
376 # multiple lines. |
82
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
377 #: utils.py:3 |
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
378 msgid "bar" |
f421e5576d26
Added support for translator comments at the API and frontends levels.(See #12, item 1). Updated docs and tests accordingly.
palgarvio
parents:
58
diff
changeset
|
379 msgstr ""''', buf.getvalue().strip()) |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
380 |
192
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
381 def test_po_with_obsolete_message(self): |
183
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
382 catalog = Catalog() |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
383 catalog.add(u'foo', u'Voh', locations=[('main.py', 1)]) |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
384 catalog.obsolete['bar'] = Message(u'bar', u'Bahr', |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
385 locations=[('utils.py', 3)], |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
386 user_comments=['User comment']) |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
387 buf = StringIO() |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
388 pofile.write_po(buf, catalog, omit_header=True) |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
389 self.assertEqual('''#: main.py:1 |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
390 msgid "foo" |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
391 msgstr "Voh" |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
392 |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
393 # User comment |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
394 #~ msgid "bar" |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
395 #~ msgstr "Bahr"''', buf.getvalue().strip()) |
e927dffc9ab4
The frontends now provide ways to update existing translations catalogs from a template. Closes #22.
cmlenz
parents:
177
diff
changeset
|
396 |
192
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
397 def test_po_with_multiline_obsolete_message(self): |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
398 catalog = Catalog() |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
399 catalog.add(u'foo', u'Voh', locations=[('main.py', 1)]) |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
400 msgid = r"""Here's a message that covers |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
401 multiple lines, and should still be handled |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
402 correctly. |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
403 """ |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
404 msgstr = r"""Here's a message that covers |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
405 multiple lines, and should still be handled |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
406 correctly. |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
407 """ |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
408 catalog.obsolete[msgid] = Message(msgid, msgstr, |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
409 locations=[('utils.py', 3)]) |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
410 buf = StringIO() |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
411 pofile.write_po(buf, catalog, omit_header=True) |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
412 self.assertEqual(r'''#: main.py:1 |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
413 msgid "foo" |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
414 msgstr "Voh" |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
415 |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
416 #~ msgid "" |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
417 #~ "Here's a message that covers\n" |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
418 #~ "multiple lines, and should still be handled\n" |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
419 #~ "correctly.\n" |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
420 #~ msgstr "" |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
421 #~ "Here's a message that covers\n" |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
422 #~ "multiple lines, and should still be handled\n" |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
423 #~ "correctly.\n"''', buf.getvalue().strip()) |
8f5805197198
Correctly write out obsolete messages spanning multiple lines. Fixes #33.
cmlenz
parents:
183
diff
changeset
|
424 |
193
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
425 def test_po_with_obsolete_message_ignored(self): |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
426 catalog = Catalog() |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
427 catalog.add(u'foo', u'Voh', locations=[('main.py', 1)]) |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
428 catalog.obsolete['bar'] = Message(u'bar', u'Bahr', |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
429 locations=[('utils.py', 3)], |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
430 user_comments=['User comment']) |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
431 buf = StringIO() |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
432 pofile.write_po(buf, catalog, omit_header=True, ignore_obsolete=True) |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
433 self.assertEqual('''#: main.py:1 |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
434 msgid "foo" |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
435 msgstr "Voh"''', buf.getvalue().strip()) |
b5e58a22ebd2
Add an option to the frontend commands for catalog updating that removes completely any obsolete messages, instead of putting them comments.
cmlenz
parents:
192
diff
changeset
|
436 |
205 | 437 def test_po_with_previous_msgid(self): |
438 catalog = Catalog() | |
439 catalog.add(u'foo', u'Voh', locations=[('main.py', 1)], | |
440 previous_id=u'fo') | |
441 buf = StringIO() | |
442 pofile.write_po(buf, catalog, omit_header=True, include_previous=True) | |
443 self.assertEqual('''#: main.py:1 | |
444 #| msgid "fo" | |
445 msgid "foo" | |
446 msgstr "Voh"''', buf.getvalue().strip()) | |
447 | |
448 def test_po_with_previous_msgid_plural(self): | |
449 catalog = Catalog() | |
450 catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'), | |
451 locations=[('main.py', 1)], previous_id=(u'fo', u'fos')) | |
452 buf = StringIO() | |
453 pofile.write_po(buf, catalog, omit_header=True, include_previous=True) | |
454 self.assertEqual('''#: main.py:1 | |
455 #| msgid "fo" | |
456 #| msgid_plural "fos" | |
457 msgid "foo" | |
458 msgid_plural "foos" | |
459 msgstr[0] "Voh" | |
460 msgstr[1] "Voeh"''', buf.getvalue().strip()) | |
461 | |
251
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
462 def test_sorted_po(self): |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
463 catalog = Catalog() |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
464 catalog.add(u'bar', locations=[('utils.py', 3)], |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
465 user_comments=['Comment About `bar` with', |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
466 'multiple lines.']) |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
467 catalog.add((u'foo', u'foos'), (u'Voh', u'Voeh'), |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
468 locations=[('main.py', 1)]) |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
469 buf = StringIO() |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
470 pofile.write_po(buf, catalog, sort_output=True) |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
471 value = buf.getvalue().strip() |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
472 assert '''\ |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
473 # Comment About `bar` with |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
474 # multiple lines. |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
475 #: utils.py:3 |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
476 msgid "bar" |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
477 msgstr "" |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
478 |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
479 #: main.py:1 |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
480 msgid "foo" |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
481 msgid_plural "foos" |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
482 msgstr[0] "Voh" |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
483 msgstr[1] "Voeh"''' in value |
3b9d993b7aa3
added test cases for correct po/mofile sorting, following up r264
pjenvey
parents:
230
diff
changeset
|
484 assert value.find('msgid ""') < value.find('msgid "bar"') < value.find('msgid "foo"') |
26
93eaa2f4a0a2
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:
19
diff
changeset
|
485 |
358
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
486 def test_silent_location_fallback(self): |
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
487 buf = StringIO('''\ |
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
488 #: broken_file.py |
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
489 msgid "missing line number" |
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
490 msgstr "" |
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
491 |
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
492 #: broken_file.py:broken_line_number |
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
493 msgid "broken line number" |
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
494 msgstr ""''') |
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
495 catalog = pofile.read_po(buf) |
379
de824f875d99
Use item access to catalog messages in tests, so that they can be easily ported back to the 0.9.x branch.
cmlenz
parents:
372
diff
changeset
|
496 self.assertEqual(catalog['missing line number'].locations, []) |
de824f875d99
Use item access to catalog messages in tests, so that they can be easily ported back to the 0.9.x branch.
cmlenz
parents:
372
diff
changeset
|
497 self.assertEqual(catalog['broken line number'].locations, []) |
358
c82ad0f5ff65
Fixed #59 by falling back silently on invalid location comments.
aronacher
parents:
352
diff
changeset
|
498 |
3 | 499 def suite(): |
500 suite = unittest.TestSuite() | |
546
10de195cfb04
catalog.add() now returns the message instance (closes #245)
fschwarz
parents:
533
diff
changeset
|
501 suite.addTest(doctest.DocTestSuite(pofile, optionflags=doctest.ELLIPSIS)) |
108
8ea225f33f28
Fix for #16: the header message (`msgid = ""`) is now treated specially by `read_po` and `Catalog`.
cmlenz
parents:
107
diff
changeset
|
502 suite.addTest(unittest.makeSuite(ReadPoTestCase)) |
106
2a00e352c986
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:
105
diff
changeset
|
503 suite.addTest(unittest.makeSuite(WritePoTestCase)) |
3 | 504 return suite |
505 | |
506 if __name__ == '__main__': | |
507 unittest.main(defaultTest='suite') |