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
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.symbol_versioning import *
45
from bzrlib.textfile import check_text_lines
46
from bzrlib.trace import mutter, warning, note
47
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
48
FinalPaths, create_by_entry, unique_add,
50
from bzrlib.versionedfile import WeaveMerge
53
# TODO: Report back as changes are merged in
55
def _get_tree(treespec, local_branch=None):
56
location, revno = treespec
57
branch = Branch.open_containing(location)[0]
61
revision = branch.last_revision()
63
revision = branch.get_rev_id(revno)
65
revision = NULL_REVISION
66
return branch, _get_revid_tree(branch, revision, local_branch)
69
def _get_revid_tree(branch, revision, local_branch):
71
base_tree = branch.bzrdir.open_workingtree()
73
if local_branch is not None:
74
if local_branch.base != branch.base:
75
local_branch.fetch(branch, revision)
76
base_tree = local_branch.repository.revision_tree(revision)
78
base_tree = branch.repository.revision_tree(revision)
82
def transform_tree(from_tree, to_tree, interesting_ids=None):
83
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
84
interesting_ids=interesting_ids, this_tree=from_tree)
88
def __init__(self, this_branch, other_tree=None, base_tree=None,
89
this_tree=None, pb=DummyProgress()):
91
assert this_tree is not None, "this_tree is required"
92
self.this_branch = this_branch
93
self.this_basis = this_branch.last_revision()
94
self.this_rev_id = None
95
self.this_tree = this_tree
96
self.this_revision_tree = None
97
self.this_basis_tree = None
98
self.other_tree = other_tree
99
self.base_tree = base_tree
100
self.ignore_zero = False
101
self.backup_files = False
102
self.interesting_ids = None
103
self.show_base = False
104
self.reprocess = False
109
def revision_tree(self, revision_id):
110
return self.this_branch.repository.revision_tree(revision_id)
112
def ensure_revision_trees(self):
113
if self.this_revision_tree is None:
114
self.this_basis_tree = self.this_branch.repository.revision_tree(
116
if self.this_basis == self.this_rev_id:
117
self.this_revision_tree = self.this_basis_tree
119
if self.other_rev_id is None:
120
other_basis_tree = self.revision_tree(self.other_basis)
121
changes = compare_trees(self.other_tree, other_basis_tree)
122
if changes.has_changed():
123
raise WorkingTreeNotRevision(self.this_tree)
124
other_rev_id = other_basis
125
self.other_tree = other_basis_tree
127
def file_revisions(self, file_id):
128
self.ensure_revision_trees()
129
def get_id(tree, file_id):
130
revision_id = tree.inventory[file_id].revision
131
assert revision_id is not None
133
if self.this_rev_id is None:
134
if self.this_basis_tree.get_file_sha1(file_id) != \
135
self.this_tree.get_file_sha1(file_id):
136
raise WorkingTreeNotRevision(self.this_tree)
138
trees = (self.this_basis_tree, self.other_tree)
139
return [get_id(tree, file_id) for tree in trees]
141
def check_basis(self, check_clean, require_commits=True):
142
if self.this_basis is None and require_commits is True:
143
raise BzrCommandError("This branch has no commits")
146
if self.this_basis != self.this_rev_id:
147
raise BzrCommandError("Working tree has uncommitted changes.")
149
def compare_basis(self):
150
changes = compare_trees(self.this_tree,
151
self.this_tree.basis_tree(), False)
152
if not changes.has_changed():
153
self.this_rev_id = self.this_basis
155
def set_interesting_files(self, file_list):
157
self._set_interesting_files(file_list)
158
except NotVersionedError, e:
159
raise BzrCommandError("%s is not a source file in any"
162
def _set_interesting_files(self, file_list):
163
"""Set the list of interesting ids from a list of files."""
164
if file_list is None:
165
self.interesting_ids = None
168
interesting_ids = set()
169
for path in file_list:
171
for tree in (self.this_tree, self.base_tree, self.other_tree):
172
file_id = tree.inventory.path2id(path)
173
if file_id is not None:
174
interesting_ids.add(file_id)
177
raise NotVersionedError(path=path)
178
self.interesting_ids = interesting_ids
180
def set_pending(self):
181
if not self.base_is_ancestor:
183
if self.other_rev_id is None:
185
ancestry = self.this_branch.repository.get_ancestry(self.this_basis)
186
if self.other_rev_id in ancestry:
188
self.this_tree.add_pending_merge(self.other_rev_id)
190
def set_other(self, other_revision):
191
other_branch, self.other_tree = _get_tree(other_revision,
193
if other_revision[1] == -1:
194
self.other_rev_id = other_branch.last_revision()
195
if self.other_rev_id is None:
196
raise NoCommits(other_branch)
197
self.other_basis = self.other_rev_id
198
elif other_revision[1] is not None:
199
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
200
self.other_basis = self.other_rev_id
202
self.other_rev_id = None
203
self.other_basis = other_branch.last_revision()
204
if self.other_basis is None:
205
raise NoCommits(other_branch)
206
if other_branch.base != self.this_branch.base:
207
self.this_branch.fetch(other_branch, last_revision=self.other_basis)
210
self.set_base([None, None])
212
def set_base(self, base_revision):
213
mutter("doing merge() with no base_revision specified")
214
if base_revision == [None, None]:
216
pb = bzrlib.ui.ui_factory.nested_progress_bar()
218
this_repo = self.this_branch.repository
219
self.base_rev_id = common_ancestor(self.this_basis,
224
except NoCommonAncestor:
225
raise UnrelatedBranches()
226
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
228
self.base_is_ancestor = True
230
base_branch, self.base_tree = _get_tree(base_revision)
231
if base_revision[1] == -1:
232
self.base_rev_id = base_branch.last_revision()
233
elif base_revision[1] is None:
234
self.base_rev_id = None
236
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
237
if self.this_branch.base != base_branch.base:
238
self.this_branch.fetch(base_branch)
239
self.base_is_ancestor = is_ancestor(self.this_basis,
244
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
245
'other_tree': self.other_tree,
246
'interesting_ids': self.interesting_ids,
248
if self.merge_type.requires_base:
249
kwargs['base_tree'] = self.base_tree
250
if self.merge_type.supports_reprocess:
251
kwargs['reprocess'] = self.reprocess
253
raise BzrError("Conflict reduction is not supported for merge"
254
" type %s." % self.merge_type)
255
if self.merge_type.supports_show_base:
256
kwargs['show_base'] = self.show_base
258
raise BzrError("Showing base is not supported for this"
259
" merge type. %s" % self.merge_type)
260
merge = self.merge_type(pb=self._pb, **kwargs)
261
if len(merge.cooked_conflicts) == 0:
262
if not self.ignore_zero:
263
note("All changes applied successfully.")
265
note("%d conflicts encountered." % len(merge.cooked_conflicts))
267
return len(merge.cooked_conflicts)
269
def regen_inventory(self, new_entries):
270
old_entries = self.this_tree.read_working_inventory()
274
for path, file_id in new_entries:
277
new_entries_map[file_id] = path
279
def id2path(file_id):
280
path = new_entries_map.get(file_id)
283
entry = old_entries[file_id]
284
if entry.parent_id is None:
286
return pathjoin(id2path(entry.parent_id), entry.name)
288
for file_id in old_entries:
289
entry = old_entries[file_id]
290
path = id2path(file_id)
291
if file_id in self.base_tree.inventory:
292
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
294
executable = getattr(entry, 'executable', False)
295
new_inventory[file_id] = (path, file_id, entry.parent_id,
296
entry.kind, executable)
298
by_path[path] = file_id
303
for path, file_id in new_entries:
305
del new_inventory[file_id]
308
new_path_list.append((path, file_id))
309
if file_id not in old_entries:
311
# Ensure no file is added before its parent
313
for path, file_id in new_path_list:
317
parent = by_path[os.path.dirname(path)]
318
abspath = pathjoin(self.this_tree.basedir, path)
319
kind = bzrlib.osutils.file_kind(abspath)
320
if file_id in self.base_tree.inventory:
321
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
324
new_inventory[file_id] = (path, file_id, parent, kind, executable)
325
by_path[path] = file_id
327
# Get a list in insertion order
328
new_inventory_list = new_inventory.values()
329
mutter ("""Inventory regeneration:
330
old length: %i insertions: %i deletions: %i new_length: %i"""\
331
% (len(old_entries), insertions, deletions,
332
len(new_inventory_list)))
333
assert len(new_inventory_list) == len(old_entries) + insertions\
335
new_inventory_list.sort()
336
return new_inventory_list
339
class Merge3Merger(object):
340
"""Three-way merger that uses the merge3 text merger"""
342
supports_reprocess = True
343
supports_show_base = True
344
history_based = False
346
def __init__(self, working_tree, this_tree, base_tree, other_tree,
347
interesting_ids=None, reprocess=False, show_base=False,
348
pb=DummyProgress(), pp=None):
349
"""Initialize the merger object and perform the merge."""
350
object.__init__(self)
351
self.this_tree = working_tree
352
self.base_tree = base_tree
353
self.other_tree = other_tree
354
self._raw_conflicts = []
355
self.cooked_conflicts = []
356
self.reprocess = reprocess
357
self.show_base = show_base
361
self.pp = ProgressPhase("Merge phase", 3, self.pb)
363
if interesting_ids is not None:
364
all_ids = interesting_ids
366
all_ids = set(base_tree)
367
all_ids.update(other_tree)
368
working_tree.lock_write()
369
self.tt = TreeTransform(working_tree, self.pb)
372
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
374
for num, file_id in enumerate(all_ids):
375
child_pb.update('Preparing file merge', num, len(all_ids))
376
self.merge_names(file_id)
377
file_status = self.merge_contents(file_id)
378
self.merge_executable(file_id, file_status)
383
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
385
fs_conflicts = resolve_conflicts(self.tt, child_pb)
388
self.cook_conflicts(fs_conflicts)
389
for conflict in self.cooked_conflicts:
392
results = self.tt.apply()
393
self.write_modified(results)
395
working_tree.set_conflicts(ConflictList(self.cooked_conflicts))
396
except UnsupportedOperation:
403
working_tree.unlock()
408
self.tt.final_kind(self.tt.root)
410
self.tt.cancel_deletion(self.tt.root)
411
if self.tt.final_file_id(self.tt.root) is None:
412
self.tt.version_file(self.tt.tree_file_id(self.tt.root),
414
if self.other_tree.inventory.root is None:
416
other_root_file_id = self.other_tree.inventory.root.file_id
417
other_root = self.tt.trans_id_file_id(other_root_file_id)
418
if other_root == self.tt.root:
421
self.tt.final_kind(other_root)
424
self.reparent_children(self.other_tree.inventory.root, self.tt.root)
425
self.tt.cancel_creation(other_root)
426
self.tt.cancel_versioning(other_root)
428
def reparent_children(self, ie, target):
429
for child in ie.children:
430
if isinstance(child, str):
431
raise "Child of %r is a string: %r" % (ie.file_id, child)
432
trans_id = self.tt.trans_id_file_id(child.file_id)
433
self.tt.adjust_path(self.tt.final_name(trans_id), target)
435
def write_modified(self, results):
437
for path in results.modified_paths:
438
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
441
hash = self.this_tree.get_file_sha1(file_id)
444
modified_hashes[file_id] = hash
445
self.this_tree.set_merge_modified(modified_hashes)
448
def parent(entry, file_id):
449
"""Determine the parent for a file_id (used as a key method)"""
452
return entry.parent_id
455
def name(entry, file_id):
456
"""Determine the name for a file_id (used as a key method)"""
462
def contents_sha1(tree, file_id):
463
"""Determine the sha1 of the file contents (used as a key method)."""
464
if file_id not in tree:
466
return tree.get_file_sha1(file_id)
469
def executable(tree, file_id):
470
"""Determine the executability of a file-id (used as a key method)."""
471
if file_id not in tree:
473
if tree.kind(file_id) != "file":
475
return tree.is_executable(file_id)
478
def kind(tree, file_id):
479
"""Determine the kind of a file-id (used as a key method)."""
480
if file_id not in tree:
482
return tree.kind(file_id)
485
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
486
"""Do a three-way test on a scalar.
487
Return "this", "other" or "conflict", depending whether a value wins.
489
key_base = key(base_tree, file_id)
490
key_other = key(other_tree, file_id)
491
#if base == other, either they all agree, or only THIS has changed.
492
if key_base == key_other:
494
key_this = key(this_tree, file_id)
495
if key_this not in (key_base, key_other):
497
# "Ambiguous clean merge"
498
elif key_this == key_other:
501
assert key_this == key_base
504
def merge_names(self, file_id):
505
"""Perform a merge on file_id names and parents"""
507
if file_id in tree.inventory:
508
return tree.inventory[file_id]
511
this_entry = get_entry(self.this_tree)
512
other_entry = get_entry(self.other_tree)
513
base_entry = get_entry(self.base_tree)
514
name_winner = self.scalar_three_way(this_entry, base_entry,
515
other_entry, file_id, self.name)
516
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
517
other_entry, file_id,
519
if this_entry is None:
520
if name_winner == "this":
521
name_winner = "other"
522
if parent_id_winner == "this":
523
parent_id_winner = "other"
524
if name_winner == "this" and parent_id_winner == "this":
526
if name_winner == "conflict":
527
trans_id = self.tt.trans_id_file_id(file_id)
528
self._raw_conflicts.append(('name conflict', trans_id,
529
self.name(this_entry, file_id),
530
self.name(other_entry, file_id)))
531
if parent_id_winner == "conflict":
532
trans_id = self.tt.trans_id_file_id(file_id)
533
self._raw_conflicts.append(('parent conflict', trans_id,
534
self.parent(this_entry, file_id),
535
self.parent(other_entry, file_id)))
536
if other_entry is None:
537
# it doesn't matter whether the result was 'other' or
538
# 'conflict'-- if there's no 'other', we leave it alone.
540
# if we get here, name_winner and parent_winner are set to safe values.
541
winner_entry = {"this": this_entry, "other": other_entry,
542
"conflict": other_entry}
543
trans_id = self.tt.trans_id_file_id(file_id)
544
parent_id = winner_entry[parent_id_winner].parent_id
545
if parent_id is not None:
546
parent_trans_id = self.tt.trans_id_file_id(parent_id)
547
self.tt.adjust_path(winner_entry[name_winner].name,
548
parent_trans_id, trans_id)
550
def merge_contents(self, file_id):
551
"""Performa a merge on file_id contents."""
552
def contents_pair(tree):
553
if file_id not in tree:
555
kind = tree.kind(file_id)
557
contents = tree.get_file_sha1(file_id)
558
elif kind == "symlink":
559
contents = tree.get_symlink_target(file_id)
562
return kind, contents
564
def contents_conflict():
565
trans_id = self.tt.trans_id_file_id(file_id)
566
name = self.tt.final_name(trans_id)
567
parent_id = self.tt.final_parent(trans_id)
568
if file_id in self.this_tree.inventory:
569
self.tt.unversion_file(trans_id)
570
self.tt.delete_contents(trans_id)
571
file_group = self._dump_conflicts(name, parent_id, file_id,
573
self._raw_conflicts.append(('contents conflict', file_group))
575
# See SPOT run. run, SPOT, run.
576
# So we're not QUITE repeating ourselves; we do tricky things with
578
base_pair = contents_pair(self.base_tree)
579
other_pair = contents_pair(self.other_tree)
580
if base_pair == other_pair:
581
# OTHER introduced no changes
583
this_pair = contents_pair(self.this_tree)
584
if this_pair == other_pair:
585
# THIS and OTHER introduced the same changes
588
trans_id = self.tt.trans_id_file_id(file_id)
589
if this_pair == base_pair:
590
# only OTHER introduced changes
591
if file_id in self.this_tree:
592
# Remove any existing contents
593
self.tt.delete_contents(trans_id)
594
if file_id in self.other_tree:
595
# OTHER changed the file
596
create_by_entry(self.tt,
597
self.other_tree.inventory[file_id],
598
self.other_tree, trans_id)
599
if file_id not in self.this_tree.inventory:
600
self.tt.version_file(file_id, trans_id)
602
elif file_id in self.this_tree.inventory:
603
# OTHER deleted the file
604
self.tt.unversion_file(trans_id)
606
#BOTH THIS and OTHER introduced changes; scalar conflict
607
elif this_pair[0] == "file" and other_pair[0] == "file":
608
# THIS and OTHER are both files, so text merge. Either
609
# BASE is a file, or both converted to files, so at least we
610
# have agreement that output should be a file.
612
self.text_merge(file_id, trans_id)
614
return contents_conflict()
615
if file_id not in self.this_tree.inventory:
616
self.tt.version_file(file_id, trans_id)
618
self.tt.tree_kind(trans_id)
619
self.tt.delete_contents(trans_id)
624
# Scalar conflict, can't text merge. Dump conflicts
625
return contents_conflict()
627
def get_lines(self, tree, file_id):
628
"""Return the lines in a file, or an empty list."""
630
return tree.get_file(file_id).readlines()
634
def text_merge(self, file_id, trans_id):
635
"""Perform a three-way text merge on a file_id"""
636
# it's possible that we got here with base as a different type.
637
# if so, we just want two-way text conflicts.
638
if file_id in self.base_tree and \
639
self.base_tree.kind(file_id) == "file":
640
base_lines = self.get_lines(self.base_tree, file_id)
643
other_lines = self.get_lines(self.other_tree, file_id)
644
this_lines = self.get_lines(self.this_tree, file_id)
645
m3 = Merge3(base_lines, this_lines, other_lines)
646
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
647
if self.show_base is True:
648
base_marker = '|' * 7
652
def iter_merge3(retval):
653
retval["text_conflicts"] = False
654
for line in m3.merge_lines(name_a = "TREE",
655
name_b = "MERGE-SOURCE",
656
name_base = "BASE-REVISION",
657
start_marker=start_marker,
658
base_marker=base_marker,
659
reprocess=self.reprocess):
660
if line.startswith(start_marker):
661
retval["text_conflicts"] = True
662
yield line.replace(start_marker, '<' * 7)
666
merge3_iterator = iter_merge3(retval)
667
self.tt.create_file(merge3_iterator, trans_id)
668
if retval["text_conflicts"] is True:
669
self._raw_conflicts.append(('text conflict', trans_id))
670
name = self.tt.final_name(trans_id)
671
parent_id = self.tt.final_parent(trans_id)
672
file_group = self._dump_conflicts(name, parent_id, file_id,
673
this_lines, base_lines,
675
file_group.append(trans_id)
677
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
678
base_lines=None, other_lines=None, set_version=False,
680
"""Emit conflict files.
681
If this_lines, base_lines, or other_lines are omitted, they will be
682
determined automatically. If set_version is true, the .OTHER, .THIS
683
or .BASE (in that order) will be created as versioned files.
685
data = [('OTHER', self.other_tree, other_lines),
686
('THIS', self.this_tree, this_lines)]
688
data.append(('BASE', self.base_tree, base_lines))
691
for suffix, tree, lines in data:
693
trans_id = self._conflict_file(name, parent_id, tree, file_id,
695
file_group.append(trans_id)
696
if set_version and not versioned:
697
self.tt.version_file(file_id, trans_id)
701
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
703
"""Emit a single conflict file."""
704
name = name + '.' + suffix
705
trans_id = self.tt.create_path(name, parent_id)
706
entry = tree.inventory[file_id]
707
create_by_entry(self.tt, entry, tree, trans_id, lines)
710
def merge_executable(self, file_id, file_status):
711
"""Perform a merge on the execute bit."""
712
if file_status == "deleted":
714
trans_id = self.tt.trans_id_file_id(file_id)
716
if self.tt.final_kind(trans_id) != "file":
720
winner = self.scalar_three_way(self.this_tree, self.base_tree,
721
self.other_tree, file_id,
723
if winner == "conflict":
724
# There must be a None in here, if we have a conflict, but we
725
# need executability since file status was not deleted.
726
if self.other_tree.is_executable(file_id) is None:
731
if file_status == "modified":
732
executability = self.this_tree.is_executable(file_id)
733
if executability is not None:
734
trans_id = self.tt.trans_id_file_id(file_id)
735
self.tt.set_executability(executability, trans_id)
737
assert winner == "other"
738
if file_id in self.other_tree:
739
executability = self.other_tree.is_executable(file_id)
740
elif file_id in self.this_tree:
741
executability = self.this_tree.is_executable(file_id)
742
elif file_id in self.base_tree:
743
executability = self.base_tree.is_executable(file_id)
744
if executability is not None:
745
trans_id = self.tt.trans_id_file_id(file_id)
746
self.tt.set_executability(executability, trans_id)
748
def cook_conflicts(self, fs_conflicts):
749
"""Convert all conflicts into a form that doesn't depend on trans_id"""
750
from conflicts import Conflict
752
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
753
fp = FinalPaths(self.tt)
754
for conflict in self._raw_conflicts:
755
conflict_type = conflict[0]
756
if conflict_type in ('name conflict', 'parent conflict'):
757
trans_id = conflict[1]
758
conflict_args = conflict[2:]
759
if trans_id not in name_conflicts:
760
name_conflicts[trans_id] = {}
761
unique_add(name_conflicts[trans_id], conflict_type,
763
if conflict_type == 'contents conflict':
764
for trans_id in conflict[1]:
765
file_id = self.tt.final_file_id(trans_id)
766
if file_id is not None:
768
path = fp.get_path(trans_id)
769
for suffix in ('.BASE', '.THIS', '.OTHER'):
770
if path.endswith(suffix):
771
path = path[:-len(suffix)]
773
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
774
self.cooked_conflicts.append(c)
775
if conflict_type == 'text conflict':
776
trans_id = conflict[1]
777
path = fp.get_path(trans_id)
778
file_id = self.tt.final_file_id(trans_id)
779
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
780
self.cooked_conflicts.append(c)
782
for trans_id, conflicts in name_conflicts.iteritems():
784
this_parent, other_parent = conflicts['parent conflict']
785
assert this_parent != other_parent
787
this_parent = other_parent = \
788
self.tt.final_file_id(self.tt.final_parent(trans_id))
790
this_name, other_name = conflicts['name conflict']
791
assert this_name != other_name
793
this_name = other_name = self.tt.final_name(trans_id)
794
other_path = fp.get_path(trans_id)
795
if this_parent is not None:
797
fp.get_path(self.tt.trans_id_file_id(this_parent))
798
this_path = pathjoin(this_parent_path, this_name)
800
this_path = "<deleted>"
801
file_id = self.tt.final_file_id(trans_id)
802
c = Conflict.factory('path conflict', path=this_path,
803
conflict_path=other_path, file_id=file_id)
804
self.cooked_conflicts.append(c)
805
self.cooked_conflicts.sort(key=Conflict.sort_key)
808
class WeaveMerger(Merge3Merger):
809
"""Three-way tree merger, text weave merger."""
810
supports_reprocess = True
811
supports_show_base = False
813
def __init__(self, working_tree, this_tree, base_tree, other_tree,
814
interesting_ids=None, pb=DummyProgress(), pp=None,
816
self.this_revision_tree = self._get_revision_tree(this_tree)
817
self.other_revision_tree = self._get_revision_tree(other_tree)
818
super(WeaveMerger, self).__init__(working_tree, this_tree,
819
base_tree, other_tree,
820
interesting_ids=interesting_ids,
821
pb=pb, pp=pp, reprocess=reprocess)
823
def _get_revision_tree(self, tree):
824
"""Return a revision tree releated to this tree.
825
If the tree is a WorkingTree, the basis will be returned.
827
if getattr(tree, 'get_weave', False) is False:
828
# If we have a WorkingTree, try using the basis
829
return tree.branch.basis_tree()
833
def _check_file(self, file_id):
834
"""Check that the revision tree's version of the file matches."""
835
for tree, rt in ((self.this_tree, self.this_revision_tree),
836
(self.other_tree, self.other_revision_tree)):
839
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
840
raise WorkingTreeNotRevision(self.this_tree)
842
def _merged_lines(self, file_id):
843
"""Generate the merged lines.
844
There is no distinction between lines that are meant to contain <<<<<<<
847
weave = self.this_revision_tree.get_weave(file_id)
848
this_revision_id = self.this_revision_tree.inventory[file_id].revision
849
other_revision_id = \
850
self.other_revision_tree.inventory[file_id].revision
851
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
852
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
853
return wm.merge_lines(self.reprocess)
855
def text_merge(self, file_id, trans_id):
856
"""Perform a (weave) text merge for a given file and file-id.
857
If conflicts are encountered, .THIS and .OTHER files will be emitted,
858
and a conflict will be noted.
860
self._check_file(file_id)
861
lines, conflicts = self._merged_lines(file_id)
863
# Note we're checking whether the OUTPUT is binary in this case,
864
# because we don't want to get into weave merge guts.
865
check_text_lines(lines)
866
self.tt.create_file(lines, trans_id)
868
self._raw_conflicts.append(('text conflict', trans_id))
869
name = self.tt.final_name(trans_id)
870
parent_id = self.tt.final_parent(trans_id)
871
file_group = self._dump_conflicts(name, parent_id, file_id,
873
file_group.append(trans_id)
876
class Diff3Merger(Merge3Merger):
877
"""Three-way merger using external diff3 for text merging"""
878
def dump_file(self, temp_dir, name, tree, file_id):
879
out_path = pathjoin(temp_dir, name)
880
out_file = file(out_path, "wb")
881
in_file = tree.get_file(file_id)
886
def text_merge(self, file_id, trans_id):
887
"""Perform a diff3 merge using a specified file-id and trans-id.
888
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
889
will be dumped, and a will be conflict noted.
892
temp_dir = mkdtemp(prefix="bzr-")
894
new_file = pathjoin(temp_dir, "new")
895
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
896
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
897
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
898
status = bzrlib.patch.diff3(new_file, this, base, other)
899
if status not in (0, 1):
900
raise BzrError("Unhandled diff3 exit code")
901
self.tt.create_file(file(new_file, "rb"), trans_id)
903
name = self.tt.final_name(trans_id)
904
parent_id = self.tt.final_parent(trans_id)
905
self._dump_conflicts(name, parent_id, file_id)
906
self._raw_conflicts.append(('text conflict', trans_id))
911
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
913
merge_type=Merge3Merger,
914
interesting_ids=None,
918
interesting_files=None,
921
"""Primary interface for merging.
923
typical use is probably
924
'merge_inner(branch, branch.get_revision_tree(other_revision),
925
branch.get_revision_tree(base_revision))'
927
if this_tree is None:
928
warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
929
"bzrlib version 0.8.",
932
this_tree = this_branch.bzrdir.open_workingtree()
933
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
935
merger.backup_files = backup_files
936
merger.merge_type = merge_type
937
merger.interesting_ids = interesting_ids
938
merger.ignore_zero = ignore_zero
939
if interesting_files:
940
assert not interesting_ids, ('Only supply interesting_ids'
941
' or interesting_files')
942
merger._set_interesting_files(interesting_files)
943
merger.show_base = show_base
944
merger.reprocess = reprocess
945
merger.other_rev_id = other_rev_id
946
merger.other_basis = other_rev_id
947
return merger.do_merge()
950
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
951
"diff3": (Diff3Merger, "Merge using external diff3"),
952
'weave': (WeaveMerger, "Weave-based merge")
956
def merge_type_help():
957
templ = '%s%%7s: %%s' % (' '*12)
958
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
959
return '\n'.join(lines)
added
removed
bzrlib/merge.py
