rbs_activerecord 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a901f8b1ee98a3837e7ee4182ffb3d247466793f367ac6b764487271f2088445
-  data.tar.gz: 749b7ec1f3dc34235087df037f7f94418e09729cff3229717e1620a08d6abbaa
+  metadata.gz: 78a25f0014350c5542d7b2ed8eeb226c736c8f3416432261413e26f84b7d5877
+  data.tar.gz: 92684a1a6ac24afc2bcf1fe160ab6bf391f0ada8bd75ae337360c01d36891114
 SHA512:
-  metadata.gz: 6c5e46b70af5fb36fbfacf1beea9f949ad18b31a78ca13bfe37578f0fb8d4c5c88738bbc9039f09adde10ce49dc7f43a49d60664ac9130f4614178a8781259bf
-  data.tar.gz: 16cdca38fc3d9d72ba97ab9c076996aea8c58864bdcb41476a0bf8d9f86123a1042fe305a4e3ff77022ad86febeba50c6d7c632fc2bf8f3512af8b9cd58c4858
+  metadata.gz: 680a2e88d185d9a7c26d124ed5b6f0240233f4199006f4eb85e1639b25abb2925fa6ac6dd623c4d25f7777eea947a137357c05e274f3d8ac02c88ee9a01e2acc
+  data.tar.gz: db219887c854a4f412e0d5c1ba7713dc2425c45d985e9bb9fd5872424d51a84c17d8b843db400273fe7c47baa35e690fc2fe8ca2d45bfce2cdfeaf3e0aaf13b7

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,20 +1,80 @@
+# NOTE: Rules are sorted in ASCII order.
+
 AllCops:
-  TargetRubyVersion: 3.1
+  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:
     - "spec/**/*.rb"
 
+Metrics/ClassLength:
+  Max: 200
+
 Metrics/MethodLength:
   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

@@ -6,13 +6,28 @@
     "rbs-helper.rbs-inline-on-save": true,
     "cSpell.words": [
         "activerecord",
+        "activestorage",
+        "bindir",
         "codebases",
         "Cyclomatic",
+        "entryable",
+        "foos",
         "kaminari",
+        "KOMIYA",
+        "kwargs",
         "mkpath",
         "modname",
+        "noargs",
+        "popen",
+        "posargs",
+        "raketask",
+        "readlines",
         "requireds",
         "rmtree",
-        "tasklib"
+        "rubocop",
+        "rubygems",
+        "Takeshi",
+        "tasklib",
+        "tk0miya"
     ]
 }

data/README.md

@@ -23,6 +23,12 @@ Run `rbs:activerecord:setup` task:
 Then rbs_activerecord will scan your code and generate RBS files into
 `sig/activerecord` directory.
 
+## Configurations
+
+You can change the behavior of the generator via rbs_activerecord.rake:
+
+* pure_accessors: Make accessor methods for columns pure.  It helps [Type narrowing](https://github.com/soutaro/steep/wiki/Release-Note-1.1#type-narrowing-on-method-calls-590).
+
 ## The goal of rbs_activerecord
 
 rbs_activerecord is an experimental project to enhance the type generation for ActiveRecord models.
@@ -43,6 +49,7 @@ Main differences between rbs_activerecord and rbs_rails are:
     * Support extension ActiveRecord from 3rd party gems ([#254](https://github.com/pocke/rbs_rails/pull/254))
         * ex. [kaminari-activerecord](https://github.com/ruby/gem_rbs_collection/pull/725)
     * Support composite primary keys ([#275](https://github.com/pocke/rbs_rails/pull/275))
+    * Support pure_accessors ([#302](https://github.com/pocke/rbs_rails/issues/302))
     * Extend return types of #pluck ([#273](https://github.com/pocke/rbs_rails/pull/273))
     * Override types of CollectionProxy ([#289](https://github.com/pocke/rbs_rails/pull/289))
 * Bug fixes

data/Rakefile

@@ -1,14 +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
-  task :generate do
-    sh "rbs-inline", "--opt-out", "--output=sig", "lib"
+  # 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_activerecord/install_generator.rb

@@ -4,14 +4,17 @@ require "rails"
 
 module RbsActiverecord
   class InstallGenerator < Rails::Generators::Base
-    def create_raketask
+    def create_raketask #: void
       create_file "lib/tasks/rbs_activerecord.rake", <<~RUBY
         # frozen_string_literal: true
 
         begin
           require "rbs_activerecord/rake_task"
 
-          RbsActiverecord::RakeTask.new
+          RbsActiverecord::RakeTask.new do |task|
+            # Make accessor methods for columns pure.
+            # task.pure_accessors = true
+          end
         rescue LoadError
           # failed to load rbs_activerecord. Skip to load rbs_activerecord tasks.
         end

data/lib/rbs_activerecord/generator/active_storage/instance_methods.rb

@@ -23,13 +23,14 @@ module RbsActiverecord
 
         def attachments #: Hash[String, untyped]
           if model.klass.respond_to?(:attachment_reflections)
-            model.klass.attachment_reflections # steep:ignore
+            model.klass.attachment_reflections
           else
             {}
           end
         end
 
         # @rbs name: String
+        # @rbs reflection: untyped
         def attachment(name, reflection) #: String
           case reflection.macro
           when :has_one_attached
@@ -44,7 +45,7 @@ module RbsActiverecord
             RBS
           when :has_many_attached
             <<~RBS
-              def #{name}: () -> ::ActiveStroage::Attached::Many
+              def #{name}: () -> ::ActiveStorage::Attached::Many
               def #{name}=: (untyped) -> untyped
             RBS
           else

data/lib/rbs_activerecord/generator/active_storage/scopes.rb

@@ -23,7 +23,7 @@ module RbsActiverecord
 
         def attachments #: Hash[String, untyped]
           if model.klass.respond_to?(:attachment_reflections)
-            model.klass.attachment_reflections # steep:ignore
+            model.klass.attachment_reflections
           else
             {}
           end

data/lib/rbs_activerecord/generator/associations.rb

@@ -25,7 +25,7 @@ module RbsActiverecord
 
       private
 
-      def has_many #: String  # rubocop:disable Naming/PredicateName
+      def has_many #: String # rubocop:disable Naming/PredicatePrefix
         model.reflect_on_all_associations(:has_many).map do |assoc|
           assoc_name = assoc.name.to_s
           klass_name = "::#{assoc.klass.name}"
@@ -41,7 +41,7 @@ module RbsActiverecord
         end.join("\n")
       end
 
-      def has_one #: String  # rubocop:disable Naming/PredicateName
+      def has_one #: String # rubocop:disable Naming/PredicatePrefix
         model.reflect_on_all_associations(:has_one).map do |assoc|
           type = "::#{assoc.klass.name}"
           optional = "#{type}?"
@@ -85,7 +85,7 @@ module RbsActiverecord
       def polymorphic_owner_types(assoc) #: String  # rubocop:disable Metrics/AbcSize
         table_name = model.klass.name.to_s.tableize.to_sym
         owners = ActiveRecord::Base.descendants.select do |klass|
-          klass.reflect_on_all_associations.any? { |a| a.name == table_name && a.options[:as] == assoc.name }
+          klass.reflect_on_all_associations.any? { _1.name == table_name && _1.options[:as] == assoc.name }
         end
 
         if owners.empty?
@@ -98,7 +98,7 @@ module RbsActiverecord
         end
       end
 
-      def has_and_belongs_to_many #: String  # rubocop:disable Naming/PredicateName
+      def has_and_belongs_to_many #: String # rubocop:disable Naming/PredicatePrefix
         model.reflect_on_all_associations(:has_and_belongs_to_many).map do |assoc|
           assoc_name = assoc.name.to_s
           klass_name = assoc.klass.name