« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1013
- compare with another revision
- download diff
- download tarball
- view history from revision 1013
- Committer: Martin Pool
- Date: 2005-08-01 20:16:14 UTC
- Revision ID: mbp@sourcefrog.net-20050801201614-17ee6319ab1c0101
todo
- files added:
- plugins/changeset
- files removed:
- HACKING
- bzrlib/util
- 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
23
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
24
splitpath, \
25
25
sha_file, appendpath, file_kind
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId, \
28
DivergedBranches, NotBranchError
26
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
29
27
from bzrlib.textui import show_status
30
28
from bzrlib.revision import Revision
29
from bzrlib.xml import unpack_xml
31
30
from bzrlib.delta import compare_trees
32
31
from bzrlib.tree import EmptyTree, RevisionTree
33
import bzrlib.xml
34
import bzrlib.ui
35
36
37
32
38
33
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
34
## TODO: Maybe include checks for common corruption of newlines, etc?
40
35
43
38
# repeatedly to calculate deltas. We could perhaps have a weakref
44
39
# cache in memory to make this faster.
45
40
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
48
49
41
50
42
def find_branch(f, **args):
51
43
if f and (f.startswith('http://') or f.startswith('https://')):
52
from bzrlib.remotebranch import RemoteBranch
53
return RemoteBranch(f, **args)
44
import remotebranch
45
return remotebranch.RemoteBranch(f, **args)
54
46
else:
55
47
return Branch(f, **args)
56
48
57
49
58
50
def find_cached_branch(f, cache_root, **args):
59
from bzrlib.remotebranch import RemoteBranch
51
from remotebranch import RemoteBranch
60
52
br = find_branch(f, **args)
61
53
def cacheify(br, store_name):
62
from bzrlib.meta_store import CachedStore
54
from meta_store import CachedStore
63
55
cache_path = os.path.join(cache_root, store_name)
64
56
os.mkdir(cache_path)
65
57
new_store = CachedStore(getattr(br, store_name), cache_path)
94
86
if tail:
95
87
s.insert(0, tail)
96
88
else:
89
from errors import NotBranchError
97
90
raise NotBranchError("path %r is not within branch %r" % (rp, base))
98
91
99
92
return os.sep.join(s)
107
100
It is not necessary that f exists.
108
101
109
102
Basically we keep looking up until we find the control directory or
110
run into the root. If there isn't one, raises NotBranchError.
111
"""
103
run into the root."""
112
104
if f == None:
113
105
f = os.getcwd()
114
106
elif hasattr(os.path, 'realpath'):
127
119
head, tail = os.path.split(f)
128
120
if head == f:
129
121
# reached the root, whatever that may be
130
raise NotBranchError('%s is not in a branch' % orig_f)
122
raise BzrError('%r is not in a branch' % orig_f)
131
123
f = head
132
133
124
125
class DivergedBranches(Exception):
126
def __init__(self, branch1, branch2):
127
self.branch1 = branch1
128
self.branch2 = branch2
129
Exception.__init__(self, "These branches have diverged.")
130
131
132
class NoSuchRevision(BzrError):
133
def __init__(self, branch, revision):
134
self.branch = branch
135
self.revision = revision
136
msg = "Branch %s has no revision %d" % (branch, revision)
137
BzrError.__init__(self, msg)
134
138
135
139
136
140
######################################################################
165
169
def __init__(self, base, init=False, find_root=True):
166
170
"""Create new branch object at a particular location.
167
171
168
base -- Base directory for the branch. May be a file:// url.
172
base -- Base directory for the branch.
169
173
170
174
init -- If True, create new control files in a previously
171
175
unversioned directory. If False, the branch must already
184
188
elif find_root:
185
189
self.base = find_branch_root(base)
186
190
else:
187
if base.startswith("file://"):
188
base = base[7:]
189
191
self.base = os.path.realpath(base)
190
192
if not isdir(self.controlfilename('.')):
193
from errors import NotBranchError
191
194
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
192
195
['use "bzr init" to initialize a new working tree',
193
196
'current bzr can only operate from top-of-tree'])
207
210
208
211
def __del__(self):
209
212
if self._lock_mode or self._lock:
210
from bzrlib.warnings import warn
213
from warnings import warn
211
214
warn("branch %r was not explicitly unlocked" % self)
212
215
self._lock.unlock()
213
216
217
218
214
219
def lock_write(self):
215
220
if self._lock_mode:
216
221
if self._lock_mode != 'w':
217
from bzrlib.errors import LockError
222
from errors import LockError
218
223
raise LockError("can't upgrade to a write lock from %r" %
219
224
self._lock_mode)
220
225
self._lock_count += 1
226
231
self._lock_count = 1
227
232
228
233
234
229
235
def lock_read(self):
230
236
if self._lock_mode:
231
237
assert self._lock_mode in ('r', 'w'), \
238
244
self._lock_mode = 'r'
239
245
self._lock_count = 1
240
246
247
248
241
249
def unlock(self):
242
250
if not self._lock_mode:
243
from bzrlib.errors import LockError
251
from errors import LockError
244
252
raise LockError('branch %r is not locked' % (self))
245
253
246
254
if self._lock_count > 1:
250
258
self._lock = None
251
259
self._lock_mode = self._lock_count = None
252
260
261
253
262
def abspath(self, name):
254
263
"""Return absolute filename for something in the branch"""
255
264
return os.path.join(self.base, name)
256
265
266
257
267
def relpath(self, path):
258
268
"""Return path relative to this branch of something inside it.
259
269
260
270
Raises an error if path is not in this branch."""
261
271
return _relpath(self.base, path)
262
272
273
263
274
def controlfilename(self, file_or_path):
264
275
"""Return location relative to branch."""
265
276
if isinstance(file_or_path, basestring):
292
303
else:
293
304
raise BzrError("invalid controlfile mode %r" % mode)
294
305
306
307
295
308
def _make_control(self):
296
309
from bzrlib.inventory import Inventory
310
from bzrlib.xml import pack_xml
297
311
298
312
os.mkdir(self.controlfilename([]))
299
313
self.controlfile('README', 'w').write(
309
323
self.controlfile(f, 'w').write('')
310
324
mutter('created control directory in ' + self.base)
311
325
312
# if we want per-tree root ids then this is the place to set
313
# them; they're not needed for now and so ommitted for
314
# simplicity.
315
f = self.controlfile('inventory','w')
316
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
326
pack_xml(Inventory(gen_root_id()), self.controlfile('inventory','w'))
317
327
318
328
319
329
def _check_format(self):
328
338
# on Windows from Linux and so on. I think it might be better
329
339
# to always make all internal files in unix format.
330
340
fmt = self.controlfile('branch-format', 'r').read()
331
fmt = fmt.replace('\r\n', '\n')
341
fmt.replace('\r\n', '')
332
342
if fmt != BZR_BRANCH_FORMAT:
333
343
raise BzrError('sorry, branch format %r not supported' % fmt,
334
344
['use a different bzr version',
354
364
def read_working_inventory(self):
355
365
"""Read the working inventory."""
356
366
from bzrlib.inventory import Inventory
367
from bzrlib.xml import unpack_xml
368
from time import time
369
before = time()
357
370
self.lock_read()
358
371
try:
359
372
# ElementTree does its own conversion from UTF-8, so open in
360
373
# binary.
361
f = self.controlfile('inventory', 'rb')
362
return bzrlib.xml.serializer_v4.read_inventory(f)
374
inv = unpack_xml(Inventory,
375
self.controlfile('inventory', 'rb'))
376
mutter("loaded inventory of %d items in %f"
377
% (len(inv), time() - before))
378
return inv
363
379
finally:
364
380
self.unlock()
365
381
371
387
will be committed to the next revision.
372
388
"""
373
389
from bzrlib.atomicfile import AtomicFile
390
from bzrlib.xml import pack_xml
374
391
375
392
self.lock_write()
376
393
try:
377
394
f = AtomicFile(self.controlfilename('inventory'), 'wb')
378
395
try:
379
bzrlib.xml.serializer_v4.write_inventory(inv, f)
396
pack_xml(inv, f)
380
397
f.commit()
381
398
finally:
382
399
f.close()
390
407
"""Inventory for the working copy.""")
391
408
392
409
393
def add(self, files, ids=None):
410
def add(self, files, verbose=False, ids=None):
394
411
"""Make files versioned.
395
412
396
Note that the command line normally calls smart_add instead,
397
which can automatically recurse.
413
Note that the command line normally calls smart_add instead.
398
414
399
415
This puts the files in the Added state, so that they will be
400
416
recorded by the next commit.
410
426
TODO: Perhaps have an option to add the ids even if the files do
411
427
not (yet) exist.
412
428
413
TODO: Perhaps yield the ids and paths as they're added.
429
TODO: Perhaps return the ids of the files? But then again it
430
is easy to retrieve them if they're needed.
431
432
TODO: Adding a directory should optionally recurse down and
433
add all non-ignored children. Perhaps do that in a
434
higher-level method.
414
435
"""
415
436
# TODO: Re-adding a file that is removed in the working copy
416
437
# should probably put it back with the previous ID.
452
473
file_id = gen_file_id(f)
453
474
inv.add_path(f, kind=kind, file_id=file_id)
454
475
476
if verbose:
477
print 'added', quotefn(f)
478
455
479
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
456
480
457
481
self._write_inventory(inv)
567
591
f.close()
568
592
569
593
570
def get_revision_xml_file(self, revision_id):
571
"""Return XML file object for revision object."""
572
if not revision_id or not isinstance(revision_id, basestring):
573
raise InvalidRevisionId(revision_id)
574
575
self.lock_read()
576
try:
577
try:
578
return self.revision_store[revision_id]
579
except (IndexError, KeyError):
580
raise bzrlib.errors.NoSuchRevision(self, revision_id)
581
finally:
582
self.unlock()
583
584
585
#deprecated
586
get_revision_xml = get_revision_xml_file
587
588
589
594
def get_revision(self, revision_id):
590
595
"""Return the Revision object for a named revision"""
591
xml_file = self.get_revision_xml_file(revision_id)
592
596
self.lock_read()
593
597
try:
594
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
595
except SyntaxError, e:
596
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
597
[revision_id,
598
str(e)])
598
if not revision_id or not isinstance(revision_id, basestring):
599
raise InvalidRevisionId(revision_id)
600
r = unpack_xml(Revision, self.revision_store[revision_id])
601
finally:
602
self.unlock()
599
603
600
604
assert r.revision_id == revision_id
601
605
return r
632
636
# the revision, (add signatures/remove signatures) and still
633
637
# have all hash pointers stay consistent.
634
638
# But for now, just hash the contents.
635
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
639
return sha_file(self.revision_store[revision_id])
636
640
637
641
638
642
def get_inventory(self, inventory_id):
642
646
parameter which can be either an integer revno or a
643
647
string hash."""
644
648
from bzrlib.inventory import Inventory
645
646
f = self.get_inventory_xml_file(inventory_id)
647
return bzrlib.xml.serializer_v4.read_inventory(f)
648
649
650
def get_inventory_xml(self, inventory_id):
651
"""Get inventory XML as a file object."""
652
return self.inventory_store[inventory_id]
653
654
get_inventory_xml_file = get_inventory_xml
649
from bzrlib.xml import unpack_xml
650
651
return unpack_xml(Inventory, self.inventory_store[inventory_id])
655
652
656
653
657
654
def get_inventory_sha1(self, inventory_id):
658
655
"""Return the sha1 hash of the inventory entry
659
656
"""
660
return sha_file(self.get_inventory_xml(inventory_id))
657
return sha_file(self.inventory_store[inventory_id])
661
658
662
659
663
660
def get_revision_inventory(self, revision_id):
687
684
688
685
def common_ancestor(self, other, self_revno=None, other_revno=None):
689
686
"""
690
>>> from bzrlib.commit import commit
687
>>> import commit
691
688
>>> sb = ScratchBranch(files=['foo', 'foo~'])
692
689
>>> sb.common_ancestor(sb) == (None, None)
693
690
True
694
>>> commit(sb, "Committing first revision", verbose=False)
691
>>> commit.commit(sb, "Committing first revision", verbose=False)
695
692
>>> sb.common_ancestor(sb)[0]
696
693
1
697
694
>>> clone = sb.clone()
698
>>> commit(sb, "Committing second revision", verbose=False)
695
>>> commit.commit(sb, "Committing second revision", verbose=False)
699
696
>>> sb.common_ancestor(sb)[0]
700
697
2
701
698
>>> sb.common_ancestor(clone)[0]
702
699
1
703
>>> commit(clone, "Committing divergent second revision",
700
>>> commit.commit(clone, "Committing divergent second revision",
704
701
... verbose=False)
705
702
>>> sb.common_ancestor(clone)[0]
706
703
1
749
746
return None
750
747
751
748
752
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
749
def missing_revisions(self, other, stop_revision=None):
753
750
"""
754
751
If self and other have not diverged, return a list of the revisions
755
752
present in other, but missing from self.
788
785
if stop_revision is None:
789
786
stop_revision = other_len
790
787
elif stop_revision > other_len:
791
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
788
raise NoSuchRevision(self, stop_revision)
792
789
793
790
return other_history[self_len:stop_revision]
794
791
795
792
796
793
def update_revisions(self, other, stop_revision=None):
797
794
"""Pull in all new revisions from other branch.
795
796
>>> from bzrlib.commit import commit
797
>>> bzrlib.trace.silent = True
798
>>> br1 = ScratchBranch(files=['foo', 'bar'])
799
>>> br1.add('foo')
800
>>> br1.add('bar')
801
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
802
>>> br2 = ScratchBranch()
803
>>> br2.update_revisions(br1)
804
Added 2 texts.
805
Added 1 inventories.
806
Added 1 revisions.
807
>>> br2.revision_history()
808
[u'REVISION-ID-1']
809
>>> br2.update_revisions(br1)
810
Added 0 texts.
811
Added 0 inventories.
812
Added 0 revisions.
813
>>> br1.text_store.total_size() == br2.text_store.total_size()
814
True
798
815
"""
799
from bzrlib.fetch import greedy_fetch
800
from bzrlib.revision import get_intervening_revisions
801
802
pb = bzrlib.ui.ui_factory.progress_bar()
816
from bzrlib.progress import ProgressBar
817
818
pb = ProgressBar()
819
803
820
pb.update('comparing histories')
804
if stop_revision is None:
805
other_revision = other.last_patch()
806
else:
807
other_revision = other.lookup_revision(stop_revision)
808
count = greedy_fetch(self, other, other_revision, pb)[0]
809
try:
810
revision_ids = self.missing_revisions(other, stop_revision)
811
except DivergedBranches, e:
812
try:
813
revision_ids = get_intervening_revisions(self.last_patch(),
814
other_revision, self)
815
assert self.last_patch() not in revision_ids
816
except bzrlib.errors.NotAncestor:
817
raise e
818
819
self.append_revision(*revision_ids)
820
pb.clear()
821
822
def install_revisions(self, other, revision_ids, pb):
821
revision_ids = self.missing_revisions(other, stop_revision)
822
823
823
if hasattr(other.revision_store, "prefetch"):
824
824
other.revision_store.prefetch(revision_ids)
825
825
if hasattr(other.inventory_store, "prefetch"):
826
inventory_ids = []
827
for rev_id in revision_ids:
828
try:
829
revision = other.get_revision(rev_id).inventory_id
830
inventory_ids.append(revision)
831
except bzrlib.errors.NoSuchRevision:
832
pass
826
inventory_ids = [other.get_revision(r).inventory_id
827
for r in revision_ids]
833
828
other.inventory_store.prefetch(inventory_ids)
834
835
if pb is None:
836
pb = bzrlib.ui.ui_factory.progress_bar()
837
829
838
830
revisions = []
839
831
needed_texts = set()
840
832
i = 0
841
842
failures = set()
843
for i, rev_id in enumerate(revision_ids):
844
pb.update('fetching revision', i+1, len(revision_ids))
845
try:
846
rev = other.get_revision(rev_id)
847
except bzrlib.errors.NoSuchRevision:
848
failures.add(rev_id)
849
continue
850
833
for rev_id in revision_ids:
834
i += 1
835
pb.update('fetching revision', i, len(revision_ids))
836
rev = other.get_revision(rev_id)
851
837
revisions.append(rev)
852
838
inv = other.get_inventory(str(rev.inventory_id))
853
839
for key, entry in inv.iter_entries():
858
844
859
845
pb.clear()
860
846
861
count, cp_fail = self.text_store.copy_multi(other.text_store,
862
needed_texts)
863
#print "Added %d texts." % count
847
count = self.text_store.copy_multi(other.text_store, needed_texts)
848
print "Added %d texts." % count
864
849
inventory_ids = [ f.inventory_id for f in revisions ]
865
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
866
inventory_ids)
867
#print "Added %d inventories." % count
850
count = self.inventory_store.copy_multi(other.inventory_store,
851
inventory_ids)
852
print "Added %d inventories." % count
868
853
revision_ids = [ f.revision_id for f in revisions]
869
870
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
871
revision_ids,
872
permit_failure=True)
873
assert len(cp_fail) == 0
874
return count, failures
875
876
854
count = self.revision_store.copy_multi(other.revision_store,
855
revision_ids)
856
for revision_id in revision_ids:
857
self.append_revision(revision_id)
858
print "Added %d revisions." % count
859
860
877
861
def commit(self, *args, **kw):
878
862
from bzrlib.commit import commit
879
863
commit(self, *args, **kw)
881
865
882
866
def lookup_revision(self, revision):
883
867
"""Return the revision identifier for a given revision information."""
884
revno, info = self._get_revision_info(revision)
868
revno, info = self.get_revision_info(revision)
885
869
return info
886
870
887
888
def revision_id_to_revno(self, revision_id):
889
"""Given a revision id, return its revno"""
890
history = self.revision_history()
891
try:
892
return history.index(revision_id) + 1
893
except ValueError:
894
raise bzrlib.errors.NoSuchRevision(self, revision_id)
895
896
897
871
def get_revision_info(self, revision):
898
872
"""Return (revno, revision id) for revision identifier.
899
873
902
876
revision can also be a string, in which case it is parsed for something like
903
877
'date:' or 'revid:' etc.
904
878
"""
905
revno, rev_id = self._get_revision_info(revision)
906
if revno is None:
907
raise bzrlib.errors.NoSuchRevision(self, revision)
908
return revno, rev_id
909
910
def get_rev_id(self, revno, history=None):
911
"""Find the revision id of the specified revno."""
912
if revno == 0:
913
return None
914
if history is None:
915
history = self.revision_history()
916
elif revno <= 0 or revno > len(history):
917
raise bzrlib.errors.NoSuchRevision(self, revno)
918
return history[revno - 1]
919
920
def _get_revision_info(self, revision):
921
"""Return (revno, revision id) for revision specifier.
922
923
revision can be an integer, in which case it is assumed to be revno
924
(though this will translate negative values into positive ones)
925
revision can also be a string, in which case it is parsed for something
926
like 'date:' or 'revid:' etc.
927
928
A revid is always returned. If it is None, the specifier referred to
929
the null revision. If the revid does not occur in the revision
930
history, revno will be None.
931
"""
932
933
879
if revision is None:
934
880
return 0, None
935
881
revno = None
939
885
pass
940
886
revs = self.revision_history()
941
887
if isinstance(revision, int):
888
if revision == 0:
889
return 0, None
890
# Mabye we should do this first, but we don't need it if revision == 0
942
891
if revision < 0:
943
892
revno = len(revs) + revision + 1
944
893
else:
945
894
revno = revision
946
rev_id = self.get_rev_id(revno, revs)
947
895
elif isinstance(revision, basestring):
948
896
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
949
897
if revision.startswith(prefix):
950
result = func(self, revs, revision)
951
if len(result) > 1:
952
revno, rev_id = result
953
else:
954
revno = result[0]
955
rev_id = self.get_rev_id(revno, revs)
898
revno = func(self, revs, revision)
956
899
break
957
900
else:
958
raise BzrError('No namespace registered for string: %r' %
959
revision)
960
else:
961
raise TypeError('Unhandled revision type %s' % revision)
901
raise BzrError('No namespace registered for string: %r' % revision)
962
902
963
if revno is None:
964
if rev_id is None:
965
raise bzrlib.errors.NoSuchRevision(self, revision)
966
return revno, rev_id
903
if revno is None or revno <= 0 or revno > len(revs):
904
raise BzrError("no such revision %s" % revision)
905
return revno, revs[revno-1]
967
906
968
907
def _namespace_revno(self, revs, revision):
969
908
"""Lookup a revision by revision number"""
970
909
assert revision.startswith('revno:')
971
910
try:
972
return (int(revision[6:]),)
911
return int(revision[6:])
973
912
except ValueError:
974
913
return None
975
914
REVISION_NAMESPACES['revno:'] = _namespace_revno
976
915
977
916
def _namespace_revid(self, revs, revision):
978
917
assert revision.startswith('revid:')
979
rev_id = revision[len('revid:'):]
980
918
try:
981
return revs.index(rev_id) + 1, rev_id
919
return revs.index(revision[6:]) + 1
982
920
except ValueError:
983
return None, rev_id
921
return None
984
922
REVISION_NAMESPACES['revid:'] = _namespace_revid
985
923
986
924
def _namespace_last(self, revs, revision):
988
926
try:
989
927
offset = int(revision[5:])
990
928
except ValueError:
991
return (None,)
929
return None
992
930
else:
993
931
if offset <= 0:
994
932
raise BzrError('You must supply a positive value for --revision last:XXX')
995
return (len(revs) - offset + 1,)
933
return len(revs) - offset + 1
996
934
REVISION_NAMESPACES['last:'] = _namespace_last
997
935
998
936
def _namespace_tag(self, revs, revision):
1073
1011
# TODO: Handle timezone.
1074
1012
dt = datetime.datetime.fromtimestamp(r.timestamp)
1075
1013
if first >= dt and (last is None or dt >= last):
1076
return (i+1,)
1014
return i+1
1077
1015
else:
1078
1016
for i in range(len(revs)):
1079
1017
r = self.get_revision(revs[i])
1080
1018
# TODO: Handle timezone.
1081
1019
dt = datetime.datetime.fromtimestamp(r.timestamp)
1082
1020
if first <= dt and (last is None or dt <= last):
1083
return (i+1,)
1021
return i+1
1084
1022
REVISION_NAMESPACES['date:'] = _namespace_date
1085
1023
1086
1087
def _namespace_ancestor(self, revs, revision):
1088
from revision import common_ancestor, MultipleRevisionSources
1089
other_branch = find_branch(_trim_namespace('ancestor', revision))
1090
revision_a = self.last_patch()
1091
revision_b = other_branch.last_patch()
1092
for r, b in ((revision_a, self), (revision_b, other_branch)):
1093
if r is None:
1094
raise bzrlib.errors.NoCommits(b)
1095
revision_source = MultipleRevisionSources(self, other_branch)
1096
result = common_ancestor(revision_a, revision_b, revision_source)
1097
try:
1098
revno = self.revision_id_to_revno(result)
1099
except bzrlib.errors.NoSuchRevision:
1100
revno = None
1101
return revno,result
1102
1103
1104
REVISION_NAMESPACES['ancestor:'] = _namespace_ancestor
1105
1106
1024
def revision_tree(self, revision_id):
1107
1025
"""Return Tree for a revision on this branch.
1108
1026
1111
1029
# TODO: refactor this to use an existing revision object
1112
1030
# so we don't need to read it in twice.
1113
1031
if revision_id == None:
1114
return EmptyTree()
1032
return EmptyTree(self.get_root_id())
1115
1033
else:
1116
1034
inv = self.get_revision_inventory(revision_id)
1117
1035
return RevisionTree(self.text_store, inv)
1119
1037
1120
1038
def working_tree(self):
1121
1039
"""Return a `Tree` for the working copy."""
1122
from bzrlib.workingtree import WorkingTree
1040
from workingtree import WorkingTree
1123
1041
return WorkingTree(self.base, self.read_working_inventory())
1124
1042
1125
1043
1130
1048
"""
1131
1049
r = self.last_patch()
1132
1050
if r == None:
1133
return EmptyTree()
1051
return EmptyTree(self.get_root_id())
1134
1052
else:
1135
1053
return RevisionTree(self.text_store, self.get_revision_inventory(r))
1136
1054
1171
1089
1172
1090
inv.rename(file_id, to_dir_id, to_tail)
1173
1091
1092
print "%s => %s" % (from_rel, to_rel)
1093
1174
1094
from_abs = self.abspath(from_rel)
1175
1095
to_abs = self.abspath(to_rel)
1176
1096
try:
1195
1115
1196
1116
Note that to_name is only the last component of the new name;
1197
1117
this doesn't change the directory.
1198
1199
This returns a list of (from_path, to_path) pairs for each
1200
entry that is moved.
1201
1118
"""
1202
result = []
1203
1119
self.lock_write()
1204
1120
try:
1205
1121
## TODO: Option to move IDs only
1240
1156
for f in from_paths:
1241
1157
name_tail = splitpath(f)[-1]
1242
1158
dest_path = appendpath(to_name, name_tail)
1243
result.append((f, dest_path))
1159
print "%s => %s" % (f, dest_path)
1244
1160
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1245
1161
try:
1246
1162
os.rename(self.abspath(f), self.abspath(dest_path))
1252
1168
finally:
1253
1169
self.unlock()
1254
1170
1255
return result
1256
1257
1171
1258
1172
def revert(self, filenames, old_tree=None, backups=True):
1259
1173
"""Restore selected files to the versions from a previous tree.
1341
1255
self.unlock()
1342
1256
1343
1257
1344
def get_parent(self):
1345
"""Return the parent location of the branch.
1346
1347
This is the default location for push/pull/missing. The usual
1348
pattern is that the user can override it by specifying a
1349
location.
1350
"""
1351
import errno
1352
_locs = ['parent', 'pull', 'x-pull']
1353
for l in _locs:
1354
try:
1355
return self.controlfile(l, 'r').read().strip('\n')
1356
except IOError, e:
1357
if e.errno != errno.ENOENT:
1358
raise
1359
return None
1360
1361
1362
def set_parent(self, url):
1363
# TODO: Maybe delete old location files?
1364
from bzrlib.atomicfile import AtomicFile
1365
self.lock_write()
1366
try:
1367
f = AtomicFile(self.controlfilename('parent'))
1368
try:
1369
f.write(url + '\n')
1370
f.commit()
1371
finally:
1372
f.close()
1373
finally:
1374
self.unlock()
1375
1376
def check_revno(self, revno):
1377
"""\
1378
Check whether a revno corresponds to any revision.
1379
Zero (the NULL revision) is considered valid.
1380
"""
1381
if revno != 0:
1382
self.check_real_revno(revno)
1383
1384
def check_real_revno(self, revno):
1385
"""\
1386
Check whether a revno corresponds to a real revision.
1387
Zero (the NULL revision) is considered invalid
1388
"""
1389
if revno < 1 or revno > self.revno():
1390
raise InvalidRevisionNumber(revno)
1391
1392
1393
1394
1258
1395
1259
class ScratchBranch(Branch):
1396
1260
"""Special test class: a branch that cleans up after itself.
1438
1302
os.rmdir(base)
1439
1303
copytree(self.base, base, symlinks=True)
1440
1304
return ScratchBranch(base=base)
1441
1442
1443
1305
1444
1306
def __del__(self):
1445
1307
self.destroy()
1515
1377
"""Return a new tree-root file id."""
1516
1378
return gen_file_id('TREE_ROOT')
1517
1379
1518
1519
def copy_branch(branch_from, to_location, revision=None):
1520
"""Copy branch_from into the existing directory to_location.
1521
1522
revision
1523
If not None, only revisions up to this point will be copied.
1524
The head of the new branch will be that revision.
1525
1526
to_location
1527
The name of a local directory that exists but is empty.
1528
"""
1529
from bzrlib.merge import merge
1530
1531
assert isinstance(branch_from, Branch)
1532
assert isinstance(to_location, basestring)
1533
1534
br_to = Branch(to_location, init=True)
1535
br_to.set_root_id(branch_from.get_root_id())
1536
if revision is None:
1537
revno = branch_from.revno()
1538
else:
1539
revno, rev_id = branch_from.get_revision_info(revision)
1540
br_to.update_revisions(branch_from, stop_revision=revno)
1541
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1542
check_clean=False, ignore_zero=True)
1543
br_to.set_parent(branch_from.base)
1544
return br_to
1545
1546
def _trim_namespace(namespace, spec):
1547
full_namespace = namespace + ':'
1548
assert spec.startswith(full_namespace)
1549
return spec[len(full_namespace):]
Loggerhead is a web-based interface for Breezy
Version: 2.0.1