18
18
# TODO: probably should say which arguments are candidates for glob
19
19
# expansion on windows and do that at the command level.
21
# TODO: Help messages for options.
23
21
# TODO: Define arguments by objects, rather than just using names.
24
22
# Those objects can specify the expected type of the argument, which
25
# would help with validation and shell completion.
23
# would help with validation and shell completion. They could also provide
24
# help/explanation for that argument in a structured way.
26
# TODO: Specific "examples" property on commands for consistent formatting.
27
28
# TODO: "--profile=cum", to change sort order. Is there any value in leaving
28
29
# the profile output behind so it can be interactively examined?
34
from bzrlib.lazy_import import lazy_import
35
lazy_import(globals(), """
32
38
from warnings import warn
33
from inspect import getdoc
37
from bzrlib.trace import mutter, note, log_error, warning
38
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
39
from bzrlib.revisionspec import RevisionSpec
40
from bzrlib import BZRDIR
51
from bzrlib.symbol_versioning import (
56
from bzrlib.option import Option
45
def register_command(cmd):
46
"Utility function to help register a command"
62
def register_command(cmd, decorate=False):
63
"""Utility function to help register a command
65
:param cmd: Command subclass to register
66
:param decorate: If true, allow overriding an existing command
67
of the same name; the old command is returned by this function.
68
Otherwise it is an error to try to override an existing command.
49
72
if k.startswith("cmd_"):
50
73
k_unsquished = _unsquish_command_name(k)
53
if not plugin_cmds.has_key(k_unsquished):
54
plugin_cmds[k_unsquished] = cmd
55
mutter('registered plugin command %s', k_unsquished)
76
if k_unsquished not in plugin_cmds:
77
plugin_cmds[k_unsquished] = cmd
78
## trace.mutter('registered plugin command %s', k_unsquished)
79
if decorate and k_unsquished in builtin_command_names():
80
return _builtin_commands()[k_unsquished]
82
result = plugin_cmds[k_unsquished]
83
plugin_cmds[k_unsquished] = cmd
57
log_error('Two plugins defined the same command: %r' % k)
58
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
86
trace.log_error('Two plugins defined the same command: %r' % k)
87
trace.log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
88
trace.log_error('Previously this command was registered from %r' %
89
sys.modules[plugin_cmds[k_unsquished].__module__])
61
92
def _squish_command_name(cmd):
67
98
return cmd[4:].replace('_','-')
70
def _parse_revision_str(revstr):
71
"""This handles a revision string -> revno.
73
This always returns a list. The list will have one element for
76
>>> _parse_revision_str('234')
77
[<RevisionSpec_int 234>]
78
>>> _parse_revision_str('234..567')
79
[<RevisionSpec_int 234>, <RevisionSpec_int 567>]
80
>>> _parse_revision_str('..')
81
[<RevisionSpec None>, <RevisionSpec None>]
82
>>> _parse_revision_str('..234')
83
[<RevisionSpec None>, <RevisionSpec_int 234>]
84
>>> _parse_revision_str('234..')
85
[<RevisionSpec_int 234>, <RevisionSpec None>]
86
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
87
[<RevisionSpec_int 234>, <RevisionSpec_int 456>, <RevisionSpec_int 789>]
88
>>> _parse_revision_str('234....789') # Error?
89
[<RevisionSpec_int 234>, <RevisionSpec None>, <RevisionSpec_int 789>]
90
>>> _parse_revision_str('revid:test@other.com-234234')
91
[<RevisionSpec_revid revid:test@other.com-234234>]
92
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
93
[<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
94
>>> _parse_revision_str('revid:test@other.com-234234..23')
95
[<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_int 23>]
96
>>> _parse_revision_str('date:2005-04-12')
97
[<RevisionSpec_date date:2005-04-12>]
98
>>> _parse_revision_str('date:2005-04-12 12:24:33')
99
[<RevisionSpec_date date:2005-04-12 12:24:33>]
100
>>> _parse_revision_str('date:2005-04-12T12:24:33')
101
[<RevisionSpec_date date:2005-04-12T12:24:33>]
102
>>> _parse_revision_str('date:2005-04-12,12:24:33')
103
[<RevisionSpec_date date:2005-04-12,12:24:33>]
104
>>> _parse_revision_str('-5..23')
105
[<RevisionSpec_int -5>, <RevisionSpec_int 23>]
106
>>> _parse_revision_str('-5')
107
[<RevisionSpec_int -5>]
108
>>> _parse_revision_str('123a')
109
Traceback (most recent call last):
111
BzrError: No namespace registered for string: '123a'
112
>>> _parse_revision_str('abc')
113
Traceback (most recent call last):
115
BzrError: No namespace registered for string: 'abc'
118
old_format_re = re.compile('\d*:\d*')
119
m = old_format_re.match(revstr)
122
warning('Colon separator for revision numbers is deprecated.'
124
for rev in revstr.split(':'):
126
revs.append(RevisionSpec(int(rev)))
128
revs.append(RevisionSpec(None))
130
for x in revstr.split('..'):
132
revs.append(RevisionSpec(None))
134
revs.append(RevisionSpec(x))
138
101
def _builtin_commands():
139
102
import bzrlib.builtins
141
104
builtins = bzrlib.builtins.__dict__
142
105
for name in builtins:
143
106
if name.startswith("cmd_"):
144
real_name = _unsquish_command_name(name)
107
real_name = _unsquish_command_name(name)
145
108
r[real_name] = builtins[name]
150
112
def builtin_command_names():
242
240
"""Construct an instance of this command."""
243
241
if self.__doc__ == Command.__doc__:
244
242
warn("No help message set for %r" % self)
247
def run_argv(self, argv):
248
"""Parse command line and run."""
249
args, opts = parse_args(argv)
243
# List of standard options directly supported
244
self.supported_std_options = []
246
def _maybe_expand_globs(self, file_list):
247
"""Glob expand file_list if the platform does not do that itself.
249
:return: A possibly empty list of unicode paths.
251
Introduced in bzrlib 0.18.
255
if sys.platform == 'win32':
256
file_list = win32utils.glob_expand(file_list)
257
return list(file_list)
260
"""Return single-line grammar for this command.
262
Only describes arguments, not options.
264
s = 'bzr ' + self.name() + ' '
265
for aname in self.takes_args:
266
aname = aname.upper()
267
if aname[-1] in ['$', '+']:
268
aname = aname[:-1] + '...'
269
elif aname[-1] == '?':
270
aname = '[' + aname[:-1] + ']'
271
elif aname[-1] == '*':
272
aname = '[' + aname[:-1] + '...]'
279
def get_help_text(self, additional_see_also=None, plain=True,
280
see_also_as_links=False):
281
"""Return a text string with help for this command.
283
:param additional_see_also: Additional help topics to be
285
:param plain: if False, raw help (reStructuredText) is
286
returned instead of plain text.
287
:param see_also_as_links: if True, convert items in 'See also'
288
list to internal links (used by bzr_man rstx generator)
292
raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
294
# Extract the summary (purpose) and sections out from the text
295
purpose,sections = self._get_help_parts(doc)
297
# If a custom usage section was provided, use it
298
if sections.has_key('Usage'):
299
usage = sections.pop('Usage')
301
usage = self._usage()
303
# The header is the purpose and usage
305
result += ':Purpose: %s\n' % purpose
306
if usage.find('\n') >= 0:
307
result += ':Usage:\n%s\n' % usage
309
result += ':Usage: %s\n' % usage
313
options = option.get_optparser(self.options()).format_option_help()
314
if options.startswith('Options:'):
315
result += ':' + options
316
elif options.startswith('options:'):
317
# Python 2.4 version of optparse
318
result += ':Options:' + options[len('options:'):]
323
# Add the description, indenting it 2 spaces
324
# to match the indentation of the options
325
if sections.has_key(None):
326
text = sections.pop(None)
327
text = '\n '.join(text.splitlines())
328
result += ':%s:\n %s\n\n' % ('Description',text)
330
# Add the custom sections (e.g. Examples). Note that there's no need
331
# to indent these as they must be indented already in the source.
333
labels = sorted(sections.keys())
335
result += ':%s:\n%s\n\n' % (label,sections[label])
337
# Add the aliases, source (plug-in) and see also links, if any
339
result += ':Aliases: '
340
result += ', '.join(self.aliases) + '\n'
341
plugin_name = self.plugin_name()
342
if plugin_name is not None:
343
result += ':From: plugin "%s"\n' % plugin_name
344
see_also = self.get_see_also(additional_see_also)
346
if not plain and see_also_as_links:
348
for item in see_also:
350
# topics doesn't have an independent section
351
# so don't create a real link
352
see_also_links.append(item)
354
# Use a reST link for this entry
355
see_also_links.append("`%s`_" % (item,))
356
see_also = see_also_links
357
result += ':See also: '
358
result += ', '.join(see_also) + '\n'
360
# If this will be rendered as plan text, convert it
362
import bzrlib.help_topics
363
result = bzrlib.help_topics.help_as_plain_text(result)
367
def _get_help_parts(text):
368
"""Split help text into a summary and named sections.
370
:return: (summary,sections) where summary is the top line and
371
sections is a dictionary of the rest indexed by section name.
372
A section starts with a heading line of the form ":xxx:".
373
Indented text on following lines is the section value.
374
All text found outside a named section is assigned to the
375
default section which is given the key of None.
377
def save_section(sections, label, section):
379
if sections.has_key(label):
380
sections[label] += '\n' + section
382
sections[label] = section
384
lines = text.rstrip().splitlines()
385
summary = lines.pop(0)
387
label,section = None,''
389
if line.startswith(':') and line.endswith(':') and len(line) > 2:
390
save_section(sections, label, section)
391
label,section = line[1:-1],''
392
elif label != None and len(line) > 1 and not line[0].isspace():
393
save_section(sections, label, section)
394
label,section = None,line
397
section += '\n' + line
400
save_section(sections, label, section)
401
return summary, sections
403
def get_help_topic(self):
404
"""Return the commands help topic - its name."""
407
def get_see_also(self, additional_terms=None):
408
"""Return a list of help topics that are related to this command.
410
The list is derived from the content of the _see_also attribute. Any
411
duplicates are removed and the result is in lexical order.
412
:param additional_terms: Additional help topics to cross-reference.
413
:return: A list of help topics.
415
see_also = set(getattr(self, '_see_also', []))
417
see_also.update(additional_terms)
418
return sorted(see_also)
421
"""Return dict of valid options for this command.
423
Maps from long option name to option object."""
424
r = Option.STD_OPTIONS.copy()
426
for o in self.takes_options:
427
if isinstance(o, basestring):
428
o = option.Option.OPTIONS[o]
430
if o.name in std_names:
431
self.supported_std_options.append(o.name)
434
def _setup_outf(self):
435
"""Return a file linked to stdout, which has proper encoding."""
436
assert self.encoding_type in ['strict', 'exact', 'replace']
438
# Originally I was using self.stdout, but that looks
439
# *way* too much like sys.stdout
440
if self.encoding_type == 'exact':
441
# force sys.stdout to be binary stream on win32
442
if sys.platform == 'win32':
443
fileno = getattr(sys.stdout, 'fileno', None)
446
msvcrt.setmode(fileno(), os.O_BINARY)
447
self.outf = sys.stdout
450
output_encoding = osutils.get_terminal_encoding()
452
self.outf = codecs.getwriter(output_encoding)(sys.stdout,
453
errors=self.encoding_type)
454
# For whatever reason codecs.getwriter() does not advertise its encoding
455
# it just returns the encoding of the wrapped file, which is completely
456
# bogus. So set the attribute, so we can find the correct encoding later.
457
self.outf.encoding = output_encoding
459
def run_argv_aliases(self, argv, alias_argv=None):
460
"""Parse the command line and run with extra aliases in alias_argv."""
462
warn("Passing None for [] is deprecated from bzrlib 0.10",
463
DeprecationWarning, stacklevel=2)
465
args, opts = parse_args(self, argv, alias_argv)
467
# Process the standard options
251
468
if 'help' in opts: # e.g. bzr add --help
252
from bzrlib.help import help_on_command
253
help_on_command(self.name())
469
sys.stdout.write(self.get_help_text())
256
# check options are reasonable
257
allowed = self.takes_options
259
if oname not in allowed:
260
raise BzrCommandError("option '--%s' is not allowed for command %r"
261
% (oname, self.name()))
471
trace.set_verbosity_level(option._verbosity_level)
472
if 'verbose' in self.supported_std_options:
473
opts['verbose'] = trace.is_verbose()
474
elif opts.has_key('verbose'):
476
if 'quiet' in self.supported_std_options:
477
opts['quiet'] = trace.is_quiet()
478
elif opts.has_key('quiet'):
263
481
# mix arguments and options into one dictionary
264
482
cmdargs = _match_argform(self.name(), self.takes_args, args)
295
515
return _unsquish_command_name(self.__class__.__name__)
517
def plugin_name(self):
518
"""Get the name of the plugin that provides this command.
298
def parse_spec(spec):
304
>>> parse_spec("../@")
306
>>> parse_spec("../f/@35")
308
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
309
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
314
parsed = spec.split('/@')
315
assert len(parsed) == 2
520
:return: The name of the plugin or None if the command is builtin.
522
mod_parts = self.__module__.split('.')
523
if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
320
parsed[1] = int(parsed[1])
322
pass # We can allow stuff like ./@revid:blahblahblah
326
parsed = [spec, None]
330
# list of all available options; the rhs can be either None for an
331
# option that takes no argument, or a constructor function that checks
345
'revision': _parse_revision_str,
370
def parse_args(argv):
529
def parse_args(command, argv, alias_argv=None):
371
530
"""Parse command line.
373
532
Arguments and options are parsed at this level before being passed
374
533
down to specific command handlers. This routine knows, from a
375
534
lookup table, something about the available options, what optargs
376
535
they take, and which commands will accept them.
378
>>> parse_args('--help'.split())
380
>>> parse_args('help -- --invalidcmd'.split())
381
(['help', '--invalidcmd'], {})
382
>>> parse_args('--version'.split())
383
([], {'version': True})
384
>>> parse_args('status --all'.split())
385
(['status'], {'all': True})
386
>>> parse_args('commit --message=biter'.split())
387
(['commit'], {'message': u'biter'})
388
>>> parse_args('log -r 500'.split())
389
(['log'], {'revision': [<RevisionSpec_int 500>]})
390
>>> parse_args('log -r500..600'.split())
391
(['log'], {'revision': [<RevisionSpec_int 500>, <RevisionSpec_int 600>]})
392
>>> parse_args('log -vr500..600'.split())
393
(['log'], {'verbose': True, 'revision': [<RevisionSpec_int 500>, <RevisionSpec_int 600>]})
394
>>> parse_args('log -rrevno:500..600'.split()) #the r takes an argument
395
(['log'], {'revision': [<RevisionSpec_revno revno:500>, <RevisionSpec_int 600>]})
403
if not argsover and a[0] == '-':
404
# option names must not be unicode
409
# We've received a standalone -- No more flags
412
mutter(" got option %r" % a)
414
optname, optarg = a[2:].split('=', 1)
417
if optname not in OPTIONS:
418
raise BzrError('unknown long option %r' % a)
421
if shortopt in SHORT_OPTIONS:
422
# Multi-character options must have a space to delimit
424
optname = SHORT_OPTIONS[shortopt]
426
# Single character short options, can be chained,
427
# and have their value appended to their name
429
if shortopt not in SHORT_OPTIONS:
430
# We didn't find the multi-character name, and we
431
# didn't find the single char name
432
raise BzrError('unknown short option %r' % a)
433
optname = SHORT_OPTIONS[shortopt]
436
# There are extra things on this option
437
# see if it is the value, or if it is another
439
optargfn = OPTIONS[optname]
441
# This option does not take an argument, so the
442
# next entry is another short option, pack it back
444
argv.insert(0, '-' + a[2:])
446
# This option takes an argument, so pack it
451
# XXX: Do we ever want to support this, e.g. for -r?
452
raise BzrError('repeated option %r' % a)
454
optargfn = OPTIONS[optname]
458
raise BzrError('option %r needs an argument' % a)
461
opts[optname] = optargfn(optarg)
464
raise BzrError('option %r takes no argument' % optname)
537
# TODO: make it a method of the Command?
538
parser = option.get_optparser(command.options())
539
if alias_argv is not None:
540
args = alias_argv + argv
544
options, args = parser.parse_args(args)
545
opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
546
v is not option.OptionParser.DEFAULT_VALUE])
469
547
return args, opts
474
550
def _match_argform(cmd, takes_args, args):
488
564
argdict[argname + '_list'] = None
489
565
elif ap[-1] == '+':
491
raise BzrCommandError("command %r needs one or more %s"
492
% (cmd, argname.upper()))
567
raise errors.BzrCommandError("command %r needs one or more %s"
568
% (cmd, argname.upper()))
494
570
argdict[argname + '_list'] = args[:]
496
572
elif ap[-1] == '$': # all but one
497
573
if len(args) < 2:
498
raise BzrCommandError("command %r needs one or more %s"
499
% (cmd, argname.upper()))
574
raise errors.BzrCommandError("command %r needs one or more %s"
575
% (cmd, argname.upper()))
500
576
argdict[argname + '_list'] = args[:-1]
503
579
# just a plain arg
506
raise BzrCommandError("command %r requires argument %s"
507
% (cmd, argname.upper()))
582
raise errors.BzrCommandError("command %r requires argument %s"
583
% (cmd, argname.upper()))
509
585
argdict[argname] = args.pop(0)
512
raise BzrCommandError("extra argument to command %s: %s"
588
raise errors.BzrCommandError("extra argument to command %s: %s"
593
def apply_coveraged(dirname, the_callable, *args, **kwargs):
594
# Cannot use "import trace", as that would import bzrlib.trace instead of
595
# the standard library's trace.
596
trace = __import__('trace')
598
tracer = trace.Trace(count=1, trace=0)
599
sys.settrace(tracer.globaltrace)
601
ret = the_callable(*args, **kwargs)
604
results = tracer.results()
605
results.write_results(show_missing=1, summary=False,
519
609
def apply_profiled(the_callable, *args, **kwargs):
557
685
Do not load plugin modules at all
560
691
Only use builtin commands. (Plugins are still allowed to change
561
692
other behaviour.)
564
Run under the Python profiler.
695
Run under the Python hotshot profiler.
698
Run under the Python lsprof profiler.
701
Generate line coverage report in the specified directory.
566
# Load all of the transport methods
567
import bzrlib.transport.local, bzrlib.transport.http
569
argv = [a.decode(bzrlib.user_encoding) for a in argv]
704
trace.mutter("bzr arguments: %r", argv)
571
opt_profile = opt_no_plugins = opt_builtin = False
706
opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
707
opt_no_aliases = False
708
opt_lsprof_file = opt_coverage_dir = None
573
710
# --no-plugins is handled specially at a very early stage. We need
574
711
# to load plugins before doing other command parsing so that they
575
712
# can override commands, but this needs to happen first.
578
718
if a == '--profile':
579
719
opt_profile = True
720
elif a == '--lsprof':
722
elif a == '--lsprof-file':
724
opt_lsprof_file = argv[i + 1]
580
726
elif a == '--no-plugins':
581
727
opt_no_plugins = True
728
elif a == '--no-aliases':
729
opt_no_aliases = True
582
730
elif a == '--builtin':
583
731
opt_builtin = True
732
elif a == '--coverage':
733
opt_coverage_dir = argv[i + 1]
735
elif a.startswith('-D'):
736
debug.debug_flags.add(a[2:])
588
if (not argv) or (argv[0] == '--help'):
589
from bzrlib.help import help
743
from bzrlib.builtins import cmd_help
744
cmd_help().run_argv_aliases([])
596
747
if argv[0] == '--version':
597
from bzrlib.builtins import show_version
748
from bzrlib.builtins import cmd_version
749
cmd_version().run_argv_aliases([])
601
752
if not opt_no_plugins:
602
753
from bzrlib.plugin import load_plugins
605
cmd = str(argv.pop(0))
756
from bzrlib.plugin import disable_plugins
761
if not opt_no_aliases:
762
alias_argv = get_alias(argv[0])
764
alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
765
argv[0] = alias_argv.pop(0)
768
# We want only 'ascii' command names, but the user may have typed
769
# in a Unicode name. In that case, they should just get a
770
# 'command not found' error later.
607
772
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
610
ret = apply_profiled(cmd_obj.run_argv, argv)
612
ret = cmd_obj.run_argv(argv)
773
run = cmd_obj.run_argv_aliases
774
run_argv = [argv, alias_argv]
780
'--coverage ignored, because --lsprof is in use.')
781
ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
785
'--coverage ignored, because --profile is in use.')
786
ret = apply_profiled(run, *run_argv)
787
elif opt_coverage_dir:
788
ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
793
# reset, in case we may do other commands later within the same process
794
option._verbosity_level = 0
796
def display_command(func):
797
"""Decorator that suppresses pipe/interrupt errors."""
798
def ignore_pipe(*args, **kwargs):
800
result = func(*args, **kwargs)
804
if getattr(e, 'errno', None) is None:
806
if e.errno != errno.EPIPE:
807
# Win32 raises IOError with errno=0 on a broken pipe
808
if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
811
except KeyboardInterrupt:
618
bzrlib.trace.log_startup(argv)
619
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
621
return run_bzr_catch_errors(argv[1:])
818
from bzrlib.ui.text import TextUIFactory
819
bzrlib.ui.ui_factory = TextUIFactory()
821
argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
822
except UnicodeDecodeError:
823
raise errors.BzrError(("Parameter '%r' is unsupported by the current "
825
ret = run_bzr_catch_errors(argv)
826
trace.mutter("return code %d", ret)
624
830
def run_bzr_catch_errors(argv):
630
# do this here inside the exception wrappers to catch EPIPE
632
#wrap common errors as CommandErrors.
633
except (NotBranchError,), e:
634
raise BzrCommandError(str(e))
635
except BzrCommandError, e:
636
# command line syntax error, etc
640
bzrlib.trace.log_exception()
642
except AssertionError, e:
643
bzrlib.trace.log_exception('assertion failed: ' + str(e))
645
except KeyboardInterrupt, e:
646
bzrlib.trace.log_exception('interrupted')
831
# Note: The except clause logic below should be kept in sync with the
832
# profile() routine in lsprof.py.
835
except (KeyboardInterrupt, Exception), e:
836
# used to handle AssertionError and KeyboardInterrupt
837
# specially here, but hopefully they're handled ok by the logger now
838
exitcode = trace.report_exception(sys.exc_info(), sys.stderr)
839
if os.environ.get('BZR_PDB'):
840
print '**** entering debugger'
842
pdb.post_mortem(sys.exc_traceback)
846
def run_bzr_catch_user_errors(argv):
847
"""Run bzr and report user errors, but let internal errors propagate.
849
This is used for the test suite, and might be useful for other programs
850
that want to wrap the commandline interface.
648
854
except Exception, e:
650
if (isinstance(e, IOError)
651
and hasattr(e, 'errno')
652
and e.errno == errno.EPIPE):
653
bzrlib.trace.note('broken pipe')
656
bzrlib.trace.log_exception()
855
if (isinstance(e, (OSError, IOError))
856
or not getattr(e, 'internal_error', True)):
857
trace.report_exception(sys.exc_info(), sys.stderr)
863
class HelpCommandIndex(object):
864
"""A index for bzr help that returns commands."""
867
self.prefix = 'commands/'
869
def get_topics(self, topic):
870
"""Search for topic amongst commands.
872
:param topic: A topic to search for.
873
:return: A list which is either empty or contains a single
876
if topic and topic.startswith(self.prefix):
877
topic = topic[len(self.prefix):]
879
cmd = _get_cmd_object(topic)
659
886
if __name__ == '__main__':
660
887
sys.exit(main(sys.argv))
added
removed
bzrlib/commands.py
