« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 966
- compare with another revision
- download diff
- download tarball
- view history from revision 966
- Committer: Martin Pool
- Date: 2005-07-22 23:32:00 UTC
- Revision ID: mbp@sourcefrog.net-20050722233200-ccdeca985093a9fb
- now needs python 2.4
- update instructions for running selftest
- update instructions for running selftest
- files added:
- bzr-man.py
- bzrlib/selftest
- effbot
- effbot/org
- plugins
- plugins/changeset
- tools
- files removed:
- bzrlib/statcache.py
- files renamed:
- bzrlib/selftest.py => bzrlib/selftest/__init__.py
- bzrlib/whitebox.py => bzrlib/selftest/whitebox.py
- files modified:
- .bzrignore
added
removed
bzrlib/commands.py
19
19
import sys, os
20
20
21
21
import bzrlib
22
from bzrlib.trace import mutter, note, log_error
23
from bzrlib.errors import bailout, BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.osutils import quotefn
25
from bzrlib import Branch, Inventory, InventoryEntry, BZRDIR, \
26
format_date
22
from bzrlib.trace import mutter, note, log_error, warning
23
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
24
from bzrlib.branch import find_branch
25
from bzrlib import BZRDIR
26
27
28
plugin_cmds = {}
29
30
31
def register_command(cmd):
32
"Utility function to help register a command"
33
global plugin_cmds
34
k = cmd.__name__
35
if k.startswith("cmd_"):
36
k_unsquished = _unsquish_command_name(k)
37
else:
38
k_unsquished = k
39
if not plugin_cmds.has_key(k_unsquished):
40
plugin_cmds[k_unsquished] = cmd
41
else:
42
log_error('Two plugins defined the same command: %r' % k)
43
log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
27
44
28
45
29
46
def _squish_command_name(cmd):
34
51
assert cmd.startswith("cmd_")
35
52
return cmd[4:].replace('_','-')
36
53
54
37
55
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' -> ?
56
"""This handles a revision string -> revno.
57
58
This always returns a list. The list will have one element for
59
60
It supports integers directly, but everything else it
61
defers for passing to Branch.get_revision_info()
62
63
>>> _parse_revision_str('234')
64
[234]
65
>>> _parse_revision_str('234..567')
66
[234, 567]
67
>>> _parse_revision_str('..')
68
[None, None]
69
>>> _parse_revision_str('..234')
70
[None, 234]
71
>>> _parse_revision_str('234..')
72
[234, None]
73
>>> _parse_revision_str('234..456..789') # Maybe this should be an error
74
[234, 456, 789]
75
>>> _parse_revision_str('234....789') # Error?
76
[234, None, 789]
77
>>> _parse_revision_str('revid:test@other.com-234234')
78
['revid:test@other.com-234234']
79
>>> _parse_revision_str('revid:test@other.com-234234..revid:test@other.com-234235')
80
['revid:test@other.com-234234', 'revid:test@other.com-234235']
81
>>> _parse_revision_str('revid:test@other.com-234234..23')
82
['revid:test@other.com-234234', 23]
83
>>> _parse_revision_str('date:2005-04-12')
84
['date:2005-04-12']
85
>>> _parse_revision_str('date:2005-04-12 12:24:33')
86
['date:2005-04-12 12:24:33']
87
>>> _parse_revision_str('date:2005-04-12T12:24:33')
88
['date:2005-04-12T12:24:33']
89
>>> _parse_revision_str('date:2005-04-12,12:24:33')
90
['date:2005-04-12,12:24:33']
91
>>> _parse_revision_str('-5..23')
92
[-5, 23]
93
>>> _parse_revision_str('-5')
94
[-5]
95
>>> _parse_revision_str('123a')
96
['123a']
97
>>> _parse_revision_str('abc')
98
['abc']
52
99
"""
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)
100
import re
101
old_format_re = re.compile('\d*:\d*')
102
m = old_format_re.match(revstr)
103
if m:
104
warning('Colon separator for revision numbers is deprecated.'
105
' Use .. instead')
106
revs = []
107
for rev in revstr.split(':'):
108
if rev:
109
revs.append(int(rev))
110
else:
111
revs.append(None)
112
return revs
113
revs = []
114
for x in revstr.split('..'):
115
if not x:
116
revs.append(None)
117
else:
118
try:
119
revs.append(int(x))
120
except ValueError:
121
revs.append(x)
69
122
return revs
70
123
71
def get_all_cmds():
72
"""Return canonical name and class for all registered commands."""
124
125
126
def _get_cmd_dict(plugins_override=True):
127
d = {}
73
128
for k, v in globals().iteritems():
74
129
if k.startswith("cmd_"):
75
yield _unsquish_command_name(k), v
76
77
def get_cmd_class(cmd):
130
d[_unsquish_command_name(k)] = v
131
# If we didn't load plugins, the plugin_cmds dict will be empty
132
if plugins_override:
133
d.update(plugin_cmds)
134
else:
135
d2 = plugin_cmds.copy()
136
d2.update(d)
137
d = d2
138
return d
139
140
141
def get_all_cmds(plugins_override=True):
142
"""Return canonical name and class for all registered commands."""
143
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
144
yield k,v
145
146
147
def get_cmd_class(cmd, plugins_override=True):
78
148
"""Return the canonical name and command class for a command.
79
149
"""
80
150
cmd = str(cmd) # not unicode
81
151
82
152
# first look up this command under the specified name
153
cmds = _get_cmd_dict(plugins_override=plugins_override)
83
154
try:
84
return cmd, globals()[_squish_command_name(cmd)]
155
return cmd, cmds[cmd]
85
156
except KeyError:
86
157
pass
87
158
88
159
# look for any command which claims this as an alias
89
for cmdname, cmdclass in get_all_cmds():
160
for cmdname, cmdclass in cmds.iteritems():
90
161
if cmd in cmdclass.aliases:
91
162
return cmdname, cmdclass
92
163
165
236
import os.path
166
237
bzrpath = os.environ.get('BZRPATH', '')
167
238
168
for dir in bzrpath.split(':'):
239
for dir in bzrpath.split(os.pathsep):
169
240
path = os.path.join(dir, cmd)
170
241
if os.path.isfile(path):
171
242
return ExternalCommand(path)
177
248
def __init__(self, path):
178
249
self.path = path
179
250
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
251
pipe = os.popen('%s --bzr-usage' % path, 'r')
184
252
self.takes_options = pipe.readline().split()
253
254
for opt in self.takes_options:
255
if not opt in OPTIONS:
256
raise BzrError("Unknown option '%s' returned by external command %s"
257
% (opt, path))
258
259
# TODO: Is there any way to check takes_args is valid here?
185
260
self.takes_args = pipe.readline().split()
186
pipe.close()
261
262
if pipe.close() is not None:
263
raise BzrError("Failed funning '%s --bzr-usage'" % path)
187
264
188
265
pipe = os.popen('%s --bzr-help' % path, 'r')
189
266
self.__doc__ = pipe.read()
190
pipe.close()
267
if pipe.close() is not None:
268
raise BzrError("Failed funning '%s --bzr-help'" % path)
191
269
192
270
def __call__(self, options, arguments):
193
271
Command.__init__(self, options, arguments)
200
278
keys = kargs.keys()
201
279
keys.sort()
202
280
for name in keys:
281
optname = name.replace('_','-')
203
282
value = kargs[name]
204
if OPTIONS.has_key(name):
283
if OPTIONS.has_key(optname):
205
284
# it's an option
206
opts.append('--%s' % name)
285
opts.append('--%s' % optname)
207
286
if value is not None and value is not True:
208
287
opts.append(str(value))
209
288
else:
253
332
directory is shown. Otherwise, only the status of the specified
254
333
files or directories is reported. If a directory is given, status
255
334
is reported for everything inside that directory.
335
336
If a revision is specified, the changes since that revision are shown.
256
337
"""
257
338
takes_args = ['file*']
258
takes_options = ['all', 'show-ids']
339
takes_options = ['all', 'show-ids', 'revision']
259
340
aliases = ['st', 'stat']
260
341
261
342
def run(self, all=False, show_ids=False, file_list=None):
262
343
if file_list:
263
b = Branch(file_list[0])
344
b = find_branch(file_list[0])
264
345
file_list = [b.relpath(x) for x in file_list]
265
346
# special case: only one path was given and it's the root
266
347
# of the branch
267
348
if file_list == ['']:
268
349
file_list = None
269
350
else:
270
b = Branch('.')
271
import status
272
status.show_status(b, show_unchanged=all, show_ids=show_ids,
273
specific_files=file_list)
351
b = find_branch('.')
352
353
from bzrlib.status import show_status
354
show_status(b, show_unchanged=all, show_ids=show_ids,
355
specific_files=file_list)
274
356
275
357
276
358
class cmd_cat_revision(Command):
280
362
takes_args = ['revision_id']
281
363
282
364
def run(self, revision_id):
283
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
365
from bzrlib.xml import pack_xml
366
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
284
367
285
368
286
369
class cmd_revno(Command):
288
371
289
372
This is equal to the number of revisions on this branch."""
290
373
def run(self):
291
print Branch('.').revno()
374
print find_branch('.').revno()
375
376
class cmd_revision_info(Command):
377
"""Show revision number and revision id for a given revision identifier.
378
"""
379
hidden = True
380
takes_args = ['revision_info*']
381
takes_options = ['revision']
382
def run(self, revision=None, revision_info_list=None):
383
from bzrlib.branch import find_branch
384
385
revs = []
386
if revision is not None:
387
revs.extend(revision)
388
if revision_info_list is not None:
389
revs.extend(revision_info_list)
390
if len(revs) == 0:
391
raise BzrCommandError('You must supply a revision identifier')
392
393
b = find_branch('.')
394
395
for rev in revs:
396
print '%4d %s' % b.get_revision_info(rev)
292
397
293
398
294
399
class cmd_add(Command):
316
421
takes_options = ['verbose', 'no-recurse']
317
422
318
423
def run(self, file_list, verbose=False, no_recurse=False):
319
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
424
from bzrlib.add import smart_add
425
smart_add(file_list, verbose, not no_recurse)
426
427
428
429
class cmd_mkdir(Command):
430
"""Create a new versioned directory.
431
432
This is equivalent to creating the directory and then adding it.
433
"""
434
takes_args = ['dir+']
435
436
def run(self, dir_list):
437
b = None
438
439
for d in dir_list:
440
os.mkdir(d)
441
if not b:
442
b = find_branch(d)
443
b.add([d], verbose=True)
320
444
321
445
322
446
class cmd_relpath(Command):
325
449
hidden = True
326
450
327
451
def run(self, filename):
328
print Branch(filename).relpath(filename)
452
print find_branch(filename).relpath(filename)
329
453
330
454
331
455
334
458
takes_options = ['revision', 'show-ids']
335
459
336
460
def run(self, revision=None, show_ids=False):
337
b = Branch('.')
461
b = find_branch('.')
338
462
if revision == None:
339
463
inv = b.read_working_inventory()
340
464
else:
341
inv = b.get_revision_inventory(b.lookup_revision(revision))
465
if len(revision) > 1:
466
raise BzrCommandError('bzr inventory --revision takes'
467
' exactly one revision identifier')
468
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
342
469
343
470
for path, entry in inv.entries():
344
471
if show_ids:
357
484
"""
358
485
takes_args = ['source$', 'dest']
359
486
def run(self, source_list, dest):
360
b = Branch('.')
487
b = find_branch('.')
361
488
362
489
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
363
490
379
506
takes_args = ['from_name', 'to_name']
380
507
381
508
def run(self, from_name, to_name):
382
b = Branch('.')
509
b = find_branch('.')
383
510
b.rename_one(b.relpath(from_name), b.relpath(to_name))
384
511
385
512
386
513
514
515
516
class cmd_pull(Command):
517
"""Pull any changes from another branch into the current one.
518
519
If the location is omitted, the last-used location will be used.
520
Both the revision history and the working directory will be
521
updated.
522
523
This command only works on branches that have not diverged. Branches are
524
considered diverged if both branches have had commits without first
525
pulling from the other.
526
527
If branches have diverged, you can use 'bzr merge' to pull the text changes
528
from one into the other.
529
"""
530
takes_args = ['location?']
531
532
def run(self, location=None):
533
from bzrlib.merge import merge
534
import tempfile
535
from shutil import rmtree
536
import errno
537
538
br_to = find_branch('.')
539
stored_loc = None
540
try:
541
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
542
except IOError, e:
543
if e.errno != errno.ENOENT:
544
raise
545
if location is None:
546
if stored_loc is None:
547
raise BzrCommandError("No pull location known or specified.")
548
else:
549
print "Using last location: %s" % stored_loc
550
location = stored_loc
551
cache_root = tempfile.mkdtemp()
552
from bzrlib.branch import DivergedBranches
553
br_from = find_branch(location)
554
location = pull_loc(br_from)
555
old_revno = br_to.revno()
556
try:
557
from branch import find_cached_branch, DivergedBranches
558
br_from = find_cached_branch(location, cache_root)
559
location = pull_loc(br_from)
560
old_revno = br_to.revno()
561
try:
562
br_to.update_revisions(br_from)
563
except DivergedBranches:
564
raise BzrCommandError("These branches have diverged."
565
" Try merge.")
566
567
merge(('.', -1), ('.', old_revno), check_clean=False)
568
if location != stored_loc:
569
br_to.controlfile("x-pull", "wb").write(location + "\n")
570
finally:
571
rmtree(cache_root)
572
573
574
575
class cmd_branch(Command):
576
"""Create a new copy of a branch.
577
578
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
579
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
580
581
To retrieve the branch as of a particular revision, supply the --revision
582
parameter, as in "branch foo/bar -r 5".
583
"""
584
takes_args = ['from_location', 'to_location?']
585
takes_options = ['revision']
586
587
def run(self, from_location, to_location=None, revision=None):
588
import errno
589
from bzrlib.merge import merge
590
from bzrlib.branch import DivergedBranches, NoSuchRevision, \
591
find_cached_branch, Branch
592
from shutil import rmtree
593
from meta_store import CachedStore
594
import tempfile
595
cache_root = tempfile.mkdtemp()
596
597
if revision is None:
598
revision = [None]
599
elif len(revision) > 1:
600
raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
601
602
try:
603
try:
604
br_from = find_cached_branch(from_location, cache_root)
605
except OSError, e:
606
if e.errno == errno.ENOENT:
607
raise BzrCommandError('Source location "%s" does not'
608
' exist.' % to_location)
609
else:
610
raise
611
612
if to_location is None:
613
to_location = os.path.basename(from_location.rstrip("/\\"))
614
615
try:
616
os.mkdir(to_location)
617
except OSError, e:
618
if e.errno == errno.EEXIST:
619
raise BzrCommandError('Target directory "%s" already'
620
' exists.' % to_location)
621
if e.errno == errno.ENOENT:
622
raise BzrCommandError('Parent of "%s" does not exist.' %
623
to_location)
624
else:
625
raise
626
br_to = Branch(to_location, init=True)
627
628
br_to.set_root_id(br_from.get_root_id())
629
630
if revision:
631
if revision[0] is None:
632
revno = br_from.revno()
633
else:
634
revno, rev_id = br_from.get_revision_info(revision[0])
635
try:
636
br_to.update_revisions(br_from, stop_revision=revno)
637
except NoSuchRevision:
638
rmtree(to_location)
639
msg = "The branch %s has no revision %d." % (from_location,
640
revno)
641
raise BzrCommandError(msg)
642
643
merge((to_location, -1), (to_location, 0), this_dir=to_location,
644
check_clean=False, ignore_zero=True)
645
from_location = pull_loc(br_from)
646
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
647
finally:
648
rmtree(cache_root)
649
650
651
def pull_loc(branch):
652
# TODO: Should perhaps just make attribute be 'base' in
653
# RemoteBranch and Branch?
654
if hasattr(branch, "baseurl"):
655
return branch.baseurl
656
else:
657
return branch.base
658
659
660
387
661
class cmd_renames(Command):
388
662
"""Show list of renamed files.
389
663
394
668
takes_args = ['dir?']
395
669
396
670
def run(self, dir='.'):
397
b = Branch(dir)
671
b = find_branch(dir)
398
672
old_inv = b.basis_tree().inventory
399
673
new_inv = b.read_working_inventory()
400
674
411
685
def run(self, branch=None):
412
686
import info
413
687
414
from branch import find_branch
415
688
b = find_branch(branch)
416
689
info.show_info(b)
417
690
426
699
takes_options = ['verbose']
427
700
428
701
def run(self, file_list, verbose=False):
429
b = Branch(file_list[0])
702
b = find_branch(file_list[0])
430
703
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
431
704
432
705
440
713
hidden = True
441
714
takes_args = ['filename']
442
715
def run(self, filename):
443
b = Branch(filename)
716
b = find_branch(filename)
444
717
i = b.inventory.path2id(b.relpath(filename))
445
718
if i == None:
446
bailout("%r is not a versioned file" % filename)
719
raise BzrError("%r is not a versioned file" % filename)
447
720
else:
448
721
print i
449
722
456
729
hidden = True
457
730
takes_args = ['filename']
458
731
def run(self, filename):
459
b = Branch(filename)
732
b = find_branch(filename)
460
733
inv = b.inventory
461
734
fid = inv.path2id(b.relpath(filename))
462
735
if fid == None:
463
bailout("%r is not a versioned file" % filename)
736
raise BzrError("%r is not a versioned file" % filename)
464
737
for fip in inv.get_idpath(fid):
465
738
print fip
466
739
469
742
"""Display list of revision ids on this branch."""
470
743
hidden = True
471
744
def run(self):
472
for patchid in Branch('.').revision_history():
745
for patchid in find_branch('.').revision_history():
473
746
print patchid
474
747
475
748
476
749
class cmd_directories(Command):
477
750
"""Display list of versioned directories in this branch."""
478
751
def run(self):
479
for name, ie in Branch('.').read_working_inventory().directories():
752
for name, ie in find_branch('.').read_working_inventory().directories():
480
753
if name == '':
481
754
print '.'
482
755
else:
497
770
bzr commit -m 'imported project'
498
771
"""
499
772
def run(self):
773
from bzrlib.branch import Branch
500
774
Branch('.', init=True)
501
775
502
776
526
800
527
801
takes_args = ['file*']
528
802
takes_options = ['revision', 'diff-options']
529
aliases = ['di']
803
aliases = ['di', 'dif']
530
804
531
805
def run(self, revision=None, file_list=None, diff_options=None):
532
806
from bzrlib.diff import show_diff
533
from bzrlib import find_branch
534
807
535
808
if file_list:
536
809
b = find_branch(file_list[0])
539
812
# just pointing to top-of-tree
540
813
file_list = None
541
814
else:
542
b = Branch('.')
815
b = find_branch('.')
816
817
# TODO: Make show_diff support taking 2 arguments
818
base_rev = None
819
if revision is not None:
820
if len(revision) != 1:
821
raise BzrCommandError('bzr diff --revision takes exactly one revision identifier')
822
base_rev = revision[0]
543
823
544
show_diff(b, revision, specific_files=file_list,
824
show_diff(b, base_rev, specific_files=file_list,
545
825
external_diff_options=diff_options)
546
826
547
827
554
834
TODO: Show files deleted since a previous revision, or between two revisions.
555
835
"""
556
836
def run(self, show_ids=False):
557
b = Branch('.')
837
b = find_branch('.')
558
838
old = b.basis_tree()
559
839
new = b.working_tree()
560
840
575
855
"""List files modified in working tree."""
576
856
hidden = True
577
857
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
858
from bzrlib.diff import compare_trees
859
860
b = find_branch('.')
861
td = compare_trees(b.basis_tree(), b.working_tree())
862
863
for path, id, kind in td.modified:
864
print path
598
865
599
866
600
867
602
869
"""List files added in working tree."""
603
870
hidden = True
604
871
def run(self):
605
b = Branch('.')
872
b = find_branch('.')
606
873
wt = b.working_tree()
607
874
basis_inv = b.basis_tree().inventory
608
875
inv = wt.inventory
624
891
takes_args = ['filename?']
625
892
def run(self, filename=None):
626
893
"""Print the branch root."""
627
from branch import find_branch
628
894
b = find_branch(filename)
629
895
print getattr(b, 'base', None) or getattr(b, 'baseurl')
630
896
636
902
-r revision requests a specific revision, -r :end or -r begin: are
637
903
also valid.
638
904
905
--message allows you to give a regular expression, which will be evaluated
906
so that only matching entries will be displayed.
907
639
908
TODO: Make --revision support uuid: and hash: [future tag:] notation.
640
909
641
910
"""
642
911
643
912
takes_args = ['filename?']
644
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
913
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision','long', 'message']
645
914
646
915
def run(self, filename=None, timezone='original',
647
916
verbose=False,
648
917
show_ids=False,
649
918
forward=False,
650
revision=None):
651
from bzrlib import show_log, find_branch
919
revision=None,
920
message=None,
921
long=False):
922
from bzrlib.branch import find_branch
923
from bzrlib.log import log_formatter, show_log
652
924
import codecs
653
925
654
926
direction = (forward and 'forward') or 'reverse'
664
936
b = find_branch('.')
665
937
file_id = None
666
938
667
if revision == None:
668
revision = [None, None]
669
elif isinstance(revision, int):
670
revision = [revision, revision]
939
if revision is None:
940
rev1 = None
941
rev2 = None
942
elif len(revision) == 1:
943
rev1 = rev2 = b.get_revision_info(revision[0])[0]
944
elif len(revision) == 2:
945
rev1 = b.get_revision_info(revision[0])[0]
946
rev2 = b.get_revision_info(revision[1])[0]
671
947
else:
672
# pair of revisions?
673
pass
674
675
assert len(revision) == 2
948
raise BzrCommandError('bzr log --revision takes one or two values.')
949
950
if rev1 == 0:
951
rev1 = None
952
if rev2 == 0:
953
rev2 = None
676
954
677
955
mutter('encoding log as %r' % bzrlib.user_encoding)
678
956
680
958
# in e.g. the default C locale.
681
959
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
682
960
683
show_log(b, file_id,
684
show_timezone=timezone,
961
if long:
962
log_format = 'long'
963
else:
964
log_format = 'short'
965
lf = log_formatter(log_format,
966
show_ids=show_ids,
967
to_file=outf,
968
show_timezone=timezone)
969
970
show_log(b,
971
lf,
972
file_id,
685
973
verbose=verbose,
686
show_ids=show_ids,
687
to_file=outf,
688
974
direction=direction,
689
start_revision=revision[0],
690
end_revision=revision[1])
975
start_revision=rev1,
976
end_revision=rev2,
977
search=message)
691
978
692
979
693
980
698
985
hidden = True
699
986
takes_args = ["filename"]
700
987
def run(self, filename):
701
b = Branch(filename)
988
b = find_branch(filename)
702
989
inv = b.read_working_inventory()
703
990
file_id = inv.path2id(b.relpath(filename))
704
991
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
712
999
"""
713
1000
hidden = True
714
1001
def run(self, revision=None, verbose=False):
715
b = Branch('.')
1002
b = find_branch('.')
716
1003
if revision == None:
717
1004
tree = b.working_tree()
718
1005
else:
734
1021
735
1022
736
1023
class cmd_unknowns(Command):
737
"""List unknown files"""
1024
"""List unknown files."""
738
1025
def run(self):
739
for f in Branch('.').unknowns():
1026
from bzrlib.osutils import quotefn
1027
for f in find_branch('.').unknowns():
740
1028
print quotefn(f)
741
1029
742
1030
743
1031
744
1032
class cmd_ignore(Command):
745
"""Ignore a command or pattern
1033
"""Ignore a command or pattern.
746
1034
747
1035
To remove patterns from the ignore list, edit the .bzrignore file.
748
1036
764
1052
from bzrlib.atomicfile import AtomicFile
765
1053
import os.path
766
1054
767
b = Branch('.')
1055
b = find_branch('.')
768
1056
ifn = b.abspath('.bzrignore')
769
1057
770
1058
if os.path.exists(ifn):
804
1092
805
1093
See also: bzr ignore"""
806
1094
def run(self):
807
tree = Branch('.').working_tree()
1095
tree = find_branch('.').working_tree()
808
1096
for path, file_class, kind, file_id in tree.list_files():
809
1097
if file_class != 'I':
810
1098
continue
828
1116
except ValueError:
829
1117
raise BzrCommandError("not a valid revision-number: %r" % revno)
830
1118
831
print Branch('.').lookup_revision(revno)
1119
print find_branch('.').lookup_revision(revno)
832
1120
833
1121
834
1122
class cmd_export(Command):
835
1123
"""Export past revision to destination directory.
836
1124
837
If no revision is specified this exports the last committed revision."""
1125
If no revision is specified this exports the last committed revision.
1126
1127
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1128
given, try to find the format with the extension. If no extension
1129
is found exports to a directory (equivalent to --format=dir).
1130
1131
Root may be the top directory for tar, tgz and tbz2 formats. If none
1132
is given, the top directory will be the root name of the file."""
1133
# TODO: list known exporters
838
1134
takes_args = ['dest']
839
takes_options = ['revision']
840
def run(self, dest, revision=None):
841
b = Branch('.')
842
if revision == None:
843
rh = b.revision_history()[-1]
1135
takes_options = ['revision', 'format', 'root']
1136
def run(self, dest, revision=None, format=None, root=None):
1137
import os.path
1138
b = find_branch('.')
1139
if revision is None:
1140
rev_id = b.last_patch()
844
1141
else:
845
rh = b.lookup_revision(int(revision))
846
t = b.revision_tree(rh)
847
t.export(dest)
1142
if len(revision) != 1:
1143
raise BzrError('bzr export --revision takes exactly 1 argument')
1144
revno, rev_id = b.get_revision_info(revision[0])
1145
t = b.revision_tree(rev_id)
1146
root, ext = os.path.splitext(dest)
1147
if not format:
1148
if ext in (".tar",):
1149
format = "tar"
1150
elif ext in (".gz", ".tgz"):
1151
format = "tgz"
1152
elif ext in (".bz2", ".tbz2"):
1153
format = "tbz2"
1154
else:
1155
format = "dir"
1156
t.export(dest, format, root)
848
1157
849
1158
850
1159
class cmd_cat(Command):
856
1165
def run(self, filename, revision=None):
857
1166
if revision == None:
858
1167
raise BzrCommandError("bzr cat requires a revision number")
859
b = Branch('.')
860
b.print_file(b.relpath(filename), int(revision))
1168
elif len(revision) != 1:
1169
raise BzrCommandError("bzr cat --revision takes exactly one number")
1170
b = find_branch('.')
1171
b.print_file(b.relpath(filename), revision[0])
861
1172
862
1173
863
1174
class cmd_local_time_offset(Command):
884
1195
TODO: Strict commit that fails if there are unknown or deleted files.
885
1196
"""
886
1197
takes_args = ['selected*']
887
takes_options = ['message', 'file', 'verbose']
1198
takes_options = ['message', 'file', 'verbose', 'unchanged']
888
1199
aliases = ['ci', 'checkin']
889
1200
890
def run(self, message=None, file=None, verbose=True, selected_list=None):
891
from bzrlib.commit import commit
1201
def run(self, message=None, file=None, verbose=True, selected_list=None,
1202
unchanged=False):
1203
from bzrlib.errors import PointlessCommit
1204
from bzrlib.osutils import get_text_message
892
1205
893
1206
## Warning: shadows builtin file()
894
1207
if not message and not file:
895
raise BzrCommandError("please specify a commit message",
896
["use either --message or --file"])
1208
import cStringIO
1209
stdout = sys.stdout
1210
catcher = cStringIO.StringIO()
1211
sys.stdout = catcher
1212
cmd_status({"file_list":selected_list}, {})
1213
info = catcher.getvalue()
1214
sys.stdout = stdout
1215
message = get_text_message(info)
1216
1217
if message is None:
1218
raise BzrCommandError("please specify a commit message",
1219
["use either --message or --file"])
897
1220
elif message and file:
898
1221
raise BzrCommandError("please specify either --message or --file")
899
1222
901
1224
import codecs
902
1225
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
903
1226
904
b = Branch('.')
905
commit(b, message, verbose=verbose, specific_files=selected_list)
1227
b = find_branch('.')
1228
1229
try:
1230
b.commit(message, verbose=verbose,
1231
specific_files=selected_list,
1232
allow_pointless=unchanged)
1233
except PointlessCommit:
1234
# FIXME: This should really happen before the file is read in;
1235
# perhaps prepare the commit; get the message; then actually commit
1236
raise BzrCommandError("no changes to commit",
1237
["use --unchanged to commit anyhow"])
906
1238
907
1239
908
1240
class cmd_check(Command):
910
1242
911
1243
This command checks various invariants about the branch storage to
912
1244
detect data corruption or bzr bugs.
913
"""
914
takes_args = ['dir?']
915
def run(self, dir='.'):
916
import bzrlib.check
917
bzrlib.check.check(Branch(dir))
1245
1246
If given the --update flag, it will update some optional fields
1247
to help ensure data consistency.
1248
"""
1249
takes_args = ['dir?']
1250
1251
def run(self, dir='.'):
1252
from bzrlib.check import check
1253
check(find_branch(dir))
1254
1255
1256
1257
class cmd_scan_cache(Command):
1258
hidden = True
1259
def run(self):
1260
from bzrlib.hashcache import HashCache
1261
import os
1262
1263
c = HashCache('.')
1264
c.read()
1265
c.scan()
1266
1267
print '%6d stats' % c.stat_count
1268
print '%6d in hashcache' % len(c._cache)
1269
print '%6d files removed from cache' % c.removed_count
1270
print '%6d hashes updated' % c.update_count
1271
print '%6d files changed too recently to cache' % c.danger_count
1272
1273
if c.needs_write:
1274
c.write()
1275
1276
1277
1278
class cmd_upgrade(Command):
1279
"""Upgrade branch storage to current format.
1280
1281
This should normally be used only after the check command tells
1282
you to run it.
1283
"""
1284
takes_args = ['dir?']
1285
1286
def run(self, dir='.'):
1287
from bzrlib.upgrade import upgrade
1288
upgrade(find_branch(dir))
918
1289
919
1290
920
1291
932
1303
class cmd_selftest(Command):
933
1304
"""Run internal test suite"""
934
1305
hidden = True
935
def run(self):
1306
takes_options = ['verbose']
1307
def run(self, verbose=False):
936
1308
from bzrlib.selftest import selftest
937
if selftest():
938
return 0
939
else:
940
return 1
941
1309
return int(not selftest(verbose=verbose))
942
1310
943
1311
944
1312
class cmd_version(Command):
945
"""Show version of bzr"""
1313
"""Show version of bzr."""
946
1314
def run(self):
947
1315
show_version()
948
1316
976
1344
['..', -1]
977
1345
>>> parse_spec("../f/@35")
978
1346
['../f', 35]
1347
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1348
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
979
1349
"""
980
1350
if spec is None:
981
1351
return [None, None]
985
1355
if parsed[1] == "":
986
1356
parsed[1] = -1
987
1357
else:
988
parsed[1] = int(parsed[1])
989
assert parsed[1] >=0
1358
try:
1359
parsed[1] = int(parsed[1])
1360
except ValueError:
1361
pass # We can allow stuff like ./@revid:blahblahblah
1362
else:
1363
assert parsed[1] >=0
990
1364
else:
991
1365
parsed = [spec, None]
992
1366
return parsed
993
1367
1368
1369
994
1370
class cmd_merge(Command):
995
1371
"""Perform a three-way merge of trees.
996
1372
1009
1385
The OTHER_SPEC parameter is required. If the BASE_SPEC parameter is
1010
1386
not supplied, the common ancestor of OTHER_SPEC the current branch is used
1011
1387
as the BASE.
1388
1389
merge refuses to run if there are any uncommitted changes, unless
1390
--force is given.
1012
1391
"""
1013
1392
takes_args = ['other_spec', 'base_spec?']
1393
takes_options = ['force']
1014
1394
1015
def run(self, other_spec, base_spec=None):
1395
def run(self, other_spec, base_spec=None, force=False):
1016
1396
from bzrlib.merge import merge
1017
merge(parse_spec(other_spec), parse_spec(base_spec))
1397
merge(parse_spec(other_spec), parse_spec(base_spec),
1398
check_clean=(not force))
1399
1018
1400
1019
1401
1020
1402
class cmd_revert(Command):
1403
"""Restore selected files from a previous revision.
1021
1404
"""
1022
Reverse all changes since the last commit. Only versioned files are
1023
affected.
1405
takes_args = ['file+']
1406
def run(self, file_list):
1407
from bzrlib.branch import find_branch
1408
1409
if not file_list:
1410
file_list = ['.']
1411
1412
b = find_branch(file_list[0])
1413
1414
b.revert([b.relpath(f) for f in file_list])
1415
1416
1417
class cmd_merge_revert(Command):
1418
"""Reverse all changes since the last commit.
1419
1420
Only versioned files are affected.
1421
1422
TODO: Store backups of any files that will be reverted, so
1423
that the revert can be undone.
1024
1424
"""
1025
1425
takes_options = ['revision']
1026
1426
1027
def run(self, revision=-1):
1028
merge.merge(('.', revision), parse_spec('.'), no_changes=False,
1029
ignore_zero=True)
1427
def run(self, revision=None):
1428
from bzrlib.merge import merge
1429
if revision is None:
1430
revision = [-1]
1431
elif len(revision) != 1:
1432
raise BzrCommandError('bzr merge-revert --revision takes exactly 1 argument')
1433
merge(('.', revision[0]), parse_spec('.'),
1434
check_clean=False,
1435
ignore_zero=True)
1030
1436
1031
1437
1032
1438
class cmd_assert_fail(Command):
1048
1454
help.help(topic)
1049
1455
1050
1456
1051
class cmd_update_stat_cache(Command):
1052
"""Update stat-cache mapping inodes to SHA-1 hashes.
1053
1054
For testing only."""
1457
1458
1459
class cmd_plugins(Command):
1460
"""List plugins"""
1055
1461
hidden = True
1056
1462
def run(self):
1057
import statcache
1058
b = Branch('.')
1059
statcache.update_cache(b.base, b.read_working_inventory())
1463
import bzrlib.plugin
1464
from inspect import getdoc
1465
from pprint import pprint
1466
for plugin in bzrlib.plugin.all_plugins:
1467
print plugin.__path__[0]
1468
d = getdoc(plugin)
1469
if d:
1470
print '\t', d.split('\n')[0]
1471
1472
#pprint(bzrlib.plugin.all_plugins)
1060
1473
1061
1474
1062
1475
1068
1481
'diff-options': str,
1069
1482
'help': None,
1070
1483
'file': unicode,
1484
'force': None,
1485
'format': unicode,
1071
1486
'forward': None,
1072
1487
'message': unicode,
1073
1488
'no-recurse': None,
1078
1493
'verbose': None,
1079
1494
'version': None,
1080
1495
'email': None,
1496
'unchanged': None,
1497
'update': None,
1498
'long': None,
1499
'root': str,
1081
1500
}
1082
1501
1083
1502
SHORT_OPTIONS = {
1086
1505
'm': 'message',
1087
1506
'r': 'revision',
1088
1507
'v': 'verbose',
1508
'l': 'long',
1089
1509
}
1090
1510
1091
1511
1105
1525
(['status'], {'all': True})
1106
1526
>>> parse_args('commit --message=biter'.split())
1107
1527
(['commit'], {'message': u'biter'})
1528
>>> parse_args('log -r 500'.split())
1529
(['log'], {'revision': [500]})
1530
>>> parse_args('log -r500..600'.split())
1531
(['log'], {'revision': [500, 600]})
1532
>>> parse_args('log -vr500..600'.split())
1533
(['log'], {'verbose': True, 'revision': [500, 600]})
1534
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1535
(['log'], {'revision': ['v500', 600]})
1108
1536
"""
1109
1537
args = []
1110
1538
opts = {}
1124
1552
else:
1125
1553
optname = a[2:]
1126
1554
if optname not in OPTIONS:
1127
bailout('unknown long option %r' % a)
1555
raise BzrError('unknown long option %r' % a)
1128
1556
else:
1129
1557
shortopt = a[1:]
1130
if shortopt not in SHORT_OPTIONS:
1131
bailout('unknown short option %r' % a)
1132
optname = SHORT_OPTIONS[shortopt]
1558
if shortopt in SHORT_OPTIONS:
1559
# Multi-character options must have a space to delimit
1560
# their value
1561
optname = SHORT_OPTIONS[shortopt]
1562
else:
1563
# Single character short options, can be chained,
1564
# and have their value appended to their name
1565
shortopt = a[1:2]
1566
if shortopt not in SHORT_OPTIONS:
1567
# We didn't find the multi-character name, and we
1568
# didn't find the single char name
1569
raise BzrError('unknown short option %r' % a)
1570
optname = SHORT_OPTIONS[shortopt]
1571
1572
if a[2:]:
1573
# There are extra things on this option
1574
# see if it is the value, or if it is another
1575
# short option
1576
optargfn = OPTIONS[optname]
1577
if optargfn is None:
1578
# This option does not take an argument, so the
1579
# next entry is another short option, pack it back
1580
# into the list
1581
argv.insert(0, '-' + a[2:])
1582
else:
1583
# This option takes an argument, so pack it
1584
# into the array
1585
optarg = a[2:]
1133
1586
1134
1587
if optname in opts:
1135
1588
# XXX: Do we ever want to support this, e.g. for -r?
1136
bailout('repeated option %r' % a)
1589
raise BzrError('repeated option %r' % a)
1137
1590
1138
1591
optargfn = OPTIONS[optname]
1139
1592
if optargfn:
1140
1593
if optarg == None:
1141
1594
if not argv:
1142
bailout('option %r needs an argument' % a)
1595
raise BzrError('option %r needs an argument' % a)
1143
1596
else:
1144
1597
optarg = argv.pop(0)
1145
1598
opts[optname] = optargfn(optarg)
1146
1599
else:
1147
1600
if optarg != None:
1148
bailout('option %r takes no argument' % optname)
1601
raise BzrError('option %r takes no argument' % optname)
1149
1602
opts[optname] = True
1150
1603
else:
1151
1604
args.append(a)
1199
1652
return argdict
1200
1653
1201
1654
1655
def _parse_master_args(argv):
1656
"""Parse the arguments that always go with the original command.
1657
These are things like bzr --no-plugins, etc.
1658
1659
There are now 2 types of option flags. Ones that come *before* the command,
1660
and ones that come *after* the command.
1661
Ones coming *before* the command are applied against all possible commands.
1662
And are generally applied before plugins are loaded.
1663
1664
The current list are:
1665
--builtin Allow plugins to load, but don't let them override builtin commands,
1666
they will still be allowed if they do not override a builtin.
1667
--no-plugins Don't load any plugins. This lets you get back to official source
1668
behavior.
1669
--profile Enable the hotspot profile before running the command.
1670
For backwards compatibility, this is also a non-master option.
1671
--version Spit out the version of bzr that is running and exit.
1672
This is also a non-master option.
1673
--help Run help and exit, also a non-master option (I think that should stay, though)
1674
1675
>>> argv, opts = _parse_master_args(['bzr', '--test'])
1676
Traceback (most recent call last):
1677
...
1678
BzrCommandError: Invalid master option: 'test'
1679
>>> argv, opts = _parse_master_args(['bzr', '--version', 'command'])
1680
>>> print argv
1681
['command']
1682
>>> print opts['version']
1683
True
1684
>>> argv, opts = _parse_master_args(['bzr', '--profile', 'command', '--more-options'])
1685
>>> print argv
1686
['command', '--more-options']
1687
>>> print opts['profile']
1688
True
1689
>>> argv, opts = _parse_master_args(['bzr', '--no-plugins', 'command'])
1690
>>> print argv
1691
['command']
1692
>>> print opts['no-plugins']
1693
True
1694
>>> print opts['profile']
1695
False
1696
>>> argv, opts = _parse_master_args(['bzr', 'command', '--profile'])
1697
>>> print argv
1698
['command', '--profile']
1699
>>> print opts['profile']
1700
False
1701
"""
1702
master_opts = {'builtin':False,
1703
'no-plugins':False,
1704
'version':False,
1705
'profile':False,
1706
'help':False
1707
}
1708
1709
# This is the point where we could hook into argv[0] to determine
1710
# what front-end is supposed to be run
1711
# For now, we are just ignoring it.
1712
cmd_name = argv.pop(0)
1713
for arg in argv[:]:
1714
if arg[:2] != '--': # at the first non-option, we return the rest
1715
break
1716
arg = arg[2:] # Remove '--'
1717
if arg not in master_opts:
1718
# We could say that this is not an error, that we should
1719
# just let it be handled by the main section instead
1720
raise BzrCommandError('Invalid master option: %r' % arg)
1721
argv.pop(0) # We are consuming this entry
1722
master_opts[arg] = True
1723
return argv, master_opts
1724
1725
1202
1726
1203
1727
def run_bzr(argv):
1204
1728
"""Execute a command.
1209
1733
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1210
1734
1211
1735
try:
1212
args, opts = parse_args(argv[1:])
1736
# some options like --builtin and --no-plugins have special effects
1737
argv, master_opts = _parse_master_args(argv)
1738
if not master_opts['no-plugins']:
1739
from bzrlib.plugin import load_plugins
1740
load_plugins()
1741
1742
args, opts = parse_args(argv)
1743
1744
if master_opts['help']:
1745
from bzrlib.help import help
1746
if argv:
1747
help(argv[0])
1748
else:
1749
help()
1750
return 0
1751
1213
1752
if 'help' in opts:
1214
import help
1753
from bzrlib.help import help
1215
1754
if args:
1216
help.help(args[0])
1755
help(args[0])
1217
1756
else:
1218
help.help()
1757
help()
1219
1758
return 0
1220
1759
elif 'version' in opts:
1221
1760
show_version()
1222
1761
return 0
1762
elif args and args[0] == 'builtin':
1763
include_plugins=False
1764
args = args[1:]
1223
1765
cmd = str(args.pop(0))
1224
1766
except IndexError:
1225
1767
import help
1227
1769
return 1
1228
1770
1229
1771
1230
canonical_cmd, cmd_class = get_cmd_class(cmd)
1772
plugins_override = not (master_opts['builtin'])
1773
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1231
1774
1232
# global option
1775
profile = master_opts['profile']
1776
# For backwards compatibility, I would rather stick with --profile being a
1777
# master/global option
1233
1778
if 'profile' in opts:
1234
1779
profile = True
1235
1780
del opts['profile']
1236
else:
1237
profile = False
1238
1781
1239
1782
# check options are reasonable
1240
1783
allowed = cmd_class.takes_options
1289
1832
1290
1833
1291
1834
def main(argv):
1292
import errno
1293
1835
1294
bzrlib.open_tracefile(argv)
1836
bzrlib.trace.open_tracefile(argv)
1295
1837
1296
1838
try:
1297
1839
try:
1318
1860
_report_exception('interrupted', quiet=True)
1319
1861
return 2
1320
1862
except Exception, e:
1863
import errno
1321
1864
quiet = False
1322
1865
if (isinstance(e, IOError)
1323
1866
and hasattr(e, 'errno')
Loggerhead is a web-based interface for Breezy
Version: 2.0.1