1
from merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
2
from changeset import generate_changeset, ExceptionConflictHandler
3
from changeset import Inventory, Diff3Merge
4
from bzrlib import find_branch
1
# Copyright (C) 2005, 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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
5
41
import bzrlib.osutils
6
from bzrlib.errors import BzrCommandError
7
from bzrlib.delta import compare_trees
8
from trace import mutter, warning
14
class UnrelatedBranches(BzrCommandError):
16
msg = "Branches have no common ancestor, and no base revision"\
18
BzrCommandError.__init__(self, msg)
21
class MergeConflictHandler(ExceptionConflictHandler):
22
"""Handle conflicts encountered while merging"""
23
def __init__(self, dir, ignore_zero=False):
24
ExceptionConflictHandler.__init__(self, dir)
26
self.ignore_zero = ignore_zero
28
def copy(self, source, dest):
29
"""Copy the text and mode of a file
30
:param source: The path of the file to copy
31
:param dest: The distination file to create
33
s_file = file(source, "rb")
34
d_file = file(dest, "wb")
37
os.chmod(dest, 0777 & os.stat(source).st_mode)
39
def add_suffix(self, name, suffix, last_new_name=None):
40
"""Rename a file to append a suffix. If the new name exists, the
41
suffix is added repeatedly until a non-existant name is found
43
:param name: The path of the file
44
:param suffix: The suffix to append
45
:param last_new_name: (used for recursive calls) the last name tried
47
if last_new_name is None:
49
new_name = last_new_name+suffix
51
os.rename(name, new_name)
54
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
56
return self.add_suffix(name, suffix, last_new_name=new_name)
58
def conflict(self, text):
63
def merge_conflict(self, new_file, this_path, base_path, other_path):
65
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
66
main file will be a version with diff3 conflicts.
67
:param new_file: Path to the output file with diff3 markers
68
:param this_path: Path to the file text for the THIS tree
69
:param base_path: Path to the file text for the BASE tree
70
:param other_path: Path to the file text for the OTHER tree
72
self.add_suffix(this_path, ".THIS")
73
self.copy(base_path, this_path+".BASE")
74
self.copy(other_path, this_path+".OTHER")
75
os.rename(new_file, this_path)
76
self.conflict("Diff3 conflict encountered in %s" % this_path)
78
def target_exists(self, entry, target, old_path):
79
"""Handle the case when the target file or dir exists"""
80
moved_path = self.add_suffix(target, ".moved")
81
self.conflict("Moved existing %s to %s" % (target, moved_path))
83
def rmdir_non_empty(self, filename):
84
"""Handle the case where the dir to be removed still has contents"""
85
self.conflict("Directory %s not removed because it is not empty"\
90
if not self.ignore_zero:
91
print "%d conflicts encountered.\n" % self.conflicts
93
class SourceFile(object):
94
def __init__(self, path, id, present=None, isdir=None):
97
self.present = present
99
self.interesting = True
102
return "SourceFile(%s, %s)" % (self.path, self.id)
104
def get_tree(treespec, temp_root, label):
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)
49
from bzrlib.versionedfile import WeaveMerge
52
# TODO: Report back as changes are merged in
54
def _get_tree(treespec, local_branch=None):
55
from bzrlib import workingtree
105
56
location, revno = treespec
106
branch = find_branch(location)
108
base_tree = branch.working_tree()
110
base_tree = branch.basis_tree()
112
base_tree = branch.revision_tree(branch.lookup_revision(revno))
113
temp_path = os.path.join(temp_root, label)
115
return branch, MergeTree(base_tree, temp_path)
118
def abspath(tree, file_id):
119
path = tree.inventory.id2path(file_id)
124
def file_exists(tree, file_id):
125
return tree.has_filename(tree.id2path(file_id))
127
def inventory_map(tree):
129
for file_id in tree.inventory:
130
path = abspath(tree, file_id)
131
inventory[path] = SourceFile(path, file_id)
135
class MergeTree(object):
136
def __init__(self, tree, tempdir):
58
tree = workingtree.WorkingTree.open_containing(location)[0]
59
return tree.branch, tree
60
branch = Branch.open_containing(location)[0]
62
revision = branch.last_revision()
64
revision = branch.get_rev_id(revno)
66
revision = NULL_REVISION
67
return branch, _get_revid_tree(branch, revision, local_branch)
70
def _get_revid_tree(branch, revision, local_branch):
72
base_tree = branch.bzrdir.open_workingtree()
74
if local_branch is not None:
75
if local_branch.base != branch.base:
76
local_branch.fetch(branch, revision)
77
base_tree = local_branch.repository.revision_tree(revision)
79
base_tree = branch.repository.revision_tree(revision)
83
def transform_tree(from_tree, to_tree, interesting_ids=None):
84
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
85
interesting_ids=interesting_ids, this_tree=from_tree)
89
def __init__(self, this_branch, other_tree=None, base_tree=None,
90
this_tree=None, pb=DummyProgress()):
137
91
object.__init__(self)
138
if hasattr(tree, "basedir"):
139
self.root = tree.basedir
142
self.inventory = inventory_map(tree)
144
self.tempdir = tempdir
145
os.mkdir(os.path.join(self.tempdir, "texts"))
148
def readonly_path(self, id):
149
if id not in self.tree:
151
if self.root is not None:
152
return self.tree.abspath(self.tree.id2path(id))
154
if self.tree.inventory[id].kind in ("directory", "root_directory"):
156
if not self.cached.has_key(id):
157
path = os.path.join(self.tempdir, "texts", id)
158
outfile = file(path, "wb")
159
outfile.write(self.tree.get_file(id).read())
160
assert(os.path.exists(path))
161
self.cached[id] = path
162
return self.cached[id]
166
def merge(other_revision, base_revision,
167
check_clean=True, ignore_zero=False,
168
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
170
"""Merge changes into a tree.
173
Base for three-way merge.
175
Other revision for three-way merge.
177
Directory to merge changes into; '.' by default.
179
If true, this_dir must have no uncommitted changes before the
182
tempdir = tempfile.mkdtemp(prefix="bzr-")
186
this_branch = find_branch(this_dir)
92
assert this_tree is not None, "this_tree is required"
93
self.this_branch = this_branch
94
self.this_basis = this_branch.last_revision()
95
self.this_rev_id = None
96
self.this_tree = this_tree
97
self.this_revision_tree = None
98
self.this_basis_tree = None
99
self.other_tree = other_tree
100
self.base_tree = base_tree
101
self.ignore_zero = False
102
self.backup_files = False
103
self.interesting_ids = None
104
self.show_base = False
105
self.reprocess = False
110
def revision_tree(self, revision_id):
111
return self.this_branch.repository.revision_tree(revision_id)
113
def ensure_revision_trees(self):
114
if self.this_revision_tree is None:
115
self.this_basis_tree = self.this_branch.repository.revision_tree(
117
if self.this_basis == self.this_rev_id:
118
self.this_revision_tree = self.this_basis_tree
120
if self.other_rev_id is None:
121
other_basis_tree = self.revision_tree(self.other_basis)
122
changes = other_basis_tree.changes_from(self.other_tree)
123
if changes.has_changed():
124
raise WorkingTreeNotRevision(self.this_tree)
125
other_rev_id = self.other_basis
126
self.other_tree = other_basis_tree
128
def file_revisions(self, file_id):
129
self.ensure_revision_trees()
130
def get_id(tree, file_id):
131
revision_id = tree.inventory[file_id].revision
132
assert revision_id is not None
134
if self.this_rev_id is None:
135
if self.this_basis_tree.get_file_sha1(file_id) != \
136
self.this_tree.get_file_sha1(file_id):
137
raise WorkingTreeNotRevision(self.this_tree)
139
trees = (self.this_basis_tree, self.other_tree)
140
return [get_id(tree, file_id) for tree in trees]
142
def check_basis(self, check_clean, require_commits=True):
143
if self.this_basis is None and require_commits is True:
144
raise BzrCommandError("This branch has no commits")
188
changes = compare_trees(this_branch.working_tree(),
189
this_branch.basis_tree(), False)
190
if changes.has_changed():
147
if self.this_basis != self.this_rev_id:
191
148
raise BzrCommandError("Working tree has uncommitted changes.")
192
other_branch, other_tree = get_tree(other_revision, tempdir, "other")
150
def compare_basis(self):
151
changes = self.this_tree.changes_from(self.this_tree.basis_tree())
152
if not changes.has_changed():
153
self.this_rev_id = self.this_basis
155
def set_interesting_files(self, file_list):
157
self._set_interesting_files(file_list)
158
except NotVersionedError, e:
159
raise BzrCommandError("%s is not a source file in any"
162
def _set_interesting_files(self, file_list):
163
"""Set the list of interesting ids from a list of files."""
164
if file_list is None:
165
self.interesting_ids = None
168
interesting_ids = set()
169
for path in file_list:
171
for tree in (self.this_tree, self.base_tree, self.other_tree):
172
file_id = tree.inventory.path2id(path)
173
if file_id is not None:
174
interesting_ids.add(file_id)
177
raise NotVersionedError(path=path)
178
self.interesting_ids = interesting_ids
180
def set_pending(self):
181
if not self.base_is_ancestor:
183
if self.other_rev_id is None:
185
ancestry = self.this_branch.repository.get_ancestry(self.this_basis)
186
if self.other_rev_id in ancestry:
188
self.this_tree.add_parent_tree((self.other_rev_id, self.other_tree))
190
def set_other(self, other_revision):
191
"""Set the revision and tree to merge from.
193
This sets the other_tree, other_rev_id, other_basis attributes.
195
:param other_revision: The [path, revision] list to merge from.
197
other_branch, self.other_tree = _get_tree(other_revision,
199
if other_revision[1] == -1:
200
self.other_rev_id = other_branch.last_revision()
201
if self.other_rev_id is None:
202
raise NoCommits(other_branch)
203
self.other_basis = self.other_rev_id
204
elif other_revision[1] is not None:
205
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
206
self.other_basis = self.other_rev_id
208
self.other_rev_id = None
209
self.other_basis = other_branch.last_revision()
210
if self.other_basis is None:
211
raise NoCommits(other_branch)
212
if other_branch.base != self.this_branch.base:
213
self.this_branch.fetch(other_branch, last_revision=self.other_basis)
216
self.set_base([None, None])
218
def set_base(self, base_revision):
219
"""Set the base revision to use for the merge.
221
:param base_revision: A 2-list containing a path and revision number.
223
mutter("doing merge() with no base_revision specified")
193
224
if base_revision == [None, None]:
194
if other_revision[1] == -1:
197
o_revno = other_revision[1]
198
base_revno = this_branch.common_ancestor(other_branch,
199
other_revno=o_revno)[0]
200
if base_revno is None:
226
pb = bzrlib.ui.ui_factory.nested_progress_bar()
228
this_repo = self.this_branch.repository
229
self.base_rev_id = common_ancestor(self.this_basis,
234
except NoCommonAncestor:
201
235
raise UnrelatedBranches()
202
base_revision = ['.', base_revno]
203
base_branch, base_tree = get_tree(base_revision, tempdir, "base")
204
if file_list is None:
205
interesting_ids = None
207
interesting_ids = set()
208
this_tree = this_branch.working_tree()
209
for fname in file_list:
210
path = this_branch.relpath(fname)
212
for tree in (this_tree, base_tree.tree, other_tree.tree):
213
file_id = tree.inventory.path2id(path)
236
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
238
self.base_is_ancestor = True
240
base_branch, self.base_tree = _get_tree(base_revision)
241
if base_revision[1] == -1:
242
self.base_rev_id = base_branch.last_revision()
243
elif base_revision[1] is None:
244
self.base_rev_id = None
246
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
247
if self.this_branch.base != base_branch.base:
248
self.this_branch.fetch(base_branch)
249
self.base_is_ancestor = is_ancestor(self.this_basis,
254
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
255
'other_tree': self.other_tree,
256
'interesting_ids': self.interesting_ids,
258
if self.merge_type.requires_base:
259
kwargs['base_tree'] = self.base_tree
260
if self.merge_type.supports_reprocess:
261
kwargs['reprocess'] = self.reprocess
263
raise BzrError("Conflict reduction is not supported for merge"
264
" type %s." % self.merge_type)
265
if self.merge_type.supports_show_base:
266
kwargs['show_base'] = self.show_base
268
raise BzrError("Showing base is not supported for this"
269
" merge type. %s" % self.merge_type)
270
merge = self.merge_type(pb=self._pb, **kwargs)
271
if len(merge.cooked_conflicts) == 0:
272
if not self.ignore_zero:
273
note("All changes applied successfully.")
275
note("%d conflicts encountered." % len(merge.cooked_conflicts))
277
return len(merge.cooked_conflicts)
279
def regen_inventory(self, new_entries):
280
old_entries = self.this_tree.read_working_inventory()
284
for path, file_id in new_entries:
287
new_entries_map[file_id] = path
289
def id2path(file_id):
290
path = new_entries_map.get(file_id)
293
entry = old_entries[file_id]
294
if entry.parent_id is None:
296
return pathjoin(id2path(entry.parent_id), entry.name)
298
for file_id in old_entries:
299
entry = old_entries[file_id]
300
path = id2path(file_id)
301
if file_id in self.base_tree.inventory:
302
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
304
executable = getattr(entry, 'executable', False)
305
new_inventory[file_id] = (path, file_id, entry.parent_id,
306
entry.kind, executable)
308
by_path[path] = file_id
313
for path, file_id in new_entries:
315
del new_inventory[file_id]
318
new_path_list.append((path, file_id))
319
if file_id not in old_entries:
321
# Ensure no file is added before its parent
323
for path, file_id in new_path_list:
327
parent = by_path[os.path.dirname(path)]
328
abspath = pathjoin(self.this_tree.basedir, path)
329
kind = bzrlib.osutils.file_kind(abspath)
330
if file_id in self.base_tree.inventory:
331
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
334
new_inventory[file_id] = (path, file_id, parent, kind, executable)
335
by_path[path] = file_id
337
# Get a list in insertion order
338
new_inventory_list = new_inventory.values()
339
mutter ("""Inventory regeneration:
340
old length: %i insertions: %i deletions: %i new_length: %i"""\
341
% (len(old_entries), insertions, deletions,
342
len(new_inventory_list)))
343
assert len(new_inventory_list) == len(old_entries) + insertions\
345
new_inventory_list.sort()
346
return new_inventory_list
349
class Merge3Merger(object):
350
"""Three-way merger that uses the merge3 text merger"""
352
supports_reprocess = True
353
supports_show_base = True
354
history_based = False
356
def __init__(self, working_tree, this_tree, base_tree, other_tree,
357
interesting_ids=None, reprocess=False, show_base=False,
358
pb=DummyProgress(), pp=None):
359
"""Initialize the merger object and perform the merge."""
360
object.__init__(self)
361
self.this_tree = working_tree
362
self.base_tree = base_tree
363
self.other_tree = other_tree
364
self._raw_conflicts = []
365
self.cooked_conflicts = []
366
self.reprocess = reprocess
367
self.show_base = show_base
371
self.pp = ProgressPhase("Merge phase", 3, self.pb)
373
if interesting_ids is not None:
374
all_ids = interesting_ids
376
all_ids = set(base_tree)
377
all_ids.update(other_tree)
378
working_tree.lock_write()
379
self.tt = TreeTransform(working_tree, self.pb)
382
child_pb = ui.ui_factory.nested_progress_bar()
384
for num, file_id in enumerate(all_ids):
385
child_pb.update('Preparing file merge', num, len(all_ids))
386
self.merge_names(file_id)
387
file_status = self.merge_contents(file_id)
388
self.merge_executable(file_id, file_status)
393
child_pb = ui.ui_factory.nested_progress_bar()
395
fs_conflicts = resolve_conflicts(self.tt, child_pb)
398
self.cook_conflicts(fs_conflicts)
399
for conflict in self.cooked_conflicts:
402
results = self.tt.apply()
403
self.write_modified(results)
405
working_tree.add_conflicts(self.cooked_conflicts)
406
except UnsupportedOperation:
410
working_tree.unlock()
413
def write_modified(self, results):
415
for path in results.modified_paths:
416
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
419
hash = self.this_tree.get_file_sha1(file_id)
422
modified_hashes[file_id] = hash
423
self.this_tree.set_merge_modified(modified_hashes)
426
def parent(entry, file_id):
427
"""Determine the parent for a file_id (used as a key method)"""
430
return entry.parent_id
433
def name(entry, file_id):
434
"""Determine the name for a file_id (used as a key method)"""
440
def contents_sha1(tree, file_id):
441
"""Determine the sha1 of the file contents (used as a key method)."""
442
if file_id not in tree:
444
return tree.get_file_sha1(file_id)
447
def executable(tree, file_id):
448
"""Determine the executability of a file-id (used as a key method)."""
449
if file_id not in tree:
451
if tree.kind(file_id) != "file":
453
return tree.is_executable(file_id)
456
def kind(tree, file_id):
457
"""Determine the kind of a file-id (used as a key method)."""
458
if file_id not in tree:
460
return tree.kind(file_id)
463
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
464
"""Do a three-way test on a scalar.
465
Return "this", "other" or "conflict", depending whether a value wins.
467
key_base = key(base_tree, file_id)
468
key_other = key(other_tree, file_id)
469
#if base == other, either they all agree, or only THIS has changed.
470
if key_base == key_other:
472
key_this = key(this_tree, file_id)
473
if key_this not in (key_base, key_other):
475
# "Ambiguous clean merge"
476
elif key_this == key_other:
479
assert key_this == key_base
482
def merge_names(self, file_id):
483
"""Perform a merge on file_id names and parents"""
485
if file_id in tree.inventory:
486
return tree.inventory[file_id]
489
this_entry = get_entry(self.this_tree)
490
other_entry = get_entry(self.other_tree)
491
base_entry = get_entry(self.base_tree)
492
name_winner = self.scalar_three_way(this_entry, base_entry,
493
other_entry, file_id, self.name)
494
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
495
other_entry, file_id,
497
if this_entry is None:
498
if name_winner == "this":
499
name_winner = "other"
500
if parent_id_winner == "this":
501
parent_id_winner = "other"
502
if name_winner == "this" and parent_id_winner == "this":
504
if name_winner == "conflict":
505
trans_id = self.tt.trans_id_file_id(file_id)
506
self._raw_conflicts.append(('name conflict', trans_id,
507
self.name(this_entry, file_id),
508
self.name(other_entry, file_id)))
509
if parent_id_winner == "conflict":
510
trans_id = self.tt.trans_id_file_id(file_id)
511
self._raw_conflicts.append(('parent conflict', trans_id,
512
self.parent(this_entry, file_id),
513
self.parent(other_entry, file_id)))
514
if other_entry is None:
515
# it doesn't matter whether the result was 'other' or
516
# 'conflict'-- if there's no 'other', we leave it alone.
518
# if we get here, name_winner and parent_winner are set to safe values.
519
winner_entry = {"this": this_entry, "other": other_entry,
520
"conflict": other_entry}
521
trans_id = self.tt.trans_id_file_id(file_id)
522
parent_id = winner_entry[parent_id_winner].parent_id
523
parent_trans_id = self.tt.trans_id_file_id(parent_id)
524
self.tt.adjust_path(winner_entry[name_winner].name, parent_trans_id,
527
def merge_contents(self, file_id):
528
"""Performa a merge on file_id contents."""
529
def contents_pair(tree):
530
if file_id not in tree:
532
kind = tree.kind(file_id)
534
contents = tree.get_file_sha1(file_id)
535
elif kind == "symlink":
536
contents = tree.get_symlink_target(file_id)
539
return kind, contents
541
def contents_conflict():
542
trans_id = self.tt.trans_id_file_id(file_id)
543
name = self.tt.final_name(trans_id)
544
parent_id = self.tt.final_parent(trans_id)
545
if file_id in self.this_tree.inventory:
546
self.tt.unversion_file(trans_id)
547
self.tt.delete_contents(trans_id)
548
file_group = self._dump_conflicts(name, parent_id, file_id,
550
self._raw_conflicts.append(('contents conflict', file_group))
552
# See SPOT run. run, SPOT, run.
553
# So we're not QUITE repeating ourselves; we do tricky things with
555
base_pair = contents_pair(self.base_tree)
556
other_pair = contents_pair(self.other_tree)
557
if base_pair == other_pair:
558
# OTHER introduced no changes
560
this_pair = contents_pair(self.this_tree)
561
if this_pair == other_pair:
562
# THIS and OTHER introduced the same changes
565
trans_id = self.tt.trans_id_file_id(file_id)
566
if this_pair == base_pair:
567
# only OTHER introduced changes
568
if file_id in self.this_tree:
569
# Remove any existing contents
570
self.tt.delete_contents(trans_id)
571
if file_id in self.other_tree:
572
# OTHER changed the file
573
create_by_entry(self.tt,
574
self.other_tree.inventory[file_id],
575
self.other_tree, trans_id)
576
if file_id not in self.this_tree.inventory:
577
self.tt.version_file(file_id, trans_id)
579
elif file_id in self.this_tree.inventory:
580
# OTHER deleted the file
581
self.tt.unversion_file(trans_id)
583
#BOTH THIS and OTHER introduced changes; scalar conflict
584
elif this_pair[0] == "file" and other_pair[0] == "file":
585
# THIS and OTHER are both files, so text merge. Either
586
# BASE is a file, or both converted to files, so at least we
587
# have agreement that output should be a file.
589
self.text_merge(file_id, trans_id)
591
return contents_conflict()
592
if file_id not in self.this_tree.inventory:
593
self.tt.version_file(file_id, trans_id)
595
self.tt.tree_kind(trans_id)
596
self.tt.delete_contents(trans_id)
601
# Scalar conflict, can't text merge. Dump conflicts
602
return contents_conflict()
604
def get_lines(self, tree, file_id):
605
"""Return the lines in a file, or an empty list."""
607
return tree.get_file(file_id).readlines()
611
def text_merge(self, file_id, trans_id):
612
"""Perform a three-way text merge on a file_id"""
613
# it's possible that we got here with base as a different type.
614
# if so, we just want two-way text conflicts.
615
if file_id in self.base_tree and \
616
self.base_tree.kind(file_id) == "file":
617
base_lines = self.get_lines(self.base_tree, file_id)
620
other_lines = self.get_lines(self.other_tree, file_id)
621
this_lines = self.get_lines(self.this_tree, file_id)
622
m3 = Merge3(base_lines, this_lines, other_lines)
623
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
624
if self.show_base is True:
625
base_marker = '|' * 7
629
def iter_merge3(retval):
630
retval["text_conflicts"] = False
631
for line in m3.merge_lines(name_a = "TREE",
632
name_b = "MERGE-SOURCE",
633
name_base = "BASE-REVISION",
634
start_marker=start_marker,
635
base_marker=base_marker,
636
reprocess=self.reprocess):
637
if line.startswith(start_marker):
638
retval["text_conflicts"] = True
639
yield line.replace(start_marker, '<' * 7)
643
merge3_iterator = iter_merge3(retval)
644
self.tt.create_file(merge3_iterator, trans_id)
645
if retval["text_conflicts"] is True:
646
self._raw_conflicts.append(('text conflict', trans_id))
647
name = self.tt.final_name(trans_id)
648
parent_id = self.tt.final_parent(trans_id)
649
file_group = self._dump_conflicts(name, parent_id, file_id,
650
this_lines, base_lines,
652
file_group.append(trans_id)
654
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
655
base_lines=None, other_lines=None, set_version=False,
657
"""Emit conflict files.
658
If this_lines, base_lines, or other_lines are omitted, they will be
659
determined automatically. If set_version is true, the .OTHER, .THIS
660
or .BASE (in that order) will be created as versioned files.
662
data = [('OTHER', self.other_tree, other_lines),
663
('THIS', self.this_tree, this_lines)]
665
data.append(('BASE', self.base_tree, base_lines))
668
for suffix, tree, lines in data:
670
trans_id = self._conflict_file(name, parent_id, tree, file_id,
672
file_group.append(trans_id)
673
if set_version and not versioned:
674
self.tt.version_file(file_id, trans_id)
678
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
680
"""Emit a single conflict file."""
681
name = name + '.' + suffix
682
trans_id = self.tt.create_path(name, parent_id)
683
entry = tree.inventory[file_id]
684
create_by_entry(self.tt, entry, tree, trans_id, lines)
687
def merge_executable(self, file_id, file_status):
688
"""Perform a merge on the execute bit."""
689
if file_status == "deleted":
691
trans_id = self.tt.trans_id_file_id(file_id)
693
if self.tt.final_kind(trans_id) != "file":
697
winner = self.scalar_three_way(self.this_tree, self.base_tree,
698
self.other_tree, file_id,
700
if winner == "conflict":
701
# There must be a None in here, if we have a conflict, but we
702
# need executability since file status was not deleted.
703
if self.executable(self.other_tree, file_id) is None:
708
if file_status == "modified":
709
executability = self.this_tree.is_executable(file_id)
710
if executability is not None:
711
trans_id = self.tt.trans_id_file_id(file_id)
712
self.tt.set_executability(executability, trans_id)
714
assert winner == "other"
715
if file_id in self.other_tree:
716
executability = self.other_tree.is_executable(file_id)
717
elif file_id in self.this_tree:
718
executability = self.this_tree.is_executable(file_id)
719
elif file_id in self.base_tree:
720
executability = self.base_tree.is_executable(file_id)
721
if executability is not None:
722
trans_id = self.tt.trans_id_file_id(file_id)
723
self.tt.set_executability(executability, trans_id)
725
def cook_conflicts(self, fs_conflicts):
726
"""Convert all conflicts into a form that doesn't depend on trans_id"""
727
from conflicts import Conflict
729
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
730
fp = FinalPaths(self.tt)
731
for conflict in self._raw_conflicts:
732
conflict_type = conflict[0]
733
if conflict_type in ('name conflict', 'parent conflict'):
734
trans_id = conflict[1]
735
conflict_args = conflict[2:]
736
if trans_id not in name_conflicts:
737
name_conflicts[trans_id] = {}
738
unique_add(name_conflicts[trans_id], conflict_type,
740
if conflict_type == 'contents conflict':
741
for trans_id in conflict[1]:
742
file_id = self.tt.final_file_id(trans_id)
214
743
if file_id is not None:
215
interesting_ids.add(file_id)
218
raise BzrCommandError("%s is not a source file in any"
220
merge_inner(this_branch, other_tree, base_tree, tempdir,
221
ignore_zero=ignore_zero, backup_files=backup_files,
222
merge_type=merge_type, interesting_ids=interesting_ids)
224
shutil.rmtree(tempdir)
227
def set_interesting(inventory_a, inventory_b, interesting_ids):
228
"""Mark files whose ids are in interesting_ids as interesting
230
for inventory in (inventory_a, inventory_b):
231
for path, source_file in inventory.iteritems():
232
source_file.interesting = source_file.id in interesting_ids
235
def set_optimized(tree_a, tree_b, inventory_a, inventory_b):
236
"""Mark files that have changed texts as interesting
238
for file_id in tree_a.tree.inventory:
239
if file_id not in tree_b.tree.inventory:
241
entry_a = tree_a.tree.inventory[file_id]
242
entry_b = tree_b.tree.inventory[file_id]
243
if (entry_a.kind, entry_b.kind) != ("file", "file"):
245
if None in (entry_a.text_id, entry_b.text_id):
247
if entry_a.text_id != entry_b.text_id:
249
inventory_a[abspath(tree_a.tree, file_id)].interesting = False
250
inventory_b[abspath(tree_b.tree, file_id)].interesting = False
253
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
254
interesting_ids=None):
255
"""Generate a changeset, with preprocessing to select interesting files.
256
using the text_id to mark really-changed files.
257
This permits blazing comparisons when text_ids are present. It also
258
disables metadata comparison for files with identical texts.
260
if interesting_ids is None:
261
set_optimized(tree_a, tree_b, inventory_a, inventory_b)
263
set_interesting(inventory_a, inventory_b, interesting_ids)
264
cset = generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
265
for entry in cset.entries.itervalues():
266
entry.metadata_change = None
270
def merge_inner(this_branch, other_tree, base_tree, tempdir,
271
ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
272
interesting_ids=None):
274
def merge_factory(base_file, other_file):
275
contents_change = merge_type(base_file, other_file)
277
contents_change = BackupBeforeChange(contents_change)
278
return contents_change
280
def generate_cset(tree_a, tree_b, inventory_a, inventory_b):
281
return generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b,
284
this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
286
def get_inventory(tree):
287
return tree.inventory
289
inv_changes = merge_flex(this_tree, base_tree, other_tree,
290
generate_cset, get_inventory,
291
MergeConflictHandler(base_tree.root,
292
ignore_zero=ignore_zero),
293
merge_factory=merge_factory)
296
for id, path in inv_changes.iteritems():
745
path = fp.get_path(trans_id)
746
for suffix in ('.BASE', '.THIS', '.OTHER'):
747
if path.endswith(suffix):
748
path = path[:-len(suffix)]
750
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
751
self.cooked_conflicts.append(c)
752
if conflict_type == 'text conflict':
753
trans_id = conflict[1]
754
path = fp.get_path(trans_id)
755
file_id = self.tt.final_file_id(trans_id)
756
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
757
self.cooked_conflicts.append(c)
759
for trans_id, conflicts in name_conflicts.iteritems():
761
this_parent, other_parent = conflicts['parent conflict']
762
assert this_parent != other_parent
764
this_parent = other_parent = \
765
self.tt.final_file_id(self.tt.final_parent(trans_id))
767
this_name, other_name = conflicts['name conflict']
768
assert this_name != other_name
770
this_name = other_name = self.tt.final_name(trans_id)
771
other_path = fp.get_path(trans_id)
772
if this_parent is not None:
774
fp.get_path(self.tt.trans_id_file_id(this_parent))
775
this_path = pathjoin(this_parent_path, this_name)
301
assert path.startswith('./')
303
adjust_ids.append((path, id))
304
this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
307
def regen_inventory(this_branch, root, new_entries):
308
old_entries = this_branch.read_working_inventory()
311
for file_id in old_entries:
312
entry = old_entries[file_id]
313
path = old_entries.id2path(file_id)
314
new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
315
by_path[path] = file_id
320
for path, file_id in new_entries:
322
del new_inventory[file_id]
325
new_path_list.append((path, file_id))
326
if file_id not in old_entries:
328
# Ensure no file is added before its parent
330
for path, file_id in new_path_list:
334
parent = by_path[os.path.dirname(path)]
335
kind = bzrlib.osutils.file_kind(os.path.join(root, path))
336
new_inventory[file_id] = (path, file_id, parent, kind)
337
by_path[path] = file_id
339
# Get a list in insertion order
340
new_inventory_list = new_inventory.values()
341
mutter ("""Inventory regeneration:
342
old length: %i insertions: %i deletions: %i new_length: %i"""\
343
% (len(old_entries), insertions, deletions, len(new_inventory_list)))
344
assert len(new_inventory_list) == len(old_entries) + insertions - deletions
345
new_inventory_list.sort()
346
return new_inventory_list
348
merge_types = { "merge3": (ApplyMerge3, "Native diff3-style merge"),
349
"diff3": (Diff3Merge, "Merge using external diff3")
777
this_path = "<deleted>"
778
file_id = self.tt.final_file_id(trans_id)
779
c = Conflict.factory('path conflict', path=this_path,
780
conflict_path=other_path, file_id=file_id)
781
self.cooked_conflicts.append(c)
782
self.cooked_conflicts.sort(key=Conflict.sort_key)
785
class WeaveMerger(Merge3Merger):
786
"""Three-way tree merger, text weave merger."""
787
supports_reprocess = True
788
supports_show_base = False
790
def __init__(self, working_tree, this_tree, base_tree, other_tree,
791
interesting_ids=None, pb=DummyProgress(), pp=None,
793
self.this_revision_tree = self._get_revision_tree(this_tree)
794
self.other_revision_tree = self._get_revision_tree(other_tree)
795
super(WeaveMerger, self).__init__(working_tree, this_tree,
796
base_tree, other_tree,
797
interesting_ids=interesting_ids,
798
pb=pb, pp=pp, reprocess=reprocess)
800
def _get_revision_tree(self, tree):
801
"""Return a revision tree related to this tree.
802
If the tree is a WorkingTree, the basis will be returned.
804
if getattr(tree, 'get_weave', False) is False:
805
# If we have a WorkingTree, try using the basis
806
return tree.branch.basis_tree()
810
def _check_file(self, file_id):
811
"""Check that the revision tree's version of the file matches."""
812
for tree, rt in ((self.this_tree, self.this_revision_tree),
813
(self.other_tree, self.other_revision_tree)):
816
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
817
raise WorkingTreeNotRevision(self.this_tree)
819
def _merged_lines(self, file_id):
820
"""Generate the merged lines.
821
There is no distinction between lines that are meant to contain <<<<<<<
824
weave = self.this_revision_tree.get_weave(file_id)
825
this_revision_id = self.this_revision_tree.inventory[file_id].revision
826
other_revision_id = \
827
self.other_revision_tree.inventory[file_id].revision
828
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
829
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
830
return wm.merge_lines(self.reprocess)
832
def text_merge(self, file_id, trans_id):
833
"""Perform a (weave) text merge for a given file and file-id.
834
If conflicts are encountered, .THIS and .OTHER files will be emitted,
835
and a conflict will be noted.
837
self._check_file(file_id)
838
lines, conflicts = self._merged_lines(file_id)
840
# Note we're checking whether the OUTPUT is binary in this case,
841
# because we don't want to get into weave merge guts.
842
check_text_lines(lines)
843
self.tt.create_file(lines, trans_id)
845
self._raw_conflicts.append(('text conflict', trans_id))
846
name = self.tt.final_name(trans_id)
847
parent_id = self.tt.final_parent(trans_id)
848
file_group = self._dump_conflicts(name, parent_id, file_id,
850
file_group.append(trans_id)
853
class Diff3Merger(Merge3Merger):
854
"""Three-way merger using external diff3 for text merging"""
856
def dump_file(self, temp_dir, name, tree, file_id):
857
out_path = pathjoin(temp_dir, name)
858
out_file = open(out_path, "wb")
860
in_file = tree.get_file(file_id)
867
def text_merge(self, file_id, trans_id):
868
"""Perform a diff3 merge using a specified file-id and trans-id.
869
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
870
will be dumped, and a will be conflict noted.
873
temp_dir = osutils.mkdtemp(prefix="bzr-")
875
new_file = pathjoin(temp_dir, "new")
876
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
877
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
878
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
879
status = bzrlib.patch.diff3(new_file, this, base, other)
880
if status not in (0, 1):
881
raise BzrError("Unhandled diff3 exit code")
882
f = open(new_file, 'rb')
884
self.tt.create_file(f, trans_id)
888
name = self.tt.final_name(trans_id)
889
parent_id = self.tt.final_parent(trans_id)
890
self._dump_conflicts(name, parent_id, file_id)
891
self._raw_conflicts.append(('text conflict', trans_id))
893
osutils.rmtree(temp_dir)
896
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
898
merge_type=Merge3Merger,
899
interesting_ids=None,
903
interesting_files=None,
906
"""Primary interface for merging.
908
typical use is probably
909
'merge_inner(branch, branch.get_revision_tree(other_revision),
910
branch.get_revision_tree(base_revision))'
912
if this_tree is None:
913
warnings.warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
914
"bzrlib version 0.8.",
917
this_tree = this_branch.bzrdir.open_workingtree()
918
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
920
merger.backup_files = backup_files
921
merger.merge_type = merge_type
922
merger.interesting_ids = interesting_ids
923
merger.ignore_zero = ignore_zero
924
if interesting_files:
925
assert not interesting_ids, ('Only supply interesting_ids'
926
' or interesting_files')
927
merger._set_interesting_files(interesting_files)
928
merger.show_base = show_base
929
merger.reprocess = reprocess
930
merger.other_rev_id = other_rev_id
931
merger.other_basis = other_rev_id
932
return merger.do_merge()
935
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
936
"diff3": (Diff3Merger, "Merge using external diff3"),
937
'weave': (WeaveMerger, "Weave-based merge")
941
def merge_type_help():
942
templ = '%s%%7s: %%s' % (' '*12)
943
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
944
return '\n'.join(lines)
added
removed
bzrlib/merge.py
