/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 bzrlib/merge.py

  • Committer: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import warnings
18
20
 
 
21
from bzrlib.lazy_import import lazy_import
 
22
lazy_import(globals(), """
19
23
from bzrlib import (
20
24
    branch as _mod_branch,
 
25
    cleanup,
21
26
    conflicts as _mod_conflicts,
22
27
    debug,
23
 
    decorators,
24
 
    errors,
 
28
    generate_ids,
25
29
    graph as _mod_graph,
26
 
    hooks,
27
30
    merge3,
28
31
    osutils,
29
32
    patiencediff,
34
37
    tree as _mod_tree,
35
38
    tsort,
36
39
    ui,
37
 
    versionedfile
38
 
    )
39
 
from bzrlib.cleanup import OperationWithCleanups
 
40
    versionedfile,
 
41
    workingtree,
 
42
    )
 
43
from bzrlib.i18n import gettext
 
44
""")
 
45
from bzrlib import (
 
46
    decorators,
 
47
    errors,
 
48
    hooks,
 
49
    registry,
 
50
    )
40
51
from bzrlib.symbol_versioning import (
41
52
    deprecated_in,
42
53
    deprecated_method,
46
57
 
47
58
def transform_tree(from_tree, to_tree, interesting_ids=None):
48
59
    from_tree.lock_tree_write()
49
 
    operation = OperationWithCleanups(merge_inner)
 
60
    operation = cleanup.OperationWithCleanups(merge_inner)
50
61
    operation.add_cleanup(from_tree.unlock)
51
62
    operation.run_simple(from_tree.branch, to_tree, from_tree,
52
63
        ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
55
66
class MergeHooks(hooks.Hooks):
56
67
 
57
68
    def __init__(self):
58
 
        hooks.Hooks.__init__(self)
59
 
        self.create_hook(hooks.HookPoint('merge_file_content',
 
69
        hooks.Hooks.__init__(self, "bzrlib.merge", "Merger.hooks")
 
70
        self.add_hook('merge_file_content',
60
71
            "Called with a bzrlib.merge.Merger object to create a per file "
61
72
            "merge object when starting a merge. "
62
73
            "Should return either None or a subclass of "
66
77
            "side has deleted the file and the other has changed it). "
67
78
            "See the AbstractPerFileMerger API docs for details on how it is "
68
79
            "used by merge.",
69
 
            (2, 1), None))
 
80
            (2, 1))
 
81
        self.add_hook('pre_merge',
 
82
            'Called before a merge. '
 
83
            'Receives a Merger object as the single argument.',
 
84
            (2, 5))
 
85
        self.add_hook('post_merge',
 
86
            'Called after a merge. '
 
87
            'Receives a Merger object as the single argument. '
 
88
            'The return value is ignored.',
 
89
            (2, 5))
70
90
 
71
91
 
72
92
class AbstractPerFileMerger(object):
84
104
    def merge_contents(self, merge_params):
85
105
        """Attempt to merge the contents of a single file.
86
106
        
87
 
        :param merge_params: A bzrlib.merge.MergeHookParams
88
 
        :return : A tuple of (status, chunks), where status is one of
 
107
        :param merge_params: A bzrlib.merge.MergeFileHookParams
 
108
        :return: A tuple of (status, chunks), where status is one of
89
109
            'not_applicable', 'success', 'conflicted', or 'delete'.  If status
90
110
            is 'success' or 'conflicted', then chunks should be an iterable of
91
111
            strings for the new file contents.
111
131
 
112
132
    def get_filename(self, params, tree):
113
133
        """Lookup the filename (i.e. basename, not path), given a Tree (e.g.
114
 
        self.merger.this_tree) and a MergeHookParams.
 
134
        self.merger.this_tree) and a MergeFileHookParams.
115
135
        """
116
136
        return osutils.basename(tree.id2path(params.file_id))
117
137
 
118
138
    def get_filepath(self, params, tree):
119
139
        """Calculate the path to the file in a tree.
120
140
 
121
 
        :param params: A MergeHookParams describing the file to merge
 
141
        :param params: A MergeFileHookParams describing the file to merge
122
142
        :param tree: a Tree, e.g. self.merger.this_tree.
123
143
        """
124
144
        return tree.id2path(params.file_id)
131
151
            params.winner == 'other' or
132
152
            # THIS and OTHER aren't both files.
133
153
            not params.is_file_merge() or
134
 
            # The filename doesn't match *.xml
 
154
            # The filename doesn't match
135
155
            not self.file_matches(params)):
136
156
            return 'not_applicable', None
137
157
        return self.merge_matching(params)
213
233
        raise NotImplementedError(self.merge_text)
214
234
 
215
235
 
216
 
class MergeHookParams(object):
 
236
class MergeFileHookParams(object):
217
237
    """Object holding parameters passed to merge_file_content hooks.
218
238
 
219
239
    There are some fields hooks can access:
421
441
        return self._cached_trees[revision_id]
422
442
 
423
443
    def _get_tree(self, treespec, possible_transports=None):
424
 
        from bzrlib import workingtree
425
444
        location, revno = treespec
426
445
        if revno is None:
427
446
            tree = workingtree.WorkingTree.open_containing(location)[0]
435
454
        revision_id = _mod_revision.ensure_null(revision_id)
436
455
        return branch, self.revision_tree(revision_id, branch)
437
456
 
438
 
    @deprecated_method(deprecated_in((2, 1, 0)))
439
 
    def ensure_revision_trees(self):
440
 
        if self.this_revision_tree is None:
441
 
            self.this_basis_tree = self.revision_tree(self.this_basis)
442
 
            if self.this_basis == self.this_rev_id:
443
 
                self.this_revision_tree = self.this_basis_tree
444
 
 
445
 
        if self.other_rev_id is None:
446
 
            other_basis_tree = self.revision_tree(self.other_basis)
447
 
            if other_basis_tree.has_changes(self.other_tree):
448
 
                raise errors.WorkingTreeNotRevision(self.this_tree)
449
 
            other_rev_id = self.other_basis
450
 
            self.other_tree = other_basis_tree
451
 
 
452
 
    @deprecated_method(deprecated_in((2, 1, 0)))
453
 
    def file_revisions(self, file_id):
454
 
        self.ensure_revision_trees()
455
 
        def get_id(tree, file_id):
456
 
            revision_id = tree.inventory[file_id].revision
457
 
            return revision_id
458
 
        if self.this_rev_id is None:
459
 
            if self.this_basis_tree.get_file_sha1(file_id) != \
460
 
                self.this_tree.get_file_sha1(file_id):
461
 
                raise errors.WorkingTreeNotRevision(self.this_tree)
462
 
 
463
 
        trees = (self.this_basis_tree, self.other_tree)
464
 
        return [get_id(tree, file_id) for tree in trees]
465
 
 
466
 
    @deprecated_method(deprecated_in((2, 1, 0)))
467
 
    def check_basis(self, check_clean, require_commits=True):
468
 
        if self.this_basis is None and require_commits is True:
469
 
            raise errors.BzrCommandError(
470
 
                "This branch has no commits."
471
 
                " (perhaps you would prefer 'bzr pull')")
472
 
        if check_clean:
473
 
            self.compare_basis()
474
 
            if self.this_basis != self.this_rev_id:
475
 
                raise errors.UncommittedChanges(self.this_tree)
476
 
 
477
 
    @deprecated_method(deprecated_in((2, 1, 0)))
478
 
    def compare_basis(self):
479
 
        try:
480
 
            basis_tree = self.revision_tree(self.this_tree.last_revision())
481
 
        except errors.NoSuchRevision:
482
 
            basis_tree = self.this_tree.basis_tree()
483
 
        if not self.this_tree.has_changes(basis_tree):
484
 
            self.this_rev_id = self.this_basis
485
 
 
486
457
    def set_interesting_files(self, file_list):
487
458
        self.interesting_files = file_list
488
459
 
495
466
    def _add_parent(self):
496
467
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
497
468
        new_parent_trees = []
498
 
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
 
469
        operation = cleanup.OperationWithCleanups(
 
470
            self.this_tree.set_parent_trees)
499
471
        for revision_id in new_parents:
500
472
            try:
501
473
                tree = self.revision_tree(revision_id)
532
504
                raise errors.NoCommits(self.other_branch)
533
505
        if self.other_rev_id is not None:
534
506
            self._cached_trees[self.other_rev_id] = self.other_tree
535
 
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
 
507
        self._maybe_fetch(self.other_branch, self.this_branch, self.other_basis)
536
508
 
537
509
    def set_other_revision(self, revision_id, other_branch):
538
510
        """Set 'other' based on a branch and revision id
576
548
            elif len(lcas) == 1:
577
549
                self.base_rev_id = list(lcas)[0]
578
550
            else: # len(lcas) > 1
 
551
                self._is_criss_cross = True
579
552
                if len(lcas) > 2:
580
553
                    # find_unique_lca can only handle 2 nodes, so we have to
581
554
                    # start back at the beginning. It is a shame to traverse
586
559
                else:
587
560
                    self.base_rev_id = self.revision_graph.find_unique_lca(
588
561
                                            *lcas)
589
 
                self._is_criss_cross = True
 
562
                sorted_lca_keys = self.revision_graph.find_merge_order(
 
563
                    revisions[0], lcas)
 
564
                if self.base_rev_id == _mod_revision.NULL_REVISION:
 
565
                    self.base_rev_id = sorted_lca_keys[0]
 
566
 
590
567
            if self.base_rev_id == _mod_revision.NULL_REVISION:
591
568
                raise errors.UnrelatedBranches()
592
569
            if self._is_criss_cross:
593
570
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
594
571
                              ' help criss-cross.')
595
572
                trace.mutter('Criss-cross lcas: %r' % lcas)
596
 
                interesting_revision_ids = [self.base_rev_id]
597
 
                interesting_revision_ids.extend(lcas)
 
573
                if self.base_rev_id in lcas:
 
574
                    trace.mutter('Unable to find unique lca. '
 
575
                                 'Fallback %r as best option.'
 
576
                                 % self.base_rev_id)
 
577
                interesting_revision_ids = set(lcas)
 
578
                interesting_revision_ids.add(self.base_rev_id)
598
579
                interesting_trees = dict((t.get_revision_id(), t)
599
580
                    for t in self.this_branch.repository.revision_trees(
600
581
                        interesting_revision_ids))
601
582
                self._cached_trees.update(interesting_trees)
602
 
                self.base_tree = interesting_trees.pop(self.base_rev_id)
603
 
                sorted_lca_keys = self.revision_graph.find_merge_order(
604
 
                    revisions[0], lcas)
 
583
                if self.base_rev_id in lcas:
 
584
                    self.base_tree = interesting_trees[self.base_rev_id]
 
585
                else:
 
586
                    self.base_tree = interesting_trees.pop(self.base_rev_id)
605
587
                self._lca_trees = [interesting_trees[key]
606
588
                                   for key in sorted_lca_keys]
607
589
            else:
630
612
            self._maybe_fetch(base_branch, self.this_branch, self.base_rev_id)
631
613
 
632
614
    def make_merger(self):
633
 
        kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
 
615
        kwargs = {'working_tree': self.this_tree, 'this_tree': self.this_tree,
634
616
                  'other_tree': self.other_tree,
635
617
                  'interesting_ids': self.interesting_ids,
636
618
                  'interesting_files': self.interesting_files,
637
619
                  'this_branch': self.this_branch,
 
620
                  'other_branch': self.other_branch,
638
621
                  'do_merge': False}
639
622
        if self.merge_type.requires_base:
640
623
            kwargs['base_tree'] = self.base_tree
666
649
        merge = self.make_merger()
667
650
        if self.other_branch is not None:
668
651
            self.other_branch.update_references(self.this_branch)
 
652
        for hook in Merger.hooks['pre_merge']:
 
653
            hook(merge)
669
654
        merge.do_merge()
 
655
        for hook in Merger.hooks['post_merge']:
 
656
            hook(merge)
670
657
        if self.recurse == 'down':
671
658
            for relpath, file_id in self.this_tree.iter_references():
672
659
                sub_tree = self.this_tree.get_nested_tree(file_id, relpath)
676
663
                    continue
677
664
                sub_merge = Merger(sub_tree.branch, this_tree=sub_tree)
678
665
                sub_merge.merge_type = self.merge_type
679
 
                other_branch = self.other_branch.reference_parent(file_id, relpath)
 
666
                other_branch = self.other_branch.reference_parent(file_id,
 
667
                                                                  relpath)
680
668
                sub_merge.set_other_revision(other_revision, other_branch)
681
669
                base_revision = self.base_tree.get_reference_revision(file_id)
682
670
                sub_merge.base_tree = \
686
674
        return merge
687
675
 
688
676
    def do_merge(self):
689
 
        operation = OperationWithCleanups(self._do_merge_to)
 
677
        operation = cleanup.OperationWithCleanups(self._do_merge_to)
690
678
        self.this_tree.lock_tree_write()
691
679
        operation.add_cleanup(self.this_tree.unlock)
692
680
        if self.base_tree is not None:
698
686
        merge = operation.run_simple()
699
687
        if len(merge.cooked_conflicts) == 0:
700
688
            if not self.ignore_zero and not trace.is_quiet():
701
 
                trace.note("All changes applied successfully.")
 
689
                trace.note(gettext("All changes applied successfully."))
702
690
        else:
703
 
            trace.note("%d conflicts encountered."
 
691
            trace.note(gettext("%d conflicts encountered.")
704
692
                       % len(merge.cooked_conflicts))
705
693
 
706
694
        return len(merge.cooked_conflicts)
738
726
                 interesting_ids=None, reprocess=False, show_base=False,
739
727
                 pb=None, pp=None, change_reporter=None,
740
728
                 interesting_files=None, do_merge=True,
741
 
                 cherrypick=False, lca_trees=None, this_branch=None):
 
729
                 cherrypick=False, lca_trees=None, this_branch=None,
 
730
                 other_branch=None):
742
731
        """Initialize the merger object and perform the merge.
743
732
 
744
733
        :param working_tree: The working tree to apply the merge to
747
736
        :param other_tree: The other tree to merge changes from
748
737
        :param this_branch: The branch associated with this_tree.  Defaults to
749
738
            this_tree.branch if not supplied.
 
739
        :param other_branch: The branch associated with other_tree, if any.
750
740
        :param interesting_ids: The file_ids of files that should be
751
741
            participate in the merge.  May not be combined with
752
742
            interesting_files.
774
764
            this_branch = this_tree.branch
775
765
        self.interesting_ids = interesting_ids
776
766
        self.interesting_files = interesting_files
777
 
        self.this_tree = working_tree
 
767
        self.working_tree = working_tree
 
768
        self.this_tree = this_tree
778
769
        self.base_tree = base_tree
779
770
        self.other_tree = other_tree
780
771
        self.this_branch = this_branch
 
772
        self.other_branch = other_branch
781
773
        self._raw_conflicts = []
782
774
        self.cooked_conflicts = []
783
775
        self.reprocess = reprocess
798
790
            warnings.warn("pb argument to Merge3Merger is deprecated")
799
791
 
800
792
    def do_merge(self):
801
 
        operation = OperationWithCleanups(self._do_merge)
802
 
        self.this_tree.lock_tree_write()
 
793
        operation = cleanup.OperationWithCleanups(self._do_merge)
 
794
        self.working_tree.lock_tree_write()
 
795
        operation.add_cleanup(self.working_tree.unlock)
 
796
        self.this_tree.lock_read()
803
797
        operation.add_cleanup(self.this_tree.unlock)
804
798
        self.base_tree.lock_read()
805
799
        operation.add_cleanup(self.base_tree.unlock)
808
802
        operation.run()
809
803
 
810
804
    def _do_merge(self, operation):
811
 
        self.tt = transform.TreeTransform(self.this_tree, None)
 
805
        self.tt = transform.TreeTransform(self.working_tree, None)
812
806
        operation.add_cleanup(self.tt.finalize)
813
807
        self._compute_transform()
814
808
        results = self.tt.apply(no_conflicts=True)
815
809
        self.write_modified(results)
816
810
        try:
817
 
            self.this_tree.add_conflicts(self.cooked_conflicts)
 
811
            self.working_tree.add_conflicts(self.cooked_conflicts)
818
812
        except errors.UnsupportedOperation:
819
813
            pass
820
814
 
821
815
    def make_preview_transform(self):
822
 
        operation = OperationWithCleanups(self._make_preview_transform)
 
816
        operation = cleanup.OperationWithCleanups(self._make_preview_transform)
823
817
        self.base_tree.lock_read()
824
818
        operation.add_cleanup(self.base_tree.unlock)
825
819
        self.other_tree.lock_read()
827
821
        return operation.run_simple()
828
822
 
829
823
    def _make_preview_transform(self):
830
 
        self.tt = transform.TransformPreview(self.this_tree)
 
824
        self.tt = transform.TransformPreview(self.working_tree)
831
825
        self._compute_transform()
832
826
        return self.tt
833
827
 
838
832
        else:
839
833
            entries = self._entries_lca()
840
834
            resolver = self._lca_multi_way
 
835
        # Prepare merge hooks
 
836
        factories = Merger.hooks['merge_file_content']
 
837
        # One hook for each registered one plus our default merger
 
838
        hooks = [factory(self) for factory in factories] + [self]
 
839
        self.active_hooks = [hook for hook in hooks if hook is not None]
841
840
        child_pb = ui.ui_factory.nested_progress_bar()
842
841
        try:
843
 
            factories = Merger.hooks['merge_file_content']
844
 
            hooks = [factory(self) for factory in factories] + [self]
845
 
            self.active_hooks = [hook for hook in hooks if hook is not None]
846
842
            for num, (file_id, changed, parents3, names3,
847
843
                      executable3) in enumerate(entries):
848
 
                child_pb.update('Preparing file merge', num, len(entries))
 
844
                # Try merging each entry
 
845
                child_pb.update(gettext('Preparing file merge'),
 
846
                                num, len(entries))
849
847
                self._merge_names(file_id, parents3, names3, resolver=resolver)
850
848
                if changed:
851
849
                    file_status = self._do_merge_contents(file_id)
855
853
                    executable3, file_status, resolver=resolver)
856
854
        finally:
857
855
            child_pb.finished()
858
 
        self.fix_root()
 
856
        self.tt.fixup_new_roots()
 
857
        self._finish_computing_transform()
 
858
 
 
859
    def _finish_computing_transform(self):
 
860
        """Finalize the transform and report the changes.
 
861
 
 
862
        This is the second half of _compute_transform.
 
863
        """
859
864
        child_pb = ui.ui_factory.nested_progress_bar()
860
865
        try:
861
866
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
868
873
                self.tt.iter_changes(), self.change_reporter)
869
874
        self.cook_conflicts(fs_conflicts)
870
875
        for conflict in self.cooked_conflicts:
871
 
            trace.warning(conflict)
 
876
            trace.warning(unicode(conflict))
872
877
 
873
878
    def _entries3(self):
874
879
        """Gather data about files modified between three trees.
881
886
        """
882
887
        result = []
883
888
        iterator = self.other_tree.iter_changes(self.base_tree,
884
 
                include_unchanged=True, specific_files=self.interesting_files,
 
889
                specific_files=self.interesting_files,
885
890
                extra_trees=[self.this_tree])
886
891
        this_entries = dict((e.file_id, e) for p, e in
887
892
                            self.this_tree.iter_entries_by_dir(
913
918
        it then compares with THIS and BASE.
914
919
 
915
920
        For the multi-valued entries, the format will be (BASE, [lca1, lca2])
916
 
        :return: [(file_id, changed, parents, names, executable)]
917
 
            file_id     Simple file_id of the entry
918
 
            changed     Boolean, True if the kind or contents changed
919
 
                        else False
920
 
            parents     ((base, [parent_id, in, lcas]), parent_id_other,
921
 
                         parent_id_this)
922
 
            names       ((base, [name, in, lcas]), name_in_other, name_in_this)
923
 
            executable  ((base, [exec, in, lcas]), exec_in_other, exec_in_this)
 
921
 
 
922
        :return: [(file_id, changed, parents, names, executable)], where:
 
923
 
 
924
            * file_id: Simple file_id of the entry
 
925
            * changed: Boolean, True if the kind or contents changed else False
 
926
            * parents: ((base, [parent_id, in, lcas]), parent_id_other,
 
927
                        parent_id_this)
 
928
            * names:   ((base, [name, in, lcas]), name_in_other, name_in_this)
 
929
            * executable: ((base, [exec, in, lcas]), exec_in_other,
 
930
                        exec_in_this)
924
931
        """
925
932
        if self.interesting_files is not None:
926
933
            lookup_trees = [self.this_tree, self.base_tree]
968
975
                else:
969
976
                    lca_entries.append(lca_ie)
970
977
 
971
 
            if file_id in base_inventory:
 
978
            if base_inventory.has_id(file_id):
972
979
                base_ie = base_inventory[file_id]
973
980
            else:
974
981
                base_ie = _none_entry
975
982
 
976
 
            if file_id in this_inventory:
 
983
            if this_inventory.has_id(file_id):
977
984
                this_ie = this_inventory[file_id]
978
985
            else:
979
986
                this_ie = _none_entry
1071
1078
                          ))
1072
1079
        return result
1073
1080
 
1074
 
 
 
1081
    @deprecated_method(deprecated_in((2, 4, 0)))
1075
1082
    def fix_root(self):
1076
 
        try:
1077
 
            self.tt.final_kind(self.tt.root)
1078
 
        except errors.NoSuchFile:
 
1083
        if self.tt.final_kind(self.tt.root) is None:
1079
1084
            self.tt.cancel_deletion(self.tt.root)
1080
1085
        if self.tt.final_file_id(self.tt.root) is None:
1081
1086
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
1086
1091
        other_root = self.tt.trans_id_file_id(other_root_file_id)
1087
1092
        if other_root == self.tt.root:
1088
1093
            return
1089
 
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
1090
 
            # the other tree's root is a non-root in the current tree (as when
1091
 
            # a previously unrelated branch is merged into another)
 
1094
        if self.this_tree.inventory.has_id(
 
1095
            self.other_tree.inventory.root.file_id):
 
1096
            # the other tree's root is a non-root in the current tree (as
 
1097
            # when a previously unrelated branch is merged into another)
1092
1098
            return
1093
 
        try:
1094
 
            self.tt.final_kind(other_root)
 
1099
        if self.tt.final_kind(other_root) is not None:
1095
1100
            other_root_is_present = True
1096
 
        except errors.NoSuchFile:
 
1101
        else:
1097
1102
            # other_root doesn't have a physical representation. We still need
1098
1103
            # to move any references to the actual root of the tree.
1099
1104
            other_root_is_present = False
1100
1105
        # 'other_tree.inventory.root' is not present in this tree. We are
1101
1106
        # calling adjust_path for children which *want* to be present with a
1102
1107
        # correct place to go.
1103
 
        for thing, child in self.other_tree.inventory.root.children.iteritems():
 
1108
        for _, child in self.other_tree.inventory.root.children.iteritems():
1104
1109
            trans_id = self.tt.trans_id_file_id(child.file_id)
1105
1110
            if not other_root_is_present:
1106
 
                # FIXME: Make final_kind returns None instead of raising
1107
 
                # NoSuchFile to avoid the ugly construct below -- vila 20100402
1108
 
                try:
1109
 
                    self.tt.final_kind(trans_id)
 
1111
                if self.tt.final_kind(trans_id) is not None:
1110
1112
                    # The item exist in the final tree and has a defined place
1111
1113
                    # to go already.
1112
1114
                    continue
1113
 
                except errors.NoSuchFile, e:
1114
 
                    pass
1115
1115
            # Move the item into the root
1116
 
            self.tt.adjust_path(self.tt.final_name(trans_id),
1117
 
                                self.tt.root, trans_id)
 
1116
            try:
 
1117
                final_name = self.tt.final_name(trans_id)
 
1118
            except errors.NoFinalPath:
 
1119
                # This file is not present anymore, ignore it.
 
1120
                continue
 
1121
            self.tt.adjust_path(final_name, self.tt.root, trans_id)
1118
1122
        if other_root_is_present:
1119
1123
            self.tt.cancel_creation(other_root)
1120
1124
            self.tt.cancel_versioning(other_root)
1122
1126
    def write_modified(self, results):
1123
1127
        modified_hashes = {}
1124
1128
        for path in results.modified_paths:
1125
 
            file_id = self.this_tree.path2id(self.this_tree.relpath(path))
 
1129
            file_id = self.working_tree.path2id(self.working_tree.relpath(path))
1126
1130
            if file_id is None:
1127
1131
                continue
1128
 
            hash = self.this_tree.get_file_sha1(file_id)
 
1132
            hash = self.working_tree.get_file_sha1(file_id)
1129
1133
            if hash is None:
1130
1134
                continue
1131
1135
            modified_hashes[file_id] = hash
1132
 
        self.this_tree.set_merge_modified(modified_hashes)
 
1136
        self.working_tree.set_merge_modified(modified_hashes)
1133
1137
 
1134
1138
    @staticmethod
1135
1139
    def parent(entry, file_id):
1148
1152
    @staticmethod
1149
1153
    def contents_sha1(tree, file_id):
1150
1154
        """Determine the sha1 of the file contents (used as a key method)."""
1151
 
        if file_id not in tree:
 
1155
        if not tree.has_id(file_id):
1152
1156
            return None
1153
1157
        return tree.get_file_sha1(file_id)
1154
1158
 
1299
1303
            self._raw_conflicts.append(('path conflict', trans_id, file_id,
1300
1304
                                        this_parent, this_name,
1301
1305
                                        other_parent, other_name))
1302
 
        if other_name is None:
 
1306
        if not self.other_tree.has_id(file_id):
1303
1307
            # it doesn't matter whether the result was 'other' or
1304
 
            # 'conflict'-- if there's no 'other', we leave it alone.
 
1308
            # 'conflict'-- if it has no file id, we leave it alone.
1305
1309
            return
1306
1310
        parent_id = parents[self.winner_idx[parent_id_winner]]
1307
 
        if parent_id is not None:
 
1311
        name = names[self.winner_idx[name_winner]]
 
1312
        if parent_id is not None or name is not None:
1308
1313
            # if we get here, name_winner and parent_winner are set to safe
1309
1314
            # values.
1310
 
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
1311
 
                                self.tt.trans_id_file_id(parent_id),
 
1315
            if parent_id is None and name is not None:
 
1316
                # if parent_id is None and name is non-None, current file is
 
1317
                # the tree root.
 
1318
                if names[self.winner_idx[parent_id_winner]] != '':
 
1319
                    raise AssertionError(
 
1320
                        'File looks like a root, but named %s' %
 
1321
                        names[self.winner_idx[parent_id_winner]])
 
1322
                parent_trans_id = transform.ROOT_PARENT
 
1323
            else:
 
1324
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1325
            self.tt.adjust_path(name, parent_trans_id,
1312
1326
                                self.tt.trans_id_file_id(file_id))
1313
1327
 
1314
1328
    def _do_merge_contents(self, file_id):
1315
1329
        """Performs a merge on file_id contents."""
1316
1330
        def contents_pair(tree):
1317
 
            if file_id not in tree:
 
1331
            if not tree.has_id(file_id):
1318
1332
                return (None, None)
1319
1333
            kind = tree.kind(file_id)
1320
1334
            if kind == "file":
1349
1363
        # We have a hypothetical conflict, but if we have files, then we
1350
1364
        # can try to merge the content
1351
1365
        trans_id = self.tt.trans_id_file_id(file_id)
1352
 
        params = MergeHookParams(self, file_id, trans_id, this_pair[0],
 
1366
        params = MergeFileHookParams(self, file_id, trans_id, this_pair[0],
1353
1367
            other_pair[0], winner)
1354
1368
        hooks = self.active_hooks
1355
1369
        hook_status = 'not_applicable'
1358
1372
            if hook_status != 'not_applicable':
1359
1373
                # Don't try any more hooks, this one applies.
1360
1374
                break
 
1375
        # If the merge ends up replacing the content of the file, we get rid of
 
1376
        # it at the end of this method (this variable is used to track the
 
1377
        # exceptions to this rule).
 
1378
        keep_this = False
1361
1379
        result = "modified"
1362
1380
        if hook_status == 'not_applicable':
1363
 
            # This is a contents conflict, because none of the available
1364
 
            # functions could merge it.
 
1381
            # No merge hook was able to resolve the situation. Two cases exist:
 
1382
            # a content conflict or a duplicate one.
1365
1383
            result = None
1366
1384
            name = self.tt.final_name(trans_id)
1367
1385
            parent_id = self.tt.final_parent(trans_id)
1368
 
            if self.this_tree.has_id(file_id):
1369
 
                self.tt.unversion_file(trans_id)
1370
 
            file_group = self._dump_conflicts(name, parent_id, file_id,
1371
 
                                              set_version=True)
1372
 
            self._raw_conflicts.append(('contents conflict', file_group))
 
1386
            duplicate = False
 
1387
            inhibit_content_conflict = False
 
1388
            if params.this_kind is None: # file_id is not in THIS
 
1389
                # Is the name used for a different file_id ?
 
1390
                dupe_path = self.other_tree.id2path(file_id)
 
1391
                this_id = self.this_tree.path2id(dupe_path)
 
1392
                if this_id is not None:
 
1393
                    # Two entries for the same path
 
1394
                    keep_this = True
 
1395
                    # versioning the merged file will trigger a duplicate
 
1396
                    # conflict
 
1397
                    self.tt.version_file(file_id, trans_id)
 
1398
                    transform.create_from_tree(
 
1399
                        self.tt, trans_id, self.other_tree, file_id,
 
1400
                        filter_tree_path=self._get_filter_tree_path(file_id))
 
1401
                    inhibit_content_conflict = True
 
1402
            elif params.other_kind is None: # file_id is not in OTHER
 
1403
                # Is the name used for a different file_id ?
 
1404
                dupe_path = self.this_tree.id2path(file_id)
 
1405
                other_id = self.other_tree.path2id(dupe_path)
 
1406
                if other_id is not None:
 
1407
                    # Two entries for the same path again, but here, the other
 
1408
                    # entry will also be merged.  We simply inhibit the
 
1409
                    # 'content' conflict creation because we know OTHER will
 
1410
                    # create (or has already created depending on ordering) an
 
1411
                    # entry at the same path. This will trigger a 'duplicate'
 
1412
                    # conflict later.
 
1413
                    keep_this = True
 
1414
                    inhibit_content_conflict = True
 
1415
            if not inhibit_content_conflict:
 
1416
                if params.this_kind is not None:
 
1417
                    self.tt.unversion_file(trans_id)
 
1418
                # This is a contents conflict, because none of the available
 
1419
                # functions could merge it.
 
1420
                file_group = self._dump_conflicts(name, parent_id, file_id,
 
1421
                                                  set_version=True)
 
1422
                self._raw_conflicts.append(('contents conflict', file_group))
1373
1423
        elif hook_status == 'success':
1374
1424
            self.tt.create_file(lines, trans_id)
1375
1425
        elif hook_status == 'conflicted':
1391
1441
            raise AssertionError('unknown hook_status: %r' % (hook_status,))
1392
1442
        if not self.this_tree.has_id(file_id) and result == "modified":
1393
1443
            self.tt.version_file(file_id, trans_id)
1394
 
        # The merge has been performed, so the old contents should not be
1395
 
        # retained.
1396
 
        try:
 
1444
        if not keep_this:
 
1445
            # The merge has been performed and produced a new content, so the
 
1446
            # old contents should not be retained.
1397
1447
            self.tt.delete_contents(trans_id)
1398
 
        except errors.NoSuchFile:
1399
 
            pass
1400
1448
        return result
1401
1449
 
1402
1450
    def _default_other_winner_merge(self, merge_hook_params):
1403
1451
        """Replace this contents with other."""
1404
1452
        file_id = merge_hook_params.file_id
1405
1453
        trans_id = merge_hook_params.trans_id
1406
 
        file_in_this = self.this_tree.has_id(file_id)
1407
1454
        if self.other_tree.has_id(file_id):
1408
1455
            # OTHER changed the file
1409
 
            wt = self.this_tree
1410
 
            if wt.supports_content_filtering():
1411
 
                # We get the path from the working tree if it exists.
1412
 
                # That fails though when OTHER is adding a file, so
1413
 
                # we fall back to the other tree to find the path if
1414
 
                # it doesn't exist locally.
1415
 
                try:
1416
 
                    filter_tree_path = wt.id2path(file_id)
1417
 
                except errors.NoSuchId:
1418
 
                    filter_tree_path = self.other_tree.id2path(file_id)
1419
 
            else:
1420
 
                # Skip the id2path lookup for older formats
1421
 
                filter_tree_path = None
1422
 
            transform.create_from_tree(self.tt, trans_id,
1423
 
                             self.other_tree, file_id,
1424
 
                             filter_tree_path=filter_tree_path)
 
1456
            transform.create_from_tree(
 
1457
                self.tt, trans_id, self.other_tree, file_id,
 
1458
                filter_tree_path=self._get_filter_tree_path(file_id))
1425
1459
            return 'done', None
1426
 
        elif file_in_this:
 
1460
        elif self.this_tree.has_id(file_id):
1427
1461
            # OTHER deleted the file
1428
1462
            return 'delete', None
1429
1463
        else:
1455
1489
    def get_lines(self, tree, file_id):
1456
1490
        """Return the lines in a file, or an empty list."""
1457
1491
        if tree.has_id(file_id):
1458
 
            return tree.get_file(file_id).readlines()
 
1492
            return tree.get_file_lines(file_id)
1459
1493
        else:
1460
1494
            return []
1461
1495
 
1503
1537
                                              other_lines)
1504
1538
            file_group.append(trans_id)
1505
1539
 
 
1540
 
 
1541
    def _get_filter_tree_path(self, file_id):
 
1542
        if self.this_tree.supports_content_filtering():
 
1543
            # We get the path from the working tree if it exists.
 
1544
            # That fails though when OTHER is adding a file, so
 
1545
            # we fall back to the other tree to find the path if
 
1546
            # it doesn't exist locally.
 
1547
            try:
 
1548
                return self.this_tree.id2path(file_id)
 
1549
            except errors.NoSuchId:
 
1550
                return self.other_tree.id2path(file_id)
 
1551
        # Skip the id2path lookup for older formats
 
1552
        return None
 
1553
 
1506
1554
    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
1507
1555
                        base_lines=None, other_lines=None, set_version=False,
1508
1556
                        no_base=False):
1574
1622
        if winner == 'this' and file_status != "modified":
1575
1623
            return
1576
1624
        trans_id = self.tt.trans_id_file_id(file_id)
1577
 
        try:
1578
 
            if self.tt.final_kind(trans_id) != "file":
1579
 
                return
1580
 
        except errors.NoSuchFile:
 
1625
        if self.tt.final_kind(trans_id) != "file":
1581
1626
            return
1582
1627
        if winner == "this":
1583
1628
            executability = this_executable
1594
1639
 
1595
1640
    def cook_conflicts(self, fs_conflicts):
1596
1641
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1597
 
        self.cooked_conflicts.extend(transform.cook_conflicts(
1598
 
                fs_conflicts, self.tt))
 
1642
        content_conflict_file_ids = set()
 
1643
        cooked_conflicts = transform.cook_conflicts(fs_conflicts, self.tt)
1599
1644
        fp = transform.FinalPaths(self.tt)
1600
1645
        for conflict in self._raw_conflicts:
1601
1646
            conflict_type = conflict[0]
1612
1657
                if other_parent is None or other_name is None:
1613
1658
                    other_path = '<deleted>'
1614
1659
                else:
1615
 
                    parent_path =  fp.get_path(
1616
 
                        self.tt.trans_id_file_id(other_parent))
 
1660
                    if other_parent == self.other_tree.get_root_id():
 
1661
                        # The tree transform doesn't know about the other root,
 
1662
                        # so we special case here to avoid a NoFinalPath
 
1663
                        # exception
 
1664
                        parent_path = ''
 
1665
                    else:
 
1666
                        parent_path =  fp.get_path(
 
1667
                            self.tt.trans_id_file_id(other_parent))
1617
1668
                    other_path = osutils.pathjoin(parent_path, other_name)
1618
1669
                c = _mod_conflicts.Conflict.factory(
1619
1670
                    'path conflict', path=this_path,
1623
1674
                for trans_id in conflict[1]:
1624
1675
                    file_id = self.tt.final_file_id(trans_id)
1625
1676
                    if file_id is not None:
 
1677
                        # Ok we found the relevant file-id
1626
1678
                        break
1627
1679
                path = fp.get_path(trans_id)
1628
1680
                for suffix in ('.BASE', '.THIS', '.OTHER'):
1629
1681
                    if path.endswith(suffix):
 
1682
                        # Here is the raw path
1630
1683
                        path = path[:-len(suffix)]
1631
1684
                        break
1632
1685
                c = _mod_conflicts.Conflict.factory(conflict_type,
1633
1686
                                                    path=path, file_id=file_id)
 
1687
                content_conflict_file_ids.add(file_id)
1634
1688
            elif conflict_type == 'text conflict':
1635
1689
                trans_id = conflict[1]
1636
1690
                path = fp.get_path(trans_id)
1639
1693
                                                    path=path, file_id=file_id)
1640
1694
            else:
1641
1695
                raise AssertionError('bad conflict type: %r' % (conflict,))
 
1696
            cooked_conflicts.append(c)
 
1697
 
 
1698
        self.cooked_conflicts = []
 
1699
        # We want to get rid of path conflicts when a corresponding contents
 
1700
        # conflict exists. This can occur when one branch deletes a file while
 
1701
        # the other renames *and* modifies it. In this case, the content
 
1702
        # conflict is enough.
 
1703
        for c in cooked_conflicts:
 
1704
            if (c.typestring == 'path conflict'
 
1705
                and c.file_id in content_conflict_file_ids):
 
1706
                continue
1642
1707
            self.cooked_conflicts.append(c)
1643
1708
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1644
1709
 
1750
1815
            osutils.rmtree(temp_dir)
1751
1816
 
1752
1817
 
 
1818
class PathNotInTree(errors.BzrError):
 
1819
 
 
1820
    _fmt = """Merge-into failed because %(tree)s does not contain %(path)s."""
 
1821
 
 
1822
    def __init__(self, path, tree):
 
1823
        errors.BzrError.__init__(self, path=path, tree=tree)
 
1824
 
 
1825
 
 
1826
class MergeIntoMerger(Merger):
 
1827
    """Merger that understands other_tree will be merged into a subdir.
 
1828
 
 
1829
    This also changes the Merger api so that it uses real Branch, revision_id,
 
1830
    and RevisonTree objects, rather than using revision specs.
 
1831
    """
 
1832
 
 
1833
    def __init__(self, this_tree, other_branch, other_tree, target_subdir,
 
1834
            source_subpath, other_rev_id=None):
 
1835
        """Create a new MergeIntoMerger object.
 
1836
 
 
1837
        source_subpath in other_tree will be effectively copied to
 
1838
        target_subdir in this_tree.
 
1839
 
 
1840
        :param this_tree: The tree that we will be merging into.
 
1841
        :param other_branch: The Branch we will be merging from.
 
1842
        :param other_tree: The RevisionTree object we want to merge.
 
1843
        :param target_subdir: The relative path where we want to merge
 
1844
            other_tree into this_tree
 
1845
        :param source_subpath: The relative path specifying the subtree of
 
1846
            other_tree to merge into this_tree.
 
1847
        """
 
1848
        # It is assumed that we are merging a tree that is not in our current
 
1849
        # ancestry, which means we are using the "EmptyTree" as our basis.
 
1850
        null_ancestor_tree = this_tree.branch.repository.revision_tree(
 
1851
                                _mod_revision.NULL_REVISION)
 
1852
        super(MergeIntoMerger, self).__init__(
 
1853
            this_branch=this_tree.branch,
 
1854
            this_tree=this_tree,
 
1855
            other_tree=other_tree,
 
1856
            base_tree=null_ancestor_tree,
 
1857
            )
 
1858
        self._target_subdir = target_subdir
 
1859
        self._source_subpath = source_subpath
 
1860
        self.other_branch = other_branch
 
1861
        if other_rev_id is None:
 
1862
            other_rev_id = other_tree.get_revision_id()
 
1863
        self.other_rev_id = self.other_basis = other_rev_id
 
1864
        self.base_is_ancestor = True
 
1865
        self.backup_files = True
 
1866
        self.merge_type = Merge3Merger
 
1867
        self.show_base = False
 
1868
        self.reprocess = False
 
1869
        self.interesting_ids = None
 
1870
        self.merge_type = _MergeTypeParameterizer(MergeIntoMergeType,
 
1871
              target_subdir=self._target_subdir,
 
1872
              source_subpath=self._source_subpath)
 
1873
        if self._source_subpath != '':
 
1874
            # If this isn't a partial merge make sure the revisions will be
 
1875
            # present.
 
1876
            self._maybe_fetch(self.other_branch, self.this_branch,
 
1877
                self.other_basis)
 
1878
 
 
1879
    def set_pending(self):
 
1880
        if self._source_subpath != '':
 
1881
            return
 
1882
        Merger.set_pending(self)
 
1883
 
 
1884
 
 
1885
class _MergeTypeParameterizer(object):
 
1886
    """Wrap a merge-type class to provide extra parameters.
 
1887
    
 
1888
    This is hack used by MergeIntoMerger to pass some extra parameters to its
 
1889
    merge_type.  Merger.do_merge() sets up its own set of parameters to pass to
 
1890
    the 'merge_type' member.  It is difficult override do_merge without
 
1891
    re-writing the whole thing, so instead we create a wrapper which will pass
 
1892
    the extra parameters.
 
1893
    """
 
1894
 
 
1895
    def __init__(self, merge_type, **kwargs):
 
1896
        self._extra_kwargs = kwargs
 
1897
        self._merge_type = merge_type
 
1898
 
 
1899
    def __call__(self, *args, **kwargs):
 
1900
        kwargs.update(self._extra_kwargs)
 
1901
        return self._merge_type(*args, **kwargs)
 
1902
 
 
1903
    def __getattr__(self, name):
 
1904
        return getattr(self._merge_type, name)
 
1905
 
 
1906
 
 
1907
class MergeIntoMergeType(Merge3Merger):
 
1908
    """Merger that incorporates a tree (or part of a tree) into another."""
 
1909
 
 
1910
    def __init__(self, *args, **kwargs):
 
1911
        """Initialize the merger object.
 
1912
 
 
1913
        :param args: See Merge3Merger.__init__'s args.
 
1914
        :param kwargs: See Merge3Merger.__init__'s keyword args, except for
 
1915
            source_subpath and target_subdir.
 
1916
        :keyword source_subpath: The relative path specifying the subtree of
 
1917
            other_tree to merge into this_tree.
 
1918
        :keyword target_subdir: The relative path where we want to merge
 
1919
            other_tree into this_tree
 
1920
        """
 
1921
        # All of the interesting work happens during Merge3Merger.__init__(),
 
1922
        # so we have have to hack in to get our extra parameters set.
 
1923
        self._source_subpath = kwargs.pop('source_subpath')
 
1924
        self._target_subdir = kwargs.pop('target_subdir')
 
1925
        super(MergeIntoMergeType, self).__init__(*args, **kwargs)
 
1926
 
 
1927
    def _compute_transform(self):
 
1928
        child_pb = ui.ui_factory.nested_progress_bar()
 
1929
        try:
 
1930
            entries = self._entries_to_incorporate()
 
1931
            entries = list(entries)
 
1932
            for num, (entry, parent_id) in enumerate(entries):
 
1933
                child_pb.update(gettext('Preparing file merge'), num, len(entries))
 
1934
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1935
                trans_id = transform.new_by_entry(self.tt, entry,
 
1936
                    parent_trans_id, self.other_tree)
 
1937
        finally:
 
1938
            child_pb.finished()
 
1939
        self._finish_computing_transform()
 
1940
 
 
1941
    def _entries_to_incorporate(self):
 
1942
        """Yields pairs of (inventory_entry, new_parent)."""
 
1943
        other_inv = self.other_tree.inventory
 
1944
        subdir_id = other_inv.path2id(self._source_subpath)
 
1945
        if subdir_id is None:
 
1946
            # XXX: The error would be clearer if it gave the URL of the source
 
1947
            # branch, but we don't have a reference to that here.
 
1948
            raise PathNotInTree(self._source_subpath, "Source tree")
 
1949
        subdir = other_inv[subdir_id]
 
1950
        parent_in_target = osutils.dirname(self._target_subdir)
 
1951
        target_id = self.this_tree.inventory.path2id(parent_in_target)
 
1952
        if target_id is None:
 
1953
            raise PathNotInTree(self._target_subdir, "Target tree")
 
1954
        name_in_target = osutils.basename(self._target_subdir)
 
1955
        merge_into_root = subdir.copy()
 
1956
        merge_into_root.name = name_in_target
 
1957
        if self.this_tree.inventory.has_id(merge_into_root.file_id):
 
1958
            # Give the root a new file-id.
 
1959
            # This can happen fairly easily if the directory we are
 
1960
            # incorporating is the root, and both trees have 'TREE_ROOT' as
 
1961
            # their root_id.  Users will expect this to Just Work, so we
 
1962
            # change the file-id here.
 
1963
            # Non-root file-ids could potentially conflict too.  That's really
 
1964
            # an edge case, so we don't do anything special for those.  We let
 
1965
            # them cause conflicts.
 
1966
            merge_into_root.file_id = generate_ids.gen_file_id(name_in_target)
 
1967
        yield (merge_into_root, target_id)
 
1968
        if subdir.kind != 'directory':
 
1969
            # No children, so we are done.
 
1970
            return
 
1971
        for ignored_path, entry in other_inv.iter_entries_by_dir(subdir_id):
 
1972
            parent_id = entry.parent_id
 
1973
            if parent_id == subdir.file_id:
 
1974
                # The root's parent ID has changed, so make sure children of
 
1975
                # the root refer to the new ID.
 
1976
                parent_id = merge_into_root.file_id
 
1977
            yield (entry, parent_id)
 
1978
 
 
1979
 
1753
1980
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1754
1981
                backup_files=False,
1755
1982
                merge_type=Merge3Merger,
1763
1990
                change_reporter=None):
1764
1991
    """Primary interface for merging.
1765
1992
 
1766
 
        typical use is probably
1767
 
        'merge_inner(branch, branch.get_revision_tree(other_revision),
1768
 
                     branch.get_revision_tree(base_revision))'
1769
 
        """
 
1993
    Typical use is probably::
 
1994
 
 
1995
        merge_inner(branch, branch.get_revision_tree(other_revision),
 
1996
                    branch.get_revision_tree(base_revision))
 
1997
    """
1770
1998
    if this_tree is None:
1771
1999
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1772
 
                              "parameter as of bzrlib version 0.8.")
 
2000
                              "parameter")
1773
2001
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1774
2002
                    pb=pb, change_reporter=change_reporter)
1775
2003
    merger.backup_files = backup_files
1792
2020
    merger.set_base_revision(get_revision_id(), this_branch)
1793
2021
    return merger.do_merge()
1794
2022
 
 
2023
 
 
2024
merge_type_registry = registry.Registry()
 
2025
merge_type_registry.register('diff3', Diff3Merger,
 
2026
                             "Merge using external diff3.")
 
2027
merge_type_registry.register('lca', LCAMerger,
 
2028
                             "LCA-newness merge.")
 
2029
merge_type_registry.register('merge3', Merge3Merger,
 
2030
                             "Native diff3-style merge.")
 
2031
merge_type_registry.register('weave', WeaveMerger,
 
2032
                             "Weave-based merge.")
 
2033
 
 
2034
 
1795
2035
def get_merge_type_registry():
1796
 
    """Merge type registry is in bzrlib.option to avoid circular imports.
 
2036
    """Merge type registry was previously in bzrlib.option
1797
2037
 
1798
 
    This method provides a sanctioned way to retrieve it.
 
2038
    This method provides a backwards compatible way to retrieve it.
1799
2039
    """
1800
 
    from bzrlib import option
1801
 
    return option._merge_type_registry
 
2040
    return merge_type_registry
1802
2041
 
1803
2042
 
1804
2043
def _plan_annotate_merge(annotated_a, annotated_b, ancestors_a, ancestors_b):
2229
2468
class _PlanLCAMerge(_PlanMergeBase):
2230
2469
    """
2231
2470
    This merge algorithm differs from _PlanMerge in that:
 
2471
 
2232
2472
    1. comparisons are done against LCAs only
2233
2473
    2. cases where a contested line is new versus one LCA but old versus
2234
2474
       another are marked as conflicts, by emitting the line as conflicted-a
2275
2515
 
2276
2516
        If a line is killed and new, this indicates that the two merge
2277
2517
        revisions contain differing conflict resolutions.
 
2518
 
2278
2519
        :param revision_id: The id of the revision in which the lines are
2279
2520
            unique
2280
2521
        :param unique_line_numbers: The line numbers of unique lines.
2281
 
        :return a tuple of (new_this, killed_other):
 
2522
        :return: a tuple of (new_this, killed_other)
2282
2523
        """
2283
2524
        new = set()
2284
2525
        killed = set()