/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/export_pot.py

  • Committer: Jelmer Vernooij
  • Date: 2019-10-13 22:53:02 UTC
  • mfrom: (7290.1.35 work)
  • mto: This revision was merged to the branch mainline in revision 7405.
  • Revision ID: jelmer@jelmer.uk-20191013225302-vg88ztajzq05hkas
Merge lp:brz/3.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/export_pot.py
 
1
# Copyright (C) 2011 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
# The normalize function is taken from pygettext which is distributed
 
18
# with Python under the Python License, which is GPL compatible.
 
19
 
 
20
"""Extract docstrings from Bazaar commands.
 
21
 
 
22
This module only handles breezy objects that use strings not directly wrapped
 
23
by a gettext() call. To generate a complete translation template file, this
 
24
output needs to be combined with that of xgettext or a similar command for
 
25
extracting those strings, as is done in the bzr Makefile. Sorting the output
 
26
is also left to that stage of the process.
 
27
"""
 
28
 
 
29
from __future__ import absolute_import
 
30
 
 
31
import inspect
 
32
import os
 
33
 
 
34
import breezy
 
35
from . import (
 
36
    commands as _mod_commands,
 
37
    errors,
 
38
    help_topics,
 
39
    option,
 
40
    plugin as _mod_plugin,
 
41
    )
 
42
from .sixish import PY3
 
43
from .trace import (
 
44
    mutter,
 
45
    note,
 
46
    )
 
47
from .i18n import gettext
 
48
 
 
49
 
 
50
def _escape(s):
 
51
    s = (s.replace('\\', '\\\\')
 
52
         .replace('\n', '\\n')
 
53
         .replace('\r', '\\r')
 
54
         .replace('\t', '\\t')
 
55
         .replace('"', '\\"')
 
56
         )
 
57
    return s
 
58
 
 
59
 
 
60
def _normalize(s):
 
61
    # This converts the various Python string types into a format that
 
62
    # is appropriate for .po files, namely much closer to C style.
 
63
    lines = s.split('\n')
 
64
    if len(lines) == 1:
 
65
        s = '"' + _escape(s) + '"'
 
66
    else:
 
67
        if not lines[-1]:
 
68
            del lines[-1]
 
69
            lines[-1] = lines[-1] + '\n'
 
70
        lineterm = '\\n"\n"'
 
71
        s = '""\n"' + lineterm.join(map(_escape, lines)) + '"'
 
72
    return s
 
73
 
 
74
 
 
75
def _parse_source(source_text, filename='<unknown>'):
 
76
    """Get object to lineno mappings from given source_text"""
 
77
    import ast
 
78
    cls_to_lineno = {}
 
79
    str_to_lineno = {}
 
80
    for node in ast.walk(ast.parse(source_text, filename)):
 
81
        # TODO: worry about duplicates?
 
82
        if isinstance(node, ast.ClassDef):
 
83
            # TODO: worry about nesting?
 
84
            cls_to_lineno[node.name] = node.lineno
 
85
        elif isinstance(node, ast.Str):
 
86
            # Python AST gives location of string literal as the line the
 
87
            # string terminates on. It's more useful to have the line the
 
88
            # string begins on. Unfortunately, counting back newlines is
 
89
            # only an approximation as the AST is ignorant of escaping.
 
90
            str_to_lineno[node.s] = node.lineno - node.s.count('\n')
 
91
    return cls_to_lineno, str_to_lineno
 
92
 
 
93
 
 
94
class _ModuleContext(object):
 
95
    """Record of the location within a source tree"""
 
96
 
 
97
    def __init__(self, path, lineno=1, _source_info=None):
 
98
        self.path = path
 
99
        self.lineno = lineno
 
100
        if _source_info is not None:
 
101
            self._cls_to_lineno, self._str_to_lineno = _source_info
 
102
 
 
103
    @classmethod
 
104
    def from_module(cls, module):
 
105
        """Get new context from module object and parse source for linenos"""
 
106
        sourcepath = inspect.getsourcefile(module)
 
107
        # TODO: fix this to do the right thing rather than rely on cwd
 
108
        relpath = os.path.relpath(sourcepath)
 
109
        return cls(relpath,
 
110
                   _source_info=_parse_source("".join(inspect.findsource(module)[0]), module.__file__))
 
111
 
 
112
    def from_class(self, cls):
 
113
        """Get new context with same details but lineno of class in source"""
 
114
        try:
 
115
            lineno = self._cls_to_lineno[cls.__name__]
 
116
        except (AttributeError, KeyError):
 
117
            mutter("Definition of %r not found in %r", cls, self.path)
 
118
            return self
 
119
        return self.__class__(self.path, lineno,
 
120
                              (self._cls_to_lineno, self._str_to_lineno))
 
121
 
 
122
    def from_string(self, string):
 
123
        """Get new context with same details but lineno of string in source"""
 
124
        try:
 
125
            lineno = self._str_to_lineno[string]
 
126
        except (AttributeError, KeyError):
 
127
            mutter("String %r not found in %r", string[:20], self.path)
 
128
            return self
 
129
        return self.__class__(self.path, lineno,
 
130
                              (self._cls_to_lineno, self._str_to_lineno))
 
131
 
 
132
 
 
133
class _PotExporter(object):
 
134
    """Write message details to output stream in .pot file format"""
 
135
 
 
136
    def __init__(self, outf, include_duplicates=False):
 
137
        self.outf = outf
 
138
        if include_duplicates:
 
139
            self._msgids = None
 
140
        else:
 
141
            self._msgids = set()
 
142
        self._module_contexts = {}
 
143
 
 
144
    def poentry(self, path, lineno, s, comment=None):
 
145
        if self._msgids is not None:
 
146
            if s in self._msgids:
 
147
                return
 
148
            self._msgids.add(s)
 
149
        if comment is None:
 
150
            comment = ''
 
151
        else:
 
152
            comment = "# %s\n" % comment
 
153
        mutter("Exporting msg %r at line %d in %r", s[:20], lineno, path)
 
154
        line = (
 
155
            "#: {path}:{lineno}\n"
 
156
            "{comment}"
 
157
            "msgid {msg}\n"
 
158
            "msgstr \"\"\n"
 
159
            "\n".format(
 
160
                path=path, lineno=lineno, comment=comment, msg=_normalize(s)))
 
161
        if not PY3:
 
162
            line = line.decode('utf-8')
 
163
        self.outf.write(line)
 
164
 
 
165
    def poentry_in_context(self, context, string, comment=None):
 
166
        context = context.from_string(string)
 
167
        self.poentry(context.path, context.lineno, string, comment)
 
168
 
 
169
    def poentry_per_paragraph(self, path, lineno, msgid, include=None):
 
170
        # TODO: How to split long help?
 
171
        paragraphs = msgid.split('\n\n')
 
172
        if include is not None:
 
173
            paragraphs = filter(include, paragraphs)
 
174
        for p in paragraphs:
 
175
            self.poentry(path, lineno, p)
 
176
            lineno += p.count('\n') + 2
 
177
 
 
178
    def get_context(self, obj):
 
179
        module = inspect.getmodule(obj)
 
180
        try:
 
181
            context = self._module_contexts[module.__name__]
 
182
        except KeyError:
 
183
            context = _ModuleContext.from_module(module)
 
184
            self._module_contexts[module.__name__] = context
 
185
        if inspect.isclass(obj):
 
186
            context = context.from_class(obj)
 
187
        return context
 
188
 
 
189
 
 
190
def _write_option(exporter, context, opt, note):
 
191
    if getattr(opt, 'hidden', False):
 
192
        return
 
193
    optname = opt.name
 
194
    if getattr(opt, 'title', None):
 
195
        exporter.poentry_in_context(context, opt.title,
 
196
                                    "title of {name!r} {what}".format(name=optname, what=note))
 
197
    for name, _, _, helptxt in opt.iter_switches():
 
198
        if name != optname:
 
199
            if opt.is_hidden(name):
 
200
                continue
 
201
            name = "=".join([optname, name])
 
202
        if helptxt:
 
203
            exporter.poentry_in_context(context, helptxt,
 
204
                                        "help of {name!r} {what}".format(name=name, what=note))
 
205
 
 
206
 
 
207
def _standard_options(exporter):
 
208
    OPTIONS = option.Option.OPTIONS
 
209
    context = exporter.get_context(option)
 
210
    for name in sorted(OPTIONS):
 
211
        opt = OPTIONS[name]
 
212
        _write_option(exporter, context.from_string(name), opt, "option")
 
213
 
 
214
 
 
215
def _command_options(exporter, context, cmd):
 
216
    note = "option of {0!r} command".format(cmd.name())
 
217
    for opt in cmd.takes_options:
 
218
        # String values in Command option lists are for global options
 
219
        if not isinstance(opt, str):
 
220
            _write_option(exporter, context, opt, note)
 
221
 
 
222
 
 
223
def _write_command_help(exporter, cmd):
 
224
    context = exporter.get_context(cmd.__class__)
 
225
    rawdoc = cmd.__doc__
 
226
    dcontext = context.from_string(rawdoc)
 
227
    doc = inspect.cleandoc(rawdoc)
 
228
 
 
229
    def exclude_usage(p):
 
230
        # ':Usage:' has special meaning in help topics.
 
231
        # This is usage example of command and should not be translated.
 
232
        if p.splitlines()[0] != ':Usage:':
 
233
            return True
 
234
 
 
235
    exporter.poentry_per_paragraph(dcontext.path, dcontext.lineno, doc,
 
236
                                   exclude_usage)
 
237
    _command_options(exporter, context, cmd)
 
238
 
 
239
 
 
240
def _command_helps(exporter, plugin_name=None):
 
241
    """Extract docstrings from path.
 
242
 
 
243
    This respects the Bazaar cmdtable/table convention and will
 
244
    only extract docstrings from functions mentioned in these tables.
 
245
    """
 
246
 
 
247
    # builtin commands
 
248
    for cmd_name in _mod_commands.builtin_command_names():
 
249
        command = _mod_commands.get_cmd_object(cmd_name, False)
 
250
        if command.hidden:
 
251
            continue
 
252
        if plugin_name is not None:
 
253
            # only export builtins if we are not exporting plugin commands
 
254
            continue
 
255
        note(gettext("Exporting messages from builtin command: %s"), cmd_name)
 
256
        _write_command_help(exporter, command)
 
257
 
 
258
    plugins = _mod_plugin.plugins()
 
259
    if plugin_name is not None and plugin_name not in plugins:
 
260
        raise errors.BzrError(gettext('Plugin %s is not loaded' % plugin_name))
 
261
    core_plugins = set(
 
262
        name for name in plugins
 
263
        if plugins[name].path().startswith(breezy.__path__[0]))
 
264
    # plugins
 
265
    for cmd_name in _mod_commands.plugin_command_names():
 
266
        command = _mod_commands.get_cmd_object(cmd_name, False)
 
267
        if command.hidden:
 
268
            continue
 
269
        if plugin_name is not None and command.plugin_name() != plugin_name:
 
270
            # if we are exporting plugin commands, skip plugins we have not
 
271
            # specified.
 
272
            continue
 
273
        if plugin_name is None and command.plugin_name() not in core_plugins:
 
274
            # skip non-core plugins
 
275
            # TODO: Support extracting from third party plugins.
 
276
            continue
 
277
        note(gettext("Exporting messages from plugin command: {0} in {1}").format(
 
278
             cmd_name, command.plugin_name()))
 
279
        _write_command_help(exporter, command)
 
280
 
 
281
 
 
282
def _error_messages(exporter):
 
283
    """Extract fmt string from breezy.errors."""
 
284
    context = exporter.get_context(errors)
 
285
    base_klass = errors.BzrError
 
286
    for name in dir(errors):
 
287
        klass = getattr(errors, name)
 
288
        if not inspect.isclass(klass):
 
289
            continue
 
290
        if not issubclass(klass, base_klass):
 
291
            continue
 
292
        if klass is base_klass:
 
293
            continue
 
294
        if klass.internal_error:
 
295
            continue
 
296
        fmt = getattr(klass, "_fmt", None)
 
297
        if fmt:
 
298
            note(gettext("Exporting message from error: %s"), name)
 
299
            exporter.poentry_in_context(context, fmt)
 
300
 
 
301
 
 
302
def _help_topics(exporter):
 
303
    topic_registry = help_topics.topic_registry
 
304
    for key in topic_registry.keys():
 
305
        doc = topic_registry.get(key)
 
306
        if isinstance(doc, str):
 
307
            exporter.poentry_per_paragraph(
 
308
                'dummy/help_topics/' + key + '/detail.txt',
 
309
                1, doc)
 
310
        elif callable(doc):  # help topics from files
 
311
            exporter.poentry_per_paragraph(
 
312
                'en/help_topics/' + key + '.txt',
 
313
                1, doc(key))
 
314
        summary = topic_registry.get_summary(key)
 
315
        if summary is not None:
 
316
            exporter.poentry('dummy/help_topics/' + key + '/summary.txt',
 
317
                             1, summary)
 
318
 
 
319
 
 
320
def export_pot(outf, plugin=None, include_duplicates=False):
 
321
    exporter = _PotExporter(outf, include_duplicates)
 
322
    if plugin is None:
 
323
        _standard_options(exporter)
 
324
        _command_helps(exporter)
 
325
        _error_messages(exporter)
 
326
        _help_topics(exporter)
 
327
    else:
 
328
        _command_helps(exporter, plugin)