← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 08:40:16 UTC
  • mfrom: (5642.4.6 712474-module-available)
  • Revision ID: pqm@pqm.ubuntu.com-20110817084016-600z65qzqmmt44w7
(vila) ModuleAvailableFeature don't try to imported already imported
 modules. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

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