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
534
winner_idx = {"this": 2, "other": 1, "conflict": 1}
740
535
supports_lca_trees = True
742
def __init__(self, working_tree, this_tree, base_tree, other_tree,
537
def __init__(self, working_tree, this_tree, base_tree, other_tree,
743
538
interesting_ids=None, reprocess=False, show_base=False,
744
pb=None, pp=None, change_reporter=None,
539
pb=DummyProgress(), pp=None, change_reporter=None,
745
540
interesting_files=None, do_merge=True,
746
cherrypick=False, lca_trees=None, this_branch=None):
541
cherrypick=False, lca_trees=None):
747
542
"""Initialize the merger object and perform the merge.
749
544
:param working_tree: The working tree to apply the merge to
750
545
:param this_tree: The local tree in the merge operation
751
546
: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.
547
:param other_tree: The other other tree to merge changes from
755
548
:param interesting_ids: The file_ids of files that should be
756
549
participate in the merge. May not be combined with
757
550
interesting_files.
758
551
:param: reprocess If True, perform conflict-reduction processing.
759
552
:param show_base: If True, show the base revision in text conflicts.
760
553
(incompatible with reprocess)
554
:param pb: A Progress bar
762
555
:param pp: A ProgressPhase object
763
556
:param change_reporter: An object that should report changes made
764
557
:param interesting_files: The tree-relative paths of files that should
793
583
# making sure we haven't missed any corner cases.
794
584
# if lca_trees is None:
795
585
# self._lca_trees = [self.base_tree]
796
588
self.change_reporter = change_reporter
797
589
self.cherrypick = cherrypick
591
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
595
def do_merge(self):
806
operation = OperationWithCleanups(self._do_merge)
807
596
self.this_tree.lock_tree_write()
808
operation.add_cleanup(self.this_tree.unlock)
809
597
self.base_tree.lock_read()
810
operation.add_cleanup(self.base_tree.unlock)
811
598
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)
599
self.tt = TreeTransform(self.this_tree, self.pb)
822
self.this_tree.add_conflicts(self.cooked_conflicts)
823
except errors.UnsupportedOperation:
602
self._compute_transform()
604
results = self.tt.apply(no_conflicts=True)
605
self.write_modified(results)
607
self.this_tree.add_conflicts(self.cooked_conflicts)
608
except UnsupportedOperation:
612
self.other_tree.unlock()
613
self.base_tree.unlock()
614
self.this_tree.unlock()
826
617
def make_preview_transform(self):
827
operation = OperationWithCleanups(self._make_preview_transform)
828
618
self.base_tree.lock_read()
829
operation.add_cleanup(self.base_tree.unlock)
830
619
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()
620
self.tt = TransformPreview(self.this_tree)
623
self._compute_transform()
626
self.other_tree.unlock()
627
self.base_tree.unlock()
839
631
def _compute_transform(self):
1091
882
other_root = self.tt.trans_id_file_id(other_root_file_id)
1092
883
if other_root == self.tt.root:
886
self.tt.final_kind(other_root)
1094
889
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)
890
# 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():
892
self.reparent_children(self.other_tree.inventory.root, self.tt.root)
893
self.tt.cancel_creation(other_root)
894
self.tt.cancel_versioning(other_root)
896
def reparent_children(self, ie, target):
897
for thing, child in ie.children.iteritems():
1109
898
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)
899
self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1127
901
def write_modified(self, results):
1128
902
modified_hashes = {}
1296
1067
parent_id_winner = "other"
1297
1068
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))
1070
if name_winner == "conflict":
1071
trans_id = self.tt.trans_id_file_id(file_id)
1072
self._raw_conflicts.append(('name conflict', trans_id,
1073
this_name, other_name))
1074
if parent_id_winner == "conflict":
1075
trans_id = self.tt.trans_id_file_id(file_id)
1076
self._raw_conflicts.append(('parent conflict', trans_id,
1077
this_parent, other_parent))
1307
1078
if other_name is None:
1308
# it doesn't matter whether the result was 'other' or
1079
# it doesn't matter whether the result was 'other' or
1309
1080
# 'conflict'-- if there's no 'other', we leave it alone.
1082
# if we get here, name_winner and parent_winner are set to safe values.
1083
trans_id = self.tt.trans_id_file_id(file_id)
1311
1084
parent_id = parents[self.winner_idx[parent_id_winner]]
1312
1085
if parent_id is not None:
1313
# if we get here, name_winner and parent_winner are set to safe
1086
parent_trans_id = self.tt.trans_id_file_id(parent_id)
1315
1087
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))
1088
parent_trans_id, trans_id)
1319
def _do_merge_contents(self, file_id):
1090
def merge_contents(self, file_id):
1320
1091
"""Performs a merge on file_id contents."""
1321
1092
def contents_pair(tree):
1322
1093
if file_id not in tree:
1351
1134
if winner == 'this':
1352
1135
# No interesting changes introduced by OTHER
1353
1136
return "unmodified"
1354
# We have a hypothetical conflict, but if we have files, then we
1355
# can try to merge the content
1356
1137
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':
1138
if winner == 'other':
1445
1139
# 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
1140
file_in_this = file_id in self.this_tree
1142
# Remove any existing contents
1143
self.tt.delete_contents(trans_id)
1144
if file_id in self.other_tree:
1145
# OTHER changed the file
1146
create_from_tree(self.tt, trans_id,
1147
self.other_tree, file_id)
1148
if not file_in_this:
1149
self.tt.version_file(file_id, trans_id)
1152
# OTHER deleted the file
1153
self.tt.unversion_file(trans_id)
1458
return 'not_applicable', None
1156
# We have a hypothetical conflict, but if we have files, then we
1157
# can try to merge the content
1158
if this_pair[0] == 'file' and other_pair[0] == 'file':
1159
# THIS and OTHER are both files, so text merge. Either
1160
# BASE is a file, or both converted to files, so at least we
1161
# have agreement that output should be a file.
1163
self.text_merge(file_id, trans_id)
1165
return contents_conflict()
1166
if file_id not in self.this_tree:
1167
self.tt.version_file(file_id, trans_id)
1169
self.tt.tree_kind(trans_id)
1170
self.tt.delete_contents(trans_id)
1175
return contents_conflict()
1460
1177
def get_lines(self, tree, file_id):
1461
1178
"""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)
1180
return tree.get_file(file_id).readlines()
1516
1233
determined automatically. If set_version is true, the .OTHER, .THIS
1517
1234
or .BASE (in that order) will be created as versioned files.
1519
data = [('OTHER', self.other_tree, other_lines),
1236
data = [('OTHER', self.other_tree, other_lines),
1520
1237
('THIS', self.this_tree, this_lines)]
1521
1238
if not no_base:
1522
1239
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
1240
versioned = False
1538
1241
file_group = []
1539
1242
for suffix, tree, lines in data:
1540
if tree.has_id(file_id):
1541
1244
trans_id = self._conflict_file(name, parent_id, tree, file_id,
1542
suffix, lines, filter_tree_path)
1543
1246
file_group.append(trans_id)
1544
1247
if set_version and not versioned:
1545
1248
self.tt.version_file(file_id, trans_id)
1546
1249
versioned = True
1547
1250
return file_group
1549
1252
def _conflict_file(self, name, parent_id, tree, file_id, suffix,
1550
lines=None, filter_tree_path=None):
1551
1254
"""Emit a single conflict file."""
1552
1255
name = name + '.' + suffix
1553
1256
trans_id = self.tt.create_path(name, parent_id)
1554
transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
1257
create_from_tree(self.tt, trans_id, tree, file_id, lines)
1556
1258
return trans_id
1558
1260
def merge_executable(self, file_id, file_status):
1634
1324
if path.endswith(suffix):
1635
1325
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':
1327
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1328
self.cooked_conflicts.append(c)
1329
if conflict_type == 'text conflict':
1640
1330
trans_id = conflict[1]
1641
1331
path = fp.get_path(trans_id)
1642
1332
file_id = self.tt.final_file_id(trans_id)
1643
c = _mod_conflicts.Conflict.factory(conflict_type,
1644
path=path, file_id=file_id)
1333
c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1334
self.cooked_conflicts.append(c)
1336
for trans_id, conflicts in name_conflicts.iteritems():
1338
this_parent, other_parent = conflicts['parent conflict']
1339
if this_parent == other_parent:
1340
raise AssertionError()
1342
this_parent = other_parent = \
1343
self.tt.final_file_id(self.tt.final_parent(trans_id))
1345
this_name, other_name = conflicts['name conflict']
1346
if this_name == other_name:
1347
raise AssertionError()
1349
this_name = other_name = self.tt.final_name(trans_id)
1350
other_path = fp.get_path(trans_id)
1351
if this_parent is not None and this_name is not None:
1352
this_parent_path = \
1353
fp.get_path(self.tt.trans_id_file_id(this_parent))
1354
this_path = pathjoin(this_parent_path, this_name)
1646
raise AssertionError('bad conflict type: %r' % (conflict,))
1356
this_path = "<deleted>"
1357
file_id = self.tt.final_file_id(trans_id)
1358
c = Conflict.factory('path conflict', path=this_path,
1359
conflict_path=other_path, file_id=file_id)
1647
1360
self.cooked_conflicts.append(c)
1648
self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1361
self.cooked_conflicts.sort(key=Conflict.sort_key)
1651
1364
class WeaveMerger(Merge3Merger):
1655
1368
supports_reverse_cherrypick = False
1656
1369
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,
1371
def _merged_lines(self, file_id):
1372
"""Generate the merged lines.
1373
There is no distinction between lines that are meant to contain <<<<<<<
1377
base = self.base_tree
1380
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
1382
if 'merge' in debug.debug_flags:
1673
1383
plan = list(plan)
1674
1384
trans_id = self.tt.trans_id_file_id(file_id)
1675
1385
name = self.tt.final_name(trans_id) + '.plan'
1676
contents = ('%11s|%s' % l for l in plan)
1386
contents = ('%10s|%s' % l for l in plan)
1677
1387
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
1388
textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1389
'>>>>>>> MERGE-SOURCE\n')
1390
return textmerge.merge_lines(self.reprocess)
1687
1392
def text_merge(self, file_id, trans_id):
1688
1393
"""Perform a (weave) text merge for a given file and file-id.
1689
1394
If conflicts are encountered, .THIS and .OTHER files will be emitted,
1690
1395
and a conflict will be noted.
1692
lines, base_lines = self._merged_lines(file_id)
1397
lines, conflicts = self._merged_lines(file_id)
1693
1398
lines = list(lines)
1694
# Note we're checking whether the OUTPUT is binary in this case,
1399
# Note we're checking whether the OUTPUT is binary in this case,
1695
1400
# because we don't want to get into weave merge guts.
1696
textfile.check_text_lines(lines)
1401
check_text_lines(lines)
1697
1402
self.tt.create_file(lines, trans_id)
1698
if base_lines is not None:
1700
1404
self._raw_conflicts.append(('text conflict', trans_id))
1701
1405
name = self.tt.final_name(trans_id)
1702
1406
parent_id = self.tt.final_parent(trans_id)
1703
file_group = self._dump_conflicts(name, parent_id, file_id,
1705
base_lines=base_lines)
1407
file_group = self._dump_conflicts(name, parent_id, file_id,
1706
1409
file_group.append(trans_id)
1709
1412
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,
1414
def _merged_lines(self, file_id):
1415
"""Generate the merged lines.
1416
There is no distinction between lines that are meant to contain <<<<<<<
1420
base = self.base_tree
1423
plan = self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1425
if 'merge' in debug.debug_flags:
1427
trans_id = self.tt.trans_id_file_id(file_id)
1428
name = self.tt.final_name(trans_id) + '.plan'
1429
contents = ('%10s|%s' % l for l in plan)
1430
self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1431
textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1432
'>>>>>>> MERGE-SOURCE\n')
1433
return textmerge.merge_lines(self.reprocess)
1715
1436
class Diff3Merger(Merge3Merger):
1716
1437
"""Three-way merger using external diff3 for text merging"""
1718
1439
def dump_file(self, temp_dir, name, tree, file_id):
1719
out_path = osutils.pathjoin(temp_dir, name)
1440
out_path = pathjoin(temp_dir, name)
1720
1441
out_file = open(out_path, "wb")
1722
1443
in_file = tree.get_file(file_id)
added
removed
bzrlib/merge.py
