/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

Merge from mbp.

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