1
# Copyright (C) 2005 Canonical Ltd
1
# Copyright (C) 2005, 2006 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
22
from fetch import greedy_fetch
25
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
24
41
import bzrlib.osutils
25
import bzrlib.revision
26
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
27
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
28
from bzrlib.changeset import Inventory, Diff3Merge
29
from bzrlib.branch import find_branch
30
from bzrlib.errors import BzrCommandError, UnrelatedBranches
31
from bzrlib.delta import compare_trees
32
from bzrlib.trace import mutter, warning
33
from bzrlib.fetch import greedy_fetch
34
from bzrlib.revision import is_ancestor
36
# comments from abentley on irc: merge happens in two stages, each
37
# of which generates a changeset object
39
# stage 1: generate OLD->OTHER,
40
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
42
class MergeConflictHandler(ExceptionConflictHandler):
43
"""Handle conflicts encountered while merging.
45
This subclasses ExceptionConflictHandler, so that any types of
46
conflict that are not explicitly handled cause an exception and
49
def __init__(self, dir, ignore_zero=False):
50
ExceptionConflictHandler.__init__(self, dir)
52
self.ignore_zero = ignore_zero
54
def copy(self, source, dest):
55
"""Copy the text and mode of a file
56
:param source: The path of the file to copy
57
:param dest: The distination file to create
59
s_file = file(source, "rb")
60
d_file = file(dest, "wb")
63
os.chmod(dest, 0777 & os.stat(source).st_mode)
65
def dump(self, lines, dest):
66
"""Copy the text and mode of a file
67
:param source: The path of the file to copy
68
:param dest: The distination file to create
70
d_file = file(dest, "wb")
74
def add_suffix(self, name, suffix, last_new_name=None):
75
"""Rename a file to append a suffix. If the new name exists, the
76
suffix is added repeatedly until a non-existant name is found
78
:param name: The path of the file
79
:param suffix: The suffix to append
80
:param last_new_name: (used for recursive calls) the last name tried
82
if last_new_name is None:
84
new_name = last_new_name+suffix
86
os.rename(name, new_name)
89
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
91
return self.add_suffix(name, suffix, last_new_name=new_name)
93
def conflict(self, text):
98
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
100
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
101
main file will be a version with diff3 conflicts.
102
:param new_file: Path to the output file with diff3 markers
103
:param this_path: Path to the file text for the THIS tree
104
:param base_path: Path to the file text for the BASE tree
105
:param other_path: Path to the file text for the OTHER tree
107
self.add_suffix(this_path, ".THIS")
108
self.dump(base_lines, this_path+".BASE")
109
self.dump(other_lines, this_path+".OTHER")
110
os.rename(new_file, this_path)
111
self.conflict("Diff3 conflict encountered in %s" % this_path)
113
def new_contents_conflict(self, filename, other_contents):
114
"""Conflicting contents for newly added file."""
115
self.copy(other_contents, filename + ".OTHER")
116
self.conflict("Conflict in newly added file %s" % filename)
119
def target_exists(self, entry, target, old_path):
120
"""Handle the case when the target file or dir exists"""
121
moved_path = self.add_suffix(target, ".moved")
122
self.conflict("Moved existing %s to %s" % (target, moved_path))
124
def rmdir_non_empty(self, filename):
125
"""Handle the case where the dir to be removed still has contents"""
126
self.conflict("Directory %s not removed because it is not empty"\
131
if not self.ignore_zero:
132
print "%d conflicts encountered.\n" % self.conflicts
134
def get_tree(treespec, temp_root, label, local_branch=None):
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
46
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
135
57
location, revno = treespec
136
branch = find_branch(location)
140
revision = branch.last_patch()
59
tree = workingtree.WorkingTree.open_containing(location)[0]
60
return tree.branch, tree
61
branch = Branch.open_containing(location)[0]
63
revision = branch.last_revision()
142
revision = branch.lookup_revision(revno)
143
return branch, get_revid_tree(branch, revision, temp_root, label,
146
def get_revid_tree(branch, revision, temp_root, label, local_branch):
65
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):
147
72
if revision is None:
148
base_tree = branch.working_tree()
73
base_tree = branch.bzrdir.open_workingtree()
150
75
if local_branch is not None:
151
greedy_fetch(local_branch, branch, revision)
152
base_tree = local_branch.revision_tree(revision)
76
if local_branch.base != branch.base:
77
local_branch.fetch(branch, revision)
78
base_tree = local_branch.repository.revision_tree(revision)
154
base_tree = branch.revision_tree(revision)
155
temp_path = os.path.join(temp_root, label)
157
return MergeTree(base_tree, temp_path)
160
def file_exists(tree, file_id):
161
return tree.has_filename(tree.id2path(file_id))
164
class MergeTree(object):
165
def __init__(self, tree, tempdir):
80
base_tree = branch.repository.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()):
166
92
object.__init__(self)
167
if hasattr(tree, "basedir"):
168
self.root = tree.basedir
172
self.tempdir = tempdir
173
os.mkdir(os.path.join(self.tempdir, "texts"))
177
return self.tree.__iter__()
179
def __contains__(self, file_id):
180
return file_id in self.tree
182
def get_file(self, file_id):
183
return self.tree.get_file(file_id)
185
def get_file_sha1(self, id):
186
return self.tree.get_file_sha1(id)
188
def id2path(self, file_id):
189
return self.tree.id2path(file_id)
191
def has_id(self, file_id):
192
return self.tree.has_id(file_id)
194
def has_or_had_id(self, file_id):
195
if file_id == self.tree.inventory.root.file_id:
197
return self.tree.inventory.has_id(file_id)
199
def has_or_had_id(self, file_id):
200
if file_id == self.tree.inventory.root.file_id:
202
return self.tree.inventory.has_id(file_id)
204
def readonly_path(self, id):
205
if id not in self.tree:
207
if self.root is not None:
208
return self.tree.abspath(self.tree.id2path(id))
210
if self.tree.inventory[id].kind in ("directory", "root_directory"):
212
if not self.cached.has_key(id):
213
path = os.path.join(self.tempdir, "texts", id)
214
outfile = file(path, "wb")
215
outfile.write(self.tree.get_file(id).read())
216
assert(os.path.exists(path))
217
self.cached[id] = path
218
return self.cached[id]
222
def merge(other_revision, base_revision,
223
check_clean=True, ignore_zero=False,
224
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
226
"""Merge changes into a tree.
229
tuple(path, revision) Base for three-way merge.
231
tuple(path, revision) Other revision for three-way merge.
233
Directory to merge changes into; '.' by default.
235
If true, this_dir must have no uncommitted changes before the
237
all available ancestors of other_revision and base_revision are
238
automatically pulled into the branch.
240
from bzrlib.revision import common_ancestor, MultipleRevisionSources
241
from bzrlib.errors import NoSuchRevision
242
tempdir = tempfile.mkdtemp(prefix="bzr-")
246
this_branch = find_branch(this_dir)
247
this_rev_id = this_branch.last_patch()
248
if this_rev_id is None:
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:
249
145
raise BzrCommandError("This branch has no commits")
251
changes = compare_trees(this_branch.working_tree(),
252
this_branch.basis_tree(), False)
253
if changes.has_changed():
148
if self.this_basis != self.this_rev_id:
254
149
raise BzrCommandError("Working tree has uncommitted changes.")
255
other_branch, other_tree = get_tree(other_revision, tempdir, "other",
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):
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
169
interesting_ids = set()
170
for path in file_list:
172
for tree in (self.this_tree, self.base_tree, self.other_tree):
173
file_id = tree.inventory.path2id(path)
174
if file_id is not None:
175
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,
257
200
if other_revision[1] == -1:
258
other_rev_id = other_branch.last_patch()
259
other_basis = other_rev_id
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
260
205
elif other_revision[1] is not None:
261
other_rev_id = other_branch.lookup_revision(other_revision[1])
262
other_basis = other_rev_id
206
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
207
self.other_basis = self.other_rev_id
265
other_basis = other_branch.last_patch()
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")
266
225
if base_revision == [None, None]:
267
base_rev_id = common_ancestor(this_rev_id, other_basis,
269
if base_rev_id is 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:
270
236
raise UnrelatedBranches()
271
base_tree = get_revid_tree(this_branch, base_rev_id, tempdir,
273
base_is_ancestor = True
237
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
239
self.base_is_ancestor = True
275
base_branch, base_tree = get_tree(base_revision, tempdir, "base")
241
base_branch, self.base_tree = _get_tree(base_revision)
276
242
if base_revision[1] == -1:
277
base_rev_id = base_branch.last_patch()
243
self.base_rev_id = base_branch.last_revision()
278
244
elif base_revision[1] is None:
281
base_rev_id = base_branch.lookup_revision(base_revision[1])
282
if base_rev_id is not None:
283
base_is_ancestor = is_ancestor(this_rev_id, base_rev_id,
284
MultipleRevisionSources(this_branch,
287
base_is_ancestor = False
288
if file_list is None:
289
interesting_ids = None
291
interesting_ids = set()
292
this_tree = this_branch.working_tree()
293
for fname in file_list:
294
path = this_branch.relpath(fname)
296
for tree in (this_tree, base_tree.tree, other_tree.tree):
297
file_id = tree.inventory.path2id(path)
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)
298
772
if file_id is not None:
299
interesting_ids.add(file_id)
302
raise BzrCommandError("%s is not a source file in any"
304
merge_inner(this_branch, other_tree, base_tree, tempdir,
305
ignore_zero=ignore_zero, backup_files=backup_files,
306
merge_type=merge_type, interesting_ids=interesting_ids)
307
if base_is_ancestor and other_rev_id is not None\
308
and other_rev_id not in this_branch.revision_history():
309
this_branch.add_pending_merge(other_rev_id)
311
shutil.rmtree(tempdir)
314
def set_interesting(inventory_a, inventory_b, interesting_ids):
315
"""Mark files whose ids are in interesting_ids as interesting
317
for inventory in (inventory_a, inventory_b):
318
for path, source_file in inventory.iteritems():
319
source_file.interesting = source_file.id in interesting_ids
322
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
323
"""Generate a changeset. If interesting_ids is supplied, only changes
324
to those files will be shown. Metadata changes are stripped.
326
cset = generate_changeset(tree_a, tree_b, interesting_ids)
327
for entry in cset.entries.itervalues():
328
entry.metadata_change = None
332
def merge_inner(this_branch, other_tree, base_tree, tempdir,
333
ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
334
interesting_ids=None):
336
def merge_factory(file_id, base, other):
337
contents_change = merge_type(file_id, base, other)
339
contents_change = BackupBeforeChange(contents_change)
340
return contents_change
342
this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
344
def get_inventory(tree):
345
return tree.tree.inventory
347
inv_changes = merge_flex(this_tree, base_tree, other_tree,
348
generate_cset_optimized, get_inventory,
349
MergeConflictHandler(base_tree.root,
350
ignore_zero=ignore_zero),
351
merge_factory=merge_factory,
352
interesting_ids=interesting_ids)
355
for id, path in inv_changes.iteritems():
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)
360
assert path.startswith('./'), "path is %s" % path
362
adjust_ids.append((path, id))
363
if len(adjust_ids) > 0:
364
this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
368
def regen_inventory(this_branch, root, new_entries):
369
old_entries = this_branch.read_working_inventory()
373
for path, file_id in new_entries:
376
new_entries_map[file_id] = path
378
def id2path(file_id):
379
path = new_entries_map.get(file_id)
382
entry = old_entries[file_id]
383
if entry.parent_id is None:
385
return os.path.join(id2path(entry.parent_id), entry.name)
387
for file_id in old_entries:
388
entry = old_entries[file_id]
389
path = id2path(file_id)
390
new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
391
by_path[path] = file_id
396
for path, file_id in new_entries:
398
del new_inventory[file_id]
401
new_path_list.append((path, file_id))
402
if file_id not in old_entries:
404
# Ensure no file is added before its parent
406
for path, file_id in new_path_list:
410
parent = by_path[os.path.dirname(path)]
411
kind = bzrlib.osutils.file_kind(os.path.join(root, path))
412
new_inventory[file_id] = (path, file_id, parent, kind)
413
by_path[path] = file_id
415
# Get a list in insertion order
416
new_inventory_list = new_inventory.values()
417
mutter ("""Inventory regeneration:
418
old length: %i insertions: %i deletions: %i new_length: %i"""\
419
% (len(old_entries), insertions, deletions, len(new_inventory_list)))
420
assert len(new_inventory_list) == len(old_entries) + insertions - deletions
421
new_inventory_list.sort()
422
return new_inventory_list
424
merge_types = { "merge3": (ApplyMerge3, "Native diff3-style merge"),
425
"diff3": (Diff3Merge, "Merge using external diff3")
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,
935
"""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")
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)