~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-03-12 17:30:53 UTC
  • mfrom: (2338.3.1 hide-nested)
  • Revision ID: pqm@pqm.ubuntu.com-20070312173053-4cdb4cd14190d29e
Hide nested-tree commands and improve their docs

Show diffs side-by-side

added added

removed removed

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