← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to tools/bzrgettext

  • Committer: INADA Naoki
  • Date: 2011-05-05 09:15:34 UTC
  • mto: (5830.3.3 i18n-msgfmt)
  • mto: This revision was merged to the branch mainline in revision 5873.
  • Revision ID: songofacandy@gmail.com-20110505091534-7sv835xpofwrmpt4
Add update-pot command to Makefile and tools/bzrgettext script that
extracts help text from bzr commands.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/bzrgettext
1
 
# Copyright (C) 2011 Canonical Ltd
 
1
#!/usr/bin/env python
 
2
#
 
3
# bzrgettext - extract docstrings for Bazaar commands
 
4
#
 
5
# Copyright 2009 Matt Mackall <mpm@selenic.com> and others
 
6
# Copyright 2011 Canonical Ltd
2
7
#
3
8
# This program is free software; you can redistribute it and/or modify
4
9
# it under the terms of the GNU General Public License as published by
14
19
# along with this program; if not, write to the Free Software
15
20
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
21
 
 
22
# This script is copied from mercurial/i18n/hggettext and modified
 
23
# for Bazaar.
 
24
 
17
25
# The normalize function is taken from pygettext which is distributed
18
26
# with Python under the Python License, which is GPL compatible.
19
27
 
 
28
 
20
29
"""Extract docstrings from Bazaar commands.
21
30
"""
22
31
 
23
 
import inspect
24
 
import os
25
 
 
26
 
from bzrlib import (
27
 
    commands as _mod_commands,
28
 
    errors,
29
 
    help_topics,
30
 
    plugin,
31
 
    )
32
 
from bzrlib.trace import (
33
 
    mutter,
34
 
    note,
35
 
    )
36
 
 
37
 
 
38
 
def _escape(s):
 
32
import os, sys, inspect
 
33
 
 
34
 
 
35
def escape(s):
39
36
    s = (s.replace('\\', '\\\\')
40
37
        .replace('\n', '\\n')
41
38
        .replace('\r', '\\r')
44
41
        )
45
42
    return s
46
43
 
47
 
def _normalize(s):
 
44
 
 
45
def normalize(s):
48
46
    # This converts the various Python string types into a format that
49
47
    # is appropriate for .po files, namely much closer to C style.
50
48
    lines = s.split('\n')
51
49
    if len(lines) == 1:
52
 
        s = '"' + _escape(s) + '"'
 
50
        s = '"' + escape(s) + '"'
53
51
    else:
54
52
        if not lines[-1]:
55
53
            del lines[-1]
56
54
            lines[-1] = lines[-1] + '\n'
57
 
        lines = map(_escape, lines)
 
55
        lines = map(escape, lines)
58
56
        lineterm = '\\n"\n"'
59
57
        s = '""\n"' + lineterm.join(lines) + '"'
60
58
    return s
61
59
 
62
60
 
63
 
_FOUND_MSGID = None # set by entry function.
64
 
 
65
 
def _poentry(outf, path, lineno, s, comment=None):
66
 
    if s in _FOUND_MSGID:
67
 
        return
68
 
    _FOUND_MSGID.add(s)
69
 
    if comment is None:
70
 
        comment = ''
 
61
def poentry(path, lineno, s):
 
62
    return ('#: %s:%d\n' % (path, lineno) +
 
63
            'msgid %s\n' % normalize(s) +
 
64
            'msgstr ""\n')
 
65
 
 
66
 
 
67
def offset(src, doc, name, default):
 
68
    """Compute offset or issue a warning on stdout."""
 
69
    # Backslashes in doc appear doubled in src.
 
70
    end = src.find(doc.replace('\\', '\\\\'))
 
71
    if end == -1:
 
72
        # This can happen if the docstring contains unnecessary escape
 
73
        # sequences such as \" in a triple-quoted string. The problem
 
74
        # is that \" is turned into " and so doc wont appear in src.
 
75
        sys.stderr.write("warning: unknown offset in %s, assuming %d lines\n"
 
76
                         % (name, default))
 
77
        return default
71
78
    else:
72
 
        comment = "# %s\n" % comment
73
 
    mutter("Exporting msg %r at line %d in %r", s[:20], lineno, path)
74
 
    print >>outf, ('#: %s:%d\n' % (path, lineno) +
75
 
           comment+
76
 
           'msgid %s\n' % _normalize(s) +
77
 
           'msgstr ""\n')
78
 
 
79
 
def _poentry_per_paragraph(outf, path, lineno, msgid, filter=lambda x: False):
80
 
    # TODO: How to split long help?
81
 
    paragraphs = msgid.split('\n\n')
82
 
    for p in paragraphs:
83
 
        if filter(p):
84
 
            continue
85
 
        _poentry(outf, path, lineno, p)
86
 
        lineno += p.count('\n') + 2
87
 
 
88
 
_LAST_CACHE = _LAST_CACHED_SRC = None
89
 
 
90
 
def _offsets_of_literal(src):
91
 
    global _LAST_CACHE, _LAST_CACHED_SRC
92
 
    if src == _LAST_CACHED_SRC:
93
 
        return _LAST_CACHE.copy()
94
 
 
95
 
    import ast
96
 
    root = ast.parse(src)
97
 
    offsets = {}
98
 
    for node in ast.walk(root):
99
 
        if not isinstance(node, ast.Str):
100
 
            continue
101
 
        offsets[node.s] = node.lineno - node.s.count('\n')
102
 
 
103
 
    _LAST_CACHED_SRC = src
104
 
    _LAST_CACHE = offsets.copy()
105
 
    return offsets
106
 
 
107
 
def _standard_options(outf):
108
 
    from bzrlib.option import Option
109
 
    src = inspect.findsource(Option)[0]
110
 
    src = ''.join(src)
111
 
    path = 'bzrlib/option.py'
112
 
    offsets = _offsets_of_literal(src)
113
 
 
114
 
    for name in sorted(Option.OPTIONS.keys()):
115
 
        opt = Option.OPTIONS[name]
116
 
        if getattr(opt, 'hidden', False):
117
 
            continue
118
 
        if getattr(opt, 'title', None):
119
 
            lineno = offsets.get(opt.title, 9999)
120
 
            if lineno == 9999:
121
 
                note("%r is not found in bzrlib/option.py" % opt.title)
122
 
            _poentry(outf, path, lineno, opt.title,
123
 
                     'title of %r option' % name)
124
 
        if getattr(opt, 'help', None):
125
 
            lineno = offsets.get(opt.help, 9999)
126
 
            if lineno == 9999:
127
 
                note("%r is not found in bzrlib/option.py" % opt.help)
128
 
            _poentry(outf, path, lineno, opt.help,
129
 
                     'help of %r option' % name)
130
 
 
131
 
def _command_options(outf, path, cmd):
132
 
    src, default_lineno = inspect.findsource(cmd.__class__)
133
 
    offsets = _offsets_of_literal(''.join(src))
134
 
    for opt in cmd.takes_options:
135
 
        if isinstance(opt, str):
136
 
            continue
137
 
        if getattr(opt, 'hidden', False):
138
 
            continue
139
 
        name = opt.name
140
 
        if getattr(opt, 'title', None):
141
 
            lineno = offsets.get(opt.title, default_lineno)
142
 
            _poentry(outf, path, lineno, opt.title,
143
 
                     'title of %r option of %r command' % (name, cmd.name()))
144
 
        if getattr(opt, 'help', None):
145
 
            lineno = offsets.get(opt.help, default_lineno)
146
 
            _poentry(outf, path, lineno, opt.help,
147
 
                     'help of %r option of %r command' % (name, cmd.name()))
148
 
 
149
 
 
150
 
def _write_command_help(outf, cmd):
151
 
    path = inspect.getfile(cmd.__class__)
152
 
    if path.endswith('.pyc'):
153
 
        path = path[:-1]
154
 
    path = os.path.relpath(path)
155
 
    src, lineno = inspect.findsource(cmd.__class__)
156
 
    offsets = _offsets_of_literal(''.join(src))
157
 
    lineno = offsets[cmd.__doc__]
158
 
    doc = inspect.getdoc(cmd)
159
 
 
160
 
    def filter(p):
161
 
        # ':Usage:' has special meaning in help topics.
162
 
        # This is usage example of command and should not be translated.
163
 
        if p.splitlines()[0] == ':Usage:':
164
 
            return True
165
 
 
166
 
    _poentry_per_paragraph(outf, path, lineno, doc, filter)
167
 
    _command_options(outf, path, cmd)
168
 
 
169
 
 
170
 
def _command_helps(outf):
 
79
        return src.count('\n', 0, end)
 
80
 
 
81
 
 
82
def importpath(path):
 
83
    """Import a path like foo/bar/baz.py and return the baz module."""
 
84
    if path.endswith('.py'):
 
85
        path = path[:-3]
 
86
    if path.endswith('/__init__'):
 
87
        path = path[:-9]
 
88
    path = path.replace('/', '.')
 
89
    mod = __import__(path)
 
90
    for comp in path.split('.')[1:]:
 
91
        mod = getattr(mod, comp)
 
92
    return mod
 
93
 
 
94
 
 
95
def docstrings(path):
171
96
    """Extract docstrings from path.
172
97
 
173
98
    This respects the Bazaar cmdtable/table convention and will
174
99
    only extract docstrings from functions mentioned in these tables.
175
100
    """
176
 
    from glob import glob
177
 
 
178
 
    # builtin commands
179
 
    for cmd_name in _mod_commands.builtin_command_names():
180
 
        command = _mod_commands.get_cmd_object(cmd_name, False)
181
 
        if command.hidden:
182
 
            continue
183
 
        note("Exporting messages from builtin command: %s", cmd_name)
184
 
        _write_command_help(outf, command)
185
 
 
186
 
    plugin_path = plugin.get_core_plugin_path()
187
 
    core_plugins = glob(plugin_path + '/*/__init__.py')
188
 
    core_plugins = [os.path.basename(os.path.dirname(p))
189
 
                        for p in core_plugins]
190
 
    # core plugins
191
 
    for cmd_name in _mod_commands.plugin_command_names():
192
 
        command = _mod_commands.get_cmd_object(cmd_name, False)
193
 
        if command.hidden:
194
 
            continue
195
 
        if command.plugin_name() not in core_plugins:
196
 
            # skip non-core plugins
197
 
            # TODO: Support extracting from third party plugins.
198
 
            continue
199
 
        note("Exporting messages from plugin command: %s in %s",
200
 
             cmd_name, command.plugin_name())
201
 
        _write_command_help(outf, command)
202
 
 
203
 
 
204
 
def _error_messages(outf):
 
101
    from bzrlib.commands import Command as cmd_klass
 
102
    mod = importpath(path)
 
103
    for name in dir(mod):
 
104
        if not name.startswith('cmd_'):
 
105
            continue
 
106
        obj = getattr(mod, name)
 
107
        try:
 
108
            doc = obj.__doc__
 
109
            if doc:
 
110
                doc = inspect.cleandoc(doc)
 
111
            else:
 
112
                continue
 
113
        except AttributeError:
 
114
            continue
 
115
        if (inspect.isclass(obj) and issubclass(obj, cmd_klass)
 
116
                and not obj is cmd_klass):
 
117
            print poentry(path, inspect.findsource(obj)[1], doc)
 
118
 
 
119
def bzrerrors():
205
120
    """Extract fmt string from bzrlib.errors."""
206
 
    path = errors.__file__
207
 
    if path.endswith('.pyc'):
208
 
        path = path[:-1]
209
 
    offsets = _offsets_of_literal(open(path).read())
210
 
 
 
121
    from bzrlib import errors
211
122
    base_klass = errors.BzrError
212
123
    for name in dir(errors):
213
124
        klass = getattr(errors, name)
221
132
            continue
222
133
        fmt = getattr(klass, "_fmt", None)
223
134
        if fmt:
224
 
            note("Exporting message from error: %s", name)
225
 
            _poentry(outf, 'bzrlib/errors.py',
226
 
                     offsets.get(fmt, 9999), fmt)
227
 
 
228
 
def _help_topics(outf):
229
 
    topic_registry = help_topics.topic_registry
230
 
    for key in topic_registry.keys():
231
 
        doc = topic_registry.get(key)
232
 
        if isinstance(doc, str):
233
 
            _poentry_per_paragraph(
234
 
                    outf,
235
 
                    'dummy/help_topics/'+key+'/detail.txt',
236
 
                    1, doc)
237
 
 
238
 
        summary = topic_registry.get_summary(key)
239
 
        if summary is not None:
240
 
            _poentry(outf, 'dummy/help_topics/'+key+'/summary.txt',
241
 
                     1, summary)
242
 
 
243
 
def export_pot(outf):
244
 
    global _FOUND_MSGID
245
 
    _FOUND_MSGID = set()
246
 
    _standard_options(outf)
247
 
    _command_helps(outf)
248
 
    _error_messages(outf)
249
 
    # disable exporting help topics until we decide  how to translate it.
250
 
    #_help_topics(outf)
 
135
            print poentry('bzrlib/erros.py',
 
136
                    inspect.findsource(klass)[1], fmt)
 
137
 
 
138
 
 
139
def rawtext(path):
 
140
    src = open(path).read()
 
141
    print poentry(path, 1, src)
 
142
 
 
143
 
 
144
if __name__ == "__main__":
 
145
    # It is very important that we import the Bazaar modules from
 
146
    # the source tree where bzrgettext is executed. Otherwise we might
 
147
    # accidentally import and extract strings from a Bazaar
 
148
    # installation mentioned in PYTHONPATH.
 
149
    sys.path.insert(0, os.getcwd())
 
150
    import bzrlib.lazy_import
 
151
    for path in sys.argv[1:]:
 
152
        if path.endswith('.txt'):
 
153
            rawtext(path)
 
154
        else:
 
155
            docstrings(path)
 
156
    bzrerrors()