14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
from itertools import chain
19
from bzrlib.lazy_import import lazy_import
20
lazy_import(globals(), """
21
23
from bzrlib import (
22
branch as _mod_branch,
24
conflicts as _mod_conflicts,
27
26
graph as _mod_graph,
31
30
revision as _mod_revision,
47
from bzrlib.symbol_versioning import (
34
from bzrlib.branch import Branch
35
from bzrlib.conflicts import ConflictList, Conflict
36
from bzrlib.errors import (BzrCommandError,
46
WorkingTreeNotRevision,
49
from bzrlib.graph import Graph
50
from bzrlib.merge3 import Merge3
51
from bzrlib.osutils import rename, pathjoin
52
from progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import (NULL_REVISION, ensure_null)
54
from bzrlib.textfile import check_text_lines
55
from bzrlib.trace import mutter, warning, note, is_quiet
56
from bzrlib.transform import (TransformPreview, TreeTransform,
57
resolve_conflicts, cook_conflicts,
58
conflict_pass, FinalPaths, create_from_tree,
59
unique_add, ROOT_PARENT)
60
from bzrlib.versionedfile import PlanWeaveMerge
51
63
# TODO: Report back as changes are merged in
54
66
def transform_tree(from_tree, to_tree, interesting_ids=None):
55
67
from_tree.lock_tree_write()
56
operation = cleanup.OperationWithCleanups(merge_inner)
57
operation.add_cleanup(from_tree.unlock)
58
operation.run_simple(from_tree.branch, to_tree, from_tree,
59
ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
62
class MergeHooks(hooks.Hooks):
65
hooks.Hooks.__init__(self, "bzrlib.merge", "Merger.hooks")
66
self.add_hook('merge_file_content',
67
"Called with a bzrlib.merge.Merger object to create a per file "
68
"merge object when starting a merge. "
69
"Should return either None or a subclass of "
70
"``bzrlib.merge.AbstractPerFileMerger``. "
71
"Such objects will then be called per file "
72
"that needs to be merged (including when one "
73
"side has deleted the file and the other has changed it). "
74
"See the AbstractPerFileMerger API docs for details on how it is "
79
class AbstractPerFileMerger(object):
80
"""PerFileMerger objects are used by plugins extending merge for bzrlib.
82
See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
84
:ivar merger: The Merge3Merger performing the merge.
87
def __init__(self, merger):
88
"""Create a PerFileMerger for use with merger."""
91
def merge_contents(self, merge_params):
92
"""Attempt to merge the contents of a single file.
94
:param merge_params: A bzrlib.merge.MergeHookParams
95
:return: A tuple of (status, chunks), where status is one of
96
'not_applicable', 'success', 'conflicted', or 'delete'. If status
97
is 'success' or 'conflicted', then chunks should be an iterable of
98
strings for the new file contents.
100
return ('not applicable', None)
103
class PerFileMerger(AbstractPerFileMerger):
104
"""Merge individual files when self.file_matches returns True.
106
This class is intended to be subclassed. The file_matches and
107
merge_matching methods should be overridden with concrete implementations.
110
def file_matches(self, params):
111
"""Return True if merge_matching should be called on this file.
113
Only called with merges of plain files with no clear winner.
115
Subclasses must override this.
117
raise NotImplementedError(self.file_matches)
119
def get_filename(self, params, tree):
120
"""Lookup the filename (i.e. basename, not path), given a Tree (e.g.
121
self.merger.this_tree) and a MergeHookParams.
123
return osutils.basename(tree.id2path(params.file_id))
125
def get_filepath(self, params, tree):
126
"""Calculate the path to the file in a tree.
128
:param params: A MergeHookParams describing the file to merge
129
:param tree: a Tree, e.g. self.merger.this_tree.
131
return tree.id2path(params.file_id)
133
def merge_contents(self, params):
134
"""Merge the contents of a single file."""
135
# Check whether this custom merge logic should be used.
137
# OTHER is a straight winner, rely on default merge.
138
params.winner == 'other' or
139
# THIS and OTHER aren't both files.
140
not params.is_file_merge() or
141
# The filename doesn't match *.xml
142
not self.file_matches(params)):
143
return 'not_applicable', None
144
return self.merge_matching(params)
146
def merge_matching(self, params):
147
"""Merge the contents of a single file that has matched the criteria
148
in PerFileMerger.merge_contents (is a conflict, is a file,
149
self.file_matches is True).
151
Subclasses must override this.
153
raise NotImplementedError(self.merge_matching)
156
class ConfigurableFileMerger(PerFileMerger):
157
"""Merge individual files when configured via a .conf file.
159
This is a base class for concrete custom file merging logic. Concrete
160
classes should implement ``merge_text``.
162
See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
164
:ivar affected_files: The configured file paths to merge.
166
:cvar name_prefix: The prefix to use when looking up configuration
167
details. <name_prefix>_merge_files describes the files targeted by the
170
:cvar default_files: The default file paths to merge when no configuration
177
def __init__(self, merger):
178
super(ConfigurableFileMerger, self).__init__(merger)
179
self.affected_files = None
180
self.default_files = self.__class__.default_files or []
181
self.name_prefix = self.__class__.name_prefix
182
if self.name_prefix is None:
183
raise ValueError("name_prefix must be set.")
185
def file_matches(self, params):
186
"""Check whether the file should call the merge hook.
188
<name_prefix>_merge_files configuration variable is a list of files
189
that should use the hook.
191
affected_files = self.affected_files
192
if affected_files is None:
193
config = self.merger.this_branch.get_config()
194
# Until bzr provides a better policy for caching the config, we
195
# just add the part we're interested in to the params to avoid
196
# reading the config files repeatedly (bazaar.conf, location.conf,
198
config_key = self.name_prefix + '_merge_files'
199
affected_files = config.get_user_option_as_list(config_key)
200
if affected_files is None:
201
# If nothing was specified in the config, use the default.
202
affected_files = self.default_files
203
self.affected_files = affected_files
205
filepath = self.get_filepath(params, self.merger.this_tree)
206
if filepath in affected_files:
210
def merge_matching(self, params):
211
return self.merge_text(params)
213
def merge_text(self, params):
214
"""Merge the byte contents of a single file.
216
This is called after checking that the merge should be performed in
217
merge_contents, and it should behave as per
218
``bzrlib.merge.AbstractPerFileMerger.merge_contents``.
220
raise NotImplementedError(self.merge_text)
223
class MergeHookParams(object):
224
"""Object holding parameters passed to merge_file_content hooks.
226
There are some fields hooks can access:
228
:ivar file_id: the file ID of the file being merged
229
:ivar trans_id: the transform ID for the merge of this file
230
:ivar this_kind: kind of file_id in 'this' tree
231
:ivar other_kind: kind of file_id in 'other' tree
232
:ivar winner: one of 'this', 'other', 'conflict'
235
def __init__(self, merger, file_id, trans_id, this_kind, other_kind,
237
self._merger = merger
238
self.file_id = file_id
239
self.trans_id = trans_id
240
self.this_kind = this_kind
241
self.other_kind = other_kind
244
def is_file_merge(self):
245
"""True if this_kind and other_kind are both 'file'."""
246
return self.this_kind == 'file' and self.other_kind == 'file'
248
@decorators.cachedproperty
249
def base_lines(self):
250
"""The lines of the 'base' version of the file."""
251
return self._merger.get_lines(self._merger.base_tree, self.file_id)
253
@decorators.cachedproperty
254
def this_lines(self):
255
"""The lines of the 'this' version of the file."""
256
return self._merger.get_lines(self._merger.this_tree, self.file_id)
258
@decorators.cachedproperty
259
def other_lines(self):
260
"""The lines of the 'other' version of the file."""
261
return self._merger.get_lines(self._merger.other_tree, self.file_id)
69
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
70
interesting_ids=interesting_ids, this_tree=from_tree)
264
75
class Merger(object):
268
76
def __init__(self, this_branch, other_tree=None, base_tree=None,
269
77
this_tree=None, pb=None, change_reporter=None,
270
78
recurse='down', revision_graph=None):
451
259
if self.other_rev_id is None:
452
260
other_basis_tree = self.revision_tree(self.other_basis)
453
261
if other_basis_tree.has_changes(self.other_tree):
454
raise errors.WorkingTreeNotRevision(self.this_tree)
262
raise WorkingTreeNotRevision(self.this_tree)
455
263
other_rev_id = self.other_basis
456
264
self.other_tree = other_basis_tree
458
@deprecated_method(deprecated_in((2, 1, 0)))
459
266
def file_revisions(self, file_id):
460
267
self.ensure_revision_trees()
268
def get_id(tree, file_id):
269
revision_id = tree.inventory[file_id].revision
461
271
if self.this_rev_id is None:
462
272
if self.this_basis_tree.get_file_sha1(file_id) != \
463
273
self.this_tree.get_file_sha1(file_id):
464
raise errors.WorkingTreeNotRevision(self.this_tree)
274
raise WorkingTreeNotRevision(self.this_tree)
466
276
trees = (self.this_basis_tree, self.other_tree)
467
return [tree.get_file_revision(file_id) for tree in trees]
277
return [get_id(tree, file_id) for tree in trees]
469
@deprecated_method(deprecated_in((2, 1, 0)))
470
279
def check_basis(self, check_clean, require_commits=True):
471
280
if self.this_basis is None and require_commits is True:
472
raise errors.BzrCommandError(
473
"This branch has no commits."
474
" (perhaps you would prefer 'bzr pull')")
281
raise BzrCommandError("This branch has no commits."
282
" (perhaps you would prefer 'bzr pull')")
476
284
self.compare_basis()
477
285
if self.this_basis != self.this_rev_id:
478
286
raise errors.UncommittedChanges(self.this_tree)
480
@deprecated_method(deprecated_in((2, 1, 0)))
481
288
def compare_basis(self):
483
290
basis_tree = self.revision_tree(self.this_tree.last_revision())
592
400
self.base_rev_id = self.revision_graph.find_unique_lca(
594
sorted_lca_keys = self.revision_graph.find_merge_order(
596
if self.base_rev_id == _mod_revision.NULL_REVISION:
597
self.base_rev_id = sorted_lca_keys[0]
599
if self.base_rev_id == _mod_revision.NULL_REVISION:
600
raise errors.UnrelatedBranches()
402
self._is_criss_cross = True
403
if self.base_rev_id == NULL_REVISION:
404
raise UnrelatedBranches()
601
405
if self._is_criss_cross:
602
trace.warning('Warning: criss-cross merge encountered. See bzr'
603
' help criss-cross.')
604
trace.mutter('Criss-cross lcas: %r' % lcas)
605
if self.base_rev_id in lcas:
606
trace.mutter('Unable to find unique lca. '
607
'Fallback %r as best option.' % self.base_rev_id)
608
interesting_revision_ids = set(lcas)
609
interesting_revision_ids.add(self.base_rev_id)
406
warning('Warning: criss-cross merge encountered. See bzr'
407
' help criss-cross.')
408
mutter('Criss-cross lcas: %r' % lcas)
409
interesting_revision_ids = [self.base_rev_id]
410
interesting_revision_ids.extend(lcas)
610
411
interesting_trees = dict((t.get_revision_id(), t)
611
412
for t in self.this_branch.repository.revision_trees(
612
413
interesting_revision_ids))
613
414
self._cached_trees.update(interesting_trees)
614
if self.base_rev_id in lcas:
615
self.base_tree = interesting_trees[self.base_rev_id]
617
self.base_tree = interesting_trees.pop(self.base_rev_id)
415
self.base_tree = interesting_trees.pop(self.base_rev_id)
416
sorted_lca_keys = self.revision_graph.find_merge_order(
618
418
self._lca_trees = [interesting_trees[key]
619
419
for key in sorted_lca_keys]
621
421
self.base_tree = self.revision_tree(self.base_rev_id)
622
422
self.base_is_ancestor = True
623
423
self.base_is_other_ancestor = True
624
trace.mutter('Base revid: %r' % self.base_rev_id)
424
mutter('Base revid: %r' % self.base_rev_id)
626
426
def set_base(self, base_revision):
627
427
"""Set the base revision to use for the merge.
629
429
:param base_revision: A 2-list containing a path and revision number.
631
trace.mutter("doing merge() with no base_revision specified")
431
mutter("doing merge() with no base_revision specified")
632
432
if base_revision == [None, None]:
801
600
# making sure we haven't missed any corner cases.
802
601
# if lca_trees is None:
803
602
# self._lca_trees = [self.base_tree]
804
605
self.change_reporter = change_reporter
805
606
self.cherrypick = cherrypick
608
self.pp = ProgressPhase("Merge phase", 3, self.pb)
809
warnings.warn("pp argument to Merge3Merger is deprecated")
811
warnings.warn("pb argument to Merge3Merger is deprecated")
813
612
def do_merge(self):
814
operation = cleanup.OperationWithCleanups(self._do_merge)
815
613
self.this_tree.lock_tree_write()
816
operation.add_cleanup(self.this_tree.unlock)
817
614
self.base_tree.lock_read()
818
operation.add_cleanup(self.base_tree.unlock)
819
615
self.other_tree.lock_read()
820
operation.add_cleanup(self.other_tree.unlock)
823
def _do_merge(self, operation):
824
self.tt = transform.TreeTransform(self.this_tree, None)
825
operation.add_cleanup(self.tt.finalize)
826
self._compute_transform()
827
results = self.tt.apply(no_conflicts=True)
828
self.write_modified(results)
830
self.this_tree.add_conflicts(self.cooked_conflicts)
831
except errors.UnsupportedOperation:
617
self.tt = TreeTransform(self.this_tree, self.pb)
620
self._compute_transform()
622
results = self.tt.apply(no_conflicts=True)
623
self.write_modified(results)
625
self.this_tree.add_conflicts(self.cooked_conflicts)
626
except UnsupportedOperation:
631
self.other_tree.unlock()
632
self.base_tree.unlock()
633
self.this_tree.unlock()
834
636
def make_preview_transform(self):
835
operation = cleanup.OperationWithCleanups(self._make_preview_transform)
836
637
self.base_tree.lock_read()
837
operation.add_cleanup(self.base_tree.unlock)
838
638
self.other_tree.lock_read()
839
operation.add_cleanup(self.other_tree.unlock)
840
return operation.run_simple()
842
def _make_preview_transform(self):
843
self.tt = transform.TransformPreview(self.this_tree)
844
self._compute_transform()
639
self.tt = TransformPreview(self.this_tree)
642
self._compute_transform()
645
self.other_tree.unlock()
646
self.base_tree.unlock()
847
650
def _compute_transform(self):
1106
901
other_root = self.tt.trans_id_file_id(other_root_file_id)
1107
902
if other_root == self.tt.root:
1109
if self.this_tree.inventory.has_id(
1110
self.other_tree.inventory.root.file_id):
1111
# the other tree's root is a non-root in the current tree (as
1112
# when a previously unrelated branch is merged into another)
1114
if self.tt.final_kind(other_root) is not None:
1115
other_root_is_present = True
1117
# other_root doesn't have a physical representation. We still need
1118
# to move any references to the actual root of the tree.
1119
other_root_is_present = False
1120
# 'other_tree.inventory.root' is not present in this tree. We are
1121
# calling adjust_path for children which *want* to be present with a
1122
# correct place to go.
1123
for _, child in self.other_tree.inventory.root.children.iteritems():
905
self.tt.final_kind(other_root)
908
if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
909
# the other tree's root is a non-root in the current tree
911
self.reparent_children(self.other_tree.inventory.root, self.tt.root)
912
self.tt.cancel_creation(other_root)
913
self.tt.cancel_versioning(other_root)
915
def reparent_children(self, ie, target):
916
for thing, child in ie.children.iteritems():
1124
917
trans_id = self.tt.trans_id_file_id(child.file_id)
1125
if not other_root_is_present:
1126
if self.tt.final_kind(trans_id) is not None:
1127
# The item exist in the final tree and has a defined place
1130
# Move the item into the root
1132
final_name = self.tt.final_name(trans_id)
1133
except errors.NoFinalPath:
1134
# This file is not present anymore, ignore it.
1136
self.tt.adjust_path(final_name, self.tt.root, trans_id)
1137
if other_root_is_present:
1138
self.tt.cancel_creation(other_root)
1139
self.tt.cancel_versioning(other_root)
918
self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1141
920
def write_modified(self, results):
1142
921
modified_hashes = {}
1310
1086
parent_id_winner = "other"
1311
1087
if name_winner == "this" and parent_id_winner == "this":
1313
if name_winner == 'conflict' or parent_id_winner == 'conflict':
1314
# Creating helpers (.OTHER or .THIS) here cause problems down the
1315
# road if a ContentConflict needs to be created so we should not do
1317
trans_id = self.tt.trans_id_file_id(file_id)
1318
self._raw_conflicts.append(('path conflict', trans_id, file_id,
1319
this_parent, this_name,
1320
other_parent, other_name))
1321
if not self.other_tree.has_id(file_id):
1089
if name_winner == "conflict":
1090
trans_id = self.tt.trans_id_file_id(file_id)
1091
self._raw_conflicts.append(('name conflict', trans_id,
1092
this_name, other_name))
1093
if parent_id_winner == "conflict":
1094
trans_id = self.tt.trans_id_file_id(file_id)
1095
self._raw_conflicts.append(('parent conflict', trans_id,
1096
this_parent, other_parent))
1097
if other_name is None:
1322
1098
# it doesn't matter whether the result was 'other' or
1323
# 'conflict'-- if it has no file id, we leave it alone.
1099
# 'conflict'-- if there's no 'other', we leave it alone.
1101
# if we get here, name_winner and parent_winner are set to safe values.
1102
trans_id = self.tt.trans_id_file_id(file_id)
1325
1103
parent_id = parents[self.winner_idx[parent_id_winner]]
1326
name = names[self.winner_idx[name_winner]]
1327
if parent_id is not None or name is not None:
1328
# if we get here, name_winner and parent_winner are set to safe
1330
if parent_id is None and name is not None:
1331
# if parent_id is None and name is non-None, current file is
1333
if names[self.winner_idx[parent_id_winner]] != '':
1334
raise AssertionError(
1335
'File looks like a root, but named %s' %
1336
names[self.winner_idx[parent_id_winner]])
1337
parent_trans_id = transform.ROOT_PARENT
1339
parent_trans_id = self.tt.trans_id_file_id(parent_id)
1340
self.tt.adjust_path(name, parent_trans_id,
1341
self.tt.trans_id_file_id(file_id))
1104
if parent_id is not None:
1105
parent_trans_id = self.tt.trans_id_file_id(parent_id)
1106
self.tt.adjust_path(names[self.winner_idx[name_winner]],
1107
parent_trans_id, trans_id)
1343
def _do_merge_contents(self, file_id):
1109
def merge_contents(self, file_id):
1344
1110
"""Performs a merge on file_id contents."""
1345
1111
def contents_pair(tree):
1346
if not tree.has_id(file_id):
1112
if file_id not in tree:
1347
1113
return (None, None)
1348
1114
kind = tree.kind(file_id)
1349
1115
if kind == "file":
1375
1153
if winner == 'this':
1376
1154
# No interesting changes introduced by OTHER
1377
1155
return "unmodified"
1378
# We have a hypothetical conflict, but if we have files, then we
1379
# can try to merge the content
1380
1156
trans_id = self.tt.trans_id_file_id(file_id)
1381
params = MergeHookParams(self, file_id, trans_id, this_pair[0],
1382
other_pair[0], winner)
1383
hooks = self.active_hooks
1384
hook_status = 'not_applicable'
1386
hook_status, lines = hook.merge_contents(params)
1387
if hook_status != 'not_applicable':
1388
# Don't try any more hooks, this one applies.
1391
if hook_status == 'not_applicable':
1392
# This is a contents conflict, because none of the available
1393
# functions could merge it.
1395
name = self.tt.final_name(trans_id)
1396
parent_id = self.tt.final_parent(trans_id)
1397
if self.this_tree.has_id(file_id):
1398
self.tt.unversion_file(trans_id)
1399
file_group = self._dump_conflicts(name, parent_id, file_id,
1401
self._raw_conflicts.append(('contents conflict', file_group))
1402
elif hook_status == 'success':
1403
self.tt.create_file(lines, trans_id)
1404
elif hook_status == 'conflicted':
1405
# XXX: perhaps the hook should be able to provide
1406
# the BASE/THIS/OTHER files?
1407
self.tt.create_file(lines, trans_id)
1408
self._raw_conflicts.append(('text conflict', trans_id))
1409
name = self.tt.final_name(trans_id)
1410
parent_id = self.tt.final_parent(trans_id)
1411
self._dump_conflicts(name, parent_id, file_id)
1412
elif hook_status == 'delete':
1413
self.tt.unversion_file(trans_id)
1415
elif hook_status == 'done':
1416
# The hook function did whatever it needs to do directly, no
1417
# further action needed here.
1420
raise AssertionError('unknown hook_status: %r' % (hook_status,))
1421
if not self.this_tree.has_id(file_id) and result == "modified":
1422
self.tt.version_file(file_id, trans_id)
1423
# The merge has been performed, so the old contents should not be
1425
self.tt.delete_contents(trans_id)
1428
def _default_other_winner_merge(self, merge_hook_params):
1429
"""Replace this contents with other."""
1430
file_id = merge_hook_params.file_id
1431
trans_id = merge_hook_params.trans_id
1432
file_in_this = self.this_tree.has_id(file_id)
1433
if self.other_tree.has_id(file_id):
1434
# OTHER changed the file
1436
if wt.supports_content_filtering():
1437
# We get the path from the working tree if it exists.
1438
# That fails though when OTHER is adding a file, so
1439
# we fall back to the other tree to find the path if
1440
# it doesn't exist locally.
1442
filter_tree_path = wt.id2path(file_id)
1443
except errors.NoSuchId:
1444
filter_tree_path = self.other_tree.id2path(file_id)
1446
# Skip the id2path lookup for older formats
1447
filter_tree_path = None
1448
transform.create_from_tree(self.tt, trans_id,
1449
self.other_tree, file_id,
1450
filter_tree_path=filter_tree_path)
1453
# OTHER deleted the file
1454
return 'delete', None
1456
raise AssertionError(
1457
'winner is OTHER, but file_id %r not in THIS or OTHER tree'
1460
def merge_contents(self, merge_hook_params):
1461
"""Fallback merge logic after user installed hooks."""
1462
# This function is used in merge hooks as the fallback instance.
1463
# Perhaps making this function and the functions it calls be a
1464
# a separate class would be better.
1465
if merge_hook_params.winner == 'other':
1157
if winner == 'other':
1466
1158
# OTHER is a straight winner, so replace this contents with other
1467
return self._default_other_winner_merge(merge_hook_params)
1468
elif merge_hook_params.is_file_merge():
1469
# THIS and OTHER are both files, so text merge. Either
1470
# BASE is a file, or both converted to files, so at least we
1471
# have agreement that output should be a file.
1473
self.text_merge(merge_hook_params.file_id,
1474
merge_hook_params.trans_id)
1475
except errors.BinaryFile:
1476
return 'not_applicable', None
1159
file_in_this = file_id in self.this_tree
1161
# Remove any existing contents
1162
self.tt.delete_contents(trans_id)
1163
if file_id in self.other_tree:
1164
# OTHER changed the file
1166
if wt.supports_content_filtering():
1167
# We get the path from the working tree if it exists.
1168
# That fails though when OTHER is adding a file, so
1169
# we fall back to the other tree to find the path if
1170
# it doesn't exist locally.
1172
filter_tree_path = wt.id2path(file_id)
1173
except errors.NoSuchId:
1174
filter_tree_path = self.other_tree.id2path(file_id)
1176
# Skip the id2path lookup for older formats
1177
filter_tree_path = None
1178
create_from_tree(self.tt, trans_id,
1179
self.other_tree, file_id,
1180
filter_tree_path=filter_tree_path)
1181
if not file_in_this:
1182
self.tt.version_file(file_id, trans_id)
1185
# OTHER deleted the file
1186
self.tt.unversion_file(trans_id)
1479
return 'not_applicable', None
1189
# We have a hypothetical conflict, but if we have files, then we
1190
# can try to merge the content
1191
if this_pair[0] == 'file' and other_pair[0] == 'file':
1192
# THIS and OTHER are both files, so text merge. Either
1193
# BASE is a file, or both converted to files, so at least we
1194
# have agreement that output should be a file.
1196
self.text_merge(file_id, trans_id)
1198
return contents_conflict()
1199
if file_id not in self.this_tree:
1200
self.tt.version_file(file_id, trans_id)
1202
self.tt.tree_kind(trans_id)
1203
self.tt.delete_contents(trans_id)
1208
return contents_conflict()
1481
1210
def get_lines(self, tree, file_id):
1482
1211
"""Return the lines in a file, or an empty list."""
1483
if tree.has_id(file_id):
1484
return tree.get_file_lines(file_id)
1213
return tree.get_file(file_id).readlines()
1618
1350
def cook_conflicts(self, fs_conflicts):
1619
1351
"""Convert all conflicts into a form that doesn't depend on trans_id"""
1620
content_conflict_file_ids = set()
1621
cooked_conflicts = transform.cook_conflicts(fs_conflicts, self.tt)
1622
fp = transform.FinalPaths(self.tt)
1352
from conflicts import Conflict
1354
self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
1355
fp = FinalPaths(self.tt)
1623
1356
for conflict in self._raw_conflicts:
1624
1357
conflict_type = conflict[0]
1625
if conflict_type == 'path conflict':
1627
this_parent, this_name,
1628
other_parent, other_name) = conflict[1:]
1629
if this_parent is None or this_name is None:
1630
this_path = '<deleted>'
1632
parent_path = fp.get_path(
1633
self.tt.trans_id_file_id(this_parent))
1634
this_path = osutils.pathjoin(parent_path, this_name)
1635
if other_parent is None or other_name is None:
1636
other_path = '<deleted>'
1638
if other_parent == self.other_tree.get_root_id():
1639
# The tree transform doesn't know about the other root,
1640
# so we special case here to avoid a NoFinalPath
1644
parent_path = fp.get_path(
1645
self.tt.trans_id_file_id(other_parent))
1646
other_path = osutils.pathjoin(parent_path, other_name)
1647
c = _mod_conflicts.Conflict.factory(
1648
'path conflict', path=this_path,
1649
conflict_path=other_path,
1651
elif conflict_type == 'contents conflict':
1358
if conflict_type in ('name conflict', 'parent conflict'):
1359
trans_id = conflict[1]
1360
conflict_args = conflict[2:]
1361
if trans_id not in name_conflicts:
1362
name_conflicts[trans_id] = {}
1363
unique_add(name_conflicts[trans_id], conflict_type,
1365
if conflict_type == 'contents conflict':
1652
1366
for trans_id in conflict[1]:
1653
1367
file_id = self.tt.final_file_id(trans_id)
1654
1368
if file_id is not None:
1658
1372
if path.endswith(suffix):
1659
1373
path = path[:-len(suffix)]
1661
c = _mod_conflicts.Conflict.factory(conflict_type,
1662
path=path, file_id=file_id)
1663
content_conflict_file_ids.add(file_id)
1664
elif conflict_type == 'text conflict':
1375
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1376
self.cooked_conflicts.append(c)
1377
if conflict_type == 'text conflict':
1665
1378
trans_id = conflict[1]
1666
1379
path = fp.get_path(trans_id)
1667
1380
file_id = self.tt.final_file_id(trans_id)
1668
c = _mod_conflicts.Conflict.factory(conflict_type,
1669
path=path, file_id=file_id)
1381
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1382
self.cooked_conflicts.append(c)
1384
for trans_id, conflicts in name_conflicts.iteritems():
1386
this_parent, other_parent = conflicts['parent conflict']
1387
if this_parent == other_parent:
1388
raise AssertionError()
1390
this_parent = other_parent = \
1391
self.tt.final_file_id(self.tt.final_parent(trans_id))
1393
this_name, other_name = conflicts['name conflict']
1394
if this_name == other_name:
1395
raise AssertionError()
1397
this_name = other_name = self.tt.final_name(trans_id)
1398
other_path = fp.get_path(trans_id)
1399
if this_parent is not None and this_name is not None:
1400
this_parent_path = \
1401
fp.get_path(self.tt.trans_id_file_id(this_parent))
1402
this_path = pathjoin(this_parent_path, this_name)
1671
raise AssertionError('bad conflict type: %r' % (conflict,))
1672
cooked_conflicts.append(c)
1674
self.cooked_conflicts = []
1675
# We want to get rid of path conflicts when a corresponding contents
1676
# conflict exists. This can occur when one branch deletes a file while
1677
# the other renames *and* modifies it. In this case, the content
1678
# conflict is enough.
1679
for c in cooked_conflicts:
1680
if (c.typestring == 'path conflict'
1681
and c.file_id in content_conflict_file_ids):
1404
this_path = "<deleted>"
1405
file_id = self.tt.final_file_id(trans_id)
1406
c = Conflict.factory('path conflict', path=this_path,
1407
conflict_path=other_path, file_id=file_id)
1683
1408
self.cooked_conflicts.append(c)
1684
self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1409
self.cooked_conflicts.sort(key=Conflict.sort_key)
1687
1412
class WeaveMerger(Merge3Merger):
1691
1416
supports_reverse_cherrypick = False
1692
1417
history_based = True
1694
def _generate_merge_plan(self, file_id, base):
1695
return self.this_tree.plan_file_merge(file_id, self.other_tree,
1419
def _merged_lines(self, file_id):
1420
"""Generate the merged lines.
1421
There is no distinction between lines that are meant to contain <<<<<<<
1425
base = self.base_tree
1428
plan = self.this_tree.plan_file_merge(file_id, self.other_tree,
1698
def _merged_lines(self, file_id):
1699
"""Generate the merged lines.
1700
There is no distinction between lines that are meant to contain <<<<<<<
1704
base = self.base_tree
1707
plan = self._generate_merge_plan(file_id, base)
1708
1430
if 'merge' in debug.debug_flags:
1709
1431
plan = list(plan)
1710
1432
trans_id = self.tt.trans_id_file_id(file_id)
1711
1433
name = self.tt.final_name(trans_id) + '.plan'
1712
contents = ('%11s|%s' % l for l in plan)
1434
contents = ('%10s|%s' % l for l in plan)
1713
1435
self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1714
textmerge = versionedfile.PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1715
'>>>>>>> MERGE-SOURCE\n')
1716
lines, conflicts = textmerge.merge_lines(self.reprocess)
1718
base_lines = textmerge.base_from_plan()
1721
return lines, base_lines
1436
textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1437
'>>>>>>> MERGE-SOURCE\n')
1438
return textmerge.merge_lines(self.reprocess)
1723
1440
def text_merge(self, file_id, trans_id):
1724
1441
"""Perform a (weave) text merge for a given file and file-id.
1725
1442
If conflicts are encountered, .THIS and .OTHER files will be emitted,
1726
1443
and a conflict will be noted.
1728
lines, base_lines = self._merged_lines(file_id)
1445
lines, conflicts = self._merged_lines(file_id)
1729
1446
lines = list(lines)
1730
1447
# Note we're checking whether the OUTPUT is binary in this case,
1731
1448
# because we don't want to get into weave merge guts.
1732
textfile.check_text_lines(lines)
1449
check_text_lines(lines)
1733
1450
self.tt.create_file(lines, trans_id)
1734
if base_lines is not None:
1736
1452
self._raw_conflicts.append(('text conflict', trans_id))
1737
1453
name = self.tt.final_name(trans_id)
1738
1454
parent_id = self.tt.final_parent(trans_id)
1739
1455
file_group = self._dump_conflicts(name, parent_id, file_id,
1741
base_lines=base_lines)
1742
1457
file_group.append(trans_id)
1745
1460
class LCAMerger(WeaveMerger):
1747
def _generate_merge_plan(self, file_id, base):
1748
return self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1462
def _merged_lines(self, file_id):
1463
"""Generate the merged lines.
1464
There is no distinction between lines that are meant to contain <<<<<<<
1468
base = self.base_tree
1471
plan = self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1473
if 'merge' in debug.debug_flags:
1475
trans_id = self.tt.trans_id_file_id(file_id)
1476
name = self.tt.final_name(trans_id) + '.plan'
1477
contents = ('%10s|%s' % l for l in plan)
1478
self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1479
textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1480
'>>>>>>> MERGE-SOURCE\n')
1481
return textmerge.merge_lines(self.reprocess)
1751
1484
class Diff3Merger(Merge3Merger):
1752
1485
"""Three-way merger using external diff3 for text merging"""
1754
1487
def dump_file(self, temp_dir, name, tree, file_id):
1755
out_path = osutils.pathjoin(temp_dir, name)
1488
out_path = pathjoin(temp_dir, name)
1756
1489
out_file = open(out_path, "wb")
1758
1491
in_file = tree.get_file(file_id)
1791
1524
osutils.rmtree(temp_dir)
1794
class PathNotInTree(errors.BzrError):
1796
_fmt = """Merge-into failed because %(tree)s does not contain %(path)s."""
1798
def __init__(self, path, tree):
1799
errors.BzrError.__init__(self, path=path, tree=tree)
1802
class MergeIntoMerger(Merger):
1803
"""Merger that understands other_tree will be merged into a subdir.
1805
This also changes the Merger api so that it uses real Branch, revision_id,
1806
and RevisonTree objects, rather than using revision specs.
1809
def __init__(self, this_tree, other_branch, other_tree, target_subdir,
1810
source_subpath, other_rev_id=None):
1811
"""Create a new MergeIntoMerger object.
1813
source_subpath in other_tree will be effectively copied to
1814
target_subdir in this_tree.
1816
:param this_tree: The tree that we will be merging into.
1817
:param other_branch: The Branch we will be merging from.
1818
:param other_tree: The RevisionTree object we want to merge.
1819
:param target_subdir: The relative path where we want to merge
1820
other_tree into this_tree
1821
:param source_subpath: The relative path specifying the subtree of
1822
other_tree to merge into this_tree.
1824
# It is assumed that we are merging a tree that is not in our current
1825
# ancestry, which means we are using the "EmptyTree" as our basis.
1826
null_ancestor_tree = this_tree.branch.repository.revision_tree(
1827
_mod_revision.NULL_REVISION)
1828
super(MergeIntoMerger, self).__init__(
1829
this_branch=this_tree.branch,
1830
this_tree=this_tree,
1831
other_tree=other_tree,
1832
base_tree=null_ancestor_tree,
1834
self._target_subdir = target_subdir
1835
self._source_subpath = source_subpath
1836
self.other_branch = other_branch
1837
if other_rev_id is None:
1838
other_rev_id = other_tree.get_revision_id()
1839
self.other_rev_id = self.other_basis = other_rev_id
1840
self.base_is_ancestor = True
1841
self.backup_files = True
1842
self.merge_type = Merge3Merger
1843
self.show_base = False
1844
self.reprocess = False
1845
self.interesting_ids = None
1846
self.merge_type = _MergeTypeParameterizer(MergeIntoMergeType,
1847
target_subdir=self._target_subdir,
1848
source_subpath=self._source_subpath)
1849
if self._source_subpath != '':
1850
# If this isn't a partial merge make sure the revisions will be
1852
self._maybe_fetch(self.other_branch, self.this_branch,
1855
def set_pending(self):
1856
if self._source_subpath != '':
1858
Merger.set_pending(self)
1861
class _MergeTypeParameterizer(object):
1862
"""Wrap a merge-type class to provide extra parameters.
1864
This is hack used by MergeIntoMerger to pass some extra parameters to its
1865
merge_type. Merger.do_merge() sets up its own set of parameters to pass to
1866
the 'merge_type' member. It is difficult override do_merge without
1867
re-writing the whole thing, so instead we create a wrapper which will pass
1868
the extra parameters.
1871
def __init__(self, merge_type, **kwargs):
1872
self._extra_kwargs = kwargs
1873
self._merge_type = merge_type
1875
def __call__(self, *args, **kwargs):
1876
kwargs.update(self._extra_kwargs)
1877
return self._merge_type(*args, **kwargs)
1879
def __getattr__(self, name):
1880
return getattr(self._merge_type, name)
1883
class MergeIntoMergeType(Merge3Merger):
1884
"""Merger that incorporates a tree (or part of a tree) into another."""
1886
def __init__(self, *args, **kwargs):
1887
"""Initialize the merger object.
1889
:param args: See Merge3Merger.__init__'s args.
1890
:param kwargs: See Merge3Merger.__init__'s keyword args, except for
1891
source_subpath and target_subdir.
1892
:keyword source_subpath: The relative path specifying the subtree of
1893
other_tree to merge into this_tree.
1894
:keyword target_subdir: The relative path where we want to merge
1895
other_tree into this_tree
1897
# All of the interesting work happens during Merge3Merger.__init__(),
1898
# so we have have to hack in to get our extra parameters set.
1899
self._source_subpath = kwargs.pop('source_subpath')
1900
self._target_subdir = kwargs.pop('target_subdir')
1901
super(MergeIntoMergeType, self).__init__(*args, **kwargs)
1903
def _compute_transform(self):
1904
child_pb = ui.ui_factory.nested_progress_bar()
1906
entries = self._entries_to_incorporate()
1907
entries = list(entries)
1908
for num, (entry, parent_id) in enumerate(entries):
1909
child_pb.update('Preparing file merge', num, len(entries))
1910
parent_trans_id = self.tt.trans_id_file_id(parent_id)
1911
trans_id = transform.new_by_entry(self.tt, entry,
1912
parent_trans_id, self.other_tree)
1915
self._finish_computing_transform()
1917
def _entries_to_incorporate(self):
1918
"""Yields pairs of (inventory_entry, new_parent)."""
1919
other_inv = self.other_tree.inventory
1920
subdir_id = other_inv.path2id(self._source_subpath)
1921
if subdir_id is None:
1922
# XXX: The error would be clearer if it gave the URL of the source
1923
# branch, but we don't have a reference to that here.
1924
raise PathNotInTree(self._source_subpath, "Source tree")
1925
subdir = other_inv[subdir_id]
1926
parent_in_target = osutils.dirname(self._target_subdir)
1927
target_id = self.this_tree.inventory.path2id(parent_in_target)
1928
if target_id is None:
1929
raise PathNotInTree(self._target_subdir, "Target tree")
1930
name_in_target = osutils.basename(self._target_subdir)
1931
merge_into_root = subdir.copy()
1932
merge_into_root.name = name_in_target
1933
if self.this_tree.inventory.has_id(merge_into_root.file_id):
1934
# Give the root a new file-id.
1935
# This can happen fairly easily if the directory we are
1936
# incorporating is the root, and both trees have 'TREE_ROOT' as
1937
# their root_id. Users will expect this to Just Work, so we
1938
# change the file-id here.
1939
# Non-root file-ids could potentially conflict too. That's really
1940
# an edge case, so we don't do anything special for those. We let
1941
# them cause conflicts.
1942
merge_into_root.file_id = generate_ids.gen_file_id(name_in_target)
1943
yield (merge_into_root, target_id)
1944
if subdir.kind != 'directory':
1945
# No children, so we are done.
1947
for ignored_path, entry in other_inv.iter_entries_by_dir(subdir_id):
1948
parent_id = entry.parent_id
1949
if parent_id == subdir.file_id:
1950
# The root's parent ID has changed, so make sure children of
1951
# the root refer to the new ID.
1952
parent_id = merge_into_root.file_id
1953
yield (entry, parent_id)
1956
1527
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1957
1528
backup_files=False,
1958
1529
merge_type=Merge3Merger,
added
removed
bzrlib/merge.py
