« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 761
- compare with another revision
- download diff
- download tarball
- view history from revision 761
- Committer: Martin Pool
- Date: 2005-06-22 09:35:24 UTC
- Revision ID: mbp@sourcefrog.net-20050622093524-b15e2d374c2ae6ea
- move standard plugins from contrib/plugins to just ./plugins
- files added:
- bzr-man.py
- bzrlib/selftest
- patches
- plugins
- plugins/changeset
- files removed:
- bzrlib/tests.py
- files renamed:
- contrib/bash/bzr => contrib/bash/bzr.simple
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
16
16
17
17
18
18
19
import sys, os, time, os.path
20
from sets import Set
19
import sys, os
21
20
22
21
import bzrlib
23
22
from bzrlib.trace import mutter, note, log_error
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, Tree
27
from bzrlib.revision import Revision
28
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
23
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
29
26
format_date
30
27
31
28
29
plugin_cmds = {}
30
31
32
def register_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
32
47
def _squish_command_name(cmd):
33
48
return 'cmd_' + cmd.replace('-', '_')
34
49
37
52
assert cmd.startswith("cmd_")
38
53
return cmd[4:].replace('_','-')
39
54
40
def get_all_cmds():
41
"""Return canonical name and class for all registered commands."""
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 = {}
42
93
for k, v in globals().iteritems():
43
94
if k.startswith("cmd_"):
44
yield _unsquish_command_name(k), v
45
46
def get_cmd_class(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):
47
113
"""Return the canonical name and command class for a command.
48
114
"""
49
115
cmd = str(cmd) # not unicode
50
116
51
117
# first look up this command under the specified name
118
cmds = _get_cmd_dict(plugins_override=plugins_override)
52
119
try:
53
return cmd, globals()[_squish_command_name(cmd)]
120
return cmd, cmds[cmd]
54
121
except KeyError:
55
122
pass
56
123
57
124
# look for any command which claims this as an alias
58
for cmdname, cmdclass in get_all_cmds():
125
for cmdname, cmdclass in cmds.iteritems():
59
126
if cmd in cmdclass.aliases:
60
127
return cmdname, cmdclass
61
128
66
133
raise BzrCommandError("unknown command %r" % cmd)
67
134
68
135
69
class Command:
136
class Command(object):
70
137
"""Base class for commands.
71
138
72
139
The docstring for an actual command should give a single-line
131
198
"""
132
199
133
200
def find_command(cls, cmd):
201
import os.path
134
202
bzrpath = os.environ.get('BZRPATH', '')
135
203
136
for dir in bzrpath.split(':'):
204
for dir in bzrpath.split(os.pathsep):
137
205
path = os.path.join(dir, cmd)
138
206
if os.path.isfile(path):
139
207
return ExternalCommand(path)
145
213
def __init__(self, path):
146
214
self.path = path
147
215
148
# TODO: If either of these fail, we should detect that and
149
# assume that path is not really a bzr plugin after all.
150
151
216
pipe = os.popen('%s --bzr-usage' % path, 'r')
152
217
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?
153
225
self.takes_args = pipe.readline().split()
154
pipe.close()
226
227
if pipe.close() is not None:
228
raise BzrError("Failed funning '%s --bzr-usage'" % path)
155
229
156
230
pipe = os.popen('%s --bzr-help' % path, 'r')
157
231
self.__doc__ = pipe.read()
158
pipe.close()
232
if pipe.close() is not None:
233
raise BzrError("Failed funning '%s --bzr-help'" % path)
159
234
160
235
def __call__(self, options, arguments):
161
236
Command.__init__(self, options, arguments)
168
243
keys = kargs.keys()
169
244
keys.sort()
170
245
for name in keys:
246
optname = name.replace('_','-')
171
247
value = kargs[name]
172
if OPTIONS.has_key(name):
248
if OPTIONS.has_key(optname):
173
249
# it's an option
174
opts.append('--%s' % name)
250
opts.append('--%s' % optname)
175
251
if value is not None and value is not True:
176
252
opts.append(str(value))
177
253
else:
228
304
229
305
def run(self, all=False, show_ids=False, file_list=None):
230
306
if file_list:
231
b = Branch(file_list[0], lock_mode='r')
307
b = Branch(file_list[0])
232
308
file_list = [b.relpath(x) for x in file_list]
233
309
# special case: only one path was given and it's the root
234
310
# of the branch
235
311
if file_list == ['']:
236
312
file_list = None
237
313
else:
238
b = Branch('.', lock_mode='r')
314
b = Branch('.')
239
315
import status
240
316
status.show_status(b, show_unchanged=all, show_ids=show_ids,
241
file_list=file_list)
317
specific_files=file_list)
242
318
243
319
244
320
class cmd_cat_revision(Command):
281
357
recursively add that parent, rather than giving an error?
282
358
"""
283
359
takes_args = ['file+']
284
takes_options = ['verbose']
360
takes_options = ['verbose', 'no-recurse']
285
361
286
def run(self, file_list, verbose=False):
287
bzrlib.add.smart_add(file_list, verbose)
362
def run(self, file_list, verbose=False, no_recurse=False):
363
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
364
365
366
367
class cmd_mkdir(Command):
368
"""Create a new versioned directory.
369
370
This is equivalent to creating the directory and then adding it.
371
"""
372
takes_args = ['dir+']
373
374
def run(self, dir_list):
375
import os
376
import bzrlib.branch
377
378
b = None
379
380
for d in dir_list:
381
os.mkdir(d)
382
if not b:
383
b = bzrlib.branch.Branch(d)
384
b.add([d], verbose=True)
288
385
289
386
290
387
class cmd_relpath(Command):
291
388
"""Show path of a file relative to root"""
292
389
takes_args = ['filename']
390
hidden = True
293
391
294
392
def run(self, filename):
295
393
print Branch(filename).relpath(filename)
298
396
299
397
class cmd_inventory(Command):
300
398
"""Show inventory of the current working copy or a revision."""
301
takes_options = ['revision']
399
takes_options = ['revision', 'show-ids']
302
400
303
def run(self, revision=None):
401
def run(self, revision=None, show_ids=False):
304
402
b = Branch('.')
305
403
if revision == None:
306
404
inv = b.read_working_inventory()
307
405
else:
308
406
inv = b.get_revision_inventory(b.lookup_revision(revision))
309
407
310
for path, entry in inv.iter_entries():
311
print '%-50s %s' % (entry.file_id, path)
408
for path, entry in inv.entries():
409
if show_ids:
410
print '%-50s %s' % (path, entry.file_id)
411
else:
412
print path
312
413
313
414
314
415
class cmd_move(Command):
348
449
349
450
350
451
452
453
454
class cmd_pull(Command):
455
"""Pull any changes from another branch into the current one.
456
457
If the location is omitted, the last-used location will be used.
458
Both the revision history and the working directory will be
459
updated.
460
461
This command only works on branches that have not diverged. Branches are
462
considered diverged if both branches have had commits without first
463
pulling from the other.
464
465
If branches have diverged, you can use 'bzr merge' to pull the text changes
466
from one into the other.
467
"""
468
takes_args = ['location?']
469
470
def run(self, location=None):
471
from bzrlib.merge import merge
472
import errno
473
474
br_to = Branch('.')
475
stored_loc = None
476
try:
477
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
478
except IOError, e:
479
if errno == errno.ENOENT:
480
raise
481
if location is None:
482
if stored_loc is None:
483
raise BzrCommandError("No pull location known or specified.")
484
else:
485
print "Using last location: %s" % stored_loc
486
location = stored_loc
487
from branch import find_branch, DivergedBranches
488
br_from = find_branch(location)
489
location = pull_loc(br_from)
490
old_revno = br_to.revno()
491
try:
492
br_to.update_revisions(br_from)
493
except DivergedBranches:
494
raise BzrCommandError("These branches have diverged. Try merge.")
495
496
merge(('.', -1), ('.', old_revno), check_clean=False)
497
if location != stored_loc:
498
br_to.controlfile("x-pull", "wb").write(location + "\n")
499
500
501
502
class cmd_branch(Command):
503
"""Create a new copy of a branch.
504
505
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
506
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
507
508
To retrieve the branch as of a particular revision, supply the --revision
509
parameter, as in "branch foo/bar -r 5".
510
"""
511
takes_args = ['from_location', 'to_location?']
512
takes_options = ['revision']
513
514
def run(self, from_location, to_location=None, revision=None):
515
import errno
516
from bzrlib.merge import merge
517
from branch import find_branch, DivergedBranches, NoSuchRevision
518
from shutil import rmtree
519
try:
520
br_from = find_branch(from_location)
521
except OSError, e:
522
if e.errno == errno.ENOENT:
523
raise BzrCommandError('Source location "%s" does not exist.' %
524
to_location)
525
else:
526
raise
527
528
if to_location is None:
529
to_location = os.path.basename(from_location.rstrip("/\\"))
530
531
try:
532
os.mkdir(to_location)
533
except OSError, e:
534
if e.errno == errno.EEXIST:
535
raise BzrCommandError('Target directory "%s" already exists.' %
536
to_location)
537
if e.errno == errno.ENOENT:
538
raise BzrCommandError('Parent of "%s" does not exist.' %
539
to_location)
540
else:
541
raise
542
br_to = Branch(to_location, init=True)
543
544
try:
545
br_to.update_revisions(br_from, stop_revision=revision)
546
except NoSuchRevision:
547
rmtree(to_location)
548
msg = "The branch %s has no revision %d." % (from_location,
549
revision)
550
raise BzrCommandError(msg)
551
merge((to_location, -1), (to_location, 0), this_dir=to_location,
552
check_clean=False, ignore_zero=True)
553
from_location = pull_loc(br_from)
554
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
555
556
557
def pull_loc(branch):
558
# TODO: Should perhaps just make attribute be 'base' in
559
# RemoteBranch and Branch?
560
if hasattr(branch, "baseurl"):
561
return branch.baseurl
562
else:
563
return branch.base
564
565
566
351
567
class cmd_renames(Command):
352
568
"""Show list of renamed files.
353
569
407
623
b = Branch(filename)
408
624
i = b.inventory.path2id(b.relpath(filename))
409
625
if i == None:
410
bailout("%r is not a versioned file" % filename)
626
raise BzrError("%r is not a versioned file" % filename)
411
627
else:
412
628
print i
413
629
424
640
inv = b.inventory
425
641
fid = inv.path2id(b.relpath(filename))
426
642
if fid == None:
427
bailout("%r is not a versioned file" % filename)
643
raise BzrError("%r is not a versioned file" % filename)
428
644
for fip in inv.get_idpath(fid):
429
645
print fip
430
646
431
647
432
648
class cmd_revision_history(Command):
433
649
"""Display list of revision ids on this branch."""
650
hidden = True
434
651
def run(self):
435
652
for patchid in Branch('.').revision_history():
436
653
print patchid
488
705
"""
489
706
490
707
takes_args = ['file*']
491
takes_options = ['revision']
492
aliases = ['di']
708
takes_options = ['revision', 'diff-options']
709
aliases = ['di', 'dif']
493
710
494
def run(self, revision=None, file_list=None):
711
def run(self, revision=None, file_list=None, diff_options=None):
495
712
from bzrlib.diff import show_diff
713
from bzrlib import find_branch
714
715
if file_list:
716
b = find_branch(file_list[0])
717
file_list = [b.relpath(f) for f in file_list]
718
if file_list == ['']:
719
# just pointing to top-of-tree
720
file_list = None
721
else:
722
b = Branch('.')
496
723
497
show_diff(Branch('.'), revision, file_list)
724
show_diff(b, revision, specific_files=file_list,
725
external_diff_options=diff_options)
498
726
499
727
500
728
584
812
class cmd_log(Command):
585
813
"""Show log of this branch.
586
814
587
TODO: Option to limit range.
815
To request a range of logs, you can use the command -r begin:end
816
-r revision requests a specific revision, -r :end or -r begin: are
817
also valid.
588
818
589
TODO: Perhaps show most-recent first with an option for last.
819
TODO: Make --revision support uuid: and hash: [future tag:] notation.
820
590
821
"""
822
591
823
takes_args = ['filename?']
592
takes_options = ['timezone', 'verbose', 'show-ids']
593
def run(self, filename=None, timezone='original', verbose=False, show_ids=False):
594
from branch import find_branch
595
b = find_branch((filename or '.'), lock_mode='r')
824
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
825
826
def run(self, filename=None, timezone='original',
827
verbose=False,
828
show_ids=False,
829
forward=False,
830
revision=None):
831
from bzrlib import show_log, find_branch
832
import codecs
833
834
direction = (forward and 'forward') or 'reverse'
835
596
836
if filename:
597
filename = b.relpath(filename)
598
bzrlib.show_log(b, filename,
599
show_timezone=timezone,
600
verbose=verbose,
601
show_ids=show_ids)
837
b = find_branch(filename)
838
fp = b.relpath(filename)
839
if fp:
840
file_id = b.read_working_inventory().path2id(fp)
841
else:
842
file_id = None # points to branch root
843
else:
844
b = find_branch('.')
845
file_id = None
846
847
if revision == None:
848
revision = [None, None]
849
elif isinstance(revision, int):
850
revision = [revision, revision]
851
else:
852
# pair of revisions?
853
pass
854
855
assert len(revision) == 2
856
857
mutter('encoding log as %r' % bzrlib.user_encoding)
858
859
# use 'replace' so that we don't abort if trying to write out
860
# in e.g. the default C locale.
861
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
862
863
show_log(b, file_id,
864
show_timezone=timezone,
865
verbose=verbose,
866
show_ids=show_ids,
867
to_file=outf,
868
direction=direction,
869
start_revision=revision[0],
870
end_revision=revision[1])
602
871
603
872
604
873
605
874
class cmd_touching_revisions(Command):
606
"""Return revision-ids which affected a particular file."""
875
"""Return revision-ids which affected a particular file.
876
877
A more user-friendly interface is "bzr log FILE"."""
607
878
hidden = True
608
879
takes_args = ["filename"]
609
880
def run(self, filename):
610
b = Branch(filename, lock_mode='r')
881
b = Branch(filename)
611
882
inv = b.read_working_inventory()
612
883
file_id = inv.path2id(b.relpath(filename))
613
884
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
643
914
644
915
645
916
class cmd_unknowns(Command):
646
"""List unknown files"""
917
"""List unknown files."""
647
918
def run(self):
648
919
for f in Branch('.').unknowns():
649
920
print quotefn(f)
651
922
652
923
653
924
class cmd_ignore(Command):
654
"""Ignore a command or pattern
925
"""Ignore a command or pattern.
655
926
656
927
To remove patterns from the ignore list, edit the .bzrignore file.
657
928
671
942
672
943
def run(self, name_pattern):
673
944
from bzrlib.atomicfile import AtomicFile
674
import codecs
945
import os.path
675
946
676
947
b = Branch('.')
677
948
ifn = b.abspath('.bzrignore')
678
949
679
# FIXME: probably doesn't handle non-ascii patterns
680
681
950
if os.path.exists(ifn):
682
f = b.controlfile(ifn, 'rt')
683
igns = f.read()
684
f.close()
951
f = open(ifn, 'rt')
952
try:
953
igns = f.read().decode('utf-8')
954
finally:
955
f.close()
685
956
else:
686
957
igns = ''
687
958
959
# TODO: If the file already uses crlf-style termination, maybe
960
# we should use that for the newly added lines?
961
688
962
if igns and igns[-1] != '\n':
689
963
igns += '\n'
690
964
igns += name_pattern + '\n'
691
965
692
f = AtomicFile(ifn, 'wt')
693
f.write(igns)
694
f.commit()
966
try:
967
f = AtomicFile(ifn, 'wt')
968
f.write(igns.encode('utf-8'))
969
f.commit()
970
finally:
971
f.close()
695
972
696
973
inv = b.working_tree().inventory
697
974
if inv.path2id('.bzrignore'):
737
1014
class cmd_export(Command):
738
1015
"""Export past revision to destination directory.
739
1016
740
If no revision is specified this exports the last committed revision."""
1017
If no revision is specified this exports the last committed revision.
1018
1019
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1020
given, exports to a directory (equivalent to --format=dir)."""
1021
# TODO: list known exporters
741
1022
takes_args = ['dest']
742
takes_options = ['revision']
743
def run(self, dest, revision=None):
1023
takes_options = ['revision', 'format']
1024
def run(self, dest, revision=None, format='dir'):
744
1025
b = Branch('.')
745
1026
if revision == None:
746
1027
rh = b.revision_history()[-1]
747
1028
else:
748
1029
rh = b.lookup_revision(int(revision))
749
1030
t = b.revision_tree(rh)
750
t.export(dest)
1031
t.export(dest, format)
751
1032
752
1033
753
1034
class cmd_cat(Command):
774
1055
class cmd_commit(Command):
775
1056
"""Commit changes into a new revision.
776
1057
777
TODO: Commit only selected files.
1058
If selected files are specified, only changes to those files are
1059
committed. If a directory is specified then its contents are also
1060
committed.
1061
1062
A selected-file commit may fail in some cases where the committed
1063
tree would be invalid, such as trying to commit a file in a
1064
newly-added directory that is not itself committed.
778
1065
779
1066
TODO: Run hooks on tree to-be-committed, and after commit.
780
1067
781
1068
TODO: Strict commit that fails if there are unknown or deleted files.
782
1069
"""
1070
takes_args = ['selected*']
783
1071
takes_options = ['message', 'file', 'verbose']
784
1072
aliases = ['ci', 'checkin']
785
1073
786
def run(self, message=None, file=None, verbose=False):
1074
def run(self, message=None, file=None, verbose=True, selected_list=None):
1075
from bzrlib.commit import commit
1076
787
1077
## Warning: shadows builtin file()
788
1078
if not message and not file:
789
1079
raise BzrCommandError("please specify a commit message",
795
1085
import codecs
796
1086
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
797
1087
798
Branch('.').commit(message, verbose=verbose)
1088
b = Branch('.')
1089
commit(b, message, verbose=verbose, specific_files=selected_list)
799
1090
800
1091
801
1092
class cmd_check(Command):
803
1094
804
1095
This command checks various invariants about the branch storage to
805
1096
detect data corruption or bzr bugs.
1097
1098
If given the --update flag, it will update some optional fields
1099
to help ensure data consistency.
806
1100
"""
807
1101
takes_args = ['dir?']
1102
808
1103
def run(self, dir='.'):
809
1104
import bzrlib.check
810
bzrlib.check.check(Branch(dir, find_root=False))
1105
bzrlib.check.check(Branch(dir))
1106
1107
1108
1109
class cmd_upgrade(Command):
1110
"""Upgrade branch storage to current format.
1111
1112
This should normally be used only after the check command tells
1113
you to run it.
1114
"""
1115
takes_args = ['dir?']
1116
1117
def run(self, dir='.'):
1118
from bzrlib.upgrade import upgrade
1119
upgrade(Branch(dir))
811
1120
812
1121
813
1122
826
1135
"""Run internal test suite"""
827
1136
hidden = True
828
1137
def run(self):
829
failures, tests = 0, 0
830
831
import doctest, bzrlib.store, bzrlib.tests
832
bzrlib.trace.verbose = False
833
834
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
835
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
836
mf, mt = doctest.testmod(m)
837
failures += mf
838
tests += mt
839
print '%-40s %3d tests' % (m.__name__, mt),
840
if mf:
841
print '%3d FAILED!' % mf
842
else:
843
print
844
845
print '%-40s %3d tests' % ('total', tests),
846
if failures:
847
print '%3d FAILED!' % failures
848
else:
849
print
850
1138
from bzrlib.selftest import selftest
1139
return int(not selftest())
851
1140
852
1141
853
1142
class cmd_version(Command):
854
"""Show version of bzr"""
1143
"""Show version of bzr."""
855
1144
def run(self):
856
1145
show_version()
857
1146
858
1147
def show_version():
859
1148
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1149
# is bzrlib itself in a branch?
1150
bzrrev = bzrlib.get_bzr_revision()
1151
if bzrrev:
1152
print " (bzr checkout, revision %d {%s})" % bzrrev
860
1153
print bzrlib.__copyright__
861
1154
print "http://bazaar-ng.org/"
862
1155
print
871
1164
def run(self):
872
1165
print "it sure does!"
873
1166
1167
def parse_spec(spec):
1168
"""
1169
>>> parse_spec(None)
1170
[None, None]
1171
>>> parse_spec("./")
1172
['./', None]
1173
>>> parse_spec("../@")
1174
['..', -1]
1175
>>> parse_spec("../f/@35")
1176
['../f', 35]
1177
"""
1178
if spec is None:
1179
return [None, None]
1180
if '/@' in spec:
1181
parsed = spec.split('/@')
1182
assert len(parsed) == 2
1183
if parsed[1] == "":
1184
parsed[1] = -1
1185
else:
1186
parsed[1] = int(parsed[1])
1187
assert parsed[1] >=0
1188
else:
1189
parsed = [spec, None]
1190
return parsed
1191
1192
1193
1194
class cmd_merge(Command):
1195
"""Perform a three-way merge of trees.
1196
1197
The SPEC parameters are working tree or revision specifiers. Working trees
1198
are specified using standard paths or urls. No component of a directory
1199
path may begin with '@'.
1200
1201
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1202
1203
Revisions are specified using a dirname/@revno pair, where dirname is the
1204
branch directory and revno is the revision within that branch. If no revno
1205
is specified, the latest revision is used.
1206
1207
Revision examples: './@127', 'foo/@', '../@1'
1208
1209
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1210
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1211
as the BASE.
1212
1213
merge refuses to run if there are any uncommitted changes, unless
1214
--force is given.
1215
"""
1216
takes_args = ['other_spec', 'base_spec?']
1217
takes_options = ['force']
1218
1219
def run(self, other_spec, base_spec=None, force=False):
1220
from bzrlib.merge import merge
1221
merge(parse_spec(other_spec), parse_spec(base_spec),
1222
check_clean=(not force))
1223
1224
1225
class cmd_revert(Command):
1226
"""Reverse all changes since the last commit.
1227
1228
Only versioned files are affected.
1229
1230
TODO: Store backups of any files that will be reverted, so
1231
that the revert can be undone.
1232
"""
1233
takes_options = ['revision']
1234
1235
def run(self, revision=-1):
1236
from bzrlib.merge import merge
1237
merge(('.', revision), parse_spec('.'),
1238
check_clean=False,
1239
ignore_zero=True)
1240
874
1241
875
1242
class cmd_assert_fail(Command):
876
1243
"""Test reporting of assertion failures"""
902
1269
statcache.update_cache(b.base, b.read_working_inventory())
903
1270
904
1271
905
######################################################################
906
# main routine
1272
1273
class cmd_plugins(Command):
1274
"""List plugins"""
1275
hidden = True
1276
def run(self):
1277
import bzrlib.plugin
1278
from pprint import pprint
1279
pprint(bzrlib.plugin.all_plugins)
1280
907
1281
908
1282
909
1283
# list of all available options; the rhs can be either None for an
911
1285
# the type.
912
1286
OPTIONS = {
913
1287
'all': None,
1288
'diff-options': str,
914
1289
'help': None,
915
1290
'file': unicode,
1291
'force': None,
1292
'format': unicode,
1293
'forward': None,
916
1294
'message': unicode,
1295
'no-recurse': None,
917
1296
'profile': None,
918
'revision': int,
1297
'revision': _parse_revision_str,
919
1298
'show-ids': None,
920
1299
'timezone': str,
921
1300
'verbose': None,
922
1301
'version': None,
923
1302
'email': None,
1303
'update': None,
924
1304
}
925
1305
926
1306
SHORT_OPTIONS = {
1307
'F': 'file',
1308
'h': 'help',
927
1309
'm': 'message',
928
'F': 'file',
929
1310
'r': 'revision',
930
1311
'v': 'verbose',
931
1312
}
947
1328
(['status'], {'all': True})
948
1329
>>> parse_args('commit --message=biter'.split())
949
1330
(['commit'], {'message': u'biter'})
1331
>>> parse_args('log -r 500'.split())
1332
(['log'], {'revision': 500})
1333
>>> parse_args('log -r500:600'.split())
1334
(['log'], {'revision': [500, 600]})
1335
>>> parse_args('log -vr500:600'.split())
1336
(['log'], {'verbose': True, 'revision': [500, 600]})
1337
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1338
Traceback (most recent call last):
1339
...
1340
ValueError: invalid literal for int(): v500
950
1341
"""
951
1342
args = []
952
1343
opts = {}
966
1357
else:
967
1358
optname = a[2:]
968
1359
if optname not in OPTIONS:
969
bailout('unknown long option %r' % a)
1360
raise BzrError('unknown long option %r' % a)
970
1361
else:
971
1362
shortopt = a[1:]
972
if shortopt not in SHORT_OPTIONS:
973
bailout('unknown short option %r' % a)
974
optname = SHORT_OPTIONS[shortopt]
1363
if shortopt in SHORT_OPTIONS:
1364
# Multi-character options must have a space to delimit
1365
# their value
1366
optname = SHORT_OPTIONS[shortopt]
1367
else:
1368
# Single character short options, can be chained,
1369
# and have their value appended to their name
1370
shortopt = a[1:2]
1371
if shortopt not in SHORT_OPTIONS:
1372
# We didn't find the multi-character name, and we
1373
# didn't find the single char name
1374
raise BzrError('unknown short option %r' % a)
1375
optname = SHORT_OPTIONS[shortopt]
1376
1377
if a[2:]:
1378
# There are extra things on this option
1379
# see if it is the value, or if it is another
1380
# short option
1381
optargfn = OPTIONS[optname]
1382
if optargfn is None:
1383
# This option does not take an argument, so the
1384
# next entry is another short option, pack it back
1385
# into the list
1386
argv.insert(0, '-' + a[2:])
1387
else:
1388
# This option takes an argument, so pack it
1389
# into the array
1390
optarg = a[2:]
975
1391
976
1392
if optname in opts:
977
1393
# XXX: Do we ever want to support this, e.g. for -r?
978
bailout('repeated option %r' % a)
1394
raise BzrError('repeated option %r' % a)
979
1395
980
1396
optargfn = OPTIONS[optname]
981
1397
if optargfn:
982
1398
if optarg == None:
983
1399
if not argv:
984
bailout('option %r needs an argument' % a)
1400
raise BzrError('option %r needs an argument' % a)
985
1401
else:
986
1402
optarg = argv.pop(0)
987
1403
opts[optname] = optargfn(optarg)
988
1404
else:
989
1405
if optarg != None:
990
bailout('option %r takes no argument' % optname)
1406
raise BzrError('option %r takes no argument' % optname)
991
1407
opts[optname] = True
992
1408
else:
993
1409
args.append(a)
1041
1457
return argdict
1042
1458
1043
1459
1460
def _parse_master_args(argv):
1461
"""Parse the arguments that always go with the original command.
1462
These are things like bzr --no-plugins, etc.
1463
1464
There are now 2 types of option flags. Ones that come *before* the command,
1465
and ones that come *after* the command.
1466
Ones coming *before* the command are applied against all possible commands.
1467
And are generally applied before plugins are loaded.
1468
1469
The current list are:
1470
--builtin Allow plugins to load, but don't let them override builtin commands,
1471
they will still be allowed if they do not override a builtin.
1472
--no-plugins Don't load any plugins. This lets you get back to official source
1473
behavior.
1474
--profile Enable the hotspot profile before running the command.
1475
For backwards compatibility, this is also a non-master option.
1476
--version Spit out the version of bzr that is running and exit.
1477
This is also a non-master option.
1478
--help Run help and exit, also a non-master option (I think that should stay, though)
1479
1480
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1481
Traceback (most recent call last):
1482
...
1483
BzrCommandError: Invalid master option: 'test'
1484
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1485
>>> print argv
1486
['command']
1487
>>> print opts['version']
1488
True
1489
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1490
>>> print argv
1491
['command', '--more-options']
1492
>>> print opts['profile']
1493
True
1494
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1495
>>> print argv
1496
['command']
1497
>>> print opts['no-plugins']
1498
True
1499
>>> print opts['profile']
1500
False
1501
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1502
>>> print argv
1503
['command', '--profile']
1504
>>> print opts['profile']
1505
False
1506
"""
1507
master_opts = {'builtin':False,
1508
'no-plugins':False,
1509
'version':False,
1510
'profile':False,
1511
'help':False
1512
}
1513
1514
# This is the point where we could hook into argv[0] to determine
1515
# what front-end is supposed to be run
1516
# For now, we are just ignoring it.
1517
cmd_name = argv.pop(0)
1518
for arg in argv[:]:
1519
if arg[:2] != '--': # at the first non-option, we return the rest
1520
break
1521
arg = arg[2:] # Remove '--'
1522
if arg not in master_opts:
1523
# We could say that this is not an error, that we should
1524
# just let it be handled by the main section instead
1525
raise BzrCommandError('Invalid master option: %r' % arg)
1526
argv.pop(0) # We are consuming this entry
1527
master_opts[arg] = True
1528
return argv, master_opts
1529
1530
1044
1531
1045
1532
def run_bzr(argv):
1046
1533
"""Execute a command.
1051
1538
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1052
1539
1053
1540
try:
1054
args, opts = parse_args(argv[1:])
1541
# some options like --builtin and --no-plugins have special effects
1542
argv, master_opts = _parse_master_args(argv)
1543
if not master_opts['no-plugins']:
1544
bzrlib.load_plugins()
1545
1546
args, opts = parse_args(argv)
1547
1548
if master_opts['help']:
1549
from bzrlib.help import help
1550
if argv:
1551
help(argv[0])
1552
else:
1553
help()
1554
return 0
1555
1055
1556
if 'help' in opts:
1056
import help
1557
from bzrlib.help import help
1057
1558
if args:
1058
help.help(args[0])
1559
help(args[0])
1059
1560
else:
1060
help.help()
1561
help()
1061
1562
return 0
1062
1563
elif 'version' in opts:
1063
1564
show_version()
1064
1565
return 0
1566
elif args and args[0] == 'builtin':
1567
include_plugins=False
1568
args = args[1:]
1065
1569
cmd = str(args.pop(0))
1066
1570
except IndexError:
1067
1571
import help
1069
1573
return 1
1070
1574
1071
1575
1072
canonical_cmd, cmd_class = get_cmd_class(cmd)
1576
plugins_override = not (master_opts['builtin'])
1577
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1073
1578
1074
# global option
1579
profile = master_opts['profile']
1580
# For backwards compatibility, I would rather stick with --profile being a
1581
# master/global option
1075
1582
if 'profile' in opts:
1076
1583
profile = True
1077
1584
del opts['profile']
1078
else:
1079
profile = False
1080
1585
1081
1586
# check options are reasonable
1082
1587
allowed = cmd_class.takes_options
1113
1618
os.close(pffileno)
1114
1619
os.remove(pfname)
1115
1620
else:
1116
cmdobj = cmd_class(cmdopts, cmdargs).status
1621
return cmd_class(cmdopts, cmdargs).status
1117
1622
1118
1623
1119
1624
def _report_exception(summary, quiet=False):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1