1
# Copyright (C) 2005, 2006 Canonical Ltd
1
# Copyright (C) 2005 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
from tempfile import mkdtemp
24
import bzrlib.revision
25
from bzrlib.merge_core import merge_flex, ApplyMerge3, BackupBeforeChange
26
from bzrlib.merge_core import WeaveMerge
27
from bzrlib.changeset import generate_changeset, ExceptionConflictHandler
28
from bzrlib.changeset import Inventory, Diff3Merge, ReplaceContents
23
29
from bzrlib.branch import Branch
24
from bzrlib.conflicts import ConflictList, Conflict
25
from bzrlib.delta import compare_trees
26
30
from bzrlib.errors import (BzrCommandError,
34
WorkingTreeNotRevision,
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.textfile import check_text_lines
37
from bzrlib.delta import compare_trees
45
38
from bzrlib.trace import mutter, warning, note
46
from bzrlib.transform import (TreeTransform, resolve_conflicts, cook_conflicts,
47
FinalPaths, create_by_entry, unique_add)
48
from bzrlib.versionedfile import WeaveMerge
39
from bzrlib.fetch import greedy_fetch, fetch
40
from bzrlib.revision import is_ancestor, NULL_REVISION
41
from bzrlib.osutils import rename
42
from bzrlib.revision import common_ancestor, MultipleRevisionSources
43
from bzrlib.errors import NoSuchRevision
51
45
# TODO: Report back as changes are merged in
53
def _get_tree(treespec, local_branch=None):
47
# TODO: build_working_dir can be built on something simpler than merge()
49
# FIXME: merge() parameters seem oriented towards the command line
50
# NOTABUG: merge is a helper for commandline functions. merge_inner is the
51
# the core functionality.
53
# comments from abentley on irc: merge happens in two stages, each
54
# of which generates a changeset object
56
# stage 1: generate OLD->OTHER,
57
# stage 2: use MINE and OLD->OTHER to generate MINE -> RESULT
59
class MergeConflictHandler(ExceptionConflictHandler):
60
"""Handle conflicts encountered while merging.
62
This subclasses ExceptionConflictHandler, so that any types of
63
conflict that are not explicitly handled cause an exception and
66
def __init__(self, this_tree, base_tree, other_tree, ignore_zero=False):
67
ExceptionConflictHandler.__init__(self)
69
self.ignore_zero = ignore_zero
70
self.this_tree = this_tree
71
self.base_tree = base_tree
72
self.other_tree = other_tree
74
def copy(self, source, dest):
75
"""Copy the text and mode of a file
76
:param source: The path of the file to copy
77
:param dest: The distination file to create
79
s_file = file(source, "rb")
80
d_file = file(dest, "wb")
83
os.chmod(dest, 0777 & os.stat(source).st_mode)
85
def dump(self, lines, dest):
86
"""Copy the text and mode of a file
87
:param source: The path of the file to copy
88
:param dest: The distination file to create
90
d_file = file(dest, "wb")
94
def add_suffix(self, name, suffix, last_new_name=None, fix_inventory=True):
95
"""Rename a file to append a suffix. If the new name exists, the
96
suffix is added repeatedly until a non-existant name is found
98
:param name: The path of the file
99
:param suffix: The suffix to append
100
:param last_new_name: (used for recursive calls) the last name tried
102
if last_new_name is None:
104
new_name = last_new_name+suffix
106
rename(name, new_name)
107
if fix_inventory is True:
109
relpath = self.this_tree.relpath(name)
110
except NotBranchError:
112
if relpath is not None:
113
file_id = self.this_tree.path2id(relpath)
114
if file_id is not None:
115
new_path = self.this_tree.relpath(new_name)
116
rename(new_name, name)
117
self.this_tree.branch.rename_one(relpath, new_path)
118
assert self.this_tree.id2path(file_id) == relpath
119
self.this_tree._inventory = self.this_tree.read_working_inventory()
120
assert self.this_tree.id2path(file_id) == new_path
122
if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
124
return self.add_suffix(name, suffix, last_new_name=new_name,
125
fix_inventory=fix_inventory)
128
def conflict(self, text):
133
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
135
Handle diff3 conflicts by producing a .THIS, .BASE and .OTHER. The
136
main file will be a version with diff3 conflicts.
137
:param new_file: Path to the output file with diff3 markers
138
:param this_path: Path to the file text for the THIS tree
139
:param base_path: Path to the file text for the BASE tree
140
:param other_path: Path to the file text for the OTHER tree
142
self.add_suffix(this_path, ".THIS", fix_inventory=False)
143
self.dump(base_lines, this_path+".BASE")
144
self.dump(other_lines, this_path+".OTHER")
145
rename(new_file, this_path)
146
self.conflict("Diff3 conflict encountered in %s" % this_path)
148
def weave_merge_conflict(self, filename, weave, other_i, out_file):
150
Handle weave conflicts by producing a .THIS, and .OTHER. The
151
main file will be a version with diff3-style conflicts.
153
self.add_suffix(filename, ".THIS")
155
self.dump(weave.get_iter(other_i), filename+".OTHER")
156
self.conflict("Text conflict encountered in %s" % filename)
158
def new_contents_conflict(self, filename, other_contents):
159
"""Conflicting contents for newly added file."""
160
other_contents(filename + ".OTHER", self, False)
161
self.conflict("Conflict in newly added file %s" % filename)
164
def target_exists(self, entry, target, old_path):
165
"""Handle the case when the target file or dir exists"""
166
moved_path = self.add_suffix(target, ".moved")
167
self.conflict("Moved existing %s to %s" % (target, moved_path))
169
def rmdir_non_empty(self, filename):
170
"""Handle the case where the dir to be removed still has contents"""
171
self.conflict("Directory %s not removed because it is not empty"\
175
def rem_contents_conflict(self, filename, this_contents, base_contents):
176
base_contents(filename+".BASE", self, False)
177
this_contents(filename+".THIS", self, False)
178
return ReplaceContents(this_contents, None)
180
def rem_contents_conflict(self, filename, this_contents, base_contents):
181
base_contents(filename+".BASE", self, False)
182
this_contents(filename+".THIS", self, False)
183
self.conflict("Other branch deleted locally modified file %s" %
185
return ReplaceContents(this_contents, None)
187
def abs_this_path(self, file_id):
188
"""Return the absolute path for a file_id in the this tree."""
189
return self.this_tree.id2abspath(file_id)
191
def add_missing_parents(self, file_id, tree):
192
"""If some of the parents for file_id are missing, add them."""
193
entry = tree.inventory[file_id]
194
if entry.parent_id not in self.this_tree:
195
return self.create_all_missing(entry.parent_id, tree)
197
return self.abs_this_path(entry.parent_id)
199
def create_all_missing(self, file_id, tree):
200
"""Add contents for a file_id and all its parents to a tree."""
201
entry = tree.inventory[file_id]
202
if entry.parent_id is not None and entry.parent_id not in self.this_tree:
203
abspath = self.create_all_missing(entry.parent_id, tree)
205
abspath = self.abs_this_path(entry.parent_id)
206
entry_path = os.path.join(abspath, entry.name)
207
if not os.path.isdir(entry_path):
208
self.create(file_id, entry_path, tree)
211
def create(self, file_id, path, tree, reverse=False):
212
"""Uses tree data to create a filesystem object for the file_id"""
213
from changeset import get_contents
214
get_contents(tree, file_id)(path, self, reverse)
216
def missing_for_merge(self, file_id, other_path):
217
"""The file_id doesn't exist in THIS, but does in OTHER and BASE"""
218
self.conflict("Other branch modified locally deleted file %s" %
220
parent_dir = self.add_missing_parents(file_id, self.other_tree)
221
stem = os.path.join(parent_dir, os.path.basename(other_path))
222
self.create(file_id, stem+".OTHER", self.other_tree)
223
self.create(file_id, stem+".BASE", self.base_tree)
225
def threeway_contents_conflict(filename, this_contents, base_contents,
227
self.conflict("Three-way conflict merging %s" % filename)
230
if not self.ignore_zero:
231
note("%d conflicts encountered.\n" % self.conflicts)
233
def get_tree(treespec, local_branch=None):
54
234
location, revno = treespec
55
235
branch = Branch.open_containing(location)[0]
61
241
revision = branch.get_rev_id(revno)
62
242
if revision is None:
63
243
revision = NULL_REVISION
64
return branch, _get_revid_tree(branch, revision, local_branch)
67
def _get_revid_tree(branch, revision, local_branch):
244
return branch, get_revid_tree(branch, revision, local_branch)
246
def get_revid_tree(branch, revision, local_branch):
68
247
if revision is None:
69
base_tree = branch.bzrdir.open_workingtree()
248
base_tree = branch.working_tree()
71
250
if local_branch is not None:
72
if local_branch.base != branch.base:
73
local_branch.fetch(branch, revision)
74
base_tree = local_branch.repository.revision_tree(revision)
251
greedy_fetch(local_branch, branch, revision)
252
base_tree = local_branch.revision_tree(revision)
76
base_tree = branch.repository.revision_tree(revision)
254
base_tree = branch.revision_tree(revision)
80
def transform_tree(from_tree, to_tree, interesting_ids=None):
81
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
82
interesting_ids=interesting_ids, this_tree=from_tree)
258
def file_exists(tree, file_id):
259
return tree.has_filename(tree.id2path(file_id))
262
def build_working_dir(to_dir):
263
"""Build a working directory in an empty directory.
265
to_dir is a directory containing branch metadata but no working files,
266
typically constructed by cloning an existing branch.
268
This is split out as a special idiomatic case of merge. It could
269
eventually be done by just building the tree directly calling into
270
lower-level code (e.g. constructing a changeset).
272
# RBC 20051019 is this not just 'export' ?
273
# AB Well, export doesn't take care of inventory...
274
this_branch = Branch.open_containing(to_dir)[0]
275
transform_tree(this_branch.working_tree(), this_branch.basis_tree())
278
def transform_tree(from_tree, to_tree):
279
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True)
282
def merge(other_revision, base_revision,
283
check_clean=True, ignore_zero=False,
284
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
285
file_list=None, show_base=False, reprocess=False):
286
"""Merge changes into a tree.
289
list(path, revno) Base for three-way merge.
290
If [None, None] then a base will be automatically determined.
292
list(path, revno) Other revision for three-way merge.
294
Directory to merge changes into; '.' by default.
296
If true, this_dir must have no uncommitted changes before the
298
ignore_zero - If true, suppress the "zero conflicts" message when
299
there are no conflicts; should be set when doing something we expect
300
to complete perfectly.
301
file_list - If supplied, merge only changes to selected files.
303
All available ancestors of other_revision and base_revision are
304
automatically pulled into the branch.
306
The revno may be -1 to indicate the last revision on the branch, which is
309
This function is intended for use from the command line; programmatic
310
clients might prefer to call merge_inner(), which has less magic behavior.
314
this_branch = Branch.open_containing(this_dir)[0]
315
if show_base and not merge_type is ApplyMerge3:
316
raise BzrCommandError("Show-base is not supported for this merge"
317
" type. %s" % merge_type)
318
if reprocess and not merge_type is ApplyMerge3:
319
raise BzrCommandError("Reprocess is not supported for this merge"
320
" type. %s" % merge_type)
321
if reprocess and show_base:
322
raise BzrCommandError("Cannot reprocess and show base.")
323
merger = Merger(this_branch)
324
merger.check_basis(check_clean)
325
merger.set_other(other_revision)
326
merger.set_base(base_revision)
327
merger.backup_files = backup_files
328
merger.merge_type = merge_type
329
merger.set_interesting_files(file_list)
330
merger.show_base = show_base
331
merger.reprocess = reprocess
332
merger.conflict_handler = MergeConflictHandler(merger.this_tree,
335
ignore_zero=ignore_zero)
336
conflicts = merger.do_merge()
340
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
341
backup_files=False, merge_type=ApplyMerge3,
342
interesting_ids=None, show_base=False, reprocess=False,
343
interesting_files=None):
344
"""Primary interface for merging.
346
typical use is probably
347
'merge_inner(branch, branch.get_revision_tree(other_revision),
348
branch.get_revision_tree(base_revision))'
350
merger = Merger(this_branch, other_tree, base_tree)
351
merger.backup_files = backup_files
352
merger.merge_type = merge_type
353
merger.interesting_ids = interesting_ids
354
if interesting_files:
355
assert not interesting_ids, ('Only supply interesting_ids'
356
' or interesting_files')
357
merger._set_interesting_files(interesting_files)
358
merger.show_base = show_base
359
merger.reprocess = reprocess
360
merger.conflict_handler = MergeConflictHandler(merger.this_tree, base_tree,
362
ignore_zero=ignore_zero)
363
return merger.do_merge()
85
366
class Merger(object):
86
def __init__(self, this_branch, other_tree=None, base_tree=None,
87
this_tree=None, pb=DummyProgress()):
367
def __init__(self, this_branch, other_tree=None, base_tree=None):
88
368
object.__init__(self)
89
assert this_tree is not None, "this_tree is required"
90
369
self.this_branch = this_branch
91
370
self.this_basis = this_branch.last_revision()
92
371
self.this_rev_id = None
93
self.this_tree = this_tree
372
self.this_tree = this_branch.working_tree()
94
373
self.this_revision_tree = None
95
self.this_basis_tree = None
96
374
self.other_tree = other_tree
97
375
self.base_tree = base_tree
98
376
self.ignore_zero = False
333
607
new_inventory_list.sort()
334
608
return new_inventory_list
337
class Merge3Merger(object):
338
"""Three-way merger that uses the merge3 text merger"""
340
supports_reprocess = True
341
supports_show_base = True
342
history_based = False
344
def __init__(self, working_tree, this_tree, base_tree, other_tree,
345
interesting_ids=None, reprocess=False, show_base=False,
346
pb=DummyProgress(), pp=None):
347
"""Initialize the merger object and perform the merge."""
348
object.__init__(self)
349
self.this_tree = working_tree
350
self.base_tree = base_tree
351
self.other_tree = other_tree
352
self._raw_conflicts = []
353
self.cooked_conflicts = []
354
self.reprocess = reprocess
355
self.show_base = show_base
359
self.pp = ProgressPhase("Merge phase", 3, self.pb)
361
if interesting_ids is not None:
362
all_ids = interesting_ids
364
all_ids = set(base_tree)
365
all_ids.update(other_tree)
366
working_tree.lock_write()
367
self.tt = TreeTransform(working_tree, self.pb)
370
child_pb = ui.ui_factory.nested_progress_bar()
372
for num, file_id in enumerate(all_ids):
373
child_pb.update('Preparing file merge', num, len(all_ids))
374
self.merge_names(file_id)
375
file_status = self.merge_contents(file_id)
376
self.merge_executable(file_id, file_status)
381
child_pb = ui.ui_factory.nested_progress_bar()
383
fs_conflicts = resolve_conflicts(self.tt, child_pb)
386
self.cook_conflicts(fs_conflicts)
387
for conflict in self.cooked_conflicts:
390
results = self.tt.apply()
391
self.write_modified(results)
393
working_tree.set_conflicts(ConflictList(self.cooked_conflicts))
394
except UnsupportedOperation:
401
working_tree.unlock()
404
def write_modified(self, results):
406
for path in results.modified_paths:
407
file_id = self.this_tree.path2id(self.this_tree.relpath(path))
410
hash = self.this_tree.get_file_sha1(file_id)
413
modified_hashes[file_id] = hash
414
self.this_tree.set_merge_modified(modified_hashes)
417
def parent(entry, file_id):
418
"""Determine the parent for a file_id (used as a key method)"""
421
return entry.parent_id
424
def name(entry, file_id):
425
"""Determine the name for a file_id (used as a key method)"""
431
def contents_sha1(tree, file_id):
432
"""Determine the sha1 of the file contents (used as a key method)."""
433
if file_id not in tree:
435
return tree.get_file_sha1(file_id)
438
def executable(tree, file_id):
439
"""Determine the executability of a file-id (used as a key method)."""
440
if file_id not in tree:
442
if tree.kind(file_id) != "file":
444
return tree.is_executable(file_id)
447
def kind(tree, file_id):
448
"""Determine the kind of a file-id (used as a key method)."""
449
if file_id not in tree:
451
return tree.kind(file_id)
454
def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
455
"""Do a three-way test on a scalar.
456
Return "this", "other" or "conflict", depending whether a value wins.
458
key_base = key(base_tree, file_id)
459
key_other = key(other_tree, file_id)
460
#if base == other, either they all agree, or only THIS has changed.
461
if key_base == key_other:
463
key_this = key(this_tree, file_id)
464
if key_this not in (key_base, key_other):
466
# "Ambiguous clean merge"
467
elif key_this == key_other:
470
assert key_this == key_base
473
def merge_names(self, file_id):
474
"""Perform a merge on file_id names and parents"""
476
if file_id in tree.inventory:
477
return tree.inventory[file_id]
480
this_entry = get_entry(self.this_tree)
481
other_entry = get_entry(self.other_tree)
482
base_entry = get_entry(self.base_tree)
483
name_winner = self.scalar_three_way(this_entry, base_entry,
484
other_entry, file_id, self.name)
485
parent_id_winner = self.scalar_three_way(this_entry, base_entry,
486
other_entry, file_id,
488
if this_entry is None:
489
if name_winner == "this":
490
name_winner = "other"
491
if parent_id_winner == "this":
492
parent_id_winner = "other"
493
if name_winner == "this" and parent_id_winner == "this":
495
if name_winner == "conflict":
496
trans_id = self.tt.trans_id_file_id(file_id)
497
self._raw_conflicts.append(('name conflict', trans_id,
498
self.name(this_entry, file_id),
499
self.name(other_entry, file_id)))
500
if parent_id_winner == "conflict":
501
trans_id = self.tt.trans_id_file_id(file_id)
502
self._raw_conflicts.append(('parent conflict', trans_id,
503
self.parent(this_entry, file_id),
504
self.parent(other_entry, file_id)))
505
if other_entry is None:
506
# it doesn't matter whether the result was 'other' or
507
# 'conflict'-- if there's no 'other', we leave it alone.
509
# if we get here, name_winner and parent_winner are set to safe values.
510
winner_entry = {"this": this_entry, "other": other_entry,
511
"conflict": other_entry}
512
trans_id = self.tt.trans_id_file_id(file_id)
513
parent_id = winner_entry[parent_id_winner].parent_id
514
parent_trans_id = self.tt.trans_id_file_id(parent_id)
515
self.tt.adjust_path(winner_entry[name_winner].name, parent_trans_id,
518
def merge_contents(self, file_id):
519
"""Performa a merge on file_id contents."""
520
def contents_pair(tree):
521
if file_id not in tree:
523
kind = tree.kind(file_id)
524
if kind == "root_directory":
527
contents = tree.get_file_sha1(file_id)
528
elif kind == "symlink":
529
contents = tree.get_symlink_target(file_id)
532
return kind, contents
534
def contents_conflict():
535
trans_id = self.tt.trans_id_file_id(file_id)
536
name = self.tt.final_name(trans_id)
537
parent_id = self.tt.final_parent(trans_id)
538
if file_id in self.this_tree.inventory:
539
self.tt.unversion_file(trans_id)
540
self.tt.delete_contents(trans_id)
541
file_group = self._dump_conflicts(name, parent_id, file_id,
543
self._raw_conflicts.append(('contents conflict', file_group))
545
# See SPOT run. run, SPOT, run.
546
# So we're not QUITE repeating ourselves; we do tricky things with
548
base_pair = contents_pair(self.base_tree)
549
other_pair = contents_pair(self.other_tree)
550
if base_pair == other_pair:
551
# OTHER introduced no changes
553
this_pair = contents_pair(self.this_tree)
554
if this_pair == other_pair:
555
# THIS and OTHER introduced the same changes
558
trans_id = self.tt.trans_id_file_id(file_id)
559
if this_pair == base_pair:
560
# only OTHER introduced changes
561
if file_id in self.this_tree:
562
# Remove any existing contents
563
self.tt.delete_contents(trans_id)
564
if file_id in self.other_tree:
565
# OTHER changed the file
566
create_by_entry(self.tt,
567
self.other_tree.inventory[file_id],
568
self.other_tree, trans_id)
569
if file_id not in self.this_tree.inventory:
570
self.tt.version_file(file_id, trans_id)
572
elif file_id in self.this_tree.inventory:
573
# OTHER deleted the file
574
self.tt.unversion_file(trans_id)
576
#BOTH THIS and OTHER introduced changes; scalar conflict
577
elif this_pair[0] == "file" and other_pair[0] == "file":
578
# THIS and OTHER are both files, so text merge. Either
579
# BASE is a file, or both converted to files, so at least we
580
# have agreement that output should be a file.
582
self.text_merge(file_id, trans_id)
584
return contents_conflict()
585
if file_id not in self.this_tree.inventory:
586
self.tt.version_file(file_id, trans_id)
588
self.tt.tree_kind(trans_id)
589
self.tt.delete_contents(trans_id)
594
# Scalar conflict, can't text merge. Dump conflicts
595
return contents_conflict()
597
def get_lines(self, tree, file_id):
598
"""Return the lines in a file, or an empty list."""
600
return tree.get_file(file_id).readlines()
604
def text_merge(self, file_id, trans_id):
605
"""Perform a three-way text merge on a file_id"""
606
# it's possible that we got here with base as a different type.
607
# if so, we just want two-way text conflicts.
608
if file_id in self.base_tree and \
609
self.base_tree.kind(file_id) == "file":
610
base_lines = self.get_lines(self.base_tree, file_id)
613
other_lines = self.get_lines(self.other_tree, file_id)
614
this_lines = self.get_lines(self.this_tree, file_id)
615
m3 = Merge3(base_lines, this_lines, other_lines)
616
start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
617
if self.show_base is True:
618
base_marker = '|' * 7
622
def iter_merge3(retval):
623
retval["text_conflicts"] = False
624
for line in m3.merge_lines(name_a = "TREE",
625
name_b = "MERGE-SOURCE",
626
name_base = "BASE-REVISION",
627
start_marker=start_marker,
628
base_marker=base_marker,
629
reprocess=self.reprocess):
630
if line.startswith(start_marker):
631
retval["text_conflicts"] = True
632
yield line.replace(start_marker, '<' * 7)
636
merge3_iterator = iter_merge3(retval)
637
self.tt.create_file(merge3_iterator, trans_id)
638
if retval["text_conflicts"] is True:
639
self._raw_conflicts.append(('text conflict', trans_id))
640
name = self.tt.final_name(trans_id)
641
parent_id = self.tt.final_parent(trans_id)
642
file_group = self._dump_conflicts(name, parent_id, file_id,
643
this_lines, base_lines,
645
file_group.append(trans_id)
647
def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
648
base_lines=None, other_lines=None, set_version=False,
650
"""Emit conflict files.
651
If this_lines, base_lines, or other_lines are omitted, they will be
652
determined automatically. If set_version is true, the .OTHER, .THIS
653
or .BASE (in that order) will be created as versioned files.
655
data = [('OTHER', self.other_tree, other_lines),
656
('THIS', self.this_tree, this_lines)]
658
data.append(('BASE', self.base_tree, base_lines))
661
for suffix, tree, lines in data:
663
trans_id = self._conflict_file(name, parent_id, tree, file_id,
665
file_group.append(trans_id)
666
if set_version and not versioned:
667
self.tt.version_file(file_id, trans_id)
671
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
673
"""Emit a single conflict file."""
674
name = name + '.' + suffix
675
trans_id = self.tt.create_path(name, parent_id)
676
entry = tree.inventory[file_id]
677
create_by_entry(self.tt, entry, tree, trans_id, lines)
680
def merge_executable(self, file_id, file_status):
681
"""Perform a merge on the execute bit."""
682
if file_status == "deleted":
684
trans_id = self.tt.trans_id_file_id(file_id)
686
if self.tt.final_kind(trans_id) != "file":
690
winner = self.scalar_three_way(self.this_tree, self.base_tree,
691
self.other_tree, file_id,
693
if winner == "conflict":
694
# There must be a None in here, if we have a conflict, but we
695
# need executability since file status was not deleted.
696
if self.other_tree.is_executable(file_id) is None:
701
if file_status == "modified":
702
executability = self.this_tree.is_executable(file_id)
703
if executability is not None:
704
trans_id = self.tt.trans_id_file_id(file_id)
705
self.tt.set_executability(executability, trans_id)
707
assert winner == "other"
708
if file_id in self.other_tree:
709
executability = self.other_tree.is_executable(file_id)
710
elif file_id in self.this_tree:
711
executability = self.this_tree.is_executable(file_id)
712
elif file_id in self.base_tree:
713
executability = self.base_tree.is_executable(file_id)
714
if executability is not None:
715
trans_id = self.tt.trans_id_file_id(file_id)
716
self.tt.set_executability(executability, trans_id)
718
def cook_conflicts(self, fs_conflicts):
719
"""Convert all conflicts into a form that doesn't depend on trans_id"""
720
from conflicts import Conflict
722
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
723
fp = FinalPaths(self.tt)
724
for conflict in self._raw_conflicts:
725
conflict_type = conflict[0]
726
if conflict_type in ('name conflict', 'parent conflict'):
727
trans_id = conflict[1]
728
conflict_args = conflict[2:]
729
if trans_id not in name_conflicts:
730
name_conflicts[trans_id] = {}
731
unique_add(name_conflicts[trans_id], conflict_type,
733
if conflict_type == 'contents conflict':
734
for trans_id in conflict[1]:
735
file_id = self.tt.final_file_id(trans_id)
736
if file_id is not None:
738
path = fp.get_path(trans_id)
739
for suffix in ('.BASE', '.THIS', '.OTHER'):
740
if path.endswith(suffix):
741
path = path[:-len(suffix)]
743
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
744
self.cooked_conflicts.append(c)
745
if conflict_type == 'text conflict':
746
trans_id = conflict[1]
747
path = fp.get_path(trans_id)
748
file_id = self.tt.final_file_id(trans_id)
749
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
750
self.cooked_conflicts.append(c)
752
for trans_id, conflicts in name_conflicts.iteritems():
754
this_parent, other_parent = conflicts['parent conflict']
755
assert this_parent != other_parent
757
this_parent = other_parent = \
758
self.tt.final_file_id(self.tt.final_parent(trans_id))
760
this_name, other_name = conflicts['name conflict']
761
assert this_name != other_name
763
this_name = other_name = self.tt.final_name(trans_id)
764
other_path = fp.get_path(trans_id)
765
if this_parent is not None:
767
fp.get_path(self.tt.trans_id_file_id(this_parent))
768
this_path = pathjoin(this_parent_path, this_name)
770
this_path = "<deleted>"
771
file_id = self.tt.final_file_id(trans_id)
772
c = Conflict.factory('path conflict', path=this_path,
773
conflict_path=other_path, file_id=file_id)
774
self.cooked_conflicts.append(c)
775
self.cooked_conflicts.sort(key=Conflict.sort_key)
778
class WeaveMerger(Merge3Merger):
779
"""Three-way tree merger, text weave merger."""
780
supports_reprocess = True
781
supports_show_base = False
783
def __init__(self, working_tree, this_tree, base_tree, other_tree,
784
interesting_ids=None, pb=DummyProgress(), pp=None,
786
self.this_revision_tree = self._get_revision_tree(this_tree)
787
self.other_revision_tree = self._get_revision_tree(other_tree)
788
super(WeaveMerger, self).__init__(working_tree, this_tree,
789
base_tree, other_tree,
790
interesting_ids=interesting_ids,
791
pb=pb, pp=pp, reprocess=reprocess)
793
def _get_revision_tree(self, tree):
794
"""Return a revision tree related to this tree.
795
If the tree is a WorkingTree, the basis will be returned.
797
if getattr(tree, 'get_weave', False) is False:
798
# If we have a WorkingTree, try using the basis
799
return tree.branch.basis_tree()
803
def _check_file(self, file_id):
804
"""Check that the revision tree's version of the file matches."""
805
for tree, rt in ((self.this_tree, self.this_revision_tree),
806
(self.other_tree, self.other_revision_tree)):
809
if tree.get_file_sha1(file_id) != rt.get_file_sha1(file_id):
810
raise WorkingTreeNotRevision(self.this_tree)
812
def _merged_lines(self, file_id):
813
"""Generate the merged lines.
814
There is no distinction between lines that are meant to contain <<<<<<<
817
weave = self.this_revision_tree.get_weave(file_id)
818
this_revision_id = self.this_revision_tree.inventory[file_id].revision
819
other_revision_id = \
820
self.other_revision_tree.inventory[file_id].revision
821
wm = WeaveMerge(weave, this_revision_id, other_revision_id,
822
'<<<<<<< TREE\n', '>>>>>>> MERGE-SOURCE\n')
823
return wm.merge_lines(self.reprocess)
825
def text_merge(self, file_id, trans_id):
826
"""Perform a (weave) text merge for a given file and file-id.
827
If conflicts are encountered, .THIS and .OTHER files will be emitted,
828
and a conflict will be noted.
830
self._check_file(file_id)
831
lines, conflicts = self._merged_lines(file_id)
833
# Note we're checking whether the OUTPUT is binary in this case,
834
# because we don't want to get into weave merge guts.
835
check_text_lines(lines)
836
self.tt.create_file(lines, trans_id)
838
self._raw_conflicts.append(('text conflict', trans_id))
839
name = self.tt.final_name(trans_id)
840
parent_id = self.tt.final_parent(trans_id)
841
file_group = self._dump_conflicts(name, parent_id, file_id,
843
file_group.append(trans_id)
846
class Diff3Merger(Merge3Merger):
847
"""Three-way merger using external diff3 for text merging"""
848
def dump_file(self, temp_dir, name, tree, file_id):
849
out_path = pathjoin(temp_dir, name)
850
out_file = file(out_path, "wb")
851
in_file = tree.get_file(file_id)
856
def text_merge(self, file_id, trans_id):
857
"""Perform a diff3 merge using a specified file-id and trans-id.
858
If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
859
will be dumped, and a will be conflict noted.
862
temp_dir = mkdtemp(prefix="bzr-")
864
new_file = pathjoin(temp_dir, "new")
865
this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
866
base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
867
other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
868
status = bzrlib.patch.diff3(new_file, this, base, other)
869
if status not in (0, 1):
870
raise BzrError("Unhandled diff3 exit code")
871
self.tt.create_file(file(new_file, "rb"), trans_id)
873
name = self.tt.final_name(trans_id)
874
parent_id = self.tt.final_parent(trans_id)
875
self._dump_conflicts(name, parent_id, file_id)
876
self._raw_conflicts.append(('text conflict', trans_id))
881
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
883
merge_type=Merge3Merger,
884
interesting_ids=None,
888
interesting_files=None,
891
"""Primary interface for merging.
893
typical use is probably
894
'merge_inner(branch, branch.get_revision_tree(other_revision),
895
branch.get_revision_tree(base_revision))'
897
if this_tree is None:
898
warnings.warn("bzrlib.merge.merge_inner requires a this_tree parameter as of "
899
"bzrlib version 0.8.",
902
this_tree = this_branch.bzrdir.open_workingtree()
903
merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
905
merger.backup_files = backup_files
906
merger.merge_type = merge_type
907
merger.interesting_ids = interesting_ids
908
merger.ignore_zero = ignore_zero
909
if interesting_files:
910
assert not interesting_ids, ('Only supply interesting_ids'
911
' or interesting_files')
912
merger._set_interesting_files(interesting_files)
913
merger.show_base = show_base
914
merger.reprocess = reprocess
915
merger.other_rev_id = other_rev_id
916
merger.other_basis = other_rev_id
917
return merger.do_merge()
920
merge_types = { "merge3": (Merge3Merger, "Native diff3-style merge"),
921
"diff3": (Diff3Merger, "Merge using external diff3"),
922
'weave': (WeaveMerger, "Weave-based merge")
610
merge_types = { "merge3": (ApplyMerge3, "Native diff3-style merge"),
611
"diff3": (Diff3Merge, "Merge using external diff3"),
612
'weave': (WeaveMerge, "Weave-based merge")
926
def merge_type_help():
927
templ = '%s%%7s: %%s' % (' '*12)
928
lines = [templ % (f[0], f[1][1]) for f in merge_types.iteritems()]
929
return '\n'.join(lines)
added
removed
bzrlib/merge.py
