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.conflicts import ConflictList, Conflict
26
from bzrlib.delta import compare_trees
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.symbol_versioning import *
46
from bzrlib.textfile import check_text_lines
47
from bzrlib.trace import mutter, warning, note
48
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
49
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):
142
if self.this_basis is None:
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)
209
def set_base(self, base_revision):
210
mutter("doing merge() with no base_revision specified")
211
if base_revision == [None, None]:
213
pb = bzrlib.ui.ui_factory.nested_progress_bar()
215
this_repo = self.this_branch.repository
216
self.base_rev_id = common_ancestor(self.this_basis,
221
except NoCommonAncestor:
222
raise UnrelatedBranches()
223
self.base_tree = _get_revid_tree(self.this_branch, self.base_rev_id,
225
self.base_is_ancestor = True
227
base_branch, self.base_tree = _get_tree(base_revision)
228
if base_revision[1] == -1:
229
self.base_rev_id = base_branch.last_revision()
230
elif base_revision[1] is None:
231
self.base_rev_id = None
233
self.base_rev_id = base_branch.get_rev_id(base_revision[1])
234
if self.this_branch.base != base_branch.base:
235
self.this_branch.fetch(base_branch)
236
self.base_is_ancestor = is_ancestor(self.this_basis,
241
kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
242
'other_tree': self.other_tree,
243
'interesting_ids': self.interesting_ids,
245
if self.merge_type.requires_base:
246
kwargs['base_tree'] = self.base_tree
247
if self.merge_type.supports_reprocess:
248
kwargs['reprocess'] = self.reprocess
250
raise BzrError("Conflict reduction is not supported for merge"
251
" type %s." % self.merge_type)
252
if self.merge_type.supports_show_base:
253
kwargs['show_base'] = self.show_base
255
raise BzrError("Showing base is not supported for this"
256
" merge type. %s" % self.merge_type)
257
merge = self.merge_type(pb=self._pb, **kwargs)
258
if len(merge.cooked_conflicts) == 0:
259
if not self.ignore_zero:
260
note("All changes applied successfully.")
262
note("%d conflicts encountered." % len(merge.cooked_conflicts))
264
return len(merge.cooked_conflicts)
266
def regen_inventory(self, new_entries):
267
old_entries = self.this_tree.read_working_inventory()
271
for path, file_id in new_entries:
274
new_entries_map[file_id] = path
276
def id2path(file_id):
277
path = new_entries_map.get(file_id)
280
entry = old_entries[file_id]
281
if entry.parent_id is None:
283
return pathjoin(id2path(entry.parent_id), entry.name)
285
for file_id in old_entries:
286
entry = old_entries[file_id]
287
path = id2path(file_id)
288
if file_id in self.base_tree.inventory:
289
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
291
executable = getattr(entry, 'executable', False)
292
new_inventory[file_id] = (path, file_id, entry.parent_id,
293
entry.kind, executable)
295
by_path[path] = file_id
300
for path, file_id in new_entries:
302
del new_inventory[file_id]
305
new_path_list.append((path, file_id))
306
if file_id not in old_entries:
308
# Ensure no file is added before its parent
310
for path, file_id in new_path_list:
314
parent = by_path[os.path.dirname(path)]
315
abspath = pathjoin(self.this_tree.basedir, path)
316
kind = bzrlib.osutils.file_kind(abspath)
317
if file_id in self.base_tree.inventory:
318
executable = getattr(self.base_tree.inventory[file_id], 'executable', False)
321
new_inventory[file_id] = (path, file_id, parent, kind, executable)
322
by_path[path] = file_id
324
# Get a list in insertion order
325
new_inventory_list = new_inventory.values()
326
mutter ("""Inventory regeneration:
327
old length: %i insertions: %i deletions: %i new_length: %i"""\
328
% (len(old_entries), insertions, deletions,
329
len(new_inventory_list)))
330
assert len(new_inventory_list) == len(old_entries) + insertions\
332
new_inventory_list.sort()
333
return new_inventory_list
336
class Merge3Merger(object):
337
"""Three-way merger that uses the merge3 text merger"""
339
supports_reprocess = True
340
supports_show_base = True
341
history_based = False
343
def __init__(self, working_tree, this_tree, base_tree, other_tree,
344
interesting_ids=None, reprocess=False, show_base=False,
345
pb=DummyProgress(), pp=None):
346
"""Initialize the merger object and perform the merge."""
347
object.__init__(self)
348
self.this_tree = working_tree
349
self.base_tree = base_tree
350
self.other_tree = other_tree
351
self._raw_conflicts = []
352
self.cooked_conflicts = []
353
self.reprocess = reprocess
354
self.show_base = show_base
358
self.pp = ProgressPhase("Merge phase", 3, self.pb)
360
if interesting_ids is not None:
361
all_ids = interesting_ids
363
all_ids = set(base_tree)
364
all_ids.update(other_tree)
365
working_tree.lock_write()
366
self.tt = TreeTransform(working_tree, self.pb)
369
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
371
for num, file_id in enumerate(all_ids):
372
child_pb.update('Preparing file merge', num, len(all_ids))
373
self.merge_names(file_id)
374
file_status = self.merge_contents(file_id)
375
self.merge_executable(file_id, file_status)
380
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
382
fs_conflicts = resolve_conflicts(self.tt, child_pb)
385
self.cook_conflicts(fs_conflicts)
386
for conflict in self.cooked_conflicts:
389
results = self.tt.apply()
390
self.write_modified(results)
392
working_tree.set_conflicts(ConflictList(self.cooked_conflicts))
393
except UnsupportedOperation:
400
working_tree.unlock()
403
def write_modified(self, results):
405
for path in results.modified_paths:
406
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
409
hash = self.this_tree.get_file_sha1(file_id)
412
modified_hashes[file_id] = hash
413
self.this_tree.set_merge_modified(modified_hashes)
416
def parent(entry, file_id):
417
"""Determine the parent for a file_id (used as a key method)"""
420
return entry.parent_id
423
def name(entry, file_id):
424
"""Determine the name for a file_id (used as a key method)"""
430
def contents_sha1(tree, file_id):
431
"""Determine the sha1 of the file contents (used as a key method)."""
432
if file_id not in tree:
434
return tree.get_file_sha1(file_id)
437
def executable(tree, file_id):
438
"""Determine the executability of a file-id (used as a key method)."""
439
if file_id not in tree:
441
if tree.kind(file_id) != "file":
443
return tree.is_executable(file_id)
446
def kind(tree, file_id):
447
"""Determine the kind of a file-id (used as a key method)."""
448
if file_id not in tree:
450
return tree.kind(file_id)
453
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
454
"""Do a three-way test on a scalar.
455
Return "this", "other" or "conflict", depending whether a value wins.
457
key_base = key(base_tree, file_id)
458
key_other = key(other_tree, file_id)
459
#if base == other, either they all agree, or only THIS has changed.
460
if key_base == key_other:
462
key_this = key(this_tree, file_id)
463
if key_this not in (key_base, key_other):
465
# "Ambiguous clean merge"
466
elif key_this == key_other:
469
assert key_this == key_base
472
def merge_names(self, file_id):
473
"""Perform a merge on file_id names and parents"""
475
if file_id in tree.inventory:
476
return tree.inventory[file_id]
479
this_entry = get_entry(self.this_tree)
480
other_entry = get_entry(self.other_tree)
481
base_entry = get_entry(self.base_tree)
482
name_winner = self.scalar_three_way(this_entry, base_entry,
483
other_entry, file_id, self.name)
484
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
485
other_entry, file_id,
487
if this_entry is None:
488
if name_winner == "this":
489
name_winner = "other"
490
if parent_id_winner == "this":
491
parent_id_winner = "other"
492
if name_winner == "this" and parent_id_winner == "this":
494
if name_winner == "conflict":
495
trans_id = self.tt.trans_id_file_id(file_id)
496
self._raw_conflicts.append(('name conflict', trans_id,
497
self.name(this_entry, file_id),
498
self.name(other_entry, file_id)))
499
if parent_id_winner == "conflict":
500
trans_id = self.tt.trans_id_file_id(file_id)
501
self._raw_conflicts.append(('parent conflict', trans_id,
502
self.parent(this_entry, file_id),
503
self.parent(other_entry, file_id)))
504
if other_entry is None:
505
# it doesn't matter whether the result was 'other' or
506
# 'conflict'-- if there's no 'other', we leave it alone.
508
# if we get here, name_winner and parent_winner are set to safe values.
509
winner_entry = {"this": this_entry, "other": other_entry,
510
"conflict": other_entry}
511
trans_id = self.tt.trans_id_file_id(file_id)
512
parent_id = winner_entry[parent_id_winner].parent_id
513
parent_trans_id = self.tt.trans_id_file_id(parent_id)
514
self.tt.adjust_path(winner_entry[name_winner].name, parent_trans_id,
517
def merge_contents(self, file_id):
518
"""Performa a merge on file_id contents."""
519
def contents_pair(tree):
520
if file_id not in tree:
522
kind = tree.kind(file_id)
523
if kind == "root_directory":
526
contents = tree.get_file_sha1(file_id)
527
elif kind == "symlink":
528
contents = tree.get_symlink_target(file_id)
531
return kind, contents
533
def contents_conflict():
534
trans_id = self.tt.trans_id_file_id(file_id)
535
name = self.tt.final_name(trans_id)
536
parent_id = self.tt.final_parent(trans_id)
537
if file_id in self.this_tree.inventory:
538
self.tt.unversion_file(trans_id)
539
self.tt.delete_contents(trans_id)
540
file_group = self._dump_conflicts(name, parent_id, file_id,
542
self._raw_conflicts.append(('contents conflict', file_group))
544
# See SPOT run. run, SPOT, run.
545
# So we're not QUITE repeating ourselves; we do tricky things with
547
base_pair = contents_pair(self.base_tree)
548
other_pair = contents_pair(self.other_tree)
549
if base_pair == other_pair:
550
# OTHER introduced no changes
552
this_pair = contents_pair(self.this_tree)
553
if this_pair == other_pair:
554
# THIS and OTHER introduced the same changes
557
trans_id = self.tt.trans_id_file_id(file_id)
558
if this_pair == base_pair:
559
# only OTHER introduced changes
560
if file_id in self.this_tree:
561
# Remove any existing contents
562
self.tt.delete_contents(trans_id)
563
if file_id in self.other_tree:
564
# OTHER changed the file
565
create_by_entry(self.tt,
566
self.other_tree.inventory[file_id],
567
self.other_tree, trans_id)
568
if file_id not in self.this_tree.inventory:
569
self.tt.version_file(file_id, trans_id)
571
elif file_id in self.this_tree.inventory:
572
# OTHER deleted the file
573
self.tt.unversion_file(trans_id)
575
#BOTH THIS and OTHER introduced changes; scalar conflict
576
elif this_pair[0] == "file" and other_pair[0] == "file":
577
# THIS and OTHER are both files, so text merge. Either
578
# BASE is a file, or both converted to files, so at least we
579
# have agreement that output should be a file.
581
self.text_merge(file_id, trans_id)
583
return contents_conflict()
584
if file_id not in self.this_tree.inventory:
585
self.tt.version_file(file_id, trans_id)
587
self.tt.tree_kind(trans_id)
588
self.tt.delete_contents(trans_id)
593
# Scalar conflict, can't text merge. Dump conflicts
594
return contents_conflict()
596
def get_lines(self, tree, file_id):
597
"""Return the lines in a file, or an empty list."""
599
return tree.get_file(file_id).readlines()
603
def text_merge(self, file_id, trans_id):
604
"""Perform a three-way text merge on a file_id"""
605
# it's possible that we got here with base as a different type.
606
# if so, we just want two-way text conflicts.
607
if file_id in self.base_tree and \
608
self.base_tree.kind(file_id) == "file":
609
base_lines = self.get_lines(self.base_tree, file_id)
612
other_lines = self.get_lines(self.other_tree, file_id)
613
this_lines = self.get_lines(self.this_tree, file_id)
614
m3 = Merge3(base_lines, this_lines, other_lines)
615
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
616
if self.show_base is True:
617
base_marker = '|' * 7
621
def iter_merge3(retval):
622
retval["text_conflicts"] = False
623
for line in m3.merge_lines(name_a = "TREE",
624
name_b = "MERGE-SOURCE",
625
name_base = "BASE-REVISION",
626
start_marker=start_marker,
627
base_marker=base_marker,
628
reprocess=self.reprocess):
629
if line.startswith(start_marker):
630
retval["text_conflicts"] = True
631
yield line.replace(start_marker, '<' * 7)
635
merge3_iterator = iter_merge3(retval)
636
self.tt.create_file(merge3_iterator, trans_id)
637
if retval["text_conflicts"] is True:
638
self._raw_conflicts.append(('text conflict', trans_id))
639
name = self.tt.final_name(trans_id)
640
parent_id = self.tt.final_parent(trans_id)
641
file_group = self._dump_conflicts(name, parent_id, file_id,
642
this_lines, base_lines,
644
file_group.append(trans_id)
646
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
647
base_lines=None, other_lines=None, set_version=False,
649
"""Emit conflict files.
650
If this_lines, base_lines, or other_lines are omitted, they will be
651
determined automatically. If set_version is true, the .OTHER, .THIS
652
or .BASE (in that order) will be created as versioned files.
654
data = [('OTHER', self.other_tree, other_lines),
655
('THIS', self.this_tree, this_lines)]
657
data.append(('BASE', self.base_tree, base_lines))
660
for suffix, tree, lines in data:
662
trans_id = self._conflict_file(name, parent_id, tree, file_id,
664
file_group.append(trans_id)
665
if set_version and not versioned:
666
self.tt.version_file(file_id, trans_id)
670
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
672
"""Emit a single conflict file."""
673
name = name + '.' + suffix
674
trans_id = self.tt.create_path(name, parent_id)
675
entry = tree.inventory[file_id]
676
create_by_entry(self.tt, entry, tree, trans_id, lines)
679
def merge_executable(self, file_id, file_status):
680
"""Perform a merge on the execute bit."""
681
if file_status == "deleted":
683
trans_id = self.tt.trans_id_file_id(file_id)
685
if self.tt.final_kind(trans_id) != "file":
689
winner = self.scalar_three_way(self.this_tree, self.base_tree,
690
self.other_tree, file_id,
692
if winner == "conflict":
693
# There must be a None in here, if we have a conflict, but we
694
# need executability since file status was not deleted.
695
if self.other_tree.is_executable(file_id) is None:
700
if file_status == "modified":
701
executability = self.this_tree.is_executable(file_id)
702
if executability is not None:
703
trans_id = self.tt.trans_id_file_id(file_id)
704
self.tt.set_executability(executability, trans_id)
706
assert winner == "other"
707
if file_id in self.other_tree:
708
executability = self.other_tree.is_executable(file_id)
709
elif file_id in self.this_tree:
710
executability = self.this_tree.is_executable(file_id)
711
elif file_id in self.base_tree:
712
executability = self.base_tree.is_executable(file_id)
713
if executability is not None:
714
trans_id = self.tt.trans_id_file_id(file_id)
715
self.tt.set_executability(executability, trans_id)
717
def cook_conflicts(self, fs_conflicts):
718
"""Convert all conflicts into a form that doesn't depend on trans_id"""
719
from conflicts import Conflict
721
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
722
fp = FinalPaths(self.tt)
723
for conflict in self._raw_conflicts:
724
conflict_type = conflict[0]
725
if conflict_type in ('name conflict', 'parent conflict'):
726
trans_id = conflict[1]
727
conflict_args = conflict[2:]
728
if trans_id not in name_conflicts:
729
name_conflicts[trans_id] = {}
730
unique_add(name_conflicts[trans_id], conflict_type,
732
if conflict_type == 'contents conflict':
733
for trans_id in conflict[1]:
734
file_id = self.tt.final_file_id(trans_id)
735
if file_id is not None:
737
path = fp.get_path(trans_id)
738
for suffix in ('.BASE', '.THIS', '.OTHER'):
739
if path.endswith(suffix):
740
path = path[:-len(suffix)]
742
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
743
self.cooked_conflicts.append(c)
744
if conflict_type == 'text conflict':
745
trans_id = conflict[1]
746
path = fp.get_path(trans_id)
747
file_id = self.tt.final_file_id(trans_id)
748
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
749
self.cooked_conflicts.append(c)
751
for trans_id, conflicts in name_conflicts.iteritems():
753
this_parent, other_parent = conflicts['parent conflict']
754
assert this_parent != other_parent
756
this_parent = other_parent = \
757
self.tt.final_file_id(self.tt.final_parent(trans_id))
759
this_name, other_name = conflicts['name conflict']
760
assert this_name != other_name
762
this_name = other_name = self.tt.final_name(trans_id)
763
other_path = fp.get_path(trans_id)
764
if this_parent is not None:
766
fp.get_path(self.tt.trans_id_file_id(this_parent))
767
this_path = pathjoin(this_parent_path, this_name)
769
this_path = "<deleted>"
770
file_id = self.tt.final_file_id(trans_id)
771
c = Conflict.factory('path conflict', path=this_path,
772
conflict_path=other_path, file_id=file_id)
773
self.cooked_conflicts.append(c)
774
self.cooked_conflicts.sort(key=Conflict.sort_key)
777
class WeaveMerger(Merge3Merger):
778
"""Three-way tree merger, text weave merger."""
779
supports_reprocess = True
780
supports_show_base = False
782
def __init__(self, working_tree, this_tree, base_tree, other_tree,
783
interesting_ids=None, pb=DummyProgress(), pp=None,
785
self.this_revision_tree = self._get_revision_tree(this_tree)
786
self.other_revision_tree = self._get_revision_tree(other_tree)
787
super(WeaveMerger, self).__init__(working_tree, this_tree,
788
base_tree, other_tree,
789
interesting_ids=interesting_ids,
790
pb=pb, pp=pp, reprocess=reprocess)
792
def _get_revision_tree(self, tree):
793
"""Return a revision tree releated to this tree.
794
If the tree is a WorkingTree, the basis will be returned.
796
if getattr(tree, 'get_weave', False) is False:
797
# If we have a WorkingTree, try using the basis
798
return tree.branch.basis_tree()
802
def _check_file(self, file_id):
803
"""Check that the revision tree's version of the file matches."""
804
for tree, rt in ((self.this_tree, self.this_revision_tree),
805
(self.other_tree, self.other_revision_tree)):
808
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
809
raise WorkingTreeNotRevision(self.this_tree)
811
def _merged_lines(self, file_id):
812
"""Generate the merged lines.
813
There is no distinction between lines that are meant to contain <<<<<<<
816
weave = self.this_revision_tree.get_weave(file_id)
817
this_revision_id = self.this_revision_tree.inventory[file_id].revision
818
other_revision_id = \
819
self.other_revision_tree.inventory[file_id].revision
820
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
821
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
822
return wm.merge_lines(self.reprocess)
824
def text_merge(self, file_id, trans_id):
825
"""Perform a (weave) text merge for a given file and file-id.
826
If conflicts are encountered, .THIS and .OTHER files will be emitted,
827
and a conflict will be noted.
829
self._check_file(file_id)
830
lines, conflicts = self._merged_lines(file_id)
832
# Note we're checking whether the OUTPUT is binary in this case,
833
# because we don't want to get into weave merge guts.
834
check_text_lines(lines)
835
self.tt.create_file(lines, trans_id)
837
self._raw_conflicts.append(('text conflict', trans_id))
838
name = self.tt.final_name(trans_id)
839
parent_id = self.tt.final_parent(trans_id)
840
file_group = self._dump_conflicts(name, parent_id, file_id,
842
file_group.append(trans_id)
845
class Diff3Merger(Merge3Merger):
846
"""Three-way merger using external diff3 for text merging"""
847
def dump_file(self, temp_dir, name, tree, file_id):
848
out_path = pathjoin(temp_dir, name)
849
out_file = file(out_path, "wb")
850
in_file = tree.get_file(file_id)
855
def text_merge(self, file_id, trans_id):
856
"""Perform a diff3 merge using a specified file-id and trans-id.
857
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
858
will be dumped, and a will be conflict noted.
861
temp_dir = mkdtemp(prefix="bzr-")
863
new_file = pathjoin(temp_dir, "new")
864
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
865
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
866
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
867
status = bzrlib.patch.diff3(new_file, this, base, other)
868
if status not in (0, 1):
869
raise BzrError("Unhandled diff3 exit code")
870
self.tt.create_file(file(new_file, "rb"), trans_id)
872
name = self.tt.final_name(trans_id)
873
parent_id = self.tt.final_parent(trans_id)
874
self._dump_conflicts(name, parent_id, file_id)
875
self._raw_conflicts.append(('text conflict', trans_id))
880
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
882
merge_type=Merge3Merger,
883
interesting_ids=None,
887
interesting_files=None,
890
"""Primary interface for merging.
892
typical use is probably
893
'merge_inner(branch, branch.get_revision_tree(other_revision),
894
branch.get_revision_tree(base_revision))'
896
if this_tree is None:
897
warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
898
"bzrlib version 0.8.",
901
this_tree = this_branch.bzrdir.open_workingtree()
902
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
904
merger.backup_files = backup_files
905
merger.merge_type = merge_type
906
merger.interesting_ids = interesting_ids
907
merger.ignore_zero = ignore_zero
908
if interesting_files:
909
assert not interesting_ids, ('Only supply interesting_ids'
910
' or interesting_files')
911
merger._set_interesting_files(interesting_files)
912
merger.show_base = show_base
913
merger.reprocess = reprocess
914
merger.other_rev_id = other_rev_id
915
merger.other_basis = other_rev_id
916
return merger.do_merge()
919
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
920
"diff3": (Diff3Merger, "Merge using external diff3"),
921
'weave': (WeaveMerger, "Weave-based merge")
added
removed
bzrlib/merge.py
