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
1
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
2
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
3
from bzrlib.changeset import Inventory, Diff3Merge
4
from bzrlib import find_branch
6
from bzrlib.errors import BzrCommandError
7
from bzrlib.delta import compare_trees
8
from trace import mutter, warning
20
from tempfile import mkdtemp
23
from bzrlib.branch import Branch
24
from bzrlib.conflicts import ConflictList, Conflict
25
from bzrlib.delta import compare_trees
26
from bzrlib.errors import (BzrCommandError,
36
WorkingTreeNotRevision,
39
from bzrlib.merge3 import Merge3
41
from bzrlib.osutils import rename, pathjoin, rmtree
42
from progress import DummyProgress, ProgressPhase
43
from bzrlib.revision import common_ancestor, is_ancestor, NULL_REVISION
44
from bzrlib.symbol_versioning import *
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):
15
# comments from abentley on irc: merge happens in two stages, each
16
# of which generates a changeset object
18
# stage 1: generate OLD->OTHER,
19
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
21
class UnrelatedBranches(BzrCommandError):
23
msg = "Branches have no common ancestor, and no base revision"\
25
BzrCommandError.__init__(self, msg)
28
class MergeConflictHandler(ExceptionConflictHandler):
29
"""Handle conflicts encountered while merging.
31
This subclasses ExceptionConflictHandler, so that any types of
32
conflict that are not explicitly handled cause an exception and
35
def __init__(self, dir, ignore_zero=False):
36
ExceptionConflictHandler.__init__(self, dir)
38
self.ignore_zero = ignore_zero
40
def copy(self, source, dest):
41
"""Copy the text and mode of a file
42
:param source: The path of the file to copy
43
:param dest: The distination file to create
45
s_file = file(source, "rb")
46
d_file = file(dest, "wb")
49
os.chmod(dest, 0777 & os.stat(source).st_mode)
51
def dump(self, lines, dest):
52
"""Copy the text and mode of a file
53
:param source: The path of the file to copy
54
:param dest: The distination file to create
56
d_file = file(dest, "wb")
60
def add_suffix(self, name, suffix, last_new_name=None):
61
"""Rename a file to append a suffix. If the new name exists, the
62
suffix is added repeatedly until a non-existant name is found
64
:param name: The path of the file
65
:param suffix: The suffix to append
66
:param last_new_name: (used for recursive calls) the last name tried
68
if last_new_name is None:
70
new_name = last_new_name+suffix
72
os.rename(name, new_name)
75
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
77
return self.add_suffix(name, suffix, last_new_name=new_name)
79
def conflict(self, text):
84
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
86
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
87
main file will be a version with diff3 conflicts.
88
:param new_file: Path to the output file with diff3 markers
89
:param this_path: Path to the file text for the THIS tree
90
:param base_path: Path to the file text for the BASE tree
91
:param other_path: Path to the file text for the OTHER tree
93
self.add_suffix(this_path, ".THIS")
94
self.dump(base_lines, this_path+".BASE")
95
self.dump(other_lines, this_path+".OTHER")
96
os.rename(new_file, this_path)
97
self.conflict("Diff3 conflict encountered in %s" % this_path)
99
def new_contents_conflict(self, filename, other_contents):
100
"""Conflicting contents for newly added file."""
101
self.copy(other_contents, filename + ".OTHER")
102
self.conflict("Conflict in newly added file %s" % filename)
105
def target_exists(self, entry, target, old_path):
106
"""Handle the case when the target file or dir exists"""
107
moved_path = self.add_suffix(target, ".moved")
108
self.conflict("Moved existing %s to %s" % (target, moved_path))
110
def rmdir_non_empty(self, filename):
111
"""Handle the case where the dir to be removed still has contents"""
112
self.conflict("Directory %s not removed because it is not empty"\
117
if not self.ignore_zero:
118
print "%d conflicts encountered.\n" % self.conflicts
120
def get_tree(treespec, temp_root, label):
55
121
location, revno = treespec
56
branch = Branch.open_containing(location)[0]
122
branch = find_branch(location)
124
base_tree = branch.working_tree()
60
revision = branch.last_revision()
62
revision = branch.get_rev_id(revno)
64
revision = NULL_REVISION
65
return branch, _get_revid_tree(branch, revision, local_branch)
68
def _get_revid_tree(branch, revision, local_branch):
70
base_tree = branch.bzrdir.open_workingtree()
72
if local_branch is not None:
73
if local_branch.base != branch.base:
74
local_branch.fetch(branch, revision)
75
base_tree = local_branch.repository.revision_tree(revision)
77
base_tree = branch.repository.revision_tree(revision)
81
def transform_tree(from_tree, to_tree, interesting_ids=None):
82
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
83
interesting_ids=interesting_ids, this_tree=from_tree)
87
def __init__(self, this_branch, other_tree=None, base_tree=None,
88
this_tree=None, pb=DummyProgress()):
126
base_tree = branch.basis_tree()
128
base_tree = branch.revision_tree(branch.lookup_revision(revno))
129
temp_path = os.path.join(temp_root, label)
131
return branch, MergeTree(base_tree, temp_path)
134
def file_exists(tree, file_id):
135
return tree.has_filename(tree.id2path(file_id))
138
class MergeTree(object):
139
def __init__(self, tree, tempdir):
89
140
object.__init__(self)
90
assert this_tree is not None, "this_tree is required"
91
self.this_branch = this_branch
92
self.this_basis = this_branch.last_revision()
93
self.this_rev_id = None
94
self.this_tree = this_tree
95
self.this_revision_tree = None
96
self.this_basis_tree = None
97
self.other_tree = other_tree
98
self.base_tree = base_tree
99
self.ignore_zero = False
100
self.backup_files = False
101
self.interesting_ids = None
102
self.show_base = False
103
self.reprocess = False
108
def revision_tree(self, revision_id):
109
return self.this_branch.repository.revision_tree(revision_id)
111
def ensure_revision_trees(self):
112
if self.this_revision_tree is None:
113
self.this_basis_tree = self.this_branch.repository.revision_tree(
115
if self.this_basis == self.this_rev_id:
116
self.this_revision_tree = self.this_basis_tree
118
if self.other_rev_id is None:
119
other_basis_tree = self.revision_tree(self.other_basis)
120
changes = compare_trees(self.other_tree, other_basis_tree)
141
if hasattr(tree, "basedir"):
142
self.root = tree.basedir
146
self.tempdir = tempdir
147
os.mkdir(os.path.join(self.tempdir, "texts"))
151
return self.tree.__iter__()
153
def __contains__(self, file_id):
154
return file_id in self.tree
156
def get_file(self, file_id):
157
return self.tree.get_file(file_id)
159
def get_file_sha1(self, id):
160
return self.tree.get_file_sha1(id)
162
def id2path(self, file_id):
163
return self.tree.id2path(file_id)
165
def has_id(self, file_id):
166
return self.tree.has_id(file_id)
168
def readonly_path(self, id):
169
if id not in self.tree:
171
if self.root is not None:
172
return self.tree.abspath(self.tree.id2path(id))
174
if self.tree.inventory[id].kind in ("directory", "root_directory"):
176
if not self.cached.has_key(id):
177
path = os.path.join(self.tempdir, "texts", id)
178
outfile = file(path, "wb")
179
outfile.write(self.tree.get_file(id).read())
180
assert(os.path.exists(path))
181
self.cached[id] = path
182
return self.cached[id]
186
def merge(other_revision, base_revision,
187
check_clean=True, ignore_zero=False,
188
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
190
"""Merge changes into a tree.
193
Base for three-way merge.
195
Other revision for three-way merge.
197
Directory to merge changes into; '.' by default.
199
If true, this_dir must have no uncommitted changes before the
202
tempdir = tempfile.mkdtemp(prefix="bzr-")
206
this_branch = find_branch(this_dir)
208
changes = compare_trees(this_branch.working_tree(),
209
this_branch.basis_tree(), False)
121
210
if changes.has_changed():
122
raise WorkingTreeNotRevision(self.this_tree)
123
other_rev_id = other_basis
124
self.other_tree = other_basis_tree
126
def file_revisions(self, file_id):
127
self.ensure_revision_trees()
128
def get_id(tree, file_id):
129
revision_id = tree.inventory[file_id].revision
130
assert revision_id is not None
132
if self.this_rev_id is None:
133
if self.this_basis_tree.get_file_sha1(file_id) != \
134
self.this_tree.get_file_sha1(file_id):
135
raise WorkingTreeNotRevision(self.this_tree)
137
trees = (self.this_basis_tree, self.other_tree)
138
return [get_id(tree, file_id) for tree in trees]
140
def check_basis(self, check_clean, require_commits=True):
141
if self.this_basis is None and require_commits is True:
142
raise BzrCommandError("This branch has no commits")
145
if self.this_basis != self.this_rev_id:
146
211
raise BzrCommandError("Working tree has uncommitted changes.")
148
def compare_basis(self):
149
changes = compare_trees(self.this_tree,
150
self.this_tree.basis_tree(), False)
151
if not changes.has_changed():
152
self.this_rev_id = self.this_basis
154
def set_interesting_files(self, file_list):
156
self._set_interesting_files(file_list)
157
except NotVersionedError, e:
158
raise BzrCommandError("%s is not a source file in any"
161
def _set_interesting_files(self, file_list):
162
"""Set the list of interesting ids from a list of files."""
163
if file_list is None:
164
self.interesting_ids = None
167
interesting_ids = set()
168
for path in file_list:
170
for tree in (self.this_tree, self.base_tree, self.other_tree):
171
file_id = tree.inventory.path2id(path)
172
if file_id is not None:
173
interesting_ids.add(file_id)
176
raise NotVersionedError(path=path)
177
self.interesting_ids = interesting_ids
179
def set_pending(self):
180
if not self.base_is_ancestor:
182
if self.other_rev_id is None:
184
ancestry = self.this_branch.repository.get_ancestry(self.this_basis)
185
if self.other_rev_id in ancestry:
187
self.this_tree.add_pending_merge(self.other_rev_id)
189
def set_other(self, other_revision):
190
other_branch, self.other_tree = _get_tree(other_revision,
192
if other_revision[1] == -1:
193
self.other_rev_id = other_branch.last_revision()
194
if self.other_rev_id is None:
195
raise NoCommits(other_branch)
196
self.other_basis = self.other_rev_id
197
elif other_revision[1] is not None:
198
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
199
self.other_basis = self.other_rev_id
201
self.other_rev_id = None
202
self.other_basis = other_branch.last_revision()
203
if self.other_basis is None:
204
raise NoCommits(other_branch)
205
if other_branch.base != self.this_branch.base:
206
self.this_branch.fetch(other_branch, last_revision=self.other_basis)
209
self.set_base([None, None])
211
def set_base(self, base_revision):
212
mutter("doing merge() with no base_revision specified")
212
other_branch, other_tree = get_tree(other_revision, tempdir, "other")
213
213
if base_revision == [None, None]:
215
pb = bzrlib.ui.ui_factory.nested_progress_bar()
217
this_repo = self.this_branch.repository
218
self.base_rev_id = common_ancestor(self.this_basis,
223
except NoCommonAncestor:
214
if other_revision[1] == -1:
217
o_revno = other_revision[1]
218
base_revno = this_branch.common_ancestor(other_branch,
219
other_revno=o_revno)[0]
220
if base_revno is None:
224
221
raise UnrelatedBranches()
225
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
227
self.base_is_ancestor = True
229
base_branch, self.base_tree = _get_tree(base_revision)
230
if base_revision[1] == -1:
231
self.base_rev_id = base_branch.last_revision()
232
elif base_revision[1] is None:
233
self.base_rev_id = None
235
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
236
if self.this_branch.base != base_branch.base:
237
self.this_branch.fetch(base_branch)
238
self.base_is_ancestor = is_ancestor(self.this_basis,
243
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
244
'other_tree': self.other_tree,
245
'interesting_ids': self.interesting_ids,
247
if self.merge_type.requires_base:
248
kwargs['base_tree'] = self.base_tree
249
if self.merge_type.supports_reprocess:
250
kwargs['reprocess'] = self.reprocess
252
raise BzrError("Conflict reduction is not supported for merge"
253
" type %s." % self.merge_type)
254
if self.merge_type.supports_show_base:
255
kwargs['show_base'] = self.show_base
257
raise BzrError("Showing base is not supported for this"
258
" merge type. %s" % self.merge_type)
259
merge = self.merge_type(pb=self._pb, **kwargs)
260
if len(merge.cooked_conflicts) == 0:
261
if not self.ignore_zero:
262
note("All changes applied successfully.")
264
note("%d conflicts encountered." % len(merge.cooked_conflicts))
266
return len(merge.cooked_conflicts)
268
def regen_inventory(self, new_entries):
269
old_entries = self.this_tree.read_working_inventory()
273
for path, file_id in new_entries:
276
new_entries_map[file_id] = path
278
def id2path(file_id):
279
path = new_entries_map.get(file_id)
282
entry = old_entries[file_id]
283
if entry.parent_id is None:
285
return pathjoin(id2path(entry.parent_id), entry.name)
287
for file_id in old_entries:
288
entry = old_entries[file_id]
289
path = id2path(file_id)
290
if file_id in self.base_tree.inventory:
291
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
293
executable = getattr(entry, 'executable', False)
294
new_inventory[file_id] = (path, file_id, entry.parent_id,
295
entry.kind, executable)
297
by_path[path] = file_id
302
for path, file_id in new_entries:
304
del new_inventory[file_id]
307
new_path_list.append((path, file_id))
308
if file_id not in old_entries:
310
# Ensure no file is added before its parent
312
for path, file_id in new_path_list:
316
parent = by_path[os.path.dirname(path)]
317
abspath = pathjoin(self.this_tree.basedir, path)
318
kind = bzrlib.osutils.file_kind(abspath)
319
if file_id in self.base_tree.inventory:
320
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
323
new_inventory[file_id] = (path, file_id, parent, kind, executable)
324
by_path[path] = file_id
326
# Get a list in insertion order
327
new_inventory_list = new_inventory.values()
328
mutter ("""Inventory regeneration:
329
old length: %i insertions: %i deletions: %i new_length: %i"""\
330
% (len(old_entries), insertions, deletions,
331
len(new_inventory_list)))
332
assert len(new_inventory_list) == len(old_entries) + insertions\
334
new_inventory_list.sort()
335
return new_inventory_list
338
class Merge3Merger(object):
339
"""Three-way merger that uses the merge3 text merger"""
341
supports_reprocess = True
342
supports_show_base = True
343
history_based = False
345
def __init__(self, working_tree, this_tree, base_tree, other_tree,
346
interesting_ids=None, reprocess=False, show_base=False,
347
pb=DummyProgress(), pp=None):
348
"""Initialize the merger object and perform the merge."""
349
object.__init__(self)
350
self.this_tree = working_tree
351
self.base_tree = base_tree
352
self.other_tree = other_tree
353
self._raw_conflicts = []
354
self.cooked_conflicts = []
355
self.reprocess = reprocess
356
self.show_base = show_base
360
self.pp = ProgressPhase("Merge phase", 3, self.pb)
362
if interesting_ids is not None:
363
all_ids = interesting_ids
365
all_ids = set(base_tree)
366
all_ids.update(other_tree)
367
working_tree.lock_write()
368
self.tt = TreeTransform(working_tree, self.pb)
371
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
373
for num, file_id in enumerate(all_ids):
374
child_pb.update('Preparing file merge', num, len(all_ids))
375
self.merge_names(file_id)
376
file_status = self.merge_contents(file_id)
377
self.merge_executable(file_id, file_status)
382
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
384
fs_conflicts = resolve_conflicts(self.tt, child_pb)
387
self.cook_conflicts(fs_conflicts)
388
for conflict in self.cooked_conflicts:
391
results = self.tt.apply()
392
self.write_modified(results)
394
working_tree.set_conflicts(ConflictList(self.cooked_conflicts))
395
except UnsupportedOperation:
402
working_tree.unlock()
405
def write_modified(self, results):
407
for path in results.modified_paths:
408
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
411
hash = self.this_tree.get_file_sha1(file_id)
414
modified_hashes[file_id] = hash
415
self.this_tree.set_merge_modified(modified_hashes)
418
def parent(entry, file_id):
419
"""Determine the parent for a file_id (used as a key method)"""
422
return entry.parent_id
425
def name(entry, file_id):
426
"""Determine the name for a file_id (used as a key method)"""
432
def contents_sha1(tree, file_id):
433
"""Determine the sha1 of the file contents (used as a key method)."""
434
if file_id not in tree:
436
return tree.get_file_sha1(file_id)
439
def executable(tree, file_id):
440
"""Determine the executability of a file-id (used as a key method)."""
441
if file_id not in tree:
443
if tree.kind(file_id) != "file":
445
return tree.is_executable(file_id)
448
def kind(tree, file_id):
449
"""Determine the kind of a file-id (used as a key method)."""
450
if file_id not in tree:
452
return tree.kind(file_id)
455
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
456
"""Do a three-way test on a scalar.
457
Return "this", "other" or "conflict", depending whether a value wins.
459
key_base = key(base_tree, file_id)
460
key_other = key(other_tree, file_id)
461
#if base == other, either they all agree, or only THIS has changed.
462
if key_base == key_other:
464
key_this = key(this_tree, file_id)
465
if key_this not in (key_base, key_other):
467
# "Ambiguous clean merge"
468
elif key_this == key_other:
471
assert key_this == key_base
474
def merge_names(self, file_id):
475
"""Perform a merge on file_id names and parents"""
477
if file_id in tree.inventory:
478
return tree.inventory[file_id]
481
this_entry = get_entry(self.this_tree)
482
other_entry = get_entry(self.other_tree)
483
base_entry = get_entry(self.base_tree)
484
name_winner = self.scalar_three_way(this_entry, base_entry,
485
other_entry, file_id, self.name)
486
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
487
other_entry, file_id,
489
if this_entry is None:
490
if name_winner == "this":
491
name_winner = "other"
492
if parent_id_winner == "this":
493
parent_id_winner = "other"
494
if name_winner == "this" and parent_id_winner == "this":
496
if name_winner == "conflict":
497
trans_id = self.tt.trans_id_file_id(file_id)
498
self._raw_conflicts.append(('name conflict', trans_id,
499
self.name(this_entry, file_id),
500
self.name(other_entry, file_id)))
501
if parent_id_winner == "conflict":
502
trans_id = self.tt.trans_id_file_id(file_id)
503
self._raw_conflicts.append(('parent conflict', trans_id,
504
self.parent(this_entry, file_id),
505
self.parent(other_entry, file_id)))
506
if other_entry is None:
507
# it doesn't matter whether the result was 'other' or
508
# 'conflict'-- if there's no 'other', we leave it alone.
510
# if we get here, name_winner and parent_winner are set to safe values.
511
winner_entry = {"this": this_entry, "other": other_entry,
512
"conflict": other_entry}
513
trans_id = self.tt.trans_id_file_id(file_id)
514
parent_id = winner_entry[parent_id_winner].parent_id
515
parent_trans_id = self.tt.trans_id_file_id(parent_id)
516
self.tt.adjust_path(winner_entry[name_winner].name, parent_trans_id,
519
def merge_contents(self, file_id):
520
"""Performa a merge on file_id contents."""
521
def contents_pair(tree):
522
if file_id not in tree:
524
kind = tree.kind(file_id)
525
if kind == "root_directory":
528
contents = tree.get_file_sha1(file_id)
529
elif kind == "symlink":
530
contents = tree.get_symlink_target(file_id)
533
return kind, contents
535
def contents_conflict():
536
trans_id = self.tt.trans_id_file_id(file_id)
537
name = self.tt.final_name(trans_id)
538
parent_id = self.tt.final_parent(trans_id)
539
if file_id in self.this_tree.inventory:
540
self.tt.unversion_file(trans_id)
541
self.tt.delete_contents(trans_id)
542
file_group = self._dump_conflicts(name, parent_id, file_id,
544
self._raw_conflicts.append(('contents conflict', file_group))
546
# See SPOT run. run, SPOT, run.
547
# So we're not QUITE repeating ourselves; we do tricky things with
549
base_pair = contents_pair(self.base_tree)
550
other_pair = contents_pair(self.other_tree)
551
if base_pair == other_pair:
552
# OTHER introduced no changes
554
this_pair = contents_pair(self.this_tree)
555
if this_pair == other_pair:
556
# THIS and OTHER introduced the same changes
559
trans_id = self.tt.trans_id_file_id(file_id)
560
if this_pair == base_pair:
561
# only OTHER introduced changes
562
if file_id in self.this_tree:
563
# Remove any existing contents
564
self.tt.delete_contents(trans_id)
565
if file_id in self.other_tree:
566
# OTHER changed the file
567
create_by_entry(self.tt,
568
self.other_tree.inventory[file_id],
569
self.other_tree, trans_id)
570
if file_id not in self.this_tree.inventory:
571
self.tt.version_file(file_id, trans_id)
573
elif file_id in self.this_tree.inventory:
574
# OTHER deleted the file
575
self.tt.unversion_file(trans_id)
577
#BOTH THIS and OTHER introduced changes; scalar conflict
578
elif this_pair[0] == "file" and other_pair[0] == "file":
579
# THIS and OTHER are both files, so text merge. Either
580
# BASE is a file, or both converted to files, so at least we
581
# have agreement that output should be a file.
583
self.text_merge(file_id, trans_id)
585
return contents_conflict()
586
if file_id not in self.this_tree.inventory:
587
self.tt.version_file(file_id, trans_id)
589
self.tt.tree_kind(trans_id)
590
self.tt.delete_contents(trans_id)
595
# Scalar conflict, can't text merge. Dump conflicts
596
return contents_conflict()
598
def get_lines(self, tree, file_id):
599
"""Return the lines in a file, or an empty list."""
601
return tree.get_file(file_id).readlines()
605
def text_merge(self, file_id, trans_id):
606
"""Perform a three-way text merge on a file_id"""
607
# it's possible that we got here with base as a different type.
608
# if so, we just want two-way text conflicts.
609
if file_id in self.base_tree and \
610
self.base_tree.kind(file_id) == "file":
611
base_lines = self.get_lines(self.base_tree, file_id)
614
other_lines = self.get_lines(self.other_tree, file_id)
615
this_lines = self.get_lines(self.this_tree, file_id)
616
m3 = Merge3(base_lines, this_lines, other_lines)
617
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
618
if self.show_base is True:
619
base_marker = '|' * 7
623
def iter_merge3(retval):
624
retval["text_conflicts"] = False
625
for line in m3.merge_lines(name_a = "TREE",
626
name_b = "MERGE-SOURCE",
627
name_base = "BASE-REVISION",
628
start_marker=start_marker,
629
base_marker=base_marker,
630
reprocess=self.reprocess):
631
if line.startswith(start_marker):
632
retval["text_conflicts"] = True
633
yield line.replace(start_marker, '<' * 7)
637
merge3_iterator = iter_merge3(retval)
638
self.tt.create_file(merge3_iterator, trans_id)
639
if retval["text_conflicts"] is True:
640
self._raw_conflicts.append(('text conflict', trans_id))
641
name = self.tt.final_name(trans_id)
642
parent_id = self.tt.final_parent(trans_id)
643
file_group = self._dump_conflicts(name, parent_id, file_id,
644
this_lines, base_lines,
646
file_group.append(trans_id)
648
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
649
base_lines=None, other_lines=None, set_version=False,
651
"""Emit conflict files.
652
If this_lines, base_lines, or other_lines are omitted, they will be
653
determined automatically. If set_version is true, the .OTHER, .THIS
654
or .BASE (in that order) will be created as versioned files.
656
data = [('OTHER', self.other_tree, other_lines),
657
('THIS', self.this_tree, this_lines)]
659
data.append(('BASE', self.base_tree, base_lines))
662
for suffix, tree, lines in data:
664
trans_id = self._conflict_file(name, parent_id, tree, file_id,
666
file_group.append(trans_id)
667
if set_version and not versioned:
668
self.tt.version_file(file_id, trans_id)
672
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
674
"""Emit a single conflict file."""
675
name = name + '.' + suffix
676
trans_id = self.tt.create_path(name, parent_id)
677
entry = tree.inventory[file_id]
678
create_by_entry(self.tt, entry, tree, trans_id, lines)
681
def merge_executable(self, file_id, file_status):
682
"""Perform a merge on the execute bit."""
683
if file_status == "deleted":
685
trans_id = self.tt.trans_id_file_id(file_id)
687
if self.tt.final_kind(trans_id) != "file":
691
winner = self.scalar_three_way(self.this_tree, self.base_tree,
692
self.other_tree, file_id,
694
if winner == "conflict":
695
# There must be a None in here, if we have a conflict, but we
696
# need executability since file status was not deleted.
697
if self.other_tree.is_executable(file_id) is None:
702
if file_status == "modified":
703
executability = self.this_tree.is_executable(file_id)
704
if executability is not None:
705
trans_id = self.tt.trans_id_file_id(file_id)
706
self.tt.set_executability(executability, trans_id)
708
assert winner == "other"
709
if file_id in self.other_tree:
710
executability = self.other_tree.is_executable(file_id)
711
elif file_id in self.this_tree:
712
executability = self.this_tree.is_executable(file_id)
713
elif file_id in self.base_tree:
714
executability = self.base_tree.is_executable(file_id)
715
if executability is not None:
716
trans_id = self.tt.trans_id_file_id(file_id)
717
self.tt.set_executability(executability, trans_id)
719
def cook_conflicts(self, fs_conflicts):
720
"""Convert all conflicts into a form that doesn't depend on trans_id"""
721
from conflicts import Conflict
723
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
724
fp = FinalPaths(self.tt)
725
for conflict in self._raw_conflicts:
726
conflict_type = conflict[0]
727
if conflict_type in ('name conflict', 'parent conflict'):
728
trans_id = conflict[1]
729
conflict_args = conflict[2:]
730
if trans_id not in name_conflicts:
731
name_conflicts[trans_id] = {}
732
unique_add(name_conflicts[trans_id], conflict_type,
734
if conflict_type == 'contents conflict':
735
for trans_id in conflict[1]:
736
file_id = self.tt.final_file_id(trans_id)
222
base_revision = ['.', base_revno]
223
base_branch, base_tree = get_tree(base_revision, tempdir, "base")
224
if file_list is None:
225
interesting_ids = None
227
interesting_ids = set()
228
this_tree = this_branch.working_tree()
229
for fname in file_list:
230
path = this_branch.relpath(fname)
232
for tree in (this_tree, base_tree.tree, other_tree.tree):
233
file_id = tree.inventory.path2id(path)
737
234
if file_id is not None:
739
path = fp.get_path(trans_id)
740
for suffix in ('.BASE', '.THIS', '.OTHER'):
741
if path.endswith(suffix):
742
path = path[:-len(suffix)]
744
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
745
self.cooked_conflicts.append(c)
746
if conflict_type == 'text conflict':
747
trans_id = conflict[1]
748
path = fp.get_path(trans_id)
749
file_id = self.tt.final_file_id(trans_id)
750
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
751
self.cooked_conflicts.append(c)
753
for trans_id, conflicts in name_conflicts.iteritems():
755
this_parent, other_parent = conflicts['parent conflict']
756
assert this_parent != other_parent
758
this_parent = other_parent = \
759
self.tt.final_file_id(self.tt.final_parent(trans_id))
761
this_name, other_name = conflicts['name conflict']
762
assert this_name != other_name
764
this_name = other_name = self.tt.final_name(trans_id)
765
other_path = fp.get_path(trans_id)
766
if this_parent is not None:
768
fp.get_path(self.tt.trans_id_file_id(this_parent))
769
this_path = pathjoin(this_parent_path, this_name)
235
interesting_ids.add(file_id)
238
raise BzrCommandError("%s is not a source file in any"
240
merge_inner(this_branch, other_tree, base_tree, tempdir,
241
ignore_zero=ignore_zero, backup_files=backup_files,
242
merge_type=merge_type, interesting_ids=interesting_ids)
244
shutil.rmtree(tempdir)
247
def set_interesting(inventory_a, inventory_b, interesting_ids):
248
"""Mark files whose ids are in interesting_ids as interesting
250
for inventory in (inventory_a, inventory_b):
251
for path, source_file in inventory.iteritems():
252
source_file.interesting = source_file.id in interesting_ids
255
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
256
"""Generate a changeset. If interesting_ids is supplied, only changes
257
to those files will be shown. Metadata changes are stripped.
259
cset = generate_changeset(tree_a, tree_b, interesting_ids)
260
for entry in cset.entries.itervalues():
261
entry.metadata_change = None
265
def merge_inner(this_branch, other_tree, base_tree, tempdir,
266
ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
267
interesting_ids=None):
269
def merge_factory(file_id, base, other):
270
contents_change = merge_type(file_id, base, other)
272
contents_change = BackupBeforeChange(contents_change)
273
return contents_change
275
this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
277
def get_inventory(tree):
278
return tree.tree.inventory
280
inv_changes = merge_flex(this_tree, base_tree, other_tree,
281
generate_cset_optimized, get_inventory,
282
MergeConflictHandler(base_tree.root,
283
ignore_zero=ignore_zero),
284
merge_factory=merge_factory,
285
interesting_ids=interesting_ids)
288
for id, path in inv_changes.iteritems():
771
this_path = "<deleted>"
772
file_id = self.tt.final_file_id(trans_id)
773
c = Conflict.factory('path conflict', path=this_path,
774
conflict_path=other_path, file_id=file_id)
775
self.cooked_conflicts.append(c)
776
self.cooked_conflicts.sort(key=Conflict.sort_key)
779
class WeaveMerger(Merge3Merger):
780
"""Three-way tree merger, text weave merger."""
781
supports_reprocess = True
782
supports_show_base = False
784
def __init__(self, working_tree, this_tree, base_tree, other_tree,
785
interesting_ids=None, pb=DummyProgress(), pp=None,
787
self.this_revision_tree = self._get_revision_tree(this_tree)
788
self.other_revision_tree = self._get_revision_tree(other_tree)
789
super(WeaveMerger, self).__init__(working_tree, this_tree,
790
base_tree, other_tree,
791
interesting_ids=interesting_ids,
792
pb=pb, pp=pp, reprocess=reprocess)
794
def _get_revision_tree(self, tree):
795
"""Return a revision tree related to this tree.
796
If the tree is a WorkingTree, the basis will be returned.
798
if getattr(tree, 'get_weave', False) is False:
799
# If we have a WorkingTree, try using the basis
800
return tree.branch.basis_tree()
804
def _check_file(self, file_id):
805
"""Check that the revision tree's version of the file matches."""
806
for tree, rt in ((self.this_tree, self.this_revision_tree),
807
(self.other_tree, self.other_revision_tree)):
810
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
811
raise WorkingTreeNotRevision(self.this_tree)
813
def _merged_lines(self, file_id):
814
"""Generate the merged lines.
815
There is no distinction between lines that are meant to contain <<<<<<<
818
weave = self.this_revision_tree.get_weave(file_id)
819
this_revision_id = self.this_revision_tree.inventory[file_id].revision
820
other_revision_id = \
821
self.other_revision_tree.inventory[file_id].revision
822
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
823
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
824
return wm.merge_lines(self.reprocess)
826
def text_merge(self, file_id, trans_id):
827
"""Perform a (weave) text merge for a given file and file-id.
828
If conflicts are encountered, .THIS and .OTHER files will be emitted,
829
and a conflict will be noted.
831
self._check_file(file_id)
832
lines, conflicts = self._merged_lines(file_id)
834
# Note we're checking whether the OUTPUT is binary in this case,
835
# because we don't want to get into weave merge guts.
836
check_text_lines(lines)
837
self.tt.create_file(lines, trans_id)
839
self._raw_conflicts.append(('text conflict', trans_id))
840
name = self.tt.final_name(trans_id)
841
parent_id = self.tt.final_parent(trans_id)
842
file_group = self._dump_conflicts(name, parent_id, file_id,
844
file_group.append(trans_id)
847
class Diff3Merger(Merge3Merger):
848
"""Three-way merger using external diff3 for text merging"""
849
def dump_file(self, temp_dir, name, tree, file_id):
850
out_path = pathjoin(temp_dir, name)
851
out_file = file(out_path, "wb")
852
in_file = tree.get_file(file_id)
857
def text_merge(self, file_id, trans_id):
858
"""Perform a diff3 merge using a specified file-id and trans-id.
859
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
860
will be dumped, and a will be conflict noted.
863
temp_dir = mkdtemp(prefix="bzr-")
865
new_file = pathjoin(temp_dir, "new")
866
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
867
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
868
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
869
status = bzrlib.patch.diff3(new_file, this, base, other)
870
if status not in (0, 1):
871
raise BzrError("Unhandled diff3 exit code")
872
self.tt.create_file(file(new_file, "rb"), trans_id)
874
name = self.tt.final_name(trans_id)
875
parent_id = self.tt.final_parent(trans_id)
876
self._dump_conflicts(name, parent_id, file_id)
877
self._raw_conflicts.append(('text conflict', trans_id))
882
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
884
merge_type=Merge3Merger,
885
interesting_ids=None,
889
interesting_files=None,
892
"""Primary interface for merging.
894
typical use is probably
895
'merge_inner(branch, branch.get_revision_tree(other_revision),
896
branch.get_revision_tree(base_revision))'
898
if this_tree is None:
899
warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
900
"bzrlib version 0.8.",
903
this_tree = this_branch.bzrdir.open_workingtree()
904
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
906
merger.backup_files = backup_files
907
merger.merge_type = merge_type
908
merger.interesting_ids = interesting_ids
909
merger.ignore_zero = ignore_zero
910
if interesting_files:
911
assert not interesting_ids, ('Only supply interesting_ids'
912
' or interesting_files')
913
merger._set_interesting_files(interesting_files)
914
merger.show_base = show_base
915
merger.reprocess = reprocess
916
merger.other_rev_id = other_rev_id
917
merger.other_basis = other_rev_id
918
return merger.do_merge()
921
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
922
"diff3": (Diff3Merger, "Merge using external diff3"),
923
'weave': (WeaveMerger, "Weave-based merge")
293
assert path.startswith('./'), "path is %s" % path
295
adjust_ids.append((path, id))
296
if len(adjust_ids) > 0:
297
this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
301
def regen_inventory(this_branch, root, new_entries):
302
old_entries = this_branch.read_working_inventory()
306
for path, file_id in new_entries:
309
new_entries_map[file_id] = path
311
def id2path(file_id):
312
path = new_entries_map.get(file_id)
315
entry = old_entries[file_id]
316
if entry.parent_id is None:
318
return os.path.join(id2path(entry.parent_id), entry.name)
320
for file_id in old_entries:
321
entry = old_entries[file_id]
322
path = id2path(file_id)
323
new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
324
by_path[path] = file_id
329
for path, file_id in new_entries:
331
del new_inventory[file_id]
334
new_path_list.append((path, file_id))
335
if file_id not in old_entries:
337
# Ensure no file is added before its parent
339
for path, file_id in new_path_list:
343
parent = by_path[os.path.dirname(path)]
344
kind = bzrlib.osutils.file_kind(os.path.join(root, path))
345
new_inventory[file_id] = (path, file_id, parent, kind)
346
by_path[path] = file_id
348
# Get a list in insertion order
349
new_inventory_list = new_inventory.values()
350
mutter ("""Inventory regeneration:
351
old length: %i insertions: %i deletions: %i new_length: %i"""\
352
% (len(old_entries), insertions, deletions, len(new_inventory_list)))
353
assert len(new_inventory_list) == len(old_entries) + insertions - deletions
354
new_inventory_list.sort()
355
return new_inventory_list
357
merge_types = { "merge3": (ApplyMerge3, "Native diff3-style merge"),
358
"diff3": (Diff3Merge, "Merge using external diff3")
927
def merge_type_help():
928
templ = '%s%%7s: %%s' % (' '*12)
929
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
930
return '\n'.join(lines)
added
removed
bzrlib/merge.py
