« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.2.6
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.2.6
- Committer: Lalo Martins
- Date: 2005-09-08 00:40:15 UTC
- mto: (1185.1.22)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: lalo@exoweb.net-20050908004014-bb63b3378ac8ff58
turned get_revision_info into a RevisionSpec class
- 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
37
37
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
38
39
## TODO: Maybe include checks for common corruption of newlines, etc?
39
40
48
49
49
50
def find_branch(f, **args):
50
51
if f and (f.startswith('http://') or f.startswith('https://')):
51
import remotebranch
52
return remotebranch.RemoteBranch(f, **args)
52
from bzrlib.remotebranch import RemoteBranch
53
return RemoteBranch(f, **args)
53
54
else:
54
return Branch(f, **args)
55
return LocalBranch(f, **args)
55
56
56
57
57
58
def find_cached_branch(f, cache_root, **args):
58
from remotebranch import RemoteBranch
59
from bzrlib.remotebranch import RemoteBranch
59
60
br = find_branch(f, **args)
60
61
def cacheify(br, store_name):
61
from meta_store import CachedStore
62
from bzrlib.meta_store import CachedStore
62
63
cache_path = os.path.join(cache_root, store_name)
63
64
os.mkdir(cache_path)
64
65
new_store = CachedStore(getattr(br, store_name), cache_path)
93
94
if tail:
94
95
s.insert(0, tail)
95
96
else:
96
from errors import NotBranchError
97
97
raise NotBranchError("path %r is not within branch %r" % (rp, base))
98
98
99
99
return os.sep.join(s)
127
127
head, tail = os.path.split(f)
128
128
if head == f:
129
129
# reached the root, whatever that may be
130
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
130
raise NotBranchError('%s is not in a branch' % orig_f)
131
131
f = head
132
132
133
133
134
134
135
# XXX: move into bzrlib.errors; subclass BzrError
136
class DivergedBranches(Exception):
137
def __init__(self, branch1, branch2):
138
self.branch1 = branch1
139
self.branch2 = branch2
140
Exception.__init__(self, "These branches have diverged.")
141
142
135
143
136
######################################################################
144
137
# branch objects
147
140
"""Branch holding a history of revisions.
148
141
149
142
base
150
Base directory of the branch.
143
Base directory/url of the branch.
144
"""
145
base = None
146
147
def __new__(cls, *a, **kw):
148
"""this is temporary, till we get rid of all code that does
149
b = Branch()
150
"""
151
# XXX: AAARGH! MY EYES! UUUUGLY!!!
152
if cls == Branch:
153
cls = LocalBranch
154
b = object.__new__(cls)
155
return b
156
157
158
class LocalBranch(Branch):
159
"""A branch stored in the actual filesystem.
160
161
Note that it's "local" in the context of the filesystem; it doesn't
162
really matter if it's on an nfs/smb/afs/coda/... share, as long as
163
it's writable, and can be accessed via the normal filesystem API.
151
164
152
165
_lock_mode
153
166
None, or 'r' or 'w'
159
172
_lock
160
173
Lock object from bzrlib.lock.
161
174
"""
162
base = None
175
# We actually expect this class to be somewhat short-lived; part of its
176
# purpose is to try to isolate what bits of the branch logic are tied to
177
# filesystem access, so that in a later step, we can extricate them to
178
# a separarte ("storage") class.
163
179
_lock_mode = None
164
180
_lock_count = None
165
181
_lock = None
166
167
# Map some sort of prefix into a namespace
168
# stuff like "revno:10", "revid:", etc.
169
# This should match a prefix with a function which accepts
170
REVISION_NAMESPACES = {}
171
182
172
183
def __init__(self, base, init=False, find_root=True):
173
184
"""Create new branch object at a particular location.
193
204
else:
194
205
self.base = os.path.realpath(base)
195
206
if not isdir(self.controlfilename('.')):
196
from errors import NotBranchError
197
207
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
198
208
['use "bzr init" to initialize a new working tree',
199
209
'current bzr can only operate from top-of-tree'])
213
223
214
224
def __del__(self):
215
225
if self._lock_mode or self._lock:
216
from warnings import warn
226
from bzrlib.warnings import warn
217
227
warn("branch %r was not explicitly unlocked" % self)
218
228
self._lock.unlock()
219
229
221
231
def lock_write(self):
222
232
if self._lock_mode:
223
233
if self._lock_mode != 'w':
224
from errors import LockError
234
from bzrlib.errors import LockError
225
235
raise LockError("can't upgrade to a write lock from %r" %
226
236
self._lock_mode)
227
237
self._lock_count += 1
247
257
248
258
def unlock(self):
249
259
if not self._lock_mode:
250
from errors import LockError
260
from bzrlib.errors import LockError
251
261
raise LockError('branch %r is not locked' % (self))
252
262
253
263
if self._lock_count > 1:
301
311
302
312
def _make_control(self):
303
313
from bzrlib.inventory import Inventory
304
from bzrlib.xml import pack_xml
305
314
306
315
os.mkdir(self.controlfilename([]))
307
316
self.controlfile('README', 'w').write(
320
329
# if we want per-tree root ids then this is the place to set
321
330
# them; they're not needed for now and so ommitted for
322
331
# simplicity.
323
pack_xml(Inventory(), self.controlfile('inventory','w'))
332
f = self.controlfile('inventory','w')
333
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
334
324
335
325
336
def _check_format(self):
326
337
"""Check this branch format is supported.
334
345
# on Windows from Linux and so on. I think it might be better
335
346
# to always make all internal files in unix format.
336
347
fmt = self.controlfile('branch-format', 'r').read()
337
fmt.replace('\r\n', '')
348
fmt = fmt.replace('\r\n', '\n')
338
349
if fmt != BZR_BRANCH_FORMAT:
339
350
raise BzrError('sorry, branch format %r not supported' % fmt,
340
351
['use a different bzr version',
360
371
def read_working_inventory(self):
361
372
"""Read the working inventory."""
362
373
from bzrlib.inventory import Inventory
363
from bzrlib.xml import unpack_xml
364
from time import time
365
before = time()
366
374
self.lock_read()
367
375
try:
368
376
# ElementTree does its own conversion from UTF-8, so open in
369
377
# binary.
370
inv = unpack_xml(Inventory,
371
self.controlfile('inventory', 'rb'))
372
mutter("loaded inventory of %d items in %f"
373
% (len(inv), time() - before))
374
return inv
378
f = self.controlfile('inventory', 'rb')
379
return bzrlib.xml.serializer_v4.read_inventory(f)
375
380
finally:
376
381
self.unlock()
377
382
383
388
will be committed to the next revision.
384
389
"""
385
390
from bzrlib.atomicfile import AtomicFile
386
from bzrlib.xml import pack_xml
387
391
388
392
self.lock_write()
389
393
try:
390
394
f = AtomicFile(self.controlfilename('inventory'), 'wb')
391
395
try:
392
pack_xml(inv, f)
396
bzrlib.xml.serializer_v4.write_inventory(inv, f)
393
397
f.commit()
394
398
finally:
395
399
f.close()
403
407
"""Inventory for the working copy.""")
404
408
405
409
406
def add(self, files, verbose=False, ids=None):
410
def add(self, files, ids=None):
407
411
"""Make files versioned.
408
412
409
Note that the command line normally calls smart_add instead.
413
Note that the command line normally calls smart_add instead,
414
which can automatically recurse.
410
415
411
416
This puts the files in the Added state, so that they will be
412
417
recorded by the next commit.
422
427
TODO: Perhaps have an option to add the ids even if the files do
423
428
not (yet) exist.
424
429
425
TODO: Perhaps return the ids of the files? But then again it
426
is easy to retrieve them if they're needed.
427
428
TODO: Adding a directory should optionally recurse down and
429
add all non-ignored children. Perhaps do that in a
430
higher-level method.
430
TODO: Perhaps yield the ids and paths as they're added.
431
431
"""
432
432
# TODO: Re-adding a file that is removed in the working copy
433
433
# should probably put it back with the previous ID.
469
469
file_id = gen_file_id(f)
470
470
inv.add_path(f, kind=kind, file_id=file_id)
471
471
472
if verbose:
473
print 'added', quotefn(f)
474
475
472
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
476
473
477
474
self._write_inventory(inv)
483
480
"""Print `file` to stdout."""
484
481
self.lock_read()
485
482
try:
486
tree = self.revision_tree(self.lookup_revision(revno))
483
tree = self.revision_tree(self.get_rev_id(revno))
487
484
# use inventory as it was in that revision
488
485
file_id = tree.inventory.path2id(file)
489
486
if not file_id:
587
584
f.close()
588
585
589
586
590
def get_revision_xml(self, revision_id):
587
def get_revision_xml_file(self, revision_id):
591
588
"""Return XML file object for revision object."""
592
589
if not revision_id or not isinstance(revision_id, basestring):
593
590
raise InvalidRevisionId(revision_id)
602
599
self.unlock()
603
600
604
601
602
#deprecated
603
get_revision_xml = get_revision_xml_file
604
605
605
606
def get_revision(self, revision_id):
606
607
"""Return the Revision object for a named revision"""
607
xml_file = self.get_revision_xml(revision_id)
608
xml_file = self.get_revision_xml_file(revision_id)
608
609
609
610
try:
610
r = unpack_xml(Revision, xml_file)
611
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
611
612
except SyntaxError, e:
612
613
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
613
614
[revision_id,
658
659
parameter which can be either an integer revno or a
659
660
string hash."""
660
661
from bzrlib.inventory import Inventory
661
from bzrlib.xml import unpack_xml
662
662
663
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
663
f = self.get_inventory_xml_file(inventory_id)
664
return bzrlib.xml.serializer_v4.read_inventory(f)
664
665
665
666
666
667
def get_inventory_xml(self, inventory_id):
667
668
"""Get inventory XML as a file object."""
668
669
return self.inventory_store[inventory_id]
670
671
get_inventory_xml_file = get_inventory_xml
669
672
670
673
671
674
def get_inventory_sha1(self, inventory_id):
701
704
702
705
def common_ancestor(self, other, self_revno=None, other_revno=None):
703
706
"""
704
>>> import commit
707
>>> from bzrlib.commit import commit
705
708
>>> sb = ScratchBranch(files=['foo', 'foo~'])
706
709
>>> sb.common_ancestor(sb) == (None, None)
707
710
True
708
>>> commit.commit(sb, "Committing first revision", verbose=False)
711
>>> commit(sb, "Committing first revision", verbose=False)
709
712
>>> sb.common_ancestor(sb)[0]
710
713
1
711
714
>>> clone = sb.clone()
712
>>> commit.commit(sb, "Committing second revision", verbose=False)
715
>>> commit(sb, "Committing second revision", verbose=False)
713
716
>>> sb.common_ancestor(sb)[0]
714
717
2
715
718
>>> sb.common_ancestor(clone)[0]
716
719
1
717
>>> commit.commit(clone, "Committing divergent second revision",
720
>>> commit(clone, "Committing divergent second revision",
718
721
... verbose=False)
719
722
>>> sb.common_ancestor(clone)[0]
720
723
1
809
812
810
813
def update_revisions(self, other, stop_revision=None):
811
814
"""Pull in all new revisions from other branch.
812
813
>>> from bzrlib.commit import commit
814
>>> bzrlib.trace.silent = True
815
>>> br1 = ScratchBranch(files=['foo', 'bar'])
816
>>> br1.add('foo')
817
>>> br1.add('bar')
818
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
819
>>> br2 = ScratchBranch()
820
>>> br2.update_revisions(br1)
821
Added 2 texts.
822
Added 1 inventories.
823
Added 1 revisions.
824
>>> br2.revision_history()
825
[u'REVISION-ID-1']
826
>>> br2.update_revisions(br1)
827
Added 0 texts.
828
Added 0 inventories.
829
Added 0 revisions.
830
>>> br1.text_store.total_size() == br2.text_store.total_size()
831
True
832
815
"""
833
progress = bzrlib.ui.ui_factory.progress_bar()
834
progress.update('comparing histories')
816
from bzrlib.fetch import greedy_fetch
817
818
pb = bzrlib.ui.ui_factory.progress_bar()
819
pb.update('comparing histories')
820
835
821
revision_ids = self.missing_revisions(other, stop_revision)
836
count = self.install_revisions(other, revision_ids, progress=progress)
822
823
if len(revision_ids) > 0:
824
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
825
else:
826
count = 0
837
827
self.append_revision(*revision_ids)
838
print "Added %d revisions." % count
839
828
## note("Added %d revisions." % count)
829
pb.clear()
840
830
841
def install_revisions(self, other, revision_ids, progress=None):
831
def install_revisions(self, other, revision_ids, pb):
842
832
if hasattr(other.revision_store, "prefetch"):
843
833
other.revision_store.prefetch(revision_ids)
844
834
if hasattr(other.inventory_store, "prefetch"):
845
835
inventory_ids = [other.get_revision(r).inventory_id
846
836
for r in revision_ids]
847
837
other.inventory_store.prefetch(inventory_ids)
838
839
if pb is None:
840
pb = bzrlib.ui.ui_factory.progress_bar()
848
841
849
842
revisions = []
850
843
needed_texts = set()
851
844
i = 0
852
for rev_id in revision_ids:
853
i += 1
854
if progress:
855
progress.update('fetching revision', i, len(revision_ids))
856
rev = other.get_revision(rev_id)
845
846
failures = set()
847
for i, rev_id in enumerate(revision_ids):
848
pb.update('fetching revision', i+1, len(revision_ids))
849
try:
850
rev = other.get_revision(rev_id)
851
except bzrlib.errors.NoSuchRevision:
852
failures.add(rev_id)
853
continue
854
857
855
revisions.append(rev)
858
856
inv = other.get_inventory(str(rev.inventory_id))
859
857
for key, entry in inv.iter_entries():
862
860
if entry.text_id not in self.text_store:
863
861
needed_texts.add(entry.text_id)
864
862
865
if progress:
866
progress.clear()
863
pb.clear()
867
864
868
count = self.text_store.copy_multi(other.text_store, needed_texts)
869
print "Added %d texts." % count
865
count, cp_fail = self.text_store.copy_multi(other.text_store,
866
needed_texts)
867
#print "Added %d texts." % count
870
868
inventory_ids = [ f.inventory_id for f in revisions ]
871
count = self.inventory_store.copy_multi(other.inventory_store,
872
inventory_ids)
873
print "Added %d inventories." % count
869
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
870
inventory_ids)
871
#print "Added %d inventories." % count
874
872
revision_ids = [ f.revision_id for f in revisions]
875
count = self.revision_store.copy_multi(other.revision_store,
876
revision_ids)
877
return count
873
874
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
875
revision_ids,
876
permit_failure=True)
877
assert len(cp_fail) == 0
878
return count, failures
878
879
880
879
881
def commit(self, *args, **kw):
880
882
from bzrlib.commit import commit
881
883
commit(self, *args, **kw)
882
884
883
885
884
886
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
887
"""Return the revision identifier for a given revision specifier."""
888
# XXX: I'm not sure this method belongs here; I'd rather have the
889
# revision spec stuff be an UI thing, and branch blissfully unaware
890
# of it.
891
# Also, I'm not entirely happy with this method returning None
892
# when the revision doesn't exist.
893
# But I'm keeping the contract I found, because this seems to be
894
# used in a lot of places - and when I do change these, I'd rather
895
# figure out case-by-case which ones actually want to care about
896
# revision specs (eg, they are UI-level) and which ones should trust
897
# that they have a revno/revid.
898
# -- lalo@exoweb.net, 2005-09-07
899
from bzrlib.errors import NoSuchRevision
900
from bzrlib.revisionspec import RevisionSpec
901
try:
902
spec = RevisionSpec(self, revision)
903
except NoSuchRevision:
904
return None
905
return spec.rev_id
888
906
889
907
890
908
def revision_id_to_revno(self, revision_id):
896
914
raise bzrlib.errors.NoSuchRevision(self, revision_id)
897
915
898
916
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
if revision is None:
908
return 0, None
909
revno = None
910
try:# Convert to int if possible
911
revision = int(revision)
912
except ValueError:
913
pass
914
revs = self.revision_history()
915
if isinstance(revision, int):
916
if revision == 0:
917
return 0, None
918
# Mabye we should do this first, but we don't need it if revision == 0
919
if revision < 0:
920
revno = len(revs) + revision + 1
921
else:
922
revno = revision
923
elif isinstance(revision, basestring):
924
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
925
if revision.startswith(prefix):
926
revno = func(self, revs, revision)
927
break
928
else:
929
raise BzrError('No namespace registered for string: %r' % revision)
930
931
if revno is None or revno <= 0 or revno > len(revs):
932
raise BzrError("no such revision %s" % revision)
933
return revno, revs[revno-1]
934
935
def _namespace_revno(self, revs, revision):
936
"""Lookup a revision by revision number"""
937
assert revision.startswith('revno:')
938
try:
939
return int(revision[6:])
940
except ValueError:
941
return None
942
REVISION_NAMESPACES['revno:'] = _namespace_revno
943
944
def _namespace_revid(self, revs, revision):
945
assert revision.startswith('revid:')
946
try:
947
return revs.index(revision[6:]) + 1
948
except ValueError:
949
return None
950
REVISION_NAMESPACES['revid:'] = _namespace_revid
951
952
def _namespace_last(self, revs, revision):
953
assert revision.startswith('last:')
954
try:
955
offset = int(revision[5:])
956
except ValueError:
957
return None
958
else:
959
if offset <= 0:
960
raise BzrError('You must supply a positive value for --revision last:XXX')
961
return len(revs) - offset + 1
962
REVISION_NAMESPACES['last:'] = _namespace_last
963
964
def _namespace_tag(self, revs, revision):
965
assert revision.startswith('tag:')
966
raise BzrError('tag: namespace registered, but not implemented.')
967
REVISION_NAMESPACES['tag:'] = _namespace_tag
968
969
def _namespace_date(self, revs, revision):
970
assert revision.startswith('date:')
971
import datetime
972
# Spec for date revisions:
973
# date:value
974
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
975
# it can also start with a '+/-/='. '+' says match the first
976
# entry after the given date. '-' is match the first entry before the date
977
# '=' is match the first entry after, but still on the given date.
978
#
979
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
980
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
981
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
982
# May 13th, 2005 at 0:00
983
#
984
# So the proper way of saying 'give me all entries for today' is:
985
# -r {date:+today}:{date:-tomorrow}
986
# The default is '=' when not supplied
987
val = revision[5:]
988
match_style = '='
989
if val[:1] in ('+', '-', '='):
990
match_style = val[:1]
991
val = val[1:]
992
993
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
994
if val.lower() == 'yesterday':
995
dt = today - datetime.timedelta(days=1)
996
elif val.lower() == 'today':
997
dt = today
998
elif val.lower() == 'tomorrow':
999
dt = today + datetime.timedelta(days=1)
1000
else:
1001
import re
1002
# This should be done outside the function to avoid recompiling it.
1003
_date_re = re.compile(
1004
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1005
r'(,|T)?\s*'
1006
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1007
)
1008
m = _date_re.match(val)
1009
if not m or (not m.group('date') and not m.group('time')):
1010
raise BzrError('Invalid revision date %r' % revision)
1011
1012
if m.group('date'):
1013
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1014
else:
1015
year, month, day = today.year, today.month, today.day
1016
if m.group('time'):
1017
hour = int(m.group('hour'))
1018
minute = int(m.group('minute'))
1019
if m.group('second'):
1020
second = int(m.group('second'))
1021
else:
1022
second = 0
1023
else:
1024
hour, minute, second = 0,0,0
1025
1026
dt = datetime.datetime(year=year, month=month, day=day,
1027
hour=hour, minute=minute, second=second)
1028
first = dt
1029
last = None
1030
reversed = False
1031
if match_style == '-':
1032
reversed = True
1033
elif match_style == '=':
1034
last = dt + datetime.timedelta(days=1)
1035
1036
if reversed:
1037
for i in range(len(revs)-1, -1, -1):
1038
r = self.get_revision(revs[i])
1039
# TODO: Handle timezone.
1040
dt = datetime.datetime.fromtimestamp(r.timestamp)
1041
if first >= dt and (last is None or dt >= last):
1042
return i+1
1043
else:
1044
for i in range(len(revs)):
1045
r = self.get_revision(revs[i])
1046
# TODO: Handle timezone.
1047
dt = datetime.datetime.fromtimestamp(r.timestamp)
1048
if first <= dt and (last is None or dt <= last):
1049
return i+1
1050
REVISION_NAMESPACES['date:'] = _namespace_date
917
def get_rev_id(self, revno, history=None):
918
"""Find the revision id of the specified revno."""
919
if revno == 0:
920
return None
921
if history is None:
922
history = self.revision_history()
923
elif revno <= 0 or revno > len(history):
924
raise bzrlib.errors.NoSuchRevision(self, revno)
925
return history[revno - 1]
1051
926
1052
927
def revision_tree(self, revision_id):
1053
928
"""Return Tree for a revision on this branch.
1065
940
1066
941
def working_tree(self):
1067
942
"""Return a `Tree` for the working copy."""
1068
from workingtree import WorkingTree
943
from bzrlib.workingtree import WorkingTree
1069
944
return WorkingTree(self.base, self.read_working_inventory())
1070
945
1071
946
1117
992
1118
993
inv.rename(file_id, to_dir_id, to_tail)
1119
994
1120
print "%s => %s" % (from_rel, to_rel)
1121
1122
995
from_abs = self.abspath(from_rel)
1123
996
to_abs = self.abspath(to_rel)
1124
997
try:
1143
1016
1144
1017
Note that to_name is only the last component of the new name;
1145
1018
this doesn't change the directory.
1019
1020
This returns a list of (from_path, to_path) pairs for each
1021
entry that is moved.
1146
1022
"""
1023
result = []
1147
1024
self.lock_write()
1148
1025
try:
1149
1026
## TODO: Option to move IDs only
1184
1061
for f in from_paths:
1185
1062
name_tail = splitpath(f)[-1]
1186
1063
dest_path = appendpath(to_name, name_tail)
1187
print "%s => %s" % (f, dest_path)
1064
result.append((f, dest_path))
1188
1065
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1189
1066
try:
1190
1067
os.rename(self.abspath(f), self.abspath(dest_path))
1196
1073
finally:
1197
1074
self.unlock()
1198
1075
1076
return result
1077
1199
1078
1200
1079
def revert(self, filenames, old_tree=None, backups=True):
1201
1080
"""Restore selected files to the versions from a previous tree.
1283
1162
self.unlock()
1284
1163
1285
1164
1286
1287
class ScratchBranch(Branch):
1165
def get_parent(self):
1166
"""Return the parent location of the branch.
1167
1168
This is the default location for push/pull/missing. The usual
1169
pattern is that the user can override it by specifying a
1170
location.
1171
"""
1172
import errno
1173
_locs = ['parent', 'pull', 'x-pull']
1174
for l in _locs:
1175
try:
1176
return self.controlfile(l, 'r').read().strip('\n')
1177
except IOError, e:
1178
if e.errno != errno.ENOENT:
1179
raise
1180
return None
1181
1182
1183
def set_parent(self, url):
1184
# TODO: Maybe delete old location files?
1185
from bzrlib.atomicfile import AtomicFile
1186
self.lock_write()
1187
try:
1188
f = AtomicFile(self.controlfilename('parent'))
1189
try:
1190
f.write(url + '\n')
1191
f.commit()
1192
finally:
1193
f.close()
1194
finally:
1195
self.unlock()
1196
1197
def check_revno(self, revno):
1198
"""\
1199
Check whether a revno corresponds to any revision.
1200
Zero (the NULL revision) is considered valid.
1201
"""
1202
if revno != 0:
1203
self.check_real_revno(revno)
1204
1205
def check_real_revno(self, revno):
1206
"""\
1207
Check whether a revno corresponds to a real revision.
1208
Zero (the NULL revision) is considered invalid
1209
"""
1210
if revno < 1 or revno > self.revno():
1211
raise InvalidRevisionNumber(revno)
1212
1213
1214
1215
1216
class ScratchBranch(LocalBranch):
1288
1217
"""Special test class: a branch that cleans up after itself.
1289
1218
1290
1219
>>> b = ScratchBranch()
1307
1236
if base is None:
1308
1237
base = mkdtemp()
1309
1238
init = True
1310
Branch.__init__(self, base, init=init)
1239
LocalBranch.__init__(self, base, init=init)
1311
1240
for d in dirs:
1312
1241
os.mkdir(self.abspath(d))
1313
1242
1330
1259
os.rmdir(base)
1331
1260
copytree(self.base, base, symlinks=True)
1332
1261
return ScratchBranch(base=base)
1262
1263
1333
1264
1334
1265
def __del__(self):
1335
1266
self.destroy()
1406
1337
return gen_file_id('TREE_ROOT')
1407
1338
1408
1339
1409
def pull_loc(branch):
1410
# TODO: Should perhaps just make attribute be 'base' in
1411
# RemoteBranch and Branch?
1412
if hasattr(branch, "baseurl"):
1413
return branch.baseurl
1414
else:
1415
return branch.base
1416
1417
1418
1340
def copy_branch(branch_from, to_location, revision=None):
1419
1341
"""Copy branch_from into the existing directory to_location.
1420
1342
1421
If revision is not None, the head of the new branch will be revision.
1343
revision
1344
If not None, only revisions up to this point will be copied.
1345
The head of the new branch will be that revision.
1346
1347
to_location
1348
The name of a local directory that exists but is empty.
1422
1349
"""
1423
1350
from bzrlib.merge import merge
1424
from bzrlib.branch import Branch
1425
from shutil import rmtree
1351
from bzrlib.revisionspec import RevisionSpec
1352
1353
assert isinstance(branch_from, Branch)
1354
assert isinstance(to_location, basestring)
1355
1426
1356
br_to = Branch(to_location, init=True)
1427
1357
br_to.set_root_id(branch_from.get_root_id())
1428
1358
if revision is None:
1429
1359
revno = branch_from.revno()
1430
1360
else:
1431
revno, rev_id = branch_from.get_revision_info(revision)
1361
revno, rev_id = RevisionSpec(branch_from, revision)
1432
1362
br_to.update_revisions(branch_from, stop_revision=revno)
1433
1363
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1434
1364
check_clean=False, ignore_zero=True)
1435
from_location = pull_loc(branch_from)
1436
br_to.controlfile("x-pull", "wb").write(from_location + "\n")
1365
1366
from_location = branch_from.base
1367
br_to.set_parent(branch_from.base)
1437
1368
Loggerhead is a web-based interface for Breezy
Version: 2.0.1