rspock 2.4.0 → 3.0.0

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'ast_transform/transformation_helper'
 require 'rspock/ast/node'
 
 module RSpock
@@ -10,12 +11,13 @@ module RSpock
       # - Binary operators (==, !=, =~, etc.) become :rspock_binary_statement nodes.
       # - Everything else becomes :rspock_statement nodes with the original source text captured.
       class StatementParser
-        include RSpock::AST::NodeBuilder
+        include ASTTransform::TransformationHelper
 
         BINARY_OPERATORS = %i[== != =~ !~ > < >= <=].freeze
         ASSIGNMENT_TYPES = %i[lvasgn masgn op_asgn or_asgn and_asgn].freeze
 
         def parse(node)
+          return build_raises(node) if raises_condition?(node)
           return node if assignment?(node)
           return build_binary_statement(node) if binary_statement?(node)
 
@@ -24,6 +26,32 @@ module RSpock
 
         private
 
+        def raises_condition?(node)
+          direct_raises?(node) || assigned_raises?(node)
+        end
+
+        def direct_raises?(node)
+          node.type == :send && node.children[0].nil? && node.children[1] == :raises
+        end
+
+        def assigned_raises?(node)
+          node.type == :lvasgn &&
+            node.children[1]&.type == :send &&
+            node.children[1].children[0].nil? &&
+            node.children[1].children[1] == :raises
+        end
+
+        def build_raises(node)
+          if node.type == :lvasgn
+            variable = s(:sym, node.children[0])
+            exception_class = node.children[1].children[2]
+            s_anchored(node, :rspock_raises, exception_class, variable)
+          else
+            exception_class = node.children[2]
+            s_anchored(node, :rspock_raises, exception_class)
+          end
+        end
+
         def assignment?(node)
           ASSIGNMENT_TYPES.include?(node.type)
         end
@@ -34,13 +62,20 @@ module RSpock
             BINARY_OPERATORS.include?(node.children[1])
         end
 
+        # RSpock IR nodes are anchored at the statement they classify, so the assertions they lower into are
+        # emitted at the statement's source line.
         def build_binary_statement(node)
-          s(:rspock_binary_statement, node.children[0], s(:sym, node.children[1]), node.children[2])
+          s_anchored(node, :rspock_binary_statement, node.children[0], s(:sym, node.children[1]), node.children[2])
         end
 
         def build_statement(node)
           source = node.loc&.expression&.source || node.inspect
-          s(:rspock_statement, node, s(:str, source))
+          s_anchored(node, :rspock_statement, node, s(:str, source))
+        end
+
+        # s_at that tolerates loc-less anchors (unit tests build synthetic ASTs).
+        def s_anchored(anchor, type, *children)
+          anchor.loc&.expression ? s_at(anchor, type, *children) : s(type, *children)
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'ast_transform/transformation_helper'
 require 'rspock/ast/node'
 
 module RSpock
@@ -12,7 +13,7 @@ module RSpock
       #           s(:rspock_body, s(:rspock_given, ...), s(:rspock_when, ...), ...),
       #           s(:rspock_where, ...))   # optional
       class TestMethodParser
-        include RSpock::AST::NodeBuilder
+        include ASTTransform::TransformationHelper
 
         def initialize(block_registry, strict: true)
           @block_registry = block_registry
@@ -74,7 +75,8 @@ module RSpock
           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}"
+            raise BlockError, "Block #{blocks.last.type} @ #{blocks.last.range} " \
+              "must be followed by one of these Blocks: #{blocks.last.successors}"
           end
         end
 

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

@@ -30,6 +30,11 @@ module RSpock
             statement_parser.parse(child)
           end
 
+          raises_count = spock_children.count { |c| c.type == :rspock_raises }
+          if raises_count > 1
+            raise BlockError, "Then block @ #{range} may contain at most one raises() condition"
+          end
+
           s(:rspock_then, *spock_children)
         end
       end

data/lib/rspock/ast/statement_to_assertion_transformation.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'ast_transform/transformation_helper'
 require 'rspock/ast/node'
 
 module RSpock
@@ -8,7 +9,7 @@ module RSpock
     # Binary statements dispatch to specialized assertions (assert_equal, assert_match, assert_operator).
     # General statements use assert_equal(true/false, expr, source_message) with negation detection.
     class StatementToAssertionTransformation
-      include RSpock::AST::NodeBuilder
+      include ASTTransform::TransformationHelper
 
       BINARY_DISPATCH = {
         :==  => :assert_equal,

data/lib/rspock/ast/test_method_def_transformation.rb

@@ -4,15 +4,16 @@ require 'rspock/ast/test_method_dstr_transformation'
 
 module RSpock
   module AST
+    # Appends the data row's index and source line to a Where-driven test's name. The values arrive through
+    # internal block parameters on the row iterator (see TestMethodTransformation#build_where_args) and surface in
+    # the test NAME only: the name is what makes identical data rows unique and what the -n selector matches to
+    # isolate a row. They are deliberately not exposed as test-scope variables.
     class TestMethodDefTransformation < ASTTransform::AbstractTransformation
-      TEST_INDEX_AST = s(:begin,
-                         s(:lvar, :_test_index_))
-
-      LINE_NUMBER_AST = s(:begin,
-                         s(:lvar, :_line_number_))
-
-      SPACE_STR_AST = s(:str, " ")
+      ROW_INDEX_ARG = :__rspock_row_index__
+      ROW_LINE_ARG = :__rspock_row_line__
 
+      ROW_INDEX_AST = s(:begin, s(:lvar, ROW_INDEX_ARG))
+      ROW_LINE_AST = s(:begin, s(:lvar, ROW_LINE_ARG))
       LINE_NUMBER_STR_AST = s(:str, " line ")
 
       def run(node)
@@ -23,7 +24,7 @@ module RSpock
 
       def on_str(node)
         merged = s(:str, "#{node.children[0]} ")
-        node.updated(:dstr, [merged, TEST_INDEX_AST, LINE_NUMBER_STR_AST, LINE_NUMBER_AST])
+        node.updated(:dstr, [merged, ROW_INDEX_AST, LINE_NUMBER_STR_AST, ROW_LINE_AST])
       end
 
       def on_dstr(node)

data/lib/rspock/ast/test_method_dstr_transformation.rb

@@ -3,15 +3,13 @@ require 'ast_transform/abstract_transformation'
 
 module RSpock
   module AST
+    # dstr counterpart of TestMethodDefTransformation: appends the row index and source line interpolations to an
+    # already-interpolated test name.
     class TestMethodDstrTransformation < ASTTransform::AbstractTransformation
-      TEST_INDEX_AST = s(:begin,
-                         s(:lvar, :_test_index_))
-
-      LINE_NUMBER_AST = s(:begin,
-                          s(:lvar, :_line_number_))
+      ROW_INDEX_AST = s(:begin, s(:lvar, :__rspock_row_index__))
+      ROW_LINE_AST = s(:begin, s(:lvar, :__rspock_row_line__))
 
       SPACE_STR_AST = s(:str, " ")
-
       LINE_NUMBER_STR_AST = s(:str, " line ")
 
       def on_dstr(node)
@@ -24,7 +22,7 @@ module RSpock
           children << SPACE_STR_AST
         end
 
-        children.push(TEST_INDEX_AST, LINE_NUMBER_STR_AST, LINE_NUMBER_AST)
+        children.push(ROW_INDEX_AST, LINE_NUMBER_STR_AST, ROW_LINE_AST)
         node.updated(nil, children)
       end
     end

data/lib/rspock/ast/test_method_transformation.rb

@@ -5,7 +5,6 @@ require 'rspock/ast/statement_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'
 
@@ -26,79 +25,187 @@ module RSpock
       private
 
       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
+        body = build_test_body(rspock_ast.body_node)
+        build_ruby_ast(method_call, method_args, body, where)
+      end
+
+      # --- Test body assembly ---
+      #
+      # Statements are assembled in SOURCE order so line-aligned emission keeps each one on its own line.
+      # Execution-order requirements that source order cannot express (interaction setups in Then must run before the
+      # When body they observe) are carried by ast-transform's thunk facility (run_after / thunk) instead of by
+      # textual hoisting.
+      def build_test_body(body_node)
+        blocks = body_node.children
+        sections = blocks.map { |block_node| transform_block(block_node) }
+
+        when_statements = statements_of_type(blocks, sections, :rspock_when)
+        cleanup_statements = statements_of_type(blocks, sections, :rspock_cleanup)
+        interaction_setups = sections.flat_map(&:interaction_setups)
+        raises_node = blocks.filter_map { |block_node| find_raises(block_node) }.first
+
+        source_order = blocks.zip(sections).flat_map do |block_node, section|
+          next [] if block_node.type == :rspock_cleanup
+
+          section.statements.reject { |statement| statement.type == :rspock_raises }
         end
 
-        transformed_body = rspock_ast.body_node.updated(nil, transformed_blocks)
-        build_ruby_ast(method_call, method_args, transformed_body, where, hoisted_setups)
+        body_children = order_execution(source_order, when_statements, interaction_setups, raises_node)
+
+        ast = s(:begin, *body_children)
+        cleanup_statements.empty? ? ast : s(:kwbegin, s(:ensure, ast, s(:begin, *cleanup_statements)))
       end
 
-      def transform_then_block(then_node, hoisted_setups)
-        interaction_setups = []
-        then_children = []
+      Section = Data.define(:statements, :interaction_setups)
+
+      def transform_block(block_node)
+        case block_node.type
+        when :rspock_then, :rspock_expect
+          transform_assertion_block(block_node)
+        else
+          Section.new(statements: block_node.children, interaction_setups: [])
+        end
+      end
 
-        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)
+      # Then/Expect children become plain Ruby in place: interactions lower to Mocha setups anchored at the
+      # interaction's own source line (plus an identity assertion for &block forwarding), statements become
+      # assertions at their own lines.
+      #
+      # Within the section, ALL setups come before all assertions: the thunked When body executes right after the
+      # last setup, and every assertion (identity or otherwise) observes the When body's effects, so none may
+      # precede that point. Setups keep source order and their anchors, so alignment holds; assertions after them
+      # are either synthetic (identity assertions, loc-less, pack anywhere) or textually below the interactions in
+      # the common case.
+      def transform_assertion_block(block_node)
+        setups = []
+        assertions = []
+        interaction_index = 0
 
-            interaction_setups << setup
-            then_children << assertion unless assertion.equal?(child)
+        block_node.children.each do |child|
+          case child.type
+          when :rspock_interaction
+            interaction_setups, identity_assertions = lower_interaction(child, interaction_index)
+            interaction_index += 1
+            setups.concat(interaction_setups)
+            assertions.concat(identity_assertions)
+          when :rspock_binary_statement, :rspock_statement
+            assertions << anchored_at(child, @statement_transformation.run(child))
           else
-            then_children << transform_statement_or_passthrough(child)
+            assertions << child
           end
         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
+        Section.new(statements: setups + assertions, interaction_setups: setups)
+      end
+
+      # @return [Array(Array, Array)] Mocha setup statements, identity assertions
+      def lower_interaction(interaction, index)
+        setup = InteractionToMochaMockTransformation.new(index).run(interaction)
+        assertion = InteractionToBlockIdentityAssertionTransformation.new(index).run(interaction)
+
+        setups = setup.type == :begin ? setup.children.dup : [setup]
+        setups[0] = anchored_at(interaction, setups[0])
+
+        [setups, assertion.equal?(interaction) ? [] : [assertion]]
+      end
 
-        then_node.updated(nil, then_children)
+      # Reorders execution (not text) where required:
+      # - interactions without raises: run the When body after the last interaction setup (run_after — the paved
+      #   road).
+      # - raises without interactions: the When body inlines directly into assert_raises; no thunk needed.
+      # - raises with interactions: the When body is thunked into the assert_raises block inserted after the last
+      #   setup; the lowering re-emits the body at its own source lines.
+      def order_execution(source_order, when_statements, interaction_setups, raises_node)
+        if raises_node
+          build_raises_body(source_order, when_statements, interaction_setups, raises_node)
+        elsif interaction_setups.any? && when_statements.any?
+          run_after(source_order, run: when_statements, after: interaction_setups.last)
+        else
+          source_order
+        end
       end
 
-      def transform_expect_block(expect_node)
-        new_children = expect_node.children.map { |child| transform_statement_or_passthrough(child) }
-        expect_node.updated(nil, new_children)
+      def build_raises_body(source_order, when_statements, interaction_setups, raises_node)
+        if interaction_setups.any?
+          assertion = build_assert_raises(raises_node, thunk(*when_statements))
+
+          reordered = replace_run(source_order, when_statements, [])
+          insert_after(reordered, interaction_setups.last, assertion)
+        else
+          when_body = when_statements.length == 1 ? when_statements[0] : s(:begin, *when_statements)
+          assertion = build_assert_raises(raises_node, when_body)
+
+          replace_run(source_order, when_statements, [assertion])
+        end
       end
 
-      def transform_statement_or_passthrough(child)
-        case child.type
-        when :rspock_binary_statement, :rspock_statement
-          @statement_transformation.run(child)
+      def build_assert_raises(raises_node, body)
+        assert_raises_call = s(:block,
+          s(:send, nil, :assert_raises, raises_node.exception_class),
+          s(:args),
+          body
+        )
+
+        if raises_node.capture_name
+          s(:lvasgn, raises_node.capture_name, assert_raises_call)
         else
-          child
+          assert_raises_call
         end
       end
 
+      def find_raises(block_node)
+        return nil unless block_node.type == :rspock_then
+
+        block_node.children.find { |child| child.type == :rspock_raises }
+      end
+
+      def statements_of_type(blocks, sections, type)
+        blocks.zip(sections)
+          .select { |block_node, _section| block_node.type == type }
+          .flat_map { |_block_node, section| section.statements }
+      end
+
+      # --- Identity-based sequence edits (non-thunk counterparts of run_after) ---
+
+      def replace_run(statements, run, replacement)
+        start = statements.index { |statement| statement.equal?(run.first) }
+        raise ArgumentError, "run is not part of statements" unless start
+
+        result = statements.dup
+        result[start, run.length] = replacement
+        result
+      end
+
+      def insert_after(statements, anchor, insertion)
+        index = statements.index { |statement| statement.equal?(anchor) }
+        raise ArgumentError, "anchor is not part of statements" unless index
+
+        result = statements.dup
+        result.insert(index + 1, insertion)
+        result
+      end
+
+      # Re-anchors +node+ at +anchor+'s source location so emission places it on the anchor's line.
+      # No-op for anchors without locations.
+      def anchored_at(anchor, node)
+        return node unless anchor.loc&.expression
+
+        s_at(anchor, node.type, *node.children)
+      end
+
       # --- Build final Ruby AST ---
 
-      def build_ruby_ast(method_call, method_args, body_node, where, hoisted_setups)
+      def build_ruby_ast(method_call, method_args, body_node, where)
         if where
-          test_def = s(:block,
+          test_def = anchored_at(method_call, s(:block,
             TestMethodDefTransformation.new.run(method_call),
             method_args,
-            build_test_body(body_node, hoisted_setups)
-          )
+            body_node
+          ))
           test_def = HeaderNodesTransformation.new(where.header).run(test_def)
 
           s(:block,
@@ -107,43 +214,19 @@ module RSpock
             test_def
           )
         else
-          s(:block,
+          anchored_at(method_call, s(:block,
             method_call,
             method_args,
-            build_test_body(body_node, hoisted_setups)
-          )
-        end
-      end
-
-      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
+            body_node
+          ))
         end
-
-        ast = s(:begin, *body_children)
-
-        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
-
-        MethodCallToLVarTransformation.new(:_test_index_, :_line_number_).run(ast)
       end
 
       # --- Where block helpers ---
+      #
+      # Each data row carries its source line as a trailing element, surfaced in the generated test NAME only
+      # (uniqueness for identical rows + the -n selector target) through internal block parameters. There is no
+      # user-facing runtime variable: isolate a row by running its generated test by name, then break normally.
 
       def build_where_iterator(data_rows)
         s(:send,
@@ -158,15 +241,16 @@ module RSpock
       def build_where_data_row(row)
         children = row.dup
         children << s(:int, row.first&.loc&.expression&.line)
-        s(:array, *children)
+        anchor = row.first
+        anchor&.loc&.expression ? s_at(anchor, :array, *children) : s(:array, *children)
       end
 
       def build_where_args(header)
         injected_args = header.map { |column| s(:arg, column) }
-        injected_args << s(:arg, :_line_number_)
+        injected_args << s(:arg, TestMethodDefTransformation::ROW_LINE_ARG)
         s(:args,
           s(:mlhs, *injected_args),
-          s(:arg, :_test_index_),
+          s(:arg, TestMethodDefTransformation::ROW_INDEX_ARG),
         )
       end
     end

data/lib/rspock/ast/transformation.rb

@@ -77,8 +77,7 @@ module RSpock
 
       def process_rspock(node)
         processed = process_all(node).compact
-        children = [source_map_rescue_wrapper(s(:begin, *[EXTEND_RSPOCK_DECLARATIVE, *processed]))]
-        node.updated(nil, children)
+        node.updated(nil, [EXTEND_RSPOCK_DECLARATIVE, *processed])
       end
 
       def on_block(node)
@@ -91,31 +90,6 @@ module RSpock
           strict: @strict
         ).run(node)
       end
-
-      def source_map_rescue_wrapper(node)
-        s(:kwbegin,
-          s(:rescue,
-            node,
-            s(:resbody,
-              s(:array,
-                s(:const, nil, :StandardError)
-              ),
-              s(:lvasgn, :e),
-              s(:begin,
-                s(:send,
-                  s(:send,
-                    s(:const,
-                      s(:const,
-                        s(:cbase), :RSpock), :BacktraceFilter), :new), :filter_exception,
-                  s(:lvar, :e)
-                ),
-                s(:send, nil, :raise)
-              )
-            ),
-            nil
-          )
-        )
-      end
     end
   end
 end

data/lib/rspock/version.rb

@@ -1,3 +1,3 @@
 module RSpock
-  VERSION = "2.4.0"
+  VERSION = "3.0.0"
 end

data/lib/rspock.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require 'rspock/version'
 
-require 'rspock/backtrace_filter'
 require 'rspock/declarative'
 
 require 'ast_transform'

data/rspock.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = '>= 3.2'
+  spec.required_ruby_version = '>= 3.3'
 
   # Development dependencies
   spec.add_development_dependency "bundler", ">= 2.1"
@@ -31,9 +31,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "simplecov", "~> 0.22"
 
   # Runtime dependencies
-  spec.add_runtime_dependency "ast_transform", "~> 2.0"
+  # parser and unparser are used only through ast_transform, which owns their floors.
+  spec.add_runtime_dependency "ast_transform", "~> 3.0"
   spec.add_runtime_dependency "minitest", "~> 5.0"
   spec.add_runtime_dependency "mocha", ">= 1.0"
-  spec.add_runtime_dependency "parser", ">= 3.0"
-  spec.add_runtime_dependency "unparser", ">= 0.6"
 end