« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 796
- compare with another revision
- download diff
- download tarball
- view history from revision 796
- Committer: Martin Pool
- Date: 2005-06-27 06:25:30 UTC
- Revision ID: mbp@sourcefrog.net-20050627062530-0002d5c96b0ed3c1
- note bzr log changes
- files added:
- bzr-man.py
- bzrlib/selftest
- effbot
- effbot/org
- patches
- plugins
- plugins/changeset
- plugins/rsync
- 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
from bzrlib.log import log_formatter
846
import codecs
847
848
direction = (forward and 'forward') or 'reverse'
849
596
850
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)
851
b = find_branch(filename)
852
fp = b.relpath(filename)
853
if fp:
854
file_id = b.read_working_inventory().path2id(fp)
855
else:
856
file_id = None # points to branch root
857
else:
858
b = find_branch('.')
859
file_id = None
860
861
if revision == None:
862
revision = [None, None]
863
elif isinstance(revision, int):
864
revision = [revision, revision]
865
else:
866
# pair of revisions?
867
pass
868
869
assert len(revision) == 2
870
871
mutter('encoding log as %r' % bzrlib.user_encoding)
872
873
# use 'replace' so that we don't abort if trying to write out
874
# in e.g. the default C locale.
875
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
876
877
lf = log_formatter('short',
878
show_ids=show_ids,
879
to_file=outf,
880
show_timezone=timezone)
881
882
show_log(b,
883
lf,
884
file_id,
885
verbose=verbose,
886
direction=direction,
887
start_revision=revision[0],
888
end_revision=revision[1])
602
889
603
890
604
891
605
892
class cmd_touching_revisions(Command):
606
"""Return revision-ids which affected a particular file."""
893
"""Return revision-ids which affected a particular file.
894
895
A more user-friendly interface is "bzr log FILE"."""
607
896
hidden = True
608
897
takes_args = ["filename"]
609
898
def run(self, filename):
610
b = Branch(filename, lock_mode='r')
899
b = Branch(filename)
611
900
inv = b.read_working_inventory()
612
901
file_id = inv.path2id(b.relpath(filename))
613
902
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
643
932
644
933
645
934
class cmd_unknowns(Command):
646
"""List unknown files"""
935
"""List unknown files."""
647
936
def run(self):
648
937
for f in Branch('.').unknowns():
649
938
print quotefn(f)
651
940
652
941
653
942
class cmd_ignore(Command):
654
"""Ignore a command or pattern
943
"""Ignore a command or pattern.
655
944
656
945
To remove patterns from the ignore list, edit the .bzrignore file.
657
946
671
960
672
961
def run(self, name_pattern):
673
962
from bzrlib.atomicfile import AtomicFile
674
import codecs
963
import os.path
675
964
676
965
b = Branch('.')
677
966
ifn = b.abspath('.bzrignore')
678
967
679
# FIXME: probably doesn't handle non-ascii patterns
680
681
968
if os.path.exists(ifn):
682
f = b.controlfile(ifn, 'rt')
683
igns = f.read()
684
f.close()
969
f = open(ifn, 'rt')
970
try:
971
igns = f.read().decode('utf-8')
972
finally:
973
f.close()
685
974
else:
686
975
igns = ''
687
976
977
# TODO: If the file already uses crlf-style termination, maybe
978
# we should use that for the newly added lines?
979
688
980
if igns and igns[-1] != '\n':
689
981
igns += '\n'
690
982
igns += name_pattern + '\n'
691
983
692
f = AtomicFile(ifn, 'wt')
693
f.write(igns)
694
f.commit()
984
try:
985
f = AtomicFile(ifn, 'wt')
986
f.write(igns.encode('utf-8'))
987
f.commit()
988
finally:
989
f.close()
695
990
696
991
inv = b.working_tree().inventory
697
992
if inv.path2id('.bzrignore'):
737
1032
class cmd_export(Command):
738
1033
"""Export past revision to destination directory.
739
1034
740
If no revision is specified this exports the last committed revision."""
1035
If no revision is specified this exports the last committed revision.
1036
1037
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1038
given, exports to a directory (equivalent to --format=dir)."""
1039
# TODO: list known exporters
741
1040
takes_args = ['dest']
742
takes_options = ['revision']
743
def run(self, dest, revision=None):
1041
takes_options = ['revision', 'format']
1042
def run(self, dest, revision=None, format='dir'):
744
1043
b = Branch('.')
745
1044
if revision == None:
746
1045
rh = b.revision_history()[-1]
747
1046
else:
748
1047
rh = b.lookup_revision(int(revision))
749
1048
t = b.revision_tree(rh)
750
t.export(dest)
1049
t.export(dest, format)
751
1050
752
1051
753
1052
class cmd_cat(Command):
774
1073
class cmd_commit(Command):
775
1074
"""Commit changes into a new revision.
776
1075
777
TODO: Commit only selected files.
1076
If selected files are specified, only changes to those files are
1077
committed. If a directory is specified then its contents are also
1078
committed.
1079
1080
A selected-file commit may fail in some cases where the committed
1081
tree would be invalid, such as trying to commit a file in a
1082
newly-added directory that is not itself committed.
778
1083
779
1084
TODO: Run hooks on tree to-be-committed, and after commit.
780
1085
781
1086
TODO: Strict commit that fails if there are unknown or deleted files.
782
1087
"""
1088
takes_args = ['selected*']
783
1089
takes_options = ['message', 'file', 'verbose']
784
1090
aliases = ['ci', 'checkin']
785
1091
786
def run(self, message=None, file=None, verbose=False):
1092
def run(self, message=None, file=None, verbose=True, selected_list=None):
1093
from bzrlib.commit import commit
1094
from bzrlib.osutils import get_text_message
1095
787
1096
## Warning: shadows builtin file()
788
1097
if not message and not file:
789
raise BzrCommandError("please specify a commit message",
790
["use either --message or --file"])
1098
import cStringIO
1099
stdout = sys.stdout
1100
catcher = cStringIO.StringIO()
1101
sys.stdout = catcher
1102
cmd_status({"file_list":selected_list}, {})
1103
info = catcher.getvalue()
1104
sys.stdout = stdout
1105
message = get_text_message(info)
1106
1107
if message is None:
1108
raise BzrCommandError("please specify a commit message",
1109
["use either --message or --file"])
791
1110
elif message and file:
792
1111
raise BzrCommandError("please specify either --message or --file")
793
1112
795
1114
import codecs
796
1115
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
797
1116
798
Branch('.').commit(message, verbose=verbose)
1117
b = Branch('.')
1118
commit(b, message, verbose=verbose, specific_files=selected_list)
799
1119
800
1120
801
1121
class cmd_check(Command):
803
1123
804
1124
This command checks various invariants about the branch storage to
805
1125
detect data corruption or bzr bugs.
1126
1127
If given the --update flag, it will update some optional fields
1128
to help ensure data consistency.
806
1129
"""
807
1130
takes_args = ['dir?']
1131
808
1132
def run(self, dir='.'):
809
1133
import bzrlib.check
810
bzrlib.check.check(Branch(dir, find_root=False))
1134
bzrlib.check.check(Branch(dir))
1135
1136
1137
1138
class cmd_upgrade(Command):
1139
"""Upgrade branch storage to current format.
1140
1141
This should normally be used only after the check command tells
1142
you to run it.
1143
"""
1144
takes_args = ['dir?']
1145
1146
def run(self, dir='.'):
1147
from bzrlib.upgrade import upgrade
1148
upgrade(Branch(dir))
811
1149
812
1150
813
1151
826
1164
"""Run internal test suite"""
827
1165
hidden = True
828
1166
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
1167
from bzrlib.selftest import selftest
1168
return int(not selftest())
851
1169
852
1170
853
1171
class cmd_version(Command):
854
"""Show version of bzr"""
1172
"""Show version of bzr."""
855
1173
def run(self):
856
1174
show_version()
857
1175
858
1176
def show_version():
859
1177
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1178
# is bzrlib itself in a branch?
1179
bzrrev = bzrlib.get_bzr_revision()
1180
if bzrrev:
1181
print " (bzr checkout, revision %d {%s})" % bzrrev
860
1182
print bzrlib.__copyright__
861
1183
print "http://bazaar-ng.org/"
862
1184
print
871
1193
def run(self):
872
1194
print "it sure does!"
873
1195
1196
def parse_spec(spec):
1197
"""
1198
>>> parse_spec(None)
1199
[None, None]
1200
>>> parse_spec("./")
1201
['./', None]
1202
>>> parse_spec("../@")
1203
['..', -1]
1204
>>> parse_spec("../f/@35")
1205
['../f', 35]
1206
"""
1207
if spec is None:
1208
return [None, None]
1209
if '/@' in spec:
1210
parsed = spec.split('/@')
1211
assert len(parsed) == 2
1212
if parsed[1] == "":
1213
parsed[1] = -1
1214
else:
1215
parsed[1] = int(parsed[1])
1216
assert parsed[1] >=0
1217
else:
1218
parsed = [spec, None]
1219
return parsed
1220
1221
1222
1223
class cmd_merge(Command):
1224
"""Perform a three-way merge of trees.
1225
1226
The SPEC parameters are working tree or revision specifiers. Working trees
1227
are specified using standard paths or urls. No component of a directory
1228
path may begin with '@'.
1229
1230
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1231
1232
Revisions are specified using a dirname/@revno pair, where dirname is the
1233
branch directory and revno is the revision within that branch. If no revno
1234
is specified, the latest revision is used.
1235
1236
Revision examples: './@127', 'foo/@', '../@1'
1237
1238
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1239
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1240
as the BASE.
1241
1242
merge refuses to run if there are any uncommitted changes, unless
1243
--force is given.
1244
"""
1245
takes_args = ['other_spec', 'base_spec?']
1246
takes_options = ['force']
1247
1248
def run(self, other_spec, base_spec=None, force=False):
1249
from bzrlib.merge import merge
1250
merge(parse_spec(other_spec), parse_spec(base_spec),
1251
check_clean=(not force))
1252
1253
1254
1255
class cmd_revert(Command):
1256
"""Restore selected files from a previous revision.
1257
"""
1258
takes_args = ['file+']
1259
def run(self, file_list):
1260
from bzrlib.branch import find_branch
1261
1262
if not file_list:
1263
file_list = ['.']
1264
1265
b = find_branch(file_list[0])
1266
1267
b.revert([b.relpath(f) for f in file_list])
1268
1269
1270
class cmd_merge_revert(Command):
1271
"""Reverse all changes since the last commit.
1272
1273
Only versioned files are affected.
1274
1275
TODO: Store backups of any files that will be reverted, so
1276
that the revert can be undone.
1277
"""
1278
takes_options = ['revision']
1279
1280
def run(self, revision=-1):
1281
from bzrlib.merge import merge
1282
merge(('.', revision), parse_spec('.'),
1283
check_clean=False,
1284
ignore_zero=True)
1285
874
1286
875
1287
class cmd_assert_fail(Command):
876
1288
"""Test reporting of assertion failures"""
902
1314
statcache.update_cache(b.base, b.read_working_inventory())
903
1315
904
1316
905
######################################################################
906
# main routine
1317
1318
class cmd_plugins(Command):
1319
"""List plugins"""
1320
hidden = True
1321
def run(self):
1322
import bzrlib.plugin
1323
from pprint import pprint
1324
pprint(bzrlib.plugin.all_plugins)
1325
907
1326
908
1327
909
1328
# list of all available options; the rhs can be either None for an
911
1330
# the type.
912
1331
OPTIONS = {
913
1332
'all': None,
1333
'diff-options': str,
914
1334
'help': None,
915
1335
'file': unicode,
1336
'force': None,
1337
'format': unicode,
1338
'forward': None,
916
1339
'message': unicode,
1340
'no-recurse': None,
917
1341
'profile': None,
918
'revision': int,
1342
'revision': _parse_revision_str,
919
1343
'show-ids': None,
920
1344
'timezone': str,
921
1345
'verbose': None,
922
1346
'version': None,
923
1347
'email': None,
1348
'update': None,
924
1349
}
925
1350
926
1351
SHORT_OPTIONS = {
1352
'F': 'file',
1353
'h': 'help',
927
1354
'm': 'message',
928
'F': 'file',
929
1355
'r': 'revision',
930
1356
'v': 'verbose',
931
1357
}
947
1373
(['status'], {'all': True})
948
1374
>>> parse_args('commit --message=biter'.split())
949
1375
(['commit'], {'message': u'biter'})
1376
>>> parse_args('log -r 500'.split())
1377
(['log'], {'revision': 500})
1378
>>> parse_args('log -r500:600'.split())
1379
(['log'], {'revision': [500, 600]})
1380
>>> parse_args('log -vr500:600'.split())
1381
(['log'], {'verbose': True, 'revision': [500, 600]})
1382
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1383
Traceback (most recent call last):
1384
...
1385
ValueError: invalid literal for int(): v500
950
1386
"""
951
1387
args = []
952
1388
opts = {}
966
1402
else:
967
1403
optname = a[2:]
968
1404
if optname not in OPTIONS:
969
bailout('unknown long option %r' % a)
1405
raise BzrError('unknown long option %r' % a)
970
1406
else:
971
1407
shortopt = a[1:]
972
if shortopt not in SHORT_OPTIONS:
973
bailout('unknown short option %r' % a)
974
optname = SHORT_OPTIONS[shortopt]
1408
if shortopt in SHORT_OPTIONS:
1409
# Multi-character options must have a space to delimit
1410
# their value
1411
optname = SHORT_OPTIONS[shortopt]
1412
else:
1413
# Single character short options, can be chained,
1414
# and have their value appended to their name
1415
shortopt = a[1:2]
1416
if shortopt not in SHORT_OPTIONS:
1417
# We didn't find the multi-character name, and we
1418
# didn't find the single char name
1419
raise BzrError('unknown short option %r' % a)
1420
optname = SHORT_OPTIONS[shortopt]
1421
1422
if a[2:]:
1423
# There are extra things on this option
1424
# see if it is the value, or if it is another
1425
# short option
1426
optargfn = OPTIONS[optname]
1427
if optargfn is None:
1428
# This option does not take an argument, so the
1429
# next entry is another short option, pack it back
1430
# into the list
1431
argv.insert(0, '-' + a[2:])
1432
else:
1433
# This option takes an argument, so pack it
1434
# into the array
1435
optarg = a[2:]
975
1436
976
1437
if optname in opts:
977
1438
# XXX: Do we ever want to support this, e.g. for -r?
978
bailout('repeated option %r' % a)
1439
raise BzrError('repeated option %r' % a)
979
1440
980
1441
optargfn = OPTIONS[optname]
981
1442
if optargfn:
982
1443
if optarg == None:
983
1444
if not argv:
984
bailout('option %r needs an argument' % a)
1445
raise BzrError('option %r needs an argument' % a)
985
1446
else:
986
1447
optarg = argv.pop(0)
987
1448
opts[optname] = optargfn(optarg)
988
1449
else:
989
1450
if optarg != None:
990
bailout('option %r takes no argument' % optname)
1451
raise BzrError('option %r takes no argument' % optname)
991
1452
opts[optname] = True
992
1453
else:
993
1454
args.append(a)
1041
1502
return argdict
1042
1503
1043
1504
1505
def _parse_master_args(argv):
1506
"""Parse the arguments that always go with the original command.
1507
These are things like bzr --no-plugins, etc.
1508
1509
There are now 2 types of option flags. Ones that come *before* the command,
1510
and ones that come *after* the command.
1511
Ones coming *before* the command are applied against all possible commands.
1512
And are generally applied before plugins are loaded.
1513
1514
The current list are:
1515
--builtin Allow plugins to load, but don't let them override builtin commands,
1516
they will still be allowed if they do not override a builtin.
1517
--no-plugins Don't load any plugins. This lets you get back to official source
1518
behavior.
1519
--profile Enable the hotspot profile before running the command.
1520
For backwards compatibility, this is also a non-master option.
1521
--version Spit out the version of bzr that is running and exit.
1522
This is also a non-master option.
1523
--help Run help and exit, also a non-master option (I think that should stay, though)
1524
1525
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1526
Traceback (most recent call last):
1527
...
1528
BzrCommandError: Invalid master option: 'test'
1529
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1530
>>> print argv
1531
['command']
1532
>>> print opts['version']
1533
True
1534
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1535
>>> print argv
1536
['command', '--more-options']
1537
>>> print opts['profile']
1538
True
1539
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1540
>>> print argv
1541
['command']
1542
>>> print opts['no-plugins']
1543
True
1544
>>> print opts['profile']
1545
False
1546
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1547
>>> print argv
1548
['command', '--profile']
1549
>>> print opts['profile']
1550
False
1551
"""
1552
master_opts = {'builtin':False,
1553
'no-plugins':False,
1554
'version':False,
1555
'profile':False,
1556
'help':False
1557
}
1558
1559
# This is the point where we could hook into argv[0] to determine
1560
# what front-end is supposed to be run
1561
# For now, we are just ignoring it.
1562
cmd_name = argv.pop(0)
1563
for arg in argv[:]:
1564
if arg[:2] != '--': # at the first non-option, we return the rest
1565
break
1566
arg = arg[2:] # Remove '--'
1567
if arg not in master_opts:
1568
# We could say that this is not an error, that we should
1569
# just let it be handled by the main section instead
1570
raise BzrCommandError('Invalid master option: %r' % arg)
1571
argv.pop(0) # We are consuming this entry
1572
master_opts[arg] = True
1573
return argv, master_opts
1574
1575
1044
1576
1045
1577
def run_bzr(argv):
1046
1578
"""Execute a command.
1051
1583
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1052
1584
1053
1585
try:
1054
args, opts = parse_args(argv[1:])
1586
# some options like --builtin and --no-plugins have special effects
1587
argv, master_opts = _parse_master_args(argv)
1588
if not master_opts['no-plugins']:
1589
bzrlib.load_plugins()
1590
1591
args, opts = parse_args(argv)
1592
1593
if master_opts['help']:
1594
from bzrlib.help import help
1595
if argv:
1596
help(argv[0])
1597
else:
1598
help()
1599
return 0
1600
1055
1601
if 'help' in opts:
1056
import help
1602
from bzrlib.help import help
1057
1603
if args:
1058
help.help(args[0])
1604
help(args[0])
1059
1605
else:
1060
help.help()
1606
help()
1061
1607
return 0
1062
1608
elif 'version' in opts:
1063
1609
show_version()
1064
1610
return 0
1611
elif args and args[0] == 'builtin':
1612
include_plugins=False
1613
args = args[1:]
1065
1614
cmd = str(args.pop(0))
1066
1615
except IndexError:
1067
1616
import help
1069
1618
return 1
1070
1619
1071
1620
1072
canonical_cmd, cmd_class = get_cmd_class(cmd)
1621
plugins_override = not (master_opts['builtin'])
1622
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1073
1623
1074
# global option
1624
profile = master_opts['profile']
1625
# For backwards compatibility, I would rather stick with --profile being a
1626
# master/global option
1075
1627
if 'profile' in opts:
1076
1628
profile = True
1077
1629
del opts['profile']
1078
else:
1079
profile = False
1080
1630
1081
1631
# check options are reasonable
1082
1632
allowed = cmd_class.takes_options
1113
1663
os.close(pffileno)
1114
1664
os.remove(pfname)
1115
1665
else:
1116
cmdobj = cmd_class(cmdopts, cmdargs).status
1666
return cmd_class(cmdopts, cmdargs).status
1117
1667
1118
1668
1119
1669
def _report_exception(summary, quiet=False):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1