/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 branch.py

https://launchpad.net/bugs/675231
Don't peel tags automatically when pushing back.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branch.py
17
17
 
18
18
"""An adapter between a Git Branch and a Bazaar Branch"""
19
19
 
 
20
from collections import defaultdict
 
21
 
20
22
from dulwich.objects import (
21
23
    Commit,
22
24
    Tag,
56
58
    ref_to_branch_name,
57
59
    ref_to_tag_name,
58
60
    tag_name_to_ref,
 
61
    UnpeelMap,
59
62
    )
60
63
 
61
64
from bzrlib.foreign import ForeignBranch
85
88
        self.branch = branch
86
89
        self.repository = branch.repository
87
90
 
 
91
    def _iter_tag_refs(self, refs):
 
92
        raise NotImplementedError(self._iter_tag_refs)
 
93
 
 
94
    def _merge_to_git(self, to_tags, refs, overwrite=False):
 
95
        target_repo = to_tags.repository
 
96
        conflicts = []
 
97
        for k, v in refs.iteritems():
 
98
            if not is_tag(k):
 
99
                continue
 
100
            if overwrite or not k in self.target.repository.refs:
 
101
                target_repo.refs[k] = v
 
102
            elif target_repo.repository.refs[k] == v:
 
103
                pass
 
104
            else:
 
105
                conflicts.append((ref_to_tag_name(k), v, target_repo.refs[k]))
 
106
        return conflicts
 
107
 
 
108
    def _merge_to_non_git(self, to_tags, refs, overwrite=False):
 
109
        unpeeled_map = defaultdict(set)
 
110
        conflicts = []
 
111
        result = dict(to_tags.get_tag_dict())
 
112
        for n, peeled, unpeeled, bzr_revid in self._iter_tag_refs(refs):
 
113
            if unpeeled is not None:
 
114
                unpeeled_map[peeled].add(unpeeled)
 
115
            if n not in result or overwrite:
 
116
                result[n] = bzr_revid
 
117
            elif result[n] == bzr_revid:
 
118
                pass
 
119
            else:
 
120
                conflicts.append((n, result[n], bzr_revid))
 
121
        to_tags._set_tag_dict(result)
 
122
        if len(unpeeled_map) > 0:
 
123
            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
 
124
            map_file.update(unpeeled_map)
 
125
            map_file.save_in_repository(to_tags.branch.repository)
 
126
        return conflicts
 
127
 
 
128
    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
 
129
                 source_refs=None):
 
130
        if source_refs is None:
 
131
            source_refs = self.repository.get_refs()
 
132
        if self == to_tags:
 
133
            return
 
134
        if isinstance(to_tags, GitTags):
 
135
            return self._merge_to_git(to_tags, source_refs,
 
136
                                      overwrite=overwrite)
 
137
        else:
 
138
            if ignore_master:
 
139
                master = None
 
140
            else:
 
141
                master = to_tags.branch.get_master_branch()
 
142
            conflicts = self._merge_to_non_git(to_tags, source_refs,
 
143
                                              overwrite=overwrite)
 
144
            if master is not None:
 
145
                conflicts += self.merge_to(to_tags, overwrite=overwrite,
 
146
                                           source_refs=source_refs,
 
147
                                           ignore_master=ignore_master)
 
148
            return conflicts
 
149
 
 
150
    def get_tag_dict(self):
 
151
        ret = {}
 
152
        refs = self.repository.get_refs()
 
153
        for (name, peeled, unpeeled, bzr_revid) in self._iter_tag_refs(refs):
 
154
            ret[name] = bzr_revid
 
155
        return ret
 
156
 
88
157
 
89
158
class LocalGitTagDict(GitTags):
90
159
    """Dictionary with tags in a local repository."""
93
162
        super(LocalGitTagDict, self).__init__(branch)
94
163
        self.refs = self.repository._git.refs
95
164
 
96
 
    def get_tag_dict(self):
97
 
        ret = {}
98
 
        refs = self.repository._git.get_refs()
 
165
    def _iter_tag_refs(self, refs):
 
166
        """Iterate over the tag refs.
 
167
 
 
168
        :param refs: Refs dictionary (name -> git sha1)
 
169
        :return: iterator over (name, peeled_sha1, unpeeled_sha1, bzr_revid)
 
170
        """
99
171
        for k, (peeled, unpeeled) in extract_tags(refs).iteritems():
100
172
            try:
101
173
                obj = self.repository._git[peeled]
112
184
                mutter("Tag %s points at object %r that is not a commit, "
113
185
                       "ignoring", k, obj)
114
186
                continue
115
 
            ret[k] = self.branch.lookup_foreign_revision_id(peeled)
116
 
        return ret
 
187
            yield (k, peeled, unpeeled,
 
188
                   self.branch.lookup_foreign_revision_id(peeled))
 
189
 
117
190
 
118
191
    def _set_tag_dict(self, to_dict):
119
192
        extra = set(self.repository._git.get_refs().keys())
625
698
        result.old_revid = self.target.last_revision()
626
699
        refs, stop_revision = self.update_refs(stop_revision)
627
700
        self.target.generate_revision_history(stop_revision, result.old_revid)
628
 
        result.tag_conflicts = self.update_tags(refs, overwrite=overwrite)
 
701
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
702
            source_refs=refs, overwrite=overwrite)
629
703
        result.new_revid = self.target.last_revision()
630
704
        return result
631
705
 
632
 
    def update_tags(self, refs, overwrite=False):
633
 
        conflicts = []
634
 
        for k, v in refs.iteritems():
635
 
            if not is_tag(k):
636
 
                continue
637
 
            if overwrite or not k in self.target.repository.refs:
638
 
                self.target.repository.refs[k] = v
639
 
            elif self.target.repository.refs[k] == v:
640
 
                pass
641
 
            else:
642
 
                conflicts.append((ref_to_tag_name(k), v, self.target.repository.refs[k]))
643
 
        return conflicts
644
 
 
645
706
    def update_refs(self, stop_revision=None):
646
707
        interrepo = repository.InterRepository.get(self.source.repository,
647
708
            self.target.repository)
663
724
        result.old_revid = self.target.last_revision()
664
725
        refs, stop_revision = self.update_refs(stop_revision)
665
726
        self.target.generate_revision_history(stop_revision, result.old_revid)
666
 
        result.tag_conflicts = self.update_tags(refs)
 
727
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
728
            overwrite=overwrite, source_refs=refs)
667
729
        result.new_revid = self.target.last_revision()
668
730
        return result
669
731