##// END OF EJS Templates
upstream » mercurial-mirror
RSS

Clone from https://www.mercurial-scm.org/repo/hg-all

interfaces: add the optional `bdiff.xdiffblocks()` method...
interfaces: add the optional `bdiff.xdiffblocks()` method PyCharm flagged where this was called on the protocol class in `mdiff.py` in the previous commit, but pytype completely missed it. PyCharm is correct here, but I'm committing this separately to highlight this potential problem- some of the implementations don't implement _all_ of the methods the others do, and there's not a great way to indicate on a protocol class that a method or attribute is optional- that's kinda the opposite of what static typing is about. Making the method an `Optional[Callable]` attribute works here, and keeps both PyCharm and pytype happy, and the generated `mdiff.pyi` and `modules.pyi` look reasonable. We might be getting a little lucky, because the method isn't invoked directly- it is returned from another method that selects which block function to use. Except since it is declared on the protocol class, every module needs this attribute (in theory, but in practice this doesn't seem to be checked), so the check for it on the module has to change from `hasattr()` to `getattr(..., None)`. We defer defining the optional attrs to the type checking phase as an extra precaution- that way it isn't an attr with a `None` value at runtime if someone is still using `hasattr()`. As to why pytype missed this, I have no clue. The generated `mdiff.pyi` even has the global variable typed as `bdiff: intmod.BDiff`, so uses of it really should comply with what is on the class, protocol class or not.
Matt Harbison - - Load All Authors

File last commit:

r52756:f4733654 default
r52827:09f3a679 default
Show More
diffhelper.py
82 lines | 2.3 KiB | text/x-python | PythonLexer
/ mercurial / diffhelper.py
History | Annotation | Raw |Copy content |Copy permalink
# diffhelper.py - helper routines for patch
#
# Copyright 2009 Olivia Mackall <olivia@selenic.com> and others
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import annotations
from .i18n import _
from . import (
error,
)
MISSING_NEWLINE_MARKER = b'\\ No newline at end of file\n'
def addlines(fp, hunk, lena, lenb, a, b):
"""Read lines from fp into the hunk
The hunk is parsed into two arrays, a and b. a gets the old state of
the text, b gets the new state. The control char from the hunk is saved
when inserting into a, but not b (for performance while deleting files.)
"""
while True:
todoa = lena - len(a)
todob = lenb - len(b)
num = max(todoa, todob)
if num == 0:
break
for i in range(num):
s = fp.readline()
if not s:
raise error.ParseError(_(b'incomplete hunk'))
if s == MISSING_NEWLINE_MARKER:
fixnewline(hunk, a, b)
continue
if s == b'\n' or s == b'\r\n':
# Some patches may be missing the control char
# on empty lines. Supply a leading space.
s = b' ' + s
hunk.append(s)
if s.startswith(b'+'):
b.append(s[1:])
elif s.startswith(b'-'):
a.append(s)
else:
b.append(s[1:])
a.append(s)
def fixnewline(hunk, a, b):
"""Fix up the last lines of a and b when the patch has no newline at EOF"""
l = hunk[-1]
# tolerate CRLF in last line
if l.endswith(b'\r\n'):
hline = l[:-2]
else:
hline = l[:-1]
if hline.startswith((b' ', b'+')):
b[-1] = hline[1:]
if hline.startswith((b' ', b'-')):
a[-1] = hline
hunk[-1] = hline
def testhunk(a, b, bstart):
"""Compare the lines in a with the lines in b
a is assumed to have a control char at the start of each line, this char
is ignored in the compare.
"""
alen = len(a)
blen = len(b)
if alen > blen - bstart or bstart < 0:
return False
for i in range(alen):
if a[i][1:] != b[i + bstart]:
return False
return True