« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 791
- compare with another revision
- download diff
- download tarball
- view history from revision 791
- Committer: Martin Pool
- Date: 2005-06-27 01:39:26 UTC
- Revision ID: mbp@sourcefrog.net-20050627013926-49413d5928809350
- import effbot.org http client
- files added:
- bzr-man.py
- bzrlib/selftest
- effbot
- effbot/org
- 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 tempfile
473
from shutil import rmtree
474
import errno
475
476
br_to = Branch('.')
477
stored_loc = None
478
try:
479
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
480
except IOError, e:
481
if e.errno != errno.ENOENT:
482
raise
483
if location is None:
484
if stored_loc is None:
485
raise BzrCommandError("No pull location known or specified.")
486
else:
487
print "Using last location: %s" % stored_loc
488
location = stored_loc
489
cache_root = tempfile.mkdtemp()
490
try:
491
from branch import find_cached_branch, DivergedBranches
492
br_from = find_cached_branch(location, cache_root)
493
location = pull_loc(br_from)
494
old_revno = br_to.revno()
495
try:
496
br_to.update_revisions(br_from)
497
except DivergedBranches:
498
raise BzrCommandError("These branches have diverged."
499
" Try merge.")
500
501
merge(('.', -1), ('.', old_revno), check_clean=False)
502
if location != stored_loc:
503
br_to.controlfile("x-pull", "wb").write(location + "\n")
504
finally:
505
rmtree(cache_root)
506
507
508
509
class cmd_branch(Command):
510
"""Create a new copy of a branch.
511
512
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
513
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
514
515
To retrieve the branch as of a particular revision, supply the --revision
516
parameter, as in "branch foo/bar -r 5".
517
"""
518
takes_args = ['from_location', 'to_location?']
519
takes_options = ['revision']
520
521
def run(self, from_location, to_location=None, revision=None):
522
import errno
523
from bzrlib.merge import merge
524
from branch import find_cached_branch, DivergedBranches, NoSuchRevision
525
from shutil import rmtree
526
from meta_store import CachedStore
527
import tempfile
528
cache_root = tempfile.mkdtemp()
529
try:
530
try:
531
br_from = find_cached_branch(from_location, cache_root)
532
except OSError, e:
533
if e.errno == errno.ENOENT:
534
raise BzrCommandError('Source location "%s" does not'
535
' exist.' % to_location)
536
else:
537
raise
538
539
if to_location is None:
540
to_location = os.path.basename(from_location.rstrip("/\\"))
541
542
try:
543
os.mkdir(to_location)
544
except OSError, e:
545
if e.errno == errno.EEXIST:
546
raise BzrCommandError('Target directory "%s" already'
547
' exists.' % to_location)
548
if e.errno == errno.ENOENT:
549
raise BzrCommandError('Parent of "%s" does not exist.' %
550
to_location)
551
else:
552
raise
553
br_to = Branch(to_location, init=True)
554
555
try:
556
br_to.update_revisions(br_from, stop_revision=revision)
557
except NoSuchRevision:
558
rmtree(to_location)
559
msg = "The branch %s has no revision %d." % (from_location,
560
revision)
561
raise BzrCommandError(msg)
562
merge((to_location, -1), (to_location, 0), this_dir=to_location,
563
check_clean=False, ignore_zero=True)
564
from_location = pull_loc(br_from)
565
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
566
finally:
567
rmtree(cache_root)
568
569
570
def pull_loc(branch):
571
# TODO: Should perhaps just make attribute be 'base' in
572
# RemoteBranch and Branch?
573
if hasattr(branch, "baseurl"):
574
return branch.baseurl
575
else:
576
return branch.base
577
578
579
351
580
class cmd_renames(Command):
352
581
"""Show list of renamed files.
353
582
407
636
b = Branch(filename)
408
637
i = b.inventory.path2id(b.relpath(filename))
409
638
if i == None:
410
bailout("%r is not a versioned file" % filename)
639
raise BzrError("%r is not a versioned file" % filename)
411
640
else:
412
641
print i
413
642
424
653
inv = b.inventory
425
654
fid = inv.path2id(b.relpath(filename))
426
655
if fid == None:
427
bailout("%r is not a versioned file" % filename)
656
raise BzrError("%r is not a versioned file" % filename)
428
657
for fip in inv.get_idpath(fid):
429
658
print fip
430
659
431
660
432
661
class cmd_revision_history(Command):
433
662
"""Display list of revision ids on this branch."""
663
hidden = True
434
664
def run(self):
435
665
for patchid in Branch('.').revision_history():
436
666
print patchid
488
718
"""
489
719
490
720
takes_args = ['file*']
491
takes_options = ['revision']
492
aliases = ['di']
721
takes_options = ['revision', 'diff-options']
722
aliases = ['di', 'dif']
493
723
494
def run(self, revision=None, file_list=None):
724
def run(self, revision=None, file_list=None, diff_options=None):
495
725
from bzrlib.diff import show_diff
726
from bzrlib import find_branch
727
728
if file_list:
729
b = find_branch(file_list[0])
730
file_list = [b.relpath(f) for f in file_list]
731
if file_list == ['']:
732
# just pointing to top-of-tree
733
file_list = None
734
else:
735
b = Branch('.')
496
736
497
show_diff(Branch('.'), revision, file_list)
737
show_diff(b, revision, specific_files=file_list,
738
external_diff_options=diff_options)
498
739
499
740
500
741
584
825
class cmd_log(Command):
585
826
"""Show log of this branch.
586
827
587
TODO: Option to limit range.
828
To request a range of logs, you can use the command -r begin:end
829
-r revision requests a specific revision, -r :end or -r begin: are
830
also valid.
588
831
589
TODO: Perhaps show most-recent first with an option for last.
832
TODO: Make --revision support uuid: and hash: [future tag:] notation.
833
590
834
"""
835
591
836
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')
837
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
838
839
def run(self, filename=None, timezone='original',
840
verbose=False,
841
show_ids=False,
842
forward=False,
843
revision=None):
844
from bzrlib import show_log, find_branch
845
import codecs
846
847
direction = (forward and 'forward') or 'reverse'
848
596
849
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)
850
b = find_branch(filename)
851
fp = b.relpath(filename)
852
if fp:
853
file_id = b.read_working_inventory().path2id(fp)
854
else:
855
file_id = None # points to branch root
856
else:
857
b = find_branch('.')
858
file_id = None
859
860
if revision == None:
861
revision = [None, None]
862
elif isinstance(revision, int):
863
revision = [revision, revision]
864
else:
865
# pair of revisions?
866
pass
867
868
assert len(revision) == 2
869
870
mutter('encoding log as %r' % bzrlib.user_encoding)
871
872
# use 'replace' so that we don't abort if trying to write out
873
# in e.g. the default C locale.
874
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
875
876
show_log(b, file_id,
877
show_timezone=timezone,
878
verbose=verbose,
879
show_ids=show_ids,
880
to_file=outf,
881
direction=direction,
882
start_revision=revision[0],
883
end_revision=revision[1])
602
884
603
885
604
886
605
887
class cmd_touching_revisions(Command):
606
"""Return revision-ids which affected a particular file."""
888
"""Return revision-ids which affected a particular file.
889
890
A more user-friendly interface is "bzr log FILE"."""
607
891
hidden = True
608
892
takes_args = ["filename"]
609
893
def run(self, filename):
610
b = Branch(filename, lock_mode='r')
894
b = Branch(filename)
611
895
inv = b.read_working_inventory()
612
896
file_id = inv.path2id(b.relpath(filename))
613
897
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
643
927
644
928
645
929
class cmd_unknowns(Command):
646
"""List unknown files"""
930
"""List unknown files."""
647
931
def run(self):
648
932
for f in Branch('.').unknowns():
649
933
print quotefn(f)
651
935
652
936
653
937
class cmd_ignore(Command):
654
"""Ignore a command or pattern
938
"""Ignore a command or pattern.
655
939
656
940
To remove patterns from the ignore list, edit the .bzrignore file.
657
941
671
955
672
956
def run(self, name_pattern):
673
957
from bzrlib.atomicfile import AtomicFile
674
import codecs
958
import os.path
675
959
676
960
b = Branch('.')
677
961
ifn = b.abspath('.bzrignore')
678
962
679
# FIXME: probably doesn't handle non-ascii patterns
680
681
963
if os.path.exists(ifn):
682
f = b.controlfile(ifn, 'rt')
683
igns = f.read()
684
f.close()
964
f = open(ifn, 'rt')
965
try:
966
igns = f.read().decode('utf-8')
967
finally:
968
f.close()
685
969
else:
686
970
igns = ''
687
971
972
# TODO: If the file already uses crlf-style termination, maybe
973
# we should use that for the newly added lines?
974
688
975
if igns and igns[-1] != '\n':
689
976
igns += '\n'
690
977
igns += name_pattern + '\n'
691
978
692
f = AtomicFile(ifn, 'wt')
693
f.write(igns)
694
f.commit()
979
try:
980
f = AtomicFile(ifn, 'wt')
981
f.write(igns.encode('utf-8'))
982
f.commit()
983
finally:
984
f.close()
695
985
696
986
inv = b.working_tree().inventory
697
987
if inv.path2id('.bzrignore'):
737
1027
class cmd_export(Command):
738
1028
"""Export past revision to destination directory.
739
1029
740
If no revision is specified this exports the last committed revision."""
1030
If no revision is specified this exports the last committed revision.
1031
1032
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1033
given, exports to a directory (equivalent to --format=dir)."""
1034
# TODO: list known exporters
741
1035
takes_args = ['dest']
742
takes_options = ['revision']
743
def run(self, dest, revision=None):
1036
takes_options = ['revision', 'format']
1037
def run(self, dest, revision=None, format='dir'):
744
1038
b = Branch('.')
745
1039
if revision == None:
746
1040
rh = b.revision_history()[-1]
747
1041
else:
748
1042
rh = b.lookup_revision(int(revision))
749
1043
t = b.revision_tree(rh)
750
t.export(dest)
1044
t.export(dest, format)
751
1045
752
1046
753
1047
class cmd_cat(Command):
774
1068
class cmd_commit(Command):
775
1069
"""Commit changes into a new revision.
776
1070
777
TODO: Commit only selected files.
1071
If selected files are specified, only changes to those files are
1072
committed. If a directory is specified then its contents are also
1073
committed.
1074
1075
A selected-file commit may fail in some cases where the committed
1076
tree would be invalid, such as trying to commit a file in a
1077
newly-added directory that is not itself committed.
778
1078
779
1079
TODO: Run hooks on tree to-be-committed, and after commit.
780
1080
781
1081
TODO: Strict commit that fails if there are unknown or deleted files.
782
1082
"""
1083
takes_args = ['selected*']
783
1084
takes_options = ['message', 'file', 'verbose']
784
1085
aliases = ['ci', 'checkin']
785
1086
786
def run(self, message=None, file=None, verbose=False):
1087
def run(self, message=None, file=None, verbose=True, selected_list=None):
1088
from bzrlib.commit import commit
1089
from bzrlib.osutils import get_text_message
1090
787
1091
## Warning: shadows builtin file()
788
1092
if not message and not file:
789
raise BzrCommandError("please specify a commit message",
790
["use either --message or --file"])
1093
import cStringIO
1094
stdout = sys.stdout
1095
catcher = cStringIO.StringIO()
1096
sys.stdout = catcher
1097
cmd_status({"file_list":selected_list}, {})
1098
info = catcher.getvalue()
1099
sys.stdout = stdout
1100
message = get_text_message(info)
1101
1102
if message is None:
1103
raise BzrCommandError("please specify a commit message",
1104
["use either --message or --file"])
791
1105
elif message and file:
792
1106
raise BzrCommandError("please specify either --message or --file")
793
1107
795
1109
import codecs
796
1110
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
797
1111
798
Branch('.').commit(message, verbose=verbose)
1112
b = Branch('.')
1113
commit(b, message, verbose=verbose, specific_files=selected_list)
799
1114
800
1115
801
1116
class cmd_check(Command):
803
1118
804
1119
This command checks various invariants about the branch storage to
805
1120
detect data corruption or bzr bugs.
1121
1122
If given the --update flag, it will update some optional fields
1123
to help ensure data consistency.
806
1124
"""
807
1125
takes_args = ['dir?']
1126
808
1127
def run(self, dir='.'):
809
1128
import bzrlib.check
810
bzrlib.check.check(Branch(dir, find_root=False))
1129
bzrlib.check.check(Branch(dir))
1130
1131
1132
1133
class cmd_upgrade(Command):
1134
"""Upgrade branch storage to current format.
1135
1136
This should normally be used only after the check command tells
1137
you to run it.
1138
"""
1139
takes_args = ['dir?']
1140
1141
def run(self, dir='.'):
1142
from bzrlib.upgrade import upgrade
1143
upgrade(Branch(dir))
811
1144
812
1145
813
1146
826
1159
"""Run internal test suite"""
827
1160
hidden = True
828
1161
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
1162
from bzrlib.selftest import selftest
1163
return int(not selftest())
851
1164
852
1165
853
1166
class cmd_version(Command):
854
"""Show version of bzr"""
1167
"""Show version of bzr."""
855
1168
def run(self):
856
1169
show_version()
857
1170
858
1171
def show_version():
859
1172
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1173
# is bzrlib itself in a branch?
1174
bzrrev = bzrlib.get_bzr_revision()
1175
if bzrrev:
1176
print " (bzr checkout, revision %d {%s})" % bzrrev
860
1177
print bzrlib.__copyright__
861
1178
print "http://bazaar-ng.org/"
862
1179
print
871
1188
def run(self):
872
1189
print "it sure does!"
873
1190
1191
def parse_spec(spec):
1192
"""
1193
>>> parse_spec(None)
1194
[None, None]
1195
>>> parse_spec("./")
1196
['./', None]
1197
>>> parse_spec("../@")
1198
['..', -1]
1199
>>> parse_spec("../f/@35")
1200
['../f', 35]
1201
"""
1202
if spec is None:
1203
return [None, None]
1204
if '/@' in spec:
1205
parsed = spec.split('/@')
1206
assert len(parsed) == 2
1207
if parsed[1] == "":
1208
parsed[1] = -1
1209
else:
1210
parsed[1] = int(parsed[1])
1211
assert parsed[1] >=0
1212
else:
1213
parsed = [spec, None]
1214
return parsed
1215
1216
1217
1218
class cmd_merge(Command):
1219
"""Perform a three-way merge of trees.
1220
1221
The SPEC parameters are working tree or revision specifiers. Working trees
1222
are specified using standard paths or urls. No component of a directory
1223
path may begin with '@'.
1224
1225
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1226
1227
Revisions are specified using a dirname/@revno pair, where dirname is the
1228
branch directory and revno is the revision within that branch. If no revno
1229
is specified, the latest revision is used.
1230
1231
Revision examples: './@127', 'foo/@', '../@1'
1232
1233
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1234
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1235
as the BASE.
1236
1237
merge refuses to run if there are any uncommitted changes, unless
1238
--force is given.
1239
"""
1240
takes_args = ['other_spec', 'base_spec?']
1241
takes_options = ['force']
1242
1243
def run(self, other_spec, base_spec=None, force=False):
1244
from bzrlib.merge import merge
1245
merge(parse_spec(other_spec), parse_spec(base_spec),
1246
check_clean=(not force))
1247
1248
1249
1250
class cmd_revert(Command):
1251
"""Restore selected files from a previous revision.
1252
"""
1253
takes_args = ['file+']
1254
def run(self, file_list):
1255
from bzrlib.branch import find_branch
1256
1257
if not file_list:
1258
file_list = ['.']
1259
1260
b = find_branch(file_list[0])
1261
1262
b.revert([b.relpath(f) for f in file_list])
1263
1264
1265
class cmd_merge_revert(Command):
1266
"""Reverse all changes since the last commit.
1267
1268
Only versioned files are affected.
1269
1270
TODO: Store backups of any files that will be reverted, so
1271
that the revert can be undone.
1272
"""
1273
takes_options = ['revision']
1274
1275
def run(self, revision=-1):
1276
from bzrlib.merge import merge
1277
merge(('.', revision), parse_spec('.'),
1278
check_clean=False,
1279
ignore_zero=True)
1280
874
1281
875
1282
class cmd_assert_fail(Command):
876
1283
"""Test reporting of assertion failures"""
902
1309
statcache.update_cache(b.base, b.read_working_inventory())
903
1310
904
1311
905
######################################################################
906
# main routine
1312
1313
class cmd_plugins(Command):
1314
"""List plugins"""
1315
hidden = True
1316
def run(self):
1317
import bzrlib.plugin
1318
from pprint import pprint
1319
pprint(bzrlib.plugin.all_plugins)
1320
907
1321
908
1322
909
1323
# list of all available options; the rhs can be either None for an
911
1325
# the type.
912
1326
OPTIONS = {
913
1327
'all': None,
1328
'diff-options': str,
914
1329
'help': None,
915
1330
'file': unicode,
1331
'force': None,
1332
'format': unicode,
1333
'forward': None,
916
1334
'message': unicode,
1335
'no-recurse': None,
917
1336
'profile': None,
918
'revision': int,
1337
'revision': _parse_revision_str,
919
1338
'show-ids': None,
920
1339
'timezone': str,
921
1340
'verbose': None,
922
1341
'version': None,
923
1342
'email': None,
1343
'update': None,
924
1344
}
925
1345
926
1346
SHORT_OPTIONS = {
1347
'F': 'file',
1348
'h': 'help',
927
1349
'm': 'message',
928
'F': 'file',
929
1350
'r': 'revision',
930
1351
'v': 'verbose',
931
1352
}
947
1368
(['status'], {'all': True})
948
1369
>>> parse_args('commit --message=biter'.split())
949
1370
(['commit'], {'message': u'biter'})
1371
>>> parse_args('log -r 500'.split())
1372
(['log'], {'revision': 500})
1373
>>> parse_args('log -r500:600'.split())
1374
(['log'], {'revision': [500, 600]})
1375
>>> parse_args('log -vr500:600'.split())
1376
(['log'], {'verbose': True, 'revision': [500, 600]})
1377
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1378
Traceback (most recent call last):
1379
...
1380
ValueError: invalid literal for int(): v500
950
1381
"""
951
1382
args = []
952
1383
opts = {}
966
1397
else:
967
1398
optname = a[2:]
968
1399
if optname not in OPTIONS:
969
bailout('unknown long option %r' % a)
1400
raise BzrError('unknown long option %r' % a)
970
1401
else:
971
1402
shortopt = a[1:]
972
if shortopt not in SHORT_OPTIONS:
973
bailout('unknown short option %r' % a)
974
optname = SHORT_OPTIONS[shortopt]
1403
if shortopt in SHORT_OPTIONS:
1404
# Multi-character options must have a space to delimit
1405
# their value
1406
optname = SHORT_OPTIONS[shortopt]
1407
else:
1408
# Single character short options, can be chained,
1409
# and have their value appended to their name
1410
shortopt = a[1:2]
1411
if shortopt not in SHORT_OPTIONS:
1412
# We didn't find the multi-character name, and we
1413
# didn't find the single char name
1414
raise BzrError('unknown short option %r' % a)
1415
optname = SHORT_OPTIONS[shortopt]
1416
1417
if a[2:]:
1418
# There are extra things on this option
1419
# see if it is the value, or if it is another
1420
# short option
1421
optargfn = OPTIONS[optname]
1422
if optargfn is None:
1423
# This option does not take an argument, so the
1424
# next entry is another short option, pack it back
1425
# into the list
1426
argv.insert(0, '-' + a[2:])
1427
else:
1428
# This option takes an argument, so pack it
1429
# into the array
1430
optarg = a[2:]
975
1431
976
1432
if optname in opts:
977
1433
# XXX: Do we ever want to support this, e.g. for -r?
978
bailout('repeated option %r' % a)
1434
raise BzrError('repeated option %r' % a)
979
1435
980
1436
optargfn = OPTIONS[optname]
981
1437
if optargfn:
982
1438
if optarg == None:
983
1439
if not argv:
984
bailout('option %r needs an argument' % a)
1440
raise BzrError('option %r needs an argument' % a)
985
1441
else:
986
1442
optarg = argv.pop(0)
987
1443
opts[optname] = optargfn(optarg)
988
1444
else:
989
1445
if optarg != None:
990
bailout('option %r takes no argument' % optname)
1446
raise BzrError('option %r takes no argument' % optname)
991
1447
opts[optname] = True
992
1448
else:
993
1449
args.append(a)
1041
1497
return argdict
1042
1498
1043
1499
1500
def _parse_master_args(argv):
1501
"""Parse the arguments that always go with the original command.
1502
These are things like bzr --no-plugins, etc.
1503
1504
There are now 2 types of option flags. Ones that come *before* the command,
1505
and ones that come *after* the command.
1506
Ones coming *before* the command are applied against all possible commands.
1507
And are generally applied before plugins are loaded.
1508
1509
The current list are:
1510
--builtin Allow plugins to load, but don't let them override builtin commands,
1511
they will still be allowed if they do not override a builtin.
1512
--no-plugins Don't load any plugins. This lets you get back to official source
1513
behavior.
1514
--profile Enable the hotspot profile before running the command.
1515
For backwards compatibility, this is also a non-master option.
1516
--version Spit out the version of bzr that is running and exit.
1517
This is also a non-master option.
1518
--help Run help and exit, also a non-master option (I think that should stay, though)
1519
1520
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1521
Traceback (most recent call last):
1522
...
1523
BzrCommandError: Invalid master option: 'test'
1524
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1525
>>> print argv
1526
['command']
1527
>>> print opts['version']
1528
True
1529
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1530
>>> print argv
1531
['command', '--more-options']
1532
>>> print opts['profile']
1533
True
1534
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1535
>>> print argv
1536
['command']
1537
>>> print opts['no-plugins']
1538
True
1539
>>> print opts['profile']
1540
False
1541
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1542
>>> print argv
1543
['command', '--profile']
1544
>>> print opts['profile']
1545
False
1546
"""
1547
master_opts = {'builtin':False,
1548
'no-plugins':False,
1549
'version':False,
1550
'profile':False,
1551
'help':False
1552
}
1553
1554
# This is the point where we could hook into argv[0] to determine
1555
# what front-end is supposed to be run
1556
# For now, we are just ignoring it.
1557
cmd_name = argv.pop(0)
1558
for arg in argv[:]:
1559
if arg[:2] != '--': # at the first non-option, we return the rest
1560
break
1561
arg = arg[2:] # Remove '--'
1562
if arg not in master_opts:
1563
# We could say that this is not an error, that we should
1564
# just let it be handled by the main section instead
1565
raise BzrCommandError('Invalid master option: %r' % arg)
1566
argv.pop(0) # We are consuming this entry
1567
master_opts[arg] = True
1568
return argv, master_opts
1569
1570
1044
1571
1045
1572
def run_bzr(argv):
1046
1573
"""Execute a command.
1051
1578
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1052
1579
1053
1580
try:
1054
args, opts = parse_args(argv[1:])
1581
# some options like --builtin and --no-plugins have special effects
1582
argv, master_opts = _parse_master_args(argv)
1583
if not master_opts['no-plugins']:
1584
bzrlib.load_plugins()
1585
1586
args, opts = parse_args(argv)
1587
1588
if master_opts['help']:
1589
from bzrlib.help import help
1590
if argv:
1591
help(argv[0])
1592
else:
1593
help()
1594
return 0
1595
1055
1596
if 'help' in opts:
1056
import help
1597
from bzrlib.help import help
1057
1598
if args:
1058
help.help(args[0])
1599
help(args[0])
1059
1600
else:
1060
help.help()
1601
help()
1061
1602
return 0
1062
1603
elif 'version' in opts:
1063
1604
show_version()
1064
1605
return 0
1606
elif args and args[0] == 'builtin':
1607
include_plugins=False
1608
args = args[1:]
1065
1609
cmd = str(args.pop(0))
1066
1610
except IndexError:
1067
1611
import help
1069
1613
return 1
1070
1614
1071
1615
1072
canonical_cmd, cmd_class = get_cmd_class(cmd)
1616
plugins_override = not (master_opts['builtin'])
1617
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1073
1618
1074
# global option
1619
profile = master_opts['profile']
1620
# For backwards compatibility, I would rather stick with --profile being a
1621
# master/global option
1075
1622
if 'profile' in opts:
1076
1623
profile = True
1077
1624
del opts['profile']
1078
else:
1079
profile = False
1080
1625
1081
1626
# check options are reasonable
1082
1627
allowed = cmd_class.takes_options
1113
1658
os.close(pffileno)
1114
1659
os.remove(pfname)
1115
1660
else:
1116
cmdobj = cmd_class(cmdopts, cmdargs).status
1661
return cmd_class(cmdopts, cmdargs).status
1117
1662
1118
1663
1119
1664
def _report_exception(summary, quiet=False):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1