claude-dev-env 2.28.0 → 2.28.1

package/hooks/blocking/test_code_rules_enforcer_dead_module_constant_alias.py

@@ -1,133 +0,0 @@
-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.
-
-    ::
-
-        tmp_path (pytest default)    -> embeds "test_..." in its name
-                                          -> is_test_file() misreads the path
-        mkdtemp(prefix="deadconst-") -> no "test_" segment  ->  reads as
-                                          a production path  ok
-
-    A ``.git`` marker is planted at the root so the cross-tree widening
-    resolves the repository root to this synthetic tree.
-    """
-    neutral_directory = Path(tempfile.mkdtemp(prefix="deadconst-")).resolve()
-    (neutral_directory / ".git").mkdir()
-    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 _assert_alias_read_constants_live(issues: list[str]) -> None:
-    assert not any(
-        "MEDIUM_TERMINAL" in each_issue or "MEDIUM_CODE" in each_issue for each_issue in issues
-    ), f"A constant read as attribute of an imported module stays live, got: {issues}"
-    assert any("MEDIUM_TEXT" in each_issue for each_issue in issues), (
-        f"A constant read by no module must still be flagged, got: {issues}"
-    )
-
-
-def test_does_not_flag_constant_read_via_from_import_module_alias_attribute(
-    neutral_root: Path,
-) -> None:
-    consumer_body = (
-        "from report_constants import render_report_constants as constants\n"
-        "\n"
-        "def panel_class(medium: str) -> str:\n"
-        "    if medium == constants.MEDIUM_TERMINAL:\n"
-        "        return 'terminal'\n"
-        "    return 'code' if medium == constants.MEDIUM_CODE else 'other'\n"
-    )
-    constants_path = _build_constants_package(
-        neutral_root / "workflow", CONSTANTS_BODY, consumer_body
-    )
-    _assert_alias_read_constants_live(_check(CONSTANTS_BODY, str(constants_path)))
-
-
-def test_does_not_flag_constant_read_via_import_as_alias_attribute(
-    neutral_root: Path,
-) -> None:
-    consumer_body = (
-        "import report_constants.render_report_constants as constants\n"
-        "\n"
-        "def label(medium: str) -> str:\n"
-        "    if medium == constants.MEDIUM_TERMINAL:\n"
-        "        return 'terminal'\n"
-        "    return 'code' if medium == constants.MEDIUM_CODE else 'other'\n"
-    )
-    constants_path = _build_constants_package(
-        neutral_root / "workflow", CONSTANTS_BODY, consumer_body
-    )
-    _assert_alias_read_constants_live(_check(CONSTANTS_BODY, str(constants_path)))
-
-
-def test_does_not_flag_constant_read_via_plain_module_name_attribute(
-    neutral_root: Path,
-) -> None:
-    consumer_body = (
-        "from report_constants import render_report_constants\n"
-        "\n"
-        "def label(medium: str) -> str:\n"
-        "    if medium == render_report_constants.MEDIUM_TERMINAL:\n"
-        "        return 'terminal'\n"
-        "    if medium == render_report_constants.MEDIUM_CODE:\n"
-        "        return 'code'\n"
-        "    return 'other'\n"
-    )
-    constants_path = _build_constants_package(
-        neutral_root / "workflow", CONSTANTS_BODY, consumer_body
-    )
-    _assert_alias_read_constants_live(_check(CONSTANTS_BODY, str(constants_path)))

package/hooks/blocking/test_code_rules_enforcer_dead_module_constant_read_cap.py

@@ -1,103 +0,0 @@
-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)
-
-
-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.
-
-    ::
-
-        tmp_path (pytest default)  -> embeds "test_..." in its name
-                                        -> is_test_file() misreads every
-                                           synthetic constants path
-        mkdtemp(prefix="deadconst-") -> no "test_" segment
-                                        -> reads as a production path  ok
-
-    A ``.git`` marker is planted at the root so the cross-tree widening
-    resolves the repository root to this synthetic tree.
-    """
-    neutral_directory = Path(tempfile.mkdtemp(prefix="deadconst-")).resolve()
-    (neutral_directory / ".git").mkdir()
-    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 _write_noise_modules(directory: Path, count: int) -> None:
-    directory.mkdir(parents=True)
-    for each_index in range(count):
-        (directory / f"mod_{each_index}.py").write_text(
-            "def noop() -> int:\n    return 1\n", encoding="utf-8"
-        )
-
-
-def test_widened_scan_bounds_total_disk_reads_on_noncandidate_flood(
-    neutral_root: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    """A read-attempt cap stops the widened pass from reading every sibling.
-
-    ::
-
-        MAX_SCAN_ROOT_READ_COUNT = 3, 50 non-candidate noise files
-        ok:   read_text() called a bounded number of times   (< 50)
-        flag: read_text() called once per noise file          (== 50)
-
-    Without the cap, ``_read_candidate_source`` opens and reads every
-    repository ``.py`` file's full text before testing it for the module
-    stem, so disk-read cost scales with repository size regardless of how
-    quickly the file cap would otherwise stop the parse-and-collect work.
-    """
-    monkeypatch.setattr("code_rules_dead_module_constant.MAX_SCAN_ROOT_READ_COUNT", 3)
-    package_directory = neutral_root / "pkg"
-    package_directory.mkdir(parents=True)
-    constants_body = 'DEAD_EXPORTED = "x"\n__all__ = ["DEAD_EXPORTED"]\n'
-    constants_path = package_directory / "settings_constants.py"
-    constants_path.write_text(constants_body, encoding="utf-8")
-    _write_noise_modules(neutral_root / "noise", 50)
-    read_count = 0
-    original_read_text = Path.read_text
-
-    def counting_read_text(self: Path, *positional: object, **keyword: object) -> str:
-        nonlocal read_count
-        read_count += 1
-        return original_read_text(self, *positional, **keyword)  # type: ignore[arg-type]  # forwards positional/keyword args mypy cannot resolve
-
-    monkeypatch.setattr(Path, "read_text", counting_read_text)
-    _check(constants_body, str(constants_path))
-    assert read_count < 50, (
-        "A read-count cap must stop the widened pass from reading every "
-        f"non-candidate sibling's full text, got {read_count} reads across 50 noise files"
-    )

package/hooks/blocking/test_code_rules_enforcer_dead_split_branch.py

@@ -1,105 +0,0 @@
-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_PATH = "C:/project/pkg/menu_info_colors.py"
-
-
-def _check(source: str) -> list[str]:
-    return code_rules_enforcer.check_dead_split_truthiness_branch(source, PRODUCTION_PATH)
-
-
-def test_flags_split_truthiness_else_arm() -> None:
-    source = (
-        "def _extract_uid_prefix(uid: str) -> str:\n"
-        '    all_parts = uid.split("_")\n'
-        "    if len(all_parts) > 2:\n"
-        '        return "_".join(all_parts[:3])\n'
-        "    return all_parts[0] if all_parts else uid\n"
-    )
-    issues = _check(source)
-    assert len(issues) == 1
-    assert "all_parts" in issues[0]
-    assert "Line 5" in issues[0]
-
-
-def test_flags_negated_guard_dead_body() -> None:
-    source = (
-        "def first_segment(path: str) -> str:\n"
-        '    all_segments = path.split("/")\n'
-        "    if not all_segments:\n"
-        "        return path\n"
-        "    return all_segments[0]\n"
-    )
-    issues = _check(source)
-    assert len(issues) == 1
-    assert "all_segments" in issues[0]
-
-
-def test_does_not_flag_split_without_separator() -> None:
-    source = (
-        "def first_token(text: str) -> str:\n"
-        "    all_parts = text.split()\n"
-        "    return all_parts[0] if all_parts else text\n"
-    )
-    assert _check(source) == []
-
-
-def test_does_not_flag_length_comparison_guard() -> None:
-    source = (
-        "def prefix(uid: str) -> str:\n"
-        '    all_parts = uid.split("_")\n'
-        "    if len(all_parts) > 1:\n"
-        "        return all_parts[0]\n"
-        "    return uid\n"
-    )
-    assert _check(source) == []
-
-
-def test_does_not_flag_when_name_reassigned() -> None:
-    source = (
-        "def normalize(uid: str) -> str:\n"
-        '    all_parts = uid.split("_")\n'
-        "    all_parts = [each_part.strip() for each_part in all_parts]\n"
-        "    return all_parts[0] if all_parts else uid\n"
-    )
-    assert _check(source) == []
-
-
-def test_does_not_flag_when_name_is_parameter() -> None:
-    source = (
-        "def shape(all_parts: list[str]) -> str:\n"
-        '    all_parts = "x".split("_")\n'
-        '    return all_parts[0] if all_parts else ""\n'
-    )
-    assert _check(source) == []
-
-
-def test_does_not_flag_attribute_receiver_split() -> None:
-    source = (
-        "def first(s: object) -> object:\n"
-        '    parts = s.str.split(",")\n'
-        "    return parts[0] if parts else 0\n"
-    )
-    assert _check(source) == []
-
-
-def test_does_not_flag_in_test_file() -> None:
-    source = (
-        "def helper(uid: str) -> str:\n"
-        '    all_parts = uid.split("_")\n'
-        "    return all_parts[0] if all_parts else uid\n"
-    )
-    assert (
-        code_rules_enforcer.check_dead_split_truthiness_branch(
-            source, "C:/project/pkg/test_thing.py"
-        )
-        == []
-    )