/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Robert Collins
  • Date: 2006-02-16 05:54:02 UTC
  • mto: (1534.1.24 integration)
  • mto: This revision was merged to the branch mainline in revision 1554.
  • Revision ID: robertc@robertcollins.net-20060216055402-bb6afc4d15c715cd
split out converter logic into per-format objects.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
from merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
2
 
from changeset import generate_changeset, ExceptionConflictHandler
3
 
from changeset import Inventory, Diff3Merge
4
 
from bzrlib import find_branch
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import os
 
19
import errno
 
20
 
 
21
import bzrlib
 
22
from bzrlib._changeset import generate_changeset, ExceptionConflictHandler
 
23
from bzrlib._changeset import Inventory, Diff3Merge, ReplaceContents
 
24
from bzrlib._merge_core import WeaveMerge
 
25
from bzrlib._merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
 
26
from bzrlib.branch import Branch
 
27
from bzrlib.delta import compare_trees
 
28
from bzrlib.errors import (BzrCommandError,
 
29
                           BzrError,
 
30
                           NoCommonAncestor,
 
31
                           NoCommits,
 
32
                           NoSuchRevision,
 
33
                           NotBranchError,
 
34
                           NotVersionedError,
 
35
                           UnrelatedBranches,
 
36
                           WorkingTreeNotRevision,
 
37
                           )
 
38
from bzrlib.fetch import greedy_fetch, fetch
5
39
import bzrlib.osutils
6
 
from bzrlib.errors import BzrCommandError
7
 
from bzrlib.delta import compare_trees
8
 
from trace import mutter, warning
9
 
import os.path
10
 
import tempfile
11
 
import shutil
12
 
import errno
13
 
 
14
 
class UnrelatedBranches(BzrCommandError):
15
 
    def __init__(self):
16
 
        msg = "Branches have no common ancestor, and no base revision"\
17
 
            " specified."
18
 
        BzrCommandError.__init__(self, msg)
19
 
 
20
 
 
21
 
class MergeConflictHandler(ExceptionConflictHandler):
22
 
    """Handle conflicts encountered while merging"""
23
 
    def __init__(self, dir, ignore_zero=False):
24
 
        ExceptionConflictHandler.__init__(self, dir)
 
40
from bzrlib.osutils import rename, pathjoin
 
41
from bzrlib.revision import common_ancestor, is_ancestor, NULL_REVISION
 
42
from bzrlib.trace import mutter, warning, note
 
43
 
 
44
# TODO: Report back as changes are merged in
 
45
 
 
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)
25
61
        self.conflicts = 0
26
62
        self.ignore_zero = ignore_zero
 
63
        self.this_tree = this_tree
 
64
        self.base_tree = base_tree
 
65
        self.other_tree = other_tree
27
66
 
28
67
    def copy(self, source, dest):
29
68
        """Copy the text and mode of a file
36
75
            d_file.write(line)
37
76
        os.chmod(dest, 0777 & os.stat(source).st_mode)
38
77
 
39
 
    def add_suffix(self, name, suffix, last_new_name=None):
 
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):
40
88
        """Rename a file to append a suffix.  If the new name exists, the
41
89
        suffix is added repeatedly until a non-existant name is found
42
90
 
48
96
            last_new_name = name
49
97
        new_name = last_new_name+suffix
50
98
        try:
51
 
            os.rename(name, new_name)
52
 
            return new_name
 
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
53
112
        except OSError, e:
54
113
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
55
114
                raise
56
 
            return self.add_suffix(name, suffix, last_new_name=new_name)
 
115
            return self.add_suffix(name, suffix, last_new_name=new_name, 
 
116
                                   fix_inventory=fix_inventory)
 
117
        return new_name
57
118
 
58
119
    def conflict(self, text):
59
120
        warning(text)
60
121
        self.conflicts += 1
61
122
        
62
123
 
63
 
    def merge_conflict(self, new_file, this_path, base_path, other_path):
 
124
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
64
125
        """
65
126
        Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER.  The
66
127
        main file will be a version with diff3 conflicts.
69
130
        :param base_path: Path to the file text for the BASE tree
70
131
        :param other_path: Path to the file text for the OTHER tree
71
132
        """
72
 
        self.add_suffix(this_path, ".THIS")
73
 
        self.copy(base_path, this_path+".BASE")
74
 
        self.copy(other_path, this_path+".OTHER")
75
 
        os.rename(new_file, this_path)
 
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)
76
137
        self.conflict("Diff3 conflict encountered in %s" % this_path)
77
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
 
78
155
    def target_exists(self, entry, target, old_path):
79
156
        """Handle the case when the target file or dir exists"""
80
157
        moved_path = self.add_suffix(target, ".moved")
86
163
            % filename)
87
164
        return "skip"
88
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
 
89
215
    def finalize(self):
90
 
        if not self.ignore_zero:
91
 
            print "%d conflicts encountered.\n" % self.conflicts
92
 
            
93
 
class SourceFile(object):
94
 
    def __init__(self, path, id, present=None, isdir=None):
95
 
        self.path = path
96
 
        self.id = id
97
 
        self.present = present
98
 
        self.isdir = isdir
99
 
        self.interesting = True
100
 
 
101
 
    def __repr__(self):
102
 
        return "SourceFile(%s, %s)" % (self.path, self.id)
103
 
 
104
 
def get_tree(treespec, temp_root, label):
 
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
def _get_tree(treespec, local_branch=None):
105
223
    location, revno = treespec
106
 
    branch = find_branch(location)
 
224
    branch = Branch.open_containing(location)[0]
107
225
    if revno is None:
108
 
        base_tree = branch.working_tree()
 
226
        revision = None
109
227
    elif revno == -1:
110
 
        base_tree = branch.basis_tree()
111
 
    else:
112
 
        base_tree = branch.revision_tree(branch.lookup_revision(revno))
113
 
    temp_path = os.path.join(temp_root, label)
114
 
    os.mkdir(temp_path)
115
 
    return branch, MergeTree(base_tree, temp_path)
116
 
 
117
 
 
118
 
def abspath(tree, file_id):
119
 
    path = tree.inventory.id2path(file_id)
120
 
    if path == "":
121
 
        return "./."
122
 
    return "./" + path
123
 
 
124
 
def file_exists(tree, file_id):
125
 
    return tree.has_filename(tree.id2path(file_id))
126
 
    
127
 
def inventory_map(tree):
128
 
    inventory = {}
129
 
    for file_id in tree.inventory:
130
 
        path = abspath(tree, file_id)
131
 
        inventory[path] = SourceFile(path, file_id)
132
 
    return inventory
133
 
 
134
 
 
135
 
class MergeTree(object):
136
 
    def __init__(self, tree, tempdir):
 
228
        revision = branch.last_revision()
 
229
    else:
 
230
        revision = branch.get_rev_id(revno)
 
231
        if revision is None:
 
232
            revision = NULL_REVISION
 
233
    return branch, _get_revid_tree(branch, revision, local_branch)
 
234
 
 
235
 
 
236
def _get_revid_tree(branch, revision, local_branch):
 
237
    if revision is None:
 
238
        base_tree = branch.bzrdir.open_workingtree()
 
239
    else:
 
240
        if local_branch is not None:
 
241
            if local_branch.base != branch.base:
 
242
                greedy_fetch(local_branch, branch, revision)
 
243
            base_tree = local_branch.repository.revision_tree(revision)
 
244
        else:
 
245
            base_tree = branch.repository.revision_tree(revision)
 
246
    return base_tree
 
247
 
 
248
 
 
249
def transform_tree(from_tree, to_tree, interesting_ids=None):
 
250
    merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
 
251
                interesting_ids=interesting_ids)
 
252
 
 
253
 
 
254
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
 
255
                backup_files=False, 
 
256
                merge_type=ApplyMerge3, 
 
257
                interesting_ids=None, 
 
258
                show_base=False, 
 
259
                reprocess=False, 
 
260
                other_rev_id=None,
 
261
                interesting_files=None,
 
262
                this_tree=None):
 
263
    """Primary interface for merging. 
 
264
 
 
265
        typical use is probably 
 
266
        'merge_inner(branch, branch.get_revision_tree(other_revision),
 
267
                     branch.get_revision_tree(base_revision))'
 
268
        """
 
269
    if this_tree is None:
 
270
        this_tree = this_branch.bzrdir.open_workingtree()
 
271
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree)
 
272
    merger.backup_files = backup_files
 
273
    merger.merge_type = merge_type
 
274
    merger.interesting_ids = interesting_ids
 
275
    if interesting_files:
 
276
        assert not interesting_ids, ('Only supply interesting_ids'
 
277
                                     ' or interesting_files')
 
278
        merger._set_interesting_files(interesting_files)
 
279
    merger.show_base = show_base 
 
280
    merger.reprocess = reprocess
 
281
    merger.conflict_handler = _MergeConflictHandler(merger.this_tree, 
 
282
                                                    base_tree, other_tree,
 
283
                                                    ignore_zero=ignore_zero)
 
284
    merger.other_rev_id = other_rev_id
 
285
    merger.other_basis = other_rev_id
 
286
    return merger.do_merge()
 
287
 
 
288
 
 
289
class Merger(object):
 
290
    def __init__(self, this_branch, other_tree=None, base_tree=None, this_tree=None):
137
291
        object.__init__(self)
138
 
        if hasattr(tree, "basedir"):
139
 
            self.root = tree.basedir
140
 
        else:
141
 
            self.root = None
142
 
        self.inventory = inventory_map(tree)
143
 
        self.tree = tree
144
 
        self.tempdir = tempdir
145
 
        os.mkdir(os.path.join(self.tempdir, "texts"))
146
 
        self.cached = {}
147
 
 
148
 
    def readonly_path(self, id):
149
 
        if id not in self.tree:
150
 
            return None
151
 
        if self.root is not None:
152
 
            return self.tree.abspath(self.tree.id2path(id))
153
 
        else:
154
 
            if self.tree.inventory[id].kind in ("directory", "root_directory"):
155
 
                return self.tempdir
156
 
            if not self.cached.has_key(id):
157
 
                path = os.path.join(self.tempdir, "texts", id)
158
 
                outfile = file(path, "wb")
159
 
                outfile.write(self.tree.get_file(id).read())
160
 
                assert(os.path.exists(path))
161
 
                self.cached[id] = path
162
 
            return self.cached[id]
163
 
 
164
 
 
165
 
 
166
 
def merge(other_revision, base_revision,
167
 
          check_clean=True, ignore_zero=False,
168
 
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
169
 
          file_list=None):
170
 
    """Merge changes into a tree.
171
 
 
172
 
    base_revision
173
 
        Base for three-way merge.
174
 
    other_revision
175
 
        Other revision for three-way merge.
176
 
    this_dir
177
 
        Directory to merge changes into; '.' by default.
178
 
    check_clean
179
 
        If true, this_dir must have no uncommitted changes before the
180
 
        merge begins.
181
 
    """
182
 
    tempdir = tempfile.mkdtemp(prefix="bzr-")
183
 
    try:
184
 
        if this_dir is None:
185
 
            this_dir = '.'
186
 
        this_branch = find_branch(this_dir)
 
292
        assert this_tree is not None, "this_tree is required"
 
293
        self.this_branch = this_branch
 
294
        self.this_basis = this_branch.last_revision()
 
295
        self.this_rev_id = None
 
296
        self.this_tree = this_tree
 
297
        self.this_revision_tree = None
 
298
        self.this_basis_tree = None
 
299
        self.other_tree = other_tree
 
300
        self.base_tree = base_tree
 
301
        self.ignore_zero = False
 
302
        self.backup_files = False
 
303
        self.interesting_ids = None
 
304
        self.show_base = False
 
305
        self.reprocess = False
 
306
        self.conflict_handler = _MergeConflictHandler(self.this_tree, 
 
307
                                                      base_tree, other_tree)
 
308
 
 
309
    def revision_tree(self, revision_id):
 
310
        return self.this_branch.repository.revision_tree(revision_id)
 
311
 
 
312
    def ensure_revision_trees(self):
 
313
        if self.this_revision_tree is None:
 
314
            self.this_basis_tree = self.this_branch.repository.revision_tree(
 
315
                self.this_basis)
 
316
            if self.this_basis == self.this_rev_id:
 
317
                self.this_revision_tree = self.this_basis_tree
 
318
 
 
319
        if self.other_rev_id is None:
 
320
            other_basis_tree = self.revision_tree(self.other_basis)
 
321
            changes = compare_trees(self.other_tree, other_basis_tree)
 
322
            if changes.has_changed():
 
323
                raise WorkingTreeNotRevision(self.this_tree)
 
324
            other_rev_id = other_basis
 
325
            self.other_tree = other_basis_tree
 
326
 
 
327
    def file_revisions(self, file_id):
 
328
        self.ensure_revision_trees()
 
329
        def get_id(tree, file_id):
 
330
            revision_id = tree.inventory[file_id].revision
 
331
            assert revision_id is not None
 
332
            return revision_id
 
333
        if self.this_rev_id is None:
 
334
            if self.this_basis_tree.get_file_sha1(file_id) != \
 
335
                self.this_tree.get_file_sha1(file_id):
 
336
                raise WorkingTreeNotRevision(self.this_tree)
 
337
 
 
338
        trees = (self.this_basis_tree, self.other_tree)
 
339
        return [get_id(tree, file_id) for tree in trees]
 
340
 
 
341
    def merge_factory(self, file_id, base, other):
 
342
        if self.merge_type.history_based:
 
343
            if self.show_base is True:
 
344
                raise BzrError("Cannot show base for hisory-based merges")
 
345
            if self.reprocess is True:
 
346
                raise BzrError("Cannot reprocess history-based merges")
 
347
                
 
348
            t_revid, o_revid = self.file_revisions(file_id)
 
349
            weave = self.this_basis_tree.get_weave(file_id)
 
350
            contents_change = self.merge_type(weave, t_revid, o_revid)
 
351
        else:
 
352
            if self.show_base is True or self.reprocess is True:
 
353
                contents_change = self.merge_type(file_id, base, other, 
 
354
                                                  show_base=self.show_base, 
 
355
                                                  reprocess=self.reprocess)
 
356
            else:
 
357
                contents_change = self.merge_type(file_id, base, other)
 
358
        if self.backup_files:
 
359
            contents_change = BackupBeforeChange(contents_change)
 
360
        return contents_change
 
361
 
 
362
    def check_basis(self, check_clean):
 
363
        if self.this_basis is None:
 
364
            raise BzrCommandError("This branch has no commits")
187
365
        if check_clean:
188
 
            changes = compare_trees(this_branch.working_tree(), 
189
 
                                    this_branch.basis_tree(), False)
190
 
            if changes.has_changed():
 
366
            self.compare_basis()
 
367
            if self.this_basis != self.this_rev_id:
191
368
                raise BzrCommandError("Working tree has uncommitted changes.")
192
 
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
 
369
 
 
370
    def compare_basis(self):
 
371
        changes = compare_trees(self.this_tree, 
 
372
                                self.this_tree.basis_tree(), False)
 
373
        if not changes.has_changed():
 
374
            self.this_rev_id = self.this_basis
 
375
 
 
376
    def set_interesting_files(self, file_list):
 
377
        try:
 
378
            self._set_interesting_files(file_list)
 
379
        except NotVersionedError, e:
 
380
            raise BzrCommandError("%s is not a source file in any"
 
381
                                      " tree." % e.path)
 
382
 
 
383
    def _set_interesting_files(self, file_list):
 
384
        """Set the list of interesting ids from a list of files."""
 
385
        if file_list is None:
 
386
            self.interesting_ids = None
 
387
            return
 
388
 
 
389
        interesting_ids = set()
 
390
        for path in file_list:
 
391
            found_id = False
 
392
            for tree in (self.this_tree, self.base_tree, self.other_tree):
 
393
                file_id = tree.inventory.path2id(path)
 
394
                if file_id is not None:
 
395
                    interesting_ids.add(file_id)
 
396
                    found_id = True
 
397
            if not found_id:
 
398
                raise NotVersionedError(path=path)
 
399
        self.interesting_ids = interesting_ids
 
400
 
 
401
    def set_pending(self):
 
402
        if not self.base_is_ancestor:
 
403
            return
 
404
        if self.other_rev_id is None:
 
405
            return
 
406
        ancestry = self.this_branch.repository.get_ancestry(self.this_basis)
 
407
        if self.other_rev_id in ancestry:
 
408
            return
 
409
        self.this_tree.add_pending_merge(self.other_rev_id)
 
410
 
 
411
    def set_other(self, other_revision):
 
412
        other_branch, self.other_tree = _get_tree(other_revision, 
 
413
                                                  self.this_branch)
 
414
        if other_revision[1] == -1:
 
415
            self.other_rev_id = other_branch.last_revision()
 
416
            if self.other_rev_id is None:
 
417
                raise NoCommits(other_branch)
 
418
            self.other_basis = self.other_rev_id
 
419
        elif other_revision[1] is not None:
 
420
            self.other_rev_id = other_branch.get_rev_id(other_revision[1])
 
421
            self.other_basis = self.other_rev_id
 
422
        else:
 
423
            self.other_rev_id = None
 
424
            self.other_basis = other_branch.last_revision()
 
425
            if self.other_basis is None:
 
426
                raise NoCommits(other_branch)
 
427
        if other_branch.base != self.this_branch.base:
 
428
            fetch(from_branch=other_branch, to_branch=self.this_branch, 
 
429
                  last_revision=self.other_basis)
 
430
 
 
431
    def set_base(self, base_revision):
 
432
        mutter("doing merge() with no base_revision specified")
193
433
        if base_revision == [None, None]:
194
 
            if other_revision[1] == -1:
195
 
                o_revno = None
196
 
            else:
197
 
                o_revno = other_revision[1]
198
 
            base_revno = this_branch.common_ancestor(other_branch, 
199
 
                                                     other_revno=o_revno)[0]
200
 
            if base_revno is None:
 
434
            try:
 
435
                self.base_rev_id = common_ancestor(self.this_basis, 
 
436
                                                   self.other_basis, 
 
437
                                                   self.this_branch.repository)
 
438
            except NoCommonAncestor:
201
439
                raise UnrelatedBranches()
202
 
            base_revision = ['.', base_revno]
203
 
        base_branch, base_tree = get_tree(base_revision, tempdir, "base")
204
 
        if file_list is None:
205
 
            interesting_ids = None
206
 
        else:
207
 
            interesting_ids = set()
208
 
            this_tree = this_branch.working_tree()
209
 
            for fname in file_list:
210
 
                path = this_branch.relpath(fname)
211
 
                found_id = False
212
 
                for tree in (this_tree, base_tree.tree, other_tree.tree):
213
 
                    file_id = tree.inventory.path2id(path)
214
 
                    if file_id is not None:
215
 
                        interesting_ids.add(file_id)
216
 
                        found_id = True
217
 
                if not found_id:
218
 
                    raise BzrCommandError("%s is not a source file in any"
219
 
                                          " tree." % fname)
220
 
        merge_inner(this_branch, other_tree, base_tree, tempdir, 
221
 
                    ignore_zero=ignore_zero, backup_files=backup_files, 
222
 
                    merge_type=merge_type, interesting_ids=interesting_ids)
223
 
    finally:
224
 
        shutil.rmtree(tempdir)
225
 
 
226
 
 
227
 
def set_interesting(inventory_a, inventory_b, interesting_ids):
228
 
    """Mark files whose ids are in interesting_ids as interesting
229
 
    """
230
 
    for inventory in (inventory_a, inventory_b):
231
 
        for path, source_file in inventory.iteritems():
232
 
             source_file.interesting = source_file.id in interesting_ids
233
 
 
234
 
 
235
 
def set_optimized(tree_a, tree_b, inventory_a, inventory_b):
236
 
    """Mark files that have changed texts as interesting
237
 
    """
238
 
    for file_id in tree_a.tree.inventory:
239
 
        if file_id not in tree_b.tree.inventory:
240
 
            continue
241
 
        entry_a = tree_a.tree.inventory[file_id]
242
 
        entry_b = tree_b.tree.inventory[file_id]
243
 
        if (entry_a.kind, entry_b.kind) != ("file", "file"):
244
 
            continue
245
 
        if None in (entry_a.text_id, entry_b.text_id):
246
 
            continue
247
 
        if entry_a.text_id != entry_b.text_id:
248
 
            continue
249
 
        inventory_a[abspath(tree_a.tree, file_id)].interesting = False
250
 
        inventory_b[abspath(tree_b.tree, file_id)].interesting = False
251
 
 
252
 
 
253
 
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
254
 
                            interesting_ids=None):
255
 
    """Generate a changeset, with preprocessing to select interesting files.
256
 
    using the text_id to mark really-changed files.
257
 
    This permits blazing comparisons when text_ids are present.  It also
258
 
    disables metadata comparison for files with identical texts.
259
 
    """ 
260
 
    if interesting_ids is None:
261
 
        set_optimized(tree_a, tree_b, inventory_a, inventory_b)
262
 
    else:
263
 
        set_interesting(inventory_a, inventory_b, interesting_ids)
264
 
    cset =  generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
265
 
    for entry in cset.entries.itervalues():
266
 
        entry.metadata_change = None
267
 
    return cset
268
 
 
269
 
 
270
 
def merge_inner(this_branch, other_tree, base_tree, tempdir, 
271
 
                ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
272
 
                interesting_ids=None):
273
 
 
274
 
    def merge_factory(base_file, other_file):
275
 
        contents_change = merge_type(base_file, other_file)
276
 
        if backup_files:
277
 
            contents_change = BackupBeforeChange(contents_change)
278
 
        return contents_change
279
 
    
280
 
    def generate_cset(tree_a, tree_b, inventory_a, inventory_b):
281
 
        return generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
282
 
                                       interesting_ids)
283
 
 
284
 
    this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
285
 
 
286
 
    def get_inventory(tree):
287
 
        return tree.inventory
288
 
 
289
 
    inv_changes = merge_flex(this_tree, base_tree, other_tree,
290
 
                             generate_cset, get_inventory,
291
 
                             MergeConflictHandler(base_tree.root,
292
 
                                                  ignore_zero=ignore_zero),
293
 
                             merge_factory=merge_factory)
294
 
 
295
 
    adjust_ids = []
296
 
    for id, path in inv_changes.iteritems():
297
 
        if path is not None:
298
 
            if path == '.':
299
 
                path = ''
300
 
            else:
301
 
                assert path.startswith('./')
302
 
            path = path[2:]
303
 
        adjust_ids.append((path, id))
304
 
    this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
305
 
 
306
 
 
307
 
def regen_inventory(this_branch, root, new_entries):
308
 
    old_entries = this_branch.read_working_inventory()
309
 
    new_inventory = {}
310
 
    by_path = {}
311
 
    for file_id in old_entries:
312
 
        entry = old_entries[file_id]
313
 
        path = old_entries.id2path(file_id)
314
 
        new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
315
 
        by_path[path] = file_id
316
 
    
317
 
    deletions = 0
318
 
    insertions = 0
319
 
    new_path_list = []
320
 
    for path, file_id in new_entries:
321
 
        if path is None:
322
 
            del new_inventory[file_id]
323
 
            deletions += 1
324
 
        else:
325
 
            new_path_list.append((path, file_id))
326
 
            if file_id not in old_entries:
327
 
                insertions += 1
328
 
    # Ensure no file is added before its parent
329
 
    new_path_list.sort()
330
 
    for path, file_id in new_path_list:
331
 
        if path == '':
332
 
            parent = None
333
 
        else:
334
 
            parent = by_path[os.path.dirname(path)]
335
 
        kind = bzrlib.osutils.file_kind(os.path.join(root, path))
336
 
        new_inventory[file_id] = (path, file_id, parent, kind)
337
 
        by_path[path] = file_id 
338
 
 
339
 
    # Get a list in insertion order
340
 
    new_inventory_list = new_inventory.values()
341
 
    mutter ("""Inventory regeneration:
342
 
old length: %i insertions: %i deletions: %i new_length: %i"""\
343
 
        % (len(old_entries), insertions, deletions, len(new_inventory_list)))
344
 
    assert len(new_inventory_list) == len(old_entries) + insertions - deletions
345
 
    new_inventory_list.sort()
346
 
    return new_inventory_list
 
440
            self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
 
441
                                            None)
 
442
            self.base_is_ancestor = True
 
443
        else:
 
444
            base_branch, self.base_tree = _get_tree(base_revision)
 
445
            if base_revision[1] == -1:
 
446
                self.base_rev_id = base_branch.last_revision()
 
447
            elif base_revision[1] is None:
 
448
                self.base_rev_id = None
 
449
            else:
 
450
                self.base_rev_id = base_branch.get_rev_id(base_revision[1])
 
451
            fetch(from_branch=base_branch, to_branch=self.this_branch)
 
452
            self.base_is_ancestor = is_ancestor(self.this_basis, 
 
453
                                                self.base_rev_id,
 
454
                                                self.this_branch)
 
455
 
 
456
    def do_merge(self):
 
457
        def get_inventory(tree):
 
458
            return tree.inventory
 
459
        
 
460
        inv_changes = merge_flex(self.this_tree, self.base_tree, 
 
461
                                 self.other_tree,
 
462
                                 generate_changeset, get_inventory,
 
463
                                 self.conflict_handler,
 
464
                                 merge_factory=self.merge_factory, 
 
465
                                 interesting_ids=self.interesting_ids)
 
466
 
 
467
        adjust_ids = []
 
468
        for id, path in inv_changes.iteritems():
 
469
            if path is not None:
 
470
                if path == u'.':
 
471
                    path = u''
 
472
                else:
 
473
                    assert path.startswith('.' + '/') or path.startswith('.' + '\\'), "path is %s" % path
 
474
                path = path[2:]
 
475
            adjust_ids.append((path, id))
 
476
        if len(adjust_ids) > 0:
 
477
            self.this_tree.set_inventory(self.regen_inventory(adjust_ids))
 
478
        conflicts = self.conflict_handler.conflicts
 
479
        self.conflict_handler.finalize()
 
480
        return conflicts
 
481
 
 
482
    def regen_inventory(self, new_entries):
 
483
        old_entries = self.this_tree.read_working_inventory()
 
484
        new_inventory = {}
 
485
        by_path = {}
 
486
        new_entries_map = {} 
 
487
        for path, file_id in new_entries:
 
488
            if path is None:
 
489
                continue
 
490
            new_entries_map[file_id] = path
 
491
 
 
492
        def id2path(file_id):
 
493
            path = new_entries_map.get(file_id)
 
494
            if path is not None:
 
495
                return path
 
496
            entry = old_entries[file_id]
 
497
            if entry.parent_id is None:
 
498
                return entry.name
 
499
            return pathjoin(id2path(entry.parent_id), entry.name)
 
500
            
 
501
        for file_id in old_entries:
 
502
            entry = old_entries[file_id]
 
503
            path = id2path(file_id)
 
504
            new_inventory[file_id] = (path, file_id, entry.parent_id, 
 
505
                                      entry.kind)
 
506
            by_path[path] = file_id
 
507
        
 
508
        deletions = 0
 
509
        insertions = 0
 
510
        new_path_list = []
 
511
        for path, file_id in new_entries:
 
512
            if path is None:
 
513
                del new_inventory[file_id]
 
514
                deletions += 1
 
515
            else:
 
516
                new_path_list.append((path, file_id))
 
517
                if file_id not in old_entries:
 
518
                    insertions += 1
 
519
        # Ensure no file is added before its parent
 
520
        new_path_list.sort()
 
521
        for path, file_id in new_path_list:
 
522
            if path == '':
 
523
                parent = None
 
524
            else:
 
525
                parent = by_path[os.path.dirname(path)]
 
526
            abspath = pathjoin(self.this_tree.basedir, path)
 
527
            kind = bzrlib.osutils.file_kind(abspath)
 
528
            new_inventory[file_id] = (path, file_id, parent, kind)
 
529
            by_path[path] = file_id 
 
530
 
 
531
        # Get a list in insertion order
 
532
        new_inventory_list = new_inventory.values()
 
533
        mutter ("""Inventory regeneration:
 
534
    old length: %i insertions: %i deletions: %i new_length: %i"""\
 
535
            % (len(old_entries), insertions, deletions, 
 
536
               len(new_inventory_list)))
 
537
        assert len(new_inventory_list) == len(old_entries) + insertions\
 
538
            - deletions
 
539
        new_inventory_list.sort()
 
540
        return new_inventory_list
 
541
 
347
542
 
348
543
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
349
 
                     "diff3": (Diff3Merge,  "Merge using external diff3")
 
544
                     "diff3": (Diff3Merge,  "Merge using external diff3"),
 
545
                     'weave': (WeaveMerge, "Weave-based merge")
350
546
              }
351