← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

(vila) Revise legal option names to be less drastic. (Vincent Ladeuil)

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.
93
113
        return ('not applicable', None)
94
114
 
95
115
 
96
 
class ConfigurableFileMerger(AbstractPerFileMerger):
 
116
class PerFileMerger(AbstractPerFileMerger):
 
117
    """Merge individual files when self.file_matches returns True.
 
118
 
 
119
    This class is intended to be subclassed.  The file_matches and
 
120
    merge_matching methods should be overridden with concrete implementations.
 
121
    """
 
122
 
 
123
    def file_matches(self, params):
 
124
        """Return True if merge_matching should be called on this file.
 
125
 
 
126
        Only called with merges of plain files with no clear winner.
 
127
 
 
128
        Subclasses must override this.
 
129
        """
 
130
        raise NotImplementedError(self.file_matches)
 
131
 
 
132
    def get_filename(self, params, tree):
 
133
        """Lookup the filename (i.e. basename, not path), given a Tree (e.g.
 
134
        self.merger.this_tree) and a MergeFileHookParams.
 
135
        """
 
136
        return osutils.basename(tree.id2path(params.file_id))
 
137
 
 
138
    def get_filepath(self, params, tree):
 
139
        """Calculate the path to the file in a tree.
 
140
 
 
141
        :param params: A MergeFileHookParams describing the file to merge
 
142
        :param tree: a Tree, e.g. self.merger.this_tree.
 
143
        """
 
144
        return tree.id2path(params.file_id)
 
145
 
 
146
    def merge_contents(self, params):
 
147
        """Merge the contents of a single file."""
 
148
        # Check whether this custom merge logic should be used.
 
149
        if (
 
150
            # OTHER is a straight winner, rely on default merge.
 
151
            params.winner == 'other' or
 
152
            # THIS and OTHER aren't both files.
 
153
            not params.is_file_merge() or
 
154
            # The filename doesn't match
 
155
            not self.file_matches(params)):
 
156
            return 'not_applicable', None
 
157
        return self.merge_matching(params)
 
158
 
 
159
    def merge_matching(self, params):
 
160
        """Merge the contents of a single file that has matched the criteria
 
161
        in PerFileMerger.merge_contents (is a conflict, is a file,
 
162
        self.file_matches is True).
 
163
 
 
164
        Subclasses must override this.
 
165
        """
 
166
        raise NotImplementedError(self.merge_matching)
 
167
 
 
168
 
 
169
class ConfigurableFileMerger(PerFileMerger):
97
170
    """Merge individual files when configured via a .conf file.
98
171
 
99
172
    This is a base class for concrete custom file merging logic. Concrete
122
195
        if self.name_prefix is None:
123
196
            raise ValueError("name_prefix must be set.")
124
197
 
125
 
    def filename_matches_config(self, params):
 
198
    def file_matches(self, params):
126
199
        """Check whether the file should call the merge hook.
127
200
 
128
201
        <name_prefix>_merge_files configuration variable is a list of files
142
215
                affected_files = self.default_files
143
216
            self.affected_files = affected_files
144
217
        if affected_files:
145
 
            filename = self.merger.this_tree.id2path(params.file_id)
146
 
            if filename in affected_files:
 
218
            filepath = self.get_filepath(params, self.merger.this_tree)
 
219
            if filepath in affected_files:
147
220
                return True
148
221
        return False
149
222
 
150
 
    def merge_contents(self, params):
151
 
        """Merge the contents of a single file."""
152
 
        # First, check whether this custom merge logic should be used.  We
153
 
        # expect most files should not be merged by this handler.
154
 
        if (
155
 
            # OTHER is a straight winner, rely on default merge.
156
 
            params.winner == 'other' or
157
 
            # THIS and OTHER aren't both files.
158
 
            not params.is_file_merge() or
159
 
            # The filename isn't listed in the 'NAME_merge_files' config
160
 
            # option.
161
 
            not self.filename_matches_config(params)):
162
 
            return 'not_applicable', None
 
223
    def merge_matching(self, params):
163
224
        return self.merge_text(params)
164
225
 
165
226
    def merge_text(self, params):
172
233
        raise NotImplementedError(self.merge_text)
173
234
 
174
235
 
175
 
class MergeHookParams(object):
 
236
class MergeFileHookParams(object):
176
237
    """Object holding parameters passed to merge_file_content hooks.
177
238
 
178
239
    There are some fields hooks can access:
380
441
        return self._cached_trees[revision_id]
381
442
 
382
443
    def _get_tree(self, treespec, possible_transports=None):
383
 
        from bzrlib import workingtree
384
444
        location, revno = treespec
385
445
        if revno is None:
386
446
            tree = workingtree.WorkingTree.open_containing(location)[0]
394
454
        revision_id = _mod_revision.ensure_null(revision_id)
395
455
        return branch, self.revision_tree(revision_id, branch)
396
456
 
397
 
    @deprecated_method(deprecated_in((2, 1, 0)))
398
 
    def ensure_revision_trees(self):
399
 
        if self.this_revision_tree is None:
400
 
            self.this_basis_tree = self.revision_tree(self.this_basis)
401
 
            if self.this_basis == self.this_rev_id:
402
 
                self.this_revision_tree = self.this_basis_tree
403
 
 
404
 
        if self.other_rev_id is None:
405
 
            other_basis_tree = self.revision_tree(self.other_basis)
406
 
            if other_basis_tree.has_changes(self.other_tree):
407
 
                raise errors.WorkingTreeNotRevision(self.this_tree)
408
 
            other_rev_id = self.other_basis
409
 
            self.other_tree = other_basis_tree
410
 
 
411
 
    @deprecated_method(deprecated_in((2, 1, 0)))
412
 
    def file_revisions(self, file_id):
413
 
        self.ensure_revision_trees()
414
 
        def get_id(tree, file_id):
415
 
            revision_id = tree.inventory[file_id].revision
416
 
            return revision_id
417
 
        if self.this_rev_id is None:
418
 
            if self.this_basis_tree.get_file_sha1(file_id) != \
419
 
                self.this_tree.get_file_sha1(file_id):
420
 
                raise errors.WorkingTreeNotRevision(self.this_tree)
421
 
 
422
 
        trees = (self.this_basis_tree, self.other_tree)
423
 
        return [get_id(tree, file_id) for tree in trees]
424
 
 
425
 
    @deprecated_method(deprecated_in((2, 1, 0)))
426
 
    def check_basis(self, check_clean, require_commits=True):
427
 
        if self.this_basis is None and require_commits is True:
428
 
            raise errors.BzrCommandError(
429
 
                "This branch has no commits."
430
 
                " (perhaps you would prefer 'bzr pull')")
431
 
        if check_clean:
432
 
            self.compare_basis()
433
 
            if self.this_basis != self.this_rev_id:
434
 
                raise errors.UncommittedChanges(self.this_tree)
435
 
 
436
 
    @deprecated_method(deprecated_in((2, 1, 0)))
437
 
    def compare_basis(self):
438
 
        try:
439
 
            basis_tree = self.revision_tree(self.this_tree.last_revision())
440
 
        except errors.NoSuchRevision:
441
 
            basis_tree = self.this_tree.basis_tree()
442
 
        if not self.this_tree.has_changes(basis_tree):
443
 
            self.this_rev_id = self.this_basis
444
 
 
445
457
    def set_interesting_files(self, file_list):
446
458
        self.interesting_files = file_list
447
459
 
454
466
    def _add_parent(self):
455
467
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
456
468
        new_parent_trees = []
457
 
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
 
469
        operation = cleanup.OperationWithCleanups(
 
470
            self.this_tree.set_parent_trees)
458
471
        for revision_id in new_parents:
459
472
            try:
460
473
                tree = self.revision_tree(revision_id)
491
504
                raise errors.NoCommits(self.other_branch)
492
505
        if self.other_rev_id is not None:
493
506
            self._cached_trees[self.other_rev_id] = self.other_tree
494
 
        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)
495
508
 
496
509
    def set_other_revision(self, revision_id, other_branch):
497
510
        """Set 'other' based on a branch and revision id
535
548
            elif len(lcas) == 1:
536
549
                self.base_rev_id = list(lcas)[0]
537
550
            else: # len(lcas) > 1
 
551
                self._is_criss_cross = True
538
552
                if len(lcas) > 2:
539
553
                    # find_unique_lca can only handle 2 nodes, so we have to
540
554
                    # start back at the beginning. It is a shame to traverse
545
559
                else:
546
560
                    self.base_rev_id = self.revision_graph.find_unique_lca(
547
561
                                            *lcas)
548
 
                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
 
549
567
            if self.base_rev_id == _mod_revision.NULL_REVISION:
550
568
                raise errors.UnrelatedBranches()
551
569
            if self._is_criss_cross:
552
570
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
553
571
                              ' help criss-cross.')
554
572
                trace.mutter('Criss-cross lcas: %r' % lcas)
555
 
                interesting_revision_ids = [self.base_rev_id]
556
 
                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)
557
579
                interesting_trees = dict((t.get_revision_id(), t)
558
580
                    for t in self.this_branch.repository.revision_trees(
559
581
                        interesting_revision_ids))
560
582
                self._cached_trees.update(interesting_trees)
561
 
                self.base_tree = interesting_trees.pop(self.base_rev_id)
562
 
                sorted_lca_keys = self.revision_graph.find_merge_order(
563
 
                    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)
564
587
                self._lca_trees = [interesting_trees[key]
565
588
                                   for key in sorted_lca_keys]
566
589
            else:
589
612
            self._maybe_fetch(base_branch, self.this_branch, self.base_rev_id)
590
613
 
591
614
    def make_merger(self):
592
 
        kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
 
615
        kwargs = {'working_tree': self.this_tree, 'this_tree': self.this_tree,
593
616
                  'other_tree': self.other_tree,
594
617
                  'interesting_ids': self.interesting_ids,
595
618
                  'interesting_files': self.interesting_files,
596
619
                  'this_branch': self.this_branch,
 
620
                  'other_branch': self.other_branch,
597
621
                  'do_merge': False}
598
622
        if self.merge_type.requires_base:
599
623
            kwargs['base_tree'] = self.base_tree
625
649
        merge = self.make_merger()
626
650
        if self.other_branch is not None:
627
651
            self.other_branch.update_references(self.this_branch)
 
652
        for hook in Merger.hooks['pre_merge']:
 
653
            hook(merge)
628
654
        merge.do_merge()
 
655
        for hook in Merger.hooks['post_merge']:
 
656
            hook(merge)
629
657
        if self.recurse == 'down':
630
658
            for relpath, file_id in self.this_tree.iter_references():
631
659
                sub_tree = self.this_tree.get_nested_tree(file_id, relpath)
635
663
                    continue
636
664
                sub_merge = Merger(sub_tree.branch, this_tree=sub_tree)
637
665
                sub_merge.merge_type = self.merge_type
638
 
                other_branch = self.other_branch.reference_parent(file_id, relpath)
 
666
                other_branch = self.other_branch.reference_parent(file_id,
 
667
                                                                  relpath)
639
668
                sub_merge.set_other_revision(other_revision, other_branch)
640
669
                base_revision = self.base_tree.get_reference_revision(file_id)
641
670
                sub_merge.base_tree = \
645
674
        return merge
646
675
 
647
676
    def do_merge(self):
648
 
        operation = OperationWithCleanups(self._do_merge_to)
 
677
        operation = cleanup.OperationWithCleanups(self._do_merge_to)
649
678
        self.this_tree.lock_tree_write()
650
679
        operation.add_cleanup(self.this_tree.unlock)
651
680
        if self.base_tree is not None:
657
686
        merge = operation.run_simple()
658
687
        if len(merge.cooked_conflicts) == 0:
659
688
            if not self.ignore_zero and not trace.is_quiet():
660
 
                trace.note("All changes applied successfully.")
 
689
                trace.note(gettext("All changes applied successfully."))
661
690
        else:
662
 
            trace.note("%d conflicts encountered."
 
691
            trace.note(gettext("%d conflicts encountered.")
663
692
                       % len(merge.cooked_conflicts))
664
693
 
665
694
        return len(merge.cooked_conflicts)
697
726
                 interesting_ids=None, reprocess=False, show_base=False,
698
727
                 pb=None, pp=None, change_reporter=None,
699
728
                 interesting_files=None, do_merge=True,
700
 
                 cherrypick=False, lca_trees=None, this_branch=None):
 
729
                 cherrypick=False, lca_trees=None, this_branch=None,
 
730
                 other_branch=None):
701
731
        """Initialize the merger object and perform the merge.
702
732
 
703
733
        :param working_tree: The working tree to apply the merge to
704
734
        :param this_tree: The local tree in the merge operation
705
735
        :param base_tree: The common tree in the merge operation
706
736
        :param other_tree: The other tree to merge changes from
707
 
        :param this_branch: The branch associated with this_tree
 
737
        :param this_branch: The branch associated with this_tree.  Defaults to
 
738
            this_tree.branch if not supplied.
 
739
        :param other_branch: The branch associated with other_tree, if any.
708
740
        :param interesting_ids: The file_ids of files that should be
709
741
            participate in the merge.  May not be combined with
710
742
            interesting_files.
728
760
        if interesting_files is not None and interesting_ids is not None:
729
761
            raise ValueError(
730
762
                'specify either interesting_ids or interesting_files')
 
763
        if this_branch is None:
 
764
            this_branch = this_tree.branch
731
765
        self.interesting_ids = interesting_ids
732
766
        self.interesting_files = interesting_files
733
 
        self.this_tree = working_tree
 
767
        self.working_tree = working_tree
 
768
        self.this_tree = this_tree
734
769
        self.base_tree = base_tree
735
770
        self.other_tree = other_tree
736
771
        self.this_branch = this_branch
 
772
        self.other_branch = other_branch
737
773
        self._raw_conflicts = []
738
774
        self.cooked_conflicts = []
739
775
        self.reprocess = reprocess
754
790
            warnings.warn("pb argument to Merge3Merger is deprecated")
755
791
 
756
792
    def do_merge(self):
757
 
        operation = OperationWithCleanups(self._do_merge)
758
 
        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()
759
797
        operation.add_cleanup(self.this_tree.unlock)
760
798
        self.base_tree.lock_read()
761
799
        operation.add_cleanup(self.base_tree.unlock)
764
802
        operation.run()
765
803
 
766
804
    def _do_merge(self, operation):
767
 
        self.tt = transform.TreeTransform(self.this_tree, None)
 
805
        self.tt = transform.TreeTransform(self.working_tree, None)
768
806
        operation.add_cleanup(self.tt.finalize)
769
807
        self._compute_transform()
770
808
        results = self.tt.apply(no_conflicts=True)
771
809
        self.write_modified(results)
772
810
        try:
773
 
            self.this_tree.add_conflicts(self.cooked_conflicts)
 
811
            self.working_tree.add_conflicts(self.cooked_conflicts)
774
812
        except errors.UnsupportedOperation:
775
813
            pass
776
814
 
777
815
    def make_preview_transform(self):
778
 
        operation = OperationWithCleanups(self._make_preview_transform)
 
816
        operation = cleanup.OperationWithCleanups(self._make_preview_transform)
779
817
        self.base_tree.lock_read()
780
818
        operation.add_cleanup(self.base_tree.unlock)
781
819
        self.other_tree.lock_read()
783
821
        return operation.run_simple()
784
822
 
785
823
    def _make_preview_transform(self):
786
 
        self.tt = transform.TransformPreview(self.this_tree)
 
824
        self.tt = transform.TransformPreview(self.working_tree)
787
825
        self._compute_transform()
788
826
        return self.tt
789
827
 
794
832
        else:
795
833
            entries = self._entries_lca()
796
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]
797
840
        child_pb = ui.ui_factory.nested_progress_bar()
798
841
        try:
799
 
            factories = Merger.hooks['merge_file_content']
800
 
            hooks = [factory(self) for factory in factories] + [self]
801
 
            self.active_hooks = [hook for hook in hooks if hook is not None]
802
842
            for num, (file_id, changed, parents3, names3,
803
843
                      executable3) in enumerate(entries):
804
 
                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))
805
847
                self._merge_names(file_id, parents3, names3, resolver=resolver)
806
848
                if changed:
807
849
                    file_status = self._do_merge_contents(file_id)
811
853
                    executable3, file_status, resolver=resolver)
812
854
        finally:
813
855
            child_pb.finished()
814
 
        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
        """
815
864
        child_pb = ui.ui_factory.nested_progress_bar()
816
865
        try:
817
866
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
824
873
                self.tt.iter_changes(), self.change_reporter)
825
874
        self.cook_conflicts(fs_conflicts)
826
875
        for conflict in self.cooked_conflicts:
827
 
            trace.warning(conflict)
 
876
            trace.warning(unicode(conflict))
828
877
 
829
878
    def _entries3(self):
830
879
        """Gather data about files modified between three trees.
837
886
        """
838
887
        result = []
839
888
        iterator = self.other_tree.iter_changes(self.base_tree,
840
 
                include_unchanged=True, specific_files=self.interesting_files,
 
889
                specific_files=self.interesting_files,
841
890
                extra_trees=[self.this_tree])
842
891
        this_entries = dict((e.file_id, e) for p, e in
843
892
                            self.this_tree.iter_entries_by_dir(
869
918
        it then compares with THIS and BASE.
870
919
 
871
920
        For the multi-valued entries, the format will be (BASE, [lca1, lca2])
872
 
        :return: [(file_id, changed, parents, names, executable)]
873
 
            file_id     Simple file_id of the entry
874
 
            changed     Boolean, True if the kind or contents changed
875
 
                        else False
876
 
            parents     ((base, [parent_id, in, lcas]), parent_id_other,
877
 
                         parent_id_this)
878
 
            names       ((base, [name, in, lcas]), name_in_other, name_in_this)
879
 
            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)
880
931
        """
881
932
        if self.interesting_files is not None:
882
933
            lookup_trees = [self.this_tree, self.base_tree]
889
940
        result = []
890
941
        walker = _mod_tree.MultiWalker(self.other_tree, self._lca_trees)
891
942
 
892
 
        base_inventory = self.base_tree.inventory
893
 
        this_inventory = self.this_tree.inventory
 
943
        base_inventory = self.base_tree.root_inventory
 
944
        this_inventory = self.this_tree.root_inventory
894
945
        for path, file_id, other_ie, lca_values in walker.iter_all():
895
946
            # Is this modified at all from any of the other trees?
896
947
            if other_ie is None:
924
975
                else:
925
976
                    lca_entries.append(lca_ie)
926
977
 
927
 
            if file_id in base_inventory:
 
978
            if base_inventory.has_id(file_id):
928
979
                base_ie = base_inventory[file_id]
929
980
            else:
930
981
                base_ie = _none_entry
931
982
 
932
 
            if file_id in this_inventory:
 
983
            if this_inventory.has_id(file_id):
933
984
                this_ie = this_inventory[file_id]
934
985
            else:
935
986
                this_ie = _none_entry
1027
1078
                          ))
1028
1079
        return result
1029
1080
 
1030
 
 
1031
 
    def fix_root(self):
1032
 
        try:
1033
 
            self.tt.final_kind(self.tt.root)
1034
 
        except errors.NoSuchFile:
1035
 
            self.tt.cancel_deletion(self.tt.root)
1036
 
        if self.tt.final_file_id(self.tt.root) is None:
1037
 
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
1038
 
                                 self.tt.root)
1039
 
        other_root_file_id = self.other_tree.get_root_id()
1040
 
        if other_root_file_id is None:
1041
 
            return
1042
 
        other_root = self.tt.trans_id_file_id(other_root_file_id)
1043
 
        if other_root == self.tt.root:
1044
 
            return
1045
 
        try:
1046
 
            self.tt.final_kind(other_root)
1047
 
        except errors.NoSuchFile:
1048
 
            return
1049
 
        if self.this_tree.has_id(self.other_tree.inventory.root.file_id):
1050
 
            # the other tree's root is a non-root in the current tree
1051
 
            return
1052
 
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
1053
 
        self.tt.cancel_creation(other_root)
1054
 
        self.tt.cancel_versioning(other_root)
1055
 
 
1056
 
    def reparent_children(self, ie, target):
1057
 
        for thing, child in ie.children.iteritems():
1058
 
            trans_id = self.tt.trans_id_file_id(child.file_id)
1059
 
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1060
 
 
1061
1081
    def write_modified(self, results):
1062
1082
        modified_hashes = {}
1063
1083
        for path in results.modified_paths:
1064
 
            file_id = self.this_tree.path2id(self.this_tree.relpath(path))
 
1084
            file_id = self.working_tree.path2id(self.working_tree.relpath(path))
1065
1085
            if file_id is None:
1066
1086
                continue
1067
 
            hash = self.this_tree.get_file_sha1(file_id)
 
1087
            hash = self.working_tree.get_file_sha1(file_id)
1068
1088
            if hash is None:
1069
1089
                continue
1070
1090
            modified_hashes[file_id] = hash
1071
 
        self.this_tree.set_merge_modified(modified_hashes)
 
1091
        self.working_tree.set_merge_modified(modified_hashes)
1072
1092
 
1073
1093
    @staticmethod
1074
1094
    def parent(entry, file_id):
1087
1107
    @staticmethod
1088
1108
    def contents_sha1(tree, file_id):
1089
1109
        """Determine the sha1 of the file contents (used as a key method)."""
1090
 
        if file_id not in tree:
 
1110
        if not tree.has_id(file_id):
1091
1111
            return None
1092
1112
        return tree.get_file_sha1(file_id)
1093
1113
 
1173
1193
        # At this point, the lcas disagree, and the tip disagree
1174
1194
        return 'conflict'
1175
1195
 
1176
 
    @staticmethod
1177
 
    @deprecated_method(deprecated_in((2, 2, 0)))
1178
 
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1179
 
        """Do a three-way test on a scalar.
1180
 
        Return "this", "other" or "conflict", depending whether a value wins.
1181
 
        """
1182
 
        key_base = key(base_tree, file_id)
1183
 
        key_other = key(other_tree, file_id)
1184
 
        #if base == other, either they all agree, or only THIS has changed.
1185
 
        if key_base == key_other:
1186
 
            return "this"
1187
 
        key_this = key(this_tree, file_id)
1188
 
        # "Ambiguous clean merge"
1189
 
        if key_this == key_other:
1190
 
            return "this"
1191
 
        elif key_this == key_base:
1192
 
            return "other"
1193
 
        else:
1194
 
            return "conflict"
1195
 
 
1196
1196
    def merge_names(self, file_id):
1197
1197
        def get_entry(tree):
1198
 
            if tree.has_id(file_id):
1199
 
                return tree.inventory[file_id]
1200
 
            else:
 
1198
            try:
 
1199
                return tree.root_inventory[file_id]
 
1200
            except errors.NoSuchId:
1201
1201
                return None
1202
1202
        this_entry = get_entry(self.this_tree)
1203
1203
        other_entry = get_entry(self.other_tree)
1238
1238
            self._raw_conflicts.append(('path conflict', trans_id, file_id,
1239
1239
                                        this_parent, this_name,
1240
1240
                                        other_parent, other_name))
1241
 
        if other_name is None:
 
1241
        if not self.other_tree.has_id(file_id):
1242
1242
            # it doesn't matter whether the result was 'other' or
1243
 
            # 'conflict'-- if there's no 'other', we leave it alone.
 
1243
            # 'conflict'-- if it has no file id, we leave it alone.
1244
1244
            return
1245
1245
        parent_id = parents[self.winner_idx[parent_id_winner]]
1246
 
        if parent_id is not None:
 
1246
        name = names[self.winner_idx[name_winner]]
 
1247
        if parent_id is not None or name is not None:
1247
1248
            # if we get here, name_winner and parent_winner are set to safe
1248
1249
            # values.
1249
 
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
1250
 
                                self.tt.trans_id_file_id(parent_id),
 
1250
            if parent_id is None and name is not None:
 
1251
                # if parent_id is None and name is non-None, current file is
 
1252
                # the tree root.
 
1253
                if names[self.winner_idx[parent_id_winner]] != '':
 
1254
                    raise AssertionError(
 
1255
                        'File looks like a root, but named %s' %
 
1256
                        names[self.winner_idx[parent_id_winner]])
 
1257
                parent_trans_id = transform.ROOT_PARENT
 
1258
            else:
 
1259
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1260
            self.tt.adjust_path(name, parent_trans_id,
1251
1261
                                self.tt.trans_id_file_id(file_id))
1252
1262
 
1253
1263
    def _do_merge_contents(self, file_id):
1254
1264
        """Performs a merge on file_id contents."""
1255
1265
        def contents_pair(tree):
1256
 
            if file_id not in tree:
 
1266
            if not tree.has_id(file_id):
1257
1267
                return (None, None)
1258
1268
            kind = tree.kind(file_id)
1259
1269
            if kind == "file":
1288
1298
        # We have a hypothetical conflict, but if we have files, then we
1289
1299
        # can try to merge the content
1290
1300
        trans_id = self.tt.trans_id_file_id(file_id)
1291
 
        params = MergeHookParams(self, file_id, trans_id, this_pair[0],
 
1301
        params = MergeFileHookParams(self, file_id, trans_id, this_pair[0],
1292
1302
            other_pair[0], winner)
1293
1303
        hooks = self.active_hooks
1294
1304
        hook_status = 'not_applicable'
1297
1307
            if hook_status != 'not_applicable':
1298
1308
                # Don't try any more hooks, this one applies.
1299
1309
                break
 
1310
        # If the merge ends up replacing the content of the file, we get rid of
 
1311
        # it at the end of this method (this variable is used to track the
 
1312
        # exceptions to this rule).
 
1313
        keep_this = False
1300
1314
        result = "modified"
1301
1315
        if hook_status == 'not_applicable':
1302
 
            # This is a contents conflict, because none of the available
1303
 
            # functions could merge it.
 
1316
            # No merge hook was able to resolve the situation. Two cases exist:
 
1317
            # a content conflict or a duplicate one.
1304
1318
            result = None
1305
1319
            name = self.tt.final_name(trans_id)
1306
1320
            parent_id = self.tt.final_parent(trans_id)
1307
 
            if self.this_tree.has_id(file_id):
1308
 
                self.tt.unversion_file(trans_id)
1309
 
            file_group = self._dump_conflicts(name, parent_id, file_id,
1310
 
                                              set_version=True)
1311
 
            self._raw_conflicts.append(('contents conflict', file_group))
 
1321
            duplicate = False
 
1322
            inhibit_content_conflict = False
 
1323
            if params.this_kind is None: # file_id is not in THIS
 
1324
                # Is the name used for a different file_id ?
 
1325
                dupe_path = self.other_tree.id2path(file_id)
 
1326
                this_id = self.this_tree.path2id(dupe_path)
 
1327
                if this_id is not None:
 
1328
                    # Two entries for the same path
 
1329
                    keep_this = True
 
1330
                    # versioning the merged file will trigger a duplicate
 
1331
                    # conflict
 
1332
                    self.tt.version_file(file_id, trans_id)
 
1333
                    transform.create_from_tree(
 
1334
                        self.tt, trans_id, self.other_tree, file_id,
 
1335
                        filter_tree_path=self._get_filter_tree_path(file_id))
 
1336
                    inhibit_content_conflict = True
 
1337
            elif params.other_kind is None: # file_id is not in OTHER
 
1338
                # Is the name used for a different file_id ?
 
1339
                dupe_path = self.this_tree.id2path(file_id)
 
1340
                other_id = self.other_tree.path2id(dupe_path)
 
1341
                if other_id is not None:
 
1342
                    # Two entries for the same path again, but here, the other
 
1343
                    # entry will also be merged.  We simply inhibit the
 
1344
                    # 'content' conflict creation because we know OTHER will
 
1345
                    # create (or has already created depending on ordering) an
 
1346
                    # entry at the same path. This will trigger a 'duplicate'
 
1347
                    # conflict later.
 
1348
                    keep_this = True
 
1349
                    inhibit_content_conflict = True
 
1350
            if not inhibit_content_conflict:
 
1351
                if params.this_kind is not None:
 
1352
                    self.tt.unversion_file(trans_id)
 
1353
                # This is a contents conflict, because none of the available
 
1354
                # functions could merge it.
 
1355
                file_group = self._dump_conflicts(name, parent_id, file_id,
 
1356
                                                  set_version=True)
 
1357
                self._raw_conflicts.append(('contents conflict', file_group))
1312
1358
        elif hook_status == 'success':
1313
1359
            self.tt.create_file(lines, trans_id)
1314
1360
        elif hook_status == 'conflicted':
1330
1376
            raise AssertionError('unknown hook_status: %r' % (hook_status,))
1331
1377
        if not self.this_tree.has_id(file_id) and result == "modified":
1332
1378
            self.tt.version_file(file_id, trans_id)
1333
 
        # The merge has been performed, so the old contents should not be
1334
 
        # retained.
1335
 
        try:
 
1379
        if not keep_this:
 
1380
            # The merge has been performed and produced a new content, so the
 
1381
            # old contents should not be retained.
1336
1382
            self.tt.delete_contents(trans_id)
1337
 
        except errors.NoSuchFile:
1338
 
            pass
1339
1383
        return result
1340
1384
 
1341
1385
    def _default_other_winner_merge(self, merge_hook_params):
1342
1386
        """Replace this contents with other."""
1343
1387
        file_id = merge_hook_params.file_id
1344
1388
        trans_id = merge_hook_params.trans_id
1345
 
        file_in_this = self.this_tree.has_id(file_id)
1346
1389
        if self.other_tree.has_id(file_id):
1347
1390
            # OTHER changed the file
1348
 
            wt = self.this_tree
1349
 
            if wt.supports_content_filtering():
1350
 
                # We get the path from the working tree if it exists.
1351
 
                # That fails though when OTHER is adding a file, so
1352
 
                # we fall back to the other tree to find the path if
1353
 
                # it doesn't exist locally.
1354
 
                try:
1355
 
                    filter_tree_path = wt.id2path(file_id)
1356
 
                except errors.NoSuchId:
1357
 
                    filter_tree_path = self.other_tree.id2path(file_id)
1358
 
            else:
1359
 
                # Skip the id2path lookup for older formats
1360
 
                filter_tree_path = None
1361
 
            transform.create_from_tree(self.tt, trans_id,
1362
 
                             self.other_tree, file_id,
1363
 
                             filter_tree_path=filter_tree_path)
 
1391
            transform.create_from_tree(
 
1392
                self.tt, trans_id, self.other_tree, file_id,
 
1393
                filter_tree_path=self._get_filter_tree_path(file_id))
1364
1394
            return 'done', None
1365
 
        elif file_in_this:
 
1395
        elif self.this_tree.has_id(file_id):
1366
1396
            # OTHER deleted the file
1367
1397
            return 'delete', None
1368
1398
        else:
1394
1424
    def get_lines(self, tree, file_id):
1395
1425
        """Return the lines in a file, or an empty list."""
1396
1426
        if tree.has_id(file_id):
1397
 
            return tree.get_file(file_id).readlines()
 
1427
            return tree.get_file_lines(file_id)
1398
1428
        else:
1399
1429
            return []
1400
1430
 
1442
1472
                                              other_lines)
1443
1473
            file_group.append(trans_id)
1444
1474
 
 
1475
 
 
1476
    def _get_filter_tree_path(self, file_id):
 
1477
        if self.this_tree.supports_content_filtering():
 
1478
            # We get the path from the working tree if it exists.
 
1479
            # That fails though when OTHER is adding a file, so
 
1480
            # we fall back to the other tree to find the path if
 
1481
            # it doesn't exist locally.
 
1482
            try:
 
1483
                return self.this_tree.id2path(file_id)
 
1484
            except errors.NoSuchId:
 
1485
                return self.other_tree.id2path(file_id)
 
1486
        # Skip the id2path lookup for older formats
 
1487
        return None
 
1488
 
1445
1489
    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
1446
1490
                        base_lines=None, other_lines=None, set_version=False,
1447
1491
                        no_base=False):
1513
1557
        if winner == 'this' and file_status != "modified":
1514
1558
            return
1515
1559
        trans_id = self.tt.trans_id_file_id(file_id)
1516
 
        try:
1517
 
            if self.tt.final_kind(trans_id) != "file":
1518
 
                return
1519
 
        except errors.NoSuchFile:
 
1560
        if self.tt.final_kind(trans_id) != "file":
1520
1561
            return
1521
1562
        if winner == "this":
1522
1563
            executability = this_executable
1533
1574
 
1534
1575
    def cook_conflicts(self, fs_conflicts):
1535
1576
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1536
 
        self.cooked_conflicts.extend(transform.cook_conflicts(
1537
 
                fs_conflicts, self.tt))
 
1577
        content_conflict_file_ids = set()
 
1578
        cooked_conflicts = transform.cook_conflicts(fs_conflicts, self.tt)
1538
1579
        fp = transform.FinalPaths(self.tt)
1539
1580
        for conflict in self._raw_conflicts:
1540
1581
            conflict_type = conflict[0]
1551
1592
                if other_parent is None or other_name is None:
1552
1593
                    other_path = '<deleted>'
1553
1594
                else:
1554
 
                    parent_path =  fp.get_path(
1555
 
                        self.tt.trans_id_file_id(other_parent))
 
1595
                    if other_parent == self.other_tree.get_root_id():
 
1596
                        # The tree transform doesn't know about the other root,
 
1597
                        # so we special case here to avoid a NoFinalPath
 
1598
                        # exception
 
1599
                        parent_path = ''
 
1600
                    else:
 
1601
                        parent_path =  fp.get_path(
 
1602
                            self.tt.trans_id_file_id(other_parent))
1556
1603
                    other_path = osutils.pathjoin(parent_path, other_name)
1557
1604
                c = _mod_conflicts.Conflict.factory(
1558
1605
                    'path conflict', path=this_path,
1562
1609
                for trans_id in conflict[1]:
1563
1610
                    file_id = self.tt.final_file_id(trans_id)
1564
1611
                    if file_id is not None:
 
1612
                        # Ok we found the relevant file-id
1565
1613
                        break
1566
1614
                path = fp.get_path(trans_id)
1567
1615
                for suffix in ('.BASE', '.THIS', '.OTHER'):
1568
1616
                    if path.endswith(suffix):
 
1617
                        # Here is the raw path
1569
1618
                        path = path[:-len(suffix)]
1570
1619
                        break
1571
1620
                c = _mod_conflicts.Conflict.factory(conflict_type,
1572
1621
                                                    path=path, file_id=file_id)
 
1622
                content_conflict_file_ids.add(file_id)
1573
1623
            elif conflict_type == 'text conflict':
1574
1624
                trans_id = conflict[1]
1575
1625
                path = fp.get_path(trans_id)
1578
1628
                                                    path=path, file_id=file_id)
1579
1629
            else:
1580
1630
                raise AssertionError('bad conflict type: %r' % (conflict,))
 
1631
            cooked_conflicts.append(c)
 
1632
 
 
1633
        self.cooked_conflicts = []
 
1634
        # We want to get rid of path conflicts when a corresponding contents
 
1635
        # conflict exists. This can occur when one branch deletes a file while
 
1636
        # the other renames *and* modifies it. In this case, the content
 
1637
        # conflict is enough.
 
1638
        for c in cooked_conflicts:
 
1639
            if (c.typestring == 'path conflict'
 
1640
                and c.file_id in content_conflict_file_ids):
 
1641
                continue
1581
1642
            self.cooked_conflicts.append(c)
1582
1643
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1583
1644
 
1689
1750
            osutils.rmtree(temp_dir)
1690
1751
 
1691
1752
 
 
1753
class PathNotInTree(errors.BzrError):
 
1754
 
 
1755
    _fmt = """Merge-into failed because %(tree)s does not contain %(path)s."""
 
1756
 
 
1757
    def __init__(self, path, tree):
 
1758
        errors.BzrError.__init__(self, path=path, tree=tree)
 
1759
 
 
1760
 
 
1761
class MergeIntoMerger(Merger):
 
1762
    """Merger that understands other_tree will be merged into a subdir.
 
1763
 
 
1764
    This also changes the Merger api so that it uses real Branch, revision_id,
 
1765
    and RevisonTree objects, rather than using revision specs.
 
1766
    """
 
1767
 
 
1768
    def __init__(self, this_tree, other_branch, other_tree, target_subdir,
 
1769
            source_subpath, other_rev_id=None):
 
1770
        """Create a new MergeIntoMerger object.
 
1771
 
 
1772
        source_subpath in other_tree will be effectively copied to
 
1773
        target_subdir in this_tree.
 
1774
 
 
1775
        :param this_tree: The tree that we will be merging into.
 
1776
        :param other_branch: The Branch we will be merging from.
 
1777
        :param other_tree: The RevisionTree object we want to merge.
 
1778
        :param target_subdir: The relative path where we want to merge
 
1779
            other_tree into this_tree
 
1780
        :param source_subpath: The relative path specifying the subtree of
 
1781
            other_tree to merge into this_tree.
 
1782
        """
 
1783
        # It is assumed that we are merging a tree that is not in our current
 
1784
        # ancestry, which means we are using the "EmptyTree" as our basis.
 
1785
        null_ancestor_tree = this_tree.branch.repository.revision_tree(
 
1786
                                _mod_revision.NULL_REVISION)
 
1787
        super(MergeIntoMerger, self).__init__(
 
1788
            this_branch=this_tree.branch,
 
1789
            this_tree=this_tree,
 
1790
            other_tree=other_tree,
 
1791
            base_tree=null_ancestor_tree,
 
1792
            )
 
1793
        self._target_subdir = target_subdir
 
1794
        self._source_subpath = source_subpath
 
1795
        self.other_branch = other_branch
 
1796
        if other_rev_id is None:
 
1797
            other_rev_id = other_tree.get_revision_id()
 
1798
        self.other_rev_id = self.other_basis = other_rev_id
 
1799
        self.base_is_ancestor = True
 
1800
        self.backup_files = True
 
1801
        self.merge_type = Merge3Merger
 
1802
        self.show_base = False
 
1803
        self.reprocess = False
 
1804
        self.interesting_ids = None
 
1805
        self.merge_type = _MergeTypeParameterizer(MergeIntoMergeType,
 
1806
              target_subdir=self._target_subdir,
 
1807
              source_subpath=self._source_subpath)
 
1808
        if self._source_subpath != '':
 
1809
            # If this isn't a partial merge make sure the revisions will be
 
1810
            # present.
 
1811
            self._maybe_fetch(self.other_branch, self.this_branch,
 
1812
                self.other_basis)
 
1813
 
 
1814
    def set_pending(self):
 
1815
        if self._source_subpath != '':
 
1816
            return
 
1817
        Merger.set_pending(self)
 
1818
 
 
1819
 
 
1820
class _MergeTypeParameterizer(object):
 
1821
    """Wrap a merge-type class to provide extra parameters.
 
1822
    
 
1823
    This is hack used by MergeIntoMerger to pass some extra parameters to its
 
1824
    merge_type.  Merger.do_merge() sets up its own set of parameters to pass to
 
1825
    the 'merge_type' member.  It is difficult override do_merge without
 
1826
    re-writing the whole thing, so instead we create a wrapper which will pass
 
1827
    the extra parameters.
 
1828
    """
 
1829
 
 
1830
    def __init__(self, merge_type, **kwargs):
 
1831
        self._extra_kwargs = kwargs
 
1832
        self._merge_type = merge_type
 
1833
 
 
1834
    def __call__(self, *args, **kwargs):
 
1835
        kwargs.update(self._extra_kwargs)
 
1836
        return self._merge_type(*args, **kwargs)
 
1837
 
 
1838
    def __getattr__(self, name):
 
1839
        return getattr(self._merge_type, name)
 
1840
 
 
1841
 
 
1842
class MergeIntoMergeType(Merge3Merger):
 
1843
    """Merger that incorporates a tree (or part of a tree) into another."""
 
1844
 
 
1845
    def __init__(self, *args, **kwargs):
 
1846
        """Initialize the merger object.
 
1847
 
 
1848
        :param args: See Merge3Merger.__init__'s args.
 
1849
        :param kwargs: See Merge3Merger.__init__'s keyword args, except for
 
1850
            source_subpath and target_subdir.
 
1851
        :keyword source_subpath: The relative path specifying the subtree of
 
1852
            other_tree to merge into this_tree.
 
1853
        :keyword target_subdir: The relative path where we want to merge
 
1854
            other_tree into this_tree
 
1855
        """
 
1856
        # All of the interesting work happens during Merge3Merger.__init__(),
 
1857
        # so we have have to hack in to get our extra parameters set.
 
1858
        self._source_subpath = kwargs.pop('source_subpath')
 
1859
        self._target_subdir = kwargs.pop('target_subdir')
 
1860
        super(MergeIntoMergeType, self).__init__(*args, **kwargs)
 
1861
 
 
1862
    def _compute_transform(self):
 
1863
        child_pb = ui.ui_factory.nested_progress_bar()
 
1864
        try:
 
1865
            entries = self._entries_to_incorporate()
 
1866
            entries = list(entries)
 
1867
            for num, (entry, parent_id) in enumerate(entries):
 
1868
                child_pb.update(gettext('Preparing file merge'), num, len(entries))
 
1869
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1870
                trans_id = transform.new_by_entry(self.tt, entry,
 
1871
                    parent_trans_id, self.other_tree)
 
1872
        finally:
 
1873
            child_pb.finished()
 
1874
        self._finish_computing_transform()
 
1875
 
 
1876
    def _entries_to_incorporate(self):
 
1877
        """Yields pairs of (inventory_entry, new_parent)."""
 
1878
        other_inv = self.other_tree.root_inventory
 
1879
        subdir_id = other_inv.path2id(self._source_subpath)
 
1880
        if subdir_id is None:
 
1881
            # XXX: The error would be clearer if it gave the URL of the source
 
1882
            # branch, but we don't have a reference to that here.
 
1883
            raise PathNotInTree(self._source_subpath, "Source tree")
 
1884
        subdir = other_inv[subdir_id]
 
1885
        parent_in_target = osutils.dirname(self._target_subdir)
 
1886
        target_id = self.this_tree.path2id(parent_in_target)
 
1887
        if target_id is None:
 
1888
            raise PathNotInTree(self._target_subdir, "Target tree")
 
1889
        name_in_target = osutils.basename(self._target_subdir)
 
1890
        merge_into_root = subdir.copy()
 
1891
        merge_into_root.name = name_in_target
 
1892
        if self.this_tree.has_id(merge_into_root.file_id):
 
1893
            # Give the root a new file-id.
 
1894
            # This can happen fairly easily if the directory we are
 
1895
            # incorporating is the root, and both trees have 'TREE_ROOT' as
 
1896
            # their root_id.  Users will expect this to Just Work, so we
 
1897
            # change the file-id here.
 
1898
            # Non-root file-ids could potentially conflict too.  That's really
 
1899
            # an edge case, so we don't do anything special for those.  We let
 
1900
            # them cause conflicts.
 
1901
            merge_into_root.file_id = generate_ids.gen_file_id(name_in_target)
 
1902
        yield (merge_into_root, target_id)
 
1903
        if subdir.kind != 'directory':
 
1904
            # No children, so we are done.
 
1905
            return
 
1906
        for ignored_path, entry in other_inv.iter_entries_by_dir(subdir_id):
 
1907
            parent_id = entry.parent_id
 
1908
            if parent_id == subdir.file_id:
 
1909
                # The root's parent ID has changed, so make sure children of
 
1910
                # the root refer to the new ID.
 
1911
                parent_id = merge_into_root.file_id
 
1912
            yield (entry, parent_id)
 
1913
 
 
1914
 
1692
1915
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1693
1916
                backup_files=False,
1694
1917
                merge_type=Merge3Merger,
1702
1925
                change_reporter=None):
1703
1926
    """Primary interface for merging.
1704
1927
 
1705
 
        typical use is probably
1706
 
        'merge_inner(branch, branch.get_revision_tree(other_revision),
1707
 
                     branch.get_revision_tree(base_revision))'
1708
 
        """
 
1928
    Typical use is probably::
 
1929
 
 
1930
        merge_inner(branch, branch.get_revision_tree(other_revision),
 
1931
                    branch.get_revision_tree(base_revision))
 
1932
    """
1709
1933
    if this_tree is None:
1710
1934
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1711
 
                              "parameter as of bzrlib version 0.8.")
 
1935
                              "parameter")
1712
1936
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1713
1937
                    pb=pb, change_reporter=change_reporter)
1714
1938
    merger.backup_files = backup_files
1731
1955
    merger.set_base_revision(get_revision_id(), this_branch)
1732
1956
    return merger.do_merge()
1733
1957
 
 
1958
 
 
1959
merge_type_registry = registry.Registry()
 
1960
merge_type_registry.register('diff3', Diff3Merger,
 
1961
                             "Merge using external diff3.")
 
1962
merge_type_registry.register('lca', LCAMerger,
 
1963
                             "LCA-newness merge.")
 
1964
merge_type_registry.register('merge3', Merge3Merger,
 
1965
                             "Native diff3-style merge.")
 
1966
merge_type_registry.register('weave', WeaveMerger,
 
1967
                             "Weave-based merge.")
 
1968
 
 
1969
 
1734
1970
def get_merge_type_registry():
1735
 
    """Merge type registry is in bzrlib.option to avoid circular imports.
 
1971
    """Merge type registry was previously in bzrlib.option
1736
1972
 
1737
 
    This method provides a sanctioned way to retrieve it.
 
1973
    This method provides a backwards compatible way to retrieve it.
1738
1974
    """
1739
 
    from bzrlib import option
1740
 
    return option._merge_type_registry
 
1975
    return merge_type_registry
1741
1976
 
1742
1977
 
1743
1978
def _plan_annotate_merge(annotated_a, annotated_b, ancestors_a, ancestors_b):
2168
2403
class _PlanLCAMerge(_PlanMergeBase):
2169
2404
    """
2170
2405
    This merge algorithm differs from _PlanMerge in that:
 
2406
 
2171
2407
    1. comparisons are done against LCAs only
2172
2408
    2. cases where a contested line is new versus one LCA but old versus
2173
2409
       another are marked as conflicts, by emitting the line as conflicted-a
2214
2450
 
2215
2451
        If a line is killed and new, this indicates that the two merge
2216
2452
        revisions contain differing conflict resolutions.
 
2453
 
2217
2454
        :param revision_id: The id of the revision in which the lines are
2218
2455
            unique
2219
2456
        :param unique_line_numbers: The line numbers of unique lines.
2220
 
        :return a tuple of (new_this, killed_other):
 
2457
        :return: a tuple of (new_this, killed_other)
2221
2458
        """
2222
2459
        new = set()
2223
2460
        killed = set()