claude-dev-env 1.76.0 → 1.78.0

package/hooks/blocking/test_code_rules_enforcer_dead_split_branch.py

@@ -0,0 +1,105 @@
+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"
+        )
+        == []
+    )

package/hooks/blocking/test_code_rules_enforcer_docstring_args_span_scope.py

@@ -0,0 +1,174 @@
+"""Tests for check_docstring_args_single_line_scope_vs_span — Category O6 drift.
+
+A docstring Args: entry that scopes a finding to one named line ("only when its
+block-anchor line is among the changed lines") while the body builds a range()
+span and routes it through a span-intersection scoper claims a narrower scope
+than the code applies. The body blocks when ANY line of the span is among the
+changed lines, so an edit touching a non-anchor line of the span still blocks —
+contradicting the single-line Args sentence. This is the deterministic slice of
+Category O6 (free-form docstring-vs-implementation drift) for an Args entry whose
+single-line scope claim disagrees with a span-intersection body.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_enforcer_module() -> ModuleType:
+    module_path = Path(__file__).parent / "code_rules_enforcer.py"
+    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+code_rules_enforcer = _load_enforcer_module()
+
+
+def check_docstring_args_single_line_scope_vs_span(content: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_docstring_args_single_line_scope_vs_span(content, file_path)
+
+
+PRODUCTION_FILE_PATH = "/project/scripts/check_import_block_sorted.py"
+TEST_FILE_PATH = "/project/scripts/test_check_import_block_sorted.py"
+HOOK_INFRASTRUCTURE_PATH = "/home/user/.claude/hooks/blocking/example.py"
+
+
+SPAN_SCOPING_BODY = (
+    "    span_range = range(line_number, block_end_line_number + 1)\n"
+    "    all_violations.append((span_range, message))\n"
+    "    return _scope_violations_to_changed_lines(\n"
+    "        all_violations, all_changed_lines, defer_scope_to_caller\n"
+    "    )\n"
+)
+
+
+def test_flags_anchor_line_scope_against_span_intersection_body() -> None:
+    content = (
+        "def check_import_block_sorted(\n"
+        "    content: str, file_path: str, all_changed_lines: set[int] | None\n"
+        ") -> list[str]:\n"
+        '    """Flag an unsorted import block scoped to the changed lines.\n'
+        "\n"
+        "    A finding is returned when any line in that block span is among\n"
+        "    all_changed_lines.\n"
+        "\n"
+        "    Args:\n"
+        "        content: The full file content the write would leave on disk.\n"
+        "        file_path: The destination path used to gate by extension.\n"
+        "        all_changed_lines: Post-edit line numbers the current edit touched, or\n"
+        "            None to treat the whole file as in scope. When provided, a finding\n"
+        "            blocks only when its block-anchor line is among the changed lines.\n"
+        "\n"
+        "    Returns:\n"
+        "        One issue string per detected finding.\n"
+        '    """\n' + SPAN_SCOPING_BODY
+    )
+    issues = check_docstring_args_single_line_scope_vs_span(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "check_import_block_sorted" in issues[0]
+    assert "all_changed_lines" in issues[0]
+
+
+def test_flags_the_line_is_among_phrasing() -> None:
+    content = (
+        "def check_block(\n"
+        "    content: str, file_path: str, all_changed_lines: set[int] | None\n"
+        ") -> list[str]:\n"
+        '    """Flag an unsorted block scoped to the diff.\n'
+        "\n"
+        "    Args:\n"
+        "        content: The file content.\n"
+        "        all_changed_lines: When provided, a finding blocks only when the\n"
+        "            anchor line is among the changed lines.\n"
+        '    """\n' + SPAN_SCOPING_BODY
+    )
+    assert len(check_docstring_args_single_line_scope_vs_span(content, PRODUCTION_FILE_PATH)) == 1
+
+
+def test_passes_when_args_says_any_line_of_the_span() -> None:
+    content = (
+        "def check_import_block_sorted(\n"
+        "    content: str, file_path: str, all_changed_lines: set[int] | None\n"
+        ") -> list[str]:\n"
+        '    """Flag an unsorted import block scoped to the changed lines.\n'
+        "\n"
+        "    Args:\n"
+        "        content: The full file content.\n"
+        "        all_changed_lines: Post-edit line numbers the current edit touched, or\n"
+        "            None to treat the whole file as in scope. When provided, a finding\n"
+        "            blocks only when any line of its block span is among the changed lines.\n"
+        '    """\n' + SPAN_SCOPING_BODY
+    )
+    assert check_docstring_args_single_line_scope_vs_span(content, PRODUCTION_FILE_PATH) == []
+
+
+def test_passes_when_body_scopes_by_single_line_not_a_span() -> None:
+    content = (
+        "def check_one_line(\n"
+        "    content: str, file_path: str, all_changed_lines: set[int] | None\n"
+        ") -> list[str]:\n"
+        '    """Flag a violation on a single line scoped to the diff.\n'
+        "\n"
+        "    Args:\n"
+        "        content: The file content.\n"
+        "        all_changed_lines: When provided, a finding blocks only when its\n"
+        "            anchor line is among the changed lines.\n"
+        '    """\n'
+        "    if all_changed_lines is not None and line_number not in all_changed_lines:\n"
+        "        return []\n"
+        "    return [message]\n"
+    )
+    assert check_docstring_args_single_line_scope_vs_span(content, PRODUCTION_FILE_PATH) == []
+
+
+def test_passes_when_no_single_line_scope_phrase() -> None:
+    content = (
+        "def check_import_block_sorted(\n"
+        "    content: str, file_path: str, all_changed_lines: set[int] | None\n"
+        ") -> list[str]:\n"
+        '    """Flag an unsorted import block scoped to the changed lines.\n'
+        "\n"
+        "    Args:\n"
+        "        content: The full file content.\n"
+        "        all_changed_lines: Post-edit line numbers the current edit touched.\n"
+        '    """\n' + SPAN_SCOPING_BODY
+    )
+    assert check_docstring_args_single_line_scope_vs_span(content, PRODUCTION_FILE_PATH) == []
+
+
+def test_test_files_are_exempt() -> None:
+    content = (
+        "def check_import_block_sorted(\n"
+        "    content: str, file_path: str, all_changed_lines: set[int] | None\n"
+        ") -> list[str]:\n"
+        '    """Flag an unsorted import block.\n'
+        "\n"
+        "    Args:\n"
+        "        all_changed_lines: A finding blocks only when its anchor line is\n"
+        "            among the changed lines.\n"
+        '    """\n' + SPAN_SCOPING_BODY
+    )
+    assert check_docstring_args_single_line_scope_vs_span(content, TEST_FILE_PATH) == []
+
+
+def test_hook_infrastructure_is_not_exempt() -> None:
+    content = (
+        "def check_import_block_sorted(\n"
+        "    content: str, file_path: str, all_changed_lines: set[int] | None\n"
+        ") -> list[str]:\n"
+        '    """Flag an unsorted import block.\n'
+        "\n"
+        "    Args:\n"
+        "        all_changed_lines: A finding blocks only when its block-anchor line is\n"
+        "            among the changed lines.\n"
+        '    """\n' + SPAN_SCOPING_BODY
+    )
+    assert (
+        len(check_docstring_args_single_line_scope_vs_span(content, HOOK_INFRASTRUCTURE_PATH)) == 1
+    )

package/hooks/blocking/test_code_rules_enforcer_docstring_cardinal_family.py

@@ -0,0 +1,176 @@
+"""Tests for check_docstring_cardinal_count_matches_constant_family — O6 drift.
+
+A docstring states a cardinal count of an outcome family ("Covers the four
+outcome branches: ...") and enumerates the family members in prose, while the
+module references more members of that constant family than the count names. The
+prose under-describes the code: a reader trusts "four" and the list to be the
+full set, but the module imports and exercises a fifth outcome. This is the
+deterministic cardinal-count slice of Category O6 docstring-prose-vs-
+implementation drift, the shape that appears when a producer adds an outcome
+branch but leaves the test-module summary at the old count. The check runs on
+test files because the drift class lives in a test-module docstring.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_enforcer_module() -> ModuleType:
+    module_path = Path(__file__).parent / "code_rules_enforcer.py"
+    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+code_rules_enforcer = _load_enforcer_module()
+
+
+def check_docstring_cardinal_count_matches_constant_family(
+    content: str, file_path: str
+) -> list[str]:
+    return code_rules_enforcer.check_docstring_cardinal_count_matches_constant_family(
+        content, file_path
+    )
+
+
+def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
+    return code_rules_enforcer.validate_content(content, file_path, old_content)
+
+
+PRODUCTION_FILE_PATH = "/project/src/dropdown_fix_rule.py"
+TEST_FILE_PATH = "/project/src/tests/test_dropdown_fix_rule.py"
+
+
+def _test_module(summary_line: str, enumeration_line: str) -> str:
+    return (
+        '"""Behavioral tests for classify_dropdown_fix.\n'
+        "\n"
+        f"{summary_line}\n"
+        f"{enumeration_line}\n"
+        '"""\n'
+        "\n"
+        "from stp_dropdown_color_fix.config.status_codes import (\n"
+        "    OUTCOME_ALREADY_OK,\n"
+        "    OUTCOME_OFFENDER_LOW_CONTRAST,\n"
+        "    OUTCOME_OFFENDER_MISSING,\n"
+        "    OUTCOME_OFFENDER_UNREADABLE,\n"
+        "    OUTCOME_SKIPPED_NO_SAFE_SOURCE,\n"
+        ")\n"
+        "\n"
+        "def test_skipped() -> None:\n"
+        "    assert classify() == OUTCOME_SKIPPED_NO_SAFE_SOURCE\n"
+        "\n"
+        "def test_missing() -> None:\n"
+        "    assert classify() == OUTCOME_OFFENDER_MISSING\n"
+        "\n"
+        "def test_low_contrast() -> None:\n"
+        "    assert classify() == OUTCOME_OFFENDER_LOW_CONTRAST\n"
+        "\n"
+        "def test_already_ok() -> None:\n"
+        "    assert classify() == OUTCOME_ALREADY_OK\n"
+        "\n"
+        "def test_unreadable() -> None:\n"
+        "    assert classify() == OUTCOME_OFFENDER_UNREADABLE\n"
+    )
+
+
+def _drifted_module() -> str:
+    return _test_module(
+        "Covers the four outcome branches: skipped_no_safe_source,",
+        "offender_missing (case A), offender_low_contrast (case B), already_ok.",
+    )
+
+
+def _matching_module() -> str:
+    return _test_module(
+        "Covers the five outcome branches: skipped_no_safe_source, offender_missing,",
+        "offender_low_contrast, already_ok, offender_unreadable.",
+    )
+
+
+def test_should_flag_test_module_omitting_an_outcome() -> None:
+    issues = check_docstring_cardinal_count_matches_constant_family(
+        _drifted_module(), TEST_FILE_PATH
+    )
+    assert any("offender_unreadable" in each for each in issues), (
+        "A test-module docstring claiming four outcome branches while the module "
+        f"references five OUTCOME_ constants must be flagged, got: {issues!r}"
+    )
+
+
+def test_should_report_category_o6_in_the_message() -> None:
+    issues = check_docstring_cardinal_count_matches_constant_family(
+        _drifted_module(), TEST_FILE_PATH
+    )
+    assert any("O6" in each for each in issues), (
+        f"Expected the Category O6 label in the message, got: {issues!r}"
+    )
+
+
+def test_should_also_flag_production_module() -> None:
+    issues = check_docstring_cardinal_count_matches_constant_family(
+        _drifted_module(), PRODUCTION_FILE_PATH
+    )
+    assert issues != [], (
+        f"The cardinal drift must be flagged on a production file too, got: {issues!r}"
+    )
+
+
+def test_should_not_flag_when_count_and_enumeration_match_family() -> None:
+    issues = check_docstring_cardinal_count_matches_constant_family(
+        _matching_module(), TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A docstring naming all five referenced outcomes must not be flagged, got: {issues!r}"
+    )
+
+
+def test_should_not_flag_without_a_cardinal_phrase() -> None:
+    source = _test_module(
+        "Covers these outcome branches: skipped_no_safe_source,",
+        "offender_missing, offender_low_contrast, already_ok.",
+    )
+    issues = check_docstring_cardinal_count_matches_constant_family(source, TEST_FILE_PATH)
+    assert issues == [], (
+        f"An enumeration with no cardinal count word must not bind, got: {issues!r}"
+    )
+
+
+def test_should_not_flag_single_passing_mention() -> None:
+    source = _test_module(
+        "Asserts the four guard paths reach already_ok when the dropdown is",
+        "absent and the dialer keeps its painted swatch.",
+    )
+    issues = check_docstring_cardinal_count_matches_constant_family(source, TEST_FILE_PATH)
+    assert issues == [], f"A single overlapping token must not bind the family, got: {issues!r}"
+
+
+def test_should_not_flag_when_family_has_one_referenced_member() -> None:
+    source = (
+        '"""Covers the four outcome branches: already_ok, more, words, here."""\n'
+        "from status_codes import OUTCOME_ALREADY_OK\n"
+        "\n"
+        "def test_only() -> None:\n"
+        "    assert classify() == OUTCOME_ALREADY_OK\n"
+    )
+    issues = check_docstring_cardinal_count_matches_constant_family(source, TEST_FILE_PATH)
+    assert issues == [], f"A family with one referenced member must not bind, got: {issues!r}"
+
+
+def test_should_handle_syntax_error_gracefully() -> None:
+    issues = check_docstring_cardinal_count_matches_constant_family("def fetch(\n", TEST_FILE_PATH)
+    assert issues == [], f"Syntax error must yield no issues, got: {issues!r}"
+
+
+def test_validate_content_surfaces_cardinal_family_drift() -> None:
+    issues = validate_content(_drifted_module(), TEST_FILE_PATH, old_content="")
+    matching_issues = [each for each in issues if "offender_unreadable" in each and "O6" in each]
+    assert matching_issues, (
+        f"Expected validate_content to surface the O6 cardinal-family drift, got: {issues!r}"
+    )