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.
28
# TODO: Help messages for options.
30
# TODO: Define arguments by objects, rather than just using names.
31
# Those objects can specify the expected type of the argument, which
32
# would help with validation and shell completion.
38
from warnings import warn
39
from inspect import getdoc
43
from bzrlib.trace import mutter, note, log_error, warning
44
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
45
from bzrlib.branch import find_branch
46
from bzrlib import BZRDIR
51
def register_command(cmd):
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)
63
log_error('Two plugins defined the same command: %r' % k)
64
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
67
def _squish_command_name(cmd):
68
return 'cmd_' + cmd.replace('-', '_')
71
def _unsquish_command_name(cmd):
72
assert cmd.startswith("cmd_")
73
return cmd[4:].replace('_','-')
76
def _parse_revision_str(revstr):
77
"""This handles a revision string -> revno.
79
This always returns a list. The list will have one element for
81
It supports integers directly, but everything else it
82
defers for passing to Branch.get_revision_info()
84
>>> _parse_revision_str('234')
86
>>> _parse_revision_str('234..567')
88
>>> _parse_revision_str('..')
90
>>> _parse_revision_str('..234')
92
>>> _parse_revision_str('234..')
94
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
96
>>> _parse_revision_str('234....789') # Error?
98
>>> _parse_revision_str('revid:test@other.com-234234')
99
['revid:test@other.com-234234']
100
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
101
['revid:test@other.com-234234', 'revid:test@other.com-234235']
102
>>> _parse_revision_str('revid:test@other.com-234234..23')
103
['revid:test@other.com-234234', 23]
104
>>> _parse_revision_str('date:2005-04-12')
106
>>> _parse_revision_str('date:2005-04-12 12:24:33')
107
['date:2005-04-12 12:24:33']
108
>>> _parse_revision_str('date:2005-04-12T12:24:33')
109
['date:2005-04-12T12:24:33']
110
>>> _parse_revision_str('date:2005-04-12,12:24:33')
111
['date:2005-04-12,12:24:33']
112
>>> _parse_revision_str('-5..23')
114
>>> _parse_revision_str('-5')
116
>>> _parse_revision_str('123a')
118
>>> _parse_revision_str('abc')
122
old_format_re = re.compile('\d*:\d*')
123
m = old_format_re.match(revstr)
125
warning('Colon separator for revision numbers is deprecated.'
128
for rev in revstr.split(':'):
130
revs.append(int(rev))
135
for x in revstr.split('..'):
146
def get_merge_type(typestring):
147
"""Attempt to find the merge class/factory associated with a string."""
148
from merge import merge_types
150
return merge_types[typestring][0]
152
templ = '%s%%7s: %%s' % (' '*12)
153
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
154
type_list = '\n'.join(lines)
155
msg = "No known merge type %s. Supported types are:\n%s" %\
156
(typestring, type_list)
157
raise BzrCommandError(msg)
160
def get_merge_type(typestring):
161
"""Attempt to find the merge class/factory associated with a string."""
162
from merge import merge_types
164
return merge_types[typestring][0]
166
templ = '%s%%7s: %%s' % (' '*12)
167
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
168
type_list = '\n'.join(lines)
169
msg = "No known merge type %s. Supported types are:\n%s" %\
170
(typestring, type_list)
171
raise BzrCommandError(msg)
174
def _builtin_commands():
175
import bzrlib.builtins
177
builtins = bzrlib.builtins.__dict__
178
for name in builtins:
179
if name.startswith("cmd_"):
180
real_name = _unsquish_command_name(name)
181
r[real_name] = builtins[name]
186
def builtin_command_names():
187
"""Return list of builtin command names."""
188
return _builtin_commands().keys()
191
def plugin_command_names():
192
return plugin_cmds.keys()
195
def _get_cmd_dict(plugins_override=True):
196
"""Return name->class mapping for all commands."""
197
d = _builtin_commands()
199
d.update(plugin_cmds)
203
def get_all_cmds(plugins_override=True):
204
"""Return canonical name and class for all registered commands."""
205
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
209
def get_cmd_object(cmd_name, plugins_override=True):
210
"""Return the canonical name and command class for a command.
213
If true, plugin commands can override builtins.
215
from bzrlib.externalcommand import ExternalCommand
217
cmd_name = str(cmd_name) # not unicode
219
# first look up this command under the specified name
220
cmds = _get_cmd_dict(plugins_override=plugins_override)
222
return cmds[cmd_name]()
226
# look for any command which claims this as an alias
227
for real_cmd_name, cmd_class in cmds.iteritems():
228
if cmd_name in cmd_class.aliases:
231
cmd_obj = ExternalCommand.find_command(cmd_name)
235
raise BzrCommandError("unknown command %r" % cmd_name)
238
class Command(object):
239
"""Base class for commands.
241
Commands are the heart of the command-line bzr interface.
243
The command object mostly handles the mapping of command-line
244
parameters into one or more bzrlib operations, and of the results
247
Commands normally don't have any state. All their arguments are
248
passed in to the run method. (Subclasses may take a different
249
policy if the behaviour of the instance needs to depend on e.g. a
250
shell plugin and not just its Python class.)
252
The docstring for an actual command should give a single-line
253
summary, then a complete description of the command. A grammar
254
description will be inserted.
257
Other accepted names for this command.
260
List of argument forms, marked with whether they are optional,
264
List of options that may be given for this command.
267
If true, this command isn't advertised. This is typically
268
for commands intended for expert users.
278
"""Construct an instance of this command."""
279
if self.__doc__ == Command.__doc__:
280
warn("No help message set for %r" % self)
283
def run_argv(self, argv):
284
"""Parse command line and run."""
285
args, opts = parse_args(argv)
287
if 'help' in opts: # e.g. bzr add --help
288
from bzrlib.help import help_on_command
289
help_on_command(self.name())
292
# check options are reasonable
293
allowed = self.takes_options
295
if oname not in allowed:
296
raise BzrCommandError("option '--%s' is not allowed for command %r"
297
% (oname, self.name()))
299
# mix arguments and options into one dictionary
300
cmdargs = _match_argform(self.name(), self.takes_args, args)
302
for k, v in opts.items():
303
cmdopts[k.replace('-', '_')] = v
305
all_cmd_args = cmdargs.copy()
306
all_cmd_args.update(cmdopts)
308
return self.run(**all_cmd_args)
312
"""Actually run the command.
314
This is invoked with the options and arguments bound to
317
Return 0 or None if the command was successful, or a non-zero
318
shell error code if not. It's OK for this method to allow
319
an exception to raise up.
321
raise NotImplementedError()
325
"""Return help message for this class."""
326
if self.__doc__ is Command.__doc__:
331
return _unsquish_command_name(self.__class__.__name__)
334
def parse_spec(spec):
340
>>> parse_spec("../@")
342
>>> parse_spec("../f/@35")
344
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
345
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
350
parsed = spec.split('/@')
351
assert len(parsed) == 2
356
parsed[1] = int(parsed[1])
358
pass # We can allow stuff like ./@revid:blahblahblah
362
parsed = [spec, None]
366
# list of all available options; the rhs can be either None for an
367
# option that takes no argument, or a constructor function that checks
380
'revision': _parse_revision_str,
392
'merge-type': get_merge_type,
406
def parse_args(argv):
407
"""Parse command line.
409
Arguments and options are parsed at this level before being passed
410
down to specific command handlers. This routine knows, from a
411
lookup table, something about the available options, what optargs
412
they take, and which commands will accept them.
414
>>> parse_args('--help'.split())
416
>>> parse_args('help -- --invalidcmd'.split())
417
(['help', '--invalidcmd'], {})
418
>>> parse_args('--version'.split())
419
([], {'version': True})
420
>>> parse_args('status --all'.split())
421
(['status'], {'all': True})
422
>>> parse_args('commit --message=biter'.split())
423
(['commit'], {'message': u'biter'})
424
>>> parse_args('log -r 500'.split())
425
(['log'], {'revision': [500]})
426
>>> parse_args('log -r500..600'.split())
427
(['log'], {'revision': [500, 600]})
428
>>> parse_args('log -vr500..600'.split())
429
(['log'], {'verbose': True, 'revision': [500, 600]})
430
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
431
(['log'], {'revision': ['v500', 600]})
439
if not argsover and a[0] == '-':
440
# option names must not be unicode
445
# We've received a standalone -- No more flags
448
mutter(" got option %r" % a)
450
optname, optarg = a[2:].split('=', 1)
453
if optname not in OPTIONS:
454
raise BzrError('unknown long option %r' % a)
457
if shortopt in SHORT_OPTIONS:
458
# Multi-character options must have a space to delimit
460
optname = SHORT_OPTIONS[shortopt]
462
# Single character short options, can be chained,
463
# and have their value appended to their name
465
if shortopt not in SHORT_OPTIONS:
466
# We didn't find the multi-character name, and we
467
# didn't find the single char name
468
raise BzrError('unknown short option %r' % a)
469
optname = SHORT_OPTIONS[shortopt]
472
# There are extra things on this option
473
# see if it is the value, or if it is another
475
optargfn = OPTIONS[optname]
477
# This option does not take an argument, so the
478
# next entry is another short option, pack it back
480
argv.insert(0, '-' + a[2:])
482
# This option takes an argument, so pack it
487
# XXX: Do we ever want to support this, e.g. for -r?
488
raise BzrError('repeated option %r' % a)
490
optargfn = OPTIONS[optname]
494
raise BzrError('option %r needs an argument' % a)
497
opts[optname] = optargfn(optarg)
500
raise BzrError('option %r takes no argument' % optname)
510
def _match_argform(cmd, takes_args, args):
513
# step through args and takes_args, allowing appropriate 0-many matches
514
for ap in takes_args:
518
argdict[argname] = args.pop(0)
519
elif ap[-1] == '*': # all remaining arguments
521
argdict[argname + '_list'] = args[:]
524
argdict[argname + '_list'] = None
527
raise BzrCommandError("command %r needs one or more %s"
528
% (cmd, argname.upper()))
530
argdict[argname + '_list'] = args[:]
532
elif ap[-1] == '$': # all but one
534
raise BzrCommandError("command %r needs one or more %s"
535
% (cmd, argname.upper()))
536
argdict[argname + '_list'] = args[:-1]
542
raise BzrCommandError("command %r requires argument %s"
543
% (cmd, argname.upper()))
545
argdict[argname] = args.pop(0)
548
raise BzrCommandError("extra argument to command %s: %s"
555
def apply_profiled(the_callable, *args, **kwargs):
558
pffileno, pfname = tempfile.mkstemp()
560
prof = hotshot.Profile(pfname)
562
ret = prof.runcall(the_callable, *args, **kwargs) or 0
567
stats = hotshot.stats.load(pfname)
569
stats.sort_stats('time')
570
## XXX: Might like to write to stderr or the trace file instead but
571
## print_stats seems hardcoded to stdout
572
stats.print_stats(20)
581
"""Execute a command.
583
This is similar to main(), but without all the trappings for
584
logging and error handling.
587
The command-line arguments, without the program name from argv[0]
589
Returns a command status or raises an exception.
591
Special master options: these must come before the command because
592
they control how the command is interpreted.
595
Do not load plugin modules at all
598
Only use builtin commands. (Plugins are still allowed to change
602
Run under the Python profiler.
605
argv = [a.decode(bzrlib.user_encoding) for a in argv]
607
opt_profile = opt_no_plugins = opt_builtin = False
609
# --no-plugins is handled specially at a very early stage. We need
610
# to load plugins before doing other command parsing so that they
611
# can override commands, but this needs to happen first.
616
elif a == '--no-plugins':
617
opt_no_plugins = True
618
elif a == '--builtin':
624
if (not argv) or (argv[0] == '--help'):
625
from bzrlib.help import help
632
if argv[0] == '--version':
633
from bzrlib.builtins import show_version
637
if not opt_no_plugins:
638
from bzrlib.plugin import load_plugins
641
cmd = str(argv.pop(0))
643
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
646
ret = apply_profiled(cmd_obj.run_argv, argv)
648
ret = cmd_obj.run_argv(argv)
654
bzrlib.trace.log_startup(argv)
655
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
659
return run_bzr(argv[1:])
661
# do this here inside the exception wrappers to catch EPIPE
663
except BzrCommandError, e:
664
# command line syntax error, etc
668
bzrlib.trace.log_exception()
670
except AssertionError, e:
671
bzrlib.trace.log_exception('assertion failed: ' + str(e))
673
except KeyboardInterrupt, e:
674
bzrlib.trace.note('interrupted')
678
if (isinstance(e, IOError)
679
and hasattr(e, 'errno')
680
and e.errno == errno.EPIPE):
681
bzrlib.trace.note('broken pipe')
684
bzrlib.trace.log_exception()
688
if __name__ == '__main__':
689
sys.exit(main(sys.argv))
added
removed
bzrlib/commands.py
