« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 984
- compare with another revision
- download diff
- download tarball
- view history from revision 984
- Committer: Martin Pool
- Date: 2005-07-27 14:53:50 UTC
- Revision ID: mbp@sourcefrog.net-20050727145350-563719542b87b856
- tidy up docstring
- files added:
- .bzrignore
- bzrlib/selftest
- contrib
- contrib/bash
- contrib/zsh
- effbot
- effbot/org
- elementtree
- patches
- plugins
- plugins/changeset
- tools
- urlgrabber
- files removed:
- bzrlib/tests.py
- files renamed:
- bzr.py => bzrlib/commands.py
- files modified:
- README
added
removed
bzrlib/commands.py
1
#! /usr/bin/python
2
3
4
# Copyright (C) 2004, 2005 by Martin Pool
5
# Copyright (C) 2005 by Canonical Ltd
6
1
# Copyright (C) 2004, 2005 by Canonical Ltd
7
2
8
3
# This program is free software; you can redistribute it and/or modify
9
4
# it under the terms of the GNU General Public License as published by
19
14
# along with this program; if not, write to the Free Software
20
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
16
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
82
from sets import Set
83
from pprint import pprint
84
from stat import *
85
from glob import glob
17
18
19
import sys, os
86
20
87
21
import bzrlib
88
from bzrlib.store import ImmutableStore
89
from bzrlib.trace import mutter, note, log_error
90
from bzrlib.errors import bailout, BzrError
91
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
92
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
93
from bzrlib.revision import Revision
94
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
95
format_date
96
97
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
98
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
99
100
## standard representation
101
NONE_STRING = '(none)'
102
EMPTY = 'empty'
103
104
105
## TODO: Perhaps a different version of inventory commands that
106
## returns iterators...
107
108
## TODO: Perhaps an AtomicFile class that writes to a temporary file and then renames.
109
110
## TODO: Some kind of locking on branches. Perhaps there should be a
111
## parameter to the branch object saying whether we want a read or
112
## write lock; release it from destructor. Perhaps don't even need a
113
## read lock to look at immutable objects?
114
115
## TODO: Perhaps make UUIDs predictable in test mode to make it easier
116
## to compare output?
117
118
119
120
121
######################################################################
122
# check status
123
124
125
def cmd_status(all=False):
22
from bzrlib.trace import mutter, note, log_error, warning
23
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.branch import find_branch
25
from bzrlib import BZRDIR
26
27
28
plugin_cmds = {}
29
30
31
def register_command(cmd):
32
"Utility function to help register a command"
33
global plugin_cmds
34
k = cmd.__name__
35
if k.startswith("cmd_"):
36
k_unsquished = _unsquish_command_name(k)
37
else:
38
k_unsquished = k
39
if not plugin_cmds.has_key(k_unsquished):
40
plugin_cmds[k_unsquished] = cmd
41
else:
42
log_error('Two plugins defined the same command: %r' % k)
43
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
44
45
46
def _squish_command_name(cmd):
47
return 'cmd_' + cmd.replace('-', '_')
48
49
50
def _unsquish_command_name(cmd):
51
assert cmd.startswith("cmd_")
52
return cmd[4:].replace('_','-')
53
54
55
def _parse_revision_str(revstr):
56
"""This handles a revision string -> revno.
57
58
This always returns a list. The list will have one element for
59
60
It supports integers directly, but everything else it
61
defers for passing to Branch.get_revision_info()
62
63
>>> _parse_revision_str('234')
64
[234]
65
>>> _parse_revision_str('234..567')
66
[234, 567]
67
>>> _parse_revision_str('..')
68
[None, None]
69
>>> _parse_revision_str('..234')
70
[None, 234]
71
>>> _parse_revision_str('234..')
72
[234, None]
73
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
74
[234, 456, 789]
75
>>> _parse_revision_str('234....789') # Error?
76
[234, None, 789]
77
>>> _parse_revision_str('revid:test@other.com-234234')
78
['revid:test@other.com-234234']
79
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
80
['revid:test@other.com-234234', 'revid:test@other.com-234235']
81
>>> _parse_revision_str('revid:test@other.com-234234..23')
82
['revid:test@other.com-234234', 23]
83
>>> _parse_revision_str('date:2005-04-12')
84
['date:2005-04-12']
85
>>> _parse_revision_str('date:2005-04-12 12:24:33')
86
['date:2005-04-12 12:24:33']
87
>>> _parse_revision_str('date:2005-04-12T12:24:33')
88
['date:2005-04-12T12:24:33']
89
>>> _parse_revision_str('date:2005-04-12,12:24:33')
90
['date:2005-04-12,12:24:33']
91
>>> _parse_revision_str('-5..23')
92
[-5, 23]
93
>>> _parse_revision_str('-5')
94
[-5]
95
>>> _parse_revision_str('123a')
96
['123a']
97
>>> _parse_revision_str('abc')
98
['abc']
99
"""
100
import re
101
old_format_re = re.compile('\d*:\d*')
102
m = old_format_re.match(revstr)
103
if m:
104
warning('Colon separator for revision numbers is deprecated.'
105
' Use .. instead')
106
revs = []
107
for rev in revstr.split(':'):
108
if rev:
109
revs.append(int(rev))
110
else:
111
revs.append(None)
112
return revs
113
revs = []
114
for x in revstr.split('..'):
115
if not x:
116
revs.append(None)
117
else:
118
try:
119
revs.append(int(x))
120
except ValueError:
121
revs.append(x)
122
return revs
123
124
125
126
def _get_cmd_dict(plugins_override=True):
127
d = {}
128
for k, v in globals().iteritems():
129
if k.startswith("cmd_"):
130
d[_unsquish_command_name(k)] = v
131
# If we didn't load plugins, the plugin_cmds dict will be empty
132
if plugins_override:
133
d.update(plugin_cmds)
134
else:
135
d2 = plugin_cmds.copy()
136
d2.update(d)
137
d = d2
138
return d
139
140
141
def get_all_cmds(plugins_override=True):
142
"""Return canonical name and class for all registered commands."""
143
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
144
yield k,v
145
146
147
def get_cmd_class(cmd, plugins_override=True):
148
"""Return the canonical name and command class for a command.
149
"""
150
cmd = str(cmd) # not unicode
151
152
# first look up this command under the specified name
153
cmds = _get_cmd_dict(plugins_override=plugins_override)
154
try:
155
return cmd, cmds[cmd]
156
except KeyError:
157
pass
158
159
# look for any command which claims this as an alias
160
for cmdname, cmdclass in cmds.iteritems():
161
if cmd in cmdclass.aliases:
162
return cmdname, cmdclass
163
164
cmdclass = ExternalCommand.find_command(cmd)
165
if cmdclass:
166
return cmd, cmdclass
167
168
raise BzrCommandError("unknown command %r" % cmd)
169
170
171
class Command(object):
172
"""Base class for commands.
173
174
The docstring for an actual command should give a single-line
175
summary, then a complete description of the command. A grammar
176
description will be inserted.
177
178
takes_args
179
List of argument forms, marked with whether they are optional,
180
repeated, etc.
181
182
takes_options
183
List of options that may be given for this command.
184
185
hidden
186
If true, this command isn't advertised.
187
"""
188
aliases = []
189
190
takes_args = []
191
takes_options = []
192
193
hidden = False
194
195
def __init__(self, options, arguments):
196
"""Construct and run the command.
197
198
Sets self.status to the return value of run()."""
199
assert isinstance(options, dict)
200
assert isinstance(arguments, dict)
201
cmdargs = options.copy()
202
cmdargs.update(arguments)
203
if self.__doc__ == Command.__doc__:
204
from warnings import warn
205
warn("No help message set for %r" % self)
206
self.status = self.run(**cmdargs)
207
if self.status is None:
208
self.status = 0
209
210
211
def run(self):
212
"""Override this in sub-classes.
213
214
This is invoked with the options and arguments bound to
215
keyword parameters.
216
217
Return 0 or None if the command was successful, or a shell
218
error code if not.
219
"""
220
return 0
221
222
223
class ExternalCommand(Command):
224
"""Class to wrap external commands.
225
226
We cheat a little here, when get_cmd_class() calls us we actually
227
give it back an object we construct that has the appropriate path,
228
help, options etc for the specified command.
229
230
When run_bzr() tries to instantiate that 'class' it gets caught by
231
the __call__ method, which we override to call the Command.__init__
232
method. That then calls our run method which is pretty straight
233
forward.
234
235
The only wrinkle is that we have to map bzr's dictionary of options
236
and arguments back into command line options and arguments for the
237
script.
238
"""
239
240
def find_command(cls, cmd):
241
import os.path
242
bzrpath = os.environ.get('BZRPATH', '')
243
244
for dir in bzrpath.split(os.pathsep):
245
path = os.path.join(dir, cmd)
246
if os.path.isfile(path):
247
return ExternalCommand(path)
248
249
return None
250
251
find_command = classmethod(find_command)
252
253
def __init__(self, path):
254
self.path = path
255
256
pipe = os.popen('%s --bzr-usage' % path, 'r')
257
self.takes_options = pipe.readline().split()
258
259
for opt in self.takes_options:
260
if not opt in OPTIONS:
261
raise BzrError("Unknown option '%s' returned by external command %s"
262
% (opt, path))
263
264
# TODO: Is there any way to check takes_args is valid here?
265
self.takes_args = pipe.readline().split()
266
267
if pipe.close() is not None:
268
raise BzrError("Failed funning '%s --bzr-usage'" % path)
269
270
pipe = os.popen('%s --bzr-help' % path, 'r')
271
self.__doc__ = pipe.read()
272
if pipe.close() is not None:
273
raise BzrError("Failed funning '%s --bzr-help'" % path)
274
275
def __call__(self, options, arguments):
276
Command.__init__(self, options, arguments)
277
return self
278
279
def run(self, **kargs):
280
opts = []
281
args = []
282
283
keys = kargs.keys()
284
keys.sort()
285
for name in keys:
286
optname = name.replace('_','-')
287
value = kargs[name]
288
if OPTIONS.has_key(optname):
289
# it's an option
290
opts.append('--%s' % optname)
291
if value is not None and value is not True:
292
opts.append(str(value))
293
else:
294
# it's an arg, or arg list
295
if type(value) is not list:
296
value = [value]
297
for v in value:
298
if v is not None:
299
args.append(str(v))
300
301
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
302
return self.status
303
304
305
class cmd_status(Command):
126
306
"""Display status summary.
127
307
128
For each file there is a single line giving its file state and name.
129
The name is that in the current revision unless it is deleted or
130
missing, in which case the old name is shown.
131
132
:todo: Don't show unchanged files unless ``--all`` is given?
133
"""
134
Branch('.').show_status(show_all=all)
135
136
137
138
######################################################################
139
# examining history
140
def cmd_get_revision(revision_id):
141
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
142
143
144
def cmd_get_inventory(inventory_id):
145
"""Return inventory in XML by hash"""
146
Branch('.').get_inventory(inventory_hash).write_xml(sys.stdout)
147
148
149
def cmd_get_revision_inventory(revision_id):
150
"""Output inventory for a revision."""
151
b = Branch('.')
152
b.get_revision_inventory(revision_id).write_xml(sys.stdout)
153
154
155
def cmd_get_file_text(text_id):
156
"""Get contents of a file by hash."""
157
sf = Branch('.').text_store[text_id]
158
pumpfile(sf, sys.stdout)
159
160
161
162
######################################################################
163
# commands
164
165
166
def cmd_revno():
167
"""Show number of revisions on this branch"""
168
print Branch('.').revno()
169
170
171
def cmd_add(file_list, verbose=False):
172
"""Add specified files.
173
174
Fails if the files are already added.
175
"""
176
Branch('.').add(file_list, verbose=verbose)
177
178
179
def cmd_inventory(revision=None):
180
"""Show inventory of the current working copy."""
181
## TODO: Also optionally show a previous inventory
182
## TODO: Format options
183
b = Branch('.')
184
if revision == None:
308
This reports on versioned and unknown files, reporting them
309
grouped by state. Possible states are:
310
311
added
312
Versioned in the working copy but not in the previous revision.
313
314
removed
315
Versioned in the previous revision but removed or deleted
316
in the working copy.
317
318
renamed
319
Path of this file changed from the previous revision;
320
the text may also have changed. This includes files whose
321
parent directory was renamed.
322
323
modified
324
Text has changed since the previous revision.
325
326
unchanged
327
Nothing about this file has changed since the previous revision.
328
Only shown with --all.
329
330
unknown
331
Not versioned and not matching an ignore pattern.
332
333
To see ignored files use 'bzr ignored'. For details in the
334
changes to file texts, use 'bzr diff'.
335
336
If no arguments are specified, the status of the entire working
337
directory is shown. Otherwise, only the status of the specified
338
files or directories is reported. If a directory is given, status
339
is reported for everything inside that directory.
340
341
If a revision is specified, the changes since that revision are shown.
342
"""
343
takes_args = ['file*']
344
takes_options = ['all', 'show-ids', 'revision']
345
aliases = ['st', 'stat']
346
347
def run(self, all=False, show_ids=False, file_list=None):
348
if file_list:
349
b = find_branch(file_list[0])
350
file_list = [b.relpath(x) for x in file_list]
351
# special case: only one path was given and it's the root
352
# of the branch
353
if file_list == ['']:
354
file_list = None
355
else:
356
b = find_branch('.')
357
358
from bzrlib.status import show_status
359
show_status(b, show_unchanged=all, show_ids=show_ids,
360
specific_files=file_list)
361
362
363
class cmd_cat_revision(Command):
364
"""Write out metadata for a revision."""
365
366
hidden = True
367
takes_args = ['revision_id']
368
369
def run(self, revision_id):
370
from bzrlib.xml import pack_xml
371
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
372
373
374
class cmd_revno(Command):
375
"""Show current revision number.
376
377
This is equal to the number of revisions on this branch."""
378
def run(self):
379
print find_branch('.').revno()
380
381
class cmd_revision_info(Command):
382
"""Show revision number and revision id for a given revision identifier.
383
"""
384
hidden = True
385
takes_args = ['revision_info*']
386
takes_options = ['revision']
387
def run(self, revision=None, revision_info_list=None):
388
from bzrlib.branch import find_branch
389
390
revs = []
391
if revision is not None:
392
revs.extend(revision)
393
if revision_info_list is not None:
394
revs.extend(revision_info_list)
395
if len(revs) == 0:
396
raise BzrCommandError('You must supply a revision identifier')
397
398
b = find_branch('.')
399
400
for rev in revs:
401
print '%4d %s' % b.get_revision_info(rev)
402
403
404
class cmd_add(Command):
405
"""Add specified files or directories.
406
407
In non-recursive mode, all the named items are added, regardless
408
of whether they were previously ignored. A warning is given if
409
any of the named files are already versioned.
410
411
In recursive mode (the default), files are treated the same way
412
but the behaviour for directories is different. Directories that
413
are already versioned do not give a warning. All directories,
414
whether already versioned or not, are searched for files or
415
subdirectories that are neither versioned or ignored, and these
416
are added. This search proceeds recursively into versioned
417
directories. If no names are given '.' is assumed.
418
419
Therefore simply saying 'bzr add' will version all files that
420
are currently unknown.
421
422
TODO: Perhaps adding a file whose directly is not versioned should
423
recursively add that parent, rather than giving an error?
424
"""
425
takes_args = ['file*']
426
takes_options = ['verbose', 'no-recurse']
427
428
def run(self, file_list, verbose=False, no_recurse=False):
429
from bzrlib.add import smart_add
430
smart_add(file_list, verbose, not no_recurse)
431
432
433
434
class cmd_mkdir(Command):
435
"""Create a new versioned directory.
436
437
This is equivalent to creating the directory and then adding it.
438
"""
439
takes_args = ['dir+']
440
441
def run(self, dir_list):
442
b = None
443
444
for d in dir_list:
445
os.mkdir(d)
446
if not b:
447
b = find_branch(d)
448
b.add([d], verbose=True)
449
450
451
class cmd_relpath(Command):
452
"""Show path of a file relative to root"""
453
takes_args = ['filename']
454
hidden = True
455
456
def run(self, filename):
457
print find_branch(filename).relpath(filename)
458
459
460
461
class cmd_inventory(Command):
462
"""Show inventory of the current working copy or a revision."""
463
takes_options = ['revision', 'show-ids']
464
465
def run(self, revision=None, show_ids=False):
466
b = find_branch('.')
467
if revision == None:
468
inv = b.read_working_inventory()
469
else:
470
if len(revision) > 1:
471
raise BzrCommandError('bzr inventory --revision takes'
472
' exactly one revision identifier')
473
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
474
475
for path, entry in inv.entries():
476
if show_ids:
477
print '%-50s %s' % (path, entry.file_id)
478
else:
479
print path
480
481
482
class cmd_move(Command):
483
"""Move files to a different directory.
484
485
examples:
486
bzr move *.txt doc
487
488
The destination must be a versioned directory in the same branch.
489
"""
490
takes_args = ['source$', 'dest']
491
def run(self, source_list, dest):
492
b = find_branch('.')
493
494
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
495
496
497
class cmd_rename(Command):
498
"""Change the name of an entry.
499
500
examples:
501
bzr rename frob.c frobber.c
502
bzr rename src/frob.c lib/frob.c
503
504
It is an error if the destination name exists.
505
506
See also the 'move' command, which moves files into a different
507
directory without changing their name.
508
509
TODO: Some way to rename multiple files without invoking bzr for each
510
one?"""
511
takes_args = ['from_name', 'to_name']
512
513
def run(self, from_name, to_name):
514
b = find_branch('.')
515
b.rename_one(b.relpath(from_name), b.relpath(to_name))
516
517
518
519
520
521
class cmd_pull(Command):
522
"""Pull any changes from another branch into the current one.
523
524
If the location is omitted, the last-used location will be used.
525
Both the revision history and the working directory will be
526
updated.
527
528
This command only works on branches that have not diverged. Branches are
529
considered diverged if both branches have had commits without first
530
pulling from the other.
531
532
If branches have diverged, you can use 'bzr merge' to pull the text changes
533
from one into the other.
534
"""
535
takes_args = ['location?']
536
537
def run(self, location=None):
538
from bzrlib.merge import merge
539
import tempfile
540
from shutil import rmtree
541
import errno
542
543
br_to = find_branch('.')
544
stored_loc = None
545
try:
546
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
547
except IOError, e:
548
if e.errno != errno.ENOENT:
549
raise
550
if location is None:
551
if stored_loc is None:
552
raise BzrCommandError("No pull location known or specified.")
553
else:
554
print "Using last location: %s" % stored_loc
555
location = stored_loc
556
cache_root = tempfile.mkdtemp()
557
from bzrlib.branch import DivergedBranches
558
br_from = find_branch(location)
559
location = pull_loc(br_from)
560
old_revno = br_to.revno()
561
try:
562
from branch import find_cached_branch, DivergedBranches
563
br_from = find_cached_branch(location, cache_root)
564
location = pull_loc(br_from)
565
old_revno = br_to.revno()
566
try:
567
br_to.update_revisions(br_from)
568
except DivergedBranches:
569
raise BzrCommandError("These branches have diverged."
570
" Try merge.")
571
572
merge(('.', -1), ('.', old_revno), check_clean=False)
573
if location != stored_loc:
574
br_to.controlfile("x-pull", "wb").write(location + "\n")
575
finally:
576
rmtree(cache_root)
577
578
579
580
class cmd_branch(Command):
581
"""Create a new copy of a branch.
582
583
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
584
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
585
586
To retrieve the branch as of a particular revision, supply the --revision
587
parameter, as in "branch foo/bar -r 5".
588
"""
589
takes_args = ['from_location', 'to_location?']
590
takes_options = ['revision']
591
592
def run(self, from_location, to_location=None, revision=None):
593
import errno
594
from bzrlib.merge import merge
595
from bzrlib.branch import DivergedBranches, NoSuchRevision, \
596
find_cached_branch, Branch
597
from shutil import rmtree
598
from meta_store import CachedStore
599
import tempfile
600
cache_root = tempfile.mkdtemp()
601
602
if revision is None:
603
revision = [None]
604
elif len(revision) > 1:
605
raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
606
607
try:
608
try:
609
br_from = find_cached_branch(from_location, cache_root)
610
except OSError, e:
611
if e.errno == errno.ENOENT:
612
raise BzrCommandError('Source location "%s" does not'
613
' exist.' % to_location)
614
else:
615
raise
616
617
if to_location is None:
618
to_location = os.path.basename(from_location.rstrip("/\\"))
619
620
try:
621
os.mkdir(to_location)
622
except OSError, e:
623
if e.errno == errno.EEXIST:
624
raise BzrCommandError('Target directory "%s" already'
625
' exists.' % to_location)
626
if e.errno == errno.ENOENT:
627
raise BzrCommandError('Parent of "%s" does not exist.' %
628
to_location)
629
else:
630
raise
631
br_to = Branch(to_location, init=True)
632
633
br_to.set_root_id(br_from.get_root_id())
634
635
if revision:
636
if revision[0] is None:
637
revno = br_from.revno()
638
else:
639
revno, rev_id = br_from.get_revision_info(revision[0])
640
try:
641
br_to.update_revisions(br_from, stop_revision=revno)
642
except NoSuchRevision:
643
rmtree(to_location)
644
msg = "The branch %s has no revision %d." % (from_location,
645
revno)
646
raise BzrCommandError(msg)
647
648
merge((to_location, -1), (to_location, 0), this_dir=to_location,
649
check_clean=False, ignore_zero=True)
650
from_location = pull_loc(br_from)
651
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
652
finally:
653
rmtree(cache_root)
654
655
656
def pull_loc(branch):
657
# TODO: Should perhaps just make attribute be 'base' in
658
# RemoteBranch and Branch?
659
if hasattr(branch, "baseurl"):
660
return branch.baseurl
661
else:
662
return branch.base
663
664
665
666
class cmd_renames(Command):
667
"""Show list of renamed files.
668
669
TODO: Option to show renames between two historical versions.
670
671
TODO: Only show renames under dir, rather than in the whole branch.
672
"""
673
takes_args = ['dir?']
674
675
def run(self, dir='.'):
676
b = find_branch(dir)
677
old_inv = b.basis_tree().inventory
678
new_inv = b.read_working_inventory()
679
680
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
681
renames.sort()
682
for old_name, new_name in renames:
683
print "%s => %s" % (old_name, new_name)
684
685
686
class cmd_info(Command):
687
"""Show statistical information about a branch."""
688
takes_args = ['branch?']
689
690
def run(self, branch=None):
691
import info
692
693
b = find_branch(branch)
694
info.show_info(b)
695
696
697
class cmd_remove(Command):
698
"""Make a file unversioned.
699
700
This makes bzr stop tracking changes to a versioned file. It does
701
not delete the working copy.
702
"""
703
takes_args = ['file+']
704
takes_options = ['verbose']
705
706
def run(self, file_list, verbose=False):
707
b = find_branch(file_list[0])
708
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
709
710
711
class cmd_file_id(Command):
712
"""Print file_id of a particular file or directory.
713
714
The file_id is assigned when the file is first added and remains the
715
same through all revisions where the file exists, even when it is
716
moved or renamed.
717
"""
718
hidden = True
719
takes_args = ['filename']
720
def run(self, filename):
721
b = find_branch(filename)
722
i = b.inventory.path2id(b.relpath(filename))
723
if i == None:
724
raise BzrError("%r is not a versioned file" % filename)
725
else:
726
print i
727
728
729
class cmd_file_path(Command):
730
"""Print path of file_ids to a file or directory.
731
732
This prints one line for each directory down to the target,
733
starting at the branch root."""
734
hidden = True
735
takes_args = ['filename']
736
def run(self, filename):
737
b = find_branch(filename)
738
inv = b.inventory
739
fid = inv.path2id(b.relpath(filename))
740
if fid == None:
741
raise BzrError("%r is not a versioned file" % filename)
742
for fip in inv.get_idpath(fid):
743
print fip
744
745
746
class cmd_revision_history(Command):
747
"""Display list of revision ids on this branch."""
748
hidden = True
749
def run(self):
750
for patchid in find_branch('.').revision_history():
751
print patchid
752
753
754
class cmd_directories(Command):
755
"""Display list of versioned directories in this branch."""
756
def run(self):
757
for name, ie in find_branch('.').read_working_inventory().directories():
758
if name == '':
759
print '.'
760
else:
761
print name
762
763
764
class cmd_init(Command):
765
"""Make a directory into a versioned branch.
766
767
Use this to create an empty branch, or before importing an
768
existing project.
769
770
Recipe for importing a tree of files:
771
cd ~/project
772
bzr init
773
bzr add -v .
774
bzr status
775
bzr commit -m 'imported project'
776
"""
777
def run(self):
778
from bzrlib.branch import Branch
779
Branch('.', init=True)
780
781
782
class cmd_diff(Command):
783
"""Show differences in working tree.
784
785
If files are listed, only the changes in those files are listed.
786
Otherwise, all changes for the tree are listed.
787
788
TODO: Given two revision arguments, show the difference between them.
789
790
TODO: Allow diff across branches.
791
792
TODO: Option to use external diff command; could be GNU diff, wdiff,
793
or a graphical diff.
794
795
TODO: Python difflib is not exactly the same as unidiff; should
796
either fix it up or prefer to use an external diff.
797
798
TODO: If a directory is given, diff everything under that.
799
800
TODO: Selected-file diff is inefficient and doesn't show you
801
deleted files.
802
803
TODO: This probably handles non-Unix newlines poorly.
804
"""
805
806
takes_args = ['file*']
807
takes_options = ['revision', 'diff-options']
808
aliases = ['di', 'dif']
809
810
def run(self, revision=None, file_list=None, diff_options=None):
811
from bzrlib.diff import show_diff
812
813
if file_list:
814
b = find_branch(file_list[0])
815
file_list = [b.relpath(f) for f in file_list]
816
if file_list == ['']:
817
# just pointing to top-of-tree
818
file_list = None
819
else:
820
b = find_branch('.')
821
822
# TODO: Make show_diff support taking 2 arguments
823
base_rev = None
824
if revision is not None:
825
if len(revision) != 1:
826
raise BzrCommandError('bzr diff --revision takes exactly one revision identifier')
827
base_rev = revision[0]
828
829
show_diff(b, base_rev, specific_files=file_list,
830
external_diff_options=diff_options)
831
832
833
834
835
836
class cmd_deleted(Command):
837
"""List files deleted in the working tree.
838
839
TODO: Show files deleted since a previous revision, or between two revisions.
840
"""
841
def run(self, show_ids=False):
842
b = find_branch('.')
843
old = b.basis_tree()
844
new = b.working_tree()
845
846
## TODO: Much more efficient way to do this: read in new
847
## directories with readdir, rather than stating each one. Same
848
## level of effort but possibly much less IO. (Or possibly not,
849
## if the directories are very large...)
850
851
for path, ie in old.inventory.iter_entries():
852
if not new.has_id(ie.file_id):
853
if show_ids:
854
print '%-50s %s' % (path, ie.file_id)
855
else:
856
print path
857
858
859
class cmd_modified(Command):
860
"""List files modified in working tree."""
861
hidden = True
862
def run(self):
863
from bzrlib.diff import compare_trees
864
865
b = find_branch('.')
866
td = compare_trees(b.basis_tree(), b.working_tree())
867
868
for path, id, kind in td.modified:
869
print path
870
871
872
873
class cmd_added(Command):
874
"""List files added in working tree."""
875
hidden = True
876
def run(self):
877
b = find_branch('.')
878
wt = b.working_tree()
879
basis_inv = b.basis_tree().inventory
880
inv = wt.inventory
881
for file_id in inv:
882
if file_id in basis_inv:
883
continue
884
path = inv.id2path(file_id)
885
if not os.access(b.abspath(path), os.F_OK):
886
continue
887
print path
888
889
890
891
class cmd_root(Command):
892
"""Show the tree root directory.
893
894
The root is the nearest enclosing directory with a .bzr control
895
directory."""
896
takes_args = ['filename?']
897
def run(self, filename=None):
898
"""Print the branch root."""
899
b = find_branch(filename)
900
print getattr(b, 'base', None) or getattr(b, 'baseurl')
901
902
903
class cmd_log(Command):
904
"""Show log of this branch.
905
906
To request a range of logs, you can use the command -r begin:end
907
-r revision requests a specific revision, -r :end or -r begin: are
908
also valid.
909
910
--message allows you to give a regular expression, which will be evaluated
911
so that only matching entries will be displayed.
912
913
TODO: Make --revision support uuid: and hash: [future tag:] notation.
914
915
"""
916
917
takes_args = ['filename?']
918
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision','long', 'message']
919
920
def run(self, filename=None, timezone='original',
921
verbose=False,
922
show_ids=False,
923
forward=False,
924
revision=None,
925
message=None,
926
long=False):
927
from bzrlib.branch import find_branch
928
from bzrlib.log import log_formatter, show_log
929
import codecs
930
931
direction = (forward and 'forward') or 'reverse'
932
933
if filename:
934
b = find_branch(filename)
935
fp = b.relpath(filename)
936
if fp:
937
file_id = b.read_working_inventory().path2id(fp)
938
else:
939
file_id = None # points to branch root
940
else:
941
b = find_branch('.')
942
file_id = None
943
944
if revision is None:
945
rev1 = None
946
rev2 = None
947
elif len(revision) == 1:
948
rev1 = rev2 = b.get_revision_info(revision[0])[0]
949
elif len(revision) == 2:
950
rev1 = b.get_revision_info(revision[0])[0]
951
rev2 = b.get_revision_info(revision[1])[0]
952
else:
953
raise BzrCommandError('bzr log --revision takes one or two values.')
954
955
if rev1 == 0:
956
rev1 = None
957
if rev2 == 0:
958
rev2 = None
959
960
mutter('encoding log as %r' % bzrlib.user_encoding)
961
962
# use 'replace' so that we don't abort if trying to write out
963
# in e.g. the default C locale.
964
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
965
966
if long:
967
log_format = 'long'
968
else:
969
log_format = 'short'
970
lf = log_formatter(log_format,
971
show_ids=show_ids,
972
to_file=outf,
973
show_timezone=timezone)
974
975
show_log(b,
976
lf,
977
file_id,
978
verbose=verbose,
979
direction=direction,
980
start_revision=rev1,
981
end_revision=rev2,
982
search=message)
983
984
985
986
class cmd_touching_revisions(Command):
987
"""Return revision-ids which affected a particular file.
988
989
A more user-friendly interface is "bzr log FILE"."""
990
hidden = True
991
takes_args = ["filename"]
992
def run(self, filename):
993
b = find_branch(filename)
185
994
inv = b.read_working_inventory()
186
else:
187
inv = b.get_revision_inventory(b.lookup_revision(revision))
188
189
for path, entry in inv.iter_entries():
190
print '%-50s %s' % (entry.file_id, path)
191
192
193
194
def cmd_info():
195
b = Branch('.')
196
print 'branch format:', b.controlfile('branch-format', 'r').readline().rstrip('\n')
197
print 'revision number:', b.revno()
198
print 'number of versioned files:', len(b.read_working_inventory())
199
200
201
def cmd_remove(file_list, verbose=False):
202
Branch('.').remove(file_list, verbose=verbose)
203
204
205
206
def cmd_file_id(filename):
207
i = Branch('.').read_working_inventory().path2id(filename)
208
if i is None:
209
bailout("%s is not a versioned file" % filename)
210
else:
211
print i
212
213
214
def cmd_find_filename(fileid):
215
n = find_filename(fileid)
216
if n is None:
217
bailout("%s is not a live file id" % fileid)
218
else:
219
print n
220
221
222
def cmd_revision_history():
223
for patchid in Branch('.').revision_history():
224
print patchid
225
226
227
228
def cmd_init():
229
# TODO: Check we're not already in a working directory? At the
230
# moment you'll get an ugly error.
231
232
# TODO: What if we're in a subdirectory of a branch? Would like
233
# to allow that, but then the parent may need to understand that
234
# the children have disappeared, or should they be versioned in
235
# both?
236
237
# TODO: Take an argument/option for branch name.
238
Branch('.', init=True)
239
240
241
def cmd_diff(revision=None):
242
"""Show diff from basis to working copy.
243
244
:todo: Take one or two revision arguments, look up those trees,
245
and diff them.
246
247
:todo: Allow diff across branches.
248
249
:todo: Mangle filenames in diff to be more relevant.
250
251
:todo: Shouldn't be in the cmd function.
252
"""
253
254
b = Branch('.')
255
256
if revision == None:
257
old_tree = b.basis_tree()
258
else:
259
old_tree = b.revision_tree(b.lookup_revision(revision))
260
261
new_tree = b.working_tree()
262
old_inv = old_tree.inventory
263
new_inv = new_tree.inventory
264
265
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
266
old_label = ''
267
new_label = ''
268
269
DEVNULL = '/dev/null'
270
# Windows users, don't panic about this filename -- it is a
271
# special signal to GNU patch that the file should be created or
272
# deleted respectively.
273
274
# TODO: Generation of pseudo-diffs for added/deleted files could
275
# be usefully made into a much faster special case.
276
277
# TODO: Better to return them in sorted order I think.
278
279
for file_state, fid, old_name, new_name, kind in bzrlib.diff_trees(old_tree, new_tree):
280
d = None
281
282
# Don't show this by default; maybe do it if an option is passed
283
# idlabel = ' {%s}' % fid
284
idlabel = ''
285
286
# FIXME: Something about the diff format makes patch unhappy
287
# with newly-added files.
288
289
def diffit(*a, **kw):
290
sys.stdout.writelines(difflib.unified_diff(*a, **kw))
291
print
292
293
if file_state in ['.', '?', 'I']:
294
continue
295
elif file_state == 'A':
296
print '*** added %s %r' % (kind, new_name)
297
if kind == 'file':
298
diffit([],
299
new_tree.get_file(fid).readlines(),
300
fromfile=DEVNULL,
301
tofile=new_label + new_name + idlabel)
302
elif file_state == 'D':
303
assert isinstance(old_name, types.StringTypes)
304
print '*** deleted %s %r' % (kind, old_name)
305
if kind == 'file':
306
diffit(old_tree.get_file(fid).readlines(), [],
307
fromfile=old_label + old_name + idlabel,
308
tofile=DEVNULL)
309
elif file_state in ['M', 'R']:
310
if file_state == 'M':
311
assert kind == 'file'
312
assert old_name == new_name
313
print '*** modified %s %r' % (kind, new_name)
314
elif file_state == 'R':
315
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
316
317
if kind == 'file':
318
diffit(old_tree.get_file(fid).readlines(),
319
new_tree.get_file(fid).readlines(),
320
fromfile=old_label + old_name + idlabel,
321
tofile=new_label + new_name)
322
else:
323
bailout("can't represent state %s {%s}" % (file_state, fid))
324
325
326
327
def cmd_log(timezone='original'):
328
"""Show log of this branch.
329
330
:todo: Options for utc; to show ids; to limit range; etc.
331
"""
332
Branch('.').write_log(show_timezone=timezone)
333
334
335
def cmd_ls(revision=None, verbose=False):
995
file_id = inv.path2id(b.relpath(filename))
996
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
997
print "%6d %s" % (revno, what)
998
999
1000
class cmd_ls(Command):
336
1001
"""List files in a tree.
337
1002
338
:todo: Take a revision or remote path and list that tree instead.
339
"""
340
b = Branch('.')
341
if revision == None:
342
tree = b.working_tree()
343
else:
344
tree = b.revision_tree(b.lookup_revision(revision))
345
346
for fp, fc, kind, fid in tree.list_files():
347
if verbose:
348
if kind == 'directory':
349
kindch = '/'
350
elif kind == 'file':
351
kindch = ''
352
else:
353
kindch = '???'
354
355
print '%-8s %s%s' % (fc, fp, kindch)
356
else:
357
print fp
358
359
360
361
def cmd_unknowns():
362
"""List unknown files"""
363
for f in Branch('.').unknowns():
364
print quotefn(f)
365
366
367
def cmd_lookup_revision(revno):
368
try:
369
revno = int(revno)
370
except ValueError:
371
bailout("usage: lookup-revision REVNO",
372
["REVNO is a non-negative revision number for this branch"])
373
374
print Branch('.').lookup_revision(revno) or NONE_STRING
375
376
377
378
def cmd_export(revno, dest):
379
"""Export past revision to destination directory."""
380
b = Branch('.')
381
rh = b.lookup_revision(int(revno))
382
t = b.revision_tree(rh)
383
t.export(dest)
384
385
386
387
######################################################################
388
# internal/test commands
389
390
391
def cmd_uuid():
392
"""Print a newly-generated UUID."""
393
print uuid()
394
395
396
397
def cmd_local_time_offset():
398
print bzrlib.osutils.local_time_offset()
399
400
401
402
def cmd_commit(message, verbose=False):
403
Branch('.').commit(message, verbose=verbose)
404
405
406
def cmd_check():
407
"""Check consistency of the branch."""
408
check()
409
410
411
def cmd_is(pred, *rest):
412
"""Test whether PREDICATE is true."""
413
try:
414
cmd_handler = globals()['assert_' + pred.replace('-', '_')]
415
except KeyError:
416
bailout("unknown predicate: %s" % quotefn(pred))
417
418
try:
419
cmd_handler(*rest)
420
except BzrCheckError:
421
# by default we don't print the message so that this can
422
# be used from shell scripts without producing noise
423
sys.exit(1)
424
425
426
def cmd_username():
427
print bzrlib.osutils.username()
428
429
430
def cmd_user_email():
431
print bzrlib.osutils.user_email()
432
433
434
def cmd_gen_revision_id():
435
import time
436
print bzrlib.branch._gen_revision_id(time.time())
437
438
439
def cmd_doctest():
440
"""Run internal doctest suite"""
441
## -v, if present, is seen by doctest; the argument is just here
442
## so our parser doesn't complain
443
444
## TODO: --verbose option
445
446
import bzr, doctest, bzrlib.store
447
bzrlib.trace.verbose = False
448
doctest.testmod(bzr)
449
doctest.testmod(bzrlib.store)
450
doctest.testmod(bzrlib.inventory)
451
doctest.testmod(bzrlib.branch)
452
doctest.testmod(bzrlib.osutils)
453
doctest.testmod(bzrlib.tree)
454
455
# more strenuous tests;
456
import bzrlib.tests
457
doctest.testmod(bzrlib.tests)
458
459
460
######################################################################
461
# help
462
463
464
def cmd_help():
465
# TODO: Specific help for particular commands
466
print __doc__
467
468
469
def cmd_version():
470
print "bzr (bazaar-ng) %s" % __version__
471
print __copyright__
1003
TODO: Take a revision or remote path and list that tree instead.
1004
"""
1005
hidden = True
1006
def run(self, revision=None, verbose=False):
1007
b = find_branch('.')
1008
if revision == None:
1009
tree = b.working_tree()
1010
else:
1011
tree = b.revision_tree(b.lookup_revision(revision))
1012
1013
for fp, fc, kind, fid in tree.list_files():
1014
if verbose:
1015
if kind == 'directory':
1016
kindch = '/'
1017
elif kind == 'file':
1018
kindch = ''
1019
else:
1020
kindch = '???'
1021
1022
print '%-8s %s%s' % (fc, fp, kindch)
1023
else:
1024
print fp
1025
1026
1027
1028
class cmd_unknowns(Command):
1029
"""List unknown files."""
1030
def run(self):
1031
from bzrlib.osutils import quotefn
1032
for f in find_branch('.').unknowns():
1033
print quotefn(f)
1034
1035
1036
1037
class cmd_ignore(Command):
1038
"""Ignore a command or pattern.
1039
1040
To remove patterns from the ignore list, edit the .bzrignore file.
1041
1042
If the pattern contains a slash, it is compared to the whole path
1043
from the branch root. Otherwise, it is comapred to only the last
1044
component of the path.
1045
1046
Ignore patterns are case-insensitive on case-insensitive systems.
1047
1048
Note: wildcards must be quoted from the shell on Unix.
1049
1050
examples:
1051
bzr ignore ./Makefile
1052
bzr ignore '*.class'
1053
"""
1054
takes_args = ['name_pattern']
1055
1056
def run(self, name_pattern):
1057
from bzrlib.atomicfile import AtomicFile
1058
import os.path
1059
1060
b = find_branch('.')
1061
ifn = b.abspath('.bzrignore')
1062
1063
if os.path.exists(ifn):
1064
f = open(ifn, 'rt')
1065
try:
1066
igns = f.read().decode('utf-8')
1067
finally:
1068
f.close()
1069
else:
1070
igns = ''
1071
1072
# TODO: If the file already uses crlf-style termination, maybe
1073
# we should use that for the newly added lines?
1074
1075
if igns and igns[-1] != '\n':
1076
igns += '\n'
1077
igns += name_pattern + '\n'
1078
1079
try:
1080
f = AtomicFile(ifn, 'wt')
1081
f.write(igns.encode('utf-8'))
1082
f.commit()
1083
finally:
1084
f.close()
1085
1086
inv = b.working_tree().inventory
1087
if inv.path2id('.bzrignore'):
1088
mutter('.bzrignore is already versioned')
1089
else:
1090
mutter('need to make new .bzrignore file versioned')
1091
b.add(['.bzrignore'])
1092
1093
1094
1095
class cmd_ignored(Command):
1096
"""List ignored files and the patterns that matched them.
1097
1098
See also: bzr ignore"""
1099
def run(self):
1100
tree = find_branch('.').working_tree()
1101
for path, file_class, kind, file_id in tree.list_files():
1102
if file_class != 'I':
1103
continue
1104
## XXX: Slightly inefficient since this was already calculated
1105
pat = tree.is_ignored(path)
1106
print '%-50s %s' % (path, pat)
1107
1108
1109
class cmd_lookup_revision(Command):
1110
"""Lookup the revision-id from a revision-number
1111
1112
example:
1113
bzr lookup-revision 33
1114
"""
1115
hidden = True
1116
takes_args = ['revno']
1117
1118
def run(self, revno):
1119
try:
1120
revno = int(revno)
1121
except ValueError:
1122
raise BzrCommandError("not a valid revision-number: %r" % revno)
1123
1124
print find_branch('.').lookup_revision(revno)
1125
1126
1127
class cmd_export(Command):
1128
"""Export past revision to destination directory.
1129
1130
If no revision is specified this exports the last committed revision.
1131
1132
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1133
given, try to find the format with the extension. If no extension
1134
is found exports to a directory (equivalent to --format=dir).
1135
1136
Root may be the top directory for tar, tgz and tbz2 formats. If none
1137
is given, the top directory will be the root name of the file."""
1138
# TODO: list known exporters
1139
takes_args = ['dest']
1140
takes_options = ['revision', 'format', 'root']
1141
def run(self, dest, revision=None, format=None, root=None):
1142
import os.path
1143
b = find_branch('.')
1144
if revision is None:
1145
rev_id = b.last_patch()
1146
else:
1147
if len(revision) != 1:
1148
raise BzrError('bzr export --revision takes exactly 1 argument')
1149
revno, rev_id = b.get_revision_info(revision[0])
1150
t = b.revision_tree(rev_id)
1151
root, ext = os.path.splitext(dest)
1152
if not format:
1153
if ext in (".tar",):
1154
format = "tar"
1155
elif ext in (".gz", ".tgz"):
1156
format = "tgz"
1157
elif ext in (".bz2", ".tbz2"):
1158
format = "tbz2"
1159
else:
1160
format = "dir"
1161
t.export(dest, format, root)
1162
1163
1164
class cmd_cat(Command):
1165
"""Write a file's text from a previous revision."""
1166
1167
takes_options = ['revision']
1168
takes_args = ['filename']
1169
1170
def run(self, filename, revision=None):
1171
if revision == None:
1172
raise BzrCommandError("bzr cat requires a revision number")
1173
elif len(revision) != 1:
1174
raise BzrCommandError("bzr cat --revision takes exactly one number")
1175
b = find_branch('.')
1176
b.print_file(b.relpath(filename), revision[0])
1177
1178
1179
class cmd_local_time_offset(Command):
1180
"""Show the offset in seconds from GMT to local time."""
1181
hidden = True
1182
def run(self):
1183
print bzrlib.osutils.local_time_offset()
1184
1185
1186
1187
class cmd_commit(Command):
1188
"""Commit changes into a new revision.
1189
1190
If no arguments are given, the entire tree is committed.
1191
1192
If selected files are specified, only changes to those files are
1193
committed. If a directory is specified then the directory and everything
1194
within it is committed.
1195
1196
A selected-file commit may fail in some cases where the committed
1197
tree would be invalid, such as trying to commit a file in a
1198
newly-added directory that is not itself committed.
1199
1200
TODO: Run hooks on tree to-be-committed, and after commit.
1201
1202
TODO: Strict commit that fails if there are unknown or deleted files.
1203
"""
1204
takes_args = ['selected*']
1205
takes_options = ['message', 'file', 'verbose', 'unchanged']
1206
aliases = ['ci', 'checkin']
1207
1208
# TODO: Give better message for -s, --summary, used by tla people
1209
1210
def run(self, message=None, file=None, verbose=True, selected_list=None,
1211
unchanged=False):
1212
from bzrlib.errors import PointlessCommit
1213
from bzrlib.osutils import get_text_message
1214
1215
## Warning: shadows builtin file()
1216
if not message and not file:
1217
# FIXME: Ugly; change status code to send to a provided function?
1218
1219
import cStringIO
1220
stdout = sys.stdout
1221
catcher = cStringIO.StringIO()
1222
sys.stdout = catcher
1223
cmd_status({"file_list":selected_list}, {})
1224
info = catcher.getvalue()
1225
sys.stdout = stdout
1226
message = get_text_message(info)
1227
1228
if message is None:
1229
raise BzrCommandError("please specify a commit message",
1230
["use either --message or --file"])
1231
elif message and file:
1232
raise BzrCommandError("please specify either --message or --file")
1233
1234
if file:
1235
import codecs
1236
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1237
1238
b = find_branch('.')
1239
if selected_list:
1240
selected_list = [b.relpath(s) for s in selected_list]
1241
1242
try:
1243
b.commit(message, verbose=verbose,
1244
specific_files=selected_list,
1245
allow_pointless=unchanged)
1246
except PointlessCommit:
1247
# FIXME: This should really happen before the file is read in;
1248
# perhaps prepare the commit; get the message; then actually commit
1249
raise BzrCommandError("no changes to commit",
1250
["use --unchanged to commit anyhow"])
1251
1252
1253
class cmd_check(Command):
1254
"""Validate consistency of branch history.
1255
1256
This command checks various invariants about the branch storage to
1257
detect data corruption or bzr bugs.
1258
1259
If given the --update flag, it will update some optional fields
1260
to help ensure data consistency.
1261
"""
1262
takes_args = ['dir?']
1263
1264
def run(self, dir='.'):
1265
from bzrlib.check import check
1266
check(find_branch(dir))
1267
1268
1269
1270
class cmd_scan_cache(Command):
1271
hidden = True
1272
def run(self):
1273
from bzrlib.hashcache import HashCache
1274
import os
1275
1276
c = HashCache('.')
1277
c.read()
1278
c.scan()
1279
1280
print '%6d stats' % c.stat_count
1281
print '%6d in hashcache' % len(c._cache)
1282
print '%6d files removed from cache' % c.removed_count
1283
print '%6d hashes updated' % c.update_count
1284
print '%6d files changed too recently to cache' % c.danger_count
1285
1286
if c.needs_write:
1287
c.write()
1288
1289
1290
1291
class cmd_upgrade(Command):
1292
"""Upgrade branch storage to current format.
1293
1294
This should normally be used only after the check command tells
1295
you to run it.
1296
"""
1297
takes_args = ['dir?']
1298
1299
def run(self, dir='.'):
1300
from bzrlib.upgrade import upgrade
1301
upgrade(find_branch(dir))
1302
1303
1304
1305
class cmd_whoami(Command):
1306
"""Show bzr user id."""
1307
takes_options = ['email']
1308
1309
def run(self, email=False):
1310
if email:
1311
print bzrlib.osutils.user_email()
1312
else:
1313
print bzrlib.osutils.username()
1314
1315
1316
class cmd_selftest(Command):
1317
"""Run internal test suite"""
1318
hidden = True
1319
takes_options = ['verbose']
1320
def run(self, verbose=False):
1321
from bzrlib.selftest import selftest
1322
return int(not selftest(verbose=verbose))
1323
1324
1325
class cmd_version(Command):
1326
"""Show version of bzr."""
1327
def run(self):
1328
show_version()
1329
1330
def show_version():
1331
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1332
# is bzrlib itself in a branch?
1333
bzrrev = bzrlib.get_bzr_revision()
1334
if bzrrev:
1335
print " (bzr checkout, revision %d {%s})" % bzrrev
1336
print bzrlib.__copyright__
472
1337
print "http://bazaar-ng.org/"
473
1338
print
474
print \
475
"""bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and
476
you may use, modify and redistribute it under the terms of the GNU
477
General Public License version 2 or later."""
478
479
480
def cmd_rocks():
1339
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1340
print "you may use, modify and redistribute it under the terms of the GNU"
1341
print "General Public License version 2 or later."
1342
1343
1344
class cmd_rocks(Command):
481
1345
"""Statement of optimism."""
482
print "it sure does!"
483
484
485
486
######################################################################
487
# main routine
1346
hidden = True
1347
def run(self):
1348
print "it sure does!"
1349
1350
def parse_spec(spec):
1351
"""
1352
>>> parse_spec(None)
1353
[None, None]
1354
>>> parse_spec("./")
1355
['./', None]
1356
>>> parse_spec("../@")
1357
['..', -1]
1358
>>> parse_spec("../f/@35")
1359
['../f', 35]
1360
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1361
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1362
"""
1363
if spec is None:
1364
return [None, None]
1365
if '/@' in spec:
1366
parsed = spec.split('/@')
1367
assert len(parsed) == 2
1368
if parsed[1] == "":
1369
parsed[1] = -1
1370
else:
1371
try:
1372
parsed[1] = int(parsed[1])
1373
except ValueError:
1374
pass # We can allow stuff like ./@revid:blahblahblah
1375
else:
1376
assert parsed[1] >=0
1377
else:
1378
parsed = [spec, None]
1379
return parsed
1380
1381
1382
1383
class cmd_merge(Command):
1384
"""Perform a three-way merge of trees.
1385
1386
The SPEC parameters are working tree or revision specifiers. Working trees
1387
are specified using standard paths or urls. No component of a directory
1388
path may begin with '@'.
1389
1390
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1391
1392
Revisions are specified using a dirname/@revno pair, where dirname is the
1393
branch directory and revno is the revision within that branch. If no revno
1394
is specified, the latest revision is used.
1395
1396
Revision examples: './@127', 'foo/@', '../@1'
1397
1398
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1399
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1400
as the BASE.
1401
1402
merge refuses to run if there are any uncommitted changes, unless
1403
--force is given.
1404
"""
1405
takes_args = ['other_spec', 'base_spec?']
1406
takes_options = ['force']
1407
1408
def run(self, other_spec, base_spec=None, force=False):
1409
from bzrlib.merge import merge
1410
merge(parse_spec(other_spec), parse_spec(base_spec),
1411
check_clean=(not force))
1412
1413
1414
1415
class cmd_revert(Command):
1416
"""Restore selected files from a previous revision.
1417
"""
1418
takes_args = ['file+']
1419
def run(self, file_list):
1420
from bzrlib.branch import find_branch
1421
1422
if not file_list:
1423
file_list = ['.']
1424
1425
b = find_branch(file_list[0])
1426
1427
b.revert([b.relpath(f) for f in file_list])
1428
1429
1430
class cmd_merge_revert(Command):
1431
"""Reverse all changes since the last commit.
1432
1433
Only versioned files are affected.
1434
1435
TODO: Store backups of any files that will be reverted, so
1436
that the revert can be undone.
1437
"""
1438
takes_options = ['revision']
1439
1440
def run(self, revision=None):
1441
from bzrlib.merge import merge
1442
if revision is None:
1443
revision = [-1]
1444
elif len(revision) != 1:
1445
raise BzrCommandError('bzr merge-revert --revision takes exactly 1 argument')
1446
merge(('.', revision[0]), parse_spec('.'),
1447
check_clean=False,
1448
ignore_zero=True)
1449
1450
1451
class cmd_assert_fail(Command):
1452
"""Test reporting of assertion failures"""
1453
hidden = True
1454
def run(self):
1455
assert False, "always fails"
1456
1457
1458
class cmd_help(Command):
1459
"""Show help on a command or other topic.
1460
1461
For a list of all available commands, say 'bzr help commands'."""
1462
takes_args = ['topic?']
1463
aliases = ['?']
1464
1465
def run(self, topic=None):
1466
import help
1467
help.help(topic)
1468
1469
1470
1471
1472
class cmd_plugins(Command):
1473
"""List plugins"""
1474
hidden = True
1475
def run(self):
1476
import bzrlib.plugin
1477
from inspect import getdoc
1478
from pprint import pprint
1479
for plugin in bzrlib.plugin.all_plugins:
1480
print plugin.__path__[0]
1481
d = getdoc(plugin)
1482
if d:
1483
print '\t', d.split('\n')[0]
1484
1485
#pprint(bzrlib.plugin.all_plugins)
1486
488
1487
489
1488
490
1489
# list of all available options; the rhs can be either None for an
492
1491
# the type.
493
1492
OPTIONS = {
494
1493
'all': None,
1494
'diff-options': str,
495
1495
'help': None,
1496
'file': unicode,
1497
'force': None,
1498
'format': unicode,
1499
'forward': None,
496
1500
'message': unicode,
497
'revision': int,
1501
'no-recurse': None,
1502
'profile': None,
1503
'revision': _parse_revision_str,
498
1504
'show-ids': None,
499
1505
'timezone': str,
500
1506
'verbose': None,
501
1507
'version': None,
1508
'email': None,
1509
'unchanged': None,
1510
'update': None,
1511
'long': None,
1512
'root': str,
502
1513
}
503
1514
504
1515
SHORT_OPTIONS = {
1516
'F': 'file',
1517
'h': 'help',
505
1518
'm': 'message',
506
1519
'r': 'revision',
507
1520
'v': 'verbose',
1521
'l': 'long',
508
1522
}
509
1523
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
'log': ['show-ids', 'timezone'],
518
'ls': ['revision', 'verbose'],
519
'remove': ['verbose'],
520
'status': ['all'],
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
541
1524
542
1525
def parse_args(argv):
543
1526
"""Parse command line.
547
1530
lookup table, something about the available options, what optargs
548
1531
they take, and which commands will accept them.
549
1532
550
>>> parse_args('bzr --help'.split())
1533
>>> parse_args('--help'.split())
551
1534
([], {'help': True})
552
>>> parse_args('bzr --version'.split())
1535
>>> parse_args('--version'.split())
553
1536
([], {'version': True})
554
>>> parse_args('bzr status --all'.split())
1537
>>> parse_args('status --all'.split())
555
1538
(['status'], {'all': True})
1539
>>> parse_args('commit --message=biter'.split())
1540
(['commit'], {'message': u'biter'})
1541
>>> parse_args('log -r 500'.split())
1542
(['log'], {'revision': [500]})
1543
>>> parse_args('log -r500..600'.split())
1544
(['log'], {'revision': [500, 600]})
1545
>>> parse_args('log -vr500..600'.split())
1546
(['log'], {'verbose': True, 'revision': [500, 600]})
1547
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1548
(['log'], {'revision': ['v500', 600]})
556
1549
"""
557
1550
args = []
558
1551
opts = {}
559
1552
560
1553
# TODO: Maybe handle '--' to end options?
561
1554
562
it = iter(argv[1:])
563
while it:
564
a = it.next()
1555
while argv:
1556
a = argv.pop(0)
565
1557
if a[0] == '-':
1558
# option names must not be unicode
1559
a = str(a)
1560
optarg = None
566
1561
if a[1] == '-':
567
1562
mutter(" got option %r" % a)
568
optname = a[2:]
1563
if '=' in a:
1564
optname, optarg = a[2:].split('=', 1)
1565
else:
1566
optname = a[2:]
569
1567
if optname not in OPTIONS:
570
bailout('unknown long option %r' % a)
1568
raise BzrError('unknown long option %r' % a)
571
1569
else:
572
1570
shortopt = a[1:]
573
if shortopt not in SHORT_OPTIONS:
574
bailout('unknown short option %r' % a)
575
optname = SHORT_OPTIONS[shortopt]
1571
if shortopt in SHORT_OPTIONS:
1572
# Multi-character options must have a space to delimit
1573
# their value
1574
optname = SHORT_OPTIONS[shortopt]
1575
else:
1576
# Single character short options, can be chained,
1577
# and have their value appended to their name
1578
shortopt = a[1:2]
1579
if shortopt not in SHORT_OPTIONS:
1580
# We didn't find the multi-character name, and we
1581
# didn't find the single char name
1582
raise BzrError('unknown short option %r' % a)
1583
optname = SHORT_OPTIONS[shortopt]
1584
1585
if a[2:]:
1586
# There are extra things on this option
1587
# see if it is the value, or if it is another
1588
# short option
1589
optargfn = OPTIONS[optname]
1590
if optargfn is None:
1591
# This option does not take an argument, so the
1592
# next entry is another short option, pack it back
1593
# into the list
1594
argv.insert(0, '-' + a[2:])
1595
else:
1596
# This option takes an argument, so pack it
1597
# into the array
1598
optarg = a[2:]
576
1599
577
1600
if optname in opts:
578
1601
# XXX: Do we ever want to support this, e.g. for -r?
579
bailout('repeated option %r' % a)
1602
raise BzrError('repeated option %r' % a)
1603
580
1604
optargfn = OPTIONS[optname]
581
1605
if optargfn:
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])
1606
if optarg == None:
1607
if not argv:
1608
raise BzrError('option %r needs an argument' % a)
1609
else:
1610
optarg = argv.pop(0)
1611
opts[optname] = optargfn(optarg)
586
1612
else:
587
# takes no option argument
1613
if optarg != None:
1614
raise BzrError('option %r takes no argument' % optname)
588
1615
opts[optname] = True
589
elif a[:1] == '-':
590
bailout('unknown short option %r' % a)
591
1616
else:
592
1617
args.append(a)
593
1618
595
1620
596
1621
597
1622
598
def _match_args(cmd, args):
599
"""Check non-option arguments match required pattern.
600
1623
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, [])
1624
def _match_argform(cmd, takes_args, args):
612
1625
argdict = {}
613
# TODO: Need a way to express 'cp SRC... DEST', where it matches
614
# all but one.
615
for ap in argform:
1626
1627
# step through args and takes_args, allowing appropriate 0-many matches
1628
for ap in takes_args:
616
1629
argname = ap[:-1]
617
1630
if ap[-1] == '?':
618
assert 0
619
elif ap[-1] == '*':
620
assert 0
1631
if args:
1632
argdict[argname] = args.pop(0)
1633
elif ap[-1] == '*': # all remaining arguments
1634
if args:
1635
argdict[argname + '_list'] = args[:]
1636
args = []
1637
else:
1638
argdict[argname + '_list'] = None
621
1639
elif ap[-1] == '+':
622
1640
if not args:
623
bailout("command %r needs one or more %s"
1641
raise BzrCommandError("command %r needs one or more %s"
624
1642
% (cmd, argname.upper()))
625
1643
else:
626
1644
argdict[argname + '_list'] = args[:]
627
1645
args = []
1646
elif ap[-1] == '$': # all but one
1647
if len(args) < 2:
1648
raise BzrCommandError("command %r needs one or more %s"
1649
% (cmd, argname.upper()))
1650
argdict[argname + '_list'] = args[:-1]
1651
args[:-1] = []
628
1652
else:
629
1653
# just a plain arg
630
1654
argname = ap
631
1655
if not args:
632
bailout("command %r requires argument %s"
1656
raise BzrCommandError("command %r requires argument %s"
633
1657
% (cmd, argname.upper()))
634
1658
else:
635
1659
argdict[argname] = args.pop(0)
636
1660
637
1661
if args:
638
bailout("extra arguments to command %s: %r"
639
% (cmd, args))
1662
raise BzrCommandError("extra argument to command %s: %s"
1663
% (cmd, args[0]))
640
1664
641
1665
return argdict
642
1666
643
1667
1668
def _parse_master_args(argv):
1669
"""Parse the arguments that always go with the original command.
1670
These are things like bzr --no-plugins, etc.
1671
1672
There are now 2 types of option flags. Ones that come *before* the command,
1673
and ones that come *after* the command.
1674
Ones coming *before* the command are applied against all possible commands.
1675
And are generally applied before plugins are loaded.
1676
1677
The current list are:
1678
--builtin Allow plugins to load, but don't let them override builtin commands,
1679
they will still be allowed if they do not override a builtin.
1680
--no-plugins Don't load any plugins. This lets you get back to official source
1681
behavior.
1682
--profile Enable the hotspot profile before running the command.
1683
For backwards compatibility, this is also a non-master option.
1684
--version Spit out the version of bzr that is running and exit.
1685
This is also a non-master option.
1686
--help Run help and exit, also a non-master option (I think that should stay, though)
1687
1688
>>> argv, opts = _parse_master_args(['--test'])
1689
Traceback (most recent call last):
1690
...
1691
BzrCommandError: Invalid master option: 'test'
1692
>>> argv, opts = _parse_master_args(['--version', 'command'])
1693
>>> print argv
1694
['command']
1695
>>> print opts['version']
1696
True
1697
>>> argv, opts = _parse_master_args(['--profile', 'command', '--more-options'])
1698
>>> print argv
1699
['command', '--more-options']
1700
>>> print opts['profile']
1701
True
1702
>>> argv, opts = _parse_master_args(['--no-plugins', 'command'])
1703
>>> print argv
1704
['command']
1705
>>> print opts['no-plugins']
1706
True
1707
>>> print opts['profile']
1708
False
1709
>>> argv, opts = _parse_master_args(['command', '--profile'])
1710
>>> print argv
1711
['command', '--profile']
1712
>>> print opts['profile']
1713
False
1714
"""
1715
master_opts = {'builtin':False,
1716
'no-plugins':False,
1717
'version':False,
1718
'profile':False,
1719
'help':False
1720
}
1721
1722
for arg in argv[:]:
1723
if arg[:2] != '--': # at the first non-option, we return the rest
1724
break
1725
arg = arg[2:] # Remove '--'
1726
if arg not in master_opts:
1727
# We could say that this is not an error, that we should
1728
# just let it be handled by the main section instead
1729
raise BzrCommandError('Invalid master option: %r' % arg)
1730
argv.pop(0) # We are consuming this entry
1731
master_opts[arg] = True
1732
return argv, master_opts
1733
1734
644
1735
645
1736
def run_bzr(argv):
646
1737
"""Execute a command.
647
1738
648
1739
This is similar to main(), but without all the trappings for
649
logging and error handling.
1740
logging and error handling.
1741
1742
argv
1743
The command-line arguments, without the program name.
1744
1745
Returns a command status or raises an exception.
650
1746
"""
1747
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1748
1749
# some options like --builtin and --no-plugins have special effects
1750
argv, master_opts = _parse_master_args(argv)
1751
if not master_opts['no-plugins']:
1752
from bzrlib.plugin import load_plugins
1753
load_plugins()
1754
1755
args, opts = parse_args(argv)
1756
1757
if master_opts.get('help') or 'help' in opts:
1758
from bzrlib.help import help
1759
if argv:
1760
help(argv[0])
1761
else:
1762
help()
1763
return 0
1764
1765
if 'version' in opts:
1766
show_version()
1767
return 0
1768
1769
if args and args[0] == 'builtin':
1770
include_plugins=False
1771
args = args[1:]
1772
651
1773
try:
652
args, opts = parse_args(argv)
653
if 'help' in opts:
654
# TODO: pass down other arguments in case they asked for
655
# help on a command name?
656
cmd_help()
657
return 0
658
elif 'version' in opts:
659
cmd_version()
660
return 0
661
cmd = args.pop(0)
1774
cmd = str(args.pop(0))
662
1775
except IndexError:
663
log_error('usage: bzr COMMAND\n')
664
log_error(' try "bzr help"\n')
1776
print >>sys.stderr, "please try 'bzr help' for help"
665
1777
return 1
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
1778
1779
plugins_override = not (master_opts['builtin'])
1780
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1781
1782
profile = master_opts['profile']
1783
# For backwards compatibility, I would rather stick with --profile being a
1784
# master/global option
1785
if 'profile' in opts:
1786
profile = True
1787
del opts['profile']
673
1788
674
1789
# check options are reasonable
675
allowed = cmd_options.get(cmd, [])
1790
allowed = cmd_class.takes_options
676
1791
for oname in opts:
677
1792
if oname not in allowed:
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
1793
raise BzrCommandError("option '--%s' is not allowed for command %r"
1794
% (oname, cmd))
1795
1796
# mix arguments and options into one dictionary
1797
cmdargs = _match_argform(cmd, cmd_class.takes_args, args)
1798
cmdopts = {}
1799
for k, v in opts.items():
1800
cmdopts[k.replace('-', '_')] = v
1801
1802
if profile:
1803
import hotshot, tempfile
1804
pffileno, pfname = tempfile.mkstemp()
1805
try:
1806
prof = hotshot.Profile(pfname)
1807
ret = prof.runcall(cmd_class, cmdopts, cmdargs) or 0
1808
prof.close()
1809
1810
import hotshot.stats
1811
stats = hotshot.stats.load(pfname)
1812
#stats.strip_dirs()
1813
stats.sort_stats('time')
1814
## XXX: Might like to write to stderr or the trace file instead but
1815
## print_stats seems hardcoded to stdout
1816
stats.print_stats(20)
1817
1818
return ret.status
1819
1820
finally:
1821
os.close(pffileno)
1822
os.remove(pfname)
1823
else:
1824
return cmd_class(cmdopts, cmdargs).status
1825
1826
1827
def _report_exception(summary, quiet=False):
1828
import traceback
1829
log_error('bzr: ' + summary)
1830
bzrlib.trace.log_exception()
1831
1832
if not quiet:
1833
tb = sys.exc_info()[2]
1834
exinfo = traceback.extract_tb(tb)
1835
if exinfo:
1836
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1837
sys.stderr.write(' see ~/.bzr.log for debug information\n')
685
1838
686
1839
687
1840
688
1841
def main(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.
1842
1843
bzrlib.trace.open_tracefile(argv)
694
1844
695
1845
try:
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
1846
try:
1847
try:
1848
return run_bzr(argv[1:])
1849
finally:
1850
# do this here inside the exception wrappers to catch EPIPE
1851
sys.stdout.flush()
1852
except BzrError, e:
1853
quiet = isinstance(e, (BzrCommandError))
1854
_report_exception('error: ' + e.args[0], quiet=quiet)
1855
if len(e.args) > 1:
1856
for h in e.args[1]:
1857
# some explanation or hints
1858
log_error(' ' + h)
1859
return 1
1860
except AssertionError, e:
1861
msg = 'assertion failed'
1862
if str(e):
1863
msg += ': ' + str(e)
1864
_report_exception(msg)
1865
return 2
1866
except KeyboardInterrupt, e:
1867
_report_exception('interrupted', quiet=True)
1868
return 2
1869
except Exception, e:
1870
import errno
1871
quiet = False
1872
if (isinstance(e, IOError)
1873
and hasattr(e, 'errno')
1874
and e.errno == errno.EPIPE):
1875
quiet = True
1876
msg = 'broken pipe'
1877
else:
1878
msg = str(e).rstrip('\n')
1879
_report_exception(msg, quiet)
1880
return 2
1881
finally:
1882
bzrlib.trace.close_trace()
731
1883
732
1884
733
1885
if __name__ == '__main__':
734
1886
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