← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: John Arbash Meinel
  • Date: 2005-12-01 19:27:48 UTC
  • mto: (1185.50.19 bzr-jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1532.
  • Revision ID: john@arbash-meinel.com-20051201192748-369238cd06ecf7e8
Added osutils.mkdtemp()

Show diffs side-by-side

added added

removed removed

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