« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 1153
- compare with another revision
- download diff
- download tarball
- view history from revision 1153
- Committer: Martin Pool
- Date: 2005-08-30 06:10:39 UTC
- Revision ID: mbp@sourcefrog.net-20050830061039-1d0347fb236c39ad
- clean up some code in revision.py
- move all exceptions to bzrlib.errors
- move all exceptions to bzrlib.errors
- files removed:
- bzrlib/externalcommand.py
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- files modified:
- Makefile
added
removed
bzrlib/commands.py
25
25
# would help with validation and shell completion.
26
26
27
27
28
29
28
import sys
30
29
import os
31
from warnings import warn
32
from inspect import getdoc
33
30
34
31
import bzrlib
35
32
import bzrlib.trace
38
35
from bzrlib.branch import find_branch
39
36
from bzrlib import BZRDIR
40
37
38
41
39
plugin_cmds = {}
42
40
43
41
150
148
raise BzrCommandError(msg)
151
149
152
150
153
def _builtin_commands():
151
def get_merge_type(typestring):
152
"""Attempt to find the merge class/factory associated with a string."""
153
from merge import merge_types
154
try:
155
return merge_types[typestring][0]
156
except KeyError:
157
templ = '%s%%7s: %%s' % (' '*12)
158
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
159
type_list = '\n'.join(lines)
160
msg = "No known merge type %s. Supported types are:\n%s" %\
161
(typestring, type_list)
162
raise BzrCommandError(msg)
163
164
165
166
def _get_cmd_dict(plugins_override=True):
154
167
import bzrlib.builtins
155
r = {}
168
169
d = {}
156
170
builtins = bzrlib.builtins.__dict__
157
171
for name in builtins:
158
172
if name.startswith("cmd_"):
159
real_name = _unsquish_command_name(name)
160
r[real_name] = builtins[name]
161
return r
162
163
164
165
def builtin_command_names():
166
"""Return list of builtin command names."""
167
return _builtin_commands().keys()
168
169
170
def plugin_command_names():
171
return plugin_cmds.keys()
172
173
174
def _get_cmd_dict(plugins_override=True):
175
"""Return name->class mapping for all commands."""
176
d = _builtin_commands()
173
d[_unsquish_command_name(name)] = builtins[name]
174
# If we didn't load plugins, the plugin_cmds dict will be empty
177
175
if plugins_override:
178
176
d.update(plugin_cmds)
177
else:
178
d2 = plugin_cmds.copy()
179
d2.update(d)
180
d = d2
179
181
return d
180
182
181
183
185
187
yield k,v
186
188
187
189
188
def get_cmd_object(cmd_name, plugins_override=True):
190
def get_cmd_class(cmd, plugins_override=True):
189
191
"""Return the canonical name and command class for a command.
190
191
plugins_override
192
If true, plugin commands can override builtins.
193
192
"""
194
from bzrlib.externalcommand import ExternalCommand
195
196
cmd_name = str(cmd_name) # not unicode
193
cmd = str(cmd) # not unicode
197
194
198
195
# first look up this command under the specified name
199
196
cmds = _get_cmd_dict(plugins_override=plugins_override)
197
mutter("all commands: %r", cmds.keys())
200
198
try:
201
return cmds[cmd_name]()
199
return cmd, cmds[cmd]
202
200
except KeyError:
203
201
pass
204
202
205
203
# look for any command which claims this as an alias
206
for real_cmd_name, cmd_class in cmds.iteritems():
207
if cmd_name in cmd_class.aliases:
208
return cmd_class()
209
210
cmd_obj = ExternalCommand.find_command(cmd_name)
211
if cmd_obj:
212
return cmd_obj
213
214
raise BzrCommandError("unknown command %r" % cmd_name)
204
for cmdname, cmdclass in cmds.iteritems():
205
if cmd in cmdclass.aliases:
206
return cmdname, cmdclass
207
208
cmdclass = ExternalCommand.find_command(cmd)
209
if cmdclass:
210
return cmd, cmdclass
211
212
raise BzrCommandError("unknown command %r" % cmd)
215
213
216
214
217
215
class Command(object):
218
216
"""Base class for commands.
219
217
220
Commands are the heart of the command-line bzr interface.
221
222
The command object mostly handles the mapping of command-line
223
parameters into one or more bzrlib operations, and of the results
224
into textual output.
225
226
Commands normally don't have any state. All their arguments are
227
passed in to the run method. (Subclasses may take a different
228
policy if the behaviour of the instance needs to depend on e.g. a
229
shell plugin and not just its Python class.)
230
231
218
The docstring for an actual command should give a single-line
232
219
summary, then a complete description of the command. A grammar
233
220
description will be inserted.
234
221
235
aliases
236
Other accepted names for this command.
237
238
222
takes_args
239
223
List of argument forms, marked with whether they are optional,
240
224
repeated, etc.
243
227
List of options that may be given for this command.
244
228
245
229
hidden
246
If true, this command isn't advertised. This is typically
247
for commands intended for expert users.
230
If true, this command isn't advertised.
248
231
"""
249
232
aliases = []
250
233
253
236
254
237
hidden = False
255
238
256
def __init__(self):
257
"""Construct an instance of this command."""
239
def __init__(self, options, arguments):
240
"""Construct and run the command.
241
242
Sets self.status to the return value of run()."""
243
assert isinstance(options, dict)
244
assert isinstance(arguments, dict)
245
cmdargs = options.copy()
246
cmdargs.update(arguments)
258
247
if self.__doc__ == Command.__doc__:
248
from warnings import warn
259
249
warn("No help message set for %r" % self)
260
261
262
def run_argv(self, argv):
263
"""Parse command line and run."""
264
args, opts = parse_args(argv)
265
266
if 'help' in opts: # e.g. bzr add --help
267
from bzrlib.help import help_on_command
268
help_on_command(self.name())
269
return 0
270
271
# check options are reasonable
272
allowed = self.takes_options
273
for oname in opts:
274
if oname not in allowed:
275
raise BzrCommandError("option '--%s' is not allowed for command %r"
276
% (oname, self.name()))
277
278
# mix arguments and options into one dictionary
279
cmdargs = _match_argform(self.name(), self.takes_args, args)
280
cmdopts = {}
281
for k, v in opts.items():
282
cmdopts[k.replace('-', '_')] = v
283
284
all_cmd_args = cmdargs.copy()
285
all_cmd_args.update(cmdopts)
286
287
return self.run(**all_cmd_args)
250
self.status = self.run(**cmdargs)
251
if self.status is None:
252
self.status = 0
288
253
289
254
290
def run(self):
291
"""Actually run the command.
255
def run(self, *args, **kwargs):
256
"""Override this in sub-classes.
292
257
293
258
This is invoked with the options and arguments bound to
294
259
keyword parameters.
295
260
296
Return 0 or None if the command was successful, or a non-zero
297
shell error code if not. It's OK for this method to allow
298
an exception to raise up.
261
Return 0 or None if the command was successful, or a shell
262
error code if not.
299
263
"""
300
264
raise NotImplementedError()
301
265
302
266
303
def help(self):
304
"""Return help message for this class."""
305
if self.__doc__ is Command.__doc__:
306
return None
307
return getdoc(self)
308
309
def name(self):
310
return _unsquish_command_name(self.__class__.__name__)
267
class ExternalCommand(Command):
268
"""Class to wrap external commands.
269
270
We cheat a little here, when get_cmd_class() calls us we actually
271
give it back an object we construct that has the appropriate path,
272
help, options etc for the specified command.
273
274
When run_bzr() tries to instantiate that 'class' it gets caught by
275
the __call__ method, which we override to call the Command.__init__
276
method. That then calls our run method which is pretty straight
277
forward.
278
279
The only wrinkle is that we have to map bzr's dictionary of options
280
and arguments back into command line options and arguments for the
281
script.
282
"""
283
284
def find_command(cls, cmd):
285
import os.path
286
bzrpath = os.environ.get('BZRPATH', '')
287
288
for dir in bzrpath.split(os.pathsep):
289
path = os.path.join(dir, cmd)
290
if os.path.isfile(path):
291
return ExternalCommand(path)
292
293
return None
294
295
find_command = classmethod(find_command)
296
297
def __init__(self, path):
298
self.path = path
299
300
pipe = os.popen('%s --bzr-usage' % path, 'r')
301
self.takes_options = pipe.readline().split()
302
303
for opt in self.takes_options:
304
if not opt in OPTIONS:
305
raise BzrError("Unknown option '%s' returned by external command %s"
306
% (opt, path))
307
308
# TODO: Is there any way to check takes_args is valid here?
309
self.takes_args = pipe.readline().split()
310
311
if pipe.close() is not None:
312
raise BzrError("Failed funning '%s --bzr-usage'" % path)
313
314
pipe = os.popen('%s --bzr-help' % path, 'r')
315
self.__doc__ = pipe.read()
316
if pipe.close() is not None:
317
raise BzrError("Failed funning '%s --bzr-help'" % path)
318
319
def __call__(self, options, arguments):
320
Command.__init__(self, options, arguments)
321
return self
322
323
def run(self, **kargs):
324
opts = []
325
args = []
326
327
keys = kargs.keys()
328
keys.sort()
329
for name in keys:
330
optname = name.replace('_','-')
331
value = kargs[name]
332
if OPTIONS.has_key(optname):
333
# it's an option
334
opts.append('--%s' % optname)
335
if value is not None and value is not True:
336
opts.append(str(value))
337
else:
338
# it's an arg, or arg list
339
if type(value) is not list:
340
value = [value]
341
for v in value:
342
if v is not None:
343
args.append(str(v))
344
345
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
346
return self.status
347
311
348
312
349
313
350
def parse_spec(spec):
533
570
534
571
535
572
536
def apply_profiled(the_callable, *args, **kwargs):
537
import hotshot
538
import tempfile
539
pffileno, pfname = tempfile.mkstemp()
540
try:
541
prof = hotshot.Profile(pfname)
542
try:
543
ret = prof.runcall(the_callable, *args, **kwargs) or 0
544
finally:
545
prof.close()
546
547
import hotshot.stats
548
stats = hotshot.stats.load(pfname)
549
#stats.strip_dirs()
550
stats.sort_stats('time')
551
## XXX: Might like to write to stderr or the trace file instead but
552
## print_stats seems hardcoded to stdout
553
stats.print_stats(20)
554
555
return ret
556
finally:
557
os.close(pffileno)
558
os.remove(pfname)
559
560
561
573
def run_bzr(argv):
562
574
"""Execute a command.
563
575
591
603
# to load plugins before doing other command parsing so that they
592
604
# can override commands, but this needs to happen first.
593
605
594
for a in argv:
606
for a in argv[:]:
595
607
if a == '--profile':
596
608
opt_profile = True
597
609
elif a == '--no-plugins':
602
614
break
603
615
argv.remove(a)
604
616
605
if (not argv) or (argv[0] == '--help'):
617
if not opt_no_plugins:
618
from bzrlib.plugin import load_plugins
619
load_plugins()
620
621
args, opts = parse_args(argv)
622
623
if 'help' in opts:
606
624
from bzrlib.help import help
607
if len(argv) > 1:
608
help(argv[1])
625
if args:
626
help(args[0])
609
627
else:
610
628
help()
611
return 0
612
613
if argv[0] == '--version':
629
return 0
630
631
if 'version' in opts:
614
632
from bzrlib.builtins import show_version
615
633
show_version()
616
634
return 0
617
618
if not opt_no_plugins:
619
from bzrlib.plugin import load_plugins
620
load_plugins()
621
622
cmd = str(argv.pop(0))
623
624
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
635
636
if not args:
637
from bzrlib.help import help
638
help(None)
639
return 0
640
641
cmd = str(args.pop(0))
642
643
canonical_cmd, cmd_class = \
644
get_cmd_class(cmd, plugins_override=not opt_builtin)
645
646
# check options are reasonable
647
allowed = cmd_class.takes_options
648
for oname in opts:
649
if oname not in allowed:
650
raise BzrCommandError("option '--%s' is not allowed for command %r"
651
% (oname, cmd))
652
653
# mix arguments and options into one dictionary
654
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
655
cmdopts = {}
656
for k, v in opts.items():
657
cmdopts[k.replace('-', '_')] = v
625
658
626
659
if opt_profile:
627
ret = apply_profiled(cmd_obj.run_argv, argv)
660
import hotshot, tempfile
661
pffileno, pfname = tempfile.mkstemp()
662
try:
663
prof = hotshot.Profile(pfname)
664
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
665
prof.close()
666
667
import hotshot.stats
668
stats = hotshot.stats.load(pfname)
669
#stats.strip_dirs()
670
stats.sort_stats('time')
671
## XXX: Might like to write to stderr or the trace file instead but
672
## print_stats seems hardcoded to stdout
673
stats.print_stats(20)
674
675
return ret.status
676
677
finally:
678
os.close(pffileno)
679
os.remove(pfname)
628
680
else:
629
ret = cmd_obj.run_argv(argv)
630
return ret or 0
681
return cmd_class(cmdopts, cmdargs).status
631
682
632
683
633
684
def main(argv):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1