1
# Copyright (C) 2004, 2005 by Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
# TODO: probably should say which arguments are candidates for glob
19
# expansion on windows and do that at the command level.
21
# TODO: Help messages for options.
23
# TODO: Define arguments by objects, rather than just using names.
24
# Those objects can specify the expected type of the argument, which
25
# would help with validation and shell completion.
27
# TODO: "--profile=cum", to change sort order. Is there any value in leaving
28
# the profile output behind so it can be interactively examined?
32
from warnings import warn
33
from inspect import getdoc
38
from bzrlib.trace import mutter, note, log_error, warning
39
from bzrlib.errors import (BzrError,
44
from bzrlib.revisionspec import RevisionSpec
45
from bzrlib import BZRDIR
46
from bzrlib.option import Option
51
def register_command(cmd, decorate=False):
52
"Utility function to help register a command"
55
if k.startswith("cmd_"):
56
k_unsquished = _unsquish_command_name(k)
59
if not plugin_cmds.has_key(k_unsquished):
60
plugin_cmds[k_unsquished] = cmd
61
mutter('registered plugin command %s', k_unsquished)
62
if decorate and k_unsquished in builtin_command_names():
63
return _builtin_commands()[k_unsquished]
65
result = plugin_cmds[k_unsquished]
66
plugin_cmds[k_unsquished] = cmd
69
log_error('Two plugins defined the same command: %r' % k)
70
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
73
def _squish_command_name(cmd):
74
return 'cmd_' + cmd.replace('-', '_')
77
def _unsquish_command_name(cmd):
78
assert cmd.startswith("cmd_")
79
return cmd[4:].replace('_','-')
82
def _builtin_commands():
83
import bzrlib.builtins
85
builtins = bzrlib.builtins.__dict__
87
if name.startswith("cmd_"):
88
real_name = _unsquish_command_name(name)
89
r[real_name] = builtins[name]
94
def builtin_command_names():
95
"""Return list of builtin command names."""
96
return _builtin_commands().keys()
99
def plugin_command_names():
100
return plugin_cmds.keys()
103
def _get_cmd_dict(plugins_override=True):
104
"""Return name->class mapping for all commands."""
105
d = _builtin_commands()
107
d.update(plugin_cmds)
111
def get_all_cmds(plugins_override=True):
112
"""Return canonical name and class for all registered commands."""
113
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
117
def get_cmd_object(cmd_name, plugins_override=True):
118
"""Return the canonical name and command class for a command.
121
If true, plugin commands can override builtins.
123
from bzrlib.externalcommand import ExternalCommand
125
cmd_name = str(cmd_name) # not unicode
127
# first look up this command under the specified name
128
cmds = _get_cmd_dict(plugins_override=plugins_override)
130
return cmds[cmd_name]()
134
# look for any command which claims this as an alias
135
for real_cmd_name, cmd_class in cmds.iteritems():
136
if cmd_name in cmd_class.aliases:
139
cmd_obj = ExternalCommand.find_command(cmd_name)
143
raise BzrCommandError("unknown command %r" % cmd_name)
146
class Command(object):
147
"""Base class for commands.
149
Commands are the heart of the command-line bzr interface.
151
The command object mostly handles the mapping of command-line
152
parameters into one or more bzrlib operations, and of the results
155
Commands normally don't have any state. All their arguments are
156
passed in to the run method. (Subclasses may take a different
157
policy if the behaviour of the instance needs to depend on e.g. a
158
shell plugin and not just its Python class.)
160
The docstring for an actual command should give a single-line
161
summary, then a complete description of the command. A grammar
162
description will be inserted.
165
Other accepted names for this command.
168
List of argument forms, marked with whether they are optional,
172
List of options that may be given for this command. These can
173
be either strings, referring to globally-defined options,
174
or option objects. Retrieve through options().
177
If true, this command isn't advertised. This is typically
178
for commands intended for expert users.
187
"""Construct an instance of this command."""
188
if self.__doc__ == Command.__doc__:
189
warn("No help message set for %r" % self)
192
"""Return dict of valid options for this command.
194
Maps from long option name to option object."""
196
r['help'] = Option.OPTIONS['help']
197
for o in self.takes_options:
198
if not isinstance(o, Option):
199
o = Option.OPTIONS[o]
203
def run_argv(self, argv):
204
"""Parse command line and run."""
205
args, opts = parse_args(self, argv)
206
if 'help' in opts: # e.g. bzr add --help
207
from bzrlib.help import help_on_command
208
help_on_command(self.name())
210
# XXX: This should be handled by the parser
211
allowed_names = self.options().keys()
213
if oname not in allowed_names:
214
raise BzrCommandError("option '--%s' is not allowed for command %r"
215
% (oname, self.name()))
216
# mix arguments and options into one dictionary
217
cmdargs = _match_argform(self.name(), self.takes_args, args)
219
for k, v in opts.items():
220
cmdopts[k.replace('-', '_')] = v
222
all_cmd_args = cmdargs.copy()
223
all_cmd_args.update(cmdopts)
225
return self.run(**all_cmd_args)
228
"""Actually run the command.
230
This is invoked with the options and arguments bound to
233
Return 0 or None if the command was successful, or a non-zero
234
shell error code if not. It's OK for this method to allow
235
an exception to raise up.
237
raise NotImplementedError()
241
"""Return help message for this class."""
242
if self.__doc__ is Command.__doc__:
247
return _unsquish_command_name(self.__class__.__name__)
250
def parse_spec(spec):
256
>>> parse_spec("../@")
258
>>> parse_spec("../f/@35")
260
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
261
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
266
parsed = spec.split('/@')
267
assert len(parsed) == 2
272
parsed[1] = int(parsed[1])
274
pass # We can allow stuff like ./@revid:blahblahblah
278
parsed = [spec, None]
281
def parse_args(command, argv):
282
"""Parse command line.
284
Arguments and options are parsed at this level before being passed
285
down to specific command handlers. This routine knows, from a
286
lookup table, something about the available options, what optargs
287
they take, and which commands will accept them.
289
# TODO: chop up this beast; make it a method of the Command
293
cmd_options = command.options()
301
# We've received a standalone -- No more flags
305
# option names must not be unicode
309
mutter(" got option %r", a)
311
optname, optarg = a[2:].split('=', 1)
314
if optname not in cmd_options:
315
raise BzrOptionError('unknown long option %r for command %s'
316
% (a, command.name()))
319
if shortopt in Option.SHORT_OPTIONS:
320
# Multi-character options must have a space to delimit
322
# ^^^ what does this mean? mbp 20051014
323
optname = Option.SHORT_OPTIONS[shortopt].name
325
# Single character short options, can be chained,
326
# and have their value appended to their name
328
if shortopt not in Option.SHORT_OPTIONS:
329
# We didn't find the multi-character name, and we
330
# didn't find the single char name
331
raise BzrError('unknown short option %r' % a)
332
optname = Option.SHORT_OPTIONS[shortopt].name
335
# There are extra things on this option
336
# see if it is the value, or if it is another
338
optargfn = Option.OPTIONS[optname].type
340
# This option does not take an argument, so the
341
# next entry is another short option, pack it back
343
argv.insert(0, '-' + a[2:])
345
# This option takes an argument, so pack it
349
if optname not in cmd_options:
350
raise BzrOptionError('unknown short option %r for command'
351
' %s' % (shortopt, command.name()))
353
# XXX: Do we ever want to support this, e.g. for -r?
354
raise BzrError('repeated option %r' % a)
356
option_obj = cmd_options[optname]
357
optargfn = option_obj.type
361
raise BzrError('option %r needs an argument' % a)
364
opts[optname] = optargfn(optarg)
367
raise BzrError('option %r takes no argument' % optname)
374
def _match_argform(cmd, takes_args, args):
377
# step through args and takes_args, allowing appropriate 0-many matches
378
for ap in takes_args:
382
argdict[argname] = args.pop(0)
383
elif ap[-1] == '*': # all remaining arguments
385
argdict[argname + '_list'] = args[:]
388
argdict[argname + '_list'] = None
391
raise BzrCommandError("command %r needs one or more %s"
392
% (cmd, argname.upper()))
394
argdict[argname + '_list'] = args[:]
396
elif ap[-1] == '$': # all but one
398
raise BzrCommandError("command %r needs one or more %s"
399
% (cmd, argname.upper()))
400
argdict[argname + '_list'] = args[:-1]
406
raise BzrCommandError("command %r requires argument %s"
407
% (cmd, argname.upper()))
409
argdict[argname] = args.pop(0)
412
raise BzrCommandError("extra argument to command %s: %s"
419
def apply_profiled(the_callable, *args, **kwargs):
423
pffileno, pfname = tempfile.mkstemp()
425
prof = hotshot.Profile(pfname)
427
ret = prof.runcall(the_callable, *args, **kwargs) or 0
430
stats = hotshot.stats.load(pfname)
432
stats.sort_stats('cum') # 'time'
433
## XXX: Might like to write to stderr or the trace file instead but
434
## print_stats seems hardcoded to stdout
435
stats.print_stats(20)
443
"""Execute a command.
445
This is similar to main(), but without all the trappings for
446
logging and error handling.
449
The command-line arguments, without the program name from argv[0]
451
Returns a command status or raises an exception.
453
Special master options: these must come before the command because
454
they control how the command is interpreted.
457
Do not load plugin modules at all
460
Only use builtin commands. (Plugins are still allowed to change
464
Run under the Python profiler.
466
argv = [a.decode(bzrlib.user_encoding) for a in argv]
468
opt_profile = opt_no_plugins = opt_builtin = False
470
# --no-plugins is handled specially at a very early stage. We need
471
# to load plugins before doing other command parsing so that they
472
# can override commands, but this needs to happen first.
477
elif a == '--no-plugins':
478
opt_no_plugins = True
479
elif a == '--builtin':
485
if (not argv) or (argv[0] == '--help'):
486
from bzrlib.help import help
493
if argv[0] == '--version':
494
from bzrlib.builtins import show_version
498
if not opt_no_plugins:
499
from bzrlib.plugin import load_plugins
502
cmd = str(argv.pop(0))
504
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
507
ret = apply_profiled(cmd_obj.run_argv, argv)
509
ret = cmd_obj.run_argv(argv)
512
def display_command(func):
513
"""Decorator that suppresses pipe/interrupt errors."""
514
def ignore_pipe(*args, **kwargs):
516
result = func(*args, **kwargs)
520
if not hasattr(e, 'errno'):
522
if e.errno != errno.EPIPE:
525
except KeyboardInterrupt:
531
bzrlib.trace.log_startup(argv)
532
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
534
return run_bzr_catch_errors(argv[1:])
537
def run_bzr_catch_errors(argv):
542
# do this here inside the exception wrappers to catch EPIPE
545
# used to handle AssertionError and KeyboardInterrupt
546
# specially here, but hopefully they're handled ok by the logger now
548
if (isinstance(e, IOError)
549
and hasattr(e, 'errno')
550
and e.errno == errno.EPIPE):
551
bzrlib.trace.note('broken pipe')
554
bzrlib.trace.log_exception()
555
if os.environ.get('BZR_PDB'):
556
print '**** entering debugger'
558
pdb.post_mortem(sys.exc_traceback)
561
if __name__ == '__main__':
562
sys.exit(main(sys.argv))
added
removed
bzrlib/commands.py
