~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: aaron.bentley at utoronto
  • Date: 2005-08-26 01:50:01 UTC
  • mto: (974.1.47)
  • mto: This revision was merged to the branch mainline in revision 1178.
  • Revision ID: aaron.bentley@utoronto.ca-20050826015001-d8b6e6330cb6401a
Merged from bzr.24

Show diffs side-by-side

added added

removed removed

Lines of Context:
829
829
        >>> br2.revision_history()
830
830
        [u'REVISION-ID-1']
831
831
        >>> br2.update_revisions(br1)
832
 
        Added 0 texts.
833
 
        Added 0 inventories.
834
832
        Added 0 revisions.
835
833
        >>> br1.text_store.total_size() == br2.text_store.total_size()
836
834
        True
837
835
        """
 
836
        from bzrlib.fetch import greedy_fetch
838
837
        pb = ProgressBar()
839
838
        pb.update('comparing histories')
840
839
        revision_ids = self.missing_revisions(other, stop_revision)
841
 
        count = self.install_revisions(other, revision_ids, pb=pb)
 
840
        if len(revision_ids) > 0:
 
841
            count = greedy_fetch(self, other, revision_ids[-1], pb)[0]
 
842
        else:
 
843
            count = 0
842
844
        self.append_revision(*revision_ids)
843
845
        print "Added %d revisions." % count
844
846
                    
855
857
        revisions = []
856
858
        needed_texts = set()
857
859
        i = 0
858
 
        for rev_id in revision_ids:
859
 
            i += 1
860
 
            pb.update('fetching revision', i, len(revision_ids))
861
 
            rev = other.get_revision(rev_id)
 
860
        failures = set()
 
861
        for i, rev_id in enumerate(revision_ids):
 
862
            pb.update('fetching revision', i+1, len(revision_ids))
 
863
            try:
 
864
                rev = other.get_revision(rev_id)
 
865
            except bzrlib.errors.NoSuchRevision:
 
866
                failures.add(rev_id)
 
867
                continue
862
868
            revisions.append(rev)
863
869
            inv = other.get_inventory(str(rev.inventory_id))
864
870
            for key, entry in inv.iter_entries():
869
875
 
870
876
        pb.clear()
871
877
                    
872
 
        count = self.text_store.copy_multi(other.text_store, needed_texts)
 
878
        count, cp_fail = self.text_store.copy_multi(other.text_store, 
 
879
                                                    needed_texts)
873
880
        print "Added %d texts." % count 
874
881
        inventory_ids = [ f.inventory_id for f in revisions ]
875
 
        count = self.inventory_store.copy_multi(other.inventory_store, 
876
 
                                                inventory_ids)
 
882
        count, cp_fail = self.inventory_store.copy_multi(other.inventory_store, 
 
883
                                                         inventory_ids)
877
884
        print "Added %d inventories." % count 
878
885
        revision_ids = [ f.revision_id for f in revisions]
879
 
        count = self.revision_store.copy_multi(other.revision_store, 
880
 
                                               revision_ids)
881
 
        return count
 
886
        count, cp_fail = self.revision_store.copy_multi(other.revision_store, 
 
887
                                                          revision_ids,
 
888
                                                          permit_failure=True)
 
889
        assert len(cp_fail) == 0 
 
890
        return count, failures
882
891
       
883
892
    def commit(self, *args, **kw):
884
893
        from bzrlib.commit import commit
887
896
 
888
897
    def lookup_revision(self, revision):
889
898
        """Return the revision identifier for a given revision information."""
890
 
        revno, info = self.get_revision_info(revision)
 
899
        revno, info = self._get_revision_info(revision)
891
900
        return info
892
901
 
893
902
    def get_revision_info(self, revision):
898
907
        revision can also be a string, in which case it is parsed for something like
899
908
            'date:' or 'revid:' etc.
900
909
        """
 
910
        revno, rev_id = self._get_revision_info(revision)
 
911
        if revno is None:
 
912
            raise bzrlib.errors.NoSuchRevision(self, revision)
 
913
        return revno, rev_id
 
914
 
 
915
    def get_rev_id(self, revno, history=None):
 
916
        """Find the revision id of the specified revno."""
 
917
        if revno == 0:
 
918
            return None
 
919
        if history is None:
 
920
            history = self.revision_history()
 
921
        elif revno <= 0 or revno > len(history):
 
922
            raise bzrlib.errors.NoSuchRevision(self, revno)
 
923
        return history[revno - 1]
 
924
 
 
925
    def _get_revision_info(self, revision):
 
926
        """Return (revno, revision id) for revision specifier.
 
927
 
 
928
        revision can be an integer, in which case it is assumed to be revno
 
929
        (though this will translate negative values into positive ones)
 
930
        revision can also be a string, in which case it is parsed for something
 
931
        like 'date:' or 'revid:' etc.
 
932
 
 
933
        A revid is always returned.  If it is None, the specifier referred to
 
934
        the null revision.  If the revid does not occur in the revision
 
935
        history, revno will be None.
 
936
        """
 
937
        
901
938
        if revision is None:
902
939
            return 0, None
903
940
        revno = None
907
944
            pass
908
945
        revs = self.revision_history()
909
946
        if isinstance(revision, int):
910
 
            if revision == 0:
911
 
                return 0, None
912
 
            # Mabye we should do this first, but we don't need it if revision == 0
913
947
            if revision < 0:
914
948
                revno = len(revs) + revision + 1
915
949
            else:
916
950
                revno = revision
 
951
            rev_id = self.get_rev_id(revno, revs)
917
952
        elif isinstance(revision, basestring):
918
953
            for prefix, func in Branch.REVISION_NAMESPACES.iteritems():
919
954
                if revision.startswith(prefix):
920
 
                    revno = func(self, revs, revision)
 
955
                    result = func(self, revs, revision)
 
956
                    if len(result) > 1:
 
957
                        revno, rev_id = result
 
958
                    else:
 
959
                        revno = result[0]
 
960
                        rev_id = self.get_rev_id(revno, revs)
921
961
                    break
922
962
            else:
923
 
                raise BzrError('No namespace registered for string: %r' % revision)
 
963
                raise BzrError('No namespace registered for string: %r' %
 
964
                               revision)
 
965
        else:
 
966
            raise TypeError('Unhandled revision type %s' % revision)
924
967
 
925
 
        if revno is None or revno <= 0 or revno > len(revs):
926
 
            raise BzrError("no such revision %s" % revision)
927
 
        return revno, revs[revno-1]
 
968
        if revno is None:
 
969
            if rev_id is None:
 
970
                raise bzrlib.errors.NoSuchRevision(self, revision)
 
971
        return revno, rev_id
928
972
 
929
973
    def _namespace_revno(self, revs, revision):
930
974
        """Lookup a revision by revision number"""
931
975
        assert revision.startswith('revno:')
932
976
        try:
933
 
            return int(revision[6:])
 
977
            return (int(revision[6:]),)
934
978
        except ValueError:
935
979
            return None
936
980
    REVISION_NAMESPACES['revno:'] = _namespace_revno
937
981
 
938
982
    def _namespace_revid(self, revs, revision):
939
983
        assert revision.startswith('revid:')
 
984
        rev_id = revision[len('revid:'):]
940
985
        try:
941
 
            return revs.index(revision[6:]) + 1
 
986
            return revs.index(rev_id) + 1, rev_id
942
987
        except ValueError:
943
 
            return None
 
988
            return None, rev_id
944
989
    REVISION_NAMESPACES['revid:'] = _namespace_revid
945
990
 
946
991
    def _namespace_last(self, revs, revision):
948
993
        try:
949
994
            offset = int(revision[5:])
950
995
        except ValueError:
951
 
            return None
 
996
            return (None,)
952
997
        else:
953
998
            if offset <= 0:
954
999
                raise BzrError('You must supply a positive value for --revision last:XXX')
955
 
            return len(revs) - offset + 1
 
1000
            return (len(revs) - offset + 1,)
956
1001
    REVISION_NAMESPACES['last:'] = _namespace_last
957
1002
 
958
1003
    def _namespace_tag(self, revs, revision):
1033
1078
                # TODO: Handle timezone.
1034
1079
                dt = datetime.datetime.fromtimestamp(r.timestamp)
1035
1080
                if first >= dt and (last is None or dt >= last):
1036
 
                    return i+1
 
1081
                    return (i+1,)
1037
1082
        else:
1038
1083
            for i in range(len(revs)):
1039
1084
                r = self.get_revision(revs[i])
1040
1085
                # TODO: Handle timezone.
1041
1086
                dt = datetime.datetime.fromtimestamp(r.timestamp)
1042
1087
                if first <= dt and (last is None or dt <= last):
1043
 
                    return i+1
 
1088
                    return (i+1,)
1044
1089
    REVISION_NAMESPACES['date:'] = _namespace_date
1045
1090
 
1046
1091
    def revision_tree(self, revision_id):