« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 618
- compare with another revision
- download diff
- download tarball
- view history from revision 618
- Committer: Martin Pool
- Date: 2005-06-01 07:45:28 UTC
- Revision ID: mbp@sourcefrog.net-20050601074528-54509f4b1d505f55
- ignore .git files as well
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- bzrlib/selftest/__init__.py => bzrlib/selftest.py
- bzrlib/selftest/whitebox.py => bzrlib/whitebox.py
- contrib/bash/bzr.simple => contrib/bash/bzr
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
# TODO: Split the command framework away from the actual commands.
19
20
# TODO: probably should say which arguments are candidates for glob
21
# expansion on windows and do that at the command level.
22
23
# TODO: Help messages for options.
24
25
# TODO: Define arguments by objects, rather than just using names.
26
# Those objects can specify the expected type of the argument, which
27
# would help with validation and shell completion.
28
29
30
import sys
31
import os
18
19
import sys, os
32
20
33
21
import bzrlib
34
import bzrlib.trace
35
from bzrlib.trace import mutter, note, log_error, warning
36
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
37
from bzrlib.branch import find_branch
38
from bzrlib import BZRDIR
39
40
41
plugin_cmds = {}
42
43
44
def register_command(cmd):
45
"Utility function to help register a command"
46
global plugin_cmds
47
k = cmd.__name__
48
if k.startswith("cmd_"):
49
k_unsquished = _unsquish_command_name(k)
50
else:
51
k_unsquished = k
52
if not plugin_cmds.has_key(k_unsquished):
53
plugin_cmds[k_unsquished] = cmd
54
else:
55
log_error('Two plugins defined the same command: %r' % k)
56
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
22
from bzrlib.trace import mutter, note, log_error
23
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
26
format_date
57
27
58
28
59
29
def _squish_command_name(cmd):
64
34
assert cmd.startswith("cmd_")
65
35
return cmd[4:].replace('_','-')
66
36
67
68
37
def _parse_revision_str(revstr):
69
"""This handles a revision string -> revno.
70
71
This always returns a list. The list will have one element for
72
73
It supports integers directly, but everything else it
74
defers for passing to Branch.get_revision_info()
75
76
>>> _parse_revision_str('234')
77
[234]
78
>>> _parse_revision_str('234..567')
79
[234, 567]
80
>>> _parse_revision_str('..')
81
[None, None]
82
>>> _parse_revision_str('..234')
83
[None, 234]
84
>>> _parse_revision_str('234..')
85
[234, None]
86
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
87
[234, 456, 789]
88
>>> _parse_revision_str('234....789') # Error?
89
[234, None, 789]
90
>>> _parse_revision_str('revid:test@other.com-234234')
91
['revid:test@other.com-234234']
92
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
93
['revid:test@other.com-234234', 'revid:test@other.com-234235']
94
>>> _parse_revision_str('revid:test@other.com-234234..23')
95
['revid:test@other.com-234234', 23]
96
>>> _parse_revision_str('date:2005-04-12')
97
['date:2005-04-12']
98
>>> _parse_revision_str('date:2005-04-12 12:24:33')
99
['date:2005-04-12 12:24:33']
100
>>> _parse_revision_str('date:2005-04-12T12:24:33')
101
['date:2005-04-12T12:24:33']
102
>>> _parse_revision_str('date:2005-04-12,12:24:33')
103
['date:2005-04-12,12:24:33']
104
>>> _parse_revision_str('-5..23')
105
[-5, 23]
106
>>> _parse_revision_str('-5')
107
[-5]
108
>>> _parse_revision_str('123a')
109
['123a']
110
>>> _parse_revision_str('abc')
111
['abc']
38
"""This handles a revision string -> revno.
39
40
There are several possibilities:
41
42
'234' -> 234
43
'234:345' -> [234, 345]
44
':234' -> [None, 234]
45
'234:' -> [234, None]
46
47
In the future we will also support:
48
'uuid:blah-blah-blah' -> ?
49
'hash:blahblahblah' -> ?
50
potentially:
51
'tag:mytag' -> ?
112
52
"""
113
import re
114
old_format_re = re.compile('\d*:\d*')
115
m = old_format_re.match(revstr)
116
if m:
117
warning('Colon separator for revision numbers is deprecated.'
118
' Use .. instead')
119
revs = []
120
for rev in revstr.split(':'):
121
if rev:
122
revs.append(int(rev))
123
else:
124
revs.append(None)
125
return revs
126
revs = []
127
for x in revstr.split('..'):
128
if not x:
129
revs.append(None)
130
else:
131
try:
132
revs.append(int(x))
133
except ValueError:
134
revs.append(x)
53
if revstr.find(':') != -1:
54
revs = revstr.split(':')
55
if len(revs) > 2:
56
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
57
58
if not revs[0]:
59
revs[0] = None
60
else:
61
revs[0] = int(revs[0])
62
63
if not revs[1]:
64
revs[1] = None
65
else:
66
revs[1] = int(revs[1])
67
else:
68
revs = int(revstr)
135
69
return revs
136
70
137
138
def get_merge_type(typestring):
139
"""Attempt to find the merge class/factory associated with a string."""
140
from merge import merge_types
141
try:
142
return merge_types[typestring][0]
143
except KeyError:
144
templ = '%s%%7s: %%s' % (' '*12)
145
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
146
type_list = '\n'.join(lines)
147
msg = "No known merge type %s. Supported types are:\n%s" %\
148
(typestring, type_list)
149
raise BzrCommandError(msg)
150
151
152
def get_merge_type(typestring):
153
"""Attempt to find the merge class/factory associated with a string."""
154
from merge import merge_types
155
try:
156
return merge_types[typestring][0]
157
except KeyError:
158
templ = '%s%%7s: %%s' % (' '*12)
159
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
160
type_list = '\n'.join(lines)
161
msg = "No known merge type %s. Supported types are:\n%s" %\
162
(typestring, type_list)
163
raise BzrCommandError(msg)
164
165
166
167
def _get_cmd_dict(plugins_override=True):
168
d = {}
71
def get_all_cmds():
72
"""Return canonical name and class for all registered commands."""
169
73
for k, v in globals().iteritems():
170
74
if k.startswith("cmd_"):
171
d[_unsquish_command_name(k)] = v
172
# If we didn't load plugins, the plugin_cmds dict will be empty
173
if plugins_override:
174
d.update(plugin_cmds)
175
else:
176
d2 = plugin_cmds.copy()
177
d2.update(d)
178
d = d2
179
return d
180
181
182
def get_all_cmds(plugins_override=True):
183
"""Return canonical name and class for all registered commands."""
184
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
185
yield k,v
186
187
188
def get_cmd_class(cmd, plugins_override=True):
75
yield _unsquish_command_name(k), v
76
77
def get_cmd_class(cmd):
189
78
"""Return the canonical name and command class for a command.
190
79
"""
191
80
cmd = str(cmd) # not unicode
192
81
193
82
# first look up this command under the specified name
194
cmds = _get_cmd_dict(plugins_override=plugins_override)
195
83
try:
196
return cmd, cmds[cmd]
84
return cmd, globals()[_squish_command_name(cmd)]
197
85
except KeyError:
198
86
pass
199
87
200
88
# look for any command which claims this as an alias
201
for cmdname, cmdclass in cmds.iteritems():
89
for cmdname, cmdclass in get_all_cmds():
202
90
if cmd in cmdclass.aliases:
203
91
return cmdname, cmdclass
204
92
241
129
assert isinstance(arguments, dict)
242
130
cmdargs = options.copy()
243
131
cmdargs.update(arguments)
244
if self.__doc__ == Command.__doc__:
245
from warnings import warn
246
warn("No help message set for %r" % self)
132
assert self.__doc__ != Command.__doc__, \
133
("No help message set for %r" % self)
247
134
self.status = self.run(**cmdargs)
248
if self.status is None:
249
self.status = 0
250
135
251
136
252
137
def run(self):
264
149
class ExternalCommand(Command):
265
150
"""Class to wrap external commands.
266
151
267
We cheat a little here, when get_cmd_class() calls us we actually
268
give it back an object we construct that has the appropriate path,
269
help, options etc for the specified command.
270
271
When run_bzr() tries to instantiate that 'class' it gets caught by
272
the __call__ method, which we override to call the Command.__init__
273
method. That then calls our run method which is pretty straight
274
forward.
275
276
The only wrinkle is that we have to map bzr's dictionary of options
277
and arguments back into command line options and arguments for the
278
script.
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.
279
162
"""
280
163
281
164
def find_command(cls, cmd):
282
165
import os.path
283
166
bzrpath = os.environ.get('BZRPATH', '')
284
167
285
for dir in bzrpath.split(os.pathsep):
168
for dir in bzrpath.split(':'):
286
169
path = os.path.join(dir, cmd)
287
170
if os.path.isfile(path):
288
171
return ExternalCommand(path)
294
177
def __init__(self, path):
295
178
self.path = path
296
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
297
183
pipe = os.popen('%s --bzr-usage' % path, 'r')
298
184
self.takes_options = pipe.readline().split()
299
300
for opt in self.takes_options:
301
if not opt in OPTIONS:
302
raise BzrError("Unknown option '%s' returned by external command %s"
303
% (opt, path))
304
305
# TODO: Is there any way to check takes_args is valid here?
306
185
self.takes_args = pipe.readline().split()
307
308
if pipe.close() is not None:
309
raise BzrError("Failed funning '%s --bzr-usage'" % path)
186
pipe.close()
310
187
311
188
pipe = os.popen('%s --bzr-help' % path, 'r')
312
189
self.__doc__ = pipe.read()
313
if pipe.close() is not None:
314
raise BzrError("Failed funning '%s --bzr-help'" % path)
190
pipe.close()
315
191
316
192
def __call__(self, options, arguments):
317
193
Command.__init__(self, options, arguments)
324
200
keys = kargs.keys()
325
201
keys.sort()
326
202
for name in keys:
327
optname = name.replace('_','-')
328
203
value = kargs[name]
329
if OPTIONS.has_key(optname):
204
if OPTIONS.has_key(name):
330
205
# it's an option
331
opts.append('--%s' % optname)
206
opts.append('--%s' % name)
332
207
if value is not None and value is not True:
333
208
opts.append(str(value))
334
209
else:
378
253
directory is shown. Otherwise, only the status of the specified
379
254
files or directories is reported. If a directory is given, status
380
255
is reported for everything inside that directory.
381
382
If a revision is specified, the changes since that revision are shown.
383
256
"""
384
257
takes_args = ['file*']
385
takes_options = ['all', 'show-ids', 'revision']
258
takes_options = ['all', 'show-ids']
386
259
aliases = ['st', 'stat']
387
260
388
261
def run(self, all=False, show_ids=False, file_list=None):
389
262
if file_list:
390
b = find_branch(file_list[0])
263
b = Branch(file_list[0])
391
264
file_list = [b.relpath(x) for x in file_list]
392
265
# special case: only one path was given and it's the root
393
266
# of the branch
394
267
if file_list == ['']:
395
268
file_list = None
396
269
else:
397
b = find_branch('.')
398
399
from bzrlib.status import show_status
400
show_status(b, show_unchanged=all, show_ids=show_ids,
401
specific_files=file_list)
270
b = Branch('.')
271
import status
272
status.show_status(b, show_unchanged=all, show_ids=show_ids,
273
specific_files=file_list)
402
274
403
275
404
276
class cmd_cat_revision(Command):
408
280
takes_args = ['revision_id']
409
281
410
282
def run(self, revision_id):
411
from bzrlib.xml import pack_xml
412
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
283
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
413
284
414
285
415
286
class cmd_revno(Command):
417
288
418
289
This is equal to the number of revisions on this branch."""
419
290
def run(self):
420
print find_branch('.').revno()
421
422
class cmd_revision_info(Command):
423
"""Show revision number and revision id for a given revision identifier.
424
"""
425
hidden = True
426
takes_args = ['revision_info*']
427
takes_options = ['revision']
428
def run(self, revision=None, revision_info_list=None):
429
from bzrlib.branch import find_branch
430
431
revs = []
432
if revision is not None:
433
revs.extend(revision)
434
if revision_info_list is not None:
435
revs.extend(revision_info_list)
436
if len(revs) == 0:
437
raise BzrCommandError('You must supply a revision identifier')
438
439
b = find_branch('.')
440
441
for rev in revs:
442
print '%4d %s' % b.get_revision_info(rev)
291
print Branch('.').revno()
443
292
444
293
445
294
class cmd_add(Command):
455
304
whether already versioned or not, are searched for files or
456
305
subdirectories that are neither versioned or ignored, and these
457
306
are added. This search proceeds recursively into versioned
458
directories. If no names are given '.' is assumed.
307
directories.
459
308
460
Therefore simply saying 'bzr add' will version all files that
309
Therefore simply saying 'bzr add .' will version all files that
461
310
are currently unknown.
462
311
463
312
TODO: Perhaps adding a file whose directly is not versioned should
464
313
recursively add that parent, rather than giving an error?
465
314
"""
466
takes_args = ['file*']
315
takes_args = ['file+']
467
316
takes_options = ['verbose', 'no-recurse']
468
317
469
318
def run(self, file_list, verbose=False, no_recurse=False):
470
from bzrlib.add import smart_add
471
472
recurse = not no_recurse
473
for path, kind, file_id in smart_add(file_list, verbose, recurse):
474
print 'added', path
475
476
477
478
class cmd_mkdir(Command):
479
"""Create a new versioned directory.
480
481
This is equivalent to creating the directory and then adding it.
482
"""
483
takes_args = ['dir+']
484
485
def run(self, dir_list):
486
b = None
487
488
for d in dir_list:
489
os.mkdir(d)
490
if not b:
491
b = find_branch(d)
492
b.add([d])
493
print 'added', d
319
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
494
320
495
321
496
322
class cmd_relpath(Command):
499
325
hidden = True
500
326
501
327
def run(self, filename):
502
print find_branch(filename).relpath(filename)
328
print Branch(filename).relpath(filename)
503
329
504
330
505
331
508
334
takes_options = ['revision', 'show-ids']
509
335
510
336
def run(self, revision=None, show_ids=False):
511
b = find_branch('.')
337
b = Branch('.')
512
338
if revision == None:
513
339
inv = b.read_working_inventory()
514
340
else:
515
if len(revision) > 1:
516
raise BzrCommandError('bzr inventory --revision takes'
517
' exactly one revision identifier')
518
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
341
inv = b.get_revision_inventory(b.lookup_revision(revision))
519
342
520
343
for path, entry in inv.entries():
521
344
if show_ids:
534
357
"""
535
358
takes_args = ['source$', 'dest']
536
359
def run(self, source_list, dest):
537
b = find_branch('.')
360
b = Branch('.')
538
361
539
# TODO: glob expansion on windows?
540
362
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
541
363
542
364
557
379
takes_args = ['from_name', 'to_name']
558
380
559
381
def run(self, from_name, to_name):
560
b = find_branch('.')
382
b = Branch('.')
561
383
b.rename_one(b.relpath(from_name), b.relpath(to_name))
562
384
563
385
564
386
565
class cmd_mv(Command):
566
"""Move or rename a file.
567
568
usage:
569
bzr mv OLDNAME NEWNAME
570
bzr mv SOURCE... DESTINATION
571
572
If the last argument is a versioned directory, all the other names
573
are moved into it. Otherwise, there must be exactly two arguments
574
and the file is changed to a new name, which must not already exist.
575
576
Files cannot be moved between branches.
577
"""
578
takes_args = ['names*']
579
def run(self, names_list):
580
if len(names_list) < 2:
581
raise BzrCommandError("missing file argument")
582
b = find_branch(names_list[0])
583
584
rel_names = [b.relpath(x) for x in names_list]
585
586
if os.path.isdir(names_list[-1]):
587
# move into existing directory
588
for pair in b.move(rel_names[:-1], rel_names[-1]):
589
print "%s => %s" % pair
590
else:
591
if len(names_list) != 2:
592
raise BzrCommandError('to mv multiple files the destination '
593
'must be a versioned directory')
594
for pair in b.move(rel_names[0], rel_names[1]):
595
print "%s => %s" % pair
596
597
598
599
600
class cmd_pull(Command):
601
"""Pull any changes from another branch into the current one.
602
603
If the location is omitted, the last-used location will be used.
604
Both the revision history and the working directory will be
605
updated.
606
607
This command only works on branches that have not diverged. Branches are
608
considered diverged if both branches have had commits without first
609
pulling from the other.
610
611
If branches have diverged, you can use 'bzr merge' to pull the text changes
612
from one into the other.
613
"""
614
takes_args = ['location?']
615
616
def run(self, location=None):
617
from bzrlib.merge import merge
618
import tempfile
619
from shutil import rmtree
620
import errno
621
622
br_to = find_branch('.')
623
stored_loc = None
624
try:
625
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
626
except IOError, e:
627
if e.errno != errno.ENOENT:
628
raise
629
if location is None:
630
if stored_loc is None:
631
raise BzrCommandError("No pull location known or specified.")
632
else:
633
print "Using last location: %s" % stored_loc
634
location = stored_loc
635
cache_root = tempfile.mkdtemp()
636
from bzrlib.branch import DivergedBranches
637
br_from = find_branch(location)
638
location = pull_loc(br_from)
639
old_revno = br_to.revno()
640
try:
641
from branch import find_cached_branch, DivergedBranches
642
br_from = find_cached_branch(location, cache_root)
643
location = pull_loc(br_from)
644
old_revno = br_to.revno()
645
try:
646
br_to.update_revisions(br_from)
647
except DivergedBranches:
648
raise BzrCommandError("These branches have diverged."
649
" Try merge.")
650
651
merge(('.', -1), ('.', old_revno), check_clean=False)
652
if location != stored_loc:
653
br_to.controlfile("x-pull", "wb").write(location + "\n")
654
finally:
655
rmtree(cache_root)
656
657
658
659
class cmd_branch(Command):
660
"""Create a new copy of a branch.
661
662
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
663
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
664
665
To retrieve the branch as of a particular revision, supply the --revision
666
parameter, as in "branch foo/bar -r 5".
667
"""
668
takes_args = ['from_location', 'to_location?']
669
takes_options = ['revision']
670
aliases = ['get', 'clone']
671
672
def run(self, from_location, to_location=None, revision=None):
673
import errno
674
from bzrlib.merge import merge
675
from bzrlib.branch import DivergedBranches, \
676
find_cached_branch, Branch
677
from shutil import rmtree
678
from meta_store import CachedStore
679
import tempfile
680
cache_root = tempfile.mkdtemp()
681
682
if revision is None:
683
revision = [None]
684
elif len(revision) > 1:
685
raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
686
687
try:
688
try:
689
br_from = find_cached_branch(from_location, cache_root)
690
except OSError, e:
691
if e.errno == errno.ENOENT:
692
raise BzrCommandError('Source location "%s" does not'
693
' exist.' % to_location)
694
else:
695
raise
696
697
if to_location is None:
698
to_location = os.path.basename(from_location.rstrip("/\\"))
699
700
try:
701
os.mkdir(to_location)
702
except OSError, e:
703
if e.errno == errno.EEXIST:
704
raise BzrCommandError('Target directory "%s" already'
705
' exists.' % to_location)
706
if e.errno == errno.ENOENT:
707
raise BzrCommandError('Parent of "%s" does not exist.' %
708
to_location)
709
else:
710
raise
711
br_to = Branch(to_location, init=True)
712
713
br_to.set_root_id(br_from.get_root_id())
714
715
if revision:
716
if revision[0] is None:
717
revno = br_from.revno()
718
else:
719
revno, rev_id = br_from.get_revision_info(revision[0])
720
try:
721
br_to.update_revisions(br_from, stop_revision=revno)
722
except bzrlib.errors.NoSuchRevision:
723
rmtree(to_location)
724
msg = "The branch %s has no revision %d." % (from_location,
725
revno)
726
raise BzrCommandError(msg)
727
728
merge((to_location, -1), (to_location, 0), this_dir=to_location,
729
check_clean=False, ignore_zero=True)
730
from_location = pull_loc(br_from)
731
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
732
finally:
733
rmtree(cache_root)
734
735
736
def pull_loc(branch):
737
# TODO: Should perhaps just make attribute be 'base' in
738
# RemoteBranch and Branch?
739
if hasattr(branch, "baseurl"):
740
return branch.baseurl
741
else:
742
return branch.base
743
744
745
746
387
class cmd_renames(Command):
747
388
"""Show list of renamed files.
748
389
753
394
takes_args = ['dir?']
754
395
755
396
def run(self, dir='.'):
756
b = find_branch(dir)
397
b = Branch(dir)
757
398
old_inv = b.basis_tree().inventory
758
399
new_inv = b.read_working_inventory()
759
400
770
411
def run(self, branch=None):
771
412
import info
772
413
414
from branch import find_branch
773
415
b = find_branch(branch)
774
416
info.show_info(b)
775
417
784
426
takes_options = ['verbose']
785
427
786
428
def run(self, file_list, verbose=False):
787
b = find_branch(file_list[0])
429
b = Branch(file_list[0])
788
430
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
789
431
790
432
798
440
hidden = True
799
441
takes_args = ['filename']
800
442
def run(self, filename):
801
b = find_branch(filename)
443
b = Branch(filename)
802
444
i = b.inventory.path2id(b.relpath(filename))
803
445
if i == None:
804
raise BzrError("%r is not a versioned file" % filename)
446
bailout("%r is not a versioned file" % filename)
805
447
else:
806
448
print i
807
449
814
456
hidden = True
815
457
takes_args = ['filename']
816
458
def run(self, filename):
817
b = find_branch(filename)
459
b = Branch(filename)
818
460
inv = b.inventory
819
461
fid = inv.path2id(b.relpath(filename))
820
462
if fid == None:
821
raise BzrError("%r is not a versioned file" % filename)
463
bailout("%r is not a versioned file" % filename)
822
464
for fip in inv.get_idpath(fid):
823
465
print fip
824
466
827
469
"""Display list of revision ids on this branch."""
828
470
hidden = True
829
471
def run(self):
830
for patchid in find_branch('.').revision_history():
472
for patchid in Branch('.').revision_history():
831
473
print patchid
832
474
833
475
834
476
class cmd_directories(Command):
835
477
"""Display list of versioned directories in this branch."""
836
478
def run(self):
837
for name, ie in find_branch('.').read_working_inventory().directories():
479
for name, ie in Branch('.').read_working_inventory().directories():
838
480
if name == '':
839
481
print '.'
840
482
else:
855
497
bzr commit -m 'imported project'
856
498
"""
857
499
def run(self):
858
from bzrlib.branch import Branch
859
500
Branch('.', init=True)
860
501
861
502
865
506
If files are listed, only the changes in those files are listed.
866
507
Otherwise, all changes for the tree are listed.
867
508
509
TODO: Given two revision arguments, show the difference between them.
510
868
511
TODO: Allow diff across branches.
869
512
870
513
TODO: Option to use external diff command; could be GNU diff, wdiff,
879
522
deleted files.
880
523
881
524
TODO: This probably handles non-Unix newlines poorly.
882
883
examples:
884
bzr diff
885
bzr diff -r1
886
bzr diff -r1:2
887
525
"""
888
526
889
527
takes_args = ['file*']
890
528
takes_options = ['revision', 'diff-options']
891
aliases = ['di', 'dif']
529
aliases = ['di']
892
530
893
531
def run(self, revision=None, file_list=None, diff_options=None):
894
532
from bzrlib.diff import show_diff
533
from bzrlib import find_branch
895
534
896
535
if file_list:
897
536
b = find_branch(file_list[0])
900
539
# just pointing to top-of-tree
901
540
file_list = None
902
541
else:
903
b = find_branch('.')
542
b = Branch('.')
543
544
show_diff(b, revision, specific_files=file_list,
545
external_diff_options=diff_options)
904
546
905
if revision is not None:
906
if len(revision) == 1:
907
show_diff(b, revision[0], specific_files=file_list,
908
external_diff_options=diff_options)
909
elif len(revision) == 2:
910
show_diff(b, revision[0], specific_files=file_list,
911
external_diff_options=diff_options,
912
revision2=revision[1])
913
else:
914
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
915
else:
916
show_diff(b, None, specific_files=file_list,
917
external_diff_options=diff_options)
918
547
919
548
920
549
925
554
TODO: Show files deleted since a previous revision, or between two revisions.
926
555
"""
927
556
def run(self, show_ids=False):
928
b = find_branch('.')
557
b = Branch('.')
929
558
old = b.basis_tree()
930
559
new = b.working_tree()
931
560
946
575
"""List files modified in working tree."""
947
576
hidden = True
948
577
def run(self):
949
from bzrlib.delta import compare_trees
950
951
b = find_branch('.')
952
td = compare_trees(b.basis_tree(), b.working_tree())
953
954
for path, id, kind in td.modified:
955
print path
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)
597
print path
956
598
957
599
958
600
960
602
"""List files added in working tree."""
961
603
hidden = True
962
604
def run(self):
963
b = find_branch('.')
605
b = Branch('.')
964
606
wt = b.working_tree()
965
607
basis_inv = b.basis_tree().inventory
966
608
inv = wt.inventory
982
624
takes_args = ['filename?']
983
625
def run(self, filename=None):
984
626
"""Print the branch root."""
627
from branch import find_branch
985
628
b = find_branch(filename)
986
629
print getattr(b, 'base', None) or getattr(b, 'baseurl')
987
630
993
636
-r revision requests a specific revision, -r :end or -r begin: are
994
637
also valid.
995
638
996
--message allows you to give a regular expression, which will be evaluated
997
so that only matching entries will be displayed.
998
999
639
TODO: Make --revision support uuid: and hash: [future tag:] notation.
1000
640
1001
641
"""
1002
642
1003
643
takes_args = ['filename?']
1004
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
1005
'long', 'message', 'short',]
644
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
1006
645
1007
646
def run(self, filename=None, timezone='original',
1008
647
verbose=False,
1009
648
show_ids=False,
1010
649
forward=False,
1011
revision=None,
1012
message=None,
1013
long=False,
1014
short=False):
1015
from bzrlib.branch import find_branch
1016
from bzrlib.log import log_formatter, show_log
650
revision=None):
651
from bzrlib import show_log, find_branch
1017
652
import codecs
1018
653
1019
654
direction = (forward and 'forward') or 'reverse'
1029
664
b = find_branch('.')
1030
665
file_id = None
1031
666
1032
if revision is None:
1033
rev1 = None
1034
rev2 = None
1035
elif len(revision) == 1:
1036
rev1 = rev2 = b.get_revision_info(revision[0])[0]
1037
elif len(revision) == 2:
1038
rev1 = b.get_revision_info(revision[0])[0]
1039
rev2 = b.get_revision_info(revision[1])[0]
667
if revision == None:
668
revision = [None, None]
669
elif isinstance(revision, int):
670
revision = [revision, revision]
1040
671
else:
1041
raise BzrCommandError('bzr log --revision takes one or two values.')
1042
1043
if rev1 == 0:
1044
rev1 = None
1045
if rev2 == 0:
1046
rev2 = None
672
# pair of revisions?
673
pass
674
675
assert len(revision) == 2
1047
676
1048
677
mutter('encoding log as %r' % bzrlib.user_encoding)
1049
678
1051
680
# in e.g. the default C locale.
1052
681
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1053
682
1054
if not short:
1055
log_format = 'long'
1056
else:
1057
log_format = 'short'
1058
lf = log_formatter(log_format,
1059
show_ids=show_ids,
1060
to_file=outf,
1061
show_timezone=timezone)
1062
1063
show_log(b,
1064
lf,
1065
file_id,
683
show_log(b, file_id,
684
show_timezone=timezone,
1066
685
verbose=verbose,
686
show_ids=show_ids,
687
to_file=outf,
1067
688
direction=direction,
1068
start_revision=rev1,
1069
end_revision=rev2,
1070
search=message)
689
start_revision=revision[0],
690
end_revision=revision[1])
1071
691
1072
692
1073
693
1078
698
hidden = True
1079
699
takes_args = ["filename"]
1080
700
def run(self, filename):
1081
b = find_branch(filename)
701
b = Branch(filename)
1082
702
inv = b.read_working_inventory()
1083
703
file_id = inv.path2id(b.relpath(filename))
1084
704
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1092
712
"""
1093
713
hidden = True
1094
714
def run(self, revision=None, verbose=False):
1095
b = find_branch('.')
715
b = Branch('.')
1096
716
if revision == None:
1097
717
tree = b.working_tree()
1098
718
else:
1114
734
1115
735
1116
736
class cmd_unknowns(Command):
1117
"""List unknown files."""
737
"""List unknown files"""
1118
738
def run(self):
1119
from bzrlib.osutils import quotefn
1120
for f in find_branch('.').unknowns():
739
for f in Branch('.').unknowns():
1121
740
print quotefn(f)
1122
741
1123
742
1124
743
1125
744
class cmd_ignore(Command):
1126
"""Ignore a command or pattern.
745
"""Ignore a command or pattern
1127
746
1128
747
To remove patterns from the ignore list, edit the .bzrignore file.
1129
748
1145
764
from bzrlib.atomicfile import AtomicFile
1146
765
import os.path
1147
766
1148
b = find_branch('.')
767
b = Branch('.')
1149
768
ifn = b.abspath('.bzrignore')
1150
769
1151
770
if os.path.exists(ifn):
1185
804
1186
805
See also: bzr ignore"""
1187
806
def run(self):
1188
tree = find_branch('.').working_tree()
807
tree = Branch('.').working_tree()
1189
808
for path, file_class, kind, file_id in tree.list_files():
1190
809
if file_class != 'I':
1191
810
continue
1209
828
except ValueError:
1210
829
raise BzrCommandError("not a valid revision-number: %r" % revno)
1211
830
1212
print find_branch('.').lookup_revision(revno)
831
print Branch('.').lookup_revision(revno)
1213
832
1214
833
1215
834
class cmd_export(Command):
1216
835
"""Export past revision to destination directory.
1217
836
1218
If no revision is specified this exports the last committed revision.
1219
1220
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1221
given, try to find the format with the extension. If no extension
1222
is found exports to a directory (equivalent to --format=dir).
1223
1224
Root may be the top directory for tar, tgz and tbz2 formats. If none
1225
is given, the top directory will be the root name of the file."""
1226
# TODO: list known exporters
837
If no revision is specified this exports the last committed revision."""
1227
838
takes_args = ['dest']
1228
takes_options = ['revision', 'format', 'root']
1229
def run(self, dest, revision=None, format=None, root=None):
1230
import os.path
1231
b = find_branch('.')
1232
if revision is None:
1233
rev_id = b.last_patch()
839
takes_options = ['revision']
840
def run(self, dest, revision=None):
841
b = Branch('.')
842
if revision == None:
843
rh = b.revision_history()[-1]
1234
844
else:
1235
if len(revision) != 1:
1236
raise BzrError('bzr export --revision takes exactly 1 argument')
1237
revno, rev_id = b.get_revision_info(revision[0])
1238
t = b.revision_tree(rev_id)
1239
root, ext = os.path.splitext(dest)
1240
if not format:
1241
if ext in (".tar",):
1242
format = "tar"
1243
elif ext in (".gz", ".tgz"):
1244
format = "tgz"
1245
elif ext in (".bz2", ".tbz2"):
1246
format = "tbz2"
1247
else:
1248
format = "dir"
1249
t.export(dest, format, root)
845
rh = b.lookup_revision(int(revision))
846
t = b.revision_tree(rh)
847
t.export(dest)
1250
848
1251
849
1252
850
class cmd_cat(Command):
1258
856
def run(self, filename, revision=None):
1259
857
if revision == None:
1260
858
raise BzrCommandError("bzr cat requires a revision number")
1261
elif len(revision) != 1:
1262
raise BzrCommandError("bzr cat --revision takes exactly one number")
1263
b = find_branch('.')
1264
b.print_file(b.relpath(filename), revision[0])
859
b = Branch('.')
860
b.print_file(b.relpath(filename), int(revision))
1265
861
1266
862
1267
863
class cmd_local_time_offset(Command):
1274
870
1275
871
class cmd_commit(Command):
1276
872
"""Commit changes into a new revision.
1277
1278
If no arguments are given, the entire tree is committed.
1279
873
1280
874
If selected files are specified, only changes to those files are
1281
committed. If a directory is specified then the directory and everything
1282
within it is committed.
875
committed. If a directory is specified then its contents are also
876
committed.
1283
877
1284
878
A selected-file commit may fail in some cases where the committed
1285
879
tree would be invalid, such as trying to commit a file in a
1290
884
TODO: Strict commit that fails if there are unknown or deleted files.
1291
885
"""
1292
886
takes_args = ['selected*']
1293
takes_options = ['message', 'file', 'verbose', 'unchanged']
887
takes_options = ['message', 'file', 'verbose']
1294
888
aliases = ['ci', 'checkin']
1295
889
1296
# TODO: Give better message for -s, --summary, used by tla people
1297
1298
def run(self, message=None, file=None, verbose=True, selected_list=None,
1299
unchanged=False):
1300
from bzrlib.errors import PointlessCommit
1301
from bzrlib.osutils import get_text_message
890
def run(self, message=None, file=None, verbose=True, selected_list=None):
891
from bzrlib.commit import commit
1302
892
1303
893
## Warning: shadows builtin file()
1304
894
if not message and not file:
1305
# FIXME: Ugly; change status code to send to a provided function?
1306
1307
import cStringIO
1308
stdout = sys.stdout
1309
catcher = cStringIO.StringIO()
1310
sys.stdout = catcher
1311
cmd_status({"file_list":selected_list}, {})
1312
info = catcher.getvalue()
1313
sys.stdout = stdout
1314
message = get_text_message(info)
1315
1316
if message is None:
1317
raise BzrCommandError("please specify a commit message",
1318
["use either --message or --file"])
895
raise BzrCommandError("please specify a commit message",
896
["use either --message or --file"])
1319
897
elif message and file:
1320
898
raise BzrCommandError("please specify either --message or --file")
1321
899
1323
901
import codecs
1324
902
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1325
903
1326
b = find_branch('.')
1327
if selected_list:
1328
selected_list = [b.relpath(s) for s in selected_list]
1329
1330
try:
1331
b.commit(message, verbose=verbose,
1332
specific_files=selected_list,
1333
allow_pointless=unchanged)
1334
except PointlessCommit:
1335
# FIXME: This should really happen before the file is read in;
1336
# perhaps prepare the commit; get the message; then actually commit
1337
raise BzrCommandError("no changes to commit",
1338
["use --unchanged to commit anyhow"])
904
b = Branch('.')
905
commit(b, message, verbose=verbose, specific_files=selected_list)
1339
906
1340
907
1341
908
class cmd_check(Command):
1343
910
1344
911
This command checks various invariants about the branch storage to
1345
912
detect data corruption or bzr bugs.
1346
1347
If given the --update flag, it will update some optional fields
1348
to help ensure data consistency.
1349
"""
1350
takes_args = ['dir?']
1351
1352
def run(self, dir='.'):
1353
from bzrlib.check import check
1354
1355
check(find_branch(dir))
1356
1357
1358
class cmd_scan_cache(Command):
1359
hidden = True
1360
def run(self):
1361
from bzrlib.hashcache import HashCache
1362
import os
1363
1364
c = HashCache('.')
1365
c.read()
1366
c.scan()
1367
1368
print '%6d stats' % c.stat_count
1369
print '%6d in hashcache' % len(c._cache)
1370
print '%6d files removed from cache' % c.removed_count
1371
print '%6d hashes updated' % c.update_count
1372
print '%6d files changed too recently to cache' % c.danger_count
1373
1374
if c.needs_write:
1375
c.write()
1376
1377
1378
1379
class cmd_upgrade(Command):
1380
"""Upgrade branch storage to current format.
1381
1382
The check command or bzr developers may sometimes advise you to run
1383
this command.
1384
"""
1385
takes_args = ['dir?']
1386
1387
def run(self, dir='.'):
1388
from bzrlib.upgrade import upgrade
1389
upgrade(find_branch(dir))
913
"""
914
takes_args = ['dir?']
915
def run(self, dir='.'):
916
import bzrlib.check
917
bzrlib.check.check(Branch(dir))
1390
918
1391
919
1392
920
1395
923
takes_options = ['email']
1396
924
1397
925
def run(self, email=False):
1398
try:
1399
b = bzrlib.branch.find_branch('.')
1400
except:
1401
b = None
1402
1403
926
if email:
1404
print bzrlib.osutils.user_email(b)
927
print bzrlib.osutils.user_email()
1405
928
else:
1406
print bzrlib.osutils.username(b)
929
print bzrlib.osutils.username()
1407
930
1408
931
1409
932
class cmd_selftest(Command):
1410
933
"""Run internal test suite"""
1411
934
hidden = True
1412
takes_options = ['verbose']
1413
def run(self, verbose=False):
1414
import bzrlib.ui
935
def run(self):
1415
936
from bzrlib.selftest import selftest
1416
1417
# we don't want progress meters from the tests to go to the
1418
# real output; and we don't want log messages cluttering up
1419
# the real logs.
1420
1421
save_ui = bzrlib.ui.ui_factory
1422
bzrlib.trace.info('running tests...')
1423
try:
1424
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1425
result = selftest(verbose=verbose)
1426
if result:
1427
bzrlib.trace.info('tests passed')
1428
else:
1429
bzrlib.trace.info('tests failed')
1430
return int(not result)
1431
finally:
1432
bzrlib.ui.ui_factory = save_ui
937
if selftest():
938
return 0
939
else:
940
return 1
941
1433
942
1434
943
1435
944
class cmd_version(Command):
1436
"""Show version of bzr."""
945
"""Show version of bzr"""
1437
946
def run(self):
1438
947
show_version()
1439
948
1458
967
print "it sure does!"
1459
968
1460
969
def parse_spec(spec):
1461
"""
1462
>>> parse_spec(None)
1463
[None, None]
1464
>>> parse_spec("./")
1465
['./', None]
1466
>>> parse_spec("../@")
1467
['..', -1]
1468
>>> parse_spec("../f/@35")
1469
['../f', 35]
1470
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1471
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1472
"""
1473
if spec is None:
1474
return [None, None]
1475
970
if '/@' in spec:
1476
971
parsed = spec.split('/@')
1477
972
assert len(parsed) == 2
1478
973
if parsed[1] == "":
1479
974
parsed[1] = -1
1480
975
else:
1481
try:
1482
parsed[1] = int(parsed[1])
1483
except ValueError:
1484
pass # We can allow stuff like ./@revid:blahblahblah
1485
else:
1486
assert parsed[1] >=0
976
parsed[1] = int(parsed[1])
977
assert parsed[1] >=0
1487
978
else:
1488
979
parsed = [spec, None]
1489
980
return parsed
1490
981
1491
1492
1493
class cmd_find_merge_base(Command):
1494
"""Find and print a base revision for merging two branches.
1495
1496
TODO: Options to specify revisions on either side, as if
1497
merging only part of the history.
1498
"""
1499
takes_args = ['branch', 'other']
1500
hidden = True
1501
1502
def run(self, branch, other):
1503
branch1 = find_branch(branch)
1504
branch2 = find_branch(other)
1505
1506
base_revno, base_revid = branch1.common_ancestor(branch2)
1507
1508
if base_revno is None:
1509
raise bzrlib.errors.UnrelatedBranches()
1510
1511
print 'merge base is revision %s' % base_revid
1512
print ' r%-6d in %s' % (base_revno, branch)
1513
1514
other_revno = branch2.revision_id_to_revno(base_revid)
1515
1516
print ' r%-6d in %s' % (other_revno, other)
1517
1518
1519
1520
982
class cmd_merge(Command):
1521
"""Perform a three-way merge.
1522
1523
The branch is the branch you will merge from. By default, it will merge
1524
the latest revision. If you specify a revision, that revision will be
1525
merged. If you specify two revisions, the first will be used as a BASE,
1526
and the second one as OTHER. Revision numbers are always relative to the
1527
specified branch.
1528
1529
Examples:
1530
1531
To merge the latest revision from bzr.dev
1532
bzr merge ../bzr.dev
1533
1534
To merge changes up to and including revision 82 from bzr.dev
1535
bzr merge -r 82 ../bzr.dev
1536
1537
To merge the changes introduced by 82, without previous changes:
1538
bzr merge -r 81..82 ../bzr.dev
1539
1540
merge refuses to run if there are any uncommitted changes, unless
1541
--force is given.
1542
"""
1543
takes_args = ['branch?']
1544
takes_options = ['revision', 'force', 'merge-type']
1545
1546
def run(self, branch='.', revision=None, force=False,
1547
merge_type=None):
1548
from bzrlib.merge import merge
1549
from bzrlib.merge_core import ApplyMerge3
1550
if merge_type is None:
1551
merge_type = ApplyMerge3
1552
1553
if revision is None or len(revision) < 1:
1554
base = (None, None)
1555
other = (branch, -1)
1556
else:
1557
if len(revision) == 1:
1558
other = (branch, revision[0])
1559
base = (None, None)
1560
else:
1561
assert len(revision) == 2
1562
if None in revision:
1563
raise BzrCommandError(
1564
"Merge doesn't permit that revision specifier.")
1565
base = (branch, revision[0])
1566
other = (branch, revision[1])
1567
1568
merge(other, base, check_clean=(not force), merge_type=merge_type)
1569
1570
1571
class cmd_revert(Command):
1572
"""Reverse all changes since the last commit.
1573
1574
Only versioned files are affected. Specify filenames to revert only
1575
those files. By default, any files that are changed will be backed up
1576
first. Backup files have a '~' appended to their name.
1577
"""
1578
takes_options = ['revision', 'no-backup']
1579
takes_args = ['file*']
1580
aliases = ['merge-revert']
1581
1582
def run(self, revision=None, no_backup=False, file_list=None):
1583
from bzrlib.merge import merge
1584
if file_list is not None:
1585
if len(file_list) == 0:
1586
raise BzrCommandError("No files specified")
1587
if revision is None:
1588
revision = [-1]
1589
elif len(revision) != 1:
1590
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1591
merge(('.', revision[0]), parse_spec('.'),
1592
check_clean=False,
1593
ignore_zero=True,
1594
backup_files=not no_backup,
1595
file_list=file_list)
1596
983
"""Perform a three-way merge of trees."""
984
takes_args = ['other_spec', 'base_spec']
985
986
def run(self, other_spec, base_spec):
987
from bzrlib.merge import merge
988
merge(parse_spec(other_spec), parse_spec(base_spec))
1597
989
1598
990
class cmd_assert_fail(Command):
1599
991
"""Test reporting of assertion failures"""
1606
998
"""Show help on a command or other topic.
1607
999
1608
1000
For a list of all available commands, say 'bzr help commands'."""
1609
takes_options = ['long']
1610
1001
takes_args = ['topic?']
1611
1002
aliases = ['?']
1612
1003
1613
def run(self, topic=None, long=False):
1004
def run(self, topic=None):
1614
1005
import help
1615
if topic is None and long:
1616
topic = "commands"
1617
1006
help.help(topic)
1618
1007
1619
1008
1620
class cmd_shell_complete(Command):
1621
"""Show appropriate completions for context.
1622
1623
For a list of all available commands, say 'bzr shell-complete'."""
1624
takes_args = ['context?']
1625
aliases = ['s-c']
1626
hidden = True
1627
1628
def run(self, context=None):
1629
import shellcomplete
1630
shellcomplete.shellcomplete(context)
1631
1632
1633
class cmd_missing(Command):
1634
"""What is missing in this branch relative to other branch.
1635
"""
1636
takes_args = ['remote?']
1637
aliases = ['mis', 'miss']
1638
# We don't have to add quiet to the list, because
1639
# unknown options are parsed as booleans
1640
takes_options = ['verbose', 'quiet']
1641
1642
def run(self, remote=None, verbose=False, quiet=False):
1643
from bzrlib.branch import find_branch, DivergedBranches
1644
from bzrlib.errors import BzrCommandError
1645
from bzrlib.missing import get_parent, show_missing
1646
1647
if verbose and quiet:
1648
raise BzrCommandError('Cannot pass both quiet and verbose')
1649
1650
b = find_branch('.')
1651
parent = get_parent(b)
1652
if remote is None:
1653
if parent is None:
1654
raise BzrCommandError("No missing location known or specified.")
1655
else:
1656
if not quiet:
1657
print "Using last location: %s" % parent
1658
remote = parent
1659
elif parent is None:
1660
# We only update x-pull if it did not exist, missing should not change the parent
1661
b.controlfile('x-pull', 'wb').write(remote + '\n')
1662
br_remote = find_branch(remote)
1663
1664
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1665
1666
1667
1668
class cmd_plugins(Command):
1669
"""List plugins"""
1009
class cmd_update_stat_cache(Command):
1010
"""Update stat-cache mapping inodes to SHA-1 hashes.
1011
1012
For testing only."""
1670
1013
hidden = True
1671
1014
def run(self):
1672
import bzrlib.plugin
1673
from inspect import getdoc
1674
from pprint import pprint
1675
for plugin in bzrlib.plugin.all_plugins:
1676
print plugin.__path__[0]
1677
d = getdoc(plugin)
1678
if d:
1679
print '\t', d.split('\n')[0]
1680
1681
#pprint(bzrlib.plugin.all_plugins)
1015
import statcache
1016
b = Branch('.')
1017
statcache.update_cache(b.base, b.read_working_inventory())
1682
1018
1683
1019
1684
1020
1690
1026
'diff-options': str,
1691
1027
'help': None,
1692
1028
'file': unicode,
1693
'force': None,
1694
'format': unicode,
1695
1029
'forward': None,
1696
1030
'message': unicode,
1697
1031
'no-recurse': None,
1698
1032
'profile': None,
1699
1033
'revision': _parse_revision_str,
1700
'short': None,
1701
1034
'show-ids': None,
1702
1035
'timezone': str,
1703
1036
'verbose': None,
1704
1037
'version': None,
1705
1038
'email': None,
1706
'unchanged': None,
1707
'update': None,
1708
'long': None,
1709
'root': str,
1710
'no-backup': None,
1711
'merge-type': get_merge_type,
1712
1039
}
1713
1040
1714
1041
SHORT_OPTIONS = {
1717
1044
'm': 'message',
1718
1045
'r': 'revision',
1719
1046
'v': 'verbose',
1720
'l': 'long',
1721
1047
}
1722
1048
1723
1049
1737
1063
(['status'], {'all': True})
1738
1064
>>> parse_args('commit --message=biter'.split())
1739
1065
(['commit'], {'message': u'biter'})
1740
>>> parse_args('log -r 500'.split())
1741
(['log'], {'revision': [500]})
1742
>>> parse_args('log -r500..600'.split())
1743
(['log'], {'revision': [500, 600]})
1744
>>> parse_args('log -vr500..600'.split())
1745
(['log'], {'verbose': True, 'revision': [500, 600]})
1746
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1747
(['log'], {'revision': ['v500', 600]})
1748
1066
"""
1749
1067
args = []
1750
1068
opts = {}
1764
1082
else:
1765
1083
optname = a[2:]
1766
1084
if optname not in OPTIONS:
1767
raise BzrError('unknown long option %r' % a)
1085
bailout('unknown long option %r' % a)
1768
1086
else:
1769
1087
shortopt = a[1:]
1770
if shortopt in SHORT_OPTIONS:
1771
# Multi-character options must have a space to delimit
1772
# their value
1773
optname = SHORT_OPTIONS[shortopt]
1774
else:
1775
# Single character short options, can be chained,
1776
# and have their value appended to their name
1777
shortopt = a[1:2]
1778
if shortopt not in SHORT_OPTIONS:
1779
# We didn't find the multi-character name, and we
1780
# didn't find the single char name
1781
raise BzrError('unknown short option %r' % a)
1782
optname = SHORT_OPTIONS[shortopt]
1783
1784
if a[2:]:
1785
# There are extra things on this option
1786
# see if it is the value, or if it is another
1787
# short option
1788
optargfn = OPTIONS[optname]
1789
if optargfn is None:
1790
# This option does not take an argument, so the
1791
# next entry is another short option, pack it back
1792
# into the list
1793
argv.insert(0, '-' + a[2:])
1794
else:
1795
# This option takes an argument, so pack it
1796
# into the array
1797
optarg = a[2:]
1088
if shortopt not in SHORT_OPTIONS:
1089
bailout('unknown short option %r' % a)
1090
optname = SHORT_OPTIONS[shortopt]
1798
1091
1799
1092
if optname in opts:
1800
1093
# XXX: Do we ever want to support this, e.g. for -r?
1801
raise BzrError('repeated option %r' % a)
1094
bailout('repeated option %r' % a)
1802
1095
1803
1096
optargfn = OPTIONS[optname]
1804
1097
if optargfn:
1805
1098
if optarg == None:
1806
1099
if not argv:
1807
raise BzrError('option %r needs an argument' % a)
1100
bailout('option %r needs an argument' % a)
1808
1101
else:
1809
1102
optarg = argv.pop(0)
1810
1103
opts[optname] = optargfn(optarg)
1811
1104
else:
1812
1105
if optarg != None:
1813
raise BzrError('option %r takes no argument' % optname)
1106
bailout('option %r takes no argument' % optname)
1814
1107
opts[optname] = True
1815
1108
else:
1816
1109
args.append(a)
1870
1163
1871
1164
This is similar to main(), but without all the trappings for
1872
1165
logging and error handling.
1873
1874
argv
1875
The command-line arguments, without the program name from argv[0]
1876
1877
Returns a command status or raises an exception.
1878
1879
Special master options: these must come before the command because
1880
they control how the command is interpreted.
1881
1882
--no-plugins
1883
Do not load plugin modules at all
1884
1885
--builtin
1886
Only use builtin commands. (Plugins are still allowed to change
1887
other behaviour.)
1888
1889
--profile
1890
Run under the Python profiler.
1891
1166
"""
1892
1893
1167
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1894
1895
opt_profile = opt_no_plugins = opt_builtin = False
1896
1897
# --no-plugins is handled specially at a very early stage. We need
1898
# to load plugins before doing other command parsing so that they
1899
# can override commands, but this needs to happen first.
1900
1901
for a in argv[:]:
1902
if a == '--profile':
1903
opt_profile = True
1904
elif a == '--no-plugins':
1905
opt_no_plugins = True
1906
elif a == '--builtin':
1907
opt_builtin = True
1908
else:
1909
break
1910
argv.remove(a)
1911
1912
if not opt_no_plugins:
1913
from bzrlib.plugin import load_plugins
1914
load_plugins()
1915
1916
args, opts = parse_args(argv)
1917
1918
if 'help' in opts:
1919
from bzrlib.help import help
1920
if args:
1921
help(args[0])
1922
else:
1923
help()
1924
return 0
1925
1926
if 'version' in opts:
1927
show_version()
1928
return 0
1929
1930
if not args:
1931
from bzrlib.help import help
1932
help(None)
1933
return 0
1934
1935
cmd = str(args.pop(0))
1936
1937
canonical_cmd, cmd_class = \
1938
get_cmd_class(cmd, plugins_override=not opt_builtin)
1168
1169
try:
1170
args, opts = parse_args(argv[1:])
1171
if 'help' in opts:
1172
import help
1173
if args:
1174
help.help(args[0])
1175
else:
1176
help.help()
1177
return 0
1178
elif 'version' in opts:
1179
show_version()
1180
return 0
1181
cmd = str(args.pop(0))
1182
except IndexError:
1183
import help
1184
help.help()
1185
return 1
1186
1187
1188
canonical_cmd, cmd_class = get_cmd_class(cmd)
1189
1190
# global option
1191
if 'profile' in opts:
1192
profile = True
1193
del opts['profile']
1194
else:
1195
profile = False
1939
1196
1940
1197
# check options are reasonable
1941
1198
allowed = cmd_class.takes_options
1950
1207
for k, v in opts.items():
1951
1208
cmdopts[k.replace('-', '_')] = v
1952
1209
1953
if opt_profile:
1210
if profile:
1954
1211
import hotshot, tempfile
1955
1212
pffileno, pfname = tempfile.mkstemp()
1956
1213
try:
1975
1232
return cmd_class(cmdopts, cmdargs).status
1976
1233
1977
1234
1235
def _report_exception(summary, quiet=False):
1236
import traceback
1237
log_error('bzr: ' + summary)
1238
bzrlib.trace.log_exception()
1239
1240
if not quiet:
1241
tb = sys.exc_info()[2]
1242
exinfo = traceback.extract_tb(tb)
1243
if exinfo:
1244
sys.stderr.write(' at %s:%d in %s()\n' % exinfo[-1][:3])
1245
sys.stderr.write(' see ~/.bzr.log for debug information\n')
1246
1247
1248
1978
1249
def main(argv):
1979
import bzrlib.ui
1250
import errno
1980
1251
1981
bzrlib.trace.log_startup(argv)
1982
1983
bzrlib.ui.ui_factory = bzrlib.ui.TextUIFactory()
1252
bzrlib.open_tracefile(argv)
1984
1253
1985
1254
try:
1986
1255
try:
1987
return run_bzr(argv[1:])
1988
finally:
1989
# do this here inside the exception wrappers to catch EPIPE
1990
sys.stdout.flush()
1991
except BzrCommandError, e:
1992
# command line syntax error, etc
1993
log_error(str(e))
1994
return 1
1995
except BzrError, e:
1996
bzrlib.trace.log_exception()
1997
return 1
1998
except AssertionError, e:
1999
bzrlib.trace.log_exception('assertion failed: ' + str(e))
2000
return 3
2001
except KeyboardInterrupt, e:
2002
bzrlib.trace.note('interrupted')
2003
return 2
2004
except Exception, e:
2005
import errno
2006
if (isinstance(e, IOError)
2007
and hasattr(e, 'errno')
2008
and e.errno == errno.EPIPE):
2009
bzrlib.trace.note('broken pipe')
2010
return 2
2011
else:
2012
bzrlib.trace.log_exception()
2013
return 2
1256
try:
1257
return run_bzr(argv)
1258
finally:
1259
# do this here inside the exception wrappers to catch EPIPE
1260
sys.stdout.flush()
1261
except BzrError, e:
1262
quiet = isinstance(e, (BzrCommandError))
1263
_report_exception('error: ' + e.args[0], quiet=quiet)
1264
if len(e.args) > 1:
1265
for h in e.args[1]:
1266
# some explanation or hints
1267
log_error(' ' + h)
1268
return 1
1269
except AssertionError, e:
1270
msg = 'assertion failed'
1271
if str(e):
1272
msg += ': ' + str(e)
1273
_report_exception(msg)
1274
return 2
1275
except KeyboardInterrupt, e:
1276
_report_exception('interrupted', quiet=True)
1277
return 2
1278
except Exception, e:
1279
quiet = False
1280
if (isinstance(e, IOError)
1281
and hasattr(e, 'errno')
1282
and e.errno == errno.EPIPE):
1283
quiet = True
1284
msg = 'broken pipe'
1285
else:
1286
msg = str(e).rstrip('\n')
1287
_report_exception(msg, quiet)
1288
return 2
1289
finally:
1290
bzrlib.trace.close_trace()
2014
1291
2015
1292
2016
1293
if __name__ == '__main__':
Loggerhead is a web-based interface for Breezy
Version: 2.0.1