« back to all changes in this revision
Viewing changes to bzr.py
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: mbp at sourcefrog
- Date: 2005-03-09 04:09:57 UTC
- Revision ID: mbp@sourcefrog.net-20050309040957-6cad07f466bb0bb8
add {arch} to default ignore pattern
- files removed:
- .bzrignore
- contrib
- contrib/bash
- contrib/zsh
- doc
- elementtree
- notes
- urlgrabber
- files renamed:
- bzrlib/commands.py => bzr.py
- files modified:
- README
added
removed
bzr.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
1
#! /usr/bin/python
2
3
4
# Copyright (C) 2004, 2005 by Martin Pool
5
# Copyright (C) 2005 by Canonical Ltd
6
2
7
3
8
# This program is free software; you can redistribute it and/or modify
4
9
# it under the terms of the GNU General Public License as published by
14
19
# along with this program; if not, write to the Free Software
15
20
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
21
17
18
19
import sys, os, time, os.path
22
"""Bazaar-NG -- a free distributed version-control tool
23
24
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
25
26
Current limitation include:
27
28
* Metadata format is not stable yet -- you may need to
29
discard history in the future.
30
31
* No handling of subdirectories, symlinks or any non-text files.
32
33
* Insufficient error handling.
34
35
* Many commands unimplemented or partially implemented.
36
37
* Space-inefficient storage.
38
39
* No merge operators yet.
40
41
Interesting commands::
42
43
bzr help
44
Show summary help screen
45
bzr version
46
Show software version/licence/non-warranty.
47
bzr init
48
Start versioning the current directory
49
bzr add FILE...
50
Make files versioned.
51
bzr log
52
Show revision history.
53
bzr diff
54
Show changes from last revision to working copy.
55
bzr commit -m 'MESSAGE'
56
Store current state as new revision.
57
bzr export REVNO DESTINATION
58
Export the branch state at a previous version.
59
bzr status
60
Show summary of pending changes.
61
bzr remove FILE...
62
Make a file not versioned.
63
"""
64
65
# not currently working:
66
# bzr check
67
# Run internal consistency checks.
68
# bzr info
69
# Show some information about this branch.
70
71
72
73
__copyright__ = "Copyright 2005 Canonical Development Ltd."
74
__author__ = "Martin Pool <mbp@canonical.com>"
75
__docformat__ = "restructuredtext en"
76
__version__ = '0.0.0'
77
78
79
import sys, os, random, time, sha, sets, types, re, shutil, tempfile
80
import traceback, socket, fnmatch, difflib
81
from os import path
20
82
from sets import Set
83
from pprint import pprint
84
from stat import *
85
from glob import glob
86
from ElementTree import Element, ElementTree, SubElement
21
87
22
88
import bzrlib
89
from bzrlib.store import ImmutableStore
23
90
from bzrlib.trace import mutter, note, log_error
24
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
91
from bzrlib.errors import bailout, BzrError
25
92
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
26
93
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
27
94
from bzrlib.revision import Revision
28
95
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
29
96
format_date
30
97
31
32
def _squish_command_name(cmd):
33
return 'cmd_' + cmd.replace('-', '_')
34
35
36
def _unsquish_command_name(cmd):
37
assert cmd.startswith("cmd_")
38
return cmd[4:].replace('_','-')
39
40
def get_all_cmds():
41
"""Return canonical name and class for all registered commands."""
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):
47
"""Return the canonical name and command class for a command.
48
"""
49
cmd = str(cmd) # not unicode
50
51
# first look up this command under the specified name
52
try:
53
return cmd, globals()[_squish_command_name(cmd)]
54
except KeyError:
55
pass
56
57
# look for any command which claims this as an alias
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)
67
68
69
class Command:
70
"""Base class for commands.
71
72
The docstring for an actual command should give a single-line
73
summary, then a complete description of the command. A grammar
74
description will be inserted.
75
76
takes_args
77
List of argument forms, marked with whether they are optional,
78
repeated, etc.
79
80
takes_options
81
List of options that may be given for this command.
82
83
hidden
84
If true, this command isn't advertised.
85
"""
86
aliases = []
87
88
takes_args = []
89
takes_options = []
90
91
hidden = False
92
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)
104
105
106
def run(self):
107
"""Override this in sub-classes.
108
109
This is invoked with the options and arguments bound to
110
keyword parameters.
111
112
Return 0 or None if the command was successful, or a shell
113
error code if not.
114
"""
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):
98
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
99
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
100
101
## standard representation
102
NONE_STRING = '(none)'
103
EMPTY = 'empty'
104
105
106
## TODO: Perhaps a different version of inventory commands that
107
## returns iterators...
108
109
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
110
111
## TODO: Some kind of locking on branches. Perhaps there should be a
112
## parameter to the branch object saying whether we want a read or
113
## write lock; release it from destructor. Perhaps don't even need a
114
## read lock to look at immutable objects?
115
116
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
117
## to compare output?
118
119
## TODO: Is ElementTree really all that much better for our purposes?
120
## Perhaps using the standard MiniDOM would be enough?
121
122
123
124
125
126
127
######################################################################
128
# check status
129
130
131
def cmd_status(all=False):
190
132
"""Display status summary.
191
133
192
134
For each file there is a single line giving its file state and name.
193
135
The name is that in the current revision unless it is deleted or
194
136
missing, in which case the old name is shown.
195
"""
196
takes_args = ['file*']
197
takes_options = ['all']
198
aliases = ['st', 'stat']
199
200
def run(self, all=False, file_list=None):
201
b = Branch('.', lock_mode='r')
202
b.show_status(show_all=all, file_list=file_list)
203
204
205
class cmd_cat_revision(Command):
206
"""Write out metadata for a revision."""
207
208
hidden = True
209
takes_args = ['revision_id']
210
211
def run(self, revision_id):
212
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
213
214
215
class cmd_revno(Command):
216
"""Show current revision number.
217
218
This is equal to the number of revisions on this branch."""
219
def run(self):
220
print Branch('.').revno()
221
222
223
class cmd_add(Command):
224
"""Add specified files or directories.
225
226
In non-recursive mode, all the named items are added, regardless
227
of whether they were previously ignored. A warning is given if
228
any of the named files are already versioned.
229
230
In recursive mode (the default), files are treated the same way
231
but the behaviour for directories is different. Directories that
232
are already versioned do not give a warning. All directories,
233
whether already versioned or not, are searched for files or
234
subdirectories that are neither versioned or ignored, and these
235
are added. This search proceeds recursively into versioned
236
directories.
237
238
Therefore simply saying 'bzr add .' will version all files that
239
are currently unknown.
240
241
TODO: Perhaps adding a file whose directly is not versioned should
242
recursively add that parent, rather than giving an error?
243
"""
244
takes_args = ['file+']
245
takes_options = ['verbose']
246
247
def run(self, file_list, verbose=False):
248
bzrlib.add.smart_add(file_list, verbose)
249
250
251
class cmd_relpath(Command):
252
"""Show path of a file relative to root"""
253
takes_args = ['filename']
254
255
def run(self, filename):
256
print Branch(filename).relpath(filename)
257
258
259
260
class cmd_inventory(Command):
261
"""Show inventory of the current working copy or a revision."""
262
takes_options = ['revision']
263
264
def run(self, revision=None):
265
b = Branch('.')
266
if revision == None:
267
inv = b.read_working_inventory()
268
else:
269
inv = b.get_revision_inventory(b.lookup_revision(revision))
270
271
for path, entry in inv.iter_entries():
272
print '%-50s %s' % (entry.file_id, path)
273
274
275
class cmd_move(Command):
276
"""Move files to a different directory.
277
278
examples:
279
bzr move *.txt doc
280
281
The destination must be a versioned directory in the same branch.
282
"""
283
takes_args = ['source$', 'dest']
284
def run(self, source_list, dest):
285
b = Branch('.')
286
287
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
288
289
290
class cmd_rename(Command):
291
"""Change the name of an entry.
292
293
examples:
294
bzr rename frob.c frobber.c
295
bzr rename src/frob.c lib/frob.c
296
297
It is an error if the destination name exists.
298
299
See also the 'move' command, which moves files into a different
300
directory without changing their name.
301
302
TODO: Some way to rename multiple files without invoking bzr for each
303
one?"""
304
takes_args = ['from_name', 'to_name']
305
306
def run(self, from_name, to_name):
307
b = Branch('.')
308
b.rename_one(b.relpath(from_name), b.relpath(to_name))
309
310
311
312
class cmd_renames(Command):
313
"""Show list of renamed files.
314
315
TODO: Option to show renames between two historical versions.
316
317
TODO: Only show renames under dir, rather than in the whole branch.
318
"""
319
takes_args = ['dir?']
320
321
def run(self, dir='.'):
322
b = Branch(dir)
323
old_inv = b.basis_tree().inventory
324
new_inv = b.read_working_inventory()
325
326
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
327
renames.sort()
328
for old_name, new_name in renames:
329
print "%s => %s" % (old_name, new_name)
330
331
332
class cmd_info(Command):
333
"""Show statistical information for this branch"""
334
def run(self):
335
import info
336
info.show_info(Branch('.'))
337
338
339
class cmd_remove(Command):
340
"""Make a file unversioned.
341
342
This makes bzr stop tracking changes to a versioned file. It does
343
not delete the working copy.
344
"""
345
takes_args = ['file+']
346
takes_options = ['verbose']
347
348
def run(self, file_list, verbose=False):
349
b = Branch(file_list[0])
350
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
351
352
353
class cmd_file_id(Command):
354
"""Print file_id of a particular file or directory.
355
356
The file_id is assigned when the file is first added and remains the
357
same through all revisions where the file exists, even when it is
358
moved or renamed.
359
"""
360
hidden = True
361
takes_args = ['filename']
362
def run(self, filename):
363
b = Branch(filename)
364
i = b.inventory.path2id(b.relpath(filename))
365
if i == None:
366
bailout("%r is not a versioned file" % filename)
367
else:
368
print i
369
370
371
class cmd_file_path(Command):
372
"""Print path of file_ids to a file or directory.
373
374
This prints one line for each directory down to the target,
375
starting at the branch root."""
376
hidden = True
377
takes_args = ['filename']
378
def run(self, filename):
379
b = Branch(filename)
380
inv = b.inventory
381
fid = inv.path2id(b.relpath(filename))
382
if fid == None:
383
bailout("%r is not a versioned file" % filename)
384
for fip in inv.get_idpath(fid):
385
print fip
386
387
388
class cmd_revision_history(Command):
389
"""Display list of revision ids on this branch."""
390
def run(self):
391
for patchid in Branch('.').revision_history():
392
print patchid
393
394
395
class cmd_directories(Command):
396
"""Display list of versioned directories in this branch."""
397
def run(self):
398
for name, ie in Branch('.').read_working_inventory().directories():
399
if name == '':
400
print '.'
401
else:
402
print name
403
404
405
class cmd_init(Command):
406
"""Make a directory into a versioned branch.
407
408
Use this to create an empty branch, or before importing an
409
existing project.
410
411
Recipe for importing a tree of files:
412
cd ~/project
413
bzr init
414
bzr add -v .
415
bzr status
416
bzr commit -m 'imported project'
417
"""
418
def run(self):
419
Branch('.', init=True)
420
421
422
class cmd_diff(Command):
423
"""Show differences in working tree.
424
425
If files are listed, only the changes in those files are listed.
426
Otherwise, all changes for the tree are listed.
427
428
TODO: Given two revision arguments, show the difference between them.
429
430
TODO: Allow diff across branches.
431
432
TODO: Option to use external diff command; could be GNU diff, wdiff,
433
or a graphical diff.
434
435
TODO: Python difflib is not exactly the same as unidiff; should
436
either fix it up or prefer to use an external diff.
437
438
TODO: If a directory is given, diff everything under that.
439
440
TODO: Selected-file diff is inefficient and doesn't show you
441
deleted files.
442
443
TODO: This probably handles non-Unix newlines poorly.
444
"""
445
446
takes_args = ['file*']
447
takes_options = ['revision']
448
aliases = ['di']
449
450
def run(self, revision=None, file_list=None):
451
from bzrlib.diff import show_diff
452
453
show_diff(Branch('.'), revision, file_list)
454
455
456
class cmd_deleted(Command):
457
"""List files deleted in the working tree.
458
459
TODO: Show files deleted since a previous revision, or between two revisions.
460
"""
461
def run(self, show_ids=False):
462
b = Branch('.')
463
old = b.basis_tree()
464
new = b.working_tree()
465
466
## TODO: Much more efficient way to do this: read in new
467
## directories with readdir, rather than stating each one. Same
468
## level of effort but possibly much less IO. (Or possibly not,
469
## if the directories are very large...)
470
471
for path, ie in old.inventory.iter_entries():
472
if not new.has_id(ie.file_id):
473
if show_ids:
474
print '%-50s %s' % (path, ie.file_id)
475
else:
476
print path
477
478
class cmd_root(Command):
479
"""Show the tree root directory.
480
481
The root is the nearest enclosing directory with a .bzr control
482
directory."""
483
takes_args = ['filename?']
484
def run(self, filename=None):
485
"""Print the branch root."""
486
from branch import find_branch
487
b = find_branch(filename)
488
print getattr(b, 'base', None) or getattr(b, 'baseurl')
489
490
491
class cmd_log(Command):
137
138
:todo: Don't show unchanged files unless ``--all`` is given?
139
"""
140
Branch('.').show_status(show_all=all)
141
142
143
144
######################################################################
145
# examining history
146
def cmd_get_revision(revision_id):
147
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
148
149
150
def cmd_get_inventory(inventory_id):
151
"""Return inventory in XML by hash"""
152
Branch('.').get_inventory(inventory_hash).write_xml(sys.stdout)
153
154
155
def cmd_get_revision_inventory(revision_id):
156
"""Output inventory for a revision."""
157
b = Branch('.')
158
b.get_revision_inventory(revision_id).write_xml(sys.stdout)
159
160
161
def cmd_get_file_text(text_id):
162
"""Get contents of a file by hash."""
163
sf = Branch('.').text_store[text_id]
164
pumpfile(sf, sys.stdout)
165
166
167
168
######################################################################
169
# commands
170
171
172
def cmd_revno():
173
"""Show number of revisions on this branch"""
174
print Branch('.').revno()
175
176
177
def cmd_add(file_list, verbose=False):
178
"""Add specified files.
179
180
Fails if the files are already added.
181
"""
182
Branch('.').add(file_list, verbose=verbose)
183
184
185
def cmd_inventory(revision=None):
186
"""Show inventory of the current working copy."""
187
## TODO: Also optionally show a previous inventory
188
## TODO: Format options
189
b = Branch('.')
190
if revision == None:
191
inv = b.read_working_inventory()
192
else:
193
inv = b.get_revision_inventory(b.lookup_revision(revision))
194
195
for path, entry in inv.iter_entries():
196
print '%-50s %s' % (entry.file_id, path)
197
198
199
200
def cmd_info():
201
b = Branch('.')
202
print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
203
print 'revision number:', b.revno()
204
print 'number of versioned files:', len(b.read_working_inventory())
205
206
207
def cmd_remove(file_list, verbose=False):
208
Branch('.').remove(file_list, verbose=verbose)
209
210
211
212
def cmd_file_id(filename):
213
i = Branch('.').read_working_inventory().path2id(filename)
214
if i is None:
215
bailout("%s is not a versioned file" % filename)
216
else:
217
print i
218
219
220
def cmd_find_filename(fileid):
221
n = find_filename(fileid)
222
if n is None:
223
bailout("%s is not a live file id" % fileid)
224
else:
225
print n
226
227
228
def cmd_revision_history():
229
for patchid in Branch('.').revision_history():
230
print patchid
231
232
233
234
def cmd_init():
235
# TODO: Check we're not already in a working directory? At the
236
# moment you'll get an ugly error.
237
238
# TODO: What if we're in a subdirectory of a branch? Would like
239
# to allow that, but then the parent may need to understand that
240
# the children have disappeared, or should they be versioned in
241
# both?
242
243
# TODO: Take an argument/option for branch name.
244
Branch('.', init=True)
245
246
247
def cmd_diff(revision=None):
248
"""Show diff from basis to working copy.
249
250
:todo: Take one or two revision arguments, look up those trees,
251
and diff them.
252
253
:todo: Allow diff across branches.
254
255
:todo: Mangle filenames in diff to be more relevant.
256
257
:todo: Shouldn't be in the cmd function.
258
"""
259
260
b = Branch('.')
261
262
if revision == None:
263
old_tree = b.basis_tree()
264
else:
265
old_tree = b.revision_tree(b.lookup_revision(revision))
266
267
new_tree = b.working_tree()
268
old_inv = old_tree.inventory
269
new_inv = new_tree.inventory
270
271
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
272
old_label = ''
273
new_label = ''
274
275
DEVNULL = '/dev/null'
276
# Windows users, don't panic about this filename -- it is a
277
# special signal to GNU patch that the file should be created or
278
# deleted respectively.
279
280
# TODO: Generation of pseudo-diffs for added/deleted files could
281
# be usefully made into a much faster special case.
282
283
# TODO: Better to return them in sorted order I think.
284
285
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
286
d = None
287
288
# Don't show this by default; maybe do it if an option is passed
289
# idlabel = ' {%s}' % fid
290
idlabel = ''
291
292
# FIXME: Something about the diff format makes patch unhappy
293
# with newly-added files.
294
295
def diffit(*a, **kw):
296
sys.stdout.writelines(difflib.unified_diff(*a, **kw))
297
print
298
299
if file_state in ['.', '?', 'I']:
300
continue
301
elif file_state == 'A':
302
print '*** added %s %r' % (kind, new_name)
303
if kind == 'file':
304
diffit([],
305
new_tree.get_file(fid).readlines(),
306
fromfile=DEVNULL,
307
tofile=new_label + new_name + idlabel)
308
elif file_state == 'D':
309
assert isinstance(old_name, types.StringTypes)
310
print '*** deleted %s %r' % (kind, old_name)
311
if kind == 'file':
312
diffit(old_tree.get_file(fid).readlines(), [],
313
fromfile=old_label + old_name + idlabel,
314
tofile=DEVNULL)
315
elif file_state in ['M', 'R']:
316
if file_state == 'M':
317
assert kind == 'file'
318
assert old_name == new_name
319
print '*** modified %s %r' % (kind, new_name)
320
elif file_state == 'R':
321
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
322
323
if kind == 'file':
324
diffit(old_tree.get_file(fid).readlines(),
325
new_tree.get_file(fid).readlines(),
326
fromfile=old_label + old_name + idlabel,
327
tofile=new_label + new_name)
328
else:
329
bailout("can't represent state %s {%s}" % (file_state, fid))
330
331
332
333
def cmd_log():
492
334
"""Show log of this branch.
493
335
494
TODO: Option to limit range.
495
496
TODO: Perhaps show most-recent first with an option for last.
336
:todo: Options for utc; to show ids; to limit range; etc.
497
337
"""
498
takes_args = ['filename?']
499
takes_options = ['timezone', 'verbose', 'show-ids']
500
def run(self, filename=None, timezone='original', verbose=False, show_ids=False):
501
from branch import find_branch
502
b = find_branch((filename or '.'), lock_mode='r')
503
if filename:
504
filename = b.relpath(filename)
505
bzrlib.show_log(b, filename,
506
show_timezone=timezone,
507
verbose=verbose,
508
show_ids=show_ids)
509
510
511
512
class cmd_touching_revisions(Command):
513
"""Return revision-ids which affected a particular file."""
514
hidden = True
515
takes_args = ["filename"]
516
def run(self, filename):
517
b = Branch(filename, lock_mode='r')
518
inv = b.read_working_inventory()
519
file_id = inv.path2id(b.relpath(filename))
520
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
521
print "%6d %s" % (revno, what)
522
523
524
class cmd_ls(Command):
338
Branch('.').write_log()
339
340
341
def cmd_ls(revision=None, verbose=False):
525
342
"""List files in a tree.
526
343
527
TODO: Take a revision or remote path and list that tree instead.
344
:todo: Take a revision or remote path and list that tree instead.
528
345
"""
529
hidden = True
530
def run(self, revision=None, verbose=False):
531
b = Branch('.')
532
if revision == None:
533
tree = b.working_tree()
346
b = Branch('.')
347
if revision == None:
348
tree = b.working_tree()
349
else:
350
tree = b.revision_tree(b.lookup_revision(revision))
351
352
for fp, fc, kind, fid in tree.list_files():
353
if verbose:
354
if kind == 'directory':
355
kindch = '/'
356
elif kind == 'file':
357
kindch = ''
358
else:
359
kindch = '???'
360
361
print '%-8s %s%s' % (fc, fp, kindch)
534
362
else:
535
tree = b.revision_tree(b.lookup_revision(revision))
536
537
for fp, fc, kind, fid in tree.list_files():
538
if verbose:
539
if kind == 'directory':
540
kindch = '/'
541
elif kind == 'file':
542
kindch = ''
543
else:
544
kindch = '???'
545
546
print '%-8s %s%s' % (fc, fp, kindch)
547
else:
548
print fp
549
550
551
552
class cmd_unknowns(Command):
363
print fp
364
365
366
367
def cmd_unknowns():
553
368
"""List unknown files"""
554
def run(self):
555
for f in Branch('.').unknowns():
556
print quotefn(f)
557
558
559
560
class cmd_ignore(Command):
561
"""Ignore a command or pattern
562
563
To remove patterns from the ignore list, edit the .bzrignore file.
564
565
If the pattern contains a slash, it is compared to the whole path
566
from the branch root. Otherwise, it is comapred to only the last
567
component of the path.
568
569
Ignore patterns are case-insensitive on case-insensitive systems.
570
571
Note: wildcards must be quoted from the shell on Unix.
572
573
examples:
574
bzr ignore ./Makefile
575
bzr ignore '*.class'
576
"""
577
takes_args = ['name_pattern']
578
579
def run(self, name_pattern):
580
from bzrlib.atomicfile import AtomicFile
581
import codecs
582
583
b = Branch('.')
584
ifn = b.abspath('.bzrignore')
585
586
# FIXME: probably doesn't handle non-ascii patterns
587
588
if os.path.exists(ifn):
589
f = b.controlfile(ifn, 'rt')
590
igns = f.read()
591
f.close()
592
else:
593
igns = ''
594
595
if igns and igns[-1] != '\n':
596
igns += '\n'
597
igns += name_pattern + '\n'
598
599
f = AtomicFile(ifn, 'wt')
600
f.write(igns)
601
f.commit()
602
603
inv = b.working_tree().inventory
604
if inv.path2id('.bzrignore'):
605
mutter('.bzrignore is already versioned')
606
else:
607
mutter('need to make new .bzrignore file versioned')
608
b.add(['.bzrignore'])
609
610
611
612
class cmd_ignored(Command):
613
"""List ignored files and the patterns that matched them.
614
615
See also: bzr ignore"""
616
def run(self):
617
tree = Branch('.').working_tree()
618
for path, file_class, kind, file_id in tree.list_files():
619
if file_class != 'I':
620
continue
621
## XXX: Slightly inefficient since this was already calculated
622
pat = tree.is_ignored(path)
623
print '%-50s %s' % (path, pat)
624
625
626
class cmd_lookup_revision(Command):
627
"""Lookup the revision-id from a revision-number
628
629
example:
630
bzr lookup-revision 33
631
"""
632
hidden = True
633
takes_args = ['revno']
634
635
def run(self, revno):
636
try:
637
revno = int(revno)
638
except ValueError:
639
raise BzrCommandError("not a valid revision-number: %r" % revno)
640
641
print Branch('.').lookup_revision(revno)
642
643
644
class cmd_export(Command):
645
"""Export past revision to destination directory.
646
647
If no revision is specified this exports the last committed revision."""
648
takes_args = ['dest']
649
takes_options = ['revision']
650
def run(self, dest, revision=None):
651
b = Branch('.')
652
if revision == None:
653
rh = b.revision_history()[-1]
654
else:
655
rh = b.lookup_revision(int(revision))
656
t = b.revision_tree(rh)
657
t.export(dest)
658
659
660
class cmd_cat(Command):
661
"""Write a file's text from a previous revision."""
662
663
takes_options = ['revision']
664
takes_args = ['filename']
665
666
def run(self, filename, revision=None):
667
if revision == None:
668
raise BzrCommandError("bzr cat requires a revision number")
669
b = Branch('.')
670
b.print_file(b.relpath(filename), int(revision))
671
672
673
class cmd_local_time_offset(Command):
674
"""Show the offset in seconds from GMT to local time."""
675
hidden = True
676
def run(self):
677
print bzrlib.osutils.local_time_offset()
678
679
680
681
class cmd_commit(Command):
682
"""Commit changes into a new revision.
683
684
TODO: Commit only selected files.
685
686
TODO: Run hooks on tree to-be-committed, and after commit.
687
688
TODO: Strict commit that fails if there are unknown or deleted files.
689
"""
690
takes_options = ['message', 'file', 'verbose']
691
aliases = ['ci', 'checkin']
692
693
def run(self, message=None, file=None, verbose=False):
694
## Warning: shadows builtin file()
695
if not message and not file:
696
raise BzrCommandError("please specify a commit message",
697
["use either --message or --file"])
698
elif message and file:
699
raise BzrCommandError("please specify either --message or --file")
369
for f in Branch('.').unknowns():
370
print quotefn(f)
371
372
373
def cmd_lookup_revision(revno):
374
try:
375
revno = int(revno)
376
except ValueError:
377
bailout("usage: lookup-revision REVNO",
378
["REVNO is a non-negative revision number for this branch"])
379
380
print Branch('.').lookup_revision(revno) or NONE_STRING
381
382
383
384
def cmd_export(revno, dest):
385
"""Export past revision to destination directory."""
386
b = Branch('.')
387
rh = b.lookup_revision(int(revno))
388
t = b.revision_tree(rh)
389
t.export(dest)
390
391
392
393
######################################################################
394
# internal/test commands
395
396
397
def cmd_uuid():
398
"""Print a newly-generated UUID."""
399
print uuid()
400
401
402
403
def cmd_commit(message, verbose=False):
404
Branch('.').commit(message, verbose=verbose)
405
406
407
def cmd_check():
408
"""Check consistency of the branch."""
409
check()
410
411
412
def cmd_is(pred, *rest):
413
"""Test whether PREDICATE is true."""
414
try:
415
cmd_handler = globals()['assert_' + pred.replace('-', '_')]
416
except KeyError:
417
bailout("unknown predicate: %s" % quotefn(pred))
700
418
701
if file:
702
import codecs
703
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
704
705
Branch('.').commit(message, verbose=verbose)
706
707
708
class cmd_check(Command):
709
"""Validate consistency of branch history.
710
711
This command checks various invariants about the branch storage to
712
detect data corruption or bzr bugs.
713
"""
714
takes_args = ['dir?']
715
def run(self, dir='.'):
716
import bzrlib.check
717
bzrlib.check.check(Branch(dir, find_root=False))
718
719
720
721
class cmd_whoami(Command):
722
"""Show bzr user id."""
723
takes_options = ['email']
419
try:
420
cmd_handler(*rest)
421
except BzrCheckError:
422
# by default we don't print the message so that this can
423
# be used from shell scripts without producing noise
424
sys.exit(1)
425
426
427
def cmd_username():
428
print bzrlib.osutils.username()
429
430
431
def cmd_user_email():
432
print bzrlib.osutils.user_email()
433
434
435
def cmd_gen_revision_id():
436
import time
437
print bzrlib.branch._gen_revision_id(time.time())
438
439
440
def cmd_doctest():
441
"""Run internal doctest suite"""
442
## -v, if present, is seen by doctest; the argument is just here
443
## so our parser doesn't complain
444
445
## TODO: --verbose option
724
446
725
def run(self, email=False):
726
if email:
727
print bzrlib.osutils.user_email()
728
else:
729
print bzrlib.osutils.username()
730
731
732
class cmd_selftest(Command):
733
"""Run internal test suite"""
734
hidden = True
735
def run(self):
736
failures, tests = 0, 0
737
738
import doctest, bzrlib.store, bzrlib.tests
739
bzrlib.trace.verbose = False
740
741
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
742
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
743
mf, mt = doctest.testmod(m)
744
failures += mf
745
tests += mt
746
print '%-40s %3d tests' % (m.__name__, mt),
747
if mf:
748
print '%3d FAILED!' % mf
749
else:
750
print
751
752
print '%-40s %3d tests' % ('total', tests),
753
if failures:
754
print '%3d FAILED!' % failures
755
else:
756
print
757
758
759
760
class cmd_version(Command):
761
"""Show version of bzr"""
762
def run(self):
763
show_version()
764
765
def show_version():
766
print "bzr (bazaar-ng) %s" % bzrlib.__version__
767
print bzrlib.__copyright__
447
import bzr, doctest, bzrlib.store
448
bzrlib.trace.verbose = False
449
doctest.testmod(bzr)
450
doctest.testmod(bzrlib.store)
451
doctest.testmod(bzrlib.inventory)
452
doctest.testmod(bzrlib.branch)
453
doctest.testmod(bzrlib.osutils)
454
doctest.testmod(bzrlib.tree)
455
456
# more strenuous tests;
457
import bzrlib.tests
458
doctest.testmod(bzrlib.tests)
459
460
461
######################################################################
462
# help
463
464
465
def cmd_help():
466
# TODO: Specific help for particular commands
467
print __doc__
468
469
470
def cmd_version():
471
print "bzr (bazaar-ng) %s" % __version__
472
print __copyright__
768
473
print "http://bazaar-ng.org/"
769
474
print
770
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
771
print "you may use, modify and redistribute it under the terms of the GNU"
772
print "General Public License version 2 or later."
773
774
775
class cmd_rocks(Command):
475
print \
476
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
477
you may use, modify and redistribute it under the terms of the GNU
478
General Public License version 2 or later."""
479
480
481
def cmd_rocks():
776
482
"""Statement of optimism."""
777
hidden = True
778
def run(self):
779
print "it sure does!"
780
781
782
class cmd_assert_fail(Command):
783
"""Test reporting of assertion failures"""
784
hidden = True
785
def run(self):
786
assert False, "always fails"
787
788
789
class cmd_help(Command):
790
"""Show help on a command or other topic.
791
792
For a list of all available commands, say 'bzr help commands'."""
793
takes_args = ['topic?']
794
aliases = ['?']
795
796
def run(self, topic=None):
797
import help
798
help.help(topic)
799
800
801
class cmd_update_stat_cache(Command):
802
"""Update stat-cache mapping inodes to SHA-1 hashes.
803
804
For testing only."""
805
hidden = True
806
def run(self):
807
import statcache
808
b = Branch('.')
809
inv = b.read_working_inventory()
810
statcache.update_cache(b, inv)
483
print "it sure does!"
484
811
485
812
486
813
487
######################################################################
820
494
OPTIONS = {
821
495
'all': None,
822
496
'help': None,
823
'file': unicode,
824
497
'message': unicode,
825
'profile': None,
826
498
'revision': int,
827
499
'show-ids': None,
828
'timezone': str,
829
500
'verbose': None,
830
501
'version': None,
831
'email': None,
832
502
}
833
503
834
504
SHORT_OPTIONS = {
835
505
'm': 'message',
836
'F': 'file',
837
506
'r': 'revision',
838
507
'v': 'verbose',
839
508
}
840
509
510
# List of options that apply to particular commands; commands not
511
# listed take none.
512
cmd_options = {
513
'add': ['verbose'],
514
'commit': ['message', 'verbose'],
515
'diff': ['revision'],
516
'inventory': ['revision'],
517
'ls': ['revision', 'verbose'],
518
'status': ['all'],
519
'log': ['show-ids'],
520
'remove': ['verbose'],
521
}
522
523
524
cmd_args = {
525
'init': [],
526
'add': ['file+'],
527
'commit': [],
528
'diff': [],
529
'file-id': ['filename'],
530
'get-file-text': ['text_id'],
531
'get-inventory': ['inventory_id'],
532
'get-revision': ['revision_id'],
533
'get-revision-inventory': ['revision_id'],
534
'log': [],
535
'lookup-revision': ['revno'],
536
'export': ['revno', 'dest'],
537
'remove': ['file+'],
538
'status': [],
539
}
540
841
541
842
542
def parse_args(argv):
843
543
"""Parse command line.
847
547
lookup table, something about the available options, what optargs
848
548
they take, and which commands will accept them.
849
549
850
>>> parse_args('--help'.split())
550
>>> parse_args('bzr --help'.split())
851
551
([], {'help': True})
852
>>> parse_args('--version'.split())
552
>>> parse_args('bzr --version'.split())
853
553
([], {'version': True})
854
>>> parse_args('status --all'.split())
554
>>> parse_args('bzr status --all'.split())
855
555
(['status'], {'all': True})
856
>>> parse_args('commit --message=biter'.split())
857
(['commit'], {'message': u'biter'})
858
556
"""
859
557
args = []
860
558
opts = {}
861
559
862
560
# TODO: Maybe handle '--' to end options?
863
561
864
while argv:
865
a = argv.pop(0)
562
it = iter(argv[1:])
563
while it:
564
a = it.next()
866
565
if a[0] == '-':
867
# option names must not be unicode
868
a = str(a)
869
optarg = None
870
566
if a[1] == '-':
871
567
mutter(" got option %r" % a)
872
if '=' in a:
873
optname, optarg = a[2:].split('=', 1)
874
else:
875
optname = a[2:]
568
optname = a[2:]
876
569
if optname not in OPTIONS:
877
570
bailout('unknown long option %r' % a)
878
571
else:
884
577
if optname in opts:
885
578
# XXX: Do we ever want to support this, e.g. for -r?
886
579
bailout('repeated option %r' % a)
887
888
580
optargfn = OPTIONS[optname]
889
581
if optargfn:
890
if optarg == None:
891
if not argv:
892
bailout('option %r needs an argument' % a)
893
else:
894
optarg = argv.pop(0)
895
opts[optname] = optargfn(optarg)
582
if not it:
583
bailout('option %r needs an argument' % a)
584
opts[optname] = optargfn(it.next())
585
mutter(" option argument %r" % opts[optname])
896
586
else:
897
if optarg != None:
898
bailout('option %r takes no argument' % optname)
587
# takes no option argument
899
588
opts[optname] = True
589
elif a[:1] == '-':
590
bailout('unknown short option %r' % a)
900
591
else:
901
592
args.append(a)
902
593
904
595
905
596
906
597
598
def _match_args(cmd, args):
599
"""Check non-option arguments match required pattern.
907
600
908
def _match_argform(cmd, takes_args, args):
601
>>> _match_args('status', ['asdasdsadasd'])
602
Traceback (most recent call last):
603
...
604
BzrError: ("extra arguments to command status: ['asdasdsadasd']", [])
605
>>> _match_args('add', ['asdasdsadasd'])
606
{'file_list': ['asdasdsadasd']}
607
>>> _match_args('add', 'abc def gj'.split())
608
{'file_list': ['abc', 'def', 'gj']}
609
"""
610
# match argument pattern
611
argform = cmd_args.get(cmd, [])
909
612
argdict = {}
910
911
# step through args and takes_args, allowing appropriate 0-many matches
912
for ap in takes_args:
613
# TODO: Need a way to express 'cp SRC... DEST', where it matches
614
# all but one.
615
for ap in argform:
913
616
argname = ap[:-1]
914
617
if ap[-1] == '?':
915
if args:
916
argdict[argname] = args.pop(0)
917
elif ap[-1] == '*': # all remaining arguments
918
if args:
919
argdict[argname + '_list'] = args[:]
920
args = []
921
else:
922
argdict[argname + '_list'] = None
618
assert 0
619
elif ap[-1] == '*':
620
assert 0
923
621
elif ap[-1] == '+':
924
622
if not args:
925
raise BzrCommandError("command %r needs one or more %s"
623
bailout("command %r needs one or more %s"
926
624
% (cmd, argname.upper()))
927
625
else:
928
626
argdict[argname + '_list'] = args[:]
929
627
args = []
930
elif ap[-1] == '$': # all but one
931
if len(args) < 2:
932
raise BzrCommandError("command %r needs one or more %s"
933
% (cmd, argname.upper()))
934
argdict[argname + '_list'] = args[:-1]
935
args[:-1] = []
936
628
else:
937
629
# just a plain arg
938
630
argname = ap
939
631
if not args:
940
raise BzrCommandError("command %r requires argument %s"
632
bailout("command %r requires argument %s"
941
633
% (cmd, argname.upper()))
942
634
else:
943
635
argdict[argname] = args.pop(0)
944
636
945
637
if args:
946
raise BzrCommandError("extra argument to command %s: %s"
947
% (cmd, args[0]))
638
bailout("extra arguments to command %s: %r"
639
% (cmd, args))
948
640
949
641
return argdict
950
642
954
646
"""Execute a command.
955
647
956
648
This is similar to main(), but without all the trappings for
957
logging and error handling.
649
logging and error handling.
958
650
"""
959
argv = [a.decode(bzrlib.user_encoding) for a in argv]
960
961
651
try:
962
args, opts = parse_args(argv[1:])
652
args, opts = parse_args(argv)
963
653
if 'help' in opts:
964
import help
965
if args:
966
help.help(args[0])
967
else:
968
help.help()
654
# TODO: pass down other arguments in case they asked for
655
# help on a command name?
656
cmd_help()
969
657
return 0
970
658
elif 'version' in opts:
971
show_version()
659
cmd_version()
972
660
return 0
973
cmd = str(args.pop(0))
661
cmd = args.pop(0)
974
662
except IndexError:
975
log_error('usage: bzr COMMAND')
976
log_error(' try "bzr help"')
663
log_error('usage: bzr COMMAND\n')
664
log_error(' try "bzr help"\n')
977
665
return 1
978
979
canonical_cmd, cmd_class = get_cmd_class(cmd)
980
981
# global option
982
if 'profile' in opts:
983
profile = True
984
del opts['profile']
985
else:
986
profile = False
666
667
try:
668
cmd_handler = globals()['cmd_' + cmd.replace('-', '_')]
669
except KeyError:
670
bailout("unknown command " + `cmd`)
671
672
# TODO: special --profile option to turn on the Python profiler
987
673
988
674
# check options are reasonable
989
allowed = cmd_class.takes_options
675
allowed = cmd_options.get(cmd, [])
990
676
for oname in opts:
991
677
if oname not in allowed:
992
raise BzrCommandError("option '--%s' is not allowed for command %r"
993
% (oname, cmd))
994
995
# mix arguments and options into one dictionary
996
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
997
cmdopts = {}
998
for k, v in opts.items():
999
cmdopts[k.replace('-', '_')] = v
1000
1001
if profile:
1002
import hotshot, tempfile
1003
pffileno, pfname = tempfile.mkstemp()
1004
try:
1005
prof = hotshot.Profile(pfname)
1006
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1007
prof.close()
1008
1009
import hotshot.stats
1010
stats = hotshot.stats.load(pfname)
1011
#stats.strip_dirs()
1012
stats.sort_stats('time')
1013
## XXX: Might like to write to stderr or the trace file instead but
1014
## print_stats seems hardcoded to stdout
1015
stats.print_stats(20)
1016
1017
return ret.status
1018
1019
finally:
1020
os.close(pffileno)
1021
os.remove(pfname)
1022
else:
1023
cmdobj = cmd_class(cmdopts, cmdargs).status
1024
1025
1026
def _report_exception(summary, quiet=False):
1027
import traceback
1028
log_error('bzr: ' + summary)
1029
bzrlib.trace.log_exception()
1030
1031
if not quiet:
1032
tb = sys.exc_info()[2]
1033
exinfo = traceback.extract_tb(tb)
1034
if exinfo:
1035
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1036
sys.stderr.write(' see ~/.bzr.log for debug information\n')
678
bailout("option %r is not allowed for command %r"
679
% (oname, cmd))
680
681
cmdargs = _match_args(cmd, args)
682
cmdargs.update(opts)
683
684
ret = cmd_handler(**cmdargs) or 0
1037
685
1038
686
1039
687
1040
688
def main(argv):
1041
import errno
1042
1043
bzrlib.open_tracefile(argv)
689
## TODO: Handle command-line options; probably know what options are valid for
690
## each command
691
692
## TODO: If the arguments are wrong, give a usage message rather
693
## than just a backtrace.
1044
694
1045
695
try:
1046
try:
1047
try:
1048
return run_bzr(argv)
1049
finally:
1050
# do this here inside the exception wrappers to catch EPIPE
1051
sys.stdout.flush()
1052
except BzrError, e:
1053
quiet = isinstance(e, (BzrCommandError))
1054
_report_exception('error: ' + e.args[0], quiet=quiet)
1055
if len(e.args) > 1:
1056
for h in e.args[1]:
1057
# some explanation or hints
1058
log_error(' ' + h)
1059
return 1
1060
except AssertionError, e:
1061
msg = 'assertion failed'
1062
if str(e):
1063
msg += ': ' + str(e)
1064
_report_exception(msg)
1065
return 2
1066
except KeyboardInterrupt, e:
1067
_report_exception('interrupted', quiet=True)
1068
return 2
1069
except Exception, e:
1070
quiet = False
1071
if (isinstance(e, IOError)
1072
and hasattr(e, 'errno')
1073
and e.errno == errno.EPIPE):
1074
quiet = True
1075
msg = 'broken pipe'
1076
else:
1077
msg = str(e).rstrip('\n')
1078
_report_exception(msg, quiet)
1079
return 2
1080
finally:
1081
bzrlib.trace.close_trace()
696
t = bzrlib.trace._tracefile
697
t.write('-' * 60 + '\n')
698
t.write('bzr invoked at %s\n' % format_date(time.time()))
699
t.write(' by %s on %s\n' % (bzrlib.osutils.username(), socket.gethostname()))
700
t.write(' arguments: %r\n' % argv)
701
702
starttime = os.times()[4]
703
704
import platform
705
t.write(' platform: %s\n' % platform.platform())
706
t.write(' python: %s\n' % platform.python_version())
707
708
ret = run_bzr(argv)
709
710
times = os.times()
711
mutter("finished, %.3fu/%.3fs cpu, %.3fu/%.3fs cum"
712
% times[:4])
713
mutter(" %.3f elapsed" % (times[4] - starttime))
714
715
return ret
716
except BzrError, e:
717
log_error('bzr: error: ' + e.args[0] + '\n')
718
if len(e.args) > 1:
719
for h in e.args[1]:
720
log_error(' ' + h + '\n')
721
return 1
722
except Exception, e:
723
log_error('bzr: exception: %s\n' % e)
724
log_error(' see .bzr.log for details\n')
725
traceback.print_exc(None, bzrlib.trace._tracefile)
726
traceback.print_exc(None, sys.stderr)
727
return 1
728
729
# TODO: Maybe nicer handling of IOError?
730
1082
731
1083
732
1084
733
if __name__ == '__main__':
1085
734
sys.exit(main(sys.argv))
735
##import profile
736
##profile.run('main(sys.argv)')
737
Loggerhead is a web-based interface for Breezy
Version: 2.0.1