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