rspock 2.2.0 → 2.3.0

data/lib/rspock/ast/parser/test_method_parser.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+require 'rspock/ast/node'
+
+module RSpock
+  module AST
+    module Parser
+      # Parses a Ruby test method AST node into a self-contained RSpock AST.
+      #
+      # Input:  s(:block, s(:send, nil, :test, ...), s(:args), s(:begin, ...))
+      # Output: s(:rspock_test,
+      #           s(:rspock_def, method_call_node, args_node),
+      #           s(:rspock_body, s(:rspock_given, ...), s(:rspock_when, ...), ...),
+      #           s(:rspock_where, ...))   # optional
+      class TestMethodParser
+        include RSpock::AST::NodeBuilder
+
+        def initialize(block_registry, strict: true)
+          @block_registry = block_registry
+          @strict = strict
+        end
+
+        # Parses a Ruby test method AST into an RSpock AST (TestNode).
+        # Returns nil when non-strict and no RSpock blocks are found.
+        def parse(node)
+          blocks = parse_blocks(node)
+
+          if blocks.empty?
+            return nil unless @strict
+            raise BlockError, "Test method @ #{node.loc&.expression || '?'} must start with one of: Given, When, Expect"
+          end
+
+          validate_blocks(blocks, node)
+          build_rspock_ast(node, blocks)
+        end
+
+        private
+
+        def parse_blocks(node)
+          blocks = []
+          test_method_nodes(node).each do |n|
+            new_block = parse_block(n)
+            if new_block
+              validate_succession(blocks, new_block)
+              blocks << new_block
+            elsif blocks.empty?
+              raise BlockError, "Test method must start with one of: Given, When, Expect" if @strict
+              # non-strict: ignore pre-block statements in plain minitest tests
+            else
+              # regular statement — associate with the current block as a child
+              blocks.last << n
+            end
+          end
+          blocks
+        end
+
+        def parse_block(node)
+          return unless @block_registry.key?(node.children[1])
+
+          @block_registry[node.children[1]].new(node)
+        end
+
+        def validate_succession(blocks, new_block)
+          return if blocks.empty?
+
+          current = blocks.last
+          unless current.valid_successor?(new_block)
+            raise BlockError, current.succession_error_msg
+          end
+        end
+
+        def validate_blocks(blocks, node)
+          unless blocks.first.can_start?
+            raise BlockError, "Test method @ #{node.loc&.expression || '?'} must start with one of: Given, When, Expect"
+          end
+
+          unless blocks.last.can_end?
+            raise BlockError, "Block #{blocks.last.type} @ #{blocks.last.range} must be followed by one of these Blocks: #{blocks.last.successors}"
+          end
+        end
+
+        def test_method_nodes(node)
+          return [] if node.children[2].nil?
+
+          node.children[2]&.type == :begin ? node.children[2].children : [node.children[2]]
+        end
+
+        def build_rspock_ast(node, blocks)
+          def_node = s(:rspock_def, node.children[0], node.children[1])
+          where_block = blocks.find { |b| b.type == :Where }
+          body_blocks = blocks.reject { |b| b.type == :Where }
+
+          body_node = s(:rspock_body, *body_blocks.map(&:to_rspock_node))
+
+          if where_block
+            s(:rspock_test, def_node, body_node, where_block.to_rspock_node)
+          else
+            s(:rspock_test, def_node, body_node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspock/ast/parser/then_block.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'rspock/ast/parser/block'
+require 'rspock/ast/parser/interaction_parser'
+
+module RSpock
+  module AST
+    module Parser
+      class ThenBlock < Block
+        def initialize(node)
+          super(:Then, node)
+        end
+
+        def can_end?
+          true
+        end
+
+        def successors
+          @successors ||= [:Cleanup, :Where].freeze
+        end
+
+        def to_rspock_node
+          parser = InteractionParser.new
+          spock_children = @children.map { |child| parser.parse(child) }
+          s(:rspock_then, *spock_children)
+        end
+      end
+    end
+  end
+end

data/lib/rspock/ast/parser/when_block.rb

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

data/lib/rspock/ast/parser/where_block.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+require 'rspock/ast/parser/block'
+
+module RSpock
+  module AST
+    module Parser
+      class WhereBlock < Block
+        class MalformedError < StandardError; end
+
+        def initialize(node)
+          super(:Where, node)
+        end
+
+        def header
+          @header ||= parse_header
+        end
+
+        def data
+          @data ||= parse_data
+        end
+
+        def to_rspock_node
+          header_node = s(:rspock_where_header, *header.map { |col| s(:sym, col) })
+          data_nodes = data.map { |row| s(:array, *row) }
+          s(:rspock_where, header_node, *data_nodes)
+        end
+
+        def can_end?
+          true
+        end
+
+        private
+
+        def parse_header
+          header = []
+          header_pipe_node?(children.first, header) || terminal_header_node?(children.first, header)
+          header
+        end
+
+        def header_pipe_node?(node, header)
+          return false if node.nil?
+
+          node.type == :send &&
+            node.children.count == 3 &&
+            (header_pipe_node?(node.children[0], header) || terminal_header_node?(node.children[0], header)) &&
+            node.children[1] == :| &&
+            terminal_header_node?(node.children[2], header)
+        end
+
+        def terminal_header_node?(node, header)
+          return false if node.nil?
+
+          result = node.type == :send &&
+            node.children.count == 2 &&
+            node.children.first.nil? &&
+            node.children.last.is_a?(Symbol)
+
+          raise MalformedError, "Where Block is malformed at location: #{node.loc&.expression || "?"}" unless result
+
+          header << node.children.last if result
+
+          result
+        end
+
+        def parse_data
+          _header_node, *row_nodes = children
+          row_nodes.map do |node|
+            data = []
+            data_pipe_node?(node, data) || terminal_data_node?(node, data)
+            data
+          end
+        end
+
+        def data_pipe_node?(node, data)
+          return false if node.nil?
+          return false unless node.type == :send && node.children.count == 3 && node.children[1] == :|
+
+          unless data_pipe_node?(node.children[0], data)
+            terminal_data_node?(node.children[0], data)
+          end
+
+          unless data_pipe_node?(node.children[2], data)
+            terminal_data_node?(node.children[2], data)
+          end
+        end
+
+        def terminal_data_node?(node, data)
+          data << node
+          true
+        end
+      end
+    end
+  end
+end

data/lib/rspock/ast/test_method_transformation.rb

@@ -1,165 +1,164 @@
 # frozen_string_literal: true
 require 'ast_transform/abstract_transformation'
+require 'rspock/ast/node'
+require 'rspock/ast/comparison_to_assertion_transformation'
 require 'rspock/ast/header_nodes_transformation'
+require 'rspock/ast/interaction_to_mocha_mock_transformation'
+require 'rspock/ast/interaction_to_block_identity_assertion_transformation'
 require 'rspock/ast/method_call_to_lvar_transformation'
 require 'rspock/ast/test_method_def_transformation'
+require 'rspock/ast/parser/test_method_parser'
 
 module RSpock
   module AST
     class TestMethodTransformation < ASTTransform::AbstractTransformation
-      def initialize(source_map, start_block_class, end_block_class, strict: true)
-        @source_map = source_map
-        @start_block_class = start_block_class
-        @end_block_class = end_block_class
-        @strict = strict
-        @blocks = []
+      def initialize(block_registry, strict: true)
+        @parser = Parser::TestMethodParser.new(block_registry, strict: strict)
+        @comparison_transformation = ComparisonToAssertionTransformation.new(:_test_index_, :_line_number_)
       end
 
       def run(node)
-        parse(node)
-        build_ast(node)
+        rspock_ast = @parser.parse(node)
+        return node if rspock_ast.nil?
+        transform(rspock_ast)
       end
 
       private
 
-      def parse(node)
-        start_block = @start_block_class.new(node)
-        start_block.node_container = !@strict
+      def transform(rspock_ast)
+        hoisted_setups = []
+
+        method_call = rspock_ast.def_node.method_call
+        method_args = rspock_ast.def_node.args
+        where = rspock_ast.where_node
+
+        transformed_blocks = rspock_ast.body_node.children.map do |block_node|
+          case block_node.type
+          when :rspock_then
+            transform_then_block(block_node, hoisted_setups)
+          when :rspock_expect
+            transform_expect_block(block_node)
+          else
+            block_node
+          end
+        end
 
-        add_block(start_block)
-        test_method_nodes(node).each { |n| parse_node(n) }
-        add_block(@end_block_class.new)
-        nil
+        transformed_body = rspock_ast.body_node.updated(nil, transformed_blocks)
+        build_ruby_ast(method_call, method_args, transformed_body, where, hoisted_setups)
       end
 
-      def build_ast(node)
-        if where_block
-          s(:block,
-            build_where_block_iterator(where_block.data),
-            build_where_block_args(where_block.header),
-            build_test_method_def(node)
-          )
-        else
-          build_test_method_def(node)
+      def transform_then_block(then_node, hoisted_setups)
+        interaction_setups = []
+        then_children = []
+
+        then_node.children.each_with_index do |child, idx|
+          if child.type == :rspock_interaction
+            setup = InteractionToMochaMockTransformation.new(idx).run(child)
+            assertion = InteractionToBlockIdentityAssertionTransformation.new(idx).run(child)
+
+            interaction_setups << setup
+            then_children << assertion unless assertion.equal?(child)
+          else
+            then_children << @comparison_transformation.run(child)
+          end
         end
-      end
 
-      def build_where_block_iterator(rows)
-        s(:send,
-          s(:send,
-            s(:array, *build_where_block_data_rows(rows)),
-            :each,
-          ),
-          :with_index
-        )
-      end
+        unless interaction_setups.empty?
+          interaction_setups.each do |node|
+            if node.type == :begin
+              hoisted_setups.concat(node.children)
+            else
+              hoisted_setups << node
+            end
+          end
+        end
 
-      def build_where_block_data_rows(rows)
-        rows.map(&method(:build_where_block_data_row))
+        then_node.updated(nil, then_children)
       end
 
-      def build_where_block_data_row(row)
-        children = row.dup
-        children << s(:int, row.first&.loc&.expression&.line)
-
-        s(:array, *children)
+      def transform_expect_block(expect_node)
+        new_children = expect_node.children.map { |child| @comparison_transformation.run(child) }
+        expect_node.updated(nil, new_children)
       end
 
-      def build_where_block_args(header)
-        injected_args = header.map { |column| s(:arg, column) }
-        injected_args << s(:arg, :_line_number_)
+      # --- Build final Ruby AST ---
 
-        s(:args,
-          s(:mlhs, *injected_args),
-          s(:arg, :_test_index_),
-        )
-      end
+      def build_ruby_ast(method_call, method_args, body_node, where, hoisted_setups)
+        if where
+          test_def = s(:block,
+            TestMethodDefTransformation.new.run(method_call),
+            method_args,
+            build_test_body(body_node, hoisted_setups)
+          )
+          test_def = HeaderNodesTransformation.new(where.header).run(test_def)
 
-      def build_test_method_def(node)
-        if where_block
-          ast = s(:block,
-            TestMethodDefTransformation.new.run(node.children[0]),
-            node.children[1],
-            build_test_body
+          s(:block,
+            build_where_iterator(where.data_rows),
+            build_where_args(where.header),
+            test_def
           )
-          HeaderNodesTransformation.new(where_block.header).run(ast)
         else
           s(:block,
-            node.children[0],
-            node.children[1],
-            build_test_body
+            method_call,
+            method_args,
+            build_test_body(body_node, hoisted_setups)
           )
         end
       end
 
-      def first_scope
-        @blocks.first
-      end
-
-      def current_scope
-        @blocks.last
-      end
-
-      def add_block(block)
-        if current_scope && !current_scope.valid_successor?(block)
-          raise RSpock::AST::BlockError, current_scope.succession_error_msg
+      def build_test_body(body_node, hoisted_setups)
+        body_children = []
+
+        body_node.children.each do |block_node|
+          case block_node.type
+          when :rspock_given
+            body_children.concat(block_node.children)
+          when :rspock_when
+            body_children.concat(hoisted_setups)
+            body_children.concat(block_node.children)
+          when :rspock_then, :rspock_expect
+            body_children.concat(block_node.children)
+          when :rspock_cleanup
+            # handled below as ensure
+          end
         end
 
-        @blocks << block
-      end
+        ast = s(:begin, *body_children)
 
-      def test_method_nodes(node)
-        return [] if node.children[2].nil?
-
-        node.children[2]&.type == :begin ? node.children[2].children : [node.children[2]]
-      end
-
-      def parse_node(node)
-        if @source_map.key?(node.children[1])
-          add_block(build_block(node))
-        else
-          current_scope << node
+        cleanup = body_node.children.find { |n| n.type == :rspock_cleanup }
+        if cleanup && !cleanup.children.empty?
+          ensure_node = s(:begin, *cleanup.children)
+          ast = s(:kwbegin, s(:ensure, ast, ensure_node))
         end
-      end
-
-      def build_block(node)
-        @source_map[node.children[1]].new(node)
-      end
 
-      def when_block
-        @when_block ||= @blocks.detect { |block| block.type == :When }
+        MethodCallToLVarTransformation.new(:_test_index_, :_line_number_).run(ast)
       end
 
-      def then_block
-        @then_block ||= @blocks.detect { |block| block.type == :Then }
-      end
+      # --- Where block helpers ---
 
-      def where_block
-        @where_block ||= @blocks.detect { |block| block.type == :Where }
+      def build_where_iterator(data_rows)
+        s(:send,
+          s(:send,
+            s(:array, *data_rows.map { |row| build_where_data_row(row) }),
+            :each,
+          ),
+          :with_index
+        )
       end
 
-      def cleanup_block
-        @cleanup_block ||= @blocks.detect { |block| block.type == :Cleanup }
+      def build_where_data_row(row)
+        children = row.dup
+        children << s(:int, row.first&.loc&.expression&.line)
+        s(:array, *children)
       end
 
-      def build_test_body
-        then_block&.interactions&.reverse&.each { |interaction| when_block.unshift(interaction) }
-
-        test_body_children = @blocks.select { |block| [:Start, :Given, :When, :Then, :Expect].include?(block.type) }
-          .map { |block| block.children }
-          .flatten
-
-        ast = s(:begin, *test_body_children)
-
-        if cleanup_block && !cleanup_block.children.empty?
-          ensure_node = s(:begin, *cleanup_block.children)
-
-          ast = s(:kwbegin,
-                  s(:ensure, ast, ensure_node)
-          )
-        end
-
-        MethodCallToLVarTransformation.new(:_test_index_, :_line_number_).run(ast)
+      def build_where_args(header)
+        injected_args = header.map { |column| s(:arg, column) }
+        injected_args << s(:arg, :_line_number_)
+        s(:args,
+          s(:mlhs, *injected_args),
+          s(:arg, :_test_index_),
+        )
       end
     end
   end

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/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.2.0"
+  VERSION = "2.3.0"
 end