( )⚙ D11966 simplemerge: make merge_groups() yield only 2-tuples

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11966

simplemerge: make merge_groups() yield only 2-tuples
ClosedPublic

Authored by martinvonz on Jan 6 2022, 3:34 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG374bf34c9ffd: simplemerge: make merge_groups() yield only 2-tuples
rHG9e2355cc5e69: simplemerge: make merge_groups() yield only 2-tuples
Summary

merge_groups() currently yields 2-tuples or 4-tuples, making the
callers check the first element to decide how to interpret the
rest. Let's make it yield only 2-tuples, thereby simplifying life a
little for the callers.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

PathPackages
Mmercurial/simplemerge.py (26 lines)
Mtests/test-simplemerge.py (2 lines)

Diff 31606

mercurial/simplemerge.py

Lines taken from a Lines taken from a
'same', lines 'same', lines
Lines taken from a (and equal to b) Lines taken from a (and equal to b)
'b', lines 'b', lines
Lines taken from b Lines taken from b
'conflict', base_lines, a_lines, b_lines 'conflict', (base_lines, a_lines, b_lines)
Lines from base were changed to either a or b and conflict. Lines from base were changed to either a or b and conflict.
""" """
for t in self.merge_regions(): for t in self.merge_regions():
what = t[0] what = t[0]
if what == b'unchanged': if what == b'unchanged':
yield what, self.base[t[1] : t[2]] yield what, self.base[t[1] : t[2]]
elif what == b'a' or what == b'same': elif what == b'a' or what == b'same':
yield what, self.a[t[1] : t[2]] yield what, self.a[t[1] : t[2]]
elif what == b'b': elif what == b'b':
yield what, self.b[t[1] : t[2]] yield what, self.b[t[1] : t[2]]
elif what == b'conflict': elif what == b'conflict':
yield ( yield (
what, what,
(
self.base[t[1] : t[2]], self.base[t[1] : t[2]],
self.a[t[3] : t[4]], self.a[t[3] : t[4]],
self.b[t[5] : t[6]], self.b[t[5] : t[6]],
),
) )
else: else:
raise ValueError(what) raise ValueError(what)
def merge_regions(self): def merge_regions(self):
"""Return sequences of matching and conflicting regions. """Return sequences of matching and conflicting regions.
This returns tuples, where the first value says what kind we This returns tuples, where the first value says what kind we
for i, override in enumerate(overrides): for i, override in enumerate(overrides):
result[i] = override result[i] = override
return result return result
def _mergediff(m3, name_a, name_b, name_base): def _mergediff(m3, name_a, name_b, name_base):
lines = [] lines = []
conflicts = False conflicts = False
for group in m3.merge_groups(): for what, group_lines in m3.merge_groups():
if group[0] == b'conflict': if what == b'conflict':
base_lines, a_lines, b_lines = group[1:] base_lines, a_lines, b_lines = group_lines
base_text = b''.join(base_lines) base_text = b''.join(base_lines)
b_blocks = list( b_blocks = list(
mdiff.allblocks( mdiff.allblocks(
base_text, base_text,
b''.join(b_lines), b''.join(b_lines),
lines1=base_lines, lines1=base_lines,
lines2=b_lines, lines2=b_lines,
) )
lines.append(b"------- %s\n" % name_base) lines.append(b"------- %s\n" % name_base)
lines.append(b"+++++++ %s\n" % name_a) lines.append(b"+++++++ %s\n" % name_a)
lines.extend(diff_lines(a_blocks, base_lines, a_lines)) lines.extend(diff_lines(a_blocks, base_lines, a_lines))
lines.append(b"======= %s\n" % name_b) lines.append(b"======= %s\n" % name_b)
lines.extend(b_lines) lines.extend(b_lines)
lines.append(b">>>>>>>\n") lines.append(b">>>>>>>\n")
conflicts = True conflicts = True
else: else:
lines.extend(group[1]) lines.extend(group_lines)
return lines, conflicts return lines, conflicts
def _resolve(m3, sides): def _resolve(m3, sides):
lines = [] lines = []
for group in m3.merge_groups(): for what, group_lines in m3.merge_groups():
if group[0] == b'conflict': if what == b'conflict':
for side in sides: for side in sides:
lines.extend(group[side + 1]) lines.extend(group_lines[side])
else: else:
lines.extend(group[1]) lines.extend(group_lines)
return lines return lines
def simplemerge(ui, localctx, basectx, otherctx, **opts): def simplemerge(ui, localctx, basectx, otherctx, **opts):
"""Performs the simplemerge algorithm. """Performs the simplemerge algorithm.
The merged result is written into `localctx`. The merged result is written into `localctx`.
""" """

tests/test-simplemerge.py

(b'unchanged', 1, 2), (b'unchanged', 1, 2),
], ],
) )
self.assertEqual( self.assertEqual(
list(m3.merge_groups()), list(m3.merge_groups()),
[ [
(b'unchanged', [b'aaa\n']), (b'unchanged', [b'aaa\n']),
(b'conflict', [], [b'111\n'], [b'222\n']), (b'conflict', ([], [b'111\n'], [b'222\n'])),
(b'unchanged', [b'bbb\n']), (b'unchanged', [b'bbb\n']),
], ],
) )
ml = m3.merge_lines( ml = m3.merge_lines(
name_a=b'a', name_a=b'a',
name_b=b'b', name_b=b'b',
start_marker=b'<<', start_marker=b'<<',