~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

Don't encode unicode messages to UTF-8 in mutter() (the stream writer does it).

Use a codec wrapped log file in tests to match the real environment.

Show diffs side-by-side

added added

removed removed

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