← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

and the tutorial patch came back, the very next day

Show diffs side-by-side

added added

removed removed

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