1
# Copyright (C) 2005 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22
from bzrlib.trace import mutter, note
23
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
25
sha_file, appendpath, file_kind
27
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
29
from bzrlib.textui import show_status
30
from bzrlib.revision import Revision
31
from bzrlib.xml import unpack_xml
32
from bzrlib.delta import compare_trees
33
from bzrlib.tree import EmptyTree, RevisionTree
38
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
39
## TODO: Maybe include checks for common corruption of newlines, etc?
42
# TODO: Some operations like log might retrieve the same revisions
43
# repeatedly to calculate deltas. We could perhaps have a weakref
44
# cache in memory to make this faster.
46
# TODO: please move the revision-string syntax stuff out of the branch
47
# object; it's clutter
50
def find_branch(f, **args):
51
if f and (f.startswith('http://') or f.startswith('https://')):
53
return remotebranch.RemoteBranch(f, **args)
55
return Branch(f, **args)
58
def find_cached_branch(f, cache_root, **args):
59
from remotebranch import RemoteBranch
60
br = find_branch(f, **args)
61
def cacheify(br, store_name):
62
from store import CachedStore
63
cache_path = os.path.join(cache_root, store_name)
65
new_store = CachedStore(getattr(br, store_name), cache_path)
66
setattr(br, store_name, new_store)
68
if isinstance(br, RemoteBranch):
69
cacheify(br, 'inventory_store')
70
cacheify(br, 'text_store')
71
cacheify(br, 'revision_store')
75
def _relpath(base, path):
76
"""Return path relative to base, or raise exception.
78
The path may be either an absolute path or a path relative to the
79
current working directory.
81
Lifted out of Branch.relpath for ease of testing.
83
os.path.commonprefix (python2.4) has a bad bug that it works just
84
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
85
avoids that problem."""
86
rp = os.path.abspath(path)
90
while len(head) >= len(base):
93
head, tail = os.path.split(head)
97
from errors import NotBranchError
98
raise NotBranchError("path %r is not within branch %r" % (rp, base))
100
return os.sep.join(s)
103
def find_branch_root(f=None):
104
"""Find the branch root enclosing f, or pwd.
106
f may be a filename or a URL.
108
It is not necessary that f exists.
110
Basically we keep looking up until we find the control directory or
111
run into the root. If there isn't one, raises NotBranchError.
115
elif hasattr(os.path, 'realpath'):
116
f = os.path.realpath(f)
118
f = os.path.abspath(f)
119
if not os.path.exists(f):
120
raise BzrError('%r does not exist' % f)
126
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
128
head, tail = os.path.split(f)
130
# reached the root, whatever that may be
131
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
136
# XXX: move into bzrlib.errors; subclass BzrError
137
class DivergedBranches(Exception):
138
def __init__(self, branch1, branch2):
139
self.branch1 = branch1
140
self.branch2 = branch2
141
Exception.__init__(self, "These branches have diverged.")
144
######################################################################
147
class Branch(object):
148
"""Branch holding a history of revisions.
151
Base directory of the branch.
157
If _lock_mode is true, a positive count of the number of times the
161
Lock object from bzrlib.lock.
168
# Map some sort of prefix into a namespace
169
# stuff like "revno:10", "revid:", etc.
170
# This should match a prefix with a function which accepts
171
REVISION_NAMESPACES = {}
173
def __init__(self, base, init=False, find_root=True):
174
"""Create new branch object at a particular location.
176
base -- Base directory for the branch. May be a file:// url.
178
init -- If True, create new control files in a previously
179
unversioned directory. If False, the branch must already
182
find_root -- If true and init is false, find the root of the
183
existing branch containing base.
185
In the test suite, creation of new trees is tested using the
186
`ScratchBranch` class.
188
from bzrlib.store import ImmutableStore
190
self.base = os.path.realpath(base)
193
self.base = find_branch_root(base)
195
if base.startswith("file://"):
197
self.base = os.path.realpath(base)
198
if not isdir(self.controlfilename('.')):
199
from errors import NotBranchError
200
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
201
['use "bzr init" to initialize a new working tree',
202
'current bzr can only operate from top-of-tree'])
205
self.text_store = ImmutableStore(self.controlfilename('text-store'))
206
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
207
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
211
return '%s(%r)' % (self.__class__.__name__, self.base)
218
if self._lock_mode or self._lock:
219
from warnings import warn
220
warn("branch %r was not explicitly unlocked" % self)
223
def lock_write(self):
225
if self._lock_mode != 'w':
226
from errors import LockError
227
raise LockError("can't upgrade to a write lock from %r" %
229
self._lock_count += 1
231
from bzrlib.lock import WriteLock
233
self._lock = WriteLock(self.controlfilename('branch-lock'))
234
self._lock_mode = 'w'
240
assert self._lock_mode in ('r', 'w'), \
241
"invalid lock mode %r" % self._lock_mode
242
self._lock_count += 1
244
from bzrlib.lock import ReadLock
246
self._lock = ReadLock(self.controlfilename('branch-lock'))
247
self._lock_mode = 'r'
251
if not self._lock_mode:
252
from errors import LockError
253
raise LockError('branch %r is not locked' % (self))
255
if self._lock_count > 1:
256
self._lock_count -= 1
260
self._lock_mode = self._lock_count = None
262
def abspath(self, name):
263
"""Return absolute filename for something in the branch"""
264
return os.path.join(self.base, name)
266
def relpath(self, path):
267
"""Return path relative to this branch of something inside it.
269
Raises an error if path is not in this branch."""
270
return _relpath(self.base, path)
272
def controlfilename(self, file_or_path):
273
"""Return location relative to branch."""
274
if isinstance(file_or_path, basestring):
275
file_or_path = [file_or_path]
276
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
279
def controlfile(self, file_or_path, mode='r'):
280
"""Open a control file for this branch.
282
There are two classes of file in the control directory: text
283
and binary. binary files are untranslated byte streams. Text
284
control files are stored with Unix newlines and in UTF-8, even
285
if the platform or locale defaults are different.
287
Controlfiles should almost never be opened in write mode but
288
rather should be atomically copied and replaced using atomicfile.
291
fn = self.controlfilename(file_or_path)
293
if mode == 'rb' or mode == 'wb':
294
return file(fn, mode)
295
elif mode == 'r' or mode == 'w':
296
# open in binary mode anyhow so there's no newline translation;
297
# codecs uses line buffering by default; don't want that.
299
return codecs.open(fn, mode + 'b', 'utf-8',
302
raise BzrError("invalid controlfile mode %r" % mode)
304
def _make_control(self):
305
from bzrlib.inventory import Inventory
306
from bzrlib.xml import pack_xml
308
os.mkdir(self.controlfilename([]))
309
self.controlfile('README', 'w').write(
310
"This is a Bazaar-NG control directory.\n"
311
"Do not change any files in this directory.\n")
312
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
313
for d in ('text-store', 'inventory-store', 'revision-store'):
314
os.mkdir(self.controlfilename(d))
315
for f in ('revision-history', 'merged-patches',
316
'pending-merged-patches', 'branch-name',
319
self.controlfile(f, 'w').write('')
320
mutter('created control directory in ' + self.base)
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
325
pack_xml(Inventory(), self.controlfile('inventory','w'))
327
def _check_format(self):
328
"""Check this branch format is supported.
330
The current tool only supports the current unstable format.
332
In the future, we might need different in-memory Branch
333
classes to support downlevel branches. But not yet.
335
# This ignores newlines so that we can open branches created
336
# on Windows from Linux and so on. I think it might be better
337
# to always make all internal files in unix format.
338
fmt = self.controlfile('branch-format', 'r').read()
339
fmt.replace('\r\n', '')
340
if fmt != BZR_BRANCH_FORMAT:
341
raise BzrError('sorry, branch format %r not supported' % fmt,
342
['use a different bzr version',
343
'or remove the .bzr directory and "bzr init" again'])
345
def get_root_id(self):
346
"""Return the id of this branches root"""
347
inv = self.read_working_inventory()
348
return inv.root.file_id
350
def set_root_id(self, file_id):
351
inv = self.read_working_inventory()
352
orig_root_id = inv.root.file_id
353
del inv._byid[inv.root.file_id]
354
inv.root.file_id = file_id
355
inv._byid[inv.root.file_id] = inv.root
358
if entry.parent_id in (None, orig_root_id):
359
entry.parent_id = inv.root.file_id
360
self._write_inventory(inv)
362
def read_working_inventory(self):
363
"""Read the working inventory."""
364
from bzrlib.inventory import Inventory
365
from bzrlib.xml import unpack_xml
366
from time import time
370
# ElementTree does its own conversion from UTF-8, so open in
372
inv = unpack_xml(Inventory,
373
self.controlfile('inventory', 'rb'))
374
mutter("loaded inventory of %d items in %f"
375
% (len(inv), time() - before))
381
def _write_inventory(self, inv):
382
"""Update the working inventory.
384
That is to say, the inventory describing changes underway, that
385
will be committed to the next revision.
387
from bzrlib.atomicfile import AtomicFile
388
from bzrlib.xml import pack_xml
392
f = AtomicFile(self.controlfilename('inventory'), 'wb')
401
mutter('wrote working inventory')
404
inventory = property(read_working_inventory, _write_inventory, None,
405
"""Inventory for the working copy.""")
408
def add(self, files, ids=None):
409
"""Make files versioned.
411
Note that the command line normally calls smart_add instead,
412
which can automatically recurse.
414
This puts the files in the Added state, so that they will be
415
recorded by the next commit.
418
List of paths to add, relative to the base of the tree.
421
If set, use these instead of automatically generated ids.
422
Must be the same length as the list of files, but may
423
contain None for ids that are to be autogenerated.
425
TODO: Perhaps have an option to add the ids even if the files do
428
TODO: Perhaps yield the ids and paths as they're added.
430
# TODO: Re-adding a file that is removed in the working copy
431
# should probably put it back with the previous ID.
432
if isinstance(files, basestring):
433
assert(ids is None or isinstance(ids, basestring))
439
ids = [None] * len(files)
441
assert(len(ids) == len(files))
445
inv = self.read_working_inventory()
446
for f,file_id in zip(files, ids):
447
if is_control_file(f):
448
raise BzrError("cannot add control file %s" % quotefn(f))
453
raise BzrError("cannot add top-level %r" % f)
455
fullpath = os.path.normpath(self.abspath(f))
458
kind = file_kind(fullpath)
460
# maybe something better?
461
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
463
if kind != 'file' and kind != 'directory':
464
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
467
file_id = gen_file_id(f)
468
inv.add_path(f, kind=kind, file_id=file_id)
470
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
472
self._write_inventory(inv)
477
def print_file(self, file, revno):
478
"""Print `file` to stdout."""
481
tree = self.revision_tree(self.lookup_revision(revno))
482
# use inventory as it was in that revision
483
file_id = tree.inventory.path2id(file)
485
raise BzrError("%r is not present in revision %s" % (file, revno))
486
tree.print_file(file_id)
491
def remove(self, files, verbose=False):
492
"""Mark nominated files for removal from the inventory.
494
This does not remove their text. This does not run on
496
TODO: Refuse to remove modified files unless --force is given?
498
TODO: Do something useful with directories.
500
TODO: Should this remove the text or not? Tough call; not
501
removing may be useful and the user can just use use rm, and
502
is the opposite of add. Removing it is consistent with most
503
other tools. Maybe an option.
505
## TODO: Normalize names
506
## TODO: Remove nested loops; better scalability
507
if isinstance(files, basestring):
513
tree = self.working_tree()
516
# do this before any modifications
520
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
521
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
523
# having remove it, it must be either ignored or unknown
524
if tree.is_ignored(f):
528
show_status(new_status, inv[fid].kind, quotefn(f))
531
self._write_inventory(inv)
536
# FIXME: this doesn't need to be a branch method
537
def set_inventory(self, new_inventory_list):
538
from bzrlib.inventory import Inventory, InventoryEntry
539
inv = Inventory(self.get_root_id())
540
for path, file_id, parent, kind in new_inventory_list:
541
name = os.path.basename(path)
544
inv.add(InventoryEntry(file_id, name, kind, parent))
545
self._write_inventory(inv)
549
"""Return all unknown files.
551
These are files in the working directory that are not versioned or
552
control files or ignored.
554
>>> b = ScratchBranch(files=['foo', 'foo~'])
555
>>> list(b.unknowns())
558
>>> list(b.unknowns())
561
>>> list(b.unknowns())
564
return self.working_tree().unknowns()
567
def append_revision(self, *revision_ids):
568
from bzrlib.atomicfile import AtomicFile
570
for revision_id in revision_ids:
571
mutter("add {%s} to revision-history" % revision_id)
573
rev_history = self.revision_history()
574
rev_history.extend(revision_ids)
576
f = AtomicFile(self.controlfilename('revision-history'))
578
for rev_id in rev_history:
584
def get_revision_xml(self, revision_id):
585
"""Return XML file object for revision object."""
586
if not revision_id or not isinstance(revision_id, basestring):
587
raise InvalidRevisionId(revision_id)
592
return self.revision_store[revision_id]
594
raise bzrlib.errors.NoSuchRevision(self, revision_id)
598
def get_revision(self, revision_id):
599
"""Return the Revision object for a named revision.
601
This operates on the storage level - it is agnostic as to
602
logical presence or absence from the branch.
604
xml_file = self.get_revision_xml(revision_id)
607
r = unpack_xml(Revision, xml_file)
608
except SyntaxError, e:
609
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
613
assert r.revision_id == revision_id
616
def get_revision_delta(self, revno):
617
"""Return the delta for one revision.
619
The delta is relative to its mainline predecessor, or the
620
empty tree for revision 1.
622
assert isinstance(revno, int)
623
rh = self.revision_history()
624
if not (1 <= revno <= len(rh)):
625
raise InvalidRevisionNumber(revno)
627
# revno is 1-based; list is 0-based
629
new_tree = self.revision_tree(rh[revno-1])
631
old_tree = EmptyTree()
633
old_tree = self.revision_tree(rh[revno-2])
635
return compare_trees(old_tree, new_tree)
637
def get_revision_sha1(self, revision_id):
638
"""Hash the stored value of a revision, and return it."""
639
# In the future, revision entries will be signed. At that
640
# point, it is probably best *not* to include the signature
641
# in the revision hash. Because that lets you re-sign
642
# the revision, (add signatures/remove signatures) and still
643
# have all hash pointers stay consistent.
644
# But for now, just hash the contents.
645
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
647
def get_inventory(self, inventory_id):
648
"""Get Inventory object by hash.
650
TODO: Perhaps for this and similar methods, take a revision
651
parameter which can be either an integer revno or a
653
from bzrlib.inventory import Inventory
654
from bzrlib.xml import unpack_xml
656
return unpack_xml(Inventory, self.get_inventory_xml(inventory_id))
658
def get_inventory_xml(self, inventory_id):
659
"""Get inventory XML as a file object."""
660
return self.inventory_store[inventory_id]
662
def get_inventory_sha1(self, inventory_id):
663
"""Return the sha1 hash of the inventory entry
665
return sha_file(self.get_inventory_xml(inventory_id))
667
def get_revision_inventory(self, revision_id):
668
"""Return inventory of a past revision."""
669
# bzr 0.0.6 imposes the constraint that the inventory_id
670
# must be the same as its revision, so this is trivial.
671
if revision_id == None:
672
from bzrlib.inventory import Inventory
673
return Inventory(self.get_root_id())
675
return self.get_inventory(revision_id)
677
def revision_history(self):
678
"""Return sequence of revision hashes on to this branch.
680
>>> ScratchBranch().revision_history()
685
return [l.rstrip('\r\n') for l in
686
self.controlfile('revision-history', 'r').readlines()]
690
def common_ancestor(self, other, self_revno=None, other_revno=None):
693
>>> sb = ScratchBranch(files=['foo', 'foo~'])
694
>>> sb.common_ancestor(sb) == (None, None)
696
>>> commit.commit(sb, "Committing first revision", verbose=False)
697
>>> sb.common_ancestor(sb)[0]
699
>>> clone = sb.clone()
700
>>> commit.commit(sb, "Committing second revision", verbose=False)
701
>>> sb.common_ancestor(sb)[0]
703
>>> sb.common_ancestor(clone)[0]
705
>>> commit.commit(clone, "Committing divergent second revision",
707
>>> sb.common_ancestor(clone)[0]
709
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
711
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
713
>>> clone2 = sb.clone()
714
>>> sb.common_ancestor(clone2)[0]
716
>>> sb.common_ancestor(clone2, self_revno=1)[0]
718
>>> sb.common_ancestor(clone2, other_revno=1)[0]
721
my_history = self.revision_history()
722
other_history = other.revision_history()
723
if self_revno is None:
724
self_revno = len(my_history)
725
if other_revno is None:
726
other_revno = len(other_history)
727
indices = range(min((self_revno, other_revno)))
730
if my_history[r] == other_history[r]:
731
return r+1, my_history[r]
736
"""Return current revision number for this branch.
738
That is equivalent to the number of revisions committed to
741
return len(self.revision_history())
744
def last_patch(self):
745
"""Return last patch hash, or None if no history.
747
ph = self.revision_history()
754
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
756
If self and other have not diverged, return a list of the revisions
757
present in other, but missing from self.
759
>>> from bzrlib.commit import commit
760
>>> bzrlib.trace.silent = True
761
>>> br1 = ScratchBranch()
762
>>> br2 = ScratchBranch()
763
>>> br1.missing_revisions(br2)
765
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
766
>>> br1.missing_revisions(br2)
768
>>> br2.missing_revisions(br1)
770
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
771
>>> br1.missing_revisions(br2)
773
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
774
>>> br1.missing_revisions(br2)
776
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
777
>>> br1.missing_revisions(br2)
778
Traceback (most recent call last):
779
DivergedBranches: These branches have diverged.
781
self_history = self.revision_history()
782
self_len = len(self_history)
783
other_history = other.revision_history()
784
other_len = len(other_history)
785
common_index = min(self_len, other_len) -1
786
if common_index >= 0 and \
787
self_history[common_index] != other_history[common_index]:
788
raise DivergedBranches(self, other)
790
if stop_revision is None:
791
stop_revision = other_len
792
elif stop_revision > other_len:
793
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
795
return other_history[self_len:stop_revision]
798
def update_revisions(self, other, stop_revision=None):
799
"""Pull in all new revisions from other branch.
801
from bzrlib.fetch import greedy_fetch
803
pb = bzrlib.ui.ui_factory.progress_bar()
804
pb.update('comparing histories')
806
revision_ids = self.missing_revisions(other, stop_revision)
808
if len(revision_ids) > 0:
809
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
812
self.append_revision(*revision_ids)
813
## note("Added %d revisions." % count)
816
def install_revisions(self, other, revision_ids, pb):
817
if hasattr(other.revision_store, "prefetch"):
818
other.revision_store.prefetch(revision_ids)
819
if hasattr(other.inventory_store, "prefetch"):
820
inventory_ids = [other.get_revision(r).inventory_id
821
for r in revision_ids]
822
other.inventory_store.prefetch(inventory_ids)
825
pb = bzrlib.ui.ui_factory.progress_bar()
832
for i, rev_id in enumerate(revision_ids):
833
pb.update('fetching revision', i+1, len(revision_ids))
835
rev = other.get_revision(rev_id)
836
except bzrlib.errors.NoSuchRevision:
840
revisions.append(rev)
841
inv = other.get_inventory(str(rev.inventory_id))
842
for key, entry in inv.iter_entries():
843
if entry.text_id is None:
845
if entry.text_id not in self.text_store:
846
needed_texts.add(entry.text_id)
850
count, cp_fail = self.text_store.copy_multi(other.text_store,
852
#print "Added %d texts." % count
853
inventory_ids = [ f.inventory_id for f in revisions ]
854
count, cp_fail = self.inventory_store.copy_multi(other.inventory_store,
856
#print "Added %d inventories." % count
857
revision_ids = [ f.revision_id for f in revisions]
859
count, cp_fail = self.revision_store.copy_multi(other.revision_store,
862
assert len(cp_fail) == 0
863
return count, failures
866
def commit(self, *args, **kw):
867
from bzrlib.commit import commit
868
commit(self, *args, **kw)
871
def lookup_revision(self, revision):
872
"""Return the revision identifier for a given revision information."""
873
revno, info = self._get_revision_info(revision)
877
def revision_id_to_revno(self, revision_id):
878
"""Given a revision id, return its revno"""
879
history = self.revision_history()
881
return history.index(revision_id) + 1
883
raise bzrlib.errors.NoSuchRevision(self, revision_id)
886
def get_revision_info(self, revision):
887
"""Return (revno, revision id) for revision identifier.
889
revision can be an integer, in which case it is assumed to be revno (though
890
this will translate negative values into positive ones)
891
revision can also be a string, in which case it is parsed for something like
892
'date:' or 'revid:' etc.
894
revno, rev_id = self._get_revision_info(revision)
896
raise bzrlib.errors.NoSuchRevision(self, revision)
899
def get_rev_id(self, revno, history=None):
900
"""Find the revision id of the specified revno."""
904
history = self.revision_history()
905
elif revno <= 0 or revno > len(history):
906
raise bzrlib.errors.NoSuchRevision(self, revno)
907
return history[revno - 1]
909
def _get_revision_info(self, revision):
910
"""Return (revno, revision id) for revision specifier.
912
revision can be an integer, in which case it is assumed to be revno
913
(though this will translate negative values into positive ones)
914
revision can also be a string, in which case it is parsed for something
915
like 'date:' or 'revid:' etc.
917
A revid is always returned. If it is None, the specifier referred to
918
the null revision. If the revid does not occur in the revision
919
history, revno will be None.
925
try:# Convert to int if possible
926
revision = int(revision)
929
revs = self.revision_history()
930
if isinstance(revision, int):
932
revno = len(revs) + revision + 1
935
rev_id = self.get_rev_id(revno, revs)
936
elif isinstance(revision, basestring):
937
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
938
if revision.startswith(prefix):
939
result = func(self, revs, revision)
941
revno, rev_id = result
944
rev_id = self.get_rev_id(revno, revs)
947
raise BzrError('No namespace registered for string: %r' %
950
raise TypeError('Unhandled revision type %s' % revision)
954
raise bzrlib.errors.NoSuchRevision(self, revision)
957
def _namespace_revno(self, revs, revision):
958
"""Lookup a revision by revision number"""
959
assert revision.startswith('revno:')
961
return (int(revision[6:]),)
964
REVISION_NAMESPACES['revno:'] = _namespace_revno
966
def _namespace_revid(self, revs, revision):
967
assert revision.startswith('revid:')
968
rev_id = revision[len('revid:'):]
970
return revs.index(rev_id) + 1, rev_id
973
REVISION_NAMESPACES['revid:'] = _namespace_revid
975
def _namespace_last(self, revs, revision):
976
assert revision.startswith('last:')
978
offset = int(revision[5:])
983
raise BzrError('You must supply a positive value for --revision last:XXX')
984
return (len(revs) - offset + 1,)
985
REVISION_NAMESPACES['last:'] = _namespace_last
987
def _namespace_tag(self, revs, revision):
988
assert revision.startswith('tag:')
989
raise BzrError('tag: namespace registered, but not implemented.')
990
REVISION_NAMESPACES['tag:'] = _namespace_tag
992
def _namespace_date(self, revs, revision):
993
assert revision.startswith('date:')
995
# Spec for date revisions:
997
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
998
# it can also start with a '+/-/='. '+' says match the first
999
# entry after the given date. '-' is match the first entry before the date
1000
# '=' is match the first entry after, but still on the given date.
1002
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
1003
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
1004
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
1005
# May 13th, 2005 at 0:00
1007
# So the proper way of saying 'give me all entries for today' is:
1008
# -r {date:+today}:{date:-tomorrow}
1009
# The default is '=' when not supplied
1012
if val[:1] in ('+', '-', '='):
1013
match_style = val[:1]
1016
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
1017
if val.lower() == 'yesterday':
1018
dt = today - datetime.timedelta(days=1)
1019
elif val.lower() == 'today':
1021
elif val.lower() == 'tomorrow':
1022
dt = today + datetime.timedelta(days=1)
1025
# This should be done outside the function to avoid recompiling it.
1026
_date_re = re.compile(
1027
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
1029
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1031
m = _date_re.match(val)
1032
if not m or (not m.group('date') and not m.group('time')):
1033
raise BzrError('Invalid revision date %r' % revision)
1036
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1038
year, month, day = today.year, today.month, today.day
1040
hour = int(m.group('hour'))
1041
minute = int(m.group('minute'))
1042
if m.group('second'):
1043
second = int(m.group('second'))
1047
hour, minute, second = 0,0,0
1049
dt = datetime.datetime(year=year, month=month, day=day,
1050
hour=hour, minute=minute, second=second)
1054
if match_style == '-':
1056
elif match_style == '=':
1057
last = dt + datetime.timedelta(days=1)
1060
for i in range(len(revs)-1, -1, -1):
1061
r = self.get_revision(revs[i])
1062
# TODO: Handle timezone.
1063
dt = datetime.datetime.fromtimestamp(r.timestamp)
1064
if first >= dt and (last is None or dt >= last):
1067
for i in range(len(revs)):
1068
r = self.get_revision(revs[i])
1069
# TODO: Handle timezone.
1070
dt = datetime.datetime.fromtimestamp(r.timestamp)
1071
if first <= dt and (last is None or dt <= last):
1073
REVISION_NAMESPACES['date:'] = _namespace_date
1075
def revision_tree(self, revision_id):
1076
"""Return Tree for a revision on this branch.
1078
`revision_id` may be None for the null revision, in which case
1079
an `EmptyTree` is returned."""
1080
# TODO: refactor this to use an existing revision object
1081
# so we don't need to read it in twice.
1082
if revision_id == None:
1085
inv = self.get_revision_inventory(revision_id)
1086
return RevisionTree(self.text_store, inv)
1089
def working_tree(self):
1090
"""Return a `Tree` for the working copy."""
1091
from workingtree import WorkingTree
1092
return WorkingTree(self.base, self.read_working_inventory())
1095
def basis_tree(self):
1096
"""Return `Tree` object for last revision.
1098
If there are no revisions yet, return an `EmptyTree`.
1100
r = self.last_patch()
1104
return RevisionTree(self.text_store, self.get_revision_inventory(r))
1108
def rename_one(self, from_rel, to_rel):
1111
This can change the directory or the filename or both.
1115
tree = self.working_tree()
1116
inv = tree.inventory
1117
if not tree.has_filename(from_rel):
1118
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1119
if tree.has_filename(to_rel):
1120
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1122
file_id = inv.path2id(from_rel)
1124
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1126
if inv.path2id(to_rel):
1127
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1129
to_dir, to_tail = os.path.split(to_rel)
1130
to_dir_id = inv.path2id(to_dir)
1131
if to_dir_id == None and to_dir != '':
1132
raise BzrError("can't determine destination directory id for %r" % to_dir)
1134
mutter("rename_one:")
1135
mutter(" file_id {%s}" % file_id)
1136
mutter(" from_rel %r" % from_rel)
1137
mutter(" to_rel %r" % to_rel)
1138
mutter(" to_dir %r" % to_dir)
1139
mutter(" to_dir_id {%s}" % to_dir_id)
1141
inv.rename(file_id, to_dir_id, to_tail)
1143
from_abs = self.abspath(from_rel)
1144
to_abs = self.abspath(to_rel)
1146
os.rename(from_abs, to_abs)
1148
raise BzrError("failed to rename %r to %r: %s"
1149
% (from_abs, to_abs, e[1]),
1150
["rename rolled back"])
1152
self._write_inventory(inv)
1157
def move(self, from_paths, to_name):
1160
to_name must exist as a versioned directory.
1162
If to_name exists and is a directory, the files are moved into
1163
it, keeping their old names. If it is a directory,
1165
Note that to_name is only the last component of the new name;
1166
this doesn't change the directory.
1168
This returns a list of (from_path, to_path) pairs for each
1169
entry that is moved.
1174
## TODO: Option to move IDs only
1175
assert not isinstance(from_paths, basestring)
1176
tree = self.working_tree()
1177
inv = tree.inventory
1178
to_abs = self.abspath(to_name)
1179
if not isdir(to_abs):
1180
raise BzrError("destination %r is not a directory" % to_abs)
1181
if not tree.has_filename(to_name):
1182
raise BzrError("destination %r not in working directory" % to_abs)
1183
to_dir_id = inv.path2id(to_name)
1184
if to_dir_id == None and to_name != '':
1185
raise BzrError("destination %r is not a versioned directory" % to_name)
1186
to_dir_ie = inv[to_dir_id]
1187
if to_dir_ie.kind not in ('directory', 'root_directory'):
1188
raise BzrError("destination %r is not a directory" % to_abs)
1190
to_idpath = inv.get_idpath(to_dir_id)
1192
for f in from_paths:
1193
if not tree.has_filename(f):
1194
raise BzrError("%r does not exist in working tree" % f)
1195
f_id = inv.path2id(f)
1197
raise BzrError("%r is not versioned" % f)
1198
name_tail = splitpath(f)[-1]
1199
dest_path = appendpath(to_name, name_tail)
1200
if tree.has_filename(dest_path):
1201
raise BzrError("destination %r already exists" % dest_path)
1202
if f_id in to_idpath:
1203
raise BzrError("can't move %r to a subdirectory of itself" % f)
1205
# OK, so there's a race here, it's possible that someone will
1206
# create a file in this interval and then the rename might be
1207
# left half-done. But we should have caught most problems.
1209
for f in from_paths:
1210
name_tail = splitpath(f)[-1]
1211
dest_path = appendpath(to_name, name_tail)
1212
result.append((f, dest_path))
1213
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1215
os.rename(self.abspath(f), self.abspath(dest_path))
1217
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1218
["rename rolled back"])
1220
self._write_inventory(inv)
1227
def revert(self, filenames, old_tree=None, backups=True):
1228
"""Restore selected files to the versions from a previous tree.
1231
If true (default) backups are made of files before
1234
from bzrlib.errors import NotVersionedError, BzrError
1235
from bzrlib.atomicfile import AtomicFile
1236
from bzrlib.osutils import backup_file
1238
inv = self.read_working_inventory()
1239
if old_tree is None:
1240
old_tree = self.basis_tree()
1241
old_inv = old_tree.inventory
1244
for fn in filenames:
1245
file_id = inv.path2id(fn)
1247
raise NotVersionedError("not a versioned file", fn)
1248
if not old_inv.has_id(file_id):
1249
raise BzrError("file not present in old tree", fn, file_id)
1250
nids.append((fn, file_id))
1252
# TODO: Rename back if it was previously at a different location
1254
# TODO: If given a directory, restore the entire contents from
1255
# the previous version.
1257
# TODO: Make a backup to a temporary file.
1259
# TODO: If the file previously didn't exist, delete it?
1260
for fn, file_id in nids:
1263
f = AtomicFile(fn, 'wb')
1265
f.write(old_tree.get_file(file_id).read())
1271
def pending_merges(self):
1272
"""Return a list of pending merges.
1274
These are revisions that have been merged into the working
1275
directory but not yet committed.
1277
cfn = self.controlfilename('pending-merges')
1278
if not os.path.exists(cfn):
1281
for l in self.controlfile('pending-merges', 'r').readlines():
1282
p.append(l.rstrip('\n'))
1286
def add_pending_merge(self, revision_id):
1287
from bzrlib.revision import validate_revision_id
1289
validate_revision_id(revision_id)
1291
p = self.pending_merges()
1292
if revision_id in p:
1294
p.append(revision_id)
1295
self.set_pending_merges(p)
1298
def set_pending_merges(self, rev_list):
1299
from bzrlib.atomicfile import AtomicFile
1302
f = AtomicFile(self.controlfilename('pending-merges'))
1313
def get_parent(self):
1314
"""Return the parent location of the branch.
1316
This is the default location for push/pull/missing. The usual
1317
pattern is that the user can override it by specifying a
1321
_locs = ['parent', 'pull', 'x-pull']
1324
return self.controlfile(l, 'r').read().strip('\n')
1326
if e.errno != errno.ENOENT:
1331
def set_parent(self, url):
1332
# TODO: Maybe delete old location files?
1333
from bzrlib.atomicfile import AtomicFile
1336
f = AtomicFile(self.controlfilename('parent'))
1345
def check_revno(self, revno):
1347
Check whether a revno corresponds to any revision.
1348
Zero (the NULL revision) is considered valid.
1351
self.check_real_revno(revno)
1353
def check_real_revno(self, revno):
1355
Check whether a revno corresponds to a real revision.
1356
Zero (the NULL revision) is considered invalid
1358
if revno < 1 or revno > self.revno():
1359
raise InvalidRevisionNumber(revno)
1364
class ScratchBranch(Branch):
1365
"""Special test class: a branch that cleans up after itself.
1367
>>> b = ScratchBranch()
1375
def __init__(self, files=[], dirs=[], base=None):
1376
"""Make a test branch.
1378
This creates a temporary directory and runs init-tree in it.
1380
If any files are listed, they are created in the working copy.
1382
from tempfile import mkdtemp
1387
Branch.__init__(self, base, init=init)
1389
os.mkdir(self.abspath(d))
1392
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1397
>>> orig = ScratchBranch(files=["file1", "file2"])
1398
>>> clone = orig.clone()
1399
>>> os.path.samefile(orig.base, clone.base)
1401
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1404
from shutil import copytree
1405
from tempfile import mkdtemp
1408
copytree(self.base, base, symlinks=True)
1409
return ScratchBranch(base=base)
1417
"""Destroy the test branch, removing the scratch directory."""
1418
from shutil import rmtree
1421
mutter("delete ScratchBranch %s" % self.base)
1424
# Work around for shutil.rmtree failing on Windows when
1425
# readonly files are encountered
1426
mutter("hit exception in destroying ScratchBranch: %s" % e)
1427
for root, dirs, files in os.walk(self.base, topdown=False):
1429
os.chmod(os.path.join(root, name), 0700)
1435
######################################################################
1439
def is_control_file(filename):
1440
## FIXME: better check
1441
filename = os.path.normpath(filename)
1442
while filename != '':
1443
head, tail = os.path.split(filename)
1444
## mutter('check %r for control file' % ((head, tail), ))
1445
if tail == bzrlib.BZRDIR:
1447
if filename == head:
1454
def gen_file_id(name):
1455
"""Return new file id.
1457
This should probably generate proper UUIDs, but for the moment we
1458
cope with just randomness because running uuidgen every time is
1461
from binascii import hexlify
1462
from time import time
1464
# get last component
1465
idx = name.rfind('/')
1467
name = name[idx+1 : ]
1468
idx = name.rfind('\\')
1470
name = name[idx+1 : ]
1472
# make it not a hidden file
1473
name = name.lstrip('.')
1475
# remove any wierd characters; we don't escape them but rather
1476
# just pull them out
1477
name = re.sub(r'[^\w.]', '', name)
1479
s = hexlify(rand_bytes(8))
1480
return '-'.join((name, compact_date(time()), s))
1484
"""Return a new tree-root file id."""
1485
return gen_file_id('TREE_ROOT')
1488
def pull_loc(branch):
1489
# TODO: Should perhaps just make attribute be 'base' in
1490
# RemoteBranch and Branch?
1491
if hasattr(branch, "baseurl"):
1492
return branch.baseurl
1497
def copy_branch(branch_from, to_location, revision=None):
1498
"""Copy branch_from into the existing directory to_location.
1501
If not None, only revisions up to this point will be copied.
1502
The head of the new branch will be that revision.
1505
The name of a local directory that exists but is empty.
1507
from bzrlib.merge import merge
1508
from bzrlib.branch import Branch
1510
assert isinstance(branch_from, Branch)
1511
assert isinstance(to_location, basestring)
1513
br_to = Branch(to_location, init=True)
1514
br_to.set_root_id(branch_from.get_root_id())
1515
if revision is None:
1516
revno = branch_from.revno()
1518
revno, rev_id = branch_from.get_revision_info(revision)
1519
br_to.update_revisions(branch_from, stop_revision=revno)
1520
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1521
check_clean=False, ignore_zero=True)
1523
from_location = pull_loc(branch_from)
1524
br_to.set_parent(pull_loc(branch_from))