1
# Copyright (C) 2005 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
20
from shutil import rmtree
21
from tempfile import mkdtemp
24
from bzrlib.branch import Branch
25
from bzrlib.delta import compare_trees
26
from bzrlib.errors import (BzrCommandError,
35
WorkingTreeNotRevision,
37
from bzrlib.merge3 import Merge3
39
from bzrlib.osutils import rename, pathjoin
40
from progress import DummyProgress, ProgressPhase
41
from bzrlib.revision import common_ancestor, is_ancestor, NULL_REVISION
42
from bzrlib.symbol_versioning import *
43
from bzrlib.trace import mutter, warning, note
44
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
45
conflicts_strings, FinalPaths, create_by_entry,
49
# TODO: Report back as changes are merged in
51
def _get_tree(treespec, local_branch=None):
52
location, revno = treespec
53
branch = Branch.open_containing(location)[0]
57
revision = branch.last_revision()
59
revision = branch.get_rev_id(revno)
61
revision = NULL_REVISION
62
return branch, _get_revid_tree(branch, revision, local_branch)
65
def _get_revid_tree(branch, revision, local_branch):
67
base_tree = branch.bzrdir.open_workingtree()
69
if local_branch is not None:
70
if local_branch.base != branch.base:
71
local_branch.fetch(branch, revision)
72
base_tree = local_branch.repository.revision_tree(revision)
74
base_tree = branch.repository.revision_tree(revision)
78
def transform_tree(from_tree, to_tree, interesting_ids=None):
79
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
80
interesting_ids=interesting_ids, this_tree=from_tree)
84
def __init__(self, this_branch, other_tree=None, base_tree=None,
85
this_tree=None, pb=DummyProgress()):
87
assert this_tree is not None, "this_tree is required"
88
self.this_branch = this_branch
89
self.this_basis = this_branch.last_revision()
90
self.this_rev_id = None
91
self.this_tree = this_tree
92
self.this_revision_tree = None
93
self.this_basis_tree = None
94
self.other_tree = other_tree
95
self.base_tree = base_tree
96
self.ignore_zero = False
97
self.backup_files = False
98
self.interesting_ids = None
99
self.show_base = False
100
self.reprocess = False
105
def revision_tree(self, revision_id):
106
return self.this_branch.repository.revision_tree(revision_id)
108
def ensure_revision_trees(self):
109
if self.this_revision_tree is None:
110
self.this_basis_tree = self.this_branch.repository.revision_tree(
112
if self.this_basis == self.this_rev_id:
113
self.this_revision_tree = self.this_basis_tree
115
if self.other_rev_id is None:
116
other_basis_tree = self.revision_tree(self.other_basis)
117
changes = compare_trees(self.other_tree, other_basis_tree)
118
if changes.has_changed():
119
raise WorkingTreeNotRevision(self.this_tree)
120
other_rev_id = other_basis
121
self.other_tree = other_basis_tree
123
def file_revisions(self, file_id):
124
self.ensure_revision_trees()
125
def get_id(tree, file_id):
126
revision_id = tree.inventory[file_id].revision
127
assert revision_id is not None
129
if self.this_rev_id is None:
130
if self.this_basis_tree.get_file_sha1(file_id) != \
131
self.this_tree.get_file_sha1(file_id):
132
raise WorkingTreeNotRevision(self.this_tree)
134
trees = (self.this_basis_tree, self.other_tree)
135
return [get_id(tree, file_id) for tree in trees]
137
def check_basis(self, check_clean):
138
if self.this_basis is None:
139
raise BzrCommandError("This branch has no commits")
142
if self.this_basis != self.this_rev_id:
143
raise BzrCommandError("Working tree has uncommitted changes.")
145
def compare_basis(self):
146
changes = compare_trees(self.this_tree,
147
self.this_tree.basis_tree(), False)
148
if not changes.has_changed():
149
self.this_rev_id = self.this_basis
151
def set_interesting_files(self, file_list):
153
self._set_interesting_files(file_list)
154
except NotVersionedError, e:
155
raise BzrCommandError("%s is not a source file in any"
158
def _set_interesting_files(self, file_list):
159
"""Set the list of interesting ids from a list of files."""
160
if file_list is None:
161
self.interesting_ids = None
164
interesting_ids = set()
165
for path in file_list:
167
for tree in (self.this_tree, self.base_tree, self.other_tree):
168
file_id = tree.inventory.path2id(path)
169
if file_id is not None:
170
interesting_ids.add(file_id)
173
raise NotVersionedError(path=path)
174
self.interesting_ids = interesting_ids
176
def set_pending(self):
177
if not self.base_is_ancestor:
179
if self.other_rev_id is None:
181
ancestry = self.this_branch.repository.get_ancestry(self.this_basis)
182
if self.other_rev_id in ancestry:
184
self.this_tree.add_pending_merge(self.other_rev_id)
186
def set_other(self, other_revision):
187
other_branch, self.other_tree = _get_tree(other_revision,
189
if other_revision[1] == -1:
190
self.other_rev_id = other_branch.last_revision()
191
if self.other_rev_id is None:
192
raise NoCommits(other_branch)
193
self.other_basis = self.other_rev_id
194
elif other_revision[1] is not None:
195
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
196
self.other_basis = self.other_rev_id
198
self.other_rev_id = None
199
self.other_basis = other_branch.last_revision()
200
if self.other_basis is None:
201
raise NoCommits(other_branch)
202
if other_branch.base != self.this_branch.base:
203
self.this_branch.fetch(other_branch, last_revision=self.other_basis)
205
def set_base(self, base_revision):
206
mutter("doing merge() with no base_revision specified")
207
if base_revision == [None, None]:
209
pb = bzrlib.ui.ui_factory.nested_progress_bar()
211
this_repo = self.this_branch.repository
212
self.base_rev_id = common_ancestor(self.this_basis,
217
except NoCommonAncestor:
218
raise UnrelatedBranches()
219
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
221
self.base_is_ancestor = True
223
base_branch, self.base_tree = _get_tree(base_revision)
224
if base_revision[1] == -1:
225
self.base_rev_id = base_branch.last_revision()
226
elif base_revision[1] is None:
227
self.base_rev_id = None
229
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
230
if self.this_branch.base != base_branch.base:
231
self.this_branch.fetch(base_branch)
232
self.base_is_ancestor = is_ancestor(self.this_basis,
237
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
238
'other_tree': self.other_tree,
239
'interesting_ids': self.interesting_ids,
241
if self.merge_type.requires_base:
242
kwargs['base_tree'] = self.base_tree
243
if self.merge_type.supports_reprocess:
244
kwargs['reprocess'] = self.reprocess
246
raise BzrError("Reprocess is not supported for this merge"
247
" type. %s" % merge_type)
248
if self.merge_type.supports_show_base:
249
kwargs['show_base'] = self.show_base
251
raise BzrError("Showing base is not supported for this"
252
" merge type. %s" % self.merge_type)
253
merge = self.merge_type(pb=self._pb, **kwargs)
254
if len(merge.cooked_conflicts) == 0:
255
if not self.ignore_zero:
256
note("All changes applied successfully.")
258
note("%d conflicts encountered." % len(merge.cooked_conflicts))
260
return len(merge.cooked_conflicts)
262
def regen_inventory(self, new_entries):
263
old_entries = self.this_tree.read_working_inventory()
267
for path, file_id in new_entries:
270
new_entries_map[file_id] = path
272
def id2path(file_id):
273
path = new_entries_map.get(file_id)
276
entry = old_entries[file_id]
277
if entry.parent_id is None:
279
return pathjoin(id2path(entry.parent_id), entry.name)
281
for file_id in old_entries:
282
entry = old_entries[file_id]
283
path = id2path(file_id)
284
if file_id in self.base_tree.inventory:
285
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
287
executable = getattr(entry, 'executable', False)
288
new_inventory[file_id] = (path, file_id, entry.parent_id,
289
entry.kind, executable)
291
by_path[path] = file_id
296
for path, file_id in new_entries:
298
del new_inventory[file_id]
301
new_path_list.append((path, file_id))
302
if file_id not in old_entries:
304
# Ensure no file is added before its parent
306
for path, file_id in new_path_list:
310
parent = by_path[os.path.dirname(path)]
311
abspath = pathjoin(self.this_tree.basedir, path)
312
kind = bzrlib.osutils.file_kind(abspath)
313
if file_id in self.base_tree.inventory:
314
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
317
new_inventory[file_id] = (path, file_id, parent, kind, executable)
318
by_path[path] = file_id
320
# Get a list in insertion order
321
new_inventory_list = new_inventory.values()
322
mutter ("""Inventory regeneration:
323
old length: %i insertions: %i deletions: %i new_length: %i"""\
324
% (len(old_entries), insertions, deletions,
325
len(new_inventory_list)))
326
assert len(new_inventory_list) == len(old_entries) + insertions\
328
new_inventory_list.sort()
329
return new_inventory_list
332
class Merge3Merger(object):
333
"""Three-way merger that uses the merge3 text merger"""
335
supports_reprocess = True
336
supports_show_base = True
337
history_based = False
339
def __init__(self, working_tree, this_tree, base_tree, other_tree,
340
interesting_ids=None, reprocess=False, show_base=False,
341
pb=DummyProgress(), pp=None):
342
"""Initialize the merger object and perform the merge."""
343
object.__init__(self)
344
self.this_tree = working_tree
345
self.base_tree = base_tree
346
self.other_tree = other_tree
347
self._raw_conflicts = []
348
self.cooked_conflicts = []
349
self.reprocess = reprocess
350
self.show_base = show_base
354
self.pp = ProgressPhase("Merge phase", 3, self.pb)
356
if interesting_ids is not None:
357
all_ids = interesting_ids
359
all_ids = set(base_tree)
360
all_ids.update(other_tree)
361
working_tree.lock_write()
362
self.tt = TreeTransform(working_tree, self.pb)
365
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
367
for num, file_id in enumerate(all_ids):
368
child_pb.update('Preparing file merge', num, len(all_ids))
369
self.merge_names(file_id)
370
file_status = self.merge_contents(file_id)
371
self.merge_executable(file_id, file_status)
376
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
378
fs_conflicts = resolve_conflicts(self.tt, child_pb)
381
self.cook_conflicts(fs_conflicts)
382
for line in conflicts_strings(self.cooked_conflicts):
385
results = self.tt.apply()
386
self.write_modified(results)
392
working_tree.unlock()
395
def write_modified(self, results):
397
for path in results.modified_paths:
398
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
401
hash = self.this_tree.get_file_sha1(file_id)
404
modified_hashes[file_id] = hash
405
self.this_tree.set_merge_modified(modified_hashes)
408
def parent(entry, file_id):
409
"""Determine the parent for a file_id (used as a key method)"""
412
return entry.parent_id
415
def name(entry, file_id):
416
"""Determine the name for a file_id (used as a key method)"""
422
def contents_sha1(tree, file_id):
423
"""Determine the sha1 of the file contents (used as a key method)."""
424
if file_id not in tree:
426
return tree.get_file_sha1(file_id)
429
def executable(tree, file_id):
430
"""Determine the executability of a file-id (used as a key method)."""
431
if file_id not in tree:
433
if tree.kind(file_id) != "file":
435
return tree.is_executable(file_id)
438
def kind(tree, file_id):
439
"""Determine the kind of a file-id (used as a key method)."""
440
if file_id not in tree:
442
return tree.kind(file_id)
445
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
446
"""Do a three-way test on a scalar.
447
Return "this", "other" or "conflict", depending whether a value wins.
449
key_base = key(base_tree, file_id)
450
key_other = key(other_tree, file_id)
451
#if base == other, either they all agree, or only THIS has changed.
452
if key_base == key_other:
454
key_this = key(this_tree, file_id)
455
if key_this not in (key_base, key_other):
457
# "Ambiguous clean merge"
458
elif key_this == key_other:
461
assert key_this == key_base
464
def merge_names(self, file_id):
465
"""Perform a merge on file_id names and parents"""
467
if file_id in tree.inventory:
468
return tree.inventory[file_id]
471
this_entry = get_entry(self.this_tree)
472
other_entry = get_entry(self.other_tree)
473
base_entry = get_entry(self.base_tree)
474
name_winner = self.scalar_three_way(this_entry, base_entry,
475
other_entry, file_id, self.name)
476
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
477
other_entry, file_id,
479
if this_entry is None:
480
if name_winner == "this":
481
name_winner = "other"
482
if parent_id_winner == "this":
483
parent_id_winner = "other"
484
if name_winner == "this" and parent_id_winner == "this":
486
if name_winner == "conflict":
487
trans_id = self.tt.trans_id_file_id(file_id)
488
self._raw_conflicts.append(('name conflict', trans_id,
489
self.name(this_entry, file_id),
490
self.name(other_entry, file_id)))
491
if parent_id_winner == "conflict":
492
trans_id = self.tt.trans_id_file_id(file_id)
493
self._raw_conflicts.append(('parent conflict', trans_id,
494
self.parent(this_entry, file_id),
495
self.parent(other_entry, file_id)))
496
if other_entry is None:
497
# it doesn't matter whether the result was 'other' or
498
# 'conflict'-- if there's no 'other', we leave it alone.
500
# if we get here, name_winner and parent_winner are set to safe values.
501
winner_entry = {"this": this_entry, "other": other_entry,
502
"conflict": other_entry}
503
trans_id = self.tt.trans_id_file_id(file_id)
504
parent_id = winner_entry[parent_id_winner].parent_id
505
parent_trans_id = self.tt.trans_id_file_id(parent_id)
506
self.tt.adjust_path(winner_entry[name_winner].name, parent_trans_id,
509
def merge_contents(self, file_id):
510
"""Performa a merge on file_id contents."""
511
def contents_pair(tree):
512
if file_id not in tree:
514
kind = tree.kind(file_id)
515
if kind == "root_directory":
518
contents = tree.get_file_sha1(file_id)
519
elif kind == "symlink":
520
contents = tree.get_symlink_target(file_id)
523
return kind, contents
524
# See SPOT run. run, SPOT, run.
525
# So we're not QUITE repeating ourselves; we do tricky things with
527
base_pair = contents_pair(self.base_tree)
528
other_pair = contents_pair(self.other_tree)
529
if base_pair == other_pair:
530
# OTHER introduced no changes
532
this_pair = contents_pair(self.this_tree)
533
if this_pair == other_pair:
534
# THIS and OTHER introduced the same changes
537
trans_id = self.tt.trans_id_file_id(file_id)
538
if this_pair == base_pair:
539
# only OTHER introduced changes
540
if file_id in self.this_tree:
541
# Remove any existing contents
542
self.tt.delete_contents(trans_id)
543
if file_id in self.other_tree:
544
# OTHER changed the file
545
create_by_entry(self.tt,
546
self.other_tree.inventory[file_id],
547
self.other_tree, trans_id)
548
if file_id not in self.this_tree.inventory:
549
self.tt.version_file(file_id, trans_id)
551
elif file_id in self.this_tree.inventory:
552
# OTHER deleted the file
553
self.tt.unversion_file(trans_id)
555
#BOTH THIS and OTHER introduced changes; scalar conflict
556
elif this_pair[0] == "file" and other_pair[0] == "file":
557
# THIS and OTHER are both files, so text merge. Either
558
# BASE is a file, or both converted to files, so at least we
559
# have agreement that output should be a file.
560
if file_id not in self.this_tree.inventory:
561
self.tt.version_file(file_id, trans_id)
562
self.text_merge(file_id, trans_id)
564
self.tt.tree_kind(trans_id)
565
self.tt.delete_contents(trans_id)
570
# Scalar conflict, can't text merge. Dump conflicts
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
def get_lines(self, tree, file_id):
582
"""Return the lines in a file, or an empty list."""
584
return tree.get_file(file_id).readlines()
588
def text_merge(self, file_id, trans_id):
589
"""Perform a three-way text merge on a file_id"""
590
# it's possible that we got here with base as a different type.
591
# if so, we just want two-way text conflicts.
592
if file_id in self.base_tree and \
593
self.base_tree.kind(file_id) == "file":
594
base_lines = self.get_lines(self.base_tree, file_id)
597
other_lines = self.get_lines(self.other_tree, file_id)
598
this_lines = self.get_lines(self.this_tree, file_id)
599
m3 = Merge3(base_lines, this_lines, other_lines)
600
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
601
if self.show_base is True:
602
base_marker = '|' * 7
606
def iter_merge3(retval):
607
retval["text_conflicts"] = False
608
for line in m3.merge_lines(name_a = "TREE",
609
name_b = "MERGE-SOURCE",
610
name_base = "BASE-REVISION",
611
start_marker=start_marker,
612
base_marker=base_marker,
613
reprocess=self.reprocess):
614
if line.startswith(start_marker):
615
retval["text_conflicts"] = True
616
yield line.replace(start_marker, '<' * 7)
620
merge3_iterator = iter_merge3(retval)
621
self.tt.create_file(merge3_iterator, trans_id)
622
if retval["text_conflicts"] is True:
623
self._raw_conflicts.append(('text conflict', trans_id))
624
name = self.tt.final_name(trans_id)
625
parent_id = self.tt.final_parent(trans_id)
626
file_group = self._dump_conflicts(name, parent_id, file_id,
627
this_lines, base_lines,
629
file_group.append(trans_id)
631
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
632
base_lines=None, other_lines=None, set_version=False,
634
"""Emit conflict files.
635
If this_lines, base_lines, or other_lines are omitted, they will be
636
determined automatically. If set_version is true, the .OTHER, .THIS
637
or .BASE (in that order) will be created as versioned files.
639
data = [('OTHER', self.other_tree, other_lines),
640
('THIS', self.this_tree, this_lines)]
642
data.append(('BASE', self.base_tree, base_lines))
645
for suffix, tree, lines in data:
647
trans_id = self._conflict_file(name, parent_id, tree, file_id,
649
file_group.append(trans_id)
650
if set_version and not versioned:
651
self.tt.version_file(file_id, trans_id)
655
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
657
"""Emit a single conflict file."""
658
name = name + '.' + suffix
659
trans_id = self.tt.create_path(name, parent_id)
660
entry = tree.inventory[file_id]
661
create_by_entry(self.tt, entry, tree, trans_id, lines)
664
def merge_executable(self, file_id, file_status):
665
"""Perform a merge on the execute bit."""
666
if file_status == "deleted":
668
trans_id = self.tt.trans_id_file_id(file_id)
670
if self.tt.final_kind(trans_id) != "file":
674
winner = self.scalar_three_way(self.this_tree, self.base_tree,
675
self.other_tree, file_id,
677
if winner == "conflict":
678
# There must be a None in here, if we have a conflict, but we
679
# need executability since file status was not deleted.
680
if self.other_tree.is_executable(file_id) is None:
685
if file_status == "modified":
686
executability = self.this_tree.is_executable(file_id)
687
if executability is not None:
688
trans_id = self.tt.trans_id_file_id(file_id)
689
self.tt.set_executability(executability, trans_id)
691
assert winner == "other"
692
if file_id in self.other_tree:
693
executability = self.other_tree.is_executable(file_id)
694
elif file_id in self.this_tree:
695
executability = self.this_tree.is_executable(file_id)
696
elif file_id in self.base_tree:
697
executability = self.base_tree.is_executable(file_id)
698
if executability is not None:
699
trans_id = self.tt.trans_id_file_id(file_id)
700
self.tt.set_executability(executability, trans_id)
702
def cook_conflicts(self, fs_conflicts):
703
"""Convert all conflicts into a form that doesn't depend on trans_id"""
705
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
706
fp = FinalPaths(self.tt)
707
for conflict in self._raw_conflicts:
708
conflict_type = conflict[0]
709
if conflict_type in ('name conflict', 'parent conflict'):
710
trans_id = conflict[1]
711
conflict_args = conflict[2:]
712
if trans_id not in name_conflicts:
713
name_conflicts[trans_id] = {}
714
unique_add(name_conflicts[trans_id], conflict_type,
716
if conflict_type == 'contents conflict':
717
for trans_id in conflict[1]:
718
file_id = self.tt.final_file_id(trans_id)
719
if file_id is not None:
721
path = fp.get_path(trans_id)
722
for suffix in ('.BASE', '.THIS', '.OTHER'):
723
if path.endswith(suffix):
724
path = path[:-len(suffix)]
726
self.cooked_conflicts.append((conflict_type, file_id, path))
727
if conflict_type == 'text conflict':
728
trans_id = conflict[1]
729
path = fp.get_path(trans_id)
730
file_id = self.tt.final_file_id(trans_id)
731
self.cooked_conflicts.append((conflict_type, file_id, path))
733
for trans_id, conflicts in name_conflicts.iteritems():
735
this_parent, other_parent = conflicts['parent conflict']
736
assert this_parent != other_parent
738
this_parent = other_parent = \
739
self.tt.final_file_id(self.tt.final_parent(trans_id))
741
this_name, other_name = conflicts['name conflict']
742
assert this_name != other_name
744
this_name = other_name = self.tt.final_name(trans_id)
745
other_path = fp.get_path(trans_id)
746
if this_parent is not None:
748
fp.get_path(self.tt.trans_id_file_id(this_parent))
749
this_path = pathjoin(this_parent_path, this_name)
751
this_path = "<deleted>"
752
file_id = self.tt.final_file_id(trans_id)
753
self.cooked_conflicts.append(('path conflict', file_id, this_path,
757
class WeaveMerger(Merge3Merger):
758
"""Three-way tree merger, text weave merger."""
759
supports_reprocess = False
760
supports_show_base = False
762
def __init__(self, working_tree, this_tree, base_tree, other_tree,
763
interesting_ids=None, pb=DummyProgress(), pp=None):
764
self.this_revision_tree = self._get_revision_tree(this_tree)
765
self.other_revision_tree = self._get_revision_tree(other_tree)
766
super(WeaveMerger, self).__init__(working_tree, this_tree,
767
base_tree, other_tree,
768
interesting_ids=interesting_ids,
771
def _get_revision_tree(self, tree):
772
"""Return a revision tree releated to this tree.
773
If the tree is a WorkingTree, the basis will be returned.
775
if getattr(tree, 'get_weave', False) is False:
776
# If we have a WorkingTree, try using the basis
777
return tree.branch.basis_tree()
781
def _check_file(self, file_id):
782
"""Check that the revision tree's version of the file matches."""
783
for tree, rt in ((self.this_tree, self.this_revision_tree),
784
(self.other_tree, self.other_revision_tree)):
787
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
788
raise WorkingTreeNotRevision(self.this_tree)
790
def _merged_lines(self, file_id):
791
"""Generate the merged lines.
792
There is no distinction between lines that are meant to contain <<<<<<<
795
weave = self.this_revision_tree.get_weave(file_id)
796
this_revision_id = self.this_revision_tree.inventory[file_id].revision
797
other_revision_id = \
798
self.other_revision_tree.inventory[file_id].revision
799
plan = weave.plan_merge(this_revision_id, other_revision_id)
800
return weave.weave_merge(plan, '<<<<<<< TREE\n',
801
'>>>>>>> MERGE-SOURCE\n')
803
def text_merge(self, file_id, trans_id):
804
"""Perform a (weave) text merge for a given file and file-id.
805
If conflicts are encountered, .THIS and .OTHER files will be emitted,
806
and a conflict will be noted.
808
self._check_file(file_id)
809
lines = list(self._merged_lines(file_id))
810
conflicts = '<<<<<<< TREE\n' in lines
811
self.tt.create_file(lines, trans_id)
813
self._raw_conflicts.append(('text conflict', trans_id))
814
name = self.tt.final_name(trans_id)
815
parent_id = self.tt.final_parent(trans_id)
816
file_group = self._dump_conflicts(name, parent_id, file_id,
818
file_group.append(trans_id)
821
class Diff3Merger(Merge3Merger):
822
"""Three-way merger using external diff3 for text merging"""
823
def dump_file(self, temp_dir, name, tree, file_id):
824
out_path = pathjoin(temp_dir, name)
825
out_file = file(out_path, "wb")
826
in_file = tree.get_file(file_id)
831
def text_merge(self, file_id, trans_id):
832
"""Perform a diff3 merge using a specified file-id and trans-id.
833
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
834
will be dumped, and a will be conflict noted.
837
temp_dir = mkdtemp(prefix="bzr-")
839
new_file = pathjoin(temp_dir, "new")
840
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
841
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
842
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
843
status = bzrlib.patch.diff3(new_file, this, base, other)
844
if status not in (0, 1):
845
raise BzrError("Unhandled diff3 exit code")
846
self.tt.create_file(file(new_file, "rb"), trans_id)
848
name = self.tt.final_name(trans_id)
849
parent_id = self.tt.final_parent(trans_id)
850
self._dump_conflicts(name, parent_id, file_id)
851
self._raw_conflicts.append(('text conflict', trans_id))
856
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
858
merge_type=Merge3Merger,
859
interesting_ids=None,
863
interesting_files=None,
866
"""Primary interface for merging.
868
typical use is probably
869
'merge_inner(branch, branch.get_revision_tree(other_revision),
870
branch.get_revision_tree(base_revision))'
872
if this_tree is None:
873
warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
874
"bzrlib version 0.8.",
877
this_tree = this_branch.bzrdir.open_workingtree()
878
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
880
merger.backup_files = backup_files
881
merger.merge_type = merge_type
882
merger.interesting_ids = interesting_ids
883
merger.ignore_zero = ignore_zero
884
if interesting_files:
885
assert not interesting_ids, ('Only supply interesting_ids'
886
' or interesting_files')
887
merger._set_interesting_files(interesting_files)
888
merger.show_base = show_base
889
merger.reprocess = reprocess
890
merger.other_rev_id = other_rev_id
891
merger.other_basis = other_rev_id
892
return merger.do_merge()
895
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
896
"diff3": (Diff3Merger, "Merge using external diff3"),
897
'weave': (WeaveMerger, "Weave-based merge")
added
removed
bzrlib/merge.py
