1
# Copyright (C) 2005, 2006 Canonical Ltd
1
# Copyright (C) 2005 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
20
from tempfile import mkdtemp
24
import bzrlib.revision
25
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
26
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
27
from bzrlib.changeset import Inventory, Diff3Merge
23
28
from bzrlib.branch import Branch
24
from bzrlib.conflicts import ConflictList, Conflict
29
from bzrlib.errors import BzrCommandError, UnrelatedBranches, NoCommonAncestor
30
from bzrlib.errors import NoCommits
25
31
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.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):
32
from bzrlib.trace import mutter, warning
33
from bzrlib.fetch import greedy_fetch, fetch
34
from bzrlib.revision import is_ancestor
35
from bzrlib.osutils import rename
36
from bzrlib.revision import common_ancestor, MultipleRevisionSources
37
from bzrlib.errors import NoSuchRevision
39
# TODO: build_working_dir can be built on something simpler than merge()
41
# FIXME: merge() parameters seem oriented towards the command line
43
# comments from abentley on irc: merge happens in two stages, each
44
# of which generates a changeset object
46
# stage 1: generate OLD->OTHER,
47
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
49
class MergeConflictHandler(ExceptionConflictHandler):
50
"""Handle conflicts encountered while merging.
52
This subclasses ExceptionConflictHandler, so that any types of
53
conflict that are not explicitly handled cause an exception and
56
def __init__(self, ignore_zero=False):
57
ExceptionConflictHandler.__init__(self)
59
self.ignore_zero = ignore_zero
61
def copy(self, source, dest):
62
"""Copy the text and mode of a file
63
:param source: The path of the file to copy
64
:param dest: The distination file to create
66
s_file = file(source, "rb")
67
d_file = file(dest, "wb")
70
os.chmod(dest, 0777 & os.stat(source).st_mode)
72
def dump(self, lines, dest):
73
"""Copy the text and mode of a file
74
:param source: The path of the file to copy
75
:param dest: The distination file to create
77
d_file = file(dest, "wb")
81
def add_suffix(self, name, suffix, last_new_name=None):
82
"""Rename a file to append a suffix. If the new name exists, the
83
suffix is added repeatedly until a non-existant name is found
85
:param name: The path of the file
86
:param suffix: The suffix to append
87
:param last_new_name: (used for recursive calls) the last name tried
89
if last_new_name is None:
91
new_name = last_new_name+suffix
93
rename(name, new_name)
96
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
98
return self.add_suffix(name, suffix, last_new_name=new_name)
100
def conflict(self, text):
105
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
107
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
108
main file will be a version with diff3 conflicts.
109
:param new_file: Path to the output file with diff3 markers
110
:param this_path: Path to the file text for the THIS tree
111
:param base_path: Path to the file text for the BASE tree
112
:param other_path: Path to the file text for the OTHER tree
114
self.add_suffix(this_path, ".THIS")
115
self.dump(base_lines, this_path+".BASE")
116
self.dump(other_lines, this_path+".OTHER")
117
rename(new_file, this_path)
118
self.conflict("Diff3 conflict encountered in %s" % this_path)
120
def new_contents_conflict(self, filename, other_contents):
121
"""Conflicting contents for newly added file."""
122
self.copy(other_contents, filename + ".OTHER")
123
self.conflict("Conflict in newly added file %s" % filename)
126
def target_exists(self, entry, target, old_path):
127
"""Handle the case when the target file or dir exists"""
128
moved_path = self.add_suffix(target, ".moved")
129
self.conflict("Moved existing %s to %s" % (target, moved_path))
131
def rmdir_non_empty(self, filename):
132
"""Handle the case where the dir to be removed still has contents"""
133
self.conflict("Directory %s not removed because it is not empty"\
138
if not self.ignore_zero:
139
print "%d conflicts encountered.\n" % self.conflicts
141
def get_tree(treespec, temp_root, label, local_branch=None):
54
142
location, revno = treespec
55
branch = Branch.open_containing(location)[0]
143
branch = Branch.open_containing(location)
59
147
revision = branch.last_revision()
61
149
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):
150
return branch, get_revid_tree(branch, revision, temp_root, label,
153
def get_revid_tree(branch, revision, temp_root, label, local_branch):
68
154
if revision is None:
69
base_tree = branch.bzrdir.open_workingtree()
155
base_tree = branch.working_tree()
71
157
if local_branch is not None:
72
if local_branch.base != branch.base:
73
local_branch.fetch(branch, revision)
74
base_tree = local_branch.repository.revision_tree(revision)
158
greedy_fetch(local_branch, branch, revision)
159
base_tree = local_branch.revision_tree(revision)
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()):
161
base_tree = branch.revision_tree(revision)
162
temp_path = os.path.join(temp_root, label)
164
return MergeTree(base_tree, temp_path)
167
def file_exists(tree, file_id):
168
return tree.has_filename(tree.id2path(file_id))
171
class MergeTree(object):
172
def __init__(self, tree, tempdir):
88
173
object.__init__(self)
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:
174
if hasattr(tree, "basedir"):
175
self.root = tree.basedir
179
self.tempdir = tempdir
180
os.mkdir(os.path.join(self.tempdir, "texts"))
184
return self.tree.__iter__()
186
def __contains__(self, file_id):
187
return file_id in self.tree
189
def get_file(self, file_id):
190
return self.tree.get_file(file_id)
192
def get_file_sha1(self, id):
193
return self.tree.get_file_sha1(id)
195
def id2path(self, file_id):
196
return self.tree.id2path(file_id)
198
def has_id(self, file_id):
199
return self.tree.has_id(file_id)
201
def has_or_had_id(self, file_id):
202
if file_id == self.tree.inventory.root.file_id:
204
return self.tree.inventory.has_id(file_id)
206
def has_or_had_id(self, file_id):
207
if file_id == self.tree.inventory.root.file_id:
209
return self.tree.inventory.has_id(file_id)
211
def readonly_path(self, id):
212
if id not in self.tree:
214
if self.root is not None:
215
return self.tree.abspath(self.tree.id2path(id))
217
if self.tree.inventory[id].kind in ("directory", "root_directory"):
219
if not self.cached.has_key(id):
220
path = os.path.join(self.tempdir, "texts", id)
221
outfile = file(path, "wb")
222
outfile.write(self.tree.get_file(id).read())
223
assert(os.path.exists(path))
224
self.cached[id] = path
225
return self.cached[id]
228
def build_working_dir(to_dir):
229
"""Build a working directory in an empty directory.
231
to_dir is a directory containing branch metadata but no working files,
232
typically constructed by cloning an existing branch.
234
This is split out as a special idiomatic case of merge. It could
235
eventually be done by just building the tree directly calling into
236
lower-level code (e.g. constructing a changeset).
238
merge((to_dir, -1), (to_dir, 0), this_dir=to_dir,
239
check_clean=False, ignore_zero=True)
242
def merge(other_revision, base_revision,
243
check_clean=True, ignore_zero=False,
244
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
246
"""Merge changes into a tree.
249
tuple(path, revision) Base for three-way merge.
251
tuple(path, revision) Other revision for three-way merge.
253
Directory to merge changes into; '.' by default.
255
If true, this_dir must have no uncommitted changes before the
257
ignore_zero - If true, suppress the "zero conflicts" message when
258
there are no conflicts; should be set when doing something we expect
259
to complete perfectly.
261
All available ancestors of other_revision and base_revision are
262
automatically pulled into the branch.
264
tempdir = tempfile.mkdtemp(prefix="bzr-")
268
this_branch = Branch.open_containing(this_dir)
269
this_rev_id = this_branch.last_revision()
270
if this_rev_id is None:
141
271
raise BzrCommandError("This branch has no commits")
144
if self.this_basis != self.this_rev_id:
273
changes = compare_trees(this_branch.working_tree(),
274
this_branch.basis_tree(), False)
275
if changes.has_changed():
145
276
raise BzrCommandError("Working tree has uncommitted changes.")
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,
277
other_branch, other_tree = get_tree(other_revision, tempdir, "other",
191
279
if other_revision[1] == -1:
192
self.other_rev_id = other_branch.last_revision()
193
if self.other_rev_id is None:
280
other_rev_id = other_branch.last_revision()
281
if other_rev_id is None:
194
282
raise NoCommits(other_branch)
195
self.other_basis = self.other_rev_id
283
other_basis = other_rev_id
196
284
elif other_revision[1] is not None:
197
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
198
self.other_basis = self.other_rev_id
285
other_rev_id = other_branch.get_rev_id(other_revision[1])
286
other_basis = other_rev_id
200
self.other_rev_id = None
201
self.other_basis = other_branch.last_revision()
202
if self.other_basis is None:
289
other_basis = other_branch.last_revision()
290
if other_basis is None:
203
291
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")
212
292
if base_revision == [None, None]:
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,
294
base_rev_id = common_ancestor(this_rev_id, other_basis,
222
296
except NoCommonAncestor:
223
297
raise UnrelatedBranches()
224
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
226
self.base_is_ancestor = True
298
base_tree = get_revid_tree(this_branch, base_rev_id, tempdir,
300
base_is_ancestor = True
228
base_branch, self.base_tree = _get_tree(base_revision)
302
base_branch, base_tree = get_tree(base_revision, tempdir, "base")
229
303
if base_revision[1] == -1:
230
self.base_rev_id = base_branch.last_revision()
304
base_rev_id = base_branch.last_revision()
231
305
elif base_revision[1] is None:
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.set_conflicts(ConflictList(self.cooked_conflicts))
394
except UnsupportedOperation:
401
working_tree.unlock()
404
def write_modified(self, results):
406
for path in results.modified_paths:
407
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
410
hash = self.this_tree.get_file_sha1(file_id)
413
modified_hashes[file_id] = hash
414
self.this_tree.set_merge_modified(modified_hashes)
417
def parent(entry, file_id):
418
"""Determine the parent for a file_id (used as a key method)"""
421
return entry.parent_id
424
def name(entry, file_id):
425
"""Determine the name for a file_id (used as a key method)"""
431
def contents_sha1(tree, file_id):
432
"""Determine the sha1 of the file contents (used as a key method)."""
433
if file_id not in tree:
435
return tree.get_file_sha1(file_id)
438
def executable(tree, file_id):
439
"""Determine the executability of a file-id (used as a key method)."""
440
if file_id not in tree:
442
if tree.kind(file_id) != "file":
444
return tree.is_executable(file_id)
447
def kind(tree, file_id):
448
"""Determine the kind of a file-id (used as a key method)."""
449
if file_id not in tree:
451
return tree.kind(file_id)
454
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
455
"""Do a three-way test on a scalar.
456
Return "this", "other" or "conflict", depending whether a value wins.
458
key_base = key(base_tree, file_id)
459
key_other = key(other_tree, file_id)
460
#if base == other, either they all agree, or only THIS has changed.
461
if key_base == key_other:
463
key_this = key(this_tree, file_id)
464
if key_this not in (key_base, key_other):
466
# "Ambiguous clean merge"
467
elif key_this == key_other:
470
assert key_this == key_base
473
def merge_names(self, file_id):
474
"""Perform a merge on file_id names and parents"""
476
if file_id in tree.inventory:
477
return tree.inventory[file_id]
480
this_entry = get_entry(self.this_tree)
481
other_entry = get_entry(self.other_tree)
482
base_entry = get_entry(self.base_tree)
483
name_winner = self.scalar_three_way(this_entry, base_entry,
484
other_entry, file_id, self.name)
485
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
486
other_entry, file_id,
488
if this_entry is None:
489
if name_winner == "this":
490
name_winner = "other"
491
if parent_id_winner == "this":
492
parent_id_winner = "other"
493
if name_winner == "this" and parent_id_winner == "this":
495
if name_winner == "conflict":
496
trans_id = self.tt.trans_id_file_id(file_id)
497
self._raw_conflicts.append(('name conflict', trans_id,
498
self.name(this_entry, file_id),
499
self.name(other_entry, file_id)))
500
if parent_id_winner == "conflict":
501
trans_id = self.tt.trans_id_file_id(file_id)
502
self._raw_conflicts.append(('parent conflict', trans_id,
503
self.parent(this_entry, file_id),
504
self.parent(other_entry, file_id)))
505
if other_entry is None:
506
# it doesn't matter whether the result was 'other' or
507
# 'conflict'-- if there's no 'other', we leave it alone.
509
# if we get here, name_winner and parent_winner are set to safe values.
510
winner_entry = {"this": this_entry, "other": other_entry,
511
"conflict": other_entry}
512
trans_id = self.tt.trans_id_file_id(file_id)
513
parent_id = winner_entry[parent_id_winner].parent_id
514
parent_trans_id = self.tt.trans_id_file_id(parent_id)
515
self.tt.adjust_path(winner_entry[name_winner].name, parent_trans_id,
518
def merge_contents(self, file_id):
519
"""Performa a merge on file_id contents."""
520
def contents_pair(tree):
521
if file_id not in tree:
523
kind = tree.kind(file_id)
524
if kind == "root_directory":
527
contents = tree.get_file_sha1(file_id)
528
elif kind == "symlink":
529
contents = tree.get_symlink_target(file_id)
532
return kind, contents
534
def contents_conflict():
535
trans_id = self.tt.trans_id_file_id(file_id)
536
name = self.tt.final_name(trans_id)
537
parent_id = self.tt.final_parent(trans_id)
538
if file_id in self.this_tree.inventory:
539
self.tt.unversion_file(trans_id)
540
self.tt.delete_contents(trans_id)
541
file_group = self._dump_conflicts(name, parent_id, file_id,
543
self._raw_conflicts.append(('contents conflict', file_group))
545
# See SPOT run. run, SPOT, run.
546
# So we're not QUITE repeating ourselves; we do tricky things with
548
base_pair = contents_pair(self.base_tree)
549
other_pair = contents_pair(self.other_tree)
550
if base_pair == other_pair:
551
# OTHER introduced no changes
553
this_pair = contents_pair(self.this_tree)
554
if this_pair == other_pair:
555
# THIS and OTHER introduced the same changes
558
trans_id = self.tt.trans_id_file_id(file_id)
559
if this_pair == base_pair:
560
# only OTHER introduced changes
561
if file_id in self.this_tree:
562
# Remove any existing contents
563
self.tt.delete_contents(trans_id)
564
if file_id in self.other_tree:
565
# OTHER changed the file
566
create_by_entry(self.tt,
567
self.other_tree.inventory[file_id],
568
self.other_tree, trans_id)
569
if file_id not in self.this_tree.inventory:
570
self.tt.version_file(file_id, trans_id)
572
elif file_id in self.this_tree.inventory:
573
# OTHER deleted the file
574
self.tt.unversion_file(trans_id)
576
#BOTH THIS and OTHER introduced changes; scalar conflict
577
elif this_pair[0] == "file" and other_pair[0] == "file":
578
# THIS and OTHER are both files, so text merge. Either
579
# BASE is a file, or both converted to files, so at least we
580
# have agreement that output should be a file.
582
self.text_merge(file_id, trans_id)
584
return contents_conflict()
585
if file_id not in self.this_tree.inventory:
586
self.tt.version_file(file_id, trans_id)
588
self.tt.tree_kind(trans_id)
589
self.tt.delete_contents(trans_id)
594
# Scalar conflict, can't text merge. Dump conflicts
595
return contents_conflict()
597
def get_lines(self, tree, file_id):
598
"""Return the lines in a file, or an empty list."""
600
return tree.get_file(file_id).readlines()
604
def text_merge(self, file_id, trans_id):
605
"""Perform a three-way text merge on a file_id"""
606
# it's possible that we got here with base as a different type.
607
# if so, we just want two-way text conflicts.
608
if file_id in self.base_tree and \
609
self.base_tree.kind(file_id) == "file":
610
base_lines = self.get_lines(self.base_tree, file_id)
613
other_lines = self.get_lines(self.other_tree, file_id)
614
this_lines = self.get_lines(self.this_tree, file_id)
615
m3 = Merge3(base_lines, this_lines, other_lines)
616
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
617
if self.show_base is True:
618
base_marker = '|' * 7
622
def iter_merge3(retval):
623
retval["text_conflicts"] = False
624
for line in m3.merge_lines(name_a = "TREE",
625
name_b = "MERGE-SOURCE",
626
name_base = "BASE-REVISION",
627
start_marker=start_marker,
628
base_marker=base_marker,
629
reprocess=self.reprocess):
630
if line.startswith(start_marker):
631
retval["text_conflicts"] = True
632
yield line.replace(start_marker, '<' * 7)
636
merge3_iterator = iter_merge3(retval)
637
self.tt.create_file(merge3_iterator, trans_id)
638
if retval["text_conflicts"] is True:
639
self._raw_conflicts.append(('text conflict', trans_id))
640
name = self.tt.final_name(trans_id)
641
parent_id = self.tt.final_parent(trans_id)
642
file_group = self._dump_conflicts(name, parent_id, file_id,
643
this_lines, base_lines,
645
file_group.append(trans_id)
647
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
648
base_lines=None, other_lines=None, set_version=False,
650
"""Emit conflict files.
651
If this_lines, base_lines, or other_lines are omitted, they will be
652
determined automatically. If set_version is true, the .OTHER, .THIS
653
or .BASE (in that order) will be created as versioned files.
655
data = [('OTHER', self.other_tree, other_lines),
656
('THIS', self.this_tree, this_lines)]
658
data.append(('BASE', self.base_tree, base_lines))
661
for suffix, tree, lines in data:
663
trans_id = self._conflict_file(name, parent_id, tree, file_id,
665
file_group.append(trans_id)
666
if set_version and not versioned:
667
self.tt.version_file(file_id, trans_id)
671
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
673
"""Emit a single conflict file."""
674
name = name + '.' + suffix
675
trans_id = self.tt.create_path(name, parent_id)
676
entry = tree.inventory[file_id]
677
create_by_entry(self.tt, entry, tree, trans_id, lines)
680
def merge_executable(self, file_id, file_status):
681
"""Perform a merge on the execute bit."""
682
if file_status == "deleted":
684
trans_id = self.tt.trans_id_file_id(file_id)
686
if self.tt.final_kind(trans_id) != "file":
690
winner = self.scalar_three_way(self.this_tree, self.base_tree,
691
self.other_tree, file_id,
693
if winner == "conflict":
694
# There must be a None in here, if we have a conflict, but we
695
# need executability since file status was not deleted.
696
if self.other_tree.is_executable(file_id) is None:
701
if file_status == "modified":
702
executability = self.this_tree.is_executable(file_id)
703
if executability is not None:
704
trans_id = self.tt.trans_id_file_id(file_id)
705
self.tt.set_executability(executability, trans_id)
707
assert winner == "other"
708
if file_id in self.other_tree:
709
executability = self.other_tree.is_executable(file_id)
710
elif file_id in self.this_tree:
711
executability = self.this_tree.is_executable(file_id)
712
elif file_id in self.base_tree:
713
executability = self.base_tree.is_executable(file_id)
714
if executability is not None:
715
trans_id = self.tt.trans_id_file_id(file_id)
716
self.tt.set_executability(executability, trans_id)
718
def cook_conflicts(self, fs_conflicts):
719
"""Convert all conflicts into a form that doesn't depend on trans_id"""
720
from conflicts import Conflict
722
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
723
fp = FinalPaths(self.tt)
724
for conflict in self._raw_conflicts:
725
conflict_type = conflict[0]
726
if conflict_type in ('name conflict', 'parent conflict'):
727
trans_id = conflict[1]
728
conflict_args = conflict[2:]
729
if trans_id not in name_conflicts:
730
name_conflicts[trans_id] = {}
731
unique_add(name_conflicts[trans_id], conflict_type,
733
if conflict_type == 'contents conflict':
734
for trans_id in conflict[1]:
735
file_id = self.tt.final_file_id(trans_id)
308
base_rev_id = base_branch.get_rev_id(base_revision[1])
309
fetch(from_branch=base_branch, to_branch=this_branch)
310
base_is_ancestor = is_ancestor(this_rev_id, base_rev_id,
312
if file_list is None:
313
interesting_ids = None
315
interesting_ids = set()
316
this_tree = this_branch.working_tree()
317
for fname in file_list:
318
path = this_branch.relpath(fname)
320
for tree in (this_tree, base_tree.tree, other_tree.tree):
321
file_id = tree.inventory.path2id(path)
736
322
if file_id is not None:
738
path = fp.get_path(trans_id)
739
for suffix in ('.BASE', '.THIS', '.OTHER'):
740
if path.endswith(suffix):
741
path = path[:-len(suffix)]
743
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
744
self.cooked_conflicts.append(c)
745
if conflict_type == 'text conflict':
746
trans_id = conflict[1]
747
path = fp.get_path(trans_id)
748
file_id = self.tt.final_file_id(trans_id)
749
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
750
self.cooked_conflicts.append(c)
752
for trans_id, conflicts in name_conflicts.iteritems():
754
this_parent, other_parent = conflicts['parent conflict']
755
assert this_parent != other_parent
757
this_parent = other_parent = \
758
self.tt.final_file_id(self.tt.final_parent(trans_id))
760
this_name, other_name = conflicts['name conflict']
761
assert this_name != other_name
763
this_name = other_name = self.tt.final_name(trans_id)
764
other_path = fp.get_path(trans_id)
765
if this_parent is not None:
767
fp.get_path(self.tt.trans_id_file_id(this_parent))
768
this_path = pathjoin(this_parent_path, this_name)
323
interesting_ids.add(file_id)
326
raise BzrCommandError("%s is not a source file in any"
328
merge_inner(this_branch, other_tree, base_tree, tempdir,
329
ignore_zero=ignore_zero, backup_files=backup_files,
330
merge_type=merge_type, interesting_ids=interesting_ids)
331
if base_is_ancestor and other_rev_id is not None\
332
and other_rev_id not in this_branch.revision_history():
333
this_branch.add_pending_merge(other_rev_id)
335
shutil.rmtree(tempdir)
338
def set_interesting(inventory_a, inventory_b, interesting_ids):
339
"""Mark files whose ids are in interesting_ids as interesting
341
for inventory in (inventory_a, inventory_b):
342
for path, source_file in inventory.iteritems():
343
source_file.interesting = source_file.id in interesting_ids
346
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
347
"""Generate a changeset. If interesting_ids is supplied, only changes
348
to those files will be shown. Metadata changes are stripped.
350
cset = generate_changeset(tree_a, tree_b, interesting_ids)
351
for entry in cset.entries.itervalues():
352
entry.metadata_change = None
356
def merge_inner(this_branch, other_tree, base_tree, tempdir,
357
ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
358
interesting_ids=None):
360
def merge_factory(file_id, base, other):
361
contents_change = merge_type(file_id, base, other)
363
contents_change = BackupBeforeChange(contents_change)
364
return contents_change
366
this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
368
def get_inventory(tree):
369
return tree.tree.inventory
371
inv_changes = merge_flex(this_tree, base_tree, other_tree,
372
generate_cset_optimized, get_inventory,
373
MergeConflictHandler(ignore_zero=ignore_zero),
374
merge_factory=merge_factory,
375
interesting_ids=interesting_ids)
378
for id, path in inv_changes.iteritems():
770
this_path = "<deleted>"
771
file_id = self.tt.final_file_id(trans_id)
772
c = Conflict.factory('path conflict', path=this_path,
773
conflict_path=other_path, file_id=file_id)
774
self.cooked_conflicts.append(c)
775
self.cooked_conflicts.sort(key=Conflict.sort_key)
778
class WeaveMerger(Merge3Merger):
779
"""Three-way tree merger, text weave merger."""
780
supports_reprocess = True
781
supports_show_base = False
783
def __init__(self, working_tree, this_tree, base_tree, other_tree,
784
interesting_ids=None, pb=DummyProgress(), pp=None,
786
self.this_revision_tree = self._get_revision_tree(this_tree)
787
self.other_revision_tree = self._get_revision_tree(other_tree)
788
super(WeaveMerger, self).__init__(working_tree, this_tree,
789
base_tree, other_tree,
790
interesting_ids=interesting_ids,
791
pb=pb, pp=pp, reprocess=reprocess)
793
def _get_revision_tree(self, tree):
794
"""Return a revision tree related to this tree.
795
If the tree is a WorkingTree, the basis will be returned.
797
if getattr(tree, 'get_weave', False) is False:
798
# If we have a WorkingTree, try using the basis
799
return tree.branch.basis_tree()
803
def _check_file(self, file_id):
804
"""Check that the revision tree's version of the file matches."""
805
for tree, rt in ((self.this_tree, self.this_revision_tree),
806
(self.other_tree, self.other_revision_tree)):
809
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
810
raise WorkingTreeNotRevision(self.this_tree)
812
def _merged_lines(self, file_id):
813
"""Generate the merged lines.
814
There is no distinction between lines that are meant to contain <<<<<<<
817
weave = self.this_revision_tree.get_weave(file_id)
818
this_revision_id = self.this_revision_tree.inventory[file_id].revision
819
other_revision_id = \
820
self.other_revision_tree.inventory[file_id].revision
821
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
822
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
823
return wm.merge_lines(self.reprocess)
825
def text_merge(self, file_id, trans_id):
826
"""Perform a (weave) text merge for a given file and file-id.
827
If conflicts are encountered, .THIS and .OTHER files will be emitted,
828
and a conflict will be noted.
830
self._check_file(file_id)
831
lines, conflicts = self._merged_lines(file_id)
833
# Note we're checking whether the OUTPUT is binary in this case,
834
# because we don't want to get into weave merge guts.
835
check_text_lines(lines)
836
self.tt.create_file(lines, trans_id)
838
self._raw_conflicts.append(('text conflict', trans_id))
839
name = self.tt.final_name(trans_id)
840
parent_id = self.tt.final_parent(trans_id)
841
file_group = self._dump_conflicts(name, parent_id, file_id,
843
file_group.append(trans_id)
846
class Diff3Merger(Merge3Merger):
847
"""Three-way merger using external diff3 for text merging"""
848
def dump_file(self, temp_dir, name, tree, file_id):
849
out_path = pathjoin(temp_dir, name)
850
out_file = file(out_path, "wb")
851
in_file = tree.get_file(file_id)
856
def text_merge(self, file_id, trans_id):
857
"""Perform a diff3 merge using a specified file-id and trans-id.
858
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
859
will be dumped, and a will be conflict noted.
862
temp_dir = mkdtemp(prefix="bzr-")
864
new_file = pathjoin(temp_dir, "new")
865
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
866
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
867
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
868
status = bzrlib.patch.diff3(new_file, this, base, other)
869
if status not in (0, 1):
870
raise BzrError("Unhandled diff3 exit code")
871
self.tt.create_file(file(new_file, "rb"), trans_id)
873
name = self.tt.final_name(trans_id)
874
parent_id = self.tt.final_parent(trans_id)
875
self._dump_conflicts(name, parent_id, file_id)
876
self._raw_conflicts.append(('text conflict', trans_id))
881
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
883
merge_type=Merge3Merger,
884
interesting_ids=None,
888
interesting_files=None,
891
"""Primary interface for merging.
893
typical use is probably
894
'merge_inner(branch, branch.get_revision_tree(other_revision),
895
branch.get_revision_tree(base_revision))'
897
if this_tree is None:
898
warnings.warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
899
"bzrlib version 0.8.",
902
this_tree = this_branch.bzrdir.open_workingtree()
903
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
905
merger.backup_files = backup_files
906
merger.merge_type = merge_type
907
merger.interesting_ids = interesting_ids
908
merger.ignore_zero = ignore_zero
909
if interesting_files:
910
assert not interesting_ids, ('Only supply interesting_ids'
911
' or interesting_files')
912
merger._set_interesting_files(interesting_files)
913
merger.show_base = show_base
914
merger.reprocess = reprocess
915
merger.other_rev_id = other_rev_id
916
merger.other_basis = other_rev_id
917
return merger.do_merge()
920
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
921
"diff3": (Diff3Merger, "Merge using external diff3"),
922
'weave': (WeaveMerger, "Weave-based merge")
383
assert path.startswith('.' + os.sep), "path is %s" % path
385
adjust_ids.append((path, id))
386
if len(adjust_ids) > 0:
387
this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
391
def regen_inventory(this_branch, root, new_entries):
392
old_entries = this_branch.read_working_inventory()
396
for path, file_id in new_entries:
399
new_entries_map[file_id] = path
401
def id2path(file_id):
402
path = new_entries_map.get(file_id)
405
entry = old_entries[file_id]
406
if entry.parent_id is None:
408
return os.path.join(id2path(entry.parent_id), entry.name)
410
for file_id in old_entries:
411
entry = old_entries[file_id]
412
path = id2path(file_id)
413
new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
414
by_path[path] = file_id
419
for path, file_id in new_entries:
421
del new_inventory[file_id]
424
new_path_list.append((path, file_id))
425
if file_id not in old_entries:
427
# Ensure no file is added before its parent
429
for path, file_id in new_path_list:
433
parent = by_path[os.path.dirname(path)]
434
kind = bzrlib.osutils.file_kind(os.path.join(root, path))
435
new_inventory[file_id] = (path, file_id, parent, kind)
436
by_path[path] = file_id
438
# Get a list in insertion order
439
new_inventory_list = new_inventory.values()
440
mutter ("""Inventory regeneration:
441
old length: %i insertions: %i deletions: %i new_length: %i"""\
442
% (len(old_entries), insertions, deletions, len(new_inventory_list)))
443
assert len(new_inventory_list) == len(old_entries) + insertions - deletions
444
new_inventory_list.sort()
445
return new_inventory_list
447
merge_types = { "merge3": (ApplyMerge3, "Native diff3-style merge"),
448
"diff3": (Diff3Merge, "Merge using external diff3")
926
def merge_type_help():
927
templ = '%s%%7s: %%s' % (' '*12)
928
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
929
return '\n'.join(lines)
added
removed
bzrlib/merge.py
