« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 623
- compare with another revision
- download diff
- download tarball
- view history from revision 623
- Committer: Martin Pool
- Date: 2005-06-06 04:47:33 UTC
- Revision ID: mbp@sourcefrog.net-20050606044733-e902b05ac1747cd2
- fix invocation of testbzr when giving explicit bzr location
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/selftest
- contrib/emacs
- effbot
- effbot/org
- plugins
- plugins/changeset
- tools
- files renamed:
- bzrlib/selftest/__init__.py => bzrlib/selftest.py
- bzrlib/selftest/whitebox.py => bzrlib/whitebox.py
- files modified:
- .bzrignore
added
removed
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
18
import sys
19
import os
18
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
19
import traceback, socket, fnmatch, difflib, time
20
from binascii import hexlify
20
21
21
22
import bzrlib
22
from bzrlib.trace import mutter, note
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
splitpath, \
25
sha_file, appendpath, file_kind
26
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
27
import bzrlib.errors
28
from bzrlib.textui import show_status
29
from bzrlib.revision import Revision
30
from bzrlib.xml import unpack_xml
31
from bzrlib.delta import compare_trees
32
from bzrlib.tree import EmptyTree, RevisionTree
33
23
from inventory import Inventory
24
from trace import mutter, note
25
from tree import Tree, EmptyTree, RevisionTree
26
from inventory import InventoryEntry, Inventory
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
28
format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
29
joinpath, sha_string, file_kind, local_time_offset, appendpath
30
from store import ImmutableStore
31
from revision import Revision
32
from errors import BzrError
33
from textui import show_status
34
34
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
35
36
## TODO: Maybe include checks for common corruption of newlines, etc?
36
37
37
38
38
# TODO: Some operations like log might retrieve the same revisions
39
# repeatedly to calculate deltas. We could perhaps have a weakref
40
# cache in memory to make this faster.
41
42
39
43
40
def find_branch(f, **args):
44
41
if f and (f.startswith('http://') or f.startswith('https://')):
48
45
return Branch(f, **args)
49
46
50
47
51
def find_cached_branch(f, cache_root, **args):
52
from remotebranch import RemoteBranch
53
br = find_branch(f, **args)
54
def cacheify(br, store_name):
55
from meta_store import CachedStore
56
cache_path = os.path.join(cache_root, store_name)
57
os.mkdir(cache_path)
58
new_store = CachedStore(getattr(br, store_name), cache_path)
59
setattr(br, store_name, new_store)
60
61
if isinstance(br, RemoteBranch):
62
cacheify(br, 'inventory_store')
63
cacheify(br, 'text_store')
64
cacheify(br, 'revision_store')
65
return br
66
67
48
68
49
def _relpath(base, path):
69
50
"""Return path relative to base, or raise exception.
123
104
raise BzrError('%r is not in a branch' % orig_f)
124
105
f = head
125
106
126
class DivergedBranches(Exception):
127
def __init__(self, branch1, branch2):
128
self.branch1 = branch1
129
self.branch2 = branch2
130
Exception.__init__(self, "These branches have diverged.")
131
107
132
108
133
109
######################################################################
154
130
_lock_count = None
155
131
_lock = None
156
132
157
# Map some sort of prefix into a namespace
158
# stuff like "revno:10", "revid:", etc.
159
# This should match a prefix with a function which accepts
160
REVISION_NAMESPACES = {}
161
162
133
def __init__(self, base, init=False, find_root=True):
163
134
"""Create new branch object at a particular location.
164
135
174
145
In the test suite, creation of new trees is tested using the
175
146
`ScratchBranch` class.
176
147
"""
177
from bzrlib.store import ImmutableStore
178
148
if init:
179
149
self.base = os.path.realpath(base)
180
150
self._make_control()
266
236
267
237
def controlfilename(self, file_or_path):
268
238
"""Return location relative to branch."""
269
if isinstance(file_or_path, basestring):
239
if isinstance(file_or_path, types.StringTypes):
270
240
file_or_path = [file_or_path]
271
241
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
272
242
299
269
300
270
301
271
def _make_control(self):
302
from bzrlib.inventory import Inventory
303
from bzrlib.xml import pack_xml
304
305
272
os.mkdir(self.controlfilename([]))
306
273
self.controlfile('README', 'w').write(
307
274
"This is a Bazaar-NG control directory.\n"
308
"Do not change any files in this directory.\n")
275
"Do not change any files in this directory.")
309
276
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
310
277
for d in ('text-store', 'inventory-store', 'revision-store'):
311
278
os.mkdir(self.controlfilename(d))
312
279
for f in ('revision-history', 'merged-patches',
313
280
'pending-merged-patches', 'branch-name',
314
'branch-lock',
315
'pending-merges'):
281
'branch-lock'):
316
282
self.controlfile(f, 'w').write('')
317
283
mutter('created control directory in ' + self.base)
318
319
# if we want per-tree root ids then this is the place to set
320
# them; they're not needed for now and so ommitted for
321
# simplicity.
322
pack_xml(Inventory(), self.controlfile('inventory','w'))
284
Inventory().write_xml(self.controlfile('inventory','w'))
323
285
324
286
325
287
def _check_format(self):
340
302
['use a different bzr version',
341
303
'or remove the .bzr directory and "bzr init" again'])
342
304
343
def get_root_id(self):
344
"""Return the id of this branches root"""
345
inv = self.read_working_inventory()
346
return inv.root.file_id
347
305
348
def set_root_id(self, file_id):
349
inv = self.read_working_inventory()
350
orig_root_id = inv.root.file_id
351
del inv._byid[inv.root.file_id]
352
inv.root.file_id = file_id
353
inv._byid[inv.root.file_id] = inv.root
354
for fid in inv:
355
entry = inv[fid]
356
if entry.parent_id in (None, orig_root_id):
357
entry.parent_id = inv.root.file_id
358
self._write_inventory(inv)
359
306
360
307
def read_working_inventory(self):
361
308
"""Read the working inventory."""
362
from bzrlib.inventory import Inventory
363
from bzrlib.xml import unpack_xml
364
from time import time
365
before = time()
309
before = time.time()
310
# ElementTree does its own conversion from UTF-8, so open in
311
# binary.
366
312
self.lock_read()
367
313
try:
368
# ElementTree does its own conversion from UTF-8, so open in
369
# binary.
370
inv = unpack_xml(Inventory,
371
self.controlfile('inventory', 'rb'))
314
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
372
315
mutter("loaded inventory of %d items in %f"
373
% (len(inv), time() - before))
316
% (len(inv), time.time() - before))
374
317
return inv
375
318
finally:
376
319
self.unlock()
382
325
That is to say, the inventory describing changes underway, that
383
326
will be committed to the next revision.
384
327
"""
385
from bzrlib.atomicfile import AtomicFile
386
from bzrlib.xml import pack_xml
387
388
self.lock_write()
389
try:
390
f = AtomicFile(self.controlfilename('inventory'), 'wb')
391
try:
392
pack_xml(inv, f)
393
f.commit()
394
finally:
395
f.close()
396
finally:
397
self.unlock()
398
328
## TODO: factor out to atomicfile? is rename safe on windows?
329
## TODO: Maybe some kind of clean/dirty marker on inventory?
330
tmpfname = self.controlfilename('inventory.tmp')
331
tmpf = file(tmpfname, 'wb')
332
inv.write_xml(tmpf)
333
tmpf.close()
334
inv_fname = self.controlfilename('inventory')
335
if sys.platform == 'win32':
336
os.remove(inv_fname)
337
os.rename(tmpfname, inv_fname)
399
338
mutter('wrote working inventory')
400
339
401
340
431
370
"""
432
371
# TODO: Re-adding a file that is removed in the working copy
433
372
# should probably put it back with the previous ID.
434
if isinstance(files, basestring):
435
assert(ids is None or isinstance(ids, basestring))
373
if isinstance(files, types.StringTypes):
374
assert(ids is None or isinstance(ids, types.StringTypes))
436
375
files = [files]
437
376
if ids is not None:
438
377
ids = [ids]
470
409
inv.add_path(f, kind=kind, file_id=file_id)
471
410
472
411
if verbose:
473
print 'added', quotefn(f)
412
show_status('A', kind, quotefn(f))
474
413
475
414
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
476
415
487
426
# use inventory as it was in that revision
488
427
file_id = tree.inventory.path2id(file)
489
428
if not file_id:
490
raise BzrError("%r is not present in revision %s" % (file, revno))
429
raise BzrError("%r is not present in revision %d" % (file, revno))
491
430
tree.print_file(file_id)
492
431
finally:
493
432
self.unlock()
509
448
"""
510
449
## TODO: Normalize names
511
450
## TODO: Remove nested loops; better scalability
512
if isinstance(files, basestring):
451
if isinstance(files, types.StringTypes):
513
452
files = [files]
514
453
515
454
self.lock_write()
540
479
541
480
# FIXME: this doesn't need to be a branch method
542
481
def set_inventory(self, new_inventory_list):
543
from bzrlib.inventory import Inventory, InventoryEntry
544
inv = Inventory(self.get_root_id())
482
inv = Inventory()
545
483
for path, file_id, parent, kind in new_inventory_list:
546
484
name = os.path.basename(path)
547
485
if name == "":
569
507
return self.working_tree().unknowns()
570
508
571
509
572
def append_revision(self, *revision_ids):
573
from bzrlib.atomicfile import AtomicFile
574
575
for revision_id in revision_ids:
576
mutter("add {%s} to revision-history" % revision_id)
577
510
def append_revision(self, revision_id):
511
mutter("add {%s} to revision-history" % revision_id)
578
512
rev_history = self.revision_history()
579
rev_history.extend(revision_ids)
580
581
f = AtomicFile(self.controlfilename('revision-history'))
582
try:
583
for rev_id in rev_history:
584
print >>f, rev_id
585
f.commit()
586
finally:
587
f.close()
588
589
590
def get_revision_xml(self, revision_id):
591
"""Return XML file object for revision object."""
592
if not revision_id or not isinstance(revision_id, basestring):
593
raise InvalidRevisionId(revision_id)
594
595
self.lock_read()
596
try:
597
try:
598
return self.revision_store[revision_id]
599
except IndexError:
600
raise bzrlib.errors.NoSuchRevision(self, revision_id)
601
finally:
602
self.unlock()
513
514
tmprhname = self.controlfilename('revision-history.tmp')
515
rhname = self.controlfilename('revision-history')
516
517
f = file(tmprhname, 'wt')
518
rev_history.append(revision_id)
519
f.write('\n'.join(rev_history))
520
f.write('\n')
521
f.close()
522
523
if sys.platform == 'win32':
524
os.remove(rhname)
525
os.rename(tmprhname, rhname)
526
603
527
604
528
605
529
def get_revision(self, revision_id):
606
530
"""Return the Revision object for a named revision"""
607
xml_file = self.get_revision_xml(revision_id)
608
609
try:
610
r = unpack_xml(Revision, xml_file)
611
except SyntaxError, e:
612
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
613
[revision_id,
614
str(e)])
615
531
r = Revision.read_xml(self.revision_store[revision_id])
616
532
assert r.revision_id == revision_id
617
533
return r
618
534
619
535
620
def get_revision_delta(self, revno):
621
"""Return the delta for one revision.
622
623
The delta is relative to its mainline predecessor, or the
624
empty tree for revision 1.
625
"""
626
assert isinstance(revno, int)
627
rh = self.revision_history()
628
if not (1 <= revno <= len(rh)):
629
raise InvalidRevisionNumber(revno)
630
631
# revno is 1-based; list is 0-based
632
633
new_tree = self.revision_tree(rh[revno-1])
634
if revno == 1:
635
old_tree = EmptyTree()
636
else:
637
old_tree = self.revision_tree(rh[revno-2])
638
639
return compare_trees(old_tree, new_tree)
640
641
642
643
def get_revision_sha1(self, revision_id):
644
"""Hash the stored value of a revision, and return it."""
645
# In the future, revision entries will be signed. At that
646
# point, it is probably best *not* to include the signature
647
# in the revision hash. Because that lets you re-sign
648
# the revision, (add signatures/remove signatures) and still
649
# have all hash pointers stay consistent.
650
# But for now, just hash the contents.
651
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
652
653
654
536
def get_inventory(self, inventory_id):
655
537
"""Get Inventory object by hash.
656
538
657
539
TODO: Perhaps for this and similar methods, take a revision
658
540
parameter which can be either an integer revno or a
659
541
string hash."""
660
from bzrlib.inventory import Inventory
661
from bzrlib.xml import unpack_xml
662
663
return unpack_xml(Inventory, self.inventory_store[inventory_id])
664
665
666
def get_inventory_sha1(self, inventory_id):
667
"""Return the sha1 hash of the inventory entry
668
"""
669
return sha_file(self.inventory_store[inventory_id])
542
i = Inventory.read_xml(self.inventory_store[inventory_id])
543
return i
670
544
671
545
672
546
def get_revision_inventory(self, revision_id):
673
547
"""Return inventory of a past revision."""
674
# bzr 0.0.6 imposes the constraint that the inventory_id
675
# must be the same as its revision, so this is trivial.
676
548
if revision_id == None:
677
from bzrlib.inventory import Inventory
678
return Inventory(self.get_root_id())
549
return Inventory()
679
550
else:
680
return self.get_inventory(revision_id)
551
return self.get_inventory(self.get_revision(revision_id).inventory_id)
681
552
682
553
683
554
def revision_history(self):
738
609
return r+1, my_history[r]
739
610
return None, None
740
611
612
def enum_history(self, direction):
613
"""Return (revno, revision_id) for history of branch.
614
615
direction
616
'forward' is from earliest to latest
617
'reverse' is from latest to earliest
618
"""
619
rh = self.revision_history()
620
if direction == 'forward':
621
i = 1
622
for rid in rh:
623
yield i, rid
624
i += 1
625
elif direction == 'reverse':
626
i = len(rh)
627
while i > 0:
628
yield i, rh[i-1]
629
i -= 1
630
else:
631
raise ValueError('invalid history direction', direction)
632
741
633
742
634
def revno(self):
743
635
"""Return current revision number for this branch.
758
650
return None
759
651
760
652
761
def missing_revisions(self, other, stop_revision=None):
762
"""
763
If self and other have not diverged, return a list of the revisions
764
present in other, but missing from self.
765
766
>>> from bzrlib.commit import commit
767
>>> bzrlib.trace.silent = True
768
>>> br1 = ScratchBranch()
769
>>> br2 = ScratchBranch()
770
>>> br1.missing_revisions(br2)
771
[]
772
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
773
>>> br1.missing_revisions(br2)
774
[u'REVISION-ID-1']
775
>>> br2.missing_revisions(br1)
776
[]
777
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
778
>>> br1.missing_revisions(br2)
779
[]
780
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
781
>>> br1.missing_revisions(br2)
782
[u'REVISION-ID-2A']
783
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
784
>>> br1.missing_revisions(br2)
785
Traceback (most recent call last):
786
DivergedBranches: These branches have diverged.
787
"""
788
self_history = self.revision_history()
789
self_len = len(self_history)
790
other_history = other.revision_history()
791
other_len = len(other_history)
792
common_index = min(self_len, other_len) -1
793
if common_index >= 0 and \
794
self_history[common_index] != other_history[common_index]:
795
raise DivergedBranches(self, other)
796
797
if stop_revision is None:
798
stop_revision = other_len
799
elif stop_revision > other_len:
800
raise NoSuchRevision(self, stop_revision)
801
802
return other_history[self_len:stop_revision]
803
804
805
def update_revisions(self, other, stop_revision=None):
806
"""Pull in all new revisions from other branch.
807
808
>>> from bzrlib.commit import commit
809
>>> bzrlib.trace.silent = True
810
>>> br1 = ScratchBranch(files=['foo', 'bar'])
811
>>> br1.add('foo')
812
>>> br1.add('bar')
813
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
814
>>> br2 = ScratchBranch()
815
>>> br2.update_revisions(br1)
816
Added 2 texts.
817
Added 1 inventories.
818
Added 1 revisions.
819
>>> br2.revision_history()
820
[u'REVISION-ID-1']
821
>>> br2.update_revisions(br1)
822
Added 0 texts.
823
Added 0 inventories.
824
Added 0 revisions.
825
>>> br1.text_store.total_size() == br2.text_store.total_size()
826
True
827
"""
828
from bzrlib.progress import ProgressBar
829
830
pb = ProgressBar()
831
832
pb.update('comparing histories')
833
revision_ids = self.missing_revisions(other, stop_revision)
834
835
if hasattr(other.revision_store, "prefetch"):
836
other.revision_store.prefetch(revision_ids)
837
if hasattr(other.inventory_store, "prefetch"):
838
inventory_ids = [other.get_revision(r).inventory_id
839
for r in revision_ids]
840
other.inventory_store.prefetch(inventory_ids)
841
842
revisions = []
843
needed_texts = set()
844
i = 0
845
for rev_id in revision_ids:
846
i += 1
847
pb.update('fetching revision', i, len(revision_ids))
848
rev = other.get_revision(rev_id)
849
revisions.append(rev)
850
inv = other.get_inventory(str(rev.inventory_id))
851
for key, entry in inv.iter_entries():
852
if entry.text_id is None:
853
continue
854
if entry.text_id not in self.text_store:
855
needed_texts.add(entry.text_id)
856
857
pb.clear()
858
859
count = self.text_store.copy_multi(other.text_store, needed_texts)
860
print "Added %d texts." % count
861
inventory_ids = [ f.inventory_id for f in revisions ]
862
count = self.inventory_store.copy_multi(other.inventory_store,
863
inventory_ids)
864
print "Added %d inventories." % count
865
revision_ids = [ f.revision_id for f in revisions]
866
count = self.revision_store.copy_multi(other.revision_store,
867
revision_ids)
868
for revision_id in revision_ids:
869
self.append_revision(revision_id)
870
print "Added %d revisions." % count
871
872
873
653
def commit(self, *args, **kw):
654
"""Deprecated"""
874
655
from bzrlib.commit import commit
875
656
commit(self, *args, **kw)
876
657
877
658
878
def lookup_revision(self, revision):
879
"""Return the revision identifier for a given revision information."""
880
revno, info = self.get_revision_info(revision)
881
return info
882
883
def get_revision_info(self, revision):
884
"""Return (revno, revision id) for revision identifier.
885
886
revision can be an integer, in which case it is assumed to be revno (though
887
this will translate negative values into positive ones)
888
revision can also be a string, in which case it is parsed for something like
889
'date:' or 'revid:' etc.
890
"""
891
if revision is None:
892
return 0, None
893
revno = None
894
try:# Convert to int if possible
895
revision = int(revision)
896
except ValueError:
897
pass
898
revs = self.revision_history()
899
if isinstance(revision, int):
900
if revision == 0:
901
return 0, None
902
# Mabye we should do this first, but we don't need it if revision == 0
903
if revision < 0:
904
revno = len(revs) + revision + 1
905
else:
906
revno = revision
907
elif isinstance(revision, basestring):
908
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
909
if revision.startswith(prefix):
910
revno = func(self, revs, revision)
911
break
912
else:
913
raise BzrError('No namespace registered for string: %r' % revision)
914
915
if revno is None or revno <= 0 or revno > len(revs):
916
raise BzrError("no such revision %s" % revision)
917
return revno, revs[revno-1]
918
919
def _namespace_revno(self, revs, revision):
920
"""Lookup a revision by revision number"""
921
assert revision.startswith('revno:')
922
try:
923
return int(revision[6:])
924
except ValueError:
925
return None
926
REVISION_NAMESPACES['revno:'] = _namespace_revno
927
928
def _namespace_revid(self, revs, revision):
929
assert revision.startswith('revid:')
930
try:
931
return revs.index(revision[6:]) + 1
932
except ValueError:
933
return None
934
REVISION_NAMESPACES['revid:'] = _namespace_revid
935
936
def _namespace_last(self, revs, revision):
937
assert revision.startswith('last:')
938
try:
939
offset = int(revision[5:])
940
except ValueError:
941
return None
942
else:
943
if offset <= 0:
944
raise BzrError('You must supply a positive value for --revision last:XXX')
945
return len(revs) - offset + 1
946
REVISION_NAMESPACES['last:'] = _namespace_last
947
948
def _namespace_tag(self, revs, revision):
949
assert revision.startswith('tag:')
950
raise BzrError('tag: namespace registered, but not implemented.')
951
REVISION_NAMESPACES['tag:'] = _namespace_tag
952
953
def _namespace_date(self, revs, revision):
954
assert revision.startswith('date:')
955
import datetime
956
# Spec for date revisions:
957
# date:value
958
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
959
# it can also start with a '+/-/='. '+' says match the first
960
# entry after the given date. '-' is match the first entry before the date
961
# '=' is match the first entry after, but still on the given date.
962
#
963
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
964
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
965
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
966
# May 13th, 2005 at 0:00
967
#
968
# So the proper way of saying 'give me all entries for today' is:
969
# -r {date:+today}:{date:-tomorrow}
970
# The default is '=' when not supplied
971
val = revision[5:]
972
match_style = '='
973
if val[:1] in ('+', '-', '='):
974
match_style = val[:1]
975
val = val[1:]
976
977
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
978
if val.lower() == 'yesterday':
979
dt = today - datetime.timedelta(days=1)
980
elif val.lower() == 'today':
981
dt = today
982
elif val.lower() == 'tomorrow':
983
dt = today + datetime.timedelta(days=1)
984
else:
985
import re
986
# This should be done outside the function to avoid recompiling it.
987
_date_re = re.compile(
988
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
989
r'(,|T)?\s*'
990
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
991
)
992
m = _date_re.match(val)
993
if not m or (not m.group('date') and not m.group('time')):
994
raise BzrError('Invalid revision date %r' % revision)
995
996
if m.group('date'):
997
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
998
else:
999
year, month, day = today.year, today.month, today.day
1000
if m.group('time'):
1001
hour = int(m.group('hour'))
1002
minute = int(m.group('minute'))
1003
if m.group('second'):
1004
second = int(m.group('second'))
1005
else:
1006
second = 0
1007
else:
1008
hour, minute, second = 0,0,0
1009
1010
dt = datetime.datetime(year=year, month=month, day=day,
1011
hour=hour, minute=minute, second=second)
1012
first = dt
1013
last = None
1014
reversed = False
1015
if match_style == '-':
1016
reversed = True
1017
elif match_style == '=':
1018
last = dt + datetime.timedelta(days=1)
1019
1020
if reversed:
1021
for i in range(len(revs)-1, -1, -1):
1022
r = self.get_revision(revs[i])
1023
# TODO: Handle timezone.
1024
dt = datetime.datetime.fromtimestamp(r.timestamp)
1025
if first >= dt and (last is None or dt >= last):
1026
return i+1
1027
else:
1028
for i in range(len(revs)):
1029
r = self.get_revision(revs[i])
1030
# TODO: Handle timezone.
1031
dt = datetime.datetime.fromtimestamp(r.timestamp)
1032
if first <= dt and (last is None or dt <= last):
1033
return i+1
1034
REVISION_NAMESPACES['date:'] = _namespace_date
659
def lookup_revision(self, revno):
660
"""Return revision hash for revision number."""
661
if revno == 0:
662
return None
663
664
try:
665
# list is 0-based; revisions are 1-based
666
return self.revision_history()[revno-1]
667
except IndexError:
668
raise BzrError("no such revision %s" % revno)
669
1035
670
1036
671
def revision_tree(self, revision_id):
1037
672
"""Return Tree for a revision on this branch.
1181
816
self.unlock()
1182
817
1183
818
1184
def revert(self, filenames, old_tree=None, backups=True):
1185
"""Restore selected files to the versions from a previous tree.
1186
1187
backups
1188
If true (default) backups are made of files before
1189
they're renamed.
1190
"""
1191
from bzrlib.errors import NotVersionedError, BzrError
1192
from bzrlib.atomicfile import AtomicFile
1193
from bzrlib.osutils import backup_file
1194
1195
inv = self.read_working_inventory()
1196
if old_tree is None:
1197
old_tree = self.basis_tree()
1198
old_inv = old_tree.inventory
1199
1200
nids = []
1201
for fn in filenames:
1202
file_id = inv.path2id(fn)
1203
if not file_id:
1204
raise NotVersionedError("not a versioned file", fn)
1205
if not old_inv.has_id(file_id):
1206
raise BzrError("file not present in old tree", fn, file_id)
1207
nids.append((fn, file_id))
1208
1209
# TODO: Rename back if it was previously at a different location
1210
1211
# TODO: If given a directory, restore the entire contents from
1212
# the previous version.
1213
1214
# TODO: Make a backup to a temporary file.
1215
1216
# TODO: If the file previously didn't exist, delete it?
1217
for fn, file_id in nids:
1218
backup_file(fn)
1219
1220
f = AtomicFile(fn, 'wb')
1221
try:
1222
f.write(old_tree.get_file(file_id).read())
1223
f.commit()
1224
finally:
1225
f.close()
1226
1227
1228
def pending_merges(self):
1229
"""Return a list of pending merges.
1230
1231
These are revisions that have been merged into the working
1232
directory but not yet committed.
1233
"""
1234
cfn = self.controlfilename('pending-merges')
1235
if not os.path.exists(cfn):
1236
return []
1237
p = []
1238
for l in self.controlfile('pending-merges', 'r').readlines():
1239
p.append(l.rstrip('\n'))
1240
return p
1241
1242
1243
def add_pending_merge(self, revision_id):
1244
from bzrlib.revision import validate_revision_id
1245
1246
validate_revision_id(revision_id)
1247
1248
p = self.pending_merges()
1249
if revision_id in p:
1250
return
1251
p.append(revision_id)
1252
self.set_pending_merges(p)
1253
1254
1255
def set_pending_merges(self, rev_list):
1256
from bzrlib.atomicfile import AtomicFile
1257
self.lock_write()
1258
try:
1259
f = AtomicFile(self.controlfilename('pending-merges'))
1260
try:
1261
for l in rev_list:
1262
print >>f, l
1263
f.commit()
1264
finally:
1265
f.close()
1266
finally:
1267
self.unlock()
1268
1269
1270
819
1271
820
class ScratchBranch(Branch):
1272
821
"""Special test class: a branch that cleans up after itself.
1286
835
1287
836
If any files are listed, they are created in the working copy.
1288
837
"""
1289
from tempfile import mkdtemp
1290
838
init = False
1291
839
if base is None:
1292
base = mkdtemp()
840
base = tempfile.mkdtemp()
1293
841
init = True
1294
842
Branch.__init__(self, base, init=init)
1295
843
for d in dirs:
1308
856
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1309
857
True
1310
858
"""
1311
from shutil import copytree
1312
from tempfile import mkdtemp
1313
base = mkdtemp()
859
base = tempfile.mkdtemp()
1314
860
os.rmdir(base)
1315
copytree(self.base, base, symlinks=True)
861
shutil.copytree(self.base, base, symlinks=True)
1316
862
return ScratchBranch(base=base)
1317
863
1318
864
def __del__(self):
1320
866
1321
867
def destroy(self):
1322
868
"""Destroy the test branch, removing the scratch directory."""
1323
from shutil import rmtree
1324
869
try:
1325
870
if self.base:
1326
871
mutter("delete ScratchBranch %s" % self.base)
1327
rmtree(self.base)
872
shutil.rmtree(self.base)
1328
873
except OSError, e:
1329
874
# Work around for shutil.rmtree failing on Windows when
1330
875
# readonly files are encountered
1332
877
for root, dirs, files in os.walk(self.base, topdown=False):
1333
878
for name in files:
1334
879
os.chmod(os.path.join(root, name), 0700)
1335
rmtree(self.base)
880
shutil.rmtree(self.base)
1336
881
self.base = None
1337
882
1338
883
1363
908
cope with just randomness because running uuidgen every time is
1364
909
slow."""
1365
910
import re
1366
from binascii import hexlify
1367
from time import time
1368
911
1369
912
# get last component
1370
913
idx = name.rfind('/')
1382
925
name = re.sub(r'[^\w.]', '', name)
1383
926
1384
927
s = hexlify(rand_bytes(8))
1385
return '-'.join((name, compact_date(time()), s))
1386
1387
1388
def gen_root_id():
1389
"""Return a new tree-root file id."""
1390
return gen_file_id('TREE_ROOT')
1391
928
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1