← 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: 2010-02-16 00:53:04 UTC
  • mfrom: (4997.1.3 find-branches-local)
  • Revision ID: pqm@pqm.ubuntu.com-20100216005304-1p8xafkhiizh6ugi
(Jelmer) Add BzrDir.list_branches().

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
190
130
        """
191
131
        affected_files = self.affected_files
192
132
        if affected_files is None:
193
 
            config = self.merger.this_branch.get_config()
 
133
            config = self.merger.this_tree.branch.get_config()
194
134
            # Until bzr provides a better policy for caching the config, we
195
135
            # just add the part we're interested in to the params to avoid
196
136
            # reading the config files repeatedly (bazaar.conf, location.conf,
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
1257
 
    @deprecated_method(deprecated_in((2, 2, 0)))
1258
1176
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1259
1177
        """Do a three-way test on a scalar.
1260
1178
        Return "this", "other" or "conflict", depending whether a value wins.
1310
1228
                parent_id_winner = "other"
1311
1229
        if name_winner == "this" and parent_id_winner == "this":
1312
1230
            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):
 
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:
1322
1240
            # it doesn't matter whether the result was 'other' or
1323
 
            # 'conflict'-- if it has no file id, we leave it alone.
 
1241
            # 'conflict'-- if there's no 'other', we leave it alone.
1324
1242
            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)
1325
1245
        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))
 
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)
1342
1250
 
1343
1251
    def _do_merge_contents(self, file_id):
1344
1252
        """Performs a merge on file_id contents."""
1345
1253
        def contents_pair(tree):
1346
 
            if not tree.has_id(file_id):
 
1254
            if file_id not in tree:
1347
1255
                return (None, None)
1348
1256
            kind = tree.kind(file_id)
1349
1257
            if kind == "file":
1422
1330
            self.tt.version_file(file_id, trans_id)
1423
1331
        # The merge has been performed, so the old contents should not be
1424
1332
        # retained.
1425
 
        self.tt.delete_contents(trans_id)
 
1333
        try:
 
1334
            self.tt.delete_contents(trans_id)
 
1335
        except errors.NoSuchFile:
 
1336
            pass
1426
1337
        return result
1427
1338
 
1428
1339
    def _default_other_winner_merge(self, merge_hook_params):
1481
1392
    def get_lines(self, tree, file_id):
1482
1393
        """Return the lines in a file, or an empty list."""
1483
1394
        if tree.has_id(file_id):
1484
 
            return tree.get_file_lines(file_id)
 
1395
            return tree.get_file(file_id).readlines()
1485
1396
        else:
1486
1397
            return []
1487
1398
 
1600
1511
        if winner == 'this' and file_status != "modified":
1601
1512
            return
1602
1513
        trans_id = self.tt.trans_id_file_id(file_id)
1603
 
        if self.tt.final_kind(trans_id) != "file":
 
1514
        try:
 
1515
            if self.tt.final_kind(trans_id) != "file":
 
1516
                return
 
1517
        except errors.NoSuchFile:
1604
1518
            return
1605
1519
        if winner == "this":
1606
1520
            executability = this_executable
1617
1531
 
1618
1532
    def cook_conflicts(self, fs_conflicts):
1619
1533
        """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)
 
1534
        name_conflicts = {}
 
1535
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1536
                fs_conflicts, self.tt))
1622
1537
        fp = transform.FinalPaths(self.tt)
1623
1538
        for conflict in self._raw_conflicts:
1624
1539
            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
 
                    parent_path =  fp.get_path(
1639
 
                        self.tt.trans_id_file_id(other_parent))
1640
 
                    other_path = osutils.pathjoin(parent_path, other_name)
1641
 
                c = _mod_conflicts.Conflict.factory(
1642
 
                    'path conflict', path=this_path,
1643
 
                    conflict_path=other_path,
1644
 
                    file_id=file_id)
1645
 
            elif conflict_type == 'contents conflict':
 
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':
1646
1548
                for trans_id in conflict[1]:
1647
1549
                    file_id = self.tt.final_file_id(trans_id)
1648
1550
                    if file_id is not None:
1654
1556
                        break
1655
1557
                c = _mod_conflicts.Conflict.factory(conflict_type,
1656
1558
                                                    path=path, file_id=file_id)
1657
 
                content_conflict_file_ids.add(file_id)
1658
 
            elif conflict_type == 'text conflict':
 
1559
                self.cooked_conflicts.append(c)
 
1560
            if conflict_type == 'text conflict':
1659
1561
                trans_id = conflict[1]
1660
1562
                path = fp.get_path(trans_id)
1661
1563
                file_id = self.tt.final_file_id(trans_id)
1662
1564
                c = _mod_conflicts.Conflict.factory(conflict_type,
1663
1565
                                                    path=path, file_id=file_id)
 
1566
                self.cooked_conflicts.append(c)
 
1567
 
 
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)
1664
1587
            else:
1665
 
                raise AssertionError('bad conflict type: %r' % (conflict,))
1666
 
            cooked_conflicts.append(c)
1667
 
 
1668
 
        self.cooked_conflicts = []
1669
 
        # We want to get rid of path conflicts when a corresponding contents
1670
 
        # conflict exists. This can occur when one branch deletes a file while
1671
 
        # the other renames *and* modifies it. In this case, the content
1672
 
        # conflict is enough.
1673
 
        for c in cooked_conflicts:
1674
 
            if (c.typestring == 'path conflict'
1675
 
                and c.file_id in content_conflict_file_ids):
1676
 
                continue
 
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)
1677
1593
            self.cooked_conflicts.append(c)
1678
1594
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1679
1595
 
1785
1701
            osutils.rmtree(temp_dir)
1786
1702
 
1787
1703
 
1788
 
class PathNotInTree(errors.BzrError):
1789
 
 
1790
 
    _fmt = """Merge-into failed because %(tree)s does not contain %(path)s."""
1791
 
 
1792
 
    def __init__(self, path, tree):
1793
 
        errors.BzrError.__init__(self, path=path, tree=tree)
1794
 
 
1795
 
 
1796
 
class MergeIntoMerger(Merger):
1797
 
    """Merger that understands other_tree will be merged into a subdir.
1798
 
 
1799
 
    This also changes the Merger api so that it uses real Branch, revision_id,
1800
 
    and RevisonTree objects, rather than using revision specs.
1801
 
    """
1802
 
 
1803
 
    def __init__(self, this_tree, other_branch, other_tree, target_subdir,
1804
 
            source_subpath, other_rev_id=None):
1805
 
        """Create a new MergeIntoMerger object.
1806
 
 
1807
 
        source_subpath in other_tree will be effectively copied to
1808
 
        target_subdir in this_tree.
1809
 
 
1810
 
        :param this_tree: The tree that we will be merging into.
1811
 
        :param other_branch: The Branch we will be merging from.
1812
 
        :param other_tree: The RevisionTree object we want to merge.
1813
 
        :param target_subdir: The relative path where we want to merge
1814
 
            other_tree into this_tree
1815
 
        :param source_subpath: The relative path specifying the subtree of
1816
 
            other_tree to merge into this_tree.
1817
 
        """
1818
 
        # It is assumed that we are merging a tree that is not in our current
1819
 
        # ancestry, which means we are using the "EmptyTree" as our basis.
1820
 
        null_ancestor_tree = this_tree.branch.repository.revision_tree(
1821
 
                                _mod_revision.NULL_REVISION)
1822
 
        super(MergeIntoMerger, self).__init__(
1823
 
            this_branch=this_tree.branch,
1824
 
            this_tree=this_tree,
1825
 
            other_tree=other_tree,
1826
 
            base_tree=null_ancestor_tree,
1827
 
            )
1828
 
        self._target_subdir = target_subdir
1829
 
        self._source_subpath = source_subpath
1830
 
        self.other_branch = other_branch
1831
 
        if other_rev_id is None:
1832
 
            other_rev_id = other_tree.get_revision_id()
1833
 
        self.other_rev_id = self.other_basis = other_rev_id
1834
 
        self.base_is_ancestor = True
1835
 
        self.backup_files = True
1836
 
        self.merge_type = Merge3Merger
1837
 
        self.show_base = False
1838
 
        self.reprocess = False
1839
 
        self.interesting_ids = None
1840
 
        self.merge_type = _MergeTypeParameterizer(MergeIntoMergeType,
1841
 
              target_subdir=self._target_subdir,
1842
 
              source_subpath=self._source_subpath)
1843
 
        if self._source_subpath != '':
1844
 
            # If this isn't a partial merge make sure the revisions will be
1845
 
            # present.
1846
 
            self._maybe_fetch(self.other_branch, self.this_branch,
1847
 
                self.other_basis)
1848
 
 
1849
 
    def set_pending(self):
1850
 
        if self._source_subpath != '':
1851
 
            return
1852
 
        Merger.set_pending(self)
1853
 
 
1854
 
 
1855
 
class _MergeTypeParameterizer(object):
1856
 
    """Wrap a merge-type class to provide extra parameters.
1857
 
    
1858
 
    This is hack used by MergeIntoMerger to pass some extra parameters to its
1859
 
    merge_type.  Merger.do_merge() sets up its own set of parameters to pass to
1860
 
    the 'merge_type' member.  It is difficult override do_merge without
1861
 
    re-writing the whole thing, so instead we create a wrapper which will pass
1862
 
    the extra parameters.
1863
 
    """
1864
 
 
1865
 
    def __init__(self, merge_type, **kwargs):
1866
 
        self._extra_kwargs = kwargs
1867
 
        self._merge_type = merge_type
1868
 
 
1869
 
    def __call__(self, *args, **kwargs):
1870
 
        kwargs.update(self._extra_kwargs)
1871
 
        return self._merge_type(*args, **kwargs)
1872
 
 
1873
 
    def __getattr__(self, name):
1874
 
        return getattr(self._merge_type, name)
1875
 
 
1876
 
 
1877
 
class MergeIntoMergeType(Merge3Merger):
1878
 
    """Merger that incorporates a tree (or part of a tree) into another."""
1879
 
 
1880
 
    def __init__(self, *args, **kwargs):
1881
 
        """Initialize the merger object.
1882
 
 
1883
 
        :param args: See Merge3Merger.__init__'s args.
1884
 
        :param kwargs: See Merge3Merger.__init__'s keyword args, except for
1885
 
            source_subpath and target_subdir.
1886
 
        :keyword source_subpath: The relative path specifying the subtree of
1887
 
            other_tree to merge into this_tree.
1888
 
        :keyword target_subdir: The relative path where we want to merge
1889
 
            other_tree into this_tree
1890
 
        """
1891
 
        # All of the interesting work happens during Merge3Merger.__init__(),
1892
 
        # so we have have to hack in to get our extra parameters set.
1893
 
        self._source_subpath = kwargs.pop('source_subpath')
1894
 
        self._target_subdir = kwargs.pop('target_subdir')
1895
 
        super(MergeIntoMergeType, self).__init__(*args, **kwargs)
1896
 
 
1897
 
    def _compute_transform(self):
1898
 
        child_pb = ui.ui_factory.nested_progress_bar()
1899
 
        try:
1900
 
            entries = self._entries_to_incorporate()
1901
 
            entries = list(entries)
1902
 
            for num, (entry, parent_id) in enumerate(entries):
1903
 
                child_pb.update('Preparing file merge', num, len(entries))
1904
 
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
1905
 
                trans_id = transform.new_by_entry(self.tt, entry,
1906
 
                    parent_trans_id, self.other_tree)
1907
 
        finally:
1908
 
            child_pb.finished()
1909
 
        self._finish_computing_transform()
1910
 
 
1911
 
    def _entries_to_incorporate(self):
1912
 
        """Yields pairs of (inventory_entry, new_parent)."""
1913
 
        other_inv = self.other_tree.inventory
1914
 
        subdir_id = other_inv.path2id(self._source_subpath)
1915
 
        if subdir_id is None:
1916
 
            # XXX: The error would be clearer if it gave the URL of the source
1917
 
            # branch, but we don't have a reference to that here.
1918
 
            raise PathNotInTree(self._source_subpath, "Source tree")
1919
 
        subdir = other_inv[subdir_id]
1920
 
        parent_in_target = osutils.dirname(self._target_subdir)
1921
 
        target_id = self.this_tree.inventory.path2id(parent_in_target)
1922
 
        if target_id is None:
1923
 
            raise PathNotInTree(self._target_subdir, "Target tree")
1924
 
        name_in_target = osutils.basename(self._target_subdir)
1925
 
        merge_into_root = subdir.copy()
1926
 
        merge_into_root.name = name_in_target
1927
 
        if self.this_tree.inventory.has_id(merge_into_root.file_id):
1928
 
            # Give the root a new file-id.
1929
 
            # This can happen fairly easily if the directory we are
1930
 
            # incorporating is the root, and both trees have 'TREE_ROOT' as
1931
 
            # their root_id.  Users will expect this to Just Work, so we
1932
 
            # change the file-id here.
1933
 
            # Non-root file-ids could potentially conflict too.  That's really
1934
 
            # an edge case, so we don't do anything special for those.  We let
1935
 
            # them cause conflicts.
1936
 
            merge_into_root.file_id = generate_ids.gen_file_id(name_in_target)
1937
 
        yield (merge_into_root, target_id)
1938
 
        if subdir.kind != 'directory':
1939
 
            # No children, so we are done.
1940
 
            return
1941
 
        for ignored_path, entry in other_inv.iter_entries_by_dir(subdir_id):
1942
 
            parent_id = entry.parent_id
1943
 
            if parent_id == subdir.file_id:
1944
 
                # The root's parent ID has changed, so make sure children of
1945
 
                # the root refer to the new ID.
1946
 
                parent_id = merge_into_root.file_id
1947
 
            yield (entry, parent_id)
1948
 
 
1949
 
 
1950
1704
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1951
1705
                backup_files=False,
1952
1706
                merge_type=Merge3Merger,
1960
1714
                change_reporter=None):
1961
1715
    """Primary interface for merging.
1962
1716
 
1963
 
    Typical use is probably::
1964
 
 
1965
 
        merge_inner(branch, branch.get_revision_tree(other_revision),
1966
 
                    branch.get_revision_tree(base_revision))
1967
 
    """
 
1717
        typical use is probably
 
1718
        'merge_inner(branch, branch.get_revision_tree(other_revision),
 
1719
                     branch.get_revision_tree(base_revision))'
 
1720
        """
1968
1721
    if this_tree is None:
1969
1722
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1970
 
                              "parameter")
 
1723
                              "parameter as of bzrlib version 0.8.")
1971
1724
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1972
1725
                    pb=pb, change_reporter=change_reporter)
1973
1726
    merger.backup_files = backup_files
2427
2180
class _PlanLCAMerge(_PlanMergeBase):
2428
2181
    """
2429
2182
    This merge algorithm differs from _PlanMerge in that:
2430
 
 
2431
2183
    1. comparisons are done against LCAs only
2432
2184
    2. cases where a contested line is new versus one LCA but old versus
2433
2185
       another are marked as conflicts, by emitting the line as conflicted-a
2474
2226
 
2475
2227
        If a line is killed and new, this indicates that the two merge
2476
2228
        revisions contain differing conflict resolutions.
2477
 
 
2478
2229
        :param revision_id: The id of the revision in which the lines are
2479
2230
            unique
2480
2231
        :param unique_line_numbers: The line numbers of unique lines.
2481
 
        :return: a tuple of (new_this, killed_other)
 
2232
        :return a tuple of (new_this, killed_other):
2482
2233
        """
2483
2234
        new = set()
2484
2235
        killed = set()