← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Martin Pool
  • Date: 2006-01-30 06:23:50 UTC
  • mfrom: (1534.1.17 integration)
  • Revision ID: mbp@sourcefrog.net-20060130062350-d6f25277ddcdfd79
[merge] robert's integration of much recent work

Show diffs side-by-side

added added

removed removed

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