« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 1092.1.6
- compare with another revision
- download diff
- download tarball
- view history from revision 1092.1.6
- Committer: Robert Collins
- Date: 2005-08-23 06:52:09 UTC
- mto: (974.1.50) (1185.1.10) (1092.3.1)
- mto: This revision was merged to the branch mainline in revision 1139.
- Revision ID: robertc@robertcollins.net-20050823065209-81cd5962c401751b
move io redirection into each test case from the global runner
- files added:
- bzrlib/plugins/checkperms
- files removed:
- bzrlib/builtins.py
- 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
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId, \
28
DivergedBranches, NotBranchError
26
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
27
import bzrlib.errors
29
28
from bzrlib.textui import show_status
30
29
from bzrlib.revision import Revision
30
from bzrlib.xml import unpack_xml
31
31
from bzrlib.delta import compare_trees
32
32
from bzrlib.tree import EmptyTree, RevisionTree
33
import bzrlib.xml
34
import bzrlib.ui
35
36
37
33
38
34
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
35
## TODO: Maybe include checks for common corruption of newlines, etc?
40
36
49
45
50
46
def find_branch(f, **args):
51
47
if f and (f.startswith('http://') or f.startswith('https://')):
52
from bzrlib.remotebranch import RemoteBranch
53
return RemoteBranch(f, **args)
48
import remotebranch
49
return remotebranch.RemoteBranch(f, **args)
54
50
else:
55
return LocalBranch(f, **args)
51
return Branch(f, **args)
56
52
57
53
58
54
def find_cached_branch(f, cache_root, **args):
59
from bzrlib.remotebranch import RemoteBranch
55
from remotebranch import RemoteBranch
60
56
br = find_branch(f, **args)
61
57
def cacheify(br, store_name):
62
from bzrlib.meta_store import CachedStore
58
from meta_store import CachedStore
63
59
cache_path = os.path.join(cache_root, store_name)
64
60
os.mkdir(cache_path)
65
61
new_store = CachedStore(getattr(br, store_name), cache_path)
94
90
if tail:
95
91
s.insert(0, tail)
96
92
else:
93
from errors import NotBranchError
97
94
raise NotBranchError("path %r is not within branch %r" % (rp, base))
98
95
99
96
return os.sep.join(s)
127
124
head, tail = os.path.split(f)
128
125
if head == f:
129
126
# reached the root, whatever that may be
130
raise NotBranchError('%s is not in a branch' % orig_f)
127
raise bzrlib.errors.NotBranchError('%r is not in a branch' % orig_f)
131
128
f = head
132
129
133
130
134
131
132
# XXX: move into bzrlib.errors; subclass BzrError
133
class DivergedBranches(Exception):
134
def __init__(self, branch1, branch2):
135
self.branch1 = branch1
136
self.branch2 = branch2
137
Exception.__init__(self, "These branches have diverged.")
138
135
139
136
140
######################################################################
137
141
# branch objects
140
144
"""Branch holding a history of revisions.
141
145
142
146
base
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.
147
Base directory of the branch.
164
148
165
149
_lock_mode
166
150
None, or 'r' or 'w'
172
156
_lock
173
157
Lock object from bzrlib.lock.
174
158
"""
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.
159
base = None
179
160
_lock_mode = None
180
161
_lock_count = None
181
162
_lock = None
163
164
# Map some sort of prefix into a namespace
165
# stuff like "revno:10", "revid:", etc.
166
# This should match a prefix with a function which accepts
167
REVISION_NAMESPACES = {}
182
168
183
169
def __init__(self, base, init=False, find_root=True):
184
170
"""Create new branch object at a particular location.
204
190
else:
205
191
self.base = os.path.realpath(base)
206
192
if not isdir(self.controlfilename('.')):
193
from errors import NotBranchError
207
194
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
208
195
['use "bzr init" to initialize a new working tree',
209
196
'current bzr can only operate from top-of-tree'])
223
210
224
211
def __del__(self):
225
212
if self._lock_mode or self._lock:
226
from bzrlib.warnings import warn
213
from warnings import warn
227
214
warn("branch %r was not explicitly unlocked" % self)
228
215
self._lock.unlock()
229
216
230
217
218
231
219
def lock_write(self):
232
220
if self._lock_mode:
233
221
if self._lock_mode != 'w':
234
from bzrlib.errors import LockError
222
from errors import LockError
235
223
raise LockError("can't upgrade to a write lock from %r" %
236
224
self._lock_mode)
237
225
self._lock_count += 1
243
231
self._lock_count = 1
244
232
245
233
234
246
235
def lock_read(self):
247
236
if self._lock_mode:
248
237
assert self._lock_mode in ('r', 'w'), \
255
244
self._lock_mode = 'r'
256
245
self._lock_count = 1
257
246
247
248
258
249
def unlock(self):
259
250
if not self._lock_mode:
260
from bzrlib.errors import LockError
251
from errors import LockError
261
252
raise LockError('branch %r is not locked' % (self))
262
253
263
254
if self._lock_count > 1:
267
258
self._lock = None
268
259
self._lock_mode = self._lock_count = None
269
260
261
270
262
def abspath(self, name):
271
263
"""Return absolute filename for something in the branch"""
272
264
return os.path.join(self.base, name)
273
265
266
274
267
def relpath(self, path):
275
268
"""Return path relative to this branch of something inside it.
276
269
277
270
Raises an error if path is not in this branch."""
278
271
return _relpath(self.base, path)
279
272
273
280
274
def controlfilename(self, file_or_path):
281
275
"""Return location relative to branch."""
282
276
if isinstance(file_or_path, basestring):
309
303
else:
310
304
raise BzrError("invalid controlfile mode %r" % mode)
311
305
306
307
312
308
def _make_control(self):
313
309
from bzrlib.inventory import Inventory
310
from bzrlib.xml import pack_xml
314
311
315
312
os.mkdir(self.controlfilename([]))
316
313
self.controlfile('README', 'w').write(
329
326
# if we want per-tree root ids then this is the place to set
330
327
# them; they're not needed for now and so ommitted for
331
328
# simplicity.
332
f = self.controlfile('inventory','w')
333
bzrlib.xml.serializer_v4.write_inventory(Inventory(), f)
329
pack_xml(Inventory(), self.controlfile('inventory','w'))
334
330
335
331
336
332
def _check_format(self):
345
341
# on Windows from Linux and so on. I think it might be better
346
342
# to always make all internal files in unix format.
347
343
fmt = self.controlfile('branch-format', 'r').read()
348
fmt = fmt.replace('\r\n', '\n')
344
fmt.replace('\r\n', '')
349
345
if fmt != BZR_BRANCH_FORMAT:
350
346
raise BzrError('sorry, branch format %r not supported' % fmt,
351
347
['use a different bzr version',
371
367
def read_working_inventory(self):
372
368
"""Read the working inventory."""
373
369
from bzrlib.inventory import Inventory
370
from bzrlib.xml import unpack_xml
371
from time import time
372
before = time()
374
373
self.lock_read()
375
374
try:
376
375
# ElementTree does its own conversion from UTF-8, so open in
377
376
# binary.
378
f = self.controlfile('inventory', 'rb')
379
return bzrlib.xml.serializer_v4.read_inventory(f)
377
inv = unpack_xml(Inventory,
378
self.controlfile('inventory', 'rb'))
379
mutter("loaded inventory of %d items in %f"
380
% (len(inv), time() - before))
381
return inv
380
382
finally:
381
383
self.unlock()
382
384
388
390
will be committed to the next revision.
389
391
"""
390
392
from bzrlib.atomicfile import AtomicFile
393
from bzrlib.xml import pack_xml
391
394
392
395
self.lock_write()
393
396
try:
394
397
f = AtomicFile(self.controlfilename('inventory'), 'wb')
395
398
try:
396
bzrlib.xml.serializer_v4.write_inventory(inv, f)
399
pack_xml(inv, f)
397
400
f.commit()
398
401
finally:
399
402
f.close()
407
410
"""Inventory for the working copy.""")
408
411
409
412
410
def add(self, files, ids=None):
413
def add(self, files, verbose=False, ids=None):
411
414
"""Make files versioned.
412
415
413
Note that the command line normally calls smart_add instead,
414
which can automatically recurse.
416
Note that the command line normally calls smart_add instead.
415
417
416
418
This puts the files in the Added state, so that they will be
417
419
recorded by the next commit.
427
429
TODO: Perhaps have an option to add the ids even if the files do
428
430
not (yet) exist.
429
431
430
TODO: Perhaps yield the ids and paths as they're added.
432
TODO: Perhaps return the ids of the files? But then again it
433
is easy to retrieve them if they're needed.
434
435
TODO: Adding a directory should optionally recurse down and
436
add all non-ignored children. Perhaps do that in a
437
higher-level method.
431
438
"""
432
439
# TODO: Re-adding a file that is removed in the working copy
433
440
# should probably put it back with the previous ID.
469
476
file_id = gen_file_id(f)
470
477
inv.add_path(f, kind=kind, file_id=file_id)
471
478
479
if verbose:
480
print 'added', quotefn(f)
481
472
482
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
473
483
474
484
self._write_inventory(inv)
480
490
"""Print `file` to stdout."""
481
491
self.lock_read()
482
492
try:
483
tree = self.revision_tree(self.get_rev_id(revno))
493
tree = self.revision_tree(self.lookup_revision(revno))
484
494
# use inventory as it was in that revision
485
495
file_id = tree.inventory.path2id(file)
486
496
if not file_id:
584
594
f.close()
585
595
586
596
587
def get_revision_xml_file(self, revision_id):
597
def get_revision_xml(self, revision_id):
588
598
"""Return XML file object for revision object."""
589
599
if not revision_id or not isinstance(revision_id, basestring):
590
600
raise InvalidRevisionId(revision_id)
599
609
self.unlock()
600
610
601
611
602
#deprecated
603
get_revision_xml = get_revision_xml_file
604
605
606
612
def get_revision(self, revision_id):
607
613
"""Return the Revision object for a named revision"""
608
xml_file = self.get_revision_xml_file(revision_id)
614
xml_file = self.get_revision_xml(revision_id)
609
615
610
616
try:
611
r = bzrlib.xml.serializer_v4.read_revision(xml_file)
617
r = unpack_xml(Revision, xml_file)
612
618
except SyntaxError, e:
613
619
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
614
620
[revision_id,
659
665
parameter which can be either an integer revno or a
660
666
string hash."""
661
667
from bzrlib.inventory import Inventory
668
from bzrlib.xml import unpack_xml
662
669
663
f = self.get_inventory_xml_file(inventory_id)
664
return bzrlib.xml.serializer_v4.read_inventory(f)
670
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
665
671
666
672
667
673
def get_inventory_xml(self, inventory_id):
668
674
"""Get inventory XML as a file object."""
669
675
return self.inventory_store[inventory_id]
670
671
get_inventory_xml_file = get_inventory_xml
672
676
673
677
674
678
def get_inventory_sha1(self, inventory_id):
704
708
705
709
def common_ancestor(self, other, self_revno=None, other_revno=None):
706
710
"""
707
>>> from bzrlib.commit import commit
711
>>> import commit
708
712
>>> sb = ScratchBranch(files=['foo', 'foo~'])
709
713
>>> sb.common_ancestor(sb) == (None, None)
710
714
True
711
>>> commit(sb, "Committing first revision", verbose=False)
715
>>> commit.commit(sb, "Committing first revision", verbose=False)
712
716
>>> sb.common_ancestor(sb)[0]
713
717
1
714
718
>>> clone = sb.clone()
715
>>> commit(sb, "Committing second revision", verbose=False)
719
>>> commit.commit(sb, "Committing second revision", verbose=False)
716
720
>>> sb.common_ancestor(sb)[0]
717
721
2
718
722
>>> sb.common_ancestor(clone)[0]
719
723
1
720
>>> commit(clone, "Committing divergent second revision",
724
>>> commit.commit(clone, "Committing divergent second revision",
721
725
... verbose=False)
722
726
>>> sb.common_ancestor(clone)[0]
723
727
1
766
770
return None
767
771
768
772
769
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
773
def missing_revisions(self, other, stop_revision=None):
770
774
"""
771
775
If self and other have not diverged, return a list of the revisions
772
776
present in other, but missing from self.
805
809
if stop_revision is None:
806
810
stop_revision = other_len
807
811
elif stop_revision > other_len:
808
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
812
raise NoSuchRevision(self, stop_revision)
809
813
810
814
return other_history[self_len:stop_revision]
811
815
812
816
813
817
def update_revisions(self, other, stop_revision=None):
814
818
"""Pull in all new revisions from other branch.
819
820
>>> from bzrlib.commit import commit
821
>>> bzrlib.trace.silent = True
822
>>> br1 = ScratchBranch(files=['foo', 'bar'])
823
>>> br1.add('foo')
824
>>> br1.add('bar')
825
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
826
>>> br2 = ScratchBranch()
827
>>> br2.update_revisions(br1)
828
Added 2 texts.
829
Added 1 inventories.
830
Added 1 revisions.
831
>>> br2.revision_history()
832
[u'REVISION-ID-1']
833
>>> br2.update_revisions(br1)
834
Added 0 texts.
835
Added 0 inventories.
836
Added 0 revisions.
837
>>> br1.text_store.total_size() == br2.text_store.total_size()
838
True
815
839
"""
816
from bzrlib.fetch import greedy_fetch
817
818
pb = bzrlib.ui.ui_factory.progress_bar()
840
from bzrlib.progress import ProgressBar
841
842
pb = ProgressBar()
843
819
844
pb.update('comparing histories')
820
821
845
revision_ids = self.missing_revisions(other, stop_revision)
822
846
823
if len(revision_ids) > 0:
824
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
825
else:
826
count = 0
827
self.append_revision(*revision_ids)
828
## note("Added %d revisions." % count)
829
pb.clear()
830
831
def install_revisions(self, other, revision_ids, pb):
832
847
if hasattr(other.revision_store, "prefetch"):
833
848
other.revision_store.prefetch(revision_ids)
834
849
if hasattr(other.inventory_store, "prefetch"):
835
850
inventory_ids = [other.get_revision(r).inventory_id
836
851
for r in revision_ids]
837
852
other.inventory_store.prefetch(inventory_ids)
838
839
if pb is None:
840
pb = bzrlib.ui.ui_factory.progress_bar()
841
853
842
854
revisions = []
843
855
needed_texts = set()
844
856
i = 0
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
for rev_id in revision_ids:
858
i += 1
859
pb.update('fetching revision', i, len(revision_ids))
860
rev = other.get_revision(rev_id)
855
861
revisions.append(rev)
856
862
inv = other.get_inventory(str(rev.inventory_id))
857
863
for key, entry in inv.iter_entries():
862
868
863
869
pb.clear()
864
870
865
count, cp_fail = self.text_store.copy_multi(other.text_store,
866
needed_texts)
867
#print "Added %d texts." % count
871
count = self.text_store.copy_multi(other.text_store, needed_texts)
872
print "Added %d texts." % count
868
873
inventory_ids = [ f.inventory_id for f in revisions ]
869
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
870
inventory_ids)
871
#print "Added %d inventories." % count
874
count = self.inventory_store.copy_multi(other.inventory_store,
875
inventory_ids)
876
print "Added %d inventories." % count
872
877
revision_ids = [ f.revision_id for f in revisions]
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
879
880
878
count = self.revision_store.copy_multi(other.revision_store,
879
revision_ids)
880
for revision_id in revision_ids:
881
self.append_revision(revision_id)
882
print "Added %d revisions." % count
883
884
881
885
def commit(self, *args, **kw):
882
886
from bzrlib.commit import commit
883
887
commit(self, *args, **kw)
884
888
885
889
886
890
def lookup_revision(self, revision):
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
906
907
908
def revision_id_to_revno(self, revision_id):
909
"""Given a revision id, return its revno"""
910
history = self.revision_history()
911
try:
912
return history.index(revision_id) + 1
913
except ValueError:
914
raise bzrlib.errors.NoSuchRevision(self, revision_id)
915
916
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]
891
"""Return the revision identifier for a given revision information."""
892
revno, info = self.get_revision_info(revision)
893
return info
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
if revision is None:
904
return 0, None
905
revno = None
906
try:# Convert to int if possible
907
revision = int(revision)
908
except ValueError:
909
pass
910
revs = self.revision_history()
911
if isinstance(revision, int):
912
if revision == 0:
913
return 0, None
914
# Mabye we should do this first, but we don't need it if revision == 0
915
if revision < 0:
916
revno = len(revs) + revision + 1
917
else:
918
revno = revision
919
elif isinstance(revision, basestring):
920
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
921
if revision.startswith(prefix):
922
revno = func(self, revs, revision)
923
break
924
else:
925
raise BzrError('No namespace registered for string: %r' % revision)
926
927
if revno is None or revno <= 0 or revno > len(revs):
928
raise BzrError("no such revision %s" % revision)
929
return revno, revs[revno-1]
930
931
def _namespace_revno(self, revs, revision):
932
"""Lookup a revision by revision number"""
933
assert revision.startswith('revno:')
934
try:
935
return int(revision[6:])
936
except ValueError:
937
return None
938
REVISION_NAMESPACES['revno:'] = _namespace_revno
939
940
def _namespace_revid(self, revs, revision):
941
assert revision.startswith('revid:')
942
try:
943
return revs.index(revision[6:]) + 1
944
except ValueError:
945
return None
946
REVISION_NAMESPACES['revid:'] = _namespace_revid
947
948
def _namespace_last(self, revs, revision):
949
assert revision.startswith('last:')
950
try:
951
offset = int(revision[5:])
952
except ValueError:
953
return None
954
else:
955
if offset <= 0:
956
raise BzrError('You must supply a positive value for --revision last:XXX')
957
return len(revs) - offset + 1
958
REVISION_NAMESPACES['last:'] = _namespace_last
959
960
def _namespace_tag(self, revs, revision):
961
assert revision.startswith('tag:')
962
raise BzrError('tag: namespace registered, but not implemented.')
963
REVISION_NAMESPACES['tag:'] = _namespace_tag
964
965
def _namespace_date(self, revs, revision):
966
assert revision.startswith('date:')
967
import datetime
968
# Spec for date revisions:
969
# date:value
970
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
971
# it can also start with a '+/-/='. '+' says match the first
972
# entry after the given date. '-' is match the first entry before the date
973
# '=' is match the first entry after, but still on the given date.
974
#
975
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
976
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
977
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
978
# May 13th, 2005 at 0:00
979
#
980
# So the proper way of saying 'give me all entries for today' is:
981
# -r {date:+today}:{date:-tomorrow}
982
# The default is '=' when not supplied
983
val = revision[5:]
984
match_style = '='
985
if val[:1] in ('+', '-', '='):
986
match_style = val[:1]
987
val = val[1:]
988
989
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
990
if val.lower() == 'yesterday':
991
dt = today - datetime.timedelta(days=1)
992
elif val.lower() == 'today':
993
dt = today
994
elif val.lower() == 'tomorrow':
995
dt = today + datetime.timedelta(days=1)
996
else:
997
import re
998
# This should be done outside the function to avoid recompiling it.
999
_date_re = re.compile(
1000
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1001
r'(,|T)?\s*'
1002
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1003
)
1004
m = _date_re.match(val)
1005
if not m or (not m.group('date') and not m.group('time')):
1006
raise BzrError('Invalid revision date %r' % revision)
1007
1008
if m.group('date'):
1009
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1010
else:
1011
year, month, day = today.year, today.month, today.day
1012
if m.group('time'):
1013
hour = int(m.group('hour'))
1014
minute = int(m.group('minute'))
1015
if m.group('second'):
1016
second = int(m.group('second'))
1017
else:
1018
second = 0
1019
else:
1020
hour, minute, second = 0,0,0
1021
1022
dt = datetime.datetime(year=year, month=month, day=day,
1023
hour=hour, minute=minute, second=second)
1024
first = dt
1025
last = None
1026
reversed = False
1027
if match_style == '-':
1028
reversed = True
1029
elif match_style == '=':
1030
last = dt + datetime.timedelta(days=1)
1031
1032
if reversed:
1033
for i in range(len(revs)-1, -1, -1):
1034
r = self.get_revision(revs[i])
1035
# TODO: Handle timezone.
1036
dt = datetime.datetime.fromtimestamp(r.timestamp)
1037
if first >= dt and (last is None or dt >= last):
1038
return i+1
1039
else:
1040
for i in range(len(revs)):
1041
r = self.get_revision(revs[i])
1042
# TODO: Handle timezone.
1043
dt = datetime.datetime.fromtimestamp(r.timestamp)
1044
if first <= dt and (last is None or dt <= last):
1045
return i+1
1046
REVISION_NAMESPACES['date:'] = _namespace_date
926
1047
927
1048
def revision_tree(self, revision_id):
928
1049
"""Return Tree for a revision on this branch.
940
1061
941
1062
def working_tree(self):
942
1063
"""Return a `Tree` for the working copy."""
943
from bzrlib.workingtree import WorkingTree
1064
from workingtree import WorkingTree
944
1065
return WorkingTree(self.base, self.read_working_inventory())
945
1066
946
1067
992
1113
993
1114
inv.rename(file_id, to_dir_id, to_tail)
994
1115
1116
print "%s => %s" % (from_rel, to_rel)
1117
995
1118
from_abs = self.abspath(from_rel)
996
1119
to_abs = self.abspath(to_rel)
997
1120
try:
1016
1139
1017
1140
Note that to_name is only the last component of the new name;
1018
1141
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.
1022
1142
"""
1023
result = []
1024
1143
self.lock_write()
1025
1144
try:
1026
1145
## TODO: Option to move IDs only
1061
1180
for f in from_paths:
1062
1181
name_tail = splitpath(f)[-1]
1063
1182
dest_path = appendpath(to_name, name_tail)
1064
result.append((f, dest_path))
1183
print "%s => %s" % (f, dest_path)
1065
1184
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1066
1185
try:
1067
1186
os.rename(self.abspath(f), self.abspath(dest_path))
1073
1192
finally:
1074
1193
self.unlock()
1075
1194
1076
return result
1077
1078
1195
1079
1196
def revert(self, filenames, old_tree=None, backups=True):
1080
1197
"""Restore selected files to the versions from a previous tree.
1162
1279
self.unlock()
1163
1280
1164
1281
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):
1282
1283
class ScratchBranch(Branch):
1217
1284
"""Special test class: a branch that cleans up after itself.
1218
1285
1219
1286
>>> b = ScratchBranch()
1236
1303
if base is None:
1237
1304
base = mkdtemp()
1238
1305
init = True
1239
LocalBranch.__init__(self, base, init=init)
1306
Branch.__init__(self, base, init=init)
1240
1307
for d in dirs:
1241
1308
os.mkdir(self.abspath(d))
1242
1309
1259
1326
os.rmdir(base)
1260
1327
copytree(self.base, base, symlinks=True)
1261
1328
return ScratchBranch(base=base)
1262
1263
1264
1329
1265
1330
def __del__(self):
1266
1331
self.destroy()
1336
1401
"""Return a new tree-root file id."""
1337
1402
return gen_file_id('TREE_ROOT')
1338
1403
1339
1340
def copy_branch(branch_from, to_location, revision=None):
1341
"""Copy branch_from into the existing directory to_location.
1342
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.
1349
"""
1350
from bzrlib.merge import merge
1351
from bzrlib.revisionspec import RevisionSpec
1352
1353
assert isinstance(branch_from, Branch)
1354
assert isinstance(to_location, basestring)
1355
1356
br_to = Branch(to_location, init=True)
1357
br_to.set_root_id(branch_from.get_root_id())
1358
if revision is None:
1359
revno = branch_from.revno()
1360
else:
1361
revno, rev_id = RevisionSpec(branch_from, revision)
1362
br_to.update_revisions(branch_from, stop_revision=revno)
1363
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1364
check_clean=False, ignore_zero=True)
1365
1366
from_location = branch_from.base
1367
br_to.set_parent(branch_from.base)
1368
Loggerhead is a web-based interface for Breezy
Version: 2.0.1