shirobai 2026.0713.1900-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a1a419f64630d93c94d120072f01047272ec8c3a810ff08ca0cd42005684a702
+  data.tar.gz: c96975359454665c58c5ae06825502d540895ddd4bf17971ce10f1870bdc097a
+SHA512:
+  metadata.gz: 88c81dbf1bfc415fdc4d09b8b477c9a6b0151d843644796bf299faffe84b2500cd5382402581dbc48602ab5bf461adf6448b2537018470aabed461b11ea74262
+  data.tar.gz: 1c395e268195a7fdcadf2f6ec8951d1d35244c6a6335fa53764536f0854dc550d0c0f83f190edd72e096f9b87d6a2fffc314d35ec5c5634cdfa15275ad1a2197

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/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module Shirobai
+  module Cop
+    # Class-level replica of `RuboCop::Cop::AllowedMethods#allowed_methods`,
+    # for `bundle_args` class methods that must derive a cop's config without
+    # a cop instance (`cop_config` is `config.for_badge(badge)`).
+    def self.allowed_methods_config(cop_config)
+      deprecated = Array(cop_config.fetch("IgnoredMethods", [])) +
+                   Array(cop_config.fetch("ExcludedMethods", []))
+      allowed = Array(cop_config.fetch("AllowedMethods", []))
+      allowed += deprecated unless deprecated.any?(Regexp)
+      allowed
+    end
+
+    # Shared `bundle_eligible?` for wrapper cops.
+    #
+    # The bundled (shared-walk) path scans `raw_source`; the standalone path
+    # scans the parser-normalized `buffer.source`. The two agree only when they
+    # are byte-identical (CRLF / BOM / `__END__` truncation break that), so a cop
+    # may take the bundle path exactly then; otherwise it falls back so every
+    # offset lines up with parser-gem's index.
+    #
+    # The verdict is memoized, but the memo is guarded on the `processed_source`
+    # identity. RuboCop's real CLI builds a fresh cop per file, yet a reused
+    # instance (vendor specs, and any future RuboCop change to instance reuse)
+    # investigates several sources in turn. A plain `@bundle_eligible` /
+    # `.nil?` / `defined?` memo would freeze the first file's verdict and leak it
+    # onto later files with a different eligibility; keying on the source
+    # identity recomputes it on each new investigation.
+    module BundleEligible
+      private
+
+      def bundle_eligible?
+        src = processed_source
+        return @bundle_eligible if defined?(@bundle_eligible_for) && @bundle_eligible_for.equal?(src)
+
+        @bundle_eligible_for = src
+        @bundle_eligible = src.buffer.source == src.raw_source
+      end
+    end
+  end
+end

data/lib/shirobai/cop/layout/access_modifier_indentation.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Layout
+      # Drop-in Rust reimplementation of `Layout/AccessModifierIndentation`.
+      #
+      # Rust walks the AST once, reproducing stock's `on_class` / `on_sclass` /
+      # `on_module` / `on_block` alias chain: for every class-like / block
+      # node, look at the body and — when it is a parser-`(begin ...)` (>= 2
+      # statements; prism's single-statement `StatementsNode` mirrors stock's
+      # bare body so we skip it) — inspect each direct child `send` that is a
+      # `bare_access_modifier?` (no receiver / no arguments / no block, name
+      # in `{public, protected, private, module_function}`). Same-line
+      # modifiers (`same_line?(node, modifier)`) are skipped, exactly like
+      # stock. For each kept modifier Rust returns `column_delta = expected -
+      # actual` (matching stock's `@column_delta` in
+      # `column_offset_between(modifier.source_range, node.loc.end)`); the
+      # wrapper either fires `correct_style_detected` (delta zero) or registers
+      # the offense and shifts the modifier's line by `column_delta` (mirroring
+      # stock's `AlignmentCorrector.correct(corrector, processed_source, node,
+      # column_delta)` for a one-line node, which simply inserts or removes
+      # leading whitespace).
+      #
+      # Stock's `AlignmentCorrector.correct` reads `processed_source.config`
+      # (for `using_tabs?`); a faithful drop-in does the same — autocorrect is
+      # skipped entirely under `Layout/IndentationStyle: tabs`, just like
+      # stock.
+      #
+      # Offenses come from the per-file bundled run (`Shirobai::Dispatch`); the
+      # behaviour is purely config-driven (`EnforcedStyle` + a per-cop or
+      # global `IndentationWidth`), so this cop is always bundle eligible.
+      class AccessModifierIndentation < RuboCop::Cop::Base
+        include RuboCop::Cop::ConfigurableEnforcedStyle
+        extend RuboCop::Cop::AutoCorrector
+
+        STYLE_TO_U8 = { indent: 0, outdent: 1 }.freeze
+
+        def self.cop_name = "Layout/AccessModifierIndentation"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # Packed args for the bundled run: `[style, indentation_width]`.
+        # `indentation_width` mirrors `Alignment#configured_indentation_width`
+        # — the cop's own `IndentationWidth` if set, else
+        # `Layout/IndentationWidth`'s `Width`, else 2.
+        def self.bundle_args(config)
+          own = config.for_badge(badge)
+          style = STYLE_TO_U8.fetch((own["EnforcedStyle"] || "indent").to_sym, 0)
+          width = own["IndentationWidth"] ||
+                  config.for_cop("Layout/IndentationWidth")["Width"] ||
+                  2
+          [style, width]
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          off = SourceOffsets.for(processed_source.raw_source)
+
+          records_for_source.each do |start, fin, message, column_delta|
+            send_range = Parser::Source::Range.new(buffer, off[start], off[fin])
+            if column_delta.zero?
+              correct_style_detected
+              next
+            end
+            add_offense(send_range, message: message) do |corrector|
+              # Delegate to stock's `AlignmentCorrector.correct`. It reads
+              # `processed_source.config` for tab-style detection and string /
+              # block-comment range avoidance; for a single-line modifier
+              # those checks fall through to a single `each_line` iteration
+              # that just inserts or removes leading whitespace. Passing the
+              # `Parser::Source::Range` directly avoids needing the actual
+              # AST node — stock's implementation accepts either (`node
+              # .respond_to?(:loc) ? node.source_range : node`).
+              RuboCop::Cop::AlignmentCorrector.correct(
+                corrector, processed_source, send_range, column_delta
+              )
+              opposite_or_unrecognized_style(column_delta)
+            end
+          end
+        end
+
+        private
+
+        def records_for_source
+          Dispatch.offenses_for(processed_source, config, :access_modifier_indentation)
+        end
+
+        # Mirror stock's `check_modifier` after `add_offense`: if the actual
+        # offset equals `unexpected_indent_offset` (`indentation_width -
+        # expected`), call `opposite_style_detected`; otherwise
+        # `unrecognized_style_detected`. Recover the actual offset from
+        # `column_delta` since `column_delta = expected - actual`.
+        def opposite_or_unrecognized_style(column_delta)
+          expected = expected_indent_offset
+          actual = expected - column_delta
+          unexpected = configured_indentation_width - expected
+          if actual == unexpected
+            opposite_style_detected
+          else
+            unrecognized_style_detected
+          end
+        end
+
+        def expected_indent_offset
+          style == :outdent ? 0 : configured_indentation_width
+        end
+
+        # Mirror `Alignment#configured_indentation_width` exactly.
+        def configured_indentation_width
+          cop_config["IndentationWidth"] ||
+            config.for_cop("Layout/IndentationWidth")["Width"] ||
+            2
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/layout/argument_alignment.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Layout
+      # Drop-in Rust reimplementation of `Layout/ArgumentAlignment`.
+      #
+      # Rust parses the source, walks every multi-argument method call, picks the
+      # alignment base for the configured `EnforcedStyle`
+      # (`with_first_argument` / `with_fixed_indentation`) and returns each
+      # misaligned argument as an offense range plus its `column_delta`. Ruby
+      # supplies the flattened config and applies the realignment via
+      # `AlignmentCorrector` (the same division of labour as the multiline
+      # indentation cops). Offenses come from the per-file bundled run
+      # (`Shirobai::Dispatch`); the config derivation is purely config-driven,
+      # so this cop is always bundle-eligible.
+      class ArgumentAlignment < RuboCop::Cop::Base
+        include RuboCop::Cop::Alignment
+        extend RuboCop::Cop::AutoCorrector
+
+        ALIGN_PARAMS_MSG = "Align the arguments of a method call if they span more than one line."
+
+        FIXED_INDENT_MSG = "Use one level of indentation for arguments " \
+                           "following the first line of a multi-line method call."
+
+        def self.cop_name = "Layout/ArgumentAlignment"
+        def self.badge = RuboCop::Cop::Badge.parse("Layout/ArgumentAlignment")
+
+        # Packed args for the bundled run: `[style, indentation_width,
+        # incompatible]`. `incompatible` replicates the instance derivation
+        # exactly: it is only true for the explicit `with_first_argument` style
+        # combined with a separator-aligned `Layout/HashAlignment`.
+        def self.bundle_args(config)
+          cop_config = config.for_badge(badge)
+          enforced_style = cop_config["EnforcedStyle"]
+          incompatible = enforced_style == "with_first_argument" &&
+                         RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES.any? do |sep_style|
+                           config.for_enabled_cop("Layout/HashAlignment")[sep_style]&.include?("separator")
+                         end
+          [
+            enforced_style == "with_fixed_indentation" ? 1 : 0,
+            cop_config["IndentationWidth"] || config.for_cop("Layout/IndentationWidth")["Width"] || 2,
+            incompatible
+          ]
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          message = fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
+
+          offenses = Dispatch.offenses_for(processed_source, config, :argument_alignment)
+          off = SourceOffsets.for(processed_source.raw_source)
+          # Stock hands `AlignmentCorrector` the argument NODE; its
+          # `inside_string_ranges` taboo then protects multi-line string
+          # interiors from the shift. Locate the parser node for each
+          # correctable range so the bare range (no taboo) is only the
+          # fallback (fluentd test_config_parser `%()` bodies).
+          located = NodeLocator.locate(
+            processed_source,
+            offenses.filter_map { |s, f, _d, ac| [off[s], off[f]] if ac }
+          )
+          offenses.each do |start, fin, column_delta, autocorrect|
+            range = Parser::Source::Range.new(buffer, off[start], off[fin])
+            # Always pass a block so the offense is correctable, matching stock:
+            # the Alignment mixin's `register_offense` always hands `add_offense`
+            # a block, even for the `within?` case where it passes a nil node and
+            # the corrector ends up empty. A blockless `add_offense` would instead
+            # mark the offense uncorrectable. `autocorrect` is false when the
+            # offense is nested in an already-corrected range; then the block
+            # returns early, leaving an empty (no-op) corrector, so the offense is
+            # reported and stays correctable but is not rewritten this pass.
+            add_offense(range, message: message) do |corrector|
+              next unless autocorrect
+
+              target = located[[off[start], off[fin]]] || range
+              RuboCop::Cop::AlignmentCorrector.correct(corrector, processed_source, target, column_delta)
+            end
+          end
+        end
+
+        private
+
+        # Config-derived and stable for the life of the instance; shares the
+        # derivation with the bundled run (single source of truth).
+        def bundle_args
+          @bundle_args ||= self.class.bundle_args(config)
+        end
+
+        def fixed_indentation?
+          bundle_args[0] == 1
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/layout/array_alignment.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Layout
+      # Drop-in Rust reimplementation of `Layout/ArrayAlignment`.
+      #
+      # Rust parses the source, walks every 2+-element array literal (plus the
+      # bracket-less arrays parser-gem synthesizes: single-assignment RHS lists
+      # and `rescue` exception lists; masgn RHS lists are skipped like stock),
+      # picks the alignment base for the configured `EnforcedStyle`
+      # (`with_first_element` / `with_fixed_indentation`) and returns each
+      # misaligned element as an offense range plus its `column_delta`. Ruby
+      # supplies the flattened config and applies the realignment via
+      # `AlignmentCorrector` (the same division of labour as
+      # `Layout/ArgumentAlignment`). The corrector receives the parser NODE for
+      # the offense range (resolved like `Layout/IndentationConsistency`), so
+      # heredoc bodies and multi-line string interiors inside a shifted element
+      # stay untouched, matching stock's taboo-range protection. Offenses come
+      # from the per-file bundled run (`Shirobai::Dispatch`); the config
+      # derivation is purely config-driven, so this cop is always
+      # bundle-eligible.
+      class ArrayAlignment < RuboCop::Cop::Base
+        include RuboCop::Cop::Alignment
+        extend RuboCop::Cop::AutoCorrector
+
+        ALIGN_ELEMENTS_MSG = "Align the elements of an array literal " \
+                             "if they span more than one line."
+
+        FIXED_INDENT_MSG = "Use one level of indentation for elements " \
+                           "following the first line of a multi-line array."
+
+        def self.cop_name = "Layout/ArrayAlignment"
+        def self.badge = RuboCop::Cop::Badge.parse("Layout/ArrayAlignment")
+
+        # Packed args for the bundled run: `[style, indentation_width]`.
+        def self.bundle_args(config)
+          cop_config = config.for_badge(badge)
+          [
+            cop_config["EnforcedStyle"] == "with_fixed_indentation" ? 1 : 0,
+            cop_config["IndentationWidth"] || config.for_cop("Layout/IndentationWidth")["Width"] || 2
+          ]
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          message = fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_ELEMENTS_MSG
+
+          offenses = Dispatch.offenses_for(processed_source, config, :array_alignment)
+          off = SourceOffsets.for(processed_source.raw_source)
+          offenses.each do |start, fin, column_delta, autocorrect|
+            range = Parser::Source::Range.new(buffer, off[start], off[fin])
+            # Always pass a block so the offense is correctable, matching stock:
+            # the Alignment mixin's `register_offense` always hands `add_offense`
+            # a block, even for the `within?` case (`autocorrect: false`) where it
+            # passes a nil node and the corrector ends up empty. A blockless
+            # `add_offense` would instead mark the offense uncorrectable. When
+            # `autocorrect` is false the block returns early, leaving an empty
+            # (no-op) corrector, so the offense stays correctable but is not
+            # rewritten this pass.
+            add_offense(range, message: message) do |corrector|
+              next unless autocorrect
+
+              # Stock passes the element NODE, whose string/heredoc interiors
+              # `AlignmentCorrector` marks taboo. A bare range would realign
+              # heredoc bodies inside the element.
+              target = node_at(off[start], off[fin]) || range
+              RuboCop::Cop::AlignmentCorrector.correct(
+                corrector, processed_source, target, column_delta
+              )
+            end
+          end
+        end
+
+        private
+
+        # Config-derived and stable for the life of the instance; shares the
+        # derivation with the bundled run (single source of truth).
+        def bundle_args
+          @bundle_args ||= self.class.bundle_args(config)
+        end
+
+        def fixed_indentation?
+          bundle_args[0] == 1
+        end
+
+        # The parser node whose `source_range` matches `[cs, ce)` (CHARACTER
+        # offsets), so `AlignmentCorrector` can protect heredocs / string
+        # interiors that a bare range would not. Falls back to `nil` (bare
+        # range) when not found.
+        def node_at(cs, ce)
+          ast = processed_source.ast
+          return nil unless ast
+
+          found = nil
+          ast.each_node do |n|
+            r = n.source_range
+            next unless r
+            next unless r.begin_pos == cs && r.end_pos == ce
+
+            found = n
+            break
+          end
+          found
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/layout/assignment_indentation.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Layout
+      # Drop-in Rust reimplementation of `Layout/AssignmentIndentation`.
+      #
+      # Rust walks the AST once and, for each assignment / setter call whose
+      # operator is on a different line from the RHS, computes the RHS's
+      # expected display column (`leftmost_multiple_assignment.display_column +
+      # IndentationWidth`). Misaligned RHSes that begin their own line emit a
+      # `[rhs_start, rhs_end, column_delta]` record, which the wrapper turns
+      # into an offense at the RHS range. Autocorrect re-locates the matching
+      # `Parser::AST::Node` by `rhs_start` and hands it to stock's
+      # `AlignmentCorrector#correct` with the same `column_delta` (this keeps
+      # the heredoc / string-literal taboo handling identical to stock).
+      class AssignmentIndentation < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        MSG = "Indent the first line of the right-hand-side of a multi-line assignment."
+
+        def self.cop_name = "Layout/AssignmentIndentation"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # `IndentationWidth` falls back to `Layout/IndentationWidth.Width`,
+        # then to 2 — exactly stock's `configured_indentation_width`.
+        def self.bundle_args(config)
+          own = config.for_badge(badge)["IndentationWidth"]
+          width = own || config.for_cop("Layout/IndentationWidth")["Width"] || 2
+          [width]
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          off = SourceOffsets.for(processed_source.raw_source)
+
+          records_for_source.each do |rhs_start, rhs_end, column_delta|
+            range = Parser::Source::Range.new(buffer, off[rhs_start], off[rhs_end])
+            node = locate_rhs_node(off[rhs_start])
+            add_offense(range, message: MSG) do |corrector|
+              # The corrector target is the Parser::AST::Node so stock's
+              # `inside_string_ranges` / `block_comment_within?` checks work;
+              # if relocation fails (defensive), fall back to the range.
+              ::RuboCop::Cop::AlignmentCorrector.correct(
+                corrector, processed_source, node || range, column_delta
+              )
+            end
+          end
+        end
+
+        private
+
+        def records_for_source
+          Dispatch.offenses_for(processed_source, config, :assignment_indentation)
+        end
+
+        # Locate the `Parser::AST::Node` whose source range begins at
+        # `rhs_begin_pos`. Stock hands the RHS node to `AlignmentCorrector` so
+        # that `inside_string_ranges` (heredoc / string literal taboos) and
+        # `block_comment_within?` can inspect descendants. Offenses are rare
+        # in practice, so the DFS cost is negligible per investigation.
+        def locate_rhs_node(rhs_begin_pos)
+          processed_source.ast&.each_node do |node|
+            return node if node.respond_to?(:loc) &&
+                           node.source_range &&
+                           node.source_range.begin_pos == rhs_begin_pos
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/layout/block_alignment.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Layout
+      # Drop-in Rust reimplementation of `Layout/BlockAlignment`.
+      #
+      # Rust walks the AST once, reproducing stock's `on_block` (and
+      # `on_numblock` / `on_itblock`): it picks the block's alignment target by
+      # walking the lineage (`block_end_align_target`), unwraps op_asgn / masgn
+      # LHS (`find_lhs_node`), and decides whether the closing token (`end` /
+      # `}`) is misaligned under the configured `EnforcedStyleAlignWith`. Each
+      # misaligned block returns its closing-token range, the formatted message
+      # (including the `either`-only " or ..." alternative), and the autocorrect
+      # target column (`compute_start_col`).
+      #
+      # The autocorrect mirrors `BlockAlignment#autocorrect`: the delta between
+      # the target column and the closing token's column is applied as inserted
+      # spaces before the token (positive delta) or removed leading whitespace
+      # (negative delta).
+      #
+      # Offenses come from the per-file bundled run (`Shirobai::Dispatch`); the
+      # style is purely config-driven, so this cop is always bundle eligible.
+      class BlockAlignment < RuboCop::Cop::Base
+        include RuboCop::Cop::ConfigurableEnforcedStyle
+        include RuboCop::Cop::RangeHelp
+        extend RuboCop::Cop::AutoCorrector
+
+        STYLE_TO_U8 = { either: 0, start_of_block: 1, start_of_line: 2 }.freeze
+
+        def self.cop_name = "Layout/BlockAlignment"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # Packed args for the bundled run: `[style]`. `EnforcedStyleAlignWith`
+        # defaults to `either` (0) when the config does not mention this cop.
+        def self.bundle_args(config)
+          align = config.for_badge(badge)["EnforcedStyleAlignWith"]
+          [STYLE_TO_U8.fetch((align || "either").to_sym, 0)]
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+          off = SourceOffsets.for(processed_source.raw_source)
+
+          records_for_source.each do |end_start, end_end, message, align_column|
+            end_range = Parser::Source::Range.new(buffer, off[end_start], off[end_end])
+            add_offense(end_range, message: message) do |corrector|
+              autocorrect(corrector, buffer, end_range, align_column)
+            end
+          end
+        end
+
+        # `EnforcedStyleAlignWith` keys the style.
+        def style_parameter_name
+          "EnforcedStyleAlignWith"
+        end
+
+        private
+
+        def records_for_source
+          Dispatch.offenses_for(processed_source, config, :block_alignment)
+        end
+
+        # `BlockAlignment#autocorrect`: `delta = start_col - loc_end.column`.
+        # Positive inserts `delta` spaces before the closing token; negative
+        # removes `-delta` characters of leading whitespace.
+        def autocorrect(corrector, buffer, end_range, start_col)
+          delta = start_col - end_range.column
+          if delta.positive?
+            corrector.insert_before(end_range, " " * delta)
+          elsif delta.negative?
+            range = Parser::Source::Range.new(buffer, end_range.begin_pos + delta, end_range.begin_pos)
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/layout/closing_parenthesis_indentation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module Layout
+      # Drop-in Rust reimplementation of `Layout/ClosingParenthesisIndentation`.
+      #
+      # Rust parses the source, walks every parenthesized method call, method
+      # definition and grouped expression, and returns each hanging `)` that is
+      # misindented as an offense range plus its `column_delta` and message.
+      # Ruby supplies the flattened config and applies the realignment via
+      # `AlignmentCorrector` over the same `)` range, exactly like stock (whose
+      # `autocorrect` passes `right_paren` itself). Offenses come from the
+      # per-file bundled run (`Shirobai::Dispatch`); the config is a single
+      # number, so this cop is always bundle-eligible.
+      class ClosingParenthesisIndentation < RuboCop::Cop::Base
+        include RuboCop::Cop::Alignment
+        extend RuboCop::Cop::AutoCorrector
+
+        def self.cop_name = "Layout/ClosingParenthesisIndentation"
+        def self.badge = RuboCop::Cop::Badge.parse("Layout/ClosingParenthesisIndentation")
+
+        # Packed args for the bundled run: `[indentation_width]`
+        # (`configured_indentation_width` from the `Alignment` mixin).
+        def self.bundle_args(config)
+          cop_config = config.for_badge(badge)
+          [cop_config["IndentationWidth"] || config.for_cop("Layout/IndentationWidth")["Width"] || 2]
+        end
+
+        def on_new_investigation
+          buffer = processed_source.buffer
+
+          offenses = Dispatch.offenses_for(processed_source, config, :closing_parenthesis_indentation)
+          off = SourceOffsets.for(processed_source.raw_source)
+          offenses.each do |start, fin, column_delta, message|
+            range = Parser::Source::Range.new(buffer, off[start], off[fin])
+            # Stock yields the corrector block for every offense (no per-offense
+            # gating); `AlignmentCorrector` itself decides whether the corrector
+            # stays empty (tabs / block comments), which keeps the lint-mode
+            # `correctable?` status identical to stock.
+            add_offense(range, message: message) do |corrector|
+              RuboCop::Cop::AlignmentCorrector.correct(
+                corrector, processed_source, range, column_delta
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end