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, BzrCheckError, BzrCommandError, NotBranchError
40
from bzrlib.revisionspec import RevisionSpec
41
from bzrlib import BZRDIR
42
from bzrlib.option import Option
47
def register_command(cmd):
48
"Utility function to help register a command"
51
if k.startswith("cmd_"):
52
k_unsquished = _unsquish_command_name(k)
55
if not plugin_cmds.has_key(k_unsquished):
56
plugin_cmds[k_unsquished] = cmd
57
mutter('registered plugin command %s', k_unsquished)
59
log_error('Two plugins defined the same command: %r' % k)
60
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
63
def _squish_command_name(cmd):
64
return 'cmd_' + cmd.replace('-', '_')
67
def _unsquish_command_name(cmd):
68
assert cmd.startswith("cmd_")
69
return cmd[4:].replace('_','-')
72
def _builtin_commands():
73
import bzrlib.builtins
75
builtins = bzrlib.builtins.__dict__
77
if name.startswith("cmd_"):
78
real_name = _unsquish_command_name(name)
79
r[real_name] = builtins[name]
84
def builtin_command_names():
85
"""Return list of builtin command names."""
86
return _builtin_commands().keys()
89
def plugin_command_names():
90
return plugin_cmds.keys()
93
def _get_cmd_dict(plugins_override=True):
94
"""Return name->class mapping for all commands."""
95
d = _builtin_commands()
101
def get_all_cmds(plugins_override=True):
102
"""Return canonical name and class for all registered commands."""
103
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
107
def get_cmd_object(cmd_name, plugins_override=True):
108
"""Return the canonical name and command class for a command.
111
If true, plugin commands can override builtins.
113
from bzrlib.externalcommand import ExternalCommand
115
cmd_name = str(cmd_name) # not unicode
117
# first look up this command under the specified name
118
cmds = _get_cmd_dict(plugins_override=plugins_override)
120
return cmds[cmd_name]()
124
# look for any command which claims this as an alias
125
for real_cmd_name, cmd_class in cmds.iteritems():
126
if cmd_name in cmd_class.aliases:
129
cmd_obj = ExternalCommand.find_command(cmd_name)
133
raise BzrCommandError("unknown command %r" % cmd_name)
136
class Command(object):
137
"""Base class for commands.
139
Commands are the heart of the command-line bzr interface.
141
The command object mostly handles the mapping of command-line
142
parameters into one or more bzrlib operations, and of the results
145
Commands normally don't have any state. All their arguments are
146
passed in to the run method. (Subclasses may take a different
147
policy if the behaviour of the instance needs to depend on e.g. a
148
shell plugin and not just its Python class.)
150
The docstring for an actual command should give a single-line
151
summary, then a complete description of the command. A grammar
152
description will be inserted.
155
Other accepted names for this command.
158
List of argument forms, marked with whether they are optional,
162
List of options that may be given for this command. These can
163
be either strings, referring to globally-defined options,
164
or option objects. Retrieve through options().
167
If true, this command isn't advertised. This is typically
168
for commands intended for expert users.
177
"""Construct an instance of this command."""
178
if self.__doc__ == Command.__doc__:
179
warn("No help message set for %r" % self)
182
"""Return dict of valid options for this command.
184
Maps from long option name to option object."""
186
r['help'] = Option.OPTIONS['help']
187
for o in self.takes_options:
188
if not isinstance(o, Option):
189
o = Option.OPTIONS[o]
193
def run_argv(self, argv):
194
"""Parse command line and run."""
195
args, opts = parse_args(self, argv)
196
if 'help' in opts: # e.g. bzr add --help
197
from bzrlib.help import help_on_command
198
help_on_command(self.name())
200
# XXX: This should be handled by the parser
201
allowed_names = self.options().keys()
203
if oname not in allowed_names:
204
raise BzrCommandError("option '--%s' is not allowed for command %r"
205
% (oname, self.name()))
206
# mix arguments and options into one dictionary
207
cmdargs = _match_argform(self.name(), self.takes_args, args)
209
for k, v in opts.items():
210
cmdopts[k.replace('-', '_')] = v
212
all_cmd_args = cmdargs.copy()
213
all_cmd_args.update(cmdopts)
215
return self.run(**all_cmd_args)
219
"""Actually run the command.
221
This is invoked with the options and arguments bound to
224
Return 0 or None if the command was successful, or a non-zero
225
shell error code if not. It's OK for this method to allow
226
an exception to raise up.
228
raise NotImplementedError()
232
"""Return help message for this class."""
233
if self.__doc__ is Command.__doc__:
238
return _unsquish_command_name(self.__class__.__name__)
241
def parse_spec(spec):
247
>>> parse_spec("../@")
249
>>> parse_spec("../f/@35")
251
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
252
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
257
parsed = spec.split('/@')
258
assert len(parsed) == 2
263
parsed[1] = int(parsed[1])
265
pass # We can allow stuff like ./@revid:blahblahblah
269
parsed = [spec, None]
272
def parse_args(command, argv):
273
"""Parse command line.
275
Arguments and options are parsed at this level before being passed
276
down to specific command handlers. This routine knows, from a
277
lookup table, something about the available options, what optargs
278
they take, and which commands will accept them.
280
# TODO: chop up this beast; make it a method of the Command
284
cmd_options = command.options()
292
# We've received a standalone -- No more flags
296
# option names must not be unicode
300
mutter(" got option %r" % a)
302
optname, optarg = a[2:].split('=', 1)
305
if optname not in cmd_options:
306
raise BzrCommandError('unknown long option %r for command %s'
307
% (a, command.name()))
310
if shortopt in Option.SHORT_OPTIONS:
311
# Multi-character options must have a space to delimit
313
# ^^^ what does this mean? mbp 20051014
314
optname = Option.SHORT_OPTIONS[shortopt].name
316
# Single character short options, can be chained,
317
# and have their value appended to their name
319
if shortopt not in Option.SHORT_OPTIONS:
320
# We didn't find the multi-character name, and we
321
# didn't find the single char name
322
raise BzrError('unknown short option %r' % a)
323
optname = Option.SHORT_OPTIONS[shortopt].name
326
# There are extra things on this option
327
# see if it is the value, or if it is another
329
optargfn = Option.OPTIONS[optname].type
331
# This option does not take an argument, so the
332
# next entry is another short option, pack it back
334
argv.insert(0, '-' + a[2:])
336
# This option takes an argument, so pack it
341
# XXX: Do we ever want to support this, e.g. for -r?
342
raise BzrError('repeated option %r' % a)
344
option_obj = cmd_options[optname]
345
optargfn = option_obj.type
349
raise BzrError('option %r needs an argument' % a)
352
opts[optname] = optargfn(optarg)
355
raise BzrError('option %r takes no argument' % optname)
362
def _match_argform(cmd, takes_args, args):
365
# step through args and takes_args, allowing appropriate 0-many matches
366
for ap in takes_args:
370
argdict[argname] = args.pop(0)
371
elif ap[-1] == '*': # all remaining arguments
373
argdict[argname + '_list'] = args[:]
376
argdict[argname + '_list'] = None
379
raise BzrCommandError("command %r needs one or more %s"
380
% (cmd, argname.upper()))
382
argdict[argname + '_list'] = args[:]
384
elif ap[-1] == '$': # all but one
386
raise BzrCommandError("command %r needs one or more %s"
387
% (cmd, argname.upper()))
388
argdict[argname + '_list'] = args[:-1]
394
raise BzrCommandError("command %r requires argument %s"
395
% (cmd, argname.upper()))
397
argdict[argname] = args.pop(0)
400
raise BzrCommandError("extra argument to command %s: %s"
407
def apply_profiled(the_callable, *args, **kwargs):
411
pffileno, pfname = tempfile.mkstemp()
413
prof = hotshot.Profile(pfname)
415
ret = prof.runcall(the_callable, *args, **kwargs) or 0
418
stats = hotshot.stats.load(pfname)
420
stats.sort_stats('cum') # 'time'
421
## XXX: Might like to write to stderr or the trace file instead but
422
## print_stats seems hardcoded to stdout
423
stats.print_stats(20)
431
"""Execute a command.
433
This is similar to main(), but without all the trappings for
434
logging and error handling.
437
The command-line arguments, without the program name from argv[0]
439
Returns a command status or raises an exception.
441
Special master options: these must come before the command because
442
they control how the command is interpreted.
445
Do not load plugin modules at all
448
Only use builtin commands. (Plugins are still allowed to change
452
Run under the Python profiler.
454
argv = [a.decode(bzrlib.user_encoding) for a in argv]
456
opt_profile = opt_no_plugins = opt_builtin = False
458
# --no-plugins is handled specially at a very early stage. We need
459
# to load plugins before doing other command parsing so that they
460
# can override commands, but this needs to happen first.
465
elif a == '--no-plugins':
466
opt_no_plugins = True
467
elif a == '--builtin':
473
if (not argv) or (argv[0] == '--help'):
474
from bzrlib.help import help
481
if argv[0] == '--version':
482
from bzrlib.builtins import show_version
486
if not opt_no_plugins:
487
from bzrlib.plugin import load_plugins
490
cmd = str(argv.pop(0))
492
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
495
ret = apply_profiled(cmd_obj.run_argv, argv)
497
ret = cmd_obj.run_argv(argv)
500
def display_command(func):
501
def ignore_pipe(*args, **kwargs):
503
func(*args, **kwargs)
505
if e.errno != errno.EPIPE:
507
except KeyboardInterrupt:
513
bzrlib.trace.log_startup(argv)
514
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
516
return run_bzr_catch_errors(argv[1:])
519
def run_bzr_catch_errors(argv):
524
# do this here inside the exception wrappers to catch EPIPE
526
except BzrCommandError, e:
527
# command line syntax error, etc
531
bzrlib.trace.log_exception()
533
except AssertionError, e:
534
bzrlib.trace.log_exception('assertion failed: ' + str(e))
536
except KeyboardInterrupt, e:
537
bzrlib.trace.log_exception('interrupted')
541
if (isinstance(e, IOError)
542
and hasattr(e, 'errno')
543
and e.errno == errno.EPIPE):
544
bzrlib.trace.note('broken pipe')
549
bzrlib.trace.log_exception()
552
if __name__ == '__main__':
553
sys.exit(main(sys.argv))
added
removed
bzrlib/commands.py
