pyproject: lock in the major version of `black` that's required
The `hghave` checks already look for an exact this minor version of this, but
according to their Stability Policy[1], we can use any version with the same
major number. The reason for adding this here is we don't want someone to
blindly run the tool and get a different format because they were running a
different major version locally. It also makes it easier to discover when the
required version has changed, because that's included in the error message.
If there's concern about duplication and forgetting to update one place or the
other, we can pipe a trivial python statement to it, and see if it exits with a
failure. FWIW, having it in the project file here is also enforced when running
`test-check-format.t`. It's not enforced by the `hghave` version check, so if
it gets out of sync, the test will run and print:
Oh no! \xf0\x9f\x92\xa5 \xf0\x9f\x92\x94 \xf0\x9f\x92\xa5 The required version `24` does not match the running version `23.3.0`!
[1] https://github.com/psf/black/blob/30759ca782429221cfb329f335e2074cb359decb/docs/the_black_code_style/index.md?plain=1#L24
# 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