« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 690
- compare with another revision
- download diff
- download tarball
- view history from revision 690
- Committer: Martin Pool
- Date: 2005-06-15 04:24:01 UTC
- Revision ID: mbp@sourcefrog.net-20050615042401-02a29d106bece661
add-bzr-to-baz allows multiple arguments
- 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
29
import sys
30
import os
31
from warnings import warn
32
from inspect import getdoc
18
19
import sys, os
33
20
34
21
import bzrlib
35
import bzrlib.trace
36
from bzrlib.trace import mutter, note, log_error, warning
37
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
38
from bzrlib.branch import find_branch
39
from bzrlib import BZRDIR
40
41
plugin_cmds = {}
42
43
44
def register_command(cmd):
45
"Utility function to help register a command"
46
global plugin_cmds
47
k = cmd.__name__
48
if k.startswith("cmd_"):
49
k_unsquished = _unsquish_command_name(k)
50
else:
51
k_unsquished = k
52
if not plugin_cmds.has_key(k_unsquished):
53
plugin_cmds[k_unsquished] = cmd
54
mutter('registered plugin command %s', k_unsquished)
55
else:
56
log_error('Two plugins defined the same command: %r' % k)
57
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
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
58
27
59
28
60
29
def _squish_command_name(cmd):
65
34
assert cmd.startswith("cmd_")
66
35
return cmd[4:].replace('_','-')
67
36
68
69
37
def _parse_revision_str(revstr):
70
"""This handles a revision string -> revno.
71
72
This always returns a list. The list will have one element for
73
74
It supports integers directly, but everything else it
75
defers for passing to Branch.get_revision_info()
76
77
>>> _parse_revision_str('234')
78
[234]
79
>>> _parse_revision_str('234..567')
80
[234, 567]
81
>>> _parse_revision_str('..')
82
[None, None]
83
>>> _parse_revision_str('..234')
84
[None, 234]
85
>>> _parse_revision_str('234..')
86
[234, None]
87
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
88
[234, 456, 789]
89
>>> _parse_revision_str('234....789') # Error?
90
[234, None, 789]
91
>>> _parse_revision_str('revid:test@other.com-234234')
92
['revid:test@other.com-234234']
93
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
94
['revid:test@other.com-234234', 'revid:test@other.com-234235']
95
>>> _parse_revision_str('revid:test@other.com-234234..23')
96
['revid:test@other.com-234234', 23]
97
>>> _parse_revision_str('date:2005-04-12')
98
['date:2005-04-12']
99
>>> _parse_revision_str('date:2005-04-12 12:24:33')
100
['date:2005-04-12 12:24:33']
101
>>> _parse_revision_str('date:2005-04-12T12:24:33')
102
['date:2005-04-12T12:24:33']
103
>>> _parse_revision_str('date:2005-04-12,12:24:33')
104
['date:2005-04-12,12:24:33']
105
>>> _parse_revision_str('-5..23')
106
[-5, 23]
107
>>> _parse_revision_str('-5')
108
[-5]
109
>>> _parse_revision_str('123a')
110
['123a']
111
>>> _parse_revision_str('abc')
112
['abc']
38
"""This handles a revision string -> revno.
39
40
There are several possibilities:
41
42
'234' -> 234
43
'234:345' -> [234, 345]
44
':234' -> [None, 234]
45
'234:' -> [234, None]
46
47
In the future we will also support:
48
'uuid:blah-blah-blah' -> ?
49
'hash:blahblahblah' -> ?
50
potentially:
51
'tag:mytag' -> ?
113
52
"""
114
import re
115
old_format_re = re.compile('\d*:\d*')
116
m = old_format_re.match(revstr)
117
if m:
118
warning('Colon separator for revision numbers is deprecated.'
119
' Use .. instead')
120
revs = []
121
for rev in revstr.split(':'):
122
if rev:
123
revs.append(int(rev))
124
else:
125
revs.append(None)
126
return revs
127
revs = []
128
for x in revstr.split('..'):
129
if not x:
130
revs.append(None)
131
else:
132
try:
133
revs.append(int(x))
134
except ValueError:
135
revs.append(x)
53
if revstr.find(':') != -1:
54
revs = revstr.split(':')
55
if len(revs) > 2:
56
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
57
58
if not revs[0]:
59
revs[0] = None
60
else:
61
revs[0] = int(revs[0])
62
63
if not revs[1]:
64
revs[1] = None
65
else:
66
revs[1] = int(revs[1])
67
else:
68
revs = int(revstr)
136
69
return revs
137
70
138
139
def get_merge_type(typestring):
140
"""Attempt to find the merge class/factory associated with a string."""
141
from merge import merge_types
142
try:
143
return merge_types[typestring][0]
144
except KeyError:
145
templ = '%s%%7s: %%s' % (' '*12)
146
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
147
type_list = '\n'.join(lines)
148
msg = "No known merge type %s. Supported types are:\n%s" %\
149
(typestring, type_list)
150
raise BzrCommandError(msg)
151
152
153
def get_merge_type(typestring):
154
"""Attempt to find the merge class/factory associated with a string."""
155
from merge import merge_types
156
try:
157
return merge_types[typestring][0]
158
except KeyError:
159
templ = '%s%%7s: %%s' % (' '*12)
160
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
161
type_list = '\n'.join(lines)
162
msg = "No known merge type %s. Supported types are:\n%s" %\
163
(typestring, type_list)
164
raise BzrCommandError(msg)
165
166
167
def _builtin_commands():
168
import bzrlib.builtins
169
r = {}
170
builtins = bzrlib.builtins.__dict__
171
for name in builtins:
172
if name.startswith("cmd_"):
173
real_name = _unsquish_command_name(name)
174
r[real_name] = builtins[name]
175
return r
176
177
178
179
def builtin_command_names():
180
"""Return list of builtin command names."""
181
return _builtin_commands().keys()
182
183
184
def plugin_command_names():
185
return plugin_cmds.keys()
186
187
188
def _get_cmd_dict(plugins_override=True):
189
"""Return name->class mapping for all commands."""
190
d = _builtin_commands()
191
if plugins_override:
192
d.update(plugin_cmds)
71
def _find_plugins():
72
"""Find all python files which are plugins, and load their commands
73
to add to the list of "all commands"
74
75
The environment variable BZRPATH is considered a delimited set of
76
paths to look through. Each entry is searched for *.py files.
77
If a directory is found, it is also searched, but they are
78
not searched recursively. This allows you to revctl the plugins.
79
80
Inside the plugin should be a series of cmd_* function, which inherit from
81
the bzrlib.commands.Command class.
82
"""
83
bzrpath = os.environ.get('BZRPLUGINPATH', '')
84
85
plugin_cmds = {}
86
if not bzrpath:
87
return plugin_cmds
88
_platform_extensions = {
89
'win32':'.pyd',
90
'cygwin':'.dll',
91
'darwin':'.dylib',
92
'linux2':'.so'
93
}
94
if _platform_extensions.has_key(sys.platform):
95
platform_extension = _platform_extensions[sys.platform]
96
else:
97
platform_extension = None
98
for d in bzrpath.split(os.pathsep):
99
plugin_names = {} # This should really be a set rather than a dict
100
for f in os.listdir(d):
101
if f.endswith('.py'):
102
f = f[:-3]
103
elif f.endswith('.pyc') or f.endswith('.pyo'):
104
f = f[:-4]
105
elif platform_extension and f.endswith(platform_extension):
106
f = f[:-len(platform_extension)]
107
if f.endswidth('module'):
108
f = f[:-len('module')]
109
else:
110
continue
111
if not plugin_names.has_key(f):
112
plugin_names[f] = True
113
114
plugin_names = plugin_names.keys()
115
plugin_names.sort()
116
try:
117
sys.path.insert(0, d)
118
for name in plugin_names:
119
try:
120
old_module = None
121
try:
122
if sys.modules.has_key(name):
123
old_module = sys.modules[name]
124
del sys.modules[name]
125
plugin = __import__(name, locals())
126
for k in dir(plugin):
127
if k.startswith('cmd_'):
128
k_unsquished = _unsquish_command_name(k)
129
if not plugin_cmds.has_key(k_unsquished):
130
plugin_cmds[k_unsquished] = getattr(plugin, k)
131
else:
132
log_error('Two plugins defined the same command: %r' % k)
133
log_error('Not loading the one in %r in dir %r' % (name, d))
134
finally:
135
if old_module:
136
sys.modules[name] = old_module
137
except ImportError, e:
138
log_error('Unable to load plugin: %r from %r\n%s' % (name, d, e))
139
finally:
140
sys.path.pop(0)
141
return plugin_cmds
142
143
def _get_cmd_dict(include_plugins=True):
144
d = {}
145
for k, v in globals().iteritems():
146
if k.startswith("cmd_"):
147
d[_unsquish_command_name(k)] = v
148
if include_plugins:
149
d.update(_find_plugins())
193
150
return d
194
195
151
196
def get_all_cmds(plugins_override=True):
152
def get_all_cmds(include_plugins=True):
197
153
"""Return canonical name and class for all registered commands."""
198
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():
199
155
yield k,v
200
156
201
157
202
def get_cmd_object(cmd_name, plugins_override=True):
158
def get_cmd_class(cmd,include_plugins=True):
203
159
"""Return the canonical name and command class for a command.
204
205
plugins_override
206
If true, plugin commands can override builtins.
207
160
"""
208
from bzrlib.externalcommand import ExternalCommand
209
210
cmd_name = str(cmd_name) # not unicode
161
cmd = str(cmd) # not unicode
211
162
212
163
# first look up this command under the specified name
213
cmds = _get_cmd_dict(plugins_override=plugins_override)
164
cmds = _get_cmd_dict(include_plugins=include_plugins)
214
165
try:
215
return cmds[cmd_name]()
166
return cmd, cmds[cmd]
216
167
except KeyError:
217
168
pass
218
169
219
170
# look for any command which claims this as an alias
220
for real_cmd_name, cmd_class in cmds.iteritems():
221
if cmd_name in cmd_class.aliases:
222
return cmd_class()
223
224
cmd_obj = ExternalCommand.find_command(cmd_name)
225
if cmd_obj:
226
return cmd_obj
227
228
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)
229
180
230
181
231
182
class Command(object):
232
183
"""Base class for commands.
233
184
234
Commands are the heart of the command-line bzr interface.
235
236
The command object mostly handles the mapping of command-line
237
parameters into one or more bzrlib operations, and of the results
238
into textual output.
239
240
Commands normally don't have any state. All their arguments are
241
passed in to the run method. (Subclasses may take a different
242
policy if the behaviour of the instance needs to depend on e.g. a
243
shell plugin and not just its Python class.)
244
245
185
The docstring for an actual command should give a single-line
246
186
summary, then a complete description of the command. A grammar
247
187
description will be inserted.
248
188
249
aliases
250
Other accepted names for this command.
251
252
189
takes_args
253
190
List of argument forms, marked with whether they are optional,
254
191
repeated, etc.
257
194
List of options that may be given for this command.
258
195
259
196
hidden
260
If true, this command isn't advertised. This is typically
261
for commands intended for expert users.
197
If true, this command isn't advertised.
262
198
"""
263
199
aliases = []
264
200
267
203
268
204
hidden = False
269
205
270
def __init__(self):
271
"""Construct an instance of this command."""
272
if self.__doc__ == Command.__doc__:
273
warn("No help message set for %r" % self)
274
275
276
def run_argv(self, argv):
277
"""Parse command line and run."""
278
args, opts = parse_args(argv)
279
280
if 'help' in opts: # e.g. bzr add --help
281
from bzrlib.help import help_on_command
282
help_on_command(self.name())
283
return 0
284
285
# check options are reasonable
286
allowed = self.takes_options
287
for oname in opts:
288
if oname not in allowed:
289
raise BzrCommandError("option '--%s' is not allowed for command %r"
290
% (oname, self.name()))
291
292
# mix arguments and options into one dictionary
293
cmdargs = _match_argform(self.name(), self.takes_args, args)
294
cmdopts = {}
295
for k, v in opts.items():
296
cmdopts[k.replace('-', '_')] = v
297
298
all_cmd_args = cmdargs.copy()
299
all_cmd_args.update(cmdopts)
300
301
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)
302
217
303
218
304
219
def run(self):
305
"""Actually run the command.
220
"""Override this in sub-classes.
306
221
307
222
This is invoked with the options and arguments bound to
308
223
keyword parameters.
309
224
310
Return 0 or None if the command was successful, or a non-zero
311
shell error code if not. It's OK for this method to allow
312
an exception to raise up.
225
Return 0 or None if the command was successful, or a shell
226
error code if not.
313
227
"""
314
raise NotImplementedError()
315
316
317
def help(self):
318
"""Return help message for this class."""
319
if self.__doc__ is Command.__doc__:
320
return None
321
return getdoc(self)
322
323
def name(self):
324
return _unsquish_command_name(self.__class__.__name__)
325
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!"
326
1180
327
1181
def parse_spec(spec):
328
1182
"""
334
1188
['..', -1]
335
1189
>>> parse_spec("../f/@35")
336
1190
['../f', 35]
337
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
338
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
339
1191
"""
340
1192
if spec is None:
341
1193
return [None, None]
345
1197
if parsed[1] == "":
346
1198
parsed[1] = -1
347
1199
else:
348
try:
349
parsed[1] = int(parsed[1])
350
except ValueError:
351
pass # We can allow stuff like ./@revid:blahblahblah
352
else:
353
assert parsed[1] >=0
1200
parsed[1] = int(parsed[1])
1201
assert parsed[1] >=0
354
1202
else:
355
1203
parsed = [spec, None]
356
1204
return parsed
357
1205
358
1206
359
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
360
1286
361
1287
# list of all available options; the rhs can be either None for an
362
1288
# option that takes no argument, or a constructor function that checks
373
1299
'no-recurse': None,
374
1300
'profile': None,
375
1301
'revision': _parse_revision_str,
376
'short': None,
377
1302
'show-ids': None,
378
1303
'timezone': str,
379
1304
'verbose': None,
380
1305
'version': None,
381
1306
'email': None,
382
'unchanged': None,
383
1307
'update': None,
384
'long': None,
385
'root': str,
386
'no-backup': None,
387
'merge-type': get_merge_type,
388
'pattern': str,
389
1308
}
390
1309
391
1310
SHORT_OPTIONS = {
394
1313
'm': 'message',
395
1314
'r': 'revision',
396
1315
'v': 'verbose',
397
'l': 'long',
398
1316
}
399
1317
400
1318
408
1326
409
1327
>>> parse_args('--help'.split())
410
1328
([], {'help': True})
411
>>> parse_args('help -- --invalidcmd'.split())
412
(['help', '--invalidcmd'], {})
413
1329
>>> parse_args('--version'.split())
414
1330
([], {'version': True})
415
1331
>>> parse_args('status --all'.split())
417
1333
>>> parse_args('commit --message=biter'.split())
418
1334
(['commit'], {'message': u'biter'})
419
1335
>>> parse_args('log -r 500'.split())
420
(['log'], {'revision': [500]})
421
>>> parse_args('log -r500..600'.split())
1336
(['log'], {'revision': 500})
1337
>>> parse_args('log -r500:600'.split())
422
1338
(['log'], {'revision': [500, 600]})
423
>>> parse_args('log -vr500..600'.split())
1339
>>> parse_args('log -vr500:600'.split())
424
1340
(['log'], {'verbose': True, 'revision': [500, 600]})
425
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
426
(['log'], {'revision': ['v500', 600]})
1341
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1342
Traceback (most recent call last):
1343
...
1344
ValueError: invalid literal for int(): v500
427
1345
"""
428
1346
args = []
429
1347
opts = {}
430
1348
431
argsover = False
1349
# TODO: Maybe handle '--' to end options?
1350
432
1351
while argv:
433
1352
a = argv.pop(0)
434
if not argsover and a[0] == '-':
1353
if a[0] == '-':
435
1354
# option names must not be unicode
436
1355
a = str(a)
437
1356
optarg = None
438
1357
if a[1] == '-':
439
if a == '--':
440
# We've received a standalone -- No more flags
441
argsover = True
442
continue
443
1358
mutter(" got option %r" % a)
444
1359
if '=' in a:
445
1360
optname, optarg = a[2:].split('=', 1)
446
1361
else:
447
1362
optname = a[2:]
448
1363
if optname not in OPTIONS:
449
raise BzrError('unknown long option %r' % a)
1364
bailout('unknown long option %r' % a)
450
1365
else:
451
1366
shortopt = a[1:]
452
1367
if shortopt in SHORT_OPTIONS:
460
1375
if shortopt not in SHORT_OPTIONS:
461
1376
# We didn't find the multi-character name, and we
462
1377
# didn't find the single char name
463
raise BzrError('unknown short option %r' % a)
1378
bailout('unknown short option %r' % a)
464
1379
optname = SHORT_OPTIONS[shortopt]
465
1380
466
1381
if a[2:]:
480
1395
481
1396
if optname in opts:
482
1397
# XXX: Do we ever want to support this, e.g. for -r?
483
raise BzrError('repeated option %r' % a)
1398
bailout('repeated option %r' % a)
484
1399
485
1400
optargfn = OPTIONS[optname]
486
1401
if optargfn:
487
1402
if optarg == None:
488
1403
if not argv:
489
raise BzrError('option %r needs an argument' % a)
1404
bailout('option %r needs an argument' % a)
490
1405
else:
491
1406
optarg = argv.pop(0)
492
1407
opts[optname] = optargfn(optarg)
493
1408
else:
494
1409
if optarg != None:
495
raise BzrError('option %r takes no argument' % optname)
1410
bailout('option %r takes no argument' % optname)
496
1411
opts[optname] = True
497
1412
else:
498
1413
args.append(a)
547
1462
548
1463
549
1464
550
def apply_profiled(the_callable, *args, **kwargs):
551
import hotshot
552
import tempfile
553
pffileno, pfname = tempfile.mkstemp()
554
try:
555
prof = hotshot.Profile(pfname)
556
try:
557
ret = prof.runcall(the_callable, *args, **kwargs) or 0
558
finally:
559
prof.close()
560
561
import hotshot.stats
562
stats = hotshot.stats.load(pfname)
563
#stats.strip_dirs()
564
stats.sort_stats('time')
565
## XXX: Might like to write to stderr or the trace file instead but
566
## print_stats seems hardcoded to stdout
567
stats.print_stats(20)
568
569
return ret
570
finally:
571
os.close(pffileno)
572
os.remove(pfname)
573
574
575
1465
def run_bzr(argv):
576
1466
"""Execute a command.
577
1467
578
1468
This is similar to main(), but without all the trappings for
579
1469
logging and error handling.
580
581
argv
582
The command-line arguments, without the program name from argv[0]
583
584
Returns a command status or raises an exception.
585
586
Special master options: these must come before the command because
587
they control how the command is interpreted.
588
589
--no-plugins
590
Do not load plugin modules at all
591
592
--builtin
593
Only use builtin commands. (Plugins are still allowed to change
594
other behaviour.)
595
596
--profile
597
Run under the Python profiler.
598
1470
"""
599
600
1471
argv = [a.decode(bzrlib.user_encoding) for a in argv]
601
602
opt_profile = opt_no_plugins = opt_builtin = False
603
604
# --no-plugins is handled specially at a very early stage. We need
605
# to load plugins before doing other command parsing so that they
606
# can override commands, but this needs to happen first.
607
608
for a in argv:
609
if a == '--profile':
610
opt_profile = True
611
elif a == '--no-plugins':
612
opt_no_plugins = True
613
elif a == '--builtin':
614
opt_builtin = True
615
else:
616
break
617
argv.remove(a)
618
619
if (not argv) or (argv[0] == '--help'):
620
from bzrlib.help import help
621
if len(argv) > 1:
622
help(argv[1])
623
else:
624
help()
625
return 0
626
627
if argv[0] == '--version':
628
from bzrlib.builtins import show_version
629
show_version()
630
return 0
631
632
if not opt_no_plugins:
633
from bzrlib.plugin import load_plugins
634
load_plugins()
635
636
cmd = str(argv.pop(0))
637
638
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
639
640
if opt_profile:
641
ret = apply_profiled(cmd_obj.run_argv, argv)
642
else:
643
ret = cmd_obj.run_argv(argv)
644
return ret or 0
1472
1473
include_plugins=True
1474
try:
1475
args, opts = parse_args(argv[1:])
1476
if 'help' in opts:
1477
import help
1478
if args:
1479
help.help(args[0])
1480
else:
1481
help.help()
1482
return 0
1483
elif 'version' in opts:
1484
show_version()
1485
return 0
1486
elif args and args[0] == 'builtin':
1487
include_plugins=False
1488
args = args[1:]
1489
cmd = str(args.pop(0))
1490
except IndexError:
1491
import help
1492
help.help()
1493
return 1
1494
1495
1496
canonical_cmd, cmd_class = get_cmd_class(cmd,include_plugins=include_plugins)
1497
1498
# global option
1499
if 'profile' in opts:
1500
profile = True
1501
del opts['profile']
1502
else:
1503
profile = False
1504
1505
# check options are reasonable
1506
allowed = cmd_class.takes_options
1507
for oname in opts:
1508
if oname not in allowed:
1509
raise BzrCommandError("option '--%s' is not allowed for command %r"
1510
% (oname, cmd))
1511
1512
# mix arguments and options into one dictionary
1513
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1514
cmdopts = {}
1515
for k, v in opts.items():
1516
cmdopts[k.replace('-', '_')] = v
1517
1518
if profile:
1519
import hotshot, tempfile
1520
pffileno, pfname = tempfile.mkstemp()
1521
try:
1522
prof = hotshot.Profile(pfname)
1523
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1524
prof.close()
1525
1526
import hotshot.stats
1527
stats = hotshot.stats.load(pfname)
1528
#stats.strip_dirs()
1529
stats.sort_stats('time')
1530
## XXX: Might like to write to stderr or the trace file instead but
1531
## print_stats seems hardcoded to stdout
1532
stats.print_stats(20)
1533
1534
return ret.status
1535
1536
finally:
1537
os.close(pffileno)
1538
os.remove(pfname)
1539
else:
1540
return cmd_class(cmdopts, cmdargs).status
1541
1542
1543
def _report_exception(summary, quiet=False):
1544
import traceback
1545
log_error('bzr: ' + summary)
1546
bzrlib.trace.log_exception()
1547
1548
if not quiet:
1549
tb = sys.exc_info()[2]
1550
exinfo = traceback.extract_tb(tb)
1551
if exinfo:
1552
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1553
sys.stderr.write(' see ~/.bzr.log for debug information\n')
1554
645
1555
646
1556
647
1557
def main(argv):
648
import bzrlib.ui
649
bzrlib.trace.log_startup(argv)
650
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
1558
import errno
1559
1560
bzrlib.open_tracefile(argv)
651
1561
652
1562
try:
653
1563
try:
654
return run_bzr(argv[1:])
655
finally:
656
# do this here inside the exception wrappers to catch EPIPE
657
sys.stdout.flush()
658
except BzrCommandError, e:
659
# command line syntax error, etc
660
log_error(str(e))
661
return 1
662
except BzrError, e:
663
bzrlib.trace.log_exception()
664
return 1
665
except AssertionError, e:
666
bzrlib.trace.log_exception('assertion failed: ' + str(e))
667
return 3
668
except KeyboardInterrupt, e:
669
bzrlib.trace.note('interrupted')
670
return 2
671
except Exception, e:
672
import errno
673
if (isinstance(e, IOError)
674
and hasattr(e, 'errno')
675
and e.errno == errno.EPIPE):
676
bzrlib.trace.note('broken pipe')
677
return 2
678
else:
679
bzrlib.trace.log_exception()
680
return 2
1564
try:
1565
return run_bzr(argv)
1566
finally:
1567
# do this here inside the exception wrappers to catch EPIPE
1568
sys.stdout.flush()
1569
except BzrError, e:
1570
quiet = isinstance(e, (BzrCommandError))
1571
_report_exception('error: ' + e.args[0], quiet=quiet)
1572
if len(e.args) > 1:
1573
for h in e.args[1]:
1574
# some explanation or hints
1575
log_error(' ' + h)
1576
return 1
1577
except AssertionError, e:
1578
msg = 'assertion failed'
1579
if str(e):
1580
msg += ': ' + str(e)
1581
_report_exception(msg)
1582
return 2
1583
except KeyboardInterrupt, e:
1584
_report_exception('interrupted', quiet=True)
1585
return 2
1586
except Exception, e:
1587
quiet = False
1588
if (isinstance(e, IOError)
1589
and hasattr(e, 'errno')
1590
and e.errno == errno.EPIPE):
1591
quiet = True
1592
msg = 'broken pipe'
1593
else:
1594
msg = str(e).rstrip('\n')
1595
_report_exception(msg, quiet)
1596
return 2
1597
finally:
1598
bzrlib.trace.close_trace()
681
1599
682
1600
683
1601
if __name__ == '__main__':
Loggerhead is a web-based interface for Breezy
Version: 2.0.1