← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: John Arbash Meinel
  • Date: 2010-01-29 11:09:30 UTC
  • mfrom: (4797.2.7 2.1)
  • mto: This revision was merged to the branch mainline in revision 4989.
  • Revision ID: john@arbash-meinel.com-20100129110930-y6ins0x1phadj5c7
Merge 2.1.0rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
 
import warnings
18
17
 
19
 
from bzrlib.lazy_import import lazy_import
20
 
lazy_import(globals(), """
21
18
from bzrlib import (
22
19
    branch as _mod_branch,
23
 
    cleanup,
24
20
    conflicts as _mod_conflicts,
25
21
    debug,
26
 
    generate_ids,
 
22
    decorators,
 
23
    errors,
27
24
    graph as _mod_graph,
 
25
    hooks,
28
26
    merge3,
29
27
    osutils,
30
28
    patiencediff,
 
29
    progress,
31
30
    revision as _mod_revision,
32
31
    textfile,
33
32
    trace,
35
34
    tree as _mod_tree,
36
35
    tsort,
37
36
    ui,
38
 
    versionedfile,
39
 
    workingtree,
40
 
    )
41
 
""")
42
 
from bzrlib import (
43
 
    decorators,
44
 
    errors,
45
 
    hooks,
 
37
    versionedfile
46
38
    )
47
39
from bzrlib.symbol_versioning import (
48
40
    deprecated_in,
53
45
 
54
46
def transform_tree(from_tree, to_tree, interesting_ids=None):
55
47
    from_tree.lock_tree_write()
56
 
    operation = cleanup.OperationWithCleanups(merge_inner)
57
 
    operation.add_cleanup(from_tree.unlock)
58
 
    operation.run_simple(from_tree.branch, to_tree, from_tree,
59
 
        ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
 
48
    try:
 
49
        merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
 
50
                    interesting_ids=interesting_ids, this_tree=from_tree)
 
51
    finally:
 
52
        from_tree.unlock()
60
53
 
61
54
 
62
55
class MergeHooks(hooks.Hooks):
63
56
 
64
57
    def __init__(self):
65
 
        hooks.Hooks.__init__(self, "bzrlib.merge", "Merger.hooks")
66
 
        self.add_hook('merge_file_content',
 
58
        hooks.Hooks.__init__(self)
 
59
        self.create_hook(hooks.HookPoint('merge_file_content',
67
60
            "Called with a bzrlib.merge.Merger object to create a per file "
68
61
            "merge object when starting a merge. "
69
62
            "Should return either None or a subclass of "
73
66
            "side has deleted the file and the other has changed it). "
74
67
            "See the AbstractPerFileMerger API docs for details on how it is "
75
68
            "used by merge.",
76
 
            (2, 1))
 
69
            (2, 1), None))
77
70
 
78
71
 
79
72
class AbstractPerFileMerger(object):
92
85
        """Attempt to merge the contents of a single file.
93
86
        
94
87
        :param merge_params: A bzrlib.merge.MergeHookParams
95
 
        :return: A tuple of (status, chunks), where status is one of
 
88
        :return : A tuple of (status, chunks), where status is one of
96
89
            'not_applicable', 'success', 'conflicted', or 'delete'.  If status
97
90
            is 'success' or 'conflicted', then chunks should be an iterable of
98
91
            strings for the new file contents.
100
93
        return ('not applicable', None)
101
94
 
102
95
 
103
 
class PerFileMerger(AbstractPerFileMerger):
104
 
    """Merge individual files when self.file_matches returns True.
105
 
 
106
 
    This class is intended to be subclassed.  The file_matches and
107
 
    merge_matching methods should be overridden with concrete implementations.
108
 
    """
109
 
 
110
 
    def file_matches(self, params):
111
 
        """Return True if merge_matching should be called on this file.
112
 
 
113
 
        Only called with merges of plain files with no clear winner.
114
 
 
115
 
        Subclasses must override this.
116
 
        """
117
 
        raise NotImplementedError(self.file_matches)
118
 
 
119
 
    def get_filename(self, params, tree):
120
 
        """Lookup the filename (i.e. basename, not path), given a Tree (e.g.
121
 
        self.merger.this_tree) and a MergeHookParams.
122
 
        """
123
 
        return osutils.basename(tree.id2path(params.file_id))
124
 
 
125
 
    def get_filepath(self, params, tree):
126
 
        """Calculate the path to the file in a tree.
127
 
 
128
 
        :param params: A MergeHookParams describing the file to merge
129
 
        :param tree: a Tree, e.g. self.merger.this_tree.
130
 
        """
131
 
        return tree.id2path(params.file_id)
132
 
 
133
 
    def merge_contents(self, params):
134
 
        """Merge the contents of a single file."""
135
 
        # Check whether this custom merge logic should be used.
136
 
        if (
137
 
            # OTHER is a straight winner, rely on default merge.
138
 
            params.winner == 'other' or
139
 
            # THIS and OTHER aren't both files.
140
 
            not params.is_file_merge() or
141
 
            # The filename doesn't match *.xml
142
 
            not self.file_matches(params)):
143
 
            return 'not_applicable', None
144
 
        return self.merge_matching(params)
145
 
 
146
 
    def merge_matching(self, params):
147
 
        """Merge the contents of a single file that has matched the criteria
148
 
        in PerFileMerger.merge_contents (is a conflict, is a file,
149
 
        self.file_matches is True).
150
 
 
151
 
        Subclasses must override this.
152
 
        """
153
 
        raise NotImplementedError(self.merge_matching)
154
 
 
155
 
 
156
 
class ConfigurableFileMerger(PerFileMerger):
 
96
class ConfigurableFileMerger(AbstractPerFileMerger):
157
97
    """Merge individual files when configured via a .conf file.
158
98
 
159
99
    This is a base class for concrete custom file merging logic. Concrete
160
100
    classes should implement ``merge_text``.
161
101
 
162
 
    See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
163
 
    
164
102
    :ivar affected_files: The configured file paths to merge.
165
 
 
166
103
    :cvar name_prefix: The prefix to use when looking up configuration
167
 
        details. <name_prefix>_merge_files describes the files targeted by the
168
 
        hook for example.
169
 
        
 
104
        details.
170
105
    :cvar default_files: The default file paths to merge when no configuration
171
106
        is present.
172
107
    """
182
117
        if self.name_prefix is None:
183
118
            raise ValueError("name_prefix must be set.")
184
119
 
185
 
    def file_matches(self, params):
186
 
        """Check whether the file should call the merge hook.
187
 
 
188
 
        <name_prefix>_merge_files configuration variable is a list of files
189
 
        that should use the hook.
190
 
        """
 
120
    def filename_matches_config(self, params):
191
121
        affected_files = self.affected_files
192
122
        if affected_files is None:
193
 
            config = self.merger.this_branch.get_config()
 
123
            config = self.merger.this_tree.branch.get_config()
194
124
            # Until bzr provides a better policy for caching the config, we
195
125
            # just add the part we're interested in to the params to avoid
196
126
            # reading the config files repeatedly (bazaar.conf, location.conf,
202
132
                affected_files = self.default_files
203
133
            self.affected_files = affected_files
204
134
        if affected_files:
205
 
            filepath = self.get_filepath(params, self.merger.this_tree)
206
 
            if filepath in affected_files:
 
135
            filename = self.merger.this_tree.id2path(params.file_id)
 
136
            if filename in affected_files:
207
137
                return True
208
138
        return False
209
139
 
210
 
    def merge_matching(self, params):
211
 
        return self.merge_text(params)
 
140
    def merge_contents(self, params):
 
141
        """Merge the contents of a single file."""
 
142
        # First, check whether this custom merge logic should be used.  We
 
143
        # expect most files should not be merged by this handler.
 
144
        if (
 
145
            # OTHER is a straight winner, rely on default merge.
 
146
            params.winner == 'other' or
 
147
            # THIS and OTHER aren't both files.
 
148
            not params.is_file_merge() or
 
149
            # The filename isn't listed in the 'NAME_merge_files' config
 
150
            # option.
 
151
            not self.filename_matches_config(params)):
 
152
            return 'not_applicable', None
 
153
        return self.merge_text(self, params)
212
154
 
213
155
    def merge_text(self, params):
214
156
        """Merge the byte contents of a single file.
285
227
        self.interesting_files = None
286
228
        self.show_base = False
287
229
        self.reprocess = False
288
 
        if pb is not None:
289
 
            warnings.warn("pb parameter to Merger() is deprecated and ignored")
 
230
        if pb is None:
 
231
            pb = progress.DummyProgress()
 
232
        self._pb = pb
290
233
        self.pp = None
291
234
        self.recurse = recurse
292
235
        self.change_reporter = change_reporter
428
371
        return self._cached_trees[revision_id]
429
372
 
430
373
    def _get_tree(self, treespec, possible_transports=None):
 
374
        from bzrlib import workingtree
431
375
        location, revno = treespec
432
376
        if revno is None:
433
377
            tree = workingtree.WorkingTree.open_containing(location)[0]
458
402
    @deprecated_method(deprecated_in((2, 1, 0)))
459
403
    def file_revisions(self, file_id):
460
404
        self.ensure_revision_trees()
 
405
        def get_id(tree, file_id):
 
406
            revision_id = tree.inventory[file_id].revision
 
407
            return revision_id
461
408
        if self.this_rev_id is None:
462
409
            if self.this_basis_tree.get_file_sha1(file_id) != \
463
410
                self.this_tree.get_file_sha1(file_id):
464
411
                raise errors.WorkingTreeNotRevision(self.this_tree)
465
412
 
466
413
        trees = (self.this_basis_tree, self.other_tree)
467
 
        return [tree.get_file_revision(file_id) for tree in trees]
 
414
        return [get_id(tree, file_id) for tree in trees]
468
415
 
469
416
    @deprecated_method(deprecated_in((2, 1, 0)))
470
417
    def check_basis(self, check_clean, require_commits=True):
498
445
    def _add_parent(self):
499
446
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
500
447
        new_parent_trees = []
501
 
        operation = cleanup.OperationWithCleanups(
502
 
            self.this_tree.set_parent_trees)
503
448
        for revision_id in new_parents:
504
449
            try:
505
450
                tree = self.revision_tree(revision_id)
507
452
                tree = None
508
453
            else:
509
454
                tree.lock_read()
510
 
                operation.add_cleanup(tree.unlock)
511
455
            new_parent_trees.append((revision_id, tree))
512
 
        operation.run_simple(new_parent_trees, allow_leftmost_as_ghost=True)
 
456
        try:
 
457
            self.this_tree.set_parent_trees(new_parent_trees,
 
458
                                            allow_leftmost_as_ghost=True)
 
459
        finally:
 
460
            for _revision_id, tree in new_parent_trees:
 
461
                if tree is not None:
 
462
                    tree.unlock()
513
463
 
514
464
    def set_other(self, other_revision, possible_transports=None):
515
465
        """Set the revision and tree to merge from.
580
530
            elif len(lcas) == 1:
581
531
                self.base_rev_id = list(lcas)[0]
582
532
            else: # len(lcas) > 1
583
 
                self._is_criss_cross = True
584
533
                if len(lcas) > 2:
585
534
                    # find_unique_lca can only handle 2 nodes, so we have to
586
535
                    # start back at the beginning. It is a shame to traverse
591
540
                else:
592
541
                    self.base_rev_id = self.revision_graph.find_unique_lca(
593
542
                                            *lcas)
594
 
                sorted_lca_keys = self.revision_graph.find_merge_order(                
595
 
                    revisions[0], lcas)
596
 
                if self.base_rev_id == _mod_revision.NULL_REVISION:
597
 
                    self.base_rev_id = sorted_lca_keys[0]
598
 
                
 
543
                self._is_criss_cross = True
599
544
            if self.base_rev_id == _mod_revision.NULL_REVISION:
600
545
                raise errors.UnrelatedBranches()
601
546
            if self._is_criss_cross:
602
547
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
603
548
                              ' help criss-cross.')
604
549
                trace.mutter('Criss-cross lcas: %r' % lcas)
605
 
                if self.base_rev_id in lcas:
606
 
                    trace.mutter('Unable to find unique lca. '
607
 
                                 'Fallback %r as best option.' % self.base_rev_id)
608
 
                interesting_revision_ids = set(lcas)
609
 
                interesting_revision_ids.add(self.base_rev_id)
 
550
                interesting_revision_ids = [self.base_rev_id]
 
551
                interesting_revision_ids.extend(lcas)
610
552
                interesting_trees = dict((t.get_revision_id(), t)
611
553
                    for t in self.this_branch.repository.revision_trees(
612
554
                        interesting_revision_ids))
613
555
                self._cached_trees.update(interesting_trees)
614
 
                if self.base_rev_id in lcas:
615
 
                    self.base_tree = interesting_trees[self.base_rev_id]
616
 
                else:
617
 
                    self.base_tree = interesting_trees.pop(self.base_rev_id)
 
556
                self.base_tree = interesting_trees.pop(self.base_rev_id)
 
557
                sorted_lca_keys = self.revision_graph.find_merge_order(
 
558
                    revisions[0], lcas)
618
559
                self._lca_trees = [interesting_trees[key]
619
560
                                   for key in sorted_lca_keys]
620
561
            else:
647
588
                  'other_tree': self.other_tree,
648
589
                  'interesting_ids': self.interesting_ids,
649
590
                  'interesting_files': self.interesting_files,
650
 
                  'this_branch': self.this_branch,
 
591
                  'pp': self.pp, 'this_branch': self.this_branch,
651
592
                  'do_merge': False}
652
593
        if self.merge_type.requires_base:
653
594
            kwargs['base_tree'] = self.base_tree
671
612
        if self._is_criss_cross and getattr(self.merge_type,
672
613
                                            'supports_lca_trees', False):
673
614
            kwargs['lca_trees'] = self._lca_trees
674
 
        return self.merge_type(pb=None,
 
615
        return self.merge_type(pb=self._pb,
675
616
                               change_reporter=self.change_reporter,
676
617
                               **kwargs)
677
618
 
678
 
    def _do_merge_to(self):
679
 
        merge = self.make_merger()
 
619
    def _do_merge_to(self, merge):
680
620
        if self.other_branch is not None:
681
621
            self.other_branch.update_references(self.this_branch)
682
622
        merge.do_merge()
696
636
                    sub_tree.branch.repository.revision_tree(base_revision)
697
637
                sub_merge.base_rev_id = base_revision
698
638
                sub_merge.do_merge()
699
 
        return merge
700
639
 
701
640
    def do_merge(self):
702
 
        operation = cleanup.OperationWithCleanups(self._do_merge_to)
703
641
        self.this_tree.lock_tree_write()
704
 
        operation.add_cleanup(self.this_tree.unlock)
705
 
        if self.base_tree is not None:
706
 
            self.base_tree.lock_read()
707
 
            operation.add_cleanup(self.base_tree.unlock)
708
 
        if self.other_tree is not None:
709
 
            self.other_tree.lock_read()
710
 
            operation.add_cleanup(self.other_tree.unlock)
711
 
        merge = operation.run_simple()
 
642
        try:
 
643
            if self.base_tree is not None:
 
644
                self.base_tree.lock_read()
 
645
            try:
 
646
                if self.other_tree is not None:
 
647
                    self.other_tree.lock_read()
 
648
                try:
 
649
                    merge = self.make_merger()
 
650
                    self._do_merge_to(merge)
 
651
                finally:
 
652
                    if self.other_tree is not None:
 
653
                        self.other_tree.unlock()
 
654
            finally:
 
655
                if self.base_tree is not None:
 
656
                    self.base_tree.unlock()
 
657
        finally:
 
658
            self.this_tree.unlock()
712
659
        if len(merge.cooked_conflicts) == 0:
713
660
            if not self.ignore_zero and not trace.is_quiet():
714
661
                trace.note("All changes applied successfully.")
749
696
 
750
697
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
751
698
                 interesting_ids=None, reprocess=False, show_base=False,
752
 
                 pb=None, pp=None, change_reporter=None,
 
699
                 pb=progress.DummyProgress(), pp=None, change_reporter=None,
753
700
                 interesting_files=None, do_merge=True,
754
701
                 cherrypick=False, lca_trees=None, this_branch=None):
755
702
        """Initialize the merger object and perform the merge.
758
705
        :param this_tree: The local tree in the merge operation
759
706
        :param base_tree: The common tree in the merge operation
760
707
        :param other_tree: The other tree to merge changes from
761
 
        :param this_branch: The branch associated with this_tree.  Defaults to
762
 
            this_tree.branch if not supplied.
 
708
        :param this_branch: The branch associated with this_tree
763
709
        :param interesting_ids: The file_ids of files that should be
764
710
            participate in the merge.  May not be combined with
765
711
            interesting_files.
766
712
        :param: reprocess If True, perform conflict-reduction processing.
767
713
        :param show_base: If True, show the base revision in text conflicts.
768
714
            (incompatible with reprocess)
769
 
        :param pb: ignored
 
715
        :param pb: A Progress bar
770
716
        :param pp: A ProgressPhase object
771
717
        :param change_reporter: An object that should report changes made
772
718
        :param interesting_files: The tree-relative paths of files that should
783
729
        if interesting_files is not None and interesting_ids is not None:
784
730
            raise ValueError(
785
731
                'specify either interesting_ids or interesting_files')
786
 
        if this_branch is None:
787
 
            this_branch = this_tree.branch
788
732
        self.interesting_ids = interesting_ids
789
733
        self.interesting_files = interesting_files
790
734
        self.this_tree = working_tree
801
745
        # making sure we haven't missed any corner cases.
802
746
        # if lca_trees is None:
803
747
        #     self._lca_trees = [self.base_tree]
 
748
        self.pb = pb
 
749
        self.pp = pp
804
750
        self.change_reporter = change_reporter
805
751
        self.cherrypick = cherrypick
 
752
        if self.pp is None:
 
753
            self.pp = progress.ProgressPhase("Merge phase", 3, self.pb)
806
754
        if do_merge:
807
755
            self.do_merge()
808
 
        if pp is not None:
809
 
            warnings.warn("pp argument to Merge3Merger is deprecated")
810
 
        if pb is not None:
811
 
            warnings.warn("pb argument to Merge3Merger is deprecated")
812
756
 
813
757
    def do_merge(self):
814
 
        operation = cleanup.OperationWithCleanups(self._do_merge)
815
758
        self.this_tree.lock_tree_write()
816
 
        operation.add_cleanup(self.this_tree.unlock)
817
759
        self.base_tree.lock_read()
818
 
        operation.add_cleanup(self.base_tree.unlock)
819
760
        self.other_tree.lock_read()
820
 
        operation.add_cleanup(self.other_tree.unlock)
821
 
        operation.run()
822
 
 
823
 
    def _do_merge(self, operation):
824
 
        self.tt = transform.TreeTransform(self.this_tree, None)
825
 
        operation.add_cleanup(self.tt.finalize)
826
 
        self._compute_transform()
827
 
        results = self.tt.apply(no_conflicts=True)
828
 
        self.write_modified(results)
829
761
        try:
830
 
            self.this_tree.add_conflicts(self.cooked_conflicts)
831
 
        except errors.UnsupportedOperation:
832
 
            pass
 
762
            self.tt = transform.TreeTransform(self.this_tree, self.pb)
 
763
            try:
 
764
                self.pp.next_phase()
 
765
                self._compute_transform()
 
766
                self.pp.next_phase()
 
767
                results = self.tt.apply(no_conflicts=True)
 
768
                self.write_modified(results)
 
769
                try:
 
770
                    self.this_tree.add_conflicts(self.cooked_conflicts)
 
771
                except errors.UnsupportedOperation:
 
772
                    pass
 
773
            finally:
 
774
                self.tt.finalize()
 
775
        finally:
 
776
            self.other_tree.unlock()
 
777
            self.base_tree.unlock()
 
778
            self.this_tree.unlock()
 
779
            self.pb.clear()
833
780
 
834
781
    def make_preview_transform(self):
835
 
        operation = cleanup.OperationWithCleanups(self._make_preview_transform)
836
782
        self.base_tree.lock_read()
837
 
        operation.add_cleanup(self.base_tree.unlock)
838
783
        self.other_tree.lock_read()
839
 
        operation.add_cleanup(self.other_tree.unlock)
840
 
        return operation.run_simple()
841
 
 
842
 
    def _make_preview_transform(self):
843
784
        self.tt = transform.TransformPreview(self.this_tree)
844
 
        self._compute_transform()
 
785
        try:
 
786
            self.pp.next_phase()
 
787
            self._compute_transform()
 
788
            self.pp.next_phase()
 
789
        finally:
 
790
            self.other_tree.unlock()
 
791
            self.base_tree.unlock()
 
792
            self.pb.clear()
845
793
        return self.tt
846
794
 
847
795
    def _compute_transform(self):
868
816
                    executable3, file_status, resolver=resolver)
869
817
        finally:
870
818
            child_pb.finished()
871
 
        self.tt.fixup_new_roots()
872
 
        self._finish_computing_transform()
873
 
 
874
 
    def _finish_computing_transform(self):
875
 
        """Finalize the transform and report the changes.
876
 
 
877
 
        This is the second half of _compute_transform.
878
 
        """
 
819
        self.fix_root()
 
820
        self.pp.next_phase()
879
821
        child_pb = ui.ui_factory.nested_progress_bar()
880
822
        try:
881
823
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
888
830
                self.tt.iter_changes(), self.change_reporter)
889
831
        self.cook_conflicts(fs_conflicts)
890
832
        for conflict in self.cooked_conflicts:
891
 
            trace.warning(unicode(conflict))
 
833
            trace.warning(conflict)
892
834
 
893
835
    def _entries3(self):
894
836
        """Gather data about files modified between three trees.
901
843
        """
902
844
        result = []
903
845
        iterator = self.other_tree.iter_changes(self.base_tree,
904
 
                specific_files=self.interesting_files,
 
846
                include_unchanged=True, specific_files=self.interesting_files,
905
847
                extra_trees=[self.this_tree])
906
848
        this_entries = dict((e.file_id, e) for p, e in
907
849
                            self.this_tree.iter_entries_by_dir(
933
875
        it then compares with THIS and BASE.
934
876
 
935
877
        For the multi-valued entries, the format will be (BASE, [lca1, lca2])
936
 
 
937
 
        :return: [(file_id, changed, parents, names, executable)], where:
938
 
 
939
 
            * file_id: Simple file_id of the entry
940
 
            * changed: Boolean, True if the kind or contents changed else False
941
 
            * parents: ((base, [parent_id, in, lcas]), parent_id_other,
942
 
                        parent_id_this)
943
 
            * names:   ((base, [name, in, lcas]), name_in_other, name_in_this)
944
 
            * executable: ((base, [exec, in, lcas]), exec_in_other,
945
 
                        exec_in_this)
 
878
        :return: [(file_id, changed, parents, names, executable)]
 
879
            file_id     Simple file_id of the entry
 
880
            changed     Boolean, True if the kind or contents changed
 
881
                        else False
 
882
            parents     ((base, [parent_id, in, lcas]), parent_id_other,
 
883
                         parent_id_this)
 
884
            names       ((base, [name, in, lcas]), name_in_other, name_in_this)
 
885
            executable  ((base, [exec, in, lcas]), exec_in_other, exec_in_this)
946
886
        """
947
887
        if self.interesting_files is not None:
948
888
            lookup_trees = [self.this_tree, self.base_tree]
990
930
                else:
991
931
                    lca_entries.append(lca_ie)
992
932
 
993
 
            if base_inventory.has_id(file_id):
 
933
            if file_id in base_inventory:
994
934
                base_ie = base_inventory[file_id]
995
935
            else:
996
936
                base_ie = _none_entry
997
937
 
998
 
            if this_inventory.has_id(file_id):
 
938
            if file_id in this_inventory:
999
939
                this_ie = this_inventory[file_id]
1000
940
            else:
1001
941
                this_ie = _none_entry
1081
1021
                        continue
1082
1022
                else:
1083
1023
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
 
1024
                # XXX: We need to handle kind == 'symlink'
1084
1025
 
1085
1026
            # If we have gotten this far, that means something has changed
1086
1027
            result.append((file_id, content_changed,
1093
1034
                          ))
1094
1035
        return result
1095
1036
 
1096
 
    @deprecated_method(deprecated_in((2, 4, 0)))
 
1037
 
1097
1038
    def fix_root(self):
1098
 
        if self.tt.final_kind(self.tt.root) is None:
 
1039
        try:
 
1040
            self.tt.final_kind(self.tt.root)
 
1041
        except errors.NoSuchFile:
1099
1042
            self.tt.cancel_deletion(self.tt.root)
1100
1043
        if self.tt.final_file_id(self.tt.root) is None:
1101
1044
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
1106
1049
        other_root = self.tt.trans_id_file_id(other_root_file_id)
1107
1050
        if other_root == self.tt.root:
1108
1051
            return
1109
 
        if self.this_tree.inventory.has_id(
1110
 
            self.other_tree.inventory.root.file_id):
1111
 
            # the other tree's root is a non-root in the current tree (as
1112
 
            # when a previously unrelated branch is merged into another)
1113
 
            return
1114
 
        if self.tt.final_kind(other_root) is not None:
1115
 
            other_root_is_present = True
1116
 
        else:
1117
 
            # other_root doesn't have a physical representation. We still need
1118
 
            # to move any references to the actual root of the tree.
1119
 
            other_root_is_present = False
1120
 
        # 'other_tree.inventory.root' is not present in this tree. We are
1121
 
        # calling adjust_path for children which *want* to be present with a
1122
 
        # correct place to go.
1123
 
        for _, child in self.other_tree.inventory.root.children.iteritems():
 
1052
        try:
 
1053
            self.tt.final_kind(other_root)
 
1054
        except errors.NoSuchFile:
 
1055
            return
 
1056
        if self.this_tree.has_id(self.other_tree.inventory.root.file_id):
 
1057
            # the other tree's root is a non-root in the current tree
 
1058
            return
 
1059
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
 
1060
        self.tt.cancel_creation(other_root)
 
1061
        self.tt.cancel_versioning(other_root)
 
1062
 
 
1063
    def reparent_children(self, ie, target):
 
1064
        for thing, child in ie.children.iteritems():
1124
1065
            trans_id = self.tt.trans_id_file_id(child.file_id)
1125
 
            if not other_root_is_present:
1126
 
                if self.tt.final_kind(trans_id) is not None:
1127
 
                    # The item exist in the final tree and has a defined place
1128
 
                    # to go already.
1129
 
                    continue
1130
 
            # Move the item into the root
1131
 
            try:
1132
 
                final_name = self.tt.final_name(trans_id)
1133
 
            except errors.NoFinalPath:
1134
 
                # This file is not present anymore, ignore it.
1135
 
                continue
1136
 
            self.tt.adjust_path(final_name, self.tt.root, trans_id)
1137
 
        if other_root_is_present:
1138
 
            self.tt.cancel_creation(other_root)
1139
 
            self.tt.cancel_versioning(other_root)
 
1066
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1140
1067
 
1141
1068
    def write_modified(self, results):
1142
1069
        modified_hashes = {}
1167
1094
    @staticmethod
1168
1095
    def contents_sha1(tree, file_id):
1169
1096
        """Determine the sha1 of the file contents (used as a key method)."""
1170
 
        if not tree.has_id(file_id):
 
1097
        if file_id not in tree:
1171
1098
            return None
1172
1099
        return tree.get_file_sha1(file_id)
1173
1100
 
1189
1116
 
1190
1117
    @staticmethod
1191
1118
    def _three_way(base, other, this):
 
1119
        #if base == other, either they all agree, or only THIS has changed.
1192
1120
        if base == other:
1193
 
            # if 'base == other', either they all agree, or only 'this' has
1194
 
            # changed.
1195
1121
            return 'this'
1196
1122
        elif this not in (base, other):
1197
 
            # 'this' is neither 'base' nor 'other', so both sides changed
1198
1123
            return 'conflict'
 
1124
        # "Ambiguous clean merge" -- both sides have made the same change.
1199
1125
        elif this == other:
1200
 
            # "Ambiguous clean merge" -- both sides have made the same change.
1201
1126
            return "this"
 
1127
        # this == base: only other has changed.
1202
1128
        else:
1203
 
            # this == base: only other has changed.
1204
1129
            return "other"
1205
1130
 
1206
1131
    @staticmethod
1250
1175
                # only has an lca value
1251
1176
                return 'other'
1252
1177
 
1253
 
        # At this point, the lcas disagree, and the tip disagree
 
1178
        # At this point, the lcas disagree, and the tips disagree
1254
1179
        return 'conflict'
1255
1180
 
1256
1181
    @staticmethod
1257
 
    @deprecated_method(deprecated_in((2, 2, 0)))
1258
1182
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1259
1183
        """Do a three-way test on a scalar.
1260
1184
        Return "this", "other" or "conflict", depending whether a value wins.
1310
1234
                parent_id_winner = "other"
1311
1235
        if name_winner == "this" and parent_id_winner == "this":
1312
1236
            return
1313
 
        if name_winner == 'conflict' or parent_id_winner == 'conflict':
1314
 
            # Creating helpers (.OTHER or .THIS) here cause problems down the
1315
 
            # road if a ContentConflict needs to be created so we should not do
1316
 
            # that
1317
 
            trans_id = self.tt.trans_id_file_id(file_id)
1318
 
            self._raw_conflicts.append(('path conflict', trans_id, file_id,
1319
 
                                        this_parent, this_name,
1320
 
                                        other_parent, other_name))
1321
 
        if not self.other_tree.has_id(file_id):
 
1237
        if name_winner == "conflict":
 
1238
            trans_id = self.tt.trans_id_file_id(file_id)
 
1239
            self._raw_conflicts.append(('name conflict', trans_id,
 
1240
                                        this_name, other_name))
 
1241
        if parent_id_winner == "conflict":
 
1242
            trans_id = self.tt.trans_id_file_id(file_id)
 
1243
            self._raw_conflicts.append(('parent conflict', trans_id,
 
1244
                                        this_parent, other_parent))
 
1245
        if other_name is None:
1322
1246
            # it doesn't matter whether the result was 'other' or
1323
 
            # 'conflict'-- if it has no file id, we leave it alone.
 
1247
            # 'conflict'-- if there's no 'other', we leave it alone.
1324
1248
            return
 
1249
        # if we get here, name_winner and parent_winner are set to safe values.
 
1250
        trans_id = self.tt.trans_id_file_id(file_id)
1325
1251
        parent_id = parents[self.winner_idx[parent_id_winner]]
1326
 
        name = names[self.winner_idx[name_winner]]
1327
 
        if parent_id is not None or name is not None:
1328
 
            # if we get here, name_winner and parent_winner are set to safe
1329
 
            # values.
1330
 
            if parent_id is None and name is not None:
1331
 
                # if parent_id is None and name is non-None, current file is
1332
 
                # the tree root.
1333
 
                if names[self.winner_idx[parent_id_winner]] != '':
1334
 
                    raise AssertionError(
1335
 
                        'File looks like a root, but named %s' %
1336
 
                        names[self.winner_idx[parent_id_winner]])
1337
 
                parent_trans_id = transform.ROOT_PARENT
1338
 
            else:
1339
 
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
1340
 
            self.tt.adjust_path(name, parent_trans_id,
1341
 
                                self.tt.trans_id_file_id(file_id))
 
1252
        if parent_id is not None:
 
1253
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1254
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
 
1255
                                parent_trans_id, trans_id)
1342
1256
 
1343
1257
    def _do_merge_contents(self, file_id):
1344
1258
        """Performs a merge on file_id contents."""
1345
1259
        def contents_pair(tree):
1346
 
            if not tree.has_id(file_id):
 
1260
            if file_id not in tree:
1347
1261
                return (None, None)
1348
1262
            kind = tree.kind(file_id)
1349
1263
            if kind == "file":
1422
1336
            self.tt.version_file(file_id, trans_id)
1423
1337
        # The merge has been performed, so the old contents should not be
1424
1338
        # retained.
1425
 
        self.tt.delete_contents(trans_id)
 
1339
        try:
 
1340
            self.tt.delete_contents(trans_id)
 
1341
        except errors.NoSuchFile:
 
1342
            pass
1426
1343
        return result
1427
1344
 
1428
1345
    def _default_other_winner_merge(self, merge_hook_params):
1481
1398
    def get_lines(self, tree, file_id):
1482
1399
        """Return the lines in a file, or an empty list."""
1483
1400
        if tree.has_id(file_id):
1484
 
            return tree.get_file_lines(file_id)
 
1401
            return tree.get_file(file_id).readlines()
1485
1402
        else:
1486
1403
            return []
1487
1404
 
1600
1517
        if winner == 'this' and file_status != "modified":
1601
1518
            return
1602
1519
        trans_id = self.tt.trans_id_file_id(file_id)
1603
 
        if self.tt.final_kind(trans_id) != "file":
 
1520
        try:
 
1521
            if self.tt.final_kind(trans_id) != "file":
 
1522
                return
 
1523
        except errors.NoSuchFile:
1604
1524
            return
1605
1525
        if winner == "this":
1606
1526
            executability = this_executable
1617
1537
 
1618
1538
    def cook_conflicts(self, fs_conflicts):
1619
1539
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1620
 
        content_conflict_file_ids = set()
1621
 
        cooked_conflicts = transform.cook_conflicts(fs_conflicts, self.tt)
 
1540
        name_conflicts = {}
 
1541
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1542
                fs_conflicts, self.tt))
1622
1543
        fp = transform.FinalPaths(self.tt)
1623
1544
        for conflict in self._raw_conflicts:
1624
1545
            conflict_type = conflict[0]
1625
 
            if conflict_type == 'path conflict':
1626
 
                (trans_id, file_id,
1627
 
                this_parent, this_name,
1628
 
                other_parent, other_name) = conflict[1:]
1629
 
                if this_parent is None or this_name is None:
1630
 
                    this_path = '<deleted>'
1631
 
                else:
1632
 
                    parent_path =  fp.get_path(
1633
 
                        self.tt.trans_id_file_id(this_parent))
1634
 
                    this_path = osutils.pathjoin(parent_path, this_name)
1635
 
                if other_parent is None or other_name is None:
1636
 
                    other_path = '<deleted>'
1637
 
                else:
1638
 
                    if other_parent == self.other_tree.get_root_id():
1639
 
                        # The tree transform doesn't know about the other root,
1640
 
                        # so we special case here to avoid a NoFinalPath
1641
 
                        # exception
1642
 
                        parent_path = ''
1643
 
                    else:
1644
 
                        parent_path =  fp.get_path(
1645
 
                            self.tt.trans_id_file_id(other_parent))
1646
 
                    other_path = osutils.pathjoin(parent_path, other_name)
1647
 
                c = _mod_conflicts.Conflict.factory(
1648
 
                    'path conflict', path=this_path,
1649
 
                    conflict_path=other_path,
1650
 
                    file_id=file_id)
1651
 
            elif conflict_type == 'contents conflict':
 
1546
            if conflict_type in ('name conflict', 'parent conflict'):
 
1547
                trans_id = conflict[1]
 
1548
                conflict_args = conflict[2:]
 
1549
                if trans_id not in name_conflicts:
 
1550
                    name_conflicts[trans_id] = {}
 
1551
                transform.unique_add(name_conflicts[trans_id], conflict_type,
 
1552
                                     conflict_args)
 
1553
            if conflict_type == 'contents conflict':
1652
1554
                for trans_id in conflict[1]:
1653
1555
                    file_id = self.tt.final_file_id(trans_id)
1654
1556
                    if file_id is not None:
1660
1562
                        break
1661
1563
                c = _mod_conflicts.Conflict.factory(conflict_type,
1662
1564
                                                    path=path, file_id=file_id)
1663
 
                content_conflict_file_ids.add(file_id)
1664
 
            elif conflict_type == 'text conflict':
 
1565
                self.cooked_conflicts.append(c)
 
1566
            if conflict_type == 'text conflict':
1665
1567
                trans_id = conflict[1]
1666
1568
                path = fp.get_path(trans_id)
1667
1569
                file_id = self.tt.final_file_id(trans_id)
1668
1570
                c = _mod_conflicts.Conflict.factory(conflict_type,
1669
1571
                                                    path=path, file_id=file_id)
 
1572
                self.cooked_conflicts.append(c)
 
1573
 
 
1574
        for trans_id, conflicts in name_conflicts.iteritems():
 
1575
            try:
 
1576
                this_parent, other_parent = conflicts['parent conflict']
 
1577
                if this_parent == other_parent:
 
1578
                    raise AssertionError()
 
1579
            except KeyError:
 
1580
                this_parent = other_parent = \
 
1581
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
 
1582
            try:
 
1583
                this_name, other_name = conflicts['name conflict']
 
1584
                if this_name == other_name:
 
1585
                    raise AssertionError()
 
1586
            except KeyError:
 
1587
                this_name = other_name = self.tt.final_name(trans_id)
 
1588
            other_path = fp.get_path(trans_id)
 
1589
            if this_parent is not None and this_name is not None:
 
1590
                this_parent_path = \
 
1591
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
 
1592
                this_path = osutils.pathjoin(this_parent_path, this_name)
1670
1593
            else:
1671
 
                raise AssertionError('bad conflict type: %r' % (conflict,))
1672
 
            cooked_conflicts.append(c)
1673
 
 
1674
 
        self.cooked_conflicts = []
1675
 
        # We want to get rid of path conflicts when a corresponding contents
1676
 
        # conflict exists. This can occur when one branch deletes a file while
1677
 
        # the other renames *and* modifies it. In this case, the content
1678
 
        # conflict is enough.
1679
 
        for c in cooked_conflicts:
1680
 
            if (c.typestring == 'path conflict'
1681
 
                and c.file_id in content_conflict_file_ids):
1682
 
                continue
 
1594
                this_path = "<deleted>"
 
1595
            file_id = self.tt.final_file_id(trans_id)
 
1596
            c = _mod_conflicts.Conflict.factory('path conflict', path=this_path,
 
1597
                                                conflict_path=other_path,
 
1598
                                                file_id=file_id)
1683
1599
            self.cooked_conflicts.append(c)
1684
1600
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1685
1601
 
1791
1707
            osutils.rmtree(temp_dir)
1792
1708
 
1793
1709
 
1794
 
class PathNotInTree(errors.BzrError):
1795
 
 
1796
 
    _fmt = """Merge-into failed because %(tree)s does not contain %(path)s."""
1797
 
 
1798
 
    def __init__(self, path, tree):
1799
 
        errors.BzrError.__init__(self, path=path, tree=tree)
1800
 
 
1801
 
 
1802
 
class MergeIntoMerger(Merger):
1803
 
    """Merger that understands other_tree will be merged into a subdir.
1804
 
 
1805
 
    This also changes the Merger api so that it uses real Branch, revision_id,
1806
 
    and RevisonTree objects, rather than using revision specs.
1807
 
    """
1808
 
 
1809
 
    def __init__(self, this_tree, other_branch, other_tree, target_subdir,
1810
 
            source_subpath, other_rev_id=None):
1811
 
        """Create a new MergeIntoMerger object.
1812
 
 
1813
 
        source_subpath in other_tree will be effectively copied to
1814
 
        target_subdir in this_tree.
1815
 
 
1816
 
        :param this_tree: The tree that we will be merging into.
1817
 
        :param other_branch: The Branch we will be merging from.
1818
 
        :param other_tree: The RevisionTree object we want to merge.
1819
 
        :param target_subdir: The relative path where we want to merge
1820
 
            other_tree into this_tree
1821
 
        :param source_subpath: The relative path specifying the subtree of
1822
 
            other_tree to merge into this_tree.
1823
 
        """
1824
 
        # It is assumed that we are merging a tree that is not in our current
1825
 
        # ancestry, which means we are using the "EmptyTree" as our basis.
1826
 
        null_ancestor_tree = this_tree.branch.repository.revision_tree(
1827
 
                                _mod_revision.NULL_REVISION)
1828
 
        super(MergeIntoMerger, self).__init__(
1829
 
            this_branch=this_tree.branch,
1830
 
            this_tree=this_tree,
1831
 
            other_tree=other_tree,
1832
 
            base_tree=null_ancestor_tree,
1833
 
            )
1834
 
        self._target_subdir = target_subdir
1835
 
        self._source_subpath = source_subpath
1836
 
        self.other_branch = other_branch
1837
 
        if other_rev_id is None:
1838
 
            other_rev_id = other_tree.get_revision_id()
1839
 
        self.other_rev_id = self.other_basis = other_rev_id
1840
 
        self.base_is_ancestor = True
1841
 
        self.backup_files = True
1842
 
        self.merge_type = Merge3Merger
1843
 
        self.show_base = False
1844
 
        self.reprocess = False
1845
 
        self.interesting_ids = None
1846
 
        self.merge_type = _MergeTypeParameterizer(MergeIntoMergeType,
1847
 
              target_subdir=self._target_subdir,
1848
 
              source_subpath=self._source_subpath)
1849
 
        if self._source_subpath != '':
1850
 
            # If this isn't a partial merge make sure the revisions will be
1851
 
            # present.
1852
 
            self._maybe_fetch(self.other_branch, self.this_branch,
1853
 
                self.other_basis)
1854
 
 
1855
 
    def set_pending(self):
1856
 
        if self._source_subpath != '':
1857
 
            return
1858
 
        Merger.set_pending(self)
1859
 
 
1860
 
 
1861
 
class _MergeTypeParameterizer(object):
1862
 
    """Wrap a merge-type class to provide extra parameters.
1863
 
    
1864
 
    This is hack used by MergeIntoMerger to pass some extra parameters to its
1865
 
    merge_type.  Merger.do_merge() sets up its own set of parameters to pass to
1866
 
    the 'merge_type' member.  It is difficult override do_merge without
1867
 
    re-writing the whole thing, so instead we create a wrapper which will pass
1868
 
    the extra parameters.
1869
 
    """
1870
 
 
1871
 
    def __init__(self, merge_type, **kwargs):
1872
 
        self._extra_kwargs = kwargs
1873
 
        self._merge_type = merge_type
1874
 
 
1875
 
    def __call__(self, *args, **kwargs):
1876
 
        kwargs.update(self._extra_kwargs)
1877
 
        return self._merge_type(*args, **kwargs)
1878
 
 
1879
 
    def __getattr__(self, name):
1880
 
        return getattr(self._merge_type, name)
1881
 
 
1882
 
 
1883
 
class MergeIntoMergeType(Merge3Merger):
1884
 
    """Merger that incorporates a tree (or part of a tree) into another."""
1885
 
 
1886
 
    def __init__(self, *args, **kwargs):
1887
 
        """Initialize the merger object.
1888
 
 
1889
 
        :param args: See Merge3Merger.__init__'s args.
1890
 
        :param kwargs: See Merge3Merger.__init__'s keyword args, except for
1891
 
            source_subpath and target_subdir.
1892
 
        :keyword source_subpath: The relative path specifying the subtree of
1893
 
            other_tree to merge into this_tree.
1894
 
        :keyword target_subdir: The relative path where we want to merge
1895
 
            other_tree into this_tree
1896
 
        """
1897
 
        # All of the interesting work happens during Merge3Merger.__init__(),
1898
 
        # so we have have to hack in to get our extra parameters set.
1899
 
        self._source_subpath = kwargs.pop('source_subpath')
1900
 
        self._target_subdir = kwargs.pop('target_subdir')
1901
 
        super(MergeIntoMergeType, self).__init__(*args, **kwargs)
1902
 
 
1903
 
    def _compute_transform(self):
1904
 
        child_pb = ui.ui_factory.nested_progress_bar()
1905
 
        try:
1906
 
            entries = self._entries_to_incorporate()
1907
 
            entries = list(entries)
1908
 
            for num, (entry, parent_id) in enumerate(entries):
1909
 
                child_pb.update('Preparing file merge', num, len(entries))
1910
 
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
1911
 
                trans_id = transform.new_by_entry(self.tt, entry,
1912
 
                    parent_trans_id, self.other_tree)
1913
 
        finally:
1914
 
            child_pb.finished()
1915
 
        self._finish_computing_transform()
1916
 
 
1917
 
    def _entries_to_incorporate(self):
1918
 
        """Yields pairs of (inventory_entry, new_parent)."""
1919
 
        other_inv = self.other_tree.inventory
1920
 
        subdir_id = other_inv.path2id(self._source_subpath)
1921
 
        if subdir_id is None:
1922
 
            # XXX: The error would be clearer if it gave the URL of the source
1923
 
            # branch, but we don't have a reference to that here.
1924
 
            raise PathNotInTree(self._source_subpath, "Source tree")
1925
 
        subdir = other_inv[subdir_id]
1926
 
        parent_in_target = osutils.dirname(self._target_subdir)
1927
 
        target_id = self.this_tree.inventory.path2id(parent_in_target)
1928
 
        if target_id is None:
1929
 
            raise PathNotInTree(self._target_subdir, "Target tree")
1930
 
        name_in_target = osutils.basename(self._target_subdir)
1931
 
        merge_into_root = subdir.copy()
1932
 
        merge_into_root.name = name_in_target
1933
 
        if self.this_tree.inventory.has_id(merge_into_root.file_id):
1934
 
            # Give the root a new file-id.
1935
 
            # This can happen fairly easily if the directory we are
1936
 
            # incorporating is the root, and both trees have 'TREE_ROOT' as
1937
 
            # their root_id.  Users will expect this to Just Work, so we
1938
 
            # change the file-id here.
1939
 
            # Non-root file-ids could potentially conflict too.  That's really
1940
 
            # an edge case, so we don't do anything special for those.  We let
1941
 
            # them cause conflicts.
1942
 
            merge_into_root.file_id = generate_ids.gen_file_id(name_in_target)
1943
 
        yield (merge_into_root, target_id)
1944
 
        if subdir.kind != 'directory':
1945
 
            # No children, so we are done.
1946
 
            return
1947
 
        for ignored_path, entry in other_inv.iter_entries_by_dir(subdir_id):
1948
 
            parent_id = entry.parent_id
1949
 
            if parent_id == subdir.file_id:
1950
 
                # The root's parent ID has changed, so make sure children of
1951
 
                # the root refer to the new ID.
1952
 
                parent_id = merge_into_root.file_id
1953
 
            yield (entry, parent_id)
1954
 
 
1955
 
 
1956
1710
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1957
1711
                backup_files=False,
1958
1712
                merge_type=Merge3Merger,
1962
1716
                other_rev_id=None,
1963
1717
                interesting_files=None,
1964
1718
                this_tree=None,
1965
 
                pb=None,
 
1719
                pb=progress.DummyProgress(),
1966
1720
                change_reporter=None):
1967
1721
    """Primary interface for merging.
1968
1722
 
1969
 
    Typical use is probably::
1970
 
 
1971
 
        merge_inner(branch, branch.get_revision_tree(other_revision),
1972
 
                    branch.get_revision_tree(base_revision))
1973
 
    """
 
1723
        typical use is probably
 
1724
        'merge_inner(branch, branch.get_revision_tree(other_revision),
 
1725
                     branch.get_revision_tree(base_revision))'
 
1726
        """
1974
1727
    if this_tree is None:
1975
1728
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1976
 
                              "parameter")
 
1729
                              "parameter as of bzrlib version 0.8.")
1977
1730
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1978
1731
                    pb=pb, change_reporter=change_reporter)
1979
1732
    merger.backup_files = backup_files
2433
2186
class _PlanLCAMerge(_PlanMergeBase):
2434
2187
    """
2435
2188
    This merge algorithm differs from _PlanMerge in that:
2436
 
 
2437
2189
    1. comparisons are done against LCAs only
2438
2190
    2. cases where a contested line is new versus one LCA but old versus
2439
2191
       another are marked as conflicts, by emitting the line as conflicted-a
2480
2232
 
2481
2233
        If a line is killed and new, this indicates that the two merge
2482
2234
        revisions contain differing conflict resolutions.
2483
 
 
2484
2235
        :param revision_id: The id of the revision in which the lines are
2485
2236
            unique
2486
2237
        :param unique_line_numbers: The line numbers of unique lines.
2487
 
        :return: a tuple of (new_this, killed_other)
 
2238
        :return a tuple of (new_this, killed_other):
2488
2239
        """
2489
2240
        new = set()
2490
2241
        killed = set()