shirobai-rspec 2026.0709.0000

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7a73330fe18d5f58a09e051463f6072c5dd4fefc91600459640adc00d3cc5ce2
+  data.tar.gz: dada93df314d81800637e9d14a93940d9cd67097d5671fe636d261c6515b9b4f
+SHA512:
+  metadata.gz: 1b9225390133b623be2a87797d411001de0a7cb415245ca0e1c5055b5d4b70aa9f1bd658d20030ce07698423a116a8b9014e5fdebf5131c61afb6bba0bbb74d5
+  data.tar.gz: 54689cbadf3ac1cda17865f99c481a2e9223ca3c926fd7141f6821a7bf7c7b7f828c88736837ea8aa7e7deabde4c55134de87bff5a05c582e7e7454836cfbbea

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/rspec/described_class.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module RSpec
+      # Drop-in Rust reimplementation of `RSpec/DescribedClass`
+      # (rubocop-rspec 3.10.2).
+      #
+      # Rust identifies candidate `describe(Const)` blocks on the shared walk.
+      # This wrapper locates the parser block node and runs stock's full
+      # detection + autocorrect VERBATIM: `find_usage` recursion with
+      # scope-change guards, `collapse_namespace`, `described_constant`,
+      # and all config axes (EnforcedStyle, SkipBlocks, OnlyStaticConstants).
+      #
+      # Probed quirks live as differential specs in
+      # described_class_edge_cases_spec.rb.
+      class DescribedClass < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+        include RuboCop::Cop::ConfigurableEnforcedStyle
+        include RuboCop::Cop::RSpec::Namespace
+        include RuboCop::RSpec::Language
+        include Shirobai::Cop::BundleEligible
+
+        DESCRIBED_CLASS = 'described_class'
+        MSG             = 'Use `%<replacement>s` instead of `%<src>s`.'
+
+        def self.cop_name = "RSpec/DescribedClass"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # No bundle_args needed -- the Rust side does not pack config for
+        # this cop (all config axes are handled in the Ruby wrapper).
+        def self.bundle_args(_config)
+          []
+        end
+
+        # @!method common_instance_exec_closure?(node)
+        def_node_matcher :common_instance_exec_closure?, <<~PATTERN
+          (block
+            {
+              (send (const nil? {:Class :Module :Struct}) :new ...)
+              (send (const nil? :Data) :define ...)
+              (send _ {:class_eval :module_eval :instance_eval} ...)
+              (send _ {:class_exec :module_exec :instance_exec} ...)
+            }
+            ...
+          )
+        PATTERN
+
+        # @!method rspec_block?(node)
+        def_node_matcher :rspec_block?,
+                         '(any_block (send #rspec? #ALL.all ...) ...)'
+
+        # @!method scope_changing_syntax?(node)
+        def_node_matcher :scope_changing_syntax?, '{def class module}'
+
+        # @!method described_constant(node)
+        def_node_matcher :described_constant, <<~PATTERN
+          (block (send _ :describe $(const ...) ...) (args) $_)
+        PATTERN
+
+        # @!method contains_described_class?(node)
+        def_node_search :contains_described_class?,
+                        '(send nil? :described_class)'
+
+        def on_new_investigation
+          RuboCop::RSpec::Language.config = config["RSpec"]["Language"]
+          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::RSpec::NodeLocator.locate(processed_source, keys)
+
+          keys.each do |key|
+            node = located[key]
+            process_candidate(node) if node&.block_type?
+          end
+        end
+
+        private
+
+        # Stock's on_block logic, copied verbatim.
+        def process_candidate(node)
+          @described_class, body = described_constant(node)
+          return unless body
+
+          find_usage(body) do |match|
+            msg = message(match.const_name)
+            add_offense(match, message: msg) do |corrector|
+              autocorrect(corrector, match)
+            end
+          end
+        end
+
+        def autocorrect(corrector, match)
+          replacement = if style == :described_class
+                          DESCRIBED_CLASS
+                        else
+                          @described_class.const_name
+                        end
+
+          corrector.replace(match, replacement)
+        end
+
+        def find_usage(node, &block)
+          yield(node) if offensive?(node)
+          return if scope_change?(node) || allowed?(node)
+
+          node.each_child_node do |child|
+            find_usage(child, &block)
+          end
+        end
+
+        def allowed?(node)
+          node.const_type? && only_static_constants?
+        end
+
+        def message(offense)
+          if style == :described_class
+            format(MSG, replacement: DESCRIBED_CLASS, src: offense)
+          else
+            format(MSG, replacement: @described_class.const_name,
+                        src: DESCRIBED_CLASS)
+          end
+        end
+
+        def scope_change?(node)
+          scope_changing_syntax?(node) ||
+            common_instance_exec_closure?(node) ||
+            skippable_block?(node)
+        end
+
+        def skippable_block?(node)
+          return false unless cop_config['SkipBlocks']
+
+          node.any_block_type? && !rspec_block?(node)
+        end
+
+        def only_static_constants?
+          cop_config.fetch('OnlyStaticConstants', true)
+        end
+
+        def offensive?(node)
+          if style == :described_class
+            offensive_described_class?(node)
+          else
+            node.send_type? && node.method?(:described_class)
+          end
+        end
+
+        def offensive_described_class?(node)
+          return false unless node.const_type?
+
+          # E.g. `described_class::CONSTANT`
+          return false if contains_described_class?(node)
+
+          nearest_described_class, = node.each_ancestor(:block)
+            .map { |ancestor| described_constant(ancestor) }.find(&:itself)
+
+          return false if nearest_described_class.equal?(node)
+
+          full_const_name(nearest_described_class) == full_const_name(node)
+        end
+
+        def full_const_name(node)
+          symbolized_namespace = namespace(node).map(&:to_sym)
+          collapse_namespace(symbolized_namespace, const_name(node))
+        end
+
+        # @param namespace [Array<Symbol>]
+        # @param const [Array<Symbol>]
+        # @return [Array<Symbol>]
+        def collapse_namespace(namespace, const)
+          return const if namespace.empty? || const.first.nil?
+
+          start = [0, (namespace.length - const.length)].max
+          max = namespace.length
+          intersection = (start..max).find do |shift|
+            namespace[shift, max - shift] == const[0, max - shift]
+          end
+          [*namespace[0, intersection], *const]
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Array<Symbol>]
+        def const_name(node)
+          namespace = node.namespace
+          name = node.short_name
+          if !namespace
+            [name]
+          elsif namespace.const_type?
+            [*const_name(namespace), name]
+          elsif %i[lvar cbase send].include?(namespace.type)
+            [nil, name]
+          end
+        end
+
+        # --- Resolution ---
+
+        def resolved_candidates
+          if bundle_eligible?
+            ranges = Dispatch.offenses_for(processed_source, config, :rspec_described_class)
+            return ranges unless ranges.nil?
+          end
+          Shirobai.check_rspec_described_class(
+            processed_source.buffer.source, *Shirobai::RSpec.segment(config)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rspec/duplicated_metadata.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module RSpec
+      # Drop-in Rust reimplementation of `RSpec/DuplicatedMetadata`
+      # (rubocop-rspec 3.10.2).
+      #
+      # Rust supplies the shared metadata-anchor block ranges; this wrapper
+      # relocates each parser block node and runs stock's `on_metadata` plus
+      # autocorrect VERBATIM, so structural `eql?` duplicate detection and the
+      # comma/space-aware removal match byte for byte.
+      class DuplicatedMetadata < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        include RuboCop::RSpec::Language
+        include Shirobai::Cop::RSpec::MetadataSupport
+        include RuboCop::Cop::RangeHelp
+
+        MSG = "Avoid duplicated metadata."
+
+        def self.cop_name = "RSpec/DuplicatedMetadata"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # Config-less; the shared anchor list needs no per-cop settings.
+        def self.bundle_args(_config)
+          []
+        end
+
+        def metadata_slot = :rspec_duplicated_metadata
+
+        # --- stock's private methods, copied verbatim (rubocop-rspec 3.10.2) ---
+
+        def on_metadata(symbols, _hash)
+          symbols.each do |symbol|
+            on_metadata_symbol(symbol)
+          end
+        end
+
+        private
+
+        def on_metadata_symbol(node)
+          return unless duplicated?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+
+        def duplicated?(node)
+          node.left_siblings.any? do |sibling|
+            sibling.eql?(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rspec/empty_example_group.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module RSpec
+      # Drop-in Rust reimplementation of `RSpec/EmptyExampleGroup`
+      # (rubocop-rspec 3.10.2).
+      #
+      # Architecture B (relocate-and-dispatch): Rust identifies candidate
+      # example-group blocks on the shared walk; this wrapper locates the
+      # parser-gem block node via `NodeLocator` and runs stock's detection
+      # logic VERBATIM. The mutually recursive `examples?` matcher is deep
+      # parser-AST structural matching that cannot be reproduced bytewise.
+      # The autocorrect is simple (remove whole lines via `range_by_whole_lines`).
+      #
+      # Stock entry method `on_block` is renamed to `process_candidate` so
+      # the Commissioner never dispatches a per-node `on_block`; only
+      # `on_new_investigation` is a real callback.
+      class EmptyExampleGroup < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        include RuboCop::RSpec::Language
+        include RuboCop::Cop::RSpec::InsideExample
+        include RuboCop::Cop::RangeHelp
+        include Shirobai::Cop::BundleEligible
+
+        MSG = "Empty example group detected."
+
+        def self.cop_name = "RSpec/EmptyExampleGroup"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # Config-less (the segment's role lists cover everything).
+        def self.bundle_args(_config)
+          []
+        end
+
+        # --- stock node-pattern matchers, copied verbatim (rubocop-rspec 3.10.2) ---
+
+        # @!method example_group_body(node)
+        def_node_matcher :example_group_body, <<~PATTERN
+          (block (send #rspec? #ExampleGroups.all ...) args $_)
+        PATTERN
+
+        # @!method example_or_group_or_include?(node)
+        def_node_matcher :example_or_group_or_include?, <<~PATTERN
+          {
+            (block
+              (send #rspec? {#Examples.all #ExampleGroups.all #Includes.all} ...)
+            ...)
+            (send nil? {#Examples.all #Includes.all} ...)
+          }
+        PATTERN
+
+        # @!method examples_inside_block?(node)
+        def_node_matcher :examples_inside_block?, <<~PATTERN
+          (block !(send nil? #Hooks.all ...) _ #examples?)
+        PATTERN
+
+        # @!method examples_directly_or_in_block?(node)
+        def_node_matcher :examples_directly_or_in_block?, <<~PATTERN
+          {
+            #example_or_group_or_include?
+            #examples_inside_block?
+          }
+        PATTERN
+
+        # @!method examples?(node)
+        def_node_matcher :examples?, <<~PATTERN
+          {
+            #examples_directly_or_in_block?
+            #examples_in_branches?
+            (begin <#examples_directly_or_in_block? ...>)
+            (begin <#examples_in_branches? ...>)
+          }
+        PATTERN
+
+        def on_new_investigation
+          RuboCop::RSpec::Language.config = config["RSpec"]["Language"]
+          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::RSpec::NodeLocator.locate(processed_source, keys)
+
+          keys.each do |key|
+            node = located[key]
+            process_candidate(node) if node&.block_type?
+          end
+        end
+
+        private
+
+        def resolved_candidates
+          if bundle_eligible?
+            candidates = Dispatch.offenses_for(processed_source, config, :rspec_empty_example_group)
+            return candidates unless candidates.nil?
+          end
+          Shirobai.check_rspec_empty_example_group(
+            processed_source.buffer.source, *Shirobai::RSpec.segment(config)
+          )
+        end
+
+        # Stock `on_block`, renamed so the Commissioner never dispatches it.
+        def process_candidate(node)
+          return if node.each_ancestor(:any_def).any?
+          return if inside_example?(node)
+
+          example_group_body(node) do |body|
+            next unless offensive?(body)
+
+            add_offense(node.send_node) do |corrector|
+              corrector.remove(removed_range(node))
+            end
+          end
+        end
+
+        # --- stock private methods, copied verbatim (rubocop-rspec 3.10.2) ---
+
+        def offensive?(body)
+          return true unless body
+          return false if conditionals_with_examples?(body)
+
+          if body.type?(:if, :case)
+            !examples_in_branches?(body)
+          else
+            !examples?(body)
+          end
+        end
+
+        def conditionals_with_examples?(body)
+          return false unless body.type?(:begin, :case)
+
+          body.each_descendant(:if, :case).any? do |condition_node|
+            examples_in_branches?(condition_node)
+          end
+        end
+
+        def examples_in_branches?(condition_node)
+          return false unless condition_node
+          return false unless condition_node.type?(:if, :case)
+
+          condition_node.branches.any? { |branch| examples?(branch) }
+        end
+
+        def removed_range(node)
+          range_by_whole_lines(
+            node.source_range,
+            include_final_newline: true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rspec/empty_line_after_example.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module RSpec
+      # Drop-in Rust reimplementation of `RSpec/EmptyLineAfterExample`
+      # (rubocop-rspec 3.10.2).
+      #
+      # The Rust rule flags every plain-block example (`it`/`specify`/`its`/...)
+      # that has a following sibling in a `:begin` sequence, minus the allowed
+      # consecutive-one-liner shape (`AllowConsecutiveOneLiners`, default true).
+      # The shared support module replays stock's comment/blank/directive walk
+      # and autocorrect. Probed quirks live in
+      # empty_line_after_example_edge_cases_spec.rb.
+      class EmptyLineAfterExample < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+        include Shirobai::Cop::BundleEligible
+        include Shirobai::Cop::RSpec::EmptyLineSeparationSupport
+
+        MSG = "Add an empty line after `%<example>s`."
+
+        def self.cop_name = "RSpec/EmptyLineAfterExample"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # `AllowConsecutiveOneLiners` (default true) -> segment num.
+        def self.bundle_args(config)
+          [config.for_badge(badge).fetch("AllowConsecutiveOneLiners", true) ? 1 : 0]
+        end
+
+        def on_new_investigation
+          emit_empty_line_offenses(resolved_offenses) do |method|
+            format(MSG, example: method)
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            offenses = Dispatch.offenses_for(processed_source, config, :rspec_empty_line_after_example)
+            return offenses unless offenses.nil?
+          end
+          Shirobai.check_rspec_empty_line_after_example(
+            processed_source.buffer.source, *Shirobai::RSpec.segment(config)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rspec/empty_line_after_example_group.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module RSpec
+      # Drop-in Rust reimplementation of `RSpec/EmptyLineAfterExampleGroup`
+      # (rubocop-rspec 3.10.2).
+      #
+      # Flags every plain-block spec group (`describe`/`context`/... AND
+      # `shared_examples`/`shared_context` with an RSpec receiver) that has a
+      # following sibling in a `:begin` sequence. Config-less.
+      class EmptyLineAfterExampleGroup < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+        include Shirobai::Cop::BundleEligible
+        include Shirobai::Cop::RSpec::EmptyLineSeparationSupport
+
+        MSG = "Add an empty line after `%<example_group>s`."
+
+        def self.cop_name = "RSpec/EmptyLineAfterExampleGroup"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        def self.bundle_args(_config)
+          []
+        end
+
+        def on_new_investigation
+          emit_empty_line_offenses(resolved_offenses) do |method|
+            format(MSG, example_group: method)
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            offenses = Dispatch.offenses_for(processed_source, config, :rspec_empty_line_after_example_group)
+            return offenses unless offenses.nil?
+          end
+          Shirobai.check_rspec_empty_line_after_example_group(
+            processed_source.buffer.source, *Shirobai::RSpec.segment(config)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rspec/empty_line_after_final_let.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module RSpec
+      # Drop-in Rust reimplementation of `RSpec/EmptyLineAfterFinalLet`
+      # (rubocop-rspec 3.10.2).
+      #
+      # For every plain-block example/shared group or `include_*` block, the
+      # Rust rule finds the last `let?` among its direct body children (block
+      # form or the `let(:x, &blk)` send form) and flags it when it is not the
+      # body's last child. Config-less.
+      class EmptyLineAfterFinalLet < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+        include Shirobai::Cop::BundleEligible
+        include Shirobai::Cop::RSpec::EmptyLineSeparationSupport
+
+        MSG = "Add an empty line after the last `%<let>s`."
+
+        def self.cop_name = "RSpec/EmptyLineAfterFinalLet"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        def self.bundle_args(_config)
+          []
+        end
+
+        def on_new_investigation
+          emit_empty_line_offenses(resolved_offenses) do |method|
+            format(MSG, let: method)
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            offenses = Dispatch.offenses_for(processed_source, config, :rspec_empty_line_after_final_let)
+            return offenses unless offenses.nil?
+          end
+          Shirobai.check_rspec_empty_line_after_final_let(
+            processed_source.buffer.source, *Shirobai::RSpec.segment(config)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shirobai/cop/rspec/empty_line_after_hook.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Shirobai
+  module Cop
+    module RSpec
+      # Drop-in Rust reimplementation of `RSpec/EmptyLineAfterHook`
+      # (rubocop-rspec 3.10.2).
+      #
+      # Flags every hook (`before`/`after`/`around`/... in ANY block form —
+      # plain, numbered, `it`-param) that has a following sibling in a `:begin`
+      # sequence, minus the allowed consecutive-one-liner hook chain
+      # (`AllowConsecutiveOneLiners`, default true).
+      class EmptyLineAfterHook < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+        include Shirobai::Cop::BundleEligible
+        include Shirobai::Cop::RSpec::EmptyLineSeparationSupport
+
+        MSG = "Add an empty line after `%<hook>s`."
+
+        def self.cop_name = "RSpec/EmptyLineAfterHook"
+        def self.badge = RuboCop::Cop::Badge.parse(cop_name)
+
+        # `AllowConsecutiveOneLiners` (default true) -> segment num.
+        def self.bundle_args(config)
+          [config.for_badge(badge).fetch("AllowConsecutiveOneLiners", true) ? 1 : 0]
+        end
+
+        def on_new_investigation
+          emit_empty_line_offenses(resolved_offenses) do |method|
+            format(MSG, hook: method)
+          end
+        end
+
+        private
+
+        def resolved_offenses
+          if bundle_eligible?
+            offenses = Dispatch.offenses_for(processed_source, config, :rspec_empty_line_after_hook)
+            return offenses unless offenses.nil?
+          end
+          Shirobai.check_rspec_empty_line_after_hook(
+            processed_source.buffer.source, *Shirobai::RSpec.segment(config)
+          )
+        end
+      end
+    end
+  end
+end