rubocop-rspec-unused-let 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 518f64b5db264aa442ab1465330d15603ccf157676f2d1d4f5f6805fa78e7e07
-  data.tar.gz: fefc8a161e2c03d21fd0c7ba9d8757a76e97344e7413628608b4f34ede4f74f1
+  metadata.gz: 724c612abc3f71f86027ff074ddd0c543b58200c7ddc8bfbb717e57308bc6a6d
+  data.tar.gz: a70d24faab3cd03e5c85ea53896b784b19a3527ce440809de887696fba2107b0
 SHA512:
-  metadata.gz: '02875504a5c1781e28d2eca15670a82b2cafa2f3c1538462dcfac3201a412c57b0aa3f2584fea635151e537b19b6ed623081a64663b77d4926a4997563dd09a1'
-  data.tar.gz: 42db99b7c7c5f9a904ce554ce49370a3d70daceabf3515e9797fa1951434cfd87f39f213d0a780b3183dab2427fdb9a3e1f7867327223a6287585a0b66aa691b
+  metadata.gz: 0eac33bde343620b5648ac00bc61cfb8e48a95692b16fe6f135d679646bb8f07c6f51ab6271da0aacf90b3d2fecd087763ea1bf1c4133cc172a4bff3b2d426fe
+  data.tar.gz: 69545def1558284cd78eccd6933edf5fbb1a890065b4b5f959d1736e693f7bac37ee83e70fe65a169f3a2f1bb01e456dd9293cd19b6ff7e49326b4043996fa3e

data/.claude/hooks/pre-commit-check.sh

@@ -18,12 +18,52 @@ fi
 
 echo "Running pre-commit checks..." >&2
 
-# Generate RBS and run all checks
-if ! bundle exec rbs-inline --opt-out --output=sig/ lib/ >&2; then
+# Regenerate RBS from scratch so that files orphaned by deleted lib/ sources are dropped too
+if ! bundle exec rake rbs:regenerate >&2; then
     echo "Error: RBS generation failed" >&2
     exit 2
 fi
 
+# True when $command stages the whole of sig/ itself, which the check below cannot see because
+# this hook runs first. Staging only part of sig/ does not count - the rest still drops out.
+stages_sig() {
+    local segment tokens token stages_everything pathspec_given
+
+    while IFS= read -r segment; do
+        segment=${segment//[\"\']/}
+        read -ra tokens <<<"${segment#*add}"
+        stages_everything=0
+        pathspec_given=0
+
+        for token in "${tokens[@]}"; do
+            case "$token" in
+                --) ;;
+                -*A*|--all) stages_everything=1 ;;
+                -*) ;;
+                .|./|sig|sig/|./sig|./sig/) return 0 ;;
+                *) pathspec_given=1 ;;
+            esac
+        done
+
+        # -A alone stages every path; given a pathspec it stages that path only
+        [ "$stages_everything" = 1 ] && [ "$pathspec_given" = 0 ] && return 0
+    done < <(grep -oE '(^|[;&|(])[[:space:]]*git[[:space:]]+add[^;&|(]*' <<<"$command")
+
+    return 1
+}
+
+# Stop rather than let the RBS just regenerated above drop out of the commit unnoticed
+if [[ "$command" =~ git[[:space:]]+commit([[:space:]]|$) ]] && ! stages_sig; then
+    unstaged_sig=$(git status --porcelain --untracked-files=all -- sig/ | awk 'substr($0, 2, 1) != " "')
+
+    if [ -n "$unstaged_sig" ]; then
+        echo "Error: sig/ has changes that are not staged:" >&2
+        echo "$unstaged_sig" >&2
+        echo "Run 'git add sig/' and commit again." >&2
+        exit 2
+    fi
+fi
+
 if ! bundle exec rake >&2; then
     echo "Error: rake checks failed" >&2
     exit 2

data/.claude/hooks/protect-sig-files.sh

@@ -1,29 +1,44 @@
 #!/bin/bash
-# .claude/hooks/protect-sig-files.sh
-#
 # Prevents direct editing of auto-generated RBS type definition files.
-# Type definitions in */sig/ directories are managed by PostToolUse hooks.
+# Type definitions in the project's own sig/ are managed by PostToolUse hooks.
+# Hand-written stubs for third-party gems under sig/gems/ are exempt.
 
-TOOL_NAME="$CLAUDE_TOOL_NAME"
-FILE_PATH="$CLAUDE_TOOL_PARAM_file_path"
-COMMAND="$CLAUDE_TOOL_PARAM_command"
+# Hook input is JSON from stdin
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.tool_name // ""')
 
 # Block Write/Edit operations on sig/ files
-if [[ "$TOOL_NAME" == "Write" || "$TOOL_NAME" == "Edit" ]]; then
-    if [[ "$FILE_PATH" == */sig/* ]]; then
-        echo "❌ ERROR: Direct editing of sig/ files is not allowed."
-        echo "📝 Type definitions are auto-generated by PostToolUse hook."
-        echo "💡 Modify inline RBS annotations in .rb files instead."
-        exit 1
+if [[ "$tool_name" == "Write" || "$tool_name" == "Edit" ]]; then
+    file_path=$(echo "$input" | jq -r '.tool_input.file_path // ""')
+
+    # Judge the path relative to the project root: only the sig/ there is
+    # generated. A sig/ nested elsewhere is hand-written and stays editable.
+    project_root="${CLAUDE_PROJECT_DIR:-$PWD}"
+    rel_path="${file_path#"${project_root}/"}"
+
+    if [[ "$rel_path" == sig/gems/* ]]; then
+        exit 0
+    fi
+
+    if [[ "$rel_path" == sig/* ]]; then
+        echo "❌ ERROR: Direct editing of generated sig/ files is not allowed." >&2
+        echo "📝 This repository's own types are generated: fix the inline RBS comments in the .rb file." >&2
+        echo "💡 Hand-written files are allowed only under sig/gems/ (stubs for third-party gems)." >&2
+        exit 2
     fi
 fi
 
 # Block manual rbs-inline execution
-if [[ "$TOOL_NAME" == "Bash" ]]; then
-    if [[ "$COMMAND" =~ rbs-inline ]]; then
-        echo "❌ ERROR: Manual rbs-inline execution is not allowed."
-        echo "🔄 Type definitions are auto-generated by hooks."
-        exit 1
+if [[ "$tool_name" == "Bash" ]]; then
+    command=$(echo "$input" | jq -r '.tool_input.command // ""')
+
+    # Match rbs-inline only at a command position, not as an argument.
+    rbs_inline_re=$'(^|[;&|(\n])[[:space:]]*(bundle[[:space:]]+exec[[:space:]]+)?([^[:space:]]*/)?rbs-inline([[:space:]]|[;&|)]|$)'
+
+    if [[ "$command" =~ $rbs_inline_re ]]; then
+        echo "❌ ERROR: Manual rbs-inline execution is not allowed." >&2
+        echo "🔄 Type definitions are auto-generated by hooks." >&2
+        exit 2
     fi
 fi
 

data/.claude/hooks/self-review.sh

@@ -1,15 +1,17 @@
 #!/bin/bash
 #
-# PostToolUse hook for self-review after git push
+# PreToolUse hook: review code before `git commit`.
 #
-# This script triggers a self-review process after git push operations.
-# The output is fed back to Claude via JSON, prompting it to perform
-# a code review.
+# Fires before a Bash `git commit` command and blocks the first commit attempt
+# for a given change-set, asking Claude to review the code before committing.
+# The review uses the `self-review` skill when available, and falls back to the
+# bundled `code-review` skill otherwise — so the hook works even in projects
+# that don't ship the custom self-review skill.
 #
-# NOTE: PostToolUse hooks with exit code 0 only show plain text stdout
-# in verbose mode. To ensure Claude receives the message, we output JSON
-# with "decision": "block" and "reason", which Claude Code delivers as
-# a system-reminder.
+# A per-change-set marker (keyed by a hash of the diff, stored under .git/)
+# prevents an infinite block loop: once a change-set has been surfaced for
+# review, the matching commit is allowed through. If the review leads to fixes,
+# the diff changes, so the new state is reviewed once more before it commits.
 #
 
 set -euo pipefail
@@ -20,49 +22,78 @@ input=$(cat)
 tool_name=$(echo "$input" | jq -r '.tool_name // empty')
 command=$(echo "$input" | jq -r '.tool_input.command // empty')
 
-# Only run for Bash tool
+# Only gate the Bash tool running a git commit.
 if [[ "$tool_name" != "Bash" ]]; then
   exit 0
 fi
+# Match `git commit`, or `git -C <path> commit`.
+commit_re='git[[:space:]]+(-C[[:space:]]+[^[:space:]]+[[:space:]]+)?commit'
+if [[ ! "$command" =~ $commit_re ]]; then
+  exit 0
+fi
+
+# If the command targets a specific repo via `git -C <path>`, operate there too.
+work_dir="."
+if [[ "$command" =~ git[[:space:]]+-C[[:space:]]+([^[:space:]]+) ]]; then
+  work_dir="${BASH_REMATCH[1]}"
+fi
+
+# Not a git repo → nothing to do.
+git_dir=$(git -C "$work_dir" rev-parse --absolute-git-dir 2>/dev/null || true)
+if [[ -z "$git_dir" ]]; then
+  exit 0
+fi
 
-# Check if it's a git push command
-if [[ ! "$command" =~ git[[:space:]]+push ]]; then
+# Hash what will be committed. `git status --porcelain` is included so a commit
+# that only adds untracked files isn't mistaken for empty; `git diff HEAD` adds
+# tracked content. On the first commit there is no HEAD, so use the working state.
+if git -C "$work_dir" rev-parse --verify HEAD >/dev/null 2>&1; then
+  changeset=$(git -C "$work_dir" status --porcelain; git -C "$work_dir" diff HEAD)
+else
+  changeset=$(git -C "$work_dir" status --porcelain; git -C "$work_dir" diff; git -C "$work_dir" diff --cached)
+fi
+
+# Nothing to review (e.g. a message-only `--amend`) → let it proceed.
+if [[ -z "$changeset" ]]; then
   exit 0
 fi
 
-# Check if push was successful (field may not exist; default to 0)
-exit_code=$(echo "$input" | jq -r '.tool_response.exit_code // 0')
+hash=$(printf '%s' "$changeset" | git hash-object --stdin)
+state_file="$git_dir/self-review-reviewed"
 
-if [[ "$exit_code" != "0" ]]; then
-  # Push failed, no need for review
+# Already surfaced for review → allow the commit.
+if [[ -f "$state_file" ]] && grep -qxF "$hash" "$state_file"; then
   exit 0
 fi
 
-# Output self-review prompt as JSON so Claude receives it
-review_prompt='SELF-REVIEW REQUIRED: A git push has been completed. Please use the Task tool with subagent_type Explore to perform a self-review of the changes. Use this prompt for the Explore subagent:
+# Record this change-set and block once to force a review first.
+echo "$hash" >> "$state_file"
+
+review_prompt='SELF-REVIEW REQUIRED before committing. Review the changes that are
+about to be committed BEFORE running git commit again:
 
-First, read CLAUDE.md to understand the project rules and conventions.
-Then review the recent git push. Run `git log origin/main..HEAD --stat` and
-`git diff origin/main...HEAD` to examine all changes from the branch point.
-Check for:
-1. Correctness: requirements met, logic errors, edge cases
-2. Code Quality: naming, readability, follows project conventions
-3. Testing: test coverage for new functionality
-4. Security: vulnerabilities, input validation
-5. Commit Quality: each commit should be a meaningful unit of work.
-   If there are minor fix commits (typos, forgotten changes, careless mistakes),
-   suggest squashing them into the relevant commit before merging.
+- If the `self-review` skill is available, invoke it (Skill tool, skill "self-review").
+- Otherwise, run the bundled `/code-review` skill on the working diff.
 
-Report findings and suggest fixes if needed.
-After the subagent review, if issues are found, create follow-up commits to address them.
+If the review finds issues, fix them and review again. Once it is clean, run the same
+git commit command again to proceed — it will be allowed through.
 
-If working in a git worktree (i.e., the working directory is under .claude/worktrees/),
-use `git -C <worktree-path>` for all git commands instead of `cd <path> && git`.
-Also avoid chaining commands with `&&` where possible — run each command separately.'
+The review runs in an isolated subagent with no memory of earlier rounds, so it cannot
+tell on its own whether it is repeating itself — only you, the caller, have that history.
+Before fixing a finding, check your own conversation: if it asks for the same change as
+a finding you already attempted to satisfy twice before (worded differently still counts),
+and it is still not resolved, do not attempt a third fix. Instead stop and ask the user
+(AskUserQuestion): what the finding wants, how the two prior attempts addressed it, why it
+still was not accepted, and the options (try a different fix, skip this finding and
+commit, or decide the review point does not apply here). Do not run git commit again until
+the user answers — another round of fixes would only repeat the same mismatch.'
 
 jq -n --arg reason "$review_prompt" '{
-  "decision": "block",
-  "reason": $reason
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": $reason
+  }
 }'
 
 exit 0

data/.claude/settings.json

@@ -20,6 +20,16 @@
             "timeout": 300000
           }
         ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/self-review.sh",
+            "timeout": 10000
+          }
+        ]
       }
     ],
     "SessionStart": [
@@ -42,16 +52,6 @@
             "timeout": 60000
           }
         ]
-      },
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/self-review.sh",
-            "timeout": 10000
-          }
-        ]
       }
     ]
   }

data/CHANGELOG.md

@@ -1,5 +1,48 @@
 ## [Unreleased]
 
+## [1.2.0] - 2026-08-08
+
+- `RSpec/UnusedLet` now also flags `subject`/`subject!` definitions that
+  nothing references. A subject answers to two names: its own, when it has
+  one, and the implicit `subject`, which RSpec's one-liner syntax
+  (`is_expected`, `are_expected`, `should`, `should_not`) and rspec-its' `its`
+  reach. A reference by either name counts, in a shared example block as much
+  as in an example group. `CheckLetBang` governs `subject!` alongside `let!`,
+  and setting the new `CheckSubject` (default `true`) to `false` turns the
+  check off entirely.
+- `RSpec/UnusedLet` now also flags helper methods (`def`) written at an
+  example group's level whose name is never referenced. Such a method
+  becomes an instance method on the group's example class, so it is checked
+  with the same rules as a `let`, and autocorrect removes it.
+- `RSpec/UnusedLet` now understands `shared_examples` / `shared_context`.
+  Where it used to silence every `let` an inclusion could reach, it now works
+  out which ones the shared block really uses, falling back to the old
+  behavior only for an inclusion it cannot resolve, and it no longer flags a
+  `let` that overrides a name an inline inclusion (`include_examples` /
+  `include_context`) injects and the shared block itself references. It also
+  checks the `let`s defined inside a shared block that carries examples —
+  expect new offenses on upgrade. `SharedExamplePaths` lists the files,
+  besides the one under inspection, whose top-level blocks are resolved, and
+  defaults to `spec/support/**/*.rb`; `CheckSharedExamples: false` leaves the
+  `let`s inside shared blocks unchecked, as before.
+- `RSpec/UnusedLet` now skips helper specs (rspec-rails `type: :helper`, or
+  files under `spec/helpers`) by default, since the auto-included module may
+  reference any `let` unseen. Set `CheckHelperSpecs: true` to check them.
+- `RSpec/UnusedLet` now recognizes `let` definitions consumed by
+  well-known gems' shared contexts and treats them as used. Currently
+  supports [rspec-validator_spec_helper](https://github.com/izumin5210/rspec-validator_spec_helper):
+  groups tagged with `type: :validator` may override `value`,
+  `attribute_names`, `options` (and the helper's other overridable
+  lets) without being flagged.
+- Fix a false positive in `RSpec/UnusedLet` when a `let` defined in a
+  nested group was only referenced from an ancestor group's `let`,
+  `subject`, or hook block. Those ancestor blocks run in the example's
+  scope, so their references resolve to the nested definition.
+- Fix a false positive in `RSpec/UnusedLet` when a `let` was only
+  referenced from a plain `def` helper method defined in an ancestor
+  example group. Such helpers become instance methods on the example
+  class and can reference `let` names visible at the example.
+
 ## [1.1.0] - 2026-07-15
 
 - `RSpec/UnusedLet` now supports autocorrect. The correction is marked