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

  • Committer: Breezy landing bot
  • Author(s): Gustav Hartvigsson
  • Date: 2021-01-10 18:46:30 UTC
  • mfrom: (7526.1.1 brz-removed-api-doc)
  • mto: This revision was merged to the branch mainline in revision 7532.
  • Revision ID: breezy.the.bot@gmail.com-20210110184630-dxu0g9dqq020uiw6
Drop documentation for removed API API.

Merged from https://code.launchpad.net/~gustav-hartvigsson/brz/removed-api-doc/+merge/396033

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/branch.py
41
41
    lock,
42
42
    repository as _mod_repository,
43
43
    revision,
44
 
    tag,
45
44
    trace,
46
45
    transport,
47
46
    urlutils,
50
49
from ..revision import (
51
50
    NULL_REVISION,
52
51
    )
 
52
from ..tag import (
 
53
    Tags,
 
54
    InterTags,
 
55
    )
53
56
from ..trace import (
54
57
    is_quiet,
55
58
    mutter,
56
59
    warning,
57
60
    )
58
61
 
59
 
from .config import (
60
 
    GitBranchConfig,
61
 
    GitBranchStack,
62
 
    )
63
62
from .errors import (
64
63
    NoPushSupport,
65
64
    )
 
65
from .mapping import (
 
66
    encode_git_path,
 
67
    decode_git_path,
 
68
    )
66
69
from .push import (
67
70
    remote_divergence,
68
71
    )
111
114
        return self._lookup_revno(self.new_revid)
112
115
 
113
116
 
114
 
class GitTags(tag.BasicTags):
115
 
    """Ref-based tag dictionary."""
116
 
 
117
 
    def __init__(self, branch):
118
 
        self.branch = branch
119
 
        self.repository = branch.repository
120
 
 
121
 
    def _merge_to_remote_git(self, target_repo, source_tag_refs,
122
 
                             overwrite=False):
 
117
class InterTagsFromGitToRemoteGit(InterTags):
 
118
 
 
119
    @classmethod
 
120
    def is_compatible(klass, source, target):
 
121
        if not isinstance(source, GitTags):
 
122
            return False
 
123
        if not isinstance(target, GitTags):
 
124
            return False
 
125
        if getattr(target.branch.repository, "_git", None) is not None:
 
126
            return False
 
127
        return True
 
128
 
 
129
    def merge(self, overwrite=False, ignore_master=False, selector=None):
 
130
        if self.source.branch.repository.has_same_location(self.target.branch.repository):
 
131
            return {}, []
123
132
        updates = {}
124
133
        conflicts = []
 
134
        source_tag_refs = self.source.branch.get_tag_refs()
 
135
        ref_to_tag_map = {}
125
136
 
126
137
        def get_changed_refs(old_refs):
127
138
            ret = dict(old_refs)
128
139
            for ref_name, tag_name, peeled, unpeeled in (
129
140
                    source_tag_refs.iteritems()):
 
141
                if selector and not selector(tag_name):
 
142
                    continue
130
143
                if old_refs.get(ref_name) == unpeeled:
131
144
                    pass
132
145
                elif overwrite or ref_name not in old_refs:
133
146
                    ret[ref_name] = unpeeled
134
 
                    updates[tag_name] = target_repo.lookup_foreign_revision_id(
 
147
                    updates[tag_name] = self.target.branch.repository.lookup_foreign_revision_id(
135
148
                        peeled)
 
149
                    ref_to_tag_map[ref_name] = tag_name
 
150
                    self.target.branch._tag_refs = None
136
151
                else:
137
152
                    conflicts.append(
138
153
                        (tag_name,
139
154
                         self.repository.lookup_foreign_revision_id(peeled),
140
 
                         target_repo.lookup_foreign_revision_id(
 
155
                         self.target.branch.repository.lookup_foreign_revision_id(
141
156
                             old_refs[ref_name])))
142
157
            return ret
143
 
        target_repo.controldir.send_pack(
 
158
        result = self.target.branch.repository.controldir.send_pack(
144
159
            get_changed_refs, lambda have, want: [])
145
 
        return updates, conflicts
146
 
 
147
 
    def _merge_to_local_git(self, target_repo, source_tag_refs,
148
 
                            overwrite=False):
 
160
        if result is not None and not isinstance(result, dict):
 
161
            for ref, error in result.ref_status.items():
 
162
                if error:
 
163
                    warning('unable to update ref %s: %s',
 
164
                            ref, error)
 
165
                    del updates[ref_to_tag_map[ref]]
 
166
        return updates, set(conflicts)
 
167
 
 
168
 
 
169
class InterTagsFromGitToLocalGit(InterTags):
 
170
 
 
171
    @classmethod
 
172
    def is_compatible(klass, source, target):
 
173
        if not isinstance(source, GitTags):
 
174
            return False
 
175
        if not isinstance(target, GitTags):
 
176
            return False
 
177
        if getattr(target.branch.repository, "_git", None) is None:
 
178
            return False
 
179
        return True
 
180
 
 
181
    def merge(self, overwrite=False, ignore_master=False, selector=None):
 
182
        if self.source.branch.repository.has_same_location(self.target.branch.repository):
 
183
            return {}, []
 
184
 
149
185
        conflicts = []
150
186
        updates = {}
 
187
        source_tag_refs = self.source.branch.get_tag_refs()
 
188
 
 
189
        target_repo = self.target.branch.repository
 
190
 
151
191
        for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
 
192
            if selector and not selector(tag_name):
 
193
                continue
152
194
            if target_repo._git.refs.get(ref_name) == unpeeled:
153
195
                pass
154
196
            elif overwrite or ref_name not in target_repo._git.refs:
164
206
                                  tag_name)
165
207
                    continue
166
208
                target_repo._git.refs[ref_name] = unpeeled or peeled
 
209
                self.target.branch._tag_refs = None
167
210
            else:
168
211
                try:
169
 
                    source_revid = self.repository.lookup_foreign_revision_id(
 
212
                    source_revid = self.source.branch.repository.lookup_foreign_revision_id(
170
213
                        peeled)
171
214
                    target_revid = target_repo.lookup_foreign_revision_id(
172
215
                        target_repo._git.refs[ref_name])
179
222
                                  tag_name)
180
223
                    continue
181
224
                conflicts.append((tag_name, source_revid, target_revid))
182
 
        return updates, conflicts
183
 
 
184
 
    def _merge_to_git(self, to_tags, source_tag_refs, overwrite=False):
185
 
        target_repo = to_tags.repository
186
 
        if self.repository.has_same_location(target_repo):
187
 
            return {}, []
188
 
        try:
189
 
            if getattr(target_repo, "_git", None):
190
 
                return self._merge_to_local_git(
191
 
                    target_repo, source_tag_refs, overwrite)
192
 
            else:
193
 
                return self._merge_to_remote_git(
194
 
                    target_repo, source_tag_refs, overwrite)
195
 
        finally:
196
 
            to_tags.branch._tag_refs = None
197
 
 
198
 
    def _merge_to_non_git(self, to_tags, source_tag_refs, overwrite=False):
 
225
        return updates, set(conflicts)
 
226
 
 
227
 
 
228
class InterTagsFromGitToNonGit(InterTags):
 
229
 
 
230
    @classmethod
 
231
    def is_compatible(klass, source, target):
 
232
        if not isinstance(source, GitTags):
 
233
            return False
 
234
        if isinstance(target, GitTags):
 
235
            return False
 
236
        return True
 
237
 
 
238
    def merge(self, overwrite=False, ignore_master=False, selector=None):
 
239
        """See Tags.merge_to."""
 
240
        source_tag_refs = self.source.branch.get_tag_refs()
 
241
        if ignore_master:
 
242
            master = None
 
243
        else:
 
244
            master = self.target.branch.get_master_branch()
 
245
        with contextlib.ExitStack() as es:
 
246
            if master is not None:
 
247
                es.enter_context(master.lock_write())
 
248
            updates, conflicts = self._merge_to(
 
249
                self.target, source_tag_refs, overwrite=overwrite,
 
250
                selector=selector)
 
251
            if master is not None:
 
252
                extra_updates, extra_conflicts = self._merge_to(
 
253
                    master.tags, overwrite=overwrite,
 
254
                    source_tag_refs=source_tag_refs,
 
255
                    ignore_master=ignore_master, selector=selector)
 
256
                updates.update(extra_updates)
 
257
                conflicts.update(extra_conflicts)
 
258
            return updates, conflicts
 
259
 
 
260
    def _merge_to(self, to_tags, source_tag_refs, overwrite=False,
 
261
                  selector=None):
199
262
        unpeeled_map = defaultdict(set)
200
263
        conflicts = []
201
264
        updates = {}
202
265
        result = dict(to_tags.get_tag_dict())
203
266
        for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
 
267
            if selector and not selector(tag_name):
 
268
                continue
204
269
            if unpeeled is not None:
205
270
                unpeeled_map[peeled].add(unpeeled)
206
271
            try:
207
 
                bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
 
272
                bzr_revid = self.source.branch.lookup_foreign_revision_id(peeled)
208
273
            except NotCommitError:
209
274
                continue
210
275
            if result.get(tag_name) == bzr_revid:
219
284
            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
220
285
            map_file.update(unpeeled_map)
221
286
            map_file.save_in_repository(to_tags.branch.repository)
222
 
        return updates, conflicts
223
 
 
224
 
    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
225
 
                 source_tag_refs=None):
226
 
        """See Tags.merge_to."""
227
 
        if source_tag_refs is None:
228
 
            source_tag_refs = self.branch.get_tag_refs()
229
 
        if self == to_tags:
230
 
            return {}, []
231
 
        if isinstance(to_tags, GitTags):
232
 
            return self._merge_to_git(to_tags, source_tag_refs,
233
 
                                      overwrite=overwrite)
234
 
        else:
235
 
            if ignore_master:
236
 
                master = None
237
 
            else:
238
 
                master = to_tags.branch.get_master_branch()
239
 
            with contextlib.ExitStack() as es:
240
 
                if master is not None:
241
 
                    es.enter_context(master.lock_write())
242
 
                updates, conflicts = self._merge_to_non_git(
243
 
                    to_tags, source_tag_refs, overwrite=overwrite)
244
 
                if master is not None:
245
 
                    extra_updates, extra_conflicts = self.merge_to(
246
 
                        master.tags, overwrite=overwrite,
247
 
                        source_tag_refs=source_tag_refs,
248
 
                        ignore_master=ignore_master)
249
 
                    updates.update(extra_updates)
250
 
                    conflicts += extra_conflicts
251
 
                return updates, conflicts
 
287
        return updates, set(conflicts)
 
288
 
 
289
 
 
290
InterTags.register_optimiser(InterTagsFromGitToRemoteGit)
 
291
InterTags.register_optimiser(InterTagsFromGitToLocalGit)
 
292
InterTags.register_optimiser(InterTagsFromGitToNonGit)
 
293
 
 
294
 
 
295
class GitTags(Tags):
 
296
    """Ref-based tag dictionary."""
 
297
 
 
298
    def __init__(self, branch):
 
299
        self.branch = branch
 
300
        self.repository = branch.repository
252
301
 
253
302
    def get_tag_dict(self):
254
303
        ret = {}
262
311
                ret[tag_name] = bzr_revid
263
312
        return ret
264
313
 
 
314
    def lookup_tag(self, tag_name):
 
315
        """Return the referent string of a tag"""
 
316
        # TODO(jelmer): Replace with something more efficient for local tags.
 
317
        td = self.get_tag_dict()
 
318
        try:
 
319
            return td[tag_name]
 
320
        except KeyError:
 
321
            raise errors.NoSuchTag(tag_name)
 
322
 
265
323
 
266
324
class LocalGitTagDict(GitTags):
267
325
    """Dictionary with tags in a local repository."""
424
482
        return "git"
425
483
 
426
484
    def get_config(self):
 
485
        from .config import GitBranchConfig
427
486
        return GitBranchConfig(self)
428
487
 
429
488
    def get_config_stack(self):
 
489
        from .config import GitBranchStack
430
490
        return GitBranchStack(self)
431
491
 
432
492
    def _get_nick(self, local=False, possible_master_transports=None):
438
498
            cs = self.repository._git.get_config_stack()
439
499
            try:
440
500
                return cs.get((b"branch", self.name.encode('utf-8')),
441
 
                              b"nick").decode("utf-8")
 
501
                        b"nick").decode("utf-8")
442
502
            except KeyError:
443
503
                pass
444
504
        return self.name or u"HEAD"
612
672
                return revision.NULL_REVISION
613
673
            return self.lookup_foreign_revision_id(self.head)
614
674
 
615
 
    def _basic_push(self, target, overwrite=False, stop_revision=None):
 
675
    def _basic_push(self, target, overwrite=False, stop_revision=None,
 
676
                    tag_selector=None):
616
677
        return branch.InterBranch.get(self, target)._basic_push(
617
 
            overwrite, stop_revision)
 
678
            overwrite, stop_revision, tag_selector=tag_selector)
618
679
 
619
680
    def lookup_foreign_revision_id(self, foreign_revid):
620
681
        try:
934
995
            stop_revision, fetch_tags=fetch_tags, limit=limit, lossy=lossy)
935
996
        return _mod_repository.FetchResult()
936
997
 
937
 
    def fetch_objects(self, stop_revision, fetch_tags, limit=None, lossy=False):
 
998
    def fetch_objects(self, stop_revision, fetch_tags, limit=None, lossy=False, tag_selector=None):
938
999
        interrepo = self._get_interrepo(self.source, self.target)
939
1000
        if fetch_tags is None:
940
1001
            c = self.source.get_config_stack()
952
1013
            else:
953
1014
                self._last_revid = stop_revision
954
1015
            real = interrepo.get_determine_wants_revids(
955
 
                [self._last_revid], include_tags=fetch_tags)
 
1016
                [self._last_revid], include_tags=fetch_tags, tag_selector=tag_selector)
956
1017
            return real(heads)
957
1018
        pack_hint, head, refs = interrepo.fetch_objects(
958
1019
            determine_wants, self.source.mapping, limit=limit,
962
1023
            self.target.repository.pack(hint=pack_hint)
963
1024
        return head, refs
964
1025
 
965
 
    def _update_revisions(self, stop_revision=None, overwrite=False):
966
 
        head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
 
1026
    def _update_revisions(self, stop_revision=None, overwrite=False, tag_selector=None):
 
1027
        head, refs = self.fetch_objects(stop_revision, fetch_tags=None, tag_selector=tag_selector)
967
1028
        if overwrite:
968
1029
            prev_last_revid = None
969
1030
        else:
982
1043
                for path, url, section in parse_submodules(
983
1044
                        GitConfigFile.from_file(f)):
984
1045
                    self.target.set_reference_info(
985
 
                        tree.path2id(path.decode('utf-8')), url.decode('utf-8'),
986
 
                        path.decode('utf-8'))
 
1046
                        tree.path2id(decode_git_path(path)), url.decode('utf-8'),
 
1047
                        decode_git_path(path))
987
1048
        except errors.NoSuchFile:
988
1049
            pass
989
1050
 
990
1051
    def _basic_pull(self, stop_revision, overwrite, run_hooks,
991
 
                    _override_hook_target, _hook_master):
 
1052
                    _override_hook_target, _hook_master, tag_selector=None):
992
1053
        if overwrite is True:
993
1054
            overwrite = set(["history", "tags"])
994
1055
        elif not overwrite:
1005
1066
            (result.old_revno, result.old_revid) = \
1006
1067
                self.target.last_revision_info()
1007
1068
            result.new_git_head, remote_refs = self._update_revisions(
1008
 
                stop_revision, overwrite=("history" in overwrite))
 
1069
                stop_revision, overwrite=("history" in overwrite),
 
1070
                tag_selector=tag_selector)
1009
1071
            tags_ret = self.source.tags.merge_to(
1010
1072
                self.target.tags, ("tags" in overwrite), ignore_master=True)
1011
1073
            if isinstance(tags_ret, tuple):
1028
1090
 
1029
1091
    def pull(self, overwrite=False, stop_revision=None,
1030
1092
             possible_transports=None, _hook_master=None, run_hooks=True,
1031
 
             _override_hook_target=None, local=False):
 
1093
             _override_hook_target=None, local=False, tag_selector=None):
1032
1094
        """See Branch.pull.
1033
1095
 
1034
1096
        :param _hook_master: Private parameter - set the branch to
1066
1128
                master_branch = None
1067
1129
            return self._basic_pull(stop_revision, overwrite, run_hooks,
1068
1130
                                    _override_hook_target,
1069
 
                                    _hook_master=master_branch)
 
1131
                                    _hook_master=master_branch,
 
1132
                                    tag_selector=tag_selector)
1070
1133
 
1071
 
    def _basic_push(self, overwrite, stop_revision):
 
1134
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1072
1135
        if overwrite is True:
1073
1136
            overwrite = set(["history", "tags"])
1074
1137
        elif not overwrite:
1078
1141
        result.target_branch = self.target
1079
1142
        result.old_revno, result.old_revid = self.target.last_revision_info()
1080
1143
        result.new_git_head, remote_refs = self._update_revisions(
1081
 
            stop_revision, overwrite=("history" in overwrite))
 
1144
            stop_revision, overwrite=("history" in overwrite),
 
1145
            tag_selector=tag_selector)
1082
1146
        tags_ret = self.source.tags.merge_to(
1083
 
            self.target.tags, "tags" in overwrite, ignore_master=True)
 
1147
            self.target.tags, "tags" in overwrite, ignore_master=True,
 
1148
            selector=tag_selector)
1084
1149
        (result.tag_updates, result.tag_conflicts) = tags_ret
1085
1150
        result.new_revno, result.new_revid = self.target.last_revision_info()
1086
1151
        self.update_references(revid=result.new_revid)
1109
1174
        return (isinstance(source, LocalGitBranch) and
1110
1175
                isinstance(target, RemoteGitBranch))
1111
1176
 
1112
 
    def _basic_push(self, overwrite, stop_revision):
 
1177
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
 
1178
        from .remote import parse_git_error
1113
1179
        result = GitBranchPushResult()
1114
1180
        result.source_branch = self.source
1115
1181
        result.target_branch = self.target
1134
1200
            result.new_revid = stop_revision
1135
1201
            for name, sha in (
1136
1202
                    self.source.repository._git.refs.as_dict(b"refs/tags").items()):
 
1203
                if tag_selector and not tag_selector(name):
 
1204
                    continue
1137
1205
                if sha not in self.source.repository._git:
1138
1206
                    trace.mutter('Ignoring missing SHA: %s', sha)
1139
1207
                    continue
1140
1208
                refs[tag_name_to_ref(name)] = sha
1141
1209
            return refs
1142
 
        self.target.repository.send_pack(
 
1210
        dw_result = self.target.repository.send_pack(
1143
1211
            get_changed_refs,
1144
 
            self.source.repository._git.object_store.generate_pack_data)
 
1212
            self.source.repository._git.generate_pack_data)
 
1213
        if dw_result is not None and not isinstance(dw_result, dict):
 
1214
            error = dw_result.ref_status.get(self.target.ref)
 
1215
            if error:
 
1216
                raise parse_git_error(self.target.user_url, error)
 
1217
            for ref, error in dw_result.ref_status.items():
 
1218
                if error:
 
1219
                    trace.warning('unable to open ref %s: %s', ref, error)
1145
1220
        return result
1146
1221
 
1147
1222
 
1173
1248
        interrepo.fetch_objects(determine_wants, limit=limit, lossy=lossy)
1174
1249
        return _mod_repository.FetchResult()
1175
1250
 
1176
 
    def _basic_push(self, overwrite=False, stop_revision=None):
 
1251
    def _basic_push(self, overwrite=False, stop_revision=None, tag_selector=None):
1177
1252
        if overwrite is True:
1178
1253
            overwrite = set(["history", "tags"])
1179
1254
        elif not overwrite:
1189
1264
            other_branch=self.source)
1190
1265
        tags_ret = self.source.tags.merge_to(
1191
1266
            self.target.tags,
1192
 
            source_tag_refs=remote_refs_dict_to_tag_refs(refs),
1193
 
            overwrite=("tags" in overwrite))
 
1267
            overwrite=("tags" in overwrite),
 
1268
            selector=tag_selector)
1194
1269
        if isinstance(tags_ret, tuple):
1195
1270
            (result.tag_updates, result.tag_conflicts) = tags_ret
1196
1271
        else:
1218
1293
        return result.refs, stop_revision
1219
1294
 
1220
1295
    def pull(self, stop_revision=None, overwrite=False,
1221
 
             possible_transports=None, run_hooks=True, local=False):
 
1296
             possible_transports=None, run_hooks=True, local=False,
 
1297
             tag_selector=None):
1222
1298
        # This type of branch can't be bound.
1223
1299
        if local:
1224
1300
            raise errors.LocalRequiresBoundBranch()
1239
1315
                other_branch=self.source)
1240
1316
            tags_ret = self.source.tags.merge_to(
1241
1317
                self.target.tags, overwrite=("tags" in overwrite),
1242
 
                source_tag_refs=remote_refs_dict_to_tag_refs(refs))
 
1318
                selector=tag_selector)
1243
1319
            if isinstance(tags_ret, tuple):
1244
1320
                (result.tag_updates, result.tag_conflicts) = tags_ret
1245
1321
            else:
1307
1383
                    refs[ref] = (None, revid)
1308
1384
        return refs, main_ref, (stop_revno, stop_revision)
1309
1385
 
1310
 
    def _update_refs(self, result, old_refs, new_refs, overwrite):
 
1386
    def _update_refs(self, result, old_refs, new_refs, overwrite, tag_selector):
1311
1387
        mutter("updating refs. old refs: %r, new refs: %r",
1312
1388
               old_refs, new_refs)
1313
1389
        result.tag_updates = {}
1314
1390
        result.tag_conflicts = []
1315
 
        ret = dict(old_refs)
 
1391
        ret = {}
1316
1392
 
1317
1393
        def ref_equals(refs, ref, git_sha, revid):
1318
1394
            try:
1346
1422
                except ValueError:
1347
1423
                    pass
1348
1424
                else:
 
1425
                    if tag_selector and not tag_selector(tag_name):
 
1426
                        continue
1349
1427
                    result.tag_updates[tag_name] = revid
1350
1428
                ret[ref] = (git_sha, revid)
1351
1429
            else:
1373
1451
                ret.append((None, v))
1374
1452
        ret.append((None, stop_revision))
1375
1453
        try:
1376
 
            revidmap = self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
 
1454
            revidmap = self.interrepo.fetch_revs(ret, lossy=lossy, limit=limit)
1377
1455
        except NoPushSupport:
1378
1456
            raise errors.NoRoundtrippingSupport(self.source, self.target)
1379
1457
        return _mod_repository.FetchResult(revidmap={
1381
1459
            for (old_revid, (new_sha, new_revid)) in revidmap.items()})
1382
1460
 
1383
1461
    def pull(self, overwrite=False, stop_revision=None, local=False,
1384
 
             possible_transports=None, run_hooks=True, _stop_revno=None):
 
1462
             possible_transports=None, run_hooks=True, _stop_revno=None,
 
1463
             tag_selector=None):
1385
1464
        result = GitBranchPullResult()
1386
1465
        result.source_branch = self.source
1387
1466
        result.target_branch = self.target
1390
1469
                stop_revision, stop_revno=_stop_revno)
1391
1470
 
1392
1471
            def update_refs(old_refs):
1393
 
                return self._update_refs(result, old_refs, new_refs, overwrite)
 
1472
                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1394
1473
            try:
1395
1474
                result.revidmap, old_refs, new_refs = (
1396
1475
                    self.interrepo.fetch_refs(update_refs, lossy=False))
1410
1489
        return result
1411
1490
 
1412
1491
    def push(self, overwrite=False, stop_revision=None, lossy=False,
1413
 
             _override_hook_source_branch=None, _stop_revno=None):
 
1492
             _override_hook_source_branch=None, _stop_revno=None,
 
1493
             tag_selector=None):
1414
1494
        result = GitBranchPushResult()
1415
1495
        result.source_branch = self.source
1416
1496
        result.target_branch = self.target
1421
1501
                stop_revision, stop_revno=_stop_revno)
1422
1502
 
1423
1503
            def update_refs(old_refs):
1424
 
                return self._update_refs(result, old_refs, new_refs, overwrite)
 
1504
                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1425
1505
            try:
1426
1506
                result.revidmap, old_refs, new_refs = (
1427
1507
                    self.interrepo.fetch_refs(