« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 562
- compare with another revision
- download diff
- download tarball
- view history from revision 562
- Committer: Martin Pool
- Date: 2005-05-26 15:13:20 UTC
- Revision ID: mbp@sourcefrog.net-20050526151319-4821dee258bbaf30
- bug fix for printing logs containing unicode
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- contrib/bash/bzr.simple => contrib/bash/bzr
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
# TODO: probably should say which arguments are candidates for glob
19
# expansion on windows and do that at the command level.
20
21
# TODO: Help messages for options.
22
23
# TODO: Define arguments by objects, rather than just using names.
24
# Those objects can specify the expected type of the argument, which
25
# would help with validation and shell completion.
26
27
28
# TODO: Help messages for options.
29
30
# TODO: Define arguments by objects, rather than just using names.
31
# Those objects can specify the expected type of the argument, which
32
# would help with validation and shell completion.
33
34
35
36
import sys
37
import os
38
from warnings import warn
39
from inspect import getdoc
18
19
import sys, os, time, os.path
40
20
41
21
import bzrlib
42
import bzrlib.trace
43
from bzrlib.trace import mutter, note, log_error, warning
44
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError, NotBranchError
45
from bzrlib.branch import find_branch
46
from bzrlib import BZRDIR
47
48
plugin_cmds = {}
49
50
51
def register_command(cmd):
52
"Utility function to help register a command"
53
global plugin_cmds
54
k = cmd.__name__
55
if k.startswith("cmd_"):
56
k_unsquished = _unsquish_command_name(k)
57
else:
58
k_unsquished = k
59
if not plugin_cmds.has_key(k_unsquished):
60
plugin_cmds[k_unsquished] = cmd
61
mutter('registered plugin command %s', k_unsquished)
62
else:
63
log_error('Two plugins defined the same command: %r' % k)
64
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
22
from bzrlib.trace import mutter, note, log_error
23
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
25
from bzrlib.tree import RevisionTree, EmptyTree, Tree
26
from bzrlib.revision import Revision
27
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
28
format_date
29
from bzrlib import merge
65
30
66
31
67
32
def _squish_command_name(cmd):
72
37
assert cmd.startswith("cmd_")
73
38
return cmd[4:].replace('_','-')
74
39
75
76
def _parse_revision_str(revstr):
77
"""This handles a revision string -> revno.
78
79
This always returns a list. The list will have one element for
80
81
It supports integers directly, but everything else it
82
defers for passing to Branch.get_revision_info()
83
84
>>> _parse_revision_str('234')
85
[234]
86
>>> _parse_revision_str('234..567')
87
[234, 567]
88
>>> _parse_revision_str('..')
89
[None, None]
90
>>> _parse_revision_str('..234')
91
[None, 234]
92
>>> _parse_revision_str('234..')
93
[234, None]
94
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
95
[234, 456, 789]
96
>>> _parse_revision_str('234....789') # Error?
97
[234, None, 789]
98
>>> _parse_revision_str('revid:test@other.com-234234')
99
['revid:test@other.com-234234']
100
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
101
['revid:test@other.com-234234', 'revid:test@other.com-234235']
102
>>> _parse_revision_str('revid:test@other.com-234234..23')
103
['revid:test@other.com-234234', 23]
104
>>> _parse_revision_str('date:2005-04-12')
105
['date:2005-04-12']
106
>>> _parse_revision_str('date:2005-04-12 12:24:33')
107
['date:2005-04-12 12:24:33']
108
>>> _parse_revision_str('date:2005-04-12T12:24:33')
109
['date:2005-04-12T12:24:33']
110
>>> _parse_revision_str('date:2005-04-12,12:24:33')
111
['date:2005-04-12,12:24:33']
112
>>> _parse_revision_str('-5..23')
113
[-5, 23]
114
>>> _parse_revision_str('-5')
115
[-5]
116
>>> _parse_revision_str('123a')
117
['123a']
118
>>> _parse_revision_str('abc')
119
['abc']
120
"""
121
import re
122
old_format_re = re.compile('\d*:\d*')
123
m = old_format_re.match(revstr)
124
if m:
125
warning('Colon separator for revision numbers is deprecated.'
126
' Use .. instead')
127
revs = []
128
for rev in revstr.split(':'):
129
if rev:
130
revs.append(int(rev))
131
else:
132
revs.append(None)
133
return revs
134
revs = []
135
for x in revstr.split('..'):
136
if not x:
137
revs.append(None)
138
else:
139
try:
140
revs.append(int(x))
141
except ValueError:
142
revs.append(x)
143
return revs
144
145
146
def get_merge_type(typestring):
147
"""Attempt to find the merge class/factory associated with a string."""
148
from merge import merge_types
149
try:
150
return merge_types[typestring][0]
151
except KeyError:
152
templ = '%s%%7s: %%s' % (' '*12)
153
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
154
type_list = '\n'.join(lines)
155
msg = "No known merge type %s. Supported types are:\n%s" %\
156
(typestring, type_list)
157
raise BzrCommandError(msg)
158
159
160
def _builtin_commands():
161
import bzrlib.builtins
162
r = {}
163
builtins = bzrlib.builtins.__dict__
164
for name in builtins:
165
if name.startswith("cmd_"):
166
real_name = _unsquish_command_name(name)
167
r[real_name] = builtins[name]
168
return r
169
170
171
172
def builtin_command_names():
173
"""Return list of builtin command names."""
174
return _builtin_commands().keys()
175
176
177
def plugin_command_names():
178
return plugin_cmds.keys()
179
180
181
def _get_cmd_dict(plugins_override=True):
182
"""Return name->class mapping for all commands."""
183
d = _builtin_commands()
184
if plugins_override:
185
d.update(plugin_cmds)
186
return d
187
188
189
def get_all_cmds(plugins_override=True):
40
def get_all_cmds():
190
41
"""Return canonical name and class for all registered commands."""
191
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
192
yield k,v
193
194
195
def get_cmd_object(cmd_name, plugins_override=True):
42
for k, v in globals().iteritems():
43
if k.startswith("cmd_"):
44
yield _unsquish_command_name(k), v
45
46
def get_cmd_class(cmd):
196
47
"""Return the canonical name and command class for a command.
197
198
plugins_override
199
If true, plugin commands can override builtins.
200
48
"""
201
from bzrlib.externalcommand import ExternalCommand
202
203
cmd_name = str(cmd_name) # not unicode
49
cmd = str(cmd) # not unicode
204
50
205
51
# first look up this command under the specified name
206
cmds = _get_cmd_dict(plugins_override=plugins_override)
207
52
try:
208
return cmds[cmd_name]()
53
return cmd, globals()[_squish_command_name(cmd)]
209
54
except KeyError:
210
55
pass
211
56
212
57
# look for any command which claims this as an alias
213
for real_cmd_name, cmd_class in cmds.iteritems():
214
if cmd_name in cmd_class.aliases:
215
return cmd_class()
216
217
cmd_obj = ExternalCommand.find_command(cmd_name)
218
if cmd_obj:
219
return cmd_obj
220
221
raise BzrCommandError("unknown command %r" % cmd_name)
58
for cmdname, cmdclass in get_all_cmds():
59
if cmd in cmdclass.aliases:
60
return cmdname, cmdclass
61
62
cmdclass = ExternalCommand.find_command(cmd)
63
if cmdclass:
64
return cmd, cmdclass
65
66
raise BzrCommandError("unknown command %r" % cmd)
222
67
223
68
224
69
class Command(object):
225
70
"""Base class for commands.
226
71
227
Commands are the heart of the command-line bzr interface.
228
229
The command object mostly handles the mapping of command-line
230
parameters into one or more bzrlib operations, and of the results
231
into textual output.
232
233
Commands normally don't have any state. All their arguments are
234
passed in to the run method. (Subclasses may take a different
235
policy if the behaviour of the instance needs to depend on e.g. a
236
shell plugin and not just its Python class.)
237
238
72
The docstring for an actual command should give a single-line
239
73
summary, then a complete description of the command. A grammar
240
74
description will be inserted.
241
75
242
aliases
243
Other accepted names for this command.
244
245
76
takes_args
246
77
List of argument forms, marked with whether they are optional,
247
78
repeated, etc.
250
81
List of options that may be given for this command.
251
82
252
83
hidden
253
If true, this command isn't advertised. This is typically
254
for commands intended for expert users.
84
If true, this command isn't advertised.
255
85
"""
256
86
aliases = []
257
87
260
90
261
91
hidden = False
262
92
263
def __init__(self):
264
"""Construct an instance of this command."""
265
if self.__doc__ == Command.__doc__:
266
warn("No help message set for %r" % self)
267
268
269
def run_argv(self, argv):
270
"""Parse command line and run."""
271
args, opts = parse_args(argv)
272
273
if 'help' in opts: # e.g. bzr add --help
274
from bzrlib.help import help_on_command
275
help_on_command(self.name())
276
return 0
277
278
# check options are reasonable
279
allowed = self.takes_options
280
for oname in opts:
281
if oname not in allowed:
282
raise BzrCommandError("option '--%s' is not allowed for command %r"
283
% (oname, self.name()))
284
285
# mix arguments and options into one dictionary
286
cmdargs = _match_argform(self.name(), self.takes_args, args)
287
cmdopts = {}
288
for k, v in opts.items():
289
cmdopts[k.replace('-', '_')] = v
290
291
all_cmd_args = cmdargs.copy()
292
all_cmd_args.update(cmdopts)
293
294
return self.run(**all_cmd_args)
93
def __init__(self, options, arguments):
94
"""Construct and run the command.
95
96
Sets self.status to the return value of run()."""
97
assert isinstance(options, dict)
98
assert isinstance(arguments, dict)
99
cmdargs = options.copy()
100
cmdargs.update(arguments)
101
assert self.__doc__ != Command.__doc__, \
102
("No help message set for %r" % self)
103
self.status = self.run(**cmdargs)
295
104
296
105
297
106
def run(self):
298
"""Actually run the command.
107
"""Override this in sub-classes.
299
108
300
109
This is invoked with the options and arguments bound to
301
110
keyword parameters.
302
111
303
Return 0 or None if the command was successful, or a non-zero
304
shell error code if not. It's OK for this method to allow
305
an exception to raise up.
112
Return 0 or None if the command was successful, or a shell
113
error code if not.
306
114
"""
307
raise NotImplementedError()
308
309
310
def help(self):
311
"""Return help message for this class."""
312
if self.__doc__ is Command.__doc__:
313
return None
314
return getdoc(self)
315
316
def name(self):
317
return _unsquish_command_name(self.__class__.__name__)
318
115
return 0
116
117
118
class ExternalCommand(Command):
119
"""Class to wrap external commands.
120
121
We cheat a little here, when get_cmd_class() calls us we actually give it back
122
an object we construct that has the appropriate path, help, options etc for the
123
specified command.
124
125
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
126
method, which we override to call the Command.__init__ method. That then calls
127
our run method which is pretty straight forward.
128
129
The only wrinkle is that we have to map bzr's dictionary of options and arguments
130
back into command line options and arguments for the script.
131
"""
132
133
def find_command(cls, cmd):
134
bzrpath = os.environ.get('BZRPATH', '')
135
136
for dir in bzrpath.split(':'):
137
path = os.path.join(dir, cmd)
138
if os.path.isfile(path):
139
return ExternalCommand(path)
140
141
return None
142
143
find_command = classmethod(find_command)
144
145
def __init__(self, path):
146
self.path = path
147
148
# TODO: If either of these fail, we should detect that and
149
# assume that path is not really a bzr plugin after all.
150
151
pipe = os.popen('%s --bzr-usage' % path, 'r')
152
self.takes_options = pipe.readline().split()
153
self.takes_args = pipe.readline().split()
154
pipe.close()
155
156
pipe = os.popen('%s --bzr-help' % path, 'r')
157
self.__doc__ = pipe.read()
158
pipe.close()
159
160
def __call__(self, options, arguments):
161
Command.__init__(self, options, arguments)
162
return self
163
164
def run(self, **kargs):
165
opts = []
166
args = []
167
168
keys = kargs.keys()
169
keys.sort()
170
for name in keys:
171
value = kargs[name]
172
if OPTIONS.has_key(name):
173
# it's an option
174
opts.append('--%s' % name)
175
if value is not None and value is not True:
176
opts.append(str(value))
177
else:
178
# it's an arg, or arg list
179
if type(value) is not list:
180
value = [value]
181
for v in value:
182
if v is not None:
183
args.append(str(v))
184
185
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
186
return self.status
187
188
189
class cmd_status(Command):
190
"""Display status summary.
191
192
This reports on versioned and unknown files, reporting them
193
grouped by state. Possible states are:
194
195
added
196
Versioned in the working copy but not in the previous revision.
197
198
removed
199
Versioned in the previous revision but removed or deleted
200
in the working copy.
201
202
renamed
203
Path of this file changed from the previous revision;
204
the text may also have changed. This includes files whose
205
parent directory was renamed.
206
207
modified
208
Text has changed since the previous revision.
209
210
unchanged
211
Nothing about this file has changed since the previous revision.
212
Only shown with --all.
213
214
unknown
215
Not versioned and not matching an ignore pattern.
216
217
To see ignored files use 'bzr ignored'. For details in the
218
changes to file texts, use 'bzr diff'.
219
220
If no arguments are specified, the status of the entire working
221
directory is shown. Otherwise, only the status of the specified
222
files or directories is reported. If a directory is given, status
223
is reported for everything inside that directory.
224
"""
225
takes_args = ['file*']
226
takes_options = ['all', 'show-ids']
227
aliases = ['st', 'stat']
228
229
def run(self, all=False, show_ids=False, file_list=None):
230
if file_list:
231
b = Branch(file_list[0], lock_mode='r')
232
file_list = [b.relpath(x) for x in file_list]
233
# special case: only one path was given and it's the root
234
# of the branch
235
if file_list == ['']:
236
file_list = None
237
else:
238
b = Branch('.', lock_mode='r')
239
import status
240
status.show_status(b, show_unchanged=all, show_ids=show_ids,
241
specific_files=file_list)
242
243
244
class cmd_cat_revision(Command):
245
"""Write out metadata for a revision."""
246
247
hidden = True
248
takes_args = ['revision_id']
249
250
def run(self, revision_id):
251
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
252
253
254
class cmd_revno(Command):
255
"""Show current revision number.
256
257
This is equal to the number of revisions on this branch."""
258
def run(self):
259
print Branch('.').revno()
260
261
262
class cmd_add(Command):
263
"""Add specified files or directories.
264
265
In non-recursive mode, all the named items are added, regardless
266
of whether they were previously ignored. A warning is given if
267
any of the named files are already versioned.
268
269
In recursive mode (the default), files are treated the same way
270
but the behaviour for directories is different. Directories that
271
are already versioned do not give a warning. All directories,
272
whether already versioned or not, are searched for files or
273
subdirectories that are neither versioned or ignored, and these
274
are added. This search proceeds recursively into versioned
275
directories.
276
277
Therefore simply saying 'bzr add .' will version all files that
278
are currently unknown.
279
280
TODO: Perhaps adding a file whose directly is not versioned should
281
recursively add that parent, rather than giving an error?
282
"""
283
takes_args = ['file+']
284
takes_options = ['verbose']
285
286
def run(self, file_list, verbose=False):
287
bzrlib.add.smart_add(file_list, verbose)
288
289
290
class cmd_relpath(Command):
291
"""Show path of a file relative to root"""
292
takes_args = ['filename']
293
294
def run(self, filename):
295
print Branch(filename).relpath(filename)
296
297
298
299
class cmd_inventory(Command):
300
"""Show inventory of the current working copy or a revision."""
301
takes_options = ['revision']
302
303
def run(self, revision=None):
304
b = Branch('.')
305
if revision == None:
306
inv = b.read_working_inventory()
307
else:
308
inv = b.get_revision_inventory(b.lookup_revision(revision))
309
310
for path, entry in inv.entries():
311
print '%-50s %s' % (entry.file_id, path)
312
313
314
class cmd_move(Command):
315
"""Move files to a different directory.
316
317
examples:
318
bzr move *.txt doc
319
320
The destination must be a versioned directory in the same branch.
321
"""
322
takes_args = ['source$', 'dest']
323
def run(self, source_list, dest):
324
b = Branch('.')
325
326
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
327
328
329
class cmd_rename(Command):
330
"""Change the name of an entry.
331
332
examples:
333
bzr rename frob.c frobber.c
334
bzr rename src/frob.c lib/frob.c
335
336
It is an error if the destination name exists.
337
338
See also the 'move' command, which moves files into a different
339
directory without changing their name.
340
341
TODO: Some way to rename multiple files without invoking bzr for each
342
one?"""
343
takes_args = ['from_name', 'to_name']
344
345
def run(self, from_name, to_name):
346
b = Branch('.')
347
b.rename_one(b.relpath(from_name), b.relpath(to_name))
348
349
350
351
class cmd_renames(Command):
352
"""Show list of renamed files.
353
354
TODO: Option to show renames between two historical versions.
355
356
TODO: Only show renames under dir, rather than in the whole branch.
357
"""
358
takes_args = ['dir?']
359
360
def run(self, dir='.'):
361
b = Branch(dir)
362
old_inv = b.basis_tree().inventory
363
new_inv = b.read_working_inventory()
364
365
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
366
renames.sort()
367
for old_name, new_name in renames:
368
print "%s => %s" % (old_name, new_name)
369
370
371
class cmd_info(Command):
372
"""Show statistical information about a branch."""
373
takes_args = ['branch?']
374
375
def run(self, branch=None):
376
import info
377
378
from branch import find_branch
379
b = find_branch(branch)
380
info.show_info(b)
381
382
383
class cmd_remove(Command):
384
"""Make a file unversioned.
385
386
This makes bzr stop tracking changes to a versioned file. It does
387
not delete the working copy.
388
"""
389
takes_args = ['file+']
390
takes_options = ['verbose']
391
392
def run(self, file_list, verbose=False):
393
b = Branch(file_list[0])
394
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
395
396
397
class cmd_file_id(Command):
398
"""Print file_id of a particular file or directory.
399
400
The file_id is assigned when the file is first added and remains the
401
same through all revisions where the file exists, even when it is
402
moved or renamed.
403
"""
404
hidden = True
405
takes_args = ['filename']
406
def run(self, filename):
407
b = Branch(filename)
408
i = b.inventory.path2id(b.relpath(filename))
409
if i == None:
410
bailout("%r is not a versioned file" % filename)
411
else:
412
print i
413
414
415
class cmd_file_path(Command):
416
"""Print path of file_ids to a file or directory.
417
418
This prints one line for each directory down to the target,
419
starting at the branch root."""
420
hidden = True
421
takes_args = ['filename']
422
def run(self, filename):
423
b = Branch(filename)
424
inv = b.inventory
425
fid = inv.path2id(b.relpath(filename))
426
if fid == None:
427
bailout("%r is not a versioned file" % filename)
428
for fip in inv.get_idpath(fid):
429
print fip
430
431
432
class cmd_revision_history(Command):
433
"""Display list of revision ids on this branch."""
434
def run(self):
435
for patchid in Branch('.').revision_history():
436
print patchid
437
438
439
class cmd_directories(Command):
440
"""Display list of versioned directories in this branch."""
441
def run(self):
442
for name, ie in Branch('.').read_working_inventory().directories():
443
if name == '':
444
print '.'
445
else:
446
print name
447
448
449
class cmd_init(Command):
450
"""Make a directory into a versioned branch.
451
452
Use this to create an empty branch, or before importing an
453
existing project.
454
455
Recipe for importing a tree of files:
456
cd ~/project
457
bzr init
458
bzr add -v .
459
bzr status
460
bzr commit -m 'imported project'
461
"""
462
def run(self):
463
Branch('.', init=True)
464
465
466
class cmd_diff(Command):
467
"""Show differences in working tree.
468
469
If files are listed, only the changes in those files are listed.
470
Otherwise, all changes for the tree are listed.
471
472
TODO: Given two revision arguments, show the difference between them.
473
474
TODO: Allow diff across branches.
475
476
TODO: Option to use external diff command; could be GNU diff, wdiff,
477
or a graphical diff.
478
479
TODO: Python difflib is not exactly the same as unidiff; should
480
either fix it up or prefer to use an external diff.
481
482
TODO: If a directory is given, diff everything under that.
483
484
TODO: Selected-file diff is inefficient and doesn't show you
485
deleted files.
486
487
TODO: This probably handles non-Unix newlines poorly.
488
"""
489
490
takes_args = ['file*']
491
takes_options = ['revision']
492
aliases = ['di']
493
494
def run(self, revision=None, file_list=None):
495
from bzrlib.diff import show_diff
496
from bzrlib import find_branch
497
498
if file_list:
499
b = find_branch(file_list[0], lock_mode='r')
500
file_list = [b.relpath(f) for f in file_list]
501
if file_list == ['']:
502
# just pointing to top-of-tree
503
file_list = None
504
else:
505
b = Branch('.', lock_mode='r')
506
507
show_diff(b, revision, specific_files=file_list)
508
509
510
511
512
513
class cmd_deleted(Command):
514
"""List files deleted in the working tree.
515
516
TODO: Show files deleted since a previous revision, or between two revisions.
517
"""
518
def run(self, show_ids=False):
519
b = Branch('.')
520
old = b.basis_tree()
521
new = b.working_tree()
522
523
## TODO: Much more efficient way to do this: read in new
524
## directories with readdir, rather than stating each one. Same
525
## level of effort but possibly much less IO. (Or possibly not,
526
## if the directories are very large...)
527
528
for path, ie in old.inventory.iter_entries():
529
if not new.has_id(ie.file_id):
530
if show_ids:
531
print '%-50s %s' % (path, ie.file_id)
532
else:
533
print path
534
535
536
class cmd_modified(Command):
537
"""List files modified in working tree."""
538
hidden = True
539
def run(self):
540
import statcache
541
b = Branch('.')
542
inv = b.read_working_inventory()
543
sc = statcache.update_cache(b, inv)
544
basis = b.basis_tree()
545
basis_inv = basis.inventory
546
547
# We used to do this through iter_entries(), but that's slow
548
# when most of the files are unmodified, as is usually the
549
# case. So instead we iterate by inventory entry, and only
550
# calculate paths as necessary.
551
552
for file_id in basis_inv:
553
cacheentry = sc.get(file_id)
554
if not cacheentry: # deleted
555
continue
556
ie = basis_inv[file_id]
557
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
558
path = inv.id2path(file_id)
559
print path
560
561
562
563
class cmd_added(Command):
564
"""List files added in working tree."""
565
hidden = True
566
def run(self):
567
b = Branch('.')
568
wt = b.working_tree()
569
basis_inv = b.basis_tree().inventory
570
inv = wt.inventory
571
for file_id in inv:
572
if file_id in basis_inv:
573
continue
574
path = inv.id2path(file_id)
575
if not os.access(b.abspath(path), os.F_OK):
576
continue
577
print path
578
579
580
581
class cmd_root(Command):
582
"""Show the tree root directory.
583
584
The root is the nearest enclosing directory with a .bzr control
585
directory."""
586
takes_args = ['filename?']
587
def run(self, filename=None):
588
"""Print the branch root."""
589
from branch import find_branch
590
b = find_branch(filename)
591
print getattr(b, 'base', None) or getattr(b, 'baseurl')
592
593
594
class cmd_log(Command):
595
"""Show log of this branch.
596
597
TODO: Option to limit range.
598
"""
599
600
takes_args = ['filename?']
601
takes_options = ['forward', 'timezone', 'verbose', 'show-ids']
602
603
def run(self, filename=None, timezone='original',
604
verbose=False,
605
show_ids=False,
606
forward=False):
607
from bzrlib import show_log, find_branch
608
import codecs
609
610
direction = (forward and 'forward') or 'reverse'
611
612
if filename:
613
b = find_branch(filename, lock_mode='r')
614
fp = b.relpath(filename)
615
if fp:
616
file_id = b.read_working_inventory().path2id(fp)
617
else:
618
file_id = None # points to branch root
619
else:
620
b = find_branch('.', lock_mode='r')
621
file_id = None
622
623
mutter('encoding log as %r' % bzrlib.user_encoding)
624
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout)
625
626
show_log(b, file_id,
627
show_timezone=timezone,
628
verbose=verbose,
629
show_ids=show_ids,
630
to_file=outf,
631
direction=direction)
632
633
634
635
class cmd_touching_revisions(Command):
636
"""Return revision-ids which affected a particular file.
637
638
A more user-friendly interface is "bzr log FILE"."""
639
hidden = True
640
takes_args = ["filename"]
641
def run(self, filename):
642
b = Branch(filename, lock_mode='r')
643
inv = b.read_working_inventory()
644
file_id = inv.path2id(b.relpath(filename))
645
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
646
print "%6d %s" % (revno, what)
647
648
649
class cmd_ls(Command):
650
"""List files in a tree.
651
652
TODO: Take a revision or remote path and list that tree instead.
653
"""
654
hidden = True
655
def run(self, revision=None, verbose=False):
656
b = Branch('.')
657
if revision == None:
658
tree = b.working_tree()
659
else:
660
tree = b.revision_tree(b.lookup_revision(revision))
661
662
for fp, fc, kind, fid in tree.list_files():
663
if verbose:
664
if kind == 'directory':
665
kindch = '/'
666
elif kind == 'file':
667
kindch = ''
668
else:
669
kindch = '???'
670
671
print '%-8s %s%s' % (fc, fp, kindch)
672
else:
673
print fp
674
675
676
677
class cmd_unknowns(Command):
678
"""List unknown files"""
679
def run(self):
680
for f in Branch('.').unknowns():
681
print quotefn(f)
682
683
684
685
class cmd_ignore(Command):
686
"""Ignore a command or pattern
687
688
To remove patterns from the ignore list, edit the .bzrignore file.
689
690
If the pattern contains a slash, it is compared to the whole path
691
from the branch root. Otherwise, it is comapred to only the last
692
component of the path.
693
694
Ignore patterns are case-insensitive on case-insensitive systems.
695
696
Note: wildcards must be quoted from the shell on Unix.
697
698
examples:
699
bzr ignore ./Makefile
700
bzr ignore '*.class'
701
"""
702
takes_args = ['name_pattern']
703
704
def run(self, name_pattern):
705
from bzrlib.atomicfile import AtomicFile
706
import codecs
707
708
b = Branch('.')
709
ifn = b.abspath('.bzrignore')
710
711
if os.path.exists(ifn):
712
f = open(ifn, 'rt')
713
try:
714
igns = f.read().decode('utf-8')
715
finally:
716
f.close()
717
else:
718
igns = ''
719
720
if igns and igns[-1] != '\n':
721
igns += '\n'
722
igns += name_pattern + '\n'
723
724
try:
725
f = AtomicFile(ifn, 'wt')
726
f.write(igns.encode('utf-8'))
727
f.commit()
728
finally:
729
f.close()
730
731
inv = b.working_tree().inventory
732
if inv.path2id('.bzrignore'):
733
mutter('.bzrignore is already versioned')
734
else:
735
mutter('need to make new .bzrignore file versioned')
736
b.add(['.bzrignore'])
737
738
739
740
class cmd_ignored(Command):
741
"""List ignored files and the patterns that matched them.
742
743
See also: bzr ignore"""
744
def run(self):
745
tree = Branch('.').working_tree()
746
for path, file_class, kind, file_id in tree.list_files():
747
if file_class != 'I':
748
continue
749
## XXX: Slightly inefficient since this was already calculated
750
pat = tree.is_ignored(path)
751
print '%-50s %s' % (path, pat)
752
753
754
class cmd_lookup_revision(Command):
755
"""Lookup the revision-id from a revision-number
756
757
example:
758
bzr lookup-revision 33
759
"""
760
hidden = True
761
takes_args = ['revno']
762
763
def run(self, revno):
764
try:
765
revno = int(revno)
766
except ValueError:
767
raise BzrCommandError("not a valid revision-number: %r" % revno)
768
769
print Branch('.').lookup_revision(revno)
770
771
772
class cmd_export(Command):
773
"""Export past revision to destination directory.
774
775
If no revision is specified this exports the last committed revision."""
776
takes_args = ['dest']
777
takes_options = ['revision']
778
def run(self, dest, revision=None):
779
b = Branch('.')
780
if revision == None:
781
rh = b.revision_history()[-1]
782
else:
783
rh = b.lookup_revision(int(revision))
784
t = b.revision_tree(rh)
785
t.export(dest)
786
787
788
class cmd_cat(Command):
789
"""Write a file's text from a previous revision."""
790
791
takes_options = ['revision']
792
takes_args = ['filename']
793
794
def run(self, filename, revision=None):
795
if revision == None:
796
raise BzrCommandError("bzr cat requires a revision number")
797
b = Branch('.')
798
b.print_file(b.relpath(filename), int(revision))
799
800
801
class cmd_local_time_offset(Command):
802
"""Show the offset in seconds from GMT to local time."""
803
hidden = True
804
def run(self):
805
print bzrlib.osutils.local_time_offset()
806
807
808
809
class cmd_commit(Command):
810
"""Commit changes into a new revision.
811
812
If selected files are specified, only changes to those files are
813
committed. If a directory is specified then its contents are also
814
committed.
815
816
A selected-file commit may fail in some cases where the committed
817
tree would be invalid, such as trying to commit a file in a
818
newly-added directory that is not itself committed.
819
820
TODO: Run hooks on tree to-be-committed, and after commit.
821
822
TODO: Strict commit that fails if there are unknown or deleted files.
823
"""
824
takes_args = ['selected*']
825
takes_options = ['message', 'file', 'verbose']
826
aliases = ['ci', 'checkin']
827
828
def run(self, message=None, file=None, verbose=True, selected_list=None):
829
from bzrlib.commit import commit
830
831
## Warning: shadows builtin file()
832
if not message and not file:
833
raise BzrCommandError("please specify a commit message",
834
["use either --message or --file"])
835
elif message and file:
836
raise BzrCommandError("please specify either --message or --file")
837
838
if file:
839
import codecs
840
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
841
842
b = Branch('.')
843
commit(b, message, verbose=verbose, specific_files=selected_list)
844
845
846
class cmd_check(Command):
847
"""Validate consistency of branch history.
848
849
This command checks various invariants about the branch storage to
850
detect data corruption or bzr bugs.
851
"""
852
takes_args = ['dir?']
853
def run(self, dir='.'):
854
import bzrlib.check
855
bzrlib.check.check(Branch(dir))
856
857
858
859
class cmd_whoami(Command):
860
"""Show bzr user id."""
861
takes_options = ['email']
862
863
def run(self, email=False):
864
if email:
865
print bzrlib.osutils.user_email()
866
else:
867
print bzrlib.osutils.username()
868
869
870
class cmd_selftest(Command):
871
"""Run internal test suite"""
872
hidden = True
873
def run(self):
874
failures, tests = 0, 0
875
876
import doctest, bzrlib.store
877
bzrlib.trace.verbose = False
878
879
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
880
bzrlib.tree, bzrlib.commands, bzrlib.add:
881
mf, mt = doctest.testmod(m)
882
failures += mf
883
tests += mt
884
print '%-40s %3d tests' % (m.__name__, mt),
885
if mf:
886
print '%3d FAILED!' % mf
887
else:
888
print
889
890
print '%-40s %3d tests' % ('total', tests),
891
if failures:
892
print '%3d FAILED!' % failures
893
return 1
894
else:
895
print
896
return 0
897
898
899
900
class cmd_version(Command):
901
"""Show version of bzr"""
902
def run(self):
903
show_version()
904
905
def show_version():
906
print "bzr (bazaar-ng) %s" % bzrlib.__version__
907
print bzrlib.__copyright__
908
print "http://bazaar-ng.org/"
909
print
910
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
911
print "you may use, modify and redistribute it under the terms of the GNU"
912
print "General Public License version 2 or later."
913
914
915
class cmd_rocks(Command):
916
"""Statement of optimism."""
917
hidden = True
918
def run(self):
919
print "it sure does!"
319
920
320
921
def parse_spec(spec):
321
"""
322
>>> parse_spec(None)
323
[None, None]
324
>>> parse_spec("./")
325
['./', None]
326
>>> parse_spec("../@")
327
['..', -1]
328
>>> parse_spec("../f/@35")
329
['../f', 35]
330
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
331
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
332
"""
333
if spec is None:
334
return [None, None]
335
922
if '/@' in spec:
336
923
parsed = spec.split('/@')
337
924
assert len(parsed) == 2
338
925
if parsed[1] == "":
339
926
parsed[1] = -1
340
927
else:
341
try:
342
parsed[1] = int(parsed[1])
343
except ValueError:
344
pass # We can allow stuff like ./@revid:blahblahblah
345
else:
346
assert parsed[1] >=0
928
parsed[1] = int(parsed[1])
929
assert parsed[1] >=0
347
930
else:
348
931
parsed = [spec, None]
349
932
return parsed
350
933
934
class cmd_merge(Command):
935
"""Perform a three-way merge of trees."""
936
takes_args = ['other_spec', 'base_spec']
937
938
def run(self, other_spec, base_spec):
939
merge.merge(parse_spec(other_spec), parse_spec(base_spec))
940
941
class cmd_assert_fail(Command):
942
"""Test reporting of assertion failures"""
943
hidden = True
944
def run(self):
945
assert False, "always fails"
946
947
948
class cmd_help(Command):
949
"""Show help on a command or other topic.
950
951
For a list of all available commands, say 'bzr help commands'."""
952
takes_args = ['topic?']
953
aliases = ['?']
954
955
def run(self, topic=None):
956
import help
957
help.help(topic)
958
959
960
class cmd_update_stat_cache(Command):
961
"""Update stat-cache mapping inodes to SHA-1 hashes.
962
963
For testing only."""
964
hidden = True
965
def run(self):
966
import statcache
967
b = Branch('.')
968
statcache.update_cache(b.base, b.read_working_inventory())
969
970
971
######################################################################
972
# main routine
973
351
974
352
975
# list of all available options; the rhs can be either None for an
353
976
# option that takes no argument, or a constructor function that checks
354
977
# the type.
355
978
OPTIONS = {
356
979
'all': None,
357
'diff-options': str,
358
980
'help': None,
359
981
'file': unicode,
360
'force': None,
361
'format': unicode,
362
982
'forward': None,
363
983
'message': unicode,
364
'no-recurse': None,
365
984
'profile': None,
366
'revision': _parse_revision_str,
367
'short': None,
985
'revision': int,
368
986
'show-ids': None,
369
987
'timezone': str,
370
988
'verbose': None,
371
989
'version': None,
372
990
'email': None,
373
'unchanged': None,
374
'update': None,
375
'long': None,
376
'root': str,
377
'no-backup': None,
378
'merge-type': get_merge_type,
379
'pattern': str,
380
991
}
381
992
382
993
SHORT_OPTIONS = {
994
'm': 'message',
383
995
'F': 'file',
384
'h': 'help',
385
'm': 'message',
386
996
'r': 'revision',
387
997
'v': 'verbose',
388
'l': 'long',
389
998
}
390
999
391
1000
399
1008
400
1009
>>> parse_args('--help'.split())
401
1010
([], {'help': True})
402
>>> parse_args('help -- --invalidcmd'.split())
403
(['help', '--invalidcmd'], {})
404
1011
>>> parse_args('--version'.split())
405
1012
([], {'version': True})
406
1013
>>> parse_args('status --all'.split())
407
1014
(['status'], {'all': True})
408
1015
>>> parse_args('commit --message=biter'.split())
409
1016
(['commit'], {'message': u'biter'})
410
>>> parse_args('log -r 500'.split())
411
(['log'], {'revision': [500]})
412
>>> parse_args('log -r500..600'.split())
413
(['log'], {'revision': [500, 600]})
414
>>> parse_args('log -vr500..600'.split())
415
(['log'], {'verbose': True, 'revision': [500, 600]})
416
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
417
(['log'], {'revision': ['v500', 600]})
418
1017
"""
419
1018
args = []
420
1019
opts = {}
421
1020
422
argsover = False
1021
# TODO: Maybe handle '--' to end options?
1022
423
1023
while argv:
424
1024
a = argv.pop(0)
425
if not argsover and a[0] == '-':
1025
if a[0] == '-':
426
1026
# option names must not be unicode
427
1027
a = str(a)
428
1028
optarg = None
429
1029
if a[1] == '-':
430
if a == '--':
431
# We've received a standalone -- No more flags
432
argsover = True
433
continue
434
1030
mutter(" got option %r" % a)
435
1031
if '=' in a:
436
1032
optname, optarg = a[2:].split('=', 1)
437
1033
else:
438
1034
optname = a[2:]
439
1035
if optname not in OPTIONS:
440
raise BzrError('unknown long option %r' % a)
1036
bailout('unknown long option %r' % a)
441
1037
else:
442
1038
shortopt = a[1:]
443
if shortopt in SHORT_OPTIONS:
444
# Multi-character options must have a space to delimit
445
# their value
446
optname = SHORT_OPTIONS[shortopt]
447
else:
448
# Single character short options, can be chained,
449
# and have their value appended to their name
450
shortopt = a[1:2]
451
if shortopt not in SHORT_OPTIONS:
452
# We didn't find the multi-character name, and we
453
# didn't find the single char name
454
raise BzrError('unknown short option %r' % a)
455
optname = SHORT_OPTIONS[shortopt]
456
457
if a[2:]:
458
# There are extra things on this option
459
# see if it is the value, or if it is another
460
# short option
461
optargfn = OPTIONS[optname]
462
if optargfn is None:
463
# This option does not take an argument, so the
464
# next entry is another short option, pack it back
465
# into the list
466
argv.insert(0, '-' + a[2:])
467
else:
468
# This option takes an argument, so pack it
469
# into the array
470
optarg = a[2:]
1039
if shortopt not in SHORT_OPTIONS:
1040
bailout('unknown short option %r' % a)
1041
optname = SHORT_OPTIONS[shortopt]
471
1042
472
1043
if optname in opts:
473
1044
# XXX: Do we ever want to support this, e.g. for -r?
474
raise BzrError('repeated option %r' % a)
1045
bailout('repeated option %r' % a)
475
1046
476
1047
optargfn = OPTIONS[optname]
477
1048
if optargfn:
478
1049
if optarg == None:
479
1050
if not argv:
480
raise BzrError('option %r needs an argument' % a)
1051
bailout('option %r needs an argument' % a)
481
1052
else:
482
1053
optarg = argv.pop(0)
483
1054
opts[optname] = optargfn(optarg)
484
1055
else:
485
1056
if optarg != None:
486
raise BzrError('option %r takes no argument' % optname)
1057
bailout('option %r takes no argument' % optname)
487
1058
opts[optname] = True
488
1059
else:
489
1060
args.append(a)
538
1109
539
1110
540
1111
541
def apply_profiled(the_callable, *args, **kwargs):
542
import hotshot
543
import tempfile
544
pffileno, pfname = tempfile.mkstemp()
545
try:
546
prof = hotshot.Profile(pfname)
547
try:
548
ret = prof.runcall(the_callable, *args, **kwargs) or 0
549
finally:
550
prof.close()
551
552
import hotshot.stats
553
stats = hotshot.stats.load(pfname)
554
#stats.strip_dirs()
555
stats.sort_stats('time')
556
## XXX: Might like to write to stderr or the trace file instead but
557
## print_stats seems hardcoded to stdout
558
stats.print_stats(20)
559
560
return ret
561
finally:
562
os.close(pffileno)
563
os.remove(pfname)
564
565
566
1112
def run_bzr(argv):
567
1113
"""Execute a command.
568
1114
569
1115
This is similar to main(), but without all the trappings for
570
1116
logging and error handling.
571
572
argv
573
The command-line arguments, without the program name from argv[0]
574
575
Returns a command status or raises an exception.
576
577
Special master options: these must come before the command because
578
they control how the command is interpreted.
579
580
--no-plugins
581
Do not load plugin modules at all
582
583
--builtin
584
Only use builtin commands. (Plugins are still allowed to change
585
other behaviour.)
586
587
--profile
588
Run under the Python profiler.
589
1117
"""
590
591
1118
argv = [a.decode(bzrlib.user_encoding) for a in argv]
592
593
opt_profile = opt_no_plugins = opt_builtin = False
594
595
# --no-plugins is handled specially at a very early stage. We need
596
# to load plugins before doing other command parsing so that they
597
# can override commands, but this needs to happen first.
598
599
for a in argv:
600
if a == '--profile':
601
opt_profile = True
602
elif a == '--no-plugins':
603
opt_no_plugins = True
604
elif a == '--builtin':
605
opt_builtin = True
606
else:
607
break
608
argv.remove(a)
609
610
if (not argv) or (argv[0] == '--help'):
611
from bzrlib.help import help
612
if len(argv) > 1:
613
help(argv[1])
614
else:
615
help()
616
return 0
617
618
if argv[0] == '--version':
619
from bzrlib.builtins import show_version
620
show_version()
621
return 0
622
623
if not opt_no_plugins:
624
from bzrlib.plugin import load_plugins
625
load_plugins()
626
627
cmd = str(argv.pop(0))
628
629
cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
630
631
if opt_profile:
632
ret = apply_profiled(cmd_obj.run_argv, argv)
633
else:
634
ret = cmd_obj.run_argv(argv)
635
return ret or 0
1119
1120
try:
1121
args, opts = parse_args(argv[1:])
1122
if 'help' in opts:
1123
import help
1124
if args:
1125
help.help(args[0])
1126
else:
1127
help.help()
1128
return 0
1129
elif 'version' in opts:
1130
show_version()
1131
return 0
1132
cmd = str(args.pop(0))
1133
except IndexError:
1134
import help
1135
help.help()
1136
return 1
1137
1138
1139
canonical_cmd, cmd_class = get_cmd_class(cmd)
1140
1141
# global option
1142
if 'profile' in opts:
1143
profile = True
1144
del opts['profile']
1145
else:
1146
profile = False
1147
1148
# check options are reasonable
1149
allowed = cmd_class.takes_options
1150
for oname in opts:
1151
if oname not in allowed:
1152
raise BzrCommandError("option '--%s' is not allowed for command %r"
1153
% (oname, cmd))
1154
1155
# mix arguments and options into one dictionary
1156
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1157
cmdopts = {}
1158
for k, v in opts.items():
1159
cmdopts[k.replace('-', '_')] = v
1160
1161
if profile:
1162
import hotshot, tempfile
1163
pffileno, pfname = tempfile.mkstemp()
1164
try:
1165
prof = hotshot.Profile(pfname)
1166
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1167
prof.close()
1168
1169
import hotshot.stats
1170
stats = hotshot.stats.load(pfname)
1171
#stats.strip_dirs()
1172
stats.sort_stats('time')
1173
## XXX: Might like to write to stderr or the trace file instead but
1174
## print_stats seems hardcoded to stdout
1175
stats.print_stats(20)
1176
1177
return ret.status
1178
1179
finally:
1180
os.close(pffileno)
1181
os.remove(pfname)
1182
else:
1183
return cmd_class(cmdopts, cmdargs).status
1184
1185
1186
def _report_exception(summary, quiet=False):
1187
import traceback
1188
log_error('bzr: ' + summary)
1189
bzrlib.trace.log_exception()
1190
1191
if not quiet:
1192
tb = sys.exc_info()[2]
1193
exinfo = traceback.extract_tb(tb)
1194
if exinfo:
1195
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1196
sys.stderr.write(' see ~/.bzr.log for debug information\n')
1197
636
1198
637
1199
638
1200
def main(argv):
639
import bzrlib.ui
640
bzrlib.trace.log_startup(argv)
641
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
1201
import errno
1202
1203
bzrlib.open_tracefile(argv)
642
1204
643
1205
try:
644
1206
try:
645
1207
try:
646
return run_bzr(argv[1:])
1208
return run_bzr(argv)
647
1209
finally:
648
1210
# do this here inside the exception wrappers to catch EPIPE
649
1211
sys.stdout.flush()
650
#wrap common errors as CommandErrors.
651
except (NotBranchError,), e:
652
raise BzrCommandError(str(e))
653
except BzrCommandError, e:
654
# command line syntax error, etc
655
log_error(str(e))
656
return 1
657
except BzrError, e:
658
bzrlib.trace.log_exception()
659
return 1
660
except AssertionError, e:
661
bzrlib.trace.log_exception('assertion failed: ' + str(e))
662
return 3
663
except KeyboardInterrupt, e:
664
bzrlib.trace.note('interrupted')
665
return 2
666
except Exception, e:
667
import errno
668
if (isinstance(e, IOError)
669
and hasattr(e, 'errno')
670
and e.errno == errno.EPIPE):
671
bzrlib.trace.note('broken pipe')
672
return 2
673
else:
674
bzrlib.trace.log_exception()
675
return 2
1212
except BzrError, e:
1213
quiet = isinstance(e, (BzrCommandError))
1214
_report_exception('error: ' + e.args[0], quiet=quiet)
1215
if len(e.args) > 1:
1216
for h in e.args[1]:
1217
# some explanation or hints
1218
log_error(' ' + h)
1219
return 1
1220
except AssertionError, e:
1221
msg = 'assertion failed'
1222
if str(e):
1223
msg += ': ' + str(e)
1224
_report_exception(msg)
1225
return 2
1226
except KeyboardInterrupt, e:
1227
_report_exception('interrupted', quiet=True)
1228
return 2
1229
except Exception, e:
1230
quiet = False
1231
if (isinstance(e, IOError)
1232
and hasattr(e, 'errno')
1233
and e.errno == errno.EPIPE):
1234
quiet = True
1235
msg = 'broken pipe'
1236
else:
1237
msg = str(e).rstrip('\n')
1238
_report_exception(msg, quiet)
1239
return 2
1240
finally:
1241
bzrlib.trace.close_trace()
676
1242
677
1243
678
1244
if __name__ == '__main__':
Loggerhead is a web-based interface for Breezy
Version: 2.0.1