rubocop-rbs_inline 1.6.1 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd596a937ef29c9dd1053c9b874725aebde2e9fab387053243268810bb0a8103
-  data.tar.gz: '03865a85b9ef1783eb85816c386aee96370e48e7169994ea5cc96c1a323aacd9'
+  metadata.gz: e4bebfc6eae9ec29990f1dafdf2fc773737b2cf001c450702b138b1d9ab81dec
+  data.tar.gz: f9ebb04f3712f5f02cd6b7388ea74b056fdce19027be61ed6b651cf1b5915ca8
 SHA512:
-  metadata.gz: a5c053242db495271ee4751bcba23bc67d876d8d668e0984634d1154452a87476ff82330ea9010c48cd0f285918124d2dc42145bb750a3a8d0f25368e8ee8e22
-  data.tar.gz: 0e78d76dc58a9ba77439f65013cf1aa46492ee84337a43c6630e81d18c02d5fba23b0fab88c42f7a73d35d3c3bf02c4cfc9bee50f9337fb4d0d2a5189ddfdbf1
+  metadata.gz: 46b9e51e95573630afbe686500cdf154a2cdf2d76bd19f441552fe76267682fb586118f96e7b0c5316352b49fc6e5ddc3b080fd1dc8b6711d31e382694ad767d
+  data.tar.gz: 9bd7d22ee40b4d009b1c2f2f86d855a37ee32349c12afffdebbda6cf5edf54bf9c474f67bdfb170987ea512c0934deb48d709f1afbc49acef88f968ebff4297a

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

@@ -0,0 +1,89 @@
+#!/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.
+
+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.'
+
+jq -n --arg reason "$review_prompt" '{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": $reason
+  }
+}'
+
+exit 0

data/.claude/settings.json

@@ -1,4 +1,7 @@
 {
+  "permissions": {
+    "allow": ["RemoteTrigger"]
+  },
   "hooks": {
     "SessionStart": [
       {
@@ -19,6 +22,11 @@
           {
             "type": "command",
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pre-commit-check.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/self-review.sh",
+            "timeout": 10000
           }
         ]
       }

data/.rubocop.yml

@@ -56,16 +56,22 @@ RSpec/NamedSubject:
 RSpec/NestedGroups:
   Max: 5
 
+# Mixin specs mirror `lib/.../rbs_inline/mixin/`, but the modules keep the
+# `RuboCop::Cop::Style::RbsInline` namespace, so the path never matches the constant.
+RSpec/SpecFilePathFormat:
+  Exclude:
+    - "spec/rubocop/cop/style/rbs_inline/mixin/**/*_spec.rb"
+
 # RbsInline
+Style/RbsInline:
+  Mode: opt_out
+
 Style/RbsInline/MissingTypeAnnotation:
   EnforcedStyle: doc_style_and_return_annotation
 
 Style/RbsInline/RedundantTypeAnnotation:
   EnforcedStyle: doc_style_and_return_annotation
 
-Style/RbsInline/RequireRbsInlineComment:
-  EnforcedStyle: never
-
 # Style
 Style/AccessorGrouping:
   Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 1.8.0 (2026-07-26)
+
+### Enhancements
+
+- **Style/RbsInline**: Added a shared `Mode` setting (`opt_in` / `opt_out`) at the department level to filter which files each cop checks based on the `# rbs_inline: enabled` / `disabled` magic comment.
+- **Style/RbsInline/RequireRbsInlineComment**: Added the `AllowMissingComment` option, which lets projects use rbs-inline on only some of their files while keeping the opt-in filter for the rest.
+
+### Bug Fixes
+
+- **Style/RbsInline/DataClassCommentAlignment**, **Style/RbsInline/StructClassCommentAlignment**: Fixed the expected annotation column being derived from arguments that cannot carry an annotation (a splat, or for `Struct.new` a leading struct name or `keyword_init:`), which reported false positives on already aligned code and made autocorrect over-pad the annotations.
+- **Style/RbsInline/MissingDataClassAnnotation**, **Style/RbsInline/MissingStructClassAnnotation**: Fixed autocorrect padding the inserted annotations to the width of an argument that cannot carry one (a splat, or for `Struct.new` a leading struct name or `keyword_init:`).
+- **Style/RbsInline/UnmatchedAnnotations**: Fixed a crash on method definitions taking a destructuring argument (ex. `def foo((a, b))`). The crash also aborted the inspection of the method definition, causing false positives on its valid annotations.
+- **Style/RbsInline/RequireRbsInlineComment**: Fixed a crash (`IndexError`) on a file whose leading comment block ends without a trailing newline. The offense is now reported and the magic comment is inserted on its own line.
+- **Style/RbsInline/RedundantTypeAnnotation**: Fixed `--auto-gen-config` generating an `EnforcedStyle` that does not resolve the offenses (including the unsupported `return_type_annotation`, which made RuboCop fail to start on the generated `.rubocop_todo.yml`). No style can make redundant annotations offense-free, so the offending files are now excluded instead.
+
+### Deprecations
+
+- **Style/RbsInline/RequireRbsInlineComment**: `EnforcedStyle` is deprecated in favor of the department-level `Mode`. Migrate `always` → `Style/RbsInline: Mode: opt_in`, `never` → `Style/RbsInline: Mode: opt_out`. Will be removed in the next major version.
+
+## 1.7.0 (2026-07-20)
+
+### New Features
+
+- **Style/RbsInline/MissingStructClassAnnotation**: New cop that checks each attribute passed to `Struct.new` has a trailing `#:` inline type annotation. Supports autocorrect.
+- **Style/RbsInline/StructClassCommentAlignment**: New cop that checks `#:` inline type annotations in a multiline `Struct.new` call are aligned. Supports autocorrect.
+- **Style/RbsInline/StructNewWithBlock**: New cop that checks for `Struct.new` calls with a block, which RBS::Inline does not parse.
+
 ## 1.6.1 (2026-07-10)
 
 ### Bug Fixes

data/CLAUDE.md

@@ -23,7 +23,7 @@ bundle exec rake rubocop:autocorrect_all   # all autocorrect
 bundle exec rake steep                     # runs steep check
 bundle exec rake rbs:validate              # validates RBS signatures
 
-# Default rake task (runs specs, rubocop, and type check)
+# Default rake task (rubocop, specs, steep, rbs:validate)
 bundle exec rake
 
 # Generate a new cop
@@ -34,32 +34,27 @@ bundle exec rake 'new_cop[Style/RbsInline/CopName]'
 
 ### Cop Structure
 
-All cops live under `RuboCop::Cop::Style::RbsInline` namespace in `lib/rubocop/cop/style/rbs_inline/`. Each cop validates a different aspect of RBS::Inline annotations:
+Cops live in `lib/rubocop/cop/style/rbs_inline/`, one per file; the shared modules they mix in live in `lib/rubocop/cop/style/rbs_inline/mixin/`. Both are under the `RuboCop::Cop::Style::RbsInline` namespace — only the directory separates them, as in `rubocop`'s `cop/mixin/`. `config/default.yml` lists every cop and its options; read it instead of a list kept here.
 
-- **InvalidComment** - Validates `#:` and `# @rbs` comment syntax
-- **InvalidTypes** - Validates RBS type syntax in annotations
-- **KeywordSeparator** - Ensures keywords like `module-self` aren't followed by `:`
-- **ParametersSeparator** - Ensures parameter annotations use `:` separator
-- **RedundantArgumentType** - Detects redundant argument type specs (configurable style)
-- **RedundantReturnType** - Detects redundant return type specs (3 style options)
-- **UnmatchedAnnotations** - Ensures annotation parameters match actual method parameters
+Conventions:
 
-### Shared CommentParser Module
-
-`comment_parser.rb` is a module mixed into cops that need to parse RBS::Inline annotations. It uses `RBS::Inline::AnnotationParser` and Prism to parse comments, and provides helpers for finding leading annotations, inline comments, and return annotations relative to method definitions.
+- Every cop `prepend`s `FileFilter` except `RequireRbsInlineComment`.
+- `Data.define` and `Struct.new` cops come in pairs sharing a base module. Behavior belongs in the module; only the node matcher and `MSG` in the cop.
 
 ### Plugin System
 
-The gem integrates with RuboCop via LintRoller (`lib/rubocop/rbs_inline/plugin.rb`). Default cop configuration is in `config/default.yml`.
+The gem integrates with RuboCop via LintRoller (`lib/rubocop/rbs_inline/plugin.rb`), which points RuboCop at `config/default.yml`.
 
 ### Type Signatures
 
-RBS type signatures for all source files are maintained in `sig/` directory. The project uses Steep for static type checking, configured via `Steepfile`.
+`sig/rubocop/` is generated from `lib/` by the hooks in `.claude/hooks/`. Never write anything there. `sig/gems/` is hand-written stubs for third-party gems and is *not* regenerated — do not delete it when refreshing signatures.
 
 ### Testing Pattern
 
 Tests use RuboCop's RSpec support helpers (`expect_offense` / `expect_no_offenses`). Test files mirror the cop file structure under `spec/rubocop/cop/style/rbs_inline/`.
 
+`:config` specs build a bare `RuboCop::Config`, so `config/default.yml` and RuboCop's department-to-cop defaults are not merged in. A spec that sets a value at the department level proves nothing about how it resolves in a real run.
+
 ## Code Style Notes
 
 - `Layout/LeadingCommentSpace` and `Style/CommentedKeyword` are disabled because RBS::Inline `#:` comments violate these rules by design.

data/README.md

@@ -27,6 +27,23 @@ plugins:
 
 rubocop-rbs_inline provides the following cops to validate [RBS::Inline](https://github.com/soutaro/rbs-inline) annotations:
 
+### Style/RbsInline (shared configuration)
+
+The `Style/RbsInline` department has a shared `Mode` setting that gates whether each `Style/RbsInline/*` cop reports offenses on a given file:
+
+- `Mode: opt_in` — cops only check files that carry `# rbs_inline: enabled`. Files with `# rbs_inline: disabled` or no magic comment are skipped. Matches RBS::Inline's opt-in mode.
+- `Mode: opt_out` — cops check every file except those with `# rbs_inline: disabled`. Matches RBS::Inline's opt-out mode.
+- unset — cops check every file (legacy behavior; the default will change to `opt_in` in the next major release).
+
+Declare it once at the department level in your `.rubocop.yml`:
+
+```yaml
+Style/RbsInline:
+  Mode: opt_in
+```
+
+Unknown `Mode` values (e.g. `Mode: opt-in`) emit a warning and disable filtering for the run.
+
 ### Style/RbsInline/DataClassCommentAlignment
 
 Checks that `#:` inline type annotations in a multiline `Data.define` call are aligned to the same column. The expected column is determined by the longest attribute name (plus its trailing comma). Folded `Data.define` calls (where multiple attributes share a line) are excluded.
@@ -198,6 +215,32 @@ MethodEntry = Data.define(
 )
 ```
 
+### Style/RbsInline/MissingStructClassAnnotation
+
+Checks that each attribute passed to `Struct.new` has a trailing `#:` inline type annotation on the same line.
+
+For folded `Struct.new` calls (where multiple attributes share a line), the cop will suggest rewriting as a multiline call so each attribute can be annotated individually. A leading string argument (the struct name) and the `keyword_init:` keyword argument are not attributes and are ignored.
+
+Supports autocorrect.
+
+**Examples:**
+```ruby
+# bad
+Point = Struct.new(:x, :y)
+
+# bad - missing annotation for :y
+Point = Struct.new(
+  :x,  #: Integer
+  :y
+)
+
+# good
+Point = Struct.new(
+  :x,  #: Integer
+  :y   #: Integer
+)
+```
+
 ### Style/RbsInline/MissingTypeAnnotation
 
 Enforces that method definitions and `attr_*` declarations have RBS inline type annotations.
@@ -212,7 +255,11 @@ Enforces that method definitions and `attr_*` declarations have RBS inline type
   - `all`: Checks all methods regardless of visibility
   - `public`: Only checks public methods and `attr_*` declarations
 
-Methods annotated with `# @rbs skip` are always excluded.
+Always excluded, regardless of `EnforcedStyle`:
+
+- Methods annotated with `# @rbs skip` or `# @rbs override`.
+- Parameters whose name starts with `_`.
+- The `...` forward-all parameter.
 
 **Examples (EnforcedStyle: doc_style):**
 ```ruby
@@ -440,13 +487,26 @@ end
 
 ### Style/RbsInline/RequireRbsInlineComment
 
-Enforces presence or absence of `# rbs_inline:` magic comment for consistency.
+Enforces the presence or absence of the `# rbs_inline:` magic comment, based on the shared [`Mode`](#stylerbsinline-shared-configuration) setting:
 
-**Configuration:** `EnforcedStyle` (default: `always`)
-- `always`: Requires `# rbs_inline: enabled` or `# rbs_inline: disabled`
-- `never`: Forbids `# rbs_inline: enabled` (allows `# rbs_inline: disabled`)
+- Under `Mode: opt_in`, files must carry `# rbs_inline: enabled` (or `# rbs_inline: disabled`).
+- Under `Mode: opt_out`, files must not carry `# rbs_inline: enabled`.
+
+**Configuration:**
+
+- `AllowMissingComment` (default: `false`) — under `Mode: opt_in`, set to `true` to skip enforcement of the magic comment on individual files. Useful when only part of the project uses rbs-inline: the shared `Mode: opt_in` filter still applies to every other cop (they only report on files that opt in), but this cop stops requiring the magic comment on files that intentionally do not use rbs-inline.
+
+```yaml
+Style/RbsInline:
+  Mode: opt_in
 
-**Examples (EnforcedStyle: always):**
+Style/RbsInline/RequireRbsInlineComment:
+  AllowMissingComment: true
+```
+
+The legacy `EnforcedStyle` parameter (`always` / `never`) is deprecated in favor of `Mode`; it will be removed in the next major release.
+
+**Examples (Mode: opt_in):**
 ```ruby
 # bad
 class Foo
@@ -458,6 +518,62 @@ class Foo
 end
 ```
 
+**Examples (Mode: opt_in, AllowMissingComment: true):**
+```ruby
+# good - the magic comment is not enforced per file
+class Foo
+end
+
+# good
+# rbs_inline: enabled
+class Foo
+end
+```
+
+### Style/RbsInline/StructClassCommentAlignment
+
+Checks that `#:` inline type annotations in a multiline `Struct.new` call are aligned to the same column. The expected column is determined by the longest attribute name (plus its trailing comma). Folded `Struct.new` calls (where multiple attributes share a line) are excluded.
+
+Supports autocorrect.
+
+**Examples:**
+```ruby
+# bad
+Point = Struct.new(
+  :x, #: Integer
+  :long_attr  #: Integer
+)
+
+# good
+Point = Struct.new(
+  :x,         #: Integer
+  :long_attr  #: Integer
+)
+```
+
+### Style/RbsInline/StructNewWithBlock
+
+Checks for `Struct.new` calls with a block. RBS::Inline does not parse block contents, so any methods defined inside the block will not be recognized for type checking. Instead, call `Struct.new` without a block and reopen the class separately to add methods.
+
+**Examples:**
+```ruby
+# bad
+User = Struct.new(:name, :role) do
+  def admin?
+    role == :admin
+  end
+end
+
+# good
+User = Struct.new(:name, :role)
+
+class User
+  def admin? #: bool
+    role == :admin
+  end
+end
+```
+
 ### Style/RbsInline/UnmatchedAnnotations
 
 Verifies that annotation parameters match the actual method parameters.
@@ -543,6 +659,8 @@ Style/RbsInline/MissingTypeAnnotation:
   Visibility: public
 ```
 
+To restrict every cop to files that carry `# rbs_inline: enabled`, see [Style/RbsInline (shared configuration)](#stylerbsinline-shared-configuration).
+
 See [config/default.yml](config/default.yml) for all available configuration options.
 
 ## Development

data/config/default.yml

@@ -5,6 +5,7 @@ Style/RbsInline:
   Exclude:
     - 'spec/**/*'
     - 'test/**/*'
+  Mode: ~
 
 Style/RbsInline/DataClassCommentAlignment:
   Description: "Checks that `#:` inline type annotations in `Data.define` blocks are aligned."
@@ -46,6 +47,11 @@ Style/RbsInline/MissingDataClassAnnotation:
   Enabled: true
   VersionAdded: '1.5.0'
 
+Style/RbsInline/MissingStructClassAnnotation:
+  Description: "Checks that `Struct.new` attributes have inline type annotations."
+  Enabled: true
+  VersionAdded: '1.7.0'
+
 Style/RbsInline/MissingTypeAnnotation:
   Description: "Checks that method definitions and attr_* declarations have RBS inline type annotations."
   Enabled: true
@@ -89,10 +95,18 @@ Style/RbsInline/RequireRbsInlineComment:
   Description: "Checks the presence or absence of `# rbs_inline: enabled` magic comment."
   Enabled: true
   VersionAdded: "1.5.0"
-  EnforcedStyle: always
-  SupportedStyles:
-    - always
-    - never
+  AllowMissingComment: false
+  EnforcedStyle: ~
+
+Style/RbsInline/StructClassCommentAlignment:
+  Description: "Checks that `#:` inline type annotations in `Struct.new` blocks are aligned."
+  Enabled: true
+  VersionAdded: '1.7.0'
+
+Style/RbsInline/StructNewWithBlock:
+  Description: "Checks for `Struct.new` calls with a block, which RBS::Inline does not parse."
+  Enabled: true
+  VersionAdded: '1.7.0'
 
 Style/RbsInline/UnmatchedAnnotations:
   Description: "Checks the rbs-inline annotation comment is surely matched."

data/lib/rubocop/cop/rbs_inline_cops.rb

@@ -1,8 +1,19 @@
 # frozen_string_literal: true
 
-require_relative "style/rbs_inline/ast_utils"
-require_relative "style/rbs_inline/source_code_helper"
-require_relative "style/rbs_inline/comment_parser"
+# Mixins first, in dependency order. Cops follow, alphabetically: `rake new_cop` sorts a
+# generated require only against the others in the same directory, so the two blocks have
+# to stay apart for it to land in the right place.
+require_relative "style/rbs_inline/mixin/annotation_keywords"
+require_relative "style/rbs_inline/mixin/ast_utils"
+require_relative "style/rbs_inline/mixin/source_code_helper"
+require_relative "style/rbs_inline/mixin/comment_parser"
+require_relative "style/rbs_inline/mixin/data_struct_helper"
+require_relative "style/rbs_inline/mixin/missing_class_annotation"
+require_relative "style/rbs_inline/mixin/class_comment_alignment"
+require_relative "style/rbs_inline/mixin/data_class_matcher"
+require_relative "style/rbs_inline/mixin/file_filter"
+require_relative "style/rbs_inline/mixin/struct_class_matcher"
+
 require_relative "style/rbs_inline/data_class_comment_alignment"
 require_relative "style/rbs_inline/data_define_with_block"
 require_relative "style/rbs_inline/embedded_rbs_spacing"
@@ -11,12 +22,15 @@ require_relative "style/rbs_inline/invalid_types"
 require_relative "style/rbs_inline/keyword_separator"
 require_relative "style/rbs_inline/method_comment_spacing"
 require_relative "style/rbs_inline/missing_data_class_annotation"
+require_relative "style/rbs_inline/missing_struct_class_annotation"
 require_relative "style/rbs_inline/missing_type_annotation"
 require_relative "style/rbs_inline/parameters_separator"
 require_relative "style/rbs_inline/redundant_annotation_with_skip"
 require_relative "style/rbs_inline/redundant_instance_variable_annotation"
 require_relative "style/rbs_inline/redundant_type_annotation"
 require_relative "style/rbs_inline/require_rbs_inline_comment"
+require_relative "style/rbs_inline/struct_class_comment_alignment"
+require_relative "style/rbs_inline/struct_new_with_block"
 require_relative "style/rbs_inline/unmatched_annotations"
 require_relative "style/rbs_inline/untyped_instance_variable"
 require_relative "style/rbs_inline/variable_comment_spacing"

data/lib/rubocop/cop/style/rbs_inline/data_class_comment_alignment.rb

@@ -26,106 +26,18 @@ module RuboCop
         #   )
         #
         class DataClassCommentAlignment < Base
-          include ASTUtils
-          include RangeHelp
-          include SourceCodeHelper
+          prepend FileFilter
+          include ClassCommentAlignment
+          include DataClassMatcher
           extend AutoCorrector
 
           MSG = "Misaligned inline type annotation for Data attribute."
 
           # @rbs node: RuboCop::AST::SendNode
           def on_send(node) #: void
-            return unless data_define?(node)
-            return if folded_data_class?(node)
+            return unless struct_like_class?(node)
 
-            check_annotation_alignment(node)
-          end
-
-          private
-
-          # @rbs node: RuboCop::AST::SendNode
-          def data_define?(node) #: bool
-            return false unless node.method_name == :define
-
-            case (r = node.receiver)
-            when RuboCop::AST::ConstNode
-              r.short_name == :Data
-            else
-              false
-            end
-          end
-
-          # @rbs arg: RuboCop::AST::Node
-          def data_attribute?(arg) #: bool
-            arg.sym_type? || arg.str_type?
-          end
-
-          # @rbs node: RuboCop::AST::SendNode
-          def data_attributes(node) #: Array[RuboCop::AST::Node]
-            node.arguments.select { data_attribute?(_1) }
-          end
-
-          # @rbs node: RuboCop::AST::SendNode
-          def folded_data_class?(node) #: bool
-            args = node.arguments
-            return false if args.empty?
-
-            lines = args.map { _1.location.line }
-            lines.uniq.length < args.length || lines.include?(node.location.line)
-          end
-
-          # @rbs node: RuboCop::AST::SendNode
-          def check_annotation_alignment(node) #: void
-            annotated = data_attributes(node).filter_map do |arg|
-              comment = inline_type_comment(arg.location.line)
-              [arg, comment] if comment #: [RuboCop::AST::Node, Parser::Source::Comment]
-            end
-            return if annotated.size < 2
-
-            expected_col = annotation_column(node)
-            annotated.each do |arg, comment|
-              actual_col = comment.location.column
-              next if actual_col == expected_col
-
-              add_offense(comment.source_range) do |corrector|
-                correct_alignment(corrector, arg, comment, expected_col)
-              end
-            end
-          end
-
-          # @rbs line: Integer
-          def inline_type_comment(line) #: Parser::Source::Comment?
-            comment = comment_at(line)
-            comment if comment&.text&.match?(/\A#:/)
-          end
-
-          # @rbs node: RuboCop::AST::SendNode
-          def annotation_column(node) #: Integer
-            last_arg = node.arguments.last
-            max_end_col = node.arguments.map do |arg|
-              comma_length = arg.equal?(last_arg) ? 0 : 1
-              arg.location.column + source!(arg).length + comma_length
-            end.max || 0
-
-            max_end_col + 2
-          end
-
-          # @rbs corrector: RuboCop::Cop::Corrector
-          # @rbs arg: RuboCop::AST::Node
-          # @rbs comment: Parser::Source::Comment
-          # @rbs expected_col: Integer
-          def correct_alignment(corrector, arg, comment, expected_col) #: void # rubocop:disable Metrics/AbcSize
-            line = arg.location.line
-            line_source = source_code_at(line)
-            source = line_source[...comment.location.column] || raise
-            content_end_col = source.rstrip.length
-            padding = [expected_col - content_end_col, 1].max || raise
-
-            line_begin = processed_source.buffer.line_range(line).begin_pos
-            replace_start = line_begin + content_end_col
-            replace_end = line_begin + comment.location.column
-
-            corrector.replace(range_between(replace_start, replace_end), " " * padding)
+            check_comment_alignment(node)
           end
         end
       end

data/lib/rubocop/cop/style/rbs_inline/data_define_with_block.rb

@@ -28,29 +28,22 @@ module RuboCop
         #   end
         #
         class DataDefineWithBlock < Base
+          prepend FileFilter
+          include DataClassMatcher
+
           MSG = "Do not use `Data.define` with a block. RBS::Inline does not parse block contents, " \
                 "so methods defined in the block will not be recognized. " \
                 "Use a separate class definition instead."
 
           # @rbs node: RuboCop::AST::SendNode
           def on_send(node) #: void
-            return unless data_define?(node)
+            return unless struct_like_class?(node)
 
             block_node = node.parent
             return unless block_node&.block_type?
 
             add_offense(node)
           end
-
-          private
-
-          # @rbs node: RuboCop::AST::SendNode
-          def data_define?(node) #: bool
-            return false unless node.method_name == :define
-
-            receiver = node.receiver
-            receiver.is_a?(RuboCop::AST::ConstNode) && receiver.short_name == :Data
-          end
         end
       end
     end

data/lib/rubocop/cop/style/rbs_inline/embedded_rbs_spacing.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "source_code_helper"
-require_relative "comment_parser"
+require_relative "mixin/source_code_helper"
+require_relative "mixin/comment_parser"
 
 module RuboCop
   module Cop
@@ -26,6 +26,7 @@ module RuboCop
         #   end
         #
         class EmbeddedRbsSpacing < Base
+          prepend FileFilter
           extend AutoCorrector
           include SourceCodeHelper
           include CommentParser

data/lib/rubocop/cop/style/rbs_inline/invalid_comment.rb

@@ -20,12 +20,12 @@ module RuboCop
         #   # @rbs param: String
         #
         class InvalidComment < Base
+          prepend FileFilter
           extend AutoCorrector
+          include AnnotationKeywords
 
           MSG = "Invalid RBS annotation comment found."
 
-          # refs: https://github.com/soutaro/rbs-inline/blob/main/lib/rbs/inline/annotation_parser/tokenizer.rb
-          RBS_INLINE_KEYWORDS = %w[inherits override use module-self generic skip module class].freeze #: Array[String]
           RBS_INLINE_KEYWORD_PATTERN = RBS_INLINE_KEYWORDS.join("|") #: String
 
           SIGNATURE_PATTERN = '\(.*\)\s*(\??\s*{.*?}\s*)?->\s*.*'