« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 426
- compare with another revision
- download diff
- download tarball
- view history from revision 426
- Committer: Martin Pool
- Date: 2005-05-10 04:32:39 UTC
- Revision ID: mbp@sourcefrog.net-20050510043239-d866ce1a4f472b7f
- Skip symlinks during recursive add (path from aaron)
- files added:
- bzrlib/tests.py
- files removed:
- bzr-man.py
- bzrlib/selftest
- patches
- files renamed:
- bzrlib/statcache.py => bzrlib/cache.py
- contrib/bash/bzr.simple => contrib/bash/bzr
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
16
16
17
17
18
18
19
import sys, os
19
import sys, os, time, os.path
20
from sets import Set
20
21
21
22
import bzrlib
22
23
from bzrlib.trace import mutter, note, log_error
23
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
24
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
25
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
26
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
27
from bzrlib.revision import Revision
28
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
26
29
format_date
27
30
28
31
29
plugin_cmds = {}
30
31
32
def register_plugin_command(cmd):
33
"Utility function to help register a command"
34
global plugin_cmds
35
k = cmd.__name__
36
if k.startswith("cmd_"):
37
k_unsquished = _unsquish_command_name(k)
38
else:
39
k_unsquished = k
40
if not plugin_cmds.has_key(k_unsquished):
41
plugin_cmds[k_unsquished] = cmd
42
else:
43
log_error('Two plugins defined the same command: %r' % k)
44
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
45
46
47
32
def _squish_command_name(cmd):
48
33
return 'cmd_' + cmd.replace('-', '_')
49
34
52
37
assert cmd.startswith("cmd_")
53
38
return cmd[4:].replace('_','-')
54
39
55
def _parse_revision_str(revstr):
56
"""This handles a revision string -> revno.
57
58
There are several possibilities:
59
60
'234' -> 234
61
'234:345' -> [234, 345]
62
':234' -> [None, 234]
63
'234:' -> [234, None]
64
65
In the future we will also support:
66
'uuid:blah-blah-blah' -> ?
67
'hash:blahblahblah' -> ?
68
potentially:
69
'tag:mytag' -> ?
70
"""
71
if revstr.find(':') != -1:
72
revs = revstr.split(':')
73
if len(revs) > 2:
74
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
75
76
if not revs[0]:
77
revs[0] = None
78
else:
79
revs[0] = int(revs[0])
80
81
if not revs[1]:
82
revs[1] = None
83
else:
84
revs[1] = int(revs[1])
85
else:
86
revs = int(revstr)
87
return revs
88
89
90
91
def _get_cmd_dict(plugins_override=True):
92
d = {}
40
def get_all_cmds():
41
"""Return canonical name and class for all registered commands."""
93
42
for k, v in globals().iteritems():
94
43
if k.startswith("cmd_"):
95
d[_unsquish_command_name(k)] = v
96
# If we didn't load plugins, the plugin_cmds dict will be empty
97
if plugins_override:
98
d.update(plugin_cmds)
99
else:
100
d2 = plugin_cmds.copy()
101
d2.update(d)
102
d = d2
103
return d
104
105
106
def get_all_cmds(plugins_override=True):
107
"""Return canonical name and class for all registered commands."""
108
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
109
yield k,v
110
111
112
def get_cmd_class(cmd, plugins_override=True):
44
yield _unsquish_command_name(k), v
45
46
def get_cmd_class(cmd):
113
47
"""Return the canonical name and command class for a command.
114
48
"""
115
49
cmd = str(cmd) # not unicode
116
50
117
51
# first look up this command under the specified name
118
cmds = _get_cmd_dict(plugins_override=plugins_override)
119
52
try:
120
return cmd, cmds[cmd]
53
return cmd, globals()[_squish_command_name(cmd)]
121
54
except KeyError:
122
55
pass
123
56
124
57
# look for any command which claims this as an alias
125
for cmdname, cmdclass in cmds.iteritems():
58
for cmdname, cmdclass in get_all_cmds():
126
59
if cmd in cmdclass.aliases:
127
60
return cmdname, cmdclass
128
61
133
66
raise BzrCommandError("unknown command %r" % cmd)
134
67
135
68
136
class Command(object):
69
class Command:
137
70
"""Base class for commands.
138
71
139
72
The docstring for an actual command should give a single-line
198
131
"""
199
132
200
133
def find_command(cls, cmd):
201
import os.path
202
134
bzrpath = os.environ.get('BZRPATH', '')
203
135
204
for dir in bzrpath.split(os.pathsep):
136
for dir in bzrpath.split(':'):
205
137
path = os.path.join(dir, cmd)
206
138
if os.path.isfile(path):
207
139
return ExternalCommand(path)
213
145
def __init__(self, path):
214
146
self.path = path
215
147
148
# TODO: If either of these fail, we should detect that and
149
# assume that path is not really a bzr plugin after all.
150
216
151
pipe = os.popen('%s --bzr-usage' % path, 'r')
217
152
self.takes_options = pipe.readline().split()
218
219
for opt in self.takes_options:
220
if not opt in OPTIONS:
221
raise BzrError("Unknown option '%s' returned by external command %s"
222
% (opt, path))
223
224
# TODO: Is there any way to check takes_args is valid here?
225
153
self.takes_args = pipe.readline().split()
226
227
if pipe.close() is not None:
228
raise BzrError("Failed funning '%s --bzr-usage'" % path)
154
pipe.close()
229
155
230
156
pipe = os.popen('%s --bzr-help' % path, 'r')
231
157
self.__doc__ = pipe.read()
232
if pipe.close() is not None:
233
raise BzrError("Failed funning '%s --bzr-help'" % path)
158
pipe.close()
234
159
235
160
def __call__(self, options, arguments):
236
161
Command.__init__(self, options, arguments)
243
168
keys = kargs.keys()
244
169
keys.sort()
245
170
for name in keys:
246
optname = name.replace('_','-')
247
171
value = kargs[name]
248
if OPTIONS.has_key(optname):
172
if OPTIONS.has_key(name):
249
173
# it's an option
250
opts.append('--%s' % optname)
174
opts.append('--%s' % name)
251
175
if value is not None and value is not True:
252
176
opts.append(str(value))
253
177
else:
265
189
class cmd_status(Command):
266
190
"""Display status summary.
267
191
268
This reports on versioned and unknown files, reporting them
269
grouped by state. Possible states are:
270
271
added
272
Versioned in the working copy but not in the previous revision.
273
274
removed
275
Versioned in the previous revision but removed or deleted
276
in the working copy.
277
278
renamed
279
Path of this file changed from the previous revision;
280
the text may also have changed. This includes files whose
281
parent directory was renamed.
282
283
modified
284
Text has changed since the previous revision.
285
286
unchanged
287
Nothing about this file has changed since the previous revision.
288
Only shown with --all.
289
290
unknown
291
Not versioned and not matching an ignore pattern.
292
293
To see ignored files use 'bzr ignored'. For details in the
294
changes to file texts, use 'bzr diff'.
295
296
If no arguments are specified, the status of the entire working
297
directory is shown. Otherwise, only the status of the specified
298
files or directories is reported. If a directory is given, status
299
is reported for everything inside that directory.
192
For each file there is a single line giving its file state and name.
193
The name is that in the current revision unless it is deleted or
194
missing, in which case the old name is shown.
300
195
"""
301
196
takes_args = ['file*']
302
takes_options = ['all', 'show-ids']
197
takes_options = ['all']
303
198
aliases = ['st', 'stat']
304
199
305
def run(self, all=False, show_ids=False, file_list=None):
306
if file_list:
307
b = Branch(file_list[0])
308
file_list = [b.relpath(x) for x in file_list]
309
# special case: only one path was given and it's the root
310
# of the branch
311
if file_list == ['']:
312
file_list = None
313
else:
314
b = Branch('.')
315
import status
316
status.show_status(b, show_unchanged=all, show_ids=show_ids,
317
specific_files=file_list)
200
def run(self, all=False, file_list=None):
201
b = Branch('.', lock_mode='r')
202
b.show_status(show_all=all, file_list=file_list)
318
203
319
204
320
205
class cmd_cat_revision(Command):
357
242
recursively add that parent, rather than giving an error?
358
243
"""
359
244
takes_args = ['file+']
360
takes_options = ['verbose', 'no-recurse']
245
takes_options = ['verbose']
361
246
362
def run(self, file_list, verbose=False, no_recurse=False):
363
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
247
def run(self, file_list, verbose=False):
248
bzrlib.add.smart_add(file_list, verbose)
364
249
365
250
366
251
class cmd_relpath(Command):
367
252
"""Show path of a file relative to root"""
368
253
takes_args = ['filename']
369
hidden = True
370
254
371
255
def run(self, filename):
372
256
print Branch(filename).relpath(filename)
375
259
376
260
class cmd_inventory(Command):
377
261
"""Show inventory of the current working copy or a revision."""
378
takes_options = ['revision', 'show-ids']
262
takes_options = ['revision']
379
263
380
def run(self, revision=None, show_ids=False):
264
def run(self, revision=None):
381
265
b = Branch('.')
382
266
if revision == None:
383
267
inv = b.read_working_inventory()
384
268
else:
385
269
inv = b.get_revision_inventory(b.lookup_revision(revision))
386
270
387
for path, entry in inv.entries():
388
if show_ids:
389
print '%-50s %s' % (path, entry.file_id)
390
else:
391
print path
271
for path, entry in inv.iter_entries():
272
print '%-50s %s' % (entry.file_id, path)
392
273
393
274
394
275
class cmd_move(Command):
428
309
429
310
430
311
431
432
433
class cmd_pull(Command):
434
"""Pull any changes from another branch into the current one.
435
436
If the location is omitted, the last-used location will be used.
437
Both the revision history and the working directory will be
438
updated.
439
440
This command only works on branches that have not diverged. Branches are
441
considered diverged if both branches have had commits without first
442
pulling from the other.
443
444
If branches have diverged, you can use 'bzr merge' to pull the text changes
445
from one into the other.
446
"""
447
takes_args = ['location?']
448
449
def run(self, location=None):
450
from bzrlib.merge import merge
451
import errno
452
453
br_to = Branch('.')
454
stored_loc = None
455
try:
456
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
457
except IOError, e:
458
if errno == errno.ENOENT:
459
raise
460
if location is None:
461
if stored_loc is None:
462
raise BzrCommandError("No pull location known or specified.")
463
else:
464
print "Using last location: %s" % stored_loc
465
location = stored_loc
466
from branch import find_branch, DivergedBranches
467
br_from = find_branch(location)
468
location = pull_loc(br_from)
469
old_revno = br_to.revno()
470
try:
471
br_to.update_revisions(br_from)
472
except DivergedBranches:
473
raise BzrCommandError("These branches have diverged. Try merge.")
474
475
merge(('.', -1), ('.', old_revno), check_clean=False)
476
if location != stored_loc:
477
br_to.controlfile("x-pull", "wb").write(location + "\n")
478
479
480
481
class cmd_branch(Command):
482
"""Create a new copy of a branch.
483
484
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
485
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
486
487
To retrieve the branch as of a particular revision, supply the --revision
488
parameter, as in "branch foo/bar -r 5".
489
"""
490
takes_args = ['from_location', 'to_location?']
491
takes_options = ['revision']
492
493
def run(self, from_location, to_location=None, revision=None):
494
import errno
495
from bzrlib.merge import merge
496
from branch import find_branch, DivergedBranches, NoSuchRevision
497
from shutil import rmtree
498
try:
499
br_from = find_branch(from_location)
500
except OSError, e:
501
if e.errno == errno.ENOENT:
502
raise BzrCommandError('Source location "%s" does not exist.' %
503
to_location)
504
else:
505
raise
506
507
if to_location is None:
508
to_location = os.path.basename(from_location.rstrip("/\\"))
509
510
try:
511
os.mkdir(to_location)
512
except OSError, e:
513
if e.errno == errno.EEXIST:
514
raise BzrCommandError('Target directory "%s" already exists.' %
515
to_location)
516
if e.errno == errno.ENOENT:
517
raise BzrCommandError('Parent of "%s" does not exist.' %
518
to_location)
519
else:
520
raise
521
br_to = Branch(to_location, init=True)
522
523
try:
524
br_to.update_revisions(br_from, stop_revision=revision)
525
except NoSuchRevision:
526
rmtree(to_location)
527
msg = "The branch %s has no revision %d." % (from_location,
528
revision)
529
raise BzrCommandError(msg)
530
merge((to_location, -1), (to_location, 0), this_dir=to_location,
531
check_clean=False, ignore_zero=True)
532
from_location = pull_loc(br_from)
533
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
534
535
536
def pull_loc(branch):
537
# TODO: Should perhaps just make attribute be 'base' in
538
# RemoteBranch and Branch?
539
if hasattr(branch, "baseurl"):
540
return branch.baseurl
541
else:
542
return branch.base
543
544
545
546
312
class cmd_renames(Command):
547
313
"""Show list of renamed files.
548
314
564
330
565
331
566
332
class cmd_info(Command):
567
"""Show statistical information about a branch."""
568
takes_args = ['branch?']
569
570
def run(self, branch=None):
333
"""Show statistical information for this branch"""
334
def run(self):
571
335
import info
572
573
from branch import find_branch
574
b = find_branch(branch)
575
info.show_info(b)
336
info.show_info(Branch('.'))
576
337
577
338
578
339
class cmd_remove(Command):
602
363
b = Branch(filename)
603
364
i = b.inventory.path2id(b.relpath(filename))
604
365
if i == None:
605
raise BzrError("%r is not a versioned file" % filename)
366
bailout("%r is not a versioned file" % filename)
606
367
else:
607
368
print i
608
369
619
380
inv = b.inventory
620
381
fid = inv.path2id(b.relpath(filename))
621
382
if fid == None:
622
raise BzrError("%r is not a versioned file" % filename)
383
bailout("%r is not a versioned file" % filename)
623
384
for fip in inv.get_idpath(fid):
624
385
print fip
625
386
626
387
627
388
class cmd_revision_history(Command):
628
389
"""Display list of revision ids on this branch."""
629
hidden = True
630
390
def run(self):
631
391
for patchid in Branch('.').revision_history():
632
392
print patchid
684
444
"""
685
445
686
446
takes_args = ['file*']
687
takes_options = ['revision', 'diff-options']
688
aliases = ['di', 'dif']
447
takes_options = ['revision']
448
aliases = ['di']
689
449
690
def run(self, revision=None, file_list=None, diff_options=None):
450
def run(self, revision=None, file_list=None):
691
451
from bzrlib.diff import show_diff
692
from bzrlib import find_branch
693
694
if file_list:
695
b = find_branch(file_list[0])
696
file_list = [b.relpath(f) for f in file_list]
697
if file_list == ['']:
698
# just pointing to top-of-tree
699
file_list = None
700
else:
701
b = Branch('.')
702
452
703
show_diff(b, revision, specific_files=file_list,
704
external_diff_options=diff_options)
705
706
707
453
show_diff(Branch('.'), revision, file_list)
708
454
709
455
710
456
class cmd_deleted(Command):
729
475
else:
730
476
print path
731
477
732
733
class cmd_modified(Command):
734
"""List files modified in working tree."""
735
hidden = True
736
def run(self):
737
import statcache
738
b = Branch('.')
739
inv = b.read_working_inventory()
740
sc = statcache.update_cache(b, inv)
741
basis = b.basis_tree()
742
basis_inv = basis.inventory
743
744
# We used to do this through iter_entries(), but that's slow
745
# when most of the files are unmodified, as is usually the
746
# case. So instead we iterate by inventory entry, and only
747
# calculate paths as necessary.
748
749
for file_id in basis_inv:
750
cacheentry = sc.get(file_id)
751
if not cacheentry: # deleted
752
continue
753
ie = basis_inv[file_id]
754
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
755
path = inv.id2path(file_id)
756
print path
757
758
759
760
class cmd_added(Command):
761
"""List files added in working tree."""
762
hidden = True
763
def run(self):
764
b = Branch('.')
765
wt = b.working_tree()
766
basis_inv = b.basis_tree().inventory
767
inv = wt.inventory
768
for file_id in inv:
769
if file_id in basis_inv:
770
continue
771
path = inv.id2path(file_id)
772
if not os.access(b.abspath(path), os.F_OK):
773
continue
774
print path
775
776
777
778
478
class cmd_root(Command):
779
479
"""Show the tree root directory.
780
480
791
491
class cmd_log(Command):
792
492
"""Show log of this branch.
793
493
794
To request a range of logs, you can use the command -r begin:end
795
-r revision requests a specific revision, -r :end or -r begin: are
796
also valid.
494
TODO: Option to limit range.
797
495
798
TODO: Make --revision support uuid: and hash: [future tag:] notation.
799
496
TODO: Perhaps show most-recent first with an option for last.
800
497
"""
801
802
498
takes_args = ['filename?']
803
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
804
805
def run(self, filename=None, timezone='original',
806
verbose=False,
807
show_ids=False,
808
forward=False,
809
revision=None):
810
from bzrlib import show_log, find_branch
811
import codecs
812
813
direction = (forward and 'forward') or 'reverse'
814
499
takes_options = ['timezone', 'verbose', 'show-ids']
500
def run(self, filename=None, timezone='original', verbose=False, show_ids=False):
501
from branch import find_branch
502
b = find_branch((filename or '.'), lock_mode='r')
815
503
if filename:
816
b = find_branch(filename)
817
fp = b.relpath(filename)
818
if fp:
819
file_id = b.read_working_inventory().path2id(fp)
820
else:
821
file_id = None # points to branch root
822
else:
823
b = find_branch('.')
824
file_id = None
825
826
if revision == None:
827
revision = [None, None]
828
elif isinstance(revision, int):
829
revision = [revision, revision]
830
else:
831
# pair of revisions?
832
pass
833
834
assert len(revision) == 2
835
836
mutter('encoding log as %r' % bzrlib.user_encoding)
837
838
# use 'replace' so that we don't abort if trying to write out
839
# in e.g. the default C locale.
840
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
841
842
show_log(b, file_id,
843
show_timezone=timezone,
844
verbose=verbose,
845
show_ids=show_ids,
846
to_file=outf,
847
direction=direction,
848
start_revision=revision[0],
849
end_revision=revision[1])
504
filename = b.relpath(filename)
505
bzrlib.show_log(b, filename,
506
show_timezone=timezone,
507
verbose=verbose,
508
show_ids=show_ids)
850
509
851
510
852
511
853
512
class cmd_touching_revisions(Command):
854
"""Return revision-ids which affected a particular file.
855
856
A more user-friendly interface is "bzr log FILE"."""
513
"""Return revision-ids which affected a particular file."""
857
514
hidden = True
858
515
takes_args = ["filename"]
859
516
def run(self, filename):
860
b = Branch(filename)
517
b = Branch(filename, lock_mode='r')
861
518
inv = b.read_working_inventory()
862
519
file_id = inv.path2id(b.relpath(filename))
863
520
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
893
550
894
551
895
552
class cmd_unknowns(Command):
896
"""List unknown files."""
553
"""List unknown files"""
897
554
def run(self):
898
555
for f in Branch('.').unknowns():
899
556
print quotefn(f)
901
558
902
559
903
560
class cmd_ignore(Command):
904
"""Ignore a command or pattern.
561
"""Ignore a command or pattern
905
562
906
563
To remove patterns from the ignore list, edit the .bzrignore file.
907
564
921
578
922
579
def run(self, name_pattern):
923
580
from bzrlib.atomicfile import AtomicFile
924
import os.path
581
import codecs
925
582
926
583
b = Branch('.')
927
584
ifn = b.abspath('.bzrignore')
928
585
586
# FIXME: probably doesn't handle non-ascii patterns
587
929
588
if os.path.exists(ifn):
930
f = open(ifn, 'rt')
931
try:
932
igns = f.read().decode('utf-8')
933
finally:
934
f.close()
589
f = b.controlfile(ifn, 'rt')
590
igns = f.read()
591
f.close()
935
592
else:
936
593
igns = ''
937
594
938
# TODO: If the file already uses crlf-style termination, maybe
939
# we should use that for the newly added lines?
940
941
595
if igns and igns[-1] != '\n':
942
596
igns += '\n'
943
597
igns += name_pattern + '\n'
944
598
945
try:
946
f = AtomicFile(ifn, 'wt')
947
f.write(igns.encode('utf-8'))
948
f.commit()
949
finally:
950
f.close()
599
f = AtomicFile(ifn, 'wt')
600
f.write(igns)
601
f.commit()
951
602
952
603
inv = b.working_tree().inventory
953
604
if inv.path2id('.bzrignore'):
993
644
class cmd_export(Command):
994
645
"""Export past revision to destination directory.
995
646
996
If no revision is specified this exports the last committed revision.
997
998
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
999
given, exports to a directory (equivalent to --format=dir)."""
1000
# TODO: list known exporters
647
If no revision is specified this exports the last committed revision."""
1001
648
takes_args = ['dest']
1002
takes_options = ['revision', 'format']
1003
def run(self, dest, revision=None, format='dir'):
649
takes_options = ['revision']
650
def run(self, dest, revision=None):
1004
651
b = Branch('.')
1005
652
if revision == None:
1006
653
rh = b.revision_history()[-1]
1007
654
else:
1008
655
rh = b.lookup_revision(int(revision))
1009
656
t = b.revision_tree(rh)
1010
t.export(dest, format)
657
t.export(dest)
1011
658
1012
659
1013
660
class cmd_cat(Command):
1034
681
class cmd_commit(Command):
1035
682
"""Commit changes into a new revision.
1036
683
1037
If selected files are specified, only changes to those files are
1038
committed. If a directory is specified then its contents are also
1039
committed.
1040
1041
A selected-file commit may fail in some cases where the committed
1042
tree would be invalid, such as trying to commit a file in a
1043
newly-added directory that is not itself committed.
684
TODO: Commit only selected files.
1044
685
1045
686
TODO: Run hooks on tree to-be-committed, and after commit.
1046
687
1047
688
TODO: Strict commit that fails if there are unknown or deleted files.
1048
689
"""
1049
takes_args = ['selected*']
1050
690
takes_options = ['message', 'file', 'verbose']
1051
691
aliases = ['ci', 'checkin']
1052
692
1053
def run(self, message=None, file=None, verbose=True, selected_list=None):
1054
from bzrlib.commit import commit
1055
693
def run(self, message=None, file=None, verbose=False):
1056
694
## Warning: shadows builtin file()
1057
695
if not message and not file:
1058
696
raise BzrCommandError("please specify a commit message",
1064
702
import codecs
1065
703
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1066
704
1067
b = Branch('.')
1068
commit(b, message, verbose=verbose, specific_files=selected_list)
705
Branch('.').commit(message, verbose=verbose)
1069
706
1070
707
1071
708
class cmd_check(Command):
1073
710
1074
711
This command checks various invariants about the branch storage to
1075
712
detect data corruption or bzr bugs.
1076
1077
If given the --update flag, it will update some optional fields
1078
to help ensure data consistency.
1079
713
"""
1080
714
takes_args = ['dir?']
1081
1082
715
def run(self, dir='.'):
1083
716
import bzrlib.check
1084
bzrlib.check.check(Branch(dir))
1085
1086
1087
1088
class cmd_upgrade(Command):
1089
"""Upgrade branch storage to current format.
1090
1091
This should normally be used only after the check command tells
1092
you to run it.
1093
"""
1094
takes_args = ['dir?']
1095
1096
def run(self, dir='.'):
1097
from bzrlib.upgrade import upgrade
1098
upgrade(Branch(dir))
717
bzrlib.check.check(Branch(dir, find_root=False))
1099
718
1100
719
1101
720
1114
733
"""Run internal test suite"""
1115
734
hidden = True
1116
735
def run(self):
1117
from bzrlib.selftest import selftest
1118
return int(not selftest())
736
failures, tests = 0, 0
737
738
import doctest, bzrlib.store, bzrlib.tests
739
bzrlib.trace.verbose = False
740
741
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
742
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
743
mf, mt = doctest.testmod(m)
744
failures += mf
745
tests += mt
746
print '%-40s %3d tests' % (m.__name__, mt),
747
if mf:
748
print '%3d FAILED!' % mf
749
else:
750
print
751
752
print '%-40s %3d tests' % ('total', tests),
753
if failures:
754
print '%3d FAILED!' % failures
755
else:
756
print
757
1119
758
1120
759
1121
760
class cmd_version(Command):
1122
"""Show version of bzr."""
761
"""Show version of bzr"""
1123
762
def run(self):
1124
763
show_version()
1125
764
1126
765
def show_version():
1127
766
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1128
# is bzrlib itself in a branch?
1129
bzrrev = bzrlib.get_bzr_revision()
1130
if bzrrev:
1131
print " (bzr checkout, revision %d {%s})" % bzrrev
1132
767
print bzrlib.__copyright__
1133
768
print "http://bazaar-ng.org/"
1134
769
print
1143
778
def run(self):
1144
779
print "it sure does!"
1145
780
1146
def parse_spec(spec):
1147
"""
1148
>>> parse_spec(None)
1149
[None, None]
1150
>>> parse_spec("./")
1151
['./', None]
1152
>>> parse_spec("../@")
1153
['..', -1]
1154
>>> parse_spec("../f/@35")
1155
['../f', 35]
1156
"""
1157
if spec is None:
1158
return [None, None]
1159
if '/@' in spec:
1160
parsed = spec.split('/@')
1161
assert len(parsed) == 2
1162
if parsed[1] == "":
1163
parsed[1] = -1
1164
else:
1165
parsed[1] = int(parsed[1])
1166
assert parsed[1] >=0
1167
else:
1168
parsed = [spec, None]
1169
return parsed
1170
1171
1172
1173
class cmd_merge(Command):
1174
"""Perform a three-way merge of trees.
1175
1176
The SPEC parameters are working tree or revision specifiers. Working trees
1177
are specified using standard paths or urls. No component of a directory
1178
path may begin with '@'.
1179
1180
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1181
1182
Revisions are specified using a dirname/@revno pair, where dirname is the
1183
branch directory and revno is the revision within that branch. If no revno
1184
is specified, the latest revision is used.
1185
1186
Revision examples: './@127', 'foo/@', '../@1'
1187
1188
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1189
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1190
as the BASE.
1191
1192
merge refuses to run if there are any uncommitted changes, unless
1193
--force is given.
1194
"""
1195
takes_args = ['other_spec', 'base_spec?']
1196
takes_options = ['force']
1197
1198
def run(self, other_spec, base_spec=None, force=False):
1199
from bzrlib.merge import merge
1200
merge(parse_spec(other_spec), parse_spec(base_spec),
1201
check_clean=(not force))
1202
1203
1204
class cmd_revert(Command):
1205
"""Reverse all changes since the last commit.
1206
1207
Only versioned files are affected.
1208
1209
TODO: Store backups of any files that will be reverted, so
1210
that the revert can be undone.
1211
"""
1212
takes_options = ['revision']
1213
1214
def run(self, revision=-1):
1215
from bzrlib.merge import merge
1216
merge(('.', revision), parse_spec('.'),
1217
check_clean=False,
1218
ignore_zero=True)
1219
1220
781
1221
782
class cmd_assert_fail(Command):
1222
783
"""Test reporting of assertion failures"""
1237
798
help.help(topic)
1238
799
1239
800
1240
class cmd_update_stat_cache(Command):
1241
"""Update stat-cache mapping inodes to SHA-1 hashes.
1242
1243
For testing only."""
1244
hidden = True
1245
def run(self):
1246
import statcache
1247
b = Branch('.')
1248
statcache.update_cache(b.base, b.read_working_inventory())
1249
801
######################################################################
802
# main routine
1250
803
1251
804
1252
805
# list of all available options; the rhs can be either None for an
1254
807
# the type.
1255
808
OPTIONS = {
1256
809
'all': None,
1257
'diff-options': str,
1258
810
'help': None,
1259
811
'file': unicode,
1260
'force': None,
1261
'format': unicode,
1262
'forward': None,
1263
812
'message': unicode,
1264
'no-recurse': None,
1265
813
'profile': None,
1266
'revision': _parse_revision_str,
814
'revision': int,
1267
815
'show-ids': None,
1268
816
'timezone': str,
1269
817
'verbose': None,
1270
818
'version': None,
1271
819
'email': None,
1272
'update': None,
1273
820
}
1274
821
1275
822
SHORT_OPTIONS = {
823
'm': 'message',
1276
824
'F': 'file',
1277
'h': 'help',
1278
'm': 'message',
1279
825
'r': 'revision',
1280
826
'v': 'verbose',
1281
827
}
1297
843
(['status'], {'all': True})
1298
844
>>> parse_args('commit --message=biter'.split())
1299
845
(['commit'], {'message': u'biter'})
1300
>>> parse_args('log -r 500'.split())
1301
(['log'], {'revision': 500})
1302
>>> parse_args('log -r500:600'.split())
1303
(['log'], {'revision': [500, 600]})
1304
>>> parse_args('log -vr500:600'.split())
1305
(['log'], {'verbose': True, 'revision': [500, 600]})
1306
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1307
Traceback (most recent call last):
1308
...
1309
ValueError: invalid literal for int(): v500
1310
846
"""
1311
847
args = []
1312
848
opts = {}
1326
862
else:
1327
863
optname = a[2:]
1328
864
if optname not in OPTIONS:
1329
raise BzrError('unknown long option %r' % a)
865
bailout('unknown long option %r' % a)
1330
866
else:
1331
867
shortopt = a[1:]
1332
if shortopt in SHORT_OPTIONS:
1333
# Multi-character options must have a space to delimit
1334
# their value
1335
optname = SHORT_OPTIONS[shortopt]
1336
else:
1337
# Single character short options, can be chained,
1338
# and have their value appended to their name
1339
shortopt = a[1:2]
1340
if shortopt not in SHORT_OPTIONS:
1341
# We didn't find the multi-character name, and we
1342
# didn't find the single char name
1343
raise BzrError('unknown short option %r' % a)
1344
optname = SHORT_OPTIONS[shortopt]
1345
1346
if a[2:]:
1347
# There are extra things on this option
1348
# see if it is the value, or if it is another
1349
# short option
1350
optargfn = OPTIONS[optname]
1351
if optargfn is None:
1352
# This option does not take an argument, so the
1353
# next entry is another short option, pack it back
1354
# into the list
1355
argv.insert(0, '-' + a[2:])
1356
else:
1357
# This option takes an argument, so pack it
1358
# into the array
1359
optarg = a[2:]
868
if shortopt not in SHORT_OPTIONS:
869
bailout('unknown short option %r' % a)
870
optname = SHORT_OPTIONS[shortopt]
1360
871
1361
872
if optname in opts:
1362
873
# XXX: Do we ever want to support this, e.g. for -r?
1363
raise BzrError('repeated option %r' % a)
874
bailout('repeated option %r' % a)
1364
875
1365
876
optargfn = OPTIONS[optname]
1366
877
if optargfn:
1367
878
if optarg == None:
1368
879
if not argv:
1369
raise BzrError('option %r needs an argument' % a)
880
bailout('option %r needs an argument' % a)
1370
881
else:
1371
882
optarg = argv.pop(0)
1372
883
opts[optname] = optargfn(optarg)
1373
884
else:
1374
885
if optarg != None:
1375
raise BzrError('option %r takes no argument' % optname)
886
bailout('option %r takes no argument' % optname)
1376
887
opts[optname] = True
1377
888
else:
1378
889
args.append(a)
1426
937
return argdict
1427
938
1428
939
1429
def _parse_master_args(argv):
1430
"""Parse the arguments that always go with the original command.
1431
These are things like bzr --no-plugins, etc.
1432
1433
There are now 2 types of option flags. Ones that come *before* the command,
1434
and ones that come *after* the command.
1435
Ones coming *before* the command are applied against all possible commands.
1436
And are generally applied before plugins are loaded.
1437
1438
The current list are:
1439
--builtin Allow plugins to load, but don't let them override builtin commands,
1440
they will still be allowed if they do not override a builtin.
1441
--no-plugins Don't load any plugins. This lets you get back to official source
1442
behavior.
1443
--profile Enable the hotspot profile before running the command.
1444
For backwards compatibility, this is also a non-master option.
1445
--version Spit out the version of bzr that is running and exit.
1446
This is also a non-master option.
1447
--help Run help and exit, also a non-master option (I think that should stay, though)
1448
1449
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1450
Traceback (most recent call last):
1451
...
1452
BzrCommandError: Invalid master option: 'test'
1453
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1454
>>> print argv
1455
['command']
1456
>>> print opts['version']
1457
True
1458
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1459
>>> print argv
1460
['command', '--more-options']
1461
>>> print opts['profile']
1462
True
1463
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1464
>>> print argv
1465
['command']
1466
>>> print opts['no-plugins']
1467
True
1468
>>> print opts['profile']
1469
False
1470
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1471
>>> print argv
1472
['command', '--profile']
1473
>>> print opts['profile']
1474
False
1475
"""
1476
master_opts = {'builtin':False,
1477
'no-plugins':False,
1478
'version':False,
1479
'profile':False,
1480
'help':False
1481
}
1482
1483
# This is the point where we could hook into argv[0] to determine
1484
# what front-end is supposed to be run
1485
# For now, we are just ignoring it.
1486
cmd_name = argv.pop(0)
1487
for arg in argv[:]:
1488
if arg[:2] != '--': # at the first non-option, we return the rest
1489
break
1490
arg = arg[2:] # Remove '--'
1491
if arg not in master_opts:
1492
# We could say that this is not an error, that we should
1493
# just let it be handled by the main section instead
1494
raise BzrCommandError('Invalid master option: %r' % arg)
1495
argv.pop(0) # We are consuming this entry
1496
master_opts[arg] = True
1497
return argv, master_opts
1498
1499
1500
940
1501
941
def run_bzr(argv):
1502
942
"""Execute a command.
1507
947
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1508
948
1509
949
try:
1510
# some options like --builtin and --no-plugins have special effects
1511
argv, master_opts = _parse_master_args(argv)
1512
if 'no-plugins' not in master_opts:
1513
bzrlib.load_plugins()
1514
1515
args, opts = parse_args(argv)
1516
1517
if master_opts['help']:
1518
from bzrlib.help import help
1519
if argv:
1520
help(argv[0])
1521
else:
1522
help()
1523
return 0
1524
950
args, opts = parse_args(argv[1:])
1525
951
if 'help' in opts:
1526
from bzrlib.help import help
952
import help
1527
953
if args:
1528
help(args[0])
954
help.help(args[0])
1529
955
else:
1530
help()
956
help.help()
1531
957
return 0
1532
958
elif 'version' in opts:
1533
959
show_version()
1534
960
return 0
1535
elif args and args[0] == 'builtin':
1536
include_plugins=False
1537
args = args[1:]
1538
961
cmd = str(args.pop(0))
1539
962
except IndexError:
1540
import help
1541
help.help()
963
log_error('usage: bzr COMMAND')
964
log_error(' try "bzr help"')
1542
965
return 1
1543
1544
1545
plugins_override = not (master_opts['builtin'])
1546
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1547
1548
profile = master_opts['profile']
1549
# For backwards compatibility, I would rather stick with --profile being a
1550
# master/global option
966
967
canonical_cmd, cmd_class = get_cmd_class(cmd)
968
969
# global option
1551
970
if 'profile' in opts:
1552
971
profile = True
1553
972
del opts['profile']
973
else:
974
profile = False
1554
975
1555
976
# check options are reasonable
1556
977
allowed = cmd_class.takes_options
1587
1008
os.close(pffileno)
1588
1009
os.remove(pfname)
1589
1010
else:
1590
return cmd_class(cmdopts, cmdargs).status
1011
cmdobj = cmd_class(cmdopts, cmdargs).status
1591
1012
1592
1013
1593
1014
def _report_exception(summary, quiet=False):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1