« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 331
- compare with another revision
- download diff
- download tarball
- view history from revision 331
- Committer: Martin Pool
- Date: 2005-05-03 07:48:54 UTC
- Revision ID: mbp@sourcefrog.net-20050503074854-adb6f9d6382e27a9
- sketchy experiments in bash and zsh completion
- files added:
- bzrlib/tests.py
- files removed:
- bzrlib/atomicfile.py
- patches
- files renamed:
- contrib/bash/bzr.simple => contrib/bash/bzr
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
18
19
import sys, os
17
"""Bazaar-NG -- a free distributed version-control tool
18
http://bazaar-ng.org/
19
20
**WARNING: THIS IS AN UNSTABLE DEVELOPMENT VERSION**
21
22
* Metadata format is not stable yet -- you may need to
23
discard history in the future.
24
25
* Many commands unimplemented or partially implemented.
26
27
* Space-inefficient storage.
28
29
* No merge operators yet.
30
31
Interesting commands:
32
33
bzr help [COMMAND]
34
Show help screen
35
bzr version
36
Show software version/licence/non-warranty.
37
bzr init
38
Start versioning the current directory
39
bzr add FILE...
40
Make files versioned.
41
bzr log
42
Show revision history.
43
bzr rename FROM TO
44
Rename one file.
45
bzr move FROM... DESTDIR
46
Move one or more files to a different directory.
47
bzr diff [FILE...]
48
Show changes from last revision to working copy.
49
bzr commit -m 'MESSAGE'
50
Store current state as new revision.
51
bzr export [-r REVNO] DESTINATION
52
Export the branch state at a previous version.
53
bzr status
54
Show summary of pending changes.
55
bzr remove FILE...
56
Make a file not versioned.
57
bzr info
58
Show statistics about this branch.
59
bzr check
60
Verify history is stored safely.
61
(for more type 'bzr help commands')
62
"""
63
64
65
66
67
import sys, os, time, types, shutil, tempfile, fnmatch, difflib, os.path
68
from sets import Set
69
from pprint import pprint
70
from stat import *
71
from glob import glob
20
72
21
73
import bzrlib
74
from bzrlib.store import ImmutableStore
22
75
from bzrlib.trace import mutter, note, log_error
23
76
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
77
from bzrlib.osutils import quotefn, pumpfile, isdir, isfile
78
from bzrlib.tree import RevisionTree, EmptyTree, WorkingTree, Tree
79
from bzrlib.revision import Revision
80
from bzrlib import Branch, Inventory, InventoryEntry, ScratchBranch, BZRDIR, \
26
81
format_date
27
82
28
29
def _squish_command_name(cmd):
30
return 'cmd_' + cmd.replace('-', '_')
31
32
33
def _unsquish_command_name(cmd):
34
assert cmd.startswith("cmd_")
35
return cmd[4:].replace('_','-')
36
37
def _parse_revision_str(revstr):
38
"""This handles a revision string -> revno.
39
40
There are several possibilities:
41
42
'234' -> 234
43
'234:345' -> [234, 345]
44
':234' -> [None, 234]
45
'234:' -> [234, None]
46
47
In the future we will also support:
48
'uuid:blah-blah-blah' -> ?
49
'hash:blahblahblah' -> ?
50
potentially:
51
'tag:mytag' -> ?
52
"""
53
if revstr.find(':') != -1:
54
revs = revstr.split(':')
55
if len(revs) > 2:
56
raise ValueError('More than 2 pieces not supported for --revision: %r' % revstr)
57
58
if not revs[0]:
59
revs[0] = None
60
else:
61
revs[0] = int(revs[0])
62
63
if not revs[1]:
64
revs[1] = None
65
else:
66
revs[1] = int(revs[1])
67
else:
68
revs = int(revstr)
69
return revs
70
71
def get_all_cmds():
72
"""Return canonical name and class for all registered commands."""
73
for k, v in globals().iteritems():
74
if k.startswith("cmd_"):
75
yield _unsquish_command_name(k), v
83
BZR_DIFF_FORMAT = "## Bazaar-NG diff, format 0 ##\n"
84
BZR_PATCHNAME_FORMAT = 'cset:sha1:%s'
85
86
## standard representation
87
NONE_STRING = '(none)'
88
EMPTY = 'empty'
89
90
91
CMD_ALIASES = {
92
'?': 'help',
93
'ci': 'commit',
94
'checkin': 'commit',
95
'di': 'diff',
96
'st': 'status',
97
'stat': 'status',
98
}
99
76
100
77
101
def get_cmd_class(cmd):
78
"""Return the canonical name and command class for a command.
79
"""
80
cmd = str(cmd) # not unicode
81
82
# first look up this command under the specified name
102
cmd = str(cmd)
103
104
cmd = CMD_ALIASES.get(cmd, cmd)
105
83
106
try:
84
return cmd, globals()[_squish_command_name(cmd)]
107
cmd_class = globals()['cmd_' + cmd.replace('-', '_')]
85
108
except KeyError:
86
pass
87
88
# look for any command which claims this as an alias
89
for cmdname, cmdclass in get_all_cmds():
90
if cmd in cmdclass.aliases:
91
return cmdname, cmdclass
92
93
cmdclass = ExternalCommand.find_command(cmd)
94
if cmdclass:
95
return cmd, cmdclass
96
97
raise BzrCommandError("unknown command %r" % cmd)
98
99
100
class Command(object):
109
raise BzrError("unknown command %r" % cmd)
110
111
return cmd, cmd_class
112
113
114
115
class Command:
101
116
"""Base class for commands.
102
117
103
118
The docstring for an actual command should give a single-line
140
155
This is invoked with the options and arguments bound to
141
156
keyword parameters.
142
157
143
Return 0 or None if the command was successful, or a shell
144
error code if not.
158
Return True if the command was successful, False if not.
145
159
"""
146
return 0
147
148
149
class ExternalCommand(Command):
150
"""Class to wrap external commands.
151
152
We cheat a little here, when get_cmd_class() calls us we actually give it back
153
an object we construct that has the appropriate path, help, options etc for the
154
specified command.
155
156
When run_bzr() tries to instantiate that 'class' it gets caught by the __call__
157
method, which we override to call the Command.__init__ method. That then calls
158
our run method which is pretty straight forward.
159
160
The only wrinkle is that we have to map bzr's dictionary of options and arguments
161
back into command line options and arguments for the script.
162
"""
163
164
def find_command(cls, cmd):
165
import os.path
166
bzrpath = os.environ.get('BZRPATH', '')
167
168
for dir in bzrpath.split(':'):
169
path = os.path.join(dir, cmd)
170
if os.path.isfile(path):
171
return ExternalCommand(path)
172
173
return None
174
175
find_command = classmethod(find_command)
176
177
def __init__(self, path):
178
self.path = path
179
180
# TODO: If either of these fail, we should detect that and
181
# assume that path is not really a bzr plugin after all.
182
183
pipe = os.popen('%s --bzr-usage' % path, 'r')
184
self.takes_options = pipe.readline().split()
185
self.takes_args = pipe.readline().split()
186
pipe.close()
187
188
pipe = os.popen('%s --bzr-help' % path, 'r')
189
self.__doc__ = pipe.read()
190
pipe.close()
191
192
def __call__(self, options, arguments):
193
Command.__init__(self, options, arguments)
194
return self
195
196
def run(self, **kargs):
197
opts = []
198
args = []
199
200
keys = kargs.keys()
201
keys.sort()
202
for name in keys:
203
value = kargs[name]
204
if OPTIONS.has_key(name):
205
# it's an option
206
opts.append('--%s' % name)
207
if value is not None and value is not True:
208
opts.append(str(value))
209
else:
210
# it's an arg, or arg list
211
if type(value) is not list:
212
value = [value]
213
for v in value:
214
if v is not None:
215
args.append(str(v))
216
217
self.status = os.spawnv(os.P_WAIT, self.path, [self.path] + opts + args)
218
return self.status
160
return True
161
219
162
220
163
221
164
class cmd_status(Command):
222
165
"""Display status summary.
223
166
224
This reports on versioned and unknown files, reporting them
225
grouped by state. Possible states are:
226
227
added
228
Versioned in the working copy but not in the previous revision.
229
230
removed
231
Versioned in the previous revision but removed or deleted
232
in the working copy.
233
234
renamed
235
Path of this file changed from the previous revision;
236
the text may also have changed. This includes files whose
237
parent directory was renamed.
238
239
modified
240
Text has changed since the previous revision.
241
242
unchanged
243
Nothing about this file has changed since the previous revision.
244
Only shown with --all.
245
246
unknown
247
Not versioned and not matching an ignore pattern.
248
249
To see ignored files use 'bzr ignored'. For details in the
250
changes to file texts, use 'bzr diff'.
251
252
If no arguments are specified, the status of the entire working
253
directory is shown. Otherwise, only the status of the specified
254
files or directories is reported. If a directory is given, status
255
is reported for everything inside that directory.
167
For each file there is a single line giving its file state and name.
168
The name is that in the current revision unless it is deleted or
169
missing, in which case the old name is shown.
256
170
"""
257
takes_args = ['file*']
258
takes_options = ['all', 'show-ids']
259
aliases = ['st', 'stat']
171
takes_options = ['all']
260
172
261
def run(self, all=False, show_ids=False, file_list=None):
262
if file_list:
263
b = Branch(file_list[0])
264
file_list = [b.relpath(x) for x in file_list]
265
# special case: only one path was given and it's the root
266
# of the branch
267
if file_list == ['']:
268
file_list = None
269
else:
270
b = Branch('.')
271
import status
272
status.show_status(b, show_unchanged=all, show_ids=show_ids,
273
specific_files=file_list)
173
def run(self, all=False):
174
#import bzrlib.status
175
#bzrlib.status.tree_status(Branch('.'))
176
Branch('.').show_status(show_all=all)
274
177
275
178
276
179
class cmd_cat_revision(Command):
313
216
recursively add that parent, rather than giving an error?
314
217
"""
315
218
takes_args = ['file+']
316
takes_options = ['verbose', 'no-recurse']
219
takes_options = ['verbose']
317
220
318
def run(self, file_list, verbose=False, no_recurse=False):
319
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
320
321
322
class cmd_relpath(Command):
221
def run(self, file_list, verbose=False):
222
bzrlib.add.smart_add(file_list, verbose)
223
224
225
def Relpath(Command):
323
226
"""Show path of a file relative to root"""
324
takes_args = ['filename']
325
hidden = True
227
takes_args = ('filename')
326
228
327
def run(self, filename):
328
print Branch(filename).relpath(filename)
229
def run(self):
230
print Branch(self.args['filename']).relpath(filename)
329
231
330
232
331
233
332
234
class cmd_inventory(Command):
333
235
"""Show inventory of the current working copy or a revision."""
334
takes_options = ['revision', 'show-ids']
236
takes_options = ['revision']
335
237
336
def run(self, revision=None, show_ids=False):
238
def run(self, revision=None):
337
239
b = Branch('.')
338
240
if revision == None:
339
241
inv = b.read_working_inventory()
340
242
else:
341
243
inv = b.get_revision_inventory(b.lookup_revision(revision))
342
244
343
for path, entry in inv.entries():
344
if show_ids:
345
print '%-50s %s' % (path, entry.file_id)
346
else:
347
print path
245
for path, entry in inv.iter_entries():
246
print '%-50s %s' % (entry.file_id, path)
348
247
349
248
350
249
class cmd_move(Command):
405
304
406
305
407
306
class cmd_info(Command):
408
"""Show statistical information about a branch."""
409
takes_args = ['branch?']
410
411
def run(self, branch=None):
307
"""Show statistical information for this branch"""
308
def run(self):
412
309
import info
413
414
from branch import find_branch
415
b = find_branch(branch)
416
info.show_info(b)
310
info.show_info(Branch('.'))
417
311
418
312
419
313
class cmd_remove(Command):
467
361
468
362
class cmd_revision_history(Command):
469
363
"""Display list of revision ids on this branch."""
470
hidden = True
471
364
def run(self):
472
365
for patchid in Branch('.').revision_history():
473
366
print patchid
525
418
"""
526
419
527
420
takes_args = ['file*']
528
takes_options = ['revision', 'diff-options']
529
aliases = ['di']
421
takes_options = ['revision']
530
422
531
def run(self, revision=None, file_list=None, diff_options=None):
423
def run(self, revision=None, file_list=None):
532
424
from bzrlib.diff import show_diff
533
from bzrlib import find_branch
534
535
if file_list:
536
b = find_branch(file_list[0])
537
file_list = [b.relpath(f) for f in file_list]
538
if file_list == ['']:
539
# just pointing to top-of-tree
540
file_list = None
541
else:
542
b = Branch('.')
543
425
544
show_diff(b, revision, specific_files=file_list,
545
external_diff_options=diff_options)
546
547
548
426
show_diff(Branch('.'), revision, file_list)
549
427
550
428
551
429
class cmd_deleted(Command):
570
448
else:
571
449
print path
572
450
573
574
class cmd_modified(Command):
575
"""List files modified in working tree."""
576
hidden = True
577
def run(self):
578
import statcache
579
b = Branch('.')
580
inv = b.read_working_inventory()
581
sc = statcache.update_cache(b, inv)
582
basis = b.basis_tree()
583
basis_inv = basis.inventory
584
585
# We used to do this through iter_entries(), but that's slow
586
# when most of the files are unmodified, as is usually the
587
# case. So instead we iterate by inventory entry, and only
588
# calculate paths as necessary.
589
590
for file_id in basis_inv:
591
cacheentry = sc.get(file_id)
592
if not cacheentry: # deleted
593
continue
594
ie = basis_inv[file_id]
595
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
596
path = inv.id2path(file_id)
597
print path
598
599
600
601
class cmd_added(Command):
602
"""List files added in working tree."""
603
hidden = True
604
def run(self):
605
b = Branch('.')
606
wt = b.working_tree()
607
basis_inv = b.basis_tree().inventory
608
inv = wt.inventory
609
for file_id in inv:
610
if file_id in basis_inv:
611
continue
612
path = inv.id2path(file_id)
613
if not os.access(b.abspath(path), os.F_OK):
614
continue
615
print path
616
617
618
619
451
class cmd_root(Command):
620
452
"""Show the tree root directory.
621
453
624
456
takes_args = ['filename?']
625
457
def run(self, filename=None):
626
458
"""Print the branch root."""
627
from branch import find_branch
628
b = find_branch(filename)
629
print getattr(b, 'base', None) or getattr(b, 'baseurl')
459
print bzrlib.branch.find_branch_root(filename)
460
630
461
631
462
632
463
class cmd_log(Command):
633
464
"""Show log of this branch.
634
465
635
To request a range of logs, you can use the command -r begin:end
636
-r revision requests a specific revision, -r :end or -r begin: are
637
also valid.
638
639
TODO: Make --revision support uuid: and hash: [future tag:] notation.
640
466
TODO: Options to show ids; to limit range; etc.
641
467
"""
642
643
takes_args = ['filename?']
644
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
645
646
def run(self, filename=None, timezone='original',
647
verbose=False,
648
show_ids=False,
649
forward=False,
650
revision=None):
651
from bzrlib import show_log, find_branch
652
import codecs
653
654
direction = (forward and 'forward') or 'reverse'
655
656
if filename:
657
b = find_branch(filename)
658
fp = b.relpath(filename)
659
if fp:
660
file_id = b.read_working_inventory().path2id(fp)
661
else:
662
file_id = None # points to branch root
663
else:
664
b = find_branch('.')
665
file_id = None
666
667
if revision == None:
668
revision = [None, None]
669
elif isinstance(revision, int):
670
revision = [revision, revision]
671
else:
672
# pair of revisions?
673
pass
674
675
assert len(revision) == 2
676
677
mutter('encoding log as %r' % bzrlib.user_encoding)
678
679
# use 'replace' so that we don't abort if trying to write out
680
# in e.g. the default C locale.
681
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
682
683
show_log(b, file_id,
684
show_timezone=timezone,
685
verbose=verbose,
686
show_ids=show_ids,
687
to_file=outf,
688
direction=direction,
689
start_revision=revision[0],
690
end_revision=revision[1])
691
692
693
694
class cmd_touching_revisions(Command):
695
"""Return revision-ids which affected a particular file.
696
697
A more user-friendly interface is "bzr log FILE"."""
698
hidden = True
699
takes_args = ["filename"]
700
def run(self, filename):
701
b = Branch(filename)
702
inv = b.read_working_inventory()
703
file_id = inv.path2id(b.relpath(filename))
704
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
705
print "%6d %s" % (revno, what)
468
takes_options = ['timezone', 'verbose']
469
def run(self, timezone='original', verbose=False):
470
Branch('.').write_log(show_timezone=timezone, verbose=verbose)
706
471
707
472
708
473
class cmd_ls(Command):
742
507
743
508
744
509
class cmd_ignore(Command):
745
"""Ignore a command or pattern
746
747
To remove patterns from the ignore list, edit the .bzrignore file.
748
749
If the pattern contains a slash, it is compared to the whole path
750
from the branch root. Otherwise, it is comapred to only the last
751
component of the path.
752
753
Ignore patterns are case-insensitive on case-insensitive systems.
754
755
Note: wildcards must be quoted from the shell on Unix.
756
757
examples:
758
bzr ignore ./Makefile
759
bzr ignore '*.class'
760
"""
510
"""Ignore a command or pattern"""
761
511
takes_args = ['name_pattern']
762
512
763
513
def run(self, name_pattern):
764
from bzrlib.atomicfile import AtomicFile
765
import os.path
766
767
514
b = Branch('.')
768
ifn = b.abspath('.bzrignore')
769
770
if os.path.exists(ifn):
771
f = open(ifn, 'rt')
772
try:
773
igns = f.read().decode('utf-8')
774
finally:
775
f.close()
776
else:
777
igns = ''
778
779
# TODO: If the file already uses crlf-style termination, maybe
780
# we should use that for the newly added lines?
781
782
if igns and igns[-1] != '\n':
783
igns += '\n'
784
igns += name_pattern + '\n'
785
786
try:
787
f = AtomicFile(ifn, 'wt')
788
f.write(igns.encode('utf-8'))
789
f.commit()
790
finally:
791
f.close()
515
516
# XXX: This will fail if it's a hardlink; should use an AtomicFile class.
517
f = open(b.abspath('.bzrignore'), 'at')
518
f.write(name_pattern + '\n')
519
f.close()
792
520
793
521
inv = b.working_tree().inventory
794
522
if inv.path2id('.bzrignore'):
800
528
801
529
802
530
class cmd_ignored(Command):
803
"""List ignored files and the patterns that matched them.
804
805
See also: bzr ignore"""
531
"""List ignored files and the patterns that matched them."""
806
532
def run(self):
807
533
tree = Branch('.').working_tree()
808
534
for path, file_class, kind, file_id in tree.list_files():
818
544
819
545
example:
820
546
bzr lookup-revision 33
821
"""
547
"""
822
548
hidden = True
823
takes_args = ['revno']
824
825
549
def run(self, revno):
826
550
try:
827
551
revno = int(revno)
828
552
except ValueError:
829
raise BzrCommandError("not a valid revision-number: %r" % revno)
830
831
print Branch('.').lookup_revision(revno)
553
raise BzrError("not a valid revision-number: %r" % revno)
554
555
print Branch('.').lookup_revision(revno) or NONE_STRING
556
832
557
833
558
834
559
class cmd_export(Command):
837
562
If no revision is specified this exports the last committed revision."""
838
563
takes_args = ['dest']
839
564
takes_options = ['revision']
840
def run(self, dest, revision=None):
565
def run(self, dest, revno=None):
841
566
b = Branch('.')
842
if revision == None:
843
rh = b.revision_history()[-1]
567
if revno == None:
568
rh = b.revision_history[-1]
844
569
else:
845
rh = b.lookup_revision(int(revision))
570
rh = b.lookup_revision(int(revno))
846
571
t = b.revision_tree(rh)
847
572
t.export(dest)
848
573
871
596
class cmd_commit(Command):
872
597
"""Commit changes into a new revision.
873
598
874
If selected files are specified, only changes to those files are
875
committed. If a directory is specified then its contents are also
876
committed.
877
878
A selected-file commit may fail in some cases where the committed
879
tree would be invalid, such as trying to commit a file in a
880
newly-added directory that is not itself committed.
599
TODO: Commit only selected files.
881
600
882
601
TODO: Run hooks on tree to-be-committed, and after commit.
883
602
884
603
TODO: Strict commit that fails if there are unknown or deleted files.
885
604
"""
886
takes_args = ['selected*']
887
takes_options = ['message', 'file', 'verbose']
888
aliases = ['ci', 'checkin']
889
890
def run(self, message=None, file=None, verbose=True, selected_list=None):
891
from bzrlib.commit import commit
892
893
## Warning: shadows builtin file()
894
if not message and not file:
895
raise BzrCommandError("please specify a commit message",
896
["use either --message or --file"])
897
elif message and file:
898
raise BzrCommandError("please specify either --message or --file")
899
900
if file:
901
import codecs
902
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
903
904
b = Branch('.')
905
commit(b, message, verbose=verbose, specific_files=selected_list)
605
takes_options = ['message', 'verbose']
606
607
def run(self, message=None, verbose=False):
608
if not message:
609
raise BzrCommandError("please specify a commit message")
610
Branch('.').commit(message, verbose=verbose)
906
611
907
612
908
613
class cmd_check(Command):
914
619
takes_args = ['dir?']
915
620
def run(self, dir='.'):
916
621
import bzrlib.check
917
bzrlib.check.check(Branch(dir))
622
bzrlib.check.check(Branch(dir, find_root=False))
918
623
919
624
920
625
933
638
"""Run internal test suite"""
934
639
hidden = True
935
640
def run(self):
936
from bzrlib.selftest import selftest
937
if selftest():
938
return 0
641
failures, tests = 0, 0
642
643
import doctest, bzrlib.store, bzrlib.tests
644
bzrlib.trace.verbose = False
645
646
for m in bzrlib.store, bzrlib.inventory, bzrlib.branch, bzrlib.osutils, \
647
bzrlib.tree, bzrlib.tests, bzrlib.commands, bzrlib.add:
648
mf, mt = doctest.testmod(m)
649
failures += mf
650
tests += mt
651
print '%-40s %3d tests' % (m.__name__, mt),
652
if mf:
653
print '%3d FAILED!' % mf
654
else:
655
print
656
657
print '%-40s %3d tests' % ('total', tests),
658
if failures:
659
print '%3d FAILED!' % failures
939
660
else:
940
return 1
661
print
941
662
942
663
943
664
948
669
949
670
def show_version():
950
671
print "bzr (bazaar-ng) %s" % bzrlib.__version__
951
# is bzrlib itself in a branch?
952
bzrrev = bzrlib.get_bzr_revision()
953
if bzrrev:
954
print " (bzr checkout, revision %d {%s})" % bzrrev
955
672
print bzrlib.__copyright__
956
673
print "http://bazaar-ng.org/"
957
674
print
966
683
def run(self):
967
684
print "it sure does!"
968
685
969
def parse_spec(spec):
970
"""
971
>>> parse_spec(None)
972
[None, None]
973
>>> parse_spec("./")
974
['./', None]
975
>>> parse_spec("../@")
976
['..', -1]
977
>>> parse_spec("../f/@35")
978
['../f', 35]
979
"""
980
if spec is None:
981
return [None, None]
982
if '/@' in spec:
983
parsed = spec.split('/@')
984
assert len(parsed) == 2
985
if parsed[1] == "":
986
parsed[1] = -1
987
else:
988
parsed[1] = int(parsed[1])
989
assert parsed[1] >=0
990
else:
991
parsed = [spec, None]
992
return parsed
993
994
class cmd_merge(Command):
995
"""Perform a three-way merge of trees.
996
997
The SPEC parameters are working tree or revision specifiers. Working trees
998
are specified using standard paths or urls. No component of a directory
999
path may begin with '@'.
1000
1001
Working tree examples: '.', '..', 'foo@', but NOT 'foo/@bar'
1002
1003
Revisions are specified using a dirname/@revno pair, where dirname is the
1004
branch directory and revno is the revision within that branch. If no revno
1005
is specified, the latest revision is used.
1006
1007
Revision examples: './@127', 'foo/@', '../@1'
1008
1009
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1010
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1011
as the BASE.
1012
"""
1013
takes_args = ['other_spec', 'base_spec?']
1014
1015
def run(self, other_spec, base_spec=None):
1016
from bzrlib.merge import merge
1017
merge(parse_spec(other_spec), parse_spec(base_spec))
1018
1019
1020
class cmd_revert(Command):
1021
"""
1022
Reverse all changes since the last commit. Only versioned files are
1023
affected.
1024
"""
1025
takes_options = ['revision']
1026
1027
def run(self, revision=-1):
1028
merge.merge(('.', revision), parse_spec('.'), no_changes=False,
1029
ignore_zero=True)
1030
1031
686
1032
687
class cmd_assert_fail(Command):
1033
688
"""Test reporting of assertion failures"""
1041
696
1042
697
For a list of all available commands, say 'bzr help commands'."""
1043
698
takes_args = ['topic?']
1044
aliases = ['?']
1045
699
1046
700
def run(self, topic=None):
1047
import help
1048
help.help(topic)
1049
1050
1051
class cmd_update_stat_cache(Command):
1052
"""Update stat-cache mapping inodes to SHA-1 hashes.
1053
1054
For testing only."""
1055
hidden = True
1056
def run(self):
1057
import statcache
1058
b = Branch('.')
1059
statcache.update_cache(b.base, b.read_working_inventory())
1060
701
help(topic)
702
703
704
def help(topic=None):
705
if topic == None:
706
print __doc__
707
elif topic == 'commands':
708
help_commands()
709
else:
710
help_on_command(topic)
711
712
713
def help_on_command(cmdname):
714
cmdname = str(cmdname)
715
716
from inspect import getdoc
717
topic, cmdclass = get_cmd_class(cmdname)
718
719
doc = getdoc(cmdclass)
720
if doc == None:
721
raise NotImplementedError("sorry, no detailed help yet for %r" % cmdname)
722
723
if '\n' in doc:
724
short, rest = doc.split('\n', 1)
725
else:
726
short = doc
727
rest = ''
728
729
print 'usage: bzr ' + topic,
730
for aname in cmdclass.takes_args:
731
aname = aname.upper()
732
if aname[-1] in ['$', '+']:
733
aname = aname[:-1] + '...'
734
elif aname[-1] == '?':
735
aname = '[' + aname[:-1] + ']'
736
elif aname[-1] == '*':
737
aname = '[' + aname[:-1] + '...]'
738
print aname,
739
print
740
print short
741
if rest:
742
print rest
743
744
if cmdclass.takes_options:
745
print
746
print 'options:'
747
for on in cmdclass.takes_options:
748
print ' --%s' % on
749
750
751
def help_commands():
752
"""List all commands"""
753
import inspect
754
755
accu = []
756
for k, v in globals().items():
757
if k.startswith('cmd_'):
758
accu.append((k[4:].replace('_','-'), v))
759
accu.sort()
760
for cmdname, cmdclass in accu:
761
if cmdclass.hidden:
762
continue
763
print cmdname
764
help = inspect.getdoc(cmdclass)
765
if help:
766
print " " + help.split('\n', 1)[0]
767
768
769
######################################################################
770
# main routine
1061
771
1062
772
1063
773
# list of all available options; the rhs can be either None for an
1065
775
# the type.
1066
776
OPTIONS = {
1067
777
'all': None,
1068
'diff-options': str,
1069
778
'help': None,
1070
'file': unicode,
1071
'forward': None,
1072
779
'message': unicode,
1073
'no-recurse': None,
1074
780
'profile': None,
1075
'revision': _parse_revision_str,
781
'revision': int,
1076
782
'show-ids': None,
1077
783
'timezone': str,
1078
784
'verbose': None,
1081
787
}
1082
788
1083
789
SHORT_OPTIONS = {
1084
'F': 'file',
1085
'h': 'help',
1086
790
'm': 'message',
1087
791
'r': 'revision',
1088
792
'v': 'verbose',
1206
910
This is similar to main(), but without all the trappings for
1207
911
logging and error handling.
1208
912
"""
913
1209
914
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1210
915
1211
916
try:
1212
917
args, opts = parse_args(argv[1:])
1213
918
if 'help' in opts:
1214
import help
1215
919
if args:
1216
help.help(args[0])
920
help(args[0])
1217
921
else:
1218
help.help()
922
help()
1219
923
return 0
1220
924
elif 'version' in opts:
1221
show_version()
925
cmd_version([], [])
1222
926
return 0
1223
927
cmd = str(args.pop(0))
1224
928
except IndexError:
1225
import help
1226
help.help()
929
log_error('usage: bzr COMMAND')
930
log_error(' try "bzr help"')
1227
931
return 1
1228
1229
932
1230
933
canonical_cmd, cmd_class = get_cmd_class(cmd)
1231
934
1240
943
allowed = cmd_class.takes_options
1241
944
for oname in opts:
1242
945
if oname not in allowed:
1243
raise BzrCommandError("option '--%s' is not allowed for command %r"
946
raise BzrCommandError("option %r is not allowed for command %r"
1244
947
% (oname, cmd))
1245
948
1246
949
# mix arguments and options into one dictionary
1250
953
cmdopts[k.replace('-', '_')] = v
1251
954
1252
955
if profile:
1253
import hotshot, tempfile
956
import hotshot
1254
957
pffileno, pfname = tempfile.mkstemp()
1255
958
try:
1256
959
prof = hotshot.Profile(pfname)
1265
968
## print_stats seems hardcoded to stdout
1266
969
stats.print_stats(20)
1267
970
1268
return ret.status
971
return ret
1269
972
1270
973
finally:
1271
974
os.close(pffileno)
1272
975
os.remove(pfname)
1273
976
else:
1274
return cmd_class(cmdopts, cmdargs).status
1275
1276
1277
def _report_exception(summary, quiet=False):
977
cmdobj = cmd_class(cmdopts, cmdargs) or 0
978
979
980
981
def _report_exception(e, summary, quiet=False):
1278
982
import traceback
1279
983
log_error('bzr: ' + summary)
1280
bzrlib.trace.log_exception()
984
bzrlib.trace.log_exception(e)
1281
985
1282
986
if not quiet:
1283
987
tb = sys.exc_info()[2]
1291
995
def main(argv):
1292
996
import errno
1293
997
1294
bzrlib.open_tracefile(argv)
998
bzrlib.trace.create_tracefile(argv)
1295
999
1296
1000
try:
1297
1001
try:
1298
try:
1299
return run_bzr(argv)
1300
finally:
1301
# do this here inside the exception wrappers to catch EPIPE
1302
sys.stdout.flush()
1002
ret = run_bzr(argv)
1003
# do this here to catch EPIPE
1004
sys.stdout.flush()
1005
return ret
1303
1006
except BzrError, e:
1304
1007
quiet = isinstance(e, (BzrCommandError))
1305
_report_exception('error: ' + e.args[0], quiet=quiet)
1008
_report_exception(e, 'error: ' + e.args[0], quiet=quiet)
1306
1009
if len(e.args) > 1:
1307
1010
for h in e.args[1]:
1308
1011
# some explanation or hints
1312
1015
msg = 'assertion failed'
1313
1016
if str(e):
1314
1017
msg += ': ' + str(e)
1315
_report_exception(msg)
1018
_report_exception(e, msg)
1316
1019
return 2
1317
1020
except KeyboardInterrupt, e:
1318
_report_exception('interrupted', quiet=True)
1021
_report_exception(e, 'interrupted', quiet=True)
1319
1022
return 2
1320
1023
except Exception, e:
1321
1024
quiet = False
1322
if (isinstance(e, IOError)
1323
and hasattr(e, 'errno')
1324
and e.errno == errno.EPIPE):
1025
if isinstance(e, IOError) and e.errno == errno.EPIPE:
1325
1026
quiet = True
1326
1027
msg = 'broken pipe'
1327
1028
else:
1328
1029
msg = str(e).rstrip('\n')
1329
_report_exception(msg, quiet)
1030
_report_exception(e, msg, quiet)
1330
1031
return 2
1331
1032
finally:
1332
1033
bzrlib.trace.close_trace()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1