« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1185.1.21
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.1.21
- Committer: Robert Collins
- Date: 2005-09-15 13:34:01 UTC
- mto: (1393.2.1) (1185.41.1 bzr.sftp) (1092.3.4) (1417.1.4) (1464.1.1) (1534.1.1 integration) (1495.1.4) (1505.1.16 bzr-bound-branch) (1508.1.15) (1526.1.3 run_tests_twice_for_i18n) (1540.1.3 bzr.dev (Main development branch)) (1685.1.1 bzr-encoding) (1553.5.1 bzr.dev (Main development branch)) (1608.2.1 bzr.mbp.escape-stores)
- mto: This revision was merged to the branch mainline in revision 1390.
- Revision ID: robertc@robertcollins.net-20050915133401-179830dbe1ad6ad7
add a clean target
- files added:
- HACKING
- bzrlib/util
- files removed:
- plugins/changeset
- files renamed:
- plugins/ => bzrlib/plugins/
- effbot/ => bzrlib/util/effbot/
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
23
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
24
splitpath, \
25
25
sha_file, appendpath, file_kind
26
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
26
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId, \
28
DivergedBranches, NotBranchError
27
29
from bzrlib.textui import show_status
28
30
from bzrlib.revision import Revision
29
from bzrlib.xml import unpack_xml
30
31
from bzrlib.delta import compare_trees
31
32
from bzrlib.tree import EmptyTree, RevisionTree
32
33
import bzrlib.xml
34
import bzrlib.ui
35
36
37
33
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
34
39
## TODO: Maybe include checks for common corruption of newlines, etc?
35
40
38
43
# repeatedly to calculate deltas. We could perhaps have a weakref
39
44
# cache in memory to make this faster.
40
45
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
48
41
49
42
50
def find_branch(f, **args):
43
51
if f and (f.startswith('http://') or f.startswith('https://')):
44
import remotebranch
45
return remotebranch.RemoteBranch(f, **args)
52
from bzrlib.remotebranch import RemoteBranch
53
return RemoteBranch(f, **args)
46
54
else:
47
55
return Branch(f, **args)
48
56
49
57
50
58
def find_cached_branch(f, cache_root, **args):
51
from remotebranch import RemoteBranch
59
from bzrlib.remotebranch import RemoteBranch
52
60
br = find_branch(f, **args)
53
61
def cacheify(br, store_name):
54
from meta_store import CachedStore
62
from bzrlib.meta_store import CachedStore
55
63
cache_path = os.path.join(cache_root, store_name)
56
64
os.mkdir(cache_path)
57
65
new_store = CachedStore(getattr(br, store_name), cache_path)
86
94
if tail:
87
95
s.insert(0, tail)
88
96
else:
89
from errors import NotBranchError
90
97
raise NotBranchError("path %r is not within branch %r" % (rp, base))
91
98
92
99
return os.sep.join(s)
100
107
It is not necessary that f exists.
101
108
102
109
Basically we keep looking up until we find the control directory or
103
run into the root."""
110
run into the root. If there isn't one, raises NotBranchError.
111
"""
104
112
if f == None:
105
113
f = os.getcwd()
106
114
elif hasattr(os.path, 'realpath'):
119
127
head, tail = os.path.split(f)
120
128
if head == f:
121
129
# reached the root, whatever that may be
122
raise BzrError('%r is not in a branch' % orig_f)
130
raise NotBranchError('%s is not in a branch' % orig_f)
123
131
f = head
124
125
class DivergedBranches(Exception):
126
def __init__(self, branch1, branch2):
127
self.branch1 = branch1
128
self.branch2 = branch2
129
Exception.__init__(self, "These branches have diverged.")
130
131
132
class NoSuchRevision(BzrError):
133
def __init__(self, branch, revision):
134
self.branch = branch
135
self.revision = revision
136
msg = "Branch %s has no revision %d" % (branch, revision)
137
BzrError.__init__(self, msg)
132
133
138
134
139
135
140
136
######################################################################
169
165
def __init__(self, base, init=False, find_root=True):
170
166
"""Create new branch object at a particular location.
171
167
172
base -- Base directory for the branch.
168
base -- Base directory for the branch. May be a file:// url.
173
169
174
170
init -- If True, create new control files in a previously
175
171
unversioned directory. If False, the branch must already
188
184
elif find_root:
189
185
self.base = find_branch_root(base)
190
186
else:
187
if base.startswith("file://"):
188
base = base[7:]
191
189
self.base = os.path.realpath(base)
192
190
if not isdir(self.controlfilename('.')):
193
from errors import NotBranchError
194
191
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
195
192
['use "bzr init" to initialize a new working tree',
196
193
'current bzr can only operate from top-of-tree'])
210
207
211
208
def __del__(self):
212
209
if self._lock_mode or self._lock:
213
from warnings import warn
210
from bzrlib.warnings import warn
214
211
warn("branch %r was not explicitly unlocked" % self)
215
212
self._lock.unlock()
216
213
217
218
219
214
def lock_write(self):
220
215
if self._lock_mode:
221
216
if self._lock_mode != 'w':
222
from errors import LockError
217
from bzrlib.errors import LockError
223
218
raise LockError("can't upgrade to a write lock from %r" %
224
219
self._lock_mode)
225
220
self._lock_count += 1
231
226
self._lock_count = 1
232
227
233
228
234
235
229
def lock_read(self):
236
230
if self._lock_mode:
237
231
assert self._lock_mode in ('r', 'w'), \
244
238
self._lock_mode = 'r'
245
239
self._lock_count = 1
246
240
247
248
249
241
def unlock(self):
250
242
if not self._lock_mode:
251
from errors import LockError
243
from bzrlib.errors import LockError
252
244
raise LockError('branch %r is not locked' % (self))
253
245
254
246
if self._lock_count > 1:
258
250
self._lock = None
259
251
self._lock_mode = self._lock_count = None
260
252
261
262
253
def abspath(self, name):
263
254
"""Return absolute filename for something in the branch"""
264
255
return os.path.join(self.base, name)
265
256
266
267
257
def relpath(self, path):
268
258
"""Return path relative to this branch of something inside it.
269
259
270
260
Raises an error if path is not in this branch."""
271
261
return _relpath(self.base, path)
272
262
273
274
263
def controlfilename(self, file_or_path):
275
264
"""Return location relative to branch."""
276
265
if isinstance(file_or_path, basestring):
303
292
else:
304
293
raise BzrError("invalid controlfile mode %r" % mode)
305
294
306
307
308
295
def _make_control(self):
309
296
from bzrlib.inventory import Inventory
310
from bzrlib.xml import pack_xml
311
297
312
298
os.mkdir(self.controlfilename([]))
313
299
self.controlfile('README', 'w').write(
323
309
self.controlfile(f, 'w').write('')
324
310
mutter('created control directory in ' + self.base)
325
311
326
pack_xml(Inventory(gen_root_id()), self.controlfile('inventory','w'))
312
# if we want per-tree root ids then this is the place to set
313
# them; they're not needed for now and so ommitted for
314
# simplicity.
315
f = self.controlfile('inventory','w')
316
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
327
317
328
318
329
319
def _check_format(self):
338
328
# on Windows from Linux and so on. I think it might be better
339
329
# to always make all internal files in unix format.
340
330
fmt = self.controlfile('branch-format', 'r').read()
341
fmt.replace('\r\n', '')
331
fmt = fmt.replace('\r\n', '\n')
342
332
if fmt != BZR_BRANCH_FORMAT:
343
333
raise BzrError('sorry, branch format %r not supported' % fmt,
344
334
['use a different bzr version',
364
354
def read_working_inventory(self):
365
355
"""Read the working inventory."""
366
356
from bzrlib.inventory import Inventory
367
from bzrlib.xml import unpack_xml
368
from time import time
369
before = time()
370
357
self.lock_read()
371
358
try:
372
359
# ElementTree does its own conversion from UTF-8, so open in
373
360
# binary.
374
inv = unpack_xml(Inventory,
375
self.controlfile('inventory', 'rb'))
376
mutter("loaded inventory of %d items in %f"
377
% (len(inv), time() - before))
378
return inv
361
f = self.controlfile('inventory', 'rb')
362
return bzrlib.xml.serializer_v4.read_inventory(f)
379
363
finally:
380
364
self.unlock()
381
365
387
371
will be committed to the next revision.
388
372
"""
389
373
from bzrlib.atomicfile import AtomicFile
390
from bzrlib.xml import pack_xml
391
374
392
375
self.lock_write()
393
376
try:
394
377
f = AtomicFile(self.controlfilename('inventory'), 'wb')
395
378
try:
396
pack_xml(inv, f)
379
bzrlib.xml.serializer_v4.write_inventory(inv, f)
397
380
f.commit()
398
381
finally:
399
382
f.close()
407
390
"""Inventory for the working copy.""")
408
391
409
392
410
def add(self, files, verbose=False, ids=None):
393
def add(self, files, ids=None):
411
394
"""Make files versioned.
412
395
413
Note that the command line normally calls smart_add instead.
396
Note that the command line normally calls smart_add instead,
397
which can automatically recurse.
414
398
415
399
This puts the files in the Added state, so that they will be
416
400
recorded by the next commit.
426
410
TODO: Perhaps have an option to add the ids even if the files do
427
411
not (yet) exist.
428
412
429
TODO: Perhaps return the ids of the files? But then again it
430
is easy to retrieve them if they're needed.
431
432
TODO: Adding a directory should optionally recurse down and
433
add all non-ignored children. Perhaps do that in a
434
higher-level method.
413
TODO: Perhaps yield the ids and paths as they're added.
435
414
"""
436
415
# TODO: Re-adding a file that is removed in the working copy
437
416
# should probably put it back with the previous ID.
473
452
file_id = gen_file_id(f)
474
453
inv.add_path(f, kind=kind, file_id=file_id)
475
454
476
if verbose:
477
print 'added', quotefn(f)
478
479
455
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
480
456
481
457
self._write_inventory(inv)
591
567
f.close()
592
568
593
569
570
def get_revision_xml_file(self, revision_id):
571
"""Return XML file object for revision object."""
572
if not revision_id or not isinstance(revision_id, basestring):
573
raise InvalidRevisionId(revision_id)
574
575
self.lock_read()
576
try:
577
try:
578
return self.revision_store[revision_id]
579
except (IndexError, KeyError):
580
raise bzrlib.errors.NoSuchRevision(self, revision_id)
581
finally:
582
self.unlock()
583
584
585
#deprecated
586
get_revision_xml = get_revision_xml_file
587
588
594
589
def get_revision(self, revision_id):
595
590
"""Return the Revision object for a named revision"""
596
self.lock_read()
591
xml_file = self.get_revision_xml_file(revision_id)
592
597
593
try:
598
if not revision_id or not isinstance(revision_id, basestring):
599
raise InvalidRevisionId(revision_id)
600
r = unpack_xml(Revision, self.revision_store[revision_id])
601
finally:
602
self.unlock()
594
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
595
except SyntaxError, e:
596
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
597
[revision_id,
598
str(e)])
603
599
604
600
assert r.revision_id == revision_id
605
601
return r
636
632
# the revision, (add signatures/remove signatures) and still
637
633
# have all hash pointers stay consistent.
638
634
# But for now, just hash the contents.
639
return sha_file(self.revision_store[revision_id])
635
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
640
636
641
637
642
638
def get_inventory(self, inventory_id):
646
642
parameter which can be either an integer revno or a
647
643
string hash."""
648
644
from bzrlib.inventory import Inventory
649
from bzrlib.xml import unpack_xml
650
651
return unpack_xml(Inventory, self.inventory_store[inventory_id])
645
646
f = self.get_inventory_xml_file(inventory_id)
647
return bzrlib.xml.serializer_v4.read_inventory(f)
648
649
650
def get_inventory_xml(self, inventory_id):
651
"""Get inventory XML as a file object."""
652
return self.inventory_store[inventory_id]
653
654
get_inventory_xml_file = get_inventory_xml
652
655
653
656
654
657
def get_inventory_sha1(self, inventory_id):
655
658
"""Return the sha1 hash of the inventory entry
656
659
"""
657
return sha_file(self.inventory_store[inventory_id])
660
return sha_file(self.get_inventory_xml(inventory_id))
658
661
659
662
660
663
def get_revision_inventory(self, revision_id):
684
687
685
688
def common_ancestor(self, other, self_revno=None, other_revno=None):
686
689
"""
687
>>> import commit
690
>>> from bzrlib.commit import commit
688
691
>>> sb = ScratchBranch(files=['foo', 'foo~'])
689
692
>>> sb.common_ancestor(sb) == (None, None)
690
693
True
691
>>> commit.commit(sb, "Committing first revision", verbose=False)
694
>>> commit(sb, "Committing first revision", verbose=False)
692
695
>>> sb.common_ancestor(sb)[0]
693
696
1
694
697
>>> clone = sb.clone()
695
>>> commit.commit(sb, "Committing second revision", verbose=False)
698
>>> commit(sb, "Committing second revision", verbose=False)
696
699
>>> sb.common_ancestor(sb)[0]
697
700
2
698
701
>>> sb.common_ancestor(clone)[0]
699
702
1
700
>>> commit.commit(clone, "Committing divergent second revision",
703
>>> commit(clone, "Committing divergent second revision",
701
704
... verbose=False)
702
705
>>> sb.common_ancestor(clone)[0]
703
706
1
746
749
return None
747
750
748
751
749
def missing_revisions(self, other, stop_revision=None):
752
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
750
753
"""
751
754
If self and other have not diverged, return a list of the revisions
752
755
present in other, but missing from self.
785
788
if stop_revision is None:
786
789
stop_revision = other_len
787
790
elif stop_revision > other_len:
788
raise NoSuchRevision(self, stop_revision)
791
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
789
792
790
793
return other_history[self_len:stop_revision]
791
794
792
795
793
796
def update_revisions(self, other, stop_revision=None):
794
797
"""Pull in all new revisions from other branch.
795
796
>>> from bzrlib.commit import commit
797
>>> bzrlib.trace.silent = True
798
>>> br1 = ScratchBranch(files=['foo', 'bar'])
799
>>> br1.add('foo')
800
>>> br1.add('bar')
801
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
802
>>> br2 = ScratchBranch()
803
>>> br2.update_revisions(br1)
804
Added 2 texts.
805
Added 1 inventories.
806
Added 1 revisions.
807
>>> br2.revision_history()
808
[u'REVISION-ID-1']
809
>>> br2.update_revisions(br1)
810
Added 0 texts.
811
Added 0 inventories.
812
Added 0 revisions.
813
>>> br1.text_store.total_size() == br2.text_store.total_size()
814
True
815
798
"""
816
from bzrlib.progress import ProgressBar
817
818
pb = ProgressBar()
819
799
from bzrlib.fetch import greedy_fetch
800
from bzrlib.revision import get_intervening_revisions
801
802
pb = bzrlib.ui.ui_factory.progress_bar()
820
803
pb.update('comparing histories')
821
revision_ids = self.missing_revisions(other, stop_revision)
822
804
if stop_revision is None:
805
other_revision = other.last_patch()
806
else:
807
other_revision = other.lookup_revision(stop_revision)
808
count = greedy_fetch(self, other, other_revision, pb)[0]
809
try:
810
revision_ids = self.missing_revisions(other, stop_revision)
811
except DivergedBranches, e:
812
try:
813
revision_ids = get_intervening_revisions(self.last_patch(),
814
other_revision, self)
815
assert self.last_patch() not in revision_ids
816
except bzrlib.errors.NotAncestor:
817
raise e
818
819
self.append_revision(*revision_ids)
820
pb.clear()
821
822
def install_revisions(self, other, revision_ids, pb):
823
823
if hasattr(other.revision_store, "prefetch"):
824
824
other.revision_store.prefetch(revision_ids)
825
825
if hasattr(other.inventory_store, "prefetch"):
826
inventory_ids = [other.get_revision(r).inventory_id
827
for r in revision_ids]
826
inventory_ids = []
827
for rev_id in revision_ids:
828
try:
829
revision = other.get_revision(rev_id).inventory_id
830
inventory_ids.append(revision)
831
except bzrlib.errors.NoSuchRevision:
832
pass
828
833
other.inventory_store.prefetch(inventory_ids)
834
835
if pb is None:
836
pb = bzrlib.ui.ui_factory.progress_bar()
829
837
830
838
revisions = []
831
839
needed_texts = set()
832
840
i = 0
833
for rev_id in revision_ids:
834
i += 1
835
pb.update('fetching revision', i, len(revision_ids))
836
rev = other.get_revision(rev_id)
841
842
failures = set()
843
for i, rev_id in enumerate(revision_ids):
844
pb.update('fetching revision', i+1, len(revision_ids))
845
try:
846
rev = other.get_revision(rev_id)
847
except bzrlib.errors.NoSuchRevision:
848
failures.add(rev_id)
849
continue
850
837
851
revisions.append(rev)
838
852
inv = other.get_inventory(str(rev.inventory_id))
839
853
for key, entry in inv.iter_entries():
844
858
845
859
pb.clear()
846
860
847
count = self.text_store.copy_multi(other.text_store, needed_texts)
848
print "Added %d texts." % count
861
count, cp_fail = self.text_store.copy_multi(other.text_store,
862
needed_texts)
863
#print "Added %d texts." % count
849
864
inventory_ids = [ f.inventory_id for f in revisions ]
850
count = self.inventory_store.copy_multi(other.inventory_store,
851
inventory_ids)
852
print "Added %d inventories." % count
865
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
866
inventory_ids)
867
#print "Added %d inventories." % count
853
868
revision_ids = [ f.revision_id for f in revisions]
854
count = self.revision_store.copy_multi(other.revision_store,
855
revision_ids)
856
for revision_id in revision_ids:
857
self.append_revision(revision_id)
858
print "Added %d revisions." % count
859
860
869
870
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
871
revision_ids,
872
permit_failure=True)
873
assert len(cp_fail) == 0
874
return count, failures
875
876
861
877
def commit(self, *args, **kw):
862
878
from bzrlib.commit import commit
863
879
commit(self, *args, **kw)
865
881
866
882
def lookup_revision(self, revision):
867
883
"""Return the revision identifier for a given revision information."""
868
revno, info = self.get_revision_info(revision)
884
revno, info = self._get_revision_info(revision)
869
885
return info
870
886
887
888
def revision_id_to_revno(self, revision_id):
889
"""Given a revision id, return its revno"""
890
history = self.revision_history()
891
try:
892
return history.index(revision_id) + 1
893
except ValueError:
894
raise bzrlib.errors.NoSuchRevision(self, revision_id)
895
896
871
897
def get_revision_info(self, revision):
872
898
"""Return (revno, revision id) for revision identifier.
873
899
876
902
revision can also be a string, in which case it is parsed for something like
877
903
'date:' or 'revid:' etc.
878
904
"""
905
revno, rev_id = self._get_revision_info(revision)
906
if revno is None:
907
raise bzrlib.errors.NoSuchRevision(self, revision)
908
return revno, rev_id
909
910
def get_rev_id(self, revno, history=None):
911
"""Find the revision id of the specified revno."""
912
if revno == 0:
913
return None
914
if history is None:
915
history = self.revision_history()
916
elif revno <= 0 or revno > len(history):
917
raise bzrlib.errors.NoSuchRevision(self, revno)
918
return history[revno - 1]
919
920
def _get_revision_info(self, revision):
921
"""Return (revno, revision id) for revision specifier.
922
923
revision can be an integer, in which case it is assumed to be revno
924
(though this will translate negative values into positive ones)
925
revision can also be a string, in which case it is parsed for something
926
like 'date:' or 'revid:' etc.
927
928
A revid is always returned. If it is None, the specifier referred to
929
the null revision. If the revid does not occur in the revision
930
history, revno will be None.
931
"""
932
879
933
if revision is None:
880
934
return 0, None
881
935
revno = None
885
939
pass
886
940
revs = self.revision_history()
887
941
if isinstance(revision, int):
888
if revision == 0:
889
return 0, None
890
# Mabye we should do this first, but we don't need it if revision == 0
891
942
if revision < 0:
892
943
revno = len(revs) + revision + 1
893
944
else:
894
945
revno = revision
946
rev_id = self.get_rev_id(revno, revs)
895
947
elif isinstance(revision, basestring):
896
948
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
897
949
if revision.startswith(prefix):
898
revno = func(self, revs, revision)
950
result = func(self, revs, revision)
951
if len(result) > 1:
952
revno, rev_id = result
953
else:
954
revno = result[0]
955
rev_id = self.get_rev_id(revno, revs)
899
956
break
900
957
else:
901
raise BzrError('No namespace registered for string: %r' % revision)
958
raise BzrError('No namespace registered for string: %r' %
959
revision)
960
else:
961
raise TypeError('Unhandled revision type %s' % revision)
902
962
903
if revno is None or revno <= 0 or revno > len(revs):
904
raise BzrError("no such revision %s" % revision)
905
return revno, revs[revno-1]
963
if revno is None:
964
if rev_id is None:
965
raise bzrlib.errors.NoSuchRevision(self, revision)
966
return revno, rev_id
906
967
907
968
def _namespace_revno(self, revs, revision):
908
969
"""Lookup a revision by revision number"""
909
970
assert revision.startswith('revno:')
910
971
try:
911
return int(revision[6:])
972
return (int(revision[6:]),)
912
973
except ValueError:
913
974
return None
914
975
REVISION_NAMESPACES['revno:'] = _namespace_revno
915
976
916
977
def _namespace_revid(self, revs, revision):
917
978
assert revision.startswith('revid:')
979
rev_id = revision[len('revid:'):]
918
980
try:
919
return revs.index(revision[6:]) + 1
981
return revs.index(rev_id) + 1, rev_id
920
982
except ValueError:
921
return None
983
return None, rev_id
922
984
REVISION_NAMESPACES['revid:'] = _namespace_revid
923
985
924
986
def _namespace_last(self, revs, revision):
926
988
try:
927
989
offset = int(revision[5:])
928
990
except ValueError:
929
return None
991
return (None,)
930
992
else:
931
993
if offset <= 0:
932
994
raise BzrError('You must supply a positive value for --revision last:XXX')
933
return len(revs) - offset + 1
995
return (len(revs) - offset + 1,)
934
996
REVISION_NAMESPACES['last:'] = _namespace_last
935
997
936
998
def _namespace_tag(self, revs, revision):
1011
1073
# TODO: Handle timezone.
1012
1074
dt = datetime.datetime.fromtimestamp(r.timestamp)
1013
1075
if first >= dt and (last is None or dt >= last):
1014
return i+1
1076
return (i+1,)
1015
1077
else:
1016
1078
for i in range(len(revs)):
1017
1079
r = self.get_revision(revs[i])
1018
1080
# TODO: Handle timezone.
1019
1081
dt = datetime.datetime.fromtimestamp(r.timestamp)
1020
1082
if first <= dt and (last is None or dt <= last):
1021
return i+1
1083
return (i+1,)
1022
1084
REVISION_NAMESPACES['date:'] = _namespace_date
1023
1085
1086
1087
def _namespace_ancestor(self, revs, revision):
1088
from revision import common_ancestor, MultipleRevisionSources
1089
other_branch = find_branch(_trim_namespace('ancestor', revision))
1090
revision_a = self.last_patch()
1091
revision_b = other_branch.last_patch()
1092
for r, b in ((revision_a, self), (revision_b, other_branch)):
1093
if r is None:
1094
raise bzrlib.errors.NoCommits(b)
1095
revision_source = MultipleRevisionSources(self, other_branch)
1096
result = common_ancestor(revision_a, revision_b, revision_source)
1097
try:
1098
revno = self.revision_id_to_revno(result)
1099
except bzrlib.errors.NoSuchRevision:
1100
revno = None
1101
return revno,result
1102
1103
1104
REVISION_NAMESPACES['ancestor:'] = _namespace_ancestor
1105
1024
1106
def revision_tree(self, revision_id):
1025
1107
"""Return Tree for a revision on this branch.
1026
1108
1037
1119
1038
1120
def working_tree(self):
1039
1121
"""Return a `Tree` for the working copy."""
1040
from workingtree import WorkingTree
1122
from bzrlib.workingtree import WorkingTree
1041
1123
return WorkingTree(self.base, self.read_working_inventory())
1042
1124
1043
1125
1089
1171
1090
1172
inv.rename(file_id, to_dir_id, to_tail)
1091
1173
1092
print "%s => %s" % (from_rel, to_rel)
1093
1094
1174
from_abs = self.abspath(from_rel)
1095
1175
to_abs = self.abspath(to_rel)
1096
1176
try:
1115
1195
1116
1196
Note that to_name is only the last component of the new name;
1117
1197
this doesn't change the directory.
1198
1199
This returns a list of (from_path, to_path) pairs for each
1200
entry that is moved.
1118
1201
"""
1202
result = []
1119
1203
self.lock_write()
1120
1204
try:
1121
1205
## TODO: Option to move IDs only
1156
1240
for f in from_paths:
1157
1241
name_tail = splitpath(f)[-1]
1158
1242
dest_path = appendpath(to_name, name_tail)
1159
print "%s => %s" % (f, dest_path)
1243
result.append((f, dest_path))
1160
1244
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1161
1245
try:
1162
1246
os.rename(self.abspath(f), self.abspath(dest_path))
1168
1252
finally:
1169
1253
self.unlock()
1170
1254
1255
return result
1256
1171
1257
1172
1258
def revert(self, filenames, old_tree=None, backups=True):
1173
1259
"""Restore selected files to the versions from a previous tree.
1255
1341
self.unlock()
1256
1342
1257
1343
1344
def get_parent(self):
1345
"""Return the parent location of the branch.
1346
1347
This is the default location for push/pull/missing. The usual
1348
pattern is that the user can override it by specifying a
1349
location.
1350
"""
1351
import errno
1352
_locs = ['parent', 'pull', 'x-pull']
1353
for l in _locs:
1354
try:
1355
return self.controlfile(l, 'r').read().strip('\n')
1356
except IOError, e:
1357
if e.errno != errno.ENOENT:
1358
raise
1359
return None
1360
1361
1362
def set_parent(self, url):
1363
# TODO: Maybe delete old location files?
1364
from bzrlib.atomicfile import AtomicFile
1365
self.lock_write()
1366
try:
1367
f = AtomicFile(self.controlfilename('parent'))
1368
try:
1369
f.write(url + '\n')
1370
f.commit()
1371
finally:
1372
f.close()
1373
finally:
1374
self.unlock()
1375
1376
def check_revno(self, revno):
1377
"""\
1378
Check whether a revno corresponds to any revision.
1379
Zero (the NULL revision) is considered valid.
1380
"""
1381
if revno != 0:
1382
self.check_real_revno(revno)
1383
1384
def check_real_revno(self, revno):
1385
"""\
1386
Check whether a revno corresponds to a real revision.
1387
Zero (the NULL revision) is considered invalid
1388
"""
1389
if revno < 1 or revno > self.revno():
1390
raise InvalidRevisionNumber(revno)
1391
1392
1393
1258
1394
1259
1395
class ScratchBranch(Branch):
1260
1396
"""Special test class: a branch that cleans up after itself.
1302
1438
os.rmdir(base)
1303
1439
copytree(self.base, base, symlinks=True)
1304
1440
return ScratchBranch(base=base)
1441
1442
1305
1443
1306
1444
def __del__(self):
1307
1445
self.destroy()
1377
1515
"""Return a new tree-root file id."""
1378
1516
return gen_file_id('TREE_ROOT')
1379
1517
1518
1519
def copy_branch(branch_from, to_location, revision=None):
1520
"""Copy branch_from into the existing directory to_location.
1521
1522
revision
1523
If not None, only revisions up to this point will be copied.
1524
The head of the new branch will be that revision.
1525
1526
to_location
1527
The name of a local directory that exists but is empty.
1528
"""
1529
from bzrlib.merge import merge
1530
1531
assert isinstance(branch_from, Branch)
1532
assert isinstance(to_location, basestring)
1533
1534
br_to = Branch(to_location, init=True)
1535
br_to.set_root_id(branch_from.get_root_id())
1536
if revision is None:
1537
revno = branch_from.revno()
1538
else:
1539
revno, rev_id = branch_from.get_revision_info(revision)
1540
br_to.update_revisions(branch_from, stop_revision=revno)
1541
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1542
check_clean=False, ignore_zero=True)
1543
br_to.set_parent(branch_from.base)
1544
return br_to
1545
1546
def _trim_namespace(namespace, spec):
1547
full_namespace = namespace + ':'
1548
assert spec.startswith(full_namespace)
1549
return spec[len(full_namespace):]
Loggerhead is a web-based interface for Breezy
Version: 2.0.1