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.
21
23
# TODO: Define arguments by objects, rather than just using names.
22
24
# Those objects can specify the expected type of the argument, which
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.
25
# would help with validation and shell completion.
28
27
# TODO: "--profile=cum", to change sort order. Is there any value in leaving
29
28
# the profile output behind so it can be interactively examined?
34
from bzrlib.lazy_import import lazy_import
35
lazy_import(globals(), """
38
32
from warnings import warn
33
from inspect import getdoc
52
from bzrlib.symbol_versioning import (
57
from bzrlib.option import Option
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
63
def register_command(cmd, decorate=False):
64
"""Utility function to help register a command
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.
45
def register_command(cmd):
46
"Utility function to help register a command"
73
49
if k.startswith("cmd_"):
74
50
k_unsquished = _unsquish_command_name(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]
83
result = plugin_cmds[k_unsquished]
84
plugin_cmds[k_unsquished] = cmd
53
if not plugin_cmds.has_key(k_unsquished):
54
plugin_cmds[k_unsquished] = cmd
55
mutter('registered plugin command %s', k_unsquished)
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__])
89
trace.log_error('Previously this command was registered from %r' %
90
sys.modules[plugin_cmds[k_unsquished].__module__])
57
log_error('Two plugins defined the same command: %r' % k)
58
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
93
61
def _squish_command_name(cmd):
97
65
def _unsquish_command_name(cmd):
66
assert cmd.startswith("cmd_")
98
67
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
74
each revision specifier supplied.
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'
116
>>> _parse_revision_str('branch:../branch2')
117
[<RevisionSpec_branch branch:../branch2>]
120
old_format_re = re.compile('\d*:\d*')
121
m = old_format_re.match(revstr)
124
warning('Colon separator for revision numbers is deprecated.'
126
for rev in revstr.split(':'):
128
revs.append(RevisionSpec(int(rev)))
130
revs.append(RevisionSpec(None))
133
for x in revstr.split('..'):
135
revs.append(RevisionSpec(None))
137
# looks like a namespace:.. has happened
138
next_prefix = x + '..'
140
if next_prefix is not None:
142
revs.append(RevisionSpec(x))
144
if next_prefix is not None:
145
revs.append(RevisionSpec(next_prefix))
101
149
def _builtin_commands():
102
150
import bzrlib.builtins
104
152
builtins = bzrlib.builtins.__dict__
105
153
for name in builtins:
106
154
if name.startswith("cmd_"):
107
real_name = _unsquish_command_name(name)
155
real_name = _unsquish_command_name(name)
108
156
r[real_name] = builtins[name]
112
161
def builtin_command_names():
251
253
"""Construct an instance of this command."""
252
254
if self.__doc__ == Command.__doc__:
253
255
warn("No help message set for %r" % self)
254
# List of standard options directly supported
255
self.supported_std_options = []
257
def _maybe_expand_globs(self, file_list):
258
"""Glob expand file_list if the platform does not do that itself.
260
:return: A possibly empty list of unicode paths.
262
Introduced in bzrlib 0.18.
266
if sys.platform == 'win32':
267
file_list = win32utils.glob_expand(file_list)
268
return list(file_list)
271
"""Return single-line grammar for this command.
273
Only describes arguments, not options.
275
s = 'bzr ' + self.name() + ' '
276
for aname in self.takes_args:
277
aname = aname.upper()
278
if aname[-1] in ['$', '+']:
279
aname = aname[:-1] + '...'
280
elif aname[-1] == '?':
281
aname = '[' + aname[:-1] + ']'
282
elif aname[-1] == '*':
283
aname = '[' + aname[:-1] + '...]'
285
s = s[:-1] # remove last space
288
def get_help_text(self, additional_see_also=None, plain=True,
289
see_also_as_links=False):
290
"""Return a text string with help for this command.
292
:param additional_see_also: Additional help topics to be
294
:param plain: if False, raw help (reStructuredText) is
295
returned instead of plain text.
296
:param see_also_as_links: if True, convert items in 'See also'
297
list to internal links (used by bzr_man rstx generator)
301
raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
303
# Extract the summary (purpose) and sections out from the text
304
purpose,sections = self._get_help_parts(doc)
306
# If a custom usage section was provided, use it
307
if sections.has_key('Usage'):
308
usage = sections.pop('Usage')
310
usage = self._usage()
312
# The header is the purpose and usage
314
result += ':Purpose: %s\n' % purpose
315
if usage.find('\n') >= 0:
316
result += ':Usage:\n%s\n' % usage
318
result += ':Usage: %s\n' % usage
322
options = option.get_optparser(self.options()).format_option_help()
323
if options.startswith('Options:'):
324
result += ':' + options
325
elif options.startswith('options:'):
326
# Python 2.4 version of optparse
327
result += ':Options:' + options[len('options:'):]
332
# Add the description, indenting it 2 spaces
333
# to match the indentation of the options
334
if sections.has_key(None):
335
text = sections.pop(None)
336
text = '\n '.join(text.splitlines())
337
result += ':%s:\n %s\n\n' % ('Description',text)
339
# Add the custom sections (e.g. Examples). Note that there's no need
340
# to indent these as they must be indented already in the source.
342
labels = sorted(sections.keys())
344
result += ':%s:\n%s\n\n' % (label,sections[label])
346
# Add the aliases, source (plug-in) and see also links, if any
348
result += ':Aliases: '
349
result += ', '.join(self.aliases) + '\n'
350
plugin_name = self.plugin_name()
351
if plugin_name is not None:
352
result += ':From: plugin "%s"\n' % plugin_name
353
see_also = self.get_see_also(additional_see_also)
355
if not plain and see_also_as_links:
357
for item in see_also:
359
# topics doesn't have an independent section
360
# so don't create a real link
361
see_also_links.append(item)
363
# Use a reST link for this entry
364
see_also_links.append("`%s`_" % (item,))
365
see_also = see_also_links
366
result += ':See also: '
367
result += ', '.join(see_also) + '\n'
369
# If this will be rendered as plain text, convert it
371
import bzrlib.help_topics
372
result = bzrlib.help_topics.help_as_plain_text(result)
376
def _get_help_parts(text):
377
"""Split help text into a summary and named sections.
379
:return: (summary,sections) where summary is the top line and
380
sections is a dictionary of the rest indexed by section name.
381
A section starts with a heading line of the form ":xxx:".
382
Indented text on following lines is the section value.
383
All text found outside a named section is assigned to the
384
default section which is given the key of None.
386
def save_section(sections, label, section):
388
if sections.has_key(label):
389
sections[label] += '\n' + section
391
sections[label] = section
393
lines = text.rstrip().splitlines()
394
summary = lines.pop(0)
396
label,section = None,''
398
if line.startswith(':') and line.endswith(':') and len(line) > 2:
399
save_section(sections, label, section)
400
label,section = line[1:-1],''
401
elif (label is not None) and len(line) > 1 and not line[0].isspace():
402
save_section(sections, label, section)
403
label,section = None,line
406
section += '\n' + line
409
save_section(sections, label, section)
410
return summary, sections
412
def get_help_topic(self):
413
"""Return the commands help topic - its name."""
416
def get_see_also(self, additional_terms=None):
417
"""Return a list of help topics that are related to this command.
419
The list is derived from the content of the _see_also attribute. Any
420
duplicates are removed and the result is in lexical order.
421
:param additional_terms: Additional help topics to cross-reference.
422
:return: A list of help topics.
424
see_also = set(getattr(self, '_see_also', []))
426
see_also.update(additional_terms)
427
return sorted(see_also)
430
"""Return dict of valid options for this command.
432
Maps from long option name to option object."""
433
r = Option.STD_OPTIONS.copy()
435
for o in self.takes_options:
436
if isinstance(o, basestring):
437
o = option.Option.OPTIONS[o]
439
if o.name in std_names:
440
self.supported_std_options.append(o.name)
443
def _setup_outf(self):
444
"""Return a file linked to stdout, which has proper encoding."""
445
# Originally I was using self.stdout, but that looks
446
# *way* too much like sys.stdout
447
if self.encoding_type == 'exact':
448
# force sys.stdout to be binary stream on win32
449
if sys.platform == 'win32':
450
fileno = getattr(sys.stdout, 'fileno', None)
453
msvcrt.setmode(fileno(), os.O_BINARY)
454
self.outf = sys.stdout
457
output_encoding = osutils.get_terminal_encoding()
459
self.outf = codecs.getwriter(output_encoding)(sys.stdout,
460
errors=self.encoding_type)
461
# For whatever reason codecs.getwriter() does not advertise its encoding
462
# it just returns the encoding of the wrapped file, which is completely
463
# bogus. So set the attribute, so we can find the correct encoding later.
464
self.outf.encoding = output_encoding
466
def run_argv_aliases(self, argv, alias_argv=None):
467
"""Parse the command line and run with extra aliases in alias_argv."""
469
warn("Passing None for [] is deprecated from bzrlib 0.10",
470
DeprecationWarning, stacklevel=2)
472
args, opts = parse_args(self, argv, alias_argv)
474
# Process the standard options
258
def run_argv(self, argv):
259
"""Parse command line and run."""
260
args, opts = parse_args(argv)
475
262
if 'help' in opts: # e.g. bzr add --help
476
sys.stdout.write(self.get_help_text())
263
from bzrlib.help import help_on_command
264
help_on_command(self.name())
478
trace.set_verbosity_level(option._verbosity_level)
479
if 'verbose' in self.supported_std_options:
480
opts['verbose'] = trace.is_verbose()
481
elif opts.has_key('verbose'):
483
if 'quiet' in self.supported_std_options:
484
opts['quiet'] = trace.is_quiet()
485
elif opts.has_key('quiet'):
267
# check options are reasonable
268
allowed = self.takes_options
270
if oname not in allowed:
271
raise BzrCommandError("option '--%s' is not allowed for command %r"
272
% (oname, self.name()))
488
274
# mix arguments and options into one dictionary
489
275
cmdargs = _match_argform(self.name(), self.takes_args, args)
522
306
return _unsquish_command_name(self.__class__.__name__)
524
def plugin_name(self):
525
"""Get the name of the plugin that provides this command.
527
:return: The name of the plugin or None if the command is builtin.
529
mod_parts = self.__module__.split('.')
530
if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
309
def parse_spec(spec):
315
>>> parse_spec("../@")
317
>>> parse_spec("../f/@35")
319
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
320
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
325
parsed = spec.split('/@')
326
assert len(parsed) == 2
536
def parse_args(command, argv, alias_argv=None):
331
parsed[1] = int(parsed[1])
333
pass # We can allow stuff like ./@revid:blahblahblah
337
parsed = [spec, None]
341
# list of all available options; the rhs can be either None for an
342
# option that takes no argument, or a constructor function that checks
356
'revision': _parse_revision_str,
382
def parse_args(argv):
537
383
"""Parse command line.
539
385
Arguments and options are parsed at this level before being passed
540
386
down to specific command handlers. This routine knows, from a
541
387
lookup table, something about the available options, what optargs
542
388
they take, and which commands will accept them.
390
>>> parse_args('--help'.split())
392
>>> parse_args('help -- --invalidcmd'.split())
393
(['help', '--invalidcmd'], {})
394
>>> parse_args('--version'.split())
395
([], {'version': True})
396
>>> parse_args('status --all'.split())
397
(['status'], {'all': True})
398
>>> parse_args('commit --message=biter'.split())
399
(['commit'], {'message': u'biter'})
400
>>> parse_args('log -r 500'.split())
401
(['log'], {'revision': [<RevisionSpec_int 500>]})
402
>>> parse_args('log -r500..600'.split())
403
(['log'], {'revision': [<RevisionSpec_int 500>, <RevisionSpec_int 600>]})
404
>>> parse_args('log -vr500..600'.split())
405
(['log'], {'verbose': True, 'revision': [<RevisionSpec_int 500>, <RevisionSpec_int 600>]})
406
>>> parse_args('log -rrevno:500..600'.split()) #the r takes an argument
407
(['log'], {'revision': [<RevisionSpec_revno revno:500>, <RevisionSpec_int 600>]})
544
# TODO: make it a method of the Command?
545
parser = option.get_optparser(command.options())
546
if alias_argv is not None:
547
args = alias_argv + argv
551
options, args = parser.parse_args(args)
552
opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
553
v is not option.OptionParser.DEFAULT_VALUE])
415
if not argsover and a[0] == '-':
416
# option names must not be unicode
421
# We've received a standalone -- No more flags
424
mutter(" got option %r" % a)
426
optname, optarg = a[2:].split('=', 1)
429
if optname not in OPTIONS:
430
raise BzrError('unknown long option %r' % a)
433
if shortopt in SHORT_OPTIONS:
434
# Multi-character options must have a space to delimit
436
optname = SHORT_OPTIONS[shortopt]
438
# Single character short options, can be chained,
439
# and have their value appended to their name
441
if shortopt not in SHORT_OPTIONS:
442
# We didn't find the multi-character name, and we
443
# didn't find the single char name
444
raise BzrError('unknown short option %r' % a)
445
optname = SHORT_OPTIONS[shortopt]
448
# There are extra things on this option
449
# see if it is the value, or if it is another
451
optargfn = OPTIONS[optname]
453
# This option does not take an argument, so the
454
# next entry is another short option, pack it back
456
argv.insert(0, '-' + a[2:])
458
# This option takes an argument, so pack it
463
# XXX: Do we ever want to support this, e.g. for -r?
464
raise BzrError('repeated option %r' % a)
466
optargfn = OPTIONS[optname]
470
raise BzrError('option %r needs an argument' % a)
473
opts[optname] = optargfn(optarg)
476
raise BzrError('option %r takes no argument' % optname)
554
481
return args, opts
557
486
def _match_argform(cmd, takes_args, args):
571
500
argdict[argname + '_list'] = None
572
501
elif ap[-1] == '+':
574
raise errors.BzrCommandError("command %r needs one or more %s"
575
% (cmd, argname.upper()))
503
raise BzrCommandError("command %r needs one or more %s"
504
% (cmd, argname.upper()))
577
506
argdict[argname + '_list'] = args[:]
579
508
elif ap[-1] == '$': # all but one
580
509
if len(args) < 2:
581
raise errors.BzrCommandError("command %r needs one or more %s"
582
% (cmd, argname.upper()))
510
raise BzrCommandError("command %r needs one or more %s"
511
% (cmd, argname.upper()))
583
512
argdict[argname + '_list'] = args[:-1]
586
515
# just a plain arg
589
raise errors.BzrCommandError("command %r requires argument %s"
590
% (cmd, argname.upper()))
518
raise BzrCommandError("command %r requires argument %s"
519
% (cmd, argname.upper()))
592
521
argdict[argname] = args.pop(0)
595
raise errors.BzrCommandError("extra argument to command %s: %s"
524
raise BzrCommandError("extra argument to command %s: %s"
600
def apply_coveraged(dirname, the_callable, *args, **kwargs):
601
# Cannot use "import trace", as that would import bzrlib.trace instead of
602
# the standard library's trace.
603
trace = __import__('trace')
605
tracer = trace.Trace(count=1, trace=0)
606
sys.settrace(tracer.globaltrace)
608
ret = the_callable(*args, **kwargs)
611
results = tracer.results()
612
results.write_results(show_missing=1, summary=False,
616
531
def apply_profiled(the_callable, *args, **kwargs):
692
569
Do not load plugin modules at all
698
572
Only use builtin commands. (Plugins are still allowed to change
699
573
other behaviour.)
702
Run under the Python hotshot profiler.
705
Run under the Python lsprof profiler.
708
Generate line coverage report in the specified directory.
576
Run under the Python profiler.
711
trace.mutter("bzr arguments: %r", argv)
578
# Load all of the transport methods
579
import bzrlib.transport.local, bzrlib.transport.http
581
argv = [a.decode(bzrlib.user_encoding) for a in argv]
713
opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
714
opt_no_aliases = False
715
opt_lsprof_file = opt_coverage_dir = None
583
opt_profile = opt_no_plugins = opt_builtin = False
717
585
# --no-plugins is handled specially at a very early stage. We need
718
586
# to load plugins before doing other command parsing so that they
719
587
# can override commands, but this needs to happen first.
725
590
if a == '--profile':
726
591
opt_profile = True
727
elif a == '--lsprof':
729
elif a == '--lsprof-file':
731
opt_lsprof_file = argv[i + 1]
733
592
elif a == '--no-plugins':
734
593
opt_no_plugins = True
735
elif a == '--no-aliases':
736
opt_no_aliases = True
737
594
elif a == '--builtin':
738
595
opt_builtin = True
739
elif a == '--coverage':
740
opt_coverage_dir = argv[i + 1]
742
elif a.startswith('-D'):
743
debug.debug_flags.add(a[2:])
750
from bzrlib.builtins import cmd_help
751
cmd_help().run_argv_aliases([])
600
if (not argv) or (argv[0] == '--help'):
601
from bzrlib.help import help
754
608
if argv[0] == '--version':
755
from bzrlib.builtins import cmd_version
756
cmd_version().run_argv_aliases([])
609
from bzrlib.builtins import show_version
759
613
if not opt_no_plugins:
760
614
from bzrlib.plugin import load_plugins
763
from bzrlib.plugin import disable_plugins
768
if not opt_no_aliases:
769
alias_argv = get_alias(argv[0])
771
alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
772
argv[0] = alias_argv.pop(0)
775
# We want only 'ascii' command names, but the user may have typed
776
# in a Unicode name. In that case, they should just get a
777
# 'command not found' error later.
617
cmd = str(argv.pop(0))
779
619
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
780
run = cmd_obj.run_argv_aliases
781
run_argv = [argv, alias_argv]
787
'--coverage ignored, because --lsprof is in use.')
788
ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
792
'--coverage ignored, because --profile is in use.')
793
ret = apply_profiled(run, *run_argv)
794
elif opt_coverage_dir:
795
ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
798
if 'memory' in debug.debug_flags:
800
status_file = file('/proc/%s/status' % os.getpid(), 'rb')
804
status = status_file.read()
806
trace.note("Process status after command:")
807
for line in status.splitlines():
811
# reset, in case we may do other commands later within the same process
812
option._verbosity_level = 0
814
def display_command(func):
815
"""Decorator that suppresses pipe/interrupt errors."""
816
def ignore_pipe(*args, **kwargs):
818
result = func(*args, **kwargs)
822
if getattr(e, 'errno', None) is None:
824
if e.errno != errno.EPIPE:
825
# Win32 raises IOError with errno=0 on a broken pipe
826
if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
829
except KeyboardInterrupt:
622
ret = apply_profiled(cmd_obj.run_argv, argv)
624
ret = cmd_obj.run_argv(argv)
836
from bzrlib.ui.text import TextUIFactory
837
bzrlib.ui.ui_factory = TextUIFactory()
839
# Is this a final release version? If so, we should suppress warnings
840
if bzrlib.version_info[3] == 'final':
841
from bzrlib import symbol_versioning
842
symbol_versioning.suppress_deprecation_warnings(override=False)
844
argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
845
except UnicodeDecodeError:
846
raise errors.BzrError(("Parameter '%r' is unsupported by the current "
848
ret = run_bzr_catch_errors(argv)
849
trace.mutter("return code %d", ret)
630
bzrlib.trace.log_startup(argv)
631
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
633
return run_bzr_catch_errors(argv[1:])
853
636
def run_bzr_catch_errors(argv):
854
# Note: The except clause logic below should be kept in sync with the
855
# profile() routine in lsprof.py.
858
except (KeyboardInterrupt, Exception), e:
859
# used to handle AssertionError and KeyboardInterrupt
860
# specially here, but hopefully they're handled ok by the logger now
861
exitcode = trace.report_exception(sys.exc_info(), sys.stderr)
862
if os.environ.get('BZR_PDB'):
863
print '**** entering debugger'
865
pdb.post_mortem(sys.exc_traceback)
869
def run_bzr_catch_user_errors(argv):
870
"""Run bzr and report user errors, but let internal errors propagate.
872
This is used for the test suite, and might be useful for other programs
873
that want to wrap the commandline interface.
641
# do this here inside the exception wrappers to catch EPIPE
643
except BzrCommandError, e:
644
# command line syntax error, etc
648
bzrlib.trace.log_exception()
650
except AssertionError, e:
651
bzrlib.trace.log_exception('assertion failed: ' + str(e))
653
except KeyboardInterrupt, e:
654
bzrlib.trace.log_exception('interrupted')
877
656
except Exception, e:
878
if (isinstance(e, (OSError, IOError))
879
or not getattr(e, 'internal_error', True)):
880
trace.report_exception(sys.exc_info(), sys.stderr)
886
class HelpCommandIndex(object):
887
"""A index for bzr help that returns commands."""
890
self.prefix = 'commands/'
892
def get_topics(self, topic):
893
"""Search for topic amongst commands.
895
:param topic: A topic to search for.
896
:return: A list which is either empty or contains a single
899
if topic and topic.startswith(self.prefix):
900
topic = topic[len(self.prefix):]
902
cmd = _get_cmd_object(topic)
909
class Provider(object):
910
'''Generic class to be overriden by plugins'''
912
def plugin_for_command(self, cmd_name):
913
'''Takes a command and returns the information for that plugin
915
:return: A dictionary with all the available information
916
for the requested plugin
918
raise NotImplementedError
921
class ProvidersRegistry(registry.Registry):
922
'''This registry exists to allow other providers to exist'''
925
for key, provider in self.iteritems():
928
command_providers_registry = ProvidersRegistry()
658
if (isinstance(e, IOError)
659
and hasattr(e, 'errno')
660
and e.errno == errno.EPIPE):
661
bzrlib.trace.note('broken pipe')
666
bzrlib.trace.log_exception()
931
669
if __name__ == '__main__':
932
670
sys.exit(main(sys.argv))
added
removed
bzrlib/commands.py
