« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 788
- compare with another revision
- download diff
- download tarball
- view history from revision 788
- Committer: Martin Pool
- Date: 2005-06-27 01:26:11 UTC
- Revision ID: mbp@sourcefrog.net-20050627012611-4effb7007553fde1
- tweak rsync upload script
- 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
from bzrlib.osutils import get_text_message
1077
787
1078
## Warning: shadows builtin file()
788
1079
if not message and not file:
789
raise BzrCommandError("please specify a commit message",
790
["use either --message or --file"])
1080
import cStringIO
1081
stdout = sys.stdout
1082
catcher = cStringIO.StringIO()
1083
sys.stdout = catcher
1084
cmd_status({"file_list":selected_list}, {})
1085
info = catcher.getvalue()
1086
sys.stdout = stdout
1087
message = get_text_message(info)
1088
1089
if message is None:
1090
raise BzrCommandError("please specify a commit message",
1091
["use either --message or --file"])
791
1092
elif message and file:
792
1093
raise BzrCommandError("please specify either --message or --file")
793
1094
795
1096
import codecs
796
1097
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
797
1098
798
Branch('.').commit(message, verbose=verbose)
1099
b = Branch('.')
1100
commit(b, message, verbose=verbose, specific_files=selected_list)
799
1101
800
1102
801
1103
class cmd_check(Command):
803
1105
804
1106
This command checks various invariants about the branch storage to
805
1107
detect data corruption or bzr bugs.
1108
1109
If given the --update flag, it will update some optional fields
1110
to help ensure data consistency.
806
1111
"""
807
1112
takes_args = ['dir?']
1113
808
1114
def run(self, dir='.'):
809
1115
import bzrlib.check
810
bzrlib.check.check(Branch(dir, find_root=False))
1116
bzrlib.check.check(Branch(dir))
1117
1118
1119
1120
class cmd_upgrade(Command):
1121
"""Upgrade branch storage to current format.
1122
1123
This should normally be used only after the check command tells
1124
you to run it.
1125
"""
1126
takes_args = ['dir?']
1127
1128
def run(self, dir='.'):
1129
from bzrlib.upgrade import upgrade
1130
upgrade(Branch(dir))
811
1131
812
1132
813
1133
826
1146
"""Run internal test suite"""
827
1147
hidden = True
828
1148
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
1149
from bzrlib.selftest import selftest
1150
return int(not selftest())
851
1151
852
1152
853
1153
class cmd_version(Command):
854
"""Show version of bzr"""
1154
"""Show version of bzr."""
855
1155
def run(self):
856
1156
show_version()
857
1157
858
1158
def show_version():
859
1159
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1160
# is bzrlib itself in a branch?
1161
bzrrev = bzrlib.get_bzr_revision()
1162
if bzrrev:
1163
print " (bzr checkout, revision %d {%s})" % bzrrev
860
1164
print bzrlib.__copyright__
861
1165
print "http://bazaar-ng.org/"
862
1166
print
871
1175
def run(self):
872
1176
print "it sure does!"
873
1177
1178
def parse_spec(spec):
1179
"""
1180
>>> parse_spec(None)
1181
[None, None]
1182
>>> parse_spec("./")
1183
['./', None]
1184
>>> parse_spec("../@")
1185
['..', -1]
1186
>>> parse_spec("../f/@35")
1187
['../f', 35]
1188
"""
1189
if spec is None:
1190
return [None, None]
1191
if '/@' in spec:
1192
parsed = spec.split('/@')
1193
assert len(parsed) == 2
1194
if parsed[1] == "":
1195
parsed[1] = -1
1196
else:
1197
parsed[1] = int(parsed[1])
1198
assert parsed[1] >=0
1199
else:
1200
parsed = [spec, None]
1201
return parsed
1202
1203
1204
1205
class cmd_merge(Command):
1206
"""Perform a three-way merge of trees.
1207
1208
The SPEC parameters are working tree or revision specifiers. Working trees
1209
are specified using standard paths or urls. No component of a directory
1210
path may begin with '@'.
1211
1212
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1213
1214
Revisions are specified using a dirname/@revno pair, where dirname is the
1215
branch directory and revno is the revision within that branch. If no revno
1216
is specified, the latest revision is used.
1217
1218
Revision examples: './@127', 'foo/@', '../@1'
1219
1220
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1221
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1222
as the BASE.
1223
1224
merge refuses to run if there are any uncommitted changes, unless
1225
--force is given.
1226
"""
1227
takes_args = ['other_spec', 'base_spec?']
1228
takes_options = ['force']
1229
1230
def run(self, other_spec, base_spec=None, force=False):
1231
from bzrlib.merge import merge
1232
merge(parse_spec(other_spec), parse_spec(base_spec),
1233
check_clean=(not force))
1234
1235
1236
1237
class cmd_revert(Command):
1238
"""Restore selected files from a previous revision.
1239
"""
1240
takes_args = ['file+']
1241
def run(self, file_list):
1242
from bzrlib.branch import find_branch
1243
1244
if not file_list:
1245
file_list = ['.']
1246
1247
b = find_branch(file_list[0])
1248
1249
b.revert([b.relpath(f) for f in file_list])
1250
1251
1252
class cmd_merge_revert(Command):
1253
"""Reverse all changes since the last commit.
1254
1255
Only versioned files are affected.
1256
1257
TODO: Store backups of any files that will be reverted, so
1258
that the revert can be undone.
1259
"""
1260
takes_options = ['revision']
1261
1262
def run(self, revision=-1):
1263
from bzrlib.merge import merge
1264
merge(('.', revision), parse_spec('.'),
1265
check_clean=False,
1266
ignore_zero=True)
1267
874
1268
875
1269
class cmd_assert_fail(Command):
876
1270
"""Test reporting of assertion failures"""
902
1296
statcache.update_cache(b.base, b.read_working_inventory())
903
1297
904
1298
905
######################################################################
906
# main routine
1299
1300
class cmd_plugins(Command):
1301
"""List plugins"""
1302
hidden = True
1303
def run(self):
1304
import bzrlib.plugin
1305
from pprint import pprint
1306
pprint(bzrlib.plugin.all_plugins)
1307
907
1308
908
1309
909
1310
# list of all available options; the rhs can be either None for an
911
1312
# the type.
912
1313
OPTIONS = {
913
1314
'all': None,
1315
'diff-options': str,
914
1316
'help': None,
915
1317
'file': unicode,
1318
'force': None,
1319
'format': unicode,
1320
'forward': None,
916
1321
'message': unicode,
1322
'no-recurse': None,
917
1323
'profile': None,
918
'revision': int,
1324
'revision': _parse_revision_str,
919
1325
'show-ids': None,
920
1326
'timezone': str,
921
1327
'verbose': None,
922
1328
'version': None,
923
1329
'email': None,
1330
'update': None,
924
1331
}
925
1332
926
1333
SHORT_OPTIONS = {
1334
'F': 'file',
1335
'h': 'help',
927
1336
'm': 'message',
928
'F': 'file',
929
1337
'r': 'revision',
930
1338
'v': 'verbose',
931
1339
}
947
1355
(['status'], {'all': True})
948
1356
>>> parse_args('commit --message=biter'.split())
949
1357
(['commit'], {'message': u'biter'})
1358
>>> parse_args('log -r 500'.split())
1359
(['log'], {'revision': 500})
1360
>>> parse_args('log -r500:600'.split())
1361
(['log'], {'revision': [500, 600]})
1362
>>> parse_args('log -vr500:600'.split())
1363
(['log'], {'verbose': True, 'revision': [500, 600]})
1364
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1365
Traceback (most recent call last):
1366
...
1367
ValueError: invalid literal for int(): v500
950
1368
"""
951
1369
args = []
952
1370
opts = {}
966
1384
else:
967
1385
optname = a[2:]
968
1386
if optname not in OPTIONS:
969
bailout('unknown long option %r' % a)
1387
raise BzrError('unknown long option %r' % a)
970
1388
else:
971
1389
shortopt = a[1:]
972
if shortopt not in SHORT_OPTIONS:
973
bailout('unknown short option %r' % a)
974
optname = SHORT_OPTIONS[shortopt]
1390
if shortopt in SHORT_OPTIONS:
1391
# Multi-character options must have a space to delimit
1392
# their value
1393
optname = SHORT_OPTIONS[shortopt]
1394
else:
1395
# Single character short options, can be chained,
1396
# and have their value appended to their name
1397
shortopt = a[1:2]
1398
if shortopt not in SHORT_OPTIONS:
1399
# We didn't find the multi-character name, and we
1400
# didn't find the single char name
1401
raise BzrError('unknown short option %r' % a)
1402
optname = SHORT_OPTIONS[shortopt]
1403
1404
if a[2:]:
1405
# There are extra things on this option
1406
# see if it is the value, or if it is another
1407
# short option
1408
optargfn = OPTIONS[optname]
1409
if optargfn is None:
1410
# This option does not take an argument, so the
1411
# next entry is another short option, pack it back
1412
# into the list
1413
argv.insert(0, '-' + a[2:])
1414
else:
1415
# This option takes an argument, so pack it
1416
# into the array
1417
optarg = a[2:]
975
1418
976
1419
if optname in opts:
977
1420
# XXX: Do we ever want to support this, e.g. for -r?
978
bailout('repeated option %r' % a)
1421
raise BzrError('repeated option %r' % a)
979
1422
980
1423
optargfn = OPTIONS[optname]
981
1424
if optargfn:
982
1425
if optarg == None:
983
1426
if not argv:
984
bailout('option %r needs an argument' % a)
1427
raise BzrError('option %r needs an argument' % a)
985
1428
else:
986
1429
optarg = argv.pop(0)
987
1430
opts[optname] = optargfn(optarg)
988
1431
else:
989
1432
if optarg != None:
990
bailout('option %r takes no argument' % optname)
1433
raise BzrError('option %r takes no argument' % optname)
991
1434
opts[optname] = True
992
1435
else:
993
1436
args.append(a)
1041
1484
return argdict
1042
1485
1043
1486
1487
def _parse_master_args(argv):
1488
"""Parse the arguments that always go with the original command.
1489
These are things like bzr --no-plugins, etc.
1490
1491
There are now 2 types of option flags. Ones that come *before* the command,
1492
and ones that come *after* the command.
1493
Ones coming *before* the command are applied against all possible commands.
1494
And are generally applied before plugins are loaded.
1495
1496
The current list are:
1497
--builtin Allow plugins to load, but don't let them override builtin commands,
1498
they will still be allowed if they do not override a builtin.
1499
--no-plugins Don't load any plugins. This lets you get back to official source
1500
behavior.
1501
--profile Enable the hotspot profile before running the command.
1502
For backwards compatibility, this is also a non-master option.
1503
--version Spit out the version of bzr that is running and exit.
1504
This is also a non-master option.
1505
--help Run help and exit, also a non-master option (I think that should stay, though)
1506
1507
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1508
Traceback (most recent call last):
1509
...
1510
BzrCommandError: Invalid master option: 'test'
1511
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1512
>>> print argv
1513
['command']
1514
>>> print opts['version']
1515
True
1516
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1517
>>> print argv
1518
['command', '--more-options']
1519
>>> print opts['profile']
1520
True
1521
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1522
>>> print argv
1523
['command']
1524
>>> print opts['no-plugins']
1525
True
1526
>>> print opts['profile']
1527
False
1528
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1529
>>> print argv
1530
['command', '--profile']
1531
>>> print opts['profile']
1532
False
1533
"""
1534
master_opts = {'builtin':False,
1535
'no-plugins':False,
1536
'version':False,
1537
'profile':False,
1538
'help':False
1539
}
1540
1541
# This is the point where we could hook into argv[0] to determine
1542
# what front-end is supposed to be run
1543
# For now, we are just ignoring it.
1544
cmd_name = argv.pop(0)
1545
for arg in argv[:]:
1546
if arg[:2] != '--': # at the first non-option, we return the rest
1547
break
1548
arg = arg[2:] # Remove '--'
1549
if arg not in master_opts:
1550
# We could say that this is not an error, that we should
1551
# just let it be handled by the main section instead
1552
raise BzrCommandError('Invalid master option: %r' % arg)
1553
argv.pop(0) # We are consuming this entry
1554
master_opts[arg] = True
1555
return argv, master_opts
1556
1557
1044
1558
1045
1559
def run_bzr(argv):
1046
1560
"""Execute a command.
1051
1565
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1052
1566
1053
1567
try:
1054
args, opts = parse_args(argv[1:])
1568
# some options like --builtin and --no-plugins have special effects
1569
argv, master_opts = _parse_master_args(argv)
1570
if not master_opts['no-plugins']:
1571
bzrlib.load_plugins()
1572
1573
args, opts = parse_args(argv)
1574
1575
if master_opts['help']:
1576
from bzrlib.help import help
1577
if argv:
1578
help(argv[0])
1579
else:
1580
help()
1581
return 0
1582
1055
1583
if 'help' in opts:
1056
import help
1584
from bzrlib.help import help
1057
1585
if args:
1058
help.help(args[0])
1586
help(args[0])
1059
1587
else:
1060
help.help()
1588
help()
1061
1589
return 0
1062
1590
elif 'version' in opts:
1063
1591
show_version()
1064
1592
return 0
1593
elif args and args[0] == 'builtin':
1594
include_plugins=False
1595
args = args[1:]
1065
1596
cmd = str(args.pop(0))
1066
1597
except IndexError:
1067
1598
import help
1069
1600
return 1
1070
1601
1071
1602
1072
canonical_cmd, cmd_class = get_cmd_class(cmd)
1603
plugins_override = not (master_opts['builtin'])
1604
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1073
1605
1074
# global option
1606
profile = master_opts['profile']
1607
# For backwards compatibility, I would rather stick with --profile being a
1608
# master/global option
1075
1609
if 'profile' in opts:
1076
1610
profile = True
1077
1611
del opts['profile']
1078
else:
1079
profile = False
1080
1612
1081
1613
# check options are reasonable
1082
1614
allowed = cmd_class.takes_options
1113
1645
os.close(pffileno)
1114
1646
os.remove(pfname)
1115
1647
else:
1116
cmdobj = cmd_class(cmdopts, cmdargs).status
1648
return cmd_class(cmdopts, cmdargs).status
1117
1649
1118
1650
1119
1651
def _report_exception(summary, quiet=False):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1