← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Martin Pool
  • Date: 2005-08-03 14:16:04 UTC
  • Revision ID: mbp@sourcefrog.net-20050803141604-b69a03512e094f37
- better summary help screen

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
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
 
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
 
5
import bzrlib.osutils
 
6
from bzrlib.errors import BzrCommandError
 
7
from bzrlib.delta import compare_trees
 
8
from trace import mutter, warning
 
9
import os.path
 
10
import tempfile
19
11
import shutil
20
12
import errno
21
13
 
22
 
import bzrlib.osutils
23
 
import bzrlib.revision
24
 
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
25
 
from bzrlib.merge_core import WeaveMerge
26
 
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
27
 
from bzrlib.changeset import Inventory, Diff3Merge, ReplaceContents
28
 
from bzrlib.branch import Branch
29
 
from bzrlib.errors import (BzrCommandError,
30
 
                           UnrelatedBranches,
31
 
                           NoCommonAncestor,
32
 
                           NoCommits,
33
 
                           WorkingTreeNotRevision,
34
 
                           NotBranchError,
35
 
                           NotVersionedError,
36
 
                           BzrError)
37
 
from bzrlib.delta import compare_trees
38
 
from bzrlib.trace import mutter, warning, note
39
 
from bzrlib.fetch import greedy_fetch, fetch
40
 
from bzrlib.revision import is_ancestor, NULL_REVISION
41
 
from bzrlib.osutils import rename, pathjoin
42
 
from bzrlib.revision import common_ancestor, MultipleRevisionSources
43
 
from bzrlib.errors import NoSuchRevision
44
 
 
45
 
# TODO: Report back as changes are merged in
46
 
 
47
 
# TODO: build_working_dir can be built on something simpler than merge()
48
 
 
49
 
# FIXME: merge() parameters seem oriented towards the command line
50
 
# NOTABUG: merge is a helper for commandline functions.  merge_inner is the
51
 
#          the core functionality.
52
 
 
53
 
# comments from abentley on irc: merge happens in two stages, each
54
 
# of which generates a changeset object
55
 
 
56
 
# stage 1: generate OLD->OTHER,
57
 
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
 
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
 
58
20
 
59
21
class MergeConflictHandler(ExceptionConflictHandler):
60
 
    """Handle conflicts encountered while merging.
61
 
 
62
 
    This subclasses ExceptionConflictHandler, so that any types of
63
 
    conflict that are not explicitly handled cause an exception and
64
 
    terminate the merge.
65
 
    """
66
 
    def __init__(self, this_tree, base_tree, other_tree, ignore_zero=False):
67
 
        ExceptionConflictHandler.__init__(self)
 
22
    """Handle conflicts encountered while merging"""
 
23
    def __init__(self, dir, ignore_zero=False):
 
24
        ExceptionConflictHandler.__init__(self, dir)
68
25
        self.conflicts = 0
69
26
        self.ignore_zero = ignore_zero
70
 
        self.this_tree = this_tree
71
 
        self.base_tree = base_tree
72
 
        self.other_tree = other_tree
73
27
 
74
28
    def copy(self, source, dest):
75
29
        """Copy the text and mode of a file
82
36
            d_file.write(line)
83
37
        os.chmod(dest, 0777 & os.stat(source).st_mode)
84
38
 
85
 
    def dump(self, lines, dest):
86
 
        """Copy the text and mode of a file
87
 
        :param source: The path of the file to copy
88
 
        :param dest: The distination file to create
89
 
        """
90
 
        d_file = file(dest, "wb")
91
 
        for line in lines:
92
 
            d_file.write(line)
93
 
 
94
 
    def add_suffix(self, name, suffix, last_new_name=None, fix_inventory=True):
 
39
    def add_suffix(self, name, suffix, last_new_name=None):
95
40
        """Rename a file to append a suffix.  If the new name exists, the
96
41
        suffix is added repeatedly until a non-existant name is found
97
42
 
103
48
            last_new_name = name
104
49
        new_name = last_new_name+suffix
105
50
        try:
106
 
            rename(name, new_name)
107
 
            if fix_inventory is True:
108
 
                try:
109
 
                    relpath = self.this_tree.relpath(name)
110
 
                except NotBranchError:
111
 
                    relpath = None
112
 
                if relpath is not None:
113
 
                    file_id = self.this_tree.path2id(relpath)
114
 
                    if file_id is not None:
115
 
                        new_path = self.this_tree.relpath(new_name)
116
 
                        rename(new_name, name)
117
 
                        self.this_tree.rename_one(relpath, new_path)
118
 
                        assert self.this_tree.id2path(file_id) == new_path
 
51
            os.rename(name, new_name)
 
52
            return new_name
119
53
        except OSError, e:
120
54
            if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
121
55
                raise
122
 
            return self.add_suffix(name, suffix, last_new_name=new_name, 
123
 
                                   fix_inventory=fix_inventory)
124
 
        return new_name
 
56
            return self.add_suffix(name, suffix, last_new_name=new_name)
125
57
 
126
58
    def conflict(self, text):
127
59
        warning(text)
128
60
        self.conflicts += 1
129
61
        
130
62
 
131
 
    def merge_conflict(self, new_file, this_path, base_lines, other_lines):
 
63
    def merge_conflict(self, new_file, this_path, base_path, other_path):
132
64
        """
133
65
        Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER.  The
134
66
        main file will be a version with diff3 conflicts.
137
69
        :param base_path: Path to the file text for the BASE tree
138
70
        :param other_path: Path to the file text for the OTHER tree
139
71
        """
140
 
        self.add_suffix(this_path, ".THIS", fix_inventory=False)
141
 
        self.dump(base_lines, this_path+".BASE")
142
 
        self.dump(other_lines, this_path+".OTHER")
143
 
        rename(new_file, this_path)
 
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)
144
76
        self.conflict("Diff3 conflict encountered in %s" % this_path)
145
77
 
146
 
    def weave_merge_conflict(self, filename, weave, other_i, out_file):
147
 
        """
148
 
        Handle weave conflicts by producing a .THIS, and .OTHER.  The
149
 
        main file will be a version with diff3-style conflicts.
150
 
        """
151
 
        self.add_suffix(filename, ".THIS", fix_inventory=False)
152
 
        out_file.commit()
153
 
        self.dump(weave.get_iter(other_i), filename+".OTHER")
154
 
        self.conflict("Text conflict encountered in %s" % filename)
155
 
 
156
 
    def new_contents_conflict(self, filename, other_contents):
157
 
        """Conflicting contents for newly added file."""
158
 
        other_contents(filename + ".OTHER", self, False)
159
 
        self.conflict("Conflict in newly added file %s" % filename)
160
 
    
161
 
 
162
78
    def target_exists(self, entry, target, old_path):
163
79
        """Handle the case when the target file or dir exists"""
164
80
        moved_path = self.add_suffix(target, ".moved")
170
86
            % filename)
171
87
        return "skip"
172
88
 
173
 
    def rem_contents_conflict(self, filename, this_contents, base_contents):
174
 
        base_contents(filename+".BASE", self)
175
 
        this_contents(filename+".THIS", self)
176
 
        self.conflict("Other branch deleted locally modified file %s" %
177
 
                      filename)
178
 
        return ReplaceContents(this_contents, None)
179
 
 
180
 
    def abs_this_path(self, file_id):
181
 
        """Return the absolute path for a file_id in the this tree."""
182
 
        return self.this_tree.id2abspath(file_id)
183
 
 
184
 
    def add_missing_parents(self, file_id, tree):
185
 
        """If some of the parents for file_id are missing, add them."""
186
 
        entry = tree.inventory[file_id]
187
 
        if entry.parent_id not in self.this_tree:
188
 
            return self.create_all_missing(entry.parent_id, tree)
189
 
        else:
190
 
            return self.abs_this_path(entry.parent_id)
191
 
 
192
 
    def create_all_missing(self, file_id, tree):
193
 
        """Add contents for a file_id and all its parents to a tree."""
194
 
        entry = tree.inventory[file_id]
195
 
        if entry.parent_id is not None and entry.parent_id not in self.this_tree:
196
 
            abspath = self.create_all_missing(entry.parent_id, tree)
197
 
        else:
198
 
            abspath = self.abs_this_path(entry.parent_id)
199
 
        entry_path = pathjoin(abspath, entry.name)
200
 
        if not os.path.isdir(entry_path):
201
 
            self.create(file_id, entry_path, tree)
202
 
        return entry_path
203
 
 
204
 
    def create(self, file_id, path, tree):
205
 
        """Uses tree data to create a filesystem object for the file_id"""
206
 
        from changeset import get_contents
207
 
        get_contents(tree, file_id)(path, self)
208
 
 
209
 
    def missing_for_merge(self, file_id, other_path):
210
 
        """The file_id doesn't exist in THIS, but does in OTHER and BASE"""
211
 
        self.conflict("Other branch modified locally deleted file %s" %
212
 
                      other_path)
213
 
        parent_dir = self.add_missing_parents(file_id, self.other_tree)
214
 
        stem = pathjoin(parent_dir, os.path.basename(other_path))
215
 
        self.create(file_id, stem+".OTHER", self.other_tree)
216
 
        self.create(file_id, stem+".BASE", self.base_tree)
217
 
 
218
 
    def threeway_contents_conflict(filename, this_contents, base_contents,
219
 
                                   other_contents):
220
 
        self.conflict("Three-way conflict merging %s" % filename)
221
 
 
222
89
    def finalize(self):
223
 
        if self.conflicts == 0:
224
 
            if not self.ignore_zero:
225
 
                note("All changes applied successfully.")
226
 
        else:
227
 
            note("%d conflicts encountered." % self.conflicts)
 
90
        if not self.ignore_zero:
 
91
            print "%d conflicts encountered.\n" % self.conflicts
228
92
            
229
 
def get_tree(treespec, local_branch=None):
 
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):
230
105
    location, revno = treespec
231
 
    branch = Branch.open_containing(location)[0]
 
106
    branch = find_branch(location)
232
107
    if revno is None:
233
 
        revision = None
 
108
        base_tree = branch.working_tree()
234
109
    elif revno == -1:
235
 
        revision = branch.last_revision()
236
 
    else:
237
 
        revision = branch.get_rev_id(revno)
238
 
        if revision is None:
239
 
            revision = NULL_REVISION
240
 
    return branch, get_revid_tree(branch, revision, local_branch)
241
 
 
242
 
def get_revid_tree(branch, revision, local_branch):
243
 
    if revision is None:
244
 
        base_tree = branch.working_tree()
245
 
    else:
246
 
        if local_branch is not None:
247
 
            greedy_fetch(local_branch, branch, revision)
248
 
            base_tree = local_branch.revision_tree(revision)
249
 
        else:
250
 
            base_tree = branch.revision_tree(revision)
251
 
    return base_tree
252
 
 
 
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
253
123
 
254
124
def file_exists(tree, file_id):
255
125
    return tree.has_filename(tree.id2path(file_id))
256
126
    
257
 
 
258
 
def build_working_dir(to_dir):
259
 
    """Build a working directory in an empty directory.
260
 
 
261
 
    to_dir is a directory containing branch metadata but no working files,
262
 
    typically constructed by cloning an existing branch. 
263
 
 
264
 
    This is split out as a special idiomatic case of merge.  It could
265
 
    eventually be done by just building the tree directly calling into 
266
 
    lower-level code (e.g. constructing a changeset).
267
 
    """
268
 
    # RBC 20051019 is this not just 'export' ?
269
 
    # AB Well, export doesn't take care of inventory...
270
 
    this_branch = Branch.open_containing(to_dir)[0]
271
 
    transform_tree(this_branch.working_tree(), this_branch.basis_tree())
272
 
 
273
 
 
274
 
def transform_tree(from_tree, to_tree, interesting_ids=None):
275
 
    merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
276
 
                interesting_ids=interesting_ids)
 
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):
 
137
        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
 
277
164
 
278
165
 
279
166
def merge(other_revision, base_revision,
280
167
          check_clean=True, ignore_zero=False,
281
168
          this_dir=None, backup_files=False, merge_type=ApplyMerge3,
282
 
          file_list=None, show_base=False, reprocess=False):
 
169
          file_list=None):
283
170
    """Merge changes into a tree.
284
171
 
285
172
    base_revision
286
 
        list(path, revno) Base for three-way merge.  
287
 
        If [None, None] then a base will be automatically determined.
 
173
        Base for three-way merge.
288
174
    other_revision
289
 
        list(path, revno) Other revision for three-way merge.
 
175
        Other revision for three-way merge.
290
176
    this_dir
291
177
        Directory to merge changes into; '.' by default.
292
178
    check_clean
293
179
        If true, this_dir must have no uncommitted changes before the
294
180
        merge begins.
295
 
    ignore_zero - If true, suppress the "zero conflicts" message when 
296
 
        there are no conflicts; should be set when doing something we expect
297
 
        to complete perfectly.
298
 
    file_list - If supplied, merge only changes to selected files.
299
 
 
300
 
    All available ancestors of other_revision and base_revision are
301
 
    automatically pulled into the branch.
302
 
 
303
 
    The revno may be -1 to indicate the last revision on the branch, which is
304
 
    the typical case.
305
 
 
306
 
    This function is intended for use from the command line; programmatic
307
 
    clients might prefer to call merge_inner(), which has less magic behavior.
308
181
    """
309
 
    if this_dir is None:
310
 
        this_dir = u'.'
311
 
    this_branch = Branch.open_containing(this_dir)[0]
312
 
    if show_base and not merge_type is ApplyMerge3:
313
 
        raise BzrCommandError("Show-base is not supported for this merge"
314
 
                              " type. %s" % merge_type)
315
 
    if reprocess and not merge_type is ApplyMerge3:
316
 
        raise BzrCommandError("Reprocess is not supported for this merge"
317
 
                              " type. %s" % merge_type)
318
 
    if reprocess and show_base:
319
 
        raise BzrCommandError("Cannot reprocess and show base.")
320
 
    merger = Merger(this_branch)
321
 
    merger.check_basis(check_clean)
322
 
    merger.set_other(other_revision)
323
 
    merger.set_base(base_revision)
324
 
    if merger.base_rev_id == merger.other_rev_id:
325
 
        note('Nothing to do.')
326
 
        return 0
327
 
    merger.backup_files = backup_files
328
 
    merger.merge_type = merge_type 
329
 
    merger.set_interesting_files(file_list)
330
 
    merger.show_base = show_base 
331
 
    merger.reprocess = reprocess
332
 
    merger.conflict_handler = MergeConflictHandler(merger.this_tree, 
333
 
                                                   merger.base_tree, 
334
 
                                                   merger.other_tree,
335
 
                                                   ignore_zero=ignore_zero)
336
 
    conflicts = merger.do_merge()
337
 
    merger.set_pending()
338
 
    return conflicts
339
 
 
340
 
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
341
 
                backup_files=False, 
342
 
                merge_type=ApplyMerge3, 
343
 
                interesting_ids=None, 
344
 
                show_base=False, 
345
 
                reprocess=False, 
346
 
                other_rev_id=None,
347
 
                interesting_files=None):
348
 
    """Primary interface for merging. 
349
 
 
350
 
        typical use is probably 
351
 
        'merge_inner(branch, branch.get_revision_tree(other_revision),
352
 
                     branch.get_revision_tree(base_revision))'
353
 
        """
354
 
    merger = Merger(this_branch, other_tree, base_tree)
355
 
    merger.backup_files = backup_files
356
 
    merger.merge_type = merge_type
357
 
    merger.interesting_ids = interesting_ids
358
 
    if interesting_files:
359
 
        assert not interesting_ids, ('Only supply interesting_ids'
360
 
                                     ' or interesting_files')
361
 
        merger._set_interesting_files(interesting_files)
362
 
    merger.show_base = show_base 
363
 
    merger.reprocess = reprocess
364
 
    merger.conflict_handler = MergeConflictHandler(merger.this_tree, base_tree, 
365
 
                                                   other_tree,
366
 
                                                   ignore_zero=ignore_zero)
367
 
    merger.other_rev_id = other_rev_id
368
 
    merger.other_basis = other_rev_id
369
 
    return merger.do_merge()
370
 
 
371
 
 
372
 
class Merger(object):
373
 
    def __init__(self, this_branch, other_tree=None, base_tree=None):
374
 
        object.__init__(self)
375
 
        self.this_branch = this_branch
376
 
        self.this_basis = this_branch.last_revision()
377
 
        self.this_rev_id = None
378
 
        self.this_tree = this_branch.working_tree()
379
 
        self.this_revision_tree = None
380
 
        self.this_basis_tree = None
381
 
        self.other_tree = other_tree
382
 
        self.base_tree = base_tree
383
 
        self.ignore_zero = False
384
 
        self.backup_files = False
385
 
        self.interesting_ids = None
386
 
        self.show_base = False
387
 
        self.reprocess = False
388
 
        self.conflict_handler = MergeConflictHandler(self.this_tree, base_tree, 
389
 
                                                     other_tree)
390
 
 
391
 
    def revision_tree(self, revision_id):
392
 
        return self.this_branch.revision_tree(revision_id)
393
 
 
394
 
    def ensure_revision_trees(self):
395
 
        if self.this_revision_tree is None:
396
 
            self.this_basis_tree = self.this_branch.revision_tree(
397
 
                self.this_basis)
398
 
            if self.this_basis == self.this_rev_id:
399
 
                self.this_revision_tree = self.this_basis_tree
400
 
 
401
 
 
402
 
        if self.other_rev_id is None:
403
 
            other_basis_tree = self.revision_tree(self.other_basis)
404
 
            changes = compare_trees(self.other_tree, other_basis_tree)
 
182
    tempdir = tempfile.mkdtemp(prefix="bzr-")
 
183
    try:
 
184
        if this_dir is None:
 
185
            this_dir = '.'
 
186
        this_branch = find_branch(this_dir)
 
187
        if check_clean:
 
188
            changes = compare_trees(this_branch.working_tree(), 
 
189
                                    this_branch.basis_tree(), False)
405
190
            if changes.has_changed():
406
 
                raise WorkingTreeNotRevision(self.this_tree)
407
 
            other_rev_id = other_basis
408
 
            self.other_tree = other_basis_tree
409
 
 
410
 
 
411
 
    def file_revisions(self, file_id):
412
 
        self.ensure_revision_trees()
413
 
        def get_id(tree, file_id):
414
 
            revision_id = tree.inventory[file_id].revision
415
 
            assert revision_id is not None
416
 
            return revision_id
417
 
        if self.this_rev_id is None:
418
 
            if self.this_basis_tree.get_file_sha1(file_id) != \
419
 
                self.this_tree.get_file_sha1(file_id):
420
 
                raise WorkingTreeNotRevision(self.this_tree)
421
 
 
422
 
        trees = (self.this_basis_tree, self.other_tree)
423
 
        return [get_id(tree, file_id) for tree in trees]
424
 
            
425
 
 
426
 
    def merge_factory(self, file_id, base, other):
427
 
        if self.merge_type.history_based:
428
 
            if self.show_base is True:
429
 
                raise BzrError("Cannot show base for hisory-based merges")
430
 
            if self.reprocess is True:
431
 
                raise BzrError("Cannot reprocess history-based merges")
432
 
                
433
 
            t_revid, o_revid = self.file_revisions(file_id)
434
 
            weave = self.this_basis_tree.get_weave(file_id)
435
 
            contents_change = self.merge_type(weave, t_revid, o_revid)
436
 
        else:
437
 
            if self.show_base is True or self.reprocess is True:
438
 
                contents_change = self.merge_type(file_id, base, other, 
439
 
                                                  show_base=self.show_base, 
440
 
                                                  reprocess=self.reprocess)
441
 
            else:
442
 
                contents_change = self.merge_type(file_id, base, other)
443
 
        if self.backup_files:
444
 
            contents_change = BackupBeforeChange(contents_change)
445
 
        return contents_change
446
 
 
447
 
    def check_basis(self, check_clean):
448
 
        if self.this_basis is None:
449
 
            raise BzrCommandError("This branch has no commits")
450
 
        if check_clean:
451
 
            self.compare_basis()
452
 
            if self.this_basis != self.this_rev_id:
453
191
                raise BzrCommandError("Working tree has uncommitted changes.")
454
 
 
455
 
    def compare_basis(self):
456
 
        changes = compare_trees(self.this_branch.working_tree(), 
457
 
                                self.this_branch.basis_tree(), False)
458
 
        if not changes.has_changed():
459
 
            self.this_rev_id = self.this_basis
460
 
 
461
 
    def set_interesting_files(self, file_list):
462
 
        try:
463
 
            self._set_interesting_files(file_list)
464
 
        except NotVersionedError, e:
465
 
            raise BzrCommandError("%s is not a source file in any"
466
 
                                      " tree." % e.path)
467
 
 
468
 
    def _set_interesting_files(self, file_list):
469
 
        """Set the list of interesting ids from a list of files."""
470
 
        if file_list is None:
471
 
            self.interesting_ids = None
472
 
            return
473
 
 
474
 
        interesting_ids = set()
475
 
        for fname in file_list:
476
 
            path = self.this_tree.relpath(fname)
477
 
            found_id = False
478
 
            for tree in (self.this_tree, self.base_tree, self.other_tree):
479
 
                file_id = tree.inventory.path2id(path)
480
 
                if file_id is not None:
481
 
                    interesting_ids.add(file_id)
482
 
                    found_id = True
483
 
            if not found_id:
484
 
                raise NotVersionedError(path=fname)
485
 
        self.interesting_ids = interesting_ids
486
 
 
487
 
    def set_pending(self):
488
 
        if not self.base_is_ancestor:
489
 
            return
490
 
        if self.other_rev_id is None:
491
 
            return
492
 
        if self.other_rev_id in self.this_branch.get_ancestry(self.this_basis):
493
 
            return
494
 
        self.this_branch.working_tree().add_pending_merge(self.other_rev_id)
495
 
 
496
 
    def set_other(self, other_revision):
497
 
        other_branch, self.other_tree = get_tree(other_revision, 
498
 
                                                 self.this_branch)
499
 
        if other_revision[1] == -1:
500
 
            self.other_rev_id = other_branch.last_revision()
501
 
            if self.other_rev_id is None:
502
 
                raise NoCommits(other_branch)
503
 
            self.other_basis = self.other_rev_id
504
 
        elif other_revision[1] is not None:
505
 
            self.other_rev_id = other_branch.get_rev_id(other_revision[1])
506
 
            self.other_basis = self.other_rev_id
507
 
        else:
508
 
            self.other_rev_id = None
509
 
            self.other_basis = other_branch.last_revision()
510
 
            if self.other_basis is None:
511
 
                raise NoCommits(other_branch)
512
 
        fetch(from_branch=other_branch, to_branch=self.this_branch, 
513
 
              last_revision=self.other_basis)
514
 
 
515
 
    def set_base(self, base_revision):
516
 
        mutter("doing merge() with no base_revision specified")
 
192
        other_branch, other_tree = get_tree(other_revision, tempdir, "other")
517
193
        if base_revision == [None, None]:
518
 
            try:
519
 
                self.base_rev_id = common_ancestor(self.this_basis, 
520
 
                                                   self.other_basis, 
521
 
                                                   self.this_branch)
522
 
            except NoCommonAncestor:
 
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:
523
201
                raise UnrelatedBranches()
524
 
            self.base_tree = get_revid_tree(self.this_branch, self.base_rev_id,
525
 
                                            None)
526
 
            self.base_is_ancestor = True
527
 
        else:
528
 
            base_branch, self.base_tree = get_tree(base_revision)
529
 
            if base_revision[1] == -1:
530
 
                self.base_rev_id = base_branch.last_revision()
531
 
            elif base_revision[1] is None:
532
 
                self.base_rev_id = None
533
 
            else:
534
 
                self.base_rev_id = base_branch.get_rev_id(base_revision[1])
535
 
            fetch(from_branch=base_branch, to_branch=self.this_branch)
536
 
            self.base_is_ancestor = is_ancestor(self.this_basis, 
537
 
                                                self.base_rev_id,
538
 
                                                self.this_branch)
539
 
 
540
 
    def do_merge(self):
541
 
        def get_inventory(tree):
542
 
            return tree.inventory
543
 
        
544
 
        inv_changes = merge_flex(self.this_tree, self.base_tree, 
545
 
                                 self.other_tree,
546
 
                                 generate_changeset, get_inventory,
547
 
                                 self.conflict_handler,
548
 
                                 merge_factory=self.merge_factory, 
549
 
                                 interesting_ids=self.interesting_ids)
550
 
 
551
 
        adjust_ids = []
552
 
        for id, path in inv_changes.iteritems():
553
 
            if path is not None:
554
 
                if path == u'.':
555
 
                    path = u''
556
 
                else:
557
 
                    assert path.startswith('.' + '/') or path.startswith('.' + '\\'), "path is %s" % path
558
 
                path = path[2:]
559
 
            adjust_ids.append((path, id))
560
 
        if len(adjust_ids) > 0:
561
 
            self.this_branch.working_tree().set_inventory(self.regen_inventory(adjust_ids))
562
 
        conflicts = self.conflict_handler.conflicts
563
 
        self.conflict_handler.finalize()
564
 
        return conflicts
565
 
 
566
 
    def regen_inventory(self, new_entries):
567
 
        old_entries = self.this_branch.working_tree().read_working_inventory()
568
 
        new_inventory = {}
569
 
        by_path = {}
570
 
        new_entries_map = {} 
571
 
        for path, file_id in new_entries:
572
 
            if path is None:
573
 
                continue
574
 
            new_entries_map[file_id] = path
575
 
 
576
 
        def id2path(file_id):
577
 
            path = new_entries_map.get(file_id)
578
 
            if path is not None:
579
 
                return path
580
 
            entry = old_entries[file_id]
581
 
            if entry.parent_id is None:
582
 
                return entry.name
583
 
            return pathjoin(id2path(entry.parent_id), entry.name)
584
 
            
585
 
        for file_id in old_entries:
586
 
            entry = old_entries[file_id]
587
 
            path = id2path(file_id)
588
 
            new_inventory[file_id] = (path, file_id, entry.parent_id, 
589
 
                                      entry.kind)
590
 
            by_path[path] = file_id
591
 
        
592
 
        deletions = 0
593
 
        insertions = 0
594
 
        new_path_list = []
595
 
        for path, file_id in new_entries:
596
 
            if path is None:
597
 
                del new_inventory[file_id]
598
 
                deletions += 1
599
 
            else:
600
 
                new_path_list.append((path, file_id))
601
 
                if file_id not in old_entries:
602
 
                    insertions += 1
603
 
        # Ensure no file is added before its parent
604
 
        new_path_list.sort()
605
 
        for path, file_id in new_path_list:
606
 
            if path == '':
607
 
                parent = None
608
 
            else:
609
 
                parent = by_path[os.path.dirname(path)]
610
 
            abspath = pathjoin(self.this_tree.basedir, path)
611
 
            kind = bzrlib.osutils.file_kind(abspath)
612
 
            new_inventory[file_id] = (path, file_id, parent, kind)
613
 
            by_path[path] = file_id 
614
 
 
615
 
        # Get a list in insertion order
616
 
        new_inventory_list = new_inventory.values()
617
 
        mutter ("""Inventory regeneration:
618
 
    old length: %i insertions: %i deletions: %i new_length: %i"""\
619
 
            % (len(old_entries), insertions, deletions, 
620
 
               len(new_inventory_list)))
621
 
        assert len(new_inventory_list) == len(old_entries) + insertions\
622
 
            - deletions
623
 
        new_inventory_list.sort()
624
 
        return new_inventory_list
 
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
625
347
 
626
348
merge_types = {     "merge3": (ApplyMerge3, "Native diff3-style merge"), 
627
 
                     "diff3": (Diff3Merge,  "Merge using external diff3"),
628
 
                     'weave': (WeaveMerge, "Weave-based merge")
 
349
                     "diff3": (Diff3Merge,  "Merge using external diff3")
629
350
              }
630
351