« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 974.1.8
- compare with another revision
- download diff
- download tarball
- view history from revision 974.1.8
- Committer: Aaron Bentley
- Date: 2005-07-28 18:46:35 UTC
- mto: (1092.1.41) (1185.3.4) (974.1.47)
- mto: This revision was merged to the branch mainline in revision 1020.
- Revision ID: abentley@panoramicfeedback.com-20050728184635-2461268fd9d1e8d1
Added default backups for merge-revert
- files added:
- plugins/changeset
- files removed:
- HACKING
- bzrlib/util
- contrib/emacs
- files renamed:
- bzrlib/util/effbot/ => effbot/
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/plugins/ => plugins/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
import sys
19
import os
18
import sys, os
20
19
21
20
import bzrlib
22
21
from bzrlib.trace import mutter, note
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
splitpath, \
22
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, splitpath, \
25
23
sha_file, appendpath, file_kind
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
28
import bzrlib.errors
29
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
31
from bzrlib.delta import compare_trees
32
from bzrlib.tree import EmptyTree, RevisionTree
33
import bzrlib.xml
34
import bzrlib.ui
35
36
24
from bzrlib.errors import BzrError
37
25
38
26
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
27
## TODO: Maybe include checks for common corruption of newlines, etc?
40
28
41
29
42
# TODO: Some operations like log might retrieve the same revisions
43
# repeatedly to calculate deltas. We could perhaps have a weakref
44
# cache in memory to make this faster.
45
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
48
49
30
50
31
def find_branch(f, **args):
51
32
if f and (f.startswith('http://') or f.startswith('https://')):
108
89
It is not necessary that f exists.
109
90
110
91
Basically we keep looking up until we find the control directory or
111
run into the root. If there isn't one, raises NotBranchError.
112
"""
92
run into the root."""
113
93
if f == None:
114
94
f = os.getcwd()
115
95
elif hasattr(os.path, 'realpath'):
128
108
head, tail = os.path.split(f)
129
109
if head == f:
130
110
# reached the root, whatever that may be
131
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
111
raise BzrError('%r is not in a branch' % orig_f)
132
112
f = head
133
134
135
136
# XXX: move into bzrlib.errors; subclass BzrError
113
137
114
class DivergedBranches(Exception):
138
115
def __init__(self, branch1, branch2):
139
116
self.branch1 = branch1
141
118
Exception.__init__(self, "These branches have diverged.")
142
119
143
120
121
class NoSuchRevision(BzrError):
122
def __init__(self, branch, revision):
123
self.branch = branch
124
self.revision = revision
125
msg = "Branch %s has no revision %d" % (branch, revision)
126
BzrError.__init__(self, msg)
127
128
144
129
######################################################################
145
130
# branch objects
146
131
219
204
self._lock.unlock()
220
205
221
206
207
222
208
def lock_write(self):
223
209
if self._lock_mode:
224
210
if self._lock_mode != 'w':
234
220
self._lock_count = 1
235
221
236
222
223
237
224
def lock_read(self):
238
225
if self._lock_mode:
239
226
assert self._lock_mode in ('r', 'w'), \
246
233
self._lock_mode = 'r'
247
234
self._lock_count = 1
248
235
236
237
249
238
def unlock(self):
250
239
if not self._lock_mode:
251
240
from errors import LockError
258
247
self._lock = None
259
248
self._lock_mode = self._lock_count = None
260
249
250
261
251
def abspath(self, name):
262
252
"""Return absolute filename for something in the branch"""
263
253
return os.path.join(self.base, name)
264
254
255
265
256
def relpath(self, path):
266
257
"""Return path relative to this branch of something inside it.
267
258
268
259
Raises an error if path is not in this branch."""
269
260
return _relpath(self.base, path)
270
261
262
271
263
def controlfilename(self, file_or_path):
272
264
"""Return location relative to branch."""
273
265
if isinstance(file_or_path, basestring):
300
292
else:
301
293
raise BzrError("invalid controlfile mode %r" % mode)
302
294
295
296
303
297
def _make_control(self):
304
298
from bzrlib.inventory import Inventory
299
from bzrlib.xml import pack_xml
305
300
306
301
os.mkdir(self.controlfilename([]))
307
302
self.controlfile('README', 'w').write(
317
312
self.controlfile(f, 'w').write('')
318
313
mutter('created control directory in ' + self.base)
319
314
320
# if we want per-tree root ids then this is the place to set
321
# them; they're not needed for now and so ommitted for
322
# simplicity.
323
f = self.controlfile('inventory','w')
324
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
315
pack_xml(Inventory(gen_root_id()), self.controlfile('inventory','w'))
325
316
326
317
327
318
def _check_format(self):
336
327
# on Windows from Linux and so on. I think it might be better
337
328
# to always make all internal files in unix format.
338
329
fmt = self.controlfile('branch-format', 'r').read()
339
fmt = fmt.replace('\r\n', '\n')
330
fmt.replace('\r\n', '')
340
331
if fmt != BZR_BRANCH_FORMAT:
341
332
raise BzrError('sorry, branch format %r not supported' % fmt,
342
333
['use a different bzr version',
362
353
def read_working_inventory(self):
363
354
"""Read the working inventory."""
364
355
from bzrlib.inventory import Inventory
356
from bzrlib.xml import unpack_xml
357
from time import time
358
before = time()
365
359
self.lock_read()
366
360
try:
367
361
# ElementTree does its own conversion from UTF-8, so open in
368
362
# binary.
369
f = self.controlfile('inventory', 'rb')
370
return bzrlib.xml.serializer_v4.read_inventory(f)
363
inv = unpack_xml(Inventory,
364
self.controlfile('inventory', 'rb'))
365
mutter("loaded inventory of %d items in %f"
366
% (len(inv), time() - before))
367
return inv
371
368
finally:
372
369
self.unlock()
373
370
379
376
will be committed to the next revision.
380
377
"""
381
378
from bzrlib.atomicfile import AtomicFile
379
from bzrlib.xml import pack_xml
382
380
383
381
self.lock_write()
384
382
try:
385
383
f = AtomicFile(self.controlfilename('inventory'), 'wb')
386
384
try:
387
bzrlib.xml.serializer_v4.write_inventory(inv, f)
385
pack_xml(inv, f)
388
386
f.commit()
389
387
finally:
390
388
f.close()
398
396
"""Inventory for the working copy.""")
399
397
400
398
401
def add(self, files, ids=None):
399
def add(self, files, verbose=False, ids=None):
402
400
"""Make files versioned.
403
401
404
Note that the command line normally calls smart_add instead,
405
which can automatically recurse.
402
Note that the command line normally calls smart_add instead.
406
403
407
404
This puts the files in the Added state, so that they will be
408
405
recorded by the next commit.
418
415
TODO: Perhaps have an option to add the ids even if the files do
419
416
not (yet) exist.
420
417
421
TODO: Perhaps yield the ids and paths as they're added.
418
TODO: Perhaps return the ids of the files? But then again it
419
is easy to retrieve them if they're needed.
420
421
TODO: Adding a directory should optionally recurse down and
422
add all non-ignored children. Perhaps do that in a
423
higher-level method.
422
424
"""
425
from bzrlib.textui import show_status
423
426
# TODO: Re-adding a file that is removed in the working copy
424
427
# should probably put it back with the previous ID.
425
428
if isinstance(files, basestring):
460
463
file_id = gen_file_id(f)
461
464
inv.add_path(f, kind=kind, file_id=file_id)
462
465
466
if verbose:
467
print 'added', quotefn(f)
468
463
469
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
464
470
465
471
self._write_inventory(inv)
495
501
is the opposite of add. Removing it is consistent with most
496
502
other tools. Maybe an option.
497
503
"""
504
from bzrlib.textui import show_status
498
505
## TODO: Normalize names
499
506
## TODO: Remove nested loops; better scalability
500
507
if isinstance(files, basestring):
575
582
f.close()
576
583
577
584
578
def get_revision_xml_file(self, revision_id):
579
"""Return XML file object for revision object."""
580
if not revision_id or not isinstance(revision_id, basestring):
581
raise InvalidRevisionId(revision_id)
582
583
self.lock_read()
584
try:
585
try:
586
return self.revision_store[revision_id]
587
except KeyError:
588
raise bzrlib.errors.NoSuchRevision(self, revision_id)
589
finally:
590
self.unlock()
591
592
593
#deprecated
594
get_revision_xml = get_revision_xml_file
595
596
597
585
def get_revision(self, revision_id):
598
586
"""Return the Revision object for a named revision"""
599
xml_file = self.get_revision_xml_file(revision_id)
587
from bzrlib.revision import Revision
588
from bzrlib.xml import unpack_xml
600
589
590
self.lock_read()
601
591
try:
602
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
603
except SyntaxError, e:
604
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
605
[revision_id,
606
str(e)])
592
if not revision_id or not isinstance(revision_id, basestring):
593
raise ValueError('invalid revision-id: %r' % revision_id)
594
r = unpack_xml(Revision, self.revision_store[revision_id])
595
finally:
596
self.unlock()
607
597
608
598
assert r.revision_id == revision_id
609
599
return r
610
611
612
def get_revision_delta(self, revno):
613
"""Return the delta for one revision.
614
615
The delta is relative to its mainline predecessor, or the
616
empty tree for revision 1.
617
"""
618
assert isinstance(revno, int)
619
rh = self.revision_history()
620
if not (1 <= revno <= len(rh)):
621
raise InvalidRevisionNumber(revno)
622
623
# revno is 1-based; list is 0-based
624
625
new_tree = self.revision_tree(rh[revno-1])
626
if revno == 1:
627
old_tree = EmptyTree()
628
else:
629
old_tree = self.revision_tree(rh[revno-2])
630
631
return compare_trees(old_tree, new_tree)
632
633
600
634
601
635
602
def get_revision_sha1(self, revision_id):
640
607
# the revision, (add signatures/remove signatures) and still
641
608
# have all hash pointers stay consistent.
642
609
# But for now, just hash the contents.
643
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
610
return sha_file(self.revision_store[revision_id])
644
611
645
612
646
613
def get_inventory(self, inventory_id):
650
617
parameter which can be either an integer revno or a
651
618
string hash."""
652
619
from bzrlib.inventory import Inventory
653
654
f = self.get_inventory_xml_file(inventory_id)
655
return bzrlib.xml.serializer_v4.read_inventory(f)
656
657
658
def get_inventory_xml(self, inventory_id):
659
"""Get inventory XML as a file object."""
660
return self.inventory_store[inventory_id]
661
662
get_inventory_xml_file = get_inventory_xml
620
from bzrlib.xml import unpack_xml
621
622
return unpack_xml(Inventory, self.inventory_store[inventory_id])
663
623
664
624
665
625
def get_inventory_sha1(self, inventory_id):
666
626
"""Return the sha1 hash of the inventory entry
667
627
"""
668
return sha_file(self.get_inventory_xml(inventory_id))
628
return sha_file(self.inventory_store[inventory_id])
669
629
670
630
671
631
def get_revision_inventory(self, revision_id):
737
697
return r+1, my_history[r]
738
698
return None, None
739
699
700
def enum_history(self, direction):
701
"""Return (revno, revision_id) for history of branch.
702
703
direction
704
'forward' is from earliest to latest
705
'reverse' is from latest to earliest
706
"""
707
rh = self.revision_history()
708
if direction == 'forward':
709
i = 1
710
for rid in rh:
711
yield i, rid
712
i += 1
713
elif direction == 'reverse':
714
i = len(rh)
715
while i > 0:
716
yield i, rh[i-1]
717
i -= 1
718
else:
719
raise ValueError('invalid history direction', direction)
720
740
721
741
722
def revno(self):
742
723
"""Return current revision number for this branch.
757
738
return None
758
739
759
740
760
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
741
def missing_revisions(self, other, stop_revision=None):
761
742
"""
762
743
If self and other have not diverged, return a list of the revisions
763
744
present in other, but missing from self.
796
777
if stop_revision is None:
797
778
stop_revision = other_len
798
779
elif stop_revision > other_len:
799
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
780
raise NoSuchRevision(self, stop_revision)
800
781
801
782
return other_history[self_len:stop_revision]
802
783
803
784
804
785
def update_revisions(self, other, stop_revision=None):
805
786
"""Pull in all new revisions from other branch.
787
788
>>> from bzrlib.commit import commit
789
>>> bzrlib.trace.silent = True
790
>>> br1 = ScratchBranch(files=['foo', 'bar'])
791
>>> br1.add('foo')
792
>>> br1.add('bar')
793
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
794
>>> br2 = ScratchBranch()
795
>>> br2.update_revisions(br1)
796
Added 2 texts.
797
Added 1 inventories.
798
Added 1 revisions.
799
>>> br2.revision_history()
800
[u'REVISION-ID-1']
801
>>> br2.update_revisions(br1)
802
Added 0 texts.
803
Added 0 inventories.
804
Added 0 revisions.
805
>>> br1.text_store.total_size() == br2.text_store.total_size()
806
True
806
807
"""
807
from bzrlib.fetch import greedy_fetch
808
from bzrlib.revision import get_intervening_revisions
809
810
pb = bzrlib.ui.ui_factory.progress_bar()
808
from bzrlib.progress import ProgressBar
809
810
pb = ProgressBar()
811
811
812
pb.update('comparing histories')
812
if stop_revision is None:
813
other_revision = other.last_patch()
814
else:
815
other_revision = other.lookup_revision(stop_revision)
816
count = greedy_fetch(self, other, other_revision, pb)[0]
817
try:
818
revision_ids = self.missing_revisions(other, stop_revision)
819
except DivergedBranches, e:
820
try:
821
revision_ids = get_intervening_revisions(self.last_patch(),
822
other_revision, self)
823
assert self.last_patch() not in revision_ids
824
except bzrlib.errors.NotAncestor:
825
raise e
826
827
self.append_revision(*revision_ids)
828
pb.clear()
829
830
def install_revisions(self, other, revision_ids, pb):
813
revision_ids = self.missing_revisions(other, stop_revision)
814
831
815
if hasattr(other.revision_store, "prefetch"):
832
816
other.revision_store.prefetch(revision_ids)
833
817
if hasattr(other.inventory_store, "prefetch"):
834
inventory_ids = []
835
for rev_id in revision_ids:
836
try:
837
revision = other.get_revision(rev_id).inventory_id
838
inventory_ids.append(revision)
839
except bzrlib.errors.NoSuchRevision:
840
pass
818
inventory_ids = [other.get_revision(r).inventory_id
819
for r in revision_ids]
841
820
other.inventory_store.prefetch(inventory_ids)
842
843
if pb is None:
844
pb = bzrlib.ui.ui_factory.progress_bar()
845
821
846
822
revisions = []
847
823
needed_texts = set()
848
824
i = 0
849
850
failures = set()
851
for i, rev_id in enumerate(revision_ids):
852
pb.update('fetching revision', i+1, len(revision_ids))
853
try:
854
rev = other.get_revision(rev_id)
855
except bzrlib.errors.NoSuchRevision:
856
failures.add(rev_id)
857
continue
858
825
for rev_id in revision_ids:
826
i += 1
827
pb.update('fetching revision', i, len(revision_ids))
828
rev = other.get_revision(rev_id)
859
829
revisions.append(rev)
860
830
inv = other.get_inventory(str(rev.inventory_id))
861
831
for key, entry in inv.iter_entries():
866
836
867
837
pb.clear()
868
838
869
count, cp_fail = self.text_store.copy_multi(other.text_store,
870
needed_texts)
871
#print "Added %d texts." % count
839
count = self.text_store.copy_multi(other.text_store, needed_texts)
840
print "Added %d texts." % count
872
841
inventory_ids = [ f.inventory_id for f in revisions ]
873
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
874
inventory_ids)
875
#print "Added %d inventories." % count
842
count = self.inventory_store.copy_multi(other.inventory_store,
843
inventory_ids)
844
print "Added %d inventories." % count
876
845
revision_ids = [ f.revision_id for f in revisions]
877
878
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
879
revision_ids,
880
permit_failure=True)
881
assert len(cp_fail) == 0
882
return count, failures
883
884
846
count = self.revision_store.copy_multi(other.revision_store,
847
revision_ids)
848
for revision_id in revision_ids:
849
self.append_revision(revision_id)
850
print "Added %d revisions." % count
851
852
885
853
def commit(self, *args, **kw):
886
854
from bzrlib.commit import commit
887
855
commit(self, *args, **kw)
889
857
890
858
def lookup_revision(self, revision):
891
859
"""Return the revision identifier for a given revision information."""
892
revno, info = self._get_revision_info(revision)
860
revno, info = self.get_revision_info(revision)
893
861
return info
894
862
895
896
def revision_id_to_revno(self, revision_id):
897
"""Given a revision id, return its revno"""
898
history = self.revision_history()
899
try:
900
return history.index(revision_id) + 1
901
except ValueError:
902
raise bzrlib.errors.NoSuchRevision(self, revision_id)
903
904
905
863
def get_revision_info(self, revision):
906
864
"""Return (revno, revision id) for revision identifier.
907
865
910
868
revision can also be a string, in which case it is parsed for something like
911
869
'date:' or 'revid:' etc.
912
870
"""
913
revno, rev_id = self._get_revision_info(revision)
914
if revno is None:
915
raise bzrlib.errors.NoSuchRevision(self, revision)
916
return revno, rev_id
917
918
def get_rev_id(self, revno, history=None):
919
"""Find the revision id of the specified revno."""
920
if revno == 0:
921
return None
922
if history is None:
923
history = self.revision_history()
924
elif revno <= 0 or revno > len(history):
925
raise bzrlib.errors.NoSuchRevision(self, revno)
926
return history[revno - 1]
927
928
def _get_revision_info(self, revision):
929
"""Return (revno, revision id) for revision specifier.
930
931
revision can be an integer, in which case it is assumed to be revno
932
(though this will translate negative values into positive ones)
933
revision can also be a string, in which case it is parsed for something
934
like 'date:' or 'revid:' etc.
935
936
A revid is always returned. If it is None, the specifier referred to
937
the null revision. If the revid does not occur in the revision
938
history, revno will be None.
939
"""
940
941
871
if revision is None:
942
872
return 0, None
943
873
revno = None
947
877
pass
948
878
revs = self.revision_history()
949
879
if isinstance(revision, int):
880
if revision == 0:
881
return 0, None
882
# Mabye we should do this first, but we don't need it if revision == 0
950
883
if revision < 0:
951
884
revno = len(revs) + revision + 1
952
885
else:
953
886
revno = revision
954
rev_id = self.get_rev_id(revno, revs)
955
887
elif isinstance(revision, basestring):
956
888
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
957
889
if revision.startswith(prefix):
958
result = func(self, revs, revision)
959
if len(result) > 1:
960
revno, rev_id = result
961
else:
962
revno = result[0]
963
rev_id = self.get_rev_id(revno, revs)
890
revno = func(self, revs, revision)
964
891
break
965
892
else:
966
raise BzrError('No namespace registered for string: %r' %
967
revision)
968
else:
969
raise TypeError('Unhandled revision type %s' % revision)
893
raise BzrError('No namespace registered for string: %r' % revision)
970
894
971
if revno is None:
972
if rev_id is None:
973
raise bzrlib.errors.NoSuchRevision(self, revision)
974
return revno, rev_id
895
if revno is None or revno <= 0 or revno > len(revs):
896
raise BzrError("no such revision %s" % revision)
897
return revno, revs[revno-1]
975
898
976
899
def _namespace_revno(self, revs, revision):
977
900
"""Lookup a revision by revision number"""
978
901
assert revision.startswith('revno:')
979
902
try:
980
return (int(revision[6:]),)
903
return int(revision[6:])
981
904
except ValueError:
982
905
return None
983
906
REVISION_NAMESPACES['revno:'] = _namespace_revno
984
907
985
908
def _namespace_revid(self, revs, revision):
986
909
assert revision.startswith('revid:')
987
rev_id = revision[len('revid:'):]
988
910
try:
989
return revs.index(rev_id) + 1, rev_id
911
return revs.index(revision[6:]) + 1
990
912
except ValueError:
991
return None, rev_id
913
return None
992
914
REVISION_NAMESPACES['revid:'] = _namespace_revid
993
915
994
916
def _namespace_last(self, revs, revision):
996
918
try:
997
919
offset = int(revision[5:])
998
920
except ValueError:
999
return (None,)
921
return None
1000
922
else:
1001
923
if offset <= 0:
1002
924
raise BzrError('You must supply a positive value for --revision last:XXX')
1003
return (len(revs) - offset + 1,)
925
return len(revs) - offset + 1
1004
926
REVISION_NAMESPACES['last:'] = _namespace_last
1005
927
1006
928
def _namespace_tag(self, revs, revision):
1081
1003
# TODO: Handle timezone.
1082
1004
dt = datetime.datetime.fromtimestamp(r.timestamp)
1083
1005
if first >= dt and (last is None or dt >= last):
1084
return (i+1,)
1006
return i+1
1085
1007
else:
1086
1008
for i in range(len(revs)):
1087
1009
r = self.get_revision(revs[i])
1088
1010
# TODO: Handle timezone.
1089
1011
dt = datetime.datetime.fromtimestamp(r.timestamp)
1090
1012
if first <= dt and (last is None or dt <= last):
1091
return (i+1,)
1013
return i+1
1092
1014
REVISION_NAMESPACES['date:'] = _namespace_date
1093
1015
1094
1095
def _namespace_ancestor(self, revs, revision):
1096
from revision import common_ancestor, MultipleRevisionSources
1097
other_branch = find_branch(_trim_namespace('ancestor', revision))
1098
revision_a = self.last_patch()
1099
revision_b = other_branch.last_patch()
1100
for r, b in ((revision_a, self), (revision_b, other_branch)):
1101
if r is None:
1102
raise bzrlib.errors.NoCommits(b)
1103
revision_source = MultipleRevisionSources(self, other_branch)
1104
result = common_ancestor(revision_a, revision_b, revision_source)
1105
try:
1106
revno = self.revision_id_to_revno(result)
1107
except bzrlib.errors.NoSuchRevision:
1108
revno = None
1109
return revno,result
1110
1111
1112
REVISION_NAMESPACES['ancestor:'] = _namespace_ancestor
1113
1114
1016
def revision_tree(self, revision_id):
1115
1017
"""Return Tree for a revision on this branch.
1116
1018
1117
1019
`revision_id` may be None for the null revision, in which case
1118
1020
an `EmptyTree` is returned."""
1021
from bzrlib.tree import EmptyTree, RevisionTree
1119
1022
# TODO: refactor this to use an existing revision object
1120
1023
# so we don't need to read it in twice.
1121
1024
if revision_id == None:
1122
return EmptyTree()
1025
return EmptyTree(self.get_root_id())
1123
1026
else:
1124
1027
inv = self.get_revision_inventory(revision_id)
1125
1028
return RevisionTree(self.text_store, inv)
1136
1039
1137
1040
If there are no revisions yet, return an `EmptyTree`.
1138
1041
"""
1042
from bzrlib.tree import EmptyTree, RevisionTree
1139
1043
r = self.last_patch()
1140
1044
if r == None:
1141
return EmptyTree()
1045
return EmptyTree(self.get_root_id())
1142
1046
else:
1143
1047
return RevisionTree(self.text_store, self.get_revision_inventory(r))
1144
1048
1179
1083
1180
1084
inv.rename(file_id, to_dir_id, to_tail)
1181
1085
1086
print "%s => %s" % (from_rel, to_rel)
1087
1182
1088
from_abs = self.abspath(from_rel)
1183
1089
to_abs = self.abspath(to_rel)
1184
1090
try:
1203
1109
1204
1110
Note that to_name is only the last component of the new name;
1205
1111
this doesn't change the directory.
1206
1207
This returns a list of (from_path, to_path) pairs for each
1208
entry that is moved.
1209
1112
"""
1210
result = []
1211
1113
self.lock_write()
1212
1114
try:
1213
1115
## TODO: Option to move IDs only
1248
1150
for f in from_paths:
1249
1151
name_tail = splitpath(f)[-1]
1250
1152
dest_path = appendpath(to_name, name_tail)
1251
result.append((f, dest_path))
1153
print "%s => %s" % (f, dest_path)
1252
1154
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1253
1155
try:
1254
1156
os.rename(self.abspath(f), self.abspath(dest_path))
1260
1162
finally:
1261
1163
self.unlock()
1262
1164
1263
return result
1264
1265
1165
1266
1166
def revert(self, filenames, old_tree=None, backups=True):
1267
1167
"""Restore selected files to the versions from a previous tree.
1349
1249
self.unlock()
1350
1250
1351
1251
1352
def get_parent(self):
1353
"""Return the parent location of the branch.
1354
1355
This is the default location for push/pull/missing. The usual
1356
pattern is that the user can override it by specifying a
1357
location.
1358
"""
1359
import errno
1360
_locs = ['parent', 'pull', 'x-pull']
1361
for l in _locs:
1362
try:
1363
return self.controlfile(l, 'r').read().strip('\n')
1364
except IOError, e:
1365
if e.errno != errno.ENOENT:
1366
raise
1367
return None
1368
1369
1370
def set_parent(self, url):
1371
# TODO: Maybe delete old location files?
1372
from bzrlib.atomicfile import AtomicFile
1373
self.lock_write()
1374
try:
1375
f = AtomicFile(self.controlfilename('parent'))
1376
try:
1377
f.write(url + '\n')
1378
f.commit()
1379
finally:
1380
f.close()
1381
finally:
1382
self.unlock()
1383
1384
def check_revno(self, revno):
1385
"""\
1386
Check whether a revno corresponds to any revision.
1387
Zero (the NULL revision) is considered valid.
1388
"""
1389
if revno != 0:
1390
self.check_real_revno(revno)
1391
1392
def check_real_revno(self, revno):
1393
"""\
1394
Check whether a revno corresponds to a real revision.
1395
Zero (the NULL revision) is considered invalid
1396
"""
1397
if revno < 1 or revno > self.revno():
1398
raise InvalidRevisionNumber(revno)
1399
1400
1401
1402
1252
1403
1253
class ScratchBranch(Branch):
1404
1254
"""Special test class: a branch that cleans up after itself.
1446
1296
os.rmdir(base)
1447
1297
copytree(self.base, base, symlinks=True)
1448
1298
return ScratchBranch(base=base)
1449
1450
1451
1299
1452
1300
def __del__(self):
1453
1301
self.destroy()
1523
1371
"""Return a new tree-root file id."""
1524
1372
return gen_file_id('TREE_ROOT')
1525
1373
1526
1527
def pull_loc(branch):
1528
# TODO: Should perhaps just make attribute be 'base' in
1529
# RemoteBranch and Branch?
1530
if hasattr(branch, "baseurl"):
1531
return branch.baseurl
1532
else:
1533
return branch.base
1534
1535
1536
def copy_branch(branch_from, to_location, revision=None):
1537
"""Copy branch_from into the existing directory to_location.
1538
1539
revision
1540
If not None, only revisions up to this point will be copied.
1541
The head of the new branch will be that revision.
1542
1543
to_location
1544
The name of a local directory that exists but is empty.
1545
"""
1546
from bzrlib.merge import merge
1547
from bzrlib.branch import Branch
1548
1549
assert isinstance(branch_from, Branch)
1550
assert isinstance(to_location, basestring)
1551
1552
br_to = Branch(to_location, init=True)
1553
br_to.set_root_id(branch_from.get_root_id())
1554
if revision is None:
1555
revno = branch_from.revno()
1556
else:
1557
revno, rev_id = branch_from.get_revision_info(revision)
1558
br_to.update_revisions(branch_from, stop_revision=revno)
1559
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1560
check_clean=False, ignore_zero=True)
1561
1562
from_location = pull_loc(branch_from)
1563
br_to.set_parent(pull_loc(branch_from))
1564
return br_to
1565
1566
def _trim_namespace(namespace, spec):
1567
full_namespace = namespace + ':'
1568
assert spec.startswith(full_namespace)
1569
return spec[len(full_namespace):]
Loggerhead is a web-based interface for Breezy
Version: 2.0.1