1
# Copyright (C) 2005 Canonical Ltd
1
# Copyright (C) 2005, 2006 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22
from fetch import greedy_fetch
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
24
40
import bzrlib.osutils
25
import bzrlib.revision
26
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
27
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
28
from bzrlib.changeset import Inventory, Diff3Merge
29
from bzrlib.branch import find_branch
30
from bzrlib.errors import BzrCommandError, UnrelatedBranches, NoCommonAncestor
31
from bzrlib.errors import NoCommits
32
from bzrlib.delta import compare_trees
33
from bzrlib.trace import mutter, warning
34
from bzrlib.fetch import greedy_fetch
35
from bzrlib.revision import is_ancestor
37
# comments from abentley on irc: merge happens in two stages, each
38
# of which generates a changeset object
40
# stage 1: generate OLD->OTHER,
41
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
43
class MergeConflictHandler(ExceptionConflictHandler):
44
"""Handle conflicts encountered while merging.
46
This subclasses ExceptionConflictHandler, so that any types of
47
conflict that are not explicitly handled cause an exception and
50
def __init__(self, dir, ignore_zero=False):
51
ExceptionConflictHandler.__init__(self, dir)
53
self.ignore_zero = ignore_zero
55
def copy(self, source, dest):
56
"""Copy the text and mode of a file
57
:param source: The path of the file to copy
58
:param dest: The distination file to create
60
s_file = file(source, "rb")
61
d_file = file(dest, "wb")
64
os.chmod(dest, 0777 & os.stat(source).st_mode)
66
def dump(self, lines, dest):
67
"""Copy the text and mode of a file
68
:param source: The path of the file to copy
69
:param dest: The distination file to create
71
d_file = file(dest, "wb")
75
def add_suffix(self, name, suffix, last_new_name=None):
76
"""Rename a file to append a suffix. If the new name exists, the
77
suffix is added repeatedly until a non-existant name is found
79
:param name: The path of the file
80
:param suffix: The suffix to append
81
:param last_new_name: (used for recursive calls) the last name tried
83
if last_new_name is None:
85
new_name = last_new_name+suffix
87
os.rename(name, new_name)
90
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
92
return self.add_suffix(name, suffix, last_new_name=new_name)
94
def conflict(self, text):
99
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
101
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
102
main file will be a version with diff3 conflicts.
103
:param new_file: Path to the output file with diff3 markers
104
:param this_path: Path to the file text for the THIS tree
105
:param base_path: Path to the file text for the BASE tree
106
:param other_path: Path to the file text for the OTHER tree
108
self.add_suffix(this_path, ".THIS")
109
self.dump(base_lines, this_path+".BASE")
110
self.dump(other_lines, this_path+".OTHER")
111
os.rename(new_file, this_path)
112
self.conflict("Diff3 conflict encountered in %s" % this_path)
114
def new_contents_conflict(self, filename, other_contents):
115
"""Conflicting contents for newly added file."""
116
self.copy(other_contents, filename + ".OTHER")
117
self.conflict("Conflict in newly added file %s" % filename)
120
def target_exists(self, entry, target, old_path):
121
"""Handle the case when the target file or dir exists"""
122
moved_path = self.add_suffix(target, ".moved")
123
self.conflict("Moved existing %s to %s" % (target, moved_path))
125
def rmdir_non_empty(self, filename):
126
"""Handle the case where the dir to be removed still has contents"""
127
self.conflict("Directory %s not removed because it is not empty"\
132
if not self.ignore_zero:
133
print "%d conflicts encountered.\n" % self.conflicts
135
def get_tree(treespec, temp_root, label, local_branch=None):
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.textfile import check_text_lines
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)
48
from bzrlib.versionedfile import WeaveMerge
51
# TODO: Report back as changes are merged in
53
def _get_tree(treespec, local_branch=None):
136
54
location, revno = treespec
137
branch = find_branch(location)
55
branch = Branch.open_containing(location)[0]
141
revision = branch.last_patch()
59
revision = branch.last_revision()
143
revision = branch.lookup_revision(revno)
144
return branch, get_revid_tree(branch, revision, temp_root, label,
147
def get_revid_tree(branch, revision, temp_root, label, local_branch):
61
revision = branch.get_rev_id(revno)
63
revision = NULL_REVISION
64
return branch, _get_revid_tree(branch, revision, local_branch)
67
def _get_revid_tree(branch, revision, local_branch):
148
68
if revision is None:
149
base_tree = branch.working_tree()
69
base_tree = branch.bzrdir.open_workingtree()
151
71
if local_branch is not None:
152
greedy_fetch(local_branch, branch, revision)
153
base_tree = local_branch.revision_tree(revision)
72
if local_branch.base != branch.base:
73
local_branch.fetch(branch, revision)
74
base_tree = local_branch.repository.revision_tree(revision)
155
base_tree = branch.revision_tree(revision)
156
temp_path = os.path.join(temp_root, label)
158
return MergeTree(base_tree, temp_path)
161
def file_exists(tree, file_id):
162
return tree.has_filename(tree.id2path(file_id))
165
class MergeTree(object):
166
def __init__(self, tree, tempdir):
76
base_tree = branch.repository.revision_tree(revision)
80
def transform_tree(from_tree, to_tree, interesting_ids=None):
81
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
82
interesting_ids=interesting_ids, this_tree=from_tree)
86
def __init__(self, this_branch, other_tree=None, base_tree=None,
87
this_tree=None, pb=DummyProgress()):
167
88
object.__init__(self)
168
if hasattr(tree, "basedir"):
169
self.root = tree.basedir
173
self.tempdir = tempdir
174
os.mkdir(os.path.join(self.tempdir, "texts"))
178
return self.tree.__iter__()
180
def __contains__(self, file_id):
181
return file_id in self.tree
183
def get_file(self, file_id):
184
return self.tree.get_file(file_id)
186
def get_file_sha1(self, id):
187
return self.tree.get_file_sha1(id)
189
def id2path(self, file_id):
190
return self.tree.id2path(file_id)
192
def has_id(self, file_id):
193
return self.tree.has_id(file_id)
195
def has_or_had_id(self, file_id):
196
if file_id == self.tree.inventory.root.file_id:
198
return self.tree.inventory.has_id(file_id)
200
def has_or_had_id(self, file_id):
201
if file_id == self.tree.inventory.root.file_id:
203
return self.tree.inventory.has_id(file_id)
205
def readonly_path(self, id):
206
if id not in self.tree:
208
if self.root is not None:
209
return self.tree.abspath(self.tree.id2path(id))
211
if self.tree.inventory[id].kind in ("directory", "root_directory"):
213
if not self.cached.has_key(id):
214
path = os.path.join(self.tempdir, "texts", id)
215
outfile = file(path, "wb")
216
outfile.write(self.tree.get_file(id).read())
217
assert(os.path.exists(path))
218
self.cached[id] = path
219
return self.cached[id]
223
def merge(other_revision, base_revision,
224
check_clean=True, ignore_zero=False,
225
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
227
"""Merge changes into a tree.
230
tuple(path, revision) Base for three-way merge.
232
tuple(path, revision) Other revision for three-way merge.
234
Directory to merge changes into; '.' by default.
236
If true, this_dir must have no uncommitted changes before the
238
all available ancestors of other_revision and base_revision are
239
automatically pulled into the branch.
241
from bzrlib.revision import common_ancestor, MultipleRevisionSources
242
from bzrlib.errors import NoSuchRevision
243
tempdir = tempfile.mkdtemp(prefix="bzr-")
247
this_branch = find_branch(this_dir)
248
this_rev_id = this_branch.last_patch()
249
if this_rev_id is None:
89
assert this_tree is not None, "this_tree is required"
90
self.this_branch = this_branch
91
self.this_basis = this_branch.last_revision()
92
self.this_rev_id = None
93
self.this_tree = this_tree
94
self.this_revision_tree = None
95
self.this_basis_tree = None
96
self.other_tree = other_tree
97
self.base_tree = base_tree
98
self.ignore_zero = False
99
self.backup_files = False
100
self.interesting_ids = None
101
self.show_base = False
102
self.reprocess = False
107
def revision_tree(self, revision_id):
108
return self.this_branch.repository.revision_tree(revision_id)
110
def ensure_revision_trees(self):
111
if self.this_revision_tree is None:
112
self.this_basis_tree = self.this_branch.repository.revision_tree(
114
if self.this_basis == self.this_rev_id:
115
self.this_revision_tree = self.this_basis_tree
117
if self.other_rev_id is None:
118
other_basis_tree = self.revision_tree(self.other_basis)
119
changes = compare_trees(self.other_tree, other_basis_tree)
120
if changes.has_changed():
121
raise WorkingTreeNotRevision(self.this_tree)
122
other_rev_id = self.other_basis
123
self.other_tree = other_basis_tree
125
def file_revisions(self, file_id):
126
self.ensure_revision_trees()
127
def get_id(tree, file_id):
128
revision_id = tree.inventory[file_id].revision
129
assert revision_id is not None
131
if self.this_rev_id is None:
132
if self.this_basis_tree.get_file_sha1(file_id) != \
133
self.this_tree.get_file_sha1(file_id):
134
raise WorkingTreeNotRevision(self.this_tree)
136
trees = (self.this_basis_tree, self.other_tree)
137
return [get_id(tree, file_id) for tree in trees]
139
def check_basis(self, check_clean, require_commits=True):
140
if self.this_basis is None and require_commits is True:
250
141
raise BzrCommandError("This branch has no commits")
252
changes = compare_trees(this_branch.working_tree(),
253
this_branch.basis_tree(), False)
254
if changes.has_changed():
144
if self.this_basis != self.this_rev_id:
255
145
raise BzrCommandError("Working tree has uncommitted changes.")
256
other_branch, other_tree = get_tree(other_revision, tempdir, "other",
147
def compare_basis(self):
148
changes = compare_trees(self.this_tree,
149
self.this_tree.basis_tree(), False)
150
if not changes.has_changed():
151
self.this_rev_id = self.this_basis
153
def set_interesting_files(self, file_list):
155
self._set_interesting_files(file_list)
156
except NotVersionedError, e:
157
raise BzrCommandError("%s is not a source file in any"
160
def _set_interesting_files(self, file_list):
161
"""Set the list of interesting ids from a list of files."""
162
if file_list is None:
163
self.interesting_ids = None
166
interesting_ids = set()
167
for path in file_list:
169
for tree in (self.this_tree, self.base_tree, self.other_tree):
170
file_id = tree.inventory.path2id(path)
171
if file_id is not None:
172
interesting_ids.add(file_id)
175
raise NotVersionedError(path=path)
176
self.interesting_ids = interesting_ids
178
def set_pending(self):
179
if not self.base_is_ancestor:
181
if self.other_rev_id is None:
183
ancestry = self.this_branch.repository.get_ancestry(self.this_basis)
184
if self.other_rev_id in ancestry:
186
self.this_tree.add_pending_merge(self.other_rev_id)
188
def set_other(self, other_revision):
189
other_branch, self.other_tree = _get_tree(other_revision,
258
191
if other_revision[1] == -1:
259
other_rev_id = other_branch.last_patch()
260
if other_rev_id is None:
192
self.other_rev_id = other_branch.last_revision()
193
if self.other_rev_id is None:
261
194
raise NoCommits(other_branch)
262
other_basis = other_rev_id
195
self.other_basis = self.other_rev_id
263
196
elif other_revision[1] is not None:
264
other_rev_id = other_branch.lookup_revision(other_revision[1])
265
other_basis = other_rev_id
197
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
198
self.other_basis = self.other_rev_id
268
other_basis = other_branch.last_patch()
269
if other_basis is None:
200
self.other_rev_id = None
201
self.other_basis = other_branch.last_revision()
202
if self.other_basis is None:
270
203
raise NoCommits(other_branch)
204
if other_branch.base != self.this_branch.base:
205
self.this_branch.fetch(other_branch, last_revision=self.other_basis)
208
self.set_base([None, None])
210
def set_base(self, base_revision):
211
mutter("doing merge() with no base_revision specified")
271
212
if base_revision == [None, None]:
273
base_rev_id = common_ancestor(this_rev_id, other_basis,
214
pb = bzrlib.ui.ui_factory.nested_progress_bar()
216
this_repo = self.this_branch.repository
217
self.base_rev_id = common_ancestor(self.this_basis,
275
222
except NoCommonAncestor:
276
223
raise UnrelatedBranches()
277
base_tree = get_revid_tree(this_branch, base_rev_id, tempdir,
279
base_is_ancestor = True
224
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
226
self.base_is_ancestor = True
281
base_branch, base_tree = get_tree(base_revision, tempdir, "base")
228
base_branch, self.base_tree = _get_tree(base_revision)
282
229
if base_revision[1] == -1:
283
base_rev_id = base_branch.last_patch()
230
self.base_rev_id = base_branch.last_revision()
284
231
elif base_revision[1] is None:
287
base_rev_id = base_branch.lookup_revision(base_revision[1])
288
if base_rev_id is not None:
289
base_is_ancestor = is_ancestor(this_rev_id, base_rev_id,
290
MultipleRevisionSources(this_branch,
293
base_is_ancestor = False
294
if file_list is None:
295
interesting_ids = None
297
interesting_ids = set()
298
this_tree = this_branch.working_tree()
299
for fname in file_list:
300
path = this_branch.relpath(fname)
302
for tree in (this_tree, base_tree.tree, other_tree.tree):
303
file_id = tree.inventory.path2id(path)
232
self.base_rev_id = None
234
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
235
if self.this_branch.base != base_branch.base:
236
self.this_branch.fetch(base_branch)
237
self.base_is_ancestor = is_ancestor(self.this_basis,
242
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
243
'other_tree': self.other_tree,
244
'interesting_ids': self.interesting_ids,
246
if self.merge_type.requires_base:
247
kwargs['base_tree'] = self.base_tree
248
if self.merge_type.supports_reprocess:
249
kwargs['reprocess'] = self.reprocess
251
raise BzrError("Conflict reduction is not supported for merge"
252
" type %s." % self.merge_type)
253
if self.merge_type.supports_show_base:
254
kwargs['show_base'] = self.show_base
256
raise BzrError("Showing base is not supported for this"
257
" merge type. %s" % self.merge_type)
258
merge = self.merge_type(pb=self._pb, **kwargs)
259
if len(merge.cooked_conflicts) == 0:
260
if not self.ignore_zero:
261
note("All changes applied successfully.")
263
note("%d conflicts encountered." % len(merge.cooked_conflicts))
265
return len(merge.cooked_conflicts)
267
def regen_inventory(self, new_entries):
268
old_entries = self.this_tree.read_working_inventory()
272
for path, file_id in new_entries:
275
new_entries_map[file_id] = path
277
def id2path(file_id):
278
path = new_entries_map.get(file_id)
281
entry = old_entries[file_id]
282
if entry.parent_id is None:
284
return pathjoin(id2path(entry.parent_id), entry.name)
286
for file_id in old_entries:
287
entry = old_entries[file_id]
288
path = id2path(file_id)
289
if file_id in self.base_tree.inventory:
290
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
292
executable = getattr(entry, 'executable', False)
293
new_inventory[file_id] = (path, file_id, entry.parent_id,
294
entry.kind, executable)
296
by_path[path] = file_id
301
for path, file_id in new_entries:
303
del new_inventory[file_id]
306
new_path_list.append((path, file_id))
307
if file_id not in old_entries:
309
# Ensure no file is added before its parent
311
for path, file_id in new_path_list:
315
parent = by_path[os.path.dirname(path)]
316
abspath = pathjoin(self.this_tree.basedir, path)
317
kind = bzrlib.osutils.file_kind(abspath)
318
if file_id in self.base_tree.inventory:
319
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
322
new_inventory[file_id] = (path, file_id, parent, kind, executable)
323
by_path[path] = file_id
325
# Get a list in insertion order
326
new_inventory_list = new_inventory.values()
327
mutter ("""Inventory regeneration:
328
old length: %i insertions: %i deletions: %i new_length: %i"""\
329
% (len(old_entries), insertions, deletions,
330
len(new_inventory_list)))
331
assert len(new_inventory_list) == len(old_entries) + insertions\
333
new_inventory_list.sort()
334
return new_inventory_list
337
class Merge3Merger(object):
338
"""Three-way merger that uses the merge3 text merger"""
340
supports_reprocess = True
341
supports_show_base = True
342
history_based = False
344
def __init__(self, working_tree, this_tree, base_tree, other_tree,
345
interesting_ids=None, reprocess=False, show_base=False,
346
pb=DummyProgress(), pp=None):
347
"""Initialize the merger object and perform the merge."""
348
object.__init__(self)
349
self.this_tree = working_tree
350
self.base_tree = base_tree
351
self.other_tree = other_tree
352
self._raw_conflicts = []
353
self.cooked_conflicts = []
354
self.reprocess = reprocess
355
self.show_base = show_base
359
self.pp = ProgressPhase("Merge phase", 3, self.pb)
361
if interesting_ids is not None:
362
all_ids = interesting_ids
364
all_ids = set(base_tree)
365
all_ids.update(other_tree)
366
working_tree.lock_write()
367
self.tt = TreeTransform(working_tree, self.pb)
370
child_pb = ui.ui_factory.nested_progress_bar()
372
for num, file_id in enumerate(all_ids):
373
child_pb.update('Preparing file merge', num, len(all_ids))
374
self.merge_names(file_id)
375
file_status = self.merge_contents(file_id)
376
self.merge_executable(file_id, file_status)
381
child_pb = ui.ui_factory.nested_progress_bar()
383
fs_conflicts = resolve_conflicts(self.tt, child_pb)
386
self.cook_conflicts(fs_conflicts)
387
for conflict in self.cooked_conflicts:
390
results = self.tt.apply()
391
self.write_modified(results)
393
working_tree.add_conflicts(self.cooked_conflicts)
394
except UnsupportedOperation:
398
working_tree.unlock()
401
def write_modified(self, results):
403
for path in results.modified_paths:
404
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
407
hash = self.this_tree.get_file_sha1(file_id)
410
modified_hashes[file_id] = hash
411
self.this_tree.set_merge_modified(modified_hashes)
414
def parent(entry, file_id):
415
"""Determine the parent for a file_id (used as a key method)"""
418
return entry.parent_id
421
def name(entry, file_id):
422
"""Determine the name for a file_id (used as a key method)"""
428
def contents_sha1(tree, file_id):
429
"""Determine the sha1 of the file contents (used as a key method)."""
430
if file_id not in tree:
432
return tree.get_file_sha1(file_id)
435
def executable(tree, file_id):
436
"""Determine the executability of a file-id (used as a key method)."""
437
if file_id not in tree:
439
if tree.kind(file_id) != "file":
441
return tree.is_executable(file_id)
444
def kind(tree, file_id):
445
"""Determine the kind of a file-id (used as a key method)."""
446
if file_id not in tree:
448
return tree.kind(file_id)
451
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
452
"""Do a three-way test on a scalar.
453
Return "this", "other" or "conflict", depending whether a value wins.
455
key_base = key(base_tree, file_id)
456
key_other = key(other_tree, file_id)
457
#if base == other, either they all agree, or only THIS has changed.
458
if key_base == key_other:
460
key_this = key(this_tree, file_id)
461
if key_this not in (key_base, key_other):
463
# "Ambiguous clean merge"
464
elif key_this == key_other:
467
assert key_this == key_base
470
def merge_names(self, file_id):
471
"""Perform a merge on file_id names and parents"""
473
if file_id in tree.inventory:
474
return tree.inventory[file_id]
477
this_entry = get_entry(self.this_tree)
478
other_entry = get_entry(self.other_tree)
479
base_entry = get_entry(self.base_tree)
480
name_winner = self.scalar_three_way(this_entry, base_entry,
481
other_entry, file_id, self.name)
482
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
483
other_entry, file_id,
485
if this_entry is None:
486
if name_winner == "this":
487
name_winner = "other"
488
if parent_id_winner == "this":
489
parent_id_winner = "other"
490
if name_winner == "this" and parent_id_winner == "this":
492
if name_winner == "conflict":
493
trans_id = self.tt.trans_id_file_id(file_id)
494
self._raw_conflicts.append(('name conflict', trans_id,
495
self.name(this_entry, file_id),
496
self.name(other_entry, file_id)))
497
if parent_id_winner == "conflict":
498
trans_id = self.tt.trans_id_file_id(file_id)
499
self._raw_conflicts.append(('parent conflict', trans_id,
500
self.parent(this_entry, file_id),
501
self.parent(other_entry, file_id)))
502
if other_entry is None:
503
# it doesn't matter whether the result was 'other' or
504
# 'conflict'-- if there's no 'other', we leave it alone.
506
# if we get here, name_winner and parent_winner are set to safe values.
507
winner_entry = {"this": this_entry, "other": other_entry,
508
"conflict": other_entry}
509
trans_id = self.tt.trans_id_file_id(file_id)
510
parent_id = winner_entry[parent_id_winner].parent_id
511
parent_trans_id = self.tt.trans_id_file_id(parent_id)
512
self.tt.adjust_path(winner_entry[name_winner].name, parent_trans_id,
515
def merge_contents(self, file_id):
516
"""Performa a merge on file_id contents."""
517
def contents_pair(tree):
518
if file_id not in tree:
520
kind = tree.kind(file_id)
521
if kind == "root_directory":
524
contents = tree.get_file_sha1(file_id)
525
elif kind == "symlink":
526
contents = tree.get_symlink_target(file_id)
529
return kind, contents
531
def contents_conflict():
532
trans_id = self.tt.trans_id_file_id(file_id)
533
name = self.tt.final_name(trans_id)
534
parent_id = self.tt.final_parent(trans_id)
535
if file_id in self.this_tree.inventory:
536
self.tt.unversion_file(trans_id)
537
self.tt.delete_contents(trans_id)
538
file_group = self._dump_conflicts(name, parent_id, file_id,
540
self._raw_conflicts.append(('contents conflict', file_group))
542
# See SPOT run. run, SPOT, run.
543
# So we're not QUITE repeating ourselves; we do tricky things with
545
base_pair = contents_pair(self.base_tree)
546
other_pair = contents_pair(self.other_tree)
547
if base_pair == other_pair:
548
# OTHER introduced no changes
550
this_pair = contents_pair(self.this_tree)
551
if this_pair == other_pair:
552
# THIS and OTHER introduced the same changes
555
trans_id = self.tt.trans_id_file_id(file_id)
556
if this_pair == base_pair:
557
# only OTHER introduced changes
558
if file_id in self.this_tree:
559
# Remove any existing contents
560
self.tt.delete_contents(trans_id)
561
if file_id in self.other_tree:
562
# OTHER changed the file
563
create_by_entry(self.tt,
564
self.other_tree.inventory[file_id],
565
self.other_tree, trans_id)
566
if file_id not in self.this_tree.inventory:
567
self.tt.version_file(file_id, trans_id)
569
elif file_id in self.this_tree.inventory:
570
# OTHER deleted the file
571
self.tt.unversion_file(trans_id)
573
#BOTH THIS and OTHER introduced changes; scalar conflict
574
elif this_pair[0] == "file" and other_pair[0] == "file":
575
# THIS and OTHER are both files, so text merge. Either
576
# BASE is a file, or both converted to files, so at least we
577
# have agreement that output should be a file.
579
self.text_merge(file_id, trans_id)
581
return contents_conflict()
582
if file_id not in self.this_tree.inventory:
583
self.tt.version_file(file_id, trans_id)
585
self.tt.tree_kind(trans_id)
586
self.tt.delete_contents(trans_id)
591
# Scalar conflict, can't text merge. Dump conflicts
592
return contents_conflict()
594
def get_lines(self, tree, file_id):
595
"""Return the lines in a file, or an empty list."""
597
return tree.get_file(file_id).readlines()
601
def text_merge(self, file_id, trans_id):
602
"""Perform a three-way text merge on a file_id"""
603
# it's possible that we got here with base as a different type.
604
# if so, we just want two-way text conflicts.
605
if file_id in self.base_tree and \
606
self.base_tree.kind(file_id) == "file":
607
base_lines = self.get_lines(self.base_tree, file_id)
610
other_lines = self.get_lines(self.other_tree, file_id)
611
this_lines = self.get_lines(self.this_tree, file_id)
612
m3 = Merge3(base_lines, this_lines, other_lines)
613
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
614
if self.show_base is True:
615
base_marker = '|' * 7
619
def iter_merge3(retval):
620
retval["text_conflicts"] = False
621
for line in m3.merge_lines(name_a = "TREE",
622
name_b = "MERGE-SOURCE",
623
name_base = "BASE-REVISION",
624
start_marker=start_marker,
625
base_marker=base_marker,
626
reprocess=self.reprocess):
627
if line.startswith(start_marker):
628
retval["text_conflicts"] = True
629
yield line.replace(start_marker, '<' * 7)
633
merge3_iterator = iter_merge3(retval)
634
self.tt.create_file(merge3_iterator, trans_id)
635
if retval["text_conflicts"] is True:
636
self._raw_conflicts.append(('text conflict', trans_id))
637
name = self.tt.final_name(trans_id)
638
parent_id = self.tt.final_parent(trans_id)
639
file_group = self._dump_conflicts(name, parent_id, file_id,
640
this_lines, base_lines,
642
file_group.append(trans_id)
644
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
645
base_lines=None, other_lines=None, set_version=False,
647
"""Emit conflict files.
648
If this_lines, base_lines, or other_lines are omitted, they will be
649
determined automatically. If set_version is true, the .OTHER, .THIS
650
or .BASE (in that order) will be created as versioned files.
652
data = [('OTHER', self.other_tree, other_lines),
653
('THIS', self.this_tree, this_lines)]
655
data.append(('BASE', self.base_tree, base_lines))
658
for suffix, tree, lines in data:
660
trans_id = self._conflict_file(name, parent_id, tree, file_id,
662
file_group.append(trans_id)
663
if set_version and not versioned:
664
self.tt.version_file(file_id, trans_id)
668
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
670
"""Emit a single conflict file."""
671
name = name + '.' + suffix
672
trans_id = self.tt.create_path(name, parent_id)
673
entry = tree.inventory[file_id]
674
create_by_entry(self.tt, entry, tree, trans_id, lines)
677
def merge_executable(self, file_id, file_status):
678
"""Perform a merge on the execute bit."""
679
if file_status == "deleted":
681
trans_id = self.tt.trans_id_file_id(file_id)
683
if self.tt.final_kind(trans_id) != "file":
687
winner = self.scalar_three_way(self.this_tree, self.base_tree,
688
self.other_tree, file_id,
690
if winner == "conflict":
691
# There must be a None in here, if we have a conflict, but we
692
# need executability since file status was not deleted.
693
if self.executable(self.other_tree, file_id) is None:
698
if file_status == "modified":
699
executability = self.this_tree.is_executable(file_id)
700
if executability is not None:
701
trans_id = self.tt.trans_id_file_id(file_id)
702
self.tt.set_executability(executability, trans_id)
704
assert winner == "other"
705
if file_id in self.other_tree:
706
executability = self.other_tree.is_executable(file_id)
707
elif file_id in self.this_tree:
708
executability = self.this_tree.is_executable(file_id)
709
elif file_id in self.base_tree:
710
executability = self.base_tree.is_executable(file_id)
711
if executability is not None:
712
trans_id = self.tt.trans_id_file_id(file_id)
713
self.tt.set_executability(executability, trans_id)
715
def cook_conflicts(self, fs_conflicts):
716
"""Convert all conflicts into a form that doesn't depend on trans_id"""
717
from conflicts import Conflict
719
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
720
fp = FinalPaths(self.tt)
721
for conflict in self._raw_conflicts:
722
conflict_type = conflict[0]
723
if conflict_type in ('name conflict', 'parent conflict'):
724
trans_id = conflict[1]
725
conflict_args = conflict[2:]
726
if trans_id not in name_conflicts:
727
name_conflicts[trans_id] = {}
728
unique_add(name_conflicts[trans_id], conflict_type,
730
if conflict_type == 'contents conflict':
731
for trans_id in conflict[1]:
732
file_id = self.tt.final_file_id(trans_id)
304
733
if file_id is not None:
305
interesting_ids.add(file_id)
308
raise BzrCommandError("%s is not a source file in any"
310
merge_inner(this_branch, other_tree, base_tree, tempdir,
311
ignore_zero=ignore_zero, backup_files=backup_files,
312
merge_type=merge_type, interesting_ids=interesting_ids)
313
if base_is_ancestor and other_rev_id is not None\
314
and other_rev_id not in this_branch.revision_history():
315
this_branch.add_pending_merge(other_rev_id)
317
shutil.rmtree(tempdir)
320
def set_interesting(inventory_a, inventory_b, interesting_ids):
321
"""Mark files whose ids are in interesting_ids as interesting
323
for inventory in (inventory_a, inventory_b):
324
for path, source_file in inventory.iteritems():
325
source_file.interesting = source_file.id in interesting_ids
328
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
329
"""Generate a changeset. If interesting_ids is supplied, only changes
330
to those files will be shown. Metadata changes are stripped.
332
cset = generate_changeset(tree_a, tree_b, interesting_ids)
333
for entry in cset.entries.itervalues():
334
entry.metadata_change = None
338
def merge_inner(this_branch, other_tree, base_tree, tempdir,
339
ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
340
interesting_ids=None):
342
def merge_factory(file_id, base, other):
343
contents_change = merge_type(file_id, base, other)
345
contents_change = BackupBeforeChange(contents_change)
346
return contents_change
348
this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
350
def get_inventory(tree):
351
return tree.tree.inventory
353
inv_changes = merge_flex(this_tree, base_tree, other_tree,
354
generate_cset_optimized, get_inventory,
355
MergeConflictHandler(base_tree.root,
356
ignore_zero=ignore_zero),
357
merge_factory=merge_factory,
358
interesting_ids=interesting_ids)
361
for id, path in inv_changes.iteritems():
735
path = fp.get_path(trans_id)
736
for suffix in ('.BASE', '.THIS', '.OTHER'):
737
if path.endswith(suffix):
738
path = path[:-len(suffix)]
740
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
741
self.cooked_conflicts.append(c)
742
if conflict_type == 'text conflict':
743
trans_id = conflict[1]
744
path = fp.get_path(trans_id)
745
file_id = self.tt.final_file_id(trans_id)
746
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
747
self.cooked_conflicts.append(c)
749
for trans_id, conflicts in name_conflicts.iteritems():
751
this_parent, other_parent = conflicts['parent conflict']
752
assert this_parent != other_parent
754
this_parent = other_parent = \
755
self.tt.final_file_id(self.tt.final_parent(trans_id))
757
this_name, other_name = conflicts['name conflict']
758
assert this_name != other_name
760
this_name = other_name = self.tt.final_name(trans_id)
761
other_path = fp.get_path(trans_id)
762
if this_parent is not None:
764
fp.get_path(self.tt.trans_id_file_id(this_parent))
765
this_path = pathjoin(this_parent_path, this_name)
366
assert path.startswith('.' + os.sep), "path is %s" % path
368
adjust_ids.append((path, id))
369
if len(adjust_ids) > 0:
370
this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
374
def regen_inventory(this_branch, root, new_entries):
375
old_entries = this_branch.read_working_inventory()
379
for path, file_id in new_entries:
382
new_entries_map[file_id] = path
384
def id2path(file_id):
385
path = new_entries_map.get(file_id)
388
entry = old_entries[file_id]
389
if entry.parent_id is None:
391
return os.path.join(id2path(entry.parent_id), entry.name)
393
for file_id in old_entries:
394
entry = old_entries[file_id]
395
path = id2path(file_id)
396
new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
397
by_path[path] = file_id
402
for path, file_id in new_entries:
404
del new_inventory[file_id]
407
new_path_list.append((path, file_id))
408
if file_id not in old_entries:
410
# Ensure no file is added before its parent
412
for path, file_id in new_path_list:
416
parent = by_path[os.path.dirname(path)]
417
kind = bzrlib.osutils.file_kind(os.path.join(root, path))
418
new_inventory[file_id] = (path, file_id, parent, kind)
419
by_path[path] = file_id
421
# Get a list in insertion order
422
new_inventory_list = new_inventory.values()
423
mutter ("""Inventory regeneration:
424
old length: %i insertions: %i deletions: %i new_length: %i"""\
425
% (len(old_entries), insertions, deletions, len(new_inventory_list)))
426
assert len(new_inventory_list) == len(old_entries) + insertions - deletions
427
new_inventory_list.sort()
428
return new_inventory_list
430
merge_types = { "merge3": (ApplyMerge3, "Native diff3-style merge"),
431
"diff3": (Diff3Merge, "Merge using external diff3")
767
this_path = "<deleted>"
768
file_id = self.tt.final_file_id(trans_id)
769
c = Conflict.factory('path conflict', path=this_path,
770
conflict_path=other_path, file_id=file_id)
771
self.cooked_conflicts.append(c)
772
self.cooked_conflicts.sort(key=Conflict.sort_key)
775
class WeaveMerger(Merge3Merger):
776
"""Three-way tree merger, text weave merger."""
777
supports_reprocess = True
778
supports_show_base = False
780
def __init__(self, working_tree, this_tree, base_tree, other_tree,
781
interesting_ids=None, pb=DummyProgress(), pp=None,
783
self.this_revision_tree = self._get_revision_tree(this_tree)
784
self.other_revision_tree = self._get_revision_tree(other_tree)
785
super(WeaveMerger, self).__init__(working_tree, this_tree,
786
base_tree, other_tree,
787
interesting_ids=interesting_ids,
788
pb=pb, pp=pp, reprocess=reprocess)
790
def _get_revision_tree(self, tree):
791
"""Return a revision tree related to this tree.
792
If the tree is a WorkingTree, the basis will be returned.
794
if getattr(tree, 'get_weave', False) is False:
795
# If we have a WorkingTree, try using the basis
796
return tree.branch.basis_tree()
800
def _check_file(self, file_id):
801
"""Check that the revision tree's version of the file matches."""
802
for tree, rt in ((self.this_tree, self.this_revision_tree),
803
(self.other_tree, self.other_revision_tree)):
806
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
807
raise WorkingTreeNotRevision(self.this_tree)
809
def _merged_lines(self, file_id):
810
"""Generate the merged lines.
811
There is no distinction between lines that are meant to contain <<<<<<<
814
weave = self.this_revision_tree.get_weave(file_id)
815
this_revision_id = self.this_revision_tree.inventory[file_id].revision
816
other_revision_id = \
817
self.other_revision_tree.inventory[file_id].revision
818
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
819
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
820
return wm.merge_lines(self.reprocess)
822
def text_merge(self, file_id, trans_id):
823
"""Perform a (weave) text merge for a given file and file-id.
824
If conflicts are encountered, .THIS and .OTHER files will be emitted,
825
and a conflict will be noted.
827
self._check_file(file_id)
828
lines, conflicts = self._merged_lines(file_id)
830
# Note we're checking whether the OUTPUT is binary in this case,
831
# because we don't want to get into weave merge guts.
832
check_text_lines(lines)
833
self.tt.create_file(lines, trans_id)
835
self._raw_conflicts.append(('text conflict', trans_id))
836
name = self.tt.final_name(trans_id)
837
parent_id = self.tt.final_parent(trans_id)
838
file_group = self._dump_conflicts(name, parent_id, file_id,
840
file_group.append(trans_id)
843
class Diff3Merger(Merge3Merger):
844
"""Three-way merger using external diff3 for text merging"""
846
def dump_file(self, temp_dir, name, tree, file_id):
847
out_path = pathjoin(temp_dir, name)
848
out_file = open(out_path, "wb")
850
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
f = open(new_file, 'rb')
874
self.tt.create_file(f, trans_id)
878
name = self.tt.final_name(trans_id)
879
parent_id = self.tt.final_parent(trans_id)
880
self._dump_conflicts(name, parent_id, file_id)
881
self._raw_conflicts.append(('text conflict', trans_id))
886
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
888
merge_type=Merge3Merger,
889
interesting_ids=None,
893
interesting_files=None,
896
"""Primary interface for merging.
898
typical use is probably
899
'merge_inner(branch, branch.get_revision_tree(other_revision),
900
branch.get_revision_tree(base_revision))'
902
if this_tree is None:
903
warnings.warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
904
"bzrlib version 0.8.",
907
this_tree = this_branch.bzrdir.open_workingtree()
908
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
910
merger.backup_files = backup_files
911
merger.merge_type = merge_type
912
merger.interesting_ids = interesting_ids
913
merger.ignore_zero = ignore_zero
914
if interesting_files:
915
assert not interesting_ids, ('Only supply interesting_ids'
916
' or interesting_files')
917
merger._set_interesting_files(interesting_files)
918
merger.show_base = show_base
919
merger.reprocess = reprocess
920
merger.other_rev_id = other_rev_id
921
merger.other_basis = other_rev_id
922
return merger.do_merge()
925
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
926
"diff3": (Diff3Merger, "Merge using external diff3"),
927
'weave': (WeaveMerger, "Weave-based merge")
931
def merge_type_help():
932
templ = '%s%%7s: %%s' % (' '*12)
933
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
934
return '\n'.join(lines)
added
removed
bzrlib/merge.py
