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,
23
conflicts as _mod_conflicts,
26
26
graph as _mod_graph,
30
30
revision as _mod_revision,
39
from bzrlib.cleanup import OperationWithCleanups
45
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
49
63
# TODO: Report back as changes are merged in
52
66
def transform_tree(from_tree, to_tree, interesting_ids=None):
53
from_tree.lock_tree_write()
54
operation = OperationWithCleanups(merge_inner)
55
operation.add_cleanup(from_tree.unlock)
56
operation.run_simple(from_tree.branch, to_tree, from_tree,
57
ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
60
class MergeHooks(hooks.Hooks):
63
hooks.Hooks.__init__(self)
64
self.create_hook(hooks.HookPoint('merge_file_content',
65
"Called with a bzrlib.merge.Merger object to create a per file "
66
"merge object when starting a merge. "
67
"Should return either None or a subclass of "
68
"``bzrlib.merge.AbstractPerFileMerger``. "
69
"Such objects will then be called per file "
70
"that needs to be merged (including when one "
71
"side has deleted the file and the other has changed it). "
72
"See the AbstractPerFileMerger API docs for details on how it is "
77
class AbstractPerFileMerger(object):
78
"""PerFileMerger objects are used by plugins extending merge for bzrlib.
80
See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
82
:ivar merger: The Merge3Merger performing the merge.
85
def __init__(self, merger):
86
"""Create a PerFileMerger for use with merger."""
89
def merge_contents(self, merge_params):
90
"""Attempt to merge the contents of a single file.
92
:param merge_params: A bzrlib.merge.MergeHookParams
93
:return : A tuple of (status, chunks), where status is one of
94
'not_applicable', 'success', 'conflicted', or 'delete'. If status
95
is 'success' or 'conflicted', then chunks should be an iterable of
96
strings for the new file contents.
98
return ('not applicable', None)
101
class PerFileMerger(AbstractPerFileMerger):
102
"""Merge individual files when self.file_matches returns True.
104
This class is intended to be subclassed. The file_matches and
105
merge_matching methods should be overridden with concrete implementations.
108
def file_matches(self, params):
109
"""Return True if merge_matching should be called on this file.
111
Only called with merges of plain files with no clear winner.
113
Subclasses must override this.
115
raise NotImplementedError(self.file_matches)
117
def get_filename(self, params, tree):
118
"""Lookup the filename (i.e. basename, not path), given a Tree (e.g.
119
self.merger.this_tree) and a MergeHookParams.
121
return osutils.basename(tree.id2path(params.file_id))
123
def get_filepath(self, params, tree):
124
"""Calculate the path to the file in a tree.
126
:param params: A MergeHookParams describing the file to merge
127
:param tree: a Tree, e.g. self.merger.this_tree.
129
return tree.id2path(params.file_id)
131
def merge_contents(self, params):
132
"""Merge the contents of a single file."""
133
# Check whether this custom merge logic should be used.
135
# OTHER is a straight winner, rely on default merge.
136
params.winner == 'other' or
137
# THIS and OTHER aren't both files.
138
not params.is_file_merge() or
139
# The filename doesn't match *.xml
140
not self.file_matches(params)):
141
return 'not_applicable', None
142
return self.merge_matching(params)
144
def merge_matching(self, params):
145
"""Merge the contents of a single file that has matched the criteria
146
in PerFileMerger.merge_contents (is a conflict, is a file,
147
self.file_matches is True).
149
Subclasses must override this.
151
raise NotImplementedError(self.merge_matching)
154
class ConfigurableFileMerger(PerFileMerger):
155
"""Merge individual files when configured via a .conf file.
157
This is a base class for concrete custom file merging logic. Concrete
158
classes should implement ``merge_text``.
160
See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
162
:ivar affected_files: The configured file paths to merge.
164
:cvar name_prefix: The prefix to use when looking up configuration
165
details. <name_prefix>_merge_files describes the files targeted by the
168
:cvar default_files: The default file paths to merge when no configuration
175
def __init__(self, merger):
176
super(ConfigurableFileMerger, self).__init__(merger)
177
self.affected_files = None
178
self.default_files = self.__class__.default_files or []
179
self.name_prefix = self.__class__.name_prefix
180
if self.name_prefix is None:
181
raise ValueError("name_prefix must be set.")
183
def file_matches(self, params):
184
"""Check whether the file should call the merge hook.
186
<name_prefix>_merge_files configuration variable is a list of files
187
that should use the hook.
189
affected_files = self.affected_files
190
if affected_files is None:
191
config = self.merger.this_branch.get_config()
192
# Until bzr provides a better policy for caching the config, we
193
# just add the part we're interested in to the params to avoid
194
# reading the config files repeatedly (bazaar.conf, location.conf,
196
config_key = self.name_prefix + '_merge_files'
197
affected_files = config.get_user_option_as_list(config_key)
198
if affected_files is None:
199
# If nothing was specified in the config, use the default.
200
affected_files = self.default_files
201
self.affected_files = affected_files
203
filepath = self.get_filepath(params, self.merger.this_tree)
204
if filepath in affected_files:
208
def merge_matching(self, params):
209
return self.merge_text(params)
211
def merge_text(self, params):
212
"""Merge the byte contents of a single file.
214
This is called after checking that the merge should be performed in
215
merge_contents, and it should behave as per
216
``bzrlib.merge.AbstractPerFileMerger.merge_contents``.
218
raise NotImplementedError(self.merge_text)
221
class MergeHookParams(object):
222
"""Object holding parameters passed to merge_file_content hooks.
224
There are some fields hooks can access:
226
:ivar file_id: the file ID of the file being merged
227
:ivar trans_id: the transform ID for the merge of this file
228
:ivar this_kind: kind of file_id in 'this' tree
229
:ivar other_kind: kind of file_id in 'other' tree
230
:ivar winner: one of 'this', 'other', 'conflict'
233
def __init__(self, merger, file_id, trans_id, this_kind, other_kind,
235
self._merger = merger
236
self.file_id = file_id
237
self.trans_id = trans_id
238
self.this_kind = this_kind
239
self.other_kind = other_kind
242
def is_file_merge(self):
243
"""True if this_kind and other_kind are both 'file'."""
244
return self.this_kind == 'file' and self.other_kind == 'file'
246
@decorators.cachedproperty
247
def base_lines(self):
248
"""The lines of the 'base' version of the file."""
249
return self._merger.get_lines(self._merger.base_tree, self.file_id)
251
@decorators.cachedproperty
252
def this_lines(self):
253
"""The lines of the 'this' version of the file."""
254
return self._merger.get_lines(self._merger.this_tree, self.file_id)
256
@decorators.cachedproperty
257
def other_lines(self):
258
"""The lines of the 'other' version of the file."""
259
return self._merger.get_lines(self._merger.other_tree, self.file_id)
67
merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
68
interesting_ids=interesting_ids, this_tree=from_tree)
262
71
class Merger(object):
266
72
def __init__(self, this_branch, other_tree=None, base_tree=None,
267
73
this_tree=None, pb=None, change_reporter=None,
268
74
recurse='down', revision_graph=None):
463
257
if self.this_rev_id is None:
464
258
if self.this_basis_tree.get_file_sha1(file_id) != \
465
259
self.this_tree.get_file_sha1(file_id):
466
raise errors.WorkingTreeNotRevision(self.this_tree)
260
raise WorkingTreeNotRevision(self.this_tree)
468
262
trees = (self.this_basis_tree, self.other_tree)
469
263
return [get_id(tree, file_id) for tree in trees]
471
@deprecated_method(deprecated_in((2, 1, 0)))
472
265
def check_basis(self, check_clean, require_commits=True):
473
266
if self.this_basis is None and require_commits is True:
474
raise errors.BzrCommandError(
475
"This branch has no commits."
476
" (perhaps you would prefer 'bzr pull')")
267
raise BzrCommandError("This branch has no commits."
268
" (perhaps you would prefer 'bzr pull')")
478
270
self.compare_basis()
479
271
if self.this_basis != self.this_rev_id:
480
272
raise errors.UncommittedChanges(self.this_tree)
482
@deprecated_method(deprecated_in((2, 1, 0)))
483
274
def compare_basis(self):
485
276
basis_tree = self.revision_tree(self.this_tree.last_revision())
486
277
except errors.NoSuchRevision:
487
278
basis_tree = self.this_tree.basis_tree()
488
if not self.this_tree.has_changes(basis_tree):
279
changes = self.this_tree.changes_from(basis_tree)
280
if not changes.has_changed():
489
281
self.this_rev_id = self.this_basis
491
283
def set_interesting_files(self, file_list):
492
284
self.interesting_files = file_list
494
286
def set_pending(self):
495
if (not self.base_is_ancestor or not self.base_is_other_ancestor
496
or self.other_rev_id is None):
287
if not self.base_is_ancestor or not self.base_is_other_ancestor or self.other_rev_id is None:
498
289
self._add_parent()
500
291
def _add_parent(self):
501
292
new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
502
293
new_parent_trees = []
503
operation = OperationWithCleanups(self.this_tree.set_parent_trees)
504
294
for revision_id in new_parents:
506
296
tree = self.revision_tree(revision_id)
793
587
# making sure we haven't missed any corner cases.
794
588
# if lca_trees is None:
795
589
# self._lca_trees = [self.base_tree]
796
592
self.change_reporter = change_reporter
797
593
self.cherrypick = cherrypick
595
self.pp = ProgressPhase("Merge phase", 3, self.pb)
801
warnings.warn("pp argument to Merge3Merger is deprecated")
803
warnings.warn("pb argument to Merge3Merger is deprecated")
805
599
def do_merge(self):
806
operation = OperationWithCleanups(self._do_merge)
807
600
self.this_tree.lock_tree_write()
808
operation.add_cleanup(self.this_tree.unlock)
809
601
self.base_tree.lock_read()
810
operation.add_cleanup(self.base_tree.unlock)
811
602
self.other_tree.lock_read()
812
operation.add_cleanup(self.other_tree.unlock)
815
def _do_merge(self, operation):
816
self.tt = transform.TreeTransform(self.this_tree, None)
817
operation.add_cleanup(self.tt.finalize)
818
self._compute_transform()
819
results = self.tt.apply(no_conflicts=True)
820
self.write_modified(results)
603
self.tt = TreeTransform(self.this_tree, self.pb)
822
self.this_tree.add_conflicts(self.cooked_conflicts)
823
except errors.UnsupportedOperation:
606
self._compute_transform()
608
results = self.tt.apply(no_conflicts=True)
609
self.write_modified(results)
611
self.this_tree.add_conflicts(self.cooked_conflicts)
612
except UnsupportedOperation:
616
self.other_tree.unlock()
617
self.base_tree.unlock()
618
self.this_tree.unlock()
826
621
def make_preview_transform(self):
827
operation = OperationWithCleanups(self._make_preview_transform)
828
622
self.base_tree.lock_read()
829
operation.add_cleanup(self.base_tree.unlock)
830
623
self.other_tree.lock_read()
831
operation.add_cleanup(self.other_tree.unlock)
832
return operation.run_simple()
834
def _make_preview_transform(self):
835
self.tt = transform.TransformPreview(self.this_tree)
836
self._compute_transform()
624
self.tt = TransformPreview(self.this_tree)
627
self._compute_transform()
630
self.other_tree.unlock()
631
self.base_tree.unlock()
839
635
def _compute_transform(self):
1091
886
other_root = self.tt.trans_id_file_id(other_root_file_id)
1092
887
if other_root == self.tt.root:
890
self.tt.final_kind(other_root)
1094
893
if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
1095
# the other tree's root is a non-root in the current tree (as when
1096
# a previously unrelated branch is merged into another)
894
# the other tree's root is a non-root in the current tree
1099
self.tt.final_kind(other_root)
1100
other_root_is_present = True
1101
except errors.NoSuchFile:
1102
# other_root doesn't have a physical representation. We still need
1103
# to move any references to the actual root of the tree.
1104
other_root_is_present = False
1105
# 'other_tree.inventory.root' is not present in this tree. We are
1106
# calling adjust_path for children which *want* to be present with a
1107
# correct place to go.
1108
for thing, child in self.other_tree.inventory.root.children.iteritems():
896
self.reparent_children(self.other_tree.inventory.root, self.tt.root)
897
self.tt.cancel_creation(other_root)
898
self.tt.cancel_versioning(other_root)
900
def reparent_children(self, ie, target):
901
for thing, child in ie.children.iteritems():
1109
902
trans_id = self.tt.trans_id_file_id(child.file_id)
1110
if not other_root_is_present:
1111
# FIXME: Make final_kind returns None instead of raising
1112
# NoSuchFile to avoid the ugly construct below -- vila 20100402
1114
self.tt.final_kind(trans_id)
1115
# The item exist in the final tree and has a defined place
1118
except errors.NoSuchFile, e:
1120
# Move the item into the root
1121
self.tt.adjust_path(self.tt.final_name(trans_id),
1122
self.tt.root, trans_id)
1123
if other_root_is_present:
1124
self.tt.cancel_creation(other_root)
1125
self.tt.cancel_versioning(other_root)
903
self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1127
905
def write_modified(self, results):
1128
906
modified_hashes = {}
1296
1071
parent_id_winner = "other"
1297
1072
if name_winner == "this" and parent_id_winner == "this":
1299
if name_winner == 'conflict' or parent_id_winner == 'conflict':
1300
# Creating helpers (.OTHER or .THIS) here cause problems down the
1301
# road if a ContentConflict needs to be created so we should not do
1303
trans_id = self.tt.trans_id_file_id(file_id)
1304
self._raw_conflicts.append(('path conflict', trans_id, file_id,
1305
this_parent, this_name,
1306
other_parent, other_name))
1074
if name_winner == "conflict":
1075
trans_id = self.tt.trans_id_file_id(file_id)
1076
self._raw_conflicts.append(('name conflict', trans_id,
1077
this_name, other_name))
1078
if parent_id_winner == "conflict":
1079
trans_id = self.tt.trans_id_file_id(file_id)
1080
self._raw_conflicts.append(('parent conflict', trans_id,
1081
this_parent, other_parent))
1307
1082
if other_name is None:
1308
1083
# it doesn't matter whether the result was 'other' or
1309
1084
# 'conflict'-- if there's no 'other', we leave it alone.
1086
# if we get here, name_winner and parent_winner are set to safe values.
1087
trans_id = self.tt.trans_id_file_id(file_id)
1311
1088
parent_id = parents[self.winner_idx[parent_id_winner]]
1312
1089
if parent_id is not None:
1313
# if we get here, name_winner and parent_winner are set to safe
1090
parent_trans_id = self.tt.trans_id_file_id(parent_id)
1315
1091
self.tt.adjust_path(names[self.winner_idx[name_winner]],
1316
self.tt.trans_id_file_id(parent_id),
1317
self.tt.trans_id_file_id(file_id))
1092
parent_trans_id, trans_id)
1319
def _do_merge_contents(self, file_id):
1094
def merge_contents(self, file_id):
1320
1095
"""Performs a merge on file_id contents."""
1321
1096
def contents_pair(tree):
1322
1097
if file_id not in tree:
1351
1138
if winner == 'this':
1352
1139
# No interesting changes introduced by OTHER
1353
1140
return "unmodified"
1354
# We have a hypothetical conflict, but if we have files, then we
1355
# can try to merge the content
1356
1141
trans_id = self.tt.trans_id_file_id(file_id)
1357
params = MergeHookParams(self, file_id, trans_id, this_pair[0],
1358
other_pair[0], winner)
1359
hooks = self.active_hooks
1360
hook_status = 'not_applicable'
1362
hook_status, lines = hook.merge_contents(params)
1363
if hook_status != 'not_applicable':
1364
# Don't try any more hooks, this one applies.
1367
if hook_status == 'not_applicable':
1368
# This is a contents conflict, because none of the available
1369
# functions could merge it.
1371
name = self.tt.final_name(trans_id)
1372
parent_id = self.tt.final_parent(trans_id)
1373
if self.this_tree.has_id(file_id):
1374
self.tt.unversion_file(trans_id)
1375
file_group = self._dump_conflicts(name, parent_id, file_id,
1377
self._raw_conflicts.append(('contents conflict', file_group))
1378
elif hook_status == 'success':
1379
self.tt.create_file(lines, trans_id)
1380
elif hook_status == 'conflicted':
1381
# XXX: perhaps the hook should be able to provide
1382
# the BASE/THIS/OTHER files?
1383
self.tt.create_file(lines, trans_id)
1384
self._raw_conflicts.append(('text conflict', trans_id))
1385
name = self.tt.final_name(trans_id)
1386
parent_id = self.tt.final_parent(trans_id)
1387
self._dump_conflicts(name, parent_id, file_id)
1388
elif hook_status == 'delete':
1389
self.tt.unversion_file(trans_id)
1391
elif hook_status == 'done':
1392
# The hook function did whatever it needs to do directly, no
1393
# further action needed here.
1396
raise AssertionError('unknown hook_status: %r' % (hook_status,))
1397
if not self.this_tree.has_id(file_id) and result == "modified":
1398
self.tt.version_file(file_id, trans_id)
1399
# The merge has been performed, so the old contents should not be
1402
self.tt.delete_contents(trans_id)
1403
except errors.NoSuchFile:
1407
def _default_other_winner_merge(self, merge_hook_params):
1408
"""Replace this contents with other."""
1409
file_id = merge_hook_params.file_id
1410
trans_id = merge_hook_params.trans_id
1411
file_in_this = self.this_tree.has_id(file_id)
1412
if self.other_tree.has_id(file_id):
1413
# OTHER changed the file
1415
if wt.supports_content_filtering():
1416
# We get the path from the working tree if it exists.
1417
# That fails though when OTHER is adding a file, so
1418
# we fall back to the other tree to find the path if
1419
# it doesn't exist locally.
1421
filter_tree_path = wt.id2path(file_id)
1422
except errors.NoSuchId:
1423
filter_tree_path = self.other_tree.id2path(file_id)
1425
# Skip the id2path lookup for older formats
1426
filter_tree_path = None
1427
transform.create_from_tree(self.tt, trans_id,
1428
self.other_tree, file_id,
1429
filter_tree_path=filter_tree_path)
1432
# OTHER deleted the file
1433
return 'delete', None
1435
raise AssertionError(
1436
'winner is OTHER, but file_id %r not in THIS or OTHER tree'
1439
def merge_contents(self, merge_hook_params):
1440
"""Fallback merge logic after user installed hooks."""
1441
# This function is used in merge hooks as the fallback instance.
1442
# Perhaps making this function and the functions it calls be a
1443
# a separate class would be better.
1444
if merge_hook_params.winner == 'other':
1142
if winner == 'other':
1445
1143
# OTHER is a straight winner, so replace this contents with other
1446
return self._default_other_winner_merge(merge_hook_params)
1447
elif merge_hook_params.is_file_merge():
1448
# THIS and OTHER are both files, so text merge. Either
1449
# BASE is a file, or both converted to files, so at least we
1450
# have agreement that output should be a file.
1452
self.text_merge(merge_hook_params.file_id,
1453
merge_hook_params.trans_id)
1454
except errors.BinaryFile:
1455
return 'not_applicable', None
1144
file_in_this = file_id in self.this_tree
1146
# Remove any existing contents
1147
self.tt.delete_contents(trans_id)
1148
if file_id in self.other_tree:
1149
# OTHER changed the file
1150
create_from_tree(self.tt, trans_id,
1151
self.other_tree, file_id)
1152
if not file_in_this:
1153
self.tt.version_file(file_id, trans_id)
1156
# OTHER deleted the file
1157
self.tt.unversion_file(trans_id)
1458
return 'not_applicable', None
1160
# We have a hypothetical conflict, but if we have files, then we
1161
# can try to merge the content
1162
if this_pair[0] == 'file' and other_pair[0] == 'file':
1163
# THIS and OTHER are both files, so text merge. Either
1164
# BASE is a file, or both converted to files, so at least we
1165
# have agreement that output should be a file.
1167
self.text_merge(file_id, trans_id)
1169
return contents_conflict()
1170
if file_id not in self.this_tree:
1171
self.tt.version_file(file_id, trans_id)
1173
self.tt.tree_kind(trans_id)
1174
self.tt.delete_contents(trans_id)
1179
return contents_conflict()
1460
1181
def get_lines(self, tree, file_id):
1461
1182
"""Return the lines in a file, or an empty list."""
1462
if tree.has_id(file_id):
1463
return tree.get_file_lines(file_id)
1184
return tree.get_file(file_id).readlines()
1634
1328
if path.endswith(suffix):
1635
1329
path = path[:-len(suffix)]
1637
c = _mod_conflicts.Conflict.factory(conflict_type,
1638
path=path, file_id=file_id)
1639
elif conflict_type == 'text conflict':
1331
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1332
self.cooked_conflicts.append(c)
1333
if conflict_type == 'text conflict':
1640
1334
trans_id = conflict[1]
1641
1335
path = fp.get_path(trans_id)
1642
1336
file_id = self.tt.final_file_id(trans_id)
1643
c = _mod_conflicts.Conflict.factory(conflict_type,
1644
path=path, file_id=file_id)
1337
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1338
self.cooked_conflicts.append(c)
1340
for trans_id, conflicts in name_conflicts.iteritems():
1342
this_parent, other_parent = conflicts['parent conflict']
1343
if this_parent == other_parent:
1344
raise AssertionError()
1346
this_parent = other_parent = \
1347
self.tt.final_file_id(self.tt.final_parent(trans_id))
1349
this_name, other_name = conflicts['name conflict']
1350
if this_name == other_name:
1351
raise AssertionError()
1353
this_name = other_name = self.tt.final_name(trans_id)
1354
other_path = fp.get_path(trans_id)
1355
if this_parent is not None and this_name is not None:
1356
this_parent_path = \
1357
fp.get_path(self.tt.trans_id_file_id(this_parent))
1358
this_path = pathjoin(this_parent_path, this_name)
1646
raise AssertionError('bad conflict type: %r' % (conflict,))
1360
this_path = "<deleted>"
1361
file_id = self.tt.final_file_id(trans_id)
1362
c = Conflict.factory('path conflict', path=this_path,
1363
conflict_path=other_path, file_id=file_id)
1647
1364
self.cooked_conflicts.append(c)
1648
self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1365
self.cooked_conflicts.sort(key=Conflict.sort_key)
1651
1368
class WeaveMerger(Merge3Merger):
1655
1372
supports_reverse_cherrypick = False
1656
1373
history_based = True
1658
def _generate_merge_plan(self, file_id, base):
1659
return self.this_tree.plan_file_merge(file_id, self.other_tree,
1375
def _merged_lines(self, file_id):
1376
"""Generate the merged lines.
1377
There is no distinction between lines that are meant to contain <<<<<<<
1381
base = self.base_tree
1384
plan = self.this_tree.plan_file_merge(file_id, self.other_tree,
1662
def _merged_lines(self, file_id):
1663
"""Generate the merged lines.
1664
There is no distinction between lines that are meant to contain <<<<<<<
1668
base = self.base_tree
1671
plan = self._generate_merge_plan(file_id, base)
1672
1386
if 'merge' in debug.debug_flags:
1673
1387
plan = list(plan)
1674
1388
trans_id = self.tt.trans_id_file_id(file_id)
1675
1389
name = self.tt.final_name(trans_id) + '.plan'
1676
contents = ('%11s|%s' % l for l in plan)
1390
contents = ('%10s|%s' % l for l in plan)
1677
1391
self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1678
textmerge = versionedfile.PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1679
'>>>>>>> MERGE-SOURCE\n')
1680
lines, conflicts = textmerge.merge_lines(self.reprocess)
1682
base_lines = textmerge.base_from_plan()
1685
return lines, base_lines
1392
textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1393
'>>>>>>> MERGE-SOURCE\n')
1394
return textmerge.merge_lines(self.reprocess)
1687
1396
def text_merge(self, file_id, trans_id):
1688
1397
"""Perform a (weave) text merge for a given file and file-id.
1689
1398
If conflicts are encountered, .THIS and .OTHER files will be emitted,
1690
1399
and a conflict will be noted.
1692
lines, base_lines = self._merged_lines(file_id)
1401
lines, conflicts = self._merged_lines(file_id)
1693
1402
lines = list(lines)
1694
1403
# Note we're checking whether the OUTPUT is binary in this case,
1695
1404
# because we don't want to get into weave merge guts.
1696
textfile.check_text_lines(lines)
1405
check_text_lines(lines)
1697
1406
self.tt.create_file(lines, trans_id)
1698
if base_lines is not None:
1700
1408
self._raw_conflicts.append(('text conflict', trans_id))
1701
1409
name = self.tt.final_name(trans_id)
1702
1410
parent_id = self.tt.final_parent(trans_id)
1703
1411
file_group = self._dump_conflicts(name, parent_id, file_id,
1705
base_lines=base_lines)
1706
1413
file_group.append(trans_id)
1709
1416
class LCAMerger(WeaveMerger):
1711
def _generate_merge_plan(self, file_id, base):
1712
return self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1418
def _merged_lines(self, file_id):
1419
"""Generate the merged lines.
1420
There is no distinction between lines that are meant to contain <<<<<<<
1424
base = self.base_tree
1427
plan = self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1429
if 'merge' in debug.debug_flags:
1431
trans_id = self.tt.trans_id_file_id(file_id)
1432
name = self.tt.final_name(trans_id) + '.plan'
1433
contents = ('%10s|%s' % l for l in plan)
1434
self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1435
textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1436
'>>>>>>> MERGE-SOURCE\n')
1437
return textmerge.merge_lines(self.reprocess)
1715
1440
class Diff3Merger(Merge3Merger):
1716
1441
"""Three-way merger using external diff3 for text merging"""
1718
1443
def dump_file(self, temp_dir, name, tree, file_id):
1719
out_path = osutils.pathjoin(temp_dir, name)
1444
out_path = pathjoin(temp_dir, name)
1720
1445
out_file = open(out_path, "wb")
1722
1447
in_file = tree.get_file(file_id)
added
removed
bzrlib/merge.py
