« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 1185.1.40
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.1.40
- Committer: Robert Collins
- Date: 2005-09-23 09:25:16 UTC
- mto: (1092.3.4)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: robertc@robertcollins.net-20050923092516-e2c3c0f31288669d
Merge what applied of Alexander Belchenko's win32 patch.
- files added:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files removed:
- bzrlib/statcache.py
- files renamed:
- bzrlib/selftest.py => bzrlib/selftest/__init__.py
- bzrlib/whitebox.py => bzrlib/selftest/whitebox.py
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/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
19
import sys, os
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
20
40
21
41
import bzrlib
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
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.revisionspec import RevisionSpec
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__])
27
65
28
66
29
67
def _squish_command_name(cmd):
34
72
assert cmd.startswith("cmd_")
35
73
return cmd[4:].replace('_','-')
36
74
75
37
76
def _parse_revision_str(revstr):
38
"""This handles a revision string -> revno.
39
40
There are several possibilities:
41
42
'234' -> 234
43
'234:345' -> [234, 345]
44
':234' -> [None, 234]
45
'234:' -> [234, None]
46
47
In the future we will also support:
48
'uuid:blah-blah-blah' -> ?
49
'hash:blahblahblah' -> ?
50
potentially:
51
'tag:mytag' -> ?
77
"""This handles a revision string -> revno.
78
79
This always returns a list. The list will have one element for
80
each revision.
81
82
>>> _parse_revision_str('234')
83
[<RevisionSpec_int 234>]
84
>>> _parse_revision_str('234..567')
85
[<RevisionSpec_int 234>, <RevisionSpec_int 567>]
86
>>> _parse_revision_str('..')
87
[<RevisionSpec None>, <RevisionSpec None>]
88
>>> _parse_revision_str('..234')
89
[<RevisionSpec None>, <RevisionSpec_int 234>]
90
>>> _parse_revision_str('234..')
91
[<RevisionSpec_int 234>, <RevisionSpec None>]
92
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
93
[<RevisionSpec_int 234>, <RevisionSpec_int 456>, <RevisionSpec_int 789>]
94
>>> _parse_revision_str('234....789') # Error?
95
[<RevisionSpec_int 234>, <RevisionSpec None>, <RevisionSpec_int 789>]
96
>>> _parse_revision_str('revid:test@other.com-234234')
97
[<RevisionSpec_revid revid:test@other.com-234234>]
98
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
99
[<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_revid revid:test@other.com-234235>]
100
>>> _parse_revision_str('revid:test@other.com-234234..23')
101
[<RevisionSpec_revid revid:test@other.com-234234>, <RevisionSpec_int 23>]
102
>>> _parse_revision_str('date:2005-04-12')
103
[<RevisionSpec_date date:2005-04-12>]
104
>>> _parse_revision_str('date:2005-04-12 12:24:33')
105
[<RevisionSpec_date date:2005-04-12 12:24:33>]
106
>>> _parse_revision_str('date:2005-04-12T12:24:33')
107
[<RevisionSpec_date date:2005-04-12T12:24:33>]
108
>>> _parse_revision_str('date:2005-04-12,12:24:33')
109
[<RevisionSpec_date date:2005-04-12,12:24:33>]
110
>>> _parse_revision_str('-5..23')
111
[<RevisionSpec_int -5>, <RevisionSpec_int 23>]
112
>>> _parse_revision_str('-5')
113
[<RevisionSpec_int -5>]
114
>>> _parse_revision_str('123a')
115
Traceback (most recent call last):
116
...
117
BzrError: No namespace registered for string: '123a'
118
>>> _parse_revision_str('abc')
119
Traceback (most recent call last):
120
...
121
BzrError: No namespace registered for string: 'abc'
52
122
"""
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])
123
import re
124
old_format_re = re.compile('\d*:\d*')
125
m = old_format_re.match(revstr)
126
revs = []
127
if m:
128
warning('Colon separator for revision numbers is deprecated.'
129
' Use .. instead')
130
for rev in revstr.split(':'):
131
if rev:
132
revs.append(RevisionSpec(int(rev)))
133
else:
134
revs.append(RevisionSpec(None))
67
135
else:
68
revs = int(revstr)
136
for x in revstr.split('..'):
137
if not x:
138
revs.append(RevisionSpec(None))
139
else:
140
revs.append(RevisionSpec(x))
69
141
return revs
70
142
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.
143
144
def get_merge_type(typestring):
145
"""Attempt to find the merge class/factory associated with a string."""
146
from merge import merge_types
147
try:
148
return merge_types[typestring][0]
149
except KeyError:
150
templ = '%s%%7s: %%s' % (' '*12)
151
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
152
type_list = '\n'.join(lines)
153
msg = "No known merge type %s. Supported types are:\n%s" %\
154
(typestring, type_list)
155
raise BzrCommandError(msg)
156
157
158
def _builtin_commands():
159
import bzrlib.builtins
160
r = {}
161
builtins = bzrlib.builtins.__dict__
162
for name in builtins:
163
if name.startswith("cmd_"):
164
real_name = _unsquish_command_name(name)
165
r[real_name] = builtins[name]
166
return r
167
168
169
170
def builtin_command_names():
171
"""Return list of builtin command names."""
172
return _builtin_commands().keys()
79
173
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())
174
175
def plugin_command_names():
176
return plugin_cmds.keys()
177
178
179
def _get_cmd_dict(plugins_override=True):
180
"""Return name->class mapping for all commands."""
181
d = _builtin_commands()
182
if plugins_override:
183
d.update(plugin_cmds)
150
184
return d
185
151
186
152
def get_all_cmds(include_plugins=True):
187
def get_all_cmds(plugins_override=True):
153
188
"""Return canonical name and class for all registered commands."""
154
for k, v in _get_cmd_dict(include_plugins=include_plugins).iteritems():
189
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
155
190
yield k,v
156
191
157
192
158
def get_cmd_class(cmd,include_plugins=True):
193
def get_cmd_object(cmd_name, plugins_override=True):
159
194
"""Return the canonical name and command class for a command.
195
196
plugins_override
197
If true, plugin commands can override builtins.
160
198
"""
161
cmd = str(cmd) # not unicode
199
from bzrlib.externalcommand import ExternalCommand
200
201
cmd_name = str(cmd_name) # not unicode
162
202
163
203
# first look up this command under the specified name
164
cmds = _get_cmd_dict(include_plugins=include_plugins)
204
cmds = _get_cmd_dict(plugins_override=plugins_override)
165
205
try:
166
return cmd, cmds[cmd]
206
return cmds[cmd_name]()
167
207
except KeyError:
168
208
pass
169
209
170
210
# look for any command which claims this as an alias
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)
211
for real_cmd_name, cmd_class in cmds.iteritems():
212
if cmd_name in cmd_class.aliases:
213
return cmd_class()
214
215
cmd_obj = ExternalCommand.find_command(cmd_name)
216
if cmd_obj:
217
return cmd_obj
218
219
raise BzrCommandError("unknown command %r" % cmd_name)
180
220
181
221
182
222
class Command(object):
183
223
"""Base class for commands.
184
224
225
Commands are the heart of the command-line bzr interface.
226
227
The command object mostly handles the mapping of command-line
228
parameters into one or more bzrlib operations, and of the results
229
into textual output.
230
231
Commands normally don't have any state. All their arguments are
232
passed in to the run method. (Subclasses may take a different
233
policy if the behaviour of the instance needs to depend on e.g. a
234
shell plugin and not just its Python class.)
235
185
236
The docstring for an actual command should give a single-line
186
237
summary, then a complete description of the command. A grammar
187
238
description will be inserted.
188
239
240
aliases
241
Other accepted names for this command.
242
189
243
takes_args
190
244
List of argument forms, marked with whether they are optional,
191
245
repeated, etc.
194
248
List of options that may be given for this command.
195
249
196
250
hidden
197
If true, this command isn't advertised.
251
If true, this command isn't advertised. This is typically
252
for commands intended for expert users.
198
253
"""
199
254
aliases = []
200
255
203
258
204
259
hidden = False
205
260
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)
261
def __init__(self):
262
"""Construct an instance of this command."""
263
if self.__doc__ == Command.__doc__:
264
warn("No help message set for %r" % self)
265
266
267
def run_argv(self, argv):
268
"""Parse command line and run."""
269
args, opts = parse_args(argv)
270
271
if 'help' in opts: # e.g. bzr add --help
272
from bzrlib.help import help_on_command
273
help_on_command(self.name())
274
return 0
275
276
# check options are reasonable
277
allowed = self.takes_options
278
for oname in opts:
279
if oname not in allowed:
280
raise BzrCommandError("option '--%s' is not allowed for command %r"
281
% (oname, self.name()))
282
283
# mix arguments and options into one dictionary
284
cmdargs = _match_argform(self.name(), self.takes_args, args)
285
cmdopts = {}
286
for k, v in opts.items():
287
cmdopts[k.replace('-', '_')] = v
288
289
all_cmd_args = cmdargs.copy()
290
all_cmd_args.update(cmdopts)
291
292
return self.run(**all_cmd_args)
217
293
218
294
219
295
def run(self):
220
"""Override this in sub-classes.
296
"""Actually run the command.
221
297
222
298
This is invoked with the options and arguments bound to
223
299
keyword parameters.
224
300
225
Return 0 or None if the command was successful, or a shell
226
error code if not.
301
Return 0 or None if the command was successful, or a non-zero
302
shell error code if not. It's OK for this method to allow
303
an exception to raise up.
227
304
"""
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
bailout("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
bailout("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
bailout("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
bailout("%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
bailout("%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!"
305
raise NotImplementedError()
306
307
308
def help(self):
309
"""Return help message for this class."""
310
if self.__doc__ is Command.__doc__:
311
return None
312
return getdoc(self)
313
314
def name(self):
315
return _unsquish_command_name(self.__class__.__name__)
316
1180
317
1181
318
def parse_spec(spec):
1182
319
"""
1188
325
['..', -1]
1189
326
>>> parse_spec("../f/@35")
1190
327
['../f', 35]
328
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
329
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1191
330
"""
1192
331
if spec is None:
1193
332
return [None, None]
1197
336
if parsed[1] == "":
1198
337
parsed[1] = -1
1199
338
else:
1200
parsed[1] = int(parsed[1])
1201
assert parsed[1] >=0
339
try:
340
parsed[1] = int(parsed[1])
341
except ValueError:
342
pass # We can allow stuff like ./@revid:blahblahblah
343
else:
344
assert parsed[1] >=0
1202
345
else:
1203
346
parsed = [spec, None]
1204
347
return parsed
1205
348
1206
349
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
1286
1287
350
# list of all available options; the rhs can be either None for an
1288
351
# option that takes no argument, or a constructor function that checks
1289
352
# the type.
1299
362
'no-recurse': None,
1300
363
'profile': None,
1301
364
'revision': _parse_revision_str,
365
'short': None,
1302
366
'show-ids': None,
1303
367
'timezone': str,
1304
368
'verbose': None,
1305
369
'version': None,
1306
370
'email': None,
371
'unchanged': None,
1307
372
'update': None,
373
'long': None,
374
'root': str,
375
'no-backup': None,
376
'merge-type': get_merge_type,
377
'pattern': str,
1308
378
}
1309
379
1310
380
SHORT_OPTIONS = {
1313
383
'm': 'message',
1314
384
'r': 'revision',
1315
385
'v': 'verbose',
386
'l': 'long',
1316
387
}
1317
388
1318
389
1326
397
1327
398
>>> parse_args('--help'.split())
1328
399
([], {'help': True})
400
>>> parse_args('help -- --invalidcmd'.split())
401
(['help', '--invalidcmd'], {})
1329
402
>>> parse_args('--version'.split())
1330
403
([], {'version': True})
1331
404
>>> parse_args('status --all'.split())
1333
406
>>> parse_args('commit --message=biter'.split())
1334
407
(['commit'], {'message': u'biter'})
1335
408
>>> parse_args('log -r 500'.split())
1336
(['log'], {'revision': 500})
1337
>>> parse_args('log -r500:600'.split())
1338
(['log'], {'revision': [500, 600]})
1339
>>> parse_args('log -vr500:600'.split())
1340
(['log'], {'verbose': True, 'revision': [500, 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
409
(['log'], {'revision': [<RevisionSpec_int 500>]})
410
>>> parse_args('log -r500..600'.split())
411
(['log'], {'revision': [<RevisionSpec_int 500>, <RevisionSpec_int 600>]})
412
>>> parse_args('log -vr500..600'.split())
413
(['log'], {'verbose': True, 'revision': [<RevisionSpec_int 500>, <RevisionSpec_int 600>]})
414
>>> parse_args('log -rrevno:500..600'.split()) #the r takes an argument
415
(['log'], {'revision': [<RevisionSpec_revno revno:500>, <RevisionSpec_int 600>]})
1345
416
"""
1346
417
args = []
1347
418
opts = {}
1348
419
1349
# TODO: Maybe handle '--' to end options?
1350
420
argsover = False
1351
421
while argv:
1352
422
a = argv.pop(0)
1353
if a[0] == '-':
423
if not argsover and a[0] == '-':
1354
424
# option names must not be unicode
1355
425
a = str(a)
1356
426
optarg = None
1357
427
if a[1] == '-':
428
if a == '--':
429
# We've received a standalone -- No more flags
430
argsover = True
431
continue
1358
432
mutter(" got option %r" % a)
1359
433
if '=' in a:
1360
434
optname, optarg = a[2:].split('=', 1)
1361
435
else:
1362
436
optname = a[2:]
1363
437
if optname not in OPTIONS:
1364
bailout('unknown long option %r' % a)
438
raise BzrError('unknown long option %r' % a)
1365
439
else:
1366
440
shortopt = a[1:]
1367
441
if shortopt in SHORT_OPTIONS:
1375
449
if shortopt not in SHORT_OPTIONS:
1376
450
# We didn't find the multi-character name, and we
1377
451
# didn't find the single char name
1378
bailout('unknown short option %r' % a)
452
raise BzrError('unknown short option %r' % a)
1379
453
optname = SHORT_OPTIONS[shortopt]
1380
454
1381
455
if a[2:]:
1395
469
1396
470
if optname in opts:
1397
471
# XXX: Do we ever want to support this, e.g. for -r?
1398
bailout('repeated option %r' % a)
472
raise BzrError('repeated option %r' % a)
1399
473
1400
474
optargfn = OPTIONS[optname]
1401
475
if optargfn:
1402
476
if optarg == None:
1403
477
if not argv:
1404
bailout('option %r needs an argument' % a)
478
raise BzrError('option %r needs an argument' % a)
1405
479
else:
1406
480
optarg = argv.pop(0)
1407
481
opts[optname] = optargfn(optarg)
1408
482
else:
1409
483
if optarg != None:
1410
bailout('option %r takes no argument' % optname)
484
raise BzrError('option %r takes no argument' % optname)
1411
485
opts[optname] = True
1412
486
else:
1413
487
args.append(a)
1462
536
1463
537
1464
538
539
def apply_profiled(the_callable, *args, **kwargs):
540
import hotshot
541
import tempfile
542
pffileno, pfname = tempfile.mkstemp()
543
try:
544
prof = hotshot.Profile(pfname)
545
try:
546
ret = prof.runcall(the_callable, *args, **kwargs) or 0
547
finally:
548
prof.close()
549
550
import hotshot.stats
551
stats = hotshot.stats.load(pfname)
552
#stats.strip_dirs()
553
stats.sort_stats('time')
554
## XXX: Might like to write to stderr or the trace file instead but
555
## print_stats seems hardcoded to stdout
556
stats.print_stats(20)
557
558
return ret
559
finally:
560
os.close(pffileno)
561
os.remove(pfname)
562
563
1465
564
def run_bzr(argv):
1466
565
"""Execute a command.
1467
566
1468
567
This is similar to main(), but without all the trappings for
1469
568
logging and error handling.
569
570
argv
571
The command-line arguments, without the program name from argv[0]
572
573
Returns a command status or raises an exception.
574
575
Special master options: these must come before the command because
576
they control how the command is interpreted.
577
578
--no-plugins
579
Do not load plugin modules at all
580
581
--builtin
582
Only use builtin commands. (Plugins are still allowed to change
583
other behaviour.)
584
585
--profile
586
Run under the Python profiler.
1470
587
"""
588
1471
589
argv = [a.decode(bzrlib.user_encoding) for a in argv]
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
590
591
opt_profile = opt_no_plugins = opt_builtin = False
592
593
# --no-plugins is handled specially at a very early stage. We need
594
# to load plugins before doing other command parsing so that they
595
# can override commands, but this needs to happen first.
596
597
for a in argv:
598
if a == '--profile':
599
opt_profile = True
600
elif a == '--no-plugins':
601
opt_no_plugins = True
602
elif a == '--builtin':
603
opt_builtin = True
604
else:
605
break
606
argv.remove(a)
607
608
if (not argv) or (argv[0] == '--help'):
609
from bzrlib.help import help
610
if len(argv) > 1:
611
help(argv[1])
612
else:
613
help()
614
return 0
615
616
if argv[0] == '--version':
617
from bzrlib.builtins import show_version
618
show_version()
619
return 0
620
621
if not opt_no_plugins:
622
from bzrlib.plugin import load_plugins
623
load_plugins()
624
625
cmd = str(argv.pop(0))
626
627
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
628
629
if opt_profile:
630
ret = apply_profiled(cmd_obj.run_argv, argv)
631
else:
632
ret = cmd_obj.run_argv(argv)
633
return ret or 0
1555
634
1556
635
1557
636
def main(argv):
1558
import errno
1559
1560
bzrlib.open_tracefile(argv)
1561
637
import bzrlib.ui
638
bzrlib.trace.log_startup(argv)
639
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
640
641
return run_bzr_catch_errors(argv[1:])
642
643
644
def run_bzr_catch_errors(argv):
1562
645
try:
1563
646
try:
1564
647
try:
1566
649
finally:
1567
650
# do this here inside the exception wrappers to catch EPIPE
1568
651
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()
652
#wrap common errors as CommandErrors.
653
except (NotBranchError,), e:
654
raise BzrCommandError(str(e))
655
except BzrCommandError, e:
656
# command line syntax error, etc
657
log_error(str(e))
658
return 1
659
except BzrError, e:
660
bzrlib.trace.log_exception()
661
return 1
662
except AssertionError, e:
663
bzrlib.trace.log_exception('assertion failed: ' + str(e))
664
return 3
665
except KeyboardInterrupt, e:
666
bzrlib.trace.note('interrupted')
667
return 2
668
except Exception, e:
669
import errno
670
if (isinstance(e, IOError)
671
and hasattr(e, 'errno')
672
and e.errno == errno.EPIPE):
673
bzrlib.trace.note('broken pipe')
674
return 2
675
else:
676
bzrlib.trace.log_exception()
677
return 2
1599
678
1600
679
1601
680
if __name__ == '__main__':
Loggerhead is a web-based interface for Breezy
Version: 2.0.1