claude-dev-env 1.58.0 → 1.60.0

package/hooks/blocking/test_code_rules_enforcer_dead_dataclass_field.py

@@ -0,0 +1,467 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+ENFORCER_PATH = Path(__file__).resolve().parent / "code_rules_enforcer.py"
+specification = importlib.util.spec_from_file_location(
+    "code_rules_enforcer", ENFORCER_PATH
+)
+assert specification is not None and specification.loader is not None
+code_rules_enforcer = importlib.util.module_from_spec(specification)
+specification.loader.exec_module(code_rules_enforcer)
+
+PRODUCTION_FILE_PATH = "packages/app/services/report.py"
+TEST_FILE_PATH = "packages/app/services/test_report.py"
+MIGRATION_FILE_PATH = "packages/app/migrations/0001_initial.py"
+WORKFLOW_FILE_PATH = "packages/app/skills/thing/workflow/render_report.py"
+
+
+def _check(source: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_dead_dataclass_fields(source, file_path)
+
+
+def test_should_flag_dataclass_field_assigned_but_never_read() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    number: int\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(number=1, url='x')\n"
+        "\n"
+        "def render(metadata: PrMetadata) -> int:\n"
+        "    return metadata.number\n"
+    )
+    issues = _check(source, PRODUCTION_FILE_PATH)
+    assert any(
+        "'url'" in each_issue and "PrMetadata" in each_issue for each_issue in issues
+    ), f"Expected dead 'url' field flagged, got: {issues}"
+    assert not any(
+        "'number'" in each_issue for each_issue in issues
+    ), f"Read field 'number' must not be flagged, got: {issues}"
+
+
+def test_should_not_flag_field_read_via_attribute_access() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+        "\n"
+        "def render(metadata: PrMetadata) -> str:\n"
+        "    return metadata.url\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_when_class_never_constructed_in_file() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PublicConfig:\n"
+        "    url: str\n"
+        "    number: int\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_non_dataclass_class() -> None:
+    source = "class Plain:\n    url: str\n\ndef build() -> Plain:\n    return Plain()\n"
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_classvar_field() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "from typing import ClassVar\n"
+        "\n"
+        "@dataclass\n"
+        "class Counter:\n"
+        "    label: ClassVar[str] = 'count'\n"
+        "    total: int\n"
+        "\n"
+        "def build() -> Counter:\n"
+        "    return Counter(total=1)\n"
+        "\n"
+        "def read(counter: Counter) -> int:\n"
+        "    return counter.total\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_field_read_via_literal_getattr() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return Row(url='x')\n"
+        "\n"
+        "def read(row: Row) -> str:\n"
+        "    return getattr(row, 'url')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_non_literal_getattr_present() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return Row(url='x')\n"
+        "\n"
+        "def read(row: Row, field_name: str) -> str:\n"
+        "    return getattr(row, field_name)\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_handle_called_dataclass_decorator() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass(frozen=True)\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    issues = _check(source, PRODUCTION_FILE_PATH)
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Expected dead field flagged on called-decorator dataclass, got: {issues}"
+
+
+def test_should_handle_dotted_dataclasses_decorator() -> None:
+    source = (
+        "import dataclasses\n"
+        "\n"
+        "@dataclasses.dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    issues = _check(source, PRODUCTION_FILE_PATH)
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Expected dead field flagged on dotted-decorator dataclass, got: {issues}"
+
+
+def test_should_be_silent_for_test_files() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    assert _check(source, TEST_FILE_PATH) == []
+
+
+def test_should_be_silent_for_migration_files() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    assert _check(source, MIGRATION_FILE_PATH) == []
+
+
+def test_should_flag_dead_field_in_workflow_path() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    issues = _check(source, WORKFLOW_FILE_PATH)
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Workflow-path files are subject to dead-code detection, got: {issues}"
+
+
+def test_should_tolerate_syntax_error() -> None:
+    assert _check("@dataclass\nclass Broken(:\n", PRODUCTION_FILE_PATH) == []
+
+
+def test_validate_content_runs_dead_field_check() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(url='x')\n"
+    )
+    issues = code_rules_enforcer.validate_content(source, PRODUCTION_FILE_PATH)
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Expected the enforcer dispatch to surface the dead field, got: {issues}"
+
+
+def test_should_suppress_check_when_asdict_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass, asdict\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> dict:\n"
+        "    return asdict(Row(url='x'))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_astuple_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass, astuple\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> tuple:\n"
+        "    return astuple(Row(url='x'))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_vars_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> dict:\n"
+        "    return vars(Row(url='x'))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_replace_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass, replace\n"
+        "\n"
+        "@dataclass(frozen=True)\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return replace(Row(url='x'), url='y')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_dotted_replace_consumes_instance() -> None:
+    source = (
+        "import dataclasses\n"
+        "\n"
+        "@dataclasses.dataclass(frozen=True)\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return dataclasses.replace(Row(url='x'), url='y')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_instance_dict_consumes_instance() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> dict:\n"
+        "    return Row(url='x').__dict__\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_field_read_via_multi_argument_attrgetter() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "from operator import attrgetter\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    first: int\n"
+        "    second: int\n"
+        "\n"
+        "def build() -> tuple:\n"
+        "    return attrgetter('first', 'second')(Row(first=1, second=2))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_two_instances_compared_for_equality() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def are_same(left: Row, right: Row) -> bool:\n"
+        "    return Row(url='a') == Row(url='b')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_ordered_instances_compared() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass(order=True)\n"
+        "class Row:\n"
+        "    priority: int\n"
+        "\n"
+        "def is_earlier() -> bool:\n"
+        "    return Row(priority=1) < Row(priority=2)\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_instances_placed_in_set() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass(frozen=True)\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def unique_rows() -> set:\n"
+        "    return {Row(url='a'), Row(url='b')}\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_whole_instance_stringified() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def describe() -> str:\n"
+        "    return str(Row(url='x'))\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_field_read_via_match_class_pattern() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def read(row: Row) -> str:\n"
+        "    match row:\n"
+        "        case Row(url=found):\n"
+        "            return found\n"
+        "    return ''\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return Row(url='x')\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_suppress_check_when_fields_reflection_consumes_instance() -> None:
+    source = (
+        "import dataclasses\n"
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    url: str\n"
+        "\n"
+        "def field_names() -> list:\n"
+        "    return [each_field.name for each_field in dataclasses.fields(Row(url='x'))]\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_not_flag_field_read_via_augmented_assignment() -> None:
+    source = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class Row:\n"
+        "    counter: int\n"
+        "\n"
+        "def bump(row: Row) -> None:\n"
+        "    row.counter += 1\n"
+        "\n"
+        "def build() -> Row:\n"
+        "    return Row(counter=0)\n"
+    )
+    assert _check(source, PRODUCTION_FILE_PATH) == []
+
+
+def test_should_evaluate_full_file_content_when_supplied() -> None:
+    fragment = "    return metadata.number\n"
+    full_file = (
+        "from dataclasses import dataclass\n"
+        "\n"
+        "@dataclass\n"
+        "class PrMetadata:\n"
+        "    number: int\n"
+        "    url: str\n"
+        "\n"
+        "def build() -> PrMetadata:\n"
+        "    return PrMetadata(number=1, url='x')\n"
+        "\n"
+        "def render(metadata: PrMetadata) -> int:\n"
+        "    return metadata.number\n"
+    )
+    issues = code_rules_enforcer.check_dead_dataclass_fields(
+        fragment, PRODUCTION_FILE_PATH, full_file
+    )
+    assert any(
+        "'url'" in each_issue for each_issue in issues
+    ), f"Expected the reconstructed whole-file content to govern, got: {issues}"
+    assert not any(
+        "'number'" in each_issue for each_issue in issues
+    ), f"Read field 'number' must not be flagged, got: {issues}"

package/hooks/blocking/test_code_rules_enforcer_dead_module_constant.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import importlib.util
+import os
+import shutil
+import stat
+import tempfile
+from collections.abc import Callable, Iterator
+from pathlib import Path
+
+import pytest
+
+ENFORCER_PATH = Path(__file__).resolve().parent / "code_rules_enforcer.py"
+specification = importlib.util.spec_from_file_location("code_rules_enforcer", ENFORCER_PATH)
+assert specification is not None and specification.loader is not None
+code_rules_enforcer = importlib.util.module_from_spec(specification)
+specification.loader.exec_module(code_rules_enforcer)
+
+CONSTANTS_BODY = 'MEDIUM_TERMINAL = "terminal"\nMEDIUM_CODE = "code"\nMEDIUM_TEXT = "text"\n'
+
+
+def _strip_read_only_and_retry(
+    removal_function: Callable[[str], object],
+    target_path: str,
+    _exc_info: BaseException,
+) -> None:
+    try:
+        os.chmod(target_path, stat.S_IWRITE)
+        removal_function(target_path)
+    except OSError:
+        pass
+
+
+@pytest.fixture
+def neutral_root() -> Iterator[Path]:
+    """Yield a temp directory whose path carries no ``test_`` segment.
+
+    The enforcer's ``is_test_file`` keys on the full path string, and pytest's
+    own ``tmp_path`` directory name embeds the test name, which would make every
+    synthetic constants path look like a test file. A neutral ``mkdtemp`` root
+    mirrors how a production constants module path looks.
+    """
+    neutral_directory = Path(tempfile.mkdtemp(prefix="deadconst-")).resolve()
+    try:
+        yield neutral_directory
+    finally:
+        shutil.rmtree(neutral_directory, onexc=_strip_read_only_and_retry)
+
+
+def _check(source: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_dead_module_constants(source, file_path)
+
+
+def _build_constants_package(
+    workflow_directory: Path,
+    constants_body: str,
+    consumer_body: str,
+) -> Path:
+    constants_package = workflow_directory / "report_constants"
+    constants_package.mkdir(parents=True)
+    (constants_package / "__init__.py").write_text("", encoding="utf-8")
+    constants_path = constants_package / "render_report_constants.py"
+    constants_path.write_text(constants_body, encoding="utf-8")
+    (workflow_directory / "render_report.py").write_text(consumer_body, encoding="utf-8")
+    return constants_path
+
+
+def test_flags_constant_imported_by_no_module_in_the_tree(neutral_root: Path) -> None:
+    consumer_body = (
+        "from report_constants.render_report_constants import (\n"
+        "    MEDIUM_CODE,\n"
+        "    MEDIUM_TERMINAL,\n"
+        ")\n"
+        "\n"
+        "def panel_class(medium: str) -> str:\n"
+        "    if medium == MEDIUM_TERMINAL:\n"
+        "        return 'terminal'\n"
+        "    return 'code-panel' if medium == MEDIUM_CODE else 'text-panel'\n"
+    )
+    constants_path = _build_constants_package(
+        neutral_root / "workflow", CONSTANTS_BODY, consumer_body
+    )
+    issues = _check(CONSTANTS_BODY, str(constants_path))
+    assert any("MEDIUM_TEXT" in each_issue for each_issue in issues), (
+        f"Expected dead MEDIUM_TEXT flagged, got: {issues}"
+    )
+    assert not any(
+        "MEDIUM_TERMINAL" in each_issue or "MEDIUM_CODE" in each_issue for each_issue in issues
+    ), f"Imported constants must not be flagged, got: {issues}"
+
+
+def test_does_not_flag_constant_imported_one_directory_up(neutral_root: Path) -> None:
+    consumer_uses_text = (
+        "from report_constants.render_report_constants import (\n"
+        "    MEDIUM_CODE,\n"
+        "    MEDIUM_TERMINAL,\n"
+        "    MEDIUM_TEXT,\n"
+        ")\n"
+        "\n"
+        "def panel_class(medium: str) -> str:\n"
+        "    if medium == MEDIUM_TERMINAL:\n"
+        "        return 'terminal'\n"
+        "    if medium == MEDIUM_TEXT:\n"
+        "        return 'text-panel'\n"
+        "    return 'code-panel' if medium == MEDIUM_CODE else 'text-panel'\n"
+    )
+    constants_path = _build_constants_package(
+        neutral_root / "workflow", CONSTANTS_BODY, consumer_uses_text
+    )
+    issues = _check(CONSTANTS_BODY, str(constants_path))
+    assert issues == [], f"No constant is dead when all are imported, got: {issues}"
+
+
+def test_does_not_flag_when_module_declares_dunder_all(neutral_root: Path) -> None:
+    constants_body = CONSTANTS_BODY + '__all__ = ["MEDIUM_TERMINAL"]\n'
+    consumer_body = (
+        "from report_constants.render_report_constants import MEDIUM_TERMINAL\n"
+        "\n"
+        "def label() -> str:\n"
+        "    return MEDIUM_TERMINAL\n"
+    )
+    constants_path = _build_constants_package(
+        neutral_root / "workflow", constants_body, consumer_body
+    )
+    issues = _check(constants_body, str(constants_path))
+    assert issues == [], f"__all__ surface suppresses the check, got: {issues}"
+
+
+def test_does_not_run_on_ordinary_production_module(neutral_root: Path) -> None:
+    workflow_directory = neutral_root / "workflow"
+    workflow_directory.mkdir(parents=True)
+    ordinary_path = workflow_directory / "render_report.py"
+    body = "WIDGET_LIMIT = 5\n\ndef widgets() -> int:\n    return WIDGET_LIMIT\n"
+    ordinary_path.write_text(body, encoding="utf-8")
+    issues = _check(body, str(ordinary_path))
+    assert issues == [], (
+        f"The dead-constant check runs only on dedicated constants modules, got: {issues}"
+    )
+
+
+def test_runs_on_config_directory_module(neutral_root: Path) -> None:
+    package_directory = neutral_root / "app"
+    config_directory = package_directory / "config"
+    config_directory.mkdir(parents=True)
+    constants_body = "TIMEOUT_SECONDS = 30\nUNUSED_THRESHOLD = 99\n"
+    constants_path = config_directory / "timing.py"
+    constants_path.write_text(constants_body, encoding="utf-8")
+    consumer_body = (
+        "from config.timing import TIMEOUT_SECONDS\n"
+        "\n"
+        "def deadline() -> int:\n"
+        "    return TIMEOUT_SECONDS\n"
+    )
+    (package_directory / "service.py").write_text(consumer_body, encoding="utf-8")
+    issues = _check(constants_body, str(constants_path))
+    assert any("UNUSED_THRESHOLD" in each_issue for each_issue in issues), (
+        f"Expected dead UNUSED_THRESHOLD flagged in config module, got: {issues}"
+    )
+    assert not any("TIMEOUT_SECONDS" in each_issue for each_issue in issues), (
+        f"Consumed config constant must not be flagged, got: {issues}"
+    )
+
+
+def test_counts_a_reference_from_a_test_module(neutral_root: Path) -> None:
+    workflow_directory = neutral_root / "workflow"
+    constants_body = 'ONLY_TESTS_USE_THIS = "x"\n'
+    constants_path = workflow_directory / "render_report_constants.py"
+    workflow_directory.mkdir(parents=True)
+    constants_path.write_text(constants_body, encoding="utf-8")
+    test_body = (
+        "from render_report_constants import ONLY_TESTS_USE_THIS\n"
+        "\n"
+        "def test_value() -> None:\n"
+        "    assert ONLY_TESTS_USE_THIS == 'x'\n"
+    )
+    (workflow_directory / "test_render_report.py").write_text(test_body, encoding="utf-8")
+    issues = _check(constants_body, str(constants_path))
+    assert issues == [], f"A constant used only by a test under the tree stays live, got: {issues}"
+
+
+def test_is_skipped_on_a_constants_test_file(neutral_root: Path) -> None:
+    workflow_directory = neutral_root / "workflow"
+    workflow_directory.mkdir(parents=True)
+    test_constants_path = workflow_directory / "test_render_report_constants.py"
+    body = 'UNREFERENCED = "y"\n'
+    test_constants_path.write_text(body, encoding="utf-8")
+    issues = _check(body, str(test_constants_path))
+    assert issues == [], f"Test files are exempt, got: {issues}"