« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1216
- compare with another revision
- download diff
- download tarball
- view history from revision 1216
- Committer: Martin Pool
- Date: 2005-09-12 09:50:44 UTC
- Revision ID: mbp@sourcefrog.net-20050912095044-6acfdb5611729987
- no tests in bzrlib.fetch anymore
- files added:
- bzrlib/weavestore.py
- files removed:
- bzrlib/graph.py
- files renamed:
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- Makefile
added
removed
bzrlib/branch.py
24
24
splitpath, \
25
25
sha_file, appendpath, file_kind
26
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId, \
28
DivergedBranches, NotBranchError
27
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
28
NoSuchRevision)
29
29
from bzrlib.textui import show_status
30
30
from bzrlib.revision import Revision
31
31
from bzrlib.delta import compare_trees
32
32
from bzrlib.tree import EmptyTree, RevisionTree
33
import bzrlib.xml
33
from bzrlib.inventory import Inventory
34
from bzrlib.weavestore import WeaveStore
35
import bzrlib.xml5
34
36
import bzrlib.ui
35
37
36
38
37
39
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
40
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
41
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
39
42
## TODO: Maybe include checks for common corruption of newlines, etc?
40
43
41
44
43
46
# repeatedly to calculate deltas. We could perhaps have a weakref
44
47
# cache in memory to make this faster.
45
48
46
def find_branch(*ignored, **ignored_too):
47
# XXX: leave this here for about one release, then remove it
48
raise NotImplementedError('find_branch() is not supported anymore, '
49
'please use one of the new branch constructors')
49
# TODO: please move the revision-string syntax stuff out of the branch
50
# object; it's clutter
51
52
53
def find_branch(f, **args):
54
if f and (f.startswith('http://') or f.startswith('https://')):
55
import remotebranch
56
return remotebranch.RemoteBranch(f, **args)
57
else:
58
return Branch(f, **args)
59
60
61
def find_cached_branch(f, cache_root, **args):
62
from remotebranch import RemoteBranch
63
br = find_branch(f, **args)
64
def cacheify(br, store_name):
65
from meta_store import CachedStore
66
cache_path = os.path.join(cache_root, store_name)
67
os.mkdir(cache_path)
68
new_store = CachedStore(getattr(br, store_name), cache_path)
69
setattr(br, store_name, new_store)
70
71
if isinstance(br, RemoteBranch):
72
cacheify(br, 'inventory_store')
73
cacheify(br, 'text_store')
74
cacheify(br, 'revision_store')
75
return br
76
50
77
51
78
def _relpath(base, path):
52
79
"""Return path relative to base, or raise exception.
70
97
if tail:
71
98
s.insert(0, tail)
72
99
else:
100
from errors import NotBranchError
73
101
raise NotBranchError("path %r is not within branch %r" % (rp, base))
74
102
75
103
return os.sep.join(s)
103
131
head, tail = os.path.split(f)
104
132
if head == f:
105
133
# reached the root, whatever that may be
106
raise NotBranchError('%s is not in a branch' % orig_f)
134
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
107
135
f = head
108
136
109
137
110
138
139
# XXX: move into bzrlib.errors; subclass BzrError
140
class DivergedBranches(Exception):
141
def __init__(self, branch1, branch2):
142
self.branch1 = branch1
143
self.branch2 = branch2
144
Exception.__init__(self, "These branches have diverged.")
145
111
146
112
147
######################################################################
113
148
# branch objects
116
151
"""Branch holding a history of revisions.
117
152
118
153
base
119
Base directory/url of the branch.
120
"""
121
base = None
122
123
def __init__(self, *ignored, **ignored_too):
124
raise NotImplementedError('The Branch class is abstract')
125
126
@staticmethod
127
def open(base):
128
"""Open an existing branch, rooted at 'base' (url)"""
129
if base and (base.startswith('http://') or base.startswith('https://')):
130
from bzrlib.remotebranch import RemoteBranch
131
return RemoteBranch(base, find_root=False)
132
else:
133
return LocalBranch(base, find_root=False)
134
135
@staticmethod
136
def open_containing(url):
137
"""Open an existing branch, containing url (search upwards for the root)
138
"""
139
if url and (url.startswith('http://') or url.startswith('https://')):
140
from bzrlib.remotebranch import RemoteBranch
141
return RemoteBranch(url)
142
else:
143
return LocalBranch(url)
144
145
@staticmethod
146
def initialize(base):
147
"""Create a new branch, rooted at 'base' (url)"""
148
if base and (base.startswith('http://') or base.startswith('https://')):
149
from bzrlib.remotebranch import RemoteBranch
150
return RemoteBranch(base, init=True)
151
else:
152
return LocalBranch(base, init=True)
153
154
def setup_caching(self, cache_root):
155
"""Subclasses that care about caching should override this, and set
156
up cached stores located under cache_root.
157
"""
158
159
160
class LocalBranch(Branch):
161
"""A branch stored in the actual filesystem.
162
163
Note that it's "local" in the context of the filesystem; it doesn't
164
really matter if it's on an nfs/smb/afs/coda/... share, as long as
165
it's writable, and can be accessed via the normal filesystem API.
154
Base directory of the branch.
166
155
167
156
_lock_mode
168
157
None, or 'r' or 'w'
174
163
_lock
175
164
Lock object from bzrlib.lock.
176
165
"""
177
# We actually expect this class to be somewhat short-lived; part of its
178
# purpose is to try to isolate what bits of the branch logic are tied to
179
# filesystem access, so that in a later step, we can extricate them to
180
# a separarte ("storage") class.
166
base = None
181
167
_lock_mode = None
182
168
_lock_count = None
183
169
_lock = None
170
171
# Map some sort of prefix into a namespace
172
# stuff like "revno:10", "revid:", etc.
173
# This should match a prefix with a function which accepts
174
REVISION_NAMESPACES = {}
184
175
185
176
def __init__(self, base, init=False, find_root=True):
186
177
"""Create new branch object at a particular location.
187
178
188
base -- Base directory for the branch. May be a file:// url.
179
base -- Base directory for the branch.
189
180
190
181
init -- If True, create new control files in a previously
191
182
unversioned directory. If False, the branch must already
204
195
elif find_root:
205
196
self.base = find_branch_root(base)
206
197
else:
207
if base.startswith("file://"):
208
base = base[7:]
209
198
self.base = os.path.realpath(base)
210
199
if not isdir(self.controlfilename('.')):
200
from errors import NotBranchError
211
201
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
212
202
['use "bzr init" to initialize a new working tree',
213
203
'current bzr can only operate from top-of-tree'])
214
204
self._check_format()
215
205
216
self.text_store = ImmutableStore(self.controlfilename('text-store'))
206
self.weave_store = WeaveStore(self.controlfilename('weaves'))
217
207
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
218
208
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
219
209
227
217
228
218
def __del__(self):
229
219
if self._lock_mode or self._lock:
230
from bzrlib.warnings import warn
220
from warnings import warn
231
221
warn("branch %r was not explicitly unlocked" % self)
232
222
self._lock.unlock()
233
223
224
234
225
def lock_write(self):
235
226
if self._lock_mode:
236
227
if self._lock_mode != 'w':
237
from bzrlib.errors import LockError
228
from errors import LockError
238
229
raise LockError("can't upgrade to a write lock from %r" %
239
230
self._lock_mode)
240
231
self._lock_count += 1
260
251
261
252
def unlock(self):
262
253
if not self._lock_mode:
263
from bzrlib.errors import LockError
254
from errors import LockError
264
255
raise LockError('branch %r is not locked' % (self))
265
256
266
257
if self._lock_count > 1:
313
304
raise BzrError("invalid controlfile mode %r" % mode)
314
305
315
306
def _make_control(self):
316
from bzrlib.inventory import Inventory
317
318
307
os.mkdir(self.controlfilename([]))
319
308
self.controlfile('README', 'w').write(
320
309
"This is a Bazaar-NG control directory.\n"
321
310
"Do not change any files in this directory.\n")
322
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
323
for d in ('text-store', 'inventory-store', 'revision-store'):
311
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT_5)
312
for d in ('text-store', 'inventory-store', 'revision-store',
313
'weaves'):
324
314
os.mkdir(self.controlfilename(d))
325
315
for f in ('revision-history', 'merged-patches',
326
316
'pending-merged-patches', 'branch-name',
333
323
# them; they're not needed for now and so ommitted for
334
324
# simplicity.
335
325
f = self.controlfile('inventory','w')
336
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
326
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), f)
337
327
338
328
339
329
def _check_format(self):
340
330
"""Check this branch format is supported.
341
331
342
The current tool only supports the current unstable format.
332
The format level is stored, as an integer, in
333
self._branch_format for code that needs to check it later.
343
334
344
335
In the future, we might need different in-memory Branch
345
336
classes to support downlevel branches. But not yet.
346
337
"""
347
# This ignores newlines so that we can open branches created
348
# on Windows from Linux and so on. I think it might be better
349
# to always make all internal files in unix format.
350
338
fmt = self.controlfile('branch-format', 'r').read()
351
fmt = fmt.replace('\r\n', '\n')
352
if fmt != BZR_BRANCH_FORMAT:
353
raise BzrError('sorry, branch format %r not supported' % fmt,
354
['use a different bzr version',
355
'or remove the .bzr directory and "bzr init" again'])
339
if fmt == BZR_BRANCH_FORMAT_5:
340
self._branch_format = 5
341
else:
342
raise BzrError('sorry, branch format "%s" not supported; '
343
'use a different bzr version, '
344
'or run "bzr upgrade", '
345
'or remove the .bzr directory and "bzr init" again'
346
% fmt.rstrip('\n\r'))
356
347
357
348
def get_root_id(self):
358
349
"""Return the id of this branches root"""
373
364
374
365
def read_working_inventory(self):
375
366
"""Read the working inventory."""
376
from bzrlib.inventory import Inventory
377
367
self.lock_read()
378
368
try:
379
369
# ElementTree does its own conversion from UTF-8, so open in
380
370
# binary.
381
371
f = self.controlfile('inventory', 'rb')
382
return bzrlib.xml.serializer_v4.read_inventory(f)
372
return bzrlib.xml5.serializer_v5.read_inventory(f)
383
373
finally:
384
374
self.unlock()
385
375
396
386
try:
397
387
f = AtomicFile(self.controlfilename('inventory'), 'wb')
398
388
try:
399
bzrlib.xml.serializer_v4.write_inventory(inv, f)
389
bzrlib.xml5.serializer_v5.write_inventory(inv, f)
400
390
f.commit()
401
391
finally:
402
392
f.close()
483
473
"""Print `file` to stdout."""
484
474
self.lock_read()
485
475
try:
486
tree = self.revision_tree(self.get_rev_id(revno))
476
tree = self.revision_tree(self.lookup_revision(revno))
487
477
# use inventory as it was in that revision
488
478
file_id = tree.inventory.path2id(file)
489
479
if not file_id:
596
586
try:
597
587
try:
598
588
return self.revision_store[revision_id]
599
except (IndexError, KeyError):
589
except IndexError:
600
590
raise bzrlib.errors.NoSuchRevision(self, revision_id)
601
591
finally:
602
592
self.unlock()
611
601
xml_file = self.get_revision_xml_file(revision_id)
612
602
613
603
try:
614
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
604
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
615
605
except SyntaxError, e:
616
606
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
617
607
[revision_id,
655
645
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
656
646
657
647
658
def get_inventory(self, inventory_id):
648
def get_inventory(self, revision_id):
659
649
"""Get Inventory object by hash.
660
650
661
651
TODO: Perhaps for this and similar methods, take a revision
662
652
parameter which can be either an integer revno or a
663
653
string hash."""
664
from bzrlib.inventory import Inventory
665
666
f = self.get_inventory_xml_file(inventory_id)
667
return bzrlib.xml.serializer_v4.read_inventory(f)
668
669
670
def get_inventory_xml(self, inventory_id):
654
f = self.get_inventory_xml_file(revision_id)
655
return bzrlib.xml5.serializer_v5.read_inventory(f)
656
657
658
def get_inventory_xml(self, revision_id):
671
659
"""Get inventory XML as a file object."""
672
return self.inventory_store[inventory_id]
660
try:
661
assert isinstance(revision_id, basestring), type(revision_id)
662
return self.inventory_store[revision_id]
663
except IndexError:
664
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
673
665
674
666
get_inventory_xml_file = get_inventory_xml
675
667
676
668
677
def get_inventory_sha1(self, inventory_id):
669
def get_inventory_sha1(self, revision_id):
678
670
"""Return the sha1 hash of the inventory entry
679
671
"""
680
return sha_file(self.get_inventory_xml(inventory_id))
672
return sha_file(self.get_inventory_xml_file(revision_id))
681
673
682
674
683
675
def get_revision_inventory(self, revision_id):
685
677
# bzr 0.0.6 imposes the constraint that the inventory_id
686
678
# must be the same as its revision, so this is trivial.
687
679
if revision_id == None:
688
from bzrlib.inventory import Inventory
689
680
return Inventory(self.get_root_id())
690
681
else:
691
682
return self.get_inventory(revision_id)
707
698
708
699
def common_ancestor(self, other, self_revno=None, other_revno=None):
709
700
"""
710
>>> from bzrlib.commit import commit
701
>>> import commit
711
702
>>> sb = ScratchBranch(files=['foo', 'foo~'])
712
703
>>> sb.common_ancestor(sb) == (None, None)
713
704
True
714
>>> commit(sb, "Committing first revision", verbose=False)
705
>>> commit.commit(sb, "Committing first revision", verbose=False)
715
706
>>> sb.common_ancestor(sb)[0]
716
707
1
717
708
>>> clone = sb.clone()
718
>>> commit(sb, "Committing second revision", verbose=False)
709
>>> commit.commit(sb, "Committing second revision", verbose=False)
719
710
>>> sb.common_ancestor(sb)[0]
720
711
2
721
712
>>> sb.common_ancestor(clone)[0]
722
713
1
723
>>> commit(clone, "Committing divergent second revision",
714
>>> commit.commit(clone, "Committing divergent second revision",
724
715
... verbose=False)
725
716
>>> sb.common_ancestor(clone)[0]
726
717
1
817
808
"""Pull in all new revisions from other branch.
818
809
"""
819
810
from bzrlib.fetch import greedy_fetch
820
from bzrlib.revision import get_intervening_revisions
821
811
822
812
pb = bzrlib.ui.ui_factory.progress_bar()
823
813
pb.update('comparing histories')
824
if stop_revision is None:
825
other_revision = other.last_patch()
814
815
revision_ids = self.missing_revisions(other, stop_revision)
816
817
if len(revision_ids) > 0:
818
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
826
819
else:
827
other_revision = other.get_rev_id(stop_revision)
828
count = greedy_fetch(self, other, other_revision, pb)[0]
829
try:
830
revision_ids = self.missing_revisions(other, stop_revision)
831
except DivergedBranches, e:
832
try:
833
revision_ids = get_intervening_revisions(self.last_patch(),
834
other_revision, self)
835
assert self.last_patch() not in revision_ids
836
except bzrlib.errors.NotAncestor:
837
raise e
838
820
count = 0
839
821
self.append_revision(*revision_ids)
822
## note("Added %d revisions." % count)
840
823
pb.clear()
841
824
842
825
def install_revisions(self, other, revision_ids, pb):
843
826
if hasattr(other.revision_store, "prefetch"):
844
827
other.revision_store.prefetch(revision_ids)
845
828
if hasattr(other.inventory_store, "prefetch"):
846
inventory_ids = []
847
for rev_id in revision_ids:
848
try:
849
revision = other.get_revision(rev_id).inventory_id
850
inventory_ids.append(revision)
851
except bzrlib.errors.NoSuchRevision:
852
pass
829
inventory_ids = [other.get_revision(r).inventory_id
830
for r in revision_ids]
853
831
other.inventory_store.prefetch(inventory_ids)
854
832
855
833
if pb is None:
895
873
896
874
897
875
def commit(self, *args, **kw):
898
from bzrlib.commit import commit
899
commit(self, *args, **kw)
876
from bzrlib.commit import Commit
877
Commit().commit(self, *args, **kw)
900
878
879
880
def lookup_revision(self, revision):
881
"""Return the revision identifier for a given revision information."""
882
revno, info = self._get_revision_info(revision)
883
return info
884
885
901
886
def revision_id_to_revno(self, revision_id):
902
887
"""Given a revision id, return its revno"""
903
888
history = self.revision_history()
906
891
except ValueError:
907
892
raise bzrlib.errors.NoSuchRevision(self, revision_id)
908
893
894
895
def get_revision_info(self, revision):
896
"""Return (revno, revision id) for revision identifier.
897
898
revision can be an integer, in which case it is assumed to be revno (though
899
this will translate negative values into positive ones)
900
revision can also be a string, in which case it is parsed for something like
901
'date:' or 'revid:' etc.
902
"""
903
revno, rev_id = self._get_revision_info(revision)
904
if revno is None:
905
raise bzrlib.errors.NoSuchRevision(self, revision)
906
return revno, rev_id
907
909
908
def get_rev_id(self, revno, history=None):
910
909
"""Find the revision id of the specified revno."""
911
910
if revno == 0:
916
915
raise bzrlib.errors.NoSuchRevision(self, revno)
917
916
return history[revno - 1]
918
917
918
def _get_revision_info(self, revision):
919
"""Return (revno, revision id) for revision specifier.
920
921
revision can be an integer, in which case it is assumed to be revno
922
(though this will translate negative values into positive ones)
923
revision can also be a string, in which case it is parsed for something
924
like 'date:' or 'revid:' etc.
925
926
A revid is always returned. If it is None, the specifier referred to
927
the null revision. If the revid does not occur in the revision
928
history, revno will be None.
929
"""
930
931
if revision is None:
932
return 0, None
933
revno = None
934
try:# Convert to int if possible
935
revision = int(revision)
936
except ValueError:
937
pass
938
revs = self.revision_history()
939
if isinstance(revision, int):
940
if revision < 0:
941
revno = len(revs) + revision + 1
942
else:
943
revno = revision
944
rev_id = self.get_rev_id(revno, revs)
945
elif isinstance(revision, basestring):
946
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
947
if revision.startswith(prefix):
948
result = func(self, revs, revision)
949
if len(result) > 1:
950
revno, rev_id = result
951
else:
952
revno = result[0]
953
rev_id = self.get_rev_id(revno, revs)
954
break
955
else:
956
raise BzrError('No namespace registered for string: %r' %
957
revision)
958
else:
959
raise TypeError('Unhandled revision type %s' % revision)
960
961
if revno is None:
962
if rev_id is None:
963
raise bzrlib.errors.NoSuchRevision(self, revision)
964
return revno, rev_id
965
966
def _namespace_revno(self, revs, revision):
967
"""Lookup a revision by revision number"""
968
assert revision.startswith('revno:')
969
try:
970
return (int(revision[6:]),)
971
except ValueError:
972
return None
973
REVISION_NAMESPACES['revno:'] = _namespace_revno
974
975
def _namespace_revid(self, revs, revision):
976
assert revision.startswith('revid:')
977
rev_id = revision[len('revid:'):]
978
try:
979
return revs.index(rev_id) + 1, rev_id
980
except ValueError:
981
return None, rev_id
982
REVISION_NAMESPACES['revid:'] = _namespace_revid
983
984
def _namespace_last(self, revs, revision):
985
assert revision.startswith('last:')
986
try:
987
offset = int(revision[5:])
988
except ValueError:
989
return (None,)
990
else:
991
if offset <= 0:
992
raise BzrError('You must supply a positive value for --revision last:XXX')
993
return (len(revs) - offset + 1,)
994
REVISION_NAMESPACES['last:'] = _namespace_last
995
996
def _namespace_tag(self, revs, revision):
997
assert revision.startswith('tag:')
998
raise BzrError('tag: namespace registered, but not implemented.')
999
REVISION_NAMESPACES['tag:'] = _namespace_tag
1000
1001
def _namespace_date(self, revs, revision):
1002
assert revision.startswith('date:')
1003
import datetime
1004
# Spec for date revisions:
1005
# date:value
1006
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
1007
# it can also start with a '+/-/='. '+' says match the first
1008
# entry after the given date. '-' is match the first entry before the date
1009
# '=' is match the first entry after, but still on the given date.
1010
#
1011
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
1012
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
1013
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
1014
# May 13th, 2005 at 0:00
1015
#
1016
# So the proper way of saying 'give me all entries for today' is:
1017
# -r {date:+today}:{date:-tomorrow}
1018
# The default is '=' when not supplied
1019
val = revision[5:]
1020
match_style = '='
1021
if val[:1] in ('+', '-', '='):
1022
match_style = val[:1]
1023
val = val[1:]
1024
1025
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1026
if val.lower() == 'yesterday':
1027
dt = today - datetime.timedelta(days=1)
1028
elif val.lower() == 'today':
1029
dt = today
1030
elif val.lower() == 'tomorrow':
1031
dt = today + datetime.timedelta(days=1)
1032
else:
1033
import re
1034
# This should be done outside the function to avoid recompiling it.
1035
_date_re = re.compile(
1036
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1037
r'(,|T)?\s*'
1038
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1039
)
1040
m = _date_re.match(val)
1041
if not m or (not m.group('date') and not m.group('time')):
1042
raise BzrError('Invalid revision date %r' % revision)
1043
1044
if m.group('date'):
1045
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1046
else:
1047
year, month, day = today.year, today.month, today.day
1048
if m.group('time'):
1049
hour = int(m.group('hour'))
1050
minute = int(m.group('minute'))
1051
if m.group('second'):
1052
second = int(m.group('second'))
1053
else:
1054
second = 0
1055
else:
1056
hour, minute, second = 0,0,0
1057
1058
dt = datetime.datetime(year=year, month=month, day=day,
1059
hour=hour, minute=minute, second=second)
1060
first = dt
1061
last = None
1062
reversed = False
1063
if match_style == '-':
1064
reversed = True
1065
elif match_style == '=':
1066
last = dt + datetime.timedelta(days=1)
1067
1068
if reversed:
1069
for i in range(len(revs)-1, -1, -1):
1070
r = self.get_revision(revs[i])
1071
# TODO: Handle timezone.
1072
dt = datetime.datetime.fromtimestamp(r.timestamp)
1073
if first >= dt and (last is None or dt >= last):
1074
return (i+1,)
1075
else:
1076
for i in range(len(revs)):
1077
r = self.get_revision(revs[i])
1078
# TODO: Handle timezone.
1079
dt = datetime.datetime.fromtimestamp(r.timestamp)
1080
if first <= dt and (last is None or dt <= last):
1081
return (i+1,)
1082
REVISION_NAMESPACES['date:'] = _namespace_date
919
1083
920
1084
def revision_tree(self, revision_id):
921
1085
"""Return Tree for a revision on this branch.
928
1092
return EmptyTree()
929
1093
else:
930
1094
inv = self.get_revision_inventory(revision_id)
931
return RevisionTree(self.text_store, inv)
1095
return RevisionTree(self.weave_store, inv, revision_id)
932
1096
933
1097
934
1098
def working_tree(self):
935
1099
"""Return a `Tree` for the working copy."""
936
from bzrlib.workingtree import WorkingTree
1100
from workingtree import WorkingTree
937
1101
return WorkingTree(self.base, self.read_working_inventory())
938
1102
939
1103
942
1106
943
1107
If there are no revisions yet, return an `EmptyTree`.
944
1108
"""
945
r = self.last_patch()
946
if r == None:
947
return EmptyTree()
948
else:
949
return RevisionTree(self.text_store, self.get_revision_inventory(r))
950
1109
return self.revision_tree(self.last_patch())
951
1110
952
1111
953
1112
def rename_one(self, from_rel, to_rel):
1204
1363
raise InvalidRevisionNumber(revno)
1205
1364
1206
1365
1207
1208
1209
1210
class ScratchBranch(LocalBranch):
1366
1367
1368
class ScratchBranch(Branch):
1211
1369
"""Special test class: a branch that cleans up after itself.
1212
1370
1213
1371
>>> b = ScratchBranch()
1230
1388
if base is None:
1231
1389
base = mkdtemp()
1232
1390
init = True
1233
LocalBranch.__init__(self, base, init=init)
1391
Branch.__init__(self, base, init=init)
1234
1392
for d in dirs:
1235
1393
os.mkdir(self.abspath(d))
1236
1394
1331
1489
return gen_file_id('TREE_ROOT')
1332
1490
1333
1491
1492
def pull_loc(branch):
1493
# TODO: Should perhaps just make attribute be 'base' in
1494
# RemoteBranch and Branch?
1495
if hasattr(branch, "baseurl"):
1496
return branch.baseurl
1497
else:
1498
return branch.base
1499
1500
1334
1501
def copy_branch(branch_from, to_location, revision=None):
1335
1502
"""Copy branch_from into the existing directory to_location.
1336
1503
1342
1509
The name of a local directory that exists but is empty.
1343
1510
"""
1344
1511
from bzrlib.merge import merge
1345
from bzrlib.revisionspec import RevisionSpec
1512
from bzrlib.branch import Branch
1346
1513
1347
1514
assert isinstance(branch_from, Branch)
1348
1515
assert isinstance(to_location, basestring)
1349
1516
1350
br_to = Branch.initialize(to_location)
1517
br_to = Branch(to_location, init=True)
1351
1518
br_to.set_root_id(branch_from.get_root_id())
1352
1519
if revision is None:
1353
1520
revno = branch_from.revno()
1354
1521
else:
1355
revno, rev_id = RevisionSpec(revision).in_history(branch_from)
1522
revno, rev_id = branch_from.get_revision_info(revision)
1356
1523
br_to.update_revisions(branch_from, stop_revision=revno)
1357
1524
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1358
1525
check_clean=False, ignore_zero=True)
1359
br_to.set_parent(branch_from.base)
1360
return br_to
1526
1527
from_location = pull_loc(branch_from)
1528
br_to.set_parent(pull_loc(branch_from))
1529
Loggerhead is a web-based interface for Breezy
Version: 2.0.1