rbs_activemodel 1.3.1 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e4dc4dbc7e78453a1e28c02b840515cd7842128f8a811be4186e7d142694bc5
-  data.tar.gz: 360bca3add7f52c45aecb98748d993d2233b7e3ac02d09dd0c8c6e7d73a4b5b0
+  metadata.gz: 1e505f32754d95ee6e0b0588c1c4e29eb1886f7815541a3cff9316e5425ffafe
+  data.tar.gz: bf675d5783c2983cac9a59f448ea2ec9bcab0e99a4da8451f9305bc3a4b5d5e7
 SHA512:
-  metadata.gz: a8f2bfa44a7646f724db738cba0e8aab2f4cc1c07c8841151a3cf70e64b520a20e885b022b5dda4d7d9998c878ea0d60a7eac3354ba4ca5d219ac370dbd7ecc5
-  data.tar.gz: 1fe675d397625b1570d1de917a9f6f32733447e4c54d36265d3645d825199d4799c9032d0860e835c88bb27c7e293090a80781a21492f130f3925a6630aba807
+  metadata.gz: 4eacf6b6a9c5fa22698a011d14d91db2767fdb07ea5a0c85e6ca8c65759ac6bb861f7c47bf1325512d043cca5271baac132c9d92a90abb04c5220106a8f38934
+  data.tar.gz: 75660cc87d4927e3cfa514760689e1c992690404b1e4465bec2063ea1487da905dff590f6f83f3bb5f50215198c8417b8bfea5366bb5b71d798c25c300e3c942

data/.claude/hooks/claude-code-web-session-start.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+set -eu
+
+if [ "${CLAUDE_CODE_REMOTE:-}" = "true" ]; then
+  eval "$(rbenv init - bash)"
+
+  # Set the latest installed Ruby version as the global default
+  rbenv global `rbenv versions --bare | sort -rV | head -1`
+
+  echo 'eval "$(rbenv init - bash)"' >> "$CLAUDE_ENV_FILE"
+  echo 'export RUBYOPT="-rcgi"' >> "$CLAUDE_ENV_FILE"
+  RUBYOPT="-rcgi" bundle install
+  bundle exec rbs collection install --frozen
+fi

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

@@ -0,0 +1,73 @@
+#!/bin/bash
+
+# Hook input is JSON from stdin
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.tool_name')
+command=$(echo "$input" | jq -r '.tool_input.command // ""')
+
+# Only run for git commit commands
+if [[ "$tool_name" != "Bash" ]] || [[ ! "$command" =~ git[[:space:]]+(commit|cherry-pick|merge|rebase) ]]; then
+    exit 0
+fi
+
+cd "$CLAUDE_PROJECT_DIR" || exit 1
+
+if [ "${CLAUDE_CODE_REMOTE:-}" = "true" ]; then
+  eval "$(rbenv init - bash)"
+fi
+
+echo "Running pre-commit checks..." >&2
+
+# 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
+fi
+
+echo "All checks passed!" >&2
+exit 0

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

@@ -0,0 +1,45 @@
+#!/bin/bash
+# Prevents direct editing of auto-generated RBS type definition files.
+# 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.
+
+# 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
+    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
+    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
+
+exit 0

data/.claude/hooks/rbs-inline.sh

@@ -0,0 +1,95 @@
+#!/bin/bash
+
+# Hook input is JSON from stdin
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.tool_name')
+
+cd "$CLAUDE_PROJECT_DIR" || exit 1
+
+if [ "${CLAUDE_CODE_REMOTE:-}" = "true" ]; then
+  eval "$(rbenv init - bash)"
+fi
+
+# Handle Edit or Write tools
+if [[ "$tool_name" == "Edit" || "$tool_name" == "Write" ]]; then
+    file_path=$(echo "$input" | jq -r '.tool_input.file_path // ""')
+
+    if [[ ! "$file_path" =~ \.rb$ ]]; then
+        exit 0
+    fi
+
+    if [[ ! "$file_path" =~ /lib/ ]]; then
+        exit 0
+    fi
+
+    echo "Running rbs-inline for $file_path..." >&2
+
+    if ! bundle exec rbs-inline --opt-out --output=sig/ "$file_path" >&2; then
+        echo "Warning: RBS generation failed for $file_path" >&2
+        exit 0
+    fi
+
+    echo "RBS generation completed." >&2
+    exit 0
+fi
+
+# Handle Bash tool for mv command
+if [[ "$tool_name" == "Bash" ]]; then
+    command=$(echo "$input" | jq -r '.tool_input.command // ""')
+
+    # Check if this is a mv command
+    if [[ ! "$command" =~ ^[[:space:]]*(mv|git\ mv)[[:space:]] ]]; then
+        exit 0
+    fi
+
+    # Extract source and destination paths from mv command
+    paths=$(echo "$command" | sed -E 's/^[[:space:]]*(git[[:space:]]+)?mv[[:space:]]+//')
+
+    source_path=$(echo "$paths" | awk '{print $1}')
+    dest_path=$(echo "$paths" | awk '{print $2}')
+
+    # Check if source was a .rb file in lib/
+    if [[ ! "$source_path" =~ \.rb$ ]] || [[ ! "$source_path" =~ lib/ ]]; then
+        exit 0
+    fi
+
+    echo "Detected mv of Ruby file in lib/: $source_path -> $dest_path" >&2
+
+    # Calculate the corresponding .rbs file path for the source
+    source_rbs=$(echo "$source_path" | sed -E 's|^(.*/)?lib/|sig/|; s|\.rb$|.rbs|')
+
+    # Remove the old .rbs file if it exists
+    if [[ -f "$source_rbs" ]]; then
+        echo "Removing old RBS file: $source_rbs" >&2
+        rm -f "$source_rbs"
+    fi
+
+    # Determine the new .rb file path
+    if [[ -d "$dest_path" ]]; then
+        dest_file="$dest_path/$(basename "$source_path")"
+    else
+        dest_file="$dest_path"
+    fi
+
+    # Check if the destination is in lib/
+    if [[ ! "$dest_file" =~ lib/ ]]; then
+        echo "Destination is not in lib/, skipping RBS generation" >&2
+        exit 0
+    fi
+
+    # Generate RBS for the new file
+    if [[ -f "$dest_file" ]]; then
+        echo "Running rbs-inline for $dest_file..." >&2
+
+        if ! bundle exec rbs-inline --opt-out --output=sig/ "$dest_file" >&2; then
+            echo "Warning: RBS generation failed for $dest_file" >&2
+            exit 0
+        fi
+
+        echo "RBS generation completed." >&2
+    fi
+
+    exit 0
+fi
+
+exit 0

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

@@ -0,0 +1,93 @@
+#!/bin/bash
+#
+# PreToolUse hook: review code before `git commit`.
+#
+# 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.
+#
+# 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
+
+# Read JSON input from stdin
+input=$(cat)
+
+tool_name=$(echo "$input" | jq -r '.tool_name // empty')
+command=$(echo "$input" | jq -r '.tool_input.command // empty')
+
+# 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
+
+# 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
+
+hash=$(printf '%s' "$changeset" | git hash-object --stdin)
+state_file="$git_dir/self-review-reviewed"
+
+# Already surfaced for review → allow the commit.
+if [[ -f "$state_file" ]] && grep -qxF "$hash" "$state_file"; then
+  exit 0
+fi
+
+# 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:
+
+- 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.
+
+Judge each finding the review returns rather than fixing it on sight. Weigh what the review
+attached to it — how it graded the point, the basis it gave — and decide whether acting on it
+is worth it. Where you skip a finding, say so; do not drop it silently. Where the choice needs
+a requirement or an intent you do not have, leave it to the user. Once every fix you judged
+necessary is in, review again; when nothing you judged worth fixing is left, run the same git
+commit command again to proceed — it will be allowed through.'
+
+jq -n --arg reason "$review_prompt" '{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": $reason
+  }
+}'
+
+exit 0

data/.claude/settings.json

@@ -0,0 +1,58 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/protect-sig-files.sh",
+            "timeout": 5000
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/pre-commit-check.sh",
+            "timeout": 300000
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/self-review.sh",
+            "timeout": 10000
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/claude-code-web-session-start.sh"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/rbs-inline.sh",
+            "timeout": 60000
+          }
+        ]
+      }
+    ]
+  }
+}

data/.rubocop.yml

@@ -1,5 +1,28 @@
+# NOTE: Rules are sorted in ASCII order.
+
 AllCops:
-  TargetRubyVersion: 2.7
+  NewCops: enable
+  TargetRubyVersion: 3.3
+
+plugins:
+  - rubocop-instance_variable_access
+  - rubocop-numbered-params
+  - rubocop-rake
+  - rubocop-rbs_inline
+  - rubocop-rspec
+  - rubocop-rspec-unused-let
+
+# Layout
+Layout/LeadingCommentSpace:
+  AllowRBSInlineAnnotation: true
+  AllowSteepAnnotation: true
+
+Layout/LineLength:
+  Max: 120
+
+# Metrics
+Metrics/AbcSize:
+  Max: 20
 
 Metrics/BlockLength:
   Exclude:
@@ -7,17 +30,55 @@ Metrics/BlockLength:
     - "spec/**/*.rb"
 
 Metrics/ClassLength:
-  Max: 150
+  Max: 200
 
 Metrics/CyclomaticComplexity:
   Max: 10
 
 Metrics/MethodLength:
-  Max: 20
+  Max: 30
+
+# RSpec
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 10
+
+RSpec/NamedSubject:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Max: 5
+
+# Style
+Style/AccessorGrouping:
+  Enabled: false
+
+Style/CommentedKeyword:
+  Enabled: false
 
 Style/Documentation:
   Enabled: false
 
+Style/HashSyntax:
+  EnforcedShorthandSyntax: always
+
+Style/RbsInline:
+  Mode: opt_out
+
+Style/RbsInline/MissingTypeAnnotation:
+  EnforcedStyle: doc_style_and_return_annotation
+
+Style/RbsInline/RedundantTypeAnnotation:
+  EnforcedStyle: doc_style_and_return_annotation
+
+Style/RedundantFormat:
+  Enabled: false
+
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 

data/.vscode/settings.json

@@ -2,5 +2,24 @@
     "[ruby]": {
         "editor.defaultFormatter": "Shopify.ruby-lsp"
     },
-    "rbs-helper.signature-directory": "sig"
+    "rbs-helper.signature-directory": "sig",
+    "cSpell.words": [
+        "Activemodel",
+        "activerecord",
+        "bigdecimal",
+        "bindir",
+        "klass",
+        "KOMIYA",
+        "mkpath",
+        "popen",
+        "raketask",
+        "readlines",
+        "rmtree",
+        "rubygems",
+        "Takeshi",
+        "tasklib",
+        "tk0miya"
+    ],
+    "rbs-helper.rbs-inline-on-save": true,
+    "rbs-helper.rbs-inline-signature-directory": "sig/"
 }

data/README.md

@@ -6,7 +6,7 @@ rbs_activemodel is a RBS generator for activemodel gem.
 
 Add a new entry to your Gemfile and run `bundle install`:
 
-   group :deveopment do
+   group :development do
      gem 'rbs_activemodel', require: false
    end
 

data/Rakefile

@@ -1,8 +1,43 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
 
-task default: :rubocop
+task default: :ci
+
+task ci: %i[rubocop spec steep rbs:validate]
+
+namespace :rbs do
+  # sig/gems holds hand-written types for external gems, so it is never regenerated
+  kept = ->(path) { path == "sig/gems" || path.start_with?("sig/gems/") }
+
+  desc "Install RBS collection"
+  task :install do
+    sh "bundle exec rbs collection install --frozen"
+  end
+
+  desc "Regenerate all RBS files under sig/ from scratch (run manually after editing lib/)"
+  task :regenerate do
+    Dir.glob("sig/**/*.rbs").reject(&kept).each { rm _1 }
+
+    sh "bundle exec rbs-inline --opt-out --output=sig lib"
+
+    # Drop the directories the deletion above left empty, deepest first
+    dirs = Dir.glob("sig/**/*").select { File.directory?(_1) }
+    dirs.reject(&kept).sort.reverse_each { rmdir _1 if Dir.empty?(_1) }
+  end
+
+  desc "Validate RBS files"
+  task validate: "rbs:install" do
+    sh "bundle exec rbs -Isig validate"
+  end
+end
+
+desc "Run steep type check"
+task steep: "rbs:install" do
+  sh "bundle exec steep check"
+end

data/lib/generators/rbs_activemodel/install_generator.rb

@@ -4,7 +4,7 @@ require "rails"
 
 module RbsActivemodel
   class InstallGenerator < Rails::Generators::Base
-    def create_raketask
+    def create_raketask #: void
       create_file "lib/tasks/rbs_activemodel.rake", <<~RUBY
         # frozen_string_literal: true