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
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
41
from bzrlib.option import Option
46
def register_command(cmd):
47
"Utility function to help register a command"
50
if k.startswith("cmd_"):
51
k_unsquished = _unsquish_command_name(k)
54
if not plugin_cmds.has_key(k_unsquished):
55
plugin_cmds[k_unsquished] = cmd
56
mutter('registered plugin command %s', k_unsquished)
58
log_error('Two plugins defined the same command: %r' % k)
59
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
62
def _squish_command_name(cmd):
63
return 'cmd_' + cmd.replace('-', '_')
66
def _unsquish_command_name(cmd):
67
assert cmd.startswith("cmd_")
68
return cmd[4:].replace('_','-')
71
def _builtin_commands():
72
import bzrlib.builtins
74
builtins = bzrlib.builtins.__dict__
76
if name.startswith("cmd_"):
77
real_name = _unsquish_command_name(name)
78
r[real_name] = builtins[name]
83
def builtin_command_names():
84
"""Return list of builtin command names."""
85
return _builtin_commands().keys()
88
def plugin_command_names():
89
return plugin_cmds.keys()
92
def _get_cmd_dict(plugins_override=True):
93
"""Return name->class mapping for all commands."""
94
d = _builtin_commands()
100
def get_all_cmds(plugins_override=True):
101
"""Return canonical name and class for all registered commands."""
102
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
106
def get_cmd_object(cmd_name, plugins_override=True):
107
"""Return the canonical name and command class for a command.
110
If true, plugin commands can override builtins.
112
from bzrlib.externalcommand import ExternalCommand
114
cmd_name = str(cmd_name) # not unicode
116
# first look up this command under the specified name
117
cmds = _get_cmd_dict(plugins_override=plugins_override)
119
return cmds[cmd_name]()
123
# look for any command which claims this as an alias
124
for real_cmd_name, cmd_class in cmds.iteritems():
125
if cmd_name in cmd_class.aliases:
128
cmd_obj = ExternalCommand.find_command(cmd_name)
132
raise BzrCommandError("unknown command %r" % cmd_name)
135
class Command(object):
136
"""Base class for commands.
138
Commands are the heart of the command-line bzr interface.
140
The command object mostly handles the mapping of command-line
141
parameters into one or more bzrlib operations, and of the results
144
Commands normally don't have any state. All their arguments are
145
passed in to the run method. (Subclasses may take a different
146
policy if the behaviour of the instance needs to depend on e.g. a
147
shell plugin and not just its Python class.)
149
The docstring for an actual command should give a single-line
150
summary, then a complete description of the command. A grammar
151
description will be inserted.
154
Other accepted names for this command.
157
List of argument forms, marked with whether they are optional,
161
List of options that may be given for this command. These can
162
be either strings, referring to globally-defined options,
163
or option objects. Retrieve through options().
166
If true, this command isn't advertised. This is typically
167
for commands intended for expert users.
176
"""Construct an instance of this command."""
177
if self.__doc__ == Command.__doc__:
178
warn("No help message set for %r" % self)
181
"""Return dict of valid options for this command.
183
Maps from long option name to option object."""
185
r['help'] = Option.OPTIONS['help']
186
for o in self.takes_options:
187
if not isinstance(o, Option):
188
o = Option.OPTIONS[o]
192
def run_argv(self, argv):
193
"""Parse command line and run."""
194
args, opts = parse_args(self, argv)
195
if 'help' in opts: # e.g. bzr add --help
196
from bzrlib.help import help_on_command
197
help_on_command(self.name())
199
# XXX: This should be handled by the parser
200
allowed_names = self.options().keys()
202
if oname not in allowed_names:
203
raise BzrCommandError("option '--%s' is not allowed for command %r"
204
% (oname, self.name()))
205
# mix arguments and options into one dictionary
206
cmdargs = _match_argform(self.name(), self.takes_args, args)
208
for k, v in opts.items():
209
cmdopts[k.replace('-', '_')] = v
211
all_cmd_args = cmdargs.copy()
212
all_cmd_args.update(cmdopts)
214
return self.run(**all_cmd_args)
218
"""Actually run the command.
220
This is invoked with the options and arguments bound to
223
Return 0 or None if the command was successful, or a non-zero
224
shell error code if not. It's OK for this method to allow
225
an exception to raise up.
227
raise NotImplementedError()
231
"""Return help message for this class."""
232
if self.__doc__ is Command.__doc__:
237
return _unsquish_command_name(self.__class__.__name__)
240
def parse_spec(spec):
246
>>> parse_spec("../@")
248
>>> parse_spec("../f/@35")
250
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
251
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
256
parsed = spec.split('/@')
257
assert len(parsed) == 2
262
parsed[1] = int(parsed[1])
264
pass # We can allow stuff like ./@revid:blahblahblah
268
parsed = [spec, None]
271
def parse_args(command, argv):
272
"""Parse command line.
274
Arguments and options are parsed at this level before being passed
275
down to specific command handlers. This routine knows, from a
276
lookup table, something about the available options, what optargs
277
they take, and which commands will accept them.
279
# TODO: chop up this beast; make it a method of the Command
283
cmd_options = command.options()
291
# We've received a standalone -- No more flags
295
# option names must not be unicode
299
mutter(" got option %r" % a)
301
optname, optarg = a[2:].split('=', 1)
304
if optname not in cmd_options:
305
raise BzrCommandError('unknown long option %r for command %s'
309
if shortopt in Option.SHORT_OPTIONS:
310
# Multi-character options must have a space to delimit
312
# ^^^ what does this mean? mbp 20051014
313
optname = Option.SHORT_OPTIONS[shortopt].name
315
# Single character short options, can be chained,
316
# and have their value appended to their name
318
if shortopt not in Option.SHORT_OPTIONS:
319
# We didn't find the multi-character name, and we
320
# didn't find the single char name
321
raise BzrError('unknown short option %r' % a)
322
optname = Option.SHORT_OPTIONS[shortopt].name
325
# There are extra things on this option
326
# see if it is the value, or if it is another
328
optargfn = Option.OPTIONS[optname].type
330
# This option does not take an argument, so the
331
# next entry is another short option, pack it back
333
argv.insert(0, '-' + a[2:])
335
# This option takes an argument, so pack it
340
# XXX: Do we ever want to support this, e.g. for -r?
341
raise BzrError('repeated option %r' % a)
343
option_obj = cmd_options[optname]
344
optargfn = option_obj.type
348
raise BzrError('option %r needs an argument' % a)
351
opts[optname] = optargfn(optarg)
354
raise BzrError('option %r takes no argument' % optname)
361
def _match_argform(cmd, takes_args, args):
364
# step through args and takes_args, allowing appropriate 0-many matches
365
for ap in takes_args:
369
argdict[argname] = args.pop(0)
370
elif ap[-1] == '*': # all remaining arguments
372
argdict[argname + '_list'] = args[:]
375
argdict[argname + '_list'] = None
378
raise BzrCommandError("command %r needs one or more %s"
379
% (cmd, argname.upper()))
381
argdict[argname + '_list'] = args[:]
383
elif ap[-1] == '$': # all but one
385
raise BzrCommandError("command %r needs one or more %s"
386
% (cmd, argname.upper()))
387
argdict[argname + '_list'] = args[:-1]
393
raise BzrCommandError("command %r requires argument %s"
394
% (cmd, argname.upper()))
396
argdict[argname] = args.pop(0)
399
raise BzrCommandError("extra argument to command %s: %s"
406
def apply_profiled(the_callable, *args, **kwargs):
410
pffileno, pfname = tempfile.mkstemp()
412
prof = hotshot.Profile(pfname)
414
ret = prof.runcall(the_callable, *args, **kwargs) or 0
417
stats = hotshot.stats.load(pfname)
419
stats.sort_stats('cum') # 'time'
420
## XXX: Might like to write to stderr or the trace file instead but
421
## print_stats seems hardcoded to stdout
422
stats.print_stats(20)
430
"""Execute a command.
432
This is similar to main(), but without all the trappings for
433
logging and error handling.
436
The command-line arguments, without the program name from argv[0]
438
Returns a command status or raises an exception.
440
Special master options: these must come before the command because
441
they control how the command is interpreted.
444
Do not load plugin modules at all
447
Only use builtin commands. (Plugins are still allowed to change
451
Run under the Python profiler.
453
argv = [a.decode(bzrlib.user_encoding) for a in argv]
455
opt_profile = opt_no_plugins = opt_builtin = False
457
# --no-plugins is handled specially at a very early stage. We need
458
# to load plugins before doing other command parsing so that they
459
# can override commands, but this needs to happen first.
464
elif a == '--no-plugins':
465
opt_no_plugins = True
466
elif a == '--builtin':
472
if (not argv) or (argv[0] == '--help'):
473
from bzrlib.help import help
480
if argv[0] == '--version':
481
from bzrlib.builtins import show_version
485
if not opt_no_plugins:
486
from bzrlib.plugin import load_plugins
489
cmd = str(argv.pop(0))
491
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
494
ret = apply_profiled(cmd_obj.run_argv, argv)
496
ret = cmd_obj.run_argv(argv)
502
bzrlib.trace.log_startup(argv)
503
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
505
return run_bzr_catch_errors(argv[1:])
508
def run_bzr_catch_errors(argv):
513
# do this here inside the exception wrappers to catch EPIPE
515
except BzrCommandError, e:
516
# command line syntax error, etc
520
bzrlib.trace.log_exception()
522
except AssertionError, e:
523
bzrlib.trace.log_exception('assertion failed: ' + str(e))
525
except KeyboardInterrupt, e:
526
bzrlib.trace.log_exception('interrupted')
530
if (isinstance(e, IOError)
531
and hasattr(e, 'errno')
532
and e.errno == errno.EPIPE):
533
bzrlib.trace.note('broken pipe')
538
bzrlib.trace.log_exception()
541
if __name__ == '__main__':
542
sys.exit(main(sys.argv))
added
removed
bzrlib/commands.py
