← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

Make needs_read_lock and needs_write_lock more visible in tracebacks

Show diffs side-by-side

added added

removed removed

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