/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: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/export_pot.py
19
19
 
20
20
"""Extract docstrings from Bazaar commands.
21
21
 
22
 
This module only handles bzrlib objects that use strings not directly wrapped
 
22
This module only handles breezy objects that use strings not directly wrapped
23
23
by a gettext() call. To generate a complete translation template file, this
24
24
output needs to be combined with that of xgettext or a similar command for
25
25
extracting those strings, as is done in the bzr Makefile. Sorting the output
26
26
is also left to that stage of the process.
27
27
"""
28
28
 
29
 
from __future__ import absolute_import
30
 
 
31
29
import inspect
32
30
import os
 
31
import sys
33
32
 
34
 
from bzrlib import (
 
33
import breezy
 
34
from . import (
35
35
    commands as _mod_commands,
36
36
    errors,
37
37
    help_topics,
38
38
    option,
39
 
    plugin,
40
 
    help,
 
39
    plugin as _mod_plugin,
41
40
    )
42
 
from bzrlib.trace import (
 
41
from .trace import (
43
42
    mutter,
44
43
    note,
45
44
    )
46
 
from bzrlib.i18n import gettext
 
45
from .i18n import gettext
47
46
 
48
47
 
49
48
def _escape(s):
50
49
    s = (s.replace('\\', '\\\\')
51
 
        .replace('\n', '\\n')
52
 
        .replace('\r', '\\r')
53
 
        .replace('\t', '\\t')
54
 
        .replace('"', '\\"')
55
 
        )
 
50
         .replace('\n', '\\n')
 
51
         .replace('\r', '\\r')
 
52
         .replace('\t', '\\t')
 
53
         .replace('"', '\\"')
 
54
         )
56
55
    return s
57
56
 
 
57
 
58
58
def _normalize(s):
59
59
    # This converts the various Python string types into a format that
60
60
    # is appropriate for .po files, namely much closer to C style.
65
65
        if not lines[-1]:
66
66
            del lines[-1]
67
67
            lines[-1] = lines[-1] + '\n'
68
 
        lines = map(_escape, lines)
69
68
        lineterm = '\\n"\n"'
70
 
        s = '""\n"' + lineterm.join(lines) + '"'
 
69
        s = '""\n"' + lineterm.join(map(_escape, lines)) + '"'
71
70
    return s
72
71
 
73
72
 
74
 
def _parse_source(source_text):
 
73
def _parse_source(source_text, filename='<unknown>'):
75
74
    """Get object to lineno mappings from given source_text"""
76
75
    import ast
77
76
    cls_to_lineno = {}
78
77
    str_to_lineno = {}
79
 
    for node in ast.walk(ast.parse(source_text)):
 
78
    for node in ast.walk(ast.parse(source_text, filename)):
80
79
        # TODO: worry about duplicates?
81
80
        if isinstance(node, ast.ClassDef):
82
81
            # TODO: worry about nesting?
86
85
            # string terminates on. It's more useful to have the line the
87
86
            # string begins on. Unfortunately, counting back newlines is
88
87
            # only an approximation as the AST is ignorant of escaping.
89
 
            str_to_lineno[node.s] = node.lineno - node.s.count('\n')
 
88
            str_to_lineno[node.s] = node.lineno - (0 if sys.version_info >= (3, 8) else node.s.count('\n'))
90
89
    return cls_to_lineno, str_to_lineno
91
90
 
92
91
 
106
105
        # TODO: fix this to do the right thing rather than rely on cwd
107
106
        relpath = os.path.relpath(sourcepath)
108
107
        return cls(relpath,
109
 
            _source_info=_parse_source("".join(inspect.findsource(module)[0])))
 
108
                   _source_info=_parse_source("".join(inspect.findsource(module)[0]), module.__file__))
110
109
 
111
110
    def from_class(self, cls):
112
111
        """Get new context with same details but lineno of class in source"""
116
115
            mutter("Definition of %r not found in %r", cls, self.path)
117
116
            return self
118
117
        return self.__class__(self.path, lineno,
119
 
            (self._cls_to_lineno, self._str_to_lineno))
 
118
                              (self._cls_to_lineno, self._str_to_lineno))
120
119
 
121
120
    def from_string(self, string):
122
121
        """Get new context with same details but lineno of string in source"""
126
125
            mutter("String %r not found in %r", string[:20], self.path)
127
126
            return self
128
127
        return self.__class__(self.path, lineno,
129
 
            (self._cls_to_lineno, self._str_to_lineno))
 
128
                              (self._cls_to_lineno, self._str_to_lineno))
130
129
 
131
130
 
132
131
class _PotExporter(object):
150
149
        else:
151
150
            comment = "# %s\n" % comment
152
151
        mutter("Exporting msg %r at line %d in %r", s[:20], lineno, path)
153
 
        self.outf.write(
 
152
        line = (
154
153
            "#: {path}:{lineno}\n"
155
154
            "{comment}"
156
155
            "msgid {msg}\n"
157
156
            "msgstr \"\"\n"
158
157
            "\n".format(
159
158
                path=path, lineno=lineno, comment=comment, msg=_normalize(s)))
 
159
        self.outf.write(line)
160
160
 
161
161
    def poentry_in_context(self, context, string, comment=None):
162
162
        context = context.from_string(string)
185
185
 
186
186
def _write_option(exporter, context, opt, note):
187
187
    if getattr(opt, 'hidden', False):
188
 
        return   
 
188
        return
189
189
    optname = opt.name
190
190
    if getattr(opt, 'title', None):
191
191
        exporter.poentry_in_context(context, opt.title,
192
 
            "title of {name!r} {what}".format(name=optname, what=note))
 
192
                                    "title of {name!r} {what}".format(name=optname, what=note))
193
193
    for name, _, _, helptxt in opt.iter_switches():
194
194
        if name != optname:
195
195
            if opt.is_hidden(name):
197
197
            name = "=".join([optname, name])
198
198
        if helptxt:
199
199
            exporter.poentry_in_context(context, helptxt,
200
 
                "help of {name!r} {what}".format(name=name, what=note))
 
200
                                        "help of {name!r} {what}".format(name=name, what=note))
201
201
 
202
202
 
203
203
def _standard_options(exporter):
204
204
    OPTIONS = option.Option.OPTIONS
205
205
    context = exporter.get_context(option)
206
 
    for name in sorted(OPTIONS.keys()):
 
206
    for name in sorted(OPTIONS):
207
207
        opt = OPTIONS[name]
208
208
        _write_option(exporter, context.from_string(name), opt, "option")
209
209
 
229
229
            return True
230
230
 
231
231
    exporter.poentry_per_paragraph(dcontext.path, dcontext.lineno, doc,
232
 
        exclude_usage)
 
232
                                   exclude_usage)
233
233
    _command_options(exporter, context, cmd)
234
234
 
235
235
 
239
239
    This respects the Bazaar cmdtable/table convention and will
240
240
    only extract docstrings from functions mentioned in these tables.
241
241
    """
242
 
    from glob import glob
243
242
 
244
243
    # builtin commands
245
244
    for cmd_name in _mod_commands.builtin_command_names():
252
251
        note(gettext("Exporting messages from builtin command: %s"), cmd_name)
253
252
        _write_command_help(exporter, command)
254
253
 
255
 
    plugin_path = plugin.get_core_plugin_path()
256
 
    core_plugins = glob(plugin_path + '/*/__init__.py')
257
 
    core_plugins = [os.path.basename(os.path.dirname(p))
258
 
                        for p in core_plugins]
 
254
    plugins = _mod_plugin.plugins()
 
255
    if plugin_name is not None and plugin_name not in plugins:
 
256
        raise errors.BzrError(gettext('Plugin %s is not loaded' % plugin_name))
 
257
    core_plugins = set(
 
258
        name for name in plugins
 
259
        if plugins[name].path().startswith(breezy.__path__[0]))
259
260
    # plugins
260
261
    for cmd_name in _mod_commands.plugin_command_names():
261
262
        command = _mod_commands.get_cmd_object(cmd_name, False)
262
263
        if command.hidden:
263
264
            continue
264
265
        if plugin_name is not None and command.plugin_name() != plugin_name:
265
 
            # if we are exporting plugin commands, skip plugins we have not specified.
 
266
            # if we are exporting plugin commands, skip plugins we have not
 
267
            # specified.
266
268
            continue
267
269
        if plugin_name is None and command.plugin_name() not in core_plugins:
268
270
            # skip non-core plugins
269
271
            # TODO: Support extracting from third party plugins.
270
272
            continue
271
273
        note(gettext("Exporting messages from plugin command: {0} in {1}").format(
272
 
             cmd_name, command.plugin_name() ))
 
274
             cmd_name, command.plugin_name()))
273
275
        _write_command_help(exporter, command)
274
276
 
275
277
 
276
278
def _error_messages(exporter):
277
 
    """Extract fmt string from bzrlib.errors."""
 
279
    """Extract fmt string from breezy.errors."""
278
280
    context = exporter.get_context(errors)
279
281
    base_klass = errors.BzrError
280
282
    for name in dir(errors):
299
301
        doc = topic_registry.get(key)
300
302
        if isinstance(doc, str):
301
303
            exporter.poentry_per_paragraph(
302
 
                    'dummy/help_topics/'+key+'/detail.txt',
303
 
                    1, doc)
304
 
        elif callable(doc): # help topics from files
 
304
                'dummy/help_topics/' + key + '/detail.txt',
 
305
                1, doc)
 
306
        elif callable(doc):  # help topics from files
305
307
            exporter.poentry_per_paragraph(
306
 
                    'en/help_topics/'+key+'.txt',
307
 
                    1, doc(key))
 
308
                'en/help_topics/' + key + '.txt',
 
309
                1, doc(key))
308
310
        summary = topic_registry.get_summary(key)
309
311
        if summary is not None:
310
 
            exporter.poentry('dummy/help_topics/'+key+'/summary.txt',
311
 
                     1, summary)
 
312
            exporter.poentry('dummy/help_topics/' + key + '/summary.txt',
 
313
                             1, summary)
312
314
 
313
315
 
314
316
def export_pot(outf, plugin=None, include_duplicates=False):