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

Merge test-run support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/git/branch.py
22
22
from io import BytesIO
23
23
from collections import defaultdict
24
24
 
25
 
from dulwich.config import (
26
 
    ConfigFile as GitConfigFile,
27
 
    parse_submodules,
28
 
    )
29
 
 
30
25
from dulwich.objects import (
31
26
    NotCommitError,
32
27
    ZERO_SHA,
33
28
    )
34
29
from dulwich.repo import check_ref_format
35
30
 
36
 
from .. import (
 
31
from ... import (
37
32
    branch,
38
 
    cleanup,
39
33
    config,
40
34
    controldir,
41
35
    errors,
42
36
    lock,
43
37
    repository as _mod_repository,
44
38
    revision,
 
39
    tag,
45
40
    trace,
46
41
    transport,
47
42
    urlutils,
48
43
    )
49
 
from ..foreign import ForeignBranch
50
 
from ..revision import (
 
44
from ...revision import (
51
45
    NULL_REVISION,
52
46
    )
53
 
from ..sixish import (
54
 
    text_type,
55
 
    viewitems,
56
 
    )
57
 
from ..tag import (
58
 
    Tags,
59
 
    InterTags,
60
 
    )
61
 
from ..trace import (
 
47
from ...sixish import text_type
 
48
from ...trace import (
62
49
    is_quiet,
63
50
    mutter,
64
51
    warning,
70
57
    )
71
58
from .errors import (
72
59
    NoPushSupport,
 
60
    NoSuchRef,
73
61
    )
74
62
from .push import (
75
63
    remote_divergence,
85
73
from .unpeel_map import (
86
74
    UnpeelMap,
87
75
    )
88
 
from .urls import (
89
 
    git_url_to_bzr_url,
90
 
    bzr_url_to_git_url,
91
 
    )
92
 
 
93
 
 
94
 
def _calculate_revnos(branch):
95
 
    if branch._format.stores_revno():
96
 
        return True
97
 
    config = branch.get_config_stack()
98
 
    return config.get('calculate_revnos')
 
76
from .urls import git_url_to_bzr_url
 
77
 
 
78
from ...foreign import ForeignBranch
99
79
 
100
80
 
101
81
class GitPullResult(branch.PullResult):
102
82
    """Result of a pull from a Git branch."""
103
83
 
104
84
    def _lookup_revno(self, revid):
105
 
        if not isinstance(revid, bytes):
 
85
        if type(revid) is not str:
106
86
            raise TypeError(revid)
107
 
        if not _calculate_revnos(self.target_branch):
108
 
            return None
109
87
        # Try in source branch first, it'll be faster
110
88
        with self.target_branch.lock_read():
111
89
            return self.target_branch.revision_id_to_revno(revid)
119
97
        return self._lookup_revno(self.new_revid)
120
98
 
121
99
 
122
 
class InterTagsFromGitToRemoteGit(InterTags):
123
 
 
124
 
    @classmethod
125
 
    def is_compatible(klass, source, target):
126
 
        if not isinstance(source, GitTags):
127
 
            return False
128
 
        if not isinstance(target, GitTags):
129
 
            return False
130
 
        if getattr(target.branch.repository, "_git", None) is not None:
131
 
            return False
132
 
        return True
133
 
 
134
 
    def merge(self, overwrite=False, ignore_master=False, selector=None):
135
 
        if self.source.branch.repository.has_same_location(self.target.branch.repository):
136
 
            return {}, []
 
100
class GitTags(tag.BasicTags):
 
101
    """Ref-based tag dictionary."""
 
102
 
 
103
    def __init__(self, branch):
 
104
        self.branch = branch
 
105
        self.repository = branch.repository
 
106
 
 
107
    def _merge_to_remote_git(self, target_repo, source_tag_refs, overwrite=False):
137
108
        updates = {}
138
109
        conflicts = []
139
 
        source_tag_refs = self.source.branch.get_tag_refs()
140
 
 
141
110
        def get_changed_refs(old_refs):
142
111
            ret = dict(old_refs)
143
 
            for ref_name, tag_name, peeled, unpeeled in (
144
 
                    source_tag_refs.iteritems()):
145
 
                if selector and not selector(tag_name):
146
 
                    continue
 
112
            for ref_name, tag_name, peeled, unpeeled in source_tag_refs.iteritems():
147
113
                if old_refs.get(ref_name) == unpeeled:
148
114
                    pass
149
 
                elif overwrite or ref_name not in old_refs:
 
115
                elif overwrite or not ref_name in old_refs:
150
116
                    ret[ref_name] = unpeeled
151
 
                    updates[tag_name] = self.target.branch.repository.lookup_foreign_revision_id(
152
 
                        peeled)
153
 
                    self.target.branch._tag_refs = None
 
117
                    updates[tag_name] = target_repo.lookup_foreign_revision_id(peeled)
154
118
                else:
155
119
                    conflicts.append(
156
120
                        (tag_name,
157
 
                         self.repository.lookup_foreign_revision_id(peeled),
158
 
                         self.target.branch.repository.lookup_foreign_revision_id(
159
 
                             old_refs[ref_name])))
 
121
                        self.repository.lookup_foreign_revision_id(peeled),
 
122
                        target_repo.lookup_foreign_revision_id(old_refs[ref_name])))
160
123
            return ret
161
 
        self.target.branch.repository.controldir.send_pack(
162
 
            get_changed_refs, lambda have, want: [])
163
 
        return updates, set(conflicts)
164
 
 
165
 
 
166
 
class InterTagsFromGitToLocalGit(InterTags):
167
 
 
168
 
    @classmethod
169
 
    def is_compatible(klass, source, target):
170
 
        if not isinstance(source, GitTags):
171
 
            return False
172
 
        if not isinstance(target, GitTags):
173
 
            return False
174
 
        if getattr(target.branch.repository, "_git", None) is None:
175
 
            return False
176
 
        return True
177
 
 
178
 
    def merge(self, overwrite=False, ignore_master=False, selector=None):
179
 
        if self.source.branch.repository.has_same_location(self.target.branch.repository):
180
 
            return {}, []
181
 
 
 
124
        target_repo.controldir.send_pack(get_changed_refs, lambda have, want: [])
 
125
        return updates, conflicts
 
126
 
 
127
    def _merge_to_local_git(self, target_repo, source_tag_refs, overwrite=False):
182
128
        conflicts = []
183
129
        updates = {}
184
 
        source_tag_refs = self.source.branch.get_tag_refs()
185
 
 
186
 
        target_repo = self.target.branch.repository
187
 
 
188
130
        for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
189
 
            if selector and not selector(tag_name):
190
 
                continue
191
131
            if target_repo._git.refs.get(ref_name) == unpeeled:
192
132
                pass
193
 
            elif overwrite or ref_name not in target_repo._git.refs:
194
 
                try:
195
 
                    updates[tag_name] = (
196
 
                        target_repo.lookup_foreign_revision_id(peeled))
197
 
                except KeyError:
198
 
                    trace.warning('%s does not point to a valid object',
199
 
                                  tag_name)
200
 
                    continue
201
 
                except NotCommitError:
202
 
                    trace.warning('%s points to a non-commit object',
203
 
                                  tag_name)
204
 
                    continue
 
133
            elif overwrite or not ref_name in target_repo._git.refs:
205
134
                target_repo._git.refs[ref_name] = unpeeled or peeled
206
 
                self.target.branch._tag_refs = None
 
135
                updates[tag_name] = self.repository.lookup_foreign_revision_id(peeled)
207
136
            else:
 
137
                source_revid = self.repository.lookup_foreign_revision_id(peeled)
208
138
                try:
209
 
                    source_revid = self.source.branch.repository.lookup_foreign_revision_id(
210
 
                        peeled)
211
139
                    target_revid = target_repo.lookup_foreign_revision_id(
212
 
                        target_repo._git.refs[ref_name])
 
140
                            target_repo._git.refs[ref_name])
213
141
                except KeyError:
214
142
                    trace.warning('%s does not point to a valid object',
215
143
                                  ref_name)
216
144
                    continue
217
 
                except NotCommitError:
218
 
                    trace.warning('%s points to a non-commit object',
219
 
                                  tag_name)
220
 
                    continue
221
145
                conflicts.append((tag_name, source_revid, target_revid))
222
 
        return updates, set(conflicts)
223
 
 
224
 
 
225
 
class InterTagsFromGitToNonGit(InterTags):
226
 
 
227
 
    @classmethod
228
 
    def is_compatible(klass, source, target):
229
 
        if not isinstance(source, GitTags):
230
 
            return False
231
 
        if isinstance(target, GitTags):
232
 
            return False
233
 
        return True
234
 
 
235
 
    def merge(self, overwrite=False, ignore_master=False, selector=None):
236
 
        """See Tags.merge_to."""
237
 
        source_tag_refs = self.source.branch.get_tag_refs()
238
 
        if ignore_master:
239
 
            master = None
240
 
        else:
241
 
            master = self.target.branch.get_master_branch()
242
 
        with cleanup.ExitStack() as es:
243
 
            if master is not None:
244
 
                es.enter_context(master.lock_write())
245
 
            updates, conflicts = self._merge_to(
246
 
                self.target, source_tag_refs, overwrite=overwrite,
247
 
                selector=selector)
248
 
            if master is not None:
249
 
                extra_updates, extra_conflicts = self._merge_to(
250
 
                    master.tags, overwrite=overwrite,
251
 
                    source_tag_refs=source_tag_refs,
252
 
                    ignore_master=ignore_master, selector=selector)
253
 
                updates.update(extra_updates)
254
 
                conflicts.update(extra_conflicts)
255
 
            return updates, conflicts
256
 
 
257
 
    def _merge_to(self, to_tags, source_tag_refs, overwrite=False,
258
 
                  selector=None):
 
146
        return updates, conflicts
 
147
 
 
148
    def _merge_to_git(self, to_tags, source_tag_refs, overwrite=False):
 
149
        target_repo = to_tags.repository
 
150
        if self.repository.has_same_location(target_repo):
 
151
            return {}, []
 
152
        try:
 
153
            if getattr(target_repo, "_git", None):
 
154
                return self._merge_to_local_git(target_repo, source_tag_refs, overwrite)
 
155
            else:
 
156
                return self._merge_to_remote_git(target_repo, source_tag_refs, overwrite)
 
157
        finally:
 
158
            to_tags.branch._tag_refs = None
 
159
 
 
160
    def _merge_to_non_git(self, to_tags, source_tag_refs, overwrite=False):
259
161
        unpeeled_map = defaultdict(set)
260
162
        conflicts = []
261
163
        updates = {}
262
164
        result = dict(to_tags.get_tag_dict())
263
165
        for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
264
 
            if selector and not selector(tag_name):
265
 
                continue
266
166
            if unpeeled is not None:
267
167
                unpeeled_map[peeled].add(unpeeled)
268
168
            try:
269
 
                bzr_revid = self.source.branch.lookup_foreign_revision_id(peeled)
 
169
                bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
270
170
            except NotCommitError:
271
171
                continue
272
172
            if result.get(tag_name) == bzr_revid:
275
175
                result[tag_name] = bzr_revid
276
176
                updates[tag_name] = bzr_revid
277
177
            else:
278
 
                conflicts.append((tag_name, bzr_revid, result[tag_name]))
 
178
                conflicts.append((tag_name, bzr_revid, result[n]))
279
179
        to_tags._set_tag_dict(result)
280
180
        if len(unpeeled_map) > 0:
281
181
            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
282
182
            map_file.update(unpeeled_map)
283
183
            map_file.save_in_repository(to_tags.branch.repository)
284
 
        return updates, set(conflicts)
285
 
 
286
 
 
287
 
InterTags.register_optimiser(InterTagsFromGitToRemoteGit)
288
 
InterTags.register_optimiser(InterTagsFromGitToLocalGit)
289
 
InterTags.register_optimiser(InterTagsFromGitToNonGit)
290
 
 
291
 
 
292
 
class GitTags(Tags):
293
 
    """Ref-based tag dictionary."""
294
 
 
295
 
    def __init__(self, branch):
296
 
        self.branch = branch
297
 
        self.repository = branch.repository
 
184
        return updates, conflicts
 
185
 
 
186
    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
 
187
                 source_tag_refs=None):
 
188
        """See Tags.merge_to."""
 
189
        if source_tag_refs is None:
 
190
            source_tag_refs = self.branch.get_tag_refs()
 
191
        if self == to_tags:
 
192
            return {}, []
 
193
        if isinstance(to_tags, GitTags):
 
194
            return self._merge_to_git(to_tags, source_tag_refs,
 
195
                                      overwrite=overwrite)
 
196
        else:
 
197
            if ignore_master:
 
198
                master = None
 
199
            else:
 
200
                master = to_tags.branch.get_master_branch()
 
201
            if master is not None:
 
202
                master.lock_write()
 
203
            try:
 
204
                updates, conflicts = self._merge_to_non_git(to_tags, source_tag_refs,
 
205
                                                  overwrite=overwrite)
 
206
                if master is not None:
 
207
                    extra_updates, extra_conflicts = self.merge_to(
 
208
                        master.tags, overwrite=overwrite,
 
209
                                               source_tag_refs=source_tag_refs,
 
210
                                               ignore_master=ignore_master)
 
211
                    updates.update(extra_updates)
 
212
                    conflicts += extra_conflicts
 
213
                return updates, conflicts
 
214
            finally:
 
215
                if master is not None:
 
216
                    master.unlock()
298
217
 
299
218
    def get_tag_dict(self):
300
219
        ret = {}
301
 
        for (ref_name, tag_name, peeled, unpeeled) in (
302
 
                self.branch.get_tag_refs()):
 
220
        for (ref_name, tag_name, peeled, unpeeled) in self.branch.get_tag_refs():
303
221
            try:
304
222
                bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
305
223
            except NotCommitError:
308
226
                ret[tag_name] = bzr_revid
309
227
        return ret
310
228
 
311
 
    def lookup_tag(self, tag_name):
312
 
        """Return the referent string of a tag"""
313
 
        # TODO(jelmer): Replace with something more efficient for local tags.
314
 
        td = self.get_tag_dict()
315
 
        try:
316
 
            return td[tag_name]
317
 
        except KeyError:
318
 
            raise errors.NoSuchTag(tag_name)
319
 
 
320
229
 
321
230
class LocalGitTagDict(GitTags):
322
231
    """Dictionary with tags in a local repository."""
327
236
 
328
237
    def _set_tag_dict(self, to_dict):
329
238
        extra = set(self.refs.allkeys())
330
 
        for k, revid in viewitems(to_dict):
 
239
        for k, revid in to_dict.iteritems():
331
240
            name = tag_name_to_ref(k)
332
241
            if name in extra:
333
242
                extra.remove(name)
334
 
            try:
335
 
                self.set_tag(k, revid)
336
 
            except errors.GhostTagsNotSupported:
337
 
                pass
 
243
            self.set_tag(k, revid)
338
244
        for name in extra:
339
245
            if is_tag(name):
340
246
                del self.repository._git[name]
349
255
 
350
256
    def delete_tag(self, name):
351
257
        ref = tag_name_to_ref(name)
352
 
        if ref not in self.refs:
 
258
        if not ref in self.refs:
353
259
            raise errors.NoSuchTag(name)
354
260
        del self.refs[ref]
355
261
        self.branch._tag_refs = None
392
298
        raise NotImplementedError(self.initialize)
393
299
 
394
300
    def get_reference(self, controldir, name=None):
395
 
        return controldir.get_branch_reference(name=name)
 
301
        return controldir.get_branch_reference(name)
396
302
 
397
303
    def set_reference(self, controldir, name, target):
398
304
        return controldir.set_branch_reference(target, name)
399
305
 
400
 
    def stores_revno(self):
401
 
        """True if this branch format store revision numbers."""
402
 
        return False
403
 
 
404
 
    supports_reference_locations = False
405
 
 
406
306
 
407
307
class LocalGitBranchFormat(GitBranchFormat):
408
308
 
419
319
        from .dir import LocalGitDir
420
320
        if not isinstance(a_controldir, LocalGitDir):
421
321
            raise errors.IncompatibleFormat(self, a_controldir._format)
422
 
        return a_controldir.create_branch(
423
 
            repository=repository, name=name,
 
322
        return a_controldir.create_branch(repository=repository, name=name,
424
323
            append_revisions_only=append_revisions_only)
425
324
 
426
325
 
489
388
 
490
389
        :return: Branch nick
491
390
        """
492
 
        if getattr(self.repository, '_git', None):
493
 
            cs = self.repository._git.get_config_stack()
494
 
            try:
495
 
                return cs.get((b"branch", self.name.encode('utf-8')),
496
 
                              b"nick").decode("utf-8")
497
 
            except KeyError:
498
 
                pass
 
391
        cs = self.repository._git.get_config_stack()
 
392
        try:
 
393
            return cs.get((b"branch", self.name.encode('utf-8')), b"nick").decode("utf-8")
 
394
        except KeyError:
 
395
            pass
499
396
        return self.name or u"HEAD"
500
397
 
501
398
    def _set_nick(self, nick):
502
399
        cf = self.repository._git.get_config()
503
 
        cf.set((b"branch", self.name.encode('utf-8')),
504
 
               b"nick", nick.encode("utf-8"))
 
400
        cf.set((b"branch", self.name.encode('utf-8')), b"nick", nick.encode("utf-8"))
505
401
        f = BytesIO()
506
402
        cf.write_to_file(f)
507
403
        self.repository._git._put_named_file('config', f.getvalue())
510
406
 
511
407
    def __repr__(self):
512
408
        return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
513
 
                                 self.name)
 
409
            self.name)
514
410
 
515
 
    def generate_revision_history(self, revid, last_rev=None,
516
 
                                  other_branch=None):
 
411
    def generate_revision_history(self, revid, last_rev=None, other_branch=None):
517
412
        if last_rev is not None:
518
413
            graph = self.repository.get_graph()
519
414
            if not graph.is_ancestor(last_rev, revid):
546
441
        # Git doesn't do stacking (yet...)
547
442
        raise branch.UnstackableBranchFormat(self._format, self.base)
548
443
 
549
 
    def _get_push_origin(self, cs):
550
 
        """Get the name for the push origin.
551
 
 
552
 
        The exact behaviour is documented in the git-config(1) manpage.
553
 
        """
554
 
        try:
555
 
            return cs.get((b'branch', self.name.encode('utf-8')), b'pushRemote')
556
 
        except KeyError:
557
 
            try:
558
 
                return cs.get((b'branch', ), b'remote')
559
 
            except KeyError:
560
 
                try:
561
 
                    return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
562
 
                except KeyError:
563
 
                    return b'origin'
564
 
 
565
 
    def _get_origin(self, cs):
566
 
        try:
567
 
            return cs.get((b'branch', self.name.encode('utf-8')), b'remote')
568
 
        except KeyError:
569
 
            return b'origin'
570
 
 
571
 
    def _get_related_push_branch(self, cs):
572
 
        remote = self._get_push_origin(cs)
573
 
        try:
574
 
            location = cs.get((b"remote", remote), b"url")
575
 
        except KeyError:
576
 
            return None
577
 
 
578
 
        return git_url_to_bzr_url(location.decode('utf-8'), ref=self.ref)
579
 
 
580
 
    def _get_related_merge_branch(self, cs):
581
 
        remote = self._get_origin(cs)
582
 
        try:
583
 
            location = cs.get((b"remote", remote), b"url")
584
 
        except KeyError:
585
 
            return None
586
 
 
587
 
        try:
588
 
            ref = cs.get((b"branch", remote), b"merge")
589
 
        except KeyError:
590
 
            ref = self.ref
591
 
 
592
 
        return git_url_to_bzr_url(location.decode('utf-8'), ref=ref)
593
 
 
594
444
    def _get_parent_location(self):
595
445
        """See Branch.get_parent()."""
 
446
        # FIXME: Set "origin" url from .git/config ?
596
447
        cs = self.repository._git.get_config_stack()
597
 
        return self._get_related_merge_branch(cs)
598
 
 
599
 
    def _write_git_config(self, cs):
600
 
        f = BytesIO()
601
 
        cs.write_to_file(f)
602
 
        self.repository._git._put_named_file('config', f.getvalue())
 
448
        try:
 
449
            location = cs.get((b"remote", b'origin'), b"url")
 
450
        except KeyError:
 
451
            return None
 
452
 
 
453
        params = {}
 
454
        try:
 
455
            ref = cs.get((b"remote", b"origin"), b"merge")
 
456
        except KeyError:
 
457
            pass
 
458
        else:
 
459
            if ref != 'HEAD':
 
460
                try:
 
461
                    params['branch'] = ref_to_branch_name(ref).encode('utf-8')
 
462
                except ValueError:
 
463
                    params['ref'] = ref.encode('utf-8')
 
464
 
 
465
        url = git_url_to_bzr_url(location)
 
466
        return urlutils.join_segment_parameters(url, params)
603
467
 
604
468
    def set_parent(self, location):
 
469
        # FIXME: Set "origin" url in .git/config ?
605
470
        cs = self.repository._git.get_config()
606
 
        remote = self._get_origin(cs)
607
 
        this_url = urlutils.strip_segment_parameters(self.user_url)
608
 
        target_url, branch, ref = bzr_url_to_git_url(location)
 
471
        this_url = urlutils.split_segment_parameters(self.user_url)[0]
 
472
        target_url, target_params = urlutils.split_segment_parameters(location)
609
473
        location = urlutils.relative_url(this_url, target_url)
610
 
        cs.set((b"remote", remote), b"url", location)
611
 
        if branch:
612
 
            cs.set((b"branch", remote), b"merge", branch_name_to_ref(branch))
613
 
        elif ref:
614
 
            cs.set((b"branch", remote), b"merge", ref)
 
474
        cs.set((b"remote", b"origin"), b"url", location)
 
475
        if 'branch' in target_params:
 
476
            cs.set((b"remote", b"origin"), b"merge",
 
477
                   branch_name_to_ref(target_params['branch']))
 
478
        elif 'ref' in target_params:
 
479
            cs.set((b"remote", b"origin"), b"merge",
 
480
                   target_params['ref'])
615
481
        else:
616
482
            # TODO(jelmer): Maybe unset rather than setting to HEAD?
617
 
            cs.set((b"branch", remote), b"merge", b'HEAD')
618
 
        self._write_git_config(cs)
 
483
            cs.set((b"remote", b"origin"), b"merge", 'HEAD')
 
484
        f = BytesIO()
 
485
        cs.write_to_file(f)
 
486
        self.repository._git._put_named_file('config', f.getvalue())
619
487
 
620
488
    def break_lock(self):
621
489
        raise NotImplementedError(self.break_lock)
667
535
                return revision.NULL_REVISION
668
536
            return self.lookup_foreign_revision_id(self.head)
669
537
 
670
 
    def _basic_push(self, target, overwrite=False, stop_revision=None,
671
 
                    tag_selector=None):
 
538
    def _basic_push(self, target, overwrite=False, stop_revision=None):
672
539
        return branch.InterBranch.get(self, target)._basic_push(
673
 
            overwrite, stop_revision, tag_selector=tag_selector)
 
540
            overwrite, stop_revision)
674
541
 
675
542
    def lookup_foreign_revision_id(self, foreign_revid):
676
543
        try:
677
544
            return self.repository.lookup_foreign_revision_id(foreign_revid,
678
 
                                                              self.mapping)
 
545
                self.mapping)
679
546
        except KeyError:
680
547
            # Let's try..
681
548
            return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
705
572
                self._tag_refs = list(self._iter_tag_refs())
706
573
            return self._tag_refs
707
574
 
708
 
    def import_last_revision_info_and_tags(self, source, revno, revid,
709
 
                                           lossy=False):
710
 
        """Set the last revision info, importing from another repo if necessary.
711
 
 
712
 
        This is used by the bound branch code to upload a revision to
713
 
        the master branch first before updating the tip of the local branch.
714
 
        Revisions referenced by source's tags are also transferred.
715
 
 
716
 
        :param source: Source branch to optionally fetch from
717
 
        :param revno: Revision number of the new tip
718
 
        :param revid: Revision id of the new tip
719
 
        :param lossy: Whether to discard metadata that can not be
720
 
            natively represented
721
 
        :return: Tuple with the new revision number and revision id
722
 
            (should only be different from the arguments when lossy=True)
723
 
        """
724
 
        push_result = source.push(
725
 
            self, stop_revision=revid, lossy=lossy, _stop_revno=revno)
726
 
        return (push_result.new_revno, push_result.new_revid)
727
 
 
728
 
    def reconcile(self, thorough=True):
729
 
        """Make sure the data stored in this branch is consistent."""
730
 
        from ..reconcile import ReconcileResult
731
 
        # Nothing to do here
732
 
        return ReconcileResult()
733
 
 
734
575
 
735
576
class LocalGitBranch(GitBranch):
736
577
    """A local Git branch."""
737
578
 
738
579
    def __init__(self, controldir, repository, ref):
739
580
        super(LocalGitBranch, self).__init__(controldir, repository, ref,
740
 
                                             LocalGitBranchFormat())
 
581
                LocalGitBranchFormat())
741
582
 
742
583
    def create_checkout(self, to_location, revision_id=None, lightweight=False,
743
 
                        accelerator_tree=None, hardlink=False):
 
584
        accelerator_tree=None, hardlink=False):
744
585
        t = transport.get_transport(to_location)
745
586
        t.ensure_base()
746
587
        format = self._get_checkout_format(lightweight=lightweight)
749
590
            from_branch = checkout.set_branch_reference(target_branch=self)
750
591
        else:
751
592
            policy = checkout.determine_repository_policy()
752
 
            policy.acquire_repository()
 
593
            repo = policy.acquire_repository()[0]
 
594
 
753
595
            checkout_branch = checkout.create_branch()
754
596
            checkout_branch.bind(self)
755
597
            checkout_branch.pull(self, stop_revision=revision_id)
756
598
            from_branch = None
757
 
        return checkout.create_workingtree(
758
 
            revision_id, from_branch=from_branch, hardlink=hardlink)
 
599
        return checkout.create_workingtree(revision_id,
 
600
                from_branch=from_branch, hardlink=hardlink)
759
601
 
760
602
    def _lock_ref(self):
761
603
        self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
766
608
    def break_lock(self):
767
609
        self.repository._git.refs.unlock_ref(self.ref)
768
610
 
 
611
    def fetch(self, from_branch, last_revision=None, limit=None):
 
612
        return branch.InterBranch.get(from_branch, self).fetch(
 
613
            stop_revision=last_revision, limit=limit)
 
614
 
769
615
    def _gen_revision_history(self):
770
616
        if self.head is None:
771
617
            return []
772
618
        last_revid = self.last_revision()
773
619
        graph = self.repository.get_graph()
774
620
        try:
775
 
            ret = list(graph.iter_lefthand_ancestry(
776
 
                last_revid, (revision.NULL_REVISION, )))
 
621
            ret = list(graph.iter_lefthand_ancestry(last_revid,
 
622
                (revision.NULL_REVISION, )))
777
623
        except errors.RevisionNotPresent as e:
778
624
            raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
779
625
        ret.reverse()
788
634
    def _read_last_revision_info(self):
789
635
        last_revid = self.last_revision()
790
636
        graph = self.repository.get_graph()
791
 
        try:
792
 
            revno = graph.find_distance_to_null(
793
 
                last_revid, [(revision.NULL_REVISION, 0)])
794
 
        except errors.GhostRevisionsHaveNoRevno:
795
 
            revno = None
 
637
        revno = graph.find_distance_to_null(last_revid,
 
638
            [(revision.NULL_REVISION, 0)])
796
639
        return revno, last_revid
797
640
 
798
641
    def set_last_revision_info(self, revno, revision_id):
805
648
        if revid == NULL_REVISION:
806
649
            newhead = None
807
650
        else:
808
 
            (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(
809
 
                revid)
 
651
            (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
810
652
            if self.mapping is None:
811
653
                raise AssertionError
812
654
        self._set_head(newhead)
826
668
    def get_push_location(self):
827
669
        """See Branch.get_push_location."""
828
670
        push_loc = self.get_config_stack().get('push_location')
829
 
        if push_loc is not None:
830
 
            return push_loc
831
 
        cs = self.repository._git.get_config_stack()
832
 
        return self._get_related_push_branch(cs)
 
671
        return push_loc
833
672
 
834
673
    def set_push_location(self, location):
835
674
        """See Branch.set_push_location."""
848
687
        :param refs: Refs dictionary (name -> git sha1)
849
688
        :return: iterator over (ref_name, tag_name, peeled_sha1, unpeeled_sha1)
850
689
        """
851
 
        refs = self.repository.controldir.get_refs_container()
852
 
        for ref_name, unpeeled in viewitems(refs.as_dict()):
 
690
        refs = self.repository._git.refs
 
691
        for ref_name, unpeeled in refs.as_dict().iteritems():
853
692
            try:
854
693
                tag_name = ref_to_tag_name(ref_name)
855
694
            except (ValueError, UnicodeDecodeError):
863
702
 
864
703
    def create_memorytree(self):
865
704
        from .memorytree import GitMemoryTree
866
 
        return GitMemoryTree(self, self.repository._git.object_store,
867
 
                             self.head)
 
705
        return GitMemoryTree(self, self.repository._git.object_store, self.head)
 
706
 
 
707
    def reference_parent(self, path, file_id=None, possible_transports=None):
 
708
        """Return the parent branch for a tree-reference file_id
 
709
 
 
710
        :param path: The path of the file_id in the tree
 
711
        :param file_id: Optional file_id of the tree reference
 
712
        :return: A branch associated with the file_id
 
713
        """
 
714
        # FIXME should provide multiple branches, based on config
 
715
        url = urlutils.join(self.user_url, path)
 
716
        return branch.Branch.open(
 
717
                url,
 
718
                possible_transports=possible_transports)
 
719
 
868
720
 
869
721
 
870
722
def _quick_lookup_revno(local_branch, remote_branch, revid):
871
 
    if not isinstance(revid, bytes):
 
723
    if type(revid) is not str:
872
724
        raise TypeError(revid)
873
725
    # Try in source branch first, it'll be faster
874
726
    with local_branch.lock_read():
875
 
        if not _calculate_revnos(local_branch):
876
 
            return None
877
727
        try:
878
728
            return local_branch.revision_id_to_revno(revid)
879
729
        except errors.NoSuchRevision:
880
730
            graph = local_branch.repository.get_graph()
881
731
            try:
882
 
                return graph.find_distance_to_null(
883
 
                    revid, [(revision.NULL_REVISION, 0)])
 
732
                return graph.find_distance_to_null(revid,
 
733
                    [(revision.NULL_REVISION, 0)])
884
734
            except errors.GhostRevisionsHaveNoRevno:
885
 
                if not _calculate_revnos(remote_branch):
886
 
                    return None
887
735
                # FIXME: Check using graph.find_distance_to_null() ?
888
736
                with remote_branch.lock_read():
889
737
                    return remote_branch.revision_id_to_revno(revid)
903
751
                to_file.write('No revisions to pull.\n')
904
752
            elif self.new_git_head is not None:
905
753
                to_file.write('Now on revision %d (git sha: %s).\n' %
906
 
                              (self.new_revno, self.new_git_head))
 
754
                        (self.new_revno, self.new_git_head))
907
755
            else:
908
756
                to_file.write('Now on revision %d.\n' % (self.new_revno,))
909
757
        self._show_tag_conficts(to_file)
910
758
 
911
759
    def _lookup_revno(self, revid):
912
760
        return _quick_lookup_revno(self.target_branch, self.source_branch,
913
 
                                   revid)
 
761
            revid)
914
762
 
915
763
    def _get_old_revno(self):
916
764
        if self._old_revno is not None:
937
785
 
938
786
    def _lookup_revno(self, revid):
939
787
        return _quick_lookup_revno(self.source_branch, self.target_branch,
940
 
                                   revid)
 
788
            revid)
941
789
 
942
790
    @property
943
791
    def old_revno(self):
969
817
 
970
818
    @classmethod
971
819
    def _get_interrepo(self, source, target):
972
 
        return _mod_repository.InterRepository.get(
973
 
            source.repository, target.repository)
 
820
        return _mod_repository.InterRepository.get(source.repository, target.repository)
974
821
 
975
822
    @classmethod
976
823
    def is_compatible(cls, source, target):
979
826
        if isinstance(target, GitBranch):
980
827
            # InterLocalGitRemoteGitBranch or InterToGitBranch should be used
981
828
            return False
982
 
        if (getattr(cls._get_interrepo(source, target), "fetch_objects", None)
983
 
                is None):
 
829
        if getattr(cls._get_interrepo(source, target), "fetch_objects", None) is None:
984
830
            # fetch_objects is necessary for this to work
985
831
            return False
986
832
        return True
987
833
 
988
 
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
989
 
        self.fetch_objects(
990
 
            stop_revision, fetch_tags=fetch_tags, limit=limit, lossy=lossy)
991
 
        return _mod_repository.FetchResult()
 
834
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
 
835
        self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
992
836
 
993
 
    def fetch_objects(self, stop_revision, fetch_tags, limit=None, lossy=False, tag_selector=None):
 
837
    def fetch_objects(self, stop_revision, fetch_tags, limit=None):
994
838
        interrepo = self._get_interrepo(self.source, self.target)
995
839
        if fetch_tags is None:
996
840
            c = self.source.get_config_stack()
997
841
            fetch_tags = c.get('branch.fetch_tags')
998
 
 
999
842
        def determine_wants(heads):
1000
843
            if stop_revision is None:
1001
844
                try:
1003
846
                except KeyError:
1004
847
                    self._last_revid = revision.NULL_REVISION
1005
848
                else:
1006
 
                    self._last_revid = self.source.lookup_foreign_revision_id(
1007
 
                        head)
 
849
                    self._last_revid = self.source.lookup_foreign_revision_id(head)
1008
850
            else:
1009
851
                self._last_revid = stop_revision
1010
852
            real = interrepo.get_determine_wants_revids(
1011
 
                [self._last_revid], include_tags=fetch_tags, tag_selector=tag_selector)
 
853
                [self._last_revid], include_tags=fetch_tags)
1012
854
            return real(heads)
1013
855
        pack_hint, head, refs = interrepo.fetch_objects(
1014
 
            determine_wants, self.source.mapping, limit=limit,
1015
 
            lossy=lossy)
 
856
            determine_wants, self.source.mapping, limit=limit)
1016
857
        if (pack_hint is not None and
1017
 
                self.target.repository._format.pack_compresses):
 
858
            self.target.repository._format.pack_compresses):
1018
859
            self.target.repository.pack(hint=pack_hint)
1019
860
        return head, refs
1020
861
 
1021
 
    def _update_revisions(self, stop_revision=None, overwrite=False, tag_selector=None):
1022
 
        head, refs = self.fetch_objects(stop_revision, fetch_tags=None, tag_selector=tag_selector)
 
862
    def _update_revisions(self, stop_revision=None, overwrite=False):
 
863
        head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
1023
864
        if overwrite:
1024
865
            prev_last_revid = None
1025
866
        else:
1026
867
            prev_last_revid = self.target.last_revision()
1027
 
        self.target.generate_revision_history(
1028
 
            self._last_revid, last_rev=prev_last_revid,
1029
 
            other_branch=self.source)
 
868
        self.target.generate_revision_history(self._last_revid,
 
869
            last_rev=prev_last_revid, other_branch=self.source)
1030
870
        return head, refs
1031
871
 
1032
 
    def update_references(self, revid=None):
1033
 
        if revid is None:
1034
 
            revid = self.target.last_revision()
1035
 
        tree = self.target.repository.revision_tree(revid)
1036
 
        try:
1037
 
            with tree.get_file('.gitmodules') as f:
1038
 
                for path, url, section in parse_submodules(
1039
 
                        GitConfigFile.from_file(f)):
1040
 
                    self.target.set_reference_info(
1041
 
                        tree.path2id(path.decode('utf-8')), url.decode('utf-8'),
1042
 
                        path.decode('utf-8'))
1043
 
        except errors.NoSuchFile:
1044
 
            pass
1045
 
 
1046
872
    def _basic_pull(self, stop_revision, overwrite, run_hooks,
1047
 
                    _override_hook_target, _hook_master, tag_selector=None):
 
873
              _override_hook_target, _hook_master):
1048
874
        if overwrite is True:
1049
875
            overwrite = set(["history", "tags"])
1050
 
        elif not overwrite:
 
876
        else:
1051
877
            overwrite = set()
1052
878
        result = GitBranchPullResult()
1053
879
        result.source_branch = self.source
1061
887
            (result.old_revno, result.old_revid) = \
1062
888
                self.target.last_revision_info()
1063
889
            result.new_git_head, remote_refs = self._update_revisions(
1064
 
                stop_revision, overwrite=("history" in overwrite),
1065
 
                tag_selector=tag_selector)
1066
 
            tags_ret = self.source.tags.merge_to(
1067
 
                self.target.tags, ("tags" in overwrite), ignore_master=True)
 
890
                stop_revision, overwrite=("history" in overwrite))
 
891
            tags_ret  = self.source.tags.merge_to(
 
892
                    self.target.tags, ("tags" in overwrite), ignore_master=True)
1068
893
            if isinstance(tags_ret, tuple):
1069
894
                result.tag_updates, result.tag_conflicts = tags_ret
1070
895
            else:
1071
896
                result.tag_conflicts = tags_ret
1072
897
            (result.new_revno, result.new_revid) = \
1073
898
                self.target.last_revision_info()
1074
 
            self.update_references(revid=result.new_revid)
1075
899
            if _hook_master:
1076
900
                result.master_branch = _hook_master
1077
901
                result.local_branch = result.target_branch
1085
909
 
1086
910
    def pull(self, overwrite=False, stop_revision=None,
1087
911
             possible_transports=None, _hook_master=None, run_hooks=True,
1088
 
             _override_hook_target=None, local=False, tag_selector=None):
 
912
             _override_hook_target=None, local=False):
1089
913
        """See Branch.pull.
1090
914
 
1091
915
        :param _hook_master: Private parameter - set the branch to
1100
924
        bound_location = self.target.get_bound_location()
1101
925
        if local and not bound_location:
1102
926
            raise errors.LocalRequiresBoundBranch()
 
927
        master_branch = None
1103
928
        source_is_master = False
1104
 
        with cleanup.ExitStack() as es:
1105
 
            es.enter_context(self.source.lock_read())
1106
 
            if bound_location:
1107
 
                # bound_location comes from a config file, some care has to be
1108
 
                # taken to relate it to source.user_url
1109
 
                normalized = urlutils.normalize_url(bound_location)
1110
 
                try:
1111
 
                    relpath = self.source.user_transport.relpath(normalized)
1112
 
                    source_is_master = (relpath == '')
1113
 
                except (errors.PathNotChild, urlutils.InvalidURL):
1114
 
                    source_is_master = False
1115
 
            if not local and bound_location and not source_is_master:
1116
 
                # not pulling from master, so we need to update master.
1117
 
                master_branch = self.target.get_master_branch(possible_transports)
1118
 
                es.enter_context(master_branch.lock_write())
1119
 
                # pull from source into master.
1120
 
                master_branch.pull(self.source, overwrite, stop_revision,
1121
 
                                   run_hooks=False)
1122
 
            else:
1123
 
                master_branch = None
1124
 
            return self._basic_pull(stop_revision, overwrite, run_hooks,
1125
 
                                    _override_hook_target,
1126
 
                                    _hook_master=master_branch,
1127
 
                                    tag_selector=tag_selector)
 
929
        self.source.lock_read()
 
930
        if bound_location:
 
931
            # bound_location comes from a config file, some care has to be
 
932
            # taken to relate it to source.user_url
 
933
            normalized = urlutils.normalize_url(bound_location)
 
934
            try:
 
935
                relpath = self.source.user_transport.relpath(normalized)
 
936
                source_is_master = (relpath == '')
 
937
            except (errors.PathNotChild, urlutils.InvalidURL):
 
938
                source_is_master = False
 
939
        if not local and bound_location and not source_is_master:
 
940
            # not pulling from master, so we need to update master.
 
941
            master_branch = self.target.get_master_branch(possible_transports)
 
942
            master_branch.lock_write()
 
943
        try:
 
944
            try:
 
945
                if master_branch:
 
946
                    # pull from source into master.
 
947
                    master_branch.pull(self.source, overwrite, stop_revision,
 
948
                        run_hooks=False)
 
949
                result = self._basic_pull(stop_revision, overwrite, run_hooks,
 
950
                    _override_hook_target, _hook_master=master_branch)
 
951
            finally:
 
952
                self.source.unlock()
 
953
        finally:
 
954
            if master_branch:
 
955
                master_branch.unlock()
 
956
        return result
1128
957
 
1129
 
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
 
958
    def _basic_push(self, overwrite, stop_revision):
1130
959
        if overwrite is True:
1131
960
            overwrite = set(["history", "tags"])
1132
 
        elif not overwrite:
 
961
        else:
1133
962
            overwrite = set()
1134
963
        result = branch.BranchPushResult()
1135
964
        result.source_branch = self.source
1136
965
        result.target_branch = self.target
1137
966
        result.old_revno, result.old_revid = self.target.last_revision_info()
1138
967
        result.new_git_head, remote_refs = self._update_revisions(
1139
 
            stop_revision, overwrite=("history" in overwrite),
1140
 
            tag_selector=tag_selector)
1141
 
        tags_ret = self.source.tags.merge_to(
1142
 
            self.target.tags, "tags" in overwrite, ignore_master=True,
1143
 
            selector=tag_selector)
 
968
            stop_revision, overwrite=("history" in overwrite))
 
969
        tags_ret = self.source.tags.merge_to(self.target.tags,
 
970
            "tags" in overwrite, ignore_master=True)
1144
971
        (result.tag_updates, result.tag_conflicts) = tags_ret
1145
972
        result.new_revno, result.new_revid = self.target.last_revision_info()
1146
 
        self.update_references(revid=result.new_revid)
1147
973
        return result
1148
974
 
1149
975
 
1150
976
class InterGitBranch(branch.GenericInterBranch):
1151
977
    """InterBranch implementation that pulls between Git branches."""
1152
978
 
1153
 
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
 
979
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1154
980
        raise NotImplementedError(self.fetch)
1155
981
 
1156
982
 
1169
995
        return (isinstance(source, LocalGitBranch) and
1170
996
                isinstance(target, RemoteGitBranch))
1171
997
 
1172
 
    def _basic_push(self, overwrite, stop_revision, tag_selector=None):
 
998
    def _basic_push(self, overwrite, stop_revision):
1173
999
        result = GitBranchPushResult()
1174
1000
        result.source_branch = self.source
1175
1001
        result.target_branch = self.target
1176
1002
        if stop_revision is None:
1177
1003
            stop_revision = self.source.last_revision()
1178
 
 
1179
1004
        def get_changed_refs(old_refs):
1180
1005
            old_ref = old_refs.get(self.target.ref, None)
1181
1006
            if old_ref is None:
1182
1007
                result.old_revid = revision.NULL_REVISION
1183
1008
            else:
1184
 
                result.old_revid = self.target.lookup_foreign_revision_id(
1185
 
                    old_ref)
1186
 
            new_ref = self.source.repository.lookup_bzr_revision_id(
1187
 
                stop_revision)[0]
 
1009
                result.old_revid = self.target.lookup_foreign_revision_id(old_ref)
 
1010
            new_ref = self.source.repository.lookup_bzr_revision_id(stop_revision)[0]
1188
1011
            if not overwrite:
1189
 
                if remote_divergence(
1190
 
                        old_ref, new_ref,
1191
 
                        self.source.repository._git.object_store):
 
1012
                if remote_divergence(old_ref, new_ref, self.source.repository._git.object_store):
1192
1013
                    raise errors.DivergedBranches(self.source, self.target)
1193
 
            refs = {self.target.ref: new_ref}
 
1014
            refs = { self.target.ref: new_ref }
1194
1015
            result.new_revid = stop_revision
1195
 
            for name, sha in viewitems(
1196
 
                    self.source.repository._git.refs.as_dict(b"refs/tags")):
1197
 
                if tag_selector and not tag_selector(name):
1198
 
                    continue
1199
 
                if sha not in self.source.repository._git:
1200
 
                    trace.mutter('Ignoring missing SHA: %s', sha)
1201
 
                    continue
 
1016
            for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():
1202
1017
                refs[tag_name_to_ref(name)] = sha
1203
1018
            return refs
1204
 
        self.target.repository.send_pack(
1205
 
            get_changed_refs,
 
1019
        self.target.repository.send_pack(get_changed_refs,
1206
1020
            self.source.repository._git.object_store.generate_pack_data)
1207
1021
        return result
1208
1022
 
1222
1036
        return (isinstance(source, GitBranch) and
1223
1037
                isinstance(target, LocalGitBranch))
1224
1038
 
1225
 
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None, lossy=False):
1226
 
        interrepo = _mod_repository.InterRepository.get(
1227
 
            self.source.repository, self.target.repository)
 
1039
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
 
1040
        interrepo = _mod_repository.InterRepository.get(self.source.repository,
 
1041
            self.target.repository)
1228
1042
        if stop_revision is None:
1229
1043
            stop_revision = self.source.last_revision()
1230
 
        if fetch_tags is None:
1231
 
            c = self.source.get_config_stack()
1232
 
            fetch_tags = c.get('branch.fetch_tags')
1233
1044
        determine_wants = interrepo.get_determine_wants_revids(
1234
1045
            [stop_revision], include_tags=fetch_tags)
1235
 
        interrepo.fetch_objects(determine_wants, limit=limit, lossy=lossy)
1236
 
        return _mod_repository.FetchResult()
 
1046
        interrepo.fetch_objects(determine_wants, limit=limit)
1237
1047
 
1238
 
    def _basic_push(self, overwrite=False, stop_revision=None, tag_selector=None):
 
1048
    def _basic_push(self, overwrite=False, stop_revision=None):
1239
1049
        if overwrite is True:
1240
1050
            overwrite = set(["history", "tags"])
1241
 
        elif not overwrite:
 
1051
        else:
1242
1052
            overwrite = set()
1243
1053
        result = GitBranchPushResult()
1244
1054
        result.source_branch = self.source
1245
1055
        result.target_branch = self.target
1246
1056
        result.old_revid = self.target.last_revision()
1247
1057
        refs, stop_revision = self.update_refs(stop_revision)
1248
 
        self.target.generate_revision_history(
1249
 
            stop_revision,
1250
 
            (result.old_revid if ("history" not in overwrite) else None),
1251
 
            other_branch=self.source)
1252
 
        tags_ret = self.source.tags.merge_to(
1253
 
            self.target.tags,
1254
 
            overwrite=("tags" in overwrite),
1255
 
            selector=tag_selector)
 
1058
        self.target.generate_revision_history(stop_revision,
 
1059
                (result.old_revid if ("history" not in overwrite) else None),
 
1060
                other_branch=self.source)
 
1061
        tags_ret = self.source.tags.merge_to(self.target.tags,
 
1062
            source_tag_refs=remote_refs_dict_to_tag_refs(refs),
 
1063
            overwrite=("tags" in overwrite))
1256
1064
        if isinstance(tags_ret, tuple):
1257
1065
            (result.tag_updates, result.tag_conflicts) = tags_ret
1258
1066
        else:
1262
1070
 
1263
1071
    def update_refs(self, stop_revision=None):
1264
1072
        interrepo = _mod_repository.InterRepository.get(
1265
 
            self.source.repository, self.target.repository)
 
1073
                self.source.repository, self.target.repository)
1266
1074
        c = self.source.get_config_stack()
1267
1075
        fetch_tags = c.get('branch.fetch_tags')
1268
1076
 
1269
1077
        if stop_revision is None:
1270
 
            result = interrepo.fetch(branches=[self.source.ref], include_tags=fetch_tags)
 
1078
            refs = interrepo.fetch(branches=["HEAD"], include_tags=fetch_tags)
1271
1079
            try:
1272
 
                head = result.refs[self.source.ref]
 
1080
                head = refs["HEAD"]
1273
1081
            except KeyError:
1274
1082
                stop_revision = revision.NULL_REVISION
1275
1083
            else:
1276
1084
                stop_revision = self.target.lookup_foreign_revision_id(head)
1277
1085
        else:
1278
 
            result = interrepo.fetch(
1279
 
                revision_id=stop_revision, include_tags=fetch_tags)
1280
 
        return result.refs, stop_revision
 
1086
            refs = interrepo.fetch(revision_id=stop_revision, include_tags=fetch_tags)
 
1087
        return refs, stop_revision
1281
1088
 
1282
1089
    def pull(self, stop_revision=None, overwrite=False,
1283
 
             possible_transports=None, run_hooks=True, local=False,
1284
 
             tag_selector=None):
 
1090
             possible_transports=None, run_hooks=True, local=False):
1285
1091
        # This type of branch can't be bound.
1286
1092
        if local:
1287
1093
            raise errors.LocalRequiresBoundBranch()
1288
1094
        if overwrite is True:
1289
1095
            overwrite = set(["history", "tags"])
1290
 
        elif not overwrite:
 
1096
        else:
1291
1097
            overwrite = set()
1292
1098
 
1293
1099
        result = GitPullResult()
1296
1102
        with self.target.lock_write(), self.source.lock_read():
1297
1103
            result.old_revid = self.target.last_revision()
1298
1104
            refs, stop_revision = self.update_refs(stop_revision)
1299
 
            self.target.generate_revision_history(
1300
 
                stop_revision,
1301
 
                (result.old_revid if ("history" not in overwrite) else None),
1302
 
                other_branch=self.source)
1303
 
            tags_ret = self.source.tags.merge_to(
1304
 
                self.target.tags, overwrite=("tags" in overwrite),
1305
 
                selector=tag_selector)
 
1105
            self.target.generate_revision_history(stop_revision,
 
1106
                    (result.old_revid if ("history" not in overwrite) else None),
 
1107
                    other_branch=self.source)
 
1108
            tags_ret = self.source.tags.merge_to(self.target.tags,
 
1109
                overwrite=("tags" in overwrite),
 
1110
                source_tag_refs=remote_refs_dict_to_tag_refs(refs))
1306
1111
            if isinstance(tags_ret, tuple):
1307
1112
                (result.tag_updates, result.tag_conflicts) = tags_ret
1308
1113
            else:
1317
1122
 
1318
1123
 
1319
1124
class InterToGitBranch(branch.GenericInterBranch):
1320
 
    """InterBranch implementation that pulls into a Git branch."""
 
1125
    """InterBranch implementation that pulls from a non-bzr into a Git branch."""
1321
1126
 
1322
1127
    def __init__(self, source, target):
1323
1128
        super(InterToGitBranch, self).__init__(source, target)
1324
1129
        self.interrepo = _mod_repository.InterRepository.get(source.repository,
1325
 
                                                             target.repository)
 
1130
                                           target.repository)
1326
1131
 
1327
1132
    @staticmethod
1328
1133
    def _get_branch_formats_to_test():
1340
1145
        return (not isinstance(source, GitBranch) and
1341
1146
                isinstance(target, GitBranch))
1342
1147
 
1343
 
    def _get_new_refs(self, stop_revision=None, fetch_tags=None,
1344
 
                      stop_revno=None):
 
1148
    def _get_new_refs(self, stop_revision=None, fetch_tags=None):
1345
1149
        if not self.source.is_locked():
1346
1150
            raise errors.ObjectNotLocked(self.source)
1347
1151
        if stop_revision is None:
1348
1152
            (stop_revno, stop_revision) = self.source.last_revision_info()
1349
 
        elif stop_revno is None:
1350
 
            try:
1351
 
                stop_revno = self.source.revision_id_to_revno(stop_revision)
1352
 
            except errors.NoSuchRevision:
1353
 
                stop_revno = None
1354
 
        if not isinstance(stop_revision, bytes):
 
1153
        else:
 
1154
            stop_revno = self.source.revision_id_to_revno(stop_revision)
 
1155
        if type(stop_revision) is not str:
1355
1156
            raise TypeError(stop_revision)
1356
1157
        main_ref = self.target.ref
1357
 
        refs = {main_ref: (None, stop_revision)}
 
1158
        refs = { main_ref: (None, stop_revision) }
1358
1159
        if fetch_tags is None:
1359
1160
            c = self.source.get_config_stack()
1360
1161
            fetch_tags = c.get('branch.fetch_tags')
1361
 
        for name, revid in viewitems(self.source.tags.get_tag_dict()):
 
1162
        for name, revid in self.source.tags.get_tag_dict().iteritems():
1362
1163
            if self.source.repository.has_revision(revid):
1363
1164
                ref = tag_name_to_ref(name)
1364
1165
                if not check_ref_format(ref):
1365
1166
                    warning("skipping tag with invalid characters %s (%s)",
1366
 
                            name, ref)
 
1167
                        name, ref)
1367
1168
                    continue
1368
1169
                if fetch_tags:
1369
1170
                    # FIXME: Skip tags that are not in the ancestry
1370
1171
                    refs[ref] = (None, revid)
1371
1172
        return refs, main_ref, (stop_revno, stop_revision)
1372
1173
 
1373
 
    def _update_refs(self, result, old_refs, new_refs, overwrite, tag_selector):
 
1174
    def _update_refs(self, result, old_refs, new_refs, overwrite):
1374
1175
        mutter("updating refs. old refs: %r, new refs: %r",
1375
1176
               old_refs, new_refs)
1376
1177
        result.tag_updates = {}
1377
1178
        result.tag_conflicts = []
1378
1179
        ret = dict(old_refs)
1379
 
 
1380
1180
        def ref_equals(refs, ref, git_sha, revid):
1381
1181
            try:
1382
1182
                value = refs[ref]
1384
1184
                return False
1385
1185
            if (value[0] is not None and
1386
1186
                git_sha is not None and
1387
 
                    value[0] == git_sha):
 
1187
                value[0] == git_sha):
1388
1188
                return True
1389
1189
            if (value[1] is not None and
1390
1190
                revid is not None and
1391
 
                    value[1] == revid):
 
1191
                value[1] == revid):
1392
1192
                return True
1393
 
            # FIXME: If one side only has the git sha available and the other
1394
 
            # only has the bzr revid, then this will cause us to show a tag as
1395
 
            # updated that hasn't actually been updated.
 
1193
            # FIXME: If one side only has the git sha available and the other only
 
1194
            # has the bzr revid, then this will cause us to show a tag as updated
 
1195
            # that hasn't actually been updated.
1396
1196
            return False
1397
1197
        # FIXME: Check for diverged branches
1398
 
        for ref, (git_sha, revid) in viewitems(new_refs):
 
1198
        for ref, (git_sha, revid) in new_refs.iteritems():
1399
1199
            if ref_equals(ret, ref, git_sha, revid):
1400
1200
                # Already up to date
1401
1201
                if git_sha is None:
1409
1209
                except ValueError:
1410
1210
                    pass
1411
1211
                else:
1412
 
                    if tag_selector and not tag_selector(tag_name):
1413
 
                        continue
1414
1212
                    result.tag_updates[tag_name] = revid
1415
1213
                ret[ref] = (git_sha, revid)
1416
1214
            else:
1422
1220
                    except ValueError:
1423
1221
                        pass
1424
1222
                    else:
1425
 
                        result.tag_conflicts.append(
1426
 
                            (name, revid, ret[name][1]))
 
1223
                        result.tag_conflicts.append((name, revid, ret[name][1]))
1427
1224
                else:
1428
1225
                    ret[ref] = (git_sha, revid)
1429
1226
        return ret
1430
1227
 
1431
 
    def fetch(self, stop_revision=None, fetch_tags=None, lossy=False,
1432
 
              limit=None):
 
1228
    def fetch(self, stop_revision=None, fetch_tags=None, lossy=False, limit=None):
1433
1229
        if stop_revision is None:
1434
1230
            stop_revision = self.source.last_revision()
1435
1231
        ret = []
1436
1232
        if fetch_tags:
1437
 
            for k, v in viewitems(self.source.tags.get_tag_dict()):
 
1233
            for k, v in self.source.tags.get_tag_dict().iteritems():
1438
1234
                ret.append((None, v))
1439
1235
        ret.append((None, stop_revision))
1440
1236
        try:
1441
 
            revidmap = self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
 
1237
            self.interrepo.fetch_objects(ret, lossy=lossy, limit=limit)
1442
1238
        except NoPushSupport:
1443
1239
            raise errors.NoRoundtrippingSupport(self.source, self.target)
1444
 
        return _mod_repository.FetchResult(revidmap={
1445
 
            old_revid: new_revid
1446
 
            for (old_revid, (new_sha, new_revid)) in revidmap.items()})
1447
1240
 
1448
1241
    def pull(self, overwrite=False, stop_revision=None, local=False,
1449
 
             possible_transports=None, run_hooks=True, _stop_revno=None,
1450
 
             tag_selector=None):
 
1242
             possible_transports=None, run_hooks=True):
1451
1243
        result = GitBranchPullResult()
1452
1244
        result.source_branch = self.source
1453
1245
        result.target_branch = self.target
1454
1246
        with self.source.lock_read(), self.target.lock_write():
1455
1247
            new_refs, main_ref, stop_revinfo = self._get_new_refs(
1456
 
                stop_revision, stop_revno=_stop_revno)
1457
 
 
 
1248
                stop_revision)
1458
1249
            def update_refs(old_refs):
1459
 
                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
 
1250
                return self._update_refs(result, old_refs, new_refs, overwrite)
1460
1251
            try:
1461
 
                result.revidmap, old_refs, new_refs = (
1462
 
                    self.interrepo.fetch_refs(update_refs, lossy=False))
 
1252
                result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
 
1253
                    update_refs, lossy=False)
1463
1254
            except NoPushSupport:
1464
1255
                raise errors.NoRoundtrippingSupport(self.source, self.target)
1465
 
            (old_sha1, result.old_revid) = old_refs.get(
1466
 
                main_ref, (ZERO_SHA, NULL_REVISION))
 
1256
            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
1467
1257
            if result.old_revid is None:
1468
 
                result.old_revid = self.target.lookup_foreign_revision_id(
1469
 
                    old_sha1)
 
1258
                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
1470
1259
            result.new_revid = new_refs[main_ref][1]
1471
1260
            result.local_branch = None
1472
1261
            result.master_branch = self.target
1476
1265
        return result
1477
1266
 
1478
1267
    def push(self, overwrite=False, stop_revision=None, lossy=False,
1479
 
             _override_hook_source_branch=None, _stop_revno=None,
1480
 
             tag_selector=None):
 
1268
             _override_hook_source_branch=None):
1481
1269
        result = GitBranchPushResult()
1482
1270
        result.source_branch = self.source
1483
1271
        result.target_branch = self.target
1484
1272
        result.local_branch = None
1485
1273
        result.master_branch = result.target_branch
1486
1274
        with self.source.lock_read(), self.target.lock_write():
1487
 
            new_refs, main_ref, stop_revinfo = self._get_new_refs(
1488
 
                stop_revision, stop_revno=_stop_revno)
1489
 
 
 
1275
            new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
1490
1276
            def update_refs(old_refs):
1491
 
                return self._update_refs(result, old_refs, new_refs, overwrite, tag_selector)
 
1277
                return self._update_refs(result, old_refs, new_refs, overwrite)
1492
1278
            try:
1493
 
                result.revidmap, old_refs, new_refs = (
1494
 
                    self.interrepo.fetch_refs(
1495
 
                        update_refs, lossy=lossy, overwrite=overwrite))
 
1279
                result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
 
1280
                    update_refs, lossy=lossy, overwrite=overwrite)
1496
1281
            except NoPushSupport:
1497
1282
                raise errors.NoRoundtrippingSupport(self.source, self.target)
1498
 
            (old_sha1, result.old_revid) = old_refs.get(
1499
 
                main_ref, (ZERO_SHA, NULL_REVISION))
1500
 
            if lossy or result.old_revid is None:
1501
 
                result.old_revid = self.target.lookup_foreign_revision_id(
1502
 
                    old_sha1)
 
1283
            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
1284
            if result.old_revid is None:
 
1285
                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
1503
1286
            result.new_revid = new_refs[main_ref][1]
1504
 
            (result.new_original_revno,
1505
 
                result.new_original_revid) = stop_revinfo
 
1287
            (result.new_original_revno, result.new_original_revid) = stop_revinfo
1506
1288
            for hook in branch.Branch.hooks['post_push']:
1507
1289
                hook(result)
1508
1290
        return result