crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/codeconfig.py

@@ -0,0 +1,113 @@
+"""Configure analysis options at different levels."""
+
+import importlib.resources
+import inspect
+import re
+import sys
+import tokenize
+from io import StringIO
+from typing import Any, Iterable, Tuple
+
+from crosshair.options import AnalysisOptionSet
+from crosshair.util import memo, sourcelines
+
+_COMMENT_TOKEN_RE = re.compile(r"^\#\s*crosshair\s*\:\s*(.*?)\s*$")
+
+
+def get_directives(source_text: str) -> Iterable[Tuple[int, int, str]]:
+    r"""
+    Extract directive text from source lines.
+
+    :returns: a list of (line number, column number, directive text) tuples
+
+    >>> get_directives("pass\n# crosshair: foo=bar")
+    [(2, 0, 'foo=bar')]
+    """
+    ret = []
+    tokens = tokenize.generate_tokens(StringIO(source_text).readline)
+    # TODO catch tokenize.TokenError ... just in case?
+    for toktyp, tokval, begin, _, _ in tokens:
+        linenum, colnum = begin
+        if toktyp == tokenize.COMMENT:
+            directive = _COMMENT_TOKEN_RE.sub(r"\1", tokval)
+            if tokval != directive:
+                ret.append((linenum, colnum, directive))
+    return ret
+
+
+class InvalidDirective(Exception):
+    pass
+
+
+def parse_directives(
+    directive_lines: Iterable[Tuple[int, int, str]],
+) -> AnalysisOptionSet:
+    """
+    Parse options from directives in comments.
+
+    >>> parse_directives([(1, 0, "off")]).enabled
+    False
+    """
+    result = AnalysisOptionSet()
+    for lineno, _colno, directive in directive_lines:
+        for part in directive.split():
+            if part == "on":
+                part = "enabled=yes"
+            if part == "off":
+                part = "enabled=no"
+            pair = part.split("=", 2)
+            if len(pair) != 2:
+                raise InvalidDirective(f'Malformed option: "{part}"', lineno)
+            key, strvalue = pair
+            if key not in AnalysisOptionSet.directive_fields:
+                raise InvalidDirective(f'Unknown option: "{key}"', lineno)
+            value = AnalysisOptionSet.parse_field(key, strvalue)
+            if value is None:
+                raise InvalidDirective(
+                    f'"{strvalue}" is not a valid "{key}" value', lineno
+                )
+            if getattr(result, key) is not None:
+                raise InvalidDirective(
+                    f'Option "{key}" is set multiple times at the same scope', lineno
+                )
+            result = result.overlay(AnalysisOptionSet(**{key: value}))
+    return result
+
+
+@memo
+def collect_options(thing: Any) -> AnalysisOptionSet:
+    parent_opts = AnalysisOptionSet()
+    is_package = thing.__name__ == getattr(thing, "__package__", None)
+    if getattr(thing, "__module__", None):
+        parent_opts = collect_options(sys.modules[thing.__module__])
+    elif getattr(thing, "__package__", None):
+        if is_package:
+            parent_pkg, _, _ = thing.__package__.rpartition(".")
+        else:
+            parent_pkg = thing.__package__
+        if parent_pkg:
+            parent_opts = collect_options(sys.modules[parent_pkg])
+
+    source_text: str
+    if is_package:
+        try:
+            if sys.version_info >= (3, 10):
+                source_text = (
+                    importlib.resources.files(thing).joinpath("__init__.py").read_text()
+                )
+            else:
+                source_text = importlib.resources.read_text(thing, "__init__.py")
+        except FileNotFoundError:
+            source_text = ""
+    else:
+        _file, _start, lines = sourcelines(thing)
+        source_text = "".join(lines)
+    directives = get_directives(source_text)
+    if inspect.ismodule(thing):
+        # Only look at toplevel comments in modules
+        # (we don't want to catch directives for functions inside it)
+        # TODO: detect directives at other levels like classes etc and warn that they
+        # will be ignored.
+        directives = [(l, c, t) for (l, c, t) in directives if c == 0]
+    my_opts = parse_directives(directives)
+    return parent_opts.overlay(my_opts)

crosshair/codeconfig_test.py

@@ -0,0 +1,117 @@
+import importlib
+import inspect
+import sys
+import textwrap
+from pathlib import Path
+
+import pytest  # type: ignore
+
+from crosshair.codeconfig import (
+    AnalysisOptionSet,
+    InvalidDirective,
+    collect_options,
+    get_directives,
+    parse_directives,
+)
+from crosshair.test_util import simplefs
+from crosshair.util import add_to_pypath
+
+
+# crosshair: off
+def override_on():
+    # crosshair: on
+    pass
+
+
+def timeout_of_10():
+    # crosshair: per_condition_timeout=10
+    pass
+
+
+def _example1():
+    # crosshair : First comment
+    # does not lead with crosshair: not present
+    print("# crosshair : this is a string, not a comment")
+    pass  # crosshair:comment with trailing space
+
+
+def test_get_directives_example1() -> None:
+    lines, _ = inspect.getsourcelines(_example1)
+    assert get_directives("".join(lines)) == [
+        (2, 4, "First comment"),
+        (5, 10, "comment with trailing space"),
+    ]
+
+
+def test_parse_directives() -> None:
+    assert parse_directives([(1, 0, "per_condition_timeout=42")]) == AnalysisOptionSet(
+        per_condition_timeout=42
+    )
+    assert parse_directives([(1, 0, "on")]) == AnalysisOptionSet(enabled=True)
+    assert parse_directives([(1, 0, "off")]) == AnalysisOptionSet(enabled=False)
+    assert parse_directives([(1, 0, "on per_path_timeout=42")]) == AnalysisOptionSet(
+        enabled=True, per_path_timeout=42
+    )
+
+
+def test_parse_directive_errors() -> None:
+    with pytest.raises(InvalidDirective, match='Malformed option: "noequals"'):
+        parse_directives([(1, 0, "noequals")])
+    with pytest.raises(InvalidDirective, match='Unknown option: "notafield"'):
+        parse_directives([(1, 0, "notafield=42")])
+    with pytest.raises(
+        InvalidDirective,
+        match='"notanumber" is not a valid "per_condition_timeout" value',
+    ):
+        parse_directives([(1, 0, "per_condition_timeout=notanumber")])
+    with pytest.raises(
+        InvalidDirective,
+        match='Option "enabled" is set multiple times at the same scope',
+    ):
+        parse_directives([(1, 0, "on off")])
+
+
+def test_get_directives_multiline_string() -> None:
+    # This tests a regression where we'd previously thrown a "EOF in multi-line string"
+    # TokenError.
+    foo = '''"""
+
+"""
+'''
+    assert list(get_directives(foo)) == []
+
+
+def test_collection_options() -> None:
+    this_module = sys.modules[__name__]
+    assert collect_options(this_module) == AnalysisOptionSet(enabled=False)
+    assert collect_options(override_on) == AnalysisOptionSet(enabled=True)
+    assert collect_options(timeout_of_10) == AnalysisOptionSet(
+        enabled=False, per_condition_timeout=10
+    )
+
+
+DIRECTIVES_TREE = {
+    "pkg1": {
+        "__init__.py": textwrap.dedent(
+            """\
+            # crosshair: off
+            # crosshair: per_condition_timeout=42
+            """
+        ),
+        "pkg2": {
+            "pkg3": {
+                "__init__.py": "# crosshair: max_iterations=5",
+                "mod.py": "# crosshair: on",
+            }
+        },
+    }
+}
+
+
+def test_package_directives(tmp_path: Path):
+    simplefs(tmp_path, DIRECTIVES_TREE)
+    with add_to_pypath(tmp_path):
+        innermod = importlib.import_module("pkg1.pkg2.pkg3.mod")
+        assert collect_options(innermod) == AnalysisOptionSet(
+            enabled=True, max_iterations=5, per_condition_timeout=42
+        )