/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2005-06-01 06:09:59 UTC
  • Revision ID: mbp@sourcefrog.net-20050601060959-e0be99c26487bd63
Major rework of locking code:

- New ReadLock and WriteLock objects, with unlock methods, and that
  give a warning if they leak without being unlocked

- The lock file is opened readonly for read locks, which should avoid
  problems when the user only has read permission for a branch.

- Selective definitions of locking code is perhaps simpler now

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
import sys
19
 
import os
 
18
import sys, os, os.path, random, time, sha, sets, types, re, shutil, tempfile
 
19
import traceback, socket, fnmatch, difflib, time
 
20
from binascii import hexlify
20
21
 
21
22
import bzrlib
22
 
from bzrlib.trace import mutter, note
23
 
from bzrlib.osutils import isdir, quotefn, compact_date, rand_bytes, \
24
 
     splitpath, \
25
 
     sha_file, appendpath, file_kind
26
 
from bzrlib.errors import BzrError, InvalidRevisionNumber, InvalidRevisionId
27
 
import bzrlib.errors
28
 
from bzrlib.textui import show_status
29
 
from bzrlib.revision import Revision
30
 
from bzrlib.xml import unpack_xml
31
 
from bzrlib.delta import compare_trees
32
 
from bzrlib.tree import EmptyTree, RevisionTree
33
 
        
 
23
from inventory import Inventory
 
24
from trace import mutter, note
 
25
from tree import Tree, EmptyTree, RevisionTree
 
26
from inventory import InventoryEntry, Inventory
 
27
from osutils import isdir, quotefn, isfile, uuid, sha_file, username, \
 
28
     format_date, compact_date, pumpfile, user_email, rand_bytes, splitpath, \
 
29
     joinpath, sha_string, file_kind, local_time_offset, appendpath
 
30
from store import ImmutableStore
 
31
from revision import Revision
 
32
from errors import BzrError
 
33
from textui import show_status
 
34
 
34
35
BZR_BRANCH_FORMAT = "Bazaar-NG branch, format 0.0.4\n"
35
36
## TODO: Maybe include checks for common corruption of newlines, etc?
36
37
 
37
38
 
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.
41
 
 
42
39
 
43
40
def find_branch(f, **args):
44
41
    if f and (f.startswith('http://') or f.startswith('https://')):
48
45
        return Branch(f, **args)
49
46
 
50
47
 
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)
57
 
        os.mkdir(cache_path)
58
 
        new_store = CachedStore(getattr(br, store_name), cache_path)
59
 
        setattr(br, store_name, new_store)
60
 
 
61
 
    if isinstance(br, RemoteBranch):
62
 
        cacheify(br, 'inventory_store')
63
 
        cacheify(br, 'text_store')
64
 
        cacheify(br, 'revision_store')
65
 
    return br
66
 
 
67
48
 
68
49
def _relpath(base, path):
69
50
    """Return path relative to base, or raise exception.
123
104
            raise BzrError('%r is not in a branch' % orig_f)
124
105
        f = head
125
106
    
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.")
131
107
 
132
108
 
133
109
######################################################################
154
130
    _lock_count = None
155
131
    _lock = None
156
132
    
157
 
    # Map some sort of prefix into a namespace
158
 
    # stuff like "revno:10", "revid:", etc.
159
 
    # This should match a prefix with a function which accepts
160
 
    REVISION_NAMESPACES = {}
161
 
 
162
133
    def __init__(self, base, init=False, find_root=True):
163
134
        """Create new branch object at a particular location.
164
135
 
174
145
        In the test suite, creation of new trees is tested using the
175
146
        `ScratchBranch` class.
176
147
        """
177
 
        from bzrlib.store import ImmutableStore
178
148
        if init:
179
149
            self.base = os.path.realpath(base)
180
150
            self._make_control()
266
236
 
267
237
    def controlfilename(self, file_or_path):
268
238
        """Return location relative to branch."""
269
 
        if isinstance(file_or_path, basestring):
 
239
        if isinstance(file_or_path, types.StringTypes):
270
240
            file_or_path = [file_or_path]
271
241
        return os.path.join(self.base, bzrlib.BZRDIR, *file_or_path)
272
242
 
299
269
 
300
270
 
301
271
    def _make_control(self):
302
 
        from bzrlib.inventory import Inventory
303
 
        from bzrlib.xml import pack_xml
304
 
        
305
272
        os.mkdir(self.controlfilename([]))
306
273
        self.controlfile('README', 'w').write(
307
274
            "This is a Bazaar-NG control directory.\n"
308
 
            "Do not change any files in this directory.\n")
 
275
            "Do not change any files in this directory.")
309
276
        self.controlfile('branch-format', 'w').write(BZR_BRANCH_FORMAT)
310
277
        for d in ('text-store', 'inventory-store', 'revision-store'):
311
278
            os.mkdir(self.controlfilename(d))
312
279
        for f in ('revision-history', 'merged-patches',
313
280
                  'pending-merged-patches', 'branch-name',
314
 
                  'branch-lock',
315
 
                  'pending-merges'):
 
281
                  'branch-lock'):
316
282
            self.controlfile(f, 'w').write('')
317
283
        mutter('created control directory in ' + self.base)
318
 
 
319
 
        pack_xml(Inventory(gen_root_id()), self.controlfile('inventory','w'))
 
284
        Inventory().write_xml(self.controlfile('inventory','w'))
320
285
 
321
286
 
322
287
    def _check_format(self):
337
302
                           ['use a different bzr version',
338
303
                            'or remove the .bzr directory and "bzr init" again'])
339
304
 
340
 
    def get_root_id(self):
341
 
        """Return the id of this branches root"""
342
 
        inv = self.read_working_inventory()
343
 
        return inv.root.file_id
344
305
 
345
 
    def set_root_id(self, file_id):
346
 
        inv = self.read_working_inventory()
347
 
        orig_root_id = inv.root.file_id
348
 
        del inv._byid[inv.root.file_id]
349
 
        inv.root.file_id = file_id
350
 
        inv._byid[inv.root.file_id] = inv.root
351
 
        for fid in inv:
352
 
            entry = inv[fid]
353
 
            if entry.parent_id in (None, orig_root_id):
354
 
                entry.parent_id = inv.root.file_id
355
 
        self._write_inventory(inv)
356
306
 
357
307
    def read_working_inventory(self):
358
308
        """Read the working inventory."""
359
 
        from bzrlib.inventory import Inventory
360
 
        from bzrlib.xml import unpack_xml
361
 
        from time import time
362
 
        before = time()
 
309
        before = time.time()
 
310
        # ElementTree does its own conversion from UTF-8, so open in
 
311
        # binary.
363
312
        self.lock_read()
364
313
        try:
365
 
            # ElementTree does its own conversion from UTF-8, so open in
366
 
            # binary.
367
 
            inv = unpack_xml(Inventory,
368
 
                             self.controlfile('inventory', 'rb'))
 
314
            inv = Inventory.read_xml(self.controlfile('inventory', 'rb'))
369
315
            mutter("loaded inventory of %d items in %f"
370
 
                   % (len(inv), time() - before))
 
316
                   % (len(inv), time.time() - before))
371
317
            return inv
372
318
        finally:
373
319
            self.unlock()
379
325
        That is to say, the inventory describing changes underway, that
380
326
        will be committed to the next revision.
381
327
        """
382
 
        from bzrlib.atomicfile import AtomicFile
383
 
        from bzrlib.xml import pack_xml
384
 
        
385
 
        self.lock_write()
386
 
        try:
387
 
            f = AtomicFile(self.controlfilename('inventory'), 'wb')
388
 
            try:
389
 
                pack_xml(inv, f)
390
 
                f.commit()
391
 
            finally:
392
 
                f.close()
393
 
        finally:
394
 
            self.unlock()
395
 
        
 
328
        ## TODO: factor out to atomicfile?  is rename safe on windows?
 
329
        ## TODO: Maybe some kind of clean/dirty marker on inventory?
 
330
        tmpfname = self.controlfilename('inventory.tmp')
 
331
        tmpf = file(tmpfname, 'wb')
 
332
        inv.write_xml(tmpf)
 
333
        tmpf.close()
 
334
        inv_fname = self.controlfilename('inventory')
 
335
        if sys.platform == 'win32':
 
336
            os.remove(inv_fname)
 
337
        os.rename(tmpfname, inv_fname)
396
338
        mutter('wrote working inventory')
397
339
            
398
340
 
428
370
        """
429
371
        # TODO: Re-adding a file that is removed in the working copy
430
372
        # should probably put it back with the previous ID.
431
 
        if isinstance(files, basestring):
432
 
            assert(ids is None or isinstance(ids, basestring))
 
373
        if isinstance(files, types.StringTypes):
 
374
            assert(ids is None or isinstance(ids, types.StringTypes))
433
375
            files = [files]
434
376
            if ids is not None:
435
377
                ids = [ids]
467
409
                inv.add_path(f, kind=kind, file_id=file_id)
468
410
 
469
411
                if verbose:
470
 
                    print 'added', quotefn(f)
 
412
                    show_status('A', kind, quotefn(f))
471
413
 
472
414
                mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
473
415
 
484
426
            # use inventory as it was in that revision
485
427
            file_id = tree.inventory.path2id(file)
486
428
            if not file_id:
487
 
                raise BzrError("%r is not present in revision %s" % (file, revno))
 
429
                raise BzrError("%r is not present in revision %d" % (file, revno))
488
430
            tree.print_file(file_id)
489
431
        finally:
490
432
            self.unlock()
506
448
        """
507
449
        ## TODO: Normalize names
508
450
        ## TODO: Remove nested loops; better scalability
509
 
        if isinstance(files, basestring):
 
451
        if isinstance(files, types.StringTypes):
510
452
            files = [files]
511
453
 
512
454
        self.lock_write()
537
479
 
538
480
    # FIXME: this doesn't need to be a branch method
539
481
    def set_inventory(self, new_inventory_list):
540
 
        from bzrlib.inventory import Inventory, InventoryEntry
541
 
        inv = Inventory(self.get_root_id())
 
482
        inv = Inventory()
542
483
        for path, file_id, parent, kind in new_inventory_list:
543
484
            name = os.path.basename(path)
544
485
            if name == "":
566
507
        return self.working_tree().unknowns()
567
508
 
568
509
 
569
 
    def append_revision(self, *revision_ids):
570
 
        from bzrlib.atomicfile import AtomicFile
571
 
 
572
 
        for revision_id in revision_ids:
573
 
            mutter("add {%s} to revision-history" % revision_id)
574
 
 
 
510
    def append_revision(self, revision_id):
 
511
        mutter("add {%s} to revision-history" % revision_id)
575
512
        rev_history = self.revision_history()
576
 
        rev_history.extend(revision_ids)
577
 
 
578
 
        f = AtomicFile(self.controlfilename('revision-history'))
579
 
        try:
580
 
            for rev_id in rev_history:
581
 
                print >>f, rev_id
582
 
            f.commit()
583
 
        finally:
584
 
            f.close()
585
 
 
586
 
 
587
 
    def get_revision_xml(self, revision_id):
588
 
        """Return XML file object for revision object."""
589
 
        if not revision_id or not isinstance(revision_id, basestring):
590
 
            raise InvalidRevisionId(revision_id)
591
 
 
592
 
        self.lock_read()
593
 
        try:
594
 
            try:
595
 
                return self.revision_store[revision_id]
596
 
            except IndexError:
597
 
                raise bzrlib.errors.NoSuchRevision(revision_id)
598
 
        finally:
599
 
            self.unlock()
 
513
 
 
514
        tmprhname = self.controlfilename('revision-history.tmp')
 
515
        rhname = self.controlfilename('revision-history')
 
516
        
 
517
        f = file(tmprhname, 'wt')
 
518
        rev_history.append(revision_id)
 
519
        f.write('\n'.join(rev_history))
 
520
        f.write('\n')
 
521
        f.close()
 
522
 
 
523
        if sys.platform == 'win32':
 
524
            os.remove(rhname)
 
525
        os.rename(tmprhname, rhname)
 
526
        
600
527
 
601
528
 
602
529
    def get_revision(self, revision_id):
603
530
        """Return the Revision object for a named revision"""
604
 
        xml_file = self.get_revision_xml(revision_id)
605
 
 
606
 
        try:
607
 
            r = unpack_xml(Revision, xml_file)
608
 
        except SyntaxError, e:
609
 
            raise bzrlib.errors.BzrError('failed to unpack revision_xml',
610
 
                                         [revision_id,
611
 
                                          str(e)])
612
 
            
 
531
        r = Revision.read_xml(self.revision_store[revision_id])
613
532
        assert r.revision_id == revision_id
614
533
        return r
615
534
 
616
535
 
617
 
    def get_revision_delta(self, revno):
618
 
        """Return the delta for one revision.
619
 
 
620
 
        The delta is relative to its mainline predecessor, or the
621
 
        empty tree for revision 1.
622
 
        """
623
 
        assert isinstance(revno, int)
624
 
        rh = self.revision_history()
625
 
        if not (1 <= revno <= len(rh)):
626
 
            raise InvalidRevisionNumber(revno)
627
 
 
628
 
        # revno is 1-based; list is 0-based
629
 
 
630
 
        new_tree = self.revision_tree(rh[revno-1])
631
 
        if revno == 1:
632
 
            old_tree = EmptyTree()
633
 
        else:
634
 
            old_tree = self.revision_tree(rh[revno-2])
635
 
 
636
 
        return compare_trees(old_tree, new_tree)
637
 
 
638
 
        
639
 
 
640
 
    def get_revision_sha1(self, revision_id):
641
 
        """Hash the stored value of a revision, and return it."""
642
 
        # In the future, revision entries will be signed. At that
643
 
        # point, it is probably best *not* to include the signature
644
 
        # in the revision hash. Because that lets you re-sign
645
 
        # the revision, (add signatures/remove signatures) and still
646
 
        # have all hash pointers stay consistent.
647
 
        # But for now, just hash the contents.
648
 
        return bzrlib.osutils.sha_file(self.get_revision_xml(revision_id))
649
 
 
650
 
 
651
536
    def get_inventory(self, inventory_id):
652
537
        """Get Inventory object by hash.
653
538
 
654
539
        TODO: Perhaps for this and similar methods, take a revision
655
540
               parameter which can be either an integer revno or a
656
541
               string hash."""
657
 
        from bzrlib.inventory import Inventory
658
 
        from bzrlib.xml import unpack_xml
659
 
 
660
 
        return unpack_xml(Inventory, self.inventory_store[inventory_id])
661
 
            
662
 
 
663
 
    def get_inventory_sha1(self, inventory_id):
664
 
        """Return the sha1 hash of the inventory entry
665
 
        """
666
 
        return sha_file(self.inventory_store[inventory_id])
 
542
        i = Inventory.read_xml(self.inventory_store[inventory_id])
 
543
        return i
667
544
 
668
545
 
669
546
    def get_revision_inventory(self, revision_id):
670
547
        """Return inventory of a past revision."""
671
 
        # bzr 0.0.6 imposes the constraint that the inventory_id
672
 
        # must be the same as its revision, so this is trivial.
673
548
        if revision_id == None:
674
 
            from bzrlib.inventory import Inventory
675
 
            return Inventory(self.get_root_id())
 
549
            return Inventory()
676
550
        else:
677
 
            return self.get_inventory(revision_id)
 
551
            return self.get_inventory(self.get_revision(revision_id).inventory_id)
678
552
 
679
553
 
680
554
    def revision_history(self):
691
565
            self.unlock()
692
566
 
693
567
 
694
 
    def common_ancestor(self, other, self_revno=None, other_revno=None):
695
 
        """
696
 
        >>> import commit
697
 
        >>> sb = ScratchBranch(files=['foo', 'foo~'])
698
 
        >>> sb.common_ancestor(sb) == (None, None)
699
 
        True
700
 
        >>> commit.commit(sb, "Committing first revision", verbose=False)
701
 
        >>> sb.common_ancestor(sb)[0]
702
 
        1
703
 
        >>> clone = sb.clone()
704
 
        >>> commit.commit(sb, "Committing second revision", verbose=False)
705
 
        >>> sb.common_ancestor(sb)[0]
706
 
        2
707
 
        >>> sb.common_ancestor(clone)[0]
708
 
        1
709
 
        >>> commit.commit(clone, "Committing divergent second revision", 
710
 
        ...               verbose=False)
711
 
        >>> sb.common_ancestor(clone)[0]
712
 
        1
713
 
        >>> sb.common_ancestor(clone) == clone.common_ancestor(sb)
714
 
        True
715
 
        >>> sb.common_ancestor(sb) != clone.common_ancestor(clone)
716
 
        True
717
 
        >>> clone2 = sb.clone()
718
 
        >>> sb.common_ancestor(clone2)[0]
719
 
        2
720
 
        >>> sb.common_ancestor(clone2, self_revno=1)[0]
721
 
        1
722
 
        >>> sb.common_ancestor(clone2, other_revno=1)[0]
723
 
        1
724
 
        """
725
 
        my_history = self.revision_history()
726
 
        other_history = other.revision_history()
727
 
        if self_revno is None:
728
 
            self_revno = len(my_history)
729
 
        if other_revno is None:
730
 
            other_revno = len(other_history)
731
 
        indices = range(min((self_revno, other_revno)))
732
 
        indices.reverse()
733
 
        for r in indices:
734
 
            if my_history[r] == other_history[r]:
735
 
                return r+1, my_history[r]
736
 
        return None, None
 
568
    def enum_history(self, direction):
 
569
        """Return (revno, revision_id) for history of branch.
 
570
 
 
571
        direction
 
572
            'forward' is from earliest to latest
 
573
            'reverse' is from latest to earliest
 
574
        """
 
575
        rh = self.revision_history()
 
576
        if direction == 'forward':
 
577
            i = 1
 
578
            for rid in rh:
 
579
                yield i, rid
 
580
                i += 1
 
581
        elif direction == 'reverse':
 
582
            i = len(rh)
 
583
            while i > 0:
 
584
                yield i, rh[i-1]
 
585
                i -= 1
 
586
        else:
 
587
            raise ValueError('invalid history direction', direction)
737
588
 
738
589
 
739
590
    def revno(self):
755
606
            return None
756
607
 
757
608
 
758
 
    def missing_revisions(self, other, stop_revision=None):
759
 
        """
760
 
        If self and other have not diverged, return a list of the revisions
761
 
        present in other, but missing from self.
762
 
 
763
 
        >>> from bzrlib.commit import commit
764
 
        >>> bzrlib.trace.silent = True
765
 
        >>> br1 = ScratchBranch()
766
 
        >>> br2 = ScratchBranch()
767
 
        >>> br1.missing_revisions(br2)
768
 
        []
769
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-1")
770
 
        >>> br1.missing_revisions(br2)
771
 
        [u'REVISION-ID-1']
772
 
        >>> br2.missing_revisions(br1)
773
 
        []
774
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1")
775
 
        >>> br1.missing_revisions(br2)
776
 
        []
777
 
        >>> commit(br2, "lala!", rev_id="REVISION-ID-2A")
778
 
        >>> br1.missing_revisions(br2)
779
 
        [u'REVISION-ID-2A']
780
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-2B")
781
 
        >>> br1.missing_revisions(br2)
782
 
        Traceback (most recent call last):
783
 
        DivergedBranches: These branches have diverged.
784
 
        """
785
 
        self_history = self.revision_history()
786
 
        self_len = len(self_history)
787
 
        other_history = other.revision_history()
788
 
        other_len = len(other_history)
789
 
        common_index = min(self_len, other_len) -1
790
 
        if common_index >= 0 and \
791
 
            self_history[common_index] != other_history[common_index]:
792
 
            raise DivergedBranches(self, other)
793
 
 
794
 
        if stop_revision is None:
795
 
            stop_revision = other_len
796
 
        elif stop_revision > other_len:
797
 
            raise NoSuchRevision(self, stop_revision)
798
 
        
799
 
        return other_history[self_len:stop_revision]
800
 
 
801
 
 
802
 
    def update_revisions(self, other, stop_revision=None):
803
 
        """Pull in all new revisions from other branch.
804
 
        
805
 
        >>> from bzrlib.commit import commit
806
 
        >>> bzrlib.trace.silent = True
807
 
        >>> br1 = ScratchBranch(files=['foo', 'bar'])
808
 
        >>> br1.add('foo')
809
 
        >>> br1.add('bar')
810
 
        >>> commit(br1, "lala!", rev_id="REVISION-ID-1", verbose=False)
811
 
        >>> br2 = ScratchBranch()
812
 
        >>> br2.update_revisions(br1)
813
 
        Added 2 texts.
814
 
        Added 1 inventories.
815
 
        Added 1 revisions.
816
 
        >>> br2.revision_history()
817
 
        [u'REVISION-ID-1']
818
 
        >>> br2.update_revisions(br1)
819
 
        Added 0 texts.
820
 
        Added 0 inventories.
821
 
        Added 0 revisions.
822
 
        >>> br1.text_store.total_size() == br2.text_store.total_size()
823
 
        True
824
 
        """
825
 
        from bzrlib.progress import ProgressBar
826
 
 
827
 
        pb = ProgressBar()
828
 
 
829
 
        pb.update('comparing histories')
830
 
        revision_ids = self.missing_revisions(other, stop_revision)
831
 
 
832
 
        if hasattr(other.revision_store, "prefetch"):
833
 
            other.revision_store.prefetch(revision_ids)
834
 
        if hasattr(other.inventory_store, "prefetch"):
835
 
            inventory_ids = [other.get_revision(r).inventory_id
836
 
                             for r in revision_ids]
837
 
            other.inventory_store.prefetch(inventory_ids)
838
 
                
839
 
        revisions = []
840
 
        needed_texts = set()
841
 
        i = 0
842
 
        for rev_id in revision_ids:
843
 
            i += 1
844
 
            pb.update('fetching revision', i, len(revision_ids))
845
 
            rev = other.get_revision(rev_id)
846
 
            revisions.append(rev)
847
 
            inv = other.get_inventory(str(rev.inventory_id))
848
 
            for key, entry in inv.iter_entries():
849
 
                if entry.text_id is None:
850
 
                    continue
851
 
                if entry.text_id not in self.text_store:
852
 
                    needed_texts.add(entry.text_id)
853
 
 
854
 
        pb.clear()
855
 
                    
856
 
        count = self.text_store.copy_multi(other.text_store, needed_texts)
857
 
        print "Added %d texts." % count 
858
 
        inventory_ids = [ f.inventory_id for f in revisions ]
859
 
        count = self.inventory_store.copy_multi(other.inventory_store, 
860
 
                                                inventory_ids)
861
 
        print "Added %d inventories." % count 
862
 
        revision_ids = [ f.revision_id for f in revisions]
863
 
        count = self.revision_store.copy_multi(other.revision_store, 
864
 
                                               revision_ids)
865
 
        for revision_id in revision_ids:
866
 
            self.append_revision(revision_id)
867
 
        print "Added %d revisions." % count
868
 
                    
869
 
        
870
609
    def commit(self, *args, **kw):
 
610
        """Deprecated"""
871
611
        from bzrlib.commit import commit
872
612
        commit(self, *args, **kw)
873
613
        
874
614
 
875
 
    def lookup_revision(self, revision):
876
 
        """Return the revision identifier for a given revision information."""
877
 
        revno, info = self.get_revision_info(revision)
878
 
        return info
879
 
 
880
 
    def get_revision_info(self, revision):
881
 
        """Return (revno, revision id) for revision identifier.
882
 
 
883
 
        revision can be an integer, in which case it is assumed to be revno (though
884
 
            this will translate negative values into positive ones)
885
 
        revision can also be a string, in which case it is parsed for something like
886
 
            'date:' or 'revid:' etc.
887
 
        """
888
 
        if revision is None:
889
 
            return 0, None
890
 
        revno = None
891
 
        try:# Convert to int if possible
892
 
            revision = int(revision)
893
 
        except ValueError:
894
 
            pass
895
 
        revs = self.revision_history()
896
 
        if isinstance(revision, int):
897
 
            if revision == 0:
898
 
                return 0, None
899
 
            # Mabye we should do this first, but we don't need it if revision == 0
900
 
            if revision < 0:
901
 
                revno = len(revs) + revision + 1
902
 
            else:
903
 
                revno = revision
904
 
        elif isinstance(revision, basestring):
905
 
            for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
906
 
                if revision.startswith(prefix):
907
 
                    revno = func(self, revs, revision)
908
 
                    break
909
 
            else:
910
 
                raise BzrError('No namespace registered for string: %r' % revision)
911
 
 
912
 
        if revno is None or revno <= 0 or revno > len(revs):
913
 
            raise BzrError("no such revision %s" % revision)
914
 
        return revno, revs[revno-1]
915
 
 
916
 
    def _namespace_revno(self, revs, revision):
917
 
        """Lookup a revision by revision number"""
918
 
        assert revision.startswith('revno:')
919
 
        try:
920
 
            return int(revision[6:])
921
 
        except ValueError:
922
 
            return None
923
 
    REVISION_NAMESPACES['revno:'] = _namespace_revno
924
 
 
925
 
    def _namespace_revid(self, revs, revision):
926
 
        assert revision.startswith('revid:')
927
 
        try:
928
 
            return revs.index(revision[6:]) + 1
929
 
        except ValueError:
930
 
            return None
931
 
    REVISION_NAMESPACES['revid:'] = _namespace_revid
932
 
 
933
 
    def _namespace_last(self, revs, revision):
934
 
        assert revision.startswith('last:')
935
 
        try:
936
 
            offset = int(revision[5:])
937
 
        except ValueError:
938
 
            return None
939
 
        else:
940
 
            if offset <= 0:
941
 
                raise BzrError('You must supply a positive value for --revision last:XXX')
942
 
            return len(revs) - offset + 1
943
 
    REVISION_NAMESPACES['last:'] = _namespace_last
944
 
 
945
 
    def _namespace_tag(self, revs, revision):
946
 
        assert revision.startswith('tag:')
947
 
        raise BzrError('tag: namespace registered, but not implemented.')
948
 
    REVISION_NAMESPACES['tag:'] = _namespace_tag
949
 
 
950
 
    def _namespace_date(self, revs, revision):
951
 
        assert revision.startswith('date:')
952
 
        import datetime
953
 
        # Spec for date revisions:
954
 
        #   date:value
955
 
        #   value can be 'yesterday', 'today', 'tomorrow' or a YYYY-MM-DD string.
956
 
        #   it can also start with a '+/-/='. '+' says match the first
957
 
        #   entry after the given date. '-' is match the first entry before the date
958
 
        #   '=' is match the first entry after, but still on the given date.
959
 
        #
960
 
        #   +2005-05-12 says find the first matching entry after May 12th, 2005 at 0:00
961
 
        #   -2005-05-12 says find the first matching entry before May 12th, 2005 at 0:00
962
 
        #   =2005-05-12 says find the first match after May 12th, 2005 at 0:00 but before
963
 
        #       May 13th, 2005 at 0:00
964
 
        #
965
 
        #   So the proper way of saying 'give me all entries for today' is:
966
 
        #       -r {date:+today}:{date:-tomorrow}
967
 
        #   The default is '=' when not supplied
968
 
        val = revision[5:]
969
 
        match_style = '='
970
 
        if val[:1] in ('+', '-', '='):
971
 
            match_style = val[:1]
972
 
            val = val[1:]
973
 
 
974
 
        today = datetime.datetime.today().replace(hour=0,minute=0,second=0,microsecond=0)
975
 
        if val.lower() == 'yesterday':
976
 
            dt = today - datetime.timedelta(days=1)
977
 
        elif val.lower() == 'today':
978
 
            dt = today
979
 
        elif val.lower() == 'tomorrow':
980
 
            dt = today + datetime.timedelta(days=1)
981
 
        else:
982
 
            import re
983
 
            # This should be done outside the function to avoid recompiling it.
984
 
            _date_re = re.compile(
985
 
                    r'(?P<date>(?P<year>\d\d\d\d)-(?P<month>\d\d)-(?P<day>\d\d))?'
986
 
                    r'(,|T)?\s*'
987
 
                    r'(?P<time>(?P<hour>\d\d):(?P<minute>\d\d)(:(?P<second>\d\d))?)?'
988
 
                )
989
 
            m = _date_re.match(val)
990
 
            if not m or (not m.group('date') and not m.group('time')):
991
 
                raise BzrError('Invalid revision date %r' % revision)
992
 
 
993
 
            if m.group('date'):
994
 
                year, month, day = int(m.group('year')), int(m.group('month')), int(m.group('day'))
995
 
            else:
996
 
                year, month, day = today.year, today.month, today.day
997
 
            if m.group('time'):
998
 
                hour = int(m.group('hour'))
999
 
                minute = int(m.group('minute'))
1000
 
                if m.group('second'):
1001
 
                    second = int(m.group('second'))
1002
 
                else:
1003
 
                    second = 0
1004
 
            else:
1005
 
                hour, minute, second = 0,0,0
1006
 
 
1007
 
            dt = datetime.datetime(year=year, month=month, day=day,
1008
 
                    hour=hour, minute=minute, second=second)
1009
 
        first = dt
1010
 
        last = None
1011
 
        reversed = False
1012
 
        if match_style == '-':
1013
 
            reversed = True
1014
 
        elif match_style == '=':
1015
 
            last = dt + datetime.timedelta(days=1)
1016
 
 
1017
 
        if reversed:
1018
 
            for i in range(len(revs)-1, -1, -1):
1019
 
                r = self.get_revision(revs[i])
1020
 
                # TODO: Handle timezone.
1021
 
                dt = datetime.datetime.fromtimestamp(r.timestamp)
1022
 
                if first >= dt and (last is None or dt >= last):
1023
 
                    return i+1
1024
 
        else:
1025
 
            for i in range(len(revs)):
1026
 
                r = self.get_revision(revs[i])
1027
 
                # TODO: Handle timezone.
1028
 
                dt = datetime.datetime.fromtimestamp(r.timestamp)
1029
 
                if first <= dt and (last is None or dt <= last):
1030
 
                    return i+1
1031
 
    REVISION_NAMESPACES['date:'] = _namespace_date
 
615
    def lookup_revision(self, revno):
 
616
        """Return revision hash for revision number."""
 
617
        if revno == 0:
 
618
            return None
 
619
 
 
620
        try:
 
621
            # list is 0-based; revisions are 1-based
 
622
            return self.revision_history()[revno-1]
 
623
        except IndexError:
 
624
            raise BzrError("no such revision %s" % revno)
 
625
 
1032
626
 
1033
627
    def revision_tree(self, revision_id):
1034
628
        """Return Tree for a revision on this branch.
1178
772
            self.unlock()
1179
773
 
1180
774
 
1181
 
    def revert(self, filenames, old_tree=None, backups=True):
1182
 
        """Restore selected files to the versions from a previous tree.
1183
 
 
1184
 
        backups
1185
 
            If true (default) backups are made of files before
1186
 
            they're renamed.
1187
 
        """
1188
 
        from bzrlib.errors import NotVersionedError, BzrError
1189
 
        from bzrlib.atomicfile import AtomicFile
1190
 
        from bzrlib.osutils import backup_file
1191
 
        
1192
 
        inv = self.read_working_inventory()
1193
 
        if old_tree is None:
1194
 
            old_tree = self.basis_tree()
1195
 
        old_inv = old_tree.inventory
1196
 
 
1197
 
        nids = []
1198
 
        for fn in filenames:
1199
 
            file_id = inv.path2id(fn)
1200
 
            if not file_id:
1201
 
                raise NotVersionedError("not a versioned file", fn)
1202
 
            if not old_inv.has_id(file_id):
1203
 
                raise BzrError("file not present in old tree", fn, file_id)
1204
 
            nids.append((fn, file_id))
1205
 
            
1206
 
        # TODO: Rename back if it was previously at a different location
1207
 
 
1208
 
        # TODO: If given a directory, restore the entire contents from
1209
 
        # the previous version.
1210
 
 
1211
 
        # TODO: Make a backup to a temporary file.
1212
 
 
1213
 
        # TODO: If the file previously didn't exist, delete it?
1214
 
        for fn, file_id in nids:
1215
 
            backup_file(fn)
1216
 
            
1217
 
            f = AtomicFile(fn, 'wb')
1218
 
            try:
1219
 
                f.write(old_tree.get_file(file_id).read())
1220
 
                f.commit()
1221
 
            finally:
1222
 
                f.close()
1223
 
 
1224
 
 
1225
 
    def pending_merges(self):
1226
 
        """Return a list of pending merges.
1227
 
 
1228
 
        These are revisions that have been merged into the working
1229
 
        directory but not yet committed.
1230
 
        """
1231
 
        cfn = self.controlfilename('pending-merges')
1232
 
        if not os.path.exists(cfn):
1233
 
            return []
1234
 
        p = []
1235
 
        for l in self.controlfile('pending-merges', 'r').readlines():
1236
 
            p.append(l.rstrip('\n'))
1237
 
        return p
1238
 
 
1239
 
 
1240
 
    def add_pending_merge(self, revision_id):
1241
 
        from bzrlib.revision import validate_revision_id
1242
 
 
1243
 
        validate_revision_id(revision_id)
1244
 
 
1245
 
        p = self.pending_merges()
1246
 
        if revision_id in p:
1247
 
            return
1248
 
        p.append(revision_id)
1249
 
        self.set_pending_merges(p)
1250
 
 
1251
 
 
1252
 
    def set_pending_merges(self, rev_list):
1253
 
        from bzrlib.atomicfile import AtomicFile
1254
 
        self.lock_write()
1255
 
        try:
1256
 
            f = AtomicFile(self.controlfilename('pending-merges'))
1257
 
            try:
1258
 
                for l in rev_list:
1259
 
                    print >>f, l
1260
 
                f.commit()
1261
 
            finally:
1262
 
                f.close()
1263
 
        finally:
1264
 
            self.unlock()
1265
 
 
1266
 
 
1267
775
 
1268
776
class ScratchBranch(Branch):
1269
777
    """Special test class: a branch that cleans up after itself.
1276
784
    >>> isdir(bd)
1277
785
    False
1278
786
    """
1279
 
    def __init__(self, files=[], dirs=[], base=None):
 
787
    def __init__(self, files=[], dirs=[]):
1280
788
        """Make a test branch.
1281
789
 
1282
790
        This creates a temporary directory and runs init-tree in it.
1283
791
 
1284
792
        If any files are listed, they are created in the working copy.
1285
793
        """
1286
 
        from tempfile import mkdtemp
1287
 
        init = False
1288
 
        if base is None:
1289
 
            base = mkdtemp()
1290
 
            init = True
1291
 
        Branch.__init__(self, base, init=init)
 
794
        Branch.__init__(self, tempfile.mkdtemp(), init=True)
1292
795
        for d in dirs:
1293
796
            os.mkdir(self.abspath(d))
1294
797
            
1296
799
            file(os.path.join(self.base, f), 'w').write('content of %s' % f)
1297
800
 
1298
801
 
1299
 
    def clone(self):
1300
 
        """
1301
 
        >>> orig = ScratchBranch(files=["file1", "file2"])
1302
 
        >>> clone = orig.clone()
1303
 
        >>> os.path.samefile(orig.base, clone.base)
1304
 
        False
1305
 
        >>> os.path.isfile(os.path.join(clone.base, "file1"))
1306
 
        True
1307
 
        """
1308
 
        from shutil import copytree
1309
 
        from tempfile import mkdtemp
1310
 
        base = mkdtemp()
1311
 
        os.rmdir(base)
1312
 
        copytree(self.base, base, symlinks=True)
1313
 
        return ScratchBranch(base=base)
1314
 
        
1315
802
    def __del__(self):
1316
803
        self.destroy()
1317
804
 
1318
805
    def destroy(self):
1319
806
        """Destroy the test branch, removing the scratch directory."""
1320
 
        from shutil import rmtree
1321
807
        try:
1322
808
            if self.base:
1323
809
                mutter("delete ScratchBranch %s" % self.base)
1324
 
                rmtree(self.base)
 
810
                shutil.rmtree(self.base)
1325
811
        except OSError, e:
1326
812
            # Work around for shutil.rmtree failing on Windows when
1327
813
            # readonly files are encountered
1329
815
            for root, dirs, files in os.walk(self.base, topdown=False):
1330
816
                for name in files:
1331
817
                    os.chmod(os.path.join(root, name), 0700)
1332
 
            rmtree(self.base)
 
818
            shutil.rmtree(self.base)
1333
819
        self.base = None
1334
820
 
1335
821
    
1360
846
    cope with just randomness because running uuidgen every time is
1361
847
    slow."""
1362
848
    import re
1363
 
    from binascii import hexlify
1364
 
    from time import time
1365
849
 
1366
850
    # get last component
1367
851
    idx = name.rfind('/')
1379
863
    name = re.sub(r'[^\w.]', '', name)
1380
864
 
1381
865
    s = hexlify(rand_bytes(8))
1382
 
    return '-'.join((name, compact_date(time()), s))
1383
 
 
1384
 
 
1385
 
def gen_root_id():
1386
 
    """Return a new tree-root file id."""
1387
 
    return gen_file_id('TREE_ROOT')
1388
 
 
 
866
    return '-'.join((name, compact_date(time.time()), s))