1
# Copyright (C) 2005, 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1
from merge_core import merge_flex
2
from changeset import generate_changeset, ExceptionConflictHandler
3
from changeset import Inventory
4
from bzrlib import find_branch
6
from bzrlib.errors import BzrCommandError
7
from bzrlib.diff import compare_trees
8
from trace import mutter, warning
20
from tempfile import mkdtemp
23
from bzrlib.branch import Branch
24
from bzrlib.conflicts import ConflictList, Conflict
25
from bzrlib.delta import compare_trees
26
from bzrlib.errors import (BzrCommandError,
36
WorkingTreeNotRevision,
39
from bzrlib.merge3 import Merge3
41
from bzrlib.osutils import rename, pathjoin, rmtree
42
from progress import DummyProgress, ProgressPhase
43
from bzrlib.revision import common_ancestor, is_ancestor, NULL_REVISION
44
from bzrlib.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):
14
class UnrelatedBranches(BzrCommandError):
16
msg = "Branches have no common ancestor, and no base revision"\
18
BzrCommandError.__init__(self, msg)
21
class MergeConflictHandler(ExceptionConflictHandler):
22
"""Handle conflicts encountered while merging"""
23
def __init__(self, dir, ignore_zero=False):
24
ExceptionConflictHandler.__init__(self, dir)
26
self.ignore_zero = ignore_zero
28
def copy(self, source, dest):
29
"""Copy the text and mode of a file
30
:param source: The path of the file to copy
31
:param dest: The distination file to create
33
s_file = file(source, "rb")
34
d_file = file(dest, "wb")
37
os.chmod(dest, 0777 & os.stat(source).st_mode)
39
def add_suffix(self, name, suffix, last_new_name=None):
40
"""Rename a file to append a suffix. If the new name exists, the
41
suffix is added repeatedly until a non-existant name is found
43
:param name: The path of the file
44
:param suffix: The suffix to append
45
:param last_new_name: (used for recursive calls) the last name tried
47
if last_new_name is None:
49
new_name = last_new_name+suffix
51
os.rename(name, new_name)
54
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
56
return self.add_suffix(name, suffix, last_new_name=new_name)
58
def conflict(self, text):
63
def merge_conflict(self, new_file, this_path, base_path, other_path):
65
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
66
main file will be a version with diff3 conflicts.
67
:param new_file: Path to the output file with diff3 markers
68
:param this_path: Path to the file text for the THIS tree
69
:param base_path: Path to the file text for the BASE tree
70
:param other_path: Path to the file text for the OTHER tree
72
self.add_suffix(this_path, ".THIS")
73
self.copy(base_path, this_path+".BASE")
74
self.copy(other_path, this_path+".OTHER")
75
os.rename(new_file, this_path)
76
self.conflict("Diff3 conflict encountered in %s" % this_path)
78
def target_exists(self, entry, target, old_path):
79
"""Handle the case when the target file or dir exists"""
80
moved_path = self.add_suffix(target, ".moved")
81
self.conflict("Moved existing %s to %s" % (target, moved_path))
84
if not self.ignore_zero:
85
print "%d conflicts encountered.\n" % self.conflicts
87
class SourceFile(object):
88
def __init__(self, path, id, present=None, isdir=None):
91
self.present = present
93
self.interesting = True
96
return "SourceFile(%s, %s)" % (self.path, self.id)
98
def get_tree(treespec, temp_root, label):
54
99
location, revno = treespec
55
branch = Branch.open_containing(location)[0]
100
branch = find_branch(location)
102
base_tree = branch.working_tree()
59
revision = branch.last_revision()
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):
69
base_tree = branch.bzrdir.open_workingtree()
71
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)
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()):
104
base_tree = branch.basis_tree()
106
base_tree = branch.revision_tree(branch.lookup_revision(revno))
107
temp_path = os.path.join(temp_root, label)
109
return branch, MergeTree(base_tree, temp_path)
112
def abspath(tree, file_id):
113
path = tree.inventory.id2path(file_id)
118
def file_exists(tree, file_id):
119
return tree.has_filename(tree.id2path(file_id))
121
def inventory_map(tree):
123
for file_id in tree.inventory:
124
if not file_exists(tree, file_id):
126
path = abspath(tree, file_id)
127
inventory[path] = SourceFile(path, file_id)
131
class MergeTree(object):
132
def __init__(self, tree, tempdir):
88
133
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)
134
if hasattr(tree, "basedir"):
135
self.root = tree.basedir
138
self.inventory = inventory_map(tree)
140
self.tempdir = tempdir
141
os.mkdir(os.path.join(self.tempdir, "texts"))
144
def readonly_path(self, id):
145
if self.root is not None:
146
return self.tree.abspath(self.tree.id2path(id))
148
if self.tree.inventory[id].kind in ("directory", "root_directory"):
150
if not self.cached.has_key(id):
151
path = os.path.join(self.tempdir, "texts", id)
152
outfile = file(path, "wb")
153
outfile.write(self.tree.get_file(id).read())
154
assert(os.path.exists(path))
155
self.cached[id] = path
156
return self.cached[id]
160
def merge(other_revision, base_revision,
161
check_clean=True, ignore_zero=False,
163
"""Merge changes into a tree.
166
Base for three-way merge.
168
Other revision for three-way merge.
170
Directory to merge changes into; '.' by default.
172
If true, this_dir must have no uncommitted changes before the
175
tempdir = tempfile.mkdtemp(prefix="bzr-")
179
this_branch = find_branch(this_dir)
181
changes = compare_trees(this_branch.working_tree(),
182
this_branch.basis_tree(), False)
120
183
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:
141
raise BzrCommandError("This branch has no commits")
144
if self.this_basis != self.this_rev_id:
145
184
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,
191
if other_revision[1] == -1:
192
self.other_rev_id = other_branch.last_revision()
193
if self.other_rev_id is None:
194
raise NoCommits(other_branch)
195
self.other_basis = self.other_rev_id
196
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
200
self.other_rev_id = None
201
self.other_basis = other_branch.last_revision()
202
if self.other_basis is None:
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")
185
other_branch, other_tree = get_tree(other_revision, tempdir, "other")
212
186
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,
222
except NoCommonAncestor:
187
if other_revision[1] == -1:
190
o_revno = other_revision[1]
191
base_revno = this_branch.common_ancestor(other_branch,
192
other_revno=o_revno)[0]
193
if base_revno is None:
223
194
raise UnrelatedBranches()
224
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
226
self.base_is_ancestor = True
228
base_branch, self.base_tree = _get_tree(base_revision)
229
if base_revision[1] == -1:
230
self.base_rev_id = base_branch.last_revision()
231
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)"""
195
base_revision = ['.', base_revno]
196
base_branch, base_tree = get_tree(base_revision, tempdir, "base")
197
merge_inner(this_branch, other_tree, base_tree, tempdir,
198
ignore_zero=ignore_zero)
200
shutil.rmtree(tempdir)
203
def generate_cset_optimized(tree_a, tree_b, inventory_a, inventory_b):
204
"""Generate a changeset, using the text_id to mark really-changed files.
205
This permits blazing comparisons when text_ids are present. It also
206
disables metadata comparison for files with identical texts.
208
for file_id in tree_a.tree.inventory:
209
if file_id not in tree_b.tree.inventory:
211
entry_a = tree_a.tree.inventory[file_id]
212
entry_b = tree_b.tree.inventory[file_id]
213
if (entry_a.kind, entry_b.kind) != ("file", "file"):
215
if None in (entry_a.text_id, entry_b.text_id):
217
if entry_a.text_id != entry_b.text_id:
219
inventory_a[abspath(tree_a.tree, file_id)].interesting = False
220
inventory_b[abspath(tree_b.tree, file_id)].interesting = False
221
cset = generate_changeset(tree_a, tree_b, inventory_a, inventory_b)
222
for entry in cset.entries.itervalues():
223
entry.metadata_change = None
227
def merge_inner(this_branch, other_tree, base_tree, tempdir,
229
this_tree = get_tree((this_branch.base, None), tempdir, "this")[1]
231
def get_inventory(tree):
232
return tree.inventory
234
inv_changes = merge_flex(this_tree, base_tree, other_tree,
235
generate_cset_optimized, get_inventory,
236
MergeConflictHandler(base_tree.root,
237
ignore_zero=ignore_zero))
240
for id, path in inv_changes.iteritems():
245
assert path.startswith('./')
247
adjust_ids.append((path, id))
248
this_branch.set_inventory(regen_inventory(this_branch, this_tree.root, adjust_ids))
251
def regen_inventory(this_branch, root, new_entries):
252
old_entries = this_branch.read_working_inventory()
255
for file_id in old_entries:
256
entry = old_entries[file_id]
257
path = old_entries.id2path(file_id)
258
new_inventory[file_id] = (path, file_id, entry.parent_id, entry.kind)
259
by_path[path] = file_id
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)
736
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)
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")
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)
264
for path, file_id in new_entries:
266
del new_inventory[file_id]
269
new_path_list.append((path, file_id))
270
if file_id not in old_entries:
272
# Ensure no file is added before its parent
274
for path, file_id in new_path_list:
278
parent = by_path[os.path.dirname(path)]
279
kind = bzrlib.osutils.file_kind(os.path.join(root, path))
280
new_inventory[file_id] = (path, file_id, parent, kind)
281
by_path[path] = file_id
283
# Get a list in insertion order
284
new_inventory_list = new_inventory.values()
285
mutter ("""Inventory regeneration:
286
old length: %i insertions: %i deletions: %i new_length: %i"""\
287
% (len(old_entries), insertions, deletions, len(new_inventory_list)))
288
assert len(new_inventory_list) == len(old_entries) + insertions - deletions
289
new_inventory_list.sort()
290
return new_inventory_list
added
removed
bzrlib/merge.py
