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
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
25
28
from bzrlib.branch import Branch
26
from bzrlib.conflicts import ConflictList, Conflict
27
from bzrlib.errors import (BzrCommandError,
37
WorkingTreeNotRevision,
40
from bzrlib.merge3 import Merge3
42
from bzrlib.osutils import rename, pathjoin
43
from progress import DummyProgress, ProgressPhase
44
from bzrlib.revision import common_ancestor, is_ancestor, NULL_REVISION
45
from bzrlib.textfile import check_text_lines
46
from bzrlib.trace import mutter, warning, note
47
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
48
FinalPaths, create_by_entry, unique_add,
50
from bzrlib.versionedfile import WeaveMerge
53
# TODO: Report back as changes are merged in
55
def _get_tree(treespec, local_branch=None):
56
from bzrlib import workingtree
29
from bzrlib.errors import BzrCommandError, UnrelatedBranches, NoCommonAncestor
30
from bzrlib.errors import NoCommits
31
from bzrlib.delta import compare_trees
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
40
# comments from abentley on irc: merge happens in two stages, each
41
# of which generates a changeset object
43
# stage 1: generate OLD->OTHER,
44
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
46
class MergeConflictHandler(ExceptionConflictHandler):
47
"""Handle conflicts encountered while merging.
49
This subclasses ExceptionConflictHandler, so that any types of
50
conflict that are not explicitly handled cause an exception and
53
def __init__(self, ignore_zero=False):
54
ExceptionConflictHandler.__init__(self)
56
self.ignore_zero = ignore_zero
58
def copy(self, source, dest):
59
"""Copy the text and mode of a file
60
:param source: The path of the file to copy
61
:param dest: The distination file to create
63
s_file = file(source, "rb")
64
d_file = file(dest, "wb")
67
os.chmod(dest, 0777 & os.stat(source).st_mode)
69
def dump(self, lines, dest):
70
"""Copy the text and mode of a file
71
:param source: The path of the file to copy
72
:param dest: The distination file to create
74
d_file = file(dest, "wb")
78
def add_suffix(self, name, suffix, last_new_name=None):
79
"""Rename a file to append a suffix. If the new name exists, the
80
suffix is added repeatedly until a non-existant name is found
82
:param name: The path of the file
83
:param suffix: The suffix to append
84
:param last_new_name: (used for recursive calls) the last name tried
86
if last_new_name is None:
88
new_name = last_new_name+suffix
90
rename(name, new_name)
93
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
95
return self.add_suffix(name, suffix, last_new_name=new_name)
97
def conflict(self, text):
102
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
104
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
105
main file will be a version with diff3 conflicts.
106
:param new_file: Path to the output file with diff3 markers
107
:param this_path: Path to the file text for the THIS tree
108
:param base_path: Path to the file text for the BASE tree
109
:param other_path: Path to the file text for the OTHER tree
111
self.add_suffix(this_path, ".THIS")
112
self.dump(base_lines, this_path+".BASE")
113
self.dump(other_lines, this_path+".OTHER")
114
rename(new_file, this_path)
115
self.conflict("Diff3 conflict encountered in %s" % this_path)
117
def new_contents_conflict(self, filename, other_contents):
118
"""Conflicting contents for newly added file."""
119
self.copy(other_contents, filename + ".OTHER")
120
self.conflict("Conflict in newly added file %s" % filename)
123
def target_exists(self, entry, target, old_path):
124
"""Handle the case when the target file or dir exists"""
125
moved_path = self.add_suffix(target, ".moved")
126
self.conflict("Moved existing %s to %s" % (target, moved_path))
128
def rmdir_non_empty(self, filename):
129
"""Handle the case where the dir to be removed still has contents"""
130
self.conflict("Directory %s not removed because it is not empty"\
135
if not self.ignore_zero:
136
print "%d conflicts encountered.\n" % self.conflicts
138
def get_tree(treespec, temp_root, label, local_branch=None):
57
139
location, revno = treespec
140
branch = Branch.open_containing(location)
59
tree = workingtree.WorkingTree.open_containing(location)[0]
60
return tree.branch, tree
61
branch = Branch.open_containing(location)[0]
63
144
revision = branch.last_revision()
65
146
revision = branch.get_rev_id(revno)
67
revision = NULL_REVISION
68
return branch, _get_revid_tree(branch, revision, local_branch)
71
def _get_revid_tree(branch, revision, local_branch):
147
return branch, get_revid_tree(branch, revision, temp_root, label,
150
def get_revid_tree(branch, revision, temp_root, label, local_branch):
72
151
if revision is None:
73
base_tree = branch.bzrdir.open_workingtree()
152
base_tree = branch.working_tree()
75
154
if local_branch is not None:
76
if local_branch.base != branch.base:
77
local_branch.fetch(branch, revision)
78
base_tree = local_branch.repository.revision_tree(revision)
155
greedy_fetch(local_branch, branch, revision)
156
base_tree = local_branch.revision_tree(revision)
80
base_tree = branch.repository.revision_tree(revision)
84
def transform_tree(from_tree, to_tree, interesting_ids=None):
85
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
86
interesting_ids=interesting_ids, this_tree=from_tree)
90
def __init__(self, this_branch, other_tree=None, base_tree=None,
91
this_tree=None, pb=DummyProgress()):
158
base_tree = branch.revision_tree(revision)
159
temp_path = os.path.join(temp_root, label)
161
return MergeTree(base_tree, temp_path)
164
def file_exists(tree, file_id):
165
return tree.has_filename(tree.id2path(file_id))
168
class MergeTree(object):
169
def __init__(self, tree, tempdir):
92
170
object.__init__(self)
93
assert this_tree is not None, "this_tree is required"
94
self.this_branch = this_branch
95
self.this_basis = this_branch.last_revision()
96
self.this_rev_id = None
97
self.this_tree = this_tree
98
self.this_revision_tree = None
99
self.this_basis_tree = None
100
self.other_tree = other_tree
101
self.base_tree = base_tree
102
self.ignore_zero = False
103
self.backup_files = False
104
self.interesting_ids = None
105
self.show_base = False
106
self.reprocess = False
111
def revision_tree(self, revision_id):
112
return self.this_branch.repository.revision_tree(revision_id)
114
def ensure_revision_trees(self):
115
if self.this_revision_tree is None:
116
self.this_basis_tree = self.this_branch.repository.revision_tree(
118
if self.this_basis == self.this_rev_id:
119
self.this_revision_tree = self.this_basis_tree
121
if self.other_rev_id is None:
122
other_basis_tree = self.revision_tree(self.other_basis)
123
changes = other_basis_tree.changes_from(self.other_tree)
124
if changes.has_changed():
125
raise WorkingTreeNotRevision(self.this_tree)
126
other_rev_id = self.other_basis
127
self.other_tree = other_basis_tree
129
def file_revisions(self, file_id):
130
self.ensure_revision_trees()
131
def get_id(tree, file_id):
132
revision_id = tree.inventory[file_id].revision
133
assert revision_id is not None
135
if self.this_rev_id is None:
136
if self.this_basis_tree.get_file_sha1(file_id) != \
137
self.this_tree.get_file_sha1(file_id):
138
raise WorkingTreeNotRevision(self.this_tree)
140
trees = (self.this_basis_tree, self.other_tree)
141
return [get_id(tree, file_id) for tree in trees]
143
def check_basis(self, check_clean, require_commits=True):
144
if self.this_basis is None and require_commits is True:
171
if hasattr(tree, "basedir"):
172
self.root = tree.basedir
176
self.tempdir = tempdir
177
os.mkdir(os.path.join(self.tempdir, "texts"))
181
return self.tree.__iter__()
183
def __contains__(self, file_id):
184
return file_id in self.tree
186
def get_file(self, file_id):
187
return self.tree.get_file(file_id)
189
def get_file_sha1(self, id):
190
return self.tree.get_file_sha1(id)
192
def id2path(self, file_id):
193
return self.tree.id2path(file_id)
195
def has_id(self, file_id):
196
return self.tree.has_id(file_id)
198
def has_or_had_id(self, file_id):
199
if file_id == self.tree.inventory.root.file_id:
201
return self.tree.inventory.has_id(file_id)
203
def has_or_had_id(self, file_id):
204
if file_id == self.tree.inventory.root.file_id:
206
return self.tree.inventory.has_id(file_id)
208
def readonly_path(self, id):
209
if id not in self.tree:
211
if self.root is not None:
212
return self.tree.abspath(self.tree.id2path(id))
214
if self.tree.inventory[id].kind in ("directory", "root_directory"):
216
if not self.cached.has_key(id):
217
path = os.path.join(self.tempdir, "texts", id)
218
outfile = file(path, "wb")
219
outfile.write(self.tree.get_file(id).read())
220
assert(os.path.exists(path))
221
self.cached[id] = path
222
return self.cached[id]
226
def merge(other_revision, base_revision,
227
check_clean=True, ignore_zero=False,
228
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
230
"""Merge changes into a tree.
233
tuple(path, revision) Base for three-way merge.
235
tuple(path, revision) Other revision for three-way merge.
237
Directory to merge changes into; '.' by default.
239
If true, this_dir must have no uncommitted changes before the
242
All available ancestors of other_revision and base_revision are
243
automatically pulled into the branch.
245
tempdir = tempfile.mkdtemp(prefix="bzr-")
249
this_branch = Branch.open_containing(this_dir)
250
this_rev_id = this_branch.last_revision()
251
if this_rev_id is None:
145
252
raise BzrCommandError("This branch has no commits")
148
if self.this_basis != self.this_rev_id:
254
changes = compare_trees(this_branch.working_tree(),
255
this_branch.basis_tree(), False)
256
if changes.has_changed():
149
257
raise BzrCommandError("Working tree has uncommitted changes.")
151
def compare_basis(self):
152
changes = self.this_tree.changes_from(self.this_tree.basis_tree())
153
if not changes.has_changed():
154
self.this_rev_id = self.this_basis
156
def set_interesting_files(self, file_list):
158
self._set_interesting_files(file_list)
159
except NotVersionedError, e:
160
raise BzrCommandError("%s is not a source file in any"
163
def _set_interesting_files(self, file_list):
164
"""Set the list of interesting ids from a list of files."""
165
if file_list is None:
166
self.interesting_ids = None
169
interesting_ids = set()
170
for path in file_list:
172
for tree in (self.this_tree, self.base_tree, self.other_tree):
173
file_id = tree.inventory.path2id(path)
174
if file_id is not None:
175
interesting_ids.add(file_id)
178
raise NotVersionedError(path=path)
179
self.interesting_ids = interesting_ids
181
def set_pending(self):
182
if not self.base_is_ancestor:
184
if self.other_rev_id is None:
186
ancestry = self.this_branch.repository.get_ancestry(self.this_basis)
187
if self.other_rev_id in ancestry:
189
self.this_tree.add_parent_tree((self.other_rev_id, self.other_tree))
191
def set_other(self, other_revision):
192
"""Set the revision and tree to merge from.
194
This sets the other_tree, other_rev_id, other_basis attributes.
196
:param other_revision: The [path, revision] list to merge from.
198
other_branch, self.other_tree = _get_tree(other_revision,
258
other_branch, other_tree = get_tree(other_revision, tempdir, "other",
200
260
if other_revision[1] == -1:
201
self.other_rev_id = other_branch.last_revision()
202
if self.other_rev_id is None:
261
other_rev_id = other_branch.last_revision()
262
if other_rev_id is None:
203
263
raise NoCommits(other_branch)
204
self.other_basis = self.other_rev_id
264
other_basis = other_rev_id
205
265
elif other_revision[1] is not None:
206
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
207
self.other_basis = self.other_rev_id
266
other_rev_id = other_branch.get_rev_id(other_revision[1])
267
other_basis = other_rev_id
209
self.other_rev_id = None
210
self.other_basis = other_branch.last_revision()
211
if self.other_basis is None:
270
other_basis = other_branch.last_revision()
271
if other_basis is None:
212
272
raise NoCommits(other_branch)
213
if other_branch.base != self.this_branch.base:
214
self.this_branch.fetch(other_branch, last_revision=self.other_basis)
217
self.set_base([None, None])
219
def set_base(self, base_revision):
220
"""Set the base revision to use for the merge.
222
:param base_revision: A 2-list containing a path and revision number.
224
mutter("doing merge() with no base_revision specified")
225
273
if base_revision == [None, None]:
227
pb = bzrlib.ui.ui_factory.nested_progress_bar()
229
this_repo = self.this_branch.repository
230
self.base_rev_id = common_ancestor(self.this_basis,
275
base_rev_id = common_ancestor(this_rev_id, other_basis,
235
277
except NoCommonAncestor:
236
278
raise UnrelatedBranches()
237
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
239
self.base_is_ancestor = True
279
base_tree = get_revid_tree(this_branch, base_rev_id, tempdir,
281
base_is_ancestor = True
241
base_branch, self.base_tree = _get_tree(base_revision)
283
base_branch, base_tree = get_tree(base_revision, tempdir, "base")
242
284
if base_revision[1] == -1:
243
self.base_rev_id = base_branch.last_revision()
285
base_rev_id = base_branch.last_revision()
244
286
elif base_revision[1] is None:
245
self.base_rev_id = None
247
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
248
if self.this_branch.base != base_branch.base:
249
self.this_branch.fetch(base_branch)
250
self.base_is_ancestor = is_ancestor(self.this_basis,
255
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
256
'other_tree': self.other_tree,
257
'interesting_ids': self.interesting_ids,
259
if self.merge_type.requires_base:
260
kwargs['base_tree'] = self.base_tree
261
if self.merge_type.supports_reprocess:
262
kwargs['reprocess'] = self.reprocess
264
raise BzrError("Conflict reduction is not supported for merge"
265
" type %s." % self.merge_type)
266
if self.merge_type.supports_show_base:
267
kwargs['show_base'] = self.show_base
269
raise BzrError("Showing base is not supported for this"
270
" merge type. %s" % self.merge_type)
271
merge = self.merge_type(pb=self._pb, **kwargs)
272
if len(merge.cooked_conflicts) == 0:
273
if not self.ignore_zero:
274
note("All changes applied successfully.")
276
note("%d conflicts encountered." % len(merge.cooked_conflicts))
278
return len(merge.cooked_conflicts)
280
def regen_inventory(self, new_entries):
281
old_entries = self.this_tree.read_working_inventory()
285
for path, file_id in new_entries:
288
new_entries_map[file_id] = path
290
def id2path(file_id):
291
path = new_entries_map.get(file_id)
294
entry = old_entries[file_id]
295
if entry.parent_id is None:
297
return pathjoin(id2path(entry.parent_id), entry.name)
299
for file_id in old_entries:
300
entry = old_entries[file_id]
301
path = id2path(file_id)
302
if file_id in self.base_tree.inventory:
303
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
305
executable = getattr(entry, 'executable', False)
306
new_inventory[file_id] = (path, file_id, entry.parent_id,
307
entry.kind, executable)
309
by_path[path] = file_id
314
for path, file_id in new_entries:
316
del new_inventory[file_id]
319
new_path_list.append((path, file_id))
320
if file_id not in old_entries:
322
# Ensure no file is added before its parent
324
for path, file_id in new_path_list:
328
parent = by_path[os.path.dirname(path)]
329
abspath = pathjoin(self.this_tree.basedir, path)
330
kind = bzrlib.osutils.file_kind(abspath)
331
if file_id in self.base_tree.inventory:
332
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
335
new_inventory[file_id] = (path, file_id, parent, kind, executable)
336
by_path[path] = file_id
338
# Get a list in insertion order
339
new_inventory_list = new_inventory.values()
340
mutter ("""Inventory regeneration:
341
old length: %i insertions: %i deletions: %i new_length: %i"""\
342
% (len(old_entries), insertions, deletions,
343
len(new_inventory_list)))
344
assert len(new_inventory_list) == len(old_entries) + insertions\
346
new_inventory_list.sort()
347
return new_inventory_list
350
class Merge3Merger(object):
351
"""Three-way merger that uses the merge3 text merger"""
353
supports_reprocess = True
354
supports_show_base = True
355
history_based = False
357
def __init__(self, working_tree, this_tree, base_tree, other_tree,
358
interesting_ids=None, reprocess=False, show_base=False,
359
pb=DummyProgress(), pp=None):
360
"""Initialize the merger object and perform the merge."""
361
object.__init__(self)
362
self.this_tree = working_tree
363
self.base_tree = base_tree
364
self.other_tree = other_tree
365
self._raw_conflicts = []
366
self.cooked_conflicts = []
367
self.reprocess = reprocess
368
self.show_base = show_base
372
self.pp = ProgressPhase("Merge phase", 3, self.pb)
374
if interesting_ids is not None:
375
all_ids = interesting_ids
377
all_ids = set(base_tree)
378
all_ids.update(other_tree)
379
working_tree.lock_tree_write()
380
self.tt = TreeTransform(working_tree, self.pb)
383
child_pb = ui.ui_factory.nested_progress_bar()
385
for num, file_id in enumerate(all_ids):
386
child_pb.update('Preparing file merge', num, len(all_ids))
387
self.merge_names(file_id)
388
file_status = self.merge_contents(file_id)
389
self.merge_executable(file_id, file_status)
394
child_pb = ui.ui_factory.nested_progress_bar()
396
fs_conflicts = resolve_conflicts(self.tt, child_pb)
399
self.cook_conflicts(fs_conflicts)
400
for conflict in self.cooked_conflicts:
403
results = self.tt.apply()
404
self.write_modified(results)
406
working_tree.add_conflicts(self.cooked_conflicts)
407
except UnsupportedOperation:
411
working_tree.unlock()
416
self.tt.final_kind(self.tt.root)
418
self.tt.cancel_deletion(self.tt.root)
419
if self.tt.final_file_id(self.tt.root) is None:
420
self.tt.version_file(self.tt.tree_file_id(self.tt.root),
422
if self.other_tree.inventory.root is None:
424
other_root_file_id = self.other_tree.inventory.root.file_id
425
other_root = self.tt.trans_id_file_id(other_root_file_id)
426
if other_root == self.tt.root:
429
self.tt.final_kind(other_root)
432
self.reparent_children(self.other_tree.inventory.root, self.tt.root)
433
self.tt.cancel_creation(other_root)
434
self.tt.cancel_versioning(other_root)
436
def reparent_children(self, ie, target):
437
for thing, child in ie.children.iteritems():
438
trans_id = self.tt.trans_id_file_id(child.file_id)
439
self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
441
def write_modified(self, results):
443
for path in results.modified_paths:
444
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
447
hash = self.this_tree.get_file_sha1(file_id)
450
modified_hashes[file_id] = hash
451
self.this_tree.set_merge_modified(modified_hashes)
454
def parent(entry, file_id):
455
"""Determine the parent for a file_id (used as a key method)"""
458
return entry.parent_id
461
def name(entry, file_id):
462
"""Determine the name for a file_id (used as a key method)"""
468
def contents_sha1(tree, file_id):
469
"""Determine the sha1 of the file contents (used as a key method)."""
470
if file_id not in tree:
472
return tree.get_file_sha1(file_id)
475
def executable(tree, file_id):
476
"""Determine the executability of a file-id (used as a key method)."""
477
if file_id not in tree:
479
if tree.kind(file_id) != "file":
481
return tree.is_executable(file_id)
484
def kind(tree, file_id):
485
"""Determine the kind of a file-id (used as a key method)."""
486
if file_id not in tree:
488
return tree.kind(file_id)
491
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
492
"""Do a three-way test on a scalar.
493
Return "this", "other" or "conflict", depending whether a value wins.
495
key_base = key(base_tree, file_id)
496
key_other = key(other_tree, file_id)
497
#if base == other, either they all agree, or only THIS has changed.
498
if key_base == key_other:
500
key_this = key(this_tree, file_id)
501
if key_this not in (key_base, key_other):
503
# "Ambiguous clean merge"
504
elif key_this == key_other:
507
assert key_this == key_base
510
def merge_names(self, file_id):
511
"""Perform a merge on file_id names and parents"""
513
if file_id in tree.inventory:
514
return tree.inventory[file_id]
517
this_entry = get_entry(self.this_tree)
518
other_entry = get_entry(self.other_tree)
519
base_entry = get_entry(self.base_tree)
520
name_winner = self.scalar_three_way(this_entry, base_entry,
521
other_entry, file_id, self.name)
522
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
523
other_entry, file_id,
525
if this_entry is None:
526
if name_winner == "this":
527
name_winner = "other"
528
if parent_id_winner == "this":
529
parent_id_winner = "other"
530
if name_winner == "this" and parent_id_winner == "this":
532
if name_winner == "conflict":
533
trans_id = self.tt.trans_id_file_id(file_id)
534
self._raw_conflicts.append(('name conflict', trans_id,
535
self.name(this_entry, file_id),
536
self.name(other_entry, file_id)))
537
if parent_id_winner == "conflict":
538
trans_id = self.tt.trans_id_file_id(file_id)
539
self._raw_conflicts.append(('parent conflict', trans_id,
540
self.parent(this_entry, file_id),
541
self.parent(other_entry, file_id)))
542
if other_entry is None:
543
# it doesn't matter whether the result was 'other' or
544
# 'conflict'-- if there's no 'other', we leave it alone.
546
# if we get here, name_winner and parent_winner are set to safe values.
547
winner_entry = {"this": this_entry, "other": other_entry,
548
"conflict": other_entry}
549
trans_id = self.tt.trans_id_file_id(file_id)
550
parent_id = winner_entry[parent_id_winner].parent_id
551
if parent_id is not None:
552
parent_trans_id = self.tt.trans_id_file_id(parent_id)
553
self.tt.adjust_path(winner_entry[name_winner].name,
554
parent_trans_id, trans_id)
556
def merge_contents(self, file_id):
557
"""Performa a merge on file_id contents."""
558
def contents_pair(tree):
559
if file_id not in tree:
561
kind = tree.kind(file_id)
563
contents = tree.get_file_sha1(file_id)
564
elif kind == "symlink":
565
contents = tree.get_symlink_target(file_id)
568
return kind, contents
570
def contents_conflict():
571
trans_id = self.tt.trans_id_file_id(file_id)
572
name = self.tt.final_name(trans_id)
573
parent_id = self.tt.final_parent(trans_id)
574
if file_id in self.this_tree.inventory:
575
self.tt.unversion_file(trans_id)
576
self.tt.delete_contents(trans_id)
577
file_group = self._dump_conflicts(name, parent_id, file_id,
579
self._raw_conflicts.append(('contents conflict', file_group))
581
# See SPOT run. run, SPOT, run.
582
# So we're not QUITE repeating ourselves; we do tricky things with
584
base_pair = contents_pair(self.base_tree)
585
other_pair = contents_pair(self.other_tree)
586
if base_pair == other_pair:
587
# OTHER introduced no changes
589
this_pair = contents_pair(self.this_tree)
590
if this_pair == other_pair:
591
# THIS and OTHER introduced the same changes
594
trans_id = self.tt.trans_id_file_id(file_id)
595
if this_pair == base_pair:
596
# only OTHER introduced changes
597
if file_id in self.this_tree:
598
# Remove any existing contents
599
self.tt.delete_contents(trans_id)
600
if file_id in self.other_tree:
601
# OTHER changed the file
602
create_by_entry(self.tt,
603
self.other_tree.inventory[file_id],
604
self.other_tree, trans_id)
605
if file_id not in self.this_tree.inventory:
606
self.tt.version_file(file_id, trans_id)
608
elif file_id in self.this_tree.inventory:
609
# OTHER deleted the file
610
self.tt.unversion_file(trans_id)
612
#BOTH THIS and OTHER introduced changes; scalar conflict
613
elif this_pair[0] == "file" and other_pair[0] == "file":
614
# THIS and OTHER are both files, so text merge. Either
615
# BASE is a file, or both converted to files, so at least we
616
# have agreement that output should be a file.
618
self.text_merge(file_id, trans_id)
620
return contents_conflict()
621
if file_id not in self.this_tree.inventory:
622
self.tt.version_file(file_id, trans_id)
624
self.tt.tree_kind(trans_id)
625
self.tt.delete_contents(trans_id)
630
# Scalar conflict, can't text merge. Dump conflicts
631
return contents_conflict()
633
def get_lines(self, tree, file_id):
634
"""Return the lines in a file, or an empty list."""
636
return tree.get_file(file_id).readlines()
640
def text_merge(self, file_id, trans_id):
641
"""Perform a three-way text merge on a file_id"""
642
# it's possible that we got here with base as a different type.
643
# if so, we just want two-way text conflicts.
644
if file_id in self.base_tree and \
645
self.base_tree.kind(file_id) == "file":
646
base_lines = self.get_lines(self.base_tree, file_id)
649
other_lines = self.get_lines(self.other_tree, file_id)
650
this_lines = self.get_lines(self.this_tree, file_id)
651
m3 = Merge3(base_lines, this_lines, other_lines)
652
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
653
if self.show_base is True:
654
base_marker = '|' * 7
658
def iter_merge3(retval):
659
retval["text_conflicts"] = False
660
for line in m3.merge_lines(name_a = "TREE",
661
name_b = "MERGE-SOURCE",
662
name_base = "BASE-REVISION",
663
start_marker=start_marker,
664
base_marker=base_marker,
665
reprocess=self.reprocess):
666
if line.startswith(start_marker):
667
retval["text_conflicts"] = True
668
yield line.replace(start_marker, '<' * 7)
672
merge3_iterator = iter_merge3(retval)
673
self.tt.create_file(merge3_iterator, trans_id)
674
if retval["text_conflicts"] is True:
675
self._raw_conflicts.append(('text conflict', trans_id))
676
name = self.tt.final_name(trans_id)
677
parent_id = self.tt.final_parent(trans_id)
678
file_group = self._dump_conflicts(name, parent_id, file_id,
679
this_lines, base_lines,
681
file_group.append(trans_id)
683
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
684
base_lines=None, other_lines=None, set_version=False,
686
"""Emit conflict files.
687
If this_lines, base_lines, or other_lines are omitted, they will be
688
determined automatically. If set_version is true, the .OTHER, .THIS
689
or .BASE (in that order) will be created as versioned files.
691
data = [('OTHER', self.other_tree, other_lines),
692
('THIS', self.this_tree, this_lines)]
694
data.append(('BASE', self.base_tree, base_lines))
697
for suffix, tree, lines in data:
699
trans_id = self._conflict_file(name, parent_id, tree, file_id,
701
file_group.append(trans_id)
702
if set_version and not versioned:
703
self.tt.version_file(file_id, trans_id)
707
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
709
"""Emit a single conflict file."""
710
name = name + '.' + suffix
711
trans_id = self.tt.create_path(name, parent_id)
712
entry = tree.inventory[file_id]
713
create_by_entry(self.tt, entry, tree, trans_id, lines)
716
def merge_executable(self, file_id, file_status):
717
"""Perform a merge on the execute bit."""
718
if file_status == "deleted":
720
trans_id = self.tt.trans_id_file_id(file_id)
722
if self.tt.final_kind(trans_id) != "file":
726
winner = self.scalar_three_way(self.this_tree, self.base_tree,
727
self.other_tree, file_id,
729
if winner == "conflict":
730
# There must be a None in here, if we have a conflict, but we
731
# need executability since file status was not deleted.
732
if self.executable(self.other_tree, file_id) is None:
737
if file_status == "modified":
738
executability = self.this_tree.is_executable(file_id)
739
if executability is not None:
740
trans_id = self.tt.trans_id_file_id(file_id)
741
self.tt.set_executability(executability, trans_id)
743
assert winner == "other"
744
if file_id in self.other_tree:
745
executability = self.other_tree.is_executable(file_id)
746
elif file_id in self.this_tree:
747
executability = self.this_tree.is_executable(file_id)
748
elif file_id in self.base_tree:
749
executability = self.base_tree.is_executable(file_id)
750
if executability is not None:
751
trans_id = self.tt.trans_id_file_id(file_id)
752
self.tt.set_executability(executability, trans_id)
754
def cook_conflicts(self, fs_conflicts):
755
"""Convert all conflicts into a form that doesn't depend on trans_id"""
756
from conflicts import Conflict
758
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
759
fp = FinalPaths(self.tt)
760
for conflict in self._raw_conflicts:
761
conflict_type = conflict[0]
762
if conflict_type in ('name conflict', 'parent conflict'):
763
trans_id = conflict[1]
764
conflict_args = conflict[2:]
765
if trans_id not in name_conflicts:
766
name_conflicts[trans_id] = {}
767
unique_add(name_conflicts[trans_id], conflict_type,
769
if conflict_type == 'contents conflict':
770
for trans_id in conflict[1]:
771
file_id = self.tt.final_file_id(trans_id)
289
base_rev_id = base_branch.get_rev_id(base_revision[1])
290
fetch(from_branch=base_branch, to_branch=this_branch)
291
base_is_ancestor = is_ancestor(this_rev_id, base_rev_id,
293
if file_list is None:
294
interesting_ids = None
296
interesting_ids = set()
297
this_tree = this_branch.working_tree()
298
for fname in file_list:
299
path = this_branch.relpath(fname)
301
for tree in (this_tree, base_tree.tree, other_tree.tree):
302
file_id = tree.inventory.path2id(path)
772
303
if file_id is not None:
774
path = fp.get_path(trans_id)
775
for suffix in ('.BASE', '.THIS', '.OTHER'):
776
if path.endswith(suffix):
777
path = path[:-len(suffix)]
779
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
780
self.cooked_conflicts.append(c)
781
if conflict_type == 'text conflict':
782
trans_id = conflict[1]
783
path = fp.get_path(trans_id)
784
file_id = self.tt.final_file_id(trans_id)
785
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
786
self.cooked_conflicts.append(c)
788
for trans_id, conflicts in name_conflicts.iteritems():
790
this_parent, other_parent = conflicts['parent conflict']
791
assert this_parent != other_parent
793
this_parent = other_parent = \
794
self.tt.final_file_id(self.tt.final_parent(trans_id))
796
this_name, other_name = conflicts['name conflict']
797
assert this_name != other_name
799
this_name = other_name = self.tt.final_name(trans_id)
800
other_path = fp.get_path(trans_id)
801
if this_parent is not None:
803
fp.get_path(self.tt.trans_id_file_id(this_parent))
804
this_path = pathjoin(this_parent_path, this_name)
304
interesting_ids.add(file_id)
307
raise BzrCommandError("%s is not a source file in any"
309
merge_inner(this_branch, other_tree, base_tree, tempdir,
310
ignore_zero=ignore_zero, backup_files=backup_files,
311
merge_type=merge_type, interesting_ids=interesting_ids)
312
if base_is_ancestor and other_rev_id is not None\
313
and other_rev_id not in this_branch.revision_history():
314
this_branch.add_pending_merge(other_rev_id)
316
shutil.rmtree(tempdir)
319
def set_interesting(inventory_a, inventory_b, interesting_ids):
320
"""Mark files whose ids are in interesting_ids as interesting
322
for inventory in (inventory_a, inventory_b):
323
for path, source_file in inventory.iteritems():
324
source_file.interesting = source_file.id in interesting_ids
327
def generate_cset_optimized(tree_a, tree_b, interesting_ids=None):
328
"""Generate a changeset. If interesting_ids is supplied, only changes
329
to those files will be shown. Metadata changes are stripped.
331
cset = generate_changeset(tree_a, tree_b, interesting_ids)
332
for entry in cset.entries.itervalues():
333
entry.metadata_change = None
337
def merge_inner(this_branch, other_tree, base_tree, tempdir,
338
ignore_zero=False, merge_type=ApplyMerge3, backup_files=False,
339
interesting_ids=None):
341
def merge_factory(file_id, base, other):
342
contents_change = merge_type(file_id, base, other)
344
contents_change = BackupBeforeChange(contents_change)
345
return contents_change
347
this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
349
def get_inventory(tree):
350
return tree.tree.inventory
352
inv_changes = merge_flex(this_tree, base_tree, other_tree,
353
generate_cset_optimized, get_inventory,
354
MergeConflictHandler(ignore_zero=ignore_zero),
355
merge_factory=merge_factory,
356
interesting_ids=interesting_ids)
359
for id, path in inv_changes.iteritems():
806
this_path = "<deleted>"
807
file_id = self.tt.final_file_id(trans_id)
808
c = Conflict.factory('path conflict', path=this_path,
809
conflict_path=other_path, file_id=file_id)
810
self.cooked_conflicts.append(c)
811
self.cooked_conflicts.sort(key=Conflict.sort_key)
814
class WeaveMerger(Merge3Merger):
815
"""Three-way tree merger, text weave merger."""
816
supports_reprocess = True
817
supports_show_base = False
819
def __init__(self, working_tree, this_tree, base_tree, other_tree,
820
interesting_ids=None, pb=DummyProgress(), pp=None,
822
self.this_revision_tree = self._get_revision_tree(this_tree)
823
self.other_revision_tree = self._get_revision_tree(other_tree)
824
super(WeaveMerger, self).__init__(working_tree, this_tree,
825
base_tree, other_tree,
826
interesting_ids=interesting_ids,
827
pb=pb, pp=pp, reprocess=reprocess)
829
def _get_revision_tree(self, tree):
830
"""Return a revision tree related to this tree.
831
If the tree is a WorkingTree, the basis will be returned.
833
if getattr(tree, 'get_weave', False) is False:
834
# If we have a WorkingTree, try using the basis
835
return tree.branch.basis_tree()
839
def _check_file(self, file_id):
840
"""Check that the revision tree's version of the file matches."""
841
for tree, rt in ((self.this_tree, self.this_revision_tree),
842
(self.other_tree, self.other_revision_tree)):
845
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
846
raise WorkingTreeNotRevision(self.this_tree)
848
def _merged_lines(self, file_id):
849
"""Generate the merged lines.
850
There is no distinction between lines that are meant to contain <<<<<<<
853
weave = self.this_revision_tree.get_weave(file_id)
854
this_revision_id = self.this_revision_tree.inventory[file_id].revision
855
other_revision_id = \
856
self.other_revision_tree.inventory[file_id].revision
857
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
858
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
859
return wm.merge_lines(self.reprocess)
861
def text_merge(self, file_id, trans_id):
862
"""Perform a (weave) text merge for a given file and file-id.
863
If conflicts are encountered, .THIS and .OTHER files will be emitted,
864
and a conflict will be noted.
866
self._check_file(file_id)
867
lines, conflicts = self._merged_lines(file_id)
869
# Note we're checking whether the OUTPUT is binary in this case,
870
# because we don't want to get into weave merge guts.
871
check_text_lines(lines)
872
self.tt.create_file(lines, trans_id)
874
self._raw_conflicts.append(('text conflict', trans_id))
875
name = self.tt.final_name(trans_id)
876
parent_id = self.tt.final_parent(trans_id)
877
file_group = self._dump_conflicts(name, parent_id, file_id,
879
file_group.append(trans_id)
882
class Diff3Merger(Merge3Merger):
883
"""Three-way merger using external diff3 for text merging"""
885
def dump_file(self, temp_dir, name, tree, file_id):
886
out_path = pathjoin(temp_dir, name)
887
out_file = open(out_path, "wb")
889
in_file = tree.get_file(file_id)
896
def text_merge(self, file_id, trans_id):
897
"""Perform a diff3 merge using a specified file-id and trans-id.
898
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
899
will be dumped, and a will be conflict noted.
902
temp_dir = osutils.mkdtemp(prefix="bzr-")
904
new_file = pathjoin(temp_dir, "new")
905
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
906
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
907
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
908
status = bzrlib.patch.diff3(new_file, this, base, other)
909
if status not in (0, 1):
910
raise BzrError("Unhandled diff3 exit code")
911
f = open(new_file, 'rb')
913
self.tt.create_file(f, trans_id)
917
name = self.tt.final_name(trans_id)
918
parent_id = self.tt.final_parent(trans_id)
919
self._dump_conflicts(name, parent_id, file_id)
920
self._raw_conflicts.append(('text conflict', trans_id))
922
osutils.rmtree(temp_dir)
925
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
927
merge_type=Merge3Merger,
928
interesting_ids=None,
932
interesting_files=None,
935
"""Primary interface for merging.
937
typical use is probably
938
'merge_inner(branch, branch.get_revision_tree(other_revision),
939
branch.get_revision_tree(base_revision))'
941
if this_tree is None:
942
warnings.warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
943
"bzrlib version 0.8.",
946
this_tree = this_branch.bzrdir.open_workingtree()
947
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
949
merger.backup_files = backup_files
950
merger.merge_type = merge_type
951
merger.interesting_ids = interesting_ids
952
merger.ignore_zero = ignore_zero
953
if interesting_files:
954
assert not interesting_ids, ('Only supply interesting_ids'
955
' or interesting_files')
956
merger._set_interesting_files(interesting_files)
957
merger.show_base = show_base
958
merger.reprocess = reprocess
959
merger.other_rev_id = other_rev_id
960
merger.other_basis = other_rev_id
961
return merger.do_merge()
964
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
965
"diff3": (Diff3Merger, "Merge using external diff3"),
966
'weave': (WeaveMerger, "Weave-based merge")
364
assert path.startswith('.' + os.sep), "path is %s" % path
366
adjust_ids.append((path, id))
367
if len(adjust_ids) > 0:
368
this_branch.set_inventory(regen_inventory(this_branch, this_tree.root,
372
def regen_inventory(this_branch, root, new_entries):
373
old_entries = this_branch.read_working_inventory()
377
for path, file_id in new_entries:
380
new_entries_map[file_id] = path
382
def id2path(file_id):
383
path = new_entries_map.get(file_id)
386
entry = old_entries[file_id]
387
if entry.parent_id is None:
389
return os.path.join(id2path(entry.parent_id), entry.name)
391
for file_id in old_entries:
392
entry = old_entries[file_id]
393
path = id2path(file_id)
394
new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
395
by_path[path] = file_id
400
for path, file_id in new_entries:
402
del new_inventory[file_id]
405
new_path_list.append((path, file_id))
406
if file_id not in old_entries:
408
# Ensure no file is added before its parent
410
for path, file_id in new_path_list:
414
parent = by_path[os.path.dirname(path)]
415
kind = bzrlib.osutils.file_kind(os.path.join(root, path))
416
new_inventory[file_id] = (path, file_id, parent, kind)
417
by_path[path] = file_id
419
# Get a list in insertion order
420
new_inventory_list = new_inventory.values()
421
mutter ("""Inventory regeneration:
422
old length: %i insertions: %i deletions: %i new_length: %i"""\
423
% (len(old_entries), insertions, deletions, len(new_inventory_list)))
424
assert len(new_inventory_list) == len(old_entries) + insertions - deletions
425
new_inventory_list.sort()
426
return new_inventory_list
428
merge_types = { "merge3": (ApplyMerge3, "Native diff3-style merge"),
429
"diff3": (Diff3Merge, "Merge using external diff3")
970
def merge_type_help():
971
templ = '%s%%7s: %%s' % (' '*12)
972
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
973
return '\n'.join(lines)
added
removed
bzrlib/merge.py
