← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Andrew Bennetts
  • Date: 2010-02-12 04:33:05 UTC
  • mfrom: (5031 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5032.
  • Revision ID: andrew.bennetts@canonical.com-20100212043305-ujdbsdoviql2t7i3
Merge lp:bzr

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
16
16
 
17
17
import warnings
18
18
 
19
 
from bzrlib.lazy_import import lazy_import
20
 
lazy_import(globals(), """
21
19
from bzrlib import (
22
20
    branch as _mod_branch,
23
 
    cleanup,
24
21
    conflicts as _mod_conflicts,
25
22
    debug,
26
 
    generate_ids,
 
23
    decorators,
 
24
    errors,
27
25
    graph as _mod_graph,
 
26
    hooks,
28
27
    merge3,
29
28
    osutils,
30
29
    patiencediff,
 
30
    progress,
31
31
    revision as _mod_revision,
32
32
    textfile,
33
33
    trace,
35
35
    tree as _mod_tree,
36
36
    tsort,
37
37
    ui,
38
 
    versionedfile,
39
 
    workingtree,
40
 
    )
41
 
""")
42
 
from bzrlib import (
43
 
    decorators,
44
 
    errors,
45
 
    hooks,
 
38
    versionedfile
46
39
    )
47
40
from bzrlib.symbol_versioning import (
48
41
    deprecated_in,
53
46
 
54
47
def transform_tree(from_tree, to_tree, interesting_ids=None):
55
48
    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)
 
49
    try:
 
50
        merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
 
51
                    interesting_ids=interesting_ids, this_tree=from_tree)
 
52
    finally:
 
53
        from_tree.unlock()
60
54
 
61
55
 
62
56
class MergeHooks(hooks.Hooks):
63
57
 
64
58
    def __init__(self):
65
 
        hooks.Hooks.__init__(self, "bzrlib.merge", "Merger.hooks")
66
 
        self.add_hook('merge_file_content',
 
59
        hooks.Hooks.__init__(self)
 
60
        self.create_hook(hooks.HookPoint('merge_file_content',
67
61
            "Called with a bzrlib.merge.Merger object to create a per file "
68
62
            "merge object when starting a merge. "
69
63
            "Should return either None or a subclass of "
73
67
            "side has deleted the file and the other has changed it). "
74
68
            "See the AbstractPerFileMerger API docs for details on how it is "
75
69
            "used by merge.",
76
 
            (2, 1))
 
70
            (2, 1), None))
77
71
 
78
72
 
79
73
class AbstractPerFileMerger(object):
92
86
        """Attempt to merge the contents of a single file.
93
87
        
94
88
        :param merge_params: A bzrlib.merge.MergeHookParams
95
 
        :return: A tuple of (status, chunks), where status is one of
 
89
        :return : A tuple of (status, chunks), where status is one of
96
90
            'not_applicable', 'success', 'conflicted', or 'delete'.  If status
97
91
            is 'success' or 'conflicted', then chunks should be an iterable of
98
92
            strings for the new file contents.
100
94
        return ('not applicable', None)
101
95
 
102
96
 
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):
 
97
class ConfigurableFileMerger(AbstractPerFileMerger):
157
98
    """Merge individual files when configured via a .conf file.
158
99
 
159
100
    This is a base class for concrete custom file merging logic. Concrete
182
123
        if self.name_prefix is None:
183
124
            raise ValueError("name_prefix must be set.")
184
125
 
185
 
    def file_matches(self, params):
 
126
    def filename_matches_config(self, params):
186
127
        """Check whether the file should call the merge hook.
187
128
 
188
129
        <name_prefix>_merge_files configuration variable is a list of files
190
131
        """
191
132
        affected_files = self.affected_files
192
133
        if affected_files is None:
193
 
            config = self.merger.this_branch.get_config()
 
134
            config = self.merger.this_tree.branch.get_config()
194
135
            # Until bzr provides a better policy for caching the config, we
195
136
            # just add the part we're interested in to the params to avoid
196
137
            # reading the config files repeatedly (bazaar.conf, location.conf,
202
143
                affected_files = self.default_files
203
144
            self.affected_files = affected_files
204
145
        if affected_files:
205
 
            filepath = self.get_filepath(params, self.merger.this_tree)
206
 
            if filepath in affected_files:
 
146
            filename = self.merger.this_tree.id2path(params.file_id)
 
147
            if filename in affected_files:
207
148
                return True
208
149
        return False
209
150
 
210
 
    def merge_matching(self, params):
 
151
    def merge_contents(self, params):
 
152
        """Merge the contents of a single file."""
 
153
        # First, check whether this custom merge logic should be used.  We
 
154
        # expect most files should not be merged by this handler.
 
155
        if (
 
156
            # OTHER is a straight winner, rely on default merge.
 
157
            params.winner == 'other' or
 
158
            # THIS and OTHER aren't both files.
 
159
            not params.is_file_merge() or
 
160
            # The filename isn't listed in the 'NAME_merge_files' config
 
161
            # option.
 
162
            not self.filename_matches_config(params)):
 
163
            return 'not_applicable', None
211
164
        return self.merge_text(params)
212
165
 
213
166
    def merge_text(self, params):
428
381
        return self._cached_trees[revision_id]
429
382
 
430
383
    def _get_tree(self, treespec, possible_transports=None):
 
384
        from bzrlib import workingtree
431
385
        location, revno = treespec
432
386
        if revno is None:
433
387
            tree = workingtree.WorkingTree.open_containing(location)[0]
458
412
    @deprecated_method(deprecated_in((2, 1, 0)))
459
413
    def file_revisions(self, file_id):
460
414
        self.ensure_revision_trees()
 
415
        def get_id(tree, file_id):
 
416
            revision_id = tree.inventory[file_id].revision
 
417
            return revision_id
461
418
        if self.this_rev_id is None:
462
419
            if self.this_basis_tree.get_file_sha1(file_id) != \
463
420
                self.this_tree.get_file_sha1(file_id):
464
421
                raise errors.WorkingTreeNotRevision(self.this_tree)
465
422
 
466
423
        trees = (self.this_basis_tree, self.other_tree)
467
 
        return [tree.get_file_revision(file_id) for tree in trees]
 
424
        return [get_id(tree, file_id) for tree in trees]
468
425
 
469
426
    @deprecated_method(deprecated_in((2, 1, 0)))
470
427
    def check_basis(self, check_clean, require_commits=True):
498
455
    def _add_parent(self):
499
456
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
500
457
        new_parent_trees = []
501
 
        operation = cleanup.OperationWithCleanups(
502
 
            self.this_tree.set_parent_trees)
503
458
        for revision_id in new_parents:
504
459
            try:
505
460
                tree = self.revision_tree(revision_id)
507
462
                tree = None
508
463
            else:
509
464
                tree.lock_read()
510
 
                operation.add_cleanup(tree.unlock)
511
465
            new_parent_trees.append((revision_id, tree))
512
 
        operation.run_simple(new_parent_trees, allow_leftmost_as_ghost=True)
 
466
        try:
 
467
            self.this_tree.set_parent_trees(new_parent_trees,
 
468
                                            allow_leftmost_as_ghost=True)
 
469
        finally:
 
470
            for _revision_id, tree in new_parent_trees:
 
471
                if tree is not None:
 
472
                    tree.unlock()
513
473
 
514
474
    def set_other(self, other_revision, possible_transports=None):
515
475
        """Set the revision and tree to merge from.
580
540
            elif len(lcas) == 1:
581
541
                self.base_rev_id = list(lcas)[0]
582
542
            else: # len(lcas) > 1
583
 
                self._is_criss_cross = True
584
543
                if len(lcas) > 2:
585
544
                    # find_unique_lca can only handle 2 nodes, so we have to
586
545
                    # start back at the beginning. It is a shame to traverse
591
550
                else:
592
551
                    self.base_rev_id = self.revision_graph.find_unique_lca(
593
552
                                            *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
 
                
 
553
                self._is_criss_cross = True
599
554
            if self.base_rev_id == _mod_revision.NULL_REVISION:
600
555
                raise errors.UnrelatedBranches()
601
556
            if self._is_criss_cross:
602
557
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
603
558
                              ' help criss-cross.')
604
559
                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)
 
560
                interesting_revision_ids = [self.base_rev_id]
 
561
                interesting_revision_ids.extend(lcas)
610
562
                interesting_trees = dict((t.get_revision_id(), t)
611
563
                    for t in self.this_branch.repository.revision_trees(
612
564
                        interesting_revision_ids))
613
565
                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)
 
566
                self.base_tree = interesting_trees.pop(self.base_rev_id)
 
567
                sorted_lca_keys = self.revision_graph.find_merge_order(
 
568
                    revisions[0], lcas)
618
569
                self._lca_trees = [interesting_trees[key]
619
570
                                   for key in sorted_lca_keys]
620
571
            else:
675
626
                               change_reporter=self.change_reporter,
676
627
                               **kwargs)
677
628
 
678
 
    def _do_merge_to(self):
679
 
        merge = self.make_merger()
 
629
    def _do_merge_to(self, merge):
680
630
        if self.other_branch is not None:
681
631
            self.other_branch.update_references(self.this_branch)
682
632
        merge.do_merge()
696
646
                    sub_tree.branch.repository.revision_tree(base_revision)
697
647
                sub_merge.base_rev_id = base_revision
698
648
                sub_merge.do_merge()
699
 
        return merge
700
649
 
701
650
    def do_merge(self):
702
 
        operation = cleanup.OperationWithCleanups(self._do_merge_to)
703
651
        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()
 
652
        try:
 
653
            if self.base_tree is not None:
 
654
                self.base_tree.lock_read()
 
655
            try:
 
656
                if self.other_tree is not None:
 
657
                    self.other_tree.lock_read()
 
658
                try:
 
659
                    merge = self.make_merger()
 
660
                    self._do_merge_to(merge)
 
661
                finally:
 
662
                    if self.other_tree is not None:
 
663
                        self.other_tree.unlock()
 
664
            finally:
 
665
                if self.base_tree is not None:
 
666
                    self.base_tree.unlock()
 
667
        finally:
 
668
            self.this_tree.unlock()
712
669
        if len(merge.cooked_conflicts) == 0:
713
670
            if not self.ignore_zero and not trace.is_quiet():
714
671
                trace.note("All changes applied successfully.")
758
715
        :param this_tree: The local tree in the merge operation
759
716
        :param base_tree: The common tree in the merge operation
760
717
        :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.
 
718
        :param this_branch: The branch associated with this_tree
763
719
        :param interesting_ids: The file_ids of files that should be
764
720
            participate in the merge.  May not be combined with
765
721
            interesting_files.
783
739
        if interesting_files is not None and interesting_ids is not None:
784
740
            raise ValueError(
785
741
                'specify either interesting_ids or interesting_files')
786
 
        if this_branch is None:
787
 
            this_branch = this_tree.branch
788
742
        self.interesting_ids = interesting_ids
789
743
        self.interesting_files = interesting_files
790
744
        self.this_tree = working_tree
811
765
            warnings.warn("pb argument to Merge3Merger is deprecated")
812
766
 
813
767
    def do_merge(self):
814
 
        operation = cleanup.OperationWithCleanups(self._do_merge)
815
768
        self.this_tree.lock_tree_write()
816
 
        operation.add_cleanup(self.this_tree.unlock)
817
769
        self.base_tree.lock_read()
818
 
        operation.add_cleanup(self.base_tree.unlock)
819
770
        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
771
        try:
830
 
            self.this_tree.add_conflicts(self.cooked_conflicts)
831
 
        except errors.UnsupportedOperation:
832
 
            pass
 
772
            self.tt = transform.TreeTransform(self.this_tree, None)
 
773
            try:
 
774
                self._compute_transform()
 
775
                results = self.tt.apply(no_conflicts=True)
 
776
                self.write_modified(results)
 
777
                try:
 
778
                    self.this_tree.add_conflicts(self.cooked_conflicts)
 
779
                except errors.UnsupportedOperation:
 
780
                    pass
 
781
            finally:
 
782
                self.tt.finalize()
 
783
        finally:
 
784
            self.other_tree.unlock()
 
785
            self.base_tree.unlock()
 
786
            self.this_tree.unlock()
833
787
 
834
788
    def make_preview_transform(self):
835
 
        operation = cleanup.OperationWithCleanups(self._make_preview_transform)
836
789
        self.base_tree.lock_read()
837
 
        operation.add_cleanup(self.base_tree.unlock)
838
790
        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
791
        self.tt = transform.TransformPreview(self.this_tree)
844
 
        self._compute_transform()
 
792
        try:
 
793
            self._compute_transform()
 
794
        finally:
 
795
            self.other_tree.unlock()
 
796
            self.base_tree.unlock()
845
797
        return self.tt
846
798
 
847
799
    def _compute_transform(self):
868
820
                    executable3, file_status, resolver=resolver)
869
821
        finally:
870
822
            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
 
        """
 
823
        self.fix_root()
879
824
        child_pb = ui.ui_factory.nested_progress_bar()
880
825
        try:
881
826
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
888
833
                self.tt.iter_changes(), self.change_reporter)
889
834
        self.cook_conflicts(fs_conflicts)
890
835
        for conflict in self.cooked_conflicts:
891
 
            trace.warning(unicode(conflict))
 
836
            trace.warning(conflict)
892
837
 
893
838
    def _entries3(self):
894
839
        """Gather data about files modified between three trees.
901
846
        """
902
847
        result = []
903
848
        iterator = self.other_tree.iter_changes(self.base_tree,
904
 
                specific_files=self.interesting_files,
 
849
                include_unchanged=True, specific_files=self.interesting_files,
905
850
                extra_trees=[self.this_tree])
906
851
        this_entries = dict((e.file_id, e) for p, e in
907
852
                            self.this_tree.iter_entries_by_dir(
933
878
        it then compares with THIS and BASE.
934
879
 
935
880
        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)
 
881
        :return: [(file_id, changed, parents, names, executable)]
 
882
            file_id     Simple file_id of the entry
 
883
            changed     Boolean, True if the kind or contents changed
 
884
                        else False
 
885
            parents     ((base, [parent_id, in, lcas]), parent_id_other,
 
886
                         parent_id_this)
 
887
            names       ((base, [name, in, lcas]), name_in_other, name_in_this)
 
888
            executable  ((base, [exec, in, lcas]), exec_in_other, exec_in_this)
946
889
        """
947
890
        if self.interesting_files is not None:
948
891
            lookup_trees = [self.this_tree, self.base_tree]
990
933
                else:
991
934
                    lca_entries.append(lca_ie)
992
935
 
993
 
            if base_inventory.has_id(file_id):
 
936
            if file_id in base_inventory:
994
937
                base_ie = base_inventory[file_id]
995
938
            else:
996
939
                base_ie = _none_entry
997
940
 
998
 
            if this_inventory.has_id(file_id):
 
941
            if file_id in this_inventory:
999
942
                this_ie = this_inventory[file_id]
1000
943
            else:
1001
944
                this_ie = _none_entry
1081
1024
                        continue
1082
1025
                else:
1083
1026
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
 
1027
                # XXX: We need to handle kind == 'symlink'
1084
1028
 
1085
1029
            # If we have gotten this far, that means something has changed
1086
1030
            result.append((file_id, content_changed,
1093
1037
                          ))
1094
1038
        return result
1095
1039
 
1096
 
    @deprecated_method(deprecated_in((2, 4, 0)))
 
1040
 
1097
1041
    def fix_root(self):
1098
 
        if self.tt.final_kind(self.tt.root) is None:
 
1042
        try:
 
1043
            self.tt.final_kind(self.tt.root)
 
1044
        except errors.NoSuchFile:
1099
1045
            self.tt.cancel_deletion(self.tt.root)
1100
1046
        if self.tt.final_file_id(self.tt.root) is None:
1101
1047
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
1106
1052
        other_root = self.tt.trans_id_file_id(other_root_file_id)
1107
1053
        if other_root == self.tt.root:
1108
1054
            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():
 
1055
        try:
 
1056
            self.tt.final_kind(other_root)
 
1057
        except errors.NoSuchFile:
 
1058
            return
 
1059
        if self.this_tree.has_id(self.other_tree.inventory.root.file_id):
 
1060
            # the other tree's root is a non-root in the current tree
 
1061
            return
 
1062
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
 
1063
        self.tt.cancel_creation(other_root)
 
1064
        self.tt.cancel_versioning(other_root)
 
1065
 
 
1066
    def reparent_children(self, ie, target):
 
1067
        for thing, child in ie.children.iteritems():
1124
1068
            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)
 
1069
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1140
1070
 
1141
1071
    def write_modified(self, results):
1142
1072
        modified_hashes = {}
1167
1097
    @staticmethod
1168
1098
    def contents_sha1(tree, file_id):
1169
1099
        """Determine the sha1 of the file contents (used as a key method)."""
1170
 
        if not tree.has_id(file_id):
 
1100
        if file_id not in tree:
1171
1101
            return None
1172
1102
        return tree.get_file_sha1(file_id)
1173
1103
 
1189
1119
 
1190
1120
    @staticmethod
1191
1121
    def _three_way(base, other, this):
 
1122
        #if base == other, either they all agree, or only THIS has changed.
1192
1123
        if base == other:
1193
 
            # if 'base == other', either they all agree, or only 'this' has
1194
 
            # changed.
1195
1124
            return 'this'
1196
1125
        elif this not in (base, other):
1197
 
            # 'this' is neither 'base' nor 'other', so both sides changed
1198
1126
            return 'conflict'
 
1127
        # "Ambiguous clean merge" -- both sides have made the same change.
1199
1128
        elif this == other:
1200
 
            # "Ambiguous clean merge" -- both sides have made the same change.
1201
1129
            return "this"
 
1130
        # this == base: only other has changed.
1202
1131
        else:
1203
 
            # this == base: only other has changed.
1204
1132
            return "other"
1205
1133
 
1206
1134
    @staticmethod
1250
1178
                # only has an lca value
1251
1179
                return 'other'
1252
1180
 
1253
 
        # At this point, the lcas disagree, and the tip disagree
 
1181
        # At this point, the lcas disagree, and the tips disagree
1254
1182
        return 'conflict'
1255
1183
 
1256
1184
    @staticmethod
1257
 
    @deprecated_method(deprecated_in((2, 2, 0)))
1258
1185
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1259
1186
        """Do a three-way test on a scalar.
1260
1187
        Return "this", "other" or "conflict", depending whether a value wins.
1310
1237
                parent_id_winner = "other"
1311
1238
        if name_winner == "this" and parent_id_winner == "this":
1312
1239
            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):
 
1240
        if name_winner == "conflict":
 
1241
            trans_id = self.tt.trans_id_file_id(file_id)
 
1242
            self._raw_conflicts.append(('name conflict', trans_id,
 
1243
                                        this_name, other_name))
 
1244
        if parent_id_winner == "conflict":
 
1245
            trans_id = self.tt.trans_id_file_id(file_id)
 
1246
            self._raw_conflicts.append(('parent conflict', trans_id,
 
1247
                                        this_parent, other_parent))
 
1248
        if other_name is None:
1322
1249
            # it doesn't matter whether the result was 'other' or
1323
 
            # 'conflict'-- if it has no file id, we leave it alone.
 
1250
            # 'conflict'-- if there's no 'other', we leave it alone.
1324
1251
            return
 
1252
        # if we get here, name_winner and parent_winner are set to safe values.
 
1253
        trans_id = self.tt.trans_id_file_id(file_id)
1325
1254
        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))
 
1255
        if parent_id is not None:
 
1256
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1257
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
 
1258
                                parent_trans_id, trans_id)
1342
1259
 
1343
1260
    def _do_merge_contents(self, file_id):
1344
1261
        """Performs a merge on file_id contents."""
1345
1262
        def contents_pair(tree):
1346
 
            if not tree.has_id(file_id):
 
1263
            if file_id not in tree:
1347
1264
                return (None, None)
1348
1265
            kind = tree.kind(file_id)
1349
1266
            if kind == "file":
1422
1339
            self.tt.version_file(file_id, trans_id)
1423
1340
        # The merge has been performed, so the old contents should not be
1424
1341
        # retained.
1425
 
        self.tt.delete_contents(trans_id)
 
1342
        try:
 
1343
            self.tt.delete_contents(trans_id)
 
1344
        except errors.NoSuchFile:
 
1345
            pass
1426
1346
        return result
1427
1347
 
1428
1348
    def _default_other_winner_merge(self, merge_hook_params):
1481
1401
    def get_lines(self, tree, file_id):
1482
1402
        """Return the lines in a file, or an empty list."""
1483
1403
        if tree.has_id(file_id):
1484
 
            return tree.get_file_lines(file_id)
 
1404
            return tree.get_file(file_id).readlines()
1485
1405
        else:
1486
1406
            return []
1487
1407
 
1600
1520
        if winner == 'this' and file_status != "modified":
1601
1521
            return
1602
1522
        trans_id = self.tt.trans_id_file_id(file_id)
1603
 
        if self.tt.final_kind(trans_id) != "file":
 
1523
        try:
 
1524
            if self.tt.final_kind(trans_id) != "file":
 
1525
                return
 
1526
        except errors.NoSuchFile:
1604
1527
            return
1605
1528
        if winner == "this":
1606
1529
            executability = this_executable
1617
1540
 
1618
1541
    def cook_conflicts(self, fs_conflicts):
1619
1542
        """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)
 
1543
        name_conflicts = {}
 
1544
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1545
                fs_conflicts, self.tt))
1622
1546
        fp = transform.FinalPaths(self.tt)
1623
1547
        for conflict in self._raw_conflicts:
1624
1548
            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':
 
1549
            if conflict_type in ('name conflict', 'parent conflict'):
 
1550
                trans_id = conflict[1]
 
1551
                conflict_args = conflict[2:]
 
1552
                if trans_id not in name_conflicts:
 
1553
                    name_conflicts[trans_id] = {}
 
1554
                transform.unique_add(name_conflicts[trans_id], conflict_type,
 
1555
                                     conflict_args)
 
1556
            if conflict_type == 'contents conflict':
1652
1557
                for trans_id in conflict[1]:
1653
1558
                    file_id = self.tt.final_file_id(trans_id)
1654
1559
                    if file_id is not None:
1660
1565
                        break
1661
1566
                c = _mod_conflicts.Conflict.factory(conflict_type,
1662
1567
                                                    path=path, file_id=file_id)
1663
 
                content_conflict_file_ids.add(file_id)
1664
 
            elif conflict_type == 'text conflict':
 
1568
                self.cooked_conflicts.append(c)
 
1569
            if conflict_type == 'text conflict':
1665
1570
                trans_id = conflict[1]
1666
1571
                path = fp.get_path(trans_id)
1667
1572
                file_id = self.tt.final_file_id(trans_id)
1668
1573
                c = _mod_conflicts.Conflict.factory(conflict_type,
1669
1574
                                                    path=path, file_id=file_id)
 
1575
                self.cooked_conflicts.append(c)
 
1576
 
 
1577
        for trans_id, conflicts in name_conflicts.iteritems():
 
1578
            try:
 
1579
                this_parent, other_parent = conflicts['parent conflict']
 
1580
                if this_parent == other_parent:
 
1581
                    raise AssertionError()
 
1582
            except KeyError:
 
1583
                this_parent = other_parent = \
 
1584
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
 
1585
            try:
 
1586
                this_name, other_name = conflicts['name conflict']
 
1587
                if this_name == other_name:
 
1588
                    raise AssertionError()
 
1589
            except KeyError:
 
1590
                this_name = other_name = self.tt.final_name(trans_id)
 
1591
            other_path = fp.get_path(trans_id)
 
1592
            if this_parent is not None and this_name is not None:
 
1593
                this_parent_path = \
 
1594
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
 
1595
                this_path = osutils.pathjoin(this_parent_path, this_name)
1670
1596
            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
 
1597
                this_path = "<deleted>"
 
1598
            file_id = self.tt.final_file_id(trans_id)
 
1599
            c = _mod_conflicts.Conflict.factory('path conflict', path=this_path,
 
1600
                                                conflict_path=other_path,
 
1601
                                                file_id=file_id)
1683
1602
            self.cooked_conflicts.append(c)
1684
1603
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1685
1604
 
1791
1710
            osutils.rmtree(temp_dir)
1792
1711
 
1793
1712
 
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
1713
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1957
1714
                backup_files=False,
1958
1715
                merge_type=Merge3Merger,
1966
1723
                change_reporter=None):
1967
1724
    """Primary interface for merging.
1968
1725
 
1969
 
    Typical use is probably::
1970
 
 
1971
 
        merge_inner(branch, branch.get_revision_tree(other_revision),
1972
 
                    branch.get_revision_tree(base_revision))
1973
 
    """
 
1726
        typical use is probably
 
1727
        'merge_inner(branch, branch.get_revision_tree(other_revision),
 
1728
                     branch.get_revision_tree(base_revision))'
 
1729
        """
1974
1730
    if this_tree is None:
1975
1731
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1976
 
                              "parameter")
 
1732
                              "parameter as of bzrlib version 0.8.")
1977
1733
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1978
1734
                    pb=pb, change_reporter=change_reporter)
1979
1735
    merger.backup_files = backup_files
2433
2189
class _PlanLCAMerge(_PlanMergeBase):
2434
2190
    """
2435
2191
    This merge algorithm differs from _PlanMerge in that:
2436
 
 
2437
2192
    1. comparisons are done against LCAs only
2438
2193
    2. cases where a contested line is new versus one LCA but old versus
2439
2194
       another are marked as conflicts, by emitting the line as conflicted-a
2480
2235
 
2481
2236
        If a line is killed and new, this indicates that the two merge
2482
2237
        revisions contain differing conflict resolutions.
2483
 
 
2484
2238
        :param revision_id: The id of the revision in which the lines are
2485
2239
            unique
2486
2240
        :param unique_line_numbers: The line numbers of unique lines.
2487
 
        :return: a tuple of (new_this, killed_other)
 
2241
        :return a tuple of (new_this, killed_other):
2488
2242
        """
2489
2243
        new = set()
2490
2244
        killed = set()