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
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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
this_tree=None, pb=None, change_reporter=None,
73
this_tree=None, pb=DummyProgress(), change_reporter=None,
268
74
recurse='down', revision_graph=None):
269
75
object.__init__(self)
270
76
self.this_branch = this_branch
463
255
if self.this_rev_id is None:
464
256
if self.this_basis_tree.get_file_sha1(file_id) != \
465
257
self.this_tree.get_file_sha1(file_id):
466
raise errors.WorkingTreeNotRevision(self.this_tree)
258
raise WorkingTreeNotRevision(self.this_tree)
468
260
trees = (self.this_basis_tree, self.other_tree)
469
261
return [get_id(tree, file_id) for tree in trees]
471
@deprecated_method(deprecated_in((2, 1, 0)))
472
263
def check_basis(self, check_clean, require_commits=True):
473
264
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')")
265
raise BzrCommandError("This branch has no commits."
266
" (perhaps you would prefer 'bzr pull')")
478
268
self.compare_basis()
479
269
if self.this_basis != self.this_rev_id:
480
270
raise errors.UncommittedChanges(self.this_tree)
482
@deprecated_method(deprecated_in((2, 1, 0)))
483
272
def compare_basis(self):
485
274
basis_tree = self.revision_tree(self.this_tree.last_revision())
486
275
except errors.NoSuchRevision:
487
276
basis_tree = self.this_tree.basis_tree()
488
if not self.this_tree.has_changes(basis_tree):
277
changes = self.this_tree.changes_from(basis_tree)
278
if not changes.has_changed():
489
279
self.this_rev_id = self.this_basis
491
281
def set_interesting_files(self, file_list):
492
282
self.interesting_files = file_list
494
284
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):
285
if not self.base_is_ancestor or not self.base_is_other_ancestor or self.other_rev_id is None:
498
287
self._add_parent()
500
289
def _add_parent(self):
501
290
new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
502
291
new_parent_trees = []
503
operation = OperationWithCleanups(self.this_tree.set_parent_trees)
504
292
for revision_id in new_parents:
506
294
tree = self.revision_tree(revision_id)
739
532
winner_idx = {"this": 2, "other": 1, "conflict": 1}
740
533
supports_lca_trees = True
742
def __init__(self, working_tree, this_tree, base_tree, other_tree,
535
def __init__(self, working_tree, this_tree, base_tree, other_tree,
743
536
interesting_ids=None, reprocess=False, show_base=False,
744
pb=None, pp=None, change_reporter=None,
537
pb=DummyProgress(), pp=None, change_reporter=None,
745
538
interesting_files=None, do_merge=True,
746
cherrypick=False, lca_trees=None, this_branch=None):
539
cherrypick=False, lca_trees=None):
747
540
"""Initialize the merger object and perform the merge.
749
542
:param working_tree: The working tree to apply the merge to
750
543
:param this_tree: The local tree in the merge operation
751
544
:param base_tree: The common tree in the merge operation
752
:param other_tree: The other tree to merge changes from
753
:param this_branch: The branch associated with this_tree. Defaults to
754
this_tree.branch if not supplied.
545
:param other_tree: The other other tree to merge changes from
755
546
:param interesting_ids: The file_ids of files that should be
756
547
participate in the merge. May not be combined with
757
548
interesting_files.
758
549
:param: reprocess If True, perform conflict-reduction processing.
759
550
:param show_base: If True, show the base revision in text conflicts.
760
551
(incompatible with reprocess)
552
:param pb: A Progress bar
762
553
:param pp: A ProgressPhase object
763
554
:param change_reporter: An object that should report changes made
764
555
:param interesting_files: The tree-relative paths of files that should
793
581
# making sure we haven't missed any corner cases.
794
582
# if lca_trees is None:
795
583
# self._lca_trees = [self.base_tree]
796
586
self.change_reporter = change_reporter
797
587
self.cherrypick = cherrypick
589
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
593
def do_merge(self):
806
operation = OperationWithCleanups(self._do_merge)
807
594
self.this_tree.lock_tree_write()
808
operation.add_cleanup(self.this_tree.unlock)
809
595
self.base_tree.lock_read()
810
operation.add_cleanup(self.base_tree.unlock)
811
596
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)
597
self.tt = TreeTransform(self.this_tree, self.pb)
822
self.this_tree.add_conflicts(self.cooked_conflicts)
823
except errors.UnsupportedOperation:
600
self._compute_transform()
602
results = self.tt.apply(no_conflicts=True)
603
self.write_modified(results)
605
self.this_tree.add_conflicts(self.cooked_conflicts)
606
except UnsupportedOperation:
610
self.other_tree.unlock()
611
self.base_tree.unlock()
612
self.this_tree.unlock()
826
615
def make_preview_transform(self):
827
operation = OperationWithCleanups(self._make_preview_transform)
828
616
self.base_tree.lock_read()
829
operation.add_cleanup(self.base_tree.unlock)
830
617
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()
618
self.tt = TransformPreview(self.this_tree)
621
self._compute_transform()
624
self.other_tree.unlock()
625
self.base_tree.unlock()
839
629
def _compute_transform(self):
1091
884
other_root = self.tt.trans_id_file_id(other_root_file_id)
1092
885
if other_root == self.tt.root:
888
self.tt.final_kind(other_root)
1094
891
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)
892
# 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():
894
self.reparent_children(self.other_tree.inventory.root, self.tt.root)
895
self.tt.cancel_creation(other_root)
896
self.tt.cancel_versioning(other_root)
898
def reparent_children(self, ie, target):
899
for thing, child in ie.children.iteritems():
1109
900
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)
901
self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1127
903
def write_modified(self, results):
1128
904
modified_hashes = {}
1296
1069
parent_id_winner = "other"
1297
1070
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))
1072
if name_winner == "conflict":
1073
trans_id = self.tt.trans_id_file_id(file_id)
1074
self._raw_conflicts.append(('name conflict', trans_id,
1075
this_name, other_name))
1076
if parent_id_winner == "conflict":
1077
trans_id = self.tt.trans_id_file_id(file_id)
1078
self._raw_conflicts.append(('parent conflict', trans_id,
1079
this_parent, other_parent))
1307
1080
if other_name is None:
1308
# it doesn't matter whether the result was 'other' or
1081
# it doesn't matter whether the result was 'other' or
1309
1082
# 'conflict'-- if there's no 'other', we leave it alone.
1084
# if we get here, name_winner and parent_winner are set to safe values.
1085
trans_id = self.tt.trans_id_file_id(file_id)
1311
1086
parent_id = parents[self.winner_idx[parent_id_winner]]
1312
1087
if parent_id is not None:
1313
# if we get here, name_winner and parent_winner are set to safe
1088
parent_trans_id = self.tt.trans_id_file_id(parent_id)
1315
1089
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))
1090
parent_trans_id, trans_id)
1319
def _do_merge_contents(self, file_id):
1320
"""Performs a merge on file_id contents."""
1092
def merge_contents(self, file_id):
1093
"""Performa a merge on file_id contents."""
1321
1094
def contents_pair(tree):
1322
1095
if file_id not in tree:
1323
1096
return (None, None)
1330
1103
contents = None
1331
1104
return kind, contents
1106
def contents_conflict():
1107
trans_id = self.tt.trans_id_file_id(file_id)
1108
name = self.tt.final_name(trans_id)
1109
parent_id = self.tt.final_parent(trans_id)
1110
if file_id in self.this_tree.inventory:
1111
self.tt.unversion_file(trans_id)
1112
if file_id in self.this_tree:
1113
self.tt.delete_contents(trans_id)
1114
file_group = self._dump_conflicts(name, parent_id, file_id,
1116
self._raw_conflicts.append(('contents conflict', file_group))
1333
1118
# See SPOT run. run, SPOT, run.
1334
1119
# So we're not QUITE repeating ourselves; we do tricky things with
1336
1121
base_pair = contents_pair(self.base_tree)
1337
1122
other_pair = contents_pair(self.other_tree)
1339
this_pair = contents_pair(self.this_tree)
1340
lca_pairs = [contents_pair(tree) for tree in self._lca_trees]
1341
winner = self._lca_multi_way((base_pair, lca_pairs), other_pair,
1342
this_pair, allow_overriding_lca=False)
1344
if base_pair == other_pair:
1347
# We delayed evaluating this_pair as long as we can to avoid
1348
# unnecessary sha1 calculation
1349
this_pair = contents_pair(self.this_tree)
1350
winner = self._three_way(base_pair, other_pair, this_pair)
1351
if winner == 'this':
1352
# No interesting changes introduced by OTHER
1354
# We have a hypothetical conflict, but if we have files, then we
1355
# can try to merge the content
1356
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':
1445
# 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
1458
return 'not_applicable', None
1123
if base_pair == other_pair:
1124
# OTHER introduced no changes
1126
this_pair = contents_pair(self.this_tree)
1127
if this_pair == other_pair:
1128
# THIS and OTHER introduced the same changes
1131
trans_id = self.tt.trans_id_file_id(file_id)
1132
if this_pair == base_pair:
1133
# only OTHER introduced changes
1134
if file_id in self.this_tree:
1135
# Remove any existing contents
1136
self.tt.delete_contents(trans_id)
1137
if file_id in self.other_tree:
1138
# OTHER changed the file
1139
create_from_tree(self.tt, trans_id,
1140
self.other_tree, file_id)
1141
if file_id not in self.this_tree:
1142
self.tt.version_file(file_id, trans_id)
1144
elif file_id in self.this_tree.inventory:
1145
# OTHER deleted the file
1146
self.tt.unversion_file(trans_id)
1148
#BOTH THIS and OTHER introduced changes; scalar conflict
1149
elif this_pair[0] == "file" and other_pair[0] == "file":
1150
# THIS and OTHER are both files, so text merge. Either
1151
# BASE is a file, or both converted to files, so at least we
1152
# have agreement that output should be a file.
1154
self.text_merge(file_id, trans_id)
1156
return contents_conflict()
1157
if file_id not in self.this_tree:
1158
self.tt.version_file(file_id, trans_id)
1160
self.tt.tree_kind(trans_id)
1161
self.tt.delete_contents(trans_id)
1166
# Scalar conflict, can't text merge. Dump conflicts
1167
return contents_conflict()
1460
1169
def get_lines(self, tree, file_id):
1461
1170
"""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)
1172
return tree.get_file(file_id).readlines()
1516
1225
determined automatically. If set_version is true, the .OTHER, .THIS
1517
1226
or .BASE (in that order) will be created as versioned files.
1519
data = [('OTHER', self.other_tree, other_lines),
1228
data = [('OTHER', self.other_tree, other_lines),
1520
1229
('THIS', self.this_tree, this_lines)]
1521
1230
if not no_base:
1522
1231
data.append(('BASE', self.base_tree, base_lines))
1524
# We need to use the actual path in the working tree of the file here,
1525
# ignoring the conflict suffixes
1527
if wt.supports_content_filtering():
1529
filter_tree_path = wt.id2path(file_id)
1530
except errors.NoSuchId:
1531
# file has been deleted
1532
filter_tree_path = None
1534
# Skip the id2path lookup for older formats
1535
filter_tree_path = None
1537
1232
versioned = False
1538
1233
file_group = []
1539
1234
for suffix, tree, lines in data:
1540
if tree.has_id(file_id):
1541
1236
trans_id = self._conflict_file(name, parent_id, tree, file_id,
1542
suffix, lines, filter_tree_path)
1543
1238
file_group.append(trans_id)
1544
1239
if set_version and not versioned:
1545
1240
self.tt.version_file(file_id, trans_id)
1546
1241
versioned = True
1547
1242
return file_group
1549
1244
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
1550
lines=None, filter_tree_path=None):
1551
1246
"""Emit a single conflict file."""
1552
1247
name = name + '.' + suffix
1553
1248
trans_id = self.tt.create_path(name, parent_id)
1554
transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
1249
create_from_tree(self.tt, trans_id, tree, file_id, lines)
1556
1250
return trans_id
1558
1252
def merge_executable(self, file_id, file_status):
1634
1316
if path.endswith(suffix):
1635
1317
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':
1319
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1320
self.cooked_conflicts.append(c)
1321
if conflict_type == 'text conflict':
1640
1322
trans_id = conflict[1]
1641
1323
path = fp.get_path(trans_id)
1642
1324
file_id = self.tt.final_file_id(trans_id)
1643
c = _mod_conflicts.Conflict.factory(conflict_type,
1644
path=path, file_id=file_id)
1325
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1326
self.cooked_conflicts.append(c)
1328
for trans_id, conflicts in name_conflicts.iteritems():
1330
this_parent, other_parent = conflicts['parent conflict']
1331
if this_parent == other_parent:
1332
raise AssertionError()
1334
this_parent = other_parent = \
1335
self.tt.final_file_id(self.tt.final_parent(trans_id))
1337
this_name, other_name = conflicts['name conflict']
1338
if this_name == other_name:
1339
raise AssertionError()
1341
this_name = other_name = self.tt.final_name(trans_id)
1342
other_path = fp.get_path(trans_id)
1343
if this_parent is not None and this_name is not None:
1344
this_parent_path = \
1345
fp.get_path(self.tt.trans_id_file_id(this_parent))
1346
this_path = pathjoin(this_parent_path, this_name)
1646
raise AssertionError('bad conflict type: %r' % (conflict,))
1348
this_path = "<deleted>"
1349
file_id = self.tt.final_file_id(trans_id)
1350
c = Conflict.factory('path conflict', path=this_path,
1351
conflict_path=other_path, file_id=file_id)
1647
1352
self.cooked_conflicts.append(c)
1648
self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1353
self.cooked_conflicts.sort(key=Conflict.sort_key)
1651
1356
class WeaveMerger(Merge3Merger):
1655
1360
supports_reverse_cherrypick = False
1656
1361
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,
1363
def _merged_lines(self, file_id):
1364
"""Generate the merged lines.
1365
There is no distinction between lines that are meant to contain <<<<<<<
1369
base = self.base_tree
1372
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
1374
if 'merge' in debug.debug_flags:
1673
1375
plan = list(plan)
1674
1376
trans_id = self.tt.trans_id_file_id(file_id)
1675
1377
name = self.tt.final_name(trans_id) + '.plan'
1676
contents = ('%11s|%s' % l for l in plan)
1378
contents = ('%10s|%s' % l for l in plan)
1677
1379
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
1380
textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1381
'>>>>>>> MERGE-SOURCE\n')
1382
return textmerge.merge_lines(self.reprocess)
1687
1384
def text_merge(self, file_id, trans_id):
1688
1385
"""Perform a (weave) text merge for a given file and file-id.
1689
1386
If conflicts are encountered, .THIS and .OTHER files will be emitted,
1690
1387
and a conflict will be noted.
1692
lines, base_lines = self._merged_lines(file_id)
1389
lines, conflicts = self._merged_lines(file_id)
1693
1390
lines = list(lines)
1694
# Note we're checking whether the OUTPUT is binary in this case,
1391
# Note we're checking whether the OUTPUT is binary in this case,
1695
1392
# because we don't want to get into weave merge guts.
1696
textfile.check_text_lines(lines)
1393
check_text_lines(lines)
1697
1394
self.tt.create_file(lines, trans_id)
1698
if base_lines is not None:
1700
1396
self._raw_conflicts.append(('text conflict', trans_id))
1701
1397
name = self.tt.final_name(trans_id)
1702
1398
parent_id = self.tt.final_parent(trans_id)
1703
file_group = self._dump_conflicts(name, parent_id, file_id,
1705
base_lines=base_lines)
1399
file_group = self._dump_conflicts(name, parent_id, file_id,
1706
1401
file_group.append(trans_id)
1709
1404
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,
1406
def _merged_lines(self, file_id):
1407
"""Generate the merged lines.
1408
There is no distinction between lines that are meant to contain <<<<<<<
1412
base = self.base_tree
1415
plan = self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1417
if 'merge' in debug.debug_flags:
1419
trans_id = self.tt.trans_id_file_id(file_id)
1420
name = self.tt.final_name(trans_id) + '.plan'
1421
contents = ('%10s|%s' % l for l in plan)
1422
self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1423
textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1424
'>>>>>>> MERGE-SOURCE\n')
1425
return textmerge.merge_lines(self.reprocess)
1715
1428
class Diff3Merger(Merge3Merger):
1716
1429
"""Three-way merger using external diff3 for text merging"""
1718
1431
def dump_file(self, temp_dir, name, tree, file_id):
1719
out_path = osutils.pathjoin(temp_dir, name)
1432
out_path = pathjoin(temp_dir, name)
1720
1433
out_file = open(out_path, "wb")
1722
1435
in_file = tree.get_file(file_id)
added
removed
bzrlib/merge.py
