« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 641
- compare with another revision
- download diff
- download tarball
- view history from revision 641
- Committer: Martin Pool
- Date: 2005-06-10 02:21:14 UTC
- Revision ID: mbp@sourcefrog.net-20050610022114-8f49c9244a5b8e2f
- improved external-command patch from john
- 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:
- 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
# TODO: Help messages for options.
29
30
# TODO: Define arguments by objects, rather than just using names.
31
# Those objects can specify the expected type of the argument, which
32
# would help with validation and shell completion.
33
34
35
36
import sys
37
import os
38
from warnings import warn
39
from inspect import getdoc
18
19
import sys, os
40
20
41
21
import bzrlib
42
import bzrlib.trace
43
from bzrlib.trace import mutter, note, log_error, warning
44
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
45
from bzrlib.branch import find_branch
46
from bzrlib import BZRDIR
47
48
plugin_cmds = {}
49
50
51
def register_command(cmd):
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
else:
63
log_error('Two plugins defined the same command: %r' % k)
64
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
65
27
66
28
67
29
def _squish_command_name(cmd):
72
34
assert cmd.startswith("cmd_")
73
35
return cmd[4:].replace('_','-')
74
36
75
76
37
def _parse_revision_str(revstr):
77
"""This handles a revision string -> revno.
78
79
This always returns a list. The list will have one element for
80
81
It supports integers directly, but everything else it
82
defers for passing to Branch.get_revision_info()
83
84
>>> _parse_revision_str('234')
85
[234]
86
>>> _parse_revision_str('234..567')
87
[234, 567]
88
>>> _parse_revision_str('..')
89
[None, None]
90
>>> _parse_revision_str('..234')
91
[None, 234]
92
>>> _parse_revision_str('234..')
93
[234, None]
94
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
95
[234, 456, 789]
96
>>> _parse_revision_str('234....789') # Error?
97
[234, None, 789]
98
>>> _parse_revision_str('revid:test@other.com-234234')
99
['revid:test@other.com-234234']
100
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
101
['revid:test@other.com-234234', 'revid:test@other.com-234235']
102
>>> _parse_revision_str('revid:test@other.com-234234..23')
103
['revid:test@other.com-234234', 23]
104
>>> _parse_revision_str('date:2005-04-12')
105
['date:2005-04-12']
106
>>> _parse_revision_str('date:2005-04-12 12:24:33')
107
['date:2005-04-12 12:24:33']
108
>>> _parse_revision_str('date:2005-04-12T12:24:33')
109
['date:2005-04-12T12:24:33']
110
>>> _parse_revision_str('date:2005-04-12,12:24:33')
111
['date:2005-04-12,12:24:33']
112
>>> _parse_revision_str('-5..23')
113
[-5, 23]
114
>>> _parse_revision_str('-5')
115
[-5]
116
>>> _parse_revision_str('123a')
117
['123a']
118
>>> _parse_revision_str('abc')
119
['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' -> ?
120
52
"""
121
import re
122
old_format_re = re.compile('\d*:\d*')
123
m = old_format_re.match(revstr)
124
if m:
125
warning('Colon separator for revision numbers is deprecated.'
126
' Use .. instead')
127
revs = []
128
for rev in revstr.split(':'):
129
if rev:
130
revs.append(int(rev))
131
else:
132
revs.append(None)
133
return revs
134
revs = []
135
for x in revstr.split('..'):
136
if not x:
137
revs.append(None)
138
else:
139
try:
140
revs.append(int(x))
141
except ValueError:
142
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)
143
69
return revs
144
70
145
146
def get_merge_type(typestring):
147
"""Attempt to find the merge class/factory associated with a string."""
148
from merge import merge_types
149
try:
150
return merge_types[typestring][0]
151
except KeyError:
152
templ = '%s%%7s: %%s' % (' '*12)
153
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
154
type_list = '\n'.join(lines)
155
msg = "No known merge type %s. Supported types are:\n%s" %\
156
(typestring, type_list)
157
raise BzrCommandError(msg)
158
159
160
def _builtin_commands():
161
import bzrlib.builtins
162
r = {}
163
builtins = bzrlib.builtins.__dict__
164
for name in builtins:
165
if name.startswith("cmd_"):
166
real_name = _unsquish_command_name(name)
167
r[real_name] = builtins[name]
168
return r
169
170
171
172
def builtin_command_names():
173
"""Return list of builtin command names."""
174
return _builtin_commands().keys()
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.
175
79
176
177
def plugin_command_names():
178
return plugin_cmds.keys()
179
180
181
def _get_cmd_dict(plugins_override=True):
182
"""Return name->class mapping for all commands."""
183
d = _builtin_commands()
184
if plugins_override:
185
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())
186
150
return d
187
188
151
189
def get_all_cmds(plugins_override=True):
152
def get_all_cmds(include_plugins=True):
190
153
"""Return canonical name and class for all registered commands."""
191
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():
192
155
yield k,v
193
156
194
157
195
def get_cmd_object(cmd_name, plugins_override=True):
158
def get_cmd_class(cmd,include_plugins=True):
196
159
"""Return the canonical name and command class for a command.
197
198
plugins_override
199
If true, plugin commands can override builtins.
200
160
"""
201
from bzrlib.externalcommand import ExternalCommand
202
203
cmd_name = str(cmd_name) # not unicode
161
cmd = str(cmd) # not unicode
204
162
205
163
# first look up this command under the specified name
206
cmds = _get_cmd_dict(plugins_override=plugins_override)
164
cmds = _get_cmd_dict(include_plugins=include_plugins)
207
165
try:
208
return cmds[cmd_name]()
166
return cmd, cmds[cmd]
209
167
except KeyError:
210
168
pass
211
169
212
170
# look for any command which claims this as an alias
213
for real_cmd_name, cmd_class in cmds.iteritems():
214
if cmd_name in cmd_class.aliases:
215
return cmd_class()
216
217
cmd_obj = ExternalCommand.find_command(cmd_name)
218
if cmd_obj:
219
return cmd_obj
220
221
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)
222
180
223
181
224
182
class Command(object):
225
183
"""Base class for commands.
226
184
227
Commands are the heart of the command-line bzr interface.
228
229
The command object mostly handles the mapping of command-line
230
parameters into one or more bzrlib operations, and of the results
231
into textual output.
232
233
Commands normally don't have any state. All their arguments are
234
passed in to the run method. (Subclasses may take a different
235
policy if the behaviour of the instance needs to depend on e.g. a
236
shell plugin and not just its Python class.)
237
238
185
The docstring for an actual command should give a single-line
239
186
summary, then a complete description of the command. A grammar
240
187
description will be inserted.
241
188
242
aliases
243
Other accepted names for this command.
244
245
189
takes_args
246
190
List of argument forms, marked with whether they are optional,
247
191
repeated, etc.
250
194
List of options that may be given for this command.
251
195
252
196
hidden
253
If true, this command isn't advertised. This is typically
254
for commands intended for expert users.
197
If true, this command isn't advertised.
255
198
"""
256
199
aliases = []
257
200
260
203
261
204
hidden = False
262
205
263
def __init__(self):
264
"""Construct an instance of this command."""
265
if self.__doc__ == Command.__doc__:
266
warn("No help message set for %r" % self)
267
268
269
def run_argv(self, argv):
270
"""Parse command line and run."""
271
args, opts = parse_args(argv)
272
273
if 'help' in opts: # e.g. bzr add --help
274
from bzrlib.help import help_on_command
275
help_on_command(self.name())
276
return 0
277
278
# check options are reasonable
279
allowed = self.takes_options
280
for oname in opts:
281
if oname not in allowed:
282
raise BzrCommandError("option '--%s' is not allowed for command %r"
283
% (oname, self.name()))
284
285
# mix arguments and options into one dictionary
286
cmdargs = _match_argform(self.name(), self.takes_args, args)
287
cmdopts = {}
288
for k, v in opts.items():
289
cmdopts[k.replace('-', '_')] = v
290
291
all_cmd_args = cmdargs.copy()
292
all_cmd_args.update(cmdopts)
293
294
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)
295
217
296
218
297
219
def run(self):
298
"""Actually run the command.
220
"""Override this in sub-classes.
299
221
300
222
This is invoked with the options and arguments bound to
301
223
keyword parameters.
302
224
303
Return 0 or None if the command was successful, or a non-zero
304
shell error code if not. It's OK for this method to allow
305
an exception to raise up.
225
Return 0 or None if the command was successful, or a shell
226
error code if not.
306
227
"""
307
raise NotImplementedError()
308
309
310
def help(self):
311
"""Return help message for this class."""
312
if self.__doc__ is Command.__doc__:
313
return None
314
return getdoc(self)
315
316
def name(self):
317
return _unsquish_command_name(self.__class__.__name__)
318
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!"
319
1155
320
1156
def parse_spec(spec):
321
1157
"""
327
1163
['..', -1]
328
1164
>>> parse_spec("../f/@35")
329
1165
['../f', 35]
330
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
331
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
332
1166
"""
333
1167
if spec is None:
334
1168
return [None, None]
338
1172
if parsed[1] == "":
339
1173
parsed[1] = -1
340
1174
else:
341
try:
342
parsed[1] = int(parsed[1])
343
except ValueError:
344
pass # We can allow stuff like ./@revid:blahblahblah
345
else:
346
assert parsed[1] >=0
1175
parsed[1] = int(parsed[1])
1176
assert parsed[1] >=0
347
1177
else:
348
1178
parsed = [spec, None]
349
1179
return parsed
350
1180
351
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
352
1262
# list of all available options; the rhs can be either None for an
353
1263
# option that takes no argument, or a constructor function that checks
354
1264
# the type.
358
1268
'help': None,
359
1269
'file': unicode,
360
1270
'force': None,
361
'format': unicode,
362
1271
'forward': None,
363
1272
'message': unicode,
364
1273
'no-recurse': None,
365
1274
'profile': None,
366
1275
'revision': _parse_revision_str,
367
'short': None,
368
1276
'show-ids': None,
369
1277
'timezone': str,
370
1278
'verbose': None,
371
1279
'version': None,
372
1280
'email': None,
373
'unchanged': None,
374
'update': None,
375
'long': None,
376
'root': str,
377
'no-backup': None,
378
'merge-type': get_merge_type,
379
'pattern': str,
380
1281
}
381
1282
382
1283
SHORT_OPTIONS = {
385
1286
'm': 'message',
386
1287
'r': 'revision',
387
1288
'v': 'verbose',
388
'l': 'long',
389
1289
}
390
1290
391
1291
399
1299
400
1300
>>> parse_args('--help'.split())
401
1301
([], {'help': True})
402
>>> parse_args('help -- --invalidcmd'.split())
403
(['help', '--invalidcmd'], {})
404
1302
>>> parse_args('--version'.split())
405
1303
([], {'version': True})
406
1304
>>> parse_args('status --all'.split())
407
1305
(['status'], {'all': True})
408
1306
>>> parse_args('commit --message=biter'.split())
409
1307
(['commit'], {'message': u'biter'})
410
>>> parse_args('log -r 500'.split())
411
(['log'], {'revision': [500]})
412
>>> parse_args('log -r500..600'.split())
413
(['log'], {'revision': [500, 600]})
414
>>> parse_args('log -vr500..600'.split())
415
(['log'], {'verbose': True, 'revision': [500, 600]})
416
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
417
(['log'], {'revision': ['v500', 600]})
418
1308
"""
419
1309
args = []
420
1310
opts = {}
421
1311
422
argsover = False
1312
# TODO: Maybe handle '--' to end options?
1313
423
1314
while argv:
424
1315
a = argv.pop(0)
425
if not argsover and a[0] == '-':
1316
if a[0] == '-':
426
1317
# option names must not be unicode
427
1318
a = str(a)
428
1319
optarg = None
429
1320
if a[1] == '-':
430
if a == '--':
431
# We've received a standalone -- No more flags
432
argsover = True
433
continue
434
1321
mutter(" got option %r" % a)
435
1322
if '=' in a:
436
1323
optname, optarg = a[2:].split('=', 1)
437
1324
else:
438
1325
optname = a[2:]
439
1326
if optname not in OPTIONS:
440
raise BzrError('unknown long option %r' % a)
1327
bailout('unknown long option %r' % a)
441
1328
else:
442
1329
shortopt = a[1:]
443
if shortopt in SHORT_OPTIONS:
444
# Multi-character options must have a space to delimit
445
# their value
446
optname = SHORT_OPTIONS[shortopt]
447
else:
448
# Single character short options, can be chained,
449
# and have their value appended to their name
450
shortopt = a[1:2]
451
if shortopt not in SHORT_OPTIONS:
452
# We didn't find the multi-character name, and we
453
# didn't find the single char name
454
raise BzrError('unknown short option %r' % a)
455
optname = SHORT_OPTIONS[shortopt]
456
457
if a[2:]:
458
# There are extra things on this option
459
# see if it is the value, or if it is another
460
# short option
461
optargfn = OPTIONS[optname]
462
if optargfn is None:
463
# This option does not take an argument, so the
464
# next entry is another short option, pack it back
465
# into the list
466
argv.insert(0, '-' + a[2:])
467
else:
468
# This option takes an argument, so pack it
469
# into the array
470
optarg = a[2:]
1330
if shortopt not in SHORT_OPTIONS:
1331
bailout('unknown short option %r' % a)
1332
optname = SHORT_OPTIONS[shortopt]
471
1333
472
1334
if optname in opts:
473
1335
# XXX: Do we ever want to support this, e.g. for -r?
474
raise BzrError('repeated option %r' % a)
1336
bailout('repeated option %r' % a)
475
1337
476
1338
optargfn = OPTIONS[optname]
477
1339
if optargfn:
478
1340
if optarg == None:
479
1341
if not argv:
480
raise BzrError('option %r needs an argument' % a)
1342
bailout('option %r needs an argument' % a)
481
1343
else:
482
1344
optarg = argv.pop(0)
483
1345
opts[optname] = optargfn(optarg)
484
1346
else:
485
1347
if optarg != None:
486
raise BzrError('option %r takes no argument' % optname)
1348
bailout('option %r takes no argument' % optname)
487
1349
opts[optname] = True
488
1350
else:
489
1351
args.append(a)
538
1400
539
1401
540
1402
541
def apply_profiled(the_callable, *args, **kwargs):
542
import hotshot
543
import tempfile
544
pffileno, pfname = tempfile.mkstemp()
545
try:
546
prof = hotshot.Profile(pfname)
547
try:
548
ret = prof.runcall(the_callable, *args, **kwargs) or 0
549
finally:
550
prof.close()
551
552
import hotshot.stats
553
stats = hotshot.stats.load(pfname)
554
#stats.strip_dirs()
555
stats.sort_stats('time')
556
## XXX: Might like to write to stderr or the trace file instead but
557
## print_stats seems hardcoded to stdout
558
stats.print_stats(20)
559
560
return ret
561
finally:
562
os.close(pffileno)
563
os.remove(pfname)
564
565
566
1403
def run_bzr(argv):
567
1404
"""Execute a command.
568
1405
569
1406
This is similar to main(), but without all the trappings for
570
1407
logging and error handling.
571
572
argv
573
The command-line arguments, without the program name from argv[0]
574
575
Returns a command status or raises an exception.
576
577
Special master options: these must come before the command because
578
they control how the command is interpreted.
579
580
--no-plugins
581
Do not load plugin modules at all
582
583
--builtin
584
Only use builtin commands. (Plugins are still allowed to change
585
other behaviour.)
586
587
--profile
588
Run under the Python profiler.
589
1408
"""
590
591
1409
argv = [a.decode(bzrlib.user_encoding) for a in argv]
592
593
opt_profile = opt_no_plugins = opt_builtin = False
594
595
# --no-plugins is handled specially at a very early stage. We need
596
# to load plugins before doing other command parsing so that they
597
# can override commands, but this needs to happen first.
598
599
for a in argv:
600
if a == '--profile':
601
opt_profile = True
602
elif a == '--no-plugins':
603
opt_no_plugins = True
604
elif a == '--builtin':
605
opt_builtin = True
606
else:
607
break
608
argv.remove(a)
609
610
if (not argv) or (argv[0] == '--help'):
611
from bzrlib.help import help
612
if len(argv) > 1:
613
help(argv[1])
614
else:
615
help()
616
return 0
617
618
if argv[0] == '--version':
619
from bzrlib.builtins import show_version
620
show_version()
621
return 0
622
623
if not opt_no_plugins:
624
from bzrlib.plugin import load_plugins
625
load_plugins()
626
627
cmd = str(argv.pop(0))
628
629
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
630
631
if opt_profile:
632
ret = apply_profiled(cmd_obj.run_argv, argv)
633
else:
634
ret = cmd_obj.run_argv(argv)
635
return ret or 0
1410
1411
include_plugins=True
1412
try:
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()
1459
try:
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
636
1493
637
1494
638
1495
def main(argv):
639
import bzrlib.ui
640
bzrlib.trace.log_startup(argv)
641
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
1496
import errno
1497
1498
bzrlib.open_tracefile(argv)
642
1499
643
1500
try:
644
1501
try:
645
1502
try:
646
return run_bzr(argv[1:])
1503
return run_bzr(argv)
647
1504
finally:
648
1505
# do this here inside the exception wrappers to catch EPIPE
649
1506
sys.stdout.flush()
650
#wrap common errors as CommandErrors.
651
except (NotBranchError,), e:
652
raise BzrCommandError(str(e))
653
except BzrCommandError, e:
654
# command line syntax error, etc
655
log_error(str(e))
656
return 1
657
except BzrError, e:
658
bzrlib.trace.log_exception()
659
return 1
660
except AssertionError, e:
661
bzrlib.trace.log_exception('assertion failed: ' + str(e))
662
return 3
663
except KeyboardInterrupt, e:
664
bzrlib.trace.note('interrupted')
665
return 2
666
except Exception, e:
667
import errno
668
if (isinstance(e, IOError)
669
and hasattr(e, 'errno')
670
and e.errno == errno.EPIPE):
671
bzrlib.trace.note('broken pipe')
672
return 2
673
else:
674
bzrlib.trace.log_exception()
675
return 2
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()
676
1537
677
1538
678
1539
if __name__ == '__main__':
Loggerhead is a web-based interface for Breezy
Version: 2.0.1