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
20
from cStringIO import StringIO
23
from bzrlib.trace import mutter, note
24
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
26
sha_file, appendpath, file_kind
28
from bzrlib.errors import (BzrError, InvalidRevisionNumber, InvalidRevisionId,
30
from bzrlib.textui import show_status
31
from bzrlib.revision import Revision
32
from bzrlib.delta import compare_trees
33
from bzrlib.tree import EmptyTree, RevisionTree
34
from bzrlib.inventory import Inventory
35
from bzrlib.weavestore import WeaveStore
36
from bzrlib.store import ImmutableStore
41
INVENTORY_FILEID = '__inventory'
42
ANCESTRY_FILEID = '__ancestry'
45
BZR_BRANCH_FORMAT_4 = "Bazaar-NG branch, format 0.0.4\n"
46
BZR_BRANCH_FORMAT_5 = "Bazaar-NG branch, format 5\n"
47
## TODO: Maybe include checks for common corruption of newlines, etc?
50
# TODO: Some operations like log might retrieve the same revisions
51
# repeatedly to calculate deltas. We could perhaps have a weakref
52
# cache in memory to make this faster. In general anything can be
53
# cached in memory between lock and unlock operations.
55
# TODO: please move the revision-string syntax stuff out of the branch
56
# object; it's clutter
59
def find_branch(f, **args):
60
if f and (f.startswith('http://') or f.startswith('https://')):
62
return remotebranch.RemoteBranch(f, **args)
64
return Branch(f, **args)
67
def find_cached_branch(f, cache_root, **args):
68
from remotebranch import RemoteBranch
69
br = find_branch(f, **args)
70
def cacheify(br, store_name):
71
from meta_store import CachedStore
72
cache_path = os.path.join(cache_root, store_name)
74
new_store = CachedStore(getattr(br, store_name), cache_path)
75
setattr(br, store_name, new_store)
77
if isinstance(br, RemoteBranch):
78
cacheify(br, 'inventory_store')
79
cacheify(br, 'text_store')
80
cacheify(br, 'revision_store')
84
def _relpath(base, path):
85
"""Return path relative to base, or raise exception.
87
The path may be either an absolute path or a path relative to the
88
current working directory.
90
Lifted out of Branch.relpath for ease of testing.
92
os.path.commonprefix (python2.4) has a bad bug that it works just
93
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
94
avoids that problem."""
95
rp = os.path.abspath(path)
99
while len(head) >= len(base):
102
head, tail = os.path.split(head)
106
from errors import NotBranchError
107
raise NotBranchError("path %r is not within branch %r" % (rp, base))
109
return os.sep.join(s)
112
def find_branch_root(f=None):
113
"""Find the branch root enclosing f, or pwd.
115
f may be a filename or a URL.
117
It is not necessary that f exists.
119
Basically we keep looking up until we find the control directory or
120
run into the root. If there isn't one, raises NotBranchError.
124
elif hasattr(os.path, 'realpath'):
125
f = os.path.realpath(f)
127
f = os.path.abspath(f)
128
if not os.path.exists(f):
129
raise BzrError('%r does not exist' % f)
135
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
137
head, tail = os.path.split(f)
139
# reached the root, whatever that may be
140
raise bzrlib.errors.NotBranchError('%s is not in a branch' % orig_f)
145
# XXX: move into bzrlib.errors; subclass BzrError
146
class DivergedBranches(Exception):
147
def __init__(self, branch1, branch2):
148
self.branch1 = branch1
149
self.branch2 = branch2
150
Exception.__init__(self, "These branches have diverged.")
153
######################################################################
156
class Branch(object):
157
"""Branch holding a history of revisions.
160
Base directory of the branch.
166
If _lock_mode is true, a positive count of the number of times the
170
Lock object from bzrlib.lock.
176
_inventory_weave = None
178
# Map some sort of prefix into a namespace
179
# stuff like "revno:10", "revid:", etc.
180
# This should match a prefix with a function which accepts
181
REVISION_NAMESPACES = {}
183
def __init__(self, base, init=False, find_root=True):
184
"""Create new branch object at a particular location.
186
base -- Base directory for the branch.
188
init -- If True, create new control files in a previously
189
unversioned directory. If False, the branch must already
192
find_root -- If true and init is false, find the root of the
193
existing branch containing base.
195
In the test suite, creation of new trees is tested using the
196
`ScratchBranch` class.
199
self.base = os.path.realpath(base)
202
self.base = find_branch_root(base)
204
self.base = os.path.realpath(base)
205
if not isdir(self.controlfilename('.')):
206
from errors import NotBranchError
207
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
208
['use "bzr init" to initialize a new working tree',
209
'current bzr can only operate from top-of-tree'])
212
self.weave_store = WeaveStore(self.controlfilename('weaves'))
213
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
217
return '%s(%r)' % (self.__class__.__name__, self.base)
224
if self._lock_mode or self._lock:
225
from warnings import warn
226
warn("branch %r was not explicitly unlocked" % self)
230
def lock_write(self):
232
if self._lock_mode != 'w':
233
from errors import LockError
234
raise LockError("can't upgrade to a write lock from %r" %
236
self._lock_count += 1
238
from bzrlib.lock import WriteLock
240
self._lock = WriteLock(self.controlfilename('branch-lock'))
241
self._lock_mode = 'w'
247
assert self._lock_mode in ('r', 'w'), \
248
"invalid lock mode %r" % self._lock_mode
249
self._lock_count += 1
251
from bzrlib.lock import ReadLock
253
self._lock = ReadLock(self.controlfilename('branch-lock'))
254
self._lock_mode = 'r'
258
if not self._lock_mode:
259
from errors import LockError
260
raise LockError('branch %r is not locked' % (self))
262
if self._lock_count > 1:
263
self._lock_count -= 1
267
self._lock_mode = self._lock_count = None
269
def abspath(self, name):
270
"""Return absolute filename for something in the branch"""
271
return os.path.join(self.base, name)
273
def relpath(self, path):
274
"""Return path relative to this branch of something inside it.
276
Raises an error if path is not in this branch."""
277
return _relpath(self.base, path)
279
def controlfilename(self, file_or_path):
280
"""Return location relative to branch."""
281
if isinstance(file_or_path, basestring):
282
file_or_path = [file_or_path]
283
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
286
def controlfile(self, file_or_path, mode='r'):
287
"""Open a control file for this branch.
289
There are two classes of file in the control directory: text
290
and binary. binary files are untranslated byte streams. Text
291
control files are stored with Unix newlines and in UTF-8, even
292
if the platform or locale defaults are different.
294
Controlfiles should almost never be opened in write mode but
295
rather should be atomically copied and replaced using atomicfile.
298
fn = self.controlfilename(file_or_path)
300
if mode == 'rb' or mode == 'wb':
301
return file(fn, mode)
302
elif mode == 'r' or mode == 'w':
303
# open in binary mode anyhow so there's no newline translation;
304
# codecs uses line buffering by default; don't want that.
306
return codecs.open(fn, mode + 'b', 'utf-8',
309
raise BzrError("invalid controlfile mode %r" % mode)
311
def _make_control(self):
312
os.mkdir(self.controlfilename([]))
313
self.controlfile('README', 'w').write(
314
"This is a Bazaar-NG control directory.\n"
315
"Do not change any files in this directory.\n")
316
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT_5)
317
for d in ('text-store', 'revision-store',
319
os.mkdir(self.controlfilename(d))
320
for f in ('revision-history', 'merged-patches',
321
'pending-merged-patches', 'branch-name',
324
self.controlfile(f, 'w').write('')
325
mutter('created control directory in ' + self.base)
327
# if we want per-tree root ids then this is the place to set
328
# them; they're not needed for now and so ommitted for
330
f = self.controlfile('inventory','w')
331
bzrlib.xml5.serializer_v5.write_inventory(Inventory(), f)
335
def _check_format(self):
336
"""Check this branch format is supported.
338
The format level is stored, as an integer, in
339
self._branch_format for code that needs to check it later.
341
In the future, we might need different in-memory Branch
342
classes to support downlevel branches. But not yet.
344
fmt = self.controlfile('branch-format', 'r').read()
345
if fmt == BZR_BRANCH_FORMAT_5:
346
self._branch_format = 5
348
raise BzrError('sorry, branch format "%s" not supported; '
349
'use a different bzr version, '
350
'or run "bzr upgrade", '
351
'or remove the .bzr directory and "bzr init" again'
352
% fmt.rstrip('\n\r'))
354
def get_root_id(self):
355
"""Return the id of this branches root"""
356
inv = self.read_working_inventory()
357
return inv.root.file_id
359
def set_root_id(self, file_id):
360
inv = self.read_working_inventory()
361
orig_root_id = inv.root.file_id
362
del inv._byid[inv.root.file_id]
363
inv.root.file_id = file_id
364
inv._byid[inv.root.file_id] = inv.root
367
if entry.parent_id in (None, orig_root_id):
368
entry.parent_id = inv.root.file_id
369
self._write_inventory(inv)
371
def read_working_inventory(self):
372
"""Read the working inventory."""
375
# ElementTree does its own conversion from UTF-8, so open in
377
f = self.controlfile('inventory', 'rb')
378
return bzrlib.xml5.serializer_v5.read_inventory(f)
383
def _write_inventory(self, inv):
384
"""Update the working inventory.
386
That is to say, the inventory describing changes underway, that
387
will be committed to the next revision.
389
from bzrlib.atomicfile import AtomicFile
393
f = AtomicFile(self.controlfilename('inventory'), 'wb')
395
bzrlib.xml5.serializer_v5.write_inventory(inv, f)
402
mutter('wrote working inventory')
405
inventory = property(read_working_inventory, _write_inventory, None,
406
"""Inventory for the working copy.""")
409
def add(self, files, ids=None):
410
"""Make files versioned.
412
Note that the command line normally calls smart_add instead,
413
which can automatically recurse.
415
This puts the files in the Added state, so that they will be
416
recorded by the next commit.
419
List of paths to add, relative to the base of the tree.
422
If set, use these instead of automatically generated ids.
423
Must be the same length as the list of files, but may
424
contain None for ids that are to be autogenerated.
426
TODO: Perhaps have an option to add the ids even if the files do
429
TODO: Perhaps yield the ids and paths as they're added.
431
# TODO: Re-adding a file that is removed in the working copy
432
# should probably put it back with the previous ID.
433
if isinstance(files, basestring):
434
assert(ids is None or isinstance(ids, basestring))
440
ids = [None] * len(files)
442
assert(len(ids) == len(files))
446
inv = self.read_working_inventory()
447
for f,file_id in zip(files, ids):
448
if is_control_file(f):
449
raise BzrError("cannot add control file %s" % quotefn(f))
454
raise BzrError("cannot add top-level %r" % f)
456
fullpath = os.path.normpath(self.abspath(f))
459
kind = file_kind(fullpath)
461
# maybe something better?
462
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
464
if kind != 'file' and kind != 'directory':
465
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
468
file_id = gen_file_id(f)
469
inv.add_path(f, kind=kind, file_id=file_id)
471
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
473
self._write_inventory(inv)
478
def print_file(self, file, revno):
479
"""Print `file` to stdout."""
482
tree = self.revision_tree(self.lookup_revision(revno))
483
# use inventory as it was in that revision
484
file_id = tree.inventory.path2id(file)
486
raise BzrError("%r is not present in revision %s" % (file, revno))
487
tree.print_file(file_id)
492
def remove(self, files, verbose=False):
493
"""Mark nominated files for removal from the inventory.
495
This does not remove their text. This does not run on
497
TODO: Refuse to remove modified files unless --force is given?
499
TODO: Do something useful with directories.
501
TODO: Should this remove the text or not? Tough call; not
502
removing may be useful and the user can just use use rm, and
503
is the opposite of add. Removing it is consistent with most
504
other tools. Maybe an option.
506
## TODO: Normalize names
507
## TODO: Remove nested loops; better scalability
508
if isinstance(files, basestring):
514
tree = self.working_tree()
517
# do this before any modifications
521
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
522
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
524
# having remove it, it must be either ignored or unknown
525
if tree.is_ignored(f):
529
show_status(new_status, inv[fid].kind, quotefn(f))
532
self._write_inventory(inv)
537
# FIXME: this doesn't need to be a branch method
538
def set_inventory(self, new_inventory_list):
539
from bzrlib.inventory import Inventory, InventoryEntry
540
inv = Inventory(self.get_root_id())
541
for path, file_id, parent, kind in new_inventory_list:
542
name = os.path.basename(path)
545
inv.add(InventoryEntry(file_id, name, kind, parent))
546
self._write_inventory(inv)
550
"""Return all unknown files.
552
These are files in the working directory that are not versioned or
553
control files or ignored.
555
>>> b = ScratchBranch(files=['foo', 'foo~'])
556
>>> list(b.unknowns())
559
>>> list(b.unknowns())
562
>>> list(b.unknowns())
565
return self.working_tree().unknowns()
568
def append_revision(self, *revision_ids):
569
from bzrlib.atomicfile import AtomicFile
571
for revision_id in revision_ids:
572
mutter("add {%s} to revision-history" % revision_id)
574
rev_history = self.revision_history()
575
rev_history.extend(revision_ids)
577
f = AtomicFile(self.controlfilename('revision-history'))
579
for rev_id in rev_history:
586
def get_revision_xml_file(self, revision_id):
587
"""Return XML file object for revision object."""
588
if not revision_id or not isinstance(revision_id, basestring):
589
raise InvalidRevisionId(revision_id)
594
return self.revision_store[revision_id]
596
raise bzrlib.errors.NoSuchRevision(self, revision_id)
601
def get_revision_xml(self, revision_id):
602
return self.get_revision_xml_file(revision_id).read()
605
def get_revision(self, revision_id):
606
"""Return the Revision object for a named revision"""
607
xml_file = self.get_revision_xml_file(revision_id)
610
r = bzrlib.xml5.serializer_v5.read_revision(xml_file)
611
except SyntaxError, e:
612
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
616
assert r.revision_id == revision_id
620
def get_revision_delta(self, revno):
621
"""Return the delta for one revision.
623
The delta is relative to its mainline predecessor, or the
624
empty tree for revision 1.
626
assert isinstance(revno, int)
627
rh = self.revision_history()
628
if not (1 <= revno <= len(rh)):
629
raise InvalidRevisionNumber(revno)
631
# revno is 1-based; list is 0-based
633
new_tree = self.revision_tree(rh[revno-1])
635
old_tree = EmptyTree()
637
old_tree = self.revision_tree(rh[revno-2])
639
return compare_trees(old_tree, new_tree)
643
def get_revision_sha1(self, revision_id):
644
"""Hash the stored value of a revision, and return it."""
645
return bzrlib.osutils.sha_file(self.get_revision_xml_file(revision_id))
648
def get_ancestry(self, revision_id):
649
"""Return a list of revision-ids integrated by a revision.
651
w = self.weave_store.get_weave(ANCESTRY_FILEID)
653
return [l[:-1] for l in w.get_iter(w.lookup(revision_id))]
656
def get_inventory_weave(self):
657
return self.weave_store.get_weave(INVENTORY_FILEID)
660
def get_inventory(self, revision_id):
661
"""Get Inventory object by hash."""
662
# FIXME: The text gets passed around a lot coming from the weave.
663
f = StringIO(self.get_inventory_xml(revision_id))
664
return bzrlib.xml5.serializer_v5.read_inventory(f)
667
def get_inventory_xml(self, revision_id):
668
"""Get inventory XML as a file object."""
670
assert isinstance(revision_id, basestring), type(revision_id)
671
iw = self.get_inventory_weave()
672
return iw.get_text(iw.lookup(revision_id))
674
raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
677
def get_inventory_sha1(self, revision_id):
678
"""Return the sha1 hash of the inventory entry
680
return self.get_revision(revision_id).inventory_sha1
683
def get_revision_inventory(self, revision_id):
684
"""Return inventory of a past revision."""
685
# bzr 0.0.6 and later imposes the constraint that the inventory_id
686
# must be the same as its revision, so this is trivial.
687
if revision_id == None:
688
return Inventory(self.get_root_id())
690
return self.get_inventory(revision_id)
693
def revision_history(self):
694
"""Return sequence of revision hashes on to this branch.
696
>>> ScratchBranch().revision_history()
701
return [l.rstrip('\r\n') for l in
702
self.controlfile('revision-history', 'r').readlines()]
707
def common_ancestor(self, other, self_revno=None, other_revno=None):
710
>>> sb = ScratchBranch(files=['foo', 'foo~'])
711
>>> sb.common_ancestor(sb) == (None, None)
713
>>> commit.commit(sb, "Committing first revision")
714
>>> sb.common_ancestor(sb)[0]
716
>>> clone = sb.clone()
717
>>> commit.commit(sb, "Committing second revision")
718
>>> sb.common_ancestor(sb)[0]
720
>>> sb.common_ancestor(clone)[0]
722
>>> commit.commit(clone, "Committing divergent second revision")
723
>>> sb.common_ancestor(clone)[0]
725
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
727
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
729
>>> clone2 = sb.clone()
730
>>> sb.common_ancestor(clone2)[0]
732
>>> sb.common_ancestor(clone2, self_revno=1)[0]
734
>>> sb.common_ancestor(clone2, other_revno=1)[0]
737
my_history = self.revision_history()
738
other_history = other.revision_history()
739
if self_revno is None:
740
self_revno = len(my_history)
741
if other_revno is None:
742
other_revno = len(other_history)
743
indices = range(min((self_revno, other_revno)))
746
if my_history[r] == other_history[r]:
747
return r+1, my_history[r]
752
"""Return current revision number for this branch.
754
That is equivalent to the number of revisions committed to
757
return len(self.revision_history())
760
def last_revision(self):
761
"""Return last patch hash, or None if no history.
763
ph = self.revision_history()
770
def missing_revisions(self, other, stop_revision=None, diverged_ok=False):
771
"""Return a list of new revisions that would perfectly fit.
773
If self and other have not diverged, return a list of the revisions
774
present in other, but missing from self.
776
>>> from bzrlib.commit import commit
777
>>> bzrlib.trace.silent = True
778
>>> br1 = ScratchBranch()
779
>>> br2 = ScratchBranch()
780
>>> br1.missing_revisions(br2)
782
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
783
>>> br1.missing_revisions(br2)
785
>>> br2.missing_revisions(br1)
787
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
788
>>> br1.missing_revisions(br2)
790
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
791
>>> br1.missing_revisions(br2)
793
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
794
>>> br1.missing_revisions(br2)
795
Traceback (most recent call last):
796
DivergedBranches: These branches have diverged.
798
# FIXME: If the branches have diverged, but the latest
799
# revision in this branch is completely merged into the other,
800
# then we should still be able to pull.
801
self_history = self.revision_history()
802
self_len = len(self_history)
803
other_history = other.revision_history()
804
other_len = len(other_history)
805
common_index = min(self_len, other_len) -1
806
if common_index >= 0 and \
807
self_history[common_index] != other_history[common_index]:
808
raise DivergedBranches(self, other)
810
if stop_revision is None:
811
stop_revision = other_len
812
elif stop_revision > other_len:
813
raise bzrlib.errors.NoSuchRevision(self, stop_revision)
815
return other_history[self_len:stop_revision]
818
def update_revisions(self, other, stop_revision=None):
819
"""Pull in new perfect-fit revisions.
821
from bzrlib.fetch import greedy_fetch
823
greedy_fetch(to_branch=self, from_branch=other,
824
revision_limit=stop_revision)
826
revision_ids = self.missing_revisions(other, stop_revision)
828
if len(revision_ids) > 0:
829
count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
832
self.append_revision(*revision_ids)
835
def commit(self, *args, **kw):
836
from bzrlib.commit import Commit
837
Commit().commit(self, *args, **kw)
840
def lookup_revision(self, revision):
841
"""Return the revision identifier for a given revision information."""
842
revno, info = self._get_revision_info(revision)
846
def revision_id_to_revno(self, revision_id):
847
"""Given a revision id, return its revno"""
848
history = self.revision_history()
850
return history.index(revision_id) + 1
852
raise bzrlib.errors.NoSuchRevision(self, revision_id)
855
def get_revision_info(self, revision):
856
"""Return (revno, revision id) for revision identifier.
858
revision can be an integer, in which case it is assumed to be revno (though
859
this will translate negative values into positive ones)
860
revision can also be a string, in which case it is parsed for something like
861
'date:' or 'revid:' etc.
863
revno, rev_id = self._get_revision_info(revision)
865
raise bzrlib.errors.NoSuchRevision(self, revision)
868
def get_rev_id(self, revno, history=None):
869
"""Find the revision id of the specified revno."""
873
history = self.revision_history()
874
elif revno <= 0 or revno > len(history):
875
raise bzrlib.errors.NoSuchRevision(self, revno)
876
return history[revno - 1]
878
def _get_revision_info(self, revision):
879
"""Return (revno, revision id) for revision specifier.
881
revision can be an integer, in which case it is assumed to be revno
882
(though this will translate negative values into positive ones)
883
revision can also be a string, in which case it is parsed for something
884
like 'date:' or 'revid:' etc.
886
A revid is always returned. If it is None, the specifier referred to
887
the null revision. If the revid does not occur in the revision
888
history, revno will be None.
894
try:# Convert to int if possible
895
revision = int(revision)
898
revs = self.revision_history()
899
if isinstance(revision, int):
901
revno = len(revs) + revision + 1
904
rev_id = self.get_rev_id(revno, revs)
905
elif isinstance(revision, basestring):
906
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
907
if revision.startswith(prefix):
908
result = func(self, revs, revision)
910
revno, rev_id = result
913
rev_id = self.get_rev_id(revno, revs)
916
raise BzrError('No namespace registered for string: %r' %
919
raise TypeError('Unhandled revision type %s' % revision)
923
raise bzrlib.errors.NoSuchRevision(self, revision)
926
def _namespace_revno(self, revs, revision):
927
"""Lookup a revision by revision number"""
928
assert revision.startswith('revno:')
930
return (int(revision[6:]),)
933
REVISION_NAMESPACES['revno:'] = _namespace_revno
935
def _namespace_revid(self, revs, revision):
936
assert revision.startswith('revid:')
937
rev_id = revision[len('revid:'):]
939
return revs.index(rev_id) + 1, rev_id
942
REVISION_NAMESPACES['revid:'] = _namespace_revid
944
def _namespace_last(self, revs, revision):
945
assert revision.startswith('last:')
947
offset = int(revision[5:])
952
raise BzrError('You must supply a positive value for --revision last:XXX')
953
return (len(revs) - offset + 1,)
954
REVISION_NAMESPACES['last:'] = _namespace_last
956
def _namespace_tag(self, revs, revision):
957
assert revision.startswith('tag:')
958
raise BzrError('tag: namespace registered, but not implemented.')
959
REVISION_NAMESPACES['tag:'] = _namespace_tag
961
def _namespace_date(self, revs, revision):
962
assert revision.startswith('date:')
964
# Spec for date revisions:
966
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
967
# it can also start with a '+/-/='. '+' says match the first
968
# entry after the given date. '-' is match the first entry before the date
969
# '=' is match the first entry after, but still on the given date.
971
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
972
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
973
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
974
# May 13th, 2005 at 0:00
976
# So the proper way of saying 'give me all entries for today' is:
977
# -r {date:+today}:{date:-tomorrow}
978
# The default is '=' when not supplied
981
if val[:1] in ('+', '-', '='):
982
match_style = val[:1]
985
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
986
if val.lower() == 'yesterday':
987
dt = today - datetime.timedelta(days=1)
988
elif val.lower() == 'today':
990
elif val.lower() == 'tomorrow':
991
dt = today + datetime.timedelta(days=1)
994
# This should be done outside the function to avoid recompiling it.
995
_date_re = re.compile(
996
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
998
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
1000
m = _date_re.match(val)
1001
if not m or (not m.group('date') and not m.group('time')):
1002
raise BzrError('Invalid revision date %r' % revision)
1005
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1007
year, month, day = today.year, today.month, today.day
1009
hour = int(m.group('hour'))
1010
minute = int(m.group('minute'))
1011
if m.group('second'):
1012
second = int(m.group('second'))
1016
hour, minute, second = 0,0,0
1018
dt = datetime.datetime(year=year, month=month, day=day,
1019
hour=hour, minute=minute, second=second)
1023
if match_style == '-':
1025
elif match_style == '=':
1026
last = dt + datetime.timedelta(days=1)
1029
for i in range(len(revs)-1, -1, -1):
1030
r = self.get_revision(revs[i])
1031
# TODO: Handle timezone.
1032
dt = datetime.datetime.fromtimestamp(r.timestamp)
1033
if first >= dt and (last is None or dt >= last):
1036
for i in range(len(revs)):
1037
r = self.get_revision(revs[i])
1038
# TODO: Handle timezone.
1039
dt = datetime.datetime.fromtimestamp(r.timestamp)
1040
if first <= dt and (last is None or dt <= last):
1042
REVISION_NAMESPACES['date:'] = _namespace_date
1044
def revision_tree(self, revision_id):
1045
"""Return Tree for a revision on this branch.
1047
`revision_id` may be None for the null revision, in which case
1048
an `EmptyTree` is returned."""
1049
# TODO: refactor this to use an existing revision object
1050
# so we don't need to read it in twice.
1051
if revision_id == None:
1054
inv = self.get_revision_inventory(revision_id)
1055
return RevisionTree(self.weave_store, inv, revision_id)
1058
def working_tree(self):
1059
"""Return a `Tree` for the working copy."""
1060
from workingtree import WorkingTree
1061
return WorkingTree(self.base, self.read_working_inventory())
1064
def basis_tree(self):
1065
"""Return `Tree` object for last revision.
1067
If there are no revisions yet, return an `EmptyTree`.
1069
return self.revision_tree(self.last_revision())
1072
def rename_one(self, from_rel, to_rel):
1075
This can change the directory or the filename or both.
1079
tree = self.working_tree()
1080
inv = tree.inventory
1081
if not tree.has_filename(from_rel):
1082
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1083
if tree.has_filename(to_rel):
1084
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1086
file_id = inv.path2id(from_rel)
1088
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1090
if inv.path2id(to_rel):
1091
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1093
to_dir, to_tail = os.path.split(to_rel)
1094
to_dir_id = inv.path2id(to_dir)
1095
if to_dir_id == None and to_dir != '':
1096
raise BzrError("can't determine destination directory id for %r" % to_dir)
1098
mutter("rename_one:")
1099
mutter(" file_id {%s}" % file_id)
1100
mutter(" from_rel %r" % from_rel)
1101
mutter(" to_rel %r" % to_rel)
1102
mutter(" to_dir %r" % to_dir)
1103
mutter(" to_dir_id {%s}" % to_dir_id)
1105
inv.rename(file_id, to_dir_id, to_tail)
1107
from_abs = self.abspath(from_rel)
1108
to_abs = self.abspath(to_rel)
1110
os.rename(from_abs, to_abs)
1112
raise BzrError("failed to rename %r to %r: %s"
1113
% (from_abs, to_abs, e[1]),
1114
["rename rolled back"])
1116
self._write_inventory(inv)
1121
def move(self, from_paths, to_name):
1124
to_name must exist as a versioned directory.
1126
If to_name exists and is a directory, the files are moved into
1127
it, keeping their old names. If it is a directory,
1129
Note that to_name is only the last component of the new name;
1130
this doesn't change the directory.
1132
This returns a list of (from_path, to_path) pairs for each
1133
entry that is moved.
1138
## TODO: Option to move IDs only
1139
assert not isinstance(from_paths, basestring)
1140
tree = self.working_tree()
1141
inv = tree.inventory
1142
to_abs = self.abspath(to_name)
1143
if not isdir(to_abs):
1144
raise BzrError("destination %r is not a directory" % to_abs)
1145
if not tree.has_filename(to_name):
1146
raise BzrError("destination %r not in working directory" % to_abs)
1147
to_dir_id = inv.path2id(to_name)
1148
if to_dir_id == None and to_name != '':
1149
raise BzrError("destination %r is not a versioned directory" % to_name)
1150
to_dir_ie = inv[to_dir_id]
1151
if to_dir_ie.kind not in ('directory', 'root_directory'):
1152
raise BzrError("destination %r is not a directory" % to_abs)
1154
to_idpath = inv.get_idpath(to_dir_id)
1156
for f in from_paths:
1157
if not tree.has_filename(f):
1158
raise BzrError("%r does not exist in working tree" % f)
1159
f_id = inv.path2id(f)
1161
raise BzrError("%r is not versioned" % f)
1162
name_tail = splitpath(f)[-1]
1163
dest_path = appendpath(to_name, name_tail)
1164
if tree.has_filename(dest_path):
1165
raise BzrError("destination %r already exists" % dest_path)
1166
if f_id in to_idpath:
1167
raise BzrError("can't move %r to a subdirectory of itself" % f)
1169
# OK, so there's a race here, it's possible that someone will
1170
# create a file in this interval and then the rename might be
1171
# left half-done. But we should have caught most problems.
1173
for f in from_paths:
1174
name_tail = splitpath(f)[-1]
1175
dest_path = appendpath(to_name, name_tail)
1176
result.append((f, dest_path))
1177
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1179
os.rename(self.abspath(f), self.abspath(dest_path))
1181
raise BzrError("failed to rename %r to %r: %s" % (f, dest_path, e[1]),
1182
["rename rolled back"])
1184
self._write_inventory(inv)
1191
def revert(self, filenames, old_tree=None, backups=True):
1192
"""Restore selected files to the versions from a previous tree.
1195
If true (default) backups are made of files before
1198
from bzrlib.errors import NotVersionedError, BzrError
1199
from bzrlib.atomicfile import AtomicFile
1200
from bzrlib.osutils import backup_file
1202
inv = self.read_working_inventory()
1203
if old_tree is None:
1204
old_tree = self.basis_tree()
1205
old_inv = old_tree.inventory
1208
for fn in filenames:
1209
file_id = inv.path2id(fn)
1211
raise NotVersionedError("not a versioned file", fn)
1212
if not old_inv.has_id(file_id):
1213
raise BzrError("file not present in old tree", fn, file_id)
1214
nids.append((fn, file_id))
1216
# TODO: Rename back if it was previously at a different location
1218
# TODO: If given a directory, restore the entire contents from
1219
# the previous version.
1221
# TODO: Make a backup to a temporary file.
1223
# TODO: If the file previously didn't exist, delete it?
1224
for fn, file_id in nids:
1227
f = AtomicFile(fn, 'wb')
1229
f.write(old_tree.get_file(file_id).read())
1235
def pending_merges(self):
1236
"""Return a list of pending merges.
1238
These are revisions that have been merged into the working
1239
directory but not yet committed.
1241
cfn = self.controlfilename('pending-merges')
1242
if not os.path.exists(cfn):
1245
for l in self.controlfile('pending-merges', 'r').readlines():
1246
p.append(l.rstrip('\n'))
1250
def add_pending_merge(self, revision_id):
1251
from bzrlib.revision import validate_revision_id
1253
validate_revision_id(revision_id)
1255
p = self.pending_merges()
1256
if revision_id in p:
1258
p.append(revision_id)
1259
self.set_pending_merges(p)
1262
def set_pending_merges(self, rev_list):
1263
from bzrlib.atomicfile import AtomicFile
1266
f = AtomicFile(self.controlfilename('pending-merges'))
1277
def get_parent(self):
1278
"""Return the parent location of the branch.
1280
This is the default location for push/pull/missing. The usual
1281
pattern is that the user can override it by specifying a
1285
_locs = ['parent', 'pull', 'x-pull']
1288
return self.controlfile(l, 'r').read().strip('\n')
1290
if e.errno != errno.ENOENT:
1295
def set_parent(self, url):
1296
# TODO: Maybe delete old location files?
1297
from bzrlib.atomicfile import AtomicFile
1300
f = AtomicFile(self.controlfilename('parent'))
1309
def check_revno(self, revno):
1311
Check whether a revno corresponds to any revision.
1312
Zero (the NULL revision) is considered valid.
1315
self.check_real_revno(revno)
1317
def check_real_revno(self, revno):
1319
Check whether a revno corresponds to a real revision.
1320
Zero (the NULL revision) is considered invalid
1322
if revno < 1 or revno > self.revno():
1323
raise InvalidRevisionNumber(revno)
1328
class ScratchBranch(Branch):
1329
"""Special test class: a branch that cleans up after itself.
1331
>>> b = ScratchBranch()
1339
def __init__(self, files=[], dirs=[], base=None):
1340
"""Make a test branch.
1342
This creates a temporary directory and runs init-tree in it.
1344
If any files are listed, they are created in the working copy.
1346
from tempfile import mkdtemp
1351
Branch.__init__(self, base, init=init)
1353
os.mkdir(self.abspath(d))
1356
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1361
>>> orig = ScratchBranch(files=["file1", "file2"])
1362
>>> clone = orig.clone()
1363
>>> os.path.samefile(orig.base, clone.base)
1365
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1368
from shutil import copytree
1369
from tempfile import mkdtemp
1372
copytree(self.base, base, symlinks=True)
1373
return ScratchBranch(base=base)
1381
"""Destroy the test branch, removing the scratch directory."""
1382
from shutil import rmtree
1385
mutter("delete ScratchBranch %s" % self.base)
1388
# Work around for shutil.rmtree failing on Windows when
1389
# readonly files are encountered
1390
mutter("hit exception in destroying ScratchBranch: %s" % e)
1391
for root, dirs, files in os.walk(self.base, topdown=False):
1393
os.chmod(os.path.join(root, name), 0700)
1399
######################################################################
1403
def is_control_file(filename):
1404
## FIXME: better check
1405
filename = os.path.normpath(filename)
1406
while filename != '':
1407
head, tail = os.path.split(filename)
1408
## mutter('check %r for control file' % ((head, tail), ))
1409
if tail == bzrlib.BZRDIR:
1411
if filename == head:
1418
def gen_file_id(name):
1419
"""Return new file id.
1421
This should probably generate proper UUIDs, but for the moment we
1422
cope with just randomness because running uuidgen every time is
1425
from binascii import hexlify
1426
from time import time
1428
# get last component
1429
idx = name.rfind('/')
1431
name = name[idx+1 : ]
1432
idx = name.rfind('\\')
1434
name = name[idx+1 : ]
1436
# make it not a hidden file
1437
name = name.lstrip('.')
1439
# remove any wierd characters; we don't escape them but rather
1440
# just pull them out
1441
name = re.sub(r'[^\w.]', '', name)
1443
s = hexlify(rand_bytes(8))
1444
return '-'.join((name, compact_date(time()), s))
1448
"""Return a new tree-root file id."""
1449
return gen_file_id('TREE_ROOT')
1452
def pull_loc(branch):
1453
# TODO: Should perhaps just make attribute be 'base' in
1454
# RemoteBranch and Branch?
1455
if hasattr(branch, "baseurl"):
1456
return branch.baseurl
1461
def copy_branch(branch_from, to_location, revision=None):
1462
"""Copy branch_from into the existing directory to_location.
1465
If not None, only revisions up to this point will be copied.
1466
The head of the new branch will be that revision.
1469
The name of a local directory that exists but is empty.
1471
from bzrlib.merge import merge
1472
from bzrlib.branch import Branch
1474
assert isinstance(branch_from, Branch)
1475
assert isinstance(to_location, basestring)
1477
br_to = Branch(to_location, init=True)
1478
br_to.set_root_id(branch_from.get_root_id())
1479
if revision is None:
1480
revno = branch_from.revno()
1482
revno, rev_id = branch_from.get_revision_info(revision)
1483
br_to.update_revisions(branch_from, stop_revision=revno)
1484
merge((to_location, -1), (to_location, 0), this_dir=to_location,
1485
check_clean=False, ignore_zero=True)
1487
from_location = pull_loc(branch_from)
1488
br_to.set_parent(pull_loc(branch_from))
added
removed
bzrlib/branch.py
