Use a pyparsing PEG parser rather than a load of regexes, even if it means monkeypatching part of coverage.py

Author: domdfcoding

.bumpversion.cfg

@@ -1,14 +1,16 @@
 [bumpversion]
-current_version = 0.0.6
+current_version = 0.2.0
 commit = True
 tag = True
 
+[bumpversion:file:pyproject.toml]
+
+[bumpversion:file:repo_helper.yml]
+
 [bumpversion:file:__pkginfo__.py]
 
 [bumpversion:file:README.rst]
 
 [bumpversion:file:doc-source/index.rst]
 
-[bumpversion:file:repo_helper.yml]
-
 [bumpversion:file:coverage_pyver_pragma/__init__.py]

README.rst

@@ -101,7 +101,7 @@ coverage_pyver_pragma
 .. |language| image:: https://img.shields.io/github/languages/top/domdfcoding/coverage_pyver_pragma
 	:alt: GitHub top language
 
-.. |commits-since| image:: https://img.shields.io/github/commits-since/domdfcoding/coverage_pyver_pragma/v0.0.6
+.. |commits-since| image:: https://img.shields.io/github/commits-since/domdfcoding/coverage_pyver_pragma/v0.2.0
 	:target: https://github.com/domdfcoding/coverage_pyver_pragma/pulse
 	:alt: GitHub commits since tagged version
 

__pkginfo__.py

@@ -26,8 +26,7 @@
 2020-2021 Dominic Davis-Foster <[email protected]>
 """
 
-__version__ = "0.0.6"
-
+__version__ = "0.2.0"
 repo_root = pathlib.Path(__file__).parent
 install_requires = (repo_root / "requirements.txt").read_text(encoding="utf-8").split('\n')
 extras_require = {"all": []}

cov-report.ini

@@ -0,0 +1,13 @@
+[run]
+plugins = coverage_pyver_pragma
+
+[report]
+fail_under = 80
+exclude_lines =
+    raise AssertionError
+    raise NotImplementedError
+    if 0:
+    if False:
+    if TYPE_CHECKING:
+    if typing.TYPE_CHECKING:
+    if __name__ == .__main__.:

coverage_pyver_pragma/__init__.py

@@ -2,9 +2,8 @@
 #
 #  __init__.py
 """
-Plugin for `Coverage.py <https://coverage.readthedocs.io/en/coverage-5.3/>`_
-to selectively ignore branches depending on the Python version.
-"""  # noqa: D400
+Plugin for Coverage.py to selectively ignore branches depending on the Python version.
+"""
 #
 #  Copyright © 2020-2021 Dominic Davis-Foster <[email protected]>
 #
@@ -28,175 +27,74 @@
 #
 
 # stdlib
-import platform
 import re
-import sys
-from typing import TYPE_CHECKING, Any, List, NamedTuple, Pattern, Tuple, Union
+from contextlib import suppress
 
 # 3rd party
-import coverage  # type: ignore
-
-if TYPE_CHECKING:
+import coverage.python  # type: ignore
+import pyparsing  # type: ignore
+from coverage.config import DEFAULT_EXCLUDE  # type: ignore
+from coverage.misc import join_regex  # type: ignore
 
-	# stdlib
-	from sys import _version_info as VersionInfo  # pragma: no cover (typing only)
+# this package
+from coverage_pyver_pragma.grammar import GRAMMAR
 
 __author__: str = "Dominic Davis-Foster"
 __copyright__: str = "2020-2021 Dominic Davis-Foster"
 __license__: str = "MIT License"
-__version__: str = "0.0.6"
+__version__: str = "0.2.0"
 __email__: str = "[email protected]"
 
-__all__ = [
-		"regex_main",
-		"Version",
-		"make_regexes",
-		"PyVerPragmaPlugin",
-		"make_not_exclude_regexs",
-		"coverage_init",
-		]
-
-regex_main: str = re.compile(r"(?i)#\s*pragma[:\s]?\s*no\s*cover").pattern
-
+__all__ = ["DSL_EXCLUDE", "evaluate_exclude"]
 
-class Version(NamedTuple):
-	"""
-	:class:`~typing.NamedTuple` with the same elements as :py:data:`sys.version_info`.
-	"""
+DSL_EXCLUDE = re.compile(r'.*#\s*(?:pragma|PRAGMA)[:\s]?\s*(?:no|NO)\s*(?:cover|COVER)\s*\((.*)\)')
+"""
+Compiled regular expression to match comments in the for ``# pragma: no cover (XXX)``,
+where ``XXX`` is an expression to be evaluated to determine whether the line should be excluded from coverage.
 
-	major: int
-	minor: int
-	micro: int = 0
-	releaselevel: str = ''
-	serial: str = ''
+.. versionadded:: 0.2.0
+"""
 
 
-def make_regexes(
-		version_tuple: Union["Version", "VersionInfo", Tuple[int, ...]],
-		current_platform: str,
-		current_implementation: str,
-		) -> List[Pattern]:
+def evaluate_exclude(expression: str) -> bool:
 	"""
-	Generates a list of regular expressions to match all valid ignores for the given Python version.
+	Evaluate the given expression to determine whether the line should be excluded from coverage.
 
-	:param version_tuple: The Python version.
-	:type version_tuple: :class:`~typing.NamedTuple` with the attributes ``major`` and ``minor``
-	:param current_platform:
-	:param current_implementation:
+	.. versionadded:: 0.2.0
 
-	:return: List of regular expressions.
+	:param expression:
 	"""
 
-	version_tuple = Version(*version_tuple)
-
-	if version_tuple.major == 3:
-		# Python 3.X
-
-		greater_than_versions = [str(x) for x in range(0, version_tuple.minor)]
-		greater_equal_versions = [*greater_than_versions, str(version_tuple.minor)]
-		less_than_versions = [str(x) for x in range(version_tuple.minor + 1, 10)]
-		# Current max Python version is 3.9
-		less_equal_versions = [str(version_tuple.minor), *less_than_versions]  # pragma: no cover (!Linux)
-		exact_versions = [str(version_tuple.minor)]
-
-		wrong_platforms_string = fr"(?!.*!{current_platform})"  # (?!.*Windows)(?!.*Darwin)
-		wrong_implementations_string = fr"(?!.*!{current_implementation})"  # (?!.*Windows)(?!.*Darwin)
-		# correct_platforms_string = r"(?=\s*(Linux)?)"
-
-		# Add regular expressions for relevant python versions
-		# We do it with re.compile to get the syntax highlighting in PyCharm
-		excludes = [
-				re.compile(
-						fr"{regex_main}\s*\((?=\s*<py3({'|'.join(less_than_versions)})){wrong_platforms_string}{wrong_implementations_string}.*\)"
-						),
-				re.compile(
-						fr"{regex_main}\s*\((?=\s*<=py3({'|'.join(less_equal_versions)})){wrong_platforms_string}{wrong_implementations_string}.*\)"
-						),
-				re.compile(
-						fr"{regex_main}\s*\((?=\s*>py3({'|'.join(greater_than_versions)})){wrong_platforms_string}{wrong_implementations_string}.*\)"
-						),
-				re.compile(
-						fr"{regex_main}\s*\((?=\s*py3({'|'.join(greater_equal_versions)})\+){wrong_platforms_string}{wrong_implementations_string}.*\)"
-						),
-				re.compile(
-						fr"{regex_main}\s*\((?=\s*>=py3({'|'.join(greater_equal_versions)})){wrong_platforms_string}{wrong_implementations_string}.*\)"
-						),
-				re.compile(
-						fr"{regex_main}\s*\((?=\s*py3({'|'.join(exact_versions)})){wrong_platforms_string}{wrong_implementations_string}.*\)"
-						),
-				re.compile(
-						fr"{regex_main}\s*\((?!.*py[0-9]+){wrong_platforms_string}{wrong_implementations_string}.*\)"
-						),
-				]
-
-		# print(excludes)
-		return excludes
-
-	else:
-		raise ValueError("Unknown Python version.")
-
-
-class PyVerPragmaPlugin(coverage.CoveragePlugin):
-	"""
-	Plugin for `Coverage.py <https://coverage.readthedocs.io/en/coverage-5.3/>`_
-	to selectively ignore branches depending on the Python version.
-	"""  # noqa: D400
-
-	def configure(self, config: Any) -> None:
-		"""
-		Configure the plugin.
-
-		:param config:
-		"""
-
-		# Coverage.py gives either a Coverage() object, or a CoverageConfig() object.
-		if isinstance(config, coverage.Coverage):
-			config = config.config  # pragma: no cover
+	return all(list(GRAMMAR.parseString(expression.lower(), parseAll=True)))
 
-		# Remove standard "pragma: no cover" regex
-		if regex_main in config.exclude_list:
-			config.exclude_list.remove(regex_main)
 
-		if "pragma: no cover" in config.exclude_list:
-			config.exclude_list.remove("pragma: no cover")
+class PythonParser(coverage.python.PythonParser):  # noqa: D102
 
-		excludes = make_regexes(sys.version_info, platform.system(), platform.python_implementation())
-		for exc_pattern in excludes:
-			config.exclude_list.append(exc_pattern.pattern)
+	def lines_matching(self, *regexes):  # noqa: D102
 
-		# Reinstate the general regex, but making sure it isn't followed by a left bracket.
-		config.exclude_list += [
-				p.pattern for p in make_not_exclude_regexs(platform.system(), platform.python_implementation())
-				]
+		combined = join_regex([*regexes, *DEFAULT_EXCLUDE])
 
-		# TODO: Python 4.X
+		regex_c = re.compile(combined)
+		matches = set()
 
+		for idx, ltext in enumerate(self.lines, start=1):
 
-def make_not_exclude_regexs(
-		current_platform: str,
-		current_implementation: str,
-		) -> List[Pattern]:
-	"""
-	Generates a list of regular expressions for lines that should not be excluded.
+			dsl_m = DSL_EXCLUDE.match(ltext)
 
-	:param current_platform:
-	:param current_implementation:
-	"""
+			# Check if it matches the DSL regex:
+			if dsl_m:
+				exclude_source = dsl_m.group(1)
 
-	return [
-			re.compile(
-					fr"{regex_main} (?!\(.*(.{{0,2}}py3\d(\+)?|!{current_platform}|!{current_implementation}).*\)).*$"
-					),
-			re.compile(fr"{regex_main}$"),
-			]
+				with suppress(pyparsing.ParseBaseException):
+					if evaluate_exclude(exclude_source):
+						matches.add(idx)
+						continue
 
+			if regex_c.search(ltext):
+				matches.add(idx)
 
-def coverage_init(reg, options):
-	"""
-	Initialise the plugin.
+		return matches
 
-	:param reg:
-	:param options:
-	"""
 
-	reg.add_configurer(PyVerPragmaPlugin())  # pragma: no cover
+def coverage_init(*args, **kwargs):
+	coverage.python.PythonParser.lines_matching = PythonParser.lines_matching