← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

Merge bzr.dev into cleanup

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,
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,
46
 
    )
 
37
    versionedfile
 
38
    )
 
39
from bzrlib.cleanup import OperationWithCleanups
47
40
from bzrlib.symbol_versioning import (
48
41
    deprecated_in,
49
42
    deprecated_method,
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)
 
49
    operation = OperationWithCleanups(merge_inner)
57
50
    operation.add_cleanup(from_tree.unlock)
58
51
    operation.run_simple(from_tree.branch, to_tree, from_tree,
59
52
        ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
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
182
122
        if self.name_prefix is None:
183
123
            raise ValueError("name_prefix must be set.")
184
124
 
185
 
    def file_matches(self, params):
 
125
    def filename_matches_config(self, params):
186
126
        """Check whether the file should call the merge hook.
187
127
 
188
128
        <name_prefix>_merge_files configuration variable is a list of files
202
142
                affected_files = self.default_files
203
143
            self.affected_files = affected_files
204
144
        if affected_files:
205
 
            filepath = self.get_filepath(params, self.merger.this_tree)
206
 
            if filepath in affected_files:
 
145
            filename = self.merger.this_tree.id2path(params.file_id)
 
146
            if filename in affected_files:
207
147
                return True
208
148
        return False
209
149
 
210
 
    def merge_matching(self, params):
 
150
    def merge_contents(self, params):
 
151
        """Merge the contents of a single file."""
 
152
        # First, check whether this custom merge logic should be used.  We
 
153
        # expect most files should not be merged by this handler.
 
154
        if (
 
155
            # OTHER is a straight winner, rely on default merge.
 
156
            params.winner == 'other' or
 
157
            # THIS and OTHER aren't both files.
 
158
            not params.is_file_merge() or
 
159
            # The filename isn't listed in the 'NAME_merge_files' config
 
160
            # option.
 
161
            not self.filename_matches_config(params)):
 
162
            return 'not_applicable', None
211
163
        return self.merge_text(params)
212
164
 
213
165
    def merge_text(self, params):
428
380
        return self._cached_trees[revision_id]
429
381
 
430
382
    def _get_tree(self, treespec, possible_transports=None):
 
383
        from bzrlib import workingtree
431
384
        location, revno = treespec
432
385
        if revno is None:
433
386
            tree = workingtree.WorkingTree.open_containing(location)[0]
458
411
    @deprecated_method(deprecated_in((2, 1, 0)))
459
412
    def file_revisions(self, file_id):
460
413
        self.ensure_revision_trees()
 
414
        def get_id(tree, file_id):
 
415
            revision_id = tree.inventory[file_id].revision
 
416
            return revision_id
461
417
        if self.this_rev_id is None:
462
418
            if self.this_basis_tree.get_file_sha1(file_id) != \
463
419
                self.this_tree.get_file_sha1(file_id):
464
420
                raise errors.WorkingTreeNotRevision(self.this_tree)
465
421
 
466
422
        trees = (self.this_basis_tree, self.other_tree)
467
 
        return [tree.get_file_revision(file_id) for tree in trees]
 
423
        return [get_id(tree, file_id) for tree in trees]
468
424
 
469
425
    @deprecated_method(deprecated_in((2, 1, 0)))
470
426
    def check_basis(self, check_clean, require_commits=True):
498
454
    def _add_parent(self):
499
455
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
500
456
        new_parent_trees = []
501
 
        operation = cleanup.OperationWithCleanups(
502
 
            self.this_tree.set_parent_trees)
 
457
        operation = OperationWithCleanups(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)
580
535
            elif len(lcas) == 1:
581
536
                self.base_rev_id = list(lcas)[0]
582
537
            else: # len(lcas) > 1
583
 
                self._is_criss_cross = True
584
538
                if len(lcas) > 2:
585
539
                    # find_unique_lca can only handle 2 nodes, so we have to
586
540
                    # start back at the beginning. It is a shame to traverse
591
545
                else:
592
546
                    self.base_rev_id = self.revision_graph.find_unique_lca(
593
547
                                            *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
 
                
 
548
                self._is_criss_cross = True
599
549
            if self.base_rev_id == _mod_revision.NULL_REVISION:
600
550
                raise errors.UnrelatedBranches()
601
551
            if self._is_criss_cross:
602
552
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
603
553
                              ' help criss-cross.')
604
554
                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)
 
555
                interesting_revision_ids = [self.base_rev_id]
 
556
                interesting_revision_ids.extend(lcas)
610
557
                interesting_trees = dict((t.get_revision_id(), t)
611
558
                    for t in self.this_branch.repository.revision_trees(
612
559
                        interesting_revision_ids))
613
560
                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)
 
561
                self.base_tree = interesting_trees.pop(self.base_rev_id)
 
562
                sorted_lca_keys = self.revision_graph.find_merge_order(
 
563
                    revisions[0], lcas)
618
564
                self._lca_trees = [interesting_trees[key]
619
565
                                   for key in sorted_lca_keys]
620
566
            else:
699
645
        return merge
700
646
 
701
647
    def do_merge(self):
702
 
        operation = cleanup.OperationWithCleanups(self._do_merge_to)
 
648
        operation = OperationWithCleanups(self._do_merge_to)
703
649
        self.this_tree.lock_tree_write()
704
650
        operation.add_cleanup(self.this_tree.unlock)
705
651
        if self.base_tree is not None:
758
704
        :param this_tree: The local tree in the merge operation
759
705
        :param base_tree: The common tree in the merge operation
760
706
        :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.
 
707
        :param this_branch: The branch associated with this_tree
763
708
        :param interesting_ids: The file_ids of files that should be
764
709
            participate in the merge.  May not be combined with
765
710
            interesting_files.
783
728
        if interesting_files is not None and interesting_ids is not None:
784
729
            raise ValueError(
785
730
                'specify either interesting_ids or interesting_files')
786
 
        if this_branch is None:
787
 
            this_branch = this_tree.branch
788
731
        self.interesting_ids = interesting_ids
789
732
        self.interesting_files = interesting_files
790
733
        self.this_tree = working_tree
811
754
            warnings.warn("pb argument to Merge3Merger is deprecated")
812
755
 
813
756
    def do_merge(self):
814
 
        operation = cleanup.OperationWithCleanups(self._do_merge)
 
757
        operation = OperationWithCleanups(self._do_merge)
815
758
        self.this_tree.lock_tree_write()
816
759
        operation.add_cleanup(self.this_tree.unlock)
817
760
        self.base_tree.lock_read()
832
775
            pass
833
776
 
834
777
    def make_preview_transform(self):
835
 
        operation = cleanup.OperationWithCleanups(self._make_preview_transform)
 
778
        operation = OperationWithCleanups(self._make_preview_transform)
836
779
        self.base_tree.lock_read()
837
780
        operation.add_cleanup(self.base_tree.unlock)
838
781
        self.other_tree.lock_read()
868
811
                    executable3, file_status, resolver=resolver)
869
812
        finally:
870
813
            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
 
        """
 
814
        self.fix_root()
879
815
        child_pb = ui.ui_factory.nested_progress_bar()
880
816
        try:
881
817
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
888
824
                self.tt.iter_changes(), self.change_reporter)
889
825
        self.cook_conflicts(fs_conflicts)
890
826
        for conflict in self.cooked_conflicts:
891
 
            trace.warning(unicode(conflict))
 
827
            trace.warning(conflict)
892
828
 
893
829
    def _entries3(self):
894
830
        """Gather data about files modified between three trees.
901
837
        """
902
838
        result = []
903
839
        iterator = self.other_tree.iter_changes(self.base_tree,
904
 
                specific_files=self.interesting_files,
 
840
                include_unchanged=True, specific_files=self.interesting_files,
905
841
                extra_trees=[self.this_tree])
906
842
        this_entries = dict((e.file_id, e) for p, e in
907
843
                            self.this_tree.iter_entries_by_dir(
933
869
        it then compares with THIS and BASE.
934
870
 
935
871
        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)
 
872
        :return: [(file_id, changed, parents, names, executable)]
 
873
            file_id     Simple file_id of the entry
 
874
            changed     Boolean, True if the kind or contents changed
 
875
                        else False
 
876
            parents     ((base, [parent_id, in, lcas]), parent_id_other,
 
877
                         parent_id_this)
 
878
            names       ((base, [name, in, lcas]), name_in_other, name_in_this)
 
879
            executable  ((base, [exec, in, lcas]), exec_in_other, exec_in_this)
946
880
        """
947
881
        if self.interesting_files is not None:
948
882
            lookup_trees = [self.this_tree, self.base_tree]
990
924
                else:
991
925
                    lca_entries.append(lca_ie)
992
926
 
993
 
            if base_inventory.has_id(file_id):
 
927
            if file_id in base_inventory:
994
928
                base_ie = base_inventory[file_id]
995
929
            else:
996
930
                base_ie = _none_entry
997
931
 
998
 
            if this_inventory.has_id(file_id):
 
932
            if file_id in this_inventory:
999
933
                this_ie = this_inventory[file_id]
1000
934
            else:
1001
935
                this_ie = _none_entry
1081
1015
                        continue
1082
1016
                else:
1083
1017
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
 
1018
                # XXX: We need to handle kind == 'symlink'
1084
1019
 
1085
1020
            # If we have gotten this far, that means something has changed
1086
1021
            result.append((file_id, content_changed,
1093
1028
                          ))
1094
1029
        return result
1095
1030
 
1096
 
    @deprecated_method(deprecated_in((2, 4, 0)))
 
1031
 
1097
1032
    def fix_root(self):
1098
 
        if self.tt.final_kind(self.tt.root) is None:
 
1033
        try:
 
1034
            self.tt.final_kind(self.tt.root)
 
1035
        except errors.NoSuchFile:
1099
1036
            self.tt.cancel_deletion(self.tt.root)
1100
1037
        if self.tt.final_file_id(self.tt.root) is None:
1101
1038
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
1106
1043
        other_root = self.tt.trans_id_file_id(other_root_file_id)
1107
1044
        if other_root == self.tt.root:
1108
1045
            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():
 
1046
        try:
 
1047
            self.tt.final_kind(other_root)
 
1048
        except errors.NoSuchFile:
 
1049
            return
 
1050
        if self.this_tree.has_id(self.other_tree.inventory.root.file_id):
 
1051
            # the other tree's root is a non-root in the current tree
 
1052
            return
 
1053
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
 
1054
        self.tt.cancel_creation(other_root)
 
1055
        self.tt.cancel_versioning(other_root)
 
1056
 
 
1057
    def reparent_children(self, ie, target):
 
1058
        for thing, child in ie.children.iteritems():
1124
1059
            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)
 
1060
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1140
1061
 
1141
1062
    def write_modified(self, results):
1142
1063
        modified_hashes = {}
1167
1088
    @staticmethod
1168
1089
    def contents_sha1(tree, file_id):
1169
1090
        """Determine the sha1 of the file contents (used as a key method)."""
1170
 
        if not tree.has_id(file_id):
 
1091
        if file_id not in tree:
1171
1092
            return None
1172
1093
        return tree.get_file_sha1(file_id)
1173
1094
 
1189
1110
 
1190
1111
    @staticmethod
1191
1112
    def _three_way(base, other, this):
 
1113
        #if base == other, either they all agree, or only THIS has changed.
1192
1114
        if base == other:
1193
 
            # if 'base == other', either they all agree, or only 'this' has
1194
 
            # changed.
1195
1115
            return 'this'
1196
1116
        elif this not in (base, other):
1197
 
            # 'this' is neither 'base' nor 'other', so both sides changed
1198
1117
            return 'conflict'
 
1118
        # "Ambiguous clean merge" -- both sides have made the same change.
1199
1119
        elif this == other:
1200
 
            # "Ambiguous clean merge" -- both sides have made the same change.
1201
1120
            return "this"
 
1121
        # this == base: only other has changed.
1202
1122
        else:
1203
 
            # this == base: only other has changed.
1204
1123
            return "other"
1205
1124
 
1206
1125
    @staticmethod
1250
1169
                # only has an lca value
1251
1170
                return 'other'
1252
1171
 
1253
 
        # At this point, the lcas disagree, and the tip disagree
 
1172
        # At this point, the lcas disagree, and the tips disagree
1254
1173
        return 'conflict'
1255
1174
 
1256
1175
    @staticmethod
1310
1229
                parent_id_winner = "other"
1311
1230
        if name_winner == "this" and parent_id_winner == "this":
1312
1231
            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):
 
1232
        if name_winner == "conflict":
 
1233
            trans_id = self.tt.trans_id_file_id(file_id)
 
1234
            self._raw_conflicts.append(('name conflict', trans_id,
 
1235
                                        this_name, other_name))
 
1236
        if parent_id_winner == "conflict":
 
1237
            trans_id = self.tt.trans_id_file_id(file_id)
 
1238
            self._raw_conflicts.append(('parent conflict', trans_id,
 
1239
                                        this_parent, other_parent))
 
1240
        if other_name is None:
1322
1241
            # it doesn't matter whether the result was 'other' or
1323
 
            # 'conflict'-- if it has no file id, we leave it alone.
 
1242
            # 'conflict'-- if there's no 'other', we leave it alone.
1324
1243
            return
 
1244
        # if we get here, name_winner and parent_winner are set to safe values.
 
1245
        trans_id = self.tt.trans_id_file_id(file_id)
1325
1246
        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))
 
1247
        if parent_id is not None:
 
1248
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1249
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
 
1250
                                parent_trans_id, trans_id)
1342
1251
 
1343
1252
    def _do_merge_contents(self, file_id):
1344
1253
        """Performs a merge on file_id contents."""
1345
1254
        def contents_pair(tree):
1346
 
            if not tree.has_id(file_id):
 
1255
            if file_id not in tree:
1347
1256
                return (None, None)
1348
1257
            kind = tree.kind(file_id)
1349
1258
            if kind == "file":
1422
1331
            self.tt.version_file(file_id, trans_id)
1423
1332
        # The merge has been performed, so the old contents should not be
1424
1333
        # retained.
1425
 
        self.tt.delete_contents(trans_id)
 
1334
        try:
 
1335
            self.tt.delete_contents(trans_id)
 
1336
        except errors.NoSuchFile:
 
1337
            pass
1426
1338
        return result
1427
1339
 
1428
1340
    def _default_other_winner_merge(self, merge_hook_params):
1481
1393
    def get_lines(self, tree, file_id):
1482
1394
        """Return the lines in a file, or an empty list."""
1483
1395
        if tree.has_id(file_id):
1484
 
            return tree.get_file_lines(file_id)
 
1396
            return tree.get_file(file_id).readlines()
1485
1397
        else:
1486
1398
            return []
1487
1399
 
1600
1512
        if winner == 'this' and file_status != "modified":
1601
1513
            return
1602
1514
        trans_id = self.tt.trans_id_file_id(file_id)
1603
 
        if self.tt.final_kind(trans_id) != "file":
 
1515
        try:
 
1516
            if self.tt.final_kind(trans_id) != "file":
 
1517
                return
 
1518
        except errors.NoSuchFile:
1604
1519
            return
1605
1520
        if winner == "this":
1606
1521
            executability = this_executable
1617
1532
 
1618
1533
    def cook_conflicts(self, fs_conflicts):
1619
1534
        """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)
 
1535
        name_conflicts = {}
 
1536
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1537
                fs_conflicts, self.tt))
1622
1538
        fp = transform.FinalPaths(self.tt)
1623
1539
        for conflict in self._raw_conflicts:
1624
1540
            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':
 
1541
            if conflict_type in ('name conflict', 'parent conflict'):
 
1542
                trans_id = conflict[1]
 
1543
                conflict_args = conflict[2:]
 
1544
                if trans_id not in name_conflicts:
 
1545
                    name_conflicts[trans_id] = {}
 
1546
                transform.unique_add(name_conflicts[trans_id], conflict_type,
 
1547
                                     conflict_args)
 
1548
            if conflict_type == 'contents conflict':
1652
1549
                for trans_id in conflict[1]:
1653
1550
                    file_id = self.tt.final_file_id(trans_id)
1654
1551
                    if file_id is not None:
1660
1557
                        break
1661
1558
                c = _mod_conflicts.Conflict.factory(conflict_type,
1662
1559
                                                    path=path, file_id=file_id)
1663
 
                content_conflict_file_ids.add(file_id)
1664
 
            elif conflict_type == 'text conflict':
 
1560
                self.cooked_conflicts.append(c)
 
1561
            if conflict_type == 'text conflict':
1665
1562
                trans_id = conflict[1]
1666
1563
                path = fp.get_path(trans_id)
1667
1564
                file_id = self.tt.final_file_id(trans_id)
1668
1565
                c = _mod_conflicts.Conflict.factory(conflict_type,
1669
1566
                                                    path=path, file_id=file_id)
 
1567
                self.cooked_conflicts.append(c)
 
1568
 
 
1569
        for trans_id, conflicts in name_conflicts.iteritems():
 
1570
            try:
 
1571
                this_parent, other_parent = conflicts['parent conflict']
 
1572
                if this_parent == other_parent:
 
1573
                    raise AssertionError()
 
1574
            except KeyError:
 
1575
                this_parent = other_parent = \
 
1576
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
 
1577
            try:
 
1578
                this_name, other_name = conflicts['name conflict']
 
1579
                if this_name == other_name:
 
1580
                    raise AssertionError()
 
1581
            except KeyError:
 
1582
                this_name = other_name = self.tt.final_name(trans_id)
 
1583
            other_path = fp.get_path(trans_id)
 
1584
            if this_parent is not None and this_name is not None:
 
1585
                this_parent_path = \
 
1586
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
 
1587
                this_path = osutils.pathjoin(this_parent_path, this_name)
1670
1588
            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
 
1589
                this_path = "<deleted>"
 
1590
            file_id = self.tt.final_file_id(trans_id)
 
1591
            c = _mod_conflicts.Conflict.factory('path conflict', path=this_path,
 
1592
                                                conflict_path=other_path,
 
1593
                                                file_id=file_id)
1683
1594
            self.cooked_conflicts.append(c)
1684
1595
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1685
1596
 
1791
1702
            osutils.rmtree(temp_dir)
1792
1703
 
1793
1704
 
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
1705
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1957
1706
                backup_files=False,
1958
1707
                merge_type=Merge3Merger,
1966
1715
                change_reporter=None):
1967
1716
    """Primary interface for merging.
1968
1717
 
1969
 
    Typical use is probably::
1970
 
 
1971
 
        merge_inner(branch, branch.get_revision_tree(other_revision),
1972
 
                    branch.get_revision_tree(base_revision))
1973
 
    """
 
1718
        typical use is probably
 
1719
        'merge_inner(branch, branch.get_revision_tree(other_revision),
 
1720
                     branch.get_revision_tree(base_revision))'
 
1721
        """
1974
1722
    if this_tree is None:
1975
1723
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1976
 
                              "parameter")
 
1724
                              "parameter as of bzrlib version 0.8.")
1977
1725
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1978
1726
                    pb=pb, change_reporter=change_reporter)
1979
1727
    merger.backup_files = backup_files
2433
2181
class _PlanLCAMerge(_PlanMergeBase):
2434
2182
    """
2435
2183
    This merge algorithm differs from _PlanMerge in that:
2436
 
 
2437
2184
    1. comparisons are done against LCAs only
2438
2185
    2. cases where a contested line is new versus one LCA but old versus
2439
2186
       another are marked as conflicts, by emitting the line as conflicted-a
2480
2227
 
2481
2228
        If a line is killed and new, this indicates that the two merge
2482
2229
        revisions contain differing conflict resolutions.
2483
 
 
2484
2230
        :param revision_id: The id of the revision in which the lines are
2485
2231
            unique
2486
2232
        :param unique_line_numbers: The line numbers of unique lines.
2487
 
        :return: a tuple of (new_this, killed_other)
 
2233
        :return a tuple of (new_this, killed_other):
2488
2234
        """
2489
2235
        new = set()
2490
2236
        killed = set()