/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 bzrlib/commands.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
# TODO: probably should say which arguments are candidates for glob
19
 
# expansion on windows and do that at the command level.
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
20
17
 
21
18
# TODO: Define arguments by objects, rather than just using names.
22
19
# Those objects can specify the expected type of the argument, which
25
22
 
26
23
# TODO: Specific "examples" property on commands for consistent formatting.
27
24
 
28
 
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
29
 
# the profile output behind so it can be interactively examined?
30
 
 
31
25
import os
32
26
import sys
33
27
 
35
29
lazy_import(globals(), """
36
30
import codecs
37
31
import errno
 
32
import threading
38
33
from warnings import warn
39
34
 
40
35
import bzrlib
41
36
from bzrlib import (
 
37
    cleanup,
 
38
    cmdline,
42
39
    debug,
43
40
    errors,
44
41
    option,
45
42
    osutils,
46
43
    trace,
 
44
    ui,
 
45
    win32utils,
47
46
    )
48
47
""")
49
48
 
 
49
from bzrlib.hooks import HookPoint, Hooks
 
50
# Compatibility - Option used to be in commands.
 
51
from bzrlib.option import Option
 
52
from bzrlib.plugin import disable_plugins, load_plugins
 
53
from bzrlib import registry
50
54
from bzrlib.symbol_versioning import (
51
55
    deprecated_function,
 
56
    deprecated_in,
52
57
    deprecated_method,
53
 
    zero_eight,
54
 
    zero_eleven,
55
58
    )
56
 
# Compatibility
57
 
from bzrlib.option import Option
58
 
 
59
 
 
60
 
plugin_cmds = {}
 
59
 
 
60
 
 
61
class CommandInfo(object):
 
62
    """Information about a command."""
 
63
 
 
64
    def __init__(self, aliases):
 
65
        """The list of aliases for the command."""
 
66
        self.aliases = aliases
 
67
 
 
68
    @classmethod
 
69
    def from_command(klass, command):
 
70
        """Factory to construct a CommandInfo from a command."""
 
71
        return klass(command.aliases)
 
72
 
 
73
 
 
74
class CommandRegistry(registry.Registry):
 
75
    """Special registry mapping command names to command classes.
 
76
    
 
77
    :ivar overridden_registry: Look in this registry for commands being
 
78
        overridden by this registry.  This can be used to tell plugin commands
 
79
        about the builtin they're decorating.
 
80
    """
 
81
 
 
82
    def __init__(self):
 
83
        registry.Registry.__init__(self)
 
84
        self.overridden_registry = None
 
85
        # map from aliases to the real command that implements the name
 
86
        self._alias_dict = {}
 
87
 
 
88
    def get(self, command_name):
 
89
        real_name = self._alias_dict.get(command_name, command_name)
 
90
        return registry.Registry.get(self, real_name)
 
91
 
 
92
    @staticmethod
 
93
    def _get_name(command_name):
 
94
        if command_name.startswith("cmd_"):
 
95
            return _unsquish_command_name(command_name)
 
96
        else:
 
97
            return command_name
 
98
 
 
99
    def register(self, cmd, decorate=False):
 
100
        """Utility function to help register a command
 
101
 
 
102
        :param cmd: Command subclass to register
 
103
        :param decorate: If true, allow overriding an existing command
 
104
            of the same name; the old command is returned by this function.
 
105
            Otherwise it is an error to try to override an existing command.
 
106
        """
 
107
        k = cmd.__name__
 
108
        k_unsquished = self._get_name(k)
 
109
        try:
 
110
            previous = self.get(k_unsquished)
 
111
        except KeyError:
 
112
            previous = None
 
113
            if self.overridden_registry:
 
114
                try:
 
115
                    previous = self.overridden_registry.get(k_unsquished)
 
116
                except KeyError:
 
117
                    pass
 
118
        info = CommandInfo.from_command(cmd)
 
119
        try:
 
120
            registry.Registry.register(self, k_unsquished, cmd,
 
121
                                       override_existing=decorate, info=info)
 
122
        except KeyError:
 
123
            trace.warning('Two plugins defined the same command: %r' % k)
 
124
            trace.warning('Not loading the one in %r' %
 
125
                sys.modules[cmd.__module__])
 
126
            trace.warning('Previously this command was registered from %r' %
 
127
                sys.modules[previous.__module__])
 
128
        for a in cmd.aliases:
 
129
            self._alias_dict[a] = k_unsquished
 
130
        return previous
 
131
 
 
132
    def register_lazy(self, command_name, aliases, module_name):
 
133
        """Register a command without loading its module.
 
134
 
 
135
        :param command_name: The primary name of the command.
 
136
        :param aliases: A list of aliases for the command.
 
137
        :module_name: The module that the command lives in.
 
138
        """
 
139
        key = self._get_name(command_name)
 
140
        registry.Registry.register_lazy(self, key, module_name, command_name,
 
141
                                        info=CommandInfo(aliases))
 
142
        for a in aliases:
 
143
            self._alias_dict[a] = key
 
144
 
 
145
 
 
146
plugin_cmds = CommandRegistry()
 
147
builtin_command_registry = CommandRegistry()
 
148
plugin_cmds.overridden_registry = builtin_command_registry
61
149
 
62
150
 
63
151
def register_command(cmd, decorate=False):
64
 
    """Utility function to help register a command
 
152
    """Register a plugin command.
65
153
 
66
 
    :param cmd: Command subclass to register
67
 
    :param decorate: If true, allow overriding an existing command
68
 
        of the same name; the old command is returned by this function.
69
 
        Otherwise it is an error to try to override an existing command.
 
154
    Should generally be avoided in favor of lazy registration. 
70
155
    """
71
156
    global plugin_cmds
72
 
    k = cmd.__name__
73
 
    if k.startswith("cmd_"):
74
 
        k_unsquished = _unsquish_command_name(k)
75
 
    else:
76
 
        k_unsquished = k
77
 
    if k_unsquished not in plugin_cmds:
78
 
        plugin_cmds[k_unsquished] = cmd
79
 
        ## trace.mutter('registered plugin command %s', k_unsquished)
80
 
        if decorate and k_unsquished in builtin_command_names():
81
 
            return _builtin_commands()[k_unsquished]
82
 
    elif decorate:
83
 
        result = plugin_cmds[k_unsquished]
84
 
        plugin_cmds[k_unsquished] = cmd
85
 
        return result
86
 
    else:
87
 
        trace.log_error('Two plugins defined the same command: %r' % k)
88
 
        trace.log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
157
    return plugin_cmds.register(cmd, decorate)
89
158
 
90
159
 
91
160
def _squish_command_name(cmd):
93
162
 
94
163
 
95
164
def _unsquish_command_name(cmd):
96
 
    assert cmd.startswith("cmd_")
97
165
    return cmd[4:].replace('_','-')
98
166
 
99
167
 
 
168
@deprecated_function(deprecated_in((2, 2, 0)))
100
169
def _builtin_commands():
 
170
    """Return a dict of {name: cmd_class} for builtin commands.
 
171
 
 
172
    :deprecated: Use the builtin_command_registry registry instead
 
173
    """
 
174
    # return dict(name: cmd_class)
 
175
    return dict(builtin_command_registry.items())
 
176
 
 
177
 
 
178
def _register_builtin_commands():
 
179
    if builtin_command_registry.keys():
 
180
        # only load once
 
181
        return
101
182
    import bzrlib.builtins
 
183
    for cmd_class in _scan_module_for_commands(bzrlib.builtins).values():
 
184
        builtin_command_registry.register(cmd_class)
 
185
    bzrlib.builtins._register_lazy_builtins()
 
186
 
 
187
 
 
188
def _scan_module_for_commands(module):
102
189
    r = {}
103
 
    builtins = bzrlib.builtins.__dict__
104
 
    for name in builtins:
 
190
    for name, obj in module.__dict__.iteritems():
105
191
        if name.startswith("cmd_"):
106
192
            real_name = _unsquish_command_name(name)
107
 
            r[real_name] = builtins[name]
 
193
            r[real_name] = obj
108
194
    return r
109
 
            
 
195
 
 
196
 
 
197
def _list_bzr_commands(names):
 
198
    """Find commands from bzr's core and plugins.
 
199
    
 
200
    This is not the public interface, just the default hook called by all_command_names.
 
201
    """
 
202
    # to eliminate duplicates
 
203
    names.update(builtin_command_names())
 
204
    names.update(plugin_command_names())
 
205
    return names
 
206
 
 
207
 
 
208
def all_command_names():
 
209
    """Return a set of all command names."""
 
210
    names = set()
 
211
    for hook in Command.hooks['list_commands']:
 
212
        names = hook(names)
 
213
        if names is None:
 
214
            raise AssertionError(
 
215
                'hook %s returned None' % Command.hooks.get_hook_name(hook))
 
216
    return names
 
217
 
110
218
 
111
219
def builtin_command_names():
112
 
    """Return list of builtin command names."""
113
 
    return _builtin_commands().keys()
 
220
    """Return list of builtin command names.
114
221
    
 
222
    Use of all_command_names() is encouraged rather than builtin_command_names
 
223
    and/or plugin_command_names.
 
224
    """
 
225
    return builtin_command_registry.keys()
 
226
 
115
227
 
116
228
def plugin_command_names():
 
229
    """Returns command names from commands registered by plugins."""
117
230
    return plugin_cmds.keys()
118
231
 
119
232
 
120
 
def _get_cmd_dict(plugins_override=True):
121
 
    """Return name->class mapping for all commands."""
122
 
    d = _builtin_commands()
123
 
    if plugins_override:
124
 
        d.update(plugin_cmds)
125
 
    return d
126
 
 
127
 
    
128
 
def get_all_cmds(plugins_override=True):
129
 
    """Return canonical name and class for all registered commands."""
130
 
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
131
 
        yield k,v
132
 
 
133
 
 
134
233
def get_cmd_object(cmd_name, plugins_override=True):
135
 
    """Return the canonical name and command class for a command.
 
234
    """Return the command object for a command.
136
235
 
137
236
    plugins_override
138
237
        If true, plugin commands can override builtins.
139
238
    """
 
239
    try:
 
240
        return _get_cmd_object(cmd_name, plugins_override)
 
241
    except KeyError:
 
242
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
243
 
 
244
 
 
245
def _get_cmd_object(cmd_name, plugins_override=True, check_missing=True):
 
246
    """Get a command object.
 
247
 
 
248
    :param cmd_name: The name of the command.
 
249
    :param plugins_override: Allow plugins to override builtins.
 
250
    :param check_missing: Look up commands not found in the regular index via
 
251
        the get_missing_command hook.
 
252
    :return: A Command object instance
 
253
    :raises KeyError: If no command is found.
 
254
    """
 
255
    # We want only 'ascii' command names, but the user may have typed
 
256
    # in a Unicode name. In that case, they should just get a
 
257
    # 'command not found' error later.
 
258
    # In the future, we may actually support Unicode command names.
 
259
    cmd = None
 
260
    # Get a command
 
261
    for hook in Command.hooks['get_command']:
 
262
        cmd = hook(cmd, cmd_name)
 
263
        if cmd is not None and not plugins_override and not cmd.plugin_name():
 
264
            # We've found a non-plugin command, don't permit it to be
 
265
            # overridden.
 
266
            break
 
267
    if cmd is None and check_missing:
 
268
        for hook in Command.hooks['get_missing_command']:
 
269
            cmd = hook(cmd_name)
 
270
            if cmd is not None:
 
271
                break
 
272
    if cmd is None:
 
273
        # No command found.
 
274
        raise KeyError
 
275
    # Allow plugins to extend commands
 
276
    for hook in Command.hooks['extend_command']:
 
277
        hook(cmd)
 
278
    return cmd
 
279
 
 
280
 
 
281
def _try_plugin_provider(cmd_name):
 
282
    """Probe for a plugin provider having cmd_name."""
 
283
    try:
 
284
        plugin_metadata, provider = probe_for_provider(cmd_name)
 
285
        raise errors.CommandAvailableInPlugin(cmd_name,
 
286
            plugin_metadata, provider)
 
287
    except errors.NoPluginAvailable:
 
288
        pass
 
289
 
 
290
 
 
291
def probe_for_provider(cmd_name):
 
292
    """Look for a provider for cmd_name.
 
293
 
 
294
    :param cmd_name: The command name.
 
295
    :return: plugin_metadata, provider for getting cmd_name.
 
296
    :raises NoPluginAvailable: When no provider can supply the plugin.
 
297
    """
 
298
    # look for providers that provide this command but aren't installed
 
299
    for provider in command_providers_registry:
 
300
        try:
 
301
            return provider.plugin_for_command(cmd_name), provider
 
302
        except errors.NoPluginAvailable:
 
303
            pass
 
304
    raise errors.NoPluginAvailable(cmd_name)
 
305
 
 
306
 
 
307
def _get_bzr_command(cmd_or_None, cmd_name):
 
308
    """Get a command from bzr's core."""
 
309
    try:
 
310
        cmd_class = builtin_command_registry.get(cmd_name)
 
311
    except KeyError:
 
312
        pass
 
313
    else:
 
314
        return cmd_class()
 
315
    return cmd_or_None
 
316
 
 
317
 
 
318
def _get_external_command(cmd_or_None, cmd_name):
 
319
    """Lookup a command that is a shell script."""
 
320
    # Only do external command lookups when no command is found so far.
 
321
    if cmd_or_None is not None:
 
322
        return cmd_or_None
140
323
    from bzrlib.externalcommand import ExternalCommand
141
 
 
142
 
    # We want only 'ascii' command names, but the user may have typed
143
 
    # in a Unicode name. In that case, they should just get a
144
 
    # 'command not found' error later.
145
 
    # In the future, we may actually support Unicode command names.
146
 
 
147
 
    # first look up this command under the specified name
148
 
    cmds = _get_cmd_dict(plugins_override=plugins_override)
149
 
    try:
150
 
        return cmds[cmd_name]()
151
 
    except KeyError:
152
 
        pass
153
 
 
154
 
    # look for any command which claims this as an alias
155
 
    for real_cmd_name, cmd_class in cmds.iteritems():
156
 
        if cmd_name in cmd_class.aliases:
157
 
            return cmd_class()
158
 
 
159
324
    cmd_obj = ExternalCommand.find_command(cmd_name)
160
325
    if cmd_obj:
161
326
        return cmd_obj
162
327
 
163
 
    raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
328
 
 
329
def _get_plugin_command(cmd_or_None, cmd_name):
 
330
    """Get a command from bzr's plugins."""
 
331
    try:
 
332
        return plugin_cmds.get(cmd_name)()
 
333
    except KeyError:
 
334
        pass
 
335
    for key in plugin_cmds.keys():
 
336
        info = plugin_cmds.get_info(key)
 
337
        if cmd_name in info.aliases:
 
338
            return plugin_cmds.get(key)()
 
339
    return cmd_or_None
164
340
 
165
341
 
166
342
class Command(object):
220
396
            sys.stdout is forced to be a binary stream, and line-endings
221
397
            will not mangled.
222
398
 
 
399
    :cvar hooks: An instance of CommandHooks.
223
400
    """
224
401
    aliases = []
225
402
    takes_args = []
227
404
    encoding_type = 'strict'
228
405
 
229
406
    hidden = False
230
 
    
 
407
 
231
408
    def __init__(self):
232
409
        """Construct an instance of this command."""
233
410
        if self.__doc__ == Command.__doc__:
234
411
            warn("No help message set for %r" % self)
 
412
        # List of standard options directly supported
 
413
        self.supported_std_options = []
 
414
        self._setup_run()
 
415
 
 
416
    def add_cleanup(self, cleanup_func, *args, **kwargs):
 
417
        """Register a function to call after self.run returns or raises.
 
418
 
 
419
        Functions will be called in LIFO order.
 
420
        """
 
421
        self._operation.add_cleanup(cleanup_func, *args, **kwargs)
 
422
 
 
423
    def cleanup_now(self):
 
424
        """Execute and empty pending cleanup functions immediately.
 
425
 
 
426
        After cleanup_now all registered cleanups are forgotten.  add_cleanup
 
427
        may be called again after cleanup_now; these cleanups will be called
 
428
        after self.run returns or raises (or when cleanup_now is next called).
 
429
 
 
430
        This is useful for releasing expensive or contentious resources (such
 
431
        as write locks) before doing further work that does not require those
 
432
        resources (such as writing results to self.outf). Note though, that
 
433
        as it releases all resources, this may release locks that the command
 
434
        wants to hold, so use should be done with care.
 
435
        """
 
436
        self._operation.cleanup_now()
 
437
 
 
438
    @deprecated_method(deprecated_in((2, 1, 0)))
 
439
    def _maybe_expand_globs(self, file_list):
 
440
        """Glob expand file_list if the platform does not do that itself.
 
441
 
 
442
        Not used anymore, now that the bzr command-line parser globs on
 
443
        Windows.
 
444
 
 
445
        :return: A possibly empty list of unicode paths.
 
446
 
 
447
        Introduced in bzrlib 0.18.
 
448
        """
 
449
        return file_list
 
450
 
 
451
    def _usage(self):
 
452
        """Return single-line grammar for this command.
 
453
 
 
454
        Only describes arguments, not options.
 
455
        """
 
456
        s = 'bzr ' + self.name() + ' '
 
457
        for aname in self.takes_args:
 
458
            aname = aname.upper()
 
459
            if aname[-1] in ['$', '+']:
 
460
                aname = aname[:-1] + '...'
 
461
            elif aname[-1] == '?':
 
462
                aname = '[' + aname[:-1] + ']'
 
463
            elif aname[-1] == '*':
 
464
                aname = '[' + aname[:-1] + '...]'
 
465
            s += aname + ' '
 
466
        s = s[:-1]      # remove last space
 
467
        return s
 
468
 
 
469
    def get_help_text(self, additional_see_also=None, plain=True,
 
470
                      see_also_as_links=False, verbose=True):
 
471
        """Return a text string with help for this command.
 
472
 
 
473
        :param additional_see_also: Additional help topics to be
 
474
            cross-referenced.
 
475
        :param plain: if False, raw help (reStructuredText) is
 
476
            returned instead of plain text.
 
477
        :param see_also_as_links: if True, convert items in 'See also'
 
478
            list to internal links (used by bzr_man rstx generator)
 
479
        :param verbose: if True, display the full help, otherwise
 
480
            leave out the descriptive sections and just display
 
481
            usage help (e.g. Purpose, Usage, Options) with a
 
482
            message explaining how to obtain full help.
 
483
        """
 
484
        doc = self.help()
 
485
        if doc is None:
 
486
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
 
487
 
 
488
        # Extract the summary (purpose) and sections out from the text
 
489
        purpose,sections,order = self._get_help_parts(doc)
 
490
 
 
491
        # If a custom usage section was provided, use it
 
492
        if sections.has_key('Usage'):
 
493
            usage = sections.pop('Usage')
 
494
        else:
 
495
            usage = self._usage()
 
496
 
 
497
        # The header is the purpose and usage
 
498
        result = ""
 
499
        result += ':Purpose: %s\n' % purpose
 
500
        if usage.find('\n') >= 0:
 
501
            result += ':Usage:\n%s\n' % usage
 
502
        else:
 
503
            result += ':Usage:   %s\n' % usage
 
504
        result += '\n'
 
505
 
 
506
        # Add the options
 
507
        #
 
508
        # XXX: optparse implicitly rewraps the help, and not always perfectly,
 
509
        # so we get <https://bugs.launchpad.net/bzr/+bug/249908>.  -- mbp
 
510
        # 20090319
 
511
        options = option.get_optparser(self.options()).format_option_help()
 
512
        # XXX: According to the spec, ReST option lists actually don't support 
 
513
        # options like --1.9 so that causes syntax errors (in Sphinx at least).
 
514
        # As that pattern always appears in the commands that break, we trap
 
515
        # on that and then format that block of 'format' options as a literal
 
516
        # block.
 
517
        if not plain and options.find('  --1.9  ') != -1:
 
518
            options = options.replace(' format:\n', ' format::\n\n', 1)
 
519
        if options.startswith('Options:'):
 
520
            result += ':' + options
 
521
        elif options.startswith('options:'):
 
522
            # Python 2.4 version of optparse
 
523
            result += ':Options:' + options[len('options:'):]
 
524
        else:
 
525
            result += options
 
526
        result += '\n'
 
527
 
 
528
        if verbose:
 
529
            # Add the description, indenting it 2 spaces
 
530
            # to match the indentation of the options
 
531
            if sections.has_key(None):
 
532
                text = sections.pop(None)
 
533
                text = '\n  '.join(text.splitlines())
 
534
                result += ':%s:\n  %s\n\n' % ('Description',text)
 
535
 
 
536
            # Add the custom sections (e.g. Examples). Note that there's no need
 
537
            # to indent these as they must be indented already in the source.
 
538
            if sections:
 
539
                for label in order:
 
540
                    if sections.has_key(label):
 
541
                        result += ':%s:\n%s\n' % (label,sections[label])
 
542
                result += '\n'
 
543
        else:
 
544
            result += ("See bzr help %s for more details and examples.\n\n"
 
545
                % self.name())
 
546
 
 
547
        # Add the aliases, source (plug-in) and see also links, if any
 
548
        if self.aliases:
 
549
            result += ':Aliases:  '
 
550
            result += ', '.join(self.aliases) + '\n'
 
551
        plugin_name = self.plugin_name()
 
552
        if plugin_name is not None:
 
553
            result += ':From:     plugin "%s"\n' % plugin_name
 
554
        see_also = self.get_see_also(additional_see_also)
 
555
        if see_also:
 
556
            if not plain and see_also_as_links:
 
557
                see_also_links = []
 
558
                for item in see_also:
 
559
                    if item == 'topics':
 
560
                        # topics doesn't have an independent section
 
561
                        # so don't create a real link
 
562
                        see_also_links.append(item)
 
563
                    else:
 
564
                        # Use a Sphinx link for this entry
 
565
                        link_text = ":doc:`%s <%s-help>`" % (item, item)
 
566
                        see_also_links.append(link_text)
 
567
                see_also = see_also_links
 
568
            result += ':See also: '
 
569
            result += ', '.join(see_also) + '\n'
 
570
 
 
571
        # If this will be rendered as plain text, convert it
 
572
        if plain:
 
573
            import bzrlib.help_topics
 
574
            result = bzrlib.help_topics.help_as_plain_text(result)
 
575
        return result
 
576
 
 
577
    @staticmethod
 
578
    def _get_help_parts(text):
 
579
        """Split help text into a summary and named sections.
 
580
 
 
581
        :return: (summary,sections,order) where summary is the top line and
 
582
            sections is a dictionary of the rest indexed by section name.
 
583
            order is the order the section appear in the text.
 
584
            A section starts with a heading line of the form ":xxx:".
 
585
            Indented text on following lines is the section value.
 
586
            All text found outside a named section is assigned to the
 
587
            default section which is given the key of None.
 
588
        """
 
589
        def save_section(sections, order, label, section):
 
590
            if len(section) > 0:
 
591
                if sections.has_key(label):
 
592
                    sections[label] += '\n' + section
 
593
                else:
 
594
                    order.append(label)
 
595
                    sections[label] = section
 
596
 
 
597
        lines = text.rstrip().splitlines()
 
598
        summary = lines.pop(0)
 
599
        sections = {}
 
600
        order = []
 
601
        label,section = None,''
 
602
        for line in lines:
 
603
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
 
604
                save_section(sections, order, label, section)
 
605
                label,section = line[1:-1],''
 
606
            elif (label is not None) and len(line) > 1 and not line[0].isspace():
 
607
                save_section(sections, order, label, section)
 
608
                label,section = None,line
 
609
            else:
 
610
                if len(section) > 0:
 
611
                    section += '\n' + line
 
612
                else:
 
613
                    section = line
 
614
        save_section(sections, order, label, section)
 
615
        return summary, sections, order
 
616
 
 
617
    def get_help_topic(self):
 
618
        """Return the commands help topic - its name."""
 
619
        return self.name()
 
620
 
 
621
    def get_see_also(self, additional_terms=None):
 
622
        """Return a list of help topics that are related to this command.
 
623
 
 
624
        The list is derived from the content of the _see_also attribute. Any
 
625
        duplicates are removed and the result is in lexical order.
 
626
        :param additional_terms: Additional help topics to cross-reference.
 
627
        :return: A list of help topics.
 
628
        """
 
629
        see_also = set(getattr(self, '_see_also', []))
 
630
        if additional_terms:
 
631
            see_also.update(additional_terms)
 
632
        return sorted(see_also)
235
633
 
236
634
    def options(self):
237
635
        """Return dict of valid options for this command.
238
636
 
239
637
        Maps from long option name to option object."""
240
 
        r = dict()
241
 
        r['help'] = option.Option.OPTIONS['help']
 
638
        r = Option.STD_OPTIONS.copy()
 
639
        std_names = r.keys()
242
640
        for o in self.takes_options:
243
641
            if isinstance(o, basestring):
244
642
                o = option.Option.OPTIONS[o]
245
643
            r[o.name] = o
 
644
            if o.name in std_names:
 
645
                self.supported_std_options.append(o.name)
246
646
        return r
247
647
 
248
648
    def _setup_outf(self):
249
649
        """Return a file linked to stdout, which has proper encoding."""
250
 
        assert self.encoding_type in ['strict', 'exact', 'replace']
251
 
 
252
 
        # Originally I was using self.stdout, but that looks
253
 
        # *way* too much like sys.stdout
254
 
        if self.encoding_type == 'exact':
255
 
            # force sys.stdout to be binary stream on win32
256
 
            if sys.platform == 'win32':
257
 
                fileno = getattr(sys.stdout, 'fileno', None)
258
 
                if fileno:
259
 
                    import msvcrt
260
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
261
 
            self.outf = sys.stdout
262
 
            return
263
 
 
264
 
        output_encoding = osutils.get_terminal_encoding()
265
 
 
266
 
        # use 'replace' so that we don't abort if trying to write out
267
 
        # in e.g. the default C locale.
268
 
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
269
 
        # For whatever reason codecs.getwriter() does not advertise its encoding
270
 
        # it just returns the encoding of the wrapped file, which is completely
271
 
        # bogus. So set the attribute, so we can find the correct encoding later.
272
 
        self.outf.encoding = output_encoding
273
 
 
274
 
    @deprecated_method(zero_eight)
275
 
    def run_argv(self, argv):
276
 
        """Parse command line and run.
277
 
        
278
 
        See run_argv_aliases for the 0.8 and beyond api.
279
 
        """
280
 
        return self.run_argv_aliases(argv)
 
650
        self.outf = ui.ui_factory.make_output_stream(
 
651
            encoding_type=self.encoding_type)
281
652
 
282
653
    def run_argv_aliases(self, argv, alias_argv=None):
283
654
        """Parse the command line and run with extra aliases in alias_argv."""
284
 
        if argv is None:
285
 
            warn("Passing None for [] is deprecated from bzrlib 0.10",
286
 
                 DeprecationWarning, stacklevel=2)
287
 
            argv = []
288
655
        args, opts = parse_args(self, argv, alias_argv)
 
656
 
 
657
        # Process the standard options
289
658
        if 'help' in opts:  # e.g. bzr add --help
290
 
            from bzrlib.help import help_on_command
291
 
            help_on_command(self.name())
292
 
            return 0
 
659
            sys.stdout.write(self.get_help_text())
 
660
            return 0
 
661
        if 'usage' in opts:  # e.g. bzr add --usage
 
662
            sys.stdout.write(self.get_help_text(verbose=False))
 
663
            return 0
 
664
        trace.set_verbosity_level(option._verbosity_level)
 
665
        if 'verbose' in self.supported_std_options:
 
666
            opts['verbose'] = trace.is_verbose()
 
667
        elif opts.has_key('verbose'):
 
668
            del opts['verbose']
 
669
        if 'quiet' in self.supported_std_options:
 
670
            opts['quiet'] = trace.is_quiet()
 
671
        elif opts.has_key('quiet'):
 
672
            del opts['quiet']
 
673
 
293
674
        # mix arguments and options into one dictionary
294
675
        cmdargs = _match_argform(self.name(), self.takes_args, args)
295
676
        cmdopts = {}
302
683
        self._setup_outf()
303
684
 
304
685
        return self.run(**all_cmd_args)
305
 
    
 
686
 
 
687
    def _setup_run(self):
 
688
        """Wrap the defined run method on self with a cleanup.
 
689
 
 
690
        This is called by __init__ to make the Command be able to be run
 
691
        by just calling run(), as it could be before cleanups were added.
 
692
 
 
693
        If a different form of cleanups are in use by your Command subclass,
 
694
        you can override this method.
 
695
        """
 
696
        class_run = self.run
 
697
        def run(*args, **kwargs):
 
698
            self._operation = cleanup.OperationWithCleanups(class_run)
 
699
            try:
 
700
                return self._operation.run_simple(*args, **kwargs)
 
701
            finally:
 
702
                del self._operation
 
703
        self.run = run
 
704
 
 
705
    @deprecated_method(deprecated_in((2, 2, 0)))
 
706
    def run_direct(self, *args, **kwargs):
 
707
        """Deprecated thunk from bzrlib 2.1."""
 
708
        return self.run(*args, **kwargs)
 
709
 
306
710
    def run(self):
307
711
        """Actually run the command.
308
712
 
312
716
        Return 0 or None if the command was successful, or a non-zero
313
717
        shell error code if not.  It's OK for this method to allow
314
718
        an exception to raise up.
 
719
 
 
720
        This method is automatically wrapped by Command.__init__ with a 
 
721
        cleanup operation, stored as self._operation. This can be used
 
722
        via self.add_cleanup to perform automatic cleanups at the end of
 
723
        run().
 
724
 
 
725
        The argument for run are assembled by introspection. So for instance,
 
726
        if your command takes an argument files, you would declare::
 
727
 
 
728
            def run(self, files=None):
 
729
                pass
315
730
        """
316
731
        raise NotImplementedError('no implementation of command %r'
317
732
                                  % self.name())
338
753
            return None
339
754
 
340
755
 
341
 
# Technically, this function hasn't been use in a *really* long time
342
 
# but we are only deprecating it now.
343
 
@deprecated_function(zero_eleven)
344
 
def parse_spec(spec):
345
 
    """
346
 
    >>> parse_spec(None)
347
 
    [None, None]
348
 
    >>> parse_spec("./")
349
 
    ['./', None]
350
 
    >>> parse_spec("../@")
351
 
    ['..', -1]
352
 
    >>> parse_spec("../f/@35")
353
 
    ['../f', 35]
354
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
355
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
356
 
    """
357
 
    if spec is None:
358
 
        return [None, None]
359
 
    if '/@' in spec:
360
 
        parsed = spec.split('/@')
361
 
        assert len(parsed) == 2
362
 
        if parsed[1] == "":
363
 
            parsed[1] = -1
364
 
        else:
365
 
            try:
366
 
                parsed[1] = int(parsed[1])
367
 
            except ValueError:
368
 
                pass # We can allow stuff like ./@revid:blahblahblah
369
 
            else:
370
 
                assert parsed[1] >=0
371
 
    else:
372
 
        parsed = [spec, None]
373
 
    return parsed
 
756
class CommandHooks(Hooks):
 
757
    """Hooks related to Command object creation/enumeration."""
 
758
 
 
759
    def __init__(self):
 
760
        """Create the default hooks.
 
761
 
 
762
        These are all empty initially, because by default nothing should get
 
763
        notified.
 
764
        """
 
765
        Hooks.__init__(self)
 
766
        self.create_hook(HookPoint('extend_command',
 
767
            "Called after creating a command object to allow modifications "
 
768
            "such as adding or removing options, docs etc. Called with the "
 
769
            "new bzrlib.commands.Command object.", (1, 13), None))
 
770
        self.create_hook(HookPoint('get_command',
 
771
            "Called when creating a single command. Called with "
 
772
            "(cmd_or_None, command_name). get_command should either return "
 
773
            "the cmd_or_None parameter, or a replacement Command object that "
 
774
            "should be used for the command. Note that the Command.hooks "
 
775
            "hooks are core infrastructure. Many users will prefer to use "
 
776
            "bzrlib.commands.register_command or plugin_cmds.register_lazy.",
 
777
            (1, 17), None))
 
778
        self.create_hook(HookPoint('get_missing_command',
 
779
            "Called when creating a single command if no command could be "
 
780
            "found. Called with (command_name). get_missing_command should "
 
781
            "either return None, or a Command object to be used for the "
 
782
            "command.", (1, 17), None))
 
783
        self.create_hook(HookPoint('list_commands',
 
784
            "Called when enumerating commands. Called with a set of "
 
785
            "cmd_name strings for all the commands found so far. This set "
 
786
            " is safe to mutate - e.g. to remove a command. "
 
787
            "list_commands should return the updated set of command names.",
 
788
            (1, 17), None))
 
789
 
 
790
Command.hooks = CommandHooks()
 
791
 
374
792
 
375
793
def parse_args(command, argv, alias_argv=None):
376
794
    """Parse command line.
377
 
    
 
795
 
378
796
    Arguments and options are parsed at this level before being passed
379
797
    down to specific command handlers.  This routine knows, from a
380
798
    lookup table, something about the available options, what optargs
429
847
                               % (cmd, argname.upper()))
430
848
            else:
431
849
                argdict[argname] = args.pop(0)
432
 
            
 
850
 
433
851
    if args:
434
852
        raise errors.BzrCommandError("extra argument to command %s: %s"
435
853
                                     % (cmd, args[0]))
436
854
 
437
855
    return argdict
438
856
 
 
857
def apply_coveraged(dirname, the_callable, *args, **kwargs):
 
858
    # Cannot use "import trace", as that would import bzrlib.trace instead of
 
859
    # the standard library's trace.
 
860
    trace = __import__('trace')
 
861
 
 
862
    tracer = trace.Trace(count=1, trace=0)
 
863
    sys.settrace(tracer.globaltrace)
 
864
    threading.settrace(tracer.globaltrace)
 
865
 
 
866
    try:
 
867
        return exception_to_return_code(the_callable, *args, **kwargs)
 
868
    finally:
 
869
        sys.settrace(None)
 
870
        results = tracer.results()
 
871
        results.write_results(show_missing=1, summary=False,
 
872
                              coverdir=dirname)
439
873
 
440
874
 
441
875
def apply_profiled(the_callable, *args, **kwargs):
446
880
    try:
447
881
        prof = hotshot.Profile(pfname)
448
882
        try:
449
 
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
 
883
            ret = prof.runcall(exception_to_return_code, the_callable, *args,
 
884
                **kwargs) or 0
450
885
        finally:
451
886
            prof.close()
452
887
        stats = hotshot.stats.load(pfname)
461
896
        os.remove(pfname)
462
897
 
463
898
 
 
899
def exception_to_return_code(the_callable, *args, **kwargs):
 
900
    """UI level helper for profiling and coverage.
 
901
 
 
902
    This transforms exceptions into a return value of 3. As such its only
 
903
    relevant to the UI layer, and should never be called where catching
 
904
    exceptions may be desirable.
 
905
    """
 
906
    try:
 
907
        return the_callable(*args, **kwargs)
 
908
    except (KeyboardInterrupt, Exception), e:
 
909
        # used to handle AssertionError and KeyboardInterrupt
 
910
        # specially here, but hopefully they're handled ok by the logger now
 
911
        exc_info = sys.exc_info()
 
912
        exitcode = trace.report_exception(exc_info, sys.stderr)
 
913
        if os.environ.get('BZR_PDB'):
 
914
            print '**** entering debugger'
 
915
            tb = exc_info[2]
 
916
            import pdb
 
917
            if sys.version_info[:2] < (2, 6):
 
918
                # XXX: we want to do
 
919
                #    pdb.post_mortem(tb)
 
920
                # but because pdb.post_mortem gives bad results for tracebacks
 
921
                # from inside generators, we do it manually.
 
922
                # (http://bugs.python.org/issue4150, fixed in Python 2.6)
 
923
 
 
924
                # Setup pdb on the traceback
 
925
                p = pdb.Pdb()
 
926
                p.reset()
 
927
                p.setup(tb.tb_frame, tb)
 
928
                # Point the debugger at the deepest frame of the stack
 
929
                p.curindex = len(p.stack) - 1
 
930
                p.curframe = p.stack[p.curindex][0]
 
931
                # Start the pdb prompt.
 
932
                p.print_stack_entry(p.stack[p.curindex])
 
933
                p.execRcLines()
 
934
                p.cmdloop()
 
935
            else:
 
936
                pdb.post_mortem(tb)
 
937
        return exitcode
 
938
 
 
939
 
464
940
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
465
941
    from bzrlib.lsprof import profile
466
 
    import cPickle
467
 
    ret, stats = profile(the_callable, *args, **kwargs)
 
942
    ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
468
943
    stats.sort()
469
944
    if filename is None:
470
945
        stats.pprint()
471
946
    else:
472
 
        stats.freeze()
473
 
        cPickle.dump(stats, open(filename, 'w'), 2)
474
 
        print 'Profile data written to %r.' % filename
 
947
        stats.save(filename)
 
948
        trace.note('Profile data written to "%s".', filename)
475
949
    return ret
476
950
 
477
951
 
 
952
@deprecated_function(deprecated_in((2, 2, 0)))
 
953
def shlex_split_unicode(unsplit):
 
954
    return cmdline.split(unsplit)
 
955
 
 
956
 
478
957
def get_alias(cmd, config=None):
479
958
    """Return an expanded alias, or None if no alias exists.
480
959
 
490
969
        config = bzrlib.config.GlobalConfig()
491
970
    alias = config.get_alias(cmd)
492
971
    if (alias):
493
 
        import shlex
494
 
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
 
972
        return cmdline.split(alias)
495
973
    return None
496
974
 
497
975
 
498
 
def run_bzr(argv):
 
976
def run_bzr(argv, load_plugins=load_plugins, disable_plugins=disable_plugins):
499
977
    """Execute a command.
500
978
 
501
 
    This is similar to main(), but without all the trappings for
502
 
    logging and error handling.  
503
 
    
504
 
    argv
505
 
       The command-line arguments, without the program name from argv[0]
506
 
       These should already be decoded. All library/test code calling
507
 
       run_bzr should be passing valid strings (don't need decoding).
508
 
    
509
 
    Returns a command status or raises an exception.
 
979
    :param argv: The command-line arguments, without the program name from
 
980
        argv[0] These should already be decoded. All library/test code calling
 
981
        run_bzr should be passing valid strings (don't need decoding).
 
982
    :param load_plugins: What function to call when triggering plugin loading.
 
983
        This function should take no arguments and cause all plugins to be
 
984
        loaded.
 
985
    :param disable_plugins: What function to call when disabling plugin
 
986
        loading. This function should take no arguments and cause all plugin
 
987
        loading to be prohibited (so that code paths in your application that
 
988
        know about some plugins possibly being present will fail to import
 
989
        those plugins even if they are installed.)
 
990
    :return: Returns a command exit code or raises an exception.
510
991
 
511
992
    Special master options: these must come before the command because
512
993
    they control how the command is interpreted.
526
1007
 
527
1008
    --lsprof
528
1009
        Run under the Python lsprof profiler.
 
1010
 
 
1011
    --coverage
 
1012
        Generate line coverage report in the specified directory.
 
1013
 
 
1014
    --concurrency
 
1015
        Specify the number of processes that can be run concurrently (selftest).
529
1016
    """
 
1017
    trace.mutter("bazaar version: " + bzrlib.__version__)
530
1018
    argv = list(argv)
531
1019
    trace.mutter("bzr arguments: %r", argv)
532
1020
 
533
1021
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
534
1022
                opt_no_aliases = False
535
 
    opt_lsprof_file = None
 
1023
    opt_lsprof_file = opt_coverage_dir = None
536
1024
 
537
1025
    # --no-plugins is handled specially at a very early stage. We need
538
1026
    # to load plugins before doing other command parsing so that they
556
1044
            opt_no_aliases = True
557
1045
        elif a == '--builtin':
558
1046
            opt_builtin = True
559
 
        elif a in ('--quiet', '-q'):
560
 
            trace.be_quiet()
 
1047
        elif a == '--concurrency':
 
1048
            os.environ['BZR_CONCURRENCY'] = argv[i + 1]
 
1049
            i += 1
 
1050
        elif a == '--coverage':
 
1051
            opt_coverage_dir = argv[i + 1]
 
1052
            i += 1
561
1053
        elif a.startswith('-D'):
562
1054
            debug.debug_flags.add(a[2:])
563
1055
        else:
564
1056
            argv_copy.append(a)
565
1057
        i += 1
566
1058
 
 
1059
    debug.set_debug_flags_from_config()
 
1060
 
 
1061
    if not opt_no_plugins:
 
1062
        load_plugins()
 
1063
    else:
 
1064
        disable_plugins()
 
1065
 
567
1066
    argv = argv_copy
568
1067
    if (not argv):
569
 
        from bzrlib.builtins import cmd_help
570
 
        cmd_help().run_argv_aliases([])
 
1068
        get_cmd_object('help').run_argv_aliases([])
571
1069
        return 0
572
1070
 
573
1071
    if argv[0] == '--version':
574
 
        from bzrlib.version import show_version
575
 
        show_version()
 
1072
        get_cmd_object('version').run_argv_aliases([])
576
1073
        return 0
577
 
        
578
 
    if not opt_no_plugins:
579
 
        from bzrlib.plugin import load_plugins
580
 
        load_plugins()
581
 
    else:
582
 
        from bzrlib.plugin import disable_plugins
583
 
        disable_plugins()
584
1074
 
585
1075
    alias_argv = None
586
1076
 
587
1077
    if not opt_no_aliases:
588
1078
        alias_argv = get_alias(argv[0])
589
1079
        if alias_argv:
590
 
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
1080
            user_encoding = osutils.get_user_encoding()
 
1081
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
591
1082
            argv[0] = alias_argv.pop(0)
592
1083
 
593
1084
    cmd = argv.pop(0)
596
1087
    # 'command not found' error later.
597
1088
 
598
1089
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
599
 
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
600
 
        run = cmd_obj.run_argv
601
 
        run_argv = [argv]
602
 
    else:
603
 
        run = cmd_obj.run_argv_aliases
604
 
        run_argv = [argv, alias_argv]
 
1090
    run = cmd_obj.run_argv_aliases
 
1091
    run_argv = [argv, alias_argv]
605
1092
 
606
1093
    try:
 
1094
        # We can be called recursively (tests for example), but we don't want
 
1095
        # the verbosity level to propagate.
 
1096
        saved_verbosity_level = option._verbosity_level
 
1097
        option._verbosity_level = 0
607
1098
        if opt_lsprof:
 
1099
            if opt_coverage_dir:
 
1100
                trace.warning(
 
1101
                    '--coverage ignored, because --lsprof is in use.')
608
1102
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
609
1103
        elif opt_profile:
 
1104
            if opt_coverage_dir:
 
1105
                trace.warning(
 
1106
                    '--coverage ignored, because --profile is in use.')
610
1107
            ret = apply_profiled(run, *run_argv)
 
1108
        elif opt_coverage_dir:
 
1109
            ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
611
1110
        else:
612
1111
            ret = run(*run_argv)
613
1112
        return ret or 0
614
1113
    finally:
615
 
        # reset, in case we may do other commands later within the same process
616
 
        trace.be_quiet(False)
 
1114
        # reset, in case we may do other commands later within the same
 
1115
        # process. Commands that want to execute sub-commands must propagate
 
1116
        # --verbose in their own way.
 
1117
        if 'memory' in debug.debug_flags:
 
1118
            trace.debug_memory('Process status after command:', short=False)
 
1119
        option._verbosity_level = saved_verbosity_level
 
1120
 
617
1121
 
618
1122
def display_command(func):
619
1123
    """Decorator that suppresses pipe/interrupt errors."""
627
1131
                raise
628
1132
            if e.errno != errno.EPIPE:
629
1133
                # Win32 raises IOError with errno=0 on a broken pipe
630
 
                if sys.platform != 'win32' or e.errno != 0:
 
1134
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
631
1135
                    raise
632
1136
            pass
633
1137
        except KeyboardInterrupt:
635
1139
    return ignore_pipe
636
1140
 
637
1141
 
638
 
def main(argv):
639
 
    import bzrlib.ui
640
 
    from bzrlib.ui.text import TextUIFactory
641
 
    bzrlib.ui.ui_factory = TextUIFactory()
642
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
1142
def install_bzr_command_hooks():
 
1143
    """Install the hooks to supply bzr's own commands."""
 
1144
    if _list_bzr_commands in Command.hooks["list_commands"]:
 
1145
        return
 
1146
    Command.hooks.install_named_hook("list_commands", _list_bzr_commands,
 
1147
        "bzr commands")
 
1148
    Command.hooks.install_named_hook("get_command", _get_bzr_command,
 
1149
        "bzr commands")
 
1150
    Command.hooks.install_named_hook("get_command", _get_plugin_command,
 
1151
        "bzr plugin commands")
 
1152
    Command.hooks.install_named_hook("get_command", _get_external_command,
 
1153
        "bzr external command lookup")
 
1154
    Command.hooks.install_named_hook("get_missing_command", _try_plugin_provider,
 
1155
        "bzr plugin-provider-db check")
 
1156
 
 
1157
 
 
1158
 
 
1159
def _specified_or_unicode_argv(argv):
 
1160
    # For internal or testing use, argv can be passed.  Otherwise, get it from
 
1161
    # the process arguments in a unicode-safe way.
 
1162
    if argv is None:
 
1163
        return osutils.get_unicode_argv()
 
1164
    else:
 
1165
        new_argv = []
 
1166
        try:
 
1167
            # ensure all arguments are unicode strings
 
1168
            for a in argv[1:]:
 
1169
                if isinstance(a, unicode):
 
1170
                    new_argv.append(a)
 
1171
                else:
 
1172
                    new_argv.append(a.decode('ascii'))
 
1173
        except UnicodeDecodeError:
 
1174
            raise errors.BzrError("argv should be list of unicode strings.")
 
1175
        return new_argv
 
1176
 
 
1177
 
 
1178
def main(argv=None):
 
1179
    """Main entry point of command-line interface.
 
1180
 
 
1181
    Typically `bzrlib.initialize` should be called first.
 
1182
 
 
1183
    :param argv: list of unicode command-line arguments similar to sys.argv.
 
1184
        argv[0] is script name usually, it will be ignored.
 
1185
        Don't pass here sys.argv because this list contains plain strings
 
1186
        and not unicode; pass None instead.
 
1187
 
 
1188
    :return: exit code of bzr command.
 
1189
    """
 
1190
    argv = _specified_or_unicode_argv(argv)
 
1191
    _register_builtin_commands()
643
1192
    ret = run_bzr_catch_errors(argv)
 
1193
    bzrlib.ui.ui_factory.log_transport_activity(
 
1194
        display=('bytes' in debug.debug_flags))
644
1195
    trace.mutter("return code %d", ret)
645
1196
    return ret
646
1197
 
647
1198
 
648
1199
def run_bzr_catch_errors(argv):
 
1200
    """Run a bzr command with parameters as described by argv.
 
1201
 
 
1202
    This function assumed that that UI layer is setup, that symbol deprecations
 
1203
    are already applied, and that unicode decoding has already been performed on argv.
 
1204
    """
 
1205
    # done here so that they're covered for every test run
 
1206
    install_bzr_command_hooks()
 
1207
    return exception_to_return_code(run_bzr, argv)
 
1208
 
 
1209
 
 
1210
def run_bzr_catch_user_errors(argv):
 
1211
    """Run bzr and report user errors, but let internal errors propagate.
 
1212
 
 
1213
    This is used for the test suite, and might be useful for other programs
 
1214
    that want to wrap the commandline interface.
 
1215
    """
 
1216
    # done here so that they're covered for every test run
 
1217
    install_bzr_command_hooks()
649
1218
    try:
650
1219
        return run_bzr(argv)
651
 
        # do this here inside the exception wrappers to catch EPIPE
652
 
        sys.stdout.flush()
653
 
    except (KeyboardInterrupt, Exception), e:
654
 
        # used to handle AssertionError and KeyboardInterrupt
655
 
        # specially here, but hopefully they're handled ok by the logger now
656
 
        trace.report_exception(sys.exc_info(), sys.stderr)
657
 
        if os.environ.get('BZR_PDB'):
658
 
            print '**** entering debugger'
659
 
            import pdb
660
 
            pdb.post_mortem(sys.exc_traceback)
661
 
        return 3
662
 
 
663
 
if __name__ == '__main__':
664
 
    sys.exit(main(sys.argv))
 
1220
    except Exception, e:
 
1221
        if (isinstance(e, (OSError, IOError))
 
1222
            or not getattr(e, 'internal_error', True)):
 
1223
            trace.report_exception(sys.exc_info(), sys.stderr)
 
1224
            return 3
 
1225
        else:
 
1226
            raise
 
1227
 
 
1228
 
 
1229
class HelpCommandIndex(object):
 
1230
    """A index for bzr help that returns commands."""
 
1231
 
 
1232
    def __init__(self):
 
1233
        self.prefix = 'commands/'
 
1234
 
 
1235
    def get_topics(self, topic):
 
1236
        """Search for topic amongst commands.
 
1237
 
 
1238
        :param topic: A topic to search for.
 
1239
        :return: A list which is either empty or contains a single
 
1240
            Command entry.
 
1241
        """
 
1242
        if topic and topic.startswith(self.prefix):
 
1243
            topic = topic[len(self.prefix):]
 
1244
        try:
 
1245
            cmd = _get_cmd_object(topic, check_missing=False)
 
1246
        except KeyError:
 
1247
            return []
 
1248
        else:
 
1249
            return [cmd]
 
1250
 
 
1251
 
 
1252
class Provider(object):
 
1253
    '''Generic class to be overriden by plugins'''
 
1254
 
 
1255
    def plugin_for_command(self, cmd_name):
 
1256
        '''Takes a command and returns the information for that plugin
 
1257
 
 
1258
        :return: A dictionary with all the available information
 
1259
        for the requested plugin
 
1260
        '''
 
1261
        raise NotImplementedError
 
1262
 
 
1263
 
 
1264
class ProvidersRegistry(registry.Registry):
 
1265
    '''This registry exists to allow other providers to exist'''
 
1266
 
 
1267
    def __iter__(self):
 
1268
        for key, provider in self.iteritems():
 
1269
            yield provider
 
1270
 
 
1271
command_providers_registry = ProvidersRegistry()