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
41
from bzrlib.osutils import rename, pathjoin
42
from progress import DummyProgress, ProgressPhase
43
from bzrlib.revision import common_ancestor, is_ancestor, NULL_REVISION
44
from bzrlib.textfile import check_text_lines
45
from bzrlib.trace import mutter, warning, note
46
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
47
FinalPaths, create_by_entry, unique_add,
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 = 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 = 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_tree_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()
415
self.tt.final_kind(self.tt.root)
417
self.tt.cancel_deletion(self.tt.root)
418
if self.tt.final_file_id(self.tt.root) is None:
419
self.tt.version_file(self.tt.tree_file_id(self.tt.root),
421
if self.other_tree.inventory.root is None:
423
other_root_file_id = self.other_tree.inventory.root.file_id
424
other_root = self.tt.trans_id_file_id(other_root_file_id)
425
if other_root == self.tt.root:
428
self.tt.final_kind(other_root)
431
self.reparent_children(self.other_tree.inventory.root, self.tt.root)
432
self.tt.cancel_creation(other_root)
433
self.tt.cancel_versioning(other_root)
435
def reparent_children(self, ie, target):
436
for thing, child in ie.children.iteritems():
437
trans_id = self.tt.trans_id_file_id(child.file_id)
438
self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
440
def write_modified(self, results):
442
for path in results.modified_paths:
443
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
446
hash = self.this_tree.get_file_sha1(file_id)
449
modified_hashes[file_id] = hash
450
self.this_tree.set_merge_modified(modified_hashes)
453
def parent(entry, file_id):
454
"""Determine the parent for a file_id (used as a key method)"""
457
return entry.parent_id
460
def name(entry, file_id):
461
"""Determine the name for a file_id (used as a key method)"""
467
def contents_sha1(tree, file_id):
468
"""Determine the sha1 of the file contents (used as a key method)."""
469
if file_id not in tree:
471
return tree.get_file_sha1(file_id)
474
def executable(tree, file_id):
475
"""Determine the executability of a file-id (used as a key method)."""
476
if file_id not in tree:
478
if tree.kind(file_id) != "file":
480
return tree.is_executable(file_id)
483
def kind(tree, file_id):
484
"""Determine the kind of a file-id (used as a key method)."""
485
if file_id not in tree:
487
return tree.kind(file_id)
490
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
491
"""Do a three-way test on a scalar.
492
Return "this", "other" or "conflict", depending whether a value wins.
494
key_base = key(base_tree, file_id)
495
key_other = key(other_tree, file_id)
496
#if base == other, either they all agree, or only THIS has changed.
497
if key_base == key_other:
499
key_this = key(this_tree, file_id)
500
if key_this not in (key_base, key_other):
502
# "Ambiguous clean merge"
503
elif key_this == key_other:
506
assert key_this == key_base
509
def merge_names(self, file_id):
510
"""Perform a merge on file_id names and parents"""
512
if file_id in tree.inventory:
513
return tree.inventory[file_id]
516
this_entry = get_entry(self.this_tree)
517
other_entry = get_entry(self.other_tree)
518
base_entry = get_entry(self.base_tree)
519
name_winner = self.scalar_three_way(this_entry, base_entry,
520
other_entry, file_id, self.name)
521
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
522
other_entry, file_id,
524
if this_entry is None:
525
if name_winner == "this":
526
name_winner = "other"
527
if parent_id_winner == "this":
528
parent_id_winner = "other"
529
if name_winner == "this" and parent_id_winner == "this":
531
if name_winner == "conflict":
532
trans_id = self.tt.trans_id_file_id(file_id)
533
self._raw_conflicts.append(('name conflict', trans_id,
534
self.name(this_entry, file_id),
535
self.name(other_entry, file_id)))
536
if parent_id_winner == "conflict":
537
trans_id = self.tt.trans_id_file_id(file_id)
538
self._raw_conflicts.append(('parent conflict', trans_id,
539
self.parent(this_entry, file_id),
540
self.parent(other_entry, file_id)))
541
if other_entry is None:
542
# it doesn't matter whether the result was 'other' or
543
# 'conflict'-- if there's no 'other', we leave it alone.
545
# if we get here, name_winner and parent_winner are set to safe values.
546
winner_entry = {"this": this_entry, "other": other_entry,
547
"conflict": other_entry}
548
trans_id = self.tt.trans_id_file_id(file_id)
549
parent_id = winner_entry[parent_id_winner].parent_id
550
if parent_id is not None:
551
parent_trans_id = self.tt.trans_id_file_id(parent_id)
552
self.tt.adjust_path(winner_entry[name_winner].name,
553
parent_trans_id, trans_id)
555
def merge_contents(self, file_id):
556
"""Performa a merge on file_id contents."""
557
def contents_pair(tree):
558
if file_id not in tree:
560
kind = tree.kind(file_id)
562
contents = tree.get_file_sha1(file_id)
563
elif kind == "symlink":
564
contents = tree.get_symlink_target(file_id)
567
return kind, contents
569
def contents_conflict():
570
trans_id = self.tt.trans_id_file_id(file_id)
571
name = self.tt.final_name(trans_id)
572
parent_id = self.tt.final_parent(trans_id)
573
if file_id in self.this_tree.inventory:
574
self.tt.unversion_file(trans_id)
575
if file_id in self.this_tree:
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
