« back to all changes in this revision
Viewing changes to bzrlib/commands.py
- browse files at revision 690
- compare with another revision
- download diff
- download tarball
- view history from revision 690
- Committer: Martin Pool
- Date: 2005-06-15 04:24:01 UTC
- Revision ID: mbp@sourcefrog.net-20050615042401-02a29d106bece661
add-bzr-to-baz allows multiple arguments
- files added:
- bzrlib/statcache.py
- files removed:
- bzrlib/hashcache.py
- bzrlib/selftest
- effbot
- effbot/org
- plugins
- plugins/changeset
- tools
- files renamed:
- bzrlib/selftest/__init__.py => bzrlib/selftest.py
- bzrlib/selftest/whitebox.py => bzrlib/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, 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__])
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
44
27
45
28
46
29
def _squish_command_name(cmd):
51
34
assert cmd.startswith("cmd_")
52
35
return cmd[4:].replace('_','-')
53
36
54
55
37
def _parse_revision_str(revstr):
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']
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' -> ?
99
52
"""
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)
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)
122
69
return revs
123
70
124
125
126
def _get_cmd_dict(plugins_override=True):
71
def _find_plugins():
72
"""Find all python files which are plugins, and load their commands
73
to add to the list of "all commands"
74
75
The environment variable BZRPATH is considered a delimited set of
76
paths to look through. Each entry is searched for *.py files.
77
If a directory is found, it is also searched, but they are
78
not searched recursively. This allows you to revctl the plugins.
79
80
Inside the plugin should be a series of cmd_* function, which inherit from
81
the bzrlib.commands.Command class.
82
"""
83
bzrpath = os.environ.get('BZRPLUGINPATH', '')
84
85
plugin_cmds = {}
86
if not bzrpath:
87
return plugin_cmds
88
_platform_extensions = {
89
'win32':'.pyd',
90
'cygwin':'.dll',
91
'darwin':'.dylib',
92
'linux2':'.so'
93
}
94
if _platform_extensions.has_key(sys.platform):
95
platform_extension = _platform_extensions[sys.platform]
96
else:
97
platform_extension = None
98
for d in bzrpath.split(os.pathsep):
99
plugin_names = {} # This should really be a set rather than a dict
100
for f in os.listdir(d):
101
if f.endswith('.py'):
102
f = f[:-3]
103
elif f.endswith('.pyc') or f.endswith('.pyo'):
104
f = f[:-4]
105
elif platform_extension and f.endswith(platform_extension):
106
f = f[:-len(platform_extension)]
107
if f.endswidth('module'):
108
f = f[:-len('module')]
109
else:
110
continue
111
if not plugin_names.has_key(f):
112
plugin_names[f] = True
113
114
plugin_names = plugin_names.keys()
115
plugin_names.sort()
116
try:
117
sys.path.insert(0, d)
118
for name in plugin_names:
119
try:
120
old_module = None
121
try:
122
if sys.modules.has_key(name):
123
old_module = sys.modules[name]
124
del sys.modules[name]
125
plugin = __import__(name, locals())
126
for k in dir(plugin):
127
if k.startswith('cmd_'):
128
k_unsquished = _unsquish_command_name(k)
129
if not plugin_cmds.has_key(k_unsquished):
130
plugin_cmds[k_unsquished] = getattr(plugin, k)
131
else:
132
log_error('Two plugins defined the same command: %r' % k)
133
log_error('Not loading the one in %r in dir %r' % (name, d))
134
finally:
135
if old_module:
136
sys.modules[name] = old_module
137
except ImportError, e:
138
log_error('Unable to load plugin: %r from %r\n%s' % (name, d, e))
139
finally:
140
sys.path.pop(0)
141
return plugin_cmds
142
143
def _get_cmd_dict(include_plugins=True):
127
144
d = {}
128
145
for k, v in globals().iteritems():
129
146
if k.startswith("cmd_"):
130
147
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
148
if include_plugins:
149
d.update(_find_plugins())
138
150
return d
139
140
151
141
def get_all_cmds(plugins_override=True):
152
def get_all_cmds(include_plugins=True):
142
153
"""Return canonical name and class for all registered commands."""
143
for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
154
for k, v in _get_cmd_dict(include_plugins=include_plugins).iteritems():
144
155
yield k,v
145
156
146
157
147
def get_cmd_class(cmd, plugins_override=True):
158
def get_cmd_class(cmd,include_plugins=True):
148
159
"""Return the canonical name and command class for a command.
149
160
"""
150
161
cmd = str(cmd) # not unicode
151
162
152
163
# first look up this command under the specified name
153
cmds = _get_cmd_dict(plugins_override=plugins_override)
164
cmds = _get_cmd_dict(include_plugins=include_plugins)
154
165
try:
155
166
return cmd, cmds[cmd]
156
167
except KeyError:
200
211
assert isinstance(arguments, dict)
201
212
cmdargs = options.copy()
202
213
cmdargs.update(arguments)
203
if self.__doc__ == Command.__doc__:
204
from warnings import warn
205
warn("No help message set for %r" % self)
214
assert self.__doc__ != Command.__doc__, \
215
("No help message set for %r" % self)
206
216
self.status = self.run(**cmdargs)
207
if self.status is None:
208
self.status = 0
209
217
210
218
211
219
def run(self):
256
264
257
265
for opt in self.takes_options:
258
266
if not opt in OPTIONS:
259
raise BzrError("Unknown option '%s' returned by external command %s"
260
% (opt, path))
267
bailout("Unknown option '%s' returned by external command %s"
268
% (opt, path))
261
269
262
270
# TODO: Is there any way to check takes_args is valid here?
263
271
self.takes_args = pipe.readline().split()
264
272
265
273
if pipe.close() is not None:
266
raise BzrError("Failed funning '%s --bzr-usage'" % path)
274
bailout("Failed funning '%s --bzr-usage'" % path)
267
275
268
276
pipe = os.popen('%s --bzr-help' % path, 'r')
269
277
self.__doc__ = pipe.read()
270
278
if pipe.close() is not None:
271
raise BzrError("Failed funning '%s --bzr-help'" % path)
279
bailout("Failed funning '%s --bzr-help'" % path)
272
280
273
281
def __call__(self, options, arguments):
274
282
Command.__init__(self, options, arguments)
335
343
directory is shown. Otherwise, only the status of the specified
336
344
files or directories is reported. If a directory is given, status
337
345
is reported for everything inside that directory.
338
339
If a revision is specified, the changes since that revision are shown.
340
346
"""
341
347
takes_args = ['file*']
342
takes_options = ['all', 'show-ids', 'revision']
348
takes_options = ['all', 'show-ids']
343
349
aliases = ['st', 'stat']
344
350
345
351
def run(self, all=False, show_ids=False, file_list=None):
346
352
if file_list:
347
b = find_branch(file_list[0])
353
b = Branch(file_list[0])
348
354
file_list = [b.relpath(x) for x in file_list]
349
355
# special case: only one path was given and it's the root
350
356
# of the branch
351
357
if file_list == ['']:
352
358
file_list = None
353
359
else:
354
b = find_branch('.')
355
356
from bzrlib.status import show_status
357
show_status(b, show_unchanged=all, show_ids=show_ids,
358
specific_files=file_list)
360
b = Branch('.')
361
import status
362
status.show_status(b, show_unchanged=all, show_ids=show_ids,
363
specific_files=file_list)
359
364
360
365
361
366
class cmd_cat_revision(Command):
365
370
takes_args = ['revision_id']
366
371
367
372
def run(self, revision_id):
368
from bzrlib.xml import pack_xml
369
pack_xml(find_branch('.').get_revision(revision_id), sys.stdout)
373
Branch('.').get_revision(revision_id).write_xml(sys.stdout)
370
374
371
375
372
376
class cmd_revno(Command):
374
378
375
379
This is equal to the number of revisions on this branch."""
376
380
def run(self):
377
print find_branch('.').revno()
378
379
class cmd_revision_info(Command):
380
"""Show revision number and revision id for a given revision identifier.
381
"""
382
hidden = True
383
takes_args = ['revision_info*']
384
takes_options = ['revision']
385
def run(self, revision=None, revision_info_list=None):
386
from bzrlib.branch import find_branch
387
388
revs = []
389
if revision is not None:
390
revs.extend(revision)
391
if revision_info_list is not None:
392
revs.extend(revision_info_list)
393
if len(revs) == 0:
394
raise BzrCommandError('You must supply a revision identifier')
395
396
b = find_branch('.')
397
398
for rev in revs:
399
print '%4d %s' % b.get_revision_info(rev)
381
print Branch('.').revno()
400
382
401
383
402
384
class cmd_add(Command):
412
394
whether already versioned or not, are searched for files or
413
395
subdirectories that are neither versioned or ignored, and these
414
396
are added. This search proceeds recursively into versioned
415
directories. If no names are given '.' is assumed.
397
directories.
416
398
417
Therefore simply saying 'bzr add' will version all files that
399
Therefore simply saying 'bzr add .' will version all files that
418
400
are currently unknown.
419
401
420
402
TODO: Perhaps adding a file whose directly is not versioned should
421
403
recursively add that parent, rather than giving an error?
422
404
"""
423
takes_args = ['file*']
405
takes_args = ['file+']
424
406
takes_options = ['verbose', 'no-recurse']
425
407
426
408
def run(self, file_list, verbose=False, no_recurse=False):
427
from bzrlib.add import smart_add
428
smart_add(file_list, verbose, not no_recurse)
429
430
431
432
class cmd_mkdir(Command):
433
"""Create a new versioned directory.
434
435
This is equivalent to creating the directory and then adding it.
436
"""
437
takes_args = ['dir+']
438
439
def run(self, dir_list):
440
b = None
441
442
for d in dir_list:
443
os.mkdir(d)
444
if not b:
445
b = find_branch(d)
446
b.add([d], verbose=True)
409
bzrlib.add.smart_add(file_list, verbose, not no_recurse)
447
410
448
411
449
412
class cmd_relpath(Command):
452
415
hidden = True
453
416
454
417
def run(self, filename):
455
print find_branch(filename).relpath(filename)
418
print Branch(filename).relpath(filename)
456
419
457
420
458
421
461
424
takes_options = ['revision', 'show-ids']
462
425
463
426
def run(self, revision=None, show_ids=False):
464
b = find_branch('.')
427
b = Branch('.')
465
428
if revision == None:
466
429
inv = b.read_working_inventory()
467
430
else:
468
if len(revision) > 1:
469
raise BzrCommandError('bzr inventory --revision takes'
470
' exactly one revision identifier')
471
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
431
inv = b.get_revision_inventory(b.lookup_revision(revision))
472
432
473
433
for path, entry in inv.entries():
474
434
if show_ids:
487
447
"""
488
448
takes_args = ['source$', 'dest']
489
449
def run(self, source_list, dest):
490
b = find_branch('.')
450
b = Branch('.')
491
451
492
452
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
493
453
509
469
takes_args = ['from_name', 'to_name']
510
470
511
471
def run(self, from_name, to_name):
512
b = find_branch('.')
472
b = Branch('.')
513
473
b.rename_one(b.relpath(from_name), b.relpath(to_name))
514
474
515
475
534
494
535
495
def run(self, location=None):
536
496
from bzrlib.merge import merge
537
import tempfile
538
from shutil import rmtree
539
497
import errno
540
498
541
br_to = find_branch('.')
499
br_to = Branch('.')
542
500
stored_loc = None
543
501
try:
544
502
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
545
503
except IOError, e:
546
if e.errno != errno.ENOENT:
504
if errno == errno.ENOENT:
547
505
raise
548
506
if location is None:
549
if stored_loc is None:
550
raise BzrCommandError("No pull location known or specified.")
551
else:
552
print "Using last location: %s" % stored_loc
553
location = stored_loc
554
cache_root = tempfile.mkdtemp()
555
from bzrlib.branch import DivergedBranches
507
location = stored_loc
508
if location is None:
509
raise BzrCommandError("No pull location known or specified.")
510
from branch import find_branch, DivergedBranches
556
511
br_from = find_branch(location)
557
512
location = pull_loc(br_from)
558
513
old_revno = br_to.revno()
559
514
try:
560
from branch import find_cached_branch, DivergedBranches
561
br_from = find_cached_branch(location, cache_root)
562
location = pull_loc(br_from)
563
old_revno = br_to.revno()
564
try:
565
br_to.update_revisions(br_from)
566
except DivergedBranches:
567
raise BzrCommandError("These branches have diverged."
568
" Try merge.")
569
570
merge(('.', -1), ('.', old_revno), check_clean=False)
571
if location != stored_loc:
572
br_to.controlfile("x-pull", "wb").write(location + "\n")
573
finally:
574
rmtree(cache_root)
515
br_to.update_revisions(br_from)
516
except DivergedBranches:
517
raise BzrCommandError("These branches have diverged. Try merge.")
518
519
merge(('.', -1), ('.', old_revno), check_clean=False)
520
if location != stored_loc:
521
br_to.controlfile("x-pull", "wb").write(location + "\n")
575
522
576
523
577
524
590
537
def run(self, from_location, to_location=None, revision=None):
591
538
import errno
592
539
from bzrlib.merge import merge
593
from bzrlib.branch import DivergedBranches, NoSuchRevision, \
594
find_cached_branch, Branch
540
from branch import find_branch, DivergedBranches, NoSuchRevision
595
541
from shutil import rmtree
596
from meta_store import CachedStore
597
import tempfile
598
cache_root = tempfile.mkdtemp()
599
600
if revision is None:
601
revision = [None]
602
elif len(revision) > 1:
603
raise BzrCommandError('bzr branch --revision takes exactly 1 revision value')
604
605
try:
606
try:
607
br_from = find_cached_branch(from_location, cache_root)
608
except OSError, e:
609
if e.errno == errno.ENOENT:
610
raise BzrCommandError('Source location "%s" does not'
611
' exist.' % to_location)
612
else:
613
raise
614
615
if to_location is None:
616
to_location = os.path.basename(from_location.rstrip("/\\"))
617
618
try:
619
os.mkdir(to_location)
620
except OSError, e:
621
if e.errno == errno.EEXIST:
622
raise BzrCommandError('Target directory "%s" already'
623
' exists.' % to_location)
624
if e.errno == errno.ENOENT:
625
raise BzrCommandError('Parent of "%s" does not exist.' %
626
to_location)
627
else:
628
raise
629
br_to = Branch(to_location, init=True)
630
631
br_to.set_root_id(br_from.get_root_id())
632
633
if revision:
634
if revision[0] is None:
635
revno = br_from.revno()
636
else:
637
revno, rev_id = br_from.get_revision_info(revision[0])
638
try:
639
br_to.update_revisions(br_from, stop_revision=revno)
640
except NoSuchRevision:
641
rmtree(to_location)
642
msg = "The branch %s has no revision %d." % (from_location,
643
revno)
644
raise BzrCommandError(msg)
645
646
merge((to_location, -1), (to_location, 0), this_dir=to_location,
647
check_clean=False, ignore_zero=True)
648
from_location = pull_loc(br_from)
649
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
650
finally:
651
rmtree(cache_root)
542
try:
543
br_from = find_branch(from_location)
544
except OSError, e:
545
if e.errno == errno.ENOENT:
546
raise BzrCommandError('Source location "%s" does not exist.' %
547
to_location)
548
else:
549
raise
550
551
if to_location is None:
552
to_location = os.path.basename(from_location.rstrip("/\\"))
553
554
try:
555
os.mkdir(to_location)
556
except OSError, e:
557
if e.errno == errno.EEXIST:
558
raise BzrCommandError('Target directory "%s" already exists.' %
559
to_location)
560
if e.errno == errno.ENOENT:
561
raise BzrCommandError('Parent of "%s" does not exist.' %
562
to_location)
563
else:
564
raise
565
br_to = Branch(to_location, init=True)
566
567
try:
568
br_to.update_revisions(br_from, stop_revision=revision)
569
except NoSuchRevision:
570
rmtree(to_location)
571
msg = "The branch %s has no revision %d." % (from_location,
572
revision)
573
raise BzrCommandError(msg)
574
merge((to_location, -1), (to_location, 0), this_dir=to_location,
575
check_clean=False)
576
from_location = pull_loc(br_from)
577
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
652
578
653
579
654
580
def pull_loc(branch):
671
597
takes_args = ['dir?']
672
598
673
599
def run(self, dir='.'):
674
b = find_branch(dir)
600
b = Branch(dir)
675
601
old_inv = b.basis_tree().inventory
676
602
new_inv = b.read_working_inventory()
677
603
688
614
def run(self, branch=None):
689
615
import info
690
616
617
from branch import find_branch
691
618
b = find_branch(branch)
692
619
info.show_info(b)
693
620
702
629
takes_options = ['verbose']
703
630
704
631
def run(self, file_list, verbose=False):
705
b = find_branch(file_list[0])
632
b = Branch(file_list[0])
706
633
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
707
634
708
635
716
643
hidden = True
717
644
takes_args = ['filename']
718
645
def run(self, filename):
719
b = find_branch(filename)
646
b = Branch(filename)
720
647
i = b.inventory.path2id(b.relpath(filename))
721
648
if i == None:
722
raise BzrError("%r is not a versioned file" % filename)
649
bailout("%r is not a versioned file" % filename)
723
650
else:
724
651
print i
725
652
732
659
hidden = True
733
660
takes_args = ['filename']
734
661
def run(self, filename):
735
b = find_branch(filename)
662
b = Branch(filename)
736
663
inv = b.inventory
737
664
fid = inv.path2id(b.relpath(filename))
738
665
if fid == None:
739
raise BzrError("%r is not a versioned file" % filename)
666
bailout("%r is not a versioned file" % filename)
740
667
for fip in inv.get_idpath(fid):
741
668
print fip
742
669
745
672
"""Display list of revision ids on this branch."""
746
673
hidden = True
747
674
def run(self):
748
for patchid in find_branch('.').revision_history():
675
for patchid in Branch('.').revision_history():
749
676
print patchid
750
677
751
678
752
679
class cmd_directories(Command):
753
680
"""Display list of versioned directories in this branch."""
754
681
def run(self):
755
for name, ie in find_branch('.').read_working_inventory().directories():
682
for name, ie in Branch('.').read_working_inventory().directories():
756
683
if name == '':
757
684
print '.'
758
685
else:
773
700
bzr commit -m 'imported project'
774
701
"""
775
702
def run(self):
776
from bzrlib.branch import Branch
777
703
Branch('.', init=True)
778
704
779
705
807
733
808
734
def run(self, revision=None, file_list=None, diff_options=None):
809
735
from bzrlib.diff import show_diff
736
from bzrlib import find_branch
810
737
811
738
if file_list:
812
739
b = find_branch(file_list[0])
815
742
# just pointing to top-of-tree
816
743
file_list = None
817
744
else:
818
b = find_branch('.')
819
820
# TODO: Make show_diff support taking 2 arguments
821
base_rev = None
822
if revision is not None:
823
if len(revision) != 1:
824
raise BzrCommandError('bzr diff --revision takes exactly one revision identifier')
825
base_rev = revision[0]
745
b = Branch('.')
826
746
827
show_diff(b, base_rev, specific_files=file_list,
747
show_diff(b, revision, specific_files=file_list,
828
748
external_diff_options=diff_options)
829
749
830
750
837
757
TODO: Show files deleted since a previous revision, or between two revisions.
838
758
"""
839
759
def run(self, show_ids=False):
840
b = find_branch('.')
760
b = Branch('.')
841
761
old = b.basis_tree()
842
762
new = b.working_tree()
843
763
858
778
"""List files modified in working tree."""
859
779
hidden = True
860
780
def run(self):
861
from bzrlib.diff import compare_trees
862
863
b = find_branch('.')
864
td = compare_trees(b.basis_tree(), b.working_tree())
865
866
for path, id, kind in td.modified:
867
print path
781
import statcache
782
b = Branch('.')
783
inv = b.read_working_inventory()
784
sc = statcache.update_cache(b, inv)
785
basis = b.basis_tree()
786
basis_inv = basis.inventory
787
788
# We used to do this through iter_entries(), but that's slow
789
# when most of the files are unmodified, as is usually the
790
# case. So instead we iterate by inventory entry, and only
791
# calculate paths as necessary.
792
793
for file_id in basis_inv:
794
cacheentry = sc.get(file_id)
795
if not cacheentry: # deleted
796
continue
797
ie = basis_inv[file_id]
798
if cacheentry[statcache.SC_SHA1] != ie.text_sha1:
799
path = inv.id2path(file_id)
800
print path
868
801
869
802
870
803
872
805
"""List files added in working tree."""
873
806
hidden = True
874
807
def run(self):
875
b = find_branch('.')
808
b = Branch('.')
876
809
wt = b.working_tree()
877
810
basis_inv = b.basis_tree().inventory
878
811
inv = wt.inventory
894
827
takes_args = ['filename?']
895
828
def run(self, filename=None):
896
829
"""Print the branch root."""
830
from branch import find_branch
897
831
b = find_branch(filename)
898
832
print getattr(b, 'base', None) or getattr(b, 'baseurl')
899
833
905
839
-r revision requests a specific revision, -r :end or -r begin: are
906
840
also valid.
907
841
908
--message allows you to give a regular expression, which will be evaluated
909
so that only matching entries will be displayed.
910
911
842
TODO: Make --revision support uuid: and hash: [future tag:] notation.
912
843
913
844
"""
914
845
915
846
takes_args = ['filename?']
916
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision','long', 'message']
847
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision']
917
848
918
849
def run(self, filename=None, timezone='original',
919
850
verbose=False,
920
851
show_ids=False,
921
852
forward=False,
922
revision=None,
923
message=None,
924
long=False):
925
from bzrlib.branch import find_branch
926
from bzrlib.log import log_formatter, show_log
853
revision=None):
854
from bzrlib import show_log, find_branch
927
855
import codecs
928
856
929
857
direction = (forward and 'forward') or 'reverse'
939
867
b = find_branch('.')
940
868
file_id = None
941
869
942
if revision is None:
943
rev1 = None
944
rev2 = None
945
elif len(revision) == 1:
946
rev1 = rev2 = b.get_revision_info(revision[0])[0]
947
elif len(revision) == 2:
948
rev1 = b.get_revision_info(revision[0])[0]
949
rev2 = b.get_revision_info(revision[1])[0]
870
if revision == None:
871
revision = [None, None]
872
elif isinstance(revision, int):
873
revision = [revision, revision]
950
874
else:
951
raise BzrCommandError('bzr log --revision takes one or two values.')
952
953
if rev1 == 0:
954
rev1 = None
955
if rev2 == 0:
956
rev2 = None
875
# pair of revisions?
876
pass
877
878
assert len(revision) == 2
957
879
958
880
mutter('encoding log as %r' % bzrlib.user_encoding)
959
881
961
883
# in e.g. the default C locale.
962
884
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
963
885
964
if long:
965
log_format = 'long'
966
else:
967
log_format = 'short'
968
lf = log_formatter(log_format,
969
show_ids=show_ids,
970
to_file=outf,
971
show_timezone=timezone)
972
973
show_log(b,
974
lf,
975
file_id,
886
show_log(b, file_id,
887
show_timezone=timezone,
976
888
verbose=verbose,
889
show_ids=show_ids,
890
to_file=outf,
977
891
direction=direction,
978
start_revision=rev1,
979
end_revision=rev2,
980
search=message)
892
start_revision=revision[0],
893
end_revision=revision[1])
981
894
982
895
983
896
988
901
hidden = True
989
902
takes_args = ["filename"]
990
903
def run(self, filename):
991
b = find_branch(filename)
904
b = Branch(filename)
992
905
inv = b.read_working_inventory()
993
906
file_id = inv.path2id(b.relpath(filename))
994
907
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1002
915
"""
1003
916
hidden = True
1004
917
def run(self, revision=None, verbose=False):
1005
b = find_branch('.')
918
b = Branch('.')
1006
919
if revision == None:
1007
920
tree = b.working_tree()
1008
921
else:
1026
939
class cmd_unknowns(Command):
1027
940
"""List unknown files."""
1028
941
def run(self):
1029
from bzrlib.osutils import quotefn
1030
for f in find_branch('.').unknowns():
942
for f in Branch('.').unknowns():
1031
943
print quotefn(f)
1032
944
1033
945
1055
967
from bzrlib.atomicfile import AtomicFile
1056
968
import os.path
1057
969
1058
b = find_branch('.')
970
b = Branch('.')
1059
971
ifn = b.abspath('.bzrignore')
1060
972
1061
973
if os.path.exists(ifn):
1095
1007
1096
1008
See also: bzr ignore"""
1097
1009
def run(self):
1098
tree = find_branch('.').working_tree()
1010
tree = Branch('.').working_tree()
1099
1011
for path, file_class, kind, file_id in tree.list_files():
1100
1012
if file_class != 'I':
1101
1013
continue
1119
1031
except ValueError:
1120
1032
raise BzrCommandError("not a valid revision-number: %r" % revno)
1121
1033
1122
print find_branch('.').lookup_revision(revno)
1034
print Branch('.').lookup_revision(revno)
1123
1035
1124
1036
1125
1037
class cmd_export(Command):
1128
1040
If no revision is specified this exports the last committed revision.
1129
1041
1130
1042
Format may be an "exporter" name, such as tar, tgz, tbz2. If none is
1131
given, try to find the format with the extension. If no extension
1132
is found exports to a directory (equivalent to --format=dir).
1133
1134
Root may be the top directory for tar, tgz and tbz2 formats. If none
1135
is given, the top directory will be the root name of the file."""
1043
given, exports to a directory (equivalent to --format=dir)."""
1136
1044
# TODO: list known exporters
1137
1045
takes_args = ['dest']
1138
takes_options = ['revision', 'format', 'root']
1139
def run(self, dest, revision=None, format=None, root=None):
1140
import os.path
1141
b = find_branch('.')
1142
if revision is None:
1143
rev_id = b.last_patch()
1046
takes_options = ['revision', 'format']
1047
def run(self, dest, revision=None, format='dir'):
1048
b = Branch('.')
1049
if revision == None:
1050
rh = b.revision_history()[-1]
1144
1051
else:
1145
if len(revision) != 1:
1146
raise BzrError('bzr export --revision takes exactly 1 argument')
1147
revno, rev_id = b.get_revision_info(revision[0])
1148
t = b.revision_tree(rev_id)
1149
root, ext = os.path.splitext(dest)
1150
if not format:
1151
if ext in (".tar",):
1152
format = "tar"
1153
elif ext in (".gz", ".tgz"):
1154
format = "tgz"
1155
elif ext in (".bz2", ".tbz2"):
1156
format = "tbz2"
1157
else:
1158
format = "dir"
1159
t.export(dest, format, root)
1052
rh = b.lookup_revision(int(revision))
1053
t = b.revision_tree(rh)
1054
t.export(dest, format)
1160
1055
1161
1056
1162
1057
class cmd_cat(Command):
1168
1063
def run(self, filename, revision=None):
1169
1064
if revision == None:
1170
1065
raise BzrCommandError("bzr cat requires a revision number")
1171
elif len(revision) != 1:
1172
raise BzrCommandError("bzr cat --revision takes exactly one number")
1173
b = find_branch('.')
1174
b.print_file(b.relpath(filename), revision[0])
1066
b = Branch('.')
1067
b.print_file(b.relpath(filename), int(revision))
1175
1068
1176
1069
1177
1070
class cmd_local_time_offset(Command):
1198
1091
TODO: Strict commit that fails if there are unknown or deleted files.
1199
1092
"""
1200
1093
takes_args = ['selected*']
1201
takes_options = ['message', 'file', 'verbose', 'unchanged']
1094
takes_options = ['message', 'file', 'verbose']
1202
1095
aliases = ['ci', 'checkin']
1203
1096
1204
def run(self, message=None, file=None, verbose=True, selected_list=None,
1205
unchanged=False):
1206
from bzrlib.errors import PointlessCommit
1207
from bzrlib.osutils import get_text_message
1097
def run(self, message=None, file=None, verbose=True, selected_list=None):
1098
from bzrlib.commit import commit
1208
1099
1209
1100
## Warning: shadows builtin file()
1210
1101
if not message and not file:
1211
import cStringIO
1212
stdout = sys.stdout
1213
catcher = cStringIO.StringIO()
1214
sys.stdout = catcher
1215
cmd_status({"file_list":selected_list}, {})
1216
info = catcher.getvalue()
1217
sys.stdout = stdout
1218
message = get_text_message(info)
1219
1220
if message is None:
1221
raise BzrCommandError("please specify a commit message",
1222
["use either --message or --file"])
1102
raise BzrCommandError("please specify a commit message",
1103
["use either --message or --file"])
1223
1104
elif message and file:
1224
1105
raise BzrCommandError("please specify either --message or --file")
1225
1106
1227
1108
import codecs
1228
1109
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1229
1110
1230
b = find_branch('.')
1231
1232
try:
1233
b.commit(message, verbose=verbose,
1234
specific_files=selected_list,
1235
allow_pointless=unchanged)
1236
except PointlessCommit:
1237
# FIXME: This should really happen before the file is read in;
1238
# perhaps prepare the commit; get the message; then actually commit
1239
raise BzrCommandError("no changes to commit",
1240
["use --unchanged to commit anyhow"])
1111
b = Branch('.')
1112
commit(b, message, verbose=verbose, specific_files=selected_list)
1241
1113
1242
1114
1243
1115
class cmd_check(Command):
1250
1122
to help ensure data consistency.
1251
1123
"""
1252
1124
takes_args = ['dir?']
1253
1254
def run(self, dir='.'):
1255
from bzrlib.check import check
1256
check(find_branch(dir))
1257
1258
1259
1260
class cmd_scan_cache(Command):
1261
hidden = True
1262
def run(self):
1263
from bzrlib.hashcache import HashCache
1264
import os
1265
1266
c = HashCache('.')
1267
c.read()
1268
c.scan()
1269
1270
print '%6d stats' % c.stat_count
1271
print '%6d in hashcache' % len(c._cache)
1272
print '%6d files removed from cache' % c.removed_count
1273
print '%6d hashes updated' % c.update_count
1274
print '%6d files changed too recently to cache' % c.danger_count
1275
1276
if c.needs_write:
1277
c.write()
1278
1279
1280
1281
class cmd_upgrade(Command):
1282
"""Upgrade branch storage to current format.
1283
1284
This should normally be used only after the check command tells
1285
you to run it.
1286
"""
1287
takes_args = ['dir?']
1288
1289
def run(self, dir='.'):
1290
from bzrlib.upgrade import upgrade
1291
upgrade(find_branch(dir))
1125
takes_options = ['update']
1126
1127
def run(self, dir='.', update=False):
1128
import bzrlib.check
1129
bzrlib.check.check(Branch(dir), update=update)
1292
1130
1293
1131
1294
1132
1306
1144
class cmd_selftest(Command):
1307
1145
"""Run internal test suite"""
1308
1146
hidden = True
1309
takes_options = ['verbose']
1310
def run(self, verbose=False):
1147
def run(self):
1311
1148
from bzrlib.selftest import selftest
1312
return int(not selftest(verbose=verbose))
1149
if selftest():
1150
return 0
1151
else:
1152
return 1
1153
1313
1154
1314
1155
1315
1156
class cmd_version(Command):
1347
1188
['..', -1]
1348
1189
>>> parse_spec("../f/@35")
1349
1190
['../f', 35]
1350
>>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
1351
['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
1352
1191
"""
1353
1192
if spec is None:
1354
1193
return [None, None]
1358
1197
if parsed[1] == "":
1359
1198
parsed[1] = -1
1360
1199
else:
1361
try:
1362
parsed[1] = int(parsed[1])
1363
except ValueError:
1364
pass # We can allow stuff like ./@revid:blahblahblah
1365
else:
1366
assert parsed[1] >=0
1200
parsed[1] = int(parsed[1])
1201
assert parsed[1] >=0
1367
1202
else:
1368
1203
parsed = [spec, None]
1369
1204
return parsed
1401
1236
check_clean=(not force))
1402
1237
1403
1238
1404
1405
1239
class cmd_revert(Command):
1406
"""Restore selected files from a previous revision.
1407
"""
1408
takes_args = ['file+']
1409
def run(self, file_list):
1410
from bzrlib.branch import find_branch
1411
1412
if not file_list:
1413
file_list = ['.']
1414
1415
b = find_branch(file_list[0])
1416
1417
b.revert([b.relpath(f) for f in file_list])
1418
1419
1420
class cmd_merge_revert(Command):
1421
1240
"""Reverse all changes since the last commit.
1422
1241
1423
1242
Only versioned files are affected.
1427
1246
"""
1428
1247
takes_options = ['revision']
1429
1248
1430
def run(self, revision=None):
1249
def run(self, revision=-1):
1431
1250
from bzrlib.merge import merge
1432
if revision is None:
1433
revision = [-1]
1434
elif len(revision) != 1:
1435
raise BzrCommandError('bzr merge-revert --revision takes exactly 1 argument')
1436
merge(('.', revision[0]), parse_spec('.'),
1251
merge(('.', revision), parse_spec('.'),
1437
1252
check_clean=False,
1438
1253
ignore_zero=True)
1439
1254
1457
1272
help.help(topic)
1458
1273
1459
1274
1460
1461
1462
class cmd_plugins(Command):
1463
"""List plugins"""
1275
class cmd_update_stat_cache(Command):
1276
"""Update stat-cache mapping inodes to SHA-1 hashes.
1277
1278
For testing only."""
1464
1279
hidden = True
1465
1280
def run(self):
1466
import bzrlib.plugin
1467
from inspect import getdoc
1468
from pprint import pprint
1469
for plugin in bzrlib.plugin.all_plugins:
1470
print plugin.__path__[0]
1471
d = getdoc(plugin)
1472
if d:
1473
print '\t', d.split('\n')[0]
1474
1475
#pprint(bzrlib.plugin.all_plugins)
1281
import statcache
1282
b = Branch('.')
1283
statcache.update_cache(b.base, b.read_working_inventory())
1476
1284
1477
1285
1478
1286
1496
1304
'verbose': None,
1497
1305
'version': None,
1498
1306
'email': None,
1499
'unchanged': None,
1500
1307
'update': None,
1501
'long': None,
1502
'root': str,
1503
1308
}
1504
1309
1505
1310
SHORT_OPTIONS = {
1508
1313
'm': 'message',
1509
1314
'r': 'revision',
1510
1315
'v': 'verbose',
1511
'l': 'long',
1512
1316
}
1513
1317
1514
1318
1529
1333
>>> parse_args('commit --message=biter'.split())
1530
1334
(['commit'], {'message': u'biter'})
1531
1335
>>> parse_args('log -r 500'.split())
1532
(['log'], {'revision': [500]})
1533
>>> parse_args('log -r500..600'.split())
1336
(['log'], {'revision': 500})
1337
>>> parse_args('log -r500:600'.split())
1534
1338
(['log'], {'revision': [500, 600]})
1535
>>> parse_args('log -vr500..600'.split())
1339
>>> parse_args('log -vr500:600'.split())
1536
1340
(['log'], {'verbose': True, 'revision': [500, 600]})
1537
>>> parse_args('log -rv500..600'.split()) #the r takes an argument
1538
(['log'], {'revision': ['v500', 600]})
1341
>>> parse_args('log -rv500:600'.split()) #the r takes an argument
1342
Traceback (most recent call last):
1343
...
1344
ValueError: invalid literal for int(): v500
1539
1345
"""
1540
1346
args = []
1541
1347
opts = {}
1555
1361
else:
1556
1362
optname = a[2:]
1557
1363
if optname not in OPTIONS:
1558
raise BzrError('unknown long option %r' % a)
1364
bailout('unknown long option %r' % a)
1559
1365
else:
1560
1366
shortopt = a[1:]
1561
1367
if shortopt in SHORT_OPTIONS:
1569
1375
if shortopt not in SHORT_OPTIONS:
1570
1376
# We didn't find the multi-character name, and we
1571
1377
# didn't find the single char name
1572
raise BzrError('unknown short option %r' % a)
1378
bailout('unknown short option %r' % a)
1573
1379
optname = SHORT_OPTIONS[shortopt]
1574
1380
1575
1381
if a[2:]:
1589
1395
1590
1396
if optname in opts:
1591
1397
# XXX: Do we ever want to support this, e.g. for -r?
1592
raise BzrError('repeated option %r' % a)
1398
bailout('repeated option %r' % a)
1593
1399
1594
1400
optargfn = OPTIONS[optname]
1595
1401
if optargfn:
1596
1402
if optarg == None:
1597
1403
if not argv:
1598
raise BzrError('option %r needs an argument' % a)
1404
bailout('option %r needs an argument' % a)
1599
1405
else:
1600
1406
optarg = argv.pop(0)
1601
1407
opts[optname] = optargfn(optarg)
1602
1408
else:
1603
1409
if optarg != None:
1604
raise BzrError('option %r takes no argument' % optname)
1410
bailout('option %r takes no argument' % optname)
1605
1411
opts[optname] = True
1606
1412
else:
1607
1413
args.append(a)
1655
1461
return argdict
1656
1462
1657
1463
1658
def _parse_master_args(argv):
1659
"""Parse the arguments that always go with the original command.
1660
These are things like bzr --no-plugins, etc.
1661
1662
There are now 2 types of option flags. Ones that come *before* the command,
1663
and ones that come *after* the command.
1664
Ones coming *before* the command are applied against all possible commands.
1665
And are generally applied before plugins are loaded.
1666
1667
The current list are:
1668
--builtin Allow plugins to load, but don't let them override builtin commands,
1669
they will still be allowed if they do not override a builtin.
1670
--no-plugins Don't load any plugins. This lets you get back to official source
1671
behavior.
1672
--profile Enable the hotspot profile before running the command.
1673
For backwards compatibility, this is also a non-master option.
1674
--version Spit out the version of bzr that is running and exit.
1675
This is also a non-master option.
1676
--help Run help and exit, also a non-master option (I think that should stay, though)
1677
1678
>>> argv, opts = _parse_master_args(['--test'])
1679
Traceback (most recent call last):
1680
...
1681
BzrCommandError: Invalid master option: 'test'
1682
>>> argv, opts = _parse_master_args(['--version', 'command'])
1683
>>> print argv
1684
['command']
1685
>>> print opts['version']
1686
True
1687
>>> argv, opts = _parse_master_args(['--profile', 'command', '--more-options'])
1688
>>> print argv
1689
['command', '--more-options']
1690
>>> print opts['profile']
1691
True
1692
>>> argv, opts = _parse_master_args(['--no-plugins', 'command'])
1693
>>> print argv
1694
['command']
1695
>>> print opts['no-plugins']
1696
True
1697
>>> print opts['profile']
1698
False
1699
>>> argv, opts = _parse_master_args(['command', '--profile'])
1700
>>> print argv
1701
['command', '--profile']
1702
>>> print opts['profile']
1703
False
1704
"""
1705
master_opts = {'builtin':False,
1706
'no-plugins':False,
1707
'version':False,
1708
'profile':False,
1709
'help':False
1710
}
1711
1712
for arg in argv[:]:
1713
if arg[:2] != '--': # at the first non-option, we return the rest
1714
break
1715
arg = arg[2:] # Remove '--'
1716
if arg not in master_opts:
1717
# We could say that this is not an error, that we should
1718
# just let it be handled by the main section instead
1719
raise BzrCommandError('Invalid master option: %r' % arg)
1720
argv.pop(0) # We are consuming this entry
1721
master_opts[arg] = True
1722
return argv, master_opts
1723
1724
1725
1464
1726
1465
def run_bzr(argv):
1727
1466
"""Execute a command.
1728
1467
1729
1468
This is similar to main(), but without all the trappings for
1730
1469
logging and error handling.
1731
1732
argv
1733
The command-line arguments, without the program name.
1734
1735
Returns a command status or raises an exception.
1736
1470
"""
1737
1471
argv = [a.decode(bzrlib.user_encoding) for a in argv]
1738
1739
# some options like --builtin and --no-plugins have special effects
1740
argv, master_opts = _parse_master_args(argv)
1741
if not master_opts['no-plugins']:
1742
from bzrlib.plugin import load_plugins
1743
load_plugins()
1744
1745
args, opts = parse_args(argv)
1746
1747
if master_opts.get('help') or 'help' in opts:
1748
from bzrlib.help import help
1749
if argv:
1750
help(argv[0])
1751
else:
1752
help()
1753
return 0
1754
1755
if 'version' in opts:
1756
show_version()
1757
return 0
1758
1759
if args and args[0] == 'builtin':
1760
include_plugins=False
1761
args = args[1:]
1762
1472
1473
include_plugins=True
1763
1474
try:
1475
args, opts = parse_args(argv[1:])
1476
if 'help' in opts:
1477
import help
1478
if args:
1479
help.help(args[0])
1480
else:
1481
help.help()
1482
return 0
1483
elif 'version' in opts:
1484
show_version()
1485
return 0
1486
elif args and args[0] == 'builtin':
1487
include_plugins=False
1488
args = args[1:]
1764
1489
cmd = str(args.pop(0))
1765
1490
except IndexError:
1766
print >>sys.stderr, "please try 'bzr help' for help"
1491
import help
1492
help.help()
1767
1493
return 1
1768
1769
plugins_override = not (master_opts['builtin'])
1770
canonical_cmd, cmd_class = get_cmd_class(cmd, plugins_override=plugins_override)
1771
1772
profile = master_opts['profile']
1773
# For backwards compatibility, I would rather stick with --profile being a
1774
# master/global option
1494
1495
1496
canonical_cmd, cmd_class = get_cmd_class(cmd,include_plugins=include_plugins)
1497
1498
# global option
1775
1499
if 'profile' in opts:
1776
1500
profile = True
1777
1501
del opts['profile']
1502
else:
1503
profile = False
1778
1504
1779
1505
# check options are reasonable
1780
1506
allowed = cmd_class.takes_options
1829
1555
1830
1556
1831
1557
def main(argv):
1558
import errno
1832
1559
1833
bzrlib.trace.open_tracefile(argv)
1560
bzrlib.open_tracefile(argv)
1834
1561
1835
1562
try:
1836
1563
try:
1837
1564
try:
1838
return run_bzr(argv[1:])
1565
return run_bzr(argv)
1839
1566
finally:
1840
1567
# do this here inside the exception wrappers to catch EPIPE
1841
1568
sys.stdout.flush()
1857
1584
_report_exception('interrupted', quiet=True)
1858
1585
return 2
1859
1586
except Exception, e:
1860
import errno
1861
1587
quiet = False
1862
1588
if (isinstance(e, IOError)
1863
1589
and hasattr(e, 'errno')
Loggerhead is a web-based interface for Breezy
Version: 2.0.1