« back to all changes in this revision
Viewing changes to bzrlib/branch.py
- browse files at revision 736
- compare with another revision
- download diff
- download tarball
- view history from revision 736
- Committer: Martin Pool
- Date: 2005-06-22 06:37:43 UTC
- Revision ID: mbp@sourcefrog.net-20050622063743-e395f04c4db8977f
- move old blackbox code from testbzr into bzrlib.selftest.blackbox
- files added:
- bzrlib/statcache.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.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
27
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
28
NoSuchRevision)
29
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
31
from bzrlib.delta import compare_trees
32
from bzrlib.tree import EmptyTree, RevisionTree
33
from bzrlib.inventory import Inventory
34
from bzrlib.weavestore import WeaveStore
35
import bzrlib.xml5
36
import bzrlib.ui
37
38
39
40
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
41
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
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_file, 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
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
42
36
## TODO: Maybe include checks for common corruption of newlines, etc?
43
37
44
38
45
# TODO: Some operations like log might retrieve the same revisions
46
# repeatedly to calculate deltas. We could perhaps have a weakref
47
# cache in memory to make this faster.
48
49
# TODO: please move the revision-string syntax stuff out of the branch
50
# object; it's clutter
51
52
39
53
40
def find_branch(f, **args):
54
41
if f and (f.startswith('http://') or f.startswith('https://')):
58
45
return Branch(f, **args)
59
46
60
47
61
def find_cached_branch(f, cache_root, **args):
62
from remotebranch import RemoteBranch
63
br = find_branch(f, **args)
64
def cacheify(br, store_name):
65
from meta_store import CachedStore
66
cache_path = os.path.join(cache_root, store_name)
67
os.mkdir(cache_path)
68
new_store = CachedStore(getattr(br, store_name), cache_path)
69
setattr(br, store_name, new_store)
70
71
if isinstance(br, RemoteBranch):
72
cacheify(br, 'inventory_store')
73
cacheify(br, 'text_store')
74
cacheify(br, 'revision_store')
75
return br
76
77
48
78
49
def _relpath(base, path):
79
50
"""Return path relative to base, or raise exception.
111
82
It is not necessary that f exists.
112
83
113
84
Basically we keep looking up until we find the control directory or
114
run into the root. If there isn't one, raises NotBranchError.
115
"""
85
run into the root."""
116
86
if f == None:
117
87
f = os.getcwd()
118
88
elif hasattr(os.path, 'realpath'):
131
101
head, tail = os.path.split(f)
132
102
if head == f:
133
103
# reached the root, whatever that may be
134
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
104
raise BzrError('%r is not in a branch' % orig_f)
135
105
f = head
136
137
138
139
# XXX: move into bzrlib.errors; subclass BzrError
106
140
107
class DivergedBranches(Exception):
141
108
def __init__(self, branch1, branch2):
142
109
self.branch1 = branch1
144
111
Exception.__init__(self, "These branches have diverged.")
145
112
146
113
114
class NoSuchRevision(BzrError):
115
def __init__(self, branch, revision):
116
self.branch = branch
117
self.revision = revision
118
msg = "Branch %s has no revision %d" % (branch, revision)
119
BzrError.__init__(self, msg)
120
121
147
122
######################################################################
148
123
# branch objects
149
124
168
143
_lock_count = None
169
144
_lock = None
170
145
171
# Map some sort of prefix into a namespace
172
# stuff like "revno:10", "revid:", etc.
173
# This should match a prefix with a function which accepts
174
REVISION_NAMESPACES = {}
175
176
146
def __init__(self, base, init=False, find_root=True):
177
147
"""Create new branch object at a particular location.
178
148
188
158
In the test suite, creation of new trees is tested using the
189
159
`ScratchBranch` class.
190
160
"""
191
from bzrlib.store import ImmutableStore
192
161
if init:
193
162
self.base = os.path.realpath(base)
194
163
self._make_control()
203
172
'current bzr can only operate from top-of-tree'])
204
173
self._check_format()
205
174
206
self.weave_store = WeaveStore(self.controlfilename('weaves'))
175
self.text_store = ImmutableStore(self.controlfilename('text-store'))
207
176
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
208
177
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
209
178
222
191
self._lock.unlock()
223
192
224
193
194
225
195
def lock_write(self):
226
196
if self._lock_mode:
227
197
if self._lock_mode != 'w':
237
207
self._lock_count = 1
238
208
239
209
210
240
211
def lock_read(self):
241
212
if self._lock_mode:
242
213
assert self._lock_mode in ('r', 'w'), \
249
220
self._lock_mode = 'r'
250
221
self._lock_count = 1
251
222
223
224
252
225
def unlock(self):
253
226
if not self._lock_mode:
254
227
from errors import LockError
261
234
self._lock = None
262
235
self._lock_mode = self._lock_count = None
263
236
237
264
238
def abspath(self, name):
265
239
"""Return absolute filename for something in the branch"""
266
240
return os.path.join(self.base, name)
267
241
242
268
243
def relpath(self, path):
269
244
"""Return path relative to this branch of something inside it.
270
245
271
246
Raises an error if path is not in this branch."""
272
247
return _relpath(self.base, path)
273
248
249
274
250
def controlfilename(self, file_or_path):
275
251
"""Return location relative to branch."""
276
if isinstance(file_or_path, basestring):
252
if isinstance(file_or_path, types.StringTypes):
277
253
file_or_path = [file_or_path]
278
254
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
279
255
303
279
else:
304
280
raise BzrError("invalid controlfile mode %r" % mode)
305
281
282
283
306
284
def _make_control(self):
307
285
os.mkdir(self.controlfilename([]))
308
286
self.controlfile('README', 'w').write(
309
287
"This is a Bazaar-NG control directory.\n"
310
288
"Do not change any files in this directory.\n")
311
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT_5)
312
for d in ('text-store', 'inventory-store', 'revision-store',
313
'weaves'):
289
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
290
for d in ('text-store', 'inventory-store', 'revision-store'):
314
291
os.mkdir(self.controlfilename(d))
315
292
for f in ('revision-history', 'merged-patches',
316
293
'pending-merged-patches', 'branch-name',
317
'branch-lock',
318
'pending-merges'):
294
'branch-lock'):
319
295
self.controlfile(f, 'w').write('')
320
296
mutter('created control directory in ' + self.base)
321
322
# if we want per-tree root ids then this is the place to set
323
# them; they're not needed for now and so ommitted for
324
# simplicity.
325
f = self.controlfile('inventory','w')
326
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), f)
297
Inventory().write_xml(self.controlfile('inventory','w'))
327
298
328
299
329
300
def _check_format(self):
330
301
"""Check this branch format is supported.
331
302
332
The format level is stored, as an integer, in
333
self._branch_format for code that needs to check it later.
303
The current tool only supports the current unstable format.
334
304
335
305
In the future, we might need different in-memory Branch
336
306
classes to support downlevel branches. But not yet.
337
307
"""
308
# This ignores newlines so that we can open branches created
309
# on Windows from Linux and so on. I think it might be better
310
# to always make all internal files in unix format.
338
311
fmt = self.controlfile('branch-format', 'r').read()
339
if fmt == BZR_BRANCH_FORMAT_5:
340
self._branch_format = 5
341
else:
342
raise BzrError('sorry, branch format "%s" not supported; '
343
'use a different bzr version, '
344
'or run "bzr upgrade", '
345
'or remove the .bzr directory and "bzr init" again'
346
% fmt.rstrip('\n\r'))
347
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
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)
312
fmt.replace('\r\n', '')
313
if fmt != BZR_BRANCH_FORMAT:
314
raise BzrError('sorry, branch format %r not supported' % fmt,
315
['use a different bzr version',
316
'or remove the .bzr directory and "bzr init" again'])
317
318
364
319
365
320
def read_working_inventory(self):
366
321
"""Read the working inventory."""
322
before = time.time()
323
# ElementTree does its own conversion from UTF-8, so open in
324
# binary.
367
325
self.lock_read()
368
326
try:
369
# ElementTree does its own conversion from UTF-8, so open in
370
# binary.
371
f = self.controlfile('inventory', 'rb')
372
return bzrlib.xml5.serializer_v5.read_inventory(f)
327
inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
328
mutter("loaded inventory of %d items in %f"
329
% (len(inv), time.time() - before))
330
return inv
373
331
finally:
374
332
self.unlock()
375
333
380
338
That is to say, the inventory describing changes underway, that
381
339
will be committed to the next revision.
382
340
"""
383
from bzrlib.atomicfile import AtomicFile
384
385
self.lock_write()
386
try:
387
f = AtomicFile(self.controlfilename('inventory'), 'wb')
388
try:
389
bzrlib.xml5.serializer_v5.write_inventory(inv, f)
390
f.commit()
391
finally:
392
f.close()
393
finally:
394
self.unlock()
395
341
## TODO: factor out to atomicfile? is rename safe on windows?
342
## TODO: Maybe some kind of clean/dirty marker on inventory?
343
tmpfname = self.controlfilename('inventory.tmp')
344
tmpf = file(tmpfname, 'wb')
345
inv.write_xml(tmpf)
346
tmpf.close()
347
inv_fname = self.controlfilename('inventory')
348
if sys.platform == 'win32':
349
os.remove(inv_fname)
350
os.rename(tmpfname, inv_fname)
396
351
mutter('wrote working inventory')
397
352
398
353
400
355
"""Inventory for the working copy.""")
401
356
402
357
403
def add(self, files, ids=None):
358
def add(self, files, verbose=False, ids=None):
404
359
"""Make files versioned.
405
360
406
Note that the command line normally calls smart_add instead,
407
which can automatically recurse.
361
Note that the command line normally calls smart_add instead.
408
362
409
363
This puts the files in the Added state, so that they will be
410
364
recorded by the next commit.
420
374
TODO: Perhaps have an option to add the ids even if the files do
421
375
not (yet) exist.
422
376
423
TODO: Perhaps yield the ids and paths as they're added.
377
TODO: Perhaps return the ids of the files? But then again it
378
is easy to retrieve them if they're needed.
379
380
TODO: Adding a directory should optionally recurse down and
381
add all non-ignored children. Perhaps do that in a
382
higher-level method.
424
383
"""
425
384
# TODO: Re-adding a file that is removed in the working copy
426
385
# should probably put it back with the previous ID.
427
if isinstance(files, basestring):
428
assert(ids is None or isinstance(ids, basestring))
386
if isinstance(files, types.StringTypes):
387
assert(ids is None or isinstance(ids, types.StringTypes))
429
388
files = [files]
430
389
if ids is not None:
431
390
ids = [ids]
462
421
file_id = gen_file_id(f)
463
422
inv.add_path(f, kind=kind, file_id=file_id)
464
423
424
if verbose:
425
show_status('A', kind, quotefn(f))
426
465
427
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
466
428
467
429
self._write_inventory(inv)
477
439
# use inventory as it was in that revision
478
440
file_id = tree.inventory.path2id(file)
479
441
if not file_id:
480
raise BzrError("%r is not present in revision %s" % (file, revno))
442
raise BzrError("%r is not present in revision %d" % (file, revno))
481
443
tree.print_file(file_id)
482
444
finally:
483
445
self.unlock()
499
461
"""
500
462
## TODO: Normalize names
501
463
## TODO: Remove nested loops; better scalability
502
if isinstance(files, basestring):
464
if isinstance(files, types.StringTypes):
503
465
files = [files]
504
466
505
467
self.lock_write()
530
492
531
493
# FIXME: this doesn't need to be a branch method
532
494
def set_inventory(self, new_inventory_list):
533
from bzrlib.inventory import Inventory, InventoryEntry
534
inv = Inventory(self.get_root_id())
495
inv = Inventory()
535
496
for path, file_id, parent, kind in new_inventory_list:
536
497
name = os.path.basename(path)
537
498
if name == "":
559
520
return self.working_tree().unknowns()
560
521
561
522
562
def append_revision(self, *revision_ids):
563
from bzrlib.atomicfile import AtomicFile
564
565
for revision_id in revision_ids:
566
mutter("add {%s} to revision-history" % revision_id)
567
523
def append_revision(self, revision_id):
524
mutter("add {%s} to revision-history" % revision_id)
568
525
rev_history = self.revision_history()
569
rev_history.extend(revision_ids)
570
571
f = AtomicFile(self.controlfilename('revision-history'))
572
try:
573
for rev_id in rev_history:
574
print >>f, rev_id
575
f.commit()
576
finally:
577
f.close()
578
579
580
def get_revision_xml_file(self, revision_id):
581
"""Return XML file object for revision object."""
582
if not revision_id or not isinstance(revision_id, basestring):
583
raise InvalidRevisionId(revision_id)
584
585
self.lock_read()
586
try:
587
try:
588
return self.revision_store[revision_id]
589
except IndexError:
590
raise bzrlib.errors.NoSuchRevision(self, revision_id)
591
finally:
592
self.unlock()
593
594
595
#deprecated
596
get_revision_xml = get_revision_xml_file
526
527
tmprhname = self.controlfilename('revision-history.tmp')
528
rhname = self.controlfilename('revision-history')
529
530
f = file(tmprhname, 'wt')
531
rev_history.append(revision_id)
532
f.write('\n'.join(rev_history))
533
f.write('\n')
534
f.close()
535
536
if sys.platform == 'win32':
537
os.remove(rhname)
538
os.rename(tmprhname, rhname)
539
597
540
598
541
599
542
def get_revision(self, revision_id):
600
543
"""Return the Revision object for a named revision"""
601
xml_file = self.get_revision_xml_file(revision_id)
602
603
try:
604
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
605
except SyntaxError, e:
606
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
607
[revision_id,
608
str(e)])
609
544
if not revision_id or not isinstance(revision_id, basestring):
545
raise ValueError('invalid revision-id: %r' % revision_id)
546
r = Revision.read_xml(self.revision_store[revision_id])
610
547
assert r.revision_id == revision_id
611
548
return r
612
549
613
614
def get_revision_delta(self, revno):
615
"""Return the delta for one revision.
616
617
The delta is relative to its mainline predecessor, or the
618
empty tree for revision 1.
619
"""
620
assert isinstance(revno, int)
621
rh = self.revision_history()
622
if not (1 <= revno <= len(rh)):
623
raise InvalidRevisionNumber(revno)
624
625
# revno is 1-based; list is 0-based
626
627
new_tree = self.revision_tree(rh[revno-1])
628
if revno == 1:
629
old_tree = EmptyTree()
630
else:
631
old_tree = self.revision_tree(rh[revno-2])
632
633
return compare_trees(old_tree, new_tree)
634
635
636
637
550
def get_revision_sha1(self, revision_id):
638
551
"""Hash the stored value of a revision, and return it."""
639
552
# In the future, revision entries will be signed. At that
642
555
# the revision, (add signatures/remove signatures) and still
643
556
# have all hash pointers stay consistent.
644
557
# But for now, just hash the contents.
645
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
646
647
648
def get_inventory(self, revision_id):
558
return sha_file(self.revision_store[revision_id])
559
560
561
def get_inventory(self, inventory_id):
649
562
"""Get Inventory object by hash.
650
563
651
564
TODO: Perhaps for this and similar methods, take a revision
652
565
parameter which can be either an integer revno or a
653
566
string hash."""
654
f = self.get_inventory_xml_file(revision_id)
655
return bzrlib.xml5.serializer_v5.read_inventory(f)
656
657
658
def get_inventory_xml(self, revision_id):
659
"""Get inventory XML as a file object."""
660
try:
661
assert isinstance(revision_id, basestring), type(revision_id)
662
return self.inventory_store[revision_id]
663
except IndexError:
664
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
665
666
get_inventory_xml_file = get_inventory_xml
667
668
669
def get_inventory_sha1(self, revision_id):
567
i = Inventory.read_xml(self.inventory_store[inventory_id])
568
return i
569
570
def get_inventory_sha1(self, inventory_id):
670
571
"""Return the sha1 hash of the inventory entry
671
572
"""
672
return sha_file(self.get_inventory_xml_file(revision_id))
573
return sha_file(self.inventory_store[inventory_id])
673
574
674
575
675
576
def get_revision_inventory(self, revision_id):
676
577
"""Return inventory of a past revision."""
677
# bzr 0.0.6 imposes the constraint that the inventory_id
678
# must be the same as its revision, so this is trivial.
679
578
if revision_id == None:
680
return Inventory(self.get_root_id())
579
return Inventory()
681
580
else:
682
return self.get_inventory(revision_id)
581
return self.get_inventory(self.get_revision(revision_id).inventory_id)
683
582
684
583
685
584
def revision_history(self):
740
639
return r+1, my_history[r]
741
640
return None, None
742
641
642
def enum_history(self, direction):
643
"""Return (revno, revision_id) for history of branch.
644
645
direction
646
'forward' is from earliest to latest
647
'reverse' is from latest to earliest
648
"""
649
rh = self.revision_history()
650
if direction == 'forward':
651
i = 1
652
for rid in rh:
653
yield i, rid
654
i += 1
655
elif direction == 'reverse':
656
i = len(rh)
657
while i > 0:
658
yield i, rh[i-1]
659
i -= 1
660
else:
661
raise ValueError('invalid history direction', direction)
662
743
663
744
664
def revno(self):
745
665
"""Return current revision number for this branch.
760
680
return None
761
681
762
682
763
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
683
def missing_revisions(self, other, stop_revision=None):
764
684
"""
765
685
If self and other have not diverged, return a list of the revisions
766
686
present in other, but missing from self.
799
719
if stop_revision is None:
800
720
stop_revision = other_len
801
721
elif stop_revision > other_len:
802
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
722
raise NoSuchRevision(self, stop_revision)
803
723
804
724
return other_history[self_len:stop_revision]
805
725
806
726
807
727
def update_revisions(self, other, stop_revision=None):
808
728
"""Pull in all new revisions from other branch.
729
730
>>> from bzrlib.commit import commit
731
>>> bzrlib.trace.silent = True
732
>>> br1 = ScratchBranch(files=['foo', 'bar'])
733
>>> br1.add('foo')
734
>>> br1.add('bar')
735
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
736
>>> br2 = ScratchBranch()
737
>>> br2.update_revisions(br1)
738
Added 2 texts.
739
Added 1 inventories.
740
Added 1 revisions.
741
>>> br2.revision_history()
742
[u'REVISION-ID-1']
743
>>> br2.update_revisions(br1)
744
Added 0 texts.
745
Added 0 inventories.
746
Added 0 revisions.
747
>>> br1.text_store.total_size() == br2.text_store.total_size()
748
True
809
749
"""
810
from bzrlib.fetch import greedy_fetch
811
812
pb = bzrlib.ui.ui_factory.progress_bar()
750
from bzrlib.progress import ProgressBar
751
752
pb = ProgressBar()
753
813
754
pb.update('comparing histories')
814
815
755
revision_ids = self.missing_revisions(other, stop_revision)
816
817
if len(revision_ids) > 0:
818
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
819
else:
820
count = 0
821
self.append_revision(*revision_ids)
822
## note("Added %d revisions." % count)
823
pb.clear()
824
825
def install_revisions(self, other, revision_ids, pb):
826
if hasattr(other.revision_store, "prefetch"):
827
other.revision_store.prefetch(revision_ids)
828
if hasattr(other.inventory_store, "prefetch"):
829
inventory_ids = [other.get_revision(r).inventory_id
830
for r in revision_ids]
831
other.inventory_store.prefetch(inventory_ids)
832
833
if pb is None:
834
pb = bzrlib.ui.ui_factory.progress_bar()
835
836
756
revisions = []
837
needed_texts = set()
757
needed_texts = sets.Set()
838
758
i = 0
839
840
failures = set()
841
for i, rev_id in enumerate(revision_ids):
842
pb.update('fetching revision', i+1, len(revision_ids))
843
try:
844
rev = other.get_revision(rev_id)
845
except bzrlib.errors.NoSuchRevision:
846
failures.add(rev_id)
847
continue
848
759
for rev_id in revision_ids:
760
i += 1
761
pb.update('fetching revision', i, len(revision_ids))
762
rev = other.get_revision(rev_id)
849
763
revisions.append(rev)
850
764
inv = other.get_inventory(str(rev.inventory_id))
851
765
for key, entry in inv.iter_entries():
856
770
857
771
pb.clear()
858
772
859
count, cp_fail = self.text_store.copy_multi(other.text_store,
860
needed_texts)
861
#print "Added %d texts." % count
773
count = self.text_store.copy_multi(other.text_store, needed_texts)
774
print "Added %d texts." % count
862
775
inventory_ids = [ f.inventory_id for f in revisions ]
863
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
864
inventory_ids)
865
#print "Added %d inventories." % count
776
count = self.inventory_store.copy_multi(other.inventory_store,
777
inventory_ids)
778
print "Added %d inventories." % count
866
779
revision_ids = [ f.revision_id for f in revisions]
867
868
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
869
revision_ids,
870
permit_failure=True)
871
assert len(cp_fail) == 0
872
return count, failures
873
874
780
count = self.revision_store.copy_multi(other.revision_store,
781
revision_ids)
782
for revision_id in revision_ids:
783
self.append_revision(revision_id)
784
print "Added %d revisions." % count
785
786
875
787
def commit(self, *args, **kw):
876
from bzrlib.commit import Commit
877
Commit().commit(self, *args, **kw)
788
"""Deprecated"""
789
from bzrlib.commit import commit
790
commit(self, *args, **kw)
878
791
879
792
880
def lookup_revision(self, revision):
881
"""Return the revision identifier for a given revision information."""
882
revno, info = self._get_revision_info(revision)
883
return info
884
885
886
def revision_id_to_revno(self, revision_id):
887
"""Given a revision id, return its revno"""
888
history = self.revision_history()
889
try:
890
return history.index(revision_id) + 1
891
except ValueError:
892
raise bzrlib.errors.NoSuchRevision(self, revision_id)
893
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
revno, rev_id = self._get_revision_info(revision)
904
if revno is None:
905
raise bzrlib.errors.NoSuchRevision(self, revision)
906
return revno, rev_id
907
908
def get_rev_id(self, revno, history=None):
909
"""Find the revision id of the specified revno."""
793
def lookup_revision(self, revno):
794
"""Return revision hash for revision number."""
910
795
if revno == 0:
911
796
return None
912
if history is None:
913
history = self.revision_history()
914
elif revno <= 0 or revno > len(history):
915
raise bzrlib.errors.NoSuchRevision(self, revno)
916
return history[revno - 1]
917
918
def _get_revision_info(self, revision):
919
"""Return (revno, revision id) for revision specifier.
920
921
revision can be an integer, in which case it is assumed to be revno
922
(though this will translate negative values into positive ones)
923
revision can also be a string, in which case it is parsed for something
924
like 'date:' or 'revid:' etc.
925
926
A revid is always returned. If it is None, the specifier referred to
927
the null revision. If the revid does not occur in the revision
928
history, revno will be None.
929
"""
930
931
if revision is None:
932
return 0, None
933
revno = None
934
try:# Convert to int if possible
935
revision = int(revision)
936
except ValueError:
937
pass
938
revs = self.revision_history()
939
if isinstance(revision, int):
940
if revision < 0:
941
revno = len(revs) + revision + 1
942
else:
943
revno = revision
944
rev_id = self.get_rev_id(revno, revs)
945
elif isinstance(revision, basestring):
946
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
947
if revision.startswith(prefix):
948
result = func(self, revs, revision)
949
if len(result) > 1:
950
revno, rev_id = result
951
else:
952
revno = result[0]
953
rev_id = self.get_rev_id(revno, revs)
954
break
955
else:
956
raise BzrError('No namespace registered for string: %r' %
957
revision)
958
else:
959
raise TypeError('Unhandled revision type %s' % revision)
960
961
if revno is None:
962
if rev_id is None:
963
raise bzrlib.errors.NoSuchRevision(self, revision)
964
return revno, rev_id
965
966
def _namespace_revno(self, revs, revision):
967
"""Lookup a revision by revision number"""
968
assert revision.startswith('revno:')
969
try:
970
return (int(revision[6:]),)
971
except ValueError:
972
return None
973
REVISION_NAMESPACES['revno:'] = _namespace_revno
974
975
def _namespace_revid(self, revs, revision):
976
assert revision.startswith('revid:')
977
rev_id = revision[len('revid:'):]
978
try:
979
return revs.index(rev_id) + 1, rev_id
980
except ValueError:
981
return None, rev_id
982
REVISION_NAMESPACES['revid:'] = _namespace_revid
983
984
def _namespace_last(self, revs, revision):
985
assert revision.startswith('last:')
986
try:
987
offset = int(revision[5:])
988
except ValueError:
989
return (None,)
990
else:
991
if offset <= 0:
992
raise BzrError('You must supply a positive value for --revision last:XXX')
993
return (len(revs) - offset + 1,)
994
REVISION_NAMESPACES['last:'] = _namespace_last
995
996
def _namespace_tag(self, revs, revision):
997
assert revision.startswith('tag:')
998
raise BzrError('tag: namespace registered, but not implemented.')
999
REVISION_NAMESPACES['tag:'] = _namespace_tag
1000
1001
def _namespace_date(self, revs, revision):
1002
assert revision.startswith('date:')
1003
import datetime
1004
# Spec for date revisions:
1005
# date:value
1006
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
1007
# it can also start with a '+/-/='. '+' says match the first
1008
# entry after the given date. '-' is match the first entry before the date
1009
# '=' is match the first entry after, but still on the given date.
1010
#
1011
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
1012
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
1013
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
1014
# May 13th, 2005 at 0:00
1015
#
1016
# So the proper way of saying 'give me all entries for today' is:
1017
# -r {date:+today}:{date:-tomorrow}
1018
# The default is '=' when not supplied
1019
val = revision[5:]
1020
match_style = '='
1021
if val[:1] in ('+', '-', '='):
1022
match_style = val[:1]
1023
val = val[1:]
1024
1025
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1026
if val.lower() == 'yesterday':
1027
dt = today - datetime.timedelta(days=1)
1028
elif val.lower() == 'today':
1029
dt = today
1030
elif val.lower() == 'tomorrow':
1031
dt = today + datetime.timedelta(days=1)
1032
else:
1033
import re
1034
# This should be done outside the function to avoid recompiling it.
1035
_date_re = re.compile(
1036
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1037
r'(,|T)?\s*'
1038
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1039
)
1040
m = _date_re.match(val)
1041
if not m or (not m.group('date') and not m.group('time')):
1042
raise BzrError('Invalid revision date %r' % revision)
1043
1044
if m.group('date'):
1045
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1046
else:
1047
year, month, day = today.year, today.month, today.day
1048
if m.group('time'):
1049
hour = int(m.group('hour'))
1050
minute = int(m.group('minute'))
1051
if m.group('second'):
1052
second = int(m.group('second'))
1053
else:
1054
second = 0
1055
else:
1056
hour, minute, second = 0,0,0
1057
1058
dt = datetime.datetime(year=year, month=month, day=day,
1059
hour=hour, minute=minute, second=second)
1060
first = dt
1061
last = None
1062
reversed = False
1063
if match_style == '-':
1064
reversed = True
1065
elif match_style == '=':
1066
last = dt + datetime.timedelta(days=1)
1067
1068
if reversed:
1069
for i in range(len(revs)-1, -1, -1):
1070
r = self.get_revision(revs[i])
1071
# TODO: Handle timezone.
1072
dt = datetime.datetime.fromtimestamp(r.timestamp)
1073
if first >= dt and (last is None or dt >= last):
1074
return (i+1,)
1075
else:
1076
for i in range(len(revs)):
1077
r = self.get_revision(revs[i])
1078
# TODO: Handle timezone.
1079
dt = datetime.datetime.fromtimestamp(r.timestamp)
1080
if first <= dt and (last is None or dt <= last):
1081
return (i+1,)
1082
REVISION_NAMESPACES['date:'] = _namespace_date
797
798
try:
799
# list is 0-based; revisions are 1-based
800
return self.revision_history()[revno-1]
801
except IndexError:
802
raise BzrError("no such revision %s" % revno)
803
1083
804
1084
805
def revision_tree(self, revision_id):
1085
806
"""Return Tree for a revision on this branch.
1092
813
return EmptyTree()
1093
814
else:
1094
815
inv = self.get_revision_inventory(revision_id)
1095
return RevisionTree(self.weave_store, inv, revision_id)
816
return RevisionTree(self.text_store, inv)
1096
817
1097
818
1098
819
def working_tree(self):
1106
827
1107
828
If there are no revisions yet, return an `EmptyTree`.
1108
829
"""
1109
return self.revision_tree(self.last_patch())
830
r = self.last_patch()
831
if r == None:
832
return EmptyTree()
833
else:
834
return RevisionTree(self.text_store, self.get_revision_inventory(r))
835
1110
836
1111
837
1112
838
def rename_one(self, from_rel, to_rel):
1144
870
1145
871
inv.rename(file_id, to_dir_id, to_tail)
1146
872
873
print "%s => %s" % (from_rel, to_rel)
874
1147
875
from_abs = self.abspath(from_rel)
1148
876
to_abs = self.abspath(to_rel)
1149
877
try:
1168
896
1169
897
Note that to_name is only the last component of the new name;
1170
898
this doesn't change the directory.
1171
1172
This returns a list of (from_path, to_path) pairs for each
1173
entry that is moved.
1174
899
"""
1175
result = []
1176
900
self.lock_write()
1177
901
try:
1178
902
## TODO: Option to move IDs only
1213
937
for f in from_paths:
1214
938
name_tail = splitpath(f)[-1]
1215
939
dest_path = appendpath(to_name, name_tail)
1216
result.append((f, dest_path))
940
print "%s => %s" % (f, dest_path)
1217
941
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1218
942
try:
1219
943
os.rename(self.abspath(f), self.abspath(dest_path))
1225
949
finally:
1226
950
self.unlock()
1227
951
1228
return result
1229
1230
1231
def revert(self, filenames, old_tree=None, backups=True):
1232
"""Restore selected files to the versions from a previous tree.
1233
1234
backups
1235
If true (default) backups are made of files before
1236
they're renamed.
1237
"""
1238
from bzrlib.errors import NotVersionedError, BzrError
1239
from bzrlib.atomicfile import AtomicFile
1240
from bzrlib.osutils import backup_file
1241
1242
inv = self.read_working_inventory()
1243
if old_tree is None:
1244
old_tree = self.basis_tree()
1245
old_inv = old_tree.inventory
1246
1247
nids = []
1248
for fn in filenames:
1249
file_id = inv.path2id(fn)
1250
if not file_id:
1251
raise NotVersionedError("not a versioned file", fn)
1252
if not old_inv.has_id(file_id):
1253
raise BzrError("file not present in old tree", fn, file_id)
1254
nids.append((fn, file_id))
1255
1256
# TODO: Rename back if it was previously at a different location
1257
1258
# TODO: If given a directory, restore the entire contents from
1259
# the previous version.
1260
1261
# TODO: Make a backup to a temporary file.
1262
1263
# TODO: If the file previously didn't exist, delete it?
1264
for fn, file_id in nids:
1265
backup_file(fn)
1266
1267
f = AtomicFile(fn, 'wb')
1268
try:
1269
f.write(old_tree.get_file(file_id).read())
1270
f.commit()
1271
finally:
1272
f.close()
1273
1274
1275
def pending_merges(self):
1276
"""Return a list of pending merges.
1277
1278
These are revisions that have been merged into the working
1279
directory but not yet committed.
1280
"""
1281
cfn = self.controlfilename('pending-merges')
1282
if not os.path.exists(cfn):
1283
return []
1284
p = []
1285
for l in self.controlfile('pending-merges', 'r').readlines():
1286
p.append(l.rstrip('\n'))
1287
return p
1288
1289
1290
def add_pending_merge(self, revision_id):
1291
from bzrlib.revision import validate_revision_id
1292
1293
validate_revision_id(revision_id)
1294
1295
p = self.pending_merges()
1296
if revision_id in p:
1297
return
1298
p.append(revision_id)
1299
self.set_pending_merges(p)
1300
1301
1302
def set_pending_merges(self, rev_list):
1303
from bzrlib.atomicfile import AtomicFile
1304
self.lock_write()
1305
try:
1306
f = AtomicFile(self.controlfilename('pending-merges'))
1307
try:
1308
for l in rev_list:
1309
print >>f, l
1310
f.commit()
1311
finally:
1312
f.close()
1313
finally:
1314
self.unlock()
1315
1316
1317
def get_parent(self):
1318
"""Return the parent location of the branch.
1319
1320
This is the default location for push/pull/missing. The usual
1321
pattern is that the user can override it by specifying a
1322
location.
1323
"""
1324
import errno
1325
_locs = ['parent', 'pull', 'x-pull']
1326
for l in _locs:
1327
try:
1328
return self.controlfile(l, 'r').read().strip('\n')
1329
except IOError, e:
1330
if e.errno != errno.ENOENT:
1331
raise
1332
return None
1333
1334
1335
def set_parent(self, url):
1336
# TODO: Maybe delete old location files?
1337
from bzrlib.atomicfile import AtomicFile
1338
self.lock_write()
1339
try:
1340
f = AtomicFile(self.controlfilename('parent'))
1341
try:
1342
f.write(url + '\n')
1343
f.commit()
1344
finally:
1345
f.close()
1346
finally:
1347
self.unlock()
1348
1349
def check_revno(self, revno):
1350
"""\
1351
Check whether a revno corresponds to any revision.
1352
Zero (the NULL revision) is considered valid.
1353
"""
1354
if revno != 0:
1355
self.check_real_revno(revno)
1356
1357
def check_real_revno(self, revno):
1358
"""\
1359
Check whether a revno corresponds to a real revision.
1360
Zero (the NULL revision) is considered invalid
1361
"""
1362
if revno < 1 or revno > self.revno():
1363
raise InvalidRevisionNumber(revno)
1364
1365
1366
952
1367
953
1368
954
class ScratchBranch(Branch):
1383
969
1384
970
If any files are listed, they are created in the working copy.
1385
971
"""
1386
from tempfile import mkdtemp
1387
972
init = False
1388
973
if base is None:
1389
base = mkdtemp()
974
base = tempfile.mkdtemp()
1390
975
init = True
1391
976
Branch.__init__(self, base, init=init)
1392
977
for d in dirs:
1405
990
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1406
991
True
1407
992
"""
1408
from shutil import copytree
1409
from tempfile import mkdtemp
1410
base = mkdtemp()
993
base = tempfile.mkdtemp()
1411
994
os.rmdir(base)
1412
copytree(self.base, base, symlinks=True)
995
shutil.copytree(self.base, base, symlinks=True)
1413
996
return ScratchBranch(base=base)
1414
1415
1416
997
1417
998
def __del__(self):
1418
999
self.destroy()
1419
1000
1420
1001
def destroy(self):
1421
1002
"""Destroy the test branch, removing the scratch directory."""
1422
from shutil import rmtree
1423
1003
try:
1424
1004
if self.base:
1425
1005
mutter("delete ScratchBranch %s" % self.base)
1426
rmtree(self.base)
1006
shutil.rmtree(self.base)
1427
1007
except OSError, e:
1428
1008
# Work around for shutil.rmtree failing on Windows when
1429
1009
# readonly files are encountered
1431
1011
for root, dirs, files in os.walk(self.base, topdown=False):
1432
1012
for name in files:
1433
1013
os.chmod(os.path.join(root, name), 0700)
1434
rmtree(self.base)
1014
shutil.rmtree(self.base)
1435
1015
self.base = None
1436
1016
1437
1017
1462
1042
cope with just randomness because running uuidgen every time is
1463
1043
slow."""
1464
1044
import re
1465
from binascii import hexlify
1466
from time import time
1467
1045
1468
1046
# get last component
1469
1047
idx = name.rfind('/')
1481
1059
name = re.sub(r'[^\w.]', '', name)
1482
1060
1483
1061
s = hexlify(rand_bytes(8))
1484
return '-'.join((name, compact_date(time()), s))
1485
1486
1487
def gen_root_id():
1488
"""Return a new tree-root file id."""
1489
return gen_file_id('TREE_ROOT')
1490
1491
1492
def pull_loc(branch):
1493
# TODO: Should perhaps just make attribute be 'base' in
1494
# RemoteBranch and Branch?
1495
if hasattr(branch, "baseurl"):
1496
return branch.baseurl
1497
else:
1498
return branch.base
1499
1500
1501
def copy_branch(branch_from, to_location, revision=None):
1502
"""Copy branch_from into the existing directory to_location.
1503
1504
revision
1505
If not None, only revisions up to this point will be copied.
1506
The head of the new branch will be that revision.
1507
1508
to_location
1509
The name of a local directory that exists but is empty.
1510
"""
1511
from bzrlib.merge import merge
1512
from bzrlib.branch import Branch
1513
1514
assert isinstance(branch_from, Branch)
1515
assert isinstance(to_location, basestring)
1516
1517
br_to = Branch(to_location, init=True)
1518
br_to.set_root_id(branch_from.get_root_id())
1519
if revision is None:
1520
revno = branch_from.revno()
1521
else:
1522
revno, rev_id = branch_from.get_revision_info(revision)
1523
br_to.update_revisions(branch_from, stop_revision=revno)
1524
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1525
check_clean=False, ignore_zero=True)
1526
1527
from_location = pull_loc(branch_from)
1528
br_to.set_parent(pull_loc(branch_from))
1529
1062
return '-'.join((name, compact_date(time.time()), s))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1