1
# Copyright (C) 2005, 2006 Canonical Ltd
1
# Copyright (C) 2005 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
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
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
25
28
from bzrlib.branch import Branch
26
from bzrlib.conflicts import ConflictList, Conflict
27
from bzrlib.errors import (BzrCommandError,
37
WorkingTreeNotRevision,
40
from bzrlib.merge3 import Merge3
42
from bzrlib.osutils import rename, pathjoin
43
from progress import DummyProgress, ProgressPhase
44
from bzrlib.revision import common_ancestor, is_ancestor, NULL_REVISION
45
from bzrlib.textfile import check_text_lines
29
from bzrlib.errors import BzrCommandError, UnrelatedBranches, NoCommonAncestor
30
from bzrlib.errors import NoCommits
31
from bzrlib.delta import compare_trees
46
32
from bzrlib.trace import mutter, warning, note
47
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
48
FinalPaths, create_by_entry, unique_add,
50
from bzrlib.versionedfile import WeaveMerge
53
# TODO: Report back as changes are merged in
55
def _get_tree(treespec, local_branch=None):
56
from bzrlib import workingtree
33
from bzrlib.fetch import greedy_fetch, fetch
34
from bzrlib.revision import is_ancestor
35
from bzrlib.osutils import rename
36
from bzrlib.revision import common_ancestor, MultipleRevisionSources
37
from bzrlib.errors import NoSuchRevision
39
# TODO: build_working_dir can be built on something simpler than merge()
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.
45
# comments from abentley on irc: merge happens in two stages, each
46
# of which generates a changeset object
48
# stage 1: generate OLD->OTHER,
49
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
51
class MergeConflictHandler(ExceptionConflictHandler):
52
"""Handle conflicts encountered while merging.
54
This subclasses ExceptionConflictHandler, so that any types of
55
conflict that are not explicitly handled cause an exception and
58
def __init__(self, this_tree, base_tree, other_tree, ignore_zero=False):
59
ExceptionConflictHandler.__init__(self)
61
self.ignore_zero = ignore_zero
62
self.this_tree = this_tree
63
self.base_tree = base_tree
64
self.other_tree = other_tree
66
def copy(self, source, dest):
67
"""Copy the text and mode of a file
68
:param source: The path of the file to copy
69
:param dest: The distination file to create
71
s_file = file(source, "rb")
72
d_file = file(dest, "wb")
75
os.chmod(dest, 0777 & os.stat(source).st_mode)
77
def dump(self, lines, dest):
78
"""Copy the text and mode of a file
79
:param source: The path of the file to copy
80
:param dest: The distination file to create
82
d_file = file(dest, "wb")
86
def add_suffix(self, name, suffix, last_new_name=None):
87
"""Rename a file to append a suffix. If the new name exists, the
88
suffix is added repeatedly until a non-existant name is found
90
:param name: The path of the file
91
:param suffix: The suffix to append
92
:param last_new_name: (used for recursive calls) the last name tried
94
if last_new_name is None:
96
new_name = last_new_name+suffix
98
rename(name, new_name)
101
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
103
return self.add_suffix(name, suffix, last_new_name=new_name)
105
def conflict(self, text):
110
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
112
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
113
main file will be a version with diff3 conflicts.
114
:param new_file: Path to the output file with diff3 markers
115
:param this_path: Path to the file text for the THIS tree
116
:param base_path: Path to the file text for the BASE tree
117
:param other_path: Path to the file text for the OTHER tree
119
self.add_suffix(this_path, ".THIS")
120
self.dump(base_lines, this_path+".BASE")
121
self.dump(other_lines, this_path+".OTHER")
122
rename(new_file, this_path)
123
self.conflict("Diff3 conflict encountered in %s" % this_path)
125
def new_contents_conflict(self, filename, other_contents):
126
"""Conflicting contents for newly added file."""
127
other.contents.apply(filename + ".OTHER")
128
self.conflict("Conflict in newly added file %s" % filename)
131
def target_exists(self, entry, target, old_path):
132
"""Handle the case when the target file or dir exists"""
133
moved_path = self.add_suffix(target, ".moved")
134
self.conflict("Moved existing %s to %s" % (target, moved_path))
136
def rmdir_non_empty(self, filename):
137
"""Handle the case where the dir to be removed still has contents"""
138
self.conflict("Directory %s not removed because it is not empty"\
142
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)
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)
150
self.conflict("Other branch deleted locally modified file %s" %
152
return ReplaceContents(this_contents, None)
154
def abs_this_path(self, file_id):
155
"""Return the absolute path for a file_id in the this tree."""
156
return self.this_tree.id2abspath(file_id)
158
def add_missing_parents(self, file_id, tree):
159
"""If some of the parents for file_id are missing, add them."""
160
entry = tree.inventory[file_id]
161
if entry.parent_id not in self.this_tree:
162
return self.create_all_missing(entry.parent_id, tree)
164
return self.abs_this_path(entry.parent_id)
166
def create_all_missing(self, file_id, tree):
167
"""Add contents for a file_id and all its parents to a tree."""
168
entry = tree.inventory[file_id]
169
if entry.parent_id is not None and entry.parent_id not in self.this_tree:
170
abspath = self.create_all_missing(entry.parent_id, tree)
172
abspath = self.abs_this_path(entry.parent_id)
173
entry_path = os.path.join(abspath, entry.name)
174
if not os.path.isdir(entry_path):
175
self.create(file_id, entry_path, tree)
178
def create(self, file_id, path, tree, reverse=False):
179
"""Uses tree data to create a filesystem object for the file_id"""
180
from changeset import get_contents
181
get_contents(tree, file_id)(path, self, reverse)
183
def missing_for_merge(self, file_id, other_path):
184
"""The file_id doesn't exist in THIS, but does in OTHER and BASE"""
185
self.conflict("Other branch modified locally deleted file %s" %
187
parent_dir = self.add_missing_parents(file_id, self.other_tree)
188
stem = os.path.join(parent_dir, os.path.basename(other_path))
189
self.create(file_id, stem+".OTHER", self.other_tree)
190
self.create(file_id, stem+".BASE", self.base_tree)
192
def threeway_contents_conflict(filename, this_contents, base_contents,
194
self.conflict("Three-way conflict merging %s" % filename)
197
if not self.ignore_zero:
198
note("%d conflicts encountered.\n" % self.conflicts)
200
def get_tree(treespec, local_branch=None):
57
201
location, revno = treespec
202
branch = Branch.open_containing(location)[0]
59
tree = workingtree.WorkingTree.open_containing(location)[0]
60
return tree.branch, tree
61
branch = Branch.open_containing(location)[0]
63
206
revision = branch.last_revision()
65
208
revision = branch.get_rev_id(revno)
67
revision = NULL_REVISION
68
return branch, _get_revid_tree(branch, revision, local_branch)
71
def _get_revid_tree(branch, revision, local_branch):
209
return branch, get_revid_tree(branch, revision, local_branch)
211
def get_revid_tree(branch, revision, local_branch):
72
212
if revision is None:
73
base_tree = branch.bzrdir.open_workingtree()
213
base_tree = branch.working_tree()
75
215
if local_branch is not None:
76
if local_branch.base != branch.base:
77
local_branch.fetch(branch, revision)
78
base_tree = local_branch.repository.revision_tree(revision)
216
greedy_fetch(local_branch, branch, revision)
217
base_tree = local_branch.revision_tree(revision)
80
base_tree = branch.repository.revision_tree(revision)
219
base_tree = branch.revision_tree(revision)
84
def transform_tree(from_tree, to_tree, interesting_ids=None):
85
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
86
interesting_ids=interesting_ids, this_tree=from_tree)
90
def __init__(self, this_branch, other_tree=None, base_tree=None,
91
this_tree=None, pb=DummyProgress()):
93
assert this_tree is not None, "this_tree is required"
94
self.this_branch = this_branch
95
self.this_basis = this_branch.last_revision()
96
self.this_rev_id = None
97
self.this_tree = this_tree
98
self.this_revision_tree = None
99
self.this_basis_tree = None
100
self.other_tree = other_tree
101
self.base_tree = base_tree
102
self.ignore_zero = False
103
self.backup_files = False
104
self.interesting_ids = None
105
self.show_base = False
106
self.reprocess = False
111
def revision_tree(self, revision_id):
112
return self.this_branch.repository.revision_tree(revision_id)
114
def ensure_revision_trees(self):
115
if self.this_revision_tree is None:
116
self.this_basis_tree = self.this_branch.repository.revision_tree(
118
if self.this_basis == self.this_rev_id:
119
self.this_revision_tree = self.this_basis_tree
121
if self.other_rev_id is None:
122
other_basis_tree = self.revision_tree(self.other_basis)
123
changes = other_basis_tree.changes_from(self.other_tree)
124
if changes.has_changed():
125
raise WorkingTreeNotRevision(self.this_tree)
126
other_rev_id = self.other_basis
127
self.other_tree = other_basis_tree
129
def file_revisions(self, file_id):
130
self.ensure_revision_trees()
131
def get_id(tree, file_id):
132
revision_id = tree.inventory[file_id].revision
133
assert revision_id is not None
135
if self.this_rev_id is None:
136
if self.this_basis_tree.get_file_sha1(file_id) != \
137
self.this_tree.get_file_sha1(file_id):
138
raise WorkingTreeNotRevision(self.this_tree)
140
trees = (self.this_basis_tree, self.other_tree)
141
return [get_id(tree, file_id) for tree in trees]
143
def check_basis(self, check_clean, require_commits=True):
144
if self.this_basis is None and require_commits is True:
145
raise BzrCommandError("This branch has no commits")
148
if self.this_basis != self.this_rev_id:
149
raise BzrCommandError("Working tree has uncommitted changes.")
151
def compare_basis(self):
152
changes = self.this_tree.changes_from(self.this_tree.basis_tree())
153
if not changes.has_changed():
154
self.this_rev_id = self.this_basis
156
def set_interesting_files(self, file_list):
223
def file_exists(tree, file_id):
224
return tree.has_filename(tree.id2path(file_id))
227
def build_working_dir(to_dir):
228
"""Build a working directory in an empty directory.
230
to_dir is a directory containing branch metadata but no working files,
231
typically constructed by cloning an existing branch.
233
This is split out as a special idiomatic case of merge. It could
234
eventually be done by just building the tree directly calling into
235
lower-level code (e.g. constructing a changeset).
237
# RBC 20051019 is this not just 'export' ?
238
merge((to_dir, -1), (to_dir, 0), this_dir=to_dir,
239
check_clean=False, ignore_zero=True)
242
def merge(other_revision, base_revision,
243
check_clean=True, ignore_zero=False,
244
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
246
"""Merge changes into a tree.
249
tuple(path, revision) Base for three-way merge.
251
tuple(path, revision) Other revision for three-way merge.
253
Directory to merge changes into; '.' by default.
255
If true, this_dir must have no uncommitted changes before the
257
ignore_zero - If true, suppress the "zero conflicts" message when
258
there are no conflicts; should be set when doing something we expect
259
to complete perfectly.
261
All available ancestors of other_revision and base_revision are
262
automatically pulled into the branch.
266
this_branch = Branch.open_containing(this_dir)[0]
267
this_rev_id = this_branch.last_revision()
268
if this_rev_id is None:
269
raise BzrCommandError("This branch has no commits")
271
changes = compare_trees(this_branch.working_tree(),
272
this_branch.basis_tree(), False)
273
if changes.has_changed():
274
raise BzrCommandError("Working tree has uncommitted changes.")
275
other_branch, other_tree = get_tree(other_revision, this_branch)
276
if other_revision[1] == -1:
277
other_rev_id = other_branch.last_revision()
278
if other_rev_id is None:
279
raise NoCommits(other_branch)
280
other_basis = other_rev_id
281
elif other_revision[1] is not None:
282
other_rev_id = other_branch.get_rev_id(other_revision[1])
283
other_basis = other_rev_id
286
other_basis = other_branch.last_revision()
287
if other_basis is None:
288
raise NoCommits(other_branch)
289
if base_revision == [None, None]:
158
self._set_interesting_files(file_list)
159
except NotVersionedError, e:
160
raise BzrCommandError("%s is not a source file in any"
163
def _set_interesting_files(self, file_list):
164
"""Set the list of interesting ids from a list of files."""
165
if file_list is None:
166
self.interesting_ids = None
291
base_rev_id = common_ancestor(this_rev_id, other_basis,
293
except NoCommonAncestor:
294
raise UnrelatedBranches()
295
base_tree = get_revid_tree(this_branch, base_rev_id, None)
296
base_is_ancestor = True
298
base_branch, base_tree = get_tree(base_revision)
299
if base_revision[1] == -1:
300
base_rev_id = base_branch.last_revision()
301
elif base_revision[1] is None:
304
base_rev_id = base_branch.get_rev_id(base_revision[1])
305
fetch(from_branch=base_branch, to_branch=this_branch)
306
base_is_ancestor = is_ancestor(this_rev_id, base_rev_id,
308
if file_list is None:
309
interesting_ids = None
169
311
interesting_ids = set()
170
for path in file_list:
312
this_tree = this_branch.working_tree()
313
for fname in file_list:
314
path = this_tree.relpath(fname)
172
for tree in (self.this_tree, self.base_tree, self.other_tree):
316
for tree in (this_tree, base_tree, other_tree):
173
317
file_id = tree.inventory.path2id(path)
174
318
if file_id is not None:
175
319
interesting_ids.add(file_id)
178
raise NotVersionedError(path=path)
179
self.interesting_ids = interesting_ids
181
def set_pending(self):
182
if not self.base_is_ancestor:
184
if self.other_rev_id is None:
186
ancestry = self.this_branch.repository.get_ancestry(self.this_basis)
187
if self.other_rev_id in ancestry:
189
self.this_tree.add_parent_tree((self.other_rev_id, self.other_tree))
191
def set_other(self, other_revision):
192
"""Set the revision and tree to merge from.
194
This sets the other_tree, other_rev_id, other_basis attributes.
196
:param other_revision: The [path, revision] list to merge from.
198
other_branch, self.other_tree = _get_tree(other_revision,
200
if other_revision[1] == -1:
201
self.other_rev_id = other_branch.last_revision()
202
if self.other_rev_id is None:
203
raise NoCommits(other_branch)
204
self.other_basis = self.other_rev_id
205
elif other_revision[1] is not None:
206
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
207
self.other_basis = self.other_rev_id
209
self.other_rev_id = None
210
self.other_basis = other_branch.last_revision()
211
if self.other_basis is None:
212
raise NoCommits(other_branch)
213
if other_branch.base != self.this_branch.base:
214
self.this_branch.fetch(other_branch, last_revision=self.other_basis)
217
self.set_base([None, None])
219
def set_base(self, base_revision):
220
"""Set the base revision to use for the merge.
222
:param base_revision: A 2-list containing a path and revision number.
224
mutter("doing merge() with no base_revision specified")
225
if base_revision == [None, None]:
227
pb = bzrlib.ui.ui_factory.nested_progress_bar()
229
this_repo = self.this_branch.repository
230
self.base_rev_id = common_ancestor(self.this_basis,
235
except NoCommonAncestor:
236
raise UnrelatedBranches()
237
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
239
self.base_is_ancestor = True
241
base_branch, self.base_tree = _get_tree(base_revision)
242
if base_revision[1] == -1:
243
self.base_rev_id = base_branch.last_revision()
244
elif base_revision[1] is None:
245
self.base_rev_id = None
247
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
248
if self.this_branch.base != base_branch.base:
249
self.this_branch.fetch(base_branch)
250
self.base_is_ancestor = is_ancestor(self.this_basis,
255
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
256
'other_tree': self.other_tree,
257
'interesting_ids': self.interesting_ids,
259
if self.merge_type.requires_base:
260
kwargs['base_tree'] = self.base_tree
261
if self.merge_type.supports_reprocess:
262
kwargs['reprocess'] = self.reprocess
264
raise BzrError("Conflict reduction is not supported for merge"
265
" type %s." % self.merge_type)
266
if self.merge_type.supports_show_base:
267
kwargs['show_base'] = self.show_base
269
raise BzrError("Showing base is not supported for this"
270
" merge type. %s" % self.merge_type)
271
merge = self.merge_type(pb=self._pb, **kwargs)
272
if len(merge.cooked_conflicts) == 0:
273
if not self.ignore_zero:
274
note("All changes applied successfully.")
276
note("%d conflicts encountered." % len(merge.cooked_conflicts))
278
return len(merge.cooked_conflicts)
280
def regen_inventory(self, new_entries):
281
old_entries = self.this_tree.read_working_inventory()
285
for path, file_id in new_entries:
288
new_entries_map[file_id] = path
290
def id2path(file_id):
291
path = new_entries_map.get(file_id)
294
entry = old_entries[file_id]
295
if entry.parent_id is None:
297
return pathjoin(id2path(entry.parent_id), entry.name)
299
for file_id in old_entries:
300
entry = old_entries[file_id]
301
path = id2path(file_id)
302
if file_id in self.base_tree.inventory:
303
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
305
executable = getattr(entry, 'executable', False)
306
new_inventory[file_id] = (path, file_id, entry.parent_id,
307
entry.kind, executable)
309
by_path[path] = file_id
314
for path, file_id in new_entries:
316
del new_inventory[file_id]
319
new_path_list.append((path, file_id))
320
if file_id not in old_entries:
322
# Ensure no file is added before its parent
324
for path, file_id in new_path_list:
328
parent = by_path[os.path.dirname(path)]
329
abspath = pathjoin(self.this_tree.basedir, path)
330
kind = bzrlib.osutils.file_kind(abspath)
331
if file_id in self.base_tree.inventory:
332
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
335
new_inventory[file_id] = (path, file_id, parent, kind, executable)
336
by_path[path] = file_id
338
# Get a list in insertion order
339
new_inventory_list = new_inventory.values()
340
mutter ("""Inventory regeneration:
341
old length: %i insertions: %i deletions: %i new_length: %i"""\
342
% (len(old_entries), insertions, deletions,
343
len(new_inventory_list)))
344
assert len(new_inventory_list) == len(old_entries) + insertions\
346
new_inventory_list.sort()
347
return new_inventory_list
350
class Merge3Merger(object):
351
"""Three-way merger that uses the merge3 text merger"""
353
supports_reprocess = True
354
supports_show_base = True
355
history_based = False
357
def __init__(self, working_tree, this_tree, base_tree, other_tree,
358
interesting_ids=None, reprocess=False, show_base=False,
359
pb=DummyProgress(), pp=None):
360
"""Initialize the merger object and perform the merge."""
361
object.__init__(self)
362
self.this_tree = working_tree
363
self.base_tree = base_tree
364
self.other_tree = other_tree
365
self._raw_conflicts = []
366
self.cooked_conflicts = []
367
self.reprocess = reprocess
368
self.show_base = show_base
372
self.pp = ProgressPhase("Merge phase", 3, self.pb)
374
if interesting_ids is not None:
375
all_ids = interesting_ids
377
all_ids = set(base_tree)
378
all_ids.update(other_tree)
379
working_tree.lock_tree_write()
380
self.tt = TreeTransform(working_tree, self.pb)
383
child_pb = ui.ui_factory.nested_progress_bar()
385
for num, file_id in enumerate(all_ids):
386
child_pb.update('Preparing file merge', num, len(all_ids))
387
self.merge_names(file_id)
388
file_status = self.merge_contents(file_id)
389
self.merge_executable(file_id, file_status)
394
child_pb = ui.ui_factory.nested_progress_bar()
396
fs_conflicts = resolve_conflicts(self.tt, child_pb)
399
self.cook_conflicts(fs_conflicts)
400
for conflict in self.cooked_conflicts:
403
results = self.tt.apply()
404
self.write_modified(results)
406
working_tree.add_conflicts(self.cooked_conflicts)
407
except UnsupportedOperation:
411
working_tree.unlock()
416
self.tt.final_kind(self.tt.root)
418
self.tt.cancel_deletion(self.tt.root)
419
if self.tt.final_file_id(self.tt.root) is None:
420
self.tt.version_file(self.tt.tree_file_id(self.tt.root),
422
if self.other_tree.inventory.root is None:
424
other_root_file_id = self.other_tree.inventory.root.file_id
425
other_root = self.tt.trans_id_file_id(other_root_file_id)
426
if other_root == self.tt.root:
429
self.tt.final_kind(other_root)
432
self.reparent_children(self.other_tree.inventory.root, self.tt.root)
433
self.tt.cancel_creation(other_root)
434
self.tt.cancel_versioning(other_root)
436
def reparent_children(self, ie, target):
437
for thing, child in ie.children.iteritems():
438
trans_id = self.tt.trans_id_file_id(child.file_id)
439
self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
441
def write_modified(self, results):
443
for path in results.modified_paths:
444
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
447
hash = self.this_tree.get_file_sha1(file_id)
450
modified_hashes[file_id] = hash
451
self.this_tree.set_merge_modified(modified_hashes)
454
def parent(entry, file_id):
455
"""Determine the parent for a file_id (used as a key method)"""
458
return entry.parent_id
461
def name(entry, file_id):
462
"""Determine the name for a file_id (used as a key method)"""
468
def contents_sha1(tree, file_id):
469
"""Determine the sha1 of the file contents (used as a key method)."""
470
if file_id not in tree:
472
return tree.get_file_sha1(file_id)
475
def executable(tree, file_id):
476
"""Determine the executability of a file-id (used as a key method)."""
477
if file_id not in tree:
479
if tree.kind(file_id) != "file":
481
return tree.is_executable(file_id)
484
def kind(tree, file_id):
485
"""Determine the kind of a file-id (used as a key method)."""
486
if file_id not in tree:
488
return tree.kind(file_id)
491
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
492
"""Do a three-way test on a scalar.
493
Return "this", "other" or "conflict", depending whether a value wins.
495
key_base = key(base_tree, file_id)
496
key_other = key(other_tree, file_id)
497
#if base == other, either they all agree, or only THIS has changed.
498
if key_base == key_other:
500
key_this = key(this_tree, file_id)
501
if key_this not in (key_base, key_other):
503
# "Ambiguous clean merge"
504
elif key_this == key_other:
507
assert key_this == key_base
510
def merge_names(self, file_id):
511
"""Perform a merge on file_id names and parents"""
513
if file_id in tree.inventory:
514
return tree.inventory[file_id]
517
this_entry = get_entry(self.this_tree)
518
other_entry = get_entry(self.other_tree)
519
base_entry = get_entry(self.base_tree)
520
name_winner = self.scalar_three_way(this_entry, base_entry,
521
other_entry, file_id, self.name)
522
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
523
other_entry, file_id,
525
if this_entry is None:
526
if name_winner == "this":
527
name_winner = "other"
528
if parent_id_winner == "this":
529
parent_id_winner = "other"
530
if name_winner == "this" and parent_id_winner == "this":
532
if name_winner == "conflict":
533
trans_id = self.tt.trans_id_file_id(file_id)
534
self._raw_conflicts.append(('name conflict', trans_id,
535
self.name(this_entry, file_id),
536
self.name(other_entry, file_id)))
537
if parent_id_winner == "conflict":
538
trans_id = self.tt.trans_id_file_id(file_id)
539
self._raw_conflicts.append(('parent conflict', trans_id,
540
self.parent(this_entry, file_id),
541
self.parent(other_entry, file_id)))
542
if other_entry is None:
543
# it doesn't matter whether the result was 'other' or
544
# 'conflict'-- if there's no 'other', we leave it alone.
546
# if we get here, name_winner and parent_winner are set to safe values.
547
winner_entry = {"this": this_entry, "other": other_entry,
548
"conflict": other_entry}
549
trans_id = self.tt.trans_id_file_id(file_id)
550
parent_id = winner_entry[parent_id_winner].parent_id
551
if parent_id is not None:
552
parent_trans_id = self.tt.trans_id_file_id(parent_id)
553
self.tt.adjust_path(winner_entry[name_winner].name,
554
parent_trans_id, trans_id)
556
def merge_contents(self, file_id):
557
"""Performa a merge on file_id contents."""
558
def contents_pair(tree):
559
if file_id not in tree:
561
kind = tree.kind(file_id)
563
contents = tree.get_file_sha1(file_id)
564
elif kind == "symlink":
565
contents = tree.get_symlink_target(file_id)
568
return kind, contents
570
def contents_conflict():
571
trans_id = self.tt.trans_id_file_id(file_id)
572
name = self.tt.final_name(trans_id)
573
parent_id = self.tt.final_parent(trans_id)
574
if file_id in self.this_tree.inventory:
575
self.tt.unversion_file(trans_id)
576
self.tt.delete_contents(trans_id)
577
file_group = self._dump_conflicts(name, parent_id, file_id,
579
self._raw_conflicts.append(('contents conflict', file_group))
581
# See SPOT run. run, SPOT, run.
582
# So we're not QUITE repeating ourselves; we do tricky things with
584
base_pair = contents_pair(self.base_tree)
585
other_pair = contents_pair(self.other_tree)
586
if base_pair == other_pair:
587
# OTHER introduced no changes
589
this_pair = contents_pair(self.this_tree)
590
if this_pair == other_pair:
591
# THIS and OTHER introduced the same changes
594
trans_id = self.tt.trans_id_file_id(file_id)
595
if this_pair == base_pair:
596
# only OTHER introduced changes
597
if file_id in self.this_tree:
598
# Remove any existing contents
599
self.tt.delete_contents(trans_id)
600
if file_id in self.other_tree:
601
# OTHER changed the file
602
create_by_entry(self.tt,
603
self.other_tree.inventory[file_id],
604
self.other_tree, trans_id)
605
if file_id not in self.this_tree.inventory:
606
self.tt.version_file(file_id, trans_id)
608
elif file_id in self.this_tree.inventory:
609
# OTHER deleted the file
610
self.tt.unversion_file(trans_id)
612
#BOTH THIS and OTHER introduced changes; scalar conflict
613
elif this_pair[0] == "file" and other_pair[0] == "file":
614
# THIS and OTHER are both files, so text merge. Either
615
# BASE is a file, or both converted to files, so at least we
616
# have agreement that output should be a file.
618
self.text_merge(file_id, trans_id)
620
return contents_conflict()
621
if file_id not in self.this_tree.inventory:
622
self.tt.version_file(file_id, trans_id)
624
self.tt.tree_kind(trans_id)
625
self.tt.delete_contents(trans_id)
630
# Scalar conflict, can't text merge. Dump conflicts
631
return contents_conflict()
633
def get_lines(self, tree, file_id):
634
"""Return the lines in a file, or an empty list."""
636
return tree.get_file(file_id).readlines()
640
def text_merge(self, file_id, trans_id):
641
"""Perform a three-way text merge on a file_id"""
642
# it's possible that we got here with base as a different type.
643
# if so, we just want two-way text conflicts.
644
if file_id in self.base_tree and \
645
self.base_tree.kind(file_id) == "file":
646
base_lines = self.get_lines(self.base_tree, file_id)
649
other_lines = self.get_lines(self.other_tree, file_id)
650
this_lines = self.get_lines(self.this_tree, file_id)
651
m3 = Merge3(base_lines, this_lines, other_lines)
652
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
653
if self.show_base is True:
654
base_marker = '|' * 7
658
def iter_merge3(retval):
659
retval["text_conflicts"] = False
660
for line in m3.merge_lines(name_a = "TREE",
661
name_b = "MERGE-SOURCE",
662
name_base = "BASE-REVISION",
663
start_marker=start_marker,
664
base_marker=base_marker,
665
reprocess=self.reprocess):
666
if line.startswith(start_marker):
667
retval["text_conflicts"] = True
668
yield line.replace(start_marker, '<' * 7)
672
merge3_iterator = iter_merge3(retval)
673
self.tt.create_file(merge3_iterator, trans_id)
674
if retval["text_conflicts"] is True:
675
self._raw_conflicts.append(('text conflict', trans_id))
676
name = self.tt.final_name(trans_id)
677
parent_id = self.tt.final_parent(trans_id)
678
file_group = self._dump_conflicts(name, parent_id, file_id,
679
this_lines, base_lines,
681
file_group.append(trans_id)
683
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
684
base_lines=None, other_lines=None, set_version=False,
686
"""Emit conflict files.
687
If this_lines, base_lines, or other_lines are omitted, they will be
688
determined automatically. If set_version is true, the .OTHER, .THIS
689
or .BASE (in that order) will be created as versioned files.
691
data = [('OTHER', self.other_tree, other_lines),
692
('THIS', self.this_tree, this_lines)]
694
data.append(('BASE', self.base_tree, base_lines))
697
for suffix, tree, lines in data:
699
trans_id = self._conflict_file(name, parent_id, tree, file_id,
701
file_group.append(trans_id)
702
if set_version and not versioned:
703
self.tt.version_file(file_id, trans_id)
707
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
709
"""Emit a single conflict file."""
710
name = name + '.' + suffix
711
trans_id = self.tt.create_path(name, parent_id)
712
entry = tree.inventory[file_id]
713
create_by_entry(self.tt, entry, tree, trans_id, lines)
716
def merge_executable(self, file_id, file_status):
717
"""Perform a merge on the execute bit."""
718
if file_status == "deleted":
720
trans_id = self.tt.trans_id_file_id(file_id)
722
if self.tt.final_kind(trans_id) != "file":
726
winner = self.scalar_three_way(self.this_tree, self.base_tree,
727
self.other_tree, file_id,
729
if winner == "conflict":
730
# There must be a None in here, if we have a conflict, but we
731
# need executability since file status was not deleted.
732
if self.executable(self.other_tree, file_id) is None:
737
if file_status == "modified":
738
executability = self.this_tree.is_executable(file_id)
739
if executability is not None:
740
trans_id = self.tt.trans_id_file_id(file_id)
741
self.tt.set_executability(executability, trans_id)
743
assert winner == "other"
744
if file_id in self.other_tree:
745
executability = self.other_tree.is_executable(file_id)
746
elif file_id in self.this_tree:
747
executability = self.this_tree.is_executable(file_id)
748
elif file_id in self.base_tree:
749
executability = self.base_tree.is_executable(file_id)
750
if executability is not None:
751
trans_id = self.tt.trans_id_file_id(file_id)
752
self.tt.set_executability(executability, trans_id)
754
def cook_conflicts(self, fs_conflicts):
755
"""Convert all conflicts into a form that doesn't depend on trans_id"""
756
from conflicts import Conflict
758
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
759
fp = FinalPaths(self.tt)
760
for conflict in self._raw_conflicts:
761
conflict_type = conflict[0]
762
if conflict_type in ('name conflict', 'parent conflict'):
763
trans_id = conflict[1]
764
conflict_args = conflict[2:]
765
if trans_id not in name_conflicts:
766
name_conflicts[trans_id] = {}
767
unique_add(name_conflicts[trans_id], conflict_type,
769
if conflict_type == 'contents conflict':
770
for trans_id in conflict[1]:
771
file_id = self.tt.final_file_id(trans_id)
772
if file_id is not None:
774
path = fp.get_path(trans_id)
775
for suffix in ('.BASE', '.THIS', '.OTHER'):
776
if path.endswith(suffix):
777
path = path[:-len(suffix)]
779
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
780
self.cooked_conflicts.append(c)
781
if conflict_type == 'text conflict':
782
trans_id = conflict[1]
783
path = fp.get_path(trans_id)
784
file_id = self.tt.final_file_id(trans_id)
785
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
786
self.cooked_conflicts.append(c)
788
for trans_id, conflicts in name_conflicts.iteritems():
790
this_parent, other_parent = conflicts['parent conflict']
791
assert this_parent != other_parent
793
this_parent = other_parent = \
794
self.tt.final_file_id(self.tt.final_parent(trans_id))
796
this_name, other_name = conflicts['name conflict']
797
assert this_name != other_name
799
this_name = other_name = self.tt.final_name(trans_id)
800
other_path = fp.get_path(trans_id)
801
if this_parent is not None:
803
fp.get_path(self.tt.trans_id_file_id(this_parent))
804
this_path = pathjoin(this_parent_path, this_name)
806
this_path = "<deleted>"
807
file_id = self.tt.final_file_id(trans_id)
808
c = Conflict.factory('path conflict', path=this_path,
809
conflict_path=other_path, file_id=file_id)
810
self.cooked_conflicts.append(c)
811
self.cooked_conflicts.sort(key=Conflict.sort_key)
814
class WeaveMerger(Merge3Merger):
815
"""Three-way tree merger, text weave merger."""
816
supports_reprocess = True
817
supports_show_base = False
819
def __init__(self, working_tree, this_tree, base_tree, other_tree,
820
interesting_ids=None, pb=DummyProgress(), pp=None,
822
self.this_revision_tree = self._get_revision_tree(this_tree)
823
self.other_revision_tree = self._get_revision_tree(other_tree)
824
super(WeaveMerger, self).__init__(working_tree, this_tree,
825
base_tree, other_tree,
826
interesting_ids=interesting_ids,
827
pb=pb, pp=pp, reprocess=reprocess)
829
def _get_revision_tree(self, tree):
830
"""Return a revision tree related to this tree.
831
If the tree is a WorkingTree, the basis will be returned.
833
if getattr(tree, 'get_weave', False) is False:
834
# If we have a WorkingTree, try using the basis
835
return tree.branch.basis_tree()
839
def _check_file(self, file_id):
840
"""Check that the revision tree's version of the file matches."""
841
for tree, rt in ((self.this_tree, self.this_revision_tree),
842
(self.other_tree, self.other_revision_tree)):
845
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
846
raise WorkingTreeNotRevision(self.this_tree)
848
def _merged_lines(self, file_id):
849
"""Generate the merged lines.
850
There is no distinction between lines that are meant to contain <<<<<<<
853
weave = self.this_revision_tree.get_weave(file_id)
854
this_revision_id = self.this_revision_tree.inventory[file_id].revision
855
other_revision_id = \
856
self.other_revision_tree.inventory[file_id].revision
857
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
858
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
859
return wm.merge_lines(self.reprocess)
861
def text_merge(self, file_id, trans_id):
862
"""Perform a (weave) text merge for a given file and file-id.
863
If conflicts are encountered, .THIS and .OTHER files will be emitted,
864
and a conflict will be noted.
866
self._check_file(file_id)
867
lines, conflicts = self._merged_lines(file_id)
869
# Note we're checking whether the OUTPUT is binary in this case,
870
# because we don't want to get into weave merge guts.
871
check_text_lines(lines)
872
self.tt.create_file(lines, trans_id)
874
self._raw_conflicts.append(('text conflict', trans_id))
875
name = self.tt.final_name(trans_id)
876
parent_id = self.tt.final_parent(trans_id)
877
file_group = self._dump_conflicts(name, parent_id, file_id,
879
file_group.append(trans_id)
882
class Diff3Merger(Merge3Merger):
883
"""Three-way merger using external diff3 for text merging"""
885
def dump_file(self, temp_dir, name, tree, file_id):
886
out_path = pathjoin(temp_dir, name)
887
out_file = open(out_path, "wb")
889
in_file = tree.get_file(file_id)
896
def text_merge(self, file_id, trans_id):
897
"""Perform a diff3 merge using a specified file-id and trans-id.
898
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
899
will be dumped, and a will be conflict noted.
902
temp_dir = osutils.mkdtemp(prefix="bzr-")
904
new_file = pathjoin(temp_dir, "new")
905
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
906
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
907
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
908
status = bzrlib.patch.diff3(new_file, this, base, other)
909
if status not in (0, 1):
910
raise BzrError("Unhandled diff3 exit code")
911
f = open(new_file, 'rb')
913
self.tt.create_file(f, trans_id)
917
name = self.tt.final_name(trans_id)
918
parent_id = self.tt.final_parent(trans_id)
919
self._dump_conflicts(name, parent_id, file_id)
920
self._raw_conflicts.append(('text conflict', trans_id))
922
osutils.rmtree(temp_dir)
925
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
927
merge_type=Merge3Merger,
928
interesting_ids=None,
932
interesting_files=None,
322
raise BzrCommandError("%s is not a source file in any"
324
merge_inner(this_branch, other_tree, base_tree, tempdir=None,
325
ignore_zero=ignore_zero, backup_files=backup_files,
326
merge_type=merge_type, interesting_ids=interesting_ids)
327
if base_is_ancestor and other_rev_id is not None\
328
and other_rev_id not in this_branch.revision_history():
329
this_branch.add_pending_merge(other_rev_id)
332
def set_interesting(inventory_a, inventory_b, interesting_ids):
333
"""Mark files whose ids are in interesting_ids as interesting
335
for inventory in (inventory_a, inventory_b):
336
for path, source_file in inventory.iteritems():
337
source_file.interesting = source_file.id in interesting_ids
340
def merge_inner(this_branch, other_tree, base_tree, tempdir=None,
341
ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
342
interesting_ids=None):
935
343
"""Primary interface for merging.
937
typical use is probably
938
'merge_inner(branch, branch.get_revision_tree(other_revision),
939
branch.get_revision_tree(base_revision))'
941
if this_tree is None:
942
warnings.warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
943
"bzrlib version 0.8.",
946
this_tree = this_branch.bzrdir.open_workingtree()
947
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
949
merger.backup_files = backup_files
950
merger.merge_type = merge_type
951
merger.interesting_ids = interesting_ids
952
merger.ignore_zero = ignore_zero
953
if interesting_files:
954
assert not interesting_ids, ('Only supply interesting_ids'
955
' or interesting_files')
956
merger._set_interesting_files(interesting_files)
957
merger.show_base = show_base
958
merger.reprocess = reprocess
959
merger.other_rev_id = other_rev_id
960
merger.other_basis = other_rev_id
961
return merger.do_merge()
964
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
965
"diff3": (Diff3Merger, "Merge using external diff3"),
966
'weave': (WeaveMerger, "Weave-based merge")
345
typical use is probably
346
'merge_inner(branch, branch.get_revision_tree(other_revision),
347
branch.get_revision_tree(base_revision))'
350
_tempdir = tempfile.mkdtemp(prefix="bzr-")
354
_merge_inner(this_branch, other_tree, base_tree, _tempdir,
355
ignore_zero, merge_type, backup_files, interesting_ids)
358
shutil.rmtree(_tempdir)
361
def _merge_inner(this_branch, other_tree, base_tree, user_tempdir,
362
ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
363
interesting_ids=None):
364
def merge_factory(file_id, base, other):
365
contents_change = merge_type(file_id, base, other)
367
contents_change = BackupBeforeChange(contents_change)
368
return contents_change
370
this_tree = get_tree((this_branch.base, None))[1]
372
def get_inventory(tree):
373
return tree.inventory
375
inv_changes = merge_flex(this_tree, base_tree, other_tree,
376
generate_changeset, get_inventory,
377
MergeConflictHandler(this_tree, base_tree,
378
other_tree, ignore_zero=ignore_zero),
379
merge_factory=merge_factory,
380
interesting_ids=interesting_ids)
383
for id, path in inv_changes.iteritems():
388
assert path.startswith('.' + os.sep), "path is %s" % path
390
adjust_ids.append((path, id))
391
if len(adjust_ids) > 0:
392
this_branch.set_inventory(regen_inventory(this_branch,
397
def regen_inventory(this_branch, root, new_entries):
398
old_entries = this_branch.read_working_inventory()
402
for path, file_id in new_entries:
405
new_entries_map[file_id] = path
407
def id2path(file_id):
408
path = new_entries_map.get(file_id)
411
entry = old_entries[file_id]
412
if entry.parent_id is None:
414
return os.path.join(id2path(entry.parent_id), entry.name)
416
for file_id in old_entries:
417
entry = old_entries[file_id]
418
path = id2path(file_id)
419
new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
420
by_path[path] = file_id
425
for path, file_id in new_entries:
427
del new_inventory[file_id]
430
new_path_list.append((path, file_id))
431
if file_id not in old_entries:
433
# Ensure no file is added before its parent
435
for path, file_id in new_path_list:
439
parent = by_path[os.path.dirname(path)]
440
kind = bzrlib.osutils.file_kind(os.path.join(root, path))
441
new_inventory[file_id] = (path, file_id, parent, kind)
442
by_path[path] = file_id
444
# Get a list in insertion order
445
new_inventory_list = new_inventory.values()
446
mutter ("""Inventory regeneration:
447
old length: %i insertions: %i deletions: %i new_length: %i"""\
448
% (len(old_entries), insertions, deletions, len(new_inventory_list)))
449
assert len(new_inventory_list) == len(old_entries) + insertions - deletions
450
new_inventory_list.sort()
451
return new_inventory_list
453
merge_types = { "merge3": (ApplyMerge3, "Native diff3-style merge"),
454
"diff3": (Diff3Merge, "Merge using external diff3")
970
def merge_type_help():
971
templ = '%s%%7s: %%s' % (' '*12)
972
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
973
return '\n'.join(lines)
added
removed
bzrlib/merge.py
