« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 647
- compare with another revision
- download diff
- download tarball
- view history from revision 647
- Committer: Martin Pool
- Date: 2005-06-10 06:34:26 UTC
- Revision ID: mbp@sourcefrog.net-20050610063426-cfcf5c0f96c271ec
- split out updated progress indicator
- files added:
- bzrlib/mdiff.py
- files removed:
- HACKING
- bzrlib/export
- bzrlib/plugins
- bzrlib/store
- bzrlib/tests
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- bzr_man.py => bzr-man.py
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/tests/__init__.py => bzrlib/selftest.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/tests/test_whitebox.py => bzrlib/whitebox.py
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/commands.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
# TODO: probably should say which arguments are candidates for glob
19
# expansion on windows and do that at the command level.
20
21
# TODO: Help messages for options.
22
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.
26
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?
29
30
import sys
31
import os
32
from warnings import warn
33
from inspect import getdoc
34
import errno
18
19
import sys, os
35
20
36
21
import bzrlib
37
import bzrlib.trace
38
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
39
from bzrlib.errors import (BzrError,
40
BzrCheckError,
41
BzrCommandError,
42
BzrOptionError,
43
NotBranchError)
44
from bzrlib.revisionspec import RevisionSpec
45
from bzrlib import BZRDIR
46
from bzrlib.option import Option
47
48
plugin_cmds = {}
49
50
51
def register_command(cmd, decorate=False):
52
"Utility function to help register a command"
53
global plugin_cmds
54
k = cmd.__name__
55
if k.startswith("cmd_"):
56
k_unsquished = _unsquish_command_name(k)
57
else:
58
k_unsquished = 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]
64
elif decorate:
65
result = plugin_cmds[k_unsquished]
66
plugin_cmds[k_unsquished] = cmd
67
return result
68
else:
69
log_error('Two plugins defined the same command: %r' % k)
70
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
22
from bzrlib.trace import mutter, note, log_error
23
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
26
format_date
71
27
72
28
73
29
def _squish_command_name(cmd):
78
34
assert cmd.startswith("cmd_")
79
35
return cmd[4:].replace('_','-')
80
36
81
82
def _builtin_commands():
83
import bzrlib.builtins
84
r = {}
85
builtins = bzrlib.builtins.__dict__
86
for name in builtins:
87
if name.startswith("cmd_"):
88
real_name = _unsquish_command_name(name)
89
r[real_name] = builtins[name]
90
return r
91
92
93
94
def builtin_command_names():
95
"""Return list of builtin command names."""
96
return _builtin_commands().keys()
37
def _parse_revision_str(revstr):
38
"""This handles a revision string -> revno.
39
40
There are several possibilities:
41
42
'234' -> 234
43
'234:345' -> [234, 345]
44
':234' -> [None, 234]
45
'234:' -> [234, None]
46
47
In the future we will also support:
48
'uuid:blah-blah-blah' -> ?
49
'hash:blahblahblah' -> ?
50
potentially:
51
'tag:mytag' -> ?
52
"""
53
if revstr.find(':') != -1:
54
revs = revstr.split(':')
55
if len(revs) > 2:
56
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
57
58
if not revs[0]:
59
revs[0] = None
60
else:
61
revs[0] = int(revs[0])
62
63
if not revs[1]:
64
revs[1] = None
65
else:
66
revs[1] = int(revs[1])
67
else:
68
revs = int(revstr)
69
return revs
70
71
def _find_plugins():
72
"""Find all python files which are plugins, and load their commands
73
to add to the list of "all commands"
74
75
The environment variable BZRPATH is considered a delimited set of
76
paths to look through. Each entry is searched for *.py files.
77
If a directory is found, it is also searched, but they are
78
not searched recursively. This allows you to revctl the plugins.
97
79
98
99
def plugin_command_names():
100
return plugin_cmds.keys()
101
102
103
def _get_cmd_dict(plugins_override=True):
104
"""Return name->class mapping for all commands."""
105
d = _builtin_commands()
106
if plugins_override:
107
d.update(plugin_cmds)
80
Inside the plugin should be a series of cmd_* function, which inherit from
81
the bzrlib.commands.Command class.
82
"""
83
bzrpath = os.environ.get('BZRPLUGINPATH', '')
84
85
plugin_cmds = {}
86
if not bzrpath:
87
return plugin_cmds
88
_platform_extensions = {
89
'win32':'.pyd',
90
'cygwin':'.dll',
91
'darwin':'.dylib',
92
'linux2':'.so'
93
}
94
if _platform_extensions.has_key(sys.platform):
95
platform_extension = _platform_extensions[sys.platform]
96
else:
97
platform_extension = None
98
for d in bzrpath.split(os.pathsep):
99
plugin_names = {} # This should really be a set rather than a dict
100
for f in os.listdir(d):
101
if f.endswith('.py'):
102
f = f[:-3]
103
elif f.endswith('.pyc') or f.endswith('.pyo'):
104
f = f[:-4]
105
elif platform_extension and f.endswith(platform_extension):
106
f = f[:-len(platform_extension)]
107
if f.endswidth('module'):
108
f = f[:-len('module')]
109
else:
110
continue
111
if not plugin_names.has_key(f):
112
plugin_names[f] = True
113
114
plugin_names = plugin_names.keys()
115
plugin_names.sort()
116
try:
117
sys.path.insert(0, d)
118
for name in plugin_names:
119
try:
120
old_module = None
121
try:
122
if sys.modules.has_key(name):
123
old_module = sys.modules[name]
124
del sys.modules[name]
125
plugin = __import__(name, locals())
126
for k in dir(plugin):
127
if k.startswith('cmd_'):
128
k_unsquished = _unsquish_command_name(k)
129
if not plugin_cmds.has_key(k_unsquished):
130
plugin_cmds[k_unsquished] = getattr(plugin, k)
131
else:
132
log_error('Two plugins defined the same command: %r' % k)
133
log_error('Not loading the one in %r in dir %r' % (name, d))
134
finally:
135
if old_module:
136
sys.modules[name] = old_module
137
except ImportError, e:
138
log_error('Unable to load plugin: %r from %r\n%s' % (name, d, e))
139
finally:
140
sys.path.pop(0)
141
return plugin_cmds
142
143
def _get_cmd_dict(include_plugins=True):
144
d = {}
145
for k, v in globals().iteritems():
146
if k.startswith("cmd_"):
147
d[_unsquish_command_name(k)] = v
148
if include_plugins:
149
d.update(_find_plugins())
108
150
return d
109
110
151
111
def get_all_cmds(plugins_override=True):
152
def get_all_cmds(include_plugins=True):
112
153
"""Return canonical name and class for all registered commands."""
113
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
154
for k, v in _get_cmd_dict(include_plugins=include_plugins).iteritems():
114
155
yield k,v
115
156
116
157
117
def get_cmd_object(cmd_name, plugins_override=True):
158
def get_cmd_class(cmd,include_plugins=True):
118
159
"""Return the canonical name and command class for a command.
119
120
plugins_override
121
If true, plugin commands can override builtins.
122
160
"""
123
from bzrlib.externalcommand import ExternalCommand
124
125
cmd_name = str(cmd_name) # not unicode
161
cmd = str(cmd) # not unicode
126
162
127
163
# first look up this command under the specified name
128
cmds = _get_cmd_dict(plugins_override=plugins_override)
164
cmds = _get_cmd_dict(include_plugins=include_plugins)
129
165
try:
130
return cmds[cmd_name]()
166
return cmd, cmds[cmd]
131
167
except KeyError:
132
168
pass
133
169
134
170
# 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:
137
return cmd_class()
138
139
cmd_obj = ExternalCommand.find_command(cmd_name)
140
if cmd_obj:
141
return cmd_obj
142
143
raise BzrCommandError("unknown command %r" % cmd_name)
171
for cmdname, cmdclass in cmds.iteritems():
172
if cmd in cmdclass.aliases:
173
return cmdname, cmdclass
174
175
cmdclass = ExternalCommand.find_command(cmd)
176
if cmdclass:
177
return cmd, cmdclass
178
179
raise BzrCommandError("unknown command %r" % cmd)
144
180
145
181
146
182
class Command(object):
147
183
"""Base class for commands.
148
184
149
Commands are the heart of the command-line bzr interface.
150
151
The command object mostly handles the mapping of command-line
152
parameters into one or more bzrlib operations, and of the results
153
into textual output.
154
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.)
159
160
185
The docstring for an actual command should give a single-line
161
186
summary, then a complete description of the command. A grammar
162
187
description will be inserted.
163
188
164
aliases
165
Other accepted names for this command.
166
167
189
takes_args
168
190
List of argument forms, marked with whether they are optional,
169
191
repeated, etc.
170
192
171
Examples:
172
173
['to_location', 'from_branch?', 'file*']
174
175
'to_location' is required
176
'from_branch' is optional
177
'file' can be specified 0 or more times
178
179
193
takes_options
180
List of options that may be given for this command. These can
181
be either strings, referring to globally-defined options,
182
or option objects. Retrieve through options().
194
List of options that may be given for this command.
183
195
184
196
hidden
185
If true, this command isn't advertised. This is typically
186
for commands intended for expert users.
197
If true, this command isn't advertised.
187
198
"""
188
199
aliases = []
200
189
201
takes_args = []
190
202
takes_options = []
191
203
192
204
hidden = False
193
205
194
def __init__(self):
195
"""Construct an instance of this command."""
196
if self.__doc__ == Command.__doc__:
197
warn("No help message set for %r" % self)
198
199
def options(self):
200
"""Return dict of valid options for this command.
201
202
Maps from long option name to option object."""
203
r = dict()
204
r['help'] = Option.OPTIONS['help']
205
for o in self.takes_options:
206
if not isinstance(o, Option):
207
o = Option.OPTIONS[o]
208
r[o.name] = o
209
return r
210
211
def run_argv(self, argv):
212
"""Parse command line and run."""
213
args, opts = parse_args(self, argv)
214
if 'help' in opts: # e.g. bzr add --help
215
from bzrlib.help import help_on_command
216
help_on_command(self.name())
217
return 0
218
# XXX: This should be handled by the parser
219
allowed_names = self.options().keys()
220
for oname in opts:
221
if oname not in allowed_names:
222
raise BzrCommandError("option '--%s' is not allowed for command %r"
223
% (oname, self.name()))
224
# mix arguments and options into one dictionary
225
cmdargs = _match_argform(self.name(), self.takes_args, args)
226
cmdopts = {}
227
for k, v in opts.items():
228
cmdopts[k.replace('-', '_')] = v
229
230
all_cmd_args = cmdargs.copy()
231
all_cmd_args.update(cmdopts)
232
233
return self.run(**all_cmd_args)
206
def __init__(self, options, arguments):
207
"""Construct and run the command.
208
209
Sets self.status to the return value of run()."""
210
assert isinstance(options, dict)
211
assert isinstance(arguments, dict)
212
cmdargs = options.copy()
213
cmdargs.update(arguments)
214
assert self.__doc__ != Command.__doc__, \
215
("No help message set for %r" % self)
216
self.status = self.run(**cmdargs)
217
234
218
235
219
def run(self):
236
"""Actually run the command.
220
"""Override this in sub-classes.
237
221
238
222
This is invoked with the options and arguments bound to
239
223
keyword parameters.
240
224
241
Return 0 or None if the command was successful, or a non-zero
242
shell error code if not. It's OK for this method to allow
243
an exception to raise up.
225
Return 0 or None if the command was successful, or a shell
226
error code if not.
244
227
"""
245
raise NotImplementedError()
246
247
248
def help(self):
249
"""Return help message for this class."""
250
if self.__doc__ is Command.__doc__:
251
return None
252
return getdoc(self)
253
254
def name(self):
255
return _unsquish_command_name(self.__class__.__name__)
256
228
return 0
229
230
231
class ExternalCommand(Command):
232
"""Class to wrap external commands.
233
234
We cheat a little here, when get_cmd_class() calls us we actually give it back
235
an object we construct that has the appropriate path, help, options etc for the
236
specified command.
237
238
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
239
method, which we override to call the Command.__init__ method. That then calls
240
our run method which is pretty straight forward.
241
242
The only wrinkle is that we have to map bzr's dictionary of options and arguments
243
back into command line options and arguments for the script.
244
"""
245
246
def find_command(cls, cmd):
247
import os.path
248
bzrpath = os.environ.get('BZRPATH', '')
249
250
for dir in bzrpath.split(os.pathsep):
251
path = os.path.join(dir, cmd)
252
if os.path.isfile(path):
253
return ExternalCommand(path)
254
255
return None
256
257
find_command = classmethod(find_command)
258
259
def __init__(self, path):
260
self.path = path
261
262
# TODO: If either of these fail, we should detect that and
263
# assume that path is not really a bzr plugin after all.
264
265
pipe = os.popen('%s --bzr-usage' % path, 'r')
266
self.takes_options = pipe.readline().split()
267
self.takes_args = pipe.readline().split()
268
pipe.close()
269
270
pipe = os.popen('%s --bzr-help' % path, 'r')
271
self.__doc__ = pipe.read()
272
pipe.close()
273
274
def __call__(self, options, arguments):
275
Command.__init__(self, options, arguments)
276
return self
277
278
def run(self, **kargs):
279
opts = []
280
args = []
281
282
keys = kargs.keys()
283
keys.sort()
284
for name in keys:
285
value = kargs[name]
286
if OPTIONS.has_key(name):
287
# it's an option
288
opts.append('--%s' % name)
289
if value is not None and value is not True:
290
opts.append(str(value))
291
else:
292
# it's an arg, or arg list
293
if type(value) is not list:
294
value = [value]
295
for v in value:
296
if v is not None:
297
args.append(str(v))
298
299
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
300
return self.status
301
302
303
class cmd_status(Command):
304
"""Display status summary.
305
306
This reports on versioned and unknown files, reporting them
307
grouped by state. Possible states are:
308
309
added
310
Versioned in the working copy but not in the previous revision.
311
312
removed
313
Versioned in the previous revision but removed or deleted
314
in the working copy.
315
316
renamed
317
Path of this file changed from the previous revision;
318
the text may also have changed. This includes files whose
319
parent directory was renamed.
320
321
modified
322
Text has changed since the previous revision.
323
324
unchanged
325
Nothing about this file has changed since the previous revision.
326
Only shown with --all.
327
328
unknown
329
Not versioned and not matching an ignore pattern.
330
331
To see ignored files use 'bzr ignored'. For details in the
332
changes to file texts, use 'bzr diff'.
333
334
If no arguments are specified, the status of the entire working
335
directory is shown. Otherwise, only the status of the specified
336
files or directories is reported. If a directory is given, status
337
is reported for everything inside that directory.
338
"""
339
takes_args = ['file*']
340
takes_options = ['all', 'show-ids']
341
aliases = ['st', 'stat']
342
343
def run(self, all=False, show_ids=False, file_list=None):
344
if file_list:
345
b = Branch(file_list[0])
346
file_list = [b.relpath(x) for x in file_list]
347
# special case: only one path was given and it's the root
348
# of the branch
349
if file_list == ['']:
350
file_list = None
351
else:
352
b = Branch('.')
353
import status
354
status.show_status(b, show_unchanged=all, show_ids=show_ids,
355
specific_files=file_list)
356
357
358
class cmd_cat_revision(Command):
359
"""Write out metadata for a revision."""
360
361
hidden = True
362
takes_args = ['revision_id']
363
364
def run(self, revision_id):
365
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
366
367
368
class cmd_revno(Command):
369
"""Show current revision number.
370
371
This is equal to the number of revisions on this branch."""
372
def run(self):
373
print Branch('.').revno()
374
375
376
class cmd_add(Command):
377
"""Add specified files or directories.
378
379
In non-recursive mode, all the named items are added, regardless
380
of whether they were previously ignored. A warning is given if
381
any of the named files are already versioned.
382
383
In recursive mode (the default), files are treated the same way
384
but the behaviour for directories is different. Directories that
385
are already versioned do not give a warning. All directories,
386
whether already versioned or not, are searched for files or
387
subdirectories that are neither versioned or ignored, and these
388
are added. This search proceeds recursively into versioned
389
directories.
390
391
Therefore simply saying 'bzr add .' will version all files that
392
are currently unknown.
393
394
TODO: Perhaps adding a file whose directly is not versioned should
395
recursively add that parent, rather than giving an error?
396
"""
397
takes_args = ['file+']
398
takes_options = ['verbose', 'no-recurse']
399
400
def run(self, file_list, verbose=False, no_recurse=False):
401
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
402
403
404
class cmd_relpath(Command):
405
"""Show path of a file relative to root"""
406
takes_args = ['filename']
407
hidden = True
408
409
def run(self, filename):
410
print Branch(filename).relpath(filename)
411
412
413
414
class cmd_inventory(Command):
415
"""Show inventory of the current working copy or a revision."""
416
takes_options = ['revision', 'show-ids']
417
418
def run(self, revision=None, show_ids=False):
419
b = Branch('.')
420
if revision == None:
421
inv = b.read_working_inventory()
422
else:
423
inv = b.get_revision_inventory(b.lookup_revision(revision))
424
425
for path, entry in inv.entries():
426
if show_ids:
427
print '%-50s %s' % (path, entry.file_id)
428
else:
429
print path
430
431
432
class cmd_move(Command):
433
"""Move files to a different directory.
434
435
examples:
436
bzr move *.txt doc
437
438
The destination must be a versioned directory in the same branch.
439
"""
440
takes_args = ['source$', 'dest']
441
def run(self, source_list, dest):
442
b = Branch('.')
443
444
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
445
446
447
class cmd_rename(Command):
448
"""Change the name of an entry.
449
450
examples:
451
bzr rename frob.c frobber.c
452
bzr rename src/frob.c lib/frob.c
453
454
It is an error if the destination name exists.
455
456
See also the 'move' command, which moves files into a different
457
directory without changing their name.
458
459
TODO: Some way to rename multiple files without invoking bzr for each
460
one?"""
461
takes_args = ['from_name', 'to_name']
462
463
def run(self, from_name, to_name):
464
b = Branch('.')
465
b.rename_one(b.relpath(from_name), b.relpath(to_name))
466
467
468
469
470
471
class cmd_pull(Command):
472
"""Pull any changes from another branch into the current one.
473
474
If the location is omitted, the last-used location will be used.
475
Both the revision history and the working directory will be
476
updated.
477
478
This command only works on branches that have not diverged. Branches are
479
considered diverged if both branches have had commits without first
480
pulling from the other.
481
482
If branches have diverged, you can use 'bzr merge' to pull the text changes
483
from one into the other.
484
"""
485
takes_args = ['location?']
486
487
def run(self, location=None):
488
from bzrlib.merge import merge
489
import errno
490
491
br_to = Branch('.')
492
stored_loc = None
493
try:
494
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
495
except IOError, e:
496
if errno == errno.ENOENT:
497
raise
498
if location is None:
499
location = stored_loc
500
if location is None:
501
raise BzrCommandError("No pull location known or specified.")
502
from branch import find_branch, DivergedBranches
503
br_from = find_branch(location)
504
location = pull_loc(br_from)
505
old_revno = br_to.revno()
506
try:
507
br_to.update_revisions(br_from)
508
except DivergedBranches:
509
raise BzrCommandError("These branches have diverged. Try merge.")
510
511
merge(('.', -1), ('.', old_revno), check_clean=False)
512
if location != stored_loc:
513
br_to.controlfile("x-pull", "wb").write(location + "\n")
514
515
516
517
class cmd_branch(Command):
518
"""Create a new copy of a branch.
519
520
If the TO_LOCATION is omitted, the last component of the
521
FROM_LOCATION will be used. In other words,
522
"branch ../foo/bar" will attempt to create ./bar.
523
"""
524
takes_args = ['from_location', 'to_location?']
525
526
def run(self, from_location, to_location=None):
527
import errno
528
from bzrlib.merge import merge
529
530
if to_location is None:
531
to_location = os.path.basename(from_location)
532
# FIXME: If there's a trailing slash, keep removing them
533
# until we find the right bit
534
535
try:
536
os.mkdir(to_location)
537
except OSError, e:
538
if e.errno == errno.EEXIST:
539
raise BzrCommandError('Target directory "%s" already exists.' %
540
to_location)
541
if e.errno == errno.ENOENT:
542
raise BzrCommandError('Parent of "%s" does not exist.' %
543
to_location)
544
else:
545
raise
546
br_to = Branch(to_location, init=True)
547
from branch import find_branch, DivergedBranches
548
try:
549
br_from = find_branch(from_location)
550
except OSError, e:
551
if e.errno == errno.ENOENT:
552
raise BzrCommandError('Source location "%s" does not exist.' %
553
to_location)
554
else:
555
raise
556
557
from_location = pull_loc(br_from)
558
br_to.update_revisions(br_from)
559
merge((to_location, -1), (to_location, 0), this_dir=to_location,
560
check_clean=False)
561
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
562
563
564
def pull_loc(branch):
565
# TODO: Should perhaps just make attribute be 'base' in
566
# RemoteBranch and Branch?
567
if hasattr(branch, "baseurl"):
568
return branch.baseurl
569
else:
570
return branch.base
571
572
573
574
class cmd_renames(Command):
575
"""Show list of renamed files.
576
577
TODO: Option to show renames between two historical versions.
578
579
TODO: Only show renames under dir, rather than in the whole branch.
580
"""
581
takes_args = ['dir?']
582
583
def run(self, dir='.'):
584
b = Branch(dir)
585
old_inv = b.basis_tree().inventory
586
new_inv = b.read_working_inventory()
587
588
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
589
renames.sort()
590
for old_name, new_name in renames:
591
print "%s => %s" % (old_name, new_name)
592
593
594
class cmd_info(Command):
595
"""Show statistical information about a branch."""
596
takes_args = ['branch?']
597
598
def run(self, branch=None):
599
import info
600
601
from branch import find_branch
602
b = find_branch(branch)
603
info.show_info(b)
604
605
606
class cmd_remove(Command):
607
"""Make a file unversioned.
608
609
This makes bzr stop tracking changes to a versioned file. It does
610
not delete the working copy.
611
"""
612
takes_args = ['file+']
613
takes_options = ['verbose']
614
615
def run(self, file_list, verbose=False):
616
b = Branch(file_list[0])
617
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
618
619
620
class cmd_file_id(Command):
621
"""Print file_id of a particular file or directory.
622
623
The file_id is assigned when the file is first added and remains the
624
same through all revisions where the file exists, even when it is
625
moved or renamed.
626
"""
627
hidden = True
628
takes_args = ['filename']
629
def run(self, filename):
630
b = Branch(filename)
631
i = b.inventory.path2id(b.relpath(filename))
632
if i == None:
633
bailout("%r is not a versioned file" % filename)
634
else:
635
print i
636
637
638
class cmd_file_path(Command):
639
"""Print path of file_ids to a file or directory.
640
641
This prints one line for each directory down to the target,
642
starting at the branch root."""
643
hidden = True
644
takes_args = ['filename']
645
def run(self, filename):
646
b = Branch(filename)
647
inv = b.inventory
648
fid = inv.path2id(b.relpath(filename))
649
if fid == None:
650
bailout("%r is not a versioned file" % filename)
651
for fip in inv.get_idpath(fid):
652
print fip
653
654
655
class cmd_revision_history(Command):
656
"""Display list of revision ids on this branch."""
657
hidden = True
658
def run(self):
659
for patchid in Branch('.').revision_history():
660
print patchid
661
662
663
class cmd_directories(Command):
664
"""Display list of versioned directories in this branch."""
665
def run(self):
666
for name, ie in Branch('.').read_working_inventory().directories():
667
if name == '':
668
print '.'
669
else:
670
print name
671
672
673
class cmd_init(Command):
674
"""Make a directory into a versioned branch.
675
676
Use this to create an empty branch, or before importing an
677
existing project.
678
679
Recipe for importing a tree of files:
680
cd ~/project
681
bzr init
682
bzr add -v .
683
bzr status
684
bzr commit -m 'imported project'
685
"""
686
def run(self):
687
Branch('.', init=True)
688
689
690
class cmd_diff(Command):
691
"""Show differences in working tree.
692
693
If files are listed, only the changes in those files are listed.
694
Otherwise, all changes for the tree are listed.
695
696
TODO: Given two revision arguments, show the difference between them.
697
698
TODO: Allow diff across branches.
699
700
TODO: Option to use external diff command; could be GNU diff, wdiff,
701
or a graphical diff.
702
703
TODO: Python difflib is not exactly the same as unidiff; should
704
either fix it up or prefer to use an external diff.
705
706
TODO: If a directory is given, diff everything under that.
707
708
TODO: Selected-file diff is inefficient and doesn't show you
709
deleted files.
710
711
TODO: This probably handles non-Unix newlines poorly.
712
"""
713
714
takes_args = ['file*']
715
takes_options = ['revision', 'diff-options']
716
aliases = ['di', 'dif']
717
718
def run(self, revision=None, file_list=None, diff_options=None):
719
from bzrlib.diff import show_diff
720
from bzrlib import find_branch
721
722
if file_list:
723
b = find_branch(file_list[0])
724
file_list = [b.relpath(f) for f in file_list]
725
if file_list == ['']:
726
# just pointing to top-of-tree
727
file_list = None
728
else:
729
b = Branch('.')
730
731
show_diff(b, revision, specific_files=file_list,
732
external_diff_options=diff_options)
733
734
735
736
737
738
class cmd_deleted(Command):
739
"""List files deleted in the working tree.
740
741
TODO: Show files deleted since a previous revision, or between two revisions.
742
"""
743
def run(self, show_ids=False):
744
b = Branch('.')
745
old = b.basis_tree()
746
new = b.working_tree()
747
748
## TODO: Much more efficient way to do this: read in new
749
## directories with readdir, rather than stating each one. Same
750
## level of effort but possibly much less IO. (Or possibly not,
751
## if the directories are very large...)
752
753
for path, ie in old.inventory.iter_entries():
754
if not new.has_id(ie.file_id):
755
if show_ids:
756
print '%-50s %s' % (path, ie.file_id)
757
else:
758
print path
759
760
761
class cmd_modified(Command):
762
"""List files modified in working tree."""
763
hidden = True
764
def run(self):
765
import statcache
766
b = Branch('.')
767
inv = b.read_working_inventory()
768
sc = statcache.update_cache(b, inv)
769
basis = b.basis_tree()
770
basis_inv = basis.inventory
771
772
# We used to do this through iter_entries(), but that's slow
773
# when most of the files are unmodified, as is usually the
774
# case. So instead we iterate by inventory entry, and only
775
# calculate paths as necessary.
776
777
for file_id in basis_inv:
778
cacheentry = sc.get(file_id)
779
if not cacheentry: # deleted
780
continue
781
ie = basis_inv[file_id]
782
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
783
path = inv.id2path(file_id)
784
print path
785
786
787
788
class cmd_added(Command):
789
"""List files added in working tree."""
790
hidden = True
791
def run(self):
792
b = Branch('.')
793
wt = b.working_tree()
794
basis_inv = b.basis_tree().inventory
795
inv = wt.inventory
796
for file_id in inv:
797
if file_id in basis_inv:
798
continue
799
path = inv.id2path(file_id)
800
if not os.access(b.abspath(path), os.F_OK):
801
continue
802
print path
803
804
805
806
class cmd_root(Command):
807
"""Show the tree root directory.
808
809
The root is the nearest enclosing directory with a .bzr control
810
directory."""
811
takes_args = ['filename?']
812
def run(self, filename=None):
813
"""Print the branch root."""
814
from branch import find_branch
815
b = find_branch(filename)
816
print getattr(b, 'base', None) or getattr(b, 'baseurl')
817
818
819
class cmd_log(Command):
820
"""Show log of this branch.
821
822
To request a range of logs, you can use the command -r begin:end
823
-r revision requests a specific revision, -r :end or -r begin: are
824
also valid.
825
826
TODO: Make --revision support uuid: and hash: [future tag:] notation.
827
828
"""
829
830
takes_args = ['filename?']
831
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
832
833
def run(self, filename=None, timezone='original',
834
verbose=False,
835
show_ids=False,
836
forward=False,
837
revision=None):
838
from bzrlib import show_log, find_branch
839
import codecs
840
841
direction = (forward and 'forward') or 'reverse'
842
843
if filename:
844
b = find_branch(filename)
845
fp = b.relpath(filename)
846
if fp:
847
file_id = b.read_working_inventory().path2id(fp)
848
else:
849
file_id = None # points to branch root
850
else:
851
b = find_branch('.')
852
file_id = None
853
854
if revision == None:
855
revision = [None, None]
856
elif isinstance(revision, int):
857
revision = [revision, revision]
858
else:
859
# pair of revisions?
860
pass
861
862
assert len(revision) == 2
863
864
mutter('encoding log as %r' % bzrlib.user_encoding)
865
866
# use 'replace' so that we don't abort if trying to write out
867
# in e.g. the default C locale.
868
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
869
870
show_log(b, file_id,
871
show_timezone=timezone,
872
verbose=verbose,
873
show_ids=show_ids,
874
to_file=outf,
875
direction=direction,
876
start_revision=revision[0],
877
end_revision=revision[1])
878
879
880
881
class cmd_touching_revisions(Command):
882
"""Return revision-ids which affected a particular file.
883
884
A more user-friendly interface is "bzr log FILE"."""
885
hidden = True
886
takes_args = ["filename"]
887
def run(self, filename):
888
b = Branch(filename)
889
inv = b.read_working_inventory()
890
file_id = inv.path2id(b.relpath(filename))
891
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
892
print "%6d %s" % (revno, what)
893
894
895
class cmd_ls(Command):
896
"""List files in a tree.
897
898
TODO: Take a revision or remote path and list that tree instead.
899
"""
900
hidden = True
901
def run(self, revision=None, verbose=False):
902
b = Branch('.')
903
if revision == None:
904
tree = b.working_tree()
905
else:
906
tree = b.revision_tree(b.lookup_revision(revision))
907
908
for fp, fc, kind, fid in tree.list_files():
909
if verbose:
910
if kind == 'directory':
911
kindch = '/'
912
elif kind == 'file':
913
kindch = ''
914
else:
915
kindch = '???'
916
917
print '%-8s %s%s' % (fc, fp, kindch)
918
else:
919
print fp
920
921
922
923
class cmd_unknowns(Command):
924
"""List unknown files."""
925
def run(self):
926
for f in Branch('.').unknowns():
927
print quotefn(f)
928
929
930
931
class cmd_ignore(Command):
932
"""Ignore a command or pattern.
933
934
To remove patterns from the ignore list, edit the .bzrignore file.
935
936
If the pattern contains a slash, it is compared to the whole path
937
from the branch root. Otherwise, it is comapred to only the last
938
component of the path.
939
940
Ignore patterns are case-insensitive on case-insensitive systems.
941
942
Note: wildcards must be quoted from the shell on Unix.
943
944
examples:
945
bzr ignore ./Makefile
946
bzr ignore '*.class'
947
"""
948
takes_args = ['name_pattern']
949
950
def run(self, name_pattern):
951
from bzrlib.atomicfile import AtomicFile
952
import os.path
953
954
b = Branch('.')
955
ifn = b.abspath('.bzrignore')
956
957
if os.path.exists(ifn):
958
f = open(ifn, 'rt')
959
try:
960
igns = f.read().decode('utf-8')
961
finally:
962
f.close()
963
else:
964
igns = ''
965
966
# TODO: If the file already uses crlf-style termination, maybe
967
# we should use that for the newly added lines?
968
969
if igns and igns[-1] != '\n':
970
igns += '\n'
971
igns += name_pattern + '\n'
972
973
try:
974
f = AtomicFile(ifn, 'wt')
975
f.write(igns.encode('utf-8'))
976
f.commit()
977
finally:
978
f.close()
979
980
inv = b.working_tree().inventory
981
if inv.path2id('.bzrignore'):
982
mutter('.bzrignore is already versioned')
983
else:
984
mutter('need to make new .bzrignore file versioned')
985
b.add(['.bzrignore'])
986
987
988
989
class cmd_ignored(Command):
990
"""List ignored files and the patterns that matched them.
991
992
See also: bzr ignore"""
993
def run(self):
994
tree = Branch('.').working_tree()
995
for path, file_class, kind, file_id in tree.list_files():
996
if file_class != 'I':
997
continue
998
## XXX: Slightly inefficient since this was already calculated
999
pat = tree.is_ignored(path)
1000
print '%-50s %s' % (path, pat)
1001
1002
1003
class cmd_lookup_revision(Command):
1004
"""Lookup the revision-id from a revision-number
1005
1006
example:
1007
bzr lookup-revision 33
1008
"""
1009
hidden = True
1010
takes_args = ['revno']
1011
1012
def run(self, revno):
1013
try:
1014
revno = int(revno)
1015
except ValueError:
1016
raise BzrCommandError("not a valid revision-number: %r" % revno)
1017
1018
print Branch('.').lookup_revision(revno)
1019
1020
1021
class cmd_export(Command):
1022
"""Export past revision to destination directory.
1023
1024
If no revision is specified this exports the last committed revision."""
1025
takes_args = ['dest']
1026
takes_options = ['revision']
1027
def run(self, dest, revision=None):
1028
b = Branch('.')
1029
if revision == None:
1030
rh = b.revision_history()[-1]
1031
else:
1032
rh = b.lookup_revision(int(revision))
1033
t = b.revision_tree(rh)
1034
t.export(dest)
1035
1036
1037
class cmd_cat(Command):
1038
"""Write a file's text from a previous revision."""
1039
1040
takes_options = ['revision']
1041
takes_args = ['filename']
1042
1043
def run(self, filename, revision=None):
1044
if revision == None:
1045
raise BzrCommandError("bzr cat requires a revision number")
1046
b = Branch('.')
1047
b.print_file(b.relpath(filename), int(revision))
1048
1049
1050
class cmd_local_time_offset(Command):
1051
"""Show the offset in seconds from GMT to local time."""
1052
hidden = True
1053
def run(self):
1054
print bzrlib.osutils.local_time_offset()
1055
1056
1057
1058
class cmd_commit(Command):
1059
"""Commit changes into a new revision.
1060
1061
If selected files are specified, only changes to those files are
1062
committed. If a directory is specified then its contents are also
1063
committed.
1064
1065
A selected-file commit may fail in some cases where the committed
1066
tree would be invalid, such as trying to commit a file in a
1067
newly-added directory that is not itself committed.
1068
1069
TODO: Run hooks on tree to-be-committed, and after commit.
1070
1071
TODO: Strict commit that fails if there are unknown or deleted files.
1072
"""
1073
takes_args = ['selected*']
1074
takes_options = ['message', 'file', 'verbose']
1075
aliases = ['ci', 'checkin']
1076
1077
def run(self, message=None, file=None, verbose=True, selected_list=None):
1078
from bzrlib.commit import commit
1079
1080
## Warning: shadows builtin file()
1081
if not message and not file:
1082
raise BzrCommandError("please specify a commit message",
1083
["use either --message or --file"])
1084
elif message and file:
1085
raise BzrCommandError("please specify either --message or --file")
1086
1087
if file:
1088
import codecs
1089
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1090
1091
b = Branch('.')
1092
commit(b, message, verbose=verbose, specific_files=selected_list)
1093
1094
1095
class cmd_check(Command):
1096
"""Validate consistency of branch history.
1097
1098
This command checks various invariants about the branch storage to
1099
detect data corruption or bzr bugs.
1100
"""
1101
takes_args = ['dir?']
1102
def run(self, dir='.'):
1103
import bzrlib.check
1104
bzrlib.check.check(Branch(dir))
1105
1106
1107
1108
class cmd_whoami(Command):
1109
"""Show bzr user id."""
1110
takes_options = ['email']
1111
1112
def run(self, email=False):
1113
if email:
1114
print bzrlib.osutils.user_email()
1115
else:
1116
print bzrlib.osutils.username()
1117
1118
1119
class cmd_selftest(Command):
1120
"""Run internal test suite"""
1121
hidden = True
1122
def run(self):
1123
from bzrlib.selftest import selftest
1124
if selftest():
1125
return 0
1126
else:
1127
return 1
1128
1129
1130
1131
class cmd_version(Command):
1132
"""Show version of bzr."""
1133
def run(self):
1134
show_version()
1135
1136
def show_version():
1137
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1138
# is bzrlib itself in a branch?
1139
bzrrev = bzrlib.get_bzr_revision()
1140
if bzrrev:
1141
print " (bzr checkout, revision %d {%s})" % bzrrev
1142
print bzrlib.__copyright__
1143
print "http://bazaar-ng.org/"
1144
print
1145
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1146
print "you may use, modify and redistribute it under the terms of the GNU"
1147
print "General Public License version 2 or later."
1148
1149
1150
class cmd_rocks(Command):
1151
"""Statement of optimism."""
1152
hidden = True
1153
def run(self):
1154
print "it sure does!"
257
1155
258
1156
def parse_spec(spec):
259
1157
"""
265
1163
['..', -1]
266
1164
>>> parse_spec("../f/@35")
267
1165
['../f', 35]
268
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
269
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
270
1166
"""
271
1167
if spec is None:
272
1168
return [None, None]
276
1172
if parsed[1] == "":
277
1173
parsed[1] = -1
278
1174
else:
279
try:
280
parsed[1] = int(parsed[1])
281
except ValueError:
282
pass # We can allow stuff like ./@revid:blahblahblah
283
else:
284
assert parsed[1] >=0
1175
parsed[1] = int(parsed[1])
1176
assert parsed[1] >=0
285
1177
else:
286
1178
parsed = [spec, None]
287
1179
return parsed
288
1180
289
def parse_args(command, argv):
1181
1182
1183
class cmd_merge(Command):
1184
"""Perform a three-way merge of trees.
1185
1186
The SPEC parameters are working tree or revision specifiers. Working trees
1187
are specified using standard paths or urls. No component of a directory
1188
path may begin with '@'.
1189
1190
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1191
1192
Revisions are specified using a dirname/@revno pair, where dirname is the
1193
branch directory and revno is the revision within that branch. If no revno
1194
is specified, the latest revision is used.
1195
1196
Revision examples: './@127', 'foo/@', '../@1'
1197
1198
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1199
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1200
as the BASE.
1201
1202
merge refuses to run if there are any uncommitted changes, unless
1203
--force is given.
1204
"""
1205
takes_args = ['other_spec', 'base_spec?']
1206
takes_options = ['force']
1207
1208
def run(self, other_spec, base_spec=None, force=False):
1209
from bzrlib.merge import merge
1210
merge(parse_spec(other_spec), parse_spec(base_spec),
1211
check_clean=(not force))
1212
1213
1214
class cmd_revert(Command):
1215
"""Reverse all changes since the last commit.
1216
1217
Only versioned files are affected.
1218
1219
TODO: Store backups of any files that will be reverted, so
1220
that the revert can be undone.
1221
"""
1222
takes_options = ['revision']
1223
1224
def run(self, revision=-1):
1225
from bzrlib.merge import merge
1226
merge(('.', revision), parse_spec('.'),
1227
check_clean=False,
1228
ignore_zero=True)
1229
1230
1231
class cmd_assert_fail(Command):
1232
"""Test reporting of assertion failures"""
1233
hidden = True
1234
def run(self):
1235
assert False, "always fails"
1236
1237
1238
class cmd_help(Command):
1239
"""Show help on a command or other topic.
1240
1241
For a list of all available commands, say 'bzr help commands'."""
1242
takes_args = ['topic?']
1243
aliases = ['?']
1244
1245
def run(self, topic=None):
1246
import help
1247
help.help(topic)
1248
1249
1250
class cmd_update_stat_cache(Command):
1251
"""Update stat-cache mapping inodes to SHA-1 hashes.
1252
1253
For testing only."""
1254
hidden = True
1255
def run(self):
1256
import statcache
1257
b = Branch('.')
1258
statcache.update_cache(b.base, b.read_working_inventory())
1259
1260
1261
1262
# list of all available options; the rhs can be either None for an
1263
# option that takes no argument, or a constructor function that checks
1264
# the type.
1265
OPTIONS = {
1266
'all': None,
1267
'diff-options': str,
1268
'help': None,
1269
'file': unicode,
1270
'force': None,
1271
'forward': None,
1272
'message': unicode,
1273
'no-recurse': None,
1274
'profile': None,
1275
'revision': _parse_revision_str,
1276
'show-ids': None,
1277
'timezone': str,
1278
'verbose': None,
1279
'version': None,
1280
'email': None,
1281
}
1282
1283
SHORT_OPTIONS = {
1284
'F': 'file',
1285
'h': 'help',
1286
'm': 'message',
1287
'r': 'revision',
1288
'v': 'verbose',
1289
}
1290
1291
1292
def parse_args(argv):
290
1293
"""Parse command line.
291
1294
292
1295
Arguments and options are parsed at this level before being passed
293
1296
down to specific command handlers. This routine knows, from a
294
1297
lookup table, something about the available options, what optargs
295
1298
they take, and which commands will accept them.
1299
1300
>>> parse_args('--help'.split())
1301
([], {'help': True})
1302
>>> parse_args('--version'.split())
1303
([], {'version': True})
1304
>>> parse_args('status --all'.split())
1305
(['status'], {'all': True})
1306
>>> parse_args('commit --message=biter'.split())
1307
(['commit'], {'message': u'biter'})
296
1308
"""
297
# TODO: chop up this beast; make it a method of the Command
298
1309
args = []
299
1310
opts = {}
300
1311
301
cmd_options = command.options()
302
argsover = False
1312
# TODO: Maybe handle '--' to end options?
1313
303
1314
while argv:
304
1315
a = argv.pop(0)
305
if argsover:
306
args.append(a)
307
continue
308
elif a == '--':
309
# We've received a standalone -- No more flags
310
argsover = True
311
continue
312
1316
if a[0] == '-':
313
1317
# option names must not be unicode
314
1318
a = str(a)
315
1319
optarg = None
316
1320
if a[1] == '-':
317
mutter(" got option %r", a)
1321
mutter(" got option %r" % a)
318
1322
if '=' in a:
319
1323
optname, optarg = a[2:].split('=', 1)
320
1324
else:
321
1325
optname = a[2:]
322
if optname not in cmd_options:
323
raise BzrOptionError('unknown long option %r for command %s'
324
% (a, command.name()))
1326
if optname not in OPTIONS:
1327
bailout('unknown long option %r' % a)
325
1328
else:
326
1329
shortopt = a[1:]
327
if shortopt in Option.SHORT_OPTIONS:
328
# Multi-character options must have a space to delimit
329
# their value
330
# ^^^ what does this mean? mbp 20051014
331
optname = Option.SHORT_OPTIONS[shortopt].name
332
else:
333
# Single character short options, can be chained,
334
# and have their value appended to their name
335
shortopt = a[1:2]
336
if shortopt not in Option.SHORT_OPTIONS:
337
# We didn't find the multi-character name, and we
338
# didn't find the single char name
339
raise BzrError('unknown short option %r' % a)
340
optname = Option.SHORT_OPTIONS[shortopt].name
341
342
if a[2:]:
343
# There are extra things on this option
344
# see if it is the value, or if it is another
345
# short option
346
optargfn = Option.OPTIONS[optname].type
347
if optargfn is None:
348
# This option does not take an argument, so the
349
# next entry is another short option, pack it back
350
# into the list
351
argv.insert(0, '-' + a[2:])
352
else:
353
# This option takes an argument, so pack it
354
# into the array
355
optarg = a[2:]
1330
if shortopt not in SHORT_OPTIONS:
1331
bailout('unknown short option %r' % a)
1332
optname = SHORT_OPTIONS[shortopt]
356
1333
357
if optname not in cmd_options:
358
raise BzrOptionError('unknown short option %r for command'
359
' %s' % (shortopt, command.name()))
360
1334
if optname in opts:
361
1335
# XXX: Do we ever want to support this, e.g. for -r?
362
raise BzrError('repeated option %r' % a)
1336
bailout('repeated option %r' % a)
363
1337
364
option_obj = cmd_options[optname]
365
optargfn = option_obj.type
1338
optargfn = OPTIONS[optname]
366
1339
if optargfn:
367
1340
if optarg == None:
368
1341
if not argv:
369
raise BzrError('option %r needs an argument' % a)
1342
bailout('option %r needs an argument' % a)
370
1343
else:
371
1344
optarg = argv.pop(0)
372
1345
opts[optname] = optargfn(optarg)
373
1346
else:
374
1347
if optarg != None:
375
raise BzrError('option %r takes no argument' % optname)
1348
bailout('option %r takes no argument' % optname)
376
1349
opts[optname] = True
377
1350
else:
378
1351
args.append(a)
1352
379
1353
return args, opts
380
1354
381
1355
1356
1357
382
1358
def _match_argform(cmd, takes_args, args):
383
1359
argdict = {}
384
1360
424
1400
425
1401
426
1402
427
def apply_profiled(the_callable, *args, **kwargs):
428
import hotshot
429
import tempfile
430
import hotshot.stats
431
pffileno, pfname = tempfile.mkstemp()
432
try:
433
prof = hotshot.Profile(pfname)
434
try:
435
ret = prof.runcall(the_callable, *args, **kwargs) or 0
436
finally:
437
prof.close()
438
stats = hotshot.stats.load(pfname)
439
stats.strip_dirs()
440
stats.sort_stats('cum') # 'time'
441
## XXX: Might like to write to stderr or the trace file instead but
442
## print_stats seems hardcoded to stdout
443
stats.print_stats(20)
444
return ret
445
finally:
446
os.close(pffileno)
447
os.remove(pfname)
448
449
450
1403
def run_bzr(argv):
451
1404
"""Execute a command.
452
1405
453
1406
This is similar to main(), but without all the trappings for
454
1407
logging and error handling.
455
456
argv
457
The command-line arguments, without the program name from argv[0]
458
459
Returns a command status or raises an exception.
460
461
Special master options: these must come before the command because
462
they control how the command is interpreted.
463
464
--no-plugins
465
Do not load plugin modules at all
466
467
--builtin
468
Only use builtin commands. (Plugins are still allowed to change
469
other behaviour.)
470
471
--profile
472
Run under the Python profiler.
473
1408
"""
474
1409
argv = [a.decode(bzrlib.user_encoding) for a in argv]
475
476
opt_profile = opt_no_plugins = opt_builtin = False
477
478
# --no-plugins is handled specially at a very early stage. We need
479
# to load plugins before doing other command parsing so that they
480
# can override commands, but this needs to happen first.
481
482
for a in argv:
483
if a == '--profile':
484
opt_profile = True
485
elif a == '--no-plugins':
486
opt_no_plugins = True
487
elif a == '--builtin':
488
opt_builtin = True
489
elif a in ('--quiet', '-q'):
490
be_quiet()
491
else:
492
continue
493
argv.remove(a)
494
495
if (not argv) or (argv[0] == '--help'):
496
from bzrlib.help import help
497
if len(argv) > 1:
498
help(argv[1])
499
else:
500
help()
501
return 0
502
503
if argv[0] == '--version':
504
from bzrlib.builtins import show_version
505
show_version()
506
return 0
507
508
if not opt_no_plugins:
509
from bzrlib.plugin import load_plugins
510
load_plugins()
511
512
cmd = str(argv.pop(0))
513
514
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
515
1410
1411
include_plugins=True
516
1412
try:
517
if opt_profile:
518
ret = apply_profiled(cmd_obj.run_argv, argv)
519
else:
520
ret = cmd_obj.run_argv(argv)
521
return ret or 0
522
finally:
523
# reset, in case we may do other commands later within the same process
524
be_quiet(False)
525
526
def display_command(func):
527
"""Decorator that suppresses pipe/interrupt errors."""
528
def ignore_pipe(*args, **kwargs):
1413
args, opts = parse_args(argv[1:])
1414
if 'help' in opts:
1415
import help
1416
if args:
1417
help.help(args[0])
1418
else:
1419
help.help()
1420
return 0
1421
elif 'version' in opts:
1422
show_version()
1423
return 0
1424
elif args and args[0] == 'builtin':
1425
include_plugins=False
1426
args = args[1:]
1427
cmd = str(args.pop(0))
1428
except IndexError:
1429
import help
1430
help.help()
1431
return 1
1432
1433
1434
canonical_cmd, cmd_class = get_cmd_class(cmd,include_plugins=include_plugins)
1435
1436
# global option
1437
if 'profile' in opts:
1438
profile = True
1439
del opts['profile']
1440
else:
1441
profile = False
1442
1443
# check options are reasonable
1444
allowed = cmd_class.takes_options
1445
for oname in opts:
1446
if oname not in allowed:
1447
raise BzrCommandError("option '--%s' is not allowed for command %r"
1448
% (oname, cmd))
1449
1450
# mix arguments and options into one dictionary
1451
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1452
cmdopts = {}
1453
for k, v in opts.items():
1454
cmdopts[k.replace('-', '_')] = v
1455
1456
if profile:
1457
import hotshot, tempfile
1458
pffileno, pfname = tempfile.mkstemp()
529
1459
try:
530
result = func(*args, **kwargs)
531
sys.stdout.flush()
532
return result
533
except IOError, e:
534
if not hasattr(e, 'errno'):
535
raise
536
if e.errno != errno.EPIPE:
537
raise
538
pass
539
except KeyboardInterrupt:
540
pass
541
return ignore_pipe
1460
prof = hotshot.Profile(pfname)
1461
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1462
prof.close()
1463
1464
import hotshot.stats
1465
stats = hotshot.stats.load(pfname)
1466
#stats.strip_dirs()
1467
stats.sort_stats('time')
1468
## XXX: Might like to write to stderr or the trace file instead but
1469
## print_stats seems hardcoded to stdout
1470
stats.print_stats(20)
1471
1472
return ret.status
1473
1474
finally:
1475
os.close(pffileno)
1476
os.remove(pfname)
1477
else:
1478
return cmd_class(cmdopts, cmdargs).status
1479
1480
1481
def _report_exception(summary, quiet=False):
1482
import traceback
1483
log_error('bzr: ' + summary)
1484
bzrlib.trace.log_exception()
1485
1486
if not quiet:
1487
tb = sys.exc_info()[2]
1488
exinfo = traceback.extract_tb(tb)
1489
if exinfo:
1490
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1491
sys.stderr.write(' see ~/.bzr.log for debug information\n')
1492
542
1493
543
1494
544
1495
def main(argv):
545
import bzrlib.ui
546
from bzrlib.ui.text import TextUIFactory
547
## bzrlib.trace.enable_default_logging()
548
bzrlib.trace.log_startup(argv)
549
bzrlib.ui.ui_factory = TextUIFactory()
550
ret = run_bzr_catch_errors(argv[1:])
551
mutter("return code %d", ret)
552
return ret
553
554
555
def run_bzr_catch_errors(argv):
1496
import errno
1497
1498
bzrlib.open_tracefile(argv)
1499
556
1500
try:
557
1501
try:
558
return run_bzr(argv)
559
finally:
560
# do this here inside the exception wrappers to catch EPIPE
561
sys.stdout.flush()
562
except Exception, e:
563
# used to handle AssertionError and KeyboardInterrupt
564
# specially here, but hopefully they're handled ok by the logger now
565
import errno
566
if (isinstance(e, IOError)
567
and hasattr(e, 'errno')
568
and e.errno == errno.EPIPE):
569
bzrlib.trace.note('broken pipe')
570
return 3
571
else:
572
bzrlib.trace.log_exception()
573
if os.environ.get('BZR_PDB'):
574
print '**** entering debugger'
575
import pdb
576
pdb.post_mortem(sys.exc_traceback)
577
return 3
1502
try:
1503
return run_bzr(argv)
1504
finally:
1505
# do this here inside the exception wrappers to catch EPIPE
1506
sys.stdout.flush()
1507
except BzrError, e:
1508
quiet = isinstance(e, (BzrCommandError))
1509
_report_exception('error: ' + e.args[0], quiet=quiet)
1510
if len(e.args) > 1:
1511
for h in e.args[1]:
1512
# some explanation or hints
1513
log_error(' ' + h)
1514
return 1
1515
except AssertionError, e:
1516
msg = 'assertion failed'
1517
if str(e):
1518
msg += ': ' + str(e)
1519
_report_exception(msg)
1520
return 2
1521
except KeyboardInterrupt, e:
1522
_report_exception('interrupted', quiet=True)
1523
return 2
1524
except Exception, e:
1525
quiet = False
1526
if (isinstance(e, IOError)
1527
and hasattr(e, 'errno')
1528
and e.errno == errno.EPIPE):
1529
quiet = True
1530
msg = 'broken pipe'
1531
else:
1532
msg = str(e).rstrip('\n')
1533
_report_exception(msg, quiet)
1534
return 2
1535
finally:
1536
bzrlib.trace.close_trace()
1537
578
1538
579
1539
if __name__ == '__main__':
580
1540
sys.exit(main(sys.argv))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1