52
from bzrlib.hooks import HookPoint, Hooks
53
# Compatibility - Option used to be in commands.
54
from bzrlib.option import Option
55
from bzrlib import registry
56
52
from bzrlib.symbol_versioning import (
57
53
deprecated_function,
59
suppress_deprecation_warnings,
63
class CommandInfo(object):
64
"""Information about a command."""
66
def __init__(self, aliases):
67
"""The list of aliases for the command."""
68
self.aliases = aliases
71
def from_command(klass, command):
72
"""Factory to construct a CommandInfo from a command."""
73
return klass(command.aliases)
76
class CommandRegistry(registry.Registry):
79
def _get_name(command_name):
80
if command_name.startswith("cmd_"):
81
return _unsquish_command_name(command_name)
85
def register(self, cmd, decorate=False):
86
"""Utility function to help register a command
88
:param cmd: Command subclass to register
89
:param decorate: If true, allow overriding an existing command
90
of the same name; the old command is returned by this function.
91
Otherwise it is an error to try to override an existing command.
94
k_unsquished = self._get_name(k)
96
previous = self.get(k_unsquished)
98
previous = _builtin_commands().get(k_unsquished)
99
info = CommandInfo.from_command(cmd)
101
registry.Registry.register(self, k_unsquished, cmd,
102
override_existing=decorate, info=info)
104
trace.log_error('Two plugins defined the same command: %r' % k)
105
trace.log_error('Not loading the one in %r' %
106
sys.modules[cmd.__module__])
107
trace.log_error('Previously this command was registered from %r' %
108
sys.modules[previous.__module__])
111
def register_lazy(self, command_name, aliases, module_name):
112
"""Register a command without loading its module.
114
:param command_name: The primary name of the command.
115
:param aliases: A list of aliases for the command.
116
:module_name: The module that the command lives in.
118
key = self._get_name(command_name)
119
registry.Registry.register_lazy(self, key, module_name, command_name,
120
info=CommandInfo(aliases))
123
plugin_cmds = CommandRegistry()
57
from bzrlib.option import Option
126
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.
127
71
global plugin_cmds
128
return plugin_cmds.register(cmd, decorate)
73
if k.startswith("cmd_"):
74
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
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__])
131
93
def _squish_command_name(cmd):
139
101
def _builtin_commands():
140
102
import bzrlib.builtins
141
return _scan_module_for_commands(bzrlib.builtins)
144
def _scan_module_for_commands(module):
146
for name, obj in module.__dict__.iteritems():
104
builtins = bzrlib.builtins.__dict__
105
for name in builtins:
147
106
if name.startswith("cmd_"):
148
107
real_name = _unsquish_command_name(name)
108
r[real_name] = builtins[name]
153
def _list_bzr_commands(names):
154
"""Find commands from bzr's core and plugins."""
155
# to eliminate duplicates
156
names.update(builtin_command_names())
157
names.update(plugin_command_names())
161
def all_command_names():
162
"""Return a set of all command names."""
164
for hook in Command.hooks['list_commands']:
167
raise AssertionError(
168
'hook %s returned None' % Command.hooks.get_hook_name(hook))
172
112
def builtin_command_names():
173
"""Return list of builtin command names.
175
Use of all_command_names() is encouraged rather than builtin_command_names
176
and/or plugin_command_names.
113
"""Return list of builtin command names."""
178
114
return _builtin_commands().keys()
181
117
def plugin_command_names():
182
"""Returns command names from commands registered by plugins."""
183
118
return plugin_cmds.keys()
186
@deprecated_function(deprecated_in((1, 17, 0)))
187
def get_all_cmds(plugins_override=False):
188
"""Return canonical name and class for most commands.
190
NB: This does not return all commands since the introduction of
191
command hooks, and returning the class is not sufficient to
192
get correctly setup commands, which is why it is deprecated.
194
Use 'all_command_names' + 'get_cmd_object' instead.
121
def _get_cmd_dict(plugins_override=True):
122
"""Return name->class mapping for all commands."""
196
123
d = _builtin_commands()
197
124
if plugins_override:
198
d.update(plugin_cmds.iteritems())
199
for k, v in d.iteritems():
125
d.update(plugin_cmds)
129
def get_all_cmds(plugins_override=True):
130
"""Return canonical name and class for all registered commands."""
131
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
203
135
def get_cmd_object(cmd_name, plugins_override=True):
204
"""Return the command object for a command.
136
"""Return the canonical name and command class for a command.
207
139
If true, plugin commands can override builtins.
215
147
def _get_cmd_object(cmd_name, plugins_override=True):
216
"""Get a command object.
148
"""Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
149
from bzrlib.externalcommand import ExternalCommand
218
:param cmd_name: The name of the command.
219
:param plugins_override: Allow plugins to override builtins.
220
:return: A Command object instance
221
:raises KeyError: If no command is found.
223
151
# We want only 'ascii' command names, but the user may have typed
224
152
# in a Unicode name. In that case, they should just get a
225
153
# 'command not found' error later.
226
154
# In the future, we may actually support Unicode command names.
229
for hook in Command.hooks['get_command']:
230
cmd = hook(cmd, cmd_name)
231
if cmd is not None and not plugins_override and not cmd.plugin_name():
232
# We've found a non-plugin command, don't permit it to be
236
for hook in Command.hooks['get_missing_command']:
243
# Allow plugins to extend commands
244
for hook in Command.hooks['extend_command']:
249
def _try_plugin_provider(cmd_name):
250
"""Probe for a plugin provider having cmd_name."""
252
plugin_metadata, provider = probe_for_provider(cmd_name)
253
raise errors.CommandAvailableInPlugin(cmd_name,
254
plugin_metadata, provider)
255
except errors.NoPluginAvailable:
259
def probe_for_provider(cmd_name):
260
"""Look for a provider for cmd_name.
262
:param cmd_name: The command name.
263
:return: plugin_metadata, provider for getting cmd_name.
264
:raises NoPluginAvailable: When no provider can supply the plugin.
266
# look for providers that provide this command but aren't installed
267
for provider in command_providers_registry:
269
return provider.plugin_for_command(cmd_name), provider
270
except errors.NoPluginAvailable:
272
raise errors.NoPluginAvailable(cmd_name)
275
def _get_bzr_command(cmd_or_None, cmd_name):
276
"""Get a command from bzr's core."""
277
cmds = _builtin_commands()
156
# first look up this command under the specified name
157
cmds = _get_cmd_dict(plugins_override=plugins_override)
279
159
return cmds[cmd_name]()
282
163
# look for any command which claims this as an alias
283
164
for real_cmd_name, cmd_class in cmds.iteritems():
284
165
if cmd_name in cmd_class.aliases:
285
166
return cmd_class()
289
def _get_external_command(cmd_or_None, cmd_name):
290
"""Lookup a command that is a shell script."""
291
# Only do external command lookups when no command is found so far.
292
if cmd_or_None is not None:
294
from bzrlib.externalcommand import ExternalCommand
295
168
cmd_obj = ExternalCommand.find_command(cmd_name)
172
# look for plugins that provide this command but aren't installed
173
for provider in command_providers_registry:
175
plugin_metadata = provider.plugin_for_command(cmd_name)
176
except errors.NoPluginAvailable:
179
raise errors.CommandAvailableInPlugin(cmd_name,
180
plugin_metadata, provider)
300
def _get_plugin_command(cmd_or_None, cmd_name):
301
"""Get a command from bzr's plugins."""
303
return plugin_cmds.get(cmd_name)()
306
for key in plugin_cmds.keys():
307
info = plugin_cmds.get_info(key)
308
if cmd_name in info.aliases:
309
return plugin_cmds.get(key)()
313
185
class Command(object):
417
288
def get_help_text(self, additional_see_also=None, plain=True,
418
see_also_as_links=False, verbose=True):
289
see_also_as_links=False):
419
290
"""Return a text string with help for this command.
421
292
:param additional_see_also: Additional help topics to be
422
293
cross-referenced.
423
294
:param plain: if False, raw help (reStructuredText) is
424
295
returned instead of plain text.
425
296
:param see_also_as_links: if True, convert items in 'See also'
426
297
list to internal links (used by bzr_man rstx generator)
427
:param verbose: if True, display the full help, otherwise
428
leave out the descriptive sections and just display
429
usage help (e.g. Purpose, Usage, Options) with a
430
message explaining how to obtain full help.
432
299
doc = self.help()
434
301
raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
436
303
# Extract the summary (purpose) and sections out from the text
437
purpose,sections,order = self._get_help_parts(doc)
304
purpose,sections = self._get_help_parts(doc)
439
306
# If a custom usage section was provided, use it
440
307
if sections.has_key('Usage'):
466
329
result += options
470
# Add the description, indenting it 2 spaces
471
# to match the indentation of the options
472
if sections.has_key(None):
473
text = sections.pop(None)
474
text = '\n '.join(text.splitlines())
475
result += ':%s:\n %s\n\n' % ('Description',text)
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)
477
# Add the custom sections (e.g. Examples). Note that there's no need
478
# to indent these as they must be indented already in the source.
481
if sections.has_key(label):
482
result += ':%s:\n%s\n' % (label,sections[label])
485
result += ("See bzr help %s for more details and examples.\n\n"
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])
488
346
# Add the aliases, source (plug-in) and see also links, if any
518
376
def _get_help_parts(text):
519
377
"""Split help text into a summary and named sections.
521
:return: (summary,sections,order) where summary is the top line and
379
:return: (summary,sections) where summary is the top line and
522
380
sections is a dictionary of the rest indexed by section name.
523
order is the order the section appear in the text.
524
381
A section starts with a heading line of the form ":xxx:".
525
382
Indented text on following lines is the section value.
526
383
All text found outside a named section is assigned to the
527
384
default section which is given the key of None.
529
def save_section(sections, order, label, section):
386
def save_section(sections, label, section):
530
387
if len(section) > 0:
531
388
if sections.has_key(label):
532
389
sections[label] += '\n' + section
535
391
sections[label] = section
537
393
lines = text.rstrip().splitlines()
538
394
summary = lines.pop(0)
541
396
label,section = None,''
542
397
for line in lines:
543
398
if line.startswith(':') and line.endswith(':') and len(line) > 2:
544
save_section(sections, order, label, section)
399
save_section(sections, label, section)
545
400
label,section = line[1:-1],''
546
401
elif (label is not None) and len(line) > 1 and not line[0].isspace():
547
save_section(sections, order, label, section)
402
save_section(sections, label, section)
548
403
label,section = None,line
550
405
if len(section) > 0:
551
406
section += '\n' + line
554
save_section(sections, order, label, section)
555
return summary, sections, order
409
save_section(sections, label, section)
410
return summary, sections
557
412
def get_help_topic(self):
558
413
"""Return the commands help topic - its name."""
684
class CommandHooks(Hooks):
685
"""Hooks related to Command object creation/enumeration."""
688
"""Create the default hooks.
690
These are all empty initially, because by default nothing should get
694
self.create_hook(HookPoint('extend_command',
695
"Called after creating a command object to allow modifications "
696
"such as adding or removing options, docs etc. Called with the "
697
"new bzrlib.commands.Command object.", (1, 13), None))
698
self.create_hook(HookPoint('get_command',
699
"Called when creating a single command. Called with "
700
"(cmd_or_None, command_name). get_command should either return "
701
"the cmd_or_None parameter, or a replacement Command object that "
702
"should be used for the command. Note that the Command.hooks "
703
"hooks are core infrastructure. Many users will prefer to use "
704
"bzrlib.commands.register_command or plugin_cmds.register_lazy.",
706
self.create_hook(HookPoint('get_missing_command',
707
"Called when creating a single command if no command could be "
708
"found. Called with (command_name). get_missing_command should "
709
"either return None, or a Command object to be used for the "
710
"command.", (1, 17), None))
711
self.create_hook(HookPoint('list_commands',
712
"Called when enumerating commands. Called with a set of "
713
"cmd_name strings for all the commands found so far. This set "
714
" is safe to mutate - e.g. to remove a command. "
715
"list_commands should return the updated set of command names.",
718
Command.hooks = CommandHooks()
721
536
def parse_args(command, argv, alias_argv=None):
722
537
"""Parse command line.
724
539
Arguments and options are parsed at this level before being passed
725
540
down to specific command handlers. This routine knows, from a
726
541
lookup table, something about the available options, what optargs
790
605
tracer = trace.Trace(count=1, trace=0)
791
606
sys.settrace(tracer.globaltrace)
792
threading.settrace(tracer.globaltrace)
795
return exception_to_return_code(the_callable, *args, **kwargs)
798
results = tracer.results()
799
results.write_results(show_missing=1, summary=False,
608
ret = the_callable(*args, **kwargs)
611
results = tracer.results()
612
results.write_results(show_missing=1, summary=False,
803
616
def apply_profiled(the_callable, *args, **kwargs):
824
636
os.remove(pfname)
827
def exception_to_return_code(the_callable, *args, **kwargs):
828
"""UI level helper for profiling and coverage.
830
This transforms exceptions into a return value of 3. As such its only
831
relevant to the UI layer, and should never be called where catching
832
exceptions may be desirable.
835
return the_callable(*args, **kwargs)
836
except (KeyboardInterrupt, Exception), e:
837
# used to handle AssertionError and KeyboardInterrupt
838
# specially here, but hopefully they're handled ok by the logger now
839
exc_info = sys.exc_info()
840
exitcode = trace.report_exception(exc_info, sys.stderr)
841
if os.environ.get('BZR_PDB'):
842
print '**** entering debugger'
845
if sys.version_info[:2] < (2, 6):
847
# pdb.post_mortem(tb)
848
# but because pdb.post_mortem gives bad results for tracebacks
849
# from inside generators, we do it manually.
850
# (http://bugs.python.org/issue4150, fixed in Python 2.6)
852
# Setup pdb on the traceback
855
p.setup(tb.tb_frame, tb)
856
# Point the debugger at the deepest frame of the stack
857
p.curindex = len(p.stack) - 1
858
p.curframe = p.stack[p.curindex][0]
859
# Start the pdb prompt.
860
p.print_stack_entry(p.stack[p.curindex])
868
639
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
869
640
from bzrlib.lsprof import profile
870
ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
641
ret, stats = profile(the_callable, *args, **kwargs)
872
643
if filename is None:
1030
797
ret = run(*run_argv)
1031
798
if 'memory' in debug.debug_flags:
1032
trace.debug_memory('Process status after command:', short=False)
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():
1035
# reset, in case we may do other commands later within the same
1036
# process. Commands that want to execute sub-commands must propagate
1037
# --verbose in their own way.
1038
option._verbosity_level = saved_verbosity_level
811
# reset, in case we may do other commands later within the same process
812
option._verbosity_level = 0
1041
814
def display_command(func):
1042
815
"""Decorator that suppresses pipe/interrupt errors."""
1058
831
return ignore_pipe
1061
def install_bzr_command_hooks():
1062
"""Install the hooks to supply bzr's own commands."""
1063
if _list_bzr_commands in Command.hooks["list_commands"]:
1065
Command.hooks.install_named_hook("list_commands", _list_bzr_commands,
1067
Command.hooks.install_named_hook("get_command", _get_bzr_command,
1069
Command.hooks.install_named_hook("get_command", _get_plugin_command,
1070
"bzr plugin commands")
1071
Command.hooks.install_named_hook("get_command", _get_external_command,
1072
"bzr external command lookup")
1073
Command.hooks.install_named_hook("get_missing_command", _try_plugin_provider,
1074
"bzr plugin-provider-db check")
1077
def main(argv=None):
1078
"""Main entry point of command-line interface.
1080
:param argv: list of unicode command-line arguments similar to sys.argv.
1081
argv[0] is script name usually, it will be ignored.
1082
Don't pass here sys.argv because this list contains plain strings
1083
and not unicode; pass None instead.
1085
:return: exit code of bzr command.
1087
835
import bzrlib.ui
1088
bzrlib.ui.ui_factory = bzrlib.ui.make_ui_for_terminal(
1089
sys.stdin, sys.stdout, sys.stderr)
836
from bzrlib.ui.text import TextUIFactory
837
bzrlib.ui.ui_factory = TextUIFactory()
1091
839
# Is this a final release version? If so, we should suppress warnings
1092
840
if bzrlib.version_info[3] == 'final':
1093
suppress_deprecation_warnings(override=False)
1095
argv = osutils.get_unicode_argv()
1099
# ensure all arguments are unicode strings
1101
if isinstance(a, unicode):
1104
new_argv.append(a.decode('ascii'))
1105
except UnicodeDecodeError:
1106
raise errors.BzrError("argv should be list of unicode strings.")
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 "
1108
848
ret = run_bzr_catch_errors(argv)
1109
849
trace.mutter("return code %d", ret)
1113
853
def run_bzr_catch_errors(argv):
1114
"""Run a bzr command with parameters as described by argv.
1116
This function assumed that that UI layer is setup, that symbol deprecations
1117
are already applied, and that unicode decoding has already been performed on argv.
1119
install_bzr_command_hooks()
1120
return exception_to_return_code(run_bzr, 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)
1123
869
def run_bzr_catch_user_errors(argv):
added
removed
bzrlib/commands.py
