Mercurial > babel > mirror

annotate babel/messages/pofile.py @ 68:269941aa0e55 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add back POT header broken in previous check-in.
author cmlenz
date Fri, 08 Jun 2007 15:47:00 +0000
parents 7b2fcd6d6d26
children 27f01e7626ea
rev   line source
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
1 # -*- coding: utf-8 -*-
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
2 #
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
3 # Copyright (C) 2007 Edgewall Software
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
4 # All rights reserved.
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
5 #
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
6 # This software is licensed as described in the file COPYING, which
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
7 # you should have received as part of this distribution. The terms
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
8 # are also available at http://babel.edgewall.org/wiki/License.
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
9 #
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
10 # This software consists of voluntary contributions made by many
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
11 # individuals. For the exact contribution history, see the revision
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
12 # history and logs, available at http://babel.edgewall.org/log/.
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
13
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
14 """Reading and writing of files in the ``gettext`` PO (portable object)
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
15 format.
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
16
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
17 :see: `The Format of PO Files
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
18 <http://www.gnu.org/software/gettext/manual/gettext.html#PO-Files>`_
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
19 """
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
20
5
132526dcd074 * The creation-date header in generated PO files now includes the timezone offset.
cmlenz
parents: 1
diff changeset
21 from datetime import date, datetime
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
22 import re
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
23 try:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
24 set
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
25 except NameError:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
26 from sets import Set as set
24
b09e90803d1b 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: 23
diff changeset
27 import textwrap
5
132526dcd074 * The creation-date header in generated PO files now includes the timezone offset.
cmlenz
parents: 1
diff changeset
28 import time
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
29
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
30 from babel import __version__ as VERSION
56
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
31 from babel.messages.catalog import Catalog
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
32
51
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
33 __all__ = ['escape', 'normalize', 'read_po', 'write_po', 'write_pot']
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
34
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
35 def read_po(fileobj):
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
36 """Read messages from a ``gettext`` PO (portable object) file from the given
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
37 file-like object and return a `Catalog`.
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
38
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
39 >>> from StringIO import StringIO
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
40 >>> buf = StringIO('''
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
41 ... #: main.py:1
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
42 ... #, fuzzy, python-format
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
43 ... msgid "foo %(name)s"
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
44 ... msgstr ""
21
cd9aa202568e Change pot header's first line, "Translations Template for %%(project)s." instead of "SOME DESCRIPTIVE TITLE.". '''`project`''' and '''`version`''' now default to '''PROJECT''' and '''VERSION''' respectively. Fixed a bug regarding '''Content-Transfer-Encoding''', it shouldn't be the charset, and we're defaulting to `8bit` untill someone complains.
palgarvio
parents: 17
diff changeset
45 ...
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
46 ... #: main.py:3
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
47 ... msgid "bar"
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
48 ... msgid_plural "baz"
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
49 ... msgstr[0] ""
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
50 ... msgstr[1] ""
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
51 ... ''')
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
52 >>> catalog = read_po(buf)
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
53 >>> for message in catalog:
67
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
54 ... if message.id:
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
55 ... print (message.id, message.string)
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
56 ... print ' ', (message.locations, message.flags)
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
57 ('foo %(name)s', '')
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
58 ([('main.py', 1)], set(['fuzzy', 'python-format']))
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
59 (('bar', 'baz'), ('', ''))
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
60 ([('main.py', 3)], set([]))
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
61
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
62 :param fileobj: the file-like object to read the PO file from
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
63 :return: an iterator over ``(message, translation, location)`` tuples
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
64 :rtype: ``iterator``
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
65 """
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
66 catalog = Catalog()
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
67
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
68 messages = []
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
69 translations = []
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
70 locations = []
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
71 flags = []
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
72 in_msgid = in_msgstr = False
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
73
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
74 def _add_message():
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
75 translations.sort()
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
76 if len(messages) > 1:
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
77 msgid = tuple(messages)
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
78 else:
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
79 msgid = messages[0]
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
80 if len(translations) > 1:
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
81 string = tuple([t[1] for t in translations])
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
82 else:
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
83 string = translations[0][1]
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
84 catalog.add(msgid, string, list(locations), set(flags))
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
85 del messages[:]; del translations[:]; del locations[:]; del flags[:]
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
86
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
87 for line in fileobj.readlines():
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
88 line = line.strip()
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
89 if line.startswith('#'):
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
90 in_msgid = in_msgstr = False
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
91 if messages:
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
92 _add_message()
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
93 if line[1:].startswith(':'):
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
94 for location in line[2:].lstrip().split():
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
95 filename, lineno = location.split(':', 1)
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
96 locations.append((filename, int(lineno)))
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
97 elif line[1:].startswith(','):
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
98 for flag in line[2:].lstrip().split(','):
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
99 flags.append(flag.strip())
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
100 elif line:
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
101 if line.startswith('msgid_plural'):
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
102 in_msgid = True
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
103 msg = line[12:].lstrip()
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
104 messages.append(msg[1:-1])
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
105 elif line.startswith('msgid'):
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
106 in_msgid = True
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
107 if messages:
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
108 _add_message()
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
109 msg = line[5:].lstrip()
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
110 messages.append(msg[1:-1])
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
111 elif line.startswith('msgstr'):
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
112 in_msgid = False
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
113 in_msgstr = True
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
114 msg = line[6:].lstrip()
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
115 if msg.startswith('['):
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
116 idx, msg = msg[1:].split(']')
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
117 translations.append([int(idx), msg.lstrip()[1:-1]])
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
118 else:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
119 translations.append([0, msg[1:-1]])
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
120 elif line.startswith('"'):
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
121 if in_msgid:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
122 messages[-1] += line.rstrip()[1:-1]
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
123 elif in_msgstr:
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
124 translations[-1][1] += line.rstrip()[1:-1]
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
125
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
126 if messages:
64
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
127 _add_message()
ef318245cfe5 `read_po` now returns a `Catalog`.
cmlenz
parents: 56
diff changeset
128 return catalog
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
129
24
b09e90803d1b 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: 23
diff changeset
130 POT_HEADER = """\
68
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
131 # Translations template for %(project)s.
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
132 # Copyright (C) %(year)s ORGANIZATION
27
54ad80b62674 Changing `write_po` to include licensing info, same as the project. Since the method is also to create the initial pot file, we also include the year in the copyright. We also mark the translations catalog template as fuzzy as it should be, only localized translations catalogs ready to be compiled should not include the fuzzy bit on the header.
palgarvio
parents: 26
diff changeset
133 # This file is distributed under the same license as the
68
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
134 # %(project)s project.
24
b09e90803d1b 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: 23
diff changeset
135 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
b09e90803d1b 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: 23
diff changeset
136 #
68
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
137 """
24
b09e90803d1b 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: 23
diff changeset
138
b09e90803d1b 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: 23
diff changeset
139 WORD_SEP = re.compile('('
b09e90803d1b 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: 23
diff changeset
140 r'\s+|' # any whitespace
b09e90803d1b 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: 23
diff changeset
141 r'[^\s\w]*\w+[a-zA-Z]-(?=\w+[a-zA-Z])|' # hyphenated words
b09e90803d1b 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: 23
diff changeset
142 r'(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w)' # em-dash
b09e90803d1b 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: 23
diff changeset
143 ')')
b09e90803d1b 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: 23
diff changeset
144
b09e90803d1b 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: 23
diff changeset
145 def escape(string):
b09e90803d1b 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: 23
diff changeset
146 r"""Escape the given string so that it can be included in double-quoted
b09e90803d1b 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: 23
diff changeset
147 strings in ``PO`` files.
b09e90803d1b 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: 23
diff changeset
148
b09e90803d1b 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: 23
diff changeset
149 >>> escape('''Say:
b09e90803d1b 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: 23
diff changeset
150 ... "hello, world!"
b09e90803d1b 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: 23
diff changeset
151 ... ''')
b09e90803d1b 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: 23
diff changeset
152 '"Say:\\n \\"hello, world!\\"\\n"'
b09e90803d1b 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: 23
diff changeset
153
b09e90803d1b 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: 23
diff changeset
154 :param string: the string to escape
b09e90803d1b 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: 23
diff changeset
155 :return: the escaped string
b09e90803d1b 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: 23
diff changeset
156 :rtype: `str` or `unicode`
b09e90803d1b 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: 23
diff changeset
157 """
b09e90803d1b 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: 23
diff changeset
158 return '"%s"' % string.replace('\\', '\\\\') \
b09e90803d1b 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: 23
diff changeset
159 .replace('\t', '\\t') \
b09e90803d1b 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: 23
diff changeset
160 .replace('\r', '\\r') \
b09e90803d1b 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: 23
diff changeset
161 .replace('\n', '\\n') \
b09e90803d1b 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: 23
diff changeset
162 .replace('\"', '\\"')
b09e90803d1b 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: 23
diff changeset
163
b09e90803d1b 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: 23
diff changeset
164 def normalize(string, width=76):
b09e90803d1b 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: 23
diff changeset
165 r"""This converts a string into a format that is appropriate for .po files.
b09e90803d1b 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: 23
diff changeset
166
b09e90803d1b 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: 23
diff changeset
167 >>> print normalize('''Say:
b09e90803d1b 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: 23
diff changeset
168 ... "hello, world!"
b09e90803d1b 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: 23
diff changeset
169 ... ''', width=None)
b09e90803d1b 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: 23
diff changeset
170 ""
b09e90803d1b 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: 23
diff changeset
171 "Say:\n"
b09e90803d1b 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: 23
diff changeset
172 " \"hello, world!\"\n"
b09e90803d1b 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: 23
diff changeset
173
b09e90803d1b 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: 23
diff changeset
174 >>> print normalize('''Say:
b09e90803d1b 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: 23
diff changeset
175 ... "Lorem ipsum dolor sit amet, consectetur adipisicing elit, "
b09e90803d1b 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: 23
diff changeset
176 ... ''', width=32)
b09e90803d1b 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: 23
diff changeset
177 ""
b09e90803d1b 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: 23
diff changeset
178 "Say:\n"
b09e90803d1b 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: 23
diff changeset
179 " \"Lorem ipsum dolor sit "
b09e90803d1b 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: 23
diff changeset
180 "amet, consectetur adipisicing"
b09e90803d1b 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: 23
diff changeset
181 " elit, \"\n"
b09e90803d1b 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: 23
diff changeset
182
b09e90803d1b 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: 23
diff changeset
183 :param string: the string to normalize
b09e90803d1b 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: 23
diff changeset
184 :param width: the maximum line width; use `None`, 0, or a negative number
b09e90803d1b 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: 23
diff changeset
185 to completely disable line wrapping
b09e90803d1b 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: 23
diff changeset
186 :return: the normalized string
b09e90803d1b 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: 23
diff changeset
187 :rtype: `unicode`
b09e90803d1b 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: 23
diff changeset
188 """
b09e90803d1b 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: 23
diff changeset
189 if width and width > 0:
b09e90803d1b 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: 23
diff changeset
190 lines = []
b09e90803d1b 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: 23
diff changeset
191 for idx, line in enumerate(string.splitlines(True)):
b09e90803d1b 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: 23
diff changeset
192 if len(escape(line)) > width:
b09e90803d1b 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: 23
diff changeset
193 chunks = WORD_SEP.split(line)
b09e90803d1b 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: 23
diff changeset
194 chunks.reverse()
b09e90803d1b 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: 23
diff changeset
195 while chunks:
b09e90803d1b 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: 23
diff changeset
196 buf = []
b09e90803d1b 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: 23
diff changeset
197 size = 2
b09e90803d1b 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: 23
diff changeset
198 while chunks:
b09e90803d1b 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: 23
diff changeset
199 l = len(escape(chunks[-1])) - 2
b09e90803d1b 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: 23
diff changeset
200 if size + l < width:
b09e90803d1b 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: 23
diff changeset
201 buf.append(chunks.pop())
b09e90803d1b 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: 23
diff changeset
202 size += l
b09e90803d1b 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: 23
diff changeset
203 else:
b09e90803d1b 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: 23
diff changeset
204 if not buf:
b09e90803d1b 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: 23
diff changeset
205 # handle long chunks by putting them on a
b09e90803d1b 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: 23
diff changeset
206 # separate line
b09e90803d1b 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: 23
diff changeset
207 buf.append(chunks.pop())
b09e90803d1b 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: 23
diff changeset
208 break
b09e90803d1b 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: 23
diff changeset
209 lines.append(u''.join(buf))
b09e90803d1b 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: 23
diff changeset
210 else:
b09e90803d1b 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: 23
diff changeset
211 lines.append(line)
b09e90803d1b 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: 23
diff changeset
212 else:
b09e90803d1b 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: 23
diff changeset
213 lines = string.splitlines(True)
b09e90803d1b 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: 23
diff changeset
214
67
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
215 if len(lines) <= 1:
24
b09e90803d1b 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: 23
diff changeset
216 return escape(string)
b09e90803d1b 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: 23
diff changeset
217
b09e90803d1b 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: 23
diff changeset
218 # Remove empty trailing line
67
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
219 if lines and not lines[-1]:
24
b09e90803d1b 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: 23
diff changeset
220 del lines[-1]
b09e90803d1b 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: 23
diff changeset
221 lines[-1] += '\n'
b09e90803d1b 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: 23
diff changeset
222 return u'""\n' + u'\n'.join([escape(l) for l in lines])
b09e90803d1b 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: 23
diff changeset
223
56
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
224 def write_pot(fileobj, catalog, project='PROJECT', version='VERSION', width=76,
21
cd9aa202568e Change pot header's first line, "Translations Template for %%(project)s." instead of "SOME DESCRIPTIVE TITLE.". '''`project`''' and '''`version`''' now default to '''PROJECT''' and '''VERSION''' respectively. Fixed a bug regarding '''Content-Transfer-Encoding''', it shouldn't be the charset, and we're defaulting to `8bit` untill someone complains.
palgarvio
parents: 17
diff changeset
225 charset='utf-8', no_location=False, omit_header=False):
56
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
226 r"""Write a ``gettext`` PO (portable object) template file for a given
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
227 message catalog to the provided file-like object.
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
228
56
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
229 >>> catalog = Catalog()
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
230 >>> catalog.add(u'foo %(name)s', locations=[('main.py', 1)],
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
231 ... flags=('fuzzy',))
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
232 >>> catalog.add((u'bar', u'baz'), locations=[('main.py', 3)])
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
233 >>> from StringIO import StringIO
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
234 >>> buf = StringIO()
56
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
235 >>> write_pot(buf, catalog, omit_header=True)
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
236
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
237 >>> print buf.getvalue()
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
238 #: main.py:1
6
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
239 #, fuzzy, python-format
c3b1b0b3d129 Add basic PO file parsing, and change the PO writing procedure to also take flags (such as "python-format" or "fuzzy").
cmlenz
parents: 5
diff changeset
240 msgid "foo %(name)s"
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
241 msgstr ""
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
242 <BLANKLINE>
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
243 #: main.py:3
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
244 msgid "bar"
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
245 msgid_plural "baz"
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
246 msgstr[0] ""
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
247 msgstr[1] ""
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
248 <BLANKLINE>
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
249 <BLANKLINE>
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
250
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
251 :param fileobj: the file-like object to write to
67
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
252 :param catalog: the `Catalog` instance
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
253 :param project: the project name
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
254 :param version: the project version
24
b09e90803d1b 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: 23
diff changeset
255 :param width: the maximum line width for the generated output; use `None`,
b09e90803d1b 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: 23
diff changeset
256 0, or a negative number to completely disable line wrapping
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
257 :param charset: the encoding
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
258 :param no_location: do not emit a location comment for every message
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
259 :param omit_header: do not include the ``msgid ""`` entry at the top of the
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
260 output
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
261 """
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
262 def _normalize(key):
24
b09e90803d1b 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: 23
diff changeset
263 return normalize(key, width=width).encode(charset, 'backslashreplace')
b09e90803d1b 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: 23
diff changeset
264
b09e90803d1b 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: 23
diff changeset
265 def _write(text):
b09e90803d1b 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: 23
diff changeset
266 if isinstance(text, unicode):
b09e90803d1b 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: 23
diff changeset
267 text = text.encode(charset)
b09e90803d1b 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: 23
diff changeset
268 fileobj.write(text)
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
269
68
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
270 catalog.project = project
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
271 catalog.version = version
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
272 catalog.charset = charset
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
273
67
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
274 for message in catalog:
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
275 if not message.id: # This is the header "message"
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
276 if omit_header:
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
277 continue
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
278 _write(POT_HEADER % {
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
279 'year': time.strftime('%Y'),
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
280 'project': project,
7b2fcd6d6d26 Enhance catalog to also manage the MIME headers.
cmlenz
parents: 64
diff changeset
281 })
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
282
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
283 if not no_location:
56
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
284 locs = u' '.join([u'%s:%d' % item for item in message.locations])
24
b09e90803d1b 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: 23
diff changeset
285 if width and width > 0:
b09e90803d1b 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: 23
diff changeset
286 locs = textwrap.wrap(locs, width, break_long_words=False)
b09e90803d1b 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: 23
diff changeset
287 for line in locs:
b09e90803d1b 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: 23
diff changeset
288 _write('#: %s\n' % line.strip())
56
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
289 if message.flags:
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
290 _write('#%s\n' % ', '.join([''] + list(message.flags)))
24
b09e90803d1b 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: 23
diff changeset
291
56
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
292 if isinstance(message.id, (list, tuple)):
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
293 _write('msgid %s\n' % _normalize(message.id[0]))
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
294 _write('msgid_plural %s\n' % _normalize(message.id[1]))
68
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
295 for i, string in enumerate(message.string):
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
296 _write('msgstr[%d] %s\n' % (i, _normalize(message.string[i])))
1
7870274479f5 Import of initial code base.
cmlenz
parents:
diff changeset
297 else:
56
f40fc143439c Add actual data structures for handling message catalogs, so that more code can be reused here between the frontends.
cmlenz
parents: 55
diff changeset
298 _write('msgid %s\n' % _normalize(message.id))
68
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
299 _write('msgstr %s\n' % _normalize(message.string or ''))
24
b09e90803d1b 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: 23
diff changeset
300 _write('\n')
51
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
301
55
a258e4015eb6 `new_catalog` now accepts another argument, `--domain`, which is used to build the output file path, which now is of the form `<output_dir>/<locale>/<domain>.po`, the correct form.
palgarvio
parents: 54
diff changeset
302 def write_po(fileobj, input_fileobj, locale_obj, project='PROJECT',
51
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
303 version='VERSION', first_author=None, first_author_email=None,
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
304 plurals=('INTEGER', 'EXPRESSION')):
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
305 r"""Write a ``gettext`` PO (portable object) file to the given file-like
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
306 object, from the given input PO template file.
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
307
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
308 >>> from StringIO import StringIO
55
a258e4015eb6 `new_catalog` now accepts another argument, `--domain`, which is used to build the output file path, which now is of the form `<output_dir>/<locale>/<domain>.po`, the correct form.
palgarvio
parents: 54
diff changeset
309 >>> from babel import Locale
a258e4015eb6 `new_catalog` now accepts another argument, `--domain`, which is used to build the output file path, which now is of the form `<output_dir>/<locale>/<domain>.po`, the correct form.
palgarvio
parents: 54
diff changeset
310 >>> locale_obj = Locale.parse('pt_PT')
68
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
311 >>> inbuf = StringIO(r'''# Translations template for FooBar.
51
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
312 ... # Copyright (C) 2007 ORGANIZATION
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
313 ... # This file is distributed under the same license as the
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
314 ... # FooBar project.
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
315 ... # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
316 ... #
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
317 ... #, fuzzy
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
318 ... msgid ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
319 ... msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
320 ... "Project-Id-Version: FooBar 0.1\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
321 ... "POT-Creation-Date: 2007-06-07 22:54+0100\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
322 ... "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
323 ... "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
324 ... "Language-Team: LANGUAGE <LL@li.org>\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
325 ... "MIME-Version: 1.0\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
326 ... "Content-Type: text/plain; charset=utf-8\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
327 ... "Content-Transfer-Encoding: 8bit\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
328 ... "Generated-By: Babel 0.1dev-r50\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
329 ...
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
330 ... #: base.py:83 templates/index.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
331 ... #: templates/index2.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
332 ... msgid "Home"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
333 ... msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
334 ...
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
335 ... #: base.py:84 templates/index.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
336 ... msgid "Accounts"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
337 ... msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
338 ... ''')
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
339 >>> outbuf = StringIO()
55
a258e4015eb6 `new_catalog` now accepts another argument, `--domain`, which is used to build the output file path, which now is of the form `<output_dir>/<locale>/<domain>.po`, the correct form.
palgarvio
parents: 54
diff changeset
340 >>> write_po(outbuf, inbuf, locale_obj, project='FooBar',
51
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
341 ... version='0.1', first_author='A Name',
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
342 ... first_author_email='user@domain.tld',
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
343 ... plurals=(2, '(n != 1)'))
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
344 >>> print outbuf.getvalue() # doctest: +ELLIPSIS
55
a258e4015eb6 `new_catalog` now accepts another argument, `--domain`, which is used to build the output file path, which now is of the form `<output_dir>/<locale>/<domain>.po`, the correct form.
palgarvio
parents: 54
diff changeset
345 # Portuguese (Portugal) Translations for FooBar
51
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
346 # Copyright (C) 2007 ORGANIZATION
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
347 # This file is distributed under the same license as the
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
348 # FooBar project.
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
349 # A Name <user@domain.tld>, ...
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
350 #
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
351 #, fuzzy
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
352 msgid ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
353 msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
354 "Project-Id-Version: FooBar 0.1\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
355 "POT-Creation-Date: 2007-06-07 22:54+0100\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
356 "PO-Revision-Date: ...\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
357 "Last-Translator: A Name <user@domain.tld>\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
358 "Language-Team: LANGUAGE <LL@li.org>\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
359 "MIME-Version: 1.0\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
360 "Content-Type: text/plain; charset=utf-8\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
361 "Content-Transfer-Encoding: 8bit\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
362 "Plural-Forms: nplurals=2; plural=(n != 1);\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
363 "Generated-By: Babel ...\n"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
364 <BLANKLINE>
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
365 #: base.py:83 templates/index.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
366 #: templates/index2.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
367 msgid "Home"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
368 msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
369 <BLANKLINE>
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
370 #: base.py:84 templates/index.html:9
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
371 msgid "Accounts"
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
372 msgstr ""
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
373 <BLANKLINE>
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
374 >>>
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
375 """
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
376
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
377 _first_author = ''
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
378 if first_author:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
379 _first_author += first_author
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
380 if first_author_email:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
381 _first_author += ' <%s>' % first_author_email
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
382
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
383 inlines = input_fileobj.readlines()
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
384 outlines = []
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
385 in_header = True
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
386 for index in range(len(inlines)):
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
387 if in_header:
68
269941aa0e55 Add back POT header broken in previous check-in.
cmlenz
parents: 67
diff changeset
388 if '# Translations template' in inlines[index]:
55
a258e4015eb6 `new_catalog` now accepts another argument, `--domain`, which is used to build the output file path, which now is of the form `<output_dir>/<locale>/<domain>.po`, the correct form.
palgarvio
parents: 54
diff changeset
389 outlines.append('# %s Translations for %s\n' % \
a258e4015eb6 `new_catalog` now accepts another argument, `--domain`, which is used to build the output file path, which now is of the form `<output_dir>/<locale>/<domain>.po`, the correct form.
palgarvio
parents: 54
diff changeset
390 (locale_obj.english_name, project))
51
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
391 elif '# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.' in inlines[index]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
392 if _first_author:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
393 outlines.append(
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
394 '# %s, %s\n' % (_first_author, time.strftime('%Y'))
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
395 )
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
396 else:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
397 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
398 elif '"PO-Revision-Date:' in inlines[index]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
399 outlines.append(
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
400 '"PO-Revision-Date: %s\\n"\n' % \
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
401 time.strftime('%Y-%m-%d %H:%M%z')
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
402 )
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
403 elif '"Last-Translator:' in inlines[index]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
404 if _first_author:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
405 outlines.append(
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
406 '"Last-Translator: %s\\n"\n' % _first_author
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
407 )
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
408 else:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
409 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
410 elif '"Content-Transfer-Encoding:' in inlines[index]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
411 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
412 if '"Plural-Forms:' not in inlines[index+1]:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
413 outlines.append(
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
414 '"Plural-Forms: nplurals=%s; plural=%s;\\n"\n' % plurals
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
415 )
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
416 elif inlines[index].endswith('\\n"\n') and \
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
417 inlines[index+1] == '\n':
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
418 in_header = False
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
419 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
420 else:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
421 outlines.append(inlines[index])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
422 else:
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
423 outlines.extend(inlines[index:])
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
424 break
d484eb9a70d5 Fixed a bug regarding plural msgid's handling when writing the `.pot` file.
palgarvio
parents: 27
diff changeset
425 fileobj.writelines(outlines)
Copyright (C) 2012-2017 Edgewall Software