1
# Copyright (C) 2005 Canonical Ltd
1
# Copyright (C) 2005, 2006 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25
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
23
41
import bzrlib.osutils
24
import bzrlib.revision
25
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
26
from bzrlib.merge_core import WeaveMerge
27
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
28
from bzrlib.changeset import Inventory, Diff3Merge, ReplaceContents
29
from bzrlib.branch import Branch
30
from bzrlib.errors import BzrCommandError, UnrelatedBranches, NoCommonAncestor
31
from bzrlib.errors import NoCommits, WorkingTreeNotRevision, NotBranchError
32
from bzrlib.delta import compare_trees
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
33
46
from bzrlib.trace import mutter, warning, note
34
from bzrlib.fetch import greedy_fetch, fetch
35
from bzrlib.revision import is_ancestor, NULL_REVISION
36
from bzrlib.osutils import rename
37
from bzrlib.revision import common_ancestor, MultipleRevisionSources
38
from bzrlib.errors import NoSuchRevision
47
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
48
FinalPaths, create_by_entry, unique_add,
50
from bzrlib.versionedfile import WeaveMerge
40
53
# TODO: Report back as changes are merged in
42
# TODO: build_working_dir can be built on something simpler than merge()
44
# FIXME: merge() parameters seem oriented towards the command line
45
# NOTABUG: merge is a helper for commandline functions. merge_inner is the
46
# the core functionality.
48
# comments from abentley on irc: merge happens in two stages, each
49
# of which generates a changeset object
51
# stage 1: generate OLD->OTHER,
52
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
54
class MergeConflictHandler(ExceptionConflictHandler):
55
"""Handle conflicts encountered while merging.
57
This subclasses ExceptionConflictHandler, so that any types of
58
conflict that are not explicitly handled cause an exception and
61
def __init__(self, this_tree, base_tree, other_tree, ignore_zero=False):
62
ExceptionConflictHandler.__init__(self)
64
self.ignore_zero = ignore_zero
65
self.this_tree = this_tree
66
self.base_tree = base_tree
67
self.other_tree = other_tree
69
def copy(self, source, 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
s_file = file(source, "rb")
75
d_file = file(dest, "wb")
78
os.chmod(dest, 0777 & os.stat(source).st_mode)
80
def dump(self, lines, dest):
81
"""Copy the text and mode of a file
82
:param source: The path of the file to copy
83
:param dest: The distination file to create
85
d_file = file(dest, "wb")
89
def add_suffix(self, name, suffix, last_new_name=None, fix_inventory=True):
90
"""Rename a file to append a suffix. If the new name exists, the
91
suffix is added repeatedly until a non-existant name is found
93
:param name: The path of the file
94
:param suffix: The suffix to append
95
:param last_new_name: (used for recursive calls) the last name tried
97
if last_new_name is None:
99
new_name = last_new_name+suffix
101
rename(name, new_name)
102
if fix_inventory is True:
104
relpath = self.this_tree.relpath(name)
105
except NotBranchError:
107
if relpath is not None:
108
file_id = self.this_tree.path2id(relpath)
109
if file_id is not None:
110
new_path = self.this_tree.relpath(new_name)
111
rename(new_name, name)
112
self.this_tree.branch.rename_one(relpath, new_path)
113
assert self.this_tree.id2path(file_id) == relpath
114
self.this_tree._inventory = self.this_tree.read_working_inventory()
115
assert self.this_tree.id2path(file_id) == new_path
117
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
119
return self.add_suffix(name, suffix, last_new_name=new_name,
120
fix_inventory=fix_inventory)
123
def conflict(self, text):
128
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
130
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
131
main file will be a version with diff3 conflicts.
132
:param new_file: Path to the output file with diff3 markers
133
:param this_path: Path to the file text for the THIS tree
134
:param base_path: Path to the file text for the BASE tree
135
:param other_path: Path to the file text for the OTHER tree
137
self.add_suffix(this_path, ".THIS", fix_inventory=False)
138
self.dump(base_lines, this_path+".BASE")
139
self.dump(other_lines, this_path+".OTHER")
140
rename(new_file, this_path)
141
self.conflict("Diff3 conflict encountered in %s" % this_path)
143
def weave_merge_conflict(self, filename, weave, other_i, out_file):
145
Handle weave conflicts by producing a .THIS, and .OTHER. The
146
main file will be a version with diff3-style conflicts.
148
self.add_suffix(filename, ".THIS")
150
self.dump(weave.get_iter(other_i), filename+".OTHER")
151
self.conflict("Text conflict encountered in %s" % filename)
153
def new_contents_conflict(self, filename, other_contents):
154
"""Conflicting contents for newly added file."""
155
other_contents(filename + ".OTHER", self, False)
156
self.conflict("Conflict in newly added file %s" % filename)
159
def target_exists(self, entry, target, old_path):
160
"""Handle the case when the target file or dir exists"""
161
moved_path = self.add_suffix(target, ".moved")
162
self.conflict("Moved existing %s to %s" % (target, moved_path))
164
def rmdir_non_empty(self, filename):
165
"""Handle the case where the dir to be removed still has contents"""
166
self.conflict("Directory %s not removed because it is not empty"\
170
def rem_contents_conflict(self, filename, this_contents, base_contents):
171
base_contents(filename+".BASE", self, False)
172
this_contents(filename+".THIS", self, False)
173
return ReplaceContents(this_contents, None)
175
def rem_contents_conflict(self, filename, this_contents, base_contents):
176
base_contents(filename+".BASE", self, False)
177
this_contents(filename+".THIS", self, False)
178
self.conflict("Other branch deleted locally modified file %s" %
180
return ReplaceContents(this_contents, None)
182
def abs_this_path(self, file_id):
183
"""Return the absolute path for a file_id in the this tree."""
184
return self.this_tree.id2abspath(file_id)
186
def add_missing_parents(self, file_id, tree):
187
"""If some of the parents for file_id are missing, add them."""
188
entry = tree.inventory[file_id]
189
if entry.parent_id not in self.this_tree:
190
return self.create_all_missing(entry.parent_id, tree)
192
return self.abs_this_path(entry.parent_id)
194
def create_all_missing(self, file_id, tree):
195
"""Add contents for a file_id and all its parents to a tree."""
196
entry = tree.inventory[file_id]
197
if entry.parent_id is not None and entry.parent_id not in self.this_tree:
198
abspath = self.create_all_missing(entry.parent_id, tree)
200
abspath = self.abs_this_path(entry.parent_id)
201
entry_path = os.path.join(abspath, entry.name)
202
if not os.path.isdir(entry_path):
203
self.create(file_id, entry_path, tree)
206
def create(self, file_id, path, tree, reverse=False):
207
"""Uses tree data to create a filesystem object for the file_id"""
208
from changeset import get_contents
209
get_contents(tree, file_id)(path, self, reverse)
211
def missing_for_merge(self, file_id, other_path):
212
"""The file_id doesn't exist in THIS, but does in OTHER and BASE"""
213
self.conflict("Other branch modified locally deleted file %s" %
215
parent_dir = self.add_missing_parents(file_id, self.other_tree)
216
stem = os.path.join(parent_dir, os.path.basename(other_path))
217
self.create(file_id, stem+".OTHER", self.other_tree)
218
self.create(file_id, stem+".BASE", self.base_tree)
220
def threeway_contents_conflict(filename, this_contents, base_contents,
222
self.conflict("Three-way conflict merging %s" % filename)
225
if not self.ignore_zero:
226
note("%d conflicts encountered.\n" % self.conflicts)
228
def get_tree(treespec, local_branch=None):
55
def _get_tree(treespec, local_branch=None):
56
from bzrlib import workingtree
229
57
location, revno = treespec
59
tree = workingtree.WorkingTree.open_containing(location)[0]
60
return tree.branch, tree
230
61
branch = Branch.open_containing(location)[0]
234
63
revision = branch.last_revision()
236
65
revision = branch.get_rev_id(revno)
237
66
if revision is None:
238
67
revision = NULL_REVISION
239
return branch, get_revid_tree(branch, revision, local_branch)
241
def get_revid_tree(branch, revision, local_branch):
68
return branch, _get_revid_tree(branch, revision, local_branch)
71
def _get_revid_tree(branch, revision, local_branch):
242
72
if revision is None:
243
base_tree = branch.working_tree()
73
base_tree = branch.bzrdir.open_workingtree()
245
75
if local_branch is not None:
246
greedy_fetch(local_branch, branch, revision)
247
base_tree = local_branch.revision_tree(revision)
76
if local_branch.base != branch.base:
77
local_branch.fetch(branch, revision)
78
base_tree = local_branch.repository.revision_tree(revision)
249
base_tree = branch.revision_tree(revision)
80
base_tree = branch.repository.revision_tree(revision)
253
def file_exists(tree, file_id):
254
return tree.has_filename(tree.id2path(file_id))
257
def build_working_dir(to_dir):
258
"""Build a working directory in an empty directory.
260
to_dir is a directory containing branch metadata but no working files,
261
typically constructed by cloning an existing branch.
263
This is split out as a special idiomatic case of merge. It could
264
eventually be done by just building the tree directly calling into
265
lower-level code (e.g. constructing a changeset).
267
# RBC 20051019 is this not just 'export' ?
268
# Well, export doesn't take care of inventory...
269
this_branch = Branch.open_containing(to_dir)[0]
270
transform_tree(this_branch.working_tree(), this_branch.basis_tree())
272
def transform_tree(from_tree, to_tree):
273
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True)
275
def merge(other_revision, base_revision,
276
check_clean=True, ignore_zero=False,
277
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
278
file_list=None, show_base=False, reprocess=False):
279
"""Merge changes into a tree.
282
list(path, revno) Base for three-way merge.
283
If [None, None] then a base will be automatically determined.
285
list(path, revno) Other revision for three-way merge.
287
Directory to merge changes into; '.' by default.
289
If true, this_dir must have no uncommitted changes before the
291
ignore_zero - If true, suppress the "zero conflicts" message when
292
there are no conflicts; should be set when doing something we expect
293
to complete perfectly.
294
file_list - If supplied, merge only changes to selected files.
296
All available ancestors of other_revision and base_revision are
297
automatically pulled into the branch.
299
The revno may be -1 to indicate the last revision on the branch, which is
302
This function is intended for use from the command line; programmatic
303
clients might prefer to call merge_inner(), which has less magic behavior.
307
this_branch = Branch.open_containing(this_dir)[0]
308
if show_base and not merge_type is ApplyMerge3:
309
raise BzrCommandError("Show-base is not supported for this merge"
310
" type. %s" % merge_type)
311
if reprocess and not merge_type is ApplyMerge3:
312
raise BzrCommandError("Reprocess is not supported for this merge"
313
" type. %s" % merge_type)
314
if reprocess and show_base:
315
raise BzrCommandError("Cannot reprocess and show base.")
316
merger = Merger(this_branch)
317
merger.check_basis(check_clean)
318
merger.set_other(other_revision)
319
merger.set_base(base_revision)
320
merger.backup_files = backup_files
321
merger.merge_type = merge_type
322
merger.set_interesting_files(file_list)
323
merger.show_base = show_base
324
merger.reprocess = reprocess
325
merger.conflict_handler = MergeConflictHandler(merger.this_tree,
328
ignore_zero=ignore_zero)
329
conflicts = merger.do_merge()
333
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
334
backup_files=False, merge_type=ApplyMerge3,
335
interesting_ids=None, show_base=False, reprocess=False):
336
"""Primary interface for merging.
338
typical use is probably
339
'merge_inner(branch, branch.get_revision_tree(other_revision),
340
branch.get_revision_tree(base_revision))'
342
merger = Merger(this_branch, other_tree, base_tree)
343
merger.backup_files = False
344
merger.merge_type = ApplyMerge3
345
merger.interesting_ids = interesting_ids
346
merger.show_base = show_base
347
merger.reprocess = reprocess
348
merger.conflict_handler = MergeConflictHandler(merger.this_tree, base_tree,
350
ignore_zero=ignore_zero)
351
return merger.do_merge()
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)
354
89
class Merger(object):
355
def __init__(self, this_branch, other_tree=None, base_tree=None):
90
def __init__(self, this_branch, other_tree=None, base_tree=None,
91
this_tree=None, pb=DummyProgress()):
356
92
object.__init__(self)
93
assert this_tree is not None, "this_tree is required"
357
94
self.this_branch = this_branch
358
95
self.this_basis = this_branch.last_revision()
359
96
self.this_rev_id = None
360
self.this_tree = this_branch.working_tree()
97
self.this_tree = this_tree
361
98
self.this_revision_tree = None
99
self.this_basis_tree = None
362
100
self.other_tree = other_tree
363
101
self.base_tree = base_tree
364
102
self.ignore_zero = False
588
346
new_inventory_list.sort()
589
347
return new_inventory_list
591
merge_types = { "merge3": (ApplyMerge3, "Native diff3-style merge"),
592
"diff3": (Diff3Merge, "Merge using external diff3"),
593
'weave': (WeaveMerge, "Weave-based merge")
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)
772
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)
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")
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
