« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 974.1.91
- compare with another revision
- download diff
- download tarball
- view history from revision 974.1.91
- Committer: Aaron Bentley
- Date: 2005-09-19 02:33:09 UTC
- mfrom: (1185.3.27)
- mto: (1185.1.29)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: aaron.bentley@utoronto.ca-20050919023309-24e8871f7f8b31cf
Merged latest from mpool
- files added:
- bzrlib/builtins.py
- files removed:
- bzrlib/plugins/checkperms
- files modified:
- .bzrignore
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
import bzrlib.errors
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId, \
28
DivergedBranches, NotBranchError
29
29
from bzrlib.textui import show_status
30
30
from bzrlib.revision import Revision
31
from bzrlib.xml import unpack_xml
32
31
from bzrlib.delta import compare_trees
33
32
from bzrlib.tree import EmptyTree, RevisionTree
33
import bzrlib.xml
34
34
import bzrlib.ui
35
35
36
36
43
43
# repeatedly to calculate deltas. We could perhaps have a weakref
44
44
# cache in memory to make this faster.
45
45
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
48
49
50
def find_branch(f, **args):
51
if f and (f.startswith('http://') or f.startswith('https://')):
52
import remotebranch
53
return remotebranch.RemoteBranch(f, **args)
54
else:
55
return Branch(f, **args)
56
57
58
def find_cached_branch(f, cache_root, **args):
59
from remotebranch import RemoteBranch
60
br = find_branch(f, **args)
61
def cacheify(br, store_name):
62
from meta_store import CachedStore
63
cache_path = os.path.join(cache_root, store_name)
64
os.mkdir(cache_path)
65
new_store = CachedStore(getattr(br, store_name), cache_path)
66
setattr(br, store_name, new_store)
67
68
if isinstance(br, RemoteBranch):
69
cacheify(br, 'inventory_store')
70
cacheify(br, 'text_store')
71
cacheify(br, 'revision_store')
72
return br
73
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')
74
50
75
51
def _relpath(base, path):
76
52
"""Return path relative to base, or raise exception.
94
70
if tail:
95
71
s.insert(0, tail)
96
72
else:
97
from errors import NotBranchError
98
73
raise NotBranchError("path %r is not within branch %r" % (rp, base))
99
74
100
75
return os.sep.join(s)
128
103
head, tail = os.path.split(f)
129
104
if head == f:
130
105
# reached the root, whatever that may be
131
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
106
raise NotBranchError('%s is not in a branch' % orig_f)
132
107
f = head
133
108
134
109
135
110
136
# XXX: move into bzrlib.errors; subclass BzrError
137
class DivergedBranches(Exception):
138
def __init__(self, branch1, branch2):
139
self.branch1 = branch1
140
self.branch2 = branch2
141
Exception.__init__(self, "These branches have diverged.")
142
143
111
144
112
######################################################################
145
113
# branch objects
148
116
"""Branch holding a history of revisions.
149
117
150
118
base
151
Base directory of the branch.
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.
152
166
153
167
_lock_mode
154
168
None, or 'r' or 'w'
160
174
_lock
161
175
Lock object from bzrlib.lock.
162
176
"""
163
base = None
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.
164
181
_lock_mode = None
165
182
_lock_count = None
166
183
_lock = None
167
168
# Map some sort of prefix into a namespace
169
# stuff like "revno:10", "revid:", etc.
170
# This should match a prefix with a function which accepts
171
REVISION_NAMESPACES = {}
172
184
173
185
def __init__(self, base, init=False, find_root=True):
174
186
"""Create new branch object at a particular location.
175
187
176
base -- Base directory for the branch.
188
base -- Base directory for the branch. May be a file:// url.
177
189
178
190
init -- If True, create new control files in a previously
179
191
unversioned directory. If False, the branch must already
192
204
elif find_root:
193
205
self.base = find_branch_root(base)
194
206
else:
207
if base.startswith("file://"):
208
base = base[7:]
195
209
self.base = os.path.realpath(base)
196
210
if not isdir(self.controlfilename('.')):
197
from errors import NotBranchError
198
211
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
199
212
['use "bzr init" to initialize a new working tree',
200
213
'current bzr can only operate from top-of-tree'])
214
227
215
228
def __del__(self):
216
229
if self._lock_mode or self._lock:
217
from warnings import warn
230
from bzrlib.warnings import warn
218
231
warn("branch %r was not explicitly unlocked" % self)
219
232
self._lock.unlock()
220
233
221
222
234
def lock_write(self):
223
235
if self._lock_mode:
224
236
if self._lock_mode != 'w':
225
from errors import LockError
237
from bzrlib.errors import LockError
226
238
raise LockError("can't upgrade to a write lock from %r" %
227
239
self._lock_mode)
228
240
self._lock_count += 1
248
260
249
261
def unlock(self):
250
262
if not self._lock_mode:
251
from errors import LockError
263
from bzrlib.errors import LockError
252
264
raise LockError('branch %r is not locked' % (self))
253
265
254
266
if self._lock_count > 1:
302
314
303
315
def _make_control(self):
304
316
from bzrlib.inventory import Inventory
305
from bzrlib.xml import pack_xml
306
317
307
318
os.mkdir(self.controlfilename([]))
308
319
self.controlfile('README', 'w').write(
321
332
# if we want per-tree root ids then this is the place to set
322
333
# them; they're not needed for now and so ommitted for
323
334
# simplicity.
324
pack_xml(Inventory(), self.controlfile('inventory','w'))
335
f = self.controlfile('inventory','w')
336
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
337
325
338
326
339
def _check_format(self):
327
340
"""Check this branch format is supported.
335
348
# on Windows from Linux and so on. I think it might be better
336
349
# to always make all internal files in unix format.
337
350
fmt = self.controlfile('branch-format', 'r').read()
338
fmt.replace('\r\n', '')
351
fmt = fmt.replace('\r\n', '\n')
339
352
if fmt != BZR_BRANCH_FORMAT:
340
353
raise BzrError('sorry, branch format %r not supported' % fmt,
341
354
['use a different bzr version',
361
374
def read_working_inventory(self):
362
375
"""Read the working inventory."""
363
376
from bzrlib.inventory import Inventory
364
from bzrlib.xml import unpack_xml
365
from time import time
366
before = time()
367
377
self.lock_read()
368
378
try:
369
379
# ElementTree does its own conversion from UTF-8, so open in
370
380
# binary.
371
inv = unpack_xml(Inventory,
372
self.controlfile('inventory', 'rb'))
373
mutter("loaded inventory of %d items in %f"
374
% (len(inv), time() - before))
375
return inv
381
f = self.controlfile('inventory', 'rb')
382
return bzrlib.xml.serializer_v4.read_inventory(f)
376
383
finally:
377
384
self.unlock()
378
385
384
391
will be committed to the next revision.
385
392
"""
386
393
from bzrlib.atomicfile import AtomicFile
387
from bzrlib.xml import pack_xml
388
394
389
395
self.lock_write()
390
396
try:
391
397
f = AtomicFile(self.controlfilename('inventory'), 'wb')
392
398
try:
393
pack_xml(inv, f)
399
bzrlib.xml.serializer_v4.write_inventory(inv, f)
394
400
f.commit()
395
401
finally:
396
402
f.close()
404
410
"""Inventory for the working copy.""")
405
411
406
412
407
def add(self, files, verbose=False, ids=None):
413
def add(self, files, ids=None):
408
414
"""Make files versioned.
409
415
410
Note that the command line normally calls smart_add instead.
416
Note that the command line normally calls smart_add instead,
417
which can automatically recurse.
411
418
412
419
This puts the files in the Added state, so that they will be
413
420
recorded by the next commit.
423
430
TODO: Perhaps have an option to add the ids even if the files do
424
431
not (yet) exist.
425
432
426
TODO: Perhaps return the ids of the files? But then again it
427
is easy to retrieve them if they're needed.
428
429
TODO: Adding a directory should optionally recurse down and
430
add all non-ignored children. Perhaps do that in a
431
higher-level method.
433
TODO: Perhaps yield the ids and paths as they're added.
432
434
"""
433
435
# TODO: Re-adding a file that is removed in the working copy
434
436
# should probably put it back with the previous ID.
470
472
file_id = gen_file_id(f)
471
473
inv.add_path(f, kind=kind, file_id=file_id)
472
474
473
if verbose:
474
print 'added', quotefn(f)
475
476
475
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
477
476
478
477
self._write_inventory(inv)
484
483
"""Print `file` to stdout."""
485
484
self.lock_read()
486
485
try:
487
tree = self.revision_tree(self.lookup_revision(revno))
486
tree = self.revision_tree(self.get_rev_id(revno))
488
487
# use inventory as it was in that revision
489
488
file_id = tree.inventory.path2id(file)
490
489
if not file_id:
588
587
f.close()
589
588
590
589
591
def get_revision_xml(self, revision_id):
590
def get_revision_xml_file(self, revision_id):
592
591
"""Return XML file object for revision object."""
593
592
if not revision_id or not isinstance(revision_id, basestring):
594
593
raise InvalidRevisionId(revision_id)
597
596
try:
598
597
try:
599
598
return self.revision_store[revision_id]
600
except IndexError:
599
except (IndexError, KeyError):
601
600
raise bzrlib.errors.NoSuchRevision(self, revision_id)
602
601
finally:
603
602
self.unlock()
604
603
605
604
605
#deprecated
606
get_revision_xml = get_revision_xml_file
607
608
606
609
def get_revision(self, revision_id):
607
610
"""Return the Revision object for a named revision"""
608
xml_file = self.get_revision_xml(revision_id)
611
xml_file = self.get_revision_xml_file(revision_id)
609
612
610
613
try:
611
r = unpack_xml(Revision, xml_file)
614
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
612
615
except SyntaxError, e:
613
616
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
614
617
[revision_id,
659
662
parameter which can be either an integer revno or a
660
663
string hash."""
661
664
from bzrlib.inventory import Inventory
662
from bzrlib.xml import unpack_xml
663
665
664
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
666
f = self.get_inventory_xml_file(inventory_id)
667
return bzrlib.xml.serializer_v4.read_inventory(f)
665
668
666
669
667
670
def get_inventory_xml(self, inventory_id):
668
671
"""Get inventory XML as a file object."""
669
672
return self.inventory_store[inventory_id]
673
674
get_inventory_xml_file = get_inventory_xml
670
675
671
676
672
677
def get_inventory_sha1(self, inventory_id):
702
707
703
708
def common_ancestor(self, other, self_revno=None, other_revno=None):
704
709
"""
705
>>> import commit
710
>>> from bzrlib.commit import commit
706
711
>>> sb = ScratchBranch(files=['foo', 'foo~'])
707
712
>>> sb.common_ancestor(sb) == (None, None)
708
713
True
709
>>> commit.commit(sb, "Committing first revision", verbose=False)
714
>>> commit(sb, "Committing first revision", verbose=False)
710
715
>>> sb.common_ancestor(sb)[0]
711
716
1
712
717
>>> clone = sb.clone()
713
>>> commit.commit(sb, "Committing second revision", verbose=False)
718
>>> commit(sb, "Committing second revision", verbose=False)
714
719
>>> sb.common_ancestor(sb)[0]
715
720
2
716
721
>>> sb.common_ancestor(clone)[0]
717
722
1
718
>>> commit.commit(clone, "Committing divergent second revision",
723
>>> commit(clone, "Committing divergent second revision",
719
724
... verbose=False)
720
725
>>> sb.common_ancestor(clone)[0]
721
726
1
812
817
"""Pull in all new revisions from other branch.
813
818
"""
814
819
from bzrlib.fetch import greedy_fetch
820
from bzrlib.revision import get_intervening_revisions
815
821
816
822
pb = bzrlib.ui.ui_factory.progress_bar()
817
823
pb.update('comparing histories')
818
819
revision_ids = self.missing_revisions(other, stop_revision)
820
821
if len(revision_ids) > 0:
822
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
824
if stop_revision is None:
825
other_revision = other.last_patch()
823
826
else:
824
count = 0
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
825
839
self.append_revision(*revision_ids)
826
## note("Added %d revisions." % count)
827
840
pb.clear()
828
841
829
842
def install_revisions(self, other, revision_ids, pb):
830
843
if hasattr(other.revision_store, "prefetch"):
831
844
other.revision_store.prefetch(revision_ids)
832
845
if hasattr(other.inventory_store, "prefetch"):
833
inventory_ids = [other.get_revision(r).inventory_id
834
for r in revision_ids]
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
835
853
other.inventory_store.prefetch(inventory_ids)
836
854
837
855
if pb is None:
881
899
commit(self, *args, **kw)
882
900
883
901
884
def lookup_revision(self, revision):
885
"""Return the revision identifier for a given revision information."""
886
revno, info = self._get_revision_info(revision)
887
return info
888
889
902
890
903
def revision_id_to_revno(self, revision_id):
891
904
"""Given a revision id, return its revno"""
896
909
raise bzrlib.errors.NoSuchRevision(self, revision_id)
897
910
898
911
899
def get_revision_info(self, revision):
900
"""Return (revno, revision id) for revision identifier.
901
902
revision can be an integer, in which case it is assumed to be revno (though
903
this will translate negative values into positive ones)
904
revision can also be a string, in which case it is parsed for something like
905
'date:' or 'revid:' etc.
906
"""
907
revno, rev_id = self._get_revision_info(revision)
908
if revno is None:
909
raise bzrlib.errors.NoSuchRevision(self, revision)
910
return revno, rev_id
911
912
912
def get_rev_id(self, revno, history=None):
913
913
"""Find the revision id of the specified revno."""
914
914
if revno == 0:
919
919
raise bzrlib.errors.NoSuchRevision(self, revno)
920
920
return history[revno - 1]
921
921
922
def _get_revision_info(self, revision):
923
"""Return (revno, revision id) for revision specifier.
924
925
revision can be an integer, in which case it is assumed to be revno
926
(though this will translate negative values into positive ones)
927
revision can also be a string, in which case it is parsed for something
928
like 'date:' or 'revid:' etc.
929
930
A revid is always returned. If it is None, the specifier referred to
931
the null revision. If the revid does not occur in the revision
932
history, revno will be None.
933
"""
934
935
if revision is None:
936
return 0, None
937
revno = None
938
try:# Convert to int if possible
939
revision = int(revision)
940
except ValueError:
941
pass
942
revs = self.revision_history()
943
if isinstance(revision, int):
944
if revision < 0:
945
revno = len(revs) + revision + 1
946
else:
947
revno = revision
948
rev_id = self.get_rev_id(revno, revs)
949
elif isinstance(revision, basestring):
950
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
951
if revision.startswith(prefix):
952
result = func(self, revs, revision)
953
if len(result) > 1:
954
revno, rev_id = result
955
else:
956
revno = result[0]
957
rev_id = self.get_rev_id(revno, revs)
958
break
959
else:
960
raise BzrError('No namespace registered for string: %r' %
961
revision)
962
else:
963
raise TypeError('Unhandled revision type %s' % revision)
964
965
if revno is None:
966
if rev_id is None:
967
raise bzrlib.errors.NoSuchRevision(self, revision)
968
return revno, rev_id
969
970
def _namespace_revno(self, revs, revision):
971
"""Lookup a revision by revision number"""
972
assert revision.startswith('revno:')
973
try:
974
return (int(revision[6:]),)
975
except ValueError:
976
return None
977
REVISION_NAMESPACES['revno:'] = _namespace_revno
978
979
def _namespace_revid(self, revs, revision):
980
assert revision.startswith('revid:')
981
rev_id = revision[len('revid:'):]
982
try:
983
return revs.index(rev_id) + 1, rev_id
984
except ValueError:
985
return None, rev_id
986
REVISION_NAMESPACES['revid:'] = _namespace_revid
987
988
def _namespace_last(self, revs, revision):
989
assert revision.startswith('last:')
990
try:
991
offset = int(revision[5:])
992
except ValueError:
993
return (None,)
994
else:
995
if offset <= 0:
996
raise BzrError('You must supply a positive value for --revision last:XXX')
997
return (len(revs) - offset + 1,)
998
REVISION_NAMESPACES['last:'] = _namespace_last
999
1000
def _namespace_tag(self, revs, revision):
1001
assert revision.startswith('tag:')
1002
raise BzrError('tag: namespace registered, but not implemented.')
1003
REVISION_NAMESPACES['tag:'] = _namespace_tag
1004
1005
def _namespace_date(self, revs, revision):
1006
assert revision.startswith('date:')
1007
import datetime
1008
# Spec for date revisions:
1009
# date:value
1010
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
1011
# it can also start with a '+/-/='. '+' says match the first
1012
# entry after the given date. '-' is match the first entry before the date
1013
# '=' is match the first entry after, but still on the given date.
1014
#
1015
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
1016
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
1017
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
1018
# May 13th, 2005 at 0:00
1019
#
1020
# So the proper way of saying 'give me all entries for today' is:
1021
# -r {date:+today}:{date:-tomorrow}
1022
# The default is '=' when not supplied
1023
val = revision[5:]
1024
match_style = '='
1025
if val[:1] in ('+', '-', '='):
1026
match_style = val[:1]
1027
val = val[1:]
1028
1029
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1030
if val.lower() == 'yesterday':
1031
dt = today - datetime.timedelta(days=1)
1032
elif val.lower() == 'today':
1033
dt = today
1034
elif val.lower() == 'tomorrow':
1035
dt = today + datetime.timedelta(days=1)
1036
else:
1037
import re
1038
# This should be done outside the function to avoid recompiling it.
1039
_date_re = re.compile(
1040
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1041
r'(,|T)?\s*'
1042
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1043
)
1044
m = _date_re.match(val)
1045
if not m or (not m.group('date') and not m.group('time')):
1046
raise BzrError('Invalid revision date %r' % revision)
1047
1048
if m.group('date'):
1049
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1050
else:
1051
year, month, day = today.year, today.month, today.day
1052
if m.group('time'):
1053
hour = int(m.group('hour'))
1054
minute = int(m.group('minute'))
1055
if m.group('second'):
1056
second = int(m.group('second'))
1057
else:
1058
second = 0
1059
else:
1060
hour, minute, second = 0,0,0
1061
1062
dt = datetime.datetime(year=year, month=month, day=day,
1063
hour=hour, minute=minute, second=second)
1064
first = dt
1065
last = None
1066
reversed = False
1067
if match_style == '-':
1068
reversed = True
1069
elif match_style == '=':
1070
last = dt + datetime.timedelta(days=1)
1071
1072
if reversed:
1073
for i in range(len(revs)-1, -1, -1):
1074
r = self.get_revision(revs[i])
1075
# TODO: Handle timezone.
1076
dt = datetime.datetime.fromtimestamp(r.timestamp)
1077
if first >= dt and (last is None or dt >= last):
1078
return (i+1,)
1079
else:
1080
for i in range(len(revs)):
1081
r = self.get_revision(revs[i])
1082
# TODO: Handle timezone.
1083
dt = datetime.datetime.fromtimestamp(r.timestamp)
1084
if first <= dt and (last is None or dt <= last):
1085
return (i+1,)
1086
REVISION_NAMESPACES['date:'] = _namespace_date
1087
922
1088
923
def revision_tree(self, revision_id):
1089
924
"""Return Tree for a revision on this branch.
1101
936
1102
937
def working_tree(self):
1103
938
"""Return a `Tree` for the working copy."""
1104
from workingtree import WorkingTree
939
from bzrlib.workingtree import WorkingTree
1105
940
return WorkingTree(self.base, self.read_working_inventory())
1106
941
1107
942
1153
988
1154
989
inv.rename(file_id, to_dir_id, to_tail)
1155
990
1156
print "%s => %s" % (from_rel, to_rel)
1157
1158
991
from_abs = self.abspath(from_rel)
1159
992
to_abs = self.abspath(to_rel)
1160
993
try:
1179
1012
1180
1013
Note that to_name is only the last component of the new name;
1181
1014
this doesn't change the directory.
1015
1016
This returns a list of (from_path, to_path) pairs for each
1017
entry that is moved.
1182
1018
"""
1019
result = []
1183
1020
self.lock_write()
1184
1021
try:
1185
1022
## TODO: Option to move IDs only
1220
1057
for f in from_paths:
1221
1058
name_tail = splitpath(f)[-1]
1222
1059
dest_path = appendpath(to_name, name_tail)
1223
print "%s => %s" % (f, dest_path)
1060
result.append((f, dest_path))
1224
1061
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1225
1062
try:
1226
1063
os.rename(self.abspath(f), self.abspath(dest_path))
1232
1069
finally:
1233
1070
self.unlock()
1234
1071
1072
return result
1073
1235
1074
1236
1075
def revert(self, filenames, old_tree=None, backups=True):
1237
1076
"""Restore selected files to the versions from a previous tree.
1319
1158
self.unlock()
1320
1159
1321
1160
1322
1323
class ScratchBranch(Branch):
1161
def get_parent(self):
1162
"""Return the parent location of the branch.
1163
1164
This is the default location for push/pull/missing. The usual
1165
pattern is that the user can override it by specifying a
1166
location.
1167
"""
1168
import errno
1169
_locs = ['parent', 'pull', 'x-pull']
1170
for l in _locs:
1171
try:
1172
return self.controlfile(l, 'r').read().strip('\n')
1173
except IOError, e:
1174
if e.errno != errno.ENOENT:
1175
raise
1176
return None
1177
1178
1179
def set_parent(self, url):
1180
# TODO: Maybe delete old location files?
1181
from bzrlib.atomicfile import AtomicFile
1182
self.lock_write()
1183
try:
1184
f = AtomicFile(self.controlfilename('parent'))
1185
try:
1186
f.write(url + '\n')
1187
f.commit()
1188
finally:
1189
f.close()
1190
finally:
1191
self.unlock()
1192
1193
def check_revno(self, revno):
1194
"""\
1195
Check whether a revno corresponds to any revision.
1196
Zero (the NULL revision) is considered valid.
1197
"""
1198
if revno != 0:
1199
self.check_real_revno(revno)
1200
1201
def check_real_revno(self, revno):
1202
"""\
1203
Check whether a revno corresponds to a real revision.
1204
Zero (the NULL revision) is considered invalid
1205
"""
1206
if revno < 1 or revno > self.revno():
1207
raise InvalidRevisionNumber(revno)
1208
1209
1210
1211
1212
1213
class ScratchBranch(LocalBranch):
1324
1214
"""Special test class: a branch that cleans up after itself.
1325
1215
1326
1216
>>> b = ScratchBranch()
1343
1233
if base is None:
1344
1234
base = mkdtemp()
1345
1235
init = True
1346
Branch.__init__(self, base, init=init)
1236
LocalBranch.__init__(self, base, init=init)
1347
1237
for d in dirs:
1348
1238
os.mkdir(self.abspath(d))
1349
1239
1366
1256
os.rmdir(base)
1367
1257
copytree(self.base, base, symlinks=True)
1368
1258
return ScratchBranch(base=base)
1259
1260
1369
1261
1370
1262
def __del__(self):
1371
1263
self.destroy()
1442
1334
return gen_file_id('TREE_ROOT')
1443
1335
1444
1336
1445
def pull_loc(branch):
1446
# TODO: Should perhaps just make attribute be 'base' in
1447
# RemoteBranch and Branch?
1448
if hasattr(branch, "baseurl"):
1449
return branch.baseurl
1450
else:
1451
return branch.base
1452
1453
1454
1337
def copy_branch(branch_from, to_location, revision=None):
1455
1338
"""Copy branch_from into the existing directory to_location.
1456
1339
1457
If revision is not None, the head of the new branch will be revision.
1340
revision
1341
If not None, only revisions up to this point will be copied.
1342
The head of the new branch will be that revision.
1343
1344
to_location
1345
The name of a local directory that exists but is empty.
1458
1346
"""
1459
1347
from bzrlib.merge import merge
1460
from bzrlib.branch import Branch
1461
br_to = Branch(to_location, init=True)
1348
from bzrlib.revisionspec import RevisionSpec
1349
1350
assert isinstance(branch_from, Branch)
1351
assert isinstance(to_location, basestring)
1352
1353
br_to = Branch.initialize(to_location)
1462
1354
br_to.set_root_id(branch_from.get_root_id())
1463
1355
if revision is None:
1464
1356
revno = branch_from.revno()
1465
1357
else:
1466
revno, rev_id = branch_from.get_revision_info(revision)
1358
revno, rev_id = RevisionSpec(revision).in_history(branch_from)
1467
1359
br_to.update_revisions(branch_from, stop_revision=revno)
1468
1360
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1469
1361
check_clean=False, ignore_zero=True)
1470
from_location = pull_loc(branch_from)
1471
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
1472
1362
br_to.set_parent(branch_from.base)
1363
return br_to
Loggerhead is a web-based interface for Breezy
Version: 2.0.1