/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to branch.py

Update docstrings.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branch.py
17
17
 
18
18
"""An adapter between a Git Branch and a Bazaar Branch"""
19
19
 
 
20
from collections import defaultdict
 
21
 
20
22
from dulwich.objects import (
21
23
    Commit,
22
24
    Tag,
 
25
    ZERO_SHA,
23
26
    )
24
27
 
25
28
from bzrlib import (
27
30
    bzrdir,
28
31
    config,
29
32
    errors,
30
 
    repository,
 
33
    repository as _mod_repository,
31
34
    revision,
32
35
    tag,
33
36
    transport,
51
54
    NoSuchRef,
52
55
    )
53
56
from bzrlib.plugins.git.refs import (
 
57
    branch_name_to_ref,
 
58
    extract_tags,
 
59
    is_tag,
54
60
    ref_to_branch_name,
55
 
    extract_tags,
 
61
    ref_to_tag_name,
56
62
    tag_name_to_ref,
57
63
    )
 
64
from bzrlib.plugins.git.unpeel_map import (
 
65
    UnpeelMap,
 
66
    )
58
67
 
59
68
from bzrlib.foreign import ForeignBranch
60
69
 
76
85
        return self._lookup_revno(self.new_revid)
77
86
 
78
87
 
79
 
class LocalGitTagDict(tag.BasicTags):
80
 
    """Dictionary with tags in a local repository."""
 
88
class GitTags(tag.BasicTags):
 
89
    """Ref-based tag dictionary."""
81
90
 
82
91
    def __init__(self, branch):
83
92
        self.branch = branch
84
93
        self.repository = branch.repository
85
94
 
 
95
    def get_refs(self):
 
96
        raise NotImplementedError(self.get_refs)
 
97
 
 
98
    def _iter_tag_refs(self, refs):
 
99
        raise NotImplementedError(self._iter_tag_refs)
 
100
 
 
101
    def _merge_to_git(self, to_tags, refs, overwrite=False):
 
102
        target_repo = to_tags.repository
 
103
        conflicts = []
 
104
        for k, v in refs.iteritems():
 
105
            if not is_tag(k):
 
106
                continue
 
107
            if overwrite or not k in target_repo._git.refs:
 
108
                target_repo._git.refs[k] = v
 
109
            elif target_repo._git.refs[k] == v:
 
110
                pass
 
111
            else:
 
112
                conflicts.append((ref_to_tag_name(k), v, target_repo.refs[k]))
 
113
        return conflicts
 
114
 
 
115
    def _merge_to_non_git(self, to_tags, refs, overwrite=False):
 
116
        unpeeled_map = defaultdict(set)
 
117
        conflicts = []
 
118
        result = dict(to_tags.get_tag_dict())
 
119
        for n, peeled, unpeeled, bzr_revid in self._iter_tag_refs(refs):
 
120
            if unpeeled is not None:
 
121
                unpeeled_map[peeled].add(unpeeled)
 
122
            if n not in result or overwrite:
 
123
                result[n] = bzr_revid
 
124
            elif result[n] == bzr_revid:
 
125
                pass
 
126
            else:
 
127
                conflicts.append((n, result[n], bzr_revid))
 
128
        to_tags._set_tag_dict(result)
 
129
        if len(unpeeled_map) > 0:
 
130
            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
 
131
            map_file.update(unpeeled_map)
 
132
            map_file.save_in_repository(to_tags.branch.repository)
 
133
        return conflicts
 
134
 
 
135
    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
 
136
                 source_refs=None):
 
137
        """See Tags.merge_to."""
 
138
        if source_refs is None:
 
139
            source_refs = self.get_refs()
 
140
        if self == to_tags:
 
141
            return
 
142
        if isinstance(to_tags, GitTags):
 
143
            return self._merge_to_git(to_tags, source_refs,
 
144
                                      overwrite=overwrite)
 
145
        else:
 
146
            if ignore_master:
 
147
                master = None
 
148
            else:
 
149
                master = to_tags.branch.get_master_branch()
 
150
            conflicts = self._merge_to_non_git(to_tags, source_refs,
 
151
                                              overwrite=overwrite)
 
152
            if master is not None:
 
153
                conflicts += self.merge_to(master.tags, overwrite=overwrite,
 
154
                                           source_refs=source_refs,
 
155
                                           ignore_master=ignore_master)
 
156
            return conflicts
 
157
 
86
158
    def get_tag_dict(self):
87
159
        ret = {}
88
 
        for k,v in extract_tags(self.repository._git.get_refs()).iteritems():
 
160
        refs = self.get_refs()
 
161
        for (name, peeled, unpeeled, bzr_revid) in self._iter_tag_refs(refs):
 
162
            ret[name] = bzr_revid
 
163
        return ret
 
164
 
 
165
 
 
166
class LocalGitTagDict(GitTags):
 
167
    """Dictionary with tags in a local repository."""
 
168
 
 
169
    def __init__(self, branch):
 
170
        super(LocalGitTagDict, self).__init__(branch)
 
171
        self.refs = self.repository._git.refs
 
172
 
 
173
    def get_refs(self):
 
174
        return self.repository._git.get_refs()
 
175
 
 
176
    def _iter_tag_refs(self, refs):
 
177
        """Iterate over the tag refs.
 
178
 
 
179
        :param refs: Refs dictionary (name -> git sha1)
 
180
        :return: iterator over (name, peeled_sha1, unpeeled_sha1, bzr_revid)
 
181
        """
 
182
        for k, (peeled, unpeeled) in extract_tags(refs).iteritems():
89
183
            try:
90
 
                obj = self.repository._git[v]
 
184
                obj = self.repository._git[peeled]
91
185
            except KeyError:
92
 
                mutter("Tag %s points at unknown object %s, ignoring", v, obj)
 
186
                mutter("Tag %s points at unknown object %s, ignoring", peeled,
 
187
                       peeled)
93
188
                continue
 
189
            # FIXME: this shouldn't really be necessary, the repository
 
190
            # already should have these unpeeled.
94
191
            while isinstance(obj, Tag):
95
 
                v = obj.object[1]
96
 
                obj = self.repository._git[v]
 
192
                peeled = obj.object[1]
 
193
                obj = self.repository._git[peeled]
97
194
            if not isinstance(obj, Commit):
98
195
                mutter("Tag %s points at object %r that is not a commit, "
99
196
                       "ignoring", k, obj)
100
197
                continue
101
 
            ret[k] = self.branch.lookup_foreign_revision_id(v)
102
 
        return ret
 
198
            yield (k, peeled, unpeeled,
 
199
                   self.branch.lookup_foreign_revision_id(peeled))
103
200
 
104
201
    def _set_tag_dict(self, to_dict):
105
 
        extra = set(self.repository._git.get_refs().keys())
 
202
        extra = set(self.get_refs().keys())
106
203
        for k, revid in to_dict.iteritems():
107
204
            name = tag_name_to_ref(k)
108
205
            if name in extra:
109
206
                extra.remove(name)
110
207
            self.set_tag(k, revid)
111
208
        for name in extra:
112
 
            if name.startswith("refs/tags/"):
 
209
            if is_tag(name):
113
210
                del self.repository._git[name]
114
211
 
115
212
    def set_tag(self, name, revid):
116
 
        self.repository._git.refs[tag_name_to_ref(name)], _ = \
 
213
        self.refs[tag_name_to_ref(name)], _ = \
117
214
            self.branch.lookup_bzr_revision_id(revid)
118
215
 
119
216
 
120
 
class DictTagDict(LocalGitTagDict):
 
217
class DictTagDict(tag.BasicTags):
121
218
 
122
219
    def __init__(self, branch, tags):
123
220
        super(DictTagDict, self).__init__(branch)
127
224
        return self._tags
128
225
 
129
226
 
 
227
class GitSymrefBranchFormat(branch.BranchFormat):
 
228
 
 
229
    def get_format_description(self):
 
230
        return 'Git Symbolic Reference Branch'
 
231
 
 
232
    def network_name(self):
 
233
        return "git"
 
234
 
 
235
    def get_reference(self, controldir, name=None):
 
236
        return controldir.get_branch_reference(name)
 
237
 
 
238
    def set_reference(self, controldir, name, target):
 
239
        return controldir.set_branch_reference(name, target)
 
240
 
 
241
 
130
242
class GitBranchFormat(branch.BranchFormat):
131
243
 
132
244
    def get_format_description(self):
138
250
    def supports_tags(self):
139
251
        return True
140
252
 
 
253
    def supports_leaving_lock(self):
 
254
        return False
 
255
 
 
256
    @property
 
257
    def _matchingbzrdir(self):
 
258
        from bzrlib.plugins.git.dir import LocalGitControlDirFormat
 
259
        return LocalGitControlDirFormat()
 
260
 
141
261
    def get_foreign_tests_branch_factory(self):
142
262
        from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory
143
263
        return ForeignTestsBranchFactory()
149
269
        else:
150
270
            return LocalGitTagDict(branch)
151
271
 
 
272
    def initialize(self, a_bzrdir, name=None, repository=None):
 
273
        from bzrlib.plugins.git.dir import LocalGitDir
 
274
        if not isinstance(a_bzrdir, LocalGitDir):
 
275
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
 
276
        if repository is None:
 
277
            repository = a_bzrdir.open_repository()
 
278
        ref = branch_name_to_ref(name, "HEAD")
 
279
        repository._git[ref] = ZERO_SHA
 
280
        return LocalGitBranch(a_bzrdir, repository, ref, a_bzrdir._lockfiles)
 
281
 
152
282
 
153
283
class GitReadLock(object):
154
284
 
159
289
class GitWriteLock(object):
160
290
 
161
291
    def __init__(self, unlock):
 
292
        self.branch_token = None
162
293
        self.unlock = unlock
163
294
 
164
295
 
165
296
class GitBranch(ForeignBranch):
166
297
    """An adapter to git repositories for bzr Branch objects."""
167
298
 
 
299
    @property
 
300
    def control_transport(self):
 
301
        return self.bzrdir.control_transport
 
302
 
168
303
    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
 
304
        self.base = bzrdir.root_transport.base
169
305
        self.repository = repository
170
306
        self._format = GitBranchFormat()
171
307
        self.control_files = lockfiles
172
308
        self.bzrdir = bzrdir
 
309
        self._lock_mode = None
 
310
        self._lock_count = 0
173
311
        super(GitBranch, self).__init__(repository.get_mapping())
174
312
        if tagsdict is not None:
175
313
            self.tags = DictTagDict(self, tagsdict)
176
314
        self.ref = ref
177
315
        self.name = ref_to_branch_name(ref)
178
316
        self._head = None
179
 
        self.base = bzrdir.root_transport.base
180
317
 
181
318
    def _get_checkout_format(self):
182
319
        """Return the most suitable metadir for a checkout of this branch.
205
342
 
206
343
    def __repr__(self):
207
344
        return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
208
 
            self.ref or "HEAD")
 
345
            self.name)
209
346
 
210
347
    def generate_revision_history(self, revid, old_revid=None):
211
 
        # FIXME: Check that old_revid is in the ancestry of revid
212
 
        newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
 
348
        if revid == NULL_REVISION:
 
349
            newhead = ZERO_SHA
 
350
        else:
 
351
            # FIXME: Check that old_revid is in the ancestry of revid
 
352
            newhead, self.mapping = self.repository.lookup_bzr_revision_id(revid)
 
353
            if self.mapping is None:
 
354
                raise AssertionError
213
355
        self._set_head(newhead)
214
356
 
215
 
    def lock_write(self):
216
 
        self.control_files.lock_write()
 
357
    def lock_write(self, token=None):
 
358
        if token is not None:
 
359
            raise errors.TokenLockingNotSupported(self)
 
360
        if self._lock_mode:
 
361
            assert self._lock_mode == 'w'
 
362
            self._lock_count += 1
 
363
        else:
 
364
            self._lock_mode = 'w'
 
365
            self._lock_count = 1
 
366
        self.repository.lock_write()
217
367
        return GitWriteLock(self.unlock)
218
368
 
219
369
    def get_stacked_on_url(self):
230
380
        pass
231
381
 
232
382
    def lock_read(self):
233
 
        self.control_files.lock_read()
 
383
        if self._lock_mode:
 
384
            assert self._lock_mode in ('r', 'w')
 
385
            self._lock_count += 1
 
386
        else:
 
387
            self._lock_mode = 'r'
 
388
            self._lock_count = 1
 
389
        self.repository.lock_read()
234
390
        return GitReadLock(self.unlock)
235
391
 
 
392
    def peek_lock_mode(self):
 
393
        return self._lock_mode
 
394
 
236
395
    def is_locked(self):
237
 
        return self.control_files.is_locked()
 
396
        return (self._lock_mode is not None)
238
397
 
239
398
    def unlock(self):
240
 
        self.control_files.unlock()
 
399
        """See Branch.unlock()."""
 
400
        self._lock_count -= 1
 
401
        if self._lock_count == 0:
 
402
            self._lock_mode = None
 
403
            self._clear_cached_state()
 
404
        self.repository.unlock()
241
405
 
242
406
    def get_physical_lock_status(self):
243
407
        return False
265
429
class LocalGitBranch(GitBranch):
266
430
    """A local Git branch."""
267
431
 
268
 
    def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
269
 
        super(LocalGitBranch, self).__init__(bzrdir, repository, name,
 
432
    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
 
433
        super(LocalGitBranch, self).__init__(bzrdir, repository, ref,
270
434
              lockfiles, tagsdict)
271
435
        refs = repository._git.get_refs()
272
 
        if not (name in refs.keys() or "HEAD" in refs.keys()):
 
436
        if not (ref in refs.keys() or "HEAD" in refs.keys()):
273
437
            raise errors.NotBranchError(self.base)
274
438
 
275
439
    def create_checkout(self, to_location, revision_id=None, lightweight=False,
309
473
    def _gen_revision_history(self):
310
474
        if self.head is None:
311
475
            return []
312
 
        ret = list(self.repository.iter_reverse_revision_history(
313
 
            self.last_revision()))
 
476
        graph = self.repository.get_graph()
 
477
        ret = list(graph.iter_lefthand_ancestry(self.last_revision(),
 
478
            (revision.NULL_REVISION, )))
314
479
        ret.reverse()
315
480
        return ret
316
481
 
320
485
        except KeyError:
321
486
            return None
322
487
 
323
 
    def set_last_revision_info(self, revno, revid):
324
 
        self.set_last_revision(revid)
 
488
    def _read_last_revision_info(self):
 
489
        last_revid = self.last_revision()
 
490
        graph = self.repository.get_graph()
 
491
        revno = graph.find_distance_to_null(last_revid,
 
492
            [(revision.NULL_REVISION, 0)])
 
493
        return revno, last_revid
 
494
 
 
495
    def set_last_revision_info(self, revno, revision_id):
 
496
        self.set_last_revision(revision_id)
 
497
        self._last_revision_info_cache = revno, revision_id
325
498
 
326
499
    def set_last_revision(self, revid):
327
 
        (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
328
 
        self.head = newhead
 
500
        if not revid or not isinstance(revid, basestring):
 
501
            raise errors.InvalidRevisionId(revision_id=revid, branch=self)
 
502
        if revid == NULL_REVISION:
 
503
            newhead = ZERO_SHA
 
504
        else:
 
505
            (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
 
506
            if self.mapping is None:
 
507
                raise AssertionError
 
508
        self._set_head(newhead)
329
509
 
330
510
    def _set_head(self, value):
331
511
        self._head = value
351
531
        return True
352
532
 
353
533
 
 
534
def _quick_lookup_revno(local_branch, remote_branch, revid):
 
535
    assert isinstance(revid, str), "was %r" % revid
 
536
    # Try in source branch first, it'll be faster
 
537
    try:
 
538
        return local_branch.revision_id_to_revno(revid)
 
539
    except errors.NoSuchRevision:
 
540
        graph = local_branch.repository.get_graph()
 
541
        try:
 
542
            return graph.find_distance_to_null(revid, [])
 
543
        except errors.GhostRevisionsHaveNoRevno:
 
544
            # FIXME: Check using graph.find_distance_to_null() ?
 
545
            return remote_branch.revision_id_to_revno(revid)
 
546
 
 
547
 
354
548
class GitBranchPullResult(branch.PullResult):
355
549
 
356
550
    def __init__(self):
371
565
        self._show_tag_conficts(to_file)
372
566
 
373
567
    def _lookup_revno(self, revid):
374
 
        assert isinstance(revid, str), "was %r" % revid
375
 
        # Try in source branch first, it'll be faster
376
 
        try:
377
 
            return self.source_branch.revision_id_to_revno(revid)
378
 
        except errors.NoSuchRevision:
379
 
            # FIXME: Check using graph.find_distance_to_null() ?
380
 
            return self.target_branch.revision_id_to_revno(revid)
 
568
        return _quick_lookup_revno(self.target_branch, self.source_branch,
 
569
                revid)
381
570
 
382
571
    def _get_old_revno(self):
383
572
        if self._old_revno is not None:
403
592
class GitBranchPushResult(branch.BranchPushResult):
404
593
 
405
594
    def _lookup_revno(self, revid):
406
 
        assert isinstance(revid, str), "was %r" % revid
407
 
        # Try in source branch first, it'll be faster
408
 
        try:
409
 
            return self.source_branch.revision_id_to_revno(revid)
410
 
        except errors.NoSuchRevision:
411
 
            # FIXME: Check using graph.find_distance_to_null() ?
412
 
            return self.target_branch.revision_id_to_revno(revid)
 
595
        return _quick_lookup_revno(self.source_branch, self.target_branch,
 
596
            revid)
413
597
 
414
598
    @property
415
599
    def old_revno(self):
417
601
 
418
602
    @property
419
603
    def new_revno(self):
 
604
        new_original_revno = getattr(self, "new_original_revno", None)
 
605
        if new_original_revno:
 
606
            return new_original_revno
 
607
        if getattr(self, "new_original_revid", None) is not None:
 
608
            return self._lookup_revno(self.new_original_revid)
420
609
        return self._lookup_revno(self.new_revid)
421
610
 
422
611
 
425
614
 
426
615
    @staticmethod
427
616
    def _get_branch_formats_to_test():
428
 
        return []
 
617
        try:
 
618
            default_format = branch.format_registry.get_default()
 
619
        except AttributeError:
 
620
            default_format = branch.BranchFormat._default_format
 
621
        return [
 
622
            (GitBranchFormat(), GitBranchFormat()),
 
623
            (GitBranchFormat(), default_format)]
429
624
 
430
625
    @classmethod
431
626
    def _get_interrepo(self, source, target):
432
 
        return repository.InterRepository.get(source.repository,
433
 
            target.repository)
 
627
        return _mod_repository.InterRepository.get(source.repository, target.repository)
434
628
 
435
629
    @classmethod
436
630
    def is_compatible(cls, source, target):
437
 
        return (isinstance(source, GitBranch) and
438
 
                not isinstance(target, GitBranch) and
439
 
                (getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))
440
 
 
441
 
    def _update_revisions(self, stop_revision=None, overwrite=False,
442
 
        graph=None, limit=None):
443
 
        """Like InterBranch.update_revisions(), but with additions.
444
 
 
445
 
        Compared to the `update_revisions()` below, this function takes a
446
 
        `limit` argument that limits how many git commits will be converted
447
 
        and returns the new git head.
448
 
        """
 
631
        if not isinstance(source, GitBranch):
 
632
            return False
 
633
        if isinstance(target, GitBranch):
 
634
            # InterLocalGitRemoteGitBranch or InterToGitBranch should be used
 
635
            return False
 
636
        if getattr(cls._get_interrepo(source, target), "fetch_objects", None) is None:
 
637
            # fetch_objects is necessary for this to work
 
638
            return False
 
639
        return True
 
640
 
 
641
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
 
642
        self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
 
643
 
 
644
    def fetch_objects(self, stop_revision, fetch_tags, limit=None):
449
645
        interrepo = self._get_interrepo(self.source, self.target)
 
646
        if fetch_tags is None:
 
647
            c = self.source.get_config()
 
648
            fetch_tags = c.get_user_option_as_bool('branch.fetch_tags')
450
649
        def determine_wants(heads):
451
650
            if self.source.ref is not None and not self.source.ref in heads:
452
651
                raise NoSuchRef(self.source.ref, heads.keys())
453
 
            if stop_revision is not None:
454
 
                self._last_revid = stop_revision
455
 
                head, mapping = self.source.repository.lookup_bzr_revision_id(
456
 
                    stop_revision)
457
 
            else:
 
652
 
 
653
            if stop_revision is None:
458
654
                if self.source.ref is not None:
459
655
                    head = heads[self.source.ref]
460
656
                else:
461
657
                    head = heads["HEAD"]
462
658
                self._last_revid = self.source.lookup_foreign_revision_id(head)
463
 
            if self.target.repository.has_revision(self._last_revid):
464
 
                return []
465
 
            return [head]
 
659
            else:
 
660
                self._last_revid = stop_revision
 
661
            real = interrepo.get_determine_wants_revids(
 
662
                [self._last_revid], include_tags=fetch_tags)
 
663
            return real(heads)
466
664
        pack_hint, head, refs = interrepo.fetch_objects(
467
665
            determine_wants, self.source.mapping, limit=limit)
468
666
        if (pack_hint is not None and
469
667
            self.target.repository._format.pack_compresses):
470
668
            self.target.repository.pack(hint=pack_hint)
471
 
        if head is not None:
472
 
            self._last_revid = self.source.lookup_foreign_revision_id(head)
 
669
        return head, refs
 
670
 
 
671
    def _update_revisions(self, stop_revision=None, overwrite=False):
 
672
        head, refs = self.fetch_objects(stop_revision, fetch_tags=None)
473
673
        if overwrite:
474
674
            prev_last_revid = None
475
675
        else:
476
676
            prev_last_revid = self.target.last_revision()
477
677
        self.target.generate_revision_history(self._last_revid,
478
 
            prev_last_revid)
479
 
        return head
480
 
 
481
 
    def update_revisions(self, stop_revision=None, overwrite=False,
482
 
                         graph=None):
483
 
        """See InterBranch.update_revisions()."""
484
 
        self._update_revisions(stop_revision, overwrite, graph)
 
678
            prev_last_revid, self.source)
 
679
        return head, refs
485
680
 
486
681
    def pull(self, overwrite=False, stop_revision=None,
487
682
             possible_transports=None, _hook_master=None, run_hooks=True,
488
 
             _override_hook_target=None, local=False, limit=None):
 
683
             _override_hook_target=None, local=False):
489
684
        """See Branch.pull.
490
685
 
491
686
        :param _hook_master: Private parameter - set the branch to
495
690
            so it should not run its hooks.
496
691
        :param _override_hook_target: Private parameter - set the branch to be
497
692
            supplied as the target_branch to pull hooks.
498
 
        :param limit: Only import this many revisons.  `None`, the default,
499
 
            means import all revisions.
500
693
        """
501
694
        # This type of branch can't be bound.
502
695
        if local:
511
704
        try:
512
705
            # We assume that during 'pull' the target repository is closer than
513
706
            # the source one.
514
 
            graph = self.target.repository.get_graph(self.source.repository)
515
707
            (result.old_revno, result.old_revid) = \
516
708
                self.target.last_revision_info()
517
 
            result.new_git_head = self._update_revisions(
518
 
                stop_revision, overwrite=overwrite, graph=graph, limit=limit)
 
709
            result.new_git_head, remote_refs = self._update_revisions(
 
710
                stop_revision, overwrite=overwrite)
519
711
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
520
712
                overwrite)
521
713
            (result.new_revno, result.new_revid) = \
537
729
        result = branch.BranchPushResult()
538
730
        result.source_branch = self.source
539
731
        result.target_branch = self.target
540
 
        graph = self.target.repository.get_graph(self.source.repository)
541
732
        result.old_revno, result.old_revid = self.target.last_revision_info()
542
 
        result.new_git_head = self._update_revisions(
543
 
            stop_revision, overwrite=overwrite, graph=graph)
 
733
        result.new_git_head, remote_refs = self._update_revisions(
 
734
            stop_revision, overwrite=overwrite)
544
735
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
545
736
            overwrite)
546
737
        result.new_revno, result.new_revid = self.target.last_revision_info()
551
742
    """InterBranch implementation that pulls between Git branches."""
552
743
 
553
744
 
554
 
class InterGitLocalRemoteBranch(InterGitBranch):
 
745
class InterLocalGitRemoteGitBranch(InterGitBranch):
555
746
    """InterBranch that copies from a local to a remote git branch."""
556
747
 
557
748
    @staticmethod
558
749
    def _get_branch_formats_to_test():
 
750
        # FIXME
559
751
        return []
560
752
 
561
753
    @classmethod
565
757
                isinstance(target, RemoteGitBranch))
566
758
 
567
759
    def _basic_push(self, overwrite=False, stop_revision=None):
568
 
        from dulwich.protocol import ZERO_SHA
569
760
        result = GitBranchPushResult()
570
761
        result.source_branch = self.source
571
762
        result.target_branch = self.target
573
764
            stop_revision = self.source.last_revision()
574
765
        # FIXME: Check for diverged branches
575
766
        def get_changed_refs(old_refs):
576
 
            result.old_revid = self.target.lookup_foreign_revision_id(old_refs.get(self.target.ref, ZERO_SHA))
 
767
            old_ref = old_refs.get(self.target.ref, ZERO_SHA)
 
768
            result.old_revid = self.target.lookup_foreign_revision_id(old_ref)
577
769
            refs = { self.target.ref: self.source.repository.lookup_bzr_revision_id(stop_revision)[0] }
578
770
            result.new_revid = stop_revision
579
771
            for name, sha in self.source.repository._git.refs.as_dict("refs/tags").iteritems():
584
776
        return result
585
777
 
586
778
 
587
 
class InterGitRemoteLocalBranch(InterGitBranch):
 
779
class InterGitLocalGitBranch(InterGitBranch):
588
780
    """InterBranch that copies from a remote to a local git branch."""
589
781
 
590
782
    @staticmethod
591
783
    def _get_branch_formats_to_test():
 
784
        # FIXME
592
785
        return []
593
786
 
594
787
    @classmethod
595
788
    def is_compatible(self, source, target):
596
 
        from bzrlib.plugins.git.remote import RemoteGitBranch
597
 
        return (isinstance(source, RemoteGitBranch) and
 
789
        return (isinstance(source, GitBranch) and
598
790
                isinstance(target, LocalGitBranch))
599
791
 
600
792
    def _basic_push(self, overwrite=False, stop_revision=None):
601
 
        result = branch.BranchPushResult()
 
793
        result = GitBranchPushResult()
602
794
        result.source_branch = self.source
603
795
        result.target_branch = self.target
604
796
        result.old_revid = self.target.last_revision()
605
797
        refs, stop_revision = self.update_refs(stop_revision)
606
798
        self.target.generate_revision_history(stop_revision, result.old_revid)
607
 
        self.update_tags(refs)
 
799
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
800
            source_refs=refs, overwrite=overwrite)
608
801
        result.new_revid = self.target.last_revision()
609
802
        return result
610
803
 
611
 
    def update_tags(self, refs):
612
 
        for name, v in extract_tags(refs).iteritems():
613
 
            revid = self.target.lookup_foreign_revision_id(v)
614
 
            self.target.tags.set_tag(name, revid)
615
 
 
616
804
    def update_refs(self, stop_revision=None):
617
 
        interrepo = repository.InterRepository.get(self.source.repository,
 
805
        interrepo = _mod_repository.InterRepository.get(self.source.repository,
618
806
            self.target.repository)
619
807
        if stop_revision is None:
620
808
            refs = interrepo.fetch(branches=["HEAD"])
634
822
        result.old_revid = self.target.last_revision()
635
823
        refs, stop_revision = self.update_refs(stop_revision)
636
824
        self.target.generate_revision_history(stop_revision, result.old_revid)
637
 
        self.update_tags(refs)
 
825
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
826
            overwrite=overwrite, source_refs=refs)
638
827
        result.new_revid = self.target.last_revision()
639
828
        return result
640
829
 
641
830
 
642
831
class InterToGitBranch(branch.GenericInterBranch):
643
 
    """InterBranch implementation that pulls from Git into bzr."""
 
832
    """InterBranch implementation that pulls into a Git branch."""
644
833
 
645
834
    def __init__(self, source, target):
646
835
        super(InterToGitBranch, self).__init__(source, target)
647
 
        self.interrepo = repository.InterRepository.get(source.repository,
 
836
        self.interrepo = _mod_repository.InterRepository.get(source.repository,
648
837
                                           target.repository)
649
838
 
650
839
    @staticmethod
651
840
    def _get_branch_formats_to_test():
652
 
        return []
 
841
        try:
 
842
            default_format = branch.format_registry.get_default()
 
843
        except AttributeError:
 
844
            default_format = branch.BranchFormat._default_format
 
845
        return [(default_format, GitBranchFormat())]
653
846
 
654
847
    @classmethod
655
848
    def is_compatible(self, source, target):
656
849
        return (not isinstance(source, GitBranch) and
657
850
                isinstance(target, GitBranch))
658
851
 
659
 
    def update_revisions(self, *args, **kwargs):
660
 
        raise NoPushSupport()
661
 
 
662
852
    def _get_new_refs(self, stop_revision=None):
663
853
        if stop_revision is None:
664
 
            stop_revision = self.source.last_revision()
 
854
            (stop_revno, stop_revision) = self.source.last_revision_info()
 
855
        else:
 
856
            stop_revno = self.source.revision_id_to_revno(stop_revision)
665
857
        assert type(stop_revision) is str
666
858
        main_ref = self.target.ref or "refs/heads/master"
667
859
        refs = { main_ref: (None, stop_revision) }
668
860
        for name, revid in self.source.tags.get_tag_dict().iteritems():
669
861
            if self.source.repository.has_revision(revid):
670
862
                refs[tag_name_to_ref(name)] = (None, revid)
671
 
        return refs, main_ref
 
863
        return refs, main_ref, (stop_revno, stop_revision)
672
864
 
673
865
    def pull(self, overwrite=False, stop_revision=None, local=False,
674
 
             possible_transports=None):
675
 
        from dulwich.protocol import ZERO_SHA
 
866
             possible_transports=None, run_hooks=True):
676
867
        result = GitBranchPullResult()
677
868
        result.source_branch = self.source
678
869
        result.target_branch = self.target
679
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
870
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
680
871
        def update_refs(old_refs):
681
 
            refs = dict(old_refs)
682
872
            # FIXME: Check for diverged branches
683
 
            refs.update(new_refs)
684
 
            return refs
685
 
        old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
686
 
        result.old_revid = self.target.lookup_foreign_revision_id(
687
 
            old_refs.get(main_ref, ZERO_SHA))
688
 
        result.new_revid = new_refs[main_ref]
 
873
            return new_refs
 
874
        try:
 
875
            result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
 
876
                update_refs, lossy=False)
 
877
        except NoPushSupport:
 
878
            raise errors.NoRoundtrippingSupport(self.source, self.target)
 
879
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
880
        if result.old_revid is None:
 
881
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
 
882
        result.new_revid = new_refs[main_ref][1]
689
883
        return result
690
884
 
691
 
    def push(self, overwrite=False, stop_revision=None,
 
885
    def push(self, overwrite=False, stop_revision=None, lossy=False,
692
886
             _override_hook_source_branch=None):
693
 
        from dulwich.protocol import ZERO_SHA
694
887
        result = GitBranchPushResult()
695
888
        result.source_branch = self.source
696
889
        result.target_branch = self.target
697
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
890
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
698
891
        def update_refs(old_refs):
699
 
            refs = dict(old_refs)
700
892
            # FIXME: Check for diverged branches
701
 
            refs.update(new_refs)
702
 
            return refs
703
 
        old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
893
            return new_refs
 
894
        try:
 
895
            result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
 
896
                update_refs, lossy=lossy)
 
897
        except NoPushSupport:
 
898
            raise errors.NoRoundtrippingSupport(self.source, self.target)
704
899
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
705
900
        if result.old_revid is None:
706
901
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
707
 
        result.new_revid = new_refs[main_ref]
 
902
        result.new_revid = new_refs[main_ref][1]
 
903
        (result.new_original_revno, result.new_original_revid) = stop_revinfo
708
904
        return result
709
905
 
710
906
    def lossy_push(self, stop_revision=None):
711
 
        result = GitBranchPushResult()
712
 
        result.source_branch = self.source
713
 
        result.target_branch = self.target
714
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
715
 
        def update_refs(old_refs):
716
 
            refs = dict(old_refs)
717
 
            # FIXME: Check for diverged branches
718
 
            refs.update(new_refs)
719
 
            return refs
720
 
        result.revidmap, old_refs, new_refs = self.interrepo.dfetch_refs(
721
 
            update_refs)
722
 
        result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]
723
 
        result.new_revid = new_refs[main_ref][1]
724
 
        return result
725
 
 
726
 
 
727
 
branch.InterBranch.register_optimiser(InterGitRemoteLocalBranch)
 
907
        # For compatibility with bzr < 2.4
 
908
        return self.push(lossy=True, stop_revision=stop_revision)
 
909
 
 
910
 
 
911
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
728
912
branch.InterBranch.register_optimiser(InterFromGitBranch)
729
913
branch.InterBranch.register_optimiser(InterToGitBranch)
730
 
branch.InterBranch.register_optimiser(InterGitLocalRemoteBranch)
 
914
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)