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