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 1254
- compare with another revision
- download diff
- download tarball
- view history from revision 1254
- Committer: Martin Pool
- Date: 2005-09-15 06:20:01 UTC
- Revision ID: mbp@sourcefrog.net-20050915062001-e127244e78bc21cf
- fix handling of selective commit with deleted files
- test for this
- test for this
- 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)
745
757
return len(self.revision_history())
746
758
747
759
748
def last_patch(self):
760
def last_revision(self):
749
761
"""Return last patch hash, or None if no history.
750
762
"""
751
763
ph = self.revision_history()
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
# FIXME: Is this redundant with just doing fetch?
818
from bzrlib.fetch import greedy_fetch
819
820
pb = bzrlib.ui.ui_factory.progress_bar()
829
821
pb.update('comparing histories')
822
830
823
revision_ids = self.missing_revisions(other, stop_revision)
831
824
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
825
if len(revision_ids) > 0:
826
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
827
else:
828
count = 0
829
self.append_revision(*revision_ids)
830
## note("Added %d revisions." % count)
854
831
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
832
833
870
834
def commit(self, *args, **kw):
871
from bzrlib.commit import commit
872
commit(self, *args, **kw)
835
from bzrlib.commit import Commit
836
Commit().commit(self, *args, **kw)
873
837
874
838
875
839
def lookup_revision(self, revision):
876
840
"""Return the revision identifier for a given revision information."""
877
revno, info = self.get_revision_info(revision)
841
revno, info = self._get_revision_info(revision)
878
842
return info
879
843
844
845
def revision_id_to_revno(self, revision_id):
846
"""Given a revision id, return its revno"""
847
history = self.revision_history()
848
try:
849
return history.index(revision_id) + 1
850
except ValueError:
851
raise bzrlib.errors.NoSuchRevision(self, revision_id)
852
853
880
854
def get_revision_info(self, revision):
881
855
"""Return (revno, revision id) for revision identifier.
882
856
885
859
revision can also be a string, in which case it is parsed for something like
886
860
'date:' or 'revid:' etc.
887
861
"""
862
revno, rev_id = self._get_revision_info(revision)
863
if revno is None:
864
raise bzrlib.errors.NoSuchRevision(self, revision)
865
return revno, rev_id
866
867
def get_rev_id(self, revno, history=None):
868
"""Find the revision id of the specified revno."""
869
if revno == 0:
870
return None
871
if history is None:
872
history = self.revision_history()
873
elif revno <= 0 or revno > len(history):
874
raise bzrlib.errors.NoSuchRevision(self, revno)
875
return history[revno - 1]
876
877
def _get_revision_info(self, revision):
878
"""Return (revno, revision id) for revision specifier.
879
880
revision can be an integer, in which case it is assumed to be revno
881
(though this will translate negative values into positive ones)
882
revision can also be a string, in which case it is parsed for something
883
like 'date:' or 'revid:' etc.
884
885
A revid is always returned. If it is None, the specifier referred to
886
the null revision. If the revid does not occur in the revision
887
history, revno will be None.
888
"""
889
888
890
if revision is None:
889
891
return 0, None
890
892
revno = None
894
896
pass
895
897
revs = self.revision_history()
896
898
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
899
if revision < 0:
901
900
revno = len(revs) + revision + 1
902
901
else:
903
902
revno = revision
903
rev_id = self.get_rev_id(revno, revs)
904
904
elif isinstance(revision, basestring):
905
905
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
906
906
if revision.startswith(prefix):
907
revno = func(self, revs, revision)
907
result = func(self, revs, revision)
908
if len(result) > 1:
909
revno, rev_id = result
910
else:
911
revno = result[0]
912
rev_id = self.get_rev_id(revno, revs)
908
913
break
909
914
else:
910
raise BzrError('No namespace registered for string: %r' % revision)
915
raise BzrError('No namespace registered for string: %r' %
916
revision)
917
else:
918
raise TypeError('Unhandled revision type %s' % revision)
911
919
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]
920
if revno is None:
921
if rev_id is None:
922
raise bzrlib.errors.NoSuchRevision(self, revision)
923
return revno, rev_id
915
924
916
925
def _namespace_revno(self, revs, revision):
917
926
"""Lookup a revision by revision number"""
918
927
assert revision.startswith('revno:')
919
928
try:
920
return int(revision[6:])
929
return (int(revision[6:]),)
921
930
except ValueError:
922
931
return None
923
932
REVISION_NAMESPACES['revno:'] = _namespace_revno
924
933
925
934
def _namespace_revid(self, revs, revision):
926
935
assert revision.startswith('revid:')
936
rev_id = revision[len('revid:'):]
927
937
try:
928
return revs.index(revision[6:]) + 1
938
return revs.index(rev_id) + 1, rev_id
929
939
except ValueError:
930
return None
940
return None, rev_id
931
941
REVISION_NAMESPACES['revid:'] = _namespace_revid
932
942
933
943
def _namespace_last(self, revs, revision):
935
945
try:
936
946
offset = int(revision[5:])
937
947
except ValueError:
938
return None
948
return (None,)
939
949
else:
940
950
if offset <= 0:
941
951
raise BzrError('You must supply a positive value for --revision last:XXX')
942
return len(revs) - offset + 1
952
return (len(revs) - offset + 1,)
943
953
REVISION_NAMESPACES['last:'] = _namespace_last
944
954
945
955
def _namespace_tag(self, revs, revision):
1020
1030
# TODO: Handle timezone.
1021
1031
dt = datetime.datetime.fromtimestamp(r.timestamp)
1022
1032
if first >= dt and (last is None or dt >= last):
1023
return i+1
1033
return (i+1,)
1024
1034
else:
1025
1035
for i in range(len(revs)):
1026
1036
r = self.get_revision(revs[i])
1027
1037
# TODO: Handle timezone.
1028
1038
dt = datetime.datetime.fromtimestamp(r.timestamp)
1029
1039
if first <= dt and (last is None or dt <= last):
1030
return i+1
1040
return (i+1,)
1031
1041
REVISION_NAMESPACES['date:'] = _namespace_date
1032
1042
1033
1043
def revision_tree(self, revision_id):
1041
1051
return EmptyTree()
1042
1052
else:
1043
1053
inv = self.get_revision_inventory(revision_id)
1044
return RevisionTree(self.text_store, inv)
1054
return RevisionTree(self.weave_store, inv, revision_id)
1045
1055
1046
1056
1047
1057
def working_tree(self):
1055
1065
1056
1066
If there are no revisions yet, return an `EmptyTree`.
1057
1067
"""
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
1068
return self.revision_tree(self.last_revision())
1064
1069
1065
1070
1066
1071
def rename_one(self, from_rel, to_rel):
1098
1103
1099
1104
inv.rename(file_id, to_dir_id, to_tail)
1100
1105
1101
print "%s => %s" % (from_rel, to_rel)
1102
1103
1106
from_abs = self.abspath(from_rel)
1104
1107
to_abs = self.abspath(to_rel)
1105
1108
try:
1124
1127
1125
1128
Note that to_name is only the last component of the new name;
1126
1129
this doesn't change the directory.
1130
1131
This returns a list of (from_path, to_path) pairs for each
1132
entry that is moved.
1127
1133
"""
1134
result = []
1128
1135
self.lock_write()
1129
1136
try:
1130
1137
## TODO: Option to move IDs only
1165
1172
for f in from_paths:
1166
1173
name_tail = splitpath(f)[-1]
1167
1174
dest_path = appendpath(to_name, name_tail)
1168
print "%s => %s" % (f, dest_path)
1175
result.append((f, dest_path))
1169
1176
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1170
1177
try:
1171
1178
os.rename(self.abspath(f), self.abspath(dest_path))
1177
1184
finally:
1178
1185
self.unlock()
1179
1186
1187
return result
1188
1180
1189
1181
1190
def revert(self, filenames, old_tree=None, backups=True):
1182
1191
"""Restore selected files to the versions from a previous tree.
1264
1273
self.unlock()
1265
1274
1266
1275
1276
def get_parent(self):
1277
"""Return the parent location of the branch.
1278
1279
This is the default location for push/pull/missing. The usual
1280
pattern is that the user can override it by specifying a
1281
location.
1282
"""
1283
import errno
1284
_locs = ['parent', 'pull', 'x-pull']
1285
for l in _locs:
1286
try:
1287
return self.controlfile(l, 'r').read().strip('\n')
1288
except IOError, e:
1289
if e.errno != errno.ENOENT:
1290
raise
1291
return None
1292
1293
1294
def set_parent(self, url):
1295
# TODO: Maybe delete old location files?
1296
from bzrlib.atomicfile import AtomicFile
1297
self.lock_write()
1298
try:
1299
f = AtomicFile(self.controlfilename('parent'))
1300
try:
1301
f.write(url + '\n')
1302
f.commit()
1303
finally:
1304
f.close()
1305
finally:
1306
self.unlock()
1307
1308
def check_revno(self, revno):
1309
"""\
1310
Check whether a revno corresponds to any revision.
1311
Zero (the NULL revision) is considered valid.
1312
"""
1313
if revno != 0:
1314
self.check_real_revno(revno)
1315
1316
def check_real_revno(self, revno):
1317
"""\
1318
Check whether a revno corresponds to a real revision.
1319
Zero (the NULL revision) is considered invalid
1320
"""
1321
if revno < 1 or revno > self.revno():
1322
raise InvalidRevisionNumber(revno)
1323
1324
1325
1267
1326
1268
1327
class ScratchBranch(Branch):
1269
1328
"""Special test class: a branch that cleans up after itself.
1311
1370
os.rmdir(base)
1312
1371
copytree(self.base, base, symlinks=True)
1313
1372
return ScratchBranch(base=base)
1373
1374
1314
1375
1315
1376
def __del__(self):
1316
1377
self.destroy()
1386
1447
"""Return a new tree-root file id."""
1387
1448
return gen_file_id('TREE_ROOT')
1388
1449
1450
1451
def pull_loc(branch):
1452
# TODO: Should perhaps just make attribute be 'base' in
1453
# RemoteBranch and Branch?
1454
if hasattr(branch, "baseurl"):
1455
return branch.baseurl
1456
else:
1457
return branch.base
1458
1459
1460
def copy_branch(branch_from, to_location, revision=None):
1461
"""Copy branch_from into the existing directory to_location.
1462
1463
revision
1464
If not None, only revisions up to this point will be copied.
1465
The head of the new branch will be that revision.
1466
1467
to_location
1468
The name of a local directory that exists but is empty.
1469
"""
1470
from bzrlib.merge import merge
1471
from bzrlib.branch import Branch
1472
1473
assert isinstance(branch_from, Branch)
1474
assert isinstance(to_location, basestring)
1475
1476
br_to = Branch(to_location, init=True)
1477
br_to.set_root_id(branch_from.get_root_id())
1478
if revision is None:
1479
revno = branch_from.revno()
1480
else:
1481
revno, rev_id = branch_from.get_revision_info(revision)
1482
br_to.update_revisions(branch_from, stop_revision=revno)
1483
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1484
check_clean=False, ignore_zero=True)
1485
1486
from_location = pull_loc(branch_from)
1487
br_to.set_parent(pull_loc(branch_from))
1488
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0