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
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
42
from bzrlib.osutils import rename, pathjoin
43
from progress import DummyProgress, ProgressPhase
44
from bzrlib.revision import common_ancestor, is_ancestor, NULL_REVISION
45
from bzrlib.textfile import check_text_lines
46
from bzrlib.trace import mutter, warning, note
47
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
48
FinalPaths, create_by_entry, unique_add)
49
from bzrlib.versionedfile import WeaveMerge
52
# TODO: Report back as changes are merged in
54
def _get_tree(treespec, local_branch=None):
55
from bzrlib import workingtree
56
location, revno = treespec
58
tree = workingtree.WorkingTree.open_containing(location)[0]
59
return tree.branch, tree
60
branch = Branch.open_containing(location)[0]
62
revision = branch.last_revision()
64
revision = branch.get_rev_id(revno)
66
revision = NULL_REVISION
67
return branch, _get_revid_tree(branch, revision, local_branch)
70
def _get_revid_tree(branch, revision, local_branch):
72
base_tree = branch.bzrdir.open_workingtree()
74
if local_branch is not None:
75
if local_branch.base != branch.base:
76
local_branch.fetch(branch, revision)
77
base_tree = local_branch.repository.revision_tree(revision)
79
base_tree = branch.repository.revision_tree(revision)
83
def transform_tree(from_tree, to_tree, interesting_ids=None):
84
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
85
interesting_ids=interesting_ids, this_tree=from_tree)
89
def __init__(self, this_branch, other_tree=None, base_tree=None,
90
this_tree=None, pb=DummyProgress()):
92
assert this_tree is not None, "this_tree is required"
93
self.this_branch = this_branch
94
self.this_basis = this_branch.last_revision()
95
self.this_rev_id = None
96
self.this_tree = this_tree
97
self.this_revision_tree = None
98
self.this_basis_tree = None
99
self.other_tree = other_tree
100
self.base_tree = base_tree
101
self.ignore_zero = False
102
self.backup_files = False
103
self.interesting_ids = None
104
self.show_base = False
105
self.reprocess = False
110
def revision_tree(self, revision_id):
111
return self.this_branch.repository.revision_tree(revision_id)
113
def ensure_revision_trees(self):
114
if self.this_revision_tree is None:
115
self.this_basis_tree = self.this_branch.repository.revision_tree(
117
if self.this_basis == self.this_rev_id:
118
self.this_revision_tree = self.this_basis_tree
120
if self.other_rev_id is None:
121
other_basis_tree = self.revision_tree(self.other_basis)
122
changes = other_basis_tree.changes_from(self.other_tree)
123
if changes.has_changed():
124
raise WorkingTreeNotRevision(self.this_tree)
125
other_rev_id = self.other_basis
126
self.other_tree = other_basis_tree
128
def file_revisions(self, file_id):
129
self.ensure_revision_trees()
130
def get_id(tree, file_id):
131
revision_id = tree.inventory[file_id].revision
132
assert revision_id is not None
134
if self.this_rev_id is None:
135
if self.this_basis_tree.get_file_sha1(file_id) != \
136
self.this_tree.get_file_sha1(file_id):
137
raise WorkingTreeNotRevision(self.this_tree)
139
trees = (self.this_basis_tree, self.other_tree)
140
return [get_id(tree, file_id) for tree in trees]
142
def check_basis(self, check_clean, require_commits=True):
143
if self.this_basis is None and require_commits is True:
144
raise BzrCommandError("This branch has no commits")
147
if self.this_basis != self.this_rev_id:
148
raise BzrCommandError("Working tree has uncommitted changes.")
150
def compare_basis(self):
151
changes = self.this_tree.changes_from(self.this_tree.basis_tree())
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_parent_tree((self.other_rev_id, self.other_tree))
190
def set_other(self, other_revision):
191
"""Set the revision and tree to merge from.
193
This sets the other_tree, other_rev_id, other_basis attributes.
195
:param other_revision: The [path, revision] list to merge from.
197
other_branch, self.other_tree = _get_tree(other_revision,
199
if other_revision[1] == -1:
200
self.other_rev_id = other_branch.last_revision()
201
if self.other_rev_id is None:
202
raise NoCommits(other_branch)
203
self.other_basis = self.other_rev_id
204
elif other_revision[1] is not None:
205
self.other_rev_id = other_branch.get_rev_id(other_revision[1])
206
self.other_basis = self.other_rev_id
208
self.other_rev_id = None
209
self.other_basis = other_branch.last_revision()
210
if self.other_basis is None:
211
raise NoCommits(other_branch)
212
if other_branch.base != self.this_branch.base:
213
self.this_branch.fetch(other_branch, last_revision=self.other_basis)
216
self.set_base([None, None])
218
def set_base(self, base_revision):
219
"""Set the base revision to use for the merge.
221
:param base_revision: A 2-list containing a path and revision number.
223
mutter("doing merge() with no base_revision specified")
224
if base_revision == [None, None]:
226
pb = bzrlib.ui.ui_factory.nested_progress_bar()
228
this_repo = self.this_branch.repository
229
self.base_rev_id = common_ancestor(self.this_basis,
234
except NoCommonAncestor:
235
raise UnrelatedBranches()
236
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
238
self.base_is_ancestor = True
240
base_branch, self.base_tree = _get_tree(base_revision)
241
if base_revision[1] == -1:
242
self.base_rev_id = base_branch.last_revision()
243
elif base_revision[1] is None:
244
self.base_rev_id = None
246
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
247
if self.this_branch.base != base_branch.base:
248
self.this_branch.fetch(base_branch)
249
self.base_is_ancestor = is_ancestor(self.this_basis,
254
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
255
'other_tree': self.other_tree,
256
'interesting_ids': self.interesting_ids,
258
if self.merge_type.requires_base:
259
kwargs['base_tree'] = self.base_tree
260
if self.merge_type.supports_reprocess:
261
kwargs['reprocess'] = self.reprocess
263
raise BzrError("Conflict reduction is not supported for merge"
264
" type %s." % self.merge_type)
265
if self.merge_type.supports_show_base:
266
kwargs['show_base'] = self.show_base
268
raise BzrError("Showing base is not supported for this"
269
" merge type. %s" % self.merge_type)
270
merge = self.merge_type(pb=self._pb, **kwargs)
271
if len(merge.cooked_conflicts) == 0:
272
if not self.ignore_zero:
273
note("All changes applied successfully.")
275
note("%d conflicts encountered." % len(merge.cooked_conflicts))
277
return len(merge.cooked_conflicts)
279
def regen_inventory(self, new_entries):
280
old_entries = self.this_tree.read_working_inventory()
284
for path, file_id in new_entries:
287
new_entries_map[file_id] = path
289
def id2path(file_id):
290
path = new_entries_map.get(file_id)
293
entry = old_entries[file_id]
294
if entry.parent_id is None:
296
return pathjoin(id2path(entry.parent_id), entry.name)
298
for file_id in old_entries:
299
entry = old_entries[file_id]
300
path = id2path(file_id)
301
if file_id in self.base_tree.inventory:
302
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
304
executable = getattr(entry, 'executable', False)
305
new_inventory[file_id] = (path, file_id, entry.parent_id,
306
entry.kind, executable)
308
by_path[path] = file_id
313
for path, file_id in new_entries:
315
del new_inventory[file_id]
318
new_path_list.append((path, file_id))
319
if file_id not in old_entries:
321
# Ensure no file is added before its parent
323
for path, file_id in new_path_list:
327
parent = by_path[os.path.dirname(path)]
328
abspath = pathjoin(self.this_tree.basedir, path)
329
kind = bzrlib.osutils.file_kind(abspath)
330
if file_id in self.base_tree.inventory:
331
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
334
new_inventory[file_id] = (path, file_id, parent, kind, executable)
335
by_path[path] = file_id
337
# Get a list in insertion order
338
new_inventory_list = new_inventory.values()
339
mutter ("""Inventory regeneration:
340
old length: %i insertions: %i deletions: %i new_length: %i"""\
341
% (len(old_entries), insertions, deletions,
342
len(new_inventory_list)))
343
assert len(new_inventory_list) == len(old_entries) + insertions\
345
new_inventory_list.sort()
346
return new_inventory_list
349
class Merge3Merger(object):
350
"""Three-way merger that uses the merge3 text merger"""
352
supports_reprocess = True
353
supports_show_base = True
354
history_based = False
356
def __init__(self, working_tree, this_tree, base_tree, other_tree,
357
interesting_ids=None, reprocess=False, show_base=False,
358
pb=DummyProgress(), pp=None):
359
"""Initialize the merger object and perform the merge."""
360
object.__init__(self)
361
self.this_tree = working_tree
362
self.base_tree = base_tree
363
self.other_tree = other_tree
364
self._raw_conflicts = []
365
self.cooked_conflicts = []
366
self.reprocess = reprocess
367
self.show_base = show_base
371
self.pp = ProgressPhase("Merge phase", 3, self.pb)
373
if interesting_ids is not None:
374
all_ids = interesting_ids
376
all_ids = set(base_tree)
377
all_ids.update(other_tree)
378
working_tree.lock_write()
379
self.tt = TreeTransform(working_tree, self.pb)
382
child_pb = ui.ui_factory.nested_progress_bar()
384
for num, file_id in enumerate(all_ids):
385
child_pb.update('Preparing file merge', num, len(all_ids))
386
self.merge_names(file_id)
387
file_status = self.merge_contents(file_id)
388
self.merge_executable(file_id, file_status)
393
child_pb = ui.ui_factory.nested_progress_bar()
395
fs_conflicts = resolve_conflicts(self.tt, child_pb)
398
self.cook_conflicts(fs_conflicts)
399
for conflict in self.cooked_conflicts:
402
results = self.tt.apply()
403
self.write_modified(results)
405
working_tree.add_conflicts(self.cooked_conflicts)
406
except UnsupportedOperation:
410
working_tree.unlock()
413
def write_modified(self, results):
415
for path in results.modified_paths:
416
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
419
hash = self.this_tree.get_file_sha1(file_id)
422
modified_hashes[file_id] = hash
423
self.this_tree.set_merge_modified(modified_hashes)
426
def parent(entry, file_id):
427
"""Determine the parent for a file_id (used as a key method)"""
430
return entry.parent_id
433
def name(entry, file_id):
434
"""Determine the name for a file_id (used as a key method)"""
440
def contents_sha1(tree, file_id):
441
"""Determine the sha1 of the file contents (used as a key method)."""
442
if file_id not in tree:
444
return tree.get_file_sha1(file_id)
447
def executable(tree, file_id):
448
"""Determine the executability of a file-id (used as a key method)."""
449
if file_id not in tree:
451
if tree.kind(file_id) != "file":
453
return tree.is_executable(file_id)
456
def kind(tree, file_id):
457
"""Determine the kind of a file-id (used as a key method)."""
458
if file_id not in tree:
460
return tree.kind(file_id)
463
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
464
"""Do a three-way test on a scalar.
465
Return "this", "other" or "conflict", depending whether a value wins.
467
key_base = key(base_tree, file_id)
468
key_other = key(other_tree, file_id)
469
#if base == other, either they all agree, or only THIS has changed.
470
if key_base == key_other:
472
key_this = key(this_tree, file_id)
473
if key_this not in (key_base, key_other):
475
# "Ambiguous clean merge"
476
elif key_this == key_other:
479
assert key_this == key_base
482
def merge_names(self, file_id):
483
"""Perform a merge on file_id names and parents"""
485
if file_id in tree.inventory:
486
return tree.inventory[file_id]
489
this_entry = get_entry(self.this_tree)
490
other_entry = get_entry(self.other_tree)
491
base_entry = get_entry(self.base_tree)
492
name_winner = self.scalar_three_way(this_entry, base_entry,
493
other_entry, file_id, self.name)
494
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
495
other_entry, file_id,
497
if this_entry is None:
498
if name_winner == "this":
499
name_winner = "other"
500
if parent_id_winner == "this":
501
parent_id_winner = "other"
502
if name_winner == "this" and parent_id_winner == "this":
504
if name_winner == "conflict":
505
trans_id = self.tt.trans_id_file_id(file_id)
506
self._raw_conflicts.append(('name conflict', trans_id,
507
self.name(this_entry, file_id),
508
self.name(other_entry, file_id)))
509
if parent_id_winner == "conflict":
510
trans_id = self.tt.trans_id_file_id(file_id)
511
self._raw_conflicts.append(('parent conflict', trans_id,
512
self.parent(this_entry, file_id),
513
self.parent(other_entry, file_id)))
514
if other_entry is None:
515
# it doesn't matter whether the result was 'other' or
516
# 'conflict'-- if there's no 'other', we leave it alone.
518
# if we get here, name_winner and parent_winner are set to safe values.
519
winner_entry = {"this": this_entry, "other": other_entry,
520
"conflict": other_entry}
521
trans_id = self.tt.trans_id_file_id(file_id)
522
parent_id = winner_entry[parent_id_winner].parent_id
523
parent_trans_id = self.tt.trans_id_file_id(parent_id)
524
self.tt.adjust_path(winner_entry[name_winner].name, parent_trans_id,
527
def merge_contents(self, file_id):
528
"""Performa a merge on file_id contents."""
529
def contents_pair(tree):
530
if file_id not in tree:
532
kind = tree.kind(file_id)
534
contents = tree.get_file_sha1(file_id)
535
elif kind == "symlink":
536
contents = tree.get_symlink_target(file_id)
539
return kind, contents
541
def contents_conflict():
542
trans_id = self.tt.trans_id_file_id(file_id)
543
name = self.tt.final_name(trans_id)
544
parent_id = self.tt.final_parent(trans_id)
545
if file_id in self.this_tree.inventory:
546
self.tt.unversion_file(trans_id)
547
self.tt.delete_contents(trans_id)
548
file_group = self._dump_conflicts(name, parent_id, file_id,
550
self._raw_conflicts.append(('contents conflict', file_group))
552
# See SPOT run. run, SPOT, run.
553
# So we're not QUITE repeating ourselves; we do tricky things with
555
base_pair = contents_pair(self.base_tree)
556
other_pair = contents_pair(self.other_tree)
557
if base_pair == other_pair:
558
# OTHER introduced no changes
560
this_pair = contents_pair(self.this_tree)
561
if this_pair == other_pair:
562
# THIS and OTHER introduced the same changes
565
trans_id = self.tt.trans_id_file_id(file_id)
566
if this_pair == base_pair:
567
# only OTHER introduced changes
568
if file_id in self.this_tree:
569
# Remove any existing contents
570
self.tt.delete_contents(trans_id)
571
if file_id in self.other_tree:
572
# OTHER changed the file
573
create_by_entry(self.tt,
574
self.other_tree.inventory[file_id],
575
self.other_tree, trans_id)
576
if file_id not in self.this_tree.inventory:
577
self.tt.version_file(file_id, trans_id)
579
elif file_id in self.this_tree.inventory:
580
# OTHER deleted the file
581
self.tt.unversion_file(trans_id)
583
#BOTH THIS and OTHER introduced changes; scalar conflict
584
elif this_pair[0] == "file" and other_pair[0] == "file":
585
# THIS and OTHER are both files, so text merge. Either
586
# BASE is a file, or both converted to files, so at least we
587
# have agreement that output should be a file.
589
self.text_merge(file_id, trans_id)
591
return contents_conflict()
592
if file_id not in self.this_tree.inventory:
593
self.tt.version_file(file_id, trans_id)
595
self.tt.tree_kind(trans_id)
596
self.tt.delete_contents(trans_id)
601
# Scalar conflict, can't text merge. Dump conflicts
602
return contents_conflict()
604
def get_lines(self, tree, file_id):
605
"""Return the lines in a file, or an empty list."""
607
return tree.get_file(file_id).readlines()
611
def text_merge(self, file_id, trans_id):
612
"""Perform a three-way text merge on a file_id"""
613
# it's possible that we got here with base as a different type.
614
# if so, we just want two-way text conflicts.
615
if file_id in self.base_tree and \
616
self.base_tree.kind(file_id) == "file":
617
base_lines = self.get_lines(self.base_tree, file_id)
620
other_lines = self.get_lines(self.other_tree, file_id)
621
this_lines = self.get_lines(self.this_tree, file_id)
622
m3 = Merge3(base_lines, this_lines, other_lines)
623
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
624
if self.show_base is True:
625
base_marker = '|' * 7
629
def iter_merge3(retval):
630
retval["text_conflicts"] = False
631
for line in m3.merge_lines(name_a = "TREE",
632
name_b = "MERGE-SOURCE",
633
name_base = "BASE-REVISION",
634
start_marker=start_marker,
635
base_marker=base_marker,
636
reprocess=self.reprocess):
637
if line.startswith(start_marker):
638
retval["text_conflicts"] = True
639
yield line.replace(start_marker, '<' * 7)
643
merge3_iterator = iter_merge3(retval)
644
self.tt.create_file(merge3_iterator, trans_id)
645
if retval["text_conflicts"] is True:
646
self._raw_conflicts.append(('text conflict', trans_id))
647
name = self.tt.final_name(trans_id)
648
parent_id = self.tt.final_parent(trans_id)
649
file_group = self._dump_conflicts(name, parent_id, file_id,
650
this_lines, base_lines,
652
file_group.append(trans_id)
654
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
655
base_lines=None, other_lines=None, set_version=False,
657
"""Emit conflict files.
658
If this_lines, base_lines, or other_lines are omitted, they will be
659
determined automatically. If set_version is true, the .OTHER, .THIS
660
or .BASE (in that order) will be created as versioned files.
662
data = [('OTHER', self.other_tree, other_lines),
663
('THIS', self.this_tree, this_lines)]
665
data.append(('BASE', self.base_tree, base_lines))
668
for suffix, tree, lines in data:
670
trans_id = self._conflict_file(name, parent_id, tree, file_id,
672
file_group.append(trans_id)
673
if set_version and not versioned:
674
self.tt.version_file(file_id, trans_id)
678
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
680
"""Emit a single conflict file."""
681
name = name + '.' + suffix
682
trans_id = self.tt.create_path(name, parent_id)
683
entry = tree.inventory[file_id]
684
create_by_entry(self.tt, entry, tree, trans_id, lines)
687
def merge_executable(self, file_id, file_status):
688
"""Perform a merge on the execute bit."""
689
if file_status == "deleted":
691
trans_id = self.tt.trans_id_file_id(file_id)
693
if self.tt.final_kind(trans_id) != "file":
697
winner = self.scalar_three_way(self.this_tree, self.base_tree,
698
self.other_tree, file_id,
700
if winner == "conflict":
701
# There must be a None in here, if we have a conflict, but we
702
# need executability since file status was not deleted.
703
if self.executable(self.other_tree, file_id) is None:
708
if file_status == "modified":
709
executability = self.this_tree.is_executable(file_id)
710
if executability is not None:
711
trans_id = self.tt.trans_id_file_id(file_id)
712
self.tt.set_executability(executability, trans_id)
714
assert winner == "other"
715
if file_id in self.other_tree:
716
executability = self.other_tree.is_executable(file_id)
717
elif file_id in self.this_tree:
718
executability = self.this_tree.is_executable(file_id)
719
elif file_id in self.base_tree:
720
executability = self.base_tree.is_executable(file_id)
721
if executability is not None:
722
trans_id = self.tt.trans_id_file_id(file_id)
723
self.tt.set_executability(executability, trans_id)
725
def cook_conflicts(self, fs_conflicts):
726
"""Convert all conflicts into a form that doesn't depend on trans_id"""
727
from conflicts import Conflict
729
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
730
fp = FinalPaths(self.tt)
731
for conflict in self._raw_conflicts:
732
conflict_type = conflict[0]
733
if conflict_type in ('name conflict', 'parent conflict'):
734
trans_id = conflict[1]
735
conflict_args = conflict[2:]
736
if trans_id not in name_conflicts:
737
name_conflicts[trans_id] = {}
738
unique_add(name_conflicts[trans_id], conflict_type,
740
if conflict_type == 'contents conflict':
741
for trans_id in conflict[1]:
742
file_id = self.tt.final_file_id(trans_id)
743
if file_id is not None:
745
path = fp.get_path(trans_id)
746
for suffix in ('.BASE', '.THIS', '.OTHER'):
747
if path.endswith(suffix):
748
path = path[:-len(suffix)]
750
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
751
self.cooked_conflicts.append(c)
752
if conflict_type == 'text conflict':
753
trans_id = conflict[1]
754
path = fp.get_path(trans_id)
755
file_id = self.tt.final_file_id(trans_id)
756
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
757
self.cooked_conflicts.append(c)
759
for trans_id, conflicts in name_conflicts.iteritems():
761
this_parent, other_parent = conflicts['parent conflict']
762
assert this_parent != other_parent
764
this_parent = other_parent = \
765
self.tt.final_file_id(self.tt.final_parent(trans_id))
767
this_name, other_name = conflicts['name conflict']
768
assert this_name != other_name
770
this_name = other_name = self.tt.final_name(trans_id)
771
other_path = fp.get_path(trans_id)
772
if this_parent is not None:
774
fp.get_path(self.tt.trans_id_file_id(this_parent))
775
this_path = pathjoin(this_parent_path, this_name)
777
this_path = "<deleted>"
778
file_id = self.tt.final_file_id(trans_id)
779
c = Conflict.factory('path conflict', path=this_path,
780
conflict_path=other_path, file_id=file_id)
781
self.cooked_conflicts.append(c)
782
self.cooked_conflicts.sort(key=Conflict.sort_key)
785
class WeaveMerger(Merge3Merger):
786
"""Three-way tree merger, text weave merger."""
787
supports_reprocess = True
788
supports_show_base = False
790
def __init__(self, working_tree, this_tree, base_tree, other_tree,
791
interesting_ids=None, pb=DummyProgress(), pp=None,
793
self.this_revision_tree = self._get_revision_tree(this_tree)
794
self.other_revision_tree = self._get_revision_tree(other_tree)
795
super(WeaveMerger, self).__init__(working_tree, this_tree,
796
base_tree, other_tree,
797
interesting_ids=interesting_ids,
798
pb=pb, pp=pp, reprocess=reprocess)
800
def _get_revision_tree(self, tree):
801
"""Return a revision tree related to this tree.
802
If the tree is a WorkingTree, the basis will be returned.
804
if getattr(tree, 'get_weave', False) is False:
805
# If we have a WorkingTree, try using the basis
806
return tree.branch.basis_tree()
810
def _check_file(self, file_id):
811
"""Check that the revision tree's version of the file matches."""
812
for tree, rt in ((self.this_tree, self.this_revision_tree),
813
(self.other_tree, self.other_revision_tree)):
816
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
817
raise WorkingTreeNotRevision(self.this_tree)
819
def _merged_lines(self, file_id):
820
"""Generate the merged lines.
821
There is no distinction between lines that are meant to contain <<<<<<<
824
weave = self.this_revision_tree.get_weave(file_id)
825
this_revision_id = self.this_revision_tree.inventory[file_id].revision
826
other_revision_id = \
827
self.other_revision_tree.inventory[file_id].revision
828
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
829
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
830
return wm.merge_lines(self.reprocess)
832
def text_merge(self, file_id, trans_id):
833
"""Perform a (weave) text merge for a given file and file-id.
834
If conflicts are encountered, .THIS and .OTHER files will be emitted,
835
and a conflict will be noted.
837
self._check_file(file_id)
838
lines, conflicts = self._merged_lines(file_id)
840
# Note we're checking whether the OUTPUT is binary in this case,
841
# because we don't want to get into weave merge guts.
842
check_text_lines(lines)
843
self.tt.create_file(lines, trans_id)
845
self._raw_conflicts.append(('text conflict', trans_id))
846
name = self.tt.final_name(trans_id)
847
parent_id = self.tt.final_parent(trans_id)
848
file_group = self._dump_conflicts(name, parent_id, file_id,
850
file_group.append(trans_id)
853
class Diff3Merger(Merge3Merger):
854
"""Three-way merger using external diff3 for text merging"""
856
def dump_file(self, temp_dir, name, tree, file_id):
857
out_path = pathjoin(temp_dir, name)
858
out_file = open(out_path, "wb")
860
in_file = tree.get_file(file_id)
867
def text_merge(self, file_id, trans_id):
868
"""Perform a diff3 merge using a specified file-id and trans-id.
869
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
870
will be dumped, and a will be conflict noted.
873
temp_dir = osutils.mkdtemp(prefix="bzr-")
875
new_file = pathjoin(temp_dir, "new")
876
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
877
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
878
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
879
status = bzrlib.patch.diff3(new_file, this, base, other)
880
if status not in (0, 1):
881
raise BzrError("Unhandled diff3 exit code")
882
f = open(new_file, 'rb')
884
self.tt.create_file(f, trans_id)
888
name = self.tt.final_name(trans_id)
889
parent_id = self.tt.final_parent(trans_id)
890
self._dump_conflicts(name, parent_id, file_id)
891
self._raw_conflicts.append(('text conflict', trans_id))
893
osutils.rmtree(temp_dir)
896
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
898
merge_type=Merge3Merger,
899
interesting_ids=None,
903
interesting_files=None,
906
"""Primary interface for merging.
908
typical use is probably
909
'merge_inner(branch, branch.get_revision_tree(other_revision),
910
branch.get_revision_tree(base_revision))'
912
if this_tree is None:
913
warnings.warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
914
"bzrlib version 0.8.",
917
this_tree = this_branch.bzrdir.open_workingtree()
918
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
920
merger.backup_files = backup_files
921
merger.merge_type = merge_type
922
merger.interesting_ids = interesting_ids
923
merger.ignore_zero = ignore_zero
924
if interesting_files:
925
assert not interesting_ids, ('Only supply interesting_ids'
926
' or interesting_files')
927
merger._set_interesting_files(interesting_files)
928
merger.show_base = show_base
929
merger.reprocess = reprocess
930
merger.other_rev_id = other_rev_id
931
merger.other_basis = other_rev_id
932
return merger.do_merge()
935
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
936
"diff3": (Diff3Merger, "Merge using external diff3"),
937
'weave': (WeaveMerger, "Weave-based merge")
941
def merge_type_help():
942
templ = '%s%%7s: %%s' % (' '*12)
943
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
944
return '\n'.join(lines)
added
removed
bzrlib/merge.py
