« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 635
- compare with another revision
- download diff
- download tarball
- view history from revision 635
- Committer: Martin Pool
- Date: 2005-06-06 13:24:18 UTC
- Revision ID: mbp@sourcefrog.net-20050606132418-1082c87e2473e266
- manpage generator by Hans Ulrich Niedermann
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- bzrlib/selftest/__init__.py => bzrlib/selftest.py
- bzrlib/selftest/whitebox.py => bzrlib/whitebox.py
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- 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
from bzrlib.progress import ProgressBar
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
36
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
37
36
## TODO: Maybe include checks for common corruption of newlines, etc?
38
37
39
38
40
# TODO: Some operations like log might retrieve the same revisions
41
# repeatedly to calculate deltas. We could perhaps have a weakref
42
# cache in memory to make this faster.
43
44
# TODO: please move the revision-string syntax stuff out of the branch
45
# object; it's clutter
46
47
39
48
40
def find_branch(f, **args):
49
41
if f and (f.startswith('http://') or f.startswith('https://')):
53
45
return Branch(f, **args)
54
46
55
47
56
def find_cached_branch(f, cache_root, **args):
57
from remotebranch import RemoteBranch
58
br = find_branch(f, **args)
59
def cacheify(br, store_name):
60
from meta_store import CachedStore
61
cache_path = os.path.join(cache_root, store_name)
62
os.mkdir(cache_path)
63
new_store = CachedStore(getattr(br, store_name), cache_path)
64
setattr(br, store_name, new_store)
65
66
if isinstance(br, RemoteBranch):
67
cacheify(br, 'inventory_store')
68
cacheify(br, 'text_store')
69
cacheify(br, 'revision_store')
70
return br
71
72
48
73
49
def _relpath(base, path):
74
50
"""Return path relative to base, or raise exception.
134
110
self.branch2 = branch2
135
111
Exception.__init__(self, "These branches have diverged.")
136
112
137
138
113
######################################################################
139
114
# branch objects
140
115
159
134
_lock_count = None
160
135
_lock = None
161
136
162
# Map some sort of prefix into a namespace
163
# stuff like "revno:10", "revid:", etc.
164
# This should match a prefix with a function which accepts
165
REVISION_NAMESPACES = {}
166
167
137
def __init__(self, base, init=False, find_root=True):
168
138
"""Create new branch object at a particular location.
169
139
179
149
In the test suite, creation of new trees is tested using the
180
150
`ScratchBranch` class.
181
151
"""
182
from bzrlib.store import ImmutableStore
183
152
if init:
184
153
self.base = os.path.realpath(base)
185
154
self._make_control()
271
240
272
241
def controlfilename(self, file_or_path):
273
242
"""Return location relative to branch."""
274
if isinstance(file_or_path, basestring):
243
if isinstance(file_or_path, types.StringTypes):
275
244
file_or_path = [file_or_path]
276
245
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
277
246
304
273
305
274
306
275
def _make_control(self):
307
from bzrlib.inventory import Inventory
308
from bzrlib.xml import pack_xml
309
310
276
os.mkdir(self.controlfilename([]))
311
277
self.controlfile('README', 'w').write(
312
278
"This is a Bazaar-NG control directory.\n"
313
"Do not change any files in this directory.\n")
279
"Do not change any files in this directory.")
314
280
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
315
281
for d in ('text-store', 'inventory-store', 'revision-store'):
316
282
os.mkdir(self.controlfilename(d))
317
283
for f in ('revision-history', 'merged-patches',
318
284
'pending-merged-patches', 'branch-name',
319
'branch-lock',
320
'pending-merges'):
285
'branch-lock'):
321
286
self.controlfile(f, 'w').write('')
322
287
mutter('created control directory in ' + self.base)
323
324
# if we want per-tree root ids then this is the place to set
325
# them; they're not needed for now and so ommitted for
326
# simplicity.
327
pack_xml(Inventory(), self.controlfile('inventory','w'))
288
Inventory().write_xml(self.controlfile('inventory','w'))
328
289
329
290
330
291
def _check_format(self):
345
306
['use a different bzr version',
346
307
'or remove the .bzr directory and "bzr init" again'])
347
308
348
def get_root_id(self):
349
"""Return the id of this branches root"""
350
inv = self.read_working_inventory()
351
return inv.root.file_id
352
309
353
def set_root_id(self, file_id):
354
inv = self.read_working_inventory()
355
orig_root_id = inv.root.file_id
356
del inv._byid[inv.root.file_id]
357
inv.root.file_id = file_id
358
inv._byid[inv.root.file_id] = inv.root
359
for fid in inv:
360
entry = inv[fid]
361
if entry.parent_id in (None, orig_root_id):
362
entry.parent_id = inv.root.file_id
363
self._write_inventory(inv)
364
310
365
311
def read_working_inventory(self):
366
312
"""Read the working inventory."""
367
from bzrlib.inventory import Inventory
368
from bzrlib.xml import unpack_xml
369
from time import time
370
before = time()
313
before = time.time()
314
# ElementTree does its own conversion from UTF-8, so open in
315
# binary.
371
316
self.lock_read()
372
317
try:
373
# ElementTree does its own conversion from UTF-8, so open in
374
# binary.
375
inv = unpack_xml(Inventory,
376
self.controlfile('inventory', 'rb'))
318
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
377
319
mutter("loaded inventory of %d items in %f"
378
% (len(inv), time() - before))
320
% (len(inv), time.time() - before))
379
321
return inv
380
322
finally:
381
323
self.unlock()
387
329
That is to say, the inventory describing changes underway, that
388
330
will be committed to the next revision.
389
331
"""
390
from bzrlib.atomicfile import AtomicFile
391
from bzrlib.xml import pack_xml
392
393
self.lock_write()
394
try:
395
f = AtomicFile(self.controlfilename('inventory'), 'wb')
396
try:
397
pack_xml(inv, f)
398
f.commit()
399
finally:
400
f.close()
401
finally:
402
self.unlock()
403
332
## TODO: factor out to atomicfile? is rename safe on windows?
333
## TODO: Maybe some kind of clean/dirty marker on inventory?
334
tmpfname = self.controlfilename('inventory.tmp')
335
tmpf = file(tmpfname, 'wb')
336
inv.write_xml(tmpf)
337
tmpf.close()
338
inv_fname = self.controlfilename('inventory')
339
if sys.platform == 'win32':
340
os.remove(inv_fname)
341
os.rename(tmpfname, inv_fname)
404
342
mutter('wrote working inventory')
405
343
406
344
436
374
"""
437
375
# TODO: Re-adding a file that is removed in the working copy
438
376
# should probably put it back with the previous ID.
439
if isinstance(files, basestring):
440
assert(ids is None or isinstance(ids, basestring))
377
if isinstance(files, types.StringTypes):
378
assert(ids is None or isinstance(ids, types.StringTypes))
441
379
files = [files]
442
380
if ids is not None:
443
381
ids = [ids]
475
413
inv.add_path(f, kind=kind, file_id=file_id)
476
414
477
415
if verbose:
478
print 'added', quotefn(f)
416
show_status('A', kind, quotefn(f))
479
417
480
418
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
481
419
492
430
# use inventory as it was in that revision
493
431
file_id = tree.inventory.path2id(file)
494
432
if not file_id:
495
raise BzrError("%r is not present in revision %s" % (file, revno))
433
raise BzrError("%r is not present in revision %d" % (file, revno))
496
434
tree.print_file(file_id)
497
435
finally:
498
436
self.unlock()
514
452
"""
515
453
## TODO: Normalize names
516
454
## TODO: Remove nested loops; better scalability
517
if isinstance(files, basestring):
455
if isinstance(files, types.StringTypes):
518
456
files = [files]
519
457
520
458
self.lock_write()
545
483
546
484
# FIXME: this doesn't need to be a branch method
547
485
def set_inventory(self, new_inventory_list):
548
from bzrlib.inventory import Inventory, InventoryEntry
549
inv = Inventory(self.get_root_id())
486
inv = Inventory()
550
487
for path, file_id, parent, kind in new_inventory_list:
551
488
name = os.path.basename(path)
552
489
if name == "":
574
511
return self.working_tree().unknowns()
575
512
576
513
577
def append_revision(self, *revision_ids):
578
from bzrlib.atomicfile import AtomicFile
579
580
for revision_id in revision_ids:
581
mutter("add {%s} to revision-history" % revision_id)
582
514
def append_revision(self, revision_id):
515
mutter("add {%s} to revision-history" % revision_id)
583
516
rev_history = self.revision_history()
584
rev_history.extend(revision_ids)
585
586
f = AtomicFile(self.controlfilename('revision-history'))
587
try:
588
for rev_id in rev_history:
589
print >>f, rev_id
590
f.commit()
591
finally:
592
f.close()
593
594
595
def get_revision_xml(self, revision_id):
596
"""Return XML file object for revision object."""
597
if not revision_id or not isinstance(revision_id, basestring):
598
raise InvalidRevisionId(revision_id)
599
600
self.lock_read()
601
try:
602
try:
603
return self.revision_store[revision_id]
604
except IndexError:
605
raise bzrlib.errors.NoSuchRevision(self, revision_id)
606
finally:
607
self.unlock()
517
518
tmprhname = self.controlfilename('revision-history.tmp')
519
rhname = self.controlfilename('revision-history')
520
521
f = file(tmprhname, 'wt')
522
rev_history.append(revision_id)
523
f.write('\n'.join(rev_history))
524
f.write('\n')
525
f.close()
526
527
if sys.platform == 'win32':
528
os.remove(rhname)
529
os.rename(tmprhname, rhname)
530
608
531
609
532
610
533
def get_revision(self, revision_id):
611
534
"""Return the Revision object for a named revision"""
612
xml_file = self.get_revision_xml(revision_id)
613
614
try:
615
r = unpack_xml(Revision, xml_file)
616
except SyntaxError, e:
617
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
618
[revision_id,
619
str(e)])
620
535
r = Revision.read_xml(self.revision_store[revision_id])
621
536
assert r.revision_id == revision_id
622
537
return r
623
538
624
539
625
def get_revision_delta(self, revno):
626
"""Return the delta for one revision.
627
628
The delta is relative to its mainline predecessor, or the
629
empty tree for revision 1.
630
"""
631
assert isinstance(revno, int)
632
rh = self.revision_history()
633
if not (1 <= revno <= len(rh)):
634
raise InvalidRevisionNumber(revno)
635
636
# revno is 1-based; list is 0-based
637
638
new_tree = self.revision_tree(rh[revno-1])
639
if revno == 1:
640
old_tree = EmptyTree()
641
else:
642
old_tree = self.revision_tree(rh[revno-2])
643
644
return compare_trees(old_tree, new_tree)
645
646
647
648
def get_revision_sha1(self, revision_id):
649
"""Hash the stored value of a revision, and return it."""
650
# In the future, revision entries will be signed. At that
651
# point, it is probably best *not* to include the signature
652
# in the revision hash. Because that lets you re-sign
653
# the revision, (add signatures/remove signatures) and still
654
# have all hash pointers stay consistent.
655
# But for now, just hash the contents.
656
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
657
658
659
540
def get_inventory(self, inventory_id):
660
541
"""Get Inventory object by hash.
661
542
662
543
TODO: Perhaps for this and similar methods, take a revision
663
544
parameter which can be either an integer revno or a
664
545
string hash."""
665
from bzrlib.inventory import Inventory
666
from bzrlib.xml import unpack_xml
667
668
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
669
670
671
def get_inventory_xml(self, inventory_id):
672
"""Get inventory XML as a file object."""
673
return self.inventory_store[inventory_id]
674
675
676
def get_inventory_sha1(self, inventory_id):
677
"""Return the sha1 hash of the inventory entry
678
"""
679
return sha_file(self.get_inventory_xml(inventory_id))
546
i = Inventory.read_xml(self.inventory_store[inventory_id])
547
return i
680
548
681
549
682
550
def get_revision_inventory(self, revision_id):
683
551
"""Return inventory of a past revision."""
684
# bzr 0.0.6 imposes the constraint that the inventory_id
685
# must be the same as its revision, so this is trivial.
686
552
if revision_id == None:
687
from bzrlib.inventory import Inventory
688
return Inventory(self.get_root_id())
553
return Inventory()
689
554
else:
690
return self.get_inventory(revision_id)
555
return self.get_inventory(self.get_revision(revision_id).inventory_id)
691
556
692
557
693
558
def revision_history(self):
748
613
return r+1, my_history[r]
749
614
return None, None
750
615
616
def enum_history(self, direction):
617
"""Return (revno, revision_id) for history of branch.
618
619
direction
620
'forward' is from earliest to latest
621
'reverse' is from latest to earliest
622
"""
623
rh = self.revision_history()
624
if direction == 'forward':
625
i = 1
626
for rid in rh:
627
yield i, rid
628
i += 1
629
elif direction == 'reverse':
630
i = len(rh)
631
while i > 0:
632
yield i, rh[i-1]
633
i -= 1
634
else:
635
raise ValueError('invalid history direction', direction)
636
751
637
752
638
def revno(self):
753
639
"""Return current revision number for this branch.
768
654
return None
769
655
770
656
771
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
657
def missing_revisions(self, other):
772
658
"""
773
659
If self and other have not diverged, return a list of the revisions
774
660
present in other, but missing from self.
803
689
if common_index >= 0 and \
804
690
self_history[common_index] != other_history[common_index]:
805
691
raise DivergedBranches(self, other)
806
807
if stop_revision is None:
808
stop_revision = other_len
809
elif stop_revision > other_len:
810
raise NoSuchRevision(self, stop_revision)
811
812
return other_history[self_len:stop_revision]
813
814
815
def update_revisions(self, other, stop_revision=None):
816
"""Pull in all new revisions from other branch.
817
692
if self_len < other_len:
693
return other_history[self_len:]
694
return []
695
696
697
def update_revisions(self, other):
698
"""If self and other have not diverged, ensure self has all the
699
revisions in other
700
818
701
>>> from bzrlib.commit import commit
819
702
>>> bzrlib.trace.silent = True
820
703
>>> br1 = ScratchBranch(files=['foo', 'bar'])
829
712
>>> br2.revision_history()
830
713
[u'REVISION-ID-1']
831
714
>>> br2.update_revisions(br1)
715
Added 0 texts.
716
Added 0 inventories.
832
717
Added 0 revisions.
833
718
>>> br1.text_store.total_size() == br2.text_store.total_size()
834
719
True
835
720
"""
836
from bzrlib.fetch import greedy_fetch
837
pb = ProgressBar()
838
pb.update('comparing histories')
839
revision_ids = self.missing_revisions(other, stop_revision)
840
if len(revision_ids) > 0:
841
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
842
else:
843
count = 0
844
self.append_revision(*revision_ids)
845
print "Added %d revisions." % count
846
847
def install_revisions(self, other, revision_ids, pb=None):
848
if pb is None:
849
pb = ProgressBar()
850
if hasattr(other.revision_store, "prefetch"):
851
other.revision_store.prefetch(revision_ids)
852
if hasattr(other.inventory_store, "prefetch"):
853
inventory_ids = [other.get_revision(r).inventory_id
854
for r in revision_ids]
855
other.inventory_store.prefetch(inventory_ids)
856
857
revisions = []
858
needed_texts = set()
859
i = 0
860
failures = set()
861
for i, rev_id in enumerate(revision_ids):
862
pb.update('fetching revision', i+1, len(revision_ids))
863
try:
864
rev = other.get_revision(rev_id)
865
except bzrlib.errors.NoSuchRevision:
866
failures.add(rev_id)
867
continue
868
revisions.append(rev)
721
revision_ids = self.missing_revisions(other)
722
revisions = [other.get_revision(f) for f in revision_ids]
723
needed_texts = sets.Set()
724
for rev in revisions:
869
725
inv = other.get_inventory(str(rev.inventory_id))
870
726
for key, entry in inv.iter_entries():
871
727
if entry.text_id is None:
872
728
continue
873
729
if entry.text_id not in self.text_store:
874
730
needed_texts.add(entry.text_id)
875
876
pb.clear()
877
878
count, cp_fail = self.text_store.copy_multi(other.text_store,
879
needed_texts)
731
count = self.text_store.copy_multi(other.text_store, needed_texts)
880
732
print "Added %d texts." % count
881
733
inventory_ids = [ f.inventory_id for f in revisions ]
882
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
883
inventory_ids)
734
count = self.inventory_store.copy_multi(other.inventory_store,
735
inventory_ids)
884
736
print "Added %d inventories." % count
885
737
revision_ids = [ f.revision_id for f in revisions]
886
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
887
revision_ids,
888
permit_failure=True)
889
assert len(cp_fail) == 0
890
return count, failures
891
738
count = self.revision_store.copy_multi(other.revision_store,
739
revision_ids)
740
for revision_id in revision_ids:
741
self.append_revision(revision_id)
742
print "Added %d revisions." % count
743
744
892
745
def commit(self, *args, **kw):
746
"""Deprecated"""
893
747
from bzrlib.commit import commit
894
748
commit(self, *args, **kw)
895
749
896
750
897
def lookup_revision(self, revision):
898
"""Return the revision identifier for a given revision information."""
899
revno, info = self.get_revision_info(revision)
900
return info
901
902
def get_revision_info(self, revision):
903
"""Return (revno, revision id) for revision identifier.
904
905
revision can be an integer, in which case it is assumed to be revno (though
906
this will translate negative values into positive ones)
907
revision can also be a string, in which case it is parsed for something like
908
'date:' or 'revid:' etc.
909
"""
910
if revision is None:
911
return 0, None
912
revno = None
913
try:# Convert to int if possible
914
revision = int(revision)
915
except ValueError:
916
pass
917
revs = self.revision_history()
918
if isinstance(revision, int):
919
if revision == 0:
920
return 0, None
921
# Mabye we should do this first, but we don't need it if revision == 0
922
if revision < 0:
923
revno = len(revs) + revision + 1
924
else:
925
revno = revision
926
elif isinstance(revision, basestring):
927
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
928
if revision.startswith(prefix):
929
revno = func(self, revs, revision)
930
break
931
else:
932
raise BzrError('No namespace registered for string: %r' % revision)
933
934
if revno is None or revno <= 0 or revno > len(revs):
935
raise BzrError("no such revision %s" % revision)
936
return revno, revs[revno-1]
937
938
def _namespace_revno(self, revs, revision):
939
"""Lookup a revision by revision number"""
940
assert revision.startswith('revno:')
941
try:
942
return int(revision[6:])
943
except ValueError:
944
return None
945
REVISION_NAMESPACES['revno:'] = _namespace_revno
946
947
def _namespace_revid(self, revs, revision):
948
assert revision.startswith('revid:')
949
try:
950
return revs.index(revision[6:]) + 1
951
except ValueError:
952
return None
953
REVISION_NAMESPACES['revid:'] = _namespace_revid
954
955
def _namespace_last(self, revs, revision):
956
assert revision.startswith('last:')
957
try:
958
offset = int(revision[5:])
959
except ValueError:
960
return None
961
else:
962
if offset <= 0:
963
raise BzrError('You must supply a positive value for --revision last:XXX')
964
return len(revs) - offset + 1
965
REVISION_NAMESPACES['last:'] = _namespace_last
966
967
def _namespace_tag(self, revs, revision):
968
assert revision.startswith('tag:')
969
raise BzrError('tag: namespace registered, but not implemented.')
970
REVISION_NAMESPACES['tag:'] = _namespace_tag
971
972
def _namespace_date(self, revs, revision):
973
assert revision.startswith('date:')
974
import datetime
975
# Spec for date revisions:
976
# date:value
977
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
978
# it can also start with a '+/-/='. '+' says match the first
979
# entry after the given date. '-' is match the first entry before the date
980
# '=' is match the first entry after, but still on the given date.
981
#
982
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
983
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
984
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
985
# May 13th, 2005 at 0:00
986
#
987
# So the proper way of saying 'give me all entries for today' is:
988
# -r {date:+today}:{date:-tomorrow}
989
# The default is '=' when not supplied
990
val = revision[5:]
991
match_style = '='
992
if val[:1] in ('+', '-', '='):
993
match_style = val[:1]
994
val = val[1:]
995
996
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
997
if val.lower() == 'yesterday':
998
dt = today - datetime.timedelta(days=1)
999
elif val.lower() == 'today':
1000
dt = today
1001
elif val.lower() == 'tomorrow':
1002
dt = today + datetime.timedelta(days=1)
1003
else:
1004
import re
1005
# This should be done outside the function to avoid recompiling it.
1006
_date_re = re.compile(
1007
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1008
r'(,|T)?\s*'
1009
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1010
)
1011
m = _date_re.match(val)
1012
if not m or (not m.group('date') and not m.group('time')):
1013
raise BzrError('Invalid revision date %r' % revision)
1014
1015
if m.group('date'):
1016
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1017
else:
1018
year, month, day = today.year, today.month, today.day
1019
if m.group('time'):
1020
hour = int(m.group('hour'))
1021
minute = int(m.group('minute'))
1022
if m.group('second'):
1023
second = int(m.group('second'))
1024
else:
1025
second = 0
1026
else:
1027
hour, minute, second = 0,0,0
1028
1029
dt = datetime.datetime(year=year, month=month, day=day,
1030
hour=hour, minute=minute, second=second)
1031
first = dt
1032
last = None
1033
reversed = False
1034
if match_style == '-':
1035
reversed = True
1036
elif match_style == '=':
1037
last = dt + datetime.timedelta(days=1)
1038
1039
if reversed:
1040
for i in range(len(revs)-1, -1, -1):
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
else:
1047
for i in range(len(revs)):
1048
r = self.get_revision(revs[i])
1049
# TODO: Handle timezone.
1050
dt = datetime.datetime.fromtimestamp(r.timestamp)
1051
if first <= dt and (last is None or dt <= last):
1052
return i+1
1053
REVISION_NAMESPACES['date:'] = _namespace_date
751
def lookup_revision(self, revno):
752
"""Return revision hash for revision number."""
753
if revno == 0:
754
return None
755
756
try:
757
# list is 0-based; revisions are 1-based
758
return self.revision_history()[revno-1]
759
except IndexError:
760
raise BzrError("no such revision %s" % revno)
761
1054
762
1055
763
def revision_tree(self, revision_id):
1056
764
"""Return Tree for a revision on this branch.
1200
908
self.unlock()
1201
909
1202
910
1203
def revert(self, filenames, old_tree=None, backups=True):
1204
"""Restore selected files to the versions from a previous tree.
1205
1206
backups
1207
If true (default) backups are made of files before
1208
they're renamed.
1209
"""
1210
from bzrlib.errors import NotVersionedError, BzrError
1211
from bzrlib.atomicfile import AtomicFile
1212
from bzrlib.osutils import backup_file
1213
1214
inv = self.read_working_inventory()
1215
if old_tree is None:
1216
old_tree = self.basis_tree()
1217
old_inv = old_tree.inventory
1218
1219
nids = []
1220
for fn in filenames:
1221
file_id = inv.path2id(fn)
1222
if not file_id:
1223
raise NotVersionedError("not a versioned file", fn)
1224
if not old_inv.has_id(file_id):
1225
raise BzrError("file not present in old tree", fn, file_id)
1226
nids.append((fn, file_id))
1227
1228
# TODO: Rename back if it was previously at a different location
1229
1230
# TODO: If given a directory, restore the entire contents from
1231
# the previous version.
1232
1233
# TODO: Make a backup to a temporary file.
1234
1235
# TODO: If the file previously didn't exist, delete it?
1236
for fn, file_id in nids:
1237
backup_file(fn)
1238
1239
f = AtomicFile(fn, 'wb')
1240
try:
1241
f.write(old_tree.get_file(file_id).read())
1242
f.commit()
1243
finally:
1244
f.close()
1245
1246
1247
def pending_merges(self):
1248
"""Return a list of pending merges.
1249
1250
These are revisions that have been merged into the working
1251
directory but not yet committed.
1252
"""
1253
cfn = self.controlfilename('pending-merges')
1254
if not os.path.exists(cfn):
1255
return []
1256
p = []
1257
for l in self.controlfile('pending-merges', 'r').readlines():
1258
p.append(l.rstrip('\n'))
1259
return p
1260
1261
1262
def add_pending_merge(self, revision_id):
1263
from bzrlib.revision import validate_revision_id
1264
1265
validate_revision_id(revision_id)
1266
1267
p = self.pending_merges()
1268
if revision_id in p:
1269
return
1270
p.append(revision_id)
1271
self.set_pending_merges(p)
1272
1273
1274
def set_pending_merges(self, rev_list):
1275
from bzrlib.atomicfile import AtomicFile
1276
self.lock_write()
1277
try:
1278
f = AtomicFile(self.controlfilename('pending-merges'))
1279
try:
1280
for l in rev_list:
1281
print >>f, l
1282
f.commit()
1283
finally:
1284
f.close()
1285
finally:
1286
self.unlock()
1287
1288
1289
911
1290
912
class ScratchBranch(Branch):
1291
913
"""Special test class: a branch that cleans up after itself.
1305
927
1306
928
If any files are listed, they are created in the working copy.
1307
929
"""
1308
from tempfile import mkdtemp
1309
930
init = False
1310
931
if base is None:
1311
base = mkdtemp()
932
base = tempfile.mkdtemp()
1312
933
init = True
1313
934
Branch.__init__(self, base, init=init)
1314
935
for d in dirs:
1327
948
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1328
949
True
1329
950
"""
1330
from shutil import copytree
1331
from tempfile import mkdtemp
1332
base = mkdtemp()
951
base = tempfile.mkdtemp()
1333
952
os.rmdir(base)
1334
copytree(self.base, base, symlinks=True)
953
shutil.copytree(self.base, base, symlinks=True)
1335
954
return ScratchBranch(base=base)
1336
955
1337
956
def __del__(self):
1339
958
1340
959
def destroy(self):
1341
960
"""Destroy the test branch, removing the scratch directory."""
1342
from shutil import rmtree
1343
961
try:
1344
962
if self.base:
1345
963
mutter("delete ScratchBranch %s" % self.base)
1346
rmtree(self.base)
964
shutil.rmtree(self.base)
1347
965
except OSError, e:
1348
966
# Work around for shutil.rmtree failing on Windows when
1349
967
# readonly files are encountered
1351
969
for root, dirs, files in os.walk(self.base, topdown=False):
1352
970
for name in files:
1353
971
os.chmod(os.path.join(root, name), 0700)
1354
rmtree(self.base)
972
shutil.rmtree(self.base)
1355
973
self.base = None
1356
974
1357
975
1382
1000
cope with just randomness because running uuidgen every time is
1383
1001
slow."""
1384
1002
import re
1385
from binascii import hexlify
1386
from time import time
1387
1003
1388
1004
# get last component
1389
1005
idx = name.rfind('/')
1401
1017
name = re.sub(r'[^\w.]', '', name)
1402
1018
1403
1019
s = hexlify(rand_bytes(8))
1404
return '-'.join((name, compact_date(time()), s))
1405
1406
1407
def gen_root_id():
1408
"""Return a new tree-root file id."""
1409
return gen_file_id('TREE_ROOT')
1410
1020
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1