~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Martin Pool
  • Date: 2005-08-18 07:51:58 UTC
  • Revision ID: mbp@sourcefrog.net-20050818075157-5f69075fa843d558
- add space to store revision-id in weave files

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
import os
 
1
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
 
2
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
 
3
from bzrlib.changeset import Inventory, Diff3Merge
 
4
from bzrlib import find_branch
 
5
import bzrlib.osutils
 
6
from bzrlib.errors import BzrCommandError
 
7
from bzrlib.delta import compare_trees
 
8
from trace import mutter, warning
 
9
import os.path
 
10
import tempfile
 
11
import shutil
19
12
import errno
20
 
import warnings
21
 
 
22
 
from bzrlib import (
23
 
    errors,
24
 
    osutils,
25
 
    registry,
26
 
    revision as _mod_revision,
27
 
    )
28
 
from bzrlib.branch import Branch
29
 
from bzrlib.conflicts import ConflictList, Conflict
30
 
from bzrlib.errors import (BzrCommandError,
31
 
                           BzrError,
32
 
                           NoCommonAncestor,
33
 
                           NoCommits,
34
 
                           NoSuchRevision,
35
 
                           NoSuchFile,
36
 
                           NotBranchError,
37
 
                           NotVersionedError,
38
 
                           UnrelatedBranches,
39
 
                           UnsupportedOperation,
40
 
                           WorkingTreeNotRevision,
41
 
                           BinaryFile,
42
 
                           )
43
 
from bzrlib.merge3 import Merge3
44
 
from bzrlib.osutils import rename, pathjoin
45
 
from progress import DummyProgress, ProgressPhase
46
 
from bzrlib.revision import (is_ancestor, NULL_REVISION, ensure_null)
47
 
from bzrlib.textfile import check_text_lines
48
 
from bzrlib.trace import mutter, warning, note
49
 
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
50
 
                              conflict_pass, FinalPaths, create_by_entry,
51
 
                              unique_add, ROOT_PARENT)
52
 
from bzrlib.versionedfile import WeaveMerge
53
 
from bzrlib import ui
54
 
 
55
 
# TODO: Report back as changes are merged in
56
 
 
57
 
 
58
 
def transform_tree(from_tree, to_tree, interesting_ids=None):
59
 
    merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
60
 
                interesting_ids=interesting_ids, this_tree=from_tree)
61
 
 
62
 
 
63
 
class Merger(object):
64
 
    def __init__(self, this_branch, other_tree=None, base_tree=None,
65
 
                 this_tree=None, pb=DummyProgress(), change_reporter=None,
66
 
                 recurse='down'):
 
13
 
 
14
 
 
15
# comments from abentley on irc: merge happens in two stages, each
 
16
# of which generates a changeset object
 
17
 
 
18
# stage 1: generate OLD->OTHER,
 
19
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
 
20
 
 
21
class UnrelatedBranches(BzrCommandError):
 
22
    def __init__(self):
 
23
        msg = "Branches have no common ancestor, and no base revision"\
 
24
            " specified."
 
25
        BzrCommandError.__init__(self, msg)
 
26
 
 
27
 
 
28
class MergeConflictHandler(ExceptionConflictHandler):
 
29
    """Handle conflicts encountered while merging.
 
30
 
 
31
    This subclasses ExceptionConflictHandler, so that any types of
 
32
    conflict that are not explicitly handled cause an exception and
 
33
    terminate the merge.
 
34
    """
 
35
    def __init__(self, dir, ignore_zero=False):
 
36
        ExceptionConflictHandler.__init__(self, dir)
 
37
        self.conflicts = 0
 
38
        self.ignore_zero = ignore_zero
 
39
 
 
40
    def copy(self, source, dest):
 
41
        """Copy the text and mode of a file
 
42
        :param source: The path of the file to copy
 
43
        :param dest: The distination file to create
 
44
        """
 
45
        s_file = file(source, "rb")
 
46
        d_file = file(dest, "wb")
 
47
        for line in s_file:
 
48
            d_file.write(line)
 
49
        os.chmod(dest, 0777 & os.stat(source).st_mode)
 
50
 
 
51
    def dump(self, lines, dest):
 
52
        """Copy the text and mode of a file
 
53
        :param source: The path of the file to copy
 
54
        :param dest: The distination file to create
 
55
        """
 
56
        d_file = file(dest, "wb")
 
57
        for line in lines:
 
58
            d_file.write(line)
 
59
 
 
60
    def add_suffix(self, name, suffix, last_new_name=None):
 
61
        """Rename a file to append a suffix.  If the new name exists, the
 
62
        suffix is added repeatedly until a non-existant name is found
 
63
 
 
64
        :param name: The path of the file
 
65
        :param suffix: The suffix to append
 
66
        :param last_new_name: (used for recursive calls) the last name tried
 
67
        """
 
68
        if last_new_name is None:
 
69
            last_new_name = name
 
70
        new_name = last_new_name+suffix
 
71
        try:
 
72
            os.rename(name, new_name)
 
73
            return new_name
 
74
        except OSError, e:
 
75
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
 
76
                raise
 
77
            return self.add_suffix(name, suffix, last_new_name=new_name)
 
78
 
 
79
    def conflict(self, text):
 
80
        warning(text)
 
81
        self.conflicts += 1
 
82
        
 
83
 
 
84
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
 
85
        """
 
86
        Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER.  The
 
87
        main file will be a version with diff3 conflicts.
 
88
        :param new_file: Path to the output file with diff3 markers
 
89
        :param this_path: Path to the file text for the THIS tree
 
90
        :param base_path: Path to the file text for the BASE tree
 
91
        :param other_path: Path to the file text for the OTHER tree
 
92
        """
 
93
        self.add_suffix(this_path, ".THIS")
 
94
        self.dump(base_lines, this_path+".BASE")
 
95
        self.dump(other_lines, this_path+".OTHER")
 
96
        os.rename(new_file, this_path)
 
97
        self.conflict("Diff3 conflict encountered in %s" % this_path)
 
98
 
 
99
    def new_contents_conflict(self, filename, other_contents):
 
100
        """Conflicting contents for newly added file."""
 
101
        self.copy(other_contents, filename + ".OTHER")
 
102
        self.conflict("Conflict in newly added file %s" % filename)
 
103
    
 
104
 
 
105
    def target_exists(self, entry, target, old_path):
 
106
        """Handle the case when the target file or dir exists"""
 
107
        moved_path = self.add_suffix(target, ".moved")
 
108
        self.conflict("Moved existing %s to %s" % (target, moved_path))
 
109
 
 
110
    def rmdir_non_empty(self, filename):
 
111
        """Handle the case where the dir to be removed still has contents"""
 
112
        self.conflict("Directory %s not removed because it is not empty"\
 
113
            % filename)
 
114
        return "skip"
 
115
 
 
116
    def finalize(self):
 
117
        if not self.ignore_zero:
 
118
            print "%d conflicts encountered.\n" % self.conflicts
 
119
            
 
120
def get_tree(treespec, temp_root, label):
 
121
    location, revno = treespec
 
122
    branch = find_branch(location)
 
123
    if revno is None:
 
124
        base_tree = branch.working_tree()
 
125
    elif revno == -1:
 
126
        base_tree = branch.basis_tree()
 
127
    else:
 
128
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
 
129
    temp_path = os.path.join(temp_root, label)
 
130
    os.mkdir(temp_path)
 
131
    return branch, MergeTree(base_tree, temp_path)
 
132
 
 
133
 
 
134
def file_exists(tree, file_id):
 
135
    return tree.has_filename(tree.id2path(file_id))
 
136
    
 
137
 
 
138
class MergeTree(object):
 
139
    def __init__(self, tree, tempdir):
67
140
        object.__init__(self)
68
 
        assert this_tree is not None, "this_tree is required"
69
 
        self.this_branch = this_branch
70
 
        self.this_basis = _mod_revision.ensure_null(
71
 
            this_branch.last_revision())
72
 
        self.this_rev_id = None
73
 
        self.this_tree = this_tree
74
 
        self.this_revision_tree = None
75
 
        self.this_basis_tree = None
76
 
        self.other_tree = other_tree
77
 
        self.other_branch = None
78
 
        self.base_tree = base_tree
79
 
        self.ignore_zero = False
80
 
        self.backup_files = False
81
 
        self.interesting_ids = None
82
 
        self.interesting_files = None
83
 
        self.show_base = False
84
 
        self.reprocess = False
85
 
        self._pb = pb
86
 
        self.pp = None
87
 
        self.recurse = recurse
88
 
        self.change_reporter = change_reporter
89
 
        self._cached_trees = {}
90
 
 
91
 
    def revision_tree(self, revision_id, branch=None):
92
 
        if revision_id not in self._cached_trees:
93
 
            if branch is None:
94
 
                branch = self.this_branch
95
 
            try:
96
 
                tree = self.this_tree.revision_tree(revision_id)
97
 
            except errors.NoSuchRevisionInTree:
98
 
                tree = branch.repository.revision_tree(revision_id)
99
 
            self._cached_trees[revision_id] = tree
100
 
        return self._cached_trees[revision_id]
101
 
 
102
 
    def _get_tree(self, treespec, possible_transports=None):
103
 
        from bzrlib import workingtree
104
 
        location, revno = treespec
105
 
        if revno is None:
106
 
            tree = workingtree.WorkingTree.open_containing(location)[0]
107
 
            return tree.branch, tree
108
 
        branch = Branch.open_containing(location, possible_transports)[0]
109
 
        if revno == -1:
110
 
            revision_id = branch.last_revision()
111
 
        else:
112
 
            revision_id = branch.get_rev_id(revno)
113
 
        revision_id = ensure_null(revision_id)
114
 
        return branch, self.revision_tree(revision_id, branch)
115
 
 
116
 
    def ensure_revision_trees(self):
117
 
        if self.this_revision_tree is None:
118
 
            self.this_basis_tree = self.revision_tree(self.this_basis)
119
 
            if self.this_basis == self.this_rev_id:
120
 
                self.this_revision_tree = self.this_basis_tree
121
 
 
122
 
        if self.other_rev_id is None:
123
 
            other_basis_tree = self.revision_tree(self.other_basis)
124
 
            changes = other_basis_tree.changes_from(self.other_tree)
 
141
        if hasattr(tree, "basedir"):
 
142
            self.root = tree.basedir
 
143
        else:
 
144
            self.root = None
 
145
        self.tree = tree
 
146
        self.tempdir = tempdir
 
147
        os.mkdir(os.path.join(self.tempdir, "texts"))
 
148
        self.cached = {}
 
149
 
 
150
    def __iter__(self):
 
151
        return self.tree.__iter__()
 
152
 
 
153
    def __contains__(self, file_id):
 
154
        return file_id in self.tree
 
155
 
 
156
    def get_file(self, file_id):
 
157
        return self.tree.get_file(file_id)
 
158
 
 
159
    def get_file_sha1(self, id):
 
160
        return self.tree.get_file_sha1(id)
 
161
 
 
162
    def id2path(self, file_id):
 
163
        return self.tree.id2path(file_id)
 
164
 
 
165
    def has_id(self, file_id):
 
166
        return self.tree.has_id(file_id)
 
167
 
 
168
    def readonly_path(self, id):
 
169
        if id not in self.tree:
 
170
            return None
 
171
        if self.root is not None:
 
172
            return self.tree.abspath(self.tree.id2path(id))
 
173
        else:
 
174
            if self.tree.inventory[id].kind in ("directory", "root_directory"):
 
175
                return self.tempdir
 
176
            if not self.cached.has_key(id):
 
177
                path = os.path.join(self.tempdir, "texts", id)
 
178
                outfile = file(path, "wb")
 
179
                outfile.write(self.tree.get_file(id).read())
 
180
                assert(os.path.exists(path))
 
181
                self.cached[id] = path
 
182
            return self.cached[id]
 
183
 
 
184
 
 
185
 
 
186
def merge(other_revision, base_revision,
 
187
          check_clean=True, ignore_zero=False,
 
188
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
 
189
          file_list=None):
 
190
    """Merge changes into a tree.
 
191
 
 
192
    base_revision
 
193
        Base for three-way merge.
 
194
    other_revision
 
195
        Other revision for three-way merge.
 
196
    this_dir
 
197
        Directory to merge changes into; '.' by default.
 
198
    check_clean
 
199
        If true, this_dir must have no uncommitted changes before the
 
200
        merge begins.
 
201
    """
 
202
    tempdir = tempfile.mkdtemp(prefix="bzr-")
 
203
    try:
 
204
        if this_dir is None:
 
205
            this_dir = '.'
 
206
        this_branch = find_branch(this_dir)
 
207
        if check_clean:
 
208
            changes = compare_trees(this_branch.working_tree(), 
 
209
                                    this_branch.basis_tree(), False)
125
210
            if changes.has_changed():
126
 
                raise WorkingTreeNotRevision(self.this_tree)
127
 
            other_rev_id = self.other_basis
128
 
            self.other_tree = other_basis_tree
129
 
 
130
 
    def file_revisions(self, file_id):
131
 
        self.ensure_revision_trees()
132
 
        def get_id(tree, file_id):
133
 
            revision_id = tree.inventory[file_id].revision
134
 
            assert revision_id is not None
135
 
            return revision_id
136
 
        if self.this_rev_id is None:
137
 
            if self.this_basis_tree.get_file_sha1(file_id) != \
138
 
                self.this_tree.get_file_sha1(file_id):
139
 
                raise WorkingTreeNotRevision(self.this_tree)
140
 
 
141
 
        trees = (self.this_basis_tree, self.other_tree)
142
 
        return [get_id(tree, file_id) for tree in trees]
143
 
 
144
 
    def check_basis(self, check_clean, require_commits=True):
145
 
        if self.this_basis is None and require_commits is True:
146
 
            raise BzrCommandError("This branch has no commits."
147
 
                                  " (perhaps you would prefer 'bzr pull')")
148
 
        if check_clean:
149
 
            self.compare_basis()
150
 
            if self.this_basis != self.this_rev_id:
151
211
                raise BzrCommandError("Working tree has uncommitted changes.")
152
 
 
153
 
    def compare_basis(self):
154
 
        try:
155
 
            basis_tree = self.revision_tree(self.this_tree.last_revision())
156
 
        except errors.RevisionNotPresent:
157
 
            basis_tree = self.this_tree.basis_tree()
158
 
        changes = self.this_tree.changes_from(basis_tree)
159
 
        if not changes.has_changed():
160
 
            self.this_rev_id = self.this_basis
161
 
 
162
 
    def set_interesting_files(self, file_list):
163
 
        self.interesting_files = file_list
164
 
 
165
 
    def set_pending(self):
166
 
        if not self.base_is_ancestor or not self.base_is_other_ancestor:
167
 
            return
168
 
        self._add_parent()
169
 
 
170
 
    def _add_parent(self):
171
 
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
172
 
        new_parent_trees = []
173
 
        for revision_id in new_parents:
174
 
            try:
175
 
                tree = self.revision_tree(revision_id)
176
 
            except errors.RevisionNotPresent:
177
 
                tree = None
 
212
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
 
213
        if base_revision == [None, None]:
 
214
            if other_revision[1] == -1:
 
215
                o_revno = None
178
216
            else:
179
 
                tree.lock_read()
180
 
            new_parent_trees.append((revision_id, tree))
181
 
        try:
182
 
            self.this_tree.set_parent_trees(new_parent_trees,
183
 
                                            allow_leftmost_as_ghost=True)
184
 
        finally:
185
 
            for _revision_id, tree in new_parent_trees:
186
 
                if tree is not None:
187
 
                    tree.unlock()
188
 
 
189
 
    def set_other(self, other_revision, possible_transports=None):
190
 
        """Set the revision and tree to merge from.
191
 
 
192
 
        This sets the other_tree, other_rev_id, other_basis attributes.
193
 
 
194
 
        :param other_revision: The [path, revision] list to merge from.
195
 
        """
196
 
        self.other_branch, self.other_tree = self._get_tree(other_revision,
197
 
                                                            possible_transports)
198
 
        if other_revision[1] == -1:
199
 
            self.other_rev_id = _mod_revision.ensure_null(
200
 
                self.other_branch.last_revision())
201
 
            if _mod_revision.is_null(self.other_rev_id):
202
 
                raise NoCommits(self.other_branch)
203
 
            self.other_basis = self.other_rev_id
204
 
        elif other_revision[1] is not None:
205
 
            self.other_rev_id = self.other_branch.get_rev_id(other_revision[1])
206
 
            self.other_basis = self.other_rev_id
207
 
        else:
208
 
            self.other_rev_id = None
209
 
            self.other_basis = self.other_branch.last_revision()
210
 
            if self.other_basis is None:
211
 
                raise NoCommits(self.other_branch)
212
 
        if self.other_rev_id is not None:
213
 
            self._cached_trees[self.other_rev_id] = self.other_tree
214
 
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
215
 
 
216
 
    def set_other_revision(self, revision_id, other_branch):
217
 
        """Set 'other' based on a branch and revision id
218
 
 
219
 
        :param revision_id: The revision to use for a tree
220
 
        :param other_branch: The branch containing this tree
221
 
        """
222
 
        self.other_rev_id = revision_id
223
 
        self.other_branch = other_branch
224
 
        self._maybe_fetch(other_branch, self.this_branch, self.other_rev_id)
225
 
        self.other_tree = self.revision_tree(revision_id)
226
 
        self.other_basis = revision_id
227
 
 
228
 
    def _maybe_fetch(self, source, target, revision_id):
229
 
        if (source.repository.bzrdir.root_transport.base !=
230
 
            target.repository.bzrdir.root_transport.base):
231
 
            target.fetch(source, revision_id)
232
 
 
233
 
    def find_base(self):
234
 
        this_repo = self.this_branch.repository
235
 
        graph = this_repo.get_graph()
236
 
        revisions = [ensure_null(self.this_basis),
237
 
                     ensure_null(self.other_basis)]
238
 
        if NULL_REVISION in revisions:
239
 
            self.base_rev_id = NULL_REVISION
240
 
        else:
241
 
            self.base_rev_id = graph.find_unique_lca(*revisions)
242
 
            if self.base_rev_id == NULL_REVISION:
 
217
                o_revno = other_revision[1]
 
218
            base_revno = this_branch.common_ancestor(other_branch, 
 
219
                                                     other_revno=o_revno)[0]
 
220
            if base_revno is None:
243
221
                raise UnrelatedBranches()
244
 
        self.base_tree = self.revision_tree(self.base_rev_id)
245
 
        self.base_is_ancestor = True
246
 
        self.base_is_other_ancestor = True
247
 
 
248
 
    def set_base(self, base_revision):
249
 
        """Set the base revision to use for the merge.
250
 
 
251
 
        :param base_revision: A 2-list containing a path and revision number.
252
 
        """
253
 
        mutter("doing merge() with no base_revision specified")
254
 
        if base_revision == [None, None]:
255
 
            self.find_base()
256
 
        else:
257
 
            base_branch, self.base_tree = self._get_tree(base_revision)
258
 
            if base_revision[1] == -1:
259
 
                self.base_rev_id = base_branch.last_revision()
260
 
            elif base_revision[1] is None:
261
 
                self.base_rev_id = _mod_revision.NULL_REVISION
262
 
            else:
263
 
                self.base_rev_id = _mod_revision.ensure_null(
264
 
                    base_branch.get_rev_id(base_revision[1]))
265
 
            self._maybe_fetch(base_branch, self.this_branch, self.base_rev_id)
266
 
            self.base_is_ancestor = is_ancestor(self.this_basis, 
267
 
                                                self.base_rev_id,
268
 
                                                self.this_branch)
269
 
            self.base_is_other_ancestor = is_ancestor(self.other_basis,
270
 
                                                      self.base_rev_id,
271
 
                                                      self.this_branch)
272
 
 
273
 
    def do_merge(self):
274
 
        kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
275
 
                  'other_tree': self.other_tree,
276
 
                  'interesting_ids': self.interesting_ids,
277
 
                  'interesting_files': self.interesting_files,
278
 
                  'pp': self.pp}
279
 
        if self.merge_type.requires_base:
280
 
            kwargs['base_tree'] = self.base_tree
281
 
        if self.merge_type.supports_reprocess:
282
 
            kwargs['reprocess'] = self.reprocess
283
 
        elif self.reprocess:
284
 
            raise BzrError("Conflict reduction is not supported for merge"
285
 
                                  " type %s." % self.merge_type)
286
 
        if self.merge_type.supports_show_base:
287
 
            kwargs['show_base'] = self.show_base
288
 
        elif self.show_base:
289
 
            raise BzrError("Showing base is not supported for this"
290
 
                                  " merge type. %s" % self.merge_type)
291
 
        self.this_tree.lock_tree_write()
292
 
        if self.base_tree is not None:
293
 
            self.base_tree.lock_read()
294
 
        if self.other_tree is not None:
295
 
            self.other_tree.lock_read()
296
 
        try:
297
 
            merge = self.merge_type(pb=self._pb,
298
 
                                    change_reporter=self.change_reporter,
299
 
                                    **kwargs)
300
 
            if self.recurse == 'down':
301
 
                for path, file_id in self.this_tree.iter_references():
302
 
                    sub_tree = self.this_tree.get_nested_tree(file_id, path)
303
 
                    other_revision = self.other_tree.get_reference_revision(
304
 
                        file_id, path)
305
 
                    if  other_revision == sub_tree.last_revision():
306
 
                        continue
307
 
                    sub_merge = Merger(sub_tree.branch, this_tree=sub_tree)
308
 
                    sub_merge.merge_type = self.merge_type
309
 
                    relpath = self.this_tree.relpath(path)
310
 
                    other_branch = self.other_branch.reference_parent(file_id, relpath)
311
 
                    sub_merge.set_other_revision(other_revision, other_branch)
312
 
                    base_revision = self.base_tree.get_reference_revision(file_id)
313
 
                    sub_merge.base_tree = \
314
 
                        sub_tree.branch.repository.revision_tree(base_revision)
315
 
                    sub_merge.do_merge()
316
 
 
317
 
        finally:
318
 
            if self.other_tree is not None:
319
 
                self.other_tree.unlock()
320
 
            if self.base_tree is not None:
321
 
                self.base_tree.unlock()
322
 
            self.this_tree.unlock()
323
 
        if len(merge.cooked_conflicts) == 0:
324
 
            if not self.ignore_zero:
325
 
                note("All changes applied successfully.")
326
 
        else:
327
 
            note("%d conflicts encountered." % len(merge.cooked_conflicts))
328
 
 
329
 
        return len(merge.cooked_conflicts)
330
 
 
331
 
 
332
 
class Merge3Merger(object):
333
 
    """Three-way merger that uses the merge3 text merger"""
334
 
    requires_base = True
335
 
    supports_reprocess = True
336
 
    supports_show_base = True
337
 
    history_based = False
338
 
    winner_idx = {"this": 2, "other": 1, "conflict": 1}
339
 
 
340
 
    def __init__(self, working_tree, this_tree, base_tree, other_tree, 
341
 
                 interesting_ids=None, reprocess=False, show_base=False,
342
 
                 pb=DummyProgress(), pp=None, change_reporter=None,
343
 
                 interesting_files=None):
344
 
        """Initialize the merger object and perform the merge.
345
 
 
346
 
        :param working_tree: The working tree to apply the merge to
347
 
        :param this_tree: The local tree in the merge operation
348
 
        :param base_tree: The common tree in the merge operation
349
 
        :param other_tree: The other other tree to merge changes from
350
 
        :param interesting_ids: The file_ids of files that should be
351
 
            participate in the merge.  May not be combined with
352
 
            interesting_files.
353
 
        :param: reprocess If True, perform conflict-reduction processing.
354
 
        :param show_base: If True, show the base revision in text conflicts.
355
 
            (incompatible with reprocess)
356
 
        :param pb: A Progress bar
357
 
        :param pp: A ProgressPhase object
358
 
        :param change_reporter: An object that should report changes made
359
 
        :param interesting_files: The tree-relative paths of files that should
360
 
            participate in the merge.  If these paths refer to directories,
361
 
            the contents of those directories will also be included.  May not
362
 
            be combined with interesting_ids.  If neither interesting_files nor
363
 
            interesting_ids is specified, all files may participate in the
364
 
            merge.
365
 
        """
366
 
        object.__init__(self)
367
 
        if interesting_files is not None:
368
 
            assert interesting_ids is None
369
 
        self.interesting_ids = interesting_ids
370
 
        self.interesting_files = interesting_files
371
 
        self.this_tree = working_tree
372
 
        self.this_tree.lock_tree_write()
373
 
        self.base_tree = base_tree
374
 
        self.base_tree.lock_read()
375
 
        self.other_tree = other_tree
376
 
        self.other_tree.lock_read()
377
 
        self._raw_conflicts = []
378
 
        self.cooked_conflicts = []
379
 
        self.reprocess = reprocess
380
 
        self.show_base = show_base
381
 
        self.pb = pb
382
 
        self.pp = pp
383
 
        self.change_reporter = change_reporter
384
 
        if self.pp is None:
385
 
            self.pp = ProgressPhase("Merge phase", 3, self.pb)
386
 
 
387
 
        self.tt = TreeTransform(working_tree, self.pb)
388
 
        try:
389
 
            self.pp.next_phase()
390
 
            entries = self._entries3()
391
 
            child_pb = ui.ui_factory.nested_progress_bar()
392
 
            try:
393
 
                for num, (file_id, changed, parents3, names3,
394
 
                          executable3) in enumerate(entries):
395
 
                    child_pb.update('Preparing file merge', num, len(entries))
396
 
                    self._merge_names(file_id, parents3, names3)
397
 
                    if changed:
398
 
                        file_status = self.merge_contents(file_id)
399
 
                    else:
400
 
                        file_status = 'unmodified'
401
 
                    self._merge_executable(file_id,
402
 
                        executable3, file_status)
403
 
            finally:
404
 
                child_pb.finished()
405
 
            self.fix_root()
406
 
            self.pp.next_phase()
407
 
            child_pb = ui.ui_factory.nested_progress_bar()
408
 
            try:
409
 
                fs_conflicts = resolve_conflicts(self.tt, child_pb,
410
 
                    lambda t, c: conflict_pass(t, c, self.other_tree))
411
 
            finally:
412
 
                child_pb.finished()
413
 
            if change_reporter is not None:
414
 
                from bzrlib import delta
415
 
                delta.report_changes(self.tt._iter_changes(), change_reporter)
416
 
            self.cook_conflicts(fs_conflicts)
417
 
            for conflict in self.cooked_conflicts:
418
 
                warning(conflict)
419
 
            self.pp.next_phase()
420
 
            results = self.tt.apply(no_conflicts=True)
421
 
            self.write_modified(results)
422
 
            try:
423
 
                working_tree.add_conflicts(self.cooked_conflicts)
424
 
            except UnsupportedOperation:
425
 
                pass
426
 
        finally:
427
 
            self.tt.finalize()
428
 
            self.other_tree.unlock()
429
 
            self.base_tree.unlock()
430
 
            self.this_tree.unlock()
431
 
            self.pb.clear()
432
 
 
433
 
    def _entries3(self):
434
 
        """Gather data about files modified between three trees.
435
 
 
436
 
        Return a list of tuples of file_id, changed, parents3, names3,
437
 
        executable3.  changed is a boolean indicating whether the file contents
438
 
        or kind were changed.  parents3 is a tuple of parent ids for base,
439
 
        other and this.  names3 is a tuple of names for base, other and this.
440
 
        executable3 is a tuple of execute-bit values for base, other and this.
441
 
        """
442
 
        result = []
443
 
        iterator = self.other_tree._iter_changes(self.base_tree,
444
 
                include_unchanged=True, specific_files=self.interesting_files,
445
 
                extra_trees=[self.this_tree])
446
 
        for (file_id, paths, changed, versioned, parents, names, kind,
447
 
             executable) in iterator:
448
 
            if (self.interesting_ids is not None and
449
 
                file_id not in self.interesting_ids):
450
 
                continue
451
 
            if file_id in self.this_tree.inventory:
452
 
                entry = self.this_tree.inventory[file_id]
453
 
                this_name = entry.name
454
 
                this_parent = entry.parent_id
455
 
                this_executable = entry.executable
456
 
            else:
457
 
                this_name = None
458
 
                this_parent = None
459
 
                this_executable = None
460
 
            parents3 = parents + (this_parent,)
461
 
            names3 = names + (this_name,)
462
 
            executable3 = executable + (this_executable,)
463
 
            result.append((file_id, changed, parents3, names3, executable3))
464
 
        return result
465
 
 
466
 
    def fix_root(self):
467
 
        try:
468
 
            self.tt.final_kind(self.tt.root)
469
 
        except NoSuchFile:
470
 
            self.tt.cancel_deletion(self.tt.root)
471
 
        if self.tt.final_file_id(self.tt.root) is None:
472
 
            self.tt.version_file(self.tt.tree_file_id(self.tt.root), 
473
 
                                 self.tt.root)
474
 
        if self.other_tree.inventory.root is None:
475
 
            return
476
 
        other_root_file_id = self.other_tree.inventory.root.file_id
477
 
        other_root = self.tt.trans_id_file_id(other_root_file_id)
478
 
        if other_root == self.tt.root:
479
 
            return
480
 
        try:
481
 
            self.tt.final_kind(other_root)
482
 
        except NoSuchFile:
483
 
            return
484
 
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
485
 
        self.tt.cancel_creation(other_root)
486
 
        self.tt.cancel_versioning(other_root)
487
 
 
488
 
    def reparent_children(self, ie, target):
489
 
        for thing, child in ie.children.iteritems():
490
 
            trans_id = self.tt.trans_id_file_id(child.file_id)
491
 
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
492
 
 
493
 
    def write_modified(self, results):
494
 
        modified_hashes = {}
495
 
        for path in results.modified_paths:
496
 
            file_id = self.this_tree.path2id(self.this_tree.relpath(path))
497
 
            if file_id is None:
498
 
                continue
499
 
            hash = self.this_tree.get_file_sha1(file_id)
500
 
            if hash is None:
501
 
                continue
502
 
            modified_hashes[file_id] = hash
503
 
        self.this_tree.set_merge_modified(modified_hashes)
504
 
 
505
 
    @staticmethod
506
 
    def parent(entry, file_id):
507
 
        """Determine the parent for a file_id (used as a key method)"""
508
 
        if entry is None:
509
 
            return None
510
 
        return entry.parent_id
511
 
 
512
 
    @staticmethod
513
 
    def name(entry, file_id):
514
 
        """Determine the name for a file_id (used as a key method)"""
515
 
        if entry is None:
516
 
            return None
517
 
        return entry.name
518
 
    
519
 
    @staticmethod
520
 
    def contents_sha1(tree, file_id):
521
 
        """Determine the sha1 of the file contents (used as a key method)."""
522
 
        if file_id not in tree:
523
 
            return None
524
 
        return tree.get_file_sha1(file_id)
525
 
 
526
 
    @staticmethod
527
 
    def executable(tree, file_id):
528
 
        """Determine the executability of a file-id (used as a key method)."""
529
 
        if file_id not in tree:
530
 
            return None
531
 
        if tree.kind(file_id) != "file":
532
 
            return False
533
 
        return tree.is_executable(file_id)
534
 
 
535
 
    @staticmethod
536
 
    def kind(tree, file_id):
537
 
        """Determine the kind of a file-id (used as a key method)."""
538
 
        if file_id not in tree:
539
 
            return None
540
 
        return tree.kind(file_id)
541
 
 
542
 
    @staticmethod
543
 
    def _three_way(base, other, this):
544
 
        #if base == other, either they all agree, or only THIS has changed.
545
 
        if base == other:
546
 
            return 'this'
547
 
        elif this not in (base, other):
548
 
            return 'conflict'
549
 
        # "Ambiguous clean merge" -- both sides have made the same change.
550
 
        elif this == other:
551
 
            return "this"
552
 
        # this == base: only other has changed.
553
 
        else:
554
 
            return "other"
555
 
 
556
 
    @staticmethod
557
 
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
558
 
        """Do a three-way test on a scalar.
559
 
        Return "this", "other" or "conflict", depending whether a value wins.
560
 
        """
561
 
        key_base = key(base_tree, file_id)
562
 
        key_other = key(other_tree, file_id)
563
 
        #if base == other, either they all agree, or only THIS has changed.
564
 
        if key_base == key_other:
565
 
            return "this"
566
 
        key_this = key(this_tree, file_id)
567
 
        if key_this not in (key_base, key_other):
568
 
            return "conflict"
569
 
        # "Ambiguous clean merge"
570
 
        elif key_this == key_other:
571
 
            return "this"
572
 
        else:
573
 
            assert key_this == key_base
574
 
            return "other"
575
 
 
576
 
    def merge_names(self, file_id):
577
 
        def get_entry(tree):
578
 
            if file_id in tree.inventory:
579
 
                return tree.inventory[file_id]
580
 
            else:
581
 
                return None
582
 
        this_entry = get_entry(self.this_tree)
583
 
        other_entry = get_entry(self.other_tree)
584
 
        base_entry = get_entry(self.base_tree)
585
 
        entries = (base_entry, other_entry, this_entry)
586
 
        names = []
587
 
        parents = []
588
 
        for entry in entries:
589
 
            if entry is None:
590
 
                names.append(None)
591
 
                parents.append(None)
592
 
            else:
593
 
                names.append(entry.name)
594
 
                parents.append(entry.parent_id)
595
 
        return self._merge_names(file_id, parents, names)
596
 
 
597
 
    def _merge_names(self, file_id, parents, names):
598
 
        """Perform a merge on file_id names and parents"""
599
 
        base_name, other_name, this_name = names
600
 
        base_parent, other_parent, this_parent = parents
601
 
 
602
 
        name_winner = self._three_way(*names)
603
 
 
604
 
        parent_id_winner = self._three_way(*parents)
605
 
        if this_name is None:
606
 
            if name_winner == "this":
607
 
                name_winner = "other"
608
 
            if parent_id_winner == "this":
609
 
                parent_id_winner = "other"
610
 
        if name_winner == "this" and parent_id_winner == "this":
611
 
            return
612
 
        if name_winner == "conflict":
613
 
            trans_id = self.tt.trans_id_file_id(file_id)
614
 
            self._raw_conflicts.append(('name conflict', trans_id, 
615
 
                                        this_name, other_name))
616
 
        if parent_id_winner == "conflict":
617
 
            trans_id = self.tt.trans_id_file_id(file_id)
618
 
            self._raw_conflicts.append(('parent conflict', trans_id, 
619
 
                                        this_parent, other_parent))
620
 
        if other_name is None:
621
 
            # it doesn't matter whether the result was 'other' or 
622
 
            # 'conflict'-- if there's no 'other', we leave it alone.
623
 
            return
624
 
        # if we get here, name_winner and parent_winner are set to safe values.
625
 
        trans_id = self.tt.trans_id_file_id(file_id)
626
 
        parent_id = parents[self.winner_idx[parent_id_winner]]
627
 
        if parent_id is not None:
628
 
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
629
 
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
630
 
                                parent_trans_id, trans_id)
631
 
 
632
 
    def merge_contents(self, file_id):
633
 
        """Performa a merge on file_id contents."""
634
 
        def contents_pair(tree):
635
 
            if file_id not in tree:
636
 
                return (None, None)
637
 
            kind = tree.kind(file_id)
638
 
            if kind == "file":
639
 
                contents = tree.get_file_sha1(file_id)
640
 
            elif kind == "symlink":
641
 
                contents = tree.get_symlink_target(file_id)
642
 
            else:
643
 
                contents = None
644
 
            return kind, contents
645
 
 
646
 
        def contents_conflict():
647
 
            trans_id = self.tt.trans_id_file_id(file_id)
648
 
            name = self.tt.final_name(trans_id)
649
 
            parent_id = self.tt.final_parent(trans_id)
650
 
            if file_id in self.this_tree.inventory:
651
 
                self.tt.unversion_file(trans_id)
652
 
                if file_id in self.this_tree:
653
 
                    self.tt.delete_contents(trans_id)
654
 
            file_group = self._dump_conflicts(name, parent_id, file_id, 
655
 
                                              set_version=True)
656
 
            self._raw_conflicts.append(('contents conflict', file_group))
657
 
 
658
 
        # See SPOT run.  run, SPOT, run.
659
 
        # So we're not QUITE repeating ourselves; we do tricky things with
660
 
        # file kind...
661
 
        base_pair = contents_pair(self.base_tree)
662
 
        other_pair = contents_pair(self.other_tree)
663
 
        if base_pair == other_pair:
664
 
            # OTHER introduced no changes
665
 
            return "unmodified"
666
 
        this_pair = contents_pair(self.this_tree)
667
 
        if this_pair == other_pair:
668
 
            # THIS and OTHER introduced the same changes
669
 
            return "unmodified"
670
 
        else:
671
 
            trans_id = self.tt.trans_id_file_id(file_id)
672
 
            if this_pair == base_pair:
673
 
                # only OTHER introduced changes
674
 
                if file_id in self.this_tree:
675
 
                    # Remove any existing contents
676
 
                    self.tt.delete_contents(trans_id)
677
 
                if file_id in self.other_tree:
678
 
                    # OTHER changed the file
679
 
                    create_by_entry(self.tt, 
680
 
                                    self.other_tree.inventory[file_id], 
681
 
                                    self.other_tree, trans_id)
682
 
                    if file_id not in self.this_tree.inventory:
683
 
                        self.tt.version_file(file_id, trans_id)
684
 
                    return "modified"
685
 
                elif file_id in self.this_tree.inventory:
686
 
                    # OTHER deleted the file
687
 
                    self.tt.unversion_file(trans_id)
688
 
                    return "deleted"
689
 
            #BOTH THIS and OTHER introduced changes; scalar conflict
690
 
            elif this_pair[0] == "file" and other_pair[0] == "file":
691
 
                # THIS and OTHER are both files, so text merge.  Either
692
 
                # BASE is a file, or both converted to files, so at least we
693
 
                # have agreement that output should be a file.
694
 
                try:
695
 
                    self.text_merge(file_id, trans_id)
696
 
                except BinaryFile:
697
 
                    return contents_conflict()
698
 
                if file_id not in self.this_tree.inventory:
699
 
                    self.tt.version_file(file_id, trans_id)
700
 
                try:
701
 
                    self.tt.tree_kind(trans_id)
702
 
                    self.tt.delete_contents(trans_id)
703
 
                except NoSuchFile:
704
 
                    pass
705
 
                return "modified"
706
 
            else:
707
 
                # Scalar conflict, can't text merge.  Dump conflicts
708
 
                return contents_conflict()
709
 
 
710
 
    def get_lines(self, tree, file_id):
711
 
        """Return the lines in a file, or an empty list."""
712
 
        if file_id in tree:
713
 
            return tree.get_file(file_id).readlines()
714
 
        else:
715
 
            return []
716
 
 
717
 
    def text_merge(self, file_id, trans_id):
718
 
        """Perform a three-way text merge on a file_id"""
719
 
        # it's possible that we got here with base as a different type.
720
 
        # if so, we just want two-way text conflicts.
721
 
        if file_id in self.base_tree and \
722
 
            self.base_tree.kind(file_id) == "file":
723
 
            base_lines = self.get_lines(self.base_tree, file_id)
724
 
        else:
725
 
            base_lines = []
726
 
        other_lines = self.get_lines(self.other_tree, file_id)
727
 
        this_lines = self.get_lines(self.this_tree, file_id)
728
 
        m3 = Merge3(base_lines, this_lines, other_lines)
729
 
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
730
 
        if self.show_base is True:
731
 
            base_marker = '|' * 7
732
 
        else:
733
 
            base_marker = None
734
 
 
735
 
        def iter_merge3(retval):
736
 
            retval["text_conflicts"] = False
737
 
            for line in m3.merge_lines(name_a = "TREE", 
738
 
                                       name_b = "MERGE-SOURCE", 
739
 
                                       name_base = "BASE-REVISION",
740
 
                                       start_marker=start_marker, 
741
 
                                       base_marker=base_marker,
742
 
                                       reprocess=self.reprocess):
743
 
                if line.startswith(start_marker):
744
 
                    retval["text_conflicts"] = True
745
 
                    yield line.replace(start_marker, '<' * 7)
746
 
                else:
747
 
                    yield line
748
 
        retval = {}
749
 
        merge3_iterator = iter_merge3(retval)
750
 
        self.tt.create_file(merge3_iterator, trans_id)
751
 
        if retval["text_conflicts"] is True:
752
 
            self._raw_conflicts.append(('text conflict', trans_id))
753
 
            name = self.tt.final_name(trans_id)
754
 
            parent_id = self.tt.final_parent(trans_id)
755
 
            file_group = self._dump_conflicts(name, parent_id, file_id, 
756
 
                                              this_lines, base_lines,
757
 
                                              other_lines)
758
 
            file_group.append(trans_id)
759
 
 
760
 
    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None, 
761
 
                        base_lines=None, other_lines=None, set_version=False,
762
 
                        no_base=False):
763
 
        """Emit conflict files.
764
 
        If this_lines, base_lines, or other_lines are omitted, they will be
765
 
        determined automatically.  If set_version is true, the .OTHER, .THIS
766
 
        or .BASE (in that order) will be created as versioned files.
767
 
        """
768
 
        data = [('OTHER', self.other_tree, other_lines), 
769
 
                ('THIS', self.this_tree, this_lines)]
770
 
        if not no_base:
771
 
            data.append(('BASE', self.base_tree, base_lines))
772
 
        versioned = False
773
 
        file_group = []
774
 
        for suffix, tree, lines in data:
775
 
            if file_id in tree:
776
 
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
777
 
                                               suffix, lines)
778
 
                file_group.append(trans_id)
779
 
                if set_version and not versioned:
780
 
                    self.tt.version_file(file_id, trans_id)
781
 
                    versioned = True
782
 
        return file_group
783
 
           
784
 
    def _conflict_file(self, name, parent_id, tree, file_id, suffix, 
785
 
                       lines=None):
786
 
        """Emit a single conflict file."""
787
 
        name = name + '.' + suffix
788
 
        trans_id = self.tt.create_path(name, parent_id)
789
 
        entry = tree.inventory[file_id]
790
 
        create_by_entry(self.tt, entry, tree, trans_id, lines)
791
 
        return trans_id
792
 
 
793
 
    def merge_executable(self, file_id, file_status):
794
 
        """Perform a merge on the execute bit."""
795
 
        executable = [self.executable(t, file_id) for t in (self.base_tree,
796
 
                      self.other_tree, self.this_tree)]
797
 
        self._merge_executable(file_id, executable, file_status)
798
 
 
799
 
    def _merge_executable(self, file_id, executable, file_status):
800
 
        """Perform a merge on the execute bit."""
801
 
        base_executable, other_executable, this_executable = executable
802
 
        if file_status == "deleted":
803
 
            return
804
 
        trans_id = self.tt.trans_id_file_id(file_id)
805
 
        try:
806
 
            if self.tt.final_kind(trans_id) != "file":
807
 
                return
808
 
        except NoSuchFile:
809
 
            return
810
 
        winner = self._three_way(*executable)
811
 
        if winner == "conflict":
812
 
        # There must be a None in here, if we have a conflict, but we
813
 
        # need executability since file status was not deleted.
814
 
            if self.executable(self.other_tree, file_id) is None:
815
 
                winner = "this"
816
 
            else:
817
 
                winner = "other"
818
 
        if winner == "this":
819
 
            if file_status == "modified":
820
 
                executability = this_executable
821
 
                if executability is not None:
822
 
                    trans_id = self.tt.trans_id_file_id(file_id)
823
 
                    self.tt.set_executability(executability, trans_id)
824
 
        else:
825
 
            assert winner == "other"
826
 
            if file_id in self.other_tree:
827
 
                executability = other_executable
828
 
            elif file_id in self.this_tree:
829
 
                executability = this_executable
830
 
            elif file_id in self.base_tree:
831
 
                executability = base_executable
832
 
            if executability is not None:
833
 
                trans_id = self.tt.trans_id_file_id(file_id)
834
 
                self.tt.set_executability(executability, trans_id)
835
 
 
836
 
    def cook_conflicts(self, fs_conflicts):
837
 
        """Convert all conflicts into a form that doesn't depend on trans_id"""
838
 
        from conflicts import Conflict
839
 
        name_conflicts = {}
840
 
        self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
841
 
        fp = FinalPaths(self.tt)
842
 
        for conflict in self._raw_conflicts:
843
 
            conflict_type = conflict[0]
844
 
            if conflict_type in ('name conflict', 'parent conflict'):
845
 
                trans_id = conflict[1]
846
 
                conflict_args = conflict[2:]
847
 
                if trans_id not in name_conflicts:
848
 
                    name_conflicts[trans_id] = {}
849
 
                unique_add(name_conflicts[trans_id], conflict_type, 
850
 
                           conflict_args)
851
 
            if conflict_type == 'contents conflict':
852
 
                for trans_id in conflict[1]:
853
 
                    file_id = self.tt.final_file_id(trans_id)
 
222
            base_revision = ['.', base_revno]
 
223
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
 
224
        if file_list is None:
 
225
            interesting_ids = None
 
226
        else:
 
227
            interesting_ids = set()
 
228
            this_tree = this_branch.working_tree()
 
229
            for fname in file_list:
 
230
                path = this_branch.relpath(fname)
 
231
                found_id = False
 
232
                for tree in (this_tree, base_tree.tree, other_tree.tree):
 
233
                    file_id = tree.inventory.path2id(path)
854
234
                    if file_id is not None:
855
 
                        break
856
 
                path = fp.get_path(trans_id)
857
 
                for suffix in ('.BASE', '.THIS', '.OTHER'):
858
 
                    if path.endswith(suffix):
859
 
                        path = path[:-len(suffix)]
860
 
                        break
861
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
862
 
                self.cooked_conflicts.append(c)
863
 
            if conflict_type == 'text conflict':
864
 
                trans_id = conflict[1]
865
 
                path = fp.get_path(trans_id)
866
 
                file_id = self.tt.final_file_id(trans_id)
867
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
868
 
                self.cooked_conflicts.append(c)
869
 
 
870
 
        for trans_id, conflicts in name_conflicts.iteritems():
871
 
            try:
872
 
                this_parent, other_parent = conflicts['parent conflict']
873
 
                assert this_parent != other_parent
874
 
            except KeyError:
875
 
                this_parent = other_parent = \
876
 
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
877
 
            try:
878
 
                this_name, other_name = conflicts['name conflict']
879
 
                assert this_name != other_name
880
 
            except KeyError:
881
 
                this_name = other_name = self.tt.final_name(trans_id)
882
 
            other_path = fp.get_path(trans_id)
883
 
            if this_parent is not None and this_name is not None:
884
 
                this_parent_path = \
885
 
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
886
 
                this_path = pathjoin(this_parent_path, this_name)
 
235
                        interesting_ids.add(file_id)
 
236
                        found_id = True
 
237
                if not found_id:
 
238
                    raise BzrCommandError("%s is not a source file in any"
 
239
                                          " tree." % fname)
 
240
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
 
241
                    ignore_zero=ignore_zero, backup_files=backup_files, 
 
242
                    merge_type=merge_type, interesting_ids=interesting_ids)
 
243
    finally:
 
244
        shutil.rmtree(tempdir)
 
245
 
 
246
 
 
247
def set_interesting(inventory_a, inventory_b, interesting_ids):
 
248
    """Mark files whose ids are in interesting_ids as interesting
 
249
    """
 
250
    for inventory in (inventory_a, inventory_b):
 
251
        for path, source_file in inventory.iteritems():
 
252
             source_file.interesting = source_file.id in interesting_ids
 
253
 
 
254
 
 
255
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
 
256
    """Generate a changeset.  If interesting_ids is supplied, only changes
 
257
    to those files will be shown.  Metadata changes are stripped.
 
258
    """ 
 
259
    cset =  generate_changeset(tree_a, tree_b, interesting_ids)
 
260
    for entry in cset.entries.itervalues():
 
261
        entry.metadata_change = None
 
262
    return cset
 
263
 
 
264
 
 
265
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
 
266
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
 
267
                interesting_ids=None):
 
268
 
 
269
    def merge_factory(file_id, base, other):
 
270
        contents_change = merge_type(file_id, base, other)
 
271
        if backup_files:
 
272
            contents_change = BackupBeforeChange(contents_change)
 
273
        return contents_change
 
274
 
 
275
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
 
276
 
 
277
    def get_inventory(tree):
 
278
        return tree.tree.inventory
 
279
 
 
280
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
 
281
                             generate_cset_optimized, get_inventory,
 
282
                             MergeConflictHandler(base_tree.root,
 
283
                                                  ignore_zero=ignore_zero),
 
284
                             merge_factory=merge_factory, 
 
285
                             interesting_ids=interesting_ids)
 
286
 
 
287
    adjust_ids = []
 
288
    for id, path in inv_changes.iteritems():
 
289
        if path is not None:
 
290
            if path == '.':
 
291
                path = ''
887
292
            else:
888
 
                this_path = "<deleted>"
889
 
            file_id = self.tt.final_file_id(trans_id)
890
 
            c = Conflict.factory('path conflict', path=this_path,
891
 
                                 conflict_path=other_path, file_id=file_id)
892
 
            self.cooked_conflicts.append(c)
893
 
        self.cooked_conflicts.sort(key=Conflict.sort_key)
894
 
 
895
 
 
896
 
class WeaveMerger(Merge3Merger):
897
 
    """Three-way tree merger, text weave merger."""
898
 
    supports_reprocess = True
899
 
    supports_show_base = False
900
 
 
901
 
    def __init__(self, working_tree, this_tree, base_tree, other_tree, 
902
 
                 interesting_ids=None, pb=DummyProgress(), pp=None,
903
 
                 reprocess=False, change_reporter=None,
904
 
                 interesting_files=None):
905
 
        self.this_revision_tree = self._get_revision_tree(this_tree)
906
 
        self.other_revision_tree = self._get_revision_tree(other_tree)
907
 
        super(WeaveMerger, self).__init__(working_tree, this_tree, 
908
 
                                          base_tree, other_tree, 
909
 
                                          interesting_ids=interesting_ids, 
910
 
                                          pb=pb, pp=pp, reprocess=reprocess,
911
 
                                          change_reporter=change_reporter)
912
 
 
913
 
    def _get_revision_tree(self, tree):
914
 
        """Return a revision tree related to this tree.
915
 
        If the tree is a WorkingTree, the basis will be returned.
916
 
        """
917
 
        if getattr(tree, 'get_weave', False) is False:
918
 
            # If we have a WorkingTree, try using the basis
919
 
            return tree.branch.basis_tree()
920
 
        else:
921
 
            return tree
922
 
 
923
 
    def _check_file(self, file_id):
924
 
        """Check that the revision tree's version of the file matches."""
925
 
        for tree, rt in ((self.this_tree, self.this_revision_tree), 
926
 
                         (self.other_tree, self.other_revision_tree)):
927
 
            if rt is tree:
928
 
                continue
929
 
            if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
930
 
                raise WorkingTreeNotRevision(self.this_tree)
931
 
 
932
 
    def _merged_lines(self, file_id):
933
 
        """Generate the merged lines.
934
 
        There is no distinction between lines that are meant to contain <<<<<<<
935
 
        and conflicts.
936
 
        """
937
 
        weave = self.this_revision_tree.get_weave(file_id)
938
 
        this_revision_id = self.this_revision_tree.inventory[file_id].revision
939
 
        other_revision_id = \
940
 
            self.other_revision_tree.inventory[file_id].revision
941
 
        wm = WeaveMerge(weave, this_revision_id, other_revision_id, 
942
 
                        '<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
943
 
        return wm.merge_lines(self.reprocess)
944
 
 
945
 
    def text_merge(self, file_id, trans_id):
946
 
        """Perform a (weave) text merge for a given file and file-id.
947
 
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
948
 
        and a conflict will be noted.
949
 
        """
950
 
        self._check_file(file_id)
951
 
        lines, conflicts = self._merged_lines(file_id)
952
 
        lines = list(lines)
953
 
        # Note we're checking whether the OUTPUT is binary in this case, 
954
 
        # because we don't want to get into weave merge guts.
955
 
        check_text_lines(lines)
956
 
        self.tt.create_file(lines, trans_id)
957
 
        if conflicts:
958
 
            self._raw_conflicts.append(('text conflict', trans_id))
959
 
            name = self.tt.final_name(trans_id)
960
 
            parent_id = self.tt.final_parent(trans_id)
961
 
            file_group = self._dump_conflicts(name, parent_id, file_id, 
962
 
                                              no_base=True)
963
 
            file_group.append(trans_id)
964
 
 
965
 
 
966
 
class Diff3Merger(Merge3Merger):
967
 
    """Three-way merger using external diff3 for text merging"""
968
 
 
969
 
    def dump_file(self, temp_dir, name, tree, file_id):
970
 
        out_path = pathjoin(temp_dir, name)
971
 
        out_file = open(out_path, "wb")
972
 
        try:
973
 
            in_file = tree.get_file(file_id)
974
 
            for line in in_file:
975
 
                out_file.write(line)
976
 
        finally:
977
 
            out_file.close()
978
 
        return out_path
979
 
 
980
 
    def text_merge(self, file_id, trans_id):
981
 
        """Perform a diff3 merge using a specified file-id and trans-id.
982
 
        If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
983
 
        will be dumped, and a will be conflict noted.
984
 
        """
985
 
        import bzrlib.patch
986
 
        temp_dir = osutils.mkdtemp(prefix="bzr-")
987
 
        try:
988
 
            new_file = pathjoin(temp_dir, "new")
989
 
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
990
 
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
991
 
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
992
 
            status = bzrlib.patch.diff3(new_file, this, base, other)
993
 
            if status not in (0, 1):
994
 
                raise BzrError("Unhandled diff3 exit code")
995
 
            f = open(new_file, 'rb')
996
 
            try:
997
 
                self.tt.create_file(f, trans_id)
998
 
            finally:
999
 
                f.close()
1000
 
            if status == 1:
1001
 
                name = self.tt.final_name(trans_id)
1002
 
                parent_id = self.tt.final_parent(trans_id)
1003
 
                self._dump_conflicts(name, parent_id, file_id)
1004
 
                self._raw_conflicts.append(('text conflict', trans_id))
1005
 
        finally:
1006
 
            osutils.rmtree(temp_dir)
1007
 
 
1008
 
 
1009
 
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1010
 
                backup_files=False,
1011
 
                merge_type=Merge3Merger,
1012
 
                interesting_ids=None,
1013
 
                show_base=False,
1014
 
                reprocess=False,
1015
 
                other_rev_id=None,
1016
 
                interesting_files=None,
1017
 
                this_tree=None,
1018
 
                pb=DummyProgress(),
1019
 
                change_reporter=None):
1020
 
    """Primary interface for merging. 
1021
 
 
1022
 
        typical use is probably 
1023
 
        'merge_inner(branch, branch.get_revision_tree(other_revision),
1024
 
                     branch.get_revision_tree(base_revision))'
1025
 
        """
1026
 
    if this_tree is None:
1027
 
        raise BzrError("bzrlib.merge.merge_inner requires a this_tree "
1028
 
            "parameter as of bzrlib version 0.8.")
1029
 
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1030
 
                    pb=pb, change_reporter=change_reporter)
1031
 
    merger.backup_files = backup_files
1032
 
    merger.merge_type = merge_type
1033
 
    merger.interesting_ids = interesting_ids
1034
 
    merger.ignore_zero = ignore_zero
1035
 
    if interesting_files:
1036
 
        assert not interesting_ids, ('Only supply interesting_ids'
1037
 
                                     ' or interesting_files')
1038
 
        merger.interesting_files = interesting_files
1039
 
    merger.show_base = show_base
1040
 
    merger.reprocess = reprocess
1041
 
    merger.other_rev_id = other_rev_id
1042
 
    merger.other_basis = other_rev_id
1043
 
    return merger.do_merge()
1044
 
 
1045
 
def get_merge_type_registry():
1046
 
    """Merge type registry is in bzrlib.option to avoid circular imports.
1047
 
 
1048
 
    This method provides a sanctioned way to retrieve it.
1049
 
    """
1050
 
    from bzrlib import option
1051
 
    return option._merge_type_registry
 
293
                assert path.startswith('./'), "path is %s" % path
 
294
            path = path[2:]
 
295
        adjust_ids.append((path, id))
 
296
    if len(adjust_ids) > 0:
 
297
        this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
 
298
                                                  adjust_ids))
 
299
 
 
300
 
 
301
def regen_inventory(this_branch, root, new_entries):
 
302
    old_entries = this_branch.read_working_inventory()
 
303
    new_inventory = {}
 
304
    by_path = {}
 
305
    new_entries_map = {} 
 
306
    for path, file_id in new_entries:
 
307
        if path is None:
 
308
            continue
 
309
        new_entries_map[file_id] = path
 
310
 
 
311
    def id2path(file_id):
 
312
        path = new_entries_map.get(file_id)
 
313
        if path is not None:
 
314
            return path
 
315
        entry = old_entries[file_id]
 
316
        if entry.parent_id is None:
 
317
            return entry.name
 
318
        return os.path.join(id2path(entry.parent_id), entry.name)
 
319
        
 
320
    for file_id in old_entries:
 
321
        entry = old_entries[file_id]
 
322
        path = id2path(file_id)
 
323
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
 
324
        by_path[path] = file_id
 
325
    
 
326
    deletions = 0
 
327
    insertions = 0
 
328
    new_path_list = []
 
329
    for path, file_id in new_entries:
 
330
        if path is None:
 
331
            del new_inventory[file_id]
 
332
            deletions += 1
 
333
        else:
 
334
            new_path_list.append((path, file_id))
 
335
            if file_id not in old_entries:
 
336
                insertions += 1
 
337
    # Ensure no file is added before its parent
 
338
    new_path_list.sort()
 
339
    for path, file_id in new_path_list:
 
340
        if path == '':
 
341
            parent = None
 
342
        else:
 
343
            parent = by_path[os.path.dirname(path)]
 
344
        kind = bzrlib.osutils.file_kind(os.path.join(root, path))
 
345
        new_inventory[file_id] = (path, file_id, parent, kind)
 
346
        by_path[path] = file_id 
 
347
 
 
348
    # Get a list in insertion order
 
349
    new_inventory_list = new_inventory.values()
 
350
    mutter ("""Inventory regeneration:
 
351
old length: %i insertions: %i deletions: %i new_length: %i"""\
 
352
        % (len(old_entries), insertions, deletions, len(new_inventory_list)))
 
353
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
 
354
    new_inventory_list.sort()
 
355
    return new_inventory_list
 
356
 
 
357
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
 
358
                     "diff3": (Diff3Merge,  "Merge using external diff3")
 
359
              }
 
360