/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: Jelmer Vernooij
  • Date: 2020-02-18 03:11:01 UTC
  • mto: (7490.3.4 work)
  • mto: This revision was merged to the branch mainline in revision 7495.
  • Revision ID: jelmer@jelmer.uk-20200218031101-trloo2n5k2n01q9r
Plumb through tag_selector.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/branch.py
667
667
                return revision.NULL_REVISION
668
668
            return self.lookup_foreign_revision_id(self.head)
669
669
 
670
 
    def _basic_push(self, target, overwrite=False, stop_revision=None):
 
670
    def _basic_push(self, target, overwrite=False, stop_revision=None, tag_selector=None):
671
671
        return branch.InterBranch.get(self, target)._basic_push(
672
 
            overwrite, stop_revision)
 
672
            overwrite, stop_revision, tag_selector=tag_selector)
673
673
 
674
674
    def lookup_foreign_revision_id(self, foreign_revid):
675
675
        try:
1043
1043
            pass
1044
1044
 
1045
1045
    def _basic_pull(self, stop_revision, overwrite, run_hooks,
1046
 
                    _override_hook_target, _hook_master):
 
1046
                    _override_hook_target, _hook_master, tag_selector=None):
1047
1047
        if overwrite is True:
1048
1048
            overwrite = set(["history", "tags"])
1049
1049
        elif not overwrite:
1062
1062
            result.new_git_head, remote_refs = self._update_revisions(
1063
1063
                stop_revision, overwrite=("history" in overwrite))
1064
1064
            tags_ret = self.source.tags.merge_to(
1065
 
                self.target.tags, ("tags" in overwrite), ignore_master=True)
 
1065
                self.target.tags, ("tags" in overwrite), ignore_master=True,
 
1066
                selector=tag_selector)
1066
1067
            if isinstance(tags_ret, tuple):
1067
1068
                result.tag_updates, result.tag_conflicts = tags_ret
1068
1069
            else:
1083
1084
 
1084
1085
    def pull(self, overwrite=False, stop_revision=None,
1085
1086
             possible_transports=None, _hook_master=None, run_hooks=True,
1086
 
             _override_hook_target=None, local=False):
 
1087
             _override_hook_target=None, local=False, tag_selector=None):
1087
1088
        """See Branch.pull.
1088
1089
 
1089
1090
        :param _hook_master: Private parameter - set the branch to
1116
1117
                es.enter_context(master_branch.lock_write())
1117
1118
                # pull from source into master.
1118
1119
                master_branch.pull(self.source, overwrite, stop_revision,
1119
 
                                   run_hooks=False)
 
1120
                                   run_hooks=False, tag_selector=tag_selector)
1120
1121
            else:
1121
1122
                master_branch = None
1122
1123
            return self._basic_pull(stop_revision, overwrite, run_hooks,
1123
1124
                                    _override_hook_target,
1124
 
                                    _hook_master=master_branch)
 
1125
                                    _hook_master=master_branch,
 
1126
                                    tag_selector=tag_selector)
1125
1127
 
1126
 
    def _basic_push(self, overwrite, stop_revision):
 
1128
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1127
1129
        if overwrite is True:
1128
1130
            overwrite = set(["history", "tags"])
1129
1131
        elif not overwrite:
1135
1137
        result.new_git_head, remote_refs = self._update_revisions(
1136
1138
            stop_revision, overwrite=("history" in overwrite))
1137
1139
        tags_ret = self.source.tags.merge_to(
1138
 
            self.target.tags, "tags" in overwrite, ignore_master=True)
 
1140
            self.target.tags, "tags" in overwrite, ignore_master=True,
 
1141
            selector=tag_selector)
1139
1142
        (result.tag_updates, result.tag_conflicts) = tags_ret
1140
1143
        result.new_revno, result.new_revid = self.target.last_revision_info()
1141
1144
        self.update_references(revid=result.new_revid)
1164
1167
        return (isinstance(source, LocalGitBranch) and
1165
1168
                isinstance(target, RemoteGitBranch))
1166
1169
 
1167
 
    def _basic_push(self, overwrite, stop_revision):
 
1170
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
1168
1171
        result = GitBranchPushResult()
1169
1172
        result.source_branch = self.source
1170
1173
        result.target_branch = self.target
1189
1192
            result.new_revid = stop_revision
1190
1193
            for name, sha in viewitems(
1191
1194
                    self.source.repository._git.refs.as_dict(b"refs/tags")):
 
1195
                tag_name = tag_name_to_ref(name)
 
1196
                if tag_selector and not tag_selector(tag_name):
 
1197
                    continue
1192
1198
                if sha not in self.source.repository._git:
1193
1199
                    trace.mutter('Ignoring missing SHA: %s', sha)
1194
1200
                    continue
1195
 
                refs[tag_name_to_ref(name)] = sha
 
1201
                refs[tag_name] = sha
1196
1202
            return refs
1197
1203
        self.target.repository.send_pack(
1198
1204
            get_changed_refs,
1228
1234
        interrepo.fetch_objects(determine_wants, limit=limit, lossy=lossy)
1229
1235
        return _mod_repository.FetchResult()
1230
1236
 
1231
 
    def _basic_push(self, overwrite=False, stop_revision=None):
 
1237
    def _basic_push(self, overwrite=False, stop_revision=None, tag_selector=None):
1232
1238
        if overwrite is True:
1233
1239
            overwrite = set(["history", "tags"])
1234
1240
        elif not overwrite:
1244
1250
            other_branch=self.source)
1245
1251
        tags_ret = self.source.tags.merge_to(
1246
1252
            self.target.tags,
1247
 
            overwrite=("tags" in overwrite))
 
1253
            overwrite=("tags" in overwrite),
 
1254
            selector=tag_selector)
1248
1255
        if isinstance(tags_ret, tuple):
1249
1256
            (result.tag_updates, result.tag_conflicts) = tags_ret
1250
1257
        else:
1272
1279
        return result.refs, stop_revision
1273
1280
 
1274
1281
    def pull(self, stop_revision=None, overwrite=False,
1275
 
             possible_transports=None, run_hooks=True, local=False):
 
1282
             possible_transports=None, run_hooks=True, local=False,
 
1283
             tag_selector=None):
1276
1284
        # This type of branch can't be bound.
1277
1285
        if local:
1278
1286
            raise errors.LocalRequiresBoundBranch()
1292
1300
                (result.old_revid if ("history" not in overwrite) else None),
1293
1301
                other_branch=self.source)
1294
1302
            tags_ret = self.source.tags.merge_to(
1295
 
                self.target.tags, overwrite=("tags" in overwrite))
 
1303
                self.target.tags, overwrite=("tags" in overwrite),
 
1304
                selector=tag_selector)
1296
1305
            if isinstance(tags_ret, tuple):
1297
1306
                (result.tag_updates, result.tag_conflicts) = tags_ret
1298
1307
            else:
1331
1340
                isinstance(target, GitBranch))
1332
1341
 
1333
1342
    def _get_new_refs(self, stop_revision=None, fetch_tags=None,
1334
 
                      stop_revno=None):
 
1343
                      stop_revno=None, tag_selector=None):
1335
1344
        if not self.source.is_locked():
1336
1345
            raise errors.ObjectNotLocked(self.source)
1337
1346
        if stop_revision is None:
1349
1358
            c = self.source.get_config_stack()
1350
1359
            fetch_tags = c.get('branch.fetch_tags')
1351
1360
        for name, revid in viewitems(self.source.tags.get_tag_dict()):
 
1361
            if tag_selector and not tag_selector(name):
 
1362
                continue
1352
1363
            if self.source.repository.has_revision(revid):
1353
1364
                ref = tag_name_to_ref(name)
1354
1365
                if not check_ref_format(ref):
1360
1371
                    refs[ref] = (None, revid)
1361
1372
        return refs, main_ref, (stop_revno, stop_revision)
1362
1373
 
1363
 
    def _update_refs(self, result, old_refs, new_refs, overwrite):
 
1374
    def _update_refs(self, result, old_refs, new_refs, overwrite, tag_selector):
1364
1375
        mutter("updating refs. old refs: %r, new refs: %r",
1365
1376
               old_refs, new_refs)
1366
1377
        result.tag_updates = {}
1399
1410
                except ValueError:
1400
1411
                    pass
1401
1412
                else:
 
1413
                    if tag_selector and not tag_selector(tag_name):
 
1414
                        continue
1402
1415
                    result.tag_updates[tag_name] = revid
1403
1416
                ret[ref] = (git_sha, revid)
1404
1417
            else:
1434
1447
            for (old_revid, (new_sha, new_revid)) in revidmap.items()})
1435
1448
 
1436
1449
    def pull(self, overwrite=False, stop_revision=None, local=False,
1437
 
             possible_transports=None, run_hooks=True, _stop_revno=None):
 
1450
             possible_transports=None, run_hooks=True, _stop_revno=None,
 
1451
             tag_selector=None):
1438
1452
        result = GitBranchPullResult()
1439
1453
        result.source_branch = self.source
1440
1454
        result.target_branch = self.target
1443
1457
                stop_revision, stop_revno=_stop_revno)
1444
1458
 
1445
1459
            def update_refs(old_refs):
1446
 
                return self._update_refs(result, old_refs, new_refs, overwrite)
 
1460
                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1447
1461
            try:
1448
1462
                result.revidmap, old_refs, new_refs = (
1449
 
                    self.interrepo.fetch_refs(update_refs, lossy=False))
 
1463
                    self.interrepo.fetch_refs(update_refs, lossy=False, overwrite=overwrite))
1450
1464
            except NoPushSupport:
1451
1465
                raise errors.NoRoundtrippingSupport(self.source, self.target)
1452
1466
            (old_sha1, result.old_revid) = old_refs.get(
1463
1477
        return result
1464
1478
 
1465
1479
    def push(self, overwrite=False, stop_revision=None, lossy=False,
1466
 
             _override_hook_source_branch=None, _stop_revno=None):
 
1480
             _override_hook_source_branch=None, _stop_revno=None,
 
1481
             tag_selector=None):
1467
1482
        result = GitBranchPushResult()
1468
1483
        result.source_branch = self.source
1469
1484
        result.target_branch = self.target
1471
1486
        result.master_branch = result.target_branch
1472
1487
        with self.source.lock_read(), self.target.lock_write():
1473
1488
            new_refs, main_ref, stop_revinfo = self._get_new_refs(
1474
 
                stop_revision, stop_revno=_stop_revno)
 
1489
                stop_revision, stop_revno=_stop_revno, tag_selector=tag_selector)
1475
1490
 
1476
1491
            def update_refs(old_refs):
1477
 
                return self._update_refs(result, old_refs, new_refs, overwrite)
 
1492
                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
1478
1493
            try:
1479
1494
                result.revidmap, old_refs, new_refs = (
1480
1495
                    self.interrepo.fetch_refs(