shirobai-rails 2026.0709.0000

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59377ca996914ce8807076603ac3a1b9ea4e36f99122b84ab54d021aa19e5ddc
+  data.tar.gz: 63686f3c441b593525971c307bca3b35cf38f14eab0fa6c8988bed3316466268
+SHA512:
+  metadata.gz: 71cb62d85e9f072a0f79bd5fd41148b685a44e09088be5e0d4d88e4885ce0082ce4830ae9807116ffadea432de54f6baab4a1516480059fbf7a2892f5f15e140
+  data.tar.gz: f75adf3a6314b9173d52822852b44ab59b9a0fb62c6fd5d991bbab2b2b0c170393d3e668acc3a3ab2a94891ea4ae6a38442a549f94a5e176feba3a6d1ded5628

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fusagiko / takayamaki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/shirobai/cop/rails/application_controller.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Rails
+      # Drop-in Rust reimplementation of `Rails/ApplicationController`
+      # (rubocop-rails 2.35.5). See `ApplicationRecord` for the shared
+      # `EnforceSuperclass` semantics and offense/autocorrect ranges.
+      #
+      # Unlike Record / Mailer / Job this cop has NO `TargetRailsVersion`
+      # gate — stock does not declare one, so it runs on every Rails version.
+      class ApplicationController < RuboCop::Cop::Base
+        include Shirobai::Cop::BundleEligible
+        extend RuboCop::Cop::AutoCorrector
+
+        MSG = "Controllers should subclass `ApplicationController`."
+        SUPERCLASS = "ApplicationController"
+
+        def self.cop_name = "Rails/ApplicationController"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        def self.bundle_args(_config)
+          []
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          source = bundle_eligible? ? processed_source.raw_source : buffer.source
+          off = SourceOffsets.for(source)
+          resolved_offenses.each do |start_offset, end_offset|
+            range = Parser::Source::Range.new(buffer, off[start_offset], off[end_offset])
+            add_offense(range, message: MSG) do |corrector|
+              corrector.replace(range, self.class::SUPERCLASS)
+            end
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            Dispatch.offenses_for(processed_source, config, :rails_application_controller)
+          else
+            Shirobai.check_rails_application_controller(processed_source.buffer.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rails/application_job.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Rails
+      # Drop-in Rust reimplementation of `Rails/ApplicationJob`
+      # (rubocop-rails 2.35.5). See `ApplicationRecord` for the shared
+      # `EnforceSuperclass` semantics and offense/autocorrect ranges. Gated on
+      # `requires_gem('railties', '>= 5.0')` like stock.
+      #
+      # (Stock defines an explicit `autocorrect(node)` returning
+      # `corrector.replace(node, SUPERCLASS)`; the other three cops reach the
+      # same replacement through the `AutoCorrector` block. Both collapse to
+      # "replace the offense range with the superclass name", which is what
+      # the shared wrapper corrector does here.)
+      class ApplicationJob < RuboCop::Cop::Base
+        include Shirobai::Cop::BundleEligible
+        extend RuboCop::Cop::AutoCorrector
+        extend RuboCop::Cop::TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        MSG = "Jobs should subclass `ApplicationJob`."
+        SUPERCLASS = "ApplicationJob"
+
+        def self.cop_name = "Rails/ApplicationJob"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        def self.bundle_args(_config)
+          []
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          source = bundle_eligible? ? processed_source.raw_source : buffer.source
+          off = SourceOffsets.for(source)
+          resolved_offenses.each do |start_offset, end_offset|
+            range = Parser::Source::Range.new(buffer, off[start_offset], off[end_offset])
+            add_offense(range, message: MSG) do |corrector|
+              corrector.replace(range, self.class::SUPERCLASS)
+            end
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            Dispatch.offenses_for(processed_source, config, :rails_application_job)
+          else
+            Shirobai.check_rails_application_job(processed_source.buffer.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rails/application_mailer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Rails
+      # Drop-in Rust reimplementation of `Rails/ApplicationMailer`
+      # (rubocop-rails 2.35.5). See `ApplicationRecord` for the shared
+      # `EnforceSuperclass` semantics and offense/autocorrect ranges. Gated on
+      # `requires_gem('railties', '>= 5.0')` like stock.
+      class ApplicationMailer < RuboCop::Cop::Base
+        include Shirobai::Cop::BundleEligible
+        extend RuboCop::Cop::AutoCorrector
+        extend RuboCop::Cop::TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        MSG = "Mailers should subclass `ApplicationMailer`."
+        SUPERCLASS = "ApplicationMailer"
+
+        def self.cop_name = "Rails/ApplicationMailer"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        def self.bundle_args(_config)
+          []
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          source = bundle_eligible? ? processed_source.raw_source : buffer.source
+          off = SourceOffsets.for(source)
+          resolved_offenses.each do |start_offset, end_offset|
+            range = Parser::Source::Range.new(buffer, off[start_offset], off[end_offset])
+            add_offense(range, message: MSG) do |corrector|
+              corrector.replace(range, self.class::SUPERCLASS)
+            end
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            Dispatch.offenses_for(processed_source, config, :rails_application_mailer)
+          else
+            Shirobai.check_rails_application_mailer(processed_source.buffer.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rails/application_record.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Rails
+      # Drop-in Rust reimplementation of `Rails/ApplicationRecord`
+      # (rubocop-rails 2.35.5).
+      #
+      # Rust replicates stock's `EnforceSuperclass` mixin: `class X <
+      # ActiveRecord::Base` (unless `X`'s terminal name is `ApplicationRecord`)
+      # and `Class.new(ActiveRecord::Base)` (unless it is the direct value of
+      # an `ApplicationRecord =` constant write, covering the `do..end` / `{}`
+      # block forms). The offense range is the superclass / argument const node
+      # (leading `::` included); the wrapper replaces it with the bare
+      # `ApplicationRecord` name — byte for byte with stock's autocorrect.
+      #
+      # `TargetRailsVersion`: like stock this cop is gated on
+      # `requires_gem('railties', '>= 5.0')`, so it stays silent on Rails <
+      # 5.0 or without railties in the target bundle. The `Exclude:
+      # db/**/*.rb` from the merged default.yml is resolved by RuboCop through
+      # this wrapper's badge, exactly as for the stock cop.
+      class ApplicationRecord < RuboCop::Cop::Base
+        include Shirobai::Cop::BundleEligible
+        extend RuboCop::Cop::AutoCorrector
+        extend RuboCop::Cop::TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        MSG = "Models should subclass `ApplicationRecord`."
+        SUPERCLASS = "ApplicationRecord"
+
+        def self.cop_name = "Rails/ApplicationRecord"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # No behavioral config: the segment is a wake-up flag only, so
+        # `bundle_args` contributes nothing.
+        def self.bundle_args(_config)
+          []
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          source = bundle_eligible? ? processed_source.raw_source : buffer.source
+          off = SourceOffsets.for(source)
+          resolved_offenses.each do |start_offset, end_offset|
+            range = Parser::Source::Range.new(buffer, off[start_offset], off[end_offset])
+            add_offense(range, message: MSG) do |corrector|
+              corrector.replace(range, self.class::SUPERCLASS)
+            end
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            Dispatch.offenses_for(processed_source, config, :rails_application_record)
+          else
+            Shirobai.check_rails_application_record(processed_source.buffer.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rails/candidate_support.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Rails
+      # Shared harness for the Architecture-B Rails cops
+      # (`HttpPositionalArguments`, `DeprecatedActiveModelErrorsMethods`).
+      #
+      # Rust identifies candidate SEND ranges once on the shared walk; this
+      # module relocates each parser send node (`Shirobai::NodeLocator`) and
+      # hands it to the cop's `investigate_send`, which is stock's `on_send`
+      # copied verbatim (renamed so the Commissioner never dispatches a
+      # per-node `on_send`). Every guard, matcher, receiver walk and
+      # autocorrect runs on the real parser AST, so detection and `-A` bytes
+      # match stock exactly; the Rust prefilter only narrows which nodes are
+      # visited.
+      #
+      # The candidate set is a superset — false positives (e.g. a routing-block
+      # `get`, a non-model bare `errors`) are dropped by the stock matchers the
+      # wrapper re-runs.
+      module CandidateSupport
+        include Shirobai::Cop::BundleEligible
+
+        def on_new_investigation
+          ranges = resolved_candidates
+          return if ranges.nil? || ranges.empty?
+
+          source = bundle_eligible? ? processed_source.raw_source : processed_source.buffer.source
+          off = SourceOffsets.for(source)
+          keys = ranges.map { |(start, fin)| [off[start], off[fin]] }
+          located = Shirobai::NodeLocator.locate(processed_source, keys)
+
+          keys.each do |key|
+            node = located[key]
+            investigate_send(node) if node&.send_type?
+          end
+        end
+
+        private
+
+        # Bundle path only when raw_source and the parser buffer agree byte for
+        # byte; a gated-off file (nil from Dispatch) falls back to the
+        # standalone entry scanning `buffer.source`. The rails origin has no
+        # per-file gate, so on a bundle-eligible file the bundle path always
+        # wins.
+        def resolved_candidates
+          if bundle_eligible?
+            ranges = Dispatch.offenses_for(processed_source, config, candidate_slot)
+            return ranges unless ranges.nil?
+          end
+          fallback_candidates
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rails/deprecated_active_model_errors_methods.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Shirobai
+  module Cop
+    module Rails
+      # Drop-in Rust-backed reimplementation of
+      # `Rails/DeprecatedActiveModelErrorsMethods` (rubocop-rails 2.35.5),
+      # Architecture B.
+      #
+      # Rust supplies candidate SEND ranges (the five errors-chain shapes:
+      # `errors[...]`/`errors.messages[...]`/`errors.details[...]` manipulation
+      # and assignment, and `errors.{keys,values,to_h,to_xml}`); this wrapper
+      # relocates each parser send node and runs stock's `on_send` (renamed
+      # `investigate_send`) plus autocorrect VERBATIM. The receiver-model
+      # heuristic (`model_file?`), the Rails <= 6.0 gate on the incompatible
+      # methods, `skip_autocorrect?` (uncorrectable `details << ...`) and the
+      # receiver-walk offense range all run on the parser AST, so offenses and
+      # `-A` bytes match stock exactly.
+      class DeprecatedActiveModelErrorsMethods < RuboCop::Cop::Base
+        include RuboCop::Cop::RangeHelp
+        include Shirobai::Cop::Rails::CandidateSupport
+        extend RuboCop::Cop::AutoCorrector
+
+        MSG = 'Avoid manipulating ActiveModel errors as hash directly.'
+        AUTOCORRECTABLE_METHODS = %i[<< clear keys].freeze
+        INCOMPATIBLE_METHODS = %i[keys values to_h to_xml].freeze
+
+        MANIPULATIVE_METHODS = Set[
+          *%i[
+            << append clear collect! compact! concat
+            delete delete_at delete_if drop drop_while fill filter! keep_if
+            flatten! insert map! pop prepend push reject! replace reverse!
+            rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift
+          ]
+        ].freeze
+
+        def self.cop_name = "Rails/DeprecatedActiveModelErrorsMethods"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        def self.bundle_args(_config)
+          []
+        end
+
+        def_node_matcher :receiver_matcher_outside_model, '{send ivar lvar}'
+        def_node_matcher :receiver_matcher_inside_model, '{nil? send ivar lvar}'
+
+        def_node_matcher :any_manipulation?, <<~PATTERN
+          {
+            #root_manipulation?
+            #root_assignment?
+            #errors_deprecated?
+            #messages_details_manipulation?
+            #messages_details_assignment?
+          }
+        PATTERN
+
+        def_node_matcher :root_manipulation?, <<~PATTERN
+          (send
+            (send
+              (send #receiver_matcher :errors) :[] ...)
+            MANIPULATIVE_METHODS
+            ...
+          )
+        PATTERN
+
+        def_node_matcher :root_assignment?, <<~PATTERN
+          (send
+            (send #receiver_matcher :errors)
+            :[]=
+            ...)
+        PATTERN
+
+        def_node_matcher :errors_deprecated?, <<~PATTERN
+          (send
+            (send #receiver_matcher :errors)
+            {:keys :values :to_h :to_xml})
+        PATTERN
+
+        def_node_matcher :messages_details_manipulation?, <<~PATTERN
+          (send
+            (send
+              (send
+                (send #receiver_matcher :errors)
+                {:messages :details})
+                :[]
+                ...)
+              MANIPULATIVE_METHODS
+            ...)
+        PATTERN
+
+        def_node_matcher :messages_details_assignment?, <<~PATTERN
+          (send
+            (send
+              (send #receiver_matcher :errors)
+              {:messages :details})
+            :[]=
+            ...)
+        PATTERN
+
+        private
+
+        def candidate_slot = :rails_deprecated_active_model_errors_methods
+
+        def fallback_candidates
+          Shirobai.check_rails_deprecated_active_model_errors_methods(processed_source.buffer.source)
+        end
+
+        # --- stock's methods, copied verbatim (rubocop-rails 2.35.5);
+        # `on_send` renamed to `investigate_send` so it is not a node callback.
+
+        def investigate_send(node)
+          any_manipulation?(node) do
+            next if target_rails_version <= 6.0 && INCOMPATIBLE_METHODS.include?(node.method_name)
+
+            add_offense(node) do |corrector|
+              next if skip_autocorrect?(node)
+
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        def skip_autocorrect?(node)
+          return true unless AUTOCORRECTABLE_METHODS.include?(node.method_name)
+          return false unless (receiver = node.receiver.receiver)
+
+          receiver.send_type? && receiver.method?(:details) && node.method?(:<<)
+        end
+
+        def autocorrect(corrector, node)
+          receiver = node.receiver
+
+          range = offense_range(node, receiver)
+          replacement = replacement(node, receiver)
+
+          corrector.replace(range, replacement)
+        end
+
+        def offense_range(node, receiver)
+          receiver = receiver.receiver while receiver.send_type? && !receiver.method?(:errors) && receiver.receiver
+          range_between(receiver.source_range.end_pos, node.source_range.end_pos)
+        end
+
+        def replacement(node, receiver)
+          return '.attribute_names' if node.method?(:keys)
+
+          key = receiver.first_argument.source
+
+          case node.method_name
+          when :<<
+            value = node.first_argument.source
+
+            ".add(#{key}, #{value})"
+          when :clear
+            ".delete(#{key})"
+          end
+        end
+
+        def receiver_matcher(node)
+          model_file? ? receiver_matcher_inside_model(node) : receiver_matcher_outside_model(node)
+        end
+
+        def model_file?
+          processed_source.file_path.include?('/models/')
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rails/dynamic_find_by.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Rails
+      # Drop-in Rust reimplementation of `Rails/DynamicFindBy`
+      # (rubocop-rails 2.35.5).
+      #
+      # Rust replicates the `on_send` / `on_csend` detection (the
+      # `/^find_by_(.+?)(!)?$/` name match, the argument count / no-splat /
+      # no-hash rules, the `AllowedMethods` / `AllowedReceivers` / `Whitelist`
+      # suppressions, and the receiverless-inside-ActiveRecord class check) and
+      # the full autocorrect: replace the selector with `find_by` / `find_by!`
+      # and insert each `col: ` keyword before its argument. The wrapper owns
+      # only the fixed `MSG` (the method name comes from the selector range).
+      class DynamicFindBy < RuboCop::Cop::Base
+        include Shirobai::Cop::BundleEligible
+        extend RuboCop::Cop::AutoCorrector
+
+        MSG = "Use `%<static_name>s` instead of dynamic `%<method>s`."
+
+        def self.cop_name = "Rails/DynamicFindBy"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # Contributes `[nums, lists]` pieces to the rails segment:
+        # `[[], [AllowedMethods, AllowedReceivers, Whitelist]]`.
+        def self.bundle_args(config)
+          cop = config.for_badge(badge)
+          [[], [cop["AllowedMethods"] || [], cop["AllowedReceivers"] || [], cop["Whitelist"] || []]]
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          source = bundle_eligible? ? processed_source.raw_source : buffer.source
+          off = SourceOffsets.for(source)
+          resolved_offenses.each do |start_o, end_o, static_name, sel_s, sel_e, inserts|
+            range = Parser::Source::Range.new(buffer, off[start_o], off[end_o])
+            sel_range = Parser::Source::Range.new(buffer, off[sel_s], off[sel_e])
+            message = format(MSG, static_name: static_name, method: sel_range.source)
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(sel_range, static_name)
+              inserts.each do |arg_start, keyword|
+                pos = off[arg_start]
+                corrector.insert_before(Parser::Source::Range.new(buffer, pos, pos), keyword)
+              end
+            end
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            Dispatch.offenses_for(processed_source, config, :rails_dynamic_find_by)
+          else
+            Shirobai.check_rails_dynamic_find_by(
+              processed_source.buffer.source,
+              cop_config["AllowedMethods"] || [], cop_config["AllowedReceivers"] || [],
+              cop_config["Whitelist"] || []
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rails/http_positional_arguments.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Rails
+      # Drop-in Rust-backed reimplementation of `Rails/HttpPositionalArguments`
+      # (rubocop-rails 2.35.5), Architecture B.
+      #
+      # Rust supplies candidate SEND ranges (bare-receiver HTTP verb calls with
+      # an action plus a data argument); this wrapper relocates each parser
+      # send node and runs stock's `on_send` (renamed `investigate_send`) plus
+      # autocorrect VERBATIM. The routing-block / rack-test guards, the
+      # `http_request?` / `needs_conversion?` matchers (kwsplat / forwarded /
+      # already-keyword hashes) and the full-node source rebuild all run on the
+      # parser AST, so offenses and `-A` bytes match stock exactly.
+      #
+      # `TargetRailsVersion`: like stock, gated on
+      # `requires_gem('railties', '>= 5.0')` — silent on Rails < 5.0 or without
+      # railties in the target bundle. The `Include: **/spec/**, **/test/**`
+      # from the merged default.yml resolves through this wrapper's badge,
+      # exactly as for the stock cop.
+      class HttpPositionalArguments < RuboCop::Cop::Base
+        include RuboCop::Cop::RangeHelp
+        include Shirobai::Cop::Rails::CandidateSupport
+        extend RuboCop::Cop::AutoCorrector
+        extend RuboCop::Cop::TargetRailsVersion
+
+        MSG = 'Use keyword arguments instead of positional arguments for http call: `%<verb>s`.'
+        KEYWORD_ARGS = %i[method params session body flash xhr as headers env to].freeze
+        ROUTING_METHODS = %i[draw routes].freeze
+        RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
+
+        minimum_target_rails_version 5.0
+
+        def self.cop_name = "Rails/HttpPositionalArguments"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # No behavioral config: the candidate list is a wake-up flag only.
+        def self.bundle_args(_config)
+          []
+        end
+
+        def_node_matcher :http_request?, <<~PATTERN
+          (send nil? {#{RESTRICT_ON_SEND.map(&:inspect).join(' ')}} !nil? $_ ...)
+        PATTERN
+
+        def_node_matcher :kwsplat_hash?, <<~PATTERN
+          (hash (kwsplat _))
+        PATTERN
+
+        def_node_matcher :forwarded_kwrestarg?, <<~PATTERN
+          (hash (forwarded-kwrestarg))
+        PATTERN
+
+        def_node_matcher :include_rack_test_methods?, <<~PATTERN
+          (send nil? :include
+            (const
+              (const
+                (const {nil? cbase} :Rack) :Test) :Methods))
+        PATTERN
+
+        private
+
+        def candidate_slot = :rails_http_positional_arguments
+
+        def fallback_candidates
+          Shirobai.check_rails_http_positional_arguments(processed_source.buffer.source)
+        end
+
+        # --- stock's methods, copied verbatim (rubocop-rails 2.35.5);
+        # `on_send` renamed to `investigate_send` so it is not a node callback.
+
+        def investigate_send(node)
+          return if in_routing_block?(node) || use_rack_test_methods?
+
+          http_request?(node) do |data|
+            return unless needs_conversion?(data)
+
+            message = format(MSG, verb: node.method_name)
+
+            add_offense(highlight_range(node), message: message) do |corrector|
+              corrector.replace(node, correction(node))
+            end
+          end
+        end
+
+        def in_routing_block?(node)
+          !!node.each_ancestor(:block).detect { |block| ROUTING_METHODS.include?(block.method_name) }
+        end
+
+        def use_rack_test_methods?
+          processed_source.ast.each_descendant(:send).any? do |node|
+            include_rack_test_methods?(node)
+          end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def needs_conversion?(data)
+          return false if data.forwarded_args_type? || forwarded_kwrestarg?(data)
+          return true unless data.hash_type?
+          return false if kwsplat_hash?(data)
+
+          data.each_pair.none? do |pair|
+            special_keyword_arg?(pair.key) || (format_arg?(pair.key) && data.pairs.one?)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def special_keyword_arg?(node)
+          node.sym_type? && KEYWORD_ARGS.include?(node.value)
+        end
+
+        def format_arg?(node)
+          node.sym_type? && node.value == :format
+        end
+
+        def highlight_range(node)
+          _http_path, *data = *node.arguments
+
+          range_between(data.first.source_range.begin_pos, data.last.source_range.end_pos)
+        end
+
+        def convert_hash_data(data, type)
+          return '' if data.hash_type? && data.empty?
+
+          hash_data = if data.hash_type?
+                        format('{ %<data>s }', data: data.pairs.map(&:source).join(', '))
+                      else
+                        # user supplies an object,
+                        # no need to surround with braces
+                        data.source
+                      end
+
+          format(', %<type>s: %<hash_data>s', type: type, hash_data: hash_data)
+        end
+
+        def correction(node)
+          http_path, *data = *node.arguments
+
+          controller_action = http_path.source
+          params = convert_hash_data(data.first, 'params')
+          session = convert_hash_data(data.last, 'session') if data.size > 1
+
+          format(correction_template(node), name: node.method_name,
+                                            action: controller_action,
+                                            params: params,
+                                            session: session)
+        end
+
+        def correction_template(node)
+          if parentheses?(node)
+            '%<name>s(%<action>s%<params>s%<session>s)'
+          else
+            '%<name>s %<action>s%<params>s%<session>s'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rails/pluck.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Rails
+      # Drop-in Rust reimplementation of `Rails/Pluck`
+      # (rubocop-rails 2.35.5).
+      #
+      # Rust detects `map { |x| x[:key] }` / `collect { |x| x[:key] }`
+      # patterns replaceable with `pluck(:key)`, including numblock (`_1`)
+      # and itblock (`it`) forms. The ancestor block-with-receiver guard
+      # (N+1 query risk) and the regexp key / block-arg-in-key exclusions
+      # are all handled Rust-side.
+      #
+      # Autocorrect: replace from the selector (map/collect) through the
+      # block end with `pluck(<key source>)`.
+      class Pluck < RuboCop::Cop::Base
+        include Shirobai::Cop::BundleEligible
+        extend RuboCop::Cop::AutoCorrector
+        extend RuboCop::Cop::TargetRailsVersion
+
+        MSG = "Prefer `%<replacement>s` over `%<current>s`."
+
+        minimum_target_rails_version 5.0
+
+        def self.cop_name = "Rails/Pluck"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # No behavioral config to pack into the segment.
+        def self.bundle_args(_config)
+          [[], []]
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          source = bundle_eligible? ? processed_source.raw_source : buffer.source
+          off = SourceOffsets.for(source)
+          resolved_offenses.each do |sel_start, block_end, key_src_start, key_src_end|
+            offense_range = Parser::Source::Range.new(buffer, off[sel_start], off[block_end])
+            key_source = source.byteslice(key_src_start, key_src_end - key_src_start)
+            replacement = "pluck(#{key_source})"
+            message = format(MSG, replacement: replacement, current: offense_range.source)
+            add_offense(offense_range, message: message) do |corrector|
+              corrector.replace(offense_range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            Dispatch.offenses_for(processed_source, config, :rails_pluck)
+          else
+            Shirobai.check_rails_pluck(processed_source.buffer.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rails/unknown_env.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Rails
+      # Drop-in Rust reimplementation of `Rails/UnknownEnv`
+      # (rubocop-rails 2.35.5).
+      #
+      # Rust detects the three `Rails.env` shapes (predicate / comparison /
+      # `case`) and emits `[start, end, name]` per unknown environment. The
+      # message — including the `DidYouMean` spell suggestion, which must stay
+      # Ruby-side — is built here from this cop's own `Environments` config, so
+      # the suggestion text is byte-for-byte stock. No autocorrect (stock has
+      # none).
+      #
+      # The `supports_local` view (`local` is a known environment for the
+      # predicate form only, and only on Rails >= 7.1) is packed into the
+      # segment so the Rust filter matches; the comparison and `case` forms
+      # never allow `local`, mirroring stock.
+      class UnknownEnv < RuboCop::Cop::Base
+        include Shirobai::Cop::BundleEligible
+
+        MSG = "Unknown environment `%<name>s`."
+        MSG_SIMILAR = "Unknown environment `%<name>s`. Did you mean `%<similar>s`?"
+
+        def self.cop_name = "Rails/UnknownEnv"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # Contributes `[nums, lists]` pieces to the rails segment:
+        # `[[supports_local], [environments]]`.
+        def self.bundle_args(config)
+          cop = config.for_badge(badge)
+          environments = cop["Environments"] || []
+          supports_local = config.target_rails_version >= 7.1
+          [[supports_local ? 1 : 0], [environments]]
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          source = bundle_eligible? ? processed_source.raw_source : buffer.source
+          off = SourceOffsets.for(source)
+          resolved_offenses.each do |start_offset, end_offset, name|
+            range = Parser::Source::Range.new(buffer, off[start_offset], off[end_offset])
+            add_offense(range, message: message(name))
+          end
+        end
+
+        private
+
+        def message(name)
+          name = name.to_s.chomp("?")
+
+          # DidYouMean::SpellChecker is not available in all versions of Ruby;
+          # feature-check first, exactly like stock.
+          similar_names = if defined?(DidYouMean::SpellChecker)
+                            DidYouMean::SpellChecker.new(dictionary: environments).correct(name)
+                          else
+                            []
+                          end
+
+          if similar_names.empty?
+            format(MSG, name: name)
+          else
+            format(MSG_SIMILAR, name: name, similar: similar_names.join(", "))
+          end
+        end
+
+        def environments
+          cop_config["Environments"] || []
+        end
+
+        def supports_local?
+          target_rails_version >= 7.1
+        end
+
+        def resolved_offenses
+          if bundle_eligible?
+            Dispatch.offenses_for(processed_source, config, :rails_unknown_env)
+          else
+            Shirobai.check_rails_unknown_env(
+              processed_source.buffer.source, environments, supports_local?
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/rails/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Rails
+    # Locked to the shirobai core gem version (release train: both gems
+    # ship together and the gemspec pins `shirobai` to this exact version).
+    VERSION = "2026.0709.0000"
+  end
+end

data/lib/shirobai-rails.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# Load order matters, and this file owns it so users don't have to:
+#
+# 1. `shirobai` first. The core gem loads the native extension, replaces
+#    the core cops, and defines `Shirobai::Dispatch` — the registration
+#    point for this gem's packed-config segment.
+# 2. `rubocop-rails` second. Stock Rails cop classes must be enlisted in
+#    RuboCop's registry BEFORE the wrappers below:
+#    `Registry#clear_enrollment_queue` resolves same-badge collisions by
+#    last-write-wins, so whoever is defined later owns the badge.
+#    Requiring it here (the gemspec pins the exact version) makes the
+#    replacement order independent of `.rubocop.yml` require order.
+# 3. Wrapper cop classes last. Defining each class auto-enlists it
+#    (`RuboCop::Cop::Base.inherited`) and replaces the stock cop under
+#    the same badge.
+#
+# Requiring rubocop-rails here does NOT merge its config/default.yml into
+# RuboCop's default configuration — that is the plugin system's job. Users
+# still declare `plugins: [rubocop-rails]` in `.rubocop.yml` (or legacy
+# `require:`, which RuboCop auto-promotes to a plugin with a deprecation
+# warning) and add `require: [shirobai-rails]`.
+require "shirobai"
+require "rubocop-rails"
+
+require_relative "shirobai/rails/version"
+require_relative "shirobai/cop/rails/application_record"
+require_relative "shirobai/cop/rails/application_controller"
+require_relative "shirobai/cop/rails/application_mailer"
+require_relative "shirobai/cop/rails/application_job"
+require_relative "shirobai/cop/rails/unknown_env"
+require_relative "shirobai/cop/rails/dynamic_find_by"
+require_relative "shirobai/cop/rails/pluck"
+require_relative "shirobai/cop/rails/candidate_support"
+require_relative "shirobai/cop/rails/http_positional_arguments"
+require_relative "shirobai/cop/rails/deprecated_active_model_errors_methods"
+
+module Shirobai
+  # Glue for the shirobai-rails plugin gem: the packed-config segment (just a
+  # wake-up flag — the Application* cluster carries no behavioral config).
+  #
+  # Unlike shirobai-rspec there is NO per-file gate: rubocop-rails cops run on
+  # every Ruby file (no department Include like RSpec's `**/*_spec.rb`), so
+  # once this gem is loaded the rails origin is always awake. The core packs
+  # this origin's segment into every config from now on.
+  module Rails
+    # Wrapper cop classes, appended as cops land. Kept for parity with the
+    # sibling plugins and for plumbing specs.
+    COP_CLASSES = [
+      Shirobai::Cop::Rails::ApplicationRecord,
+      Shirobai::Cop::Rails::ApplicationController,
+      Shirobai::Cop::Rails::ApplicationMailer,
+      Shirobai::Cop::Rails::ApplicationJob,
+      Shirobai::Cop::Rails::UnknownEnv,
+      Shirobai::Cop::Rails::DynamicFindBy,
+      Shirobai::Cop::Rails::Pluck,
+      Shirobai::Cop::Rails::HttpPositionalArguments,
+      Shirobai::Cop::Rails::DeprecatedActiveModelErrorsMethods
+    ].freeze
+
+    class << self
+      # The rails origin's `[nums, lists]` segment for `config`. The wake-up
+      # flag is always `1` once the gem is loaded; the rest is each config-
+      # bearing cop's own `bundle_args` (the single source of its config).
+      #
+      # Segment layout (crates/shirobai-core/src/rules/rails_config.rs):
+      #   nums  = [enabled, unknown_env_supports_local]
+      #   lists = [unknown_env_environments,
+      #            dynamic_find_by_allowed_methods,
+      #            dynamic_find_by_allowed_receivers,
+      #            dynamic_find_by_whitelist]
+      #
+      # Per-cop gating that DOES vary (the `Rails/ApplicationRecord`
+      # `Exclude: db/**/*.rb`, the `TargetRailsVersion` gates, and each cop's
+      # `Enabled`) is NOT in this segment: RuboCop resolves it through each
+      # wrapper's own cop config exactly as for the stock cop, so a file a
+      # wrapper does not run on simply drops that cop's Rust-computed slot
+      # while the other cops' slots (from the same shared walk) are consumed.
+      def segment(config)
+        ue = Shirobai::Cop::Rails::UnknownEnv.bundle_args(config)
+        dfb = Shirobai::Cop::Rails::DynamicFindBy.bundle_args(config)
+        nums = [1, *ue[0]]
+        lists = [*ue[1], *dfb[1]]
+        [nums, lists]
+      end
+    end
+  end
+end
+
+# Wake up the rails origin in the shared bundle: from now on every packed
+# config carries this origin's segment with `enabled=1` (segment layout:
+# crates/shirobai-core/src/rules/bundle.rs BundleConfig). No gate — the
+# Application* cops run on every Ruby file. Without this gem the core packs
+# the dormant segment and the Rust side skips the Rails rules entirely.
+Shirobai::Dispatch.register_plugin_packer(:rails) { |config| Shirobai::Rails.segment(config) }

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: shirobai-rails
+version: !ruby/object:Gem::Version
+  version: 2026.0709.0000
+platform: ruby
+authors:
+- fusagiko / takayamaki
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shirobai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2026.0709.0000
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2026.0709.0000
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.35.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.35.5
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- lib/shirobai-rails.rb
+- lib/shirobai/cop/rails/application_controller.rb
+- lib/shirobai/cop/rails/application_job.rb
+- lib/shirobai/cop/rails/application_mailer.rb
+- lib/shirobai/cop/rails/application_record.rb
+- lib/shirobai/cop/rails/candidate_support.rb
+- lib/shirobai/cop/rails/deprecated_active_model_errors_methods.rb
+- lib/shirobai/cop/rails/dynamic_find_by.rb
+- lib/shirobai/cop/rails/http_positional_arguments.rb
+- lib/shirobai/cop/rails/pluck.rb
+- lib/shirobai/cop/rails/unknown_env.rb
+- lib/shirobai/rails/version.rb
+homepage: https://github.com/takayamaki/shirobai
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Drop-in Rust replacement for rubocop-rails cops
+test_files: []