To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1239
- compare with another revision
- download diff
- download tarball
- view history from revision 1239
- Committer: Martin Pool
- Date: 2005-09-13 23:08:19 UTC
- Revision ID: mbp@sourcefrog.net-20050913230819-6ceae96050d32faa
ignore .bzr-shelf
- files added:
- HACKING
- bzrlib/util
- files removed:
- plugins/changeset
- files renamed:
- plugins/ => bzrlib/plugins/
- tools/testweave.py => bzrlib/selftest/test_weave.py
- effbot/ => bzrlib/util/effbot/
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
17
17
18
18
import sys
19
19
import os
20
from cStringIO import StringIO
20
21
21
22
import bzrlib
22
23
from bzrlib.trace import mutter, note
23
24
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
25
splitpath, \
25
26
sha_file, appendpath, file_kind
26
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
27
import bzrlib.errors
27
28
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
29
NoSuchRevision)
28
30
from bzrlib.textui import show_status
29
31
from bzrlib.revision import Revision
30
from bzrlib.xml import unpack_xml
31
32
from bzrlib.delta import compare_trees
32
33
from bzrlib.tree import EmptyTree, RevisionTree
33
34
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
34
from bzrlib.inventory import Inventory
35
from bzrlib.weavestore import WeaveStore
36
from bzrlib.store import ImmutableStore
37
import bzrlib.xml5
38
import bzrlib.ui
39
40
41
INVENTORY_FILEID = '__inventory'
42
ANCESTRY_FILEID = '__ancestry'
43
44
45
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
46
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
35
47
## TODO: Maybe include checks for common corruption of newlines, etc?
36
48
37
49
38
50
# TODO: Some operations like log might retrieve the same revisions
39
51
# repeatedly to calculate deltas. We could perhaps have a weakref
40
# cache in memory to make this faster.
52
# cache in memory to make this faster. In general anything can be
53
# cached in memory between lock and unlock operations.
54
55
# TODO: please move the revision-string syntax stuff out of the branch
56
# object; it's clutter
41
57
42
58
43
59
def find_branch(f, **args):
101
117
It is not necessary that f exists.
102
118
103
119
Basically we keep looking up until we find the control directory or
104
run into the root."""
120
run into the root. If there isn't one, raises NotBranchError.
121
"""
105
122
if f == None:
106
123
f = os.getcwd()
107
124
elif hasattr(os.path, 'realpath'):
120
137
head, tail = os.path.split(f)
121
138
if head == f:
122
139
# reached the root, whatever that may be
123
raise BzrError('%r is not in a branch' % orig_f)
140
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
124
141
f = head
125
142
143
144
145
# XXX: move into bzrlib.errors; subclass BzrError
126
146
class DivergedBranches(Exception):
127
147
def __init__(self, branch1, branch2):
128
148
self.branch1 = branch1
153
173
_lock_mode = None
154
174
_lock_count = None
155
175
_lock = None
176
_inventory_weave = None
156
177
157
178
# Map some sort of prefix into a namespace
158
179
# stuff like "revno:10", "revid:", etc.
174
195
In the test suite, creation of new trees is tested using the
175
196
`ScratchBranch` class.
176
197
"""
177
from bzrlib.store import ImmutableStore
178
198
if init:
179
199
self.base = os.path.realpath(base)
180
200
self._make_control()
189
209
'current bzr can only operate from top-of-tree'])
190
210
self._check_format()
191
211
192
self.text_store = ImmutableStore(self.controlfilename('text-store'))
212
self.weave_store = WeaveStore(self.controlfilename('weaves'))
193
213
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
194
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
195
214
196
215
197
216
def __str__(self):
208
227
self._lock.unlock()
209
228
210
229
211
212
230
def lock_write(self):
213
231
if self._lock_mode:
214
232
if self._lock_mode != 'w':
224
242
self._lock_count = 1
225
243
226
244
227
228
245
def lock_read(self):
229
246
if self._lock_mode:
230
247
assert self._lock_mode in ('r', 'w'), \
237
254
self._lock_mode = 'r'
238
255
self._lock_count = 1
239
256
240
241
242
257
def unlock(self):
243
258
if not self._lock_mode:
244
259
from errors import LockError
251
266
self._lock = None
252
267
self._lock_mode = self._lock_count = None
253
268
254
255
269
def abspath(self, name):
256
270
"""Return absolute filename for something in the branch"""
257
271
return os.path.join(self.base, name)
258
272
259
260
273
def relpath(self, path):
261
274
"""Return path relative to this branch of something inside it.
262
275
263
276
Raises an error if path is not in this branch."""
264
277
return _relpath(self.base, path)
265
278
266
267
279
def controlfilename(self, file_or_path):
268
280
"""Return location relative to branch."""
269
281
if isinstance(file_or_path, basestring):
296
308
else:
297
309
raise BzrError("invalid controlfile mode %r" % mode)
298
310
299
300
301
311
def _make_control(self):
302
from bzrlib.inventory import Inventory
303
from bzrlib.xml import pack_xml
304
305
312
os.mkdir(self.controlfilename([]))
306
313
self.controlfile('README', 'w').write(
307
314
"This is a Bazaar-NG control directory.\n"
308
315
"Do not change any files in this directory.\n")
309
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
310
for d in ('text-store', 'inventory-store', 'revision-store'):
316
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT_5)
317
for d in ('text-store', 'revision-store',
318
'weaves'):
311
319
os.mkdir(self.controlfilename(d))
312
320
for f in ('revision-history', 'merged-patches',
313
321
'pending-merged-patches', 'branch-name',
316
324
self.controlfile(f, 'w').write('')
317
325
mutter('created control directory in ' + self.base)
318
326
319
pack_xml(Inventory(gen_root_id()), self.controlfile('inventory','w'))
327
# if we want per-tree root ids then this is the place to set
328
# them; they're not needed for now and so ommitted for
329
# simplicity.
330
f = self.controlfile('inventory','w')
331
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), f)
332
320
333
321
334
322
335
def _check_format(self):
323
336
"""Check this branch format is supported.
324
337
325
The current tool only supports the current unstable format.
338
The format level is stored, as an integer, in
339
self._branch_format for code that needs to check it later.
326
340
327
341
In the future, we might need different in-memory Branch
328
342
classes to support downlevel branches. But not yet.
329
343
"""
330
# This ignores newlines so that we can open branches created
331
# on Windows from Linux and so on. I think it might be better
332
# to always make all internal files in unix format.
333
344
fmt = self.controlfile('branch-format', 'r').read()
334
fmt.replace('\r\n', '')
335
if fmt != BZR_BRANCH_FORMAT:
336
raise BzrError('sorry, branch format %r not supported' % fmt,
337
['use a different bzr version',
338
'or remove the .bzr directory and "bzr init" again'])
345
if fmt == BZR_BRANCH_FORMAT_5:
346
self._branch_format = 5
347
else:
348
raise BzrError('sorry, branch format "%s" not supported; '
349
'use a different bzr version, '
350
'or run "bzr upgrade", '
351
'or remove the .bzr directory and "bzr init" again'
352
% fmt.rstrip('\n\r'))
339
353
340
354
def get_root_id(self):
341
355
"""Return the id of this branches root"""
356
370
357
371
def read_working_inventory(self):
358
372
"""Read the working inventory."""
359
from bzrlib.inventory import Inventory
360
from bzrlib.xml import unpack_xml
361
from time import time
362
before = time()
363
373
self.lock_read()
364
374
try:
365
375
# ElementTree does its own conversion from UTF-8, so open in
366
376
# binary.
367
inv = unpack_xml(Inventory,
368
self.controlfile('inventory', 'rb'))
369
mutter("loaded inventory of %d items in %f"
370
% (len(inv), time() - before))
371
return inv
377
f = self.controlfile('inventory', 'rb')
378
return bzrlib.xml5.serializer_v5.read_inventory(f)
372
379
finally:
373
380
self.unlock()
374
381
380
387
will be committed to the next revision.
381
388
"""
382
389
from bzrlib.atomicfile import AtomicFile
383
from bzrlib.xml import pack_xml
384
390
385
391
self.lock_write()
386
392
try:
387
393
f = AtomicFile(self.controlfilename('inventory'), 'wb')
388
394
try:
389
pack_xml(inv, f)
395
bzrlib.xml5.serializer_v5.write_inventory(inv, f)
390
396
f.commit()
391
397
finally:
392
398
f.close()
400
406
"""Inventory for the working copy.""")
401
407
402
408
403
def add(self, files, verbose=False, ids=None):
409
def add(self, files, ids=None):
404
410
"""Make files versioned.
405
411
406
Note that the command line normally calls smart_add instead.
412
Note that the command line normally calls smart_add instead,
413
which can automatically recurse.
407
414
408
415
This puts the files in the Added state, so that they will be
409
416
recorded by the next commit.
419
426
TODO: Perhaps have an option to add the ids even if the files do
420
427
not (yet) exist.
421
428
422
TODO: Perhaps return the ids of the files? But then again it
423
is easy to retrieve them if they're needed.
424
425
TODO: Adding a directory should optionally recurse down and
426
add all non-ignored children. Perhaps do that in a
427
higher-level method.
429
TODO: Perhaps yield the ids and paths as they're added.
428
430
"""
429
431
# TODO: Re-adding a file that is removed in the working copy
430
432
# should probably put it back with the previous ID.
466
468
file_id = gen_file_id(f)
467
469
inv.add_path(f, kind=kind, file_id=file_id)
468
470
469
if verbose:
470
print 'added', quotefn(f)
471
472
471
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
473
472
474
473
self._write_inventory(inv)
584
583
f.close()
585
584
586
585
587
def get_revision_xml(self, revision_id):
586
def get_revision_xml_file(self, revision_id):
588
587
"""Return XML file object for revision object."""
589
588
if not revision_id or not isinstance(revision_id, basestring):
590
589
raise InvalidRevisionId(revision_id)
594
593
try:
595
594
return self.revision_store[revision_id]
596
595
except IndexError:
597
raise bzrlib.errors.NoSuchRevision(revision_id)
596
raise bzrlib.errors.NoSuchRevision(self, revision_id)
598
597
finally:
599
598
self.unlock()
600
599
601
600
601
def get_revision_xml(self, revision_id):
602
return self.get_revision_xml_file(revision_id).read()
603
604
602
605
def get_revision(self, revision_id):
603
606
"""Return the Revision object for a named revision"""
604
xml_file = self.get_revision_xml(revision_id)
607
xml_file = self.get_revision_xml_file(revision_id)
605
608
606
609
try:
607
r = unpack_xml(Revision, xml_file)
610
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
608
611
except SyntaxError, e:
609
612
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
610
613
[revision_id,
639
642
640
643
def get_revision_sha1(self, revision_id):
641
644
"""Hash the stored value of a revision, and return it."""
642
# In the future, revision entries will be signed. At that
643
# point, it is probably best *not* to include the signature
644
# in the revision hash. Because that lets you re-sign
645
# the revision, (add signatures/remove signatures) and still
646
# have all hash pointers stay consistent.
647
# But for now, just hash the contents.
648
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
649
650
651
def get_inventory(self, inventory_id):
652
"""Get Inventory object by hash.
653
654
TODO: Perhaps for this and similar methods, take a revision
655
parameter which can be either an integer revno or a
656
string hash."""
657
from bzrlib.inventory import Inventory
658
from bzrlib.xml import unpack_xml
659
660
return unpack_xml(Inventory, self.inventory_store[inventory_id])
661
662
663
def get_inventory_sha1(self, inventory_id):
645
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
646
647
648
def get_ancestry(self, revision_id):
649
"""Return a list of revision-ids integrated by a revision.
650
"""
651
w = self.weave_store.get_weave(ANCESTRY_FILEID)
652
# strip newlines
653
return [l[:-1] for l in w.get_iter(w.lookup(revision_id))]
654
655
656
def get_inventory_weave(self):
657
return self.weave_store.get_weave(INVENTORY_FILEID)
658
659
660
def get_inventory(self, revision_id):
661
"""Get Inventory object by hash."""
662
# FIXME: The text gets passed around a lot coming from the weave.
663
f = StringIO(self.get_inventory_xml(revision_id))
664
return bzrlib.xml5.serializer_v5.read_inventory(f)
665
666
667
def get_inventory_xml(self, revision_id):
668
"""Get inventory XML as a file object."""
669
try:
670
assert isinstance(revision_id, basestring), type(revision_id)
671
iw = self.get_inventory_weave()
672
return iw.get_text(iw.lookup(revision_id))
673
except IndexError:
674
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
675
676
677
def get_inventory_sha1(self, revision_id):
664
678
"""Return the sha1 hash of the inventory entry
665
679
"""
666
return sha_file(self.inventory_store[inventory_id])
680
return self.get_revision(revision_id).inventory_sha1
667
681
668
682
669
683
def get_revision_inventory(self, revision_id):
670
684
"""Return inventory of a past revision."""
671
# bzr 0.0.6 imposes the constraint that the inventory_id
685
# bzr 0.0.6 and later imposes the constraint that the inventory_id
672
686
# must be the same as its revision, so this is trivial.
673
687
if revision_id == None:
674
from bzrlib.inventory import Inventory
675
688
return Inventory(self.get_root_id())
676
689
else:
677
690
return self.get_inventory(revision_id)
697
710
>>> sb = ScratchBranch(files=['foo', 'foo~'])
698
711
>>> sb.common_ancestor(sb) == (None, None)
699
712
True
700
>>> commit.commit(sb, "Committing first revision", verbose=False)
713
>>> commit.commit(sb, "Committing first revision")
701
714
>>> sb.common_ancestor(sb)[0]
702
715
1
703
716
>>> clone = sb.clone()
704
>>> commit.commit(sb, "Committing second revision", verbose=False)
717
>>> commit.commit(sb, "Committing second revision")
705
718
>>> sb.common_ancestor(sb)[0]
706
719
2
707
720
>>> sb.common_ancestor(clone)[0]
708
721
1
709
>>> commit.commit(clone, "Committing divergent second revision",
710
... verbose=False)
722
>>> commit.commit(clone, "Committing divergent second revision")
711
723
>>> sb.common_ancestor(clone)[0]
712
724
1
713
725
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
755
767
return None
756
768
757
769
758
def missing_revisions(self, other, stop_revision=None):
770
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
759
771
"""
760
772
If self and other have not diverged, return a list of the revisions
761
773
present in other, but missing from self.
794
806
if stop_revision is None:
795
807
stop_revision = other_len
796
808
elif stop_revision > other_len:
797
raise NoSuchRevision(self, stop_revision)
809
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
798
810
799
811
return other_history[self_len:stop_revision]
800
812
801
813
802
814
def update_revisions(self, other, stop_revision=None):
803
815
"""Pull in all new revisions from other branch.
804
805
>>> from bzrlib.commit import commit
806
>>> bzrlib.trace.silent = True
807
>>> br1 = ScratchBranch(files=['foo', 'bar'])
808
>>> br1.add('foo')
809
>>> br1.add('bar')
810
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
811
>>> br2 = ScratchBranch()
812
>>> br2.update_revisions(br1)
813
Added 2 texts.
814
Added 1 inventories.
815
Added 1 revisions.
816
>>> br2.revision_history()
817
[u'REVISION-ID-1']
818
>>> br2.update_revisions(br1)
819
Added 0 texts.
820
Added 0 inventories.
821
Added 0 revisions.
822
>>> br1.text_store.total_size() == br2.text_store.total_size()
823
True
824
816
"""
825
from bzrlib.progress import ProgressBar
826
827
pb = ProgressBar()
828
817
from bzrlib.fetch import greedy_fetch
818
819
pb = bzrlib.ui.ui_factory.progress_bar()
829
820
pb.update('comparing histories')
821
830
822
revision_ids = self.missing_revisions(other, stop_revision)
831
823
832
if hasattr(other.revision_store, "prefetch"):
833
other.revision_store.prefetch(revision_ids)
834
if hasattr(other.inventory_store, "prefetch"):
835
inventory_ids = [other.get_revision(r).inventory_id
836
for r in revision_ids]
837
other.inventory_store.prefetch(inventory_ids)
838
839
revisions = []
840
needed_texts = set()
841
i = 0
842
for rev_id in revision_ids:
843
i += 1
844
pb.update('fetching revision', i, len(revision_ids))
845
rev = other.get_revision(rev_id)
846
revisions.append(rev)
847
inv = other.get_inventory(str(rev.inventory_id))
848
for key, entry in inv.iter_entries():
849
if entry.text_id is None:
850
continue
851
if entry.text_id not in self.text_store:
852
needed_texts.add(entry.text_id)
853
824
if len(revision_ids) > 0:
825
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
826
else:
827
count = 0
828
self.append_revision(*revision_ids)
829
## note("Added %d revisions." % count)
854
830
pb.clear()
855
856
count = self.text_store.copy_multi(other.text_store, needed_texts)
857
print "Added %d texts." % count
858
inventory_ids = [ f.inventory_id for f in revisions ]
859
count = self.inventory_store.copy_multi(other.inventory_store,
860
inventory_ids)
861
print "Added %d inventories." % count
862
revision_ids = [ f.revision_id for f in revisions]
863
count = self.revision_store.copy_multi(other.revision_store,
864
revision_ids)
865
for revision_id in revision_ids:
866
self.append_revision(revision_id)
867
print "Added %d revisions." % count
868
869
831
832
870
833
def commit(self, *args, **kw):
871
from bzrlib.commit import commit
872
commit(self, *args, **kw)
834
from bzrlib.commit import Commit
835
Commit().commit(self, *args, **kw)
873
836
874
837
875
838
def lookup_revision(self, revision):
876
839
"""Return the revision identifier for a given revision information."""
877
revno, info = self.get_revision_info(revision)
840
revno, info = self._get_revision_info(revision)
878
841
return info
879
842
843
844
def revision_id_to_revno(self, revision_id):
845
"""Given a revision id, return its revno"""
846
history = self.revision_history()
847
try:
848
return history.index(revision_id) + 1
849
except ValueError:
850
raise bzrlib.errors.NoSuchRevision(self, revision_id)
851
852
880
853
def get_revision_info(self, revision):
881
854
"""Return (revno, revision id) for revision identifier.
882
855
885
858
revision can also be a string, in which case it is parsed for something like
886
859
'date:' or 'revid:' etc.
887
860
"""
861
revno, rev_id = self._get_revision_info(revision)
862
if revno is None:
863
raise bzrlib.errors.NoSuchRevision(self, revision)
864
return revno, rev_id
865
866
def get_rev_id(self, revno, history=None):
867
"""Find the revision id of the specified revno."""
868
if revno == 0:
869
return None
870
if history is None:
871
history = self.revision_history()
872
elif revno <= 0 or revno > len(history):
873
raise bzrlib.errors.NoSuchRevision(self, revno)
874
return history[revno - 1]
875
876
def _get_revision_info(self, revision):
877
"""Return (revno, revision id) for revision specifier.
878
879
revision can be an integer, in which case it is assumed to be revno
880
(though this will translate negative values into positive ones)
881
revision can also be a string, in which case it is parsed for something
882
like 'date:' or 'revid:' etc.
883
884
A revid is always returned. If it is None, the specifier referred to
885
the null revision. If the revid does not occur in the revision
886
history, revno will be None.
887
"""
888
888
889
if revision is None:
889
890
return 0, None
890
891
revno = None
894
895
pass
895
896
revs = self.revision_history()
896
897
if isinstance(revision, int):
897
if revision == 0:
898
return 0, None
899
# Mabye we should do this first, but we don't need it if revision == 0
900
898
if revision < 0:
901
899
revno = len(revs) + revision + 1
902
900
else:
903
901
revno = revision
902
rev_id = self.get_rev_id(revno, revs)
904
903
elif isinstance(revision, basestring):
905
904
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
906
905
if revision.startswith(prefix):
907
revno = func(self, revs, revision)
906
result = func(self, revs, revision)
907
if len(result) > 1:
908
revno, rev_id = result
909
else:
910
revno = result[0]
911
rev_id = self.get_rev_id(revno, revs)
908
912
break
909
913
else:
910
raise BzrError('No namespace registered for string: %r' % revision)
914
raise BzrError('No namespace registered for string: %r' %
915
revision)
916
else:
917
raise TypeError('Unhandled revision type %s' % revision)
911
918
912
if revno is None or revno <= 0 or revno > len(revs):
913
raise BzrError("no such revision %s" % revision)
914
return revno, revs[revno-1]
919
if revno is None:
920
if rev_id is None:
921
raise bzrlib.errors.NoSuchRevision(self, revision)
922
return revno, rev_id
915
923
916
924
def _namespace_revno(self, revs, revision):
917
925
"""Lookup a revision by revision number"""
918
926
assert revision.startswith('revno:')
919
927
try:
920
return int(revision[6:])
928
return (int(revision[6:]),)
921
929
except ValueError:
922
930
return None
923
931
REVISION_NAMESPACES['revno:'] = _namespace_revno
924
932
925
933
def _namespace_revid(self, revs, revision):
926
934
assert revision.startswith('revid:')
935
rev_id = revision[len('revid:'):]
927
936
try:
928
return revs.index(revision[6:]) + 1
937
return revs.index(rev_id) + 1, rev_id
929
938
except ValueError:
930
return None
939
return None, rev_id
931
940
REVISION_NAMESPACES['revid:'] = _namespace_revid
932
941
933
942
def _namespace_last(self, revs, revision):
935
944
try:
936
945
offset = int(revision[5:])
937
946
except ValueError:
938
return None
947
return (None,)
939
948
else:
940
949
if offset <= 0:
941
950
raise BzrError('You must supply a positive value for --revision last:XXX')
942
return len(revs) - offset + 1
951
return (len(revs) - offset + 1,)
943
952
REVISION_NAMESPACES['last:'] = _namespace_last
944
953
945
954
def _namespace_tag(self, revs, revision):
1020
1029
# TODO: Handle timezone.
1021
1030
dt = datetime.datetime.fromtimestamp(r.timestamp)
1022
1031
if first >= dt and (last is None or dt >= last):
1023
return i+1
1032
return (i+1,)
1024
1033
else:
1025
1034
for i in range(len(revs)):
1026
1035
r = self.get_revision(revs[i])
1027
1036
# TODO: Handle timezone.
1028
1037
dt = datetime.datetime.fromtimestamp(r.timestamp)
1029
1038
if first <= dt and (last is None or dt <= last):
1030
return i+1
1039
return (i+1,)
1031
1040
REVISION_NAMESPACES['date:'] = _namespace_date
1032
1041
1033
1042
def revision_tree(self, revision_id):
1041
1050
return EmptyTree()
1042
1051
else:
1043
1052
inv = self.get_revision_inventory(revision_id)
1044
return RevisionTree(self.text_store, inv)
1053
return RevisionTree(self.weave_store, inv, revision_id)
1045
1054
1046
1055
1047
1056
def working_tree(self):
1055
1064
1056
1065
If there are no revisions yet, return an `EmptyTree`.
1057
1066
"""
1058
r = self.last_patch()
1059
if r == None:
1060
return EmptyTree()
1061
else:
1062
return RevisionTree(self.text_store, self.get_revision_inventory(r))
1063
1067
return self.revision_tree(self.last_patch())
1064
1068
1065
1069
1066
1070
def rename_one(self, from_rel, to_rel):
1098
1102
1099
1103
inv.rename(file_id, to_dir_id, to_tail)
1100
1104
1101
print "%s => %s" % (from_rel, to_rel)
1102
1103
1105
from_abs = self.abspath(from_rel)
1104
1106
to_abs = self.abspath(to_rel)
1105
1107
try:
1124
1126
1125
1127
Note that to_name is only the last component of the new name;
1126
1128
this doesn't change the directory.
1129
1130
This returns a list of (from_path, to_path) pairs for each
1131
entry that is moved.
1127
1132
"""
1133
result = []
1128
1134
self.lock_write()
1129
1135
try:
1130
1136
## TODO: Option to move IDs only
1165
1171
for f in from_paths:
1166
1172
name_tail = splitpath(f)[-1]
1167
1173
dest_path = appendpath(to_name, name_tail)
1168
print "%s => %s" % (f, dest_path)
1174
result.append((f, dest_path))
1169
1175
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1170
1176
try:
1171
1177
os.rename(self.abspath(f), self.abspath(dest_path))
1177
1183
finally:
1178
1184
self.unlock()
1179
1185
1186
return result
1187
1180
1188
1181
1189
def revert(self, filenames, old_tree=None, backups=True):
1182
1190
"""Restore selected files to the versions from a previous tree.
1264
1272
self.unlock()
1265
1273
1266
1274
1275
def get_parent(self):
1276
"""Return the parent location of the branch.
1277
1278
This is the default location for push/pull/missing. The usual
1279
pattern is that the user can override it by specifying a
1280
location.
1281
"""
1282
import errno
1283
_locs = ['parent', 'pull', 'x-pull']
1284
for l in _locs:
1285
try:
1286
return self.controlfile(l, 'r').read().strip('\n')
1287
except IOError, e:
1288
if e.errno != errno.ENOENT:
1289
raise
1290
return None
1291
1292
1293
def set_parent(self, url):
1294
# TODO: Maybe delete old location files?
1295
from bzrlib.atomicfile import AtomicFile
1296
self.lock_write()
1297
try:
1298
f = AtomicFile(self.controlfilename('parent'))
1299
try:
1300
f.write(url + '\n')
1301
f.commit()
1302
finally:
1303
f.close()
1304
finally:
1305
self.unlock()
1306
1307
def check_revno(self, revno):
1308
"""\
1309
Check whether a revno corresponds to any revision.
1310
Zero (the NULL revision) is considered valid.
1311
"""
1312
if revno != 0:
1313
self.check_real_revno(revno)
1314
1315
def check_real_revno(self, revno):
1316
"""\
1317
Check whether a revno corresponds to a real revision.
1318
Zero (the NULL revision) is considered invalid
1319
"""
1320
if revno < 1 or revno > self.revno():
1321
raise InvalidRevisionNumber(revno)
1322
1323
1324
1267
1325
1268
1326
class ScratchBranch(Branch):
1269
1327
"""Special test class: a branch that cleans up after itself.
1311
1369
os.rmdir(base)
1312
1370
copytree(self.base, base, symlinks=True)
1313
1371
return ScratchBranch(base=base)
1372
1373
1314
1374
1315
1375
def __del__(self):
1316
1376
self.destroy()
1386
1446
"""Return a new tree-root file id."""
1387
1447
return gen_file_id('TREE_ROOT')
1388
1448
1449
1450
def pull_loc(branch):
1451
# TODO: Should perhaps just make attribute be 'base' in
1452
# RemoteBranch and Branch?
1453
if hasattr(branch, "baseurl"):
1454
return branch.baseurl
1455
else:
1456
return branch.base
1457
1458
1459
def copy_branch(branch_from, to_location, revision=None):
1460
"""Copy branch_from into the existing directory to_location.
1461
1462
revision
1463
If not None, only revisions up to this point will be copied.
1464
The head of the new branch will be that revision.
1465
1466
to_location
1467
The name of a local directory that exists but is empty.
1468
"""
1469
from bzrlib.merge import merge
1470
from bzrlib.branch import Branch
1471
1472
assert isinstance(branch_from, Branch)
1473
assert isinstance(to_location, basestring)
1474
1475
br_to = Branch(to_location, init=True)
1476
br_to.set_root_id(branch_from.get_root_id())
1477
if revision is None:
1478
revno = branch_from.revno()
1479
else:
1480
revno, rev_id = branch_from.get_revision_info(revision)
1481
br_to.update_revisions(branch_from, stop_revision=revno)
1482
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1483
check_clean=False, ignore_zero=True)
1484
1485
from_location = pull_loc(branch_from)
1486
br_to.set_parent(pull_loc(branch_from))
1487
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0