rspock 2.1.0 → 2.3.0

data/lib/rspock/ast/transformation.rb

@@ -1,37 +1,31 @@
 # frozen_string_literal: true
 require 'ast_transform/abstract_transformation'
-require 'rspock/ast/start_block'
-require 'rspock/ast/given_block'
-require 'rspock/ast/when_block'
-require 'rspock/ast/then_block'
-require 'rspock/ast/expect_block'
-require 'rspock/ast/cleanup_block'
-require 'rspock/ast/where_block'
-require 'rspock/ast/end_block'
+require 'rspock/ast/parser/given_block'
+require 'rspock/ast/parser/when_block'
+require 'rspock/ast/parser/then_block'
+require 'rspock/ast/parser/expect_block'
+require 'rspock/ast/parser/cleanup_block'
+require 'rspock/ast/parser/where_block'
 require 'rspock/ast/test_method_transformation'
 
 module RSpock
   module AST
     class Transformation < ASTTransform::AbstractTransformation
-      DefaultSourceMap = {
-        Given: RSpock::AST::GivenBlock,
-        When: RSpock::AST::WhenBlock,
-        Then: RSpock::AST::ThenBlock,
-        Expect: RSpock::AST::ExpectBlock,
-        Cleanup: RSpock::AST::CleanupBlock,
-        Where: RSpock::AST::WhereBlock,
+      DEFAULT_BLOCK_REGISTRY = {
+        Given: Parser::GivenBlock,
+        When: Parser::WhenBlock,
+        Then: Parser::ThenBlock,
+        Expect: Parser::ExpectBlock,
+        Cleanup: Parser::CleanupBlock,
+        Where: Parser::WhereBlock,
       }.freeze
 
       def initialize(
-        start_block_class: StartBlock,
-        end_block_class: EndBlock,
-        source_map: DefaultSourceMap,
+        block_registry: DEFAULT_BLOCK_REGISTRY,
         strict: true
       )
         super()
-        @start_block_class = start_block_class
-        @source_map = source_map
-        @end_block_class = end_block_class
+        @block_registry = block_registry
         @strict = strict
       end
 
@@ -93,9 +87,7 @@ module RSpock
         end
 
         TestMethodTransformation.new(
-          @source_map,
-          @start_block_class,
-          @end_block_class,
+          @block_registry,
           strict: @strict
         ).run(node)
       end

data/lib/rspock/backtrace_filter.rb

@@ -33,7 +33,7 @@ module RSpock
       return location unless source_map
 
       line_number = source_map.line(lineno) || '?'
-      location.gsub(/#{ASTTransform.output_path}\/([\S]+):(\d+)/, "\\1:#{line_number}")
+      location.sub("#{file_path}:#{lineno}", "#{source_map.source_file_path}:#{line_number}")
     end
 
     private

data/lib/rspock/helpers/block_capture.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RSpock
+  module Helpers
+    module BlockCapture
+      # Installs a block-capture wrapper on +obj+ for +method_name+.
+      # Must be called AFTER Mocha's expects/stubs so the wrapper sits
+      # in front of whatever Mocha installed.
+      #
+      # Returns a lambda that, when called, returns the captured block
+      # (or nil if no block was passed).
+      def self.capture(obj, method_name)
+        state = { captured: nil }
+
+        if obj.respond_to?(method_name, true)
+          # Real objects or objects where Mocha defined the method on
+          # the singleton class. Prepend a module so we intercept the
+          # call before Mocha's stub (prepend wins over define_singleton_method).
+          s = state
+          capture_mod = Module.new do
+            define_method(method_name) do |*args, **kwargs, &blk|
+              s[:captured] = blk
+              super(*args, **kwargs, &blk)
+            end
+          end
+          obj.singleton_class.prepend(capture_mod)
+        else
+          # Mock objects where the method goes through method_missing.
+          original_mm = obj.method(:method_missing)
+          s = state
+          obj.define_singleton_method(:method_missing) do |name, *args, **kwargs, &blk|
+            s[:captured] = blk if name == method_name
+            original_mm.call(name, *args, **kwargs, &blk)
+          end
+        end
+
+        -> { state[:captured] }
+      end
+    end
+  end
+end

data/lib/rspock/version.rb

@@ -1,3 +1,3 @@
 module RSpock
-  VERSION = "2.1.0"
+  VERSION = "2.3.0"
 end

data/rspock.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "minitest", "~> 5.14"
   spec.add_development_dependency "minitest-reporters", "~> 1.4"
   spec.add_development_dependency "pry", ">= 0.14"
+  spec.add_development_dependency "pry-byebug", "~> 3.9"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "simplecov", "~> 0.22"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspock
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Jean-Philippe Duchesne
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-21 00:00:00.000000000 Z
+date: 2026-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -171,6 +185,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/CLAUDE.md"
+- ".cursor/rules/base.mdc"
+- ".cursor/rules/best-practices.mdc"
 - ".github/workflows/ci.yml"
 - ".github/workflows/release.yml"
 - ".gitignore"
@@ -190,25 +207,28 @@ files:
 - lib/generators/templates/rspock_initializer.rb
 - lib/minitest/rspock_plugin.rb
 - lib/rspock.rb
-- lib/rspock/ast/block.rb
-- lib/rspock/ast/cleanup_block.rb
 - lib/rspock/ast/comparison_to_assertion_transformation.rb
-- lib/rspock/ast/end_block.rb
-- lib/rspock/ast/expect_block.rb
-- lib/rspock/ast/given_block.rb
 - lib/rspock/ast/header_nodes_transformation.rb
-- lib/rspock/ast/interaction_transformation.rb
+- lib/rspock/ast/interaction_to_block_identity_assertion_transformation.rb
+- lib/rspock/ast/interaction_to_mocha_mock_transformation.rb
 - lib/rspock/ast/method_call_to_lvar_transformation.rb
-- lib/rspock/ast/start_block.rb
+- lib/rspock/ast/node.rb
+- lib/rspock/ast/parser/block.rb
+- lib/rspock/ast/parser/cleanup_block.rb
+- lib/rspock/ast/parser/expect_block.rb
+- lib/rspock/ast/parser/given_block.rb
+- lib/rspock/ast/parser/interaction_parser.rb
+- lib/rspock/ast/parser/test_method_parser.rb
+- lib/rspock/ast/parser/then_block.rb
+- lib/rspock/ast/parser/when_block.rb
+- lib/rspock/ast/parser/where_block.rb
 - lib/rspock/ast/test_method_def_transformation.rb
 - lib/rspock/ast/test_method_dstr_transformation.rb
 - lib/rspock/ast/test_method_transformation.rb
-- lib/rspock/ast/then_block.rb
 - lib/rspock/ast/transformation.rb
-- lib/rspock/ast/when_block.rb
-- lib/rspock/ast/where_block.rb
 - lib/rspock/backtrace_filter.rb
 - lib/rspock/declarative.rb
+- lib/rspock/helpers/block_capture.rb
 - lib/rspock/minitest/backtrace_filter.rb
 - lib/rspock/railtie.rb
 - lib/rspock/tasks/rspock.rake

data/lib/rspock/ast/block.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-module RSpock
-  module AST
-    class BlockError < StandardError; end
-
-    class Block
-      # Constructs a new Block.
-      #
-      # @param type [Symbol] The Block type.
-      # @param node [Parser::AST::Node] The node associated to this Block.
-      def initialize(type, node)
-        @type = type
-        @node = node
-        @children = []
-        @node_container = true
-      end
-
-      attr_reader :type, :node
-
-      # Adds the given +child_node+ to this Block.
-      #
-      # @param child_node [Parser::AST::Node] The node to be added.
-      #
-      # @raise [BlockError] if this Block cannot contain other nodes.
-      def <<(child_node)
-        raise BlockError, succession_error_msg unless node_container?
-
-        @children << child_node
-      end
-
-      # Adds the given +child_node+ to the beginning of this Block.
-      #
-      # @param child_node [Parser::AST::Node] The node to be added.
-      #
-      # @raise [BlockError] if this Block cannot contain other nodes.
-      def unshift(child_node)
-        raise BlockError, succession_error_msg unless node_container?
-
-        @children.unshift(child_node)
-      end
-
-      # Checks whether this Block can contain other nodes.
-      #
-      # @return [Boolean] True if this Block can contain other nodes, false otherwise.
-      def node_container?
-        @node_container
-      end
-
-      # Sets whether this Block can contain other nodes.
-      #
-      # @param value [Boolean] True if this Block can contain other nodes, false otherwise.
-      def node_container=(value)
-        @node_container = value
-      end
-
-      # Retrieves the Parser::Source::Range for this Block.
-      #
-      # @return [Parser::Source::Range] The range.
-      def range
-        node&.loc&.expression || "?"
-      end
-
-      # Retrieves the valid successors for this Block.
-      # Note: Defaults to [:End].
-      #
-      # @return [Array<Symbol>] This Block's successors.
-      def successors
-        @successors ||= [:End].freeze
-      end
-
-      # Retrieves the duped array of children AST nodes for this Block.
-      #
-      # @return [Array<Parser::AST::Node>] The children nodes.
-      def children
-        @children.dup
-      end
-
-      # Checks whether or not the given +block+ is a valid successor for this Block.
-      #
-      # @param block [Block] The candidate successor.
-      #
-      # @return [Boolean] True if the given block is a valid successor, false otherwise.
-      def valid_successor?(block)
-        successors.include?(block.type)
-      end
-
-      # Retrieves the error message for succession errors.
-      #
-      # @return [String] The error message.
-      def succession_error_msg
-        "Block #{type} @ #{range} must be followed by one of these Blocks: #{successors}"
-      end
-    end
-  end
-end

data/lib/rspock/ast/cleanup_block.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-require 'rspock/ast/block'
-
-module RSpock
-  module AST
-    class CleanupBlock < Block
-      def initialize(node)
-        super(:Cleanup, node)
-      end
-
-      def successors
-        @successors ||= [:Where, :End].freeze
-      end
-    end
-  end
-end

data/lib/rspock/ast/end_block.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-require 'rspock/ast/block'
-
-module RSpock
-  module AST
-    class EndBlock < Block
-      def initialize
-        super(:End, nil)
-        @node_container = false
-      end
-
-      def successors
-        @successors ||= [].freeze
-      end
-    end
-  end
-end

data/lib/rspock/ast/expect_block.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-require 'rspock/ast/block'
-require 'rspock/ast/comparison_to_assertion_transformation'
-
-module RSpock
-  module AST
-    class ExpectBlock < Block
-      def initialize(node)
-        super(:Expect, node)
-      end
-
-      def successors
-        @successors ||= [:Cleanup, :Where, :End].freeze
-      end
-
-      def children
-        super.map { |child| ComparisonToAssertionTransformation.new(:_test_index_, :_line_number_).run(child) }
-      end
-    end
-  end
-end

data/lib/rspock/ast/given_block.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-require 'rspock/ast/block'
-
-module RSpock
-  module AST
-    class GivenBlock < Block
-      def initialize(node)
-        super(:Given, node)
-      end
-
-      def successors
-        @successors ||= [:When, :Expect].freeze
-      end
-    end
-  end
-end

data/lib/rspock/ast/interaction_transformation.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-require 'ast_transform/abstract_transformation'
-
-module RSpock
-  module AST
-    class InteractionTransformation < ASTTransform::AbstractTransformation
-      class InteractionError < RuntimeError; end
-
-      def run(node)
-        return node unless interaction_node?(node)
-
-        parse_node(node)
-        transform_node
-      end
-
-      def interaction_node?(node)
-        return false if node.nil?
-
-        node.type == :send && node.children[1] == :*
-      end
-
-      private
-
-      ALLOWED_NODES = [:send, :lvar, :int]
-      private_constant(:ALLOWED_NODES)
-
-      def transform_node
-        result = chain_call(@receiver_node, :expects, s(:sym, @message))
-        result = chain_call(result, :with, *@arg_nodes) unless @arg_nodes.empty?
-
-        if any_matcher_node?(@times_node)
-          result = chain_call(result, :at_least, s(:int, 0))
-        elsif ALLOWED_NODES.include?(@times_node.type)
-          result = chain_call(result, :times, @times_node)
-        elsif @times_node.type == :begin && @times_node.children[0]&.type == :irange
-          min_node, max_node = @times_node.children[0].children
-
-          result = transform_irange_node(result, min_node, max_node)
-        elsif @times_node.type == :begin && @times_node.children[0]&.type == :erange
-          min_node, max_node = @times_node.children[0].children
-          max_node = chain_call(max_node, :-, s(:int, 1))
-
-          result = transform_erange_node(result, min_node, max_node)
-        else
-          raise ArgumentError, "Unrecognized times constraint in interaction: #{@times_node&.loc&.expression || "?"}"
-        end
-
-        result
-      end
-
-      def chain_call(receiver_node, method_name, *arg_nodes)
-        s(:send, receiver_node, method_name, *arg_nodes)
-      end
-
-      def transform_irange_node(receiver_node, min_node, max_node)
-        result = receiver_node
-
-        if any_matcher_node?(min_node) && any_matcher_node?(max_node)
-          result = chain_call(result, :at_least, s(:int, 0))
-        elsif !any_matcher_node?(min_node) && any_matcher_node?(max_node)
-          result = chain_call(result, :at_least, min_node)
-        elsif any_matcher_node?(min_node) && !any_matcher_node?(max_node)
-          result = chain_call(result, :at_least, s(:int, 0))
-          result = chain_call(result, :at_most, max_node)
-        elsif !any_matcher_node?(min_node) && !any_matcher_node?(max_node)
-          result = chain_call(result, :at_least, min_node)
-          result = chain_call(result, :at_most, max_node)
-        end
-
-        result
-      end
-
-      def transform_erange_node(receiver_node, min_node, max_node)
-        result = receiver_node
-
-        if any_matcher_node?(min_node) && any_matcher_node?(max_node.children[0])
-          result = chain_call(result, :at_least, s(:int, 0))
-        elsif !any_matcher_node?(min_node) && any_matcher_node?(max_node.children[0])
-          result = chain_call(result, :at_least, min_node)
-        elsif any_matcher_node?(min_node) && !any_matcher_node?(max_node.children[0])
-          result = chain_call(result, :at_least, s(:int, 0))
-          result = chain_call(result, :at_most, max_node)
-        elsif !any_matcher_node?(min_node) && !any_matcher_node?(max_node.children[0])
-          result = chain_call(result, :at_least, min_node)
-          result = chain_call(result, :at_most, max_node)
-        end
-
-        result
-      end
-
-      def any_matcher_node?(node)
-        node.type == :send && node.children[0].nil? && node.children[1] == :_
-      end
-
-      def parse_node(node)
-        parse_lhs(node.children[0])
-        parse_rhs(node.children[2])
-      end
-
-      def parse_lhs(node)
-        @times_node = node
-
-        case @times_node.type
-        when *ALLOWED_NODES
-          # OK
-        when :begin
-          if node.children.count > 1
-            raise_lhs_error(node, msg_prefix: "Left-hand side of ", msg_suffix: " or a range in parentheses")
-          end
-          case node.children[0].type
-          when :irange, :erange
-            unless ALLOWED_NODES.include?(node.children[0].children[0].type)
-              raise_lhs_error(node.children[0].children[0], msg_prefix: "Minimum range of ")
-            end
-            unless ALLOWED_NODES.include?(node.children[0].children[1].type)
-              raise_lhs_error(node.children[0].children[1], msg_prefix: "Maximum range of ")
-            end
-          else
-            raise_lhs_error(node, msg_prefix: "Left-hand side of ", msg_suffix: " or a range in parentheses")
-          end
-        else
-          raise_lhs_error(node, msg_prefix: "Left-hand side of ", msg_suffix: " or a range in parentheses")
-        end
-      end
-
-      def parse_rhs(node)
-        if node.type != :send
-          raise InteractionError, "Right-hand side of Interaction @ #{range(node)} must be a :send node."
-        end
-
-        @receiver_node, @message, *@arg_nodes = node.children
-
-        if @receiver_node.nil?
-          raise InteractionError, "Right-hand side of Interaction @ #{range(node)} must have a receiver."
-        end
-      end
-
-      def range(node)
-        node&.loc&.expression || "?"
-      end
-
-      def raise_lhs_error(node, msg_prefix: "", msg_suffix: "")
-        raise InteractionError, "#{msg_prefix}Interaction @ #{range(node)} must be one of "\
-          "#{ALLOWED_NODES}#{msg_suffix}."
-      end
-    end
-  end
-end

data/lib/rspock/ast/start_block.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-require 'rspock/ast/block'
-
-module RSpock
-  module AST
-    class StartBlock < Block
-      def initialize(node)
-        super(:Start, node)
-        @node_container = false
-      end
-
-      def successors
-        if @children.empty?
-          SUCCESSORS_WITHOUT_CHILDREN
-        else
-          SUCCESSORS_WITH_CHILDREN
-        end
-      end
-
-      def succession_error_msg
-        "Test method @ #{range} must start with one of these Blocks: #{successors}"
-      end
-
-      SUCCESSORS_WITHOUT_CHILDREN = [:Given, :When, :Expect].freeze
-      SUCCESSORS_WITH_CHILDREN = [:End].freeze
-    end
-  end
-end

data/lib/rspock/ast/then_block.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require 'rspock/ast/block'
-require 'rspock/ast/comparison_to_assertion_transformation'
-require 'rspock/ast/interaction_transformation'
-
-module RSpock
-  module AST
-    class ThenBlock < Block
-      def initialize(node)
-        super(:Then, node)
-      end
-
-      def successors
-        @successors ||= [:Cleanup, :Where, :End].freeze
-      end
-
-      def children
-        super.reject { |child| interaction_transformation.interaction_node?(child) }
-          .map { |child| ComparisonToAssertionTransformation.new(:_test_index_, :_line_number_).run(child) }
-      end
-
-      def interactions
-        @children.select { |child| interaction_transformation.interaction_node?(child) }
-          .map { |child| interaction_transformation.run(child) }
-      end
-
-      private
-
-      def interaction_transformation
-        @interaction_transformation ||= RSpock::AST::InteractionTransformation.new
-      end
-    end
-  end
-end

data/lib/rspock/ast/when_block.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-require 'rspock/ast/block'
-
-module RSpock
-  module AST
-    class WhenBlock < Block
-      def initialize(node)
-        super(:When, node)
-      end
-
-      def successors
-        @successors ||= [:Then].freeze
-      end
-    end
-  end
-end