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.
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?
34
from bzrlib.lazy_import import lazy_import
35
lazy_import(globals(), """
31
38
from warnings import warn
32
from inspect import getdoc
36
from bzrlib.trace import mutter, note, log_error, warning
37
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
38
from bzrlib.branch import find_branch
39
from bzrlib import BZRDIR
52
from bzrlib.symbol_versioning import (
57
from bzrlib.option import Option
44
def register_command(cmd):
45
"Utility function to help register a command"
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.
48
73
if k.startswith("cmd_"):
49
74
k_unsquished = _unsquish_command_name(k)
52
if not plugin_cmds.has_key(k_unsquished):
53
plugin_cmds[k_unsquished] = cmd
54
mutter('registered plugin command %s', k_unsquished)
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
56
log_error('Two plugins defined the same command: %r' % k)
57
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
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__])
60
93
def _squish_command_name(cmd):
64
97
def _unsquish_command_name(cmd):
65
assert cmd.startswith("cmd_")
66
98
return cmd[4:].replace('_','-')
69
def _parse_revision_str(revstr):
70
"""This handles a revision string -> revno.
72
This always returns a list. The list will have one element for
74
It supports integers directly, but everything else it
75
defers for passing to Branch.get_revision_info()
77
>>> _parse_revision_str('234')
79
>>> _parse_revision_str('234..567')
81
>>> _parse_revision_str('..')
83
>>> _parse_revision_str('..234')
85
>>> _parse_revision_str('234..')
87
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
89
>>> _parse_revision_str('234....789') # Error?
91
>>> _parse_revision_str('revid:test@other.com-234234')
92
['revid:test@other.com-234234']
93
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
94
['revid:test@other.com-234234', 'revid:test@other.com-234235']
95
>>> _parse_revision_str('revid:test@other.com-234234..23')
96
['revid:test@other.com-234234', 23]
97
>>> _parse_revision_str('date:2005-04-12')
99
>>> _parse_revision_str('date:2005-04-12 12:24:33')
100
['date:2005-04-12 12:24:33']
101
>>> _parse_revision_str('date:2005-04-12T12:24:33')
102
['date:2005-04-12T12:24:33']
103
>>> _parse_revision_str('date:2005-04-12,12:24:33')
104
['date:2005-04-12,12:24:33']
105
>>> _parse_revision_str('-5..23')
107
>>> _parse_revision_str('-5')
109
>>> _parse_revision_str('123a')
111
>>> _parse_revision_str('abc')
115
old_format_re = re.compile('\d*:\d*')
116
m = old_format_re.match(revstr)
118
warning('Colon separator for revision numbers is deprecated.'
121
for rev in revstr.split(':'):
123
revs.append(int(rev))
128
for x in revstr.split('..'):
139
def get_merge_type(typestring):
140
"""Attempt to find the merge class/factory associated with a string."""
141
from merge import merge_types
143
return merge_types[typestring][0]
145
templ = '%s%%7s: %%s' % (' '*12)
146
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
147
type_list = '\n'.join(lines)
148
msg = "No known merge type %s. Supported types are:\n%s" %\
149
(typestring, type_list)
150
raise BzrCommandError(msg)
153
101
def _builtin_commands():
154
102
import bzrlib.builtins
156
104
builtins = bzrlib.builtins.__dict__
157
105
for name in builtins:
158
106
if name.startswith("cmd_"):
159
real_name = _unsquish_command_name(name)
107
real_name = _unsquish_command_name(name)
160
108
r[real_name] = builtins[name]
165
112
def builtin_command_names():
257
251
"""Construct an instance of this command."""
258
252
if self.__doc__ == Command.__doc__:
259
253
warn("No help message set for %r" % self)
262
def run_argv(self, argv):
263
"""Parse command line and run."""
264
args, opts = parse_args(argv)
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
266
475
if 'help' in opts: # e.g. bzr add --help
267
from bzrlib.help import help_on_command
268
help_on_command(self.name())
476
sys.stdout.write(self.get_help_text())
271
# check options are reasonable
272
allowed = self.takes_options
274
if oname not in allowed:
275
raise BzrCommandError("option '--%s' is not allowed for command %r"
276
% (oname, 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'):
278
488
# mix arguments and options into one dictionary
279
489
cmdargs = _match_argform(self.name(), self.takes_args, args)
310
522
return _unsquish_command_name(self.__class__.__name__)
524
def plugin_name(self):
525
"""Get the name of the plugin that provides this command.
313
def parse_spec(spec):
319
>>> parse_spec("../@")
321
>>> parse_spec("../f/@35")
323
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
324
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
329
parsed = spec.split('/@')
330
assert len(parsed) == 2
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':
335
parsed[1] = int(parsed[1])
337
pass # We can allow stuff like ./@revid:blahblahblah
341
parsed = [spec, None]
347
# list of all available options; the rhs can be either None for an
348
# option that takes no argument, or a constructor function that checks
361
'revision': _parse_revision_str,
373
'merge-type': get_merge_type,
387
def parse_args(argv):
536
def parse_args(command, argv, alias_argv=None):
388
537
"""Parse command line.
390
539
Arguments and options are parsed at this level before being passed
391
540
down to specific command handlers. This routine knows, from a
392
541
lookup table, something about the available options, what optargs
393
542
they take, and which commands will accept them.
395
>>> parse_args('--help'.split())
397
>>> parse_args('help -- --invalidcmd'.split())
398
(['help', '--invalidcmd'], {})
399
>>> parse_args('--version'.split())
400
([], {'version': True})
401
>>> parse_args('status --all'.split())
402
(['status'], {'all': True})
403
>>> parse_args('commit --message=biter'.split())
404
(['commit'], {'message': u'biter'})
405
>>> parse_args('log -r 500'.split())
406
(['log'], {'revision': [500]})
407
>>> parse_args('log -r500..600'.split())
408
(['log'], {'revision': [500, 600]})
409
>>> parse_args('log -vr500..600'.split())
410
(['log'], {'verbose': True, 'revision': [500, 600]})
411
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
412
(['log'], {'revision': ['v500', 600]})
420
if not argsover and a[0] == '-':
421
# option names must not be unicode
426
# We've received a standalone -- No more flags
429
mutter(" got option %r" % a)
431
optname, optarg = a[2:].split('=', 1)
434
if optname not in OPTIONS:
435
raise BzrError('unknown long option %r' % a)
438
if shortopt in SHORT_OPTIONS:
439
# Multi-character options must have a space to delimit
441
optname = SHORT_OPTIONS[shortopt]
443
# Single character short options, can be chained,
444
# and have their value appended to their name
446
if shortopt not in SHORT_OPTIONS:
447
# We didn't find the multi-character name, and we
448
# didn't find the single char name
449
raise BzrError('unknown short option %r' % a)
450
optname = SHORT_OPTIONS[shortopt]
453
# There are extra things on this option
454
# see if it is the value, or if it is another
456
optargfn = OPTIONS[optname]
458
# This option does not take an argument, so the
459
# next entry is another short option, pack it back
461
argv.insert(0, '-' + a[2:])
463
# This option takes an argument, so pack it
468
# XXX: Do we ever want to support this, e.g. for -r?
469
raise BzrError('repeated option %r' % a)
471
optargfn = OPTIONS[optname]
475
raise BzrError('option %r needs an argument' % a)
478
opts[optname] = optargfn(optarg)
481
raise BzrError('option %r takes no argument' % optname)
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])
486
554
return args, opts
491
557
def _match_argform(cmd, takes_args, args):
505
571
argdict[argname + '_list'] = None
506
572
elif ap[-1] == '+':
508
raise BzrCommandError("command %r needs one or more %s"
509
% (cmd, argname.upper()))
574
raise errors.BzrCommandError("command %r needs one or more %s"
575
% (cmd, argname.upper()))
511
577
argdict[argname + '_list'] = args[:]
513
579
elif ap[-1] == '$': # all but one
514
580
if len(args) < 2:
515
raise BzrCommandError("command %r needs one or more %s"
516
% (cmd, argname.upper()))
581
raise errors.BzrCommandError("command %r needs one or more %s"
582
% (cmd, argname.upper()))
517
583
argdict[argname + '_list'] = args[:-1]
520
586
# just a plain arg
523
raise BzrCommandError("command %r requires argument %s"
524
% (cmd, argname.upper()))
589
raise errors.BzrCommandError("command %r requires argument %s"
590
% (cmd, argname.upper()))
526
592
argdict[argname] = args.pop(0)
529
raise BzrCommandError("extra argument to command %s: %s"
595
raise errors.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,
536
616
def apply_profiled(the_callable, *args, **kwargs):
539
620
pffileno, pfname = tempfile.mkstemp()
541
622
prof = hotshot.Profile(pfname)
576
692
Do not load plugin modules at all
579
698
Only use builtin commands. (Plugins are still allowed to change
580
699
other behaviour.)
583
Run under the Python profiler.
702
Run under the Python hotshot profiler.
705
Run under the Python lsprof profiler.
708
Generate line coverage report in the specified directory.
586
argv = [a.decode(bzrlib.user_encoding) for a in argv]
711
trace.mutter("bzr arguments: %r", argv)
588
opt_profile = opt_no_plugins = opt_builtin = False
713
opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
714
opt_no_aliases = False
715
opt_lsprof_file = opt_coverage_dir = None
590
717
# --no-plugins is handled specially at a very early stage. We need
591
718
# to load plugins before doing other command parsing so that they
592
719
# can override commands, but this needs to happen first.
595
725
if a == '--profile':
596
726
opt_profile = True
727
elif a == '--lsprof':
729
elif a == '--lsprof-file':
731
opt_lsprof_file = argv[i + 1]
597
733
elif a == '--no-plugins':
598
734
opt_no_plugins = True
735
elif a == '--no-aliases':
736
opt_no_aliases = True
599
737
elif a == '--builtin':
600
738
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:])
605
if (not argv) or (argv[0] == '--help'):
606
from bzrlib.help import help
750
from bzrlib.builtins import cmd_help
751
cmd_help().run_argv_aliases([])
613
754
if argv[0] == '--version':
614
from bzrlib.builtins import show_version
755
from bzrlib.builtins import cmd_version
756
cmd_version().run_argv_aliases([])
618
759
if not opt_no_plugins:
619
760
from bzrlib.plugin import load_plugins
622
cmd = str(argv.pop(0))
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.
624
779
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
627
ret = apply_profiled(cmd_obj.run_argv, argv)
629
ret = cmd_obj.run_argv(argv)
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:
635
bzrlib.trace.log_startup(argv)
636
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
640
return run_bzr(argv[1:])
642
# do this here inside the exception wrappers to catch EPIPE
644
except BzrCommandError, e:
645
# command line syntax error, etc
649
bzrlib.trace.log_exception()
651
except AssertionError, e:
652
bzrlib.trace.log_exception('assertion failed: ' + str(e))
654
except KeyboardInterrupt, e:
655
bzrlib.trace.note('interrupted')
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)
853
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.
657
877
except Exception, e:
659
if (isinstance(e, IOError)
660
and hasattr(e, 'errno')
661
and e.errno == errno.EPIPE):
662
bzrlib.trace.note('broken pipe')
665
bzrlib.trace.log_exception()
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()
669
931
if __name__ == '__main__':
added
removed
bzrlib/commands.py
