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
26
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
28
from bzrlib.textui import show_status
29
from bzrlib.revision import Revision
30
from bzrlib.xml import unpack_xml
31
from bzrlib.delta import compare_trees
32
from bzrlib.tree import EmptyTree, RevisionTree
34
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
35
## TODO: Maybe include checks for common corruption of newlines, etc?
38
# TODO: Some operations like log might retrieve the same revisions
39
# repeatedly to calculate deltas. We could perhaps have a weakref
40
# cache in memory to make this faster.
43
def find_branch(f, **args):
44
if f and (f.startswith('http://') or f.startswith('https://')):
46
return remotebranch.RemoteBranch(f, **args)
48
return Branch(f, **args)
51
def find_cached_branch(f, cache_root, **args):
52
from remotebranch import RemoteBranch
53
br = find_branch(f, **args)
54
def cacheify(br, store_name):
55
from meta_store import CachedStore
56
cache_path = os.path.join(cache_root, store_name)
58
new_store = CachedStore(getattr(br, store_name), cache_path)
59
setattr(br, store_name, new_store)
61
if isinstance(br, RemoteBranch):
62
cacheify(br, 'inventory_store')
63
cacheify(br, 'text_store')
64
cacheify(br, 'revision_store')
68
def _relpath(base, path):
69
"""Return path relative to base, or raise exception.
71
The path may be either an absolute path or a path relative to the
72
current working directory.
74
Lifted out of Branch.relpath for ease of testing.
76
os.path.commonprefix (python2.4) has a bad bug that it works just
77
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
78
avoids that problem."""
79
rp = os.path.abspath(path)
83
while len(head) >= len(base):
86
head, tail = os.path.split(head)
90
from errors import NotBranchError
91
raise NotBranchError("path %r is not within branch %r" % (rp, base))
96
def find_branch_root(f=None):
97
"""Find the branch root enclosing f, or pwd.
99
f may be a filename or a URL.
101
It is not necessary that f exists.
103
Basically we keep looking up until we find the control directory or
104
run into the root."""
107
elif hasattr(os.path, 'realpath'):
108
f = os.path.realpath(f)
110
f = os.path.abspath(f)
111
if not os.path.exists(f):
112
raise BzrError('%r does not exist' % f)
118
if os.path.exists(os.path.join(f, bzrlib.BZRDIR)):
120
head, tail = os.path.split(f)
122
# reached the root, whatever that may be
123
raise BzrError('%r is not in a branch' % orig_f)
126
class DivergedBranches(Exception):
127
def __init__(self, branch1, branch2):
128
self.branch1 = branch1
129
self.branch2 = branch2
130
Exception.__init__(self, "These branches have diverged.")
133
class NoSuchRevision(BzrError):
134
def __init__(self, branch, revision):
136
self.revision = revision
137
msg = "Branch %s has no revision %d" % (branch, revision)
138
BzrError.__init__(self, msg)
141
######################################################################
144
class Branch(object):
145
"""Branch holding a history of revisions.
148
Base directory of the branch.
154
If _lock_mode is true, a positive count of the number of times the
158
Lock object from bzrlib.lock.
165
# Map some sort of prefix into a namespace
166
# stuff like "revno:10", "revid:", etc.
167
# This should match a prefix with a function which accepts
168
REVISION_NAMESPACES = {}
170
def __init__(self, base, init=False, find_root=True):
171
"""Create new branch object at a particular location.
173
base -- Base directory for the branch.
175
init -- If True, create new control files in a previously
176
unversioned directory. If False, the branch must already
179
find_root -- If true and init is false, find the root of the
180
existing branch containing base.
182
In the test suite, creation of new trees is tested using the
183
`ScratchBranch` class.
185
from bzrlib.store import ImmutableStore
187
self.base = os.path.realpath(base)
190
self.base = find_branch_root(base)
192
self.base = os.path.realpath(base)
193
if not isdir(self.controlfilename('.')):
194
from errors import NotBranchError
195
raise NotBranchError("not a bzr branch: %s" % quotefn(base),
196
['use "bzr init" to initialize a new working tree',
197
'current bzr can only operate from top-of-tree'])
200
self.text_store = ImmutableStore(self.controlfilename('text-store'))
201
self.revision_store = ImmutableStore(self.controlfilename('revision-store'))
202
self.inventory_store = ImmutableStore(self.controlfilename('inventory-store'))
206
return '%s(%r)' % (self.__class__.__name__, self.base)
213
if self._lock_mode or self._lock:
214
from warnings import warn
215
warn("branch %r was not explicitly unlocked" % self)
220
def lock_write(self):
222
if self._lock_mode != 'w':
223
from errors import LockError
224
raise LockError("can't upgrade to a write lock from %r" %
226
self._lock_count += 1
228
from bzrlib.lock import WriteLock
230
self._lock = WriteLock(self.controlfilename('branch-lock'))
231
self._lock_mode = 'w'
238
assert self._lock_mode in ('r', 'w'), \
239
"invalid lock mode %r" % self._lock_mode
240
self._lock_count += 1
242
from bzrlib.lock import ReadLock
244
self._lock = ReadLock(self.controlfilename('branch-lock'))
245
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
263
def abspath(self, name):
264
"""Return absolute filename for something in the branch"""
265
return os.path.join(self.base, name)
268
def relpath(self, path):
269
"""Return path relative to this branch of something inside it.
271
Raises an error if path is not in this branch."""
272
return _relpath(self.base, path)
275
def controlfilename(self, file_or_path):
276
"""Return location relative to branch."""
277
if isinstance(file_or_path, basestring):
278
file_or_path = [file_or_path]
279
return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
282
def controlfile(self, file_or_path, mode='r'):
283
"""Open a control file for this branch.
285
There are two classes of file in the control directory: text
286
and binary. binary files are untranslated byte streams. Text
287
control files are stored with Unix newlines and in UTF-8, even
288
if the platform or locale defaults are different.
290
Controlfiles should almost never be opened in write mode but
291
rather should be atomically copied and replaced using atomicfile.
294
fn = self.controlfilename(file_or_path)
296
if mode == 'rb' or mode == 'wb':
297
return file(fn, mode)
298
elif mode == 'r' or mode == 'w':
299
# open in binary mode anyhow so there's no newline translation;
300
# codecs uses line buffering by default; don't want that.
302
return codecs.open(fn, mode + 'b', 'utf-8',
305
raise BzrError("invalid controlfile mode %r" % mode)
309
def _make_control(self):
310
from bzrlib.inventory import Inventory
311
from bzrlib.xml import pack_xml
313
os.mkdir(self.controlfilename([]))
314
self.controlfile('README', 'w').write(
315
"This is a Bazaar-NG control directory.\n"
316
"Do not change any files in this directory.\n")
317
self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
318
for d in ('text-store', 'inventory-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
pack_xml(Inventory(gen_root_id()), self.controlfile('inventory','w'))
330
def _check_format(self):
331
"""Check this branch format is supported.
333
The current tool only supports the current unstable format.
335
In the future, we might need different in-memory Branch
336
classes to support downlevel branches. But not yet.
338
# This ignores newlines so that we can open branches created
339
# on Windows from Linux and so on. I think it might be better
340
# to always make all internal files in unix format.
341
fmt = self.controlfile('branch-format', 'r').read()
342
fmt.replace('\r\n', '')
343
if fmt != BZR_BRANCH_FORMAT:
344
raise BzrError('sorry, branch format %r not supported' % fmt,
345
['use a different bzr version',
346
'or remove the .bzr directory and "bzr init" again'])
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
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
361
if entry.parent_id in (None, orig_root_id):
362
entry.parent_id = inv.root.file_id
363
self._write_inventory(inv)
365
def read_working_inventory(self):
366
"""Read the working inventory."""
367
from bzrlib.inventory import Inventory
368
from bzrlib.xml import unpack_xml
369
from time import time
373
# ElementTree does its own conversion from UTF-8, so open in
375
inv = unpack_xml(Inventory,
376
self.controlfile('inventory', 'rb'))
377
mutter("loaded inventory of %d items in %f"
378
% (len(inv), time() - before))
384
def _write_inventory(self, inv):
385
"""Update the working inventory.
387
That is to say, the inventory describing changes underway, that
388
will be committed to the next revision.
390
from bzrlib.atomicfile import AtomicFile
391
from bzrlib.xml import pack_xml
395
f = AtomicFile(self.controlfilename('inventory'), 'wb')
404
mutter('wrote working inventory')
407
inventory = property(read_working_inventory, _write_inventory, None,
408
"""Inventory for the working copy.""")
411
def add(self, files, verbose=False, ids=None):
412
"""Make files versioned.
414
Note that the command line normally calls smart_add instead.
416
This puts the files in the Added state, so that they will be
417
recorded by the next commit.
420
List of paths to add, relative to the base of the tree.
423
If set, use these instead of automatically generated ids.
424
Must be the same length as the list of files, but may
425
contain None for ids that are to be autogenerated.
427
TODO: Perhaps have an option to add the ids even if the files do
430
TODO: Perhaps return the ids of the files? But then again it
431
is easy to retrieve them if they're needed.
433
TODO: Adding a directory should optionally recurse down and
434
add all non-ignored children. Perhaps do that in a
437
# TODO: Re-adding a file that is removed in the working copy
438
# should probably put it back with the previous ID.
439
if isinstance(files, basestring):
440
assert(ids is None or isinstance(ids, basestring))
446
ids = [None] * len(files)
448
assert(len(ids) == len(files))
452
inv = self.read_working_inventory()
453
for f,file_id in zip(files, ids):
454
if is_control_file(f):
455
raise BzrError("cannot add control file %s" % quotefn(f))
460
raise BzrError("cannot add top-level %r" % f)
462
fullpath = os.path.normpath(self.abspath(f))
465
kind = file_kind(fullpath)
467
# maybe something better?
468
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
470
if kind != 'file' and kind != 'directory':
471
raise BzrError('cannot add: not a regular file or directory: %s' % quotefn(f))
474
file_id = gen_file_id(f)
475
inv.add_path(f, kind=kind, file_id=file_id)
478
print 'added', quotefn(f)
480
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
482
self._write_inventory(inv)
487
def print_file(self, file, revno):
488
"""Print `file` to stdout."""
491
tree = self.revision_tree(self.lookup_revision(revno))
492
# use inventory as it was in that revision
493
file_id = tree.inventory.path2id(file)
495
raise BzrError("%r is not present in revision %s" % (file, revno))
496
tree.print_file(file_id)
501
def remove(self, files, verbose=False):
502
"""Mark nominated files for removal from the inventory.
504
This does not remove their text. This does not run on
506
TODO: Refuse to remove modified files unless --force is given?
508
TODO: Do something useful with directories.
510
TODO: Should this remove the text or not? Tough call; not
511
removing may be useful and the user can just use use rm, and
512
is the opposite of add. Removing it is consistent with most
513
other tools. Maybe an option.
515
## TODO: Normalize names
516
## TODO: Remove nested loops; better scalability
517
if isinstance(files, basestring):
523
tree = self.working_tree()
526
# do this before any modifications
530
raise BzrError("cannot remove unversioned file %s" % quotefn(f))
531
mutter("remove inventory entry %s {%s}" % (quotefn(f), fid))
533
# having remove it, it must be either ignored or unknown
534
if tree.is_ignored(f):
538
show_status(new_status, inv[fid].kind, quotefn(f))
541
self._write_inventory(inv)
546
# FIXME: this doesn't need to be a branch method
547
def set_inventory(self, new_inventory_list):
548
from bzrlib.inventory import Inventory, InventoryEntry
549
inv = Inventory(self.get_root_id())
550
for path, file_id, parent, kind in new_inventory_list:
551
name = os.path.basename(path)
554
inv.add(InventoryEntry(file_id, name, kind, parent))
555
self._write_inventory(inv)
559
"""Return all unknown files.
561
These are files in the working directory that are not versioned or
562
control files or ignored.
564
>>> b = ScratchBranch(files=['foo', 'foo~'])
565
>>> list(b.unknowns())
568
>>> list(b.unknowns())
571
>>> list(b.unknowns())
574
return self.working_tree().unknowns()
577
def append_revision(self, *revision_ids):
578
from bzrlib.atomicfile import AtomicFile
580
for revision_id in revision_ids:
581
mutter("add {%s} to revision-history" % revision_id)
583
rev_history = self.revision_history()
584
rev_history.extend(revision_ids)
586
f = AtomicFile(self.controlfilename('revision-history'))
588
for rev_id in rev_history:
595
def get_revision_xml(self, revision_id):
596
"""Return XML file object for revision object."""
597
if not revision_id or not isinstance(revision_id, basestring):
598
raise InvalidRevisionId(revision_id)
603
return self.revision_store[revision_id]
605
raise bzrlib.errors.RevisionNotPresent(revision_id)
610
def get_revision(self, revision_id):
611
"""Return the Revision object for a named revision"""
612
xml_file = self.get_revision_xml(revision_id)
615
r = unpack_xml(Revision, xml_file)
616
except SyntaxError, e:
617
raise bzrlib.errors.BzrError('failed to unpack revision_xml',
621
assert r.revision_id == revision_id
625
def get_revision_delta(self, revno):
626
"""Return the delta for one revision.
628
The delta is relative to its mainline predecessor, or the
629
empty tree for revision 1.
631
assert isinstance(revno, int)
632
rh = self.revision_history()
633
if not (1 <= revno <= len(rh)):
634
raise InvalidRevisionNumber(revno)
636
# revno is 1-based; list is 0-based
638
new_tree = self.revision_tree(rh[revno-1])
640
old_tree = EmptyTree()
642
old_tree = self.revision_tree(rh[revno-2])
644
return compare_trees(old_tree, new_tree)
648
def get_revision_sha1(self, revision_id):
649
"""Hash the stored value of a revision, and return it."""
650
# In the future, revision entries will be signed. At that
651
# point, it is probably best *not* to include the signature
652
# in the revision hash. Because that lets you re-sign
653
# the revision, (add signatures/remove signatures) and still
654
# have all hash pointers stay consistent.
655
# But for now, just hash the contents.
656
return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
659
def get_inventory(self, inventory_id):
660
"""Get Inventory object by hash.
662
TODO: Perhaps for this and similar methods, take a revision
663
parameter which can be either an integer revno or a
665
from bzrlib.inventory import Inventory
666
from bzrlib.xml import unpack_xml
668
return unpack_xml(Inventory, self.inventory_store[inventory_id])
671
def get_inventory_sha1(self, inventory_id):
672
"""Return the sha1 hash of the inventory entry
674
return sha_file(self.inventory_store[inventory_id])
677
def get_revision_inventory(self, revision_id):
678
"""Return inventory of a past revision."""
679
# bzr 0.0.6 imposes the constraint that the inventory_id
680
# must be the same as its revision, so this is trivial.
681
if revision_id == None:
682
from bzrlib.inventory import Inventory
683
return Inventory(self.get_root_id())
685
return self.get_inventory(revision_id)
688
def revision_history(self):
689
"""Return sequence of revision hashes on to this branch.
691
>>> ScratchBranch().revision_history()
696
return [l.rstrip('\r\n') for l in
697
self.controlfile('revision-history', 'r').readlines()]
702
def common_ancestor(self, other, self_revno=None, other_revno=None):
705
>>> sb = ScratchBranch(files=['foo', 'foo~'])
706
>>> sb.common_ancestor(sb) == (None, None)
708
>>> commit.commit(sb, "Committing first revision", verbose=False)
709
>>> sb.common_ancestor(sb)[0]
711
>>> clone = sb.clone()
712
>>> commit.commit(sb, "Committing second revision", verbose=False)
713
>>> sb.common_ancestor(sb)[0]
715
>>> sb.common_ancestor(clone)[0]
717
>>> commit.commit(clone, "Committing divergent second revision",
719
>>> sb.common_ancestor(clone)[0]
721
>>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
723
>>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
725
>>> clone2 = sb.clone()
726
>>> sb.common_ancestor(clone2)[0]
728
>>> sb.common_ancestor(clone2, self_revno=1)[0]
730
>>> sb.common_ancestor(clone2, other_revno=1)[0]
733
my_history = self.revision_history()
734
other_history = other.revision_history()
735
if self_revno is None:
736
self_revno = len(my_history)
737
if other_revno is None:
738
other_revno = len(other_history)
739
indices = range(min((self_revno, other_revno)))
742
if my_history[r] == other_history[r]:
743
return r+1, my_history[r]
748
"""Return current revision number for this branch.
750
That is equivalent to the number of revisions committed to
753
return len(self.revision_history())
756
def last_patch(self):
757
"""Return last patch hash, or None if no history.
759
ph = self.revision_history()
766
def missing_revisions(self, other, stop_revision=None):
768
If self and other have not diverged, return a list of the revisions
769
present in other, but missing from self.
771
>>> from bzrlib.commit import commit
772
>>> bzrlib.trace.silent = True
773
>>> br1 = ScratchBranch()
774
>>> br2 = ScratchBranch()
775
>>> br1.missing_revisions(br2)
777
>>> commit(br2, "lala!", rev_id="REVISION-ID-1")
778
>>> br1.missing_revisions(br2)
780
>>> br2.missing_revisions(br1)
782
>>> commit(br1, "lala!", rev_id="REVISION-ID-1")
783
>>> br1.missing_revisions(br2)
785
>>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
786
>>> br1.missing_revisions(br2)
788
>>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
789
>>> br1.missing_revisions(br2)
790
Traceback (most recent call last):
791
DivergedBranches: These branches have diverged.
793
self_history = self.revision_history()
794
self_len = len(self_history)
795
other_history = other.revision_history()
796
other_len = len(other_history)
797
common_index = min(self_len, other_len) -1
798
if common_index >= 0 and \
799
self_history[common_index] != other_history[common_index]:
800
raise DivergedBranches(self, other)
802
if stop_revision is None:
803
stop_revision = other_len
804
elif stop_revision > other_len:
805
raise NoSuchRevision(self, stop_revision)
807
return other_history[self_len:stop_revision]
810
def update_revisions(self, other, stop_revision=None):
811
"""Pull in all new revisions from other branch.
813
>>> from bzrlib.commit import commit
814
>>> bzrlib.trace.silent = True
815
>>> br1 = ScratchBranch(files=['foo', 'bar'])
818
>>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
819
>>> br2 = ScratchBranch()
820
>>> br2.update_revisions(br1)
824
>>> br2.revision_history()
826
>>> br2.update_revisions(br1)
830
>>> br1.text_store.total_size() == br2.text_store.total_size()
833
from bzrlib.progress import ProgressBar
837
pb.update('comparing histories')
838
revision_ids = self.missing_revisions(other, stop_revision)
840
if hasattr(other.revision_store, "prefetch"):
841
other.revision_store.prefetch(revision_ids)
842
if hasattr(other.inventory_store, "prefetch"):
843
inventory_ids = [other.get_revision(r).inventory_id
844
for r in revision_ids]
845
other.inventory_store.prefetch(inventory_ids)
850
for rev_id in revision_ids:
852
pb.update('fetching revision', i, len(revision_ids))
853
rev = other.get_revision(rev_id)
854
revisions.append(rev)
855
inv = other.get_inventory(str(rev.inventory_id))
856
for key, entry in inv.iter_entries():
857
if entry.text_id is None:
859
if entry.text_id not in self.text_store:
860
needed_texts.add(entry.text_id)
864
count = self.text_store.copy_multi(other.text_store, needed_texts)
865
print "Added %d texts." % count
866
inventory_ids = [ f.inventory_id for f in revisions ]
867
count = self.inventory_store.copy_multi(other.inventory_store,
869
print "Added %d inventories." % count
870
revision_ids = [ f.revision_id for f in revisions]
871
count = self.revision_store.copy_multi(other.revision_store,
873
for revision_id in revision_ids:
874
self.append_revision(revision_id)
875
print "Added %d revisions." % count
878
def commit(self, *args, **kw):
879
from bzrlib.commit import commit
880
commit(self, *args, **kw)
883
def lookup_revision(self, revision):
884
"""Return the revision identifier for a given revision information."""
885
revno, info = self.get_revision_info(revision)
888
def get_revision_info(self, revision):
889
"""Return (revno, revision id) for revision identifier.
891
revision can be an integer, in which case it is assumed to be revno (though
892
this will translate negative values into positive ones)
893
revision can also be a string, in which case it is parsed for something like
894
'date:' or 'revid:' etc.
899
try:# Convert to int if possible
900
revision = int(revision)
903
revs = self.revision_history()
904
if isinstance(revision, int):
907
# Mabye we should do this first, but we don't need it if revision == 0
909
revno = len(revs) + revision + 1
912
elif isinstance(revision, basestring):
913
for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
914
if revision.startswith(prefix):
915
revno = func(self, revs, revision)
918
raise BzrError('No namespace registered for string: %r' % revision)
920
if revno is None or revno <= 0 or revno > len(revs):
921
raise BzrError("no such revision %s" % revision)
922
return revno, revs[revno-1]
924
def _namespace_revno(self, revs, revision):
925
"""Lookup a revision by revision number"""
926
assert revision.startswith('revno:')
928
return int(revision[6:])
931
REVISION_NAMESPACES['revno:'] = _namespace_revno
933
def _namespace_revid(self, revs, revision):
934
assert revision.startswith('revid:')
936
return revs.index(revision[6:]) + 1
939
REVISION_NAMESPACES['revid:'] = _namespace_revid
941
def _namespace_last(self, revs, revision):
942
assert revision.startswith('last:')
944
offset = int(revision[5:])
949
raise BzrError('You must supply a positive value for --revision last:XXX')
950
return len(revs) - offset + 1
951
REVISION_NAMESPACES['last:'] = _namespace_last
953
def _namespace_tag(self, revs, revision):
954
assert revision.startswith('tag:')
955
raise BzrError('tag: namespace registered, but not implemented.')
956
REVISION_NAMESPACES['tag:'] = _namespace_tag
958
def _namespace_date(self, revs, revision):
959
assert revision.startswith('date:')
961
# Spec for date revisions:
963
# value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
964
# it can also start with a '+/-/='. '+' says match the first
965
# entry after the given date. '-' is match the first entry before the date
966
# '=' is match the first entry after, but still on the given date.
968
# +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
969
# -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
970
# =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
971
# May 13th, 2005 at 0:00
973
# So the proper way of saying 'give me all entries for today' is:
974
# -r {date:+today}:{date:-tomorrow}
975
# The default is '=' when not supplied
978
if val[:1] in ('+', '-', '='):
979
match_style = val[:1]
982
today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
983
if val.lower() == 'yesterday':
984
dt = today - datetime.timedelta(days=1)
985
elif val.lower() == 'today':
987
elif val.lower() == 'tomorrow':
988
dt = today + datetime.timedelta(days=1)
991
# This should be done outside the function to avoid recompiling it.
992
_date_re = re.compile(
993
r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
995
r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
997
m = _date_re.match(val)
998
if not m or (not m.group('date') and not m.group('time')):
999
raise BzrError('Invalid revision date %r' % revision)
1002
year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
1004
year, month, day = today.year, today.month, today.day
1006
hour = int(m.group('hour'))
1007
minute = int(m.group('minute'))
1008
if m.group('second'):
1009
second = int(m.group('second'))
1013
hour, minute, second = 0,0,0
1015
dt = datetime.datetime(year=year, month=month, day=day,
1016
hour=hour, minute=minute, second=second)
1020
if match_style == '-':
1022
elif match_style == '=':
1023
last = dt + datetime.timedelta(days=1)
1026
for i in range(len(revs)-1, -1, -1):
1027
r = self.get_revision(revs[i])
1028
# TODO: Handle timezone.
1029
dt = datetime.datetime.fromtimestamp(r.timestamp)
1030
if first >= dt and (last is None or dt >= last):
1033
for i in range(len(revs)):
1034
r = self.get_revision(revs[i])
1035
# TODO: Handle timezone.
1036
dt = datetime.datetime.fromtimestamp(r.timestamp)
1037
if first <= dt and (last is None or dt <= last):
1039
REVISION_NAMESPACES['date:'] = _namespace_date
1041
def revision_tree(self, revision_id):
1042
"""Return Tree for a revision on this branch.
1044
`revision_id` may be None for the null revision, in which case
1045
an `EmptyTree` is returned."""
1046
# TODO: refactor this to use an existing revision object
1047
# so we don't need to read it in twice.
1048
if revision_id == None:
1051
inv = self.get_revision_inventory(revision_id)
1052
return RevisionTree(self.text_store, inv)
1055
def working_tree(self):
1056
"""Return a `Tree` for the working copy."""
1057
from workingtree import WorkingTree
1058
return WorkingTree(self.base, self.read_working_inventory())
1061
def basis_tree(self):
1062
"""Return `Tree` object for last revision.
1064
If there are no revisions yet, return an `EmptyTree`.
1066
r = self.last_patch()
1070
return RevisionTree(self.text_store, self.get_revision_inventory(r))
1074
def rename_one(self, from_rel, to_rel):
1077
This can change the directory or the filename or both.
1081
tree = self.working_tree()
1082
inv = tree.inventory
1083
if not tree.has_filename(from_rel):
1084
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1085
if tree.has_filename(to_rel):
1086
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1088
file_id = inv.path2id(from_rel)
1090
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1092
if inv.path2id(to_rel):
1093
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1095
to_dir, to_tail = os.path.split(to_rel)
1096
to_dir_id = inv.path2id(to_dir)
1097
if to_dir_id == None and to_dir != '':
1098
raise BzrError("can't determine destination directory id for %r" % to_dir)
1100
mutter("rename_one:")
1101
mutter(" file_id {%s}" % file_id)
1102
mutter(" from_rel %r" % from_rel)
1103
mutter(" to_rel %r" % to_rel)
1104
mutter(" to_dir %r" % to_dir)
1105
mutter(" to_dir_id {%s}" % to_dir_id)
1107
inv.rename(file_id, to_dir_id, to_tail)
1109
print "%s => %s" % (from_rel, to_rel)
1111
from_abs = self.abspath(from_rel)
1112
to_abs = self.abspath(to_rel)
1114
os.rename(from_abs, to_abs)
1116
raise BzrError("failed to rename %r to %r: %s"
1117
% (from_abs, to_abs, e[1]),
1118
["rename rolled back"])
1120
self._write_inventory(inv)
1125
def move(self, from_paths, to_name):
1128
to_name must exist as a versioned directory.
1130
If to_name exists and is a directory, the files are moved into
1131
it, keeping their old names. If it is a directory,
1133
Note that to_name is only the last component of the new name;
1134
this doesn't change the directory.
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
print "%s => %s" % (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)
1189
def revert(self, filenames, old_tree=None, backups=True):
1190
"""Restore selected files to the versions from a previous tree.
1193
If true (default) backups are made of files before
1196
from bzrlib.errors import NotVersionedError, BzrError
1197
from bzrlib.atomicfile import AtomicFile
1198
from bzrlib.osutils import backup_file
1200
inv = self.read_working_inventory()
1201
if old_tree is None:
1202
old_tree = self.basis_tree()
1203
old_inv = old_tree.inventory
1206
for fn in filenames:
1207
file_id = inv.path2id(fn)
1209
raise NotVersionedError("not a versioned file", fn)
1210
if not old_inv.has_id(file_id):
1211
raise BzrError("file not present in old tree", fn, file_id)
1212
nids.append((fn, file_id))
1214
# TODO: Rename back if it was previously at a different location
1216
# TODO: If given a directory, restore the entire contents from
1217
# the previous version.
1219
# TODO: Make a backup to a temporary file.
1221
# TODO: If the file previously didn't exist, delete it?
1222
for fn, file_id in nids:
1225
f = AtomicFile(fn, 'wb')
1227
f.write(old_tree.get_file(file_id).read())
1233
def pending_merges(self):
1234
"""Return a list of pending merges.
1236
These are revisions that have been merged into the working
1237
directory but not yet committed.
1239
cfn = self.controlfilename('pending-merges')
1240
if not os.path.exists(cfn):
1243
for l in self.controlfile('pending-merges', 'r').readlines():
1244
p.append(l.rstrip('\n'))
1248
def add_pending_merge(self, revision_id):
1249
from bzrlib.revision import validate_revision_id
1251
validate_revision_id(revision_id)
1253
p = self.pending_merges()
1254
if revision_id in p:
1256
p.append(revision_id)
1257
self.set_pending_merges(p)
1260
def set_pending_merges(self, rev_list):
1261
from bzrlib.atomicfile import AtomicFile
1264
f = AtomicFile(self.controlfilename('pending-merges'))
1276
class ScratchBranch(Branch):
1277
"""Special test class: a branch that cleans up after itself.
1279
>>> b = ScratchBranch()
1287
def __init__(self, files=[], dirs=[], base=None):
1288
"""Make a test branch.
1290
This creates a temporary directory and runs init-tree in it.
1292
If any files are listed, they are created in the working copy.
1294
from tempfile import mkdtemp
1299
Branch.__init__(self, base, init=init)
1301
os.mkdir(self.abspath(d))
1304
file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1309
>>> orig = ScratchBranch(files=["file1", "file2"])
1310
>>> clone = orig.clone()
1311
>>> os.path.samefile(orig.base, clone.base)
1313
>>> os.path.isfile(os.path.join(clone.base, "file1"))
1316
from shutil import copytree
1317
from tempfile import mkdtemp
1320
copytree(self.base, base, symlinks=True)
1321
return ScratchBranch(base=base)
1327
"""Destroy the test branch, removing the scratch directory."""
1328
from shutil import rmtree
1331
mutter("delete ScratchBranch %s" % self.base)
1334
# Work around for shutil.rmtree failing on Windows when
1335
# readonly files are encountered
1336
mutter("hit exception in destroying ScratchBranch: %s" % e)
1337
for root, dirs, files in os.walk(self.base, topdown=False):
1339
os.chmod(os.path.join(root, name), 0700)
1345
######################################################################
1349
def is_control_file(filename):
1350
## FIXME: better check
1351
filename = os.path.normpath(filename)
1352
while filename != '':
1353
head, tail = os.path.split(filename)
1354
## mutter('check %r for control file' % ((head, tail), ))
1355
if tail == bzrlib.BZRDIR:
1357
if filename == head:
1364
def gen_file_id(name):
1365
"""Return new file id.
1367
This should probably generate proper UUIDs, but for the moment we
1368
cope with just randomness because running uuidgen every time is
1371
from binascii import hexlify
1372
from time import time
1374
# get last component
1375
idx = name.rfind('/')
1377
name = name[idx+1 : ]
1378
idx = name.rfind('\\')
1380
name = name[idx+1 : ]
1382
# make it not a hidden file
1383
name = name.lstrip('.')
1385
# remove any wierd characters; we don't escape them but rather
1386
# just pull them out
1387
name = re.sub(r'[^\w.]', '', name)
1389
s = hexlify(rand_bytes(8))
1390
return '-'.join((name, compact_date(time()), s))
1394
"""Return a new tree-root file id."""
1395
return gen_file_id('TREE_ROOT')
added
removed
bzrlib/branch.py
