~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: John Arbash Meinel
  • Date: 2005-11-08 18:36:26 UTC
  • mto: This revision was merged to the branch mainline in revision 1727.
  • Revision ID: john@arbash-meinel.com-20051108183626-71f8414338043265
Updating unified_diff to take a factory, using the new diff algorithm in the code.

Show diffs side-by-side

added added

removed removed

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