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
1
# Copyright (C) 2005 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
20
from shutil import rmtree
21
from tempfile import mkdtemp
24
from bzrlib.branch import Branch
25
from bzrlib.conflicts import ConflictList
26
from bzrlib.delta import compare_trees
27
from bzrlib.errors import (BzrCommandError,
37
WorkingTreeNotRevision,
39
from bzrlib.merge3 import Merge3
5
40
import bzrlib.osutils
6
from bzrlib.errors import BzrCommandError
7
from bzrlib.delta import compare_trees
8
from trace import mutter, warning
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):
41
from bzrlib.osutils import rename, pathjoin
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.trace import mutter, warning, note
46
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
47
FinalPaths, create_by_entry, unique_add)
50
# TODO: Report back as changes are merged in
52
def _get_tree(treespec, local_branch=None):
121
53
location, revno = treespec
122
branch = find_branch(location)
54
branch = Branch.open_containing(location)[0]
124
base_tree = branch.working_tree()
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):
58
revision = branch.last_revision()
60
revision = branch.get_rev_id(revno)
62
revision = NULL_REVISION
63
return branch, _get_revid_tree(branch, revision, local_branch)
66
def _get_revid_tree(branch, revision, local_branch):
68
base_tree = branch.bzrdir.open_workingtree()
70
if local_branch is not None:
71
if local_branch.base != branch.base:
72
local_branch.fetch(branch, revision)
73
base_tree = local_branch.repository.revision_tree(revision)
75
base_tree = branch.repository.revision_tree(revision)
79
def transform_tree(from_tree, to_tree, interesting_ids=None):
80
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
81
interesting_ids=interesting_ids, this_tree=from_tree)
85
def __init__(self, this_branch, other_tree=None, base_tree=None,
86
this_tree=None, pb=DummyProgress()):
140
87
object.__init__(self)
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)
88
assert this_tree is not None, "this_tree is required"
89
self.this_branch = this_branch
90
self.this_basis = this_branch.last_revision()
91
self.this_rev_id = None
92
self.this_tree = this_tree
93
self.this_revision_tree = None
94
self.this_basis_tree = None
95
self.other_tree = other_tree
96
self.base_tree = base_tree
97
self.ignore_zero = False
98
self.backup_files = False
99
self.interesting_ids = None
100
self.show_base = False
101
self.reprocess = False
106
def revision_tree(self, revision_id):
107
return self.this_branch.repository.revision_tree(revision_id)
109
def ensure_revision_trees(self):
110
if self.this_revision_tree is None:
111
self.this_basis_tree = self.this_branch.repository.revision_tree(
113
if self.this_basis == self.this_rev_id:
114
self.this_revision_tree = self.this_basis_tree
116
if self.other_rev_id is None:
117
other_basis_tree = self.revision_tree(self.other_basis)
118
changes = compare_trees(self.other_tree, other_basis_tree)
119
if changes.has_changed():
120
raise WorkingTreeNotRevision(self.this_tree)
121
other_rev_id = other_basis
122
self.other_tree = other_basis_tree
124
def file_revisions(self, file_id):
125
self.ensure_revision_trees()
126
def get_id(tree, file_id):
127
revision_id = tree.inventory[file_id].revision
128
assert revision_id is not None
130
if self.this_rev_id is None:
131
if self.this_basis_tree.get_file_sha1(file_id) != \
132
self.this_tree.get_file_sha1(file_id):
133
raise WorkingTreeNotRevision(self.this_tree)
135
trees = (self.this_basis_tree, self.other_tree)
136
return [get_id(tree, file_id) for tree in trees]
138
def check_basis(self, check_clean):
139
if self.this_basis is None:
140
raise BzrCommandError("This branch has no commits")
208
changes = compare_trees(this_branch.working_tree(),
209
this_branch.basis_tree(), False)
210
if changes.has_changed():
143
if self.this_basis != self.this_rev_id:
211
144
raise BzrCommandError("Working tree has uncommitted changes.")
212
other_branch, other_tree = get_tree(other_revision, tempdir, "other")
146
def compare_basis(self):
147
changes = compare_trees(self.this_tree,
148
self.this_tree.basis_tree(), False)
149
if not changes.has_changed():
150
self.this_rev_id = self.this_basis
152
def set_interesting_files(self, file_list):
154
self._set_interesting_files(file_list)
155
except NotVersionedError, e:
156
raise BzrCommandError("%s is not a source file in any"
159
def _set_interesting_files(self, file_list):
160
"""Set the list of interesting ids from a list of files."""
161
if file_list is None:
162
self.interesting_ids = None
165
interesting_ids = set()
166
for path in file_list:
168
for tree in (self.this_tree, self.base_tree, self.other_tree):
169
file_id = tree.inventory.path2id(path)
170
if file_id is not None:
171
interesting_ids.add(file_id)
174
raise NotVersionedError(path=path)
175
self.interesting_ids = interesting_ids
177
def set_pending(self):
178
if not self.base_is_ancestor:
180
if self.other_rev_id is None:
182
ancestry = self.this_branch.repository.get_ancestry(self.this_basis)
183
if self.other_rev_id in ancestry:
185
self.this_tree.add_pending_merge(self.other_rev_id)
187
def set_other(self, other_revision):
188
other_branch, self.other_tree = _get_tree(other_revision,
190
if other_revision[1] == -1:
191
self.other_rev_id = other_branch.last_revision()
192
if self.other_rev_id is None:
193
raise NoCommits(other_branch)
194
self.other_basis = self.other_rev_id
195
elif other_revision[1] is not None:
196
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
197
self.other_basis = self.other_rev_id
199
self.other_rev_id = None
200
self.other_basis = other_branch.last_revision()
201
if self.other_basis is None:
202
raise NoCommits(other_branch)
203
if other_branch.base != self.this_branch.base:
204
self.this_branch.fetch(other_branch, last_revision=self.other_basis)
206
def set_base(self, base_revision):
207
mutter("doing merge() with no base_revision specified")
213
208
if base_revision == [None, None]:
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:
210
pb = bzrlib.ui.ui_factory.nested_progress_bar()
212
this_repo = self.this_branch.repository
213
self.base_rev_id = common_ancestor(self.this_basis,
218
except NoCommonAncestor:
221
219
raise UnrelatedBranches()
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)
220
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
222
self.base_is_ancestor = True
224
base_branch, self.base_tree = _get_tree(base_revision)
225
if base_revision[1] == -1:
226
self.base_rev_id = base_branch.last_revision()
227
elif base_revision[1] is None:
228
self.base_rev_id = None
230
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
231
if self.this_branch.base != base_branch.base:
232
self.this_branch.fetch(base_branch)
233
self.base_is_ancestor = is_ancestor(self.this_basis,
238
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
239
'other_tree': self.other_tree,
240
'interesting_ids': self.interesting_ids,
242
if self.merge_type.requires_base:
243
kwargs['base_tree'] = self.base_tree
244
if self.merge_type.supports_reprocess:
245
kwargs['reprocess'] = self.reprocess
247
raise BzrError("Reprocess is not supported for this merge"
248
" type. %s" % merge_type)
249
if self.merge_type.supports_show_base:
250
kwargs['show_base'] = self.show_base
252
raise BzrError("Showing base is not supported for this"
253
" merge type. %s" % self.merge_type)
254
merge = self.merge_type(pb=self._pb, **kwargs)
255
if len(merge.cooked_conflicts) == 0:
256
if not self.ignore_zero:
257
note("All changes applied successfully.")
259
note("%d conflicts encountered." % len(merge.cooked_conflicts))
261
return len(merge.cooked_conflicts)
263
def regen_inventory(self, new_entries):
264
old_entries = self.this_tree.read_working_inventory()
268
for path, file_id in new_entries:
271
new_entries_map[file_id] = path
273
def id2path(file_id):
274
path = new_entries_map.get(file_id)
277
entry = old_entries[file_id]
278
if entry.parent_id is None:
280
return pathjoin(id2path(entry.parent_id), entry.name)
282
for file_id in old_entries:
283
entry = old_entries[file_id]
284
path = id2path(file_id)
285
new_inventory[file_id] = (path, file_id, entry.parent_id,
287
by_path[path] = file_id
292
for path, file_id in new_entries:
294
del new_inventory[file_id]
297
new_path_list.append((path, file_id))
298
if file_id not in old_entries:
300
# Ensure no file is added before its parent
302
for path, file_id in new_path_list:
306
parent = by_path[os.path.dirname(path)]
307
abspath = pathjoin(self.this_tree.basedir, path)
308
kind = bzrlib.osutils.file_kind(abspath)
309
new_inventory[file_id] = (path, file_id, parent, kind)
310
by_path[path] = file_id
312
# Get a list in insertion order
313
new_inventory_list = new_inventory.values()
314
mutter ("""Inventory regeneration:
315
old length: %i insertions: %i deletions: %i new_length: %i"""\
316
% (len(old_entries), insertions, deletions,
317
len(new_inventory_list)))
318
assert len(new_inventory_list) == len(old_entries) + insertions\
320
new_inventory_list.sort()
321
return new_inventory_list
324
class Merge3Merger(object):
325
"""Three-way merger that uses the merge3 text merger"""
327
supports_reprocess = True
328
supports_show_base = True
329
history_based = False
331
def __init__(self, working_tree, this_tree, base_tree, other_tree,
332
interesting_ids=None, reprocess=False, show_base=False,
333
pb=DummyProgress(), pp=None):
334
"""Initialize the merger object and perform the merge."""
335
object.__init__(self)
336
self.this_tree = working_tree
337
self.base_tree = base_tree
338
self.other_tree = other_tree
339
self._raw_conflicts = []
340
self.cooked_conflicts = []
341
self.reprocess = reprocess
342
self.show_base = show_base
346
self.pp = ProgressPhase("Merge phase", 3, self.pb)
348
if interesting_ids is not None:
349
all_ids = interesting_ids
351
all_ids = set(base_tree)
352
all_ids.update(other_tree)
353
working_tree.lock_write()
354
self.tt = TreeTransform(working_tree, self.pb)
357
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
359
for num, file_id in enumerate(all_ids):
360
child_pb.update('Preparing file merge', num, len(all_ids))
361
self.merge_names(file_id)
362
file_status = self.merge_contents(file_id)
363
self.merge_executable(file_id, file_status)
368
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
370
fs_conflicts = resolve_conflicts(self.tt, child_pb)
373
self.cook_conflicts(fs_conflicts)
374
for conflict in self.cooked_conflicts:
377
results = self.tt.apply()
378
self.write_modified(results)
380
working_tree.set_conflicts(ConflictList(self.cooked_conflicts))
381
except UnsupportedOperation:
388
working_tree.unlock()
391
def write_modified(self, results):
393
for path in results.modified_paths:
394
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
397
hash = self.this_tree.get_file_sha1(file_id)
400
modified_hashes[file_id] = hash
401
self.this_tree.set_merge_modified(modified_hashes)
404
def parent(entry, file_id):
405
"""Determine the parent for a file_id (used as a key method)"""
408
return entry.parent_id
411
def name(entry, file_id):
412
"""Determine the name for a file_id (used as a key method)"""
418
def contents_sha1(tree, file_id):
419
"""Determine the sha1 of the file contents (used as a key method)."""
420
if file_id not in tree:
422
return tree.get_file_sha1(file_id)
425
def executable(tree, file_id):
426
"""Determine the executability of a file-id (used as a key method)."""
427
if file_id not in tree:
429
if tree.kind(file_id) != "file":
431
return tree.is_executable(file_id)
434
def kind(tree, file_id):
435
"""Determine the kind of a file-id (used as a key method)."""
436
if file_id not in tree:
438
return tree.kind(file_id)
441
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
442
"""Do a three-way test on a scalar.
443
Return "this", "other" or "conflict", depending whether a value wins.
445
key_base = key(base_tree, file_id)
446
key_other = key(other_tree, file_id)
447
#if base == other, either they all agree, or only THIS has changed.
448
if key_base == key_other:
450
key_this = key(this_tree, file_id)
451
if key_this not in (key_base, key_other):
453
# "Ambiguous clean merge"
454
elif key_this == key_other:
457
assert key_this == key_base
460
def merge_names(self, file_id):
461
"""Perform a merge on file_id names and parents"""
463
if file_id in tree.inventory:
464
return tree.inventory[file_id]
467
this_entry = get_entry(self.this_tree)
468
other_entry = get_entry(self.other_tree)
469
base_entry = get_entry(self.base_tree)
470
name_winner = self.scalar_three_way(this_entry, base_entry,
471
other_entry, file_id, self.name)
472
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
473
other_entry, file_id,
475
if this_entry is None:
476
if name_winner == "this":
477
name_winner = "other"
478
if parent_id_winner == "this":
479
parent_id_winner = "other"
480
if name_winner == "this" and parent_id_winner == "this":
482
if name_winner == "conflict":
483
trans_id = self.tt.trans_id_file_id(file_id)
484
self._raw_conflicts.append(('name conflict', trans_id,
485
self.name(this_entry, file_id),
486
self.name(other_entry, file_id)))
487
if parent_id_winner == "conflict":
488
trans_id = self.tt.trans_id_file_id(file_id)
489
self._raw_conflicts.append(('parent conflict', trans_id,
490
self.parent(this_entry, file_id),
491
self.parent(other_entry, file_id)))
492
if other_entry is None:
493
# it doesn't matter whether the result was 'other' or
494
# 'conflict'-- if there's no 'other', we leave it alone.
496
# if we get here, name_winner and parent_winner are set to safe values.
497
winner_entry = {"this": this_entry, "other": other_entry,
498
"conflict": other_entry}
499
trans_id = self.tt.trans_id_file_id(file_id)
500
parent_id = winner_entry[parent_id_winner].parent_id
501
parent_trans_id = self.tt.trans_id_file_id(parent_id)
502
self.tt.adjust_path(winner_entry[name_winner].name, parent_trans_id,
505
def merge_contents(self, file_id):
506
"""Performa a merge on file_id contents."""
507
def contents_pair(tree):
508
if file_id not in tree:
510
kind = tree.kind(file_id)
511
if kind == "root_directory":
514
contents = tree.get_file_sha1(file_id)
515
elif kind == "symlink":
516
contents = tree.get_symlink_target(file_id)
519
return kind, contents
520
# See SPOT run. run, SPOT, run.
521
# So we're not QUITE repeating ourselves; we do tricky things with
523
base_pair = contents_pair(self.base_tree)
524
other_pair = contents_pair(self.other_tree)
525
if base_pair == other_pair:
526
# OTHER introduced no changes
528
this_pair = contents_pair(self.this_tree)
529
if this_pair == other_pair:
530
# THIS and OTHER introduced the same changes
533
trans_id = self.tt.trans_id_file_id(file_id)
534
if this_pair == base_pair:
535
# only OTHER introduced changes
536
if file_id in self.this_tree:
537
# Remove any existing contents
538
self.tt.delete_contents(trans_id)
539
if file_id in self.other_tree:
540
# OTHER changed the file
541
create_by_entry(self.tt,
542
self.other_tree.inventory[file_id],
543
self.other_tree, trans_id)
544
if file_id not in self.this_tree.inventory:
545
self.tt.version_file(file_id, trans_id)
547
elif file_id in self.this_tree.inventory:
548
# OTHER deleted the file
549
self.tt.unversion_file(trans_id)
551
#BOTH THIS and OTHER introduced changes; scalar conflict
552
elif this_pair[0] == "file" and other_pair[0] == "file":
553
# THIS and OTHER are both files, so text merge. Either
554
# BASE is a file, or both converted to files, so at least we
555
# have agreement that output should be a file.
556
if file_id not in self.this_tree.inventory:
557
self.tt.version_file(file_id, trans_id)
558
self.text_merge(file_id, trans_id)
560
self.tt.tree_kind(trans_id)
561
self.tt.delete_contents(trans_id)
566
# Scalar conflict, can't text merge. Dump conflicts
567
trans_id = self.tt.trans_id_file_id(file_id)
568
name = self.tt.final_name(trans_id)
569
parent_id = self.tt.final_parent(trans_id)
570
if file_id in self.this_tree.inventory:
571
self.tt.unversion_file(trans_id)
572
self.tt.delete_contents(trans_id)
573
file_group = self._dump_conflicts(name, parent_id, file_id,
575
self._raw_conflicts.append(('contents conflict', file_group))
577
def get_lines(self, tree, file_id):
578
"""Return the lines in a file, or an empty list."""
580
return tree.get_file(file_id).readlines()
584
def text_merge(self, file_id, trans_id):
585
"""Perform a three-way text merge on a file_id"""
586
# it's possible that we got here with base as a different type.
587
# if so, we just want two-way text conflicts.
588
if file_id in self.base_tree and \
589
self.base_tree.kind(file_id) == "file":
590
base_lines = self.get_lines(self.base_tree, file_id)
593
other_lines = self.get_lines(self.other_tree, file_id)
594
this_lines = self.get_lines(self.this_tree, file_id)
595
m3 = Merge3(base_lines, this_lines, other_lines)
596
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
597
if self.show_base is True:
598
base_marker = '|' * 7
602
def iter_merge3(retval):
603
retval["text_conflicts"] = False
604
for line in m3.merge_lines(name_a = "TREE",
605
name_b = "MERGE-SOURCE",
606
name_base = "BASE-REVISION",
607
start_marker=start_marker,
608
base_marker=base_marker,
609
reprocess=self.reprocess):
610
if line.startswith(start_marker):
611
retval["text_conflicts"] = True
612
yield line.replace(start_marker, '<' * 7)
616
merge3_iterator = iter_merge3(retval)
617
self.tt.create_file(merge3_iterator, trans_id)
618
if retval["text_conflicts"] is True:
619
self._raw_conflicts.append(('text conflict', trans_id))
620
name = self.tt.final_name(trans_id)
621
parent_id = self.tt.final_parent(trans_id)
622
file_group = self._dump_conflicts(name, parent_id, file_id,
623
this_lines, base_lines,
625
file_group.append(trans_id)
627
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
628
base_lines=None, other_lines=None, set_version=False,
630
"""Emit conflict files.
631
If this_lines, base_lines, or other_lines are omitted, they will be
632
determined automatically. If set_version is true, the .OTHER, .THIS
633
or .BASE (in that order) will be created as versioned files.
635
data = [('OTHER', self.other_tree, other_lines),
636
('THIS', self.this_tree, this_lines)]
638
data.append(('BASE', self.base_tree, base_lines))
641
for suffix, tree, lines in data:
643
trans_id = self._conflict_file(name, parent_id, tree, file_id,
645
file_group.append(trans_id)
646
if set_version and not versioned:
647
self.tt.version_file(file_id, trans_id)
651
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
653
"""Emit a single conflict file."""
654
name = name + '.' + suffix
655
trans_id = self.tt.create_path(name, parent_id)
656
entry = tree.inventory[file_id]
657
create_by_entry(self.tt, entry, tree, trans_id, lines)
660
def merge_executable(self, file_id, file_status):
661
"""Perform a merge on the execute bit."""
662
if file_status == "deleted":
664
trans_id = self.tt.trans_id_file_id(file_id)
666
if self.tt.final_kind(trans_id) != "file":
670
winner = self.scalar_three_way(self.this_tree, self.base_tree,
671
self.other_tree, file_id,
673
if winner == "conflict":
674
# There must be a None in here, if we have a conflict, but we
675
# need executability since file status was not deleted.
676
if self.other_tree.is_executable(file_id) is None:
681
if file_status == "modified":
682
executability = self.this_tree.is_executable(file_id)
683
if executability is not None:
684
trans_id = self.tt.trans_id_file_id(file_id)
685
self.tt.set_executability(executability, trans_id)
687
assert winner == "other"
688
if file_id in self.other_tree:
689
executability = self.other_tree.is_executable(file_id)
690
elif file_id in self.this_tree:
691
executability = self.this_tree.is_executable(file_id)
692
elif file_id in self.base_tree:
693
executability = self.base_tree.is_executable(file_id)
694
if executability is not None:
695
trans_id = self.tt.trans_id_file_id(file_id)
696
self.tt.set_executability(executability, trans_id)
698
def cook_conflicts(self, fs_conflicts):
699
"""Convert all conflicts into a form that doesn't depend on trans_id"""
700
from conflicts import Conflict
702
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
703
fp = FinalPaths(self.tt)
704
for conflict in self._raw_conflicts:
705
conflict_type = conflict[0]
706
if conflict_type in ('name conflict', 'parent conflict'):
707
trans_id = conflict[1]
708
conflict_args = conflict[2:]
709
if trans_id not in name_conflicts:
710
name_conflicts[trans_id] = {}
711
unique_add(name_conflicts[trans_id], conflict_type,
713
if conflict_type == 'contents conflict':
714
for trans_id in conflict[1]:
715
file_id = self.tt.final_file_id(trans_id)
234
716
if file_id is not None:
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():
718
path = fp.get_path(trans_id)
719
for suffix in ('.BASE', '.THIS', '.OTHER'):
720
if path.endswith(suffix):
721
path = path[:-len(suffix)]
723
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
724
self.cooked_conflicts.append(c)
725
if conflict_type == 'text conflict':
726
trans_id = conflict[1]
727
path = fp.get_path(trans_id)
728
file_id = self.tt.final_file_id(trans_id)
729
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
730
self.cooked_conflicts.append(c)
732
for trans_id, conflicts in name_conflicts.iteritems():
734
this_parent, other_parent = conflicts['parent conflict']
735
assert this_parent != other_parent
737
this_parent = other_parent = \
738
self.tt.final_file_id(self.tt.final_parent(trans_id))
740
this_name, other_name = conflicts['name conflict']
741
assert this_name != other_name
743
this_name = other_name = self.tt.final_name(trans_id)
744
other_path = fp.get_path(trans_id)
745
if this_parent is not None:
747
fp.get_path(self.tt.trans_id_file_id(this_parent))
748
this_path = pathjoin(this_parent_path, this_name)
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")
750
this_path = "<deleted>"
751
file_id = self.tt.final_file_id(trans_id)
752
c = Conflict.factory('path conflict', path=this_path,
753
conflict_path=other_path, file_id=file_id)
754
self.cooked_conflicts.append(c)
757
class WeaveMerger(Merge3Merger):
758
"""Three-way tree merger, text weave merger."""
759
supports_reprocess = False
760
supports_show_base = False
762
def __init__(self, working_tree, this_tree, base_tree, other_tree,
763
interesting_ids=None, pb=DummyProgress(), pp=None):
764
self.this_revision_tree = self._get_revision_tree(this_tree)
765
self.other_revision_tree = self._get_revision_tree(other_tree)
766
super(WeaveMerger, self).__init__(working_tree, this_tree,
767
base_tree, other_tree,
768
interesting_ids=interesting_ids,
771
def _get_revision_tree(self, tree):
772
"""Return a revision tree releated to this tree.
773
If the tree is a WorkingTree, the basis will be returned.
775
if getattr(tree, 'get_weave', False) is False:
776
# If we have a WorkingTree, try using the basis
777
return tree.branch.basis_tree()
781
def _check_file(self, file_id):
782
"""Check that the revision tree's version of the file matches."""
783
for tree, rt in ((self.this_tree, self.this_revision_tree),
784
(self.other_tree, self.other_revision_tree)):
787
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
788
raise WorkingTreeNotRevision(self.this_tree)
790
def _merged_lines(self, file_id):
791
"""Generate the merged lines.
792
There is no distinction between lines that are meant to contain <<<<<<<
795
weave = self.this_revision_tree.get_weave(file_id)
796
this_revision_id = self.this_revision_tree.inventory[file_id].revision
797
other_revision_id = \
798
self.other_revision_tree.inventory[file_id].revision
799
plan = weave.plan_merge(this_revision_id, other_revision_id)
800
return weave.weave_merge(plan, '<<<<<<< TREE\n',
801
'>>>>>>> MERGE-SOURCE\n')
803
def text_merge(self, file_id, trans_id):
804
"""Perform a (weave) text merge for a given file and file-id.
805
If conflicts are encountered, .THIS and .OTHER files will be emitted,
806
and a conflict will be noted.
808
self._check_file(file_id)
809
lines = list(self._merged_lines(file_id))
810
conflicts = '<<<<<<< TREE\n' in lines
811
self.tt.create_file(lines, trans_id)
813
self._raw_conflicts.append(('text conflict', trans_id))
814
name = self.tt.final_name(trans_id)
815
parent_id = self.tt.final_parent(trans_id)
816
file_group = self._dump_conflicts(name, parent_id, file_id,
818
file_group.append(trans_id)
821
class Diff3Merger(Merge3Merger):
822
"""Three-way merger using external diff3 for text merging"""
823
def dump_file(self, temp_dir, name, tree, file_id):
824
out_path = pathjoin(temp_dir, name)
825
out_file = file(out_path, "wb")
826
in_file = tree.get_file(file_id)
831
def text_merge(self, file_id, trans_id):
832
"""Perform a diff3 merge using a specified file-id and trans-id.
833
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
834
will be dumped, and a will be conflict noted.
837
temp_dir = mkdtemp(prefix="bzr-")
839
new_file = pathjoin(temp_dir, "new")
840
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
841
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
842
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
843
status = bzrlib.patch.diff3(new_file, this, base, other)
844
if status not in (0, 1):
845
raise BzrError("Unhandled diff3 exit code")
846
self.tt.create_file(file(new_file, "rb"), trans_id)
848
name = self.tt.final_name(trans_id)
849
parent_id = self.tt.final_parent(trans_id)
850
self._dump_conflicts(name, parent_id, file_id)
851
self._raw_conflicts.append(('text conflict', trans_id))
856
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
858
merge_type=Merge3Merger,
859
interesting_ids=None,
863
interesting_files=None,
866
"""Primary interface for merging.
868
typical use is probably
869
'merge_inner(branch, branch.get_revision_tree(other_revision),
870
branch.get_revision_tree(base_revision))'
872
if this_tree is None:
873
warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
874
"bzrlib version 0.8.",
877
this_tree = this_branch.bzrdir.open_workingtree()
878
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
880
merger.backup_files = backup_files
881
merger.merge_type = merge_type
882
merger.interesting_ids = interesting_ids
883
merger.ignore_zero = ignore_zero
884
if interesting_files:
885
assert not interesting_ids, ('Only supply interesting_ids'
886
' or interesting_files')
887
merger._set_interesting_files(interesting_files)
888
merger.show_base = show_base
889
merger.reprocess = reprocess
890
merger.other_rev_id = other_rev_id
891
merger.other_basis = other_rev_id
892
return merger.do_merge()
895
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
896
"diff3": (Diff3Merger, "Merge using external diff3"),
897
'weave': (WeaveMerger, "Weave-based merge")
added
removed
bzrlib/merge.py
