← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

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
130
203
        """
131
204
        affected_files = self.affected_files
132
205
        if affected_files is None:
133
 
            config = self.merger.this_tree.branch.get_config()
 
206
            config = self.merger.this_branch.get_config()
134
207
            # Until bzr provides a better policy for caching the config, we
135
208
            # just add the part we're interested in to the params to avoid
136
209
            # reading the config files repeatedly (bazaar.conf, location.conf,
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
1015
1066
                        continue
1016
1067
                else:
1017
1068
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
1018
 
                # XXX: We need to handle kind == 'symlink'
1019
1069
 
1020
1070
            # If we have gotten this far, that means something has changed
1021
1071
            result.append((file_id, content_changed,
1028
1078
                          ))
1029
1079
        return result
1030
1080
 
1031
 
 
1032
 
    def fix_root(self):
1033
 
        try:
1034
 
            self.tt.final_kind(self.tt.root)
1035
 
        except errors.NoSuchFile:
1036
 
            self.tt.cancel_deletion(self.tt.root)
1037
 
        if self.tt.final_file_id(self.tt.root) is None:
1038
 
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
1039
 
                                 self.tt.root)
1040
 
        other_root_file_id = self.other_tree.get_root_id()
1041
 
        if other_root_file_id is None:
1042
 
            return
1043
 
        other_root = self.tt.trans_id_file_id(other_root_file_id)
1044
 
        if other_root == self.tt.root:
1045
 
            return
1046
 
        try:
1047
 
            self.tt.final_kind(other_root)
1048
 
        except errors.NoSuchFile:
1049
 
            return
1050
 
        if self.this_tree.has_id(self.other_tree.inventory.root.file_id):
1051
 
            # the other tree's root is a non-root in the current tree
1052
 
            return
1053
 
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
1054
 
        self.tt.cancel_creation(other_root)
1055
 
        self.tt.cancel_versioning(other_root)
1056
 
 
1057
 
    def reparent_children(self, ie, target):
1058
 
        for thing, child in ie.children.iteritems():
1059
 
            trans_id = self.tt.trans_id_file_id(child.file_id)
1060
 
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1061
 
 
1062
1081
    def write_modified(self, results):
1063
1082
        modified_hashes = {}
1064
1083
        for path in results.modified_paths:
1065
 
            file_id = self.this_tree.path2id(self.this_tree.relpath(path))
 
1084
            file_id = self.working_tree.path2id(self.working_tree.relpath(path))
1066
1085
            if file_id is None:
1067
1086
                continue
1068
 
            hash = self.this_tree.get_file_sha1(file_id)
 
1087
            hash = self.working_tree.get_file_sha1(file_id)
1069
1088
            if hash is None:
1070
1089
                continue
1071
1090
            modified_hashes[file_id] = hash
1072
 
        self.this_tree.set_merge_modified(modified_hashes)
 
1091
        self.working_tree.set_merge_modified(modified_hashes)
1073
1092
 
1074
1093
    @staticmethod
1075
1094
    def parent(entry, file_id):
1088
1107
    @staticmethod
1089
1108
    def contents_sha1(tree, file_id):
1090
1109
        """Determine the sha1 of the file contents (used as a key method)."""
1091
 
        if file_id not in tree:
 
1110
        if not tree.has_id(file_id):
1092
1111
            return None
1093
1112
        return tree.get_file_sha1(file_id)
1094
1113
 
1110
1129
 
1111
1130
    @staticmethod
1112
1131
    def _three_way(base, other, this):
1113
 
        #if base == other, either they all agree, or only THIS has changed.
1114
1132
        if base == other:
 
1133
            # if 'base == other', either they all agree, or only 'this' has
 
1134
            # changed.
1115
1135
            return 'this'
1116
1136
        elif this not in (base, other):
 
1137
            # 'this' is neither 'base' nor 'other', so both sides changed
1117
1138
            return 'conflict'
1118
 
        # "Ambiguous clean merge" -- both sides have made the same change.
1119
1139
        elif this == other:
 
1140
            # "Ambiguous clean merge" -- both sides have made the same change.
1120
1141
            return "this"
1121
 
        # this == base: only other has changed.
1122
1142
        else:
 
1143
            # this == base: only other has changed.
1123
1144
            return "other"
1124
1145
 
1125
1146
    @staticmethod
1169
1190
                # only has an lca value
1170
1191
                return 'other'
1171
1192
 
1172
 
        # At this point, the lcas disagree, and the tips disagree
 
1193
        # At this point, the lcas disagree, and the tip disagree
1173
1194
        return 'conflict'
1174
1195
 
1175
 
    @staticmethod
1176
 
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1177
 
        """Do a three-way test on a scalar.
1178
 
        Return "this", "other" or "conflict", depending whether a value wins.
1179
 
        """
1180
 
        key_base = key(base_tree, file_id)
1181
 
        key_other = key(other_tree, file_id)
1182
 
        #if base == other, either they all agree, or only THIS has changed.
1183
 
        if key_base == key_other:
1184
 
            return "this"
1185
 
        key_this = key(this_tree, file_id)
1186
 
        # "Ambiguous clean merge"
1187
 
        if key_this == key_other:
1188
 
            return "this"
1189
 
        elif key_this == key_base:
1190
 
            return "other"
1191
 
        else:
1192
 
            return "conflict"
1193
 
 
1194
1196
    def merge_names(self, file_id):
1195
1197
        def get_entry(tree):
1196
 
            if tree.has_id(file_id):
1197
 
                return tree.inventory[file_id]
1198
 
            else:
 
1198
            try:
 
1199
                return tree.root_inventory[file_id]
 
1200
            except errors.NoSuchId:
1199
1201
                return None
1200
1202
        this_entry = get_entry(self.this_tree)
1201
1203
        other_entry = get_entry(self.other_tree)
1228
1230
                parent_id_winner = "other"
1229
1231
        if name_winner == "this" and parent_id_winner == "this":
1230
1232
            return
1231
 
        if name_winner == "conflict":
1232
 
            trans_id = self.tt.trans_id_file_id(file_id)
1233
 
            self._raw_conflicts.append(('name conflict', trans_id,
1234
 
                                        this_name, other_name))
1235
 
        if parent_id_winner == "conflict":
1236
 
            trans_id = self.tt.trans_id_file_id(file_id)
1237
 
            self._raw_conflicts.append(('parent conflict', trans_id,
1238
 
                                        this_parent, other_parent))
1239
 
        if other_name is None:
 
1233
        if name_winner == 'conflict' or parent_id_winner == 'conflict':
 
1234
            # Creating helpers (.OTHER or .THIS) here cause problems down the
 
1235
            # road if a ContentConflict needs to be created so we should not do
 
1236
            # that
 
1237
            trans_id = self.tt.trans_id_file_id(file_id)
 
1238
            self._raw_conflicts.append(('path conflict', trans_id, file_id,
 
1239
                                        this_parent, this_name,
 
1240
                                        other_parent, other_name))
 
1241
        if not self.other_tree.has_id(file_id):
1240
1242
            # it doesn't matter whether the result was 'other' or
1241
 
            # 'conflict'-- if there's no 'other', we leave it alone.
 
1243
            # 'conflict'-- if it has no file id, we leave it alone.
1242
1244
            return
1243
 
        # if we get here, name_winner and parent_winner are set to safe values.
1244
 
        trans_id = self.tt.trans_id_file_id(file_id)
1245
1245
        parent_id = parents[self.winner_idx[parent_id_winner]]
1246
 
        if parent_id is not None:
1247
 
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
1248
 
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
1249
 
                                parent_trans_id, trans_id)
 
1246
        name = names[self.winner_idx[name_winner]]
 
1247
        if parent_id is not None or name is not None:
 
1248
            # if we get here, name_winner and parent_winner are set to safe
 
1249
            # values.
 
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,
 
1261
                                self.tt.trans_id_file_id(file_id))
1250
1262
 
1251
1263
    def _do_merge_contents(self, file_id):
1252
1264
        """Performs a merge on file_id contents."""
1253
1265
        def contents_pair(tree):
1254
 
            if file_id not in tree:
 
1266
            if not tree.has_id(file_id):
1255
1267
                return (None, None)
1256
1268
            kind = tree.kind(file_id)
1257
1269
            if kind == "file":
1286
1298
        # We have a hypothetical conflict, but if we have files, then we
1287
1299
        # can try to merge the content
1288
1300
        trans_id = self.tt.trans_id_file_id(file_id)
1289
 
        params = MergeHookParams(self, file_id, trans_id, this_pair[0],
 
1301
        params = MergeFileHookParams(self, file_id, trans_id, this_pair[0],
1290
1302
            other_pair[0], winner)
1291
1303
        hooks = self.active_hooks
1292
1304
        hook_status = 'not_applicable'
1295
1307
            if hook_status != 'not_applicable':
1296
1308
                # Don't try any more hooks, this one applies.
1297
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
1298
1314
        result = "modified"
1299
1315
        if hook_status == 'not_applicable':
1300
 
            # This is a contents conflict, because none of the available
1301
 
            # 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.
1302
1318
            result = None
1303
1319
            name = self.tt.final_name(trans_id)
1304
1320
            parent_id = self.tt.final_parent(trans_id)
1305
 
            if self.this_tree.has_id(file_id):
1306
 
                self.tt.unversion_file(trans_id)
1307
 
            file_group = self._dump_conflicts(name, parent_id, file_id,
1308
 
                                              set_version=True)
1309
 
            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))
1310
1358
        elif hook_status == 'success':
1311
1359
            self.tt.create_file(lines, trans_id)
1312
1360
        elif hook_status == 'conflicted':
1328
1376
            raise AssertionError('unknown hook_status: %r' % (hook_status,))
1329
1377
        if not self.this_tree.has_id(file_id) and result == "modified":
1330
1378
            self.tt.version_file(file_id, trans_id)
1331
 
        # The merge has been performed, so the old contents should not be
1332
 
        # retained.
1333
 
        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.
1334
1382
            self.tt.delete_contents(trans_id)
1335
 
        except errors.NoSuchFile:
1336
 
            pass
1337
1383
        return result
1338
1384
 
1339
1385
    def _default_other_winner_merge(self, merge_hook_params):
1340
1386
        """Replace this contents with other."""
1341
1387
        file_id = merge_hook_params.file_id
1342
1388
        trans_id = merge_hook_params.trans_id
1343
 
        file_in_this = self.this_tree.has_id(file_id)
1344
1389
        if self.other_tree.has_id(file_id):
1345
1390
            # OTHER changed the file
1346
 
            wt = self.this_tree
1347
 
            if wt.supports_content_filtering():
1348
 
                # We get the path from the working tree if it exists.
1349
 
                # That fails though when OTHER is adding a file, so
1350
 
                # we fall back to the other tree to find the path if
1351
 
                # it doesn't exist locally.
1352
 
                try:
1353
 
                    filter_tree_path = wt.id2path(file_id)
1354
 
                except errors.NoSuchId:
1355
 
                    filter_tree_path = self.other_tree.id2path(file_id)
1356
 
            else:
1357
 
                # Skip the id2path lookup for older formats
1358
 
                filter_tree_path = None
1359
 
            transform.create_from_tree(self.tt, trans_id,
1360
 
                             self.other_tree, file_id,
1361
 
                             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))
1362
1394
            return 'done', None
1363
 
        elif file_in_this:
 
1395
        elif self.this_tree.has_id(file_id):
1364
1396
            # OTHER deleted the file
1365
1397
            return 'delete', None
1366
1398
        else:
1392
1424
    def get_lines(self, tree, file_id):
1393
1425
        """Return the lines in a file, or an empty list."""
1394
1426
        if tree.has_id(file_id):
1395
 
            return tree.get_file(file_id).readlines()
 
1427
            return tree.get_file_lines(file_id)
1396
1428
        else:
1397
1429
            return []
1398
1430
 
1440
1472
                                              other_lines)
1441
1473
            file_group.append(trans_id)
1442
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
 
1443
1489
    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
1444
1490
                        base_lines=None, other_lines=None, set_version=False,
1445
1491
                        no_base=False):
1511
1557
        if winner == 'this' and file_status != "modified":
1512
1558
            return
1513
1559
        trans_id = self.tt.trans_id_file_id(file_id)
1514
 
        try:
1515
 
            if self.tt.final_kind(trans_id) != "file":
1516
 
                return
1517
 
        except errors.NoSuchFile:
 
1560
        if self.tt.final_kind(trans_id) != "file":
1518
1561
            return
1519
1562
        if winner == "this":
1520
1563
            executability = this_executable
1531
1574
 
1532
1575
    def cook_conflicts(self, fs_conflicts):
1533
1576
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1534
 
        name_conflicts = {}
1535
 
        self.cooked_conflicts.extend(transform.cook_conflicts(
1536
 
                fs_conflicts, self.tt))
 
1577
        content_conflict_file_ids = set()
 
1578
        cooked_conflicts = transform.cook_conflicts(fs_conflicts, self.tt)
1537
1579
        fp = transform.FinalPaths(self.tt)
1538
1580
        for conflict in self._raw_conflicts:
1539
1581
            conflict_type = conflict[0]
1540
 
            if conflict_type in ('name conflict', 'parent conflict'):
1541
 
                trans_id = conflict[1]
1542
 
                conflict_args = conflict[2:]
1543
 
                if trans_id not in name_conflicts:
1544
 
                    name_conflicts[trans_id] = {}
1545
 
                transform.unique_add(name_conflicts[trans_id], conflict_type,
1546
 
                                     conflict_args)
1547
 
            if conflict_type == 'contents conflict':
 
1582
            if conflict_type == 'path conflict':
 
1583
                (trans_id, file_id,
 
1584
                this_parent, this_name,
 
1585
                other_parent, other_name) = conflict[1:]
 
1586
                if this_parent is None or this_name is None:
 
1587
                    this_path = '<deleted>'
 
1588
                else:
 
1589
                    parent_path =  fp.get_path(
 
1590
                        self.tt.trans_id_file_id(this_parent))
 
1591
                    this_path = osutils.pathjoin(parent_path, this_name)
 
1592
                if other_parent is None or other_name is None:
 
1593
                    other_path = '<deleted>'
 
1594
                else:
 
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))
 
1603
                    other_path = osutils.pathjoin(parent_path, other_name)
 
1604
                c = _mod_conflicts.Conflict.factory(
 
1605
                    'path conflict', path=this_path,
 
1606
                    conflict_path=other_path,
 
1607
                    file_id=file_id)
 
1608
            elif conflict_type == 'contents conflict':
1548
1609
                for trans_id in conflict[1]:
1549
1610
                    file_id = self.tt.final_file_id(trans_id)
1550
1611
                    if file_id is not None:
 
1612
                        # Ok we found the relevant file-id
1551
1613
                        break
1552
1614
                path = fp.get_path(trans_id)
1553
1615
                for suffix in ('.BASE', '.THIS', '.OTHER'):
1554
1616
                    if path.endswith(suffix):
 
1617
                        # Here is the raw path
1555
1618
                        path = path[:-len(suffix)]
1556
1619
                        break
1557
1620
                c = _mod_conflicts.Conflict.factory(conflict_type,
1558
1621
                                                    path=path, file_id=file_id)
1559
 
                self.cooked_conflicts.append(c)
1560
 
            if conflict_type == 'text conflict':
 
1622
                content_conflict_file_ids.add(file_id)
 
1623
            elif conflict_type == 'text conflict':
1561
1624
                trans_id = conflict[1]
1562
1625
                path = fp.get_path(trans_id)
1563
1626
                file_id = self.tt.final_file_id(trans_id)
1564
1627
                c = _mod_conflicts.Conflict.factory(conflict_type,
1565
1628
                                                    path=path, file_id=file_id)
1566
 
                self.cooked_conflicts.append(c)
 
1629
            else:
 
1630
                raise AssertionError('bad conflict type: %r' % (conflict,))
 
1631
            cooked_conflicts.append(c)
1567
1632
 
1568
 
        for trans_id, conflicts in name_conflicts.iteritems():
1569
 
            try:
1570
 
                this_parent, other_parent = conflicts['parent conflict']
1571
 
                if this_parent == other_parent:
1572
 
                    raise AssertionError()
1573
 
            except KeyError:
1574
 
                this_parent = other_parent = \
1575
 
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
1576
 
            try:
1577
 
                this_name, other_name = conflicts['name conflict']
1578
 
                if this_name == other_name:
1579
 
                    raise AssertionError()
1580
 
            except KeyError:
1581
 
                this_name = other_name = self.tt.final_name(trans_id)
1582
 
            other_path = fp.get_path(trans_id)
1583
 
            if this_parent is not None and this_name is not None:
1584
 
                this_parent_path = \
1585
 
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
1586
 
                this_path = osutils.pathjoin(this_parent_path, this_name)
1587
 
            else:
1588
 
                this_path = "<deleted>"
1589
 
            file_id = self.tt.final_file_id(trans_id)
1590
 
            c = _mod_conflicts.Conflict.factory('path conflict', path=this_path,
1591
 
                                                conflict_path=other_path,
1592
 
                                                file_id=file_id)
 
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
1593
1642
            self.cooked_conflicts.append(c)
1594
1643
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1595
1644
 
1701
1750
            osutils.rmtree(temp_dir)
1702
1751
 
1703
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
 
1704
1915
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1705
1916
                backup_files=False,
1706
1917
                merge_type=Merge3Merger,
1714
1925
                change_reporter=None):
1715
1926
    """Primary interface for merging.
1716
1927
 
1717
 
        typical use is probably
1718
 
        'merge_inner(branch, branch.get_revision_tree(other_revision),
1719
 
                     branch.get_revision_tree(base_revision))'
1720
 
        """
 
1928
    Typical use is probably::
 
1929
 
 
1930
        merge_inner(branch, branch.get_revision_tree(other_revision),
 
1931
                    branch.get_revision_tree(base_revision))
 
1932
    """
1721
1933
    if this_tree is None:
1722
1934
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1723
 
                              "parameter as of bzrlib version 0.8.")
 
1935
                              "parameter")
1724
1936
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1725
1937
                    pb=pb, change_reporter=change_reporter)
1726
1938
    merger.backup_files = backup_files
1743
1955
    merger.set_base_revision(get_revision_id(), this_branch)
1744
1956
    return merger.do_merge()
1745
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
 
1746
1970
def get_merge_type_registry():
1747
 
    """Merge type registry is in bzrlib.option to avoid circular imports.
 
1971
    """Merge type registry was previously in bzrlib.option
1748
1972
 
1749
 
    This method provides a sanctioned way to retrieve it.
 
1973
    This method provides a backwards compatible way to retrieve it.
1750
1974
    """
1751
 
    from bzrlib import option
1752
 
    return option._merge_type_registry
 
1975
    return merge_type_registry
1753
1976
 
1754
1977
 
1755
1978
def _plan_annotate_merge(annotated_a, annotated_b, ancestors_a, ancestors_b):
2180
2403
class _PlanLCAMerge(_PlanMergeBase):
2181
2404
    """
2182
2405
    This merge algorithm differs from _PlanMerge in that:
 
2406
 
2183
2407
    1. comparisons are done against LCAs only
2184
2408
    2. cases where a contested line is new versus one LCA but old versus
2185
2409
       another are marked as conflicts, by emitting the line as conflicted-a
2226
2450
 
2227
2451
        If a line is killed and new, this indicates that the two merge
2228
2452
        revisions contain differing conflict resolutions.
 
2453
 
2229
2454
        :param revision_id: The id of the revision in which the lines are
2230
2455
            unique
2231
2456
        :param unique_line_numbers: The line numbers of unique lines.
2232
 
        :return a tuple of (new_this, killed_other):
 
2457
        :return: a tuple of (new_this, killed_other)
2233
2458
        """
2234
2459
        new = set()
2235
2460
        killed = set()