( )⚙ D11967 simplemerge: rewrite `merge_lines()` using `merge_groups()`

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11967

simplemerge: rewrite `merge_lines()` using `merge_groups()`
ClosedPublic

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

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG88a45330b290: simplemerge: rewrite `merge_lines()` using `merge_groups()`
rHG95f9ecd911dd: simplemerge: rewrite `merge_lines()` using `merge_groups()`
Summary

Simple is better.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

martinvonz created this revision.Jan 6 2022, 3:35 PM
martinvonz added a comment.EditedJan 6 2022, 3:38 PM

I refactored it a bit to try to convince pytype. That resulted in D11966. I still don't understand what pytype was thinking. It didn't help to add explicit type annotations (something like Union[Tuple[bytes, List[bytes]], Tuple[bytes, List[bytes], List[bytes], List[bytes]]]).

Alphare accepted this revision.Jan 7 2022, 4:52 AM
Alphare added a subscriber: Alphare.

Superseeds D11904

This revision is now accepted and ready to land.Jan 7 2022, 4:52 AM

Revision Contents
Changeset List

PathPackages
Mmercurial/simplemerge.py (83 lines)

Diff 31620

mercurial/simplemerge.py

elif self.a[0].endswith(b'\r'): elif self.a[0].endswith(b'\r'):
newline = b'\r' newline = b'\r'
if name_a and start_marker: if name_a and start_marker:
start_marker = start_marker + b' ' + name_a start_marker = start_marker + b' ' + name_a
if name_b and end_marker: if name_b and end_marker:
end_marker = end_marker + b' ' + name_b end_marker = end_marker + b' ' + name_b
if name_base and base_marker: if name_base and base_marker:
base_marker = base_marker + b' ' + name_base base_marker = base_marker + b' ' + name_base
merge_regions = self.merge_regions() merge_groups = self.merge_groups()
if minimize: if minimize:
merge_regions = self.minimize(merge_regions) merge_groups = self.minimize(merge_groups)
for t in merge_regions: for what, lines in merge_groups:
what = t[0] if what == b'conflict':
if what == b'unchanged': base_lines, a_lines, b_lines = lines
for i in range(t[1], t[2]):
yield self.base[i]
elif what == b'a' or what == b'same':
for i in range(t[1], t[2]):
yield self.a[i]
elif what == b'b':
for i in range(t[1], t[2]):
yield self.b[i]
elif what == b'conflict':
self.conflicts = True self.conflicts = True
if start_marker is not None: if start_marker is not None:
yield start_marker + newline yield start_marker + newline
for i in range(t[3], t[4]): for line in a_lines:
yield self.a[i] yield line
if base_marker is not None: if base_marker is not None:
yield base_marker + newline yield base_marker + newline
for i in range(t[1], t[2]): for line in base_lines:
yield self.base[i] yield line
if mid_marker is not None: if mid_marker is not None:
yield mid_marker + newline yield mid_marker + newline
for i in range(t[5], t[6]): for line in b_lines:
yield self.b[i] yield line
if end_marker is not None: if end_marker is not None:
yield end_marker + newline yield end_marker + newline
else: else:
raise ValueError(what) for line in lines:
yield line
def merge_groups(self): def merge_groups(self):
"""Yield sequence of line groups. Each one is a tuple: """Yield sequence of line groups. Each one is a tuple:
'unchanged', lines 'unchanged', lines
Lines unchanged from base Lines unchanged from base
'a', lines 'a', lines
assert ib == bmatch assert ib == bmatch
assert iz == zmatch assert iz == zmatch
yield b'unchanged', zmatch, zend yield b'unchanged', zmatch, zend
iz = zend iz = zend
ia = aend ia = aend
ib = bend ib = bend
def minimize(self, merge_regions): def minimize(self, merge_groups):
"""Trim conflict regions of lines where A and B sides match. """Trim conflict regions of lines where A and B sides match.
Lines where both A and B have made the same changes at the beginning Lines where both A and B have made the same changes at the beginning
or the end of each merge region are eliminated from the conflict or the end of each merge region are eliminated from the conflict
region and are instead considered the same. region and are instead considered the same.
""" """
for region in merge_regions: for what, lines in merge_groups:
if region[0] != b"conflict": if what != b"conflict":
yield region yield what, lines
continue continue
# pytype thinks this tuple contains only 3 things, but base_lines, a_lines, b_lines = lines
# that's clearly not true because this code successfully alen = len(a_lines)
# executes. It might be wise to rework merge_regions to be blen = len(b_lines)
# some kind of attrs type.
(
issue,
z1,
z2,
a1,
a2,
b1,
b2,
) = region # pytype: disable=bad-unpacking
alen = a2 - a1
blen = b2 - b1
# find matches at the front # find matches at the front
ii = 0 ii = 0
while ( while ii < alen and ii < blen and a_lines[ii] == b_lines[ii]:
ii < alen and ii < blen and self.a[a1 + ii] == self.b[b1 + ii]
):
ii += 1 ii += 1
startmatches = ii startmatches = ii
# find matches at the end # find matches at the end
ii = 0 ii = 0
while ( while (
ii < alen ii < alen and ii < blen and a_lines[-ii - 1] == b_lines[-ii - 1]
and ii < blen
and self.a[a2 - ii - 1] == self.b[b2 - ii - 1]
): ):
ii += 1 ii += 1
endmatches = ii endmatches = ii
if startmatches > 0: if startmatches > 0:
yield b'same', a1, a1 + startmatches yield b'same', a_lines[:startmatches]
yield ( yield (
b'conflict', b'conflict',
z1, (
z2, base_lines,
a1 + startmatches, a_lines[startmatches : alen - endmatches],
a2 - endmatches, b_lines[startmatches : blen - endmatches],
b1 + startmatches, ),
b2 - endmatches,
) )
if endmatches > 0: if endmatches > 0:
yield b'same', a2 - endmatches, a2 yield b'same', a_lines[alen - endmatches :]
def find_sync_regions(self): def find_sync_regions(self):
"""Return a list of sync regions, where both descendants match the base. """Return a list of sync regions, where both descendants match the base.
Generates a list of (base1, base2, a1, a2, b1, b2). There is Generates a list of (base1, base2, a1, a2, b1, b2). There is
always a zero-length sync region at the end of all the files. always a zero-length sync region at the end of all the files.
""" """