/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): Jelmer Vernooij
  • Date: 2020-07-28 02:47:10 UTC
  • mfrom: (7519.1.1 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200728024710-a2ylds219f1lsl62
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/388173

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/branch.py
17
17
 
18
18
"""An adapter between a Git Branch and a Bazaar Branch"""
19
19
 
20
 
from __future__ import absolute_import
21
20
 
 
21
import contextlib
22
22
from io import BytesIO
23
23
from collections import defaultdict
24
24
 
35
35
 
36
36
from .. import (
37
37
    branch,
38
 
    cleanup,
39
38
    config,
40
39
    controldir,
41
40
    errors,
50
49
from ..revision import (
51
50
    NULL_REVISION,
52
51
    )
53
 
from ..sixish import (
54
 
    text_type,
55
 
    viewitems,
56
 
    )
57
52
from ..tag import (
58
53
    Tags,
59
54
    InterTags,
64
59
    warning,
65
60
    )
66
61
 
67
 
from .config import (
68
 
    GitBranchConfig,
69
 
    GitBranchStack,
70
 
    )
71
62
from .errors import (
72
63
    NoPushSupport,
73
64
    )
 
65
from .mapping import (
 
66
    encode_git_path,
 
67
    decode_git_path,
 
68
    )
74
69
from .push import (
75
70
    remote_divergence,
76
71
    )
137
132
        updates = {}
138
133
        conflicts = []
139
134
        source_tag_refs = self.source.branch.get_tag_refs()
 
135
        ref_to_tag_map = {}
140
136
 
141
137
        def get_changed_refs(old_refs):
142
138
            ret = dict(old_refs)
150
146
                    ret[ref_name] = unpeeled
151
147
                    updates[tag_name] = self.target.branch.repository.lookup_foreign_revision_id(
152
148
                        peeled)
 
149
                    ref_to_tag_map[ref_name] = tag_name
153
150
                    self.target.branch._tag_refs = None
154
151
                else:
155
152
                    conflicts.append(
158
155
                         self.target.branch.repository.lookup_foreign_revision_id(
159
156
                             old_refs[ref_name])))
160
157
            return ret
161
 
        self.target.branch.repository.controldir.send_pack(
 
158
        result = self.target.branch.repository.controldir.send_pack(
162
159
            get_changed_refs, lambda have, want: [])
 
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]]
163
166
        return updates, set(conflicts)
164
167
 
165
168
 
239
242
            master = None
240
243
        else:
241
244
            master = self.target.branch.get_master_branch()
242
 
        with cleanup.ExitStack() as es:
 
245
        with contextlib.ExitStack() as es:
243
246
            if master is not None:
244
247
                es.enter_context(master.lock_write())
245
248
            updates, conflicts = self._merge_to(
327
330
 
328
331
    def _set_tag_dict(self, to_dict):
329
332
        extra = set(self.refs.allkeys())
330
 
        for k, revid in viewitems(to_dict):
 
333
        for k, revid in to_dict.items():
331
334
            name = tag_name_to_ref(k)
332
335
            if name in extra:
333
336
                extra.remove(name)
479
482
        return "git"
480
483
 
481
484
    def get_config(self):
 
485
        from .config import GitBranchConfig
482
486
        return GitBranchConfig(self)
483
487
 
484
488
    def get_config_stack(self):
 
489
        from .config import GitBranchStack
485
490
        return GitBranchStack(self)
486
491
 
487
492
    def _get_nick(self, local=False, possible_master_transports=None):
493
498
            cs = self.repository._git.get_config_stack()
494
499
            try:
495
500
                return cs.get((b"branch", self.name.encode('utf-8')),
496
 
                              b"nick").decode("utf-8")
 
501
                        b"nick").decode("utf-8")
497
502
            except KeyError:
498
503
                pass
499
504
        return self.name or u"HEAD"
849
854
        :return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
850
855
        """
851
856
        refs = self.repository.controldir.get_refs_container()
852
 
        for ref_name, unpeeled in viewitems(refs.as_dict()):
 
857
        for ref_name, unpeeled in refs.as_dict().items():
853
858
            try:
854
859
                tag_name = ref_to_tag_name(ref_name)
855
860
            except (ValueError, UnicodeDecodeError):
857
862
            peeled = refs.get_peeled(ref_name)
858
863
            if peeled is None:
859
864
                peeled = unpeeled
860
 
            if not isinstance(tag_name, text_type):
 
865
            if not isinstance(tag_name, str):
861
866
                raise TypeError(tag_name)
862
867
            yield (ref_name, tag_name, peeled, unpeeled)
863
868
 
1038
1043
                for path, url, section in parse_submodules(
1039
1044
                        GitConfigFile.from_file(f)):
1040
1045
                    self.target.set_reference_info(
1041
 
                        tree.path2id(path.decode('utf-8')), url.decode('utf-8'),
1042
 
                        path.decode('utf-8'))
 
1046
                        tree.path2id(decode_git_path(path)), url.decode('utf-8'),
 
1047
                        decode_git_path(path))
1043
1048
        except errors.NoSuchFile:
1044
1049
            pass
1045
1050
 
1101
1106
        if local and not bound_location:
1102
1107
            raise errors.LocalRequiresBoundBranch()
1103
1108
        source_is_master = False
1104
 
        with cleanup.ExitStack() as es:
 
1109
        with contextlib.ExitStack() as es:
1105
1110
            es.enter_context(self.source.lock_read())
1106
1111
            if bound_location:
1107
1112
                # bound_location comes from a config file, some care has to be
1170
1175
                isinstance(target, RemoteGitBranch))
1171
1176
 
1172
1177
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
 
1178
        from .remote import parse_git_error
1173
1179
        result = GitBranchPushResult()
1174
1180
        result.source_branch = self.source
1175
1181
        result.target_branch = self.target
1192
1198
                    raise errors.DivergedBranches(self.source, self.target)
1193
1199
            refs = {self.target.ref: new_ref}
1194
1200
            result.new_revid = stop_revision
1195
 
            for name, sha in viewitems(
1196
 
                    self.source.repository._git.refs.as_dict(b"refs/tags")):
 
1201
            for name, sha in (
 
1202
                    self.source.repository._git.refs.as_dict(b"refs/tags").items()):
1197
1203
                if tag_selector and not tag_selector(name):
1198
1204
                    continue
1199
1205
                if sha not in self.source.repository._git:
1201
1207
                    continue
1202
1208
                refs[tag_name_to_ref(name)] = sha
1203
1209
            return refs
1204
 
        self.target.repository.send_pack(
 
1210
        dw_result = self.target.repository.send_pack(
1205
1211
            get_changed_refs,
1206
 
            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)
1207
1220
        return result
1208
1221
 
1209
1222
 
1358
1371
        if fetch_tags is None:
1359
1372
            c = self.source.get_config_stack()
1360
1373
            fetch_tags = c.get('branch.fetch_tags')
1361
 
        for name, revid in viewitems(self.source.tags.get_tag_dict()):
 
1374
        for name, revid in self.source.tags.get_tag_dict().items():
1362
1375
            if self.source.repository.has_revision(revid):
1363
1376
                ref = tag_name_to_ref(name)
1364
1377
                if not check_ref_format(ref):
1375
1388
               old_refs, new_refs)
1376
1389
        result.tag_updates = {}
1377
1390
        result.tag_conflicts = []
1378
 
        ret = dict(old_refs)
 
1391
        ret = {}
1379
1392
 
1380
1393
        def ref_equals(refs, ref, git_sha, revid):
1381
1394
            try:
1395
1408
            # updated that hasn't actually been updated.
1396
1409
            return False
1397
1410
        # FIXME: Check for diverged branches
1398
 
        for ref, (git_sha, revid) in viewitems(new_refs):
 
1411
        for ref, (git_sha, revid) in new_refs.items():
1399
1412
            if ref_equals(ret, ref, git_sha, revid):
1400
1413
                # Already up to date
1401
1414
                if git_sha is None:
1434
1447
            stop_revision = self.source.last_revision()
1435
1448
        ret = []
1436
1449
        if fetch_tags:
1437
 
            for k, v in viewitems(self.source.tags.get_tag_dict()):
 
1450
            for k, v in self.source.tags.get_tag_dict().items():
1438
1451
                ret.append((None, v))
1439
1452
        ret.append((None, stop_revision))
1440
1453
        try: