rspock 2.3.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0a24add88d2e5100613beaedf3c8b158e3d463a04e17377c99f2a2c98b63157
-  data.tar.gz: d179439aaf99e0e50a6565cadae7c2541b3ae2e399fb847cc073023ad130e7d3
+  metadata.gz: d6c10b52d342827b092af647c5bc144f4e381dff91167eedf93a0f99c9488ee2
+  data.tar.gz: 20ea274b4fa0e3a79eefb88f33c53ddf84adfc582fd37fe3e2ee9688a8137747
 SHA512:
-  metadata.gz: bfbf1995a238d569be2c5cb598e02808a77847d8bc3a0a785a5448af6bcebfc7d222e746da44892e4fa2e17c2c74153049ed4d1297cc815900c173e385b9ef3e
-  data.tar.gz: 76b576315949d04b5579ff7ead6b6d85330d0030e3045680a4eb0a369b721d1c40b53d3353d5696f02c182fd0ce4b026ab7ba9fa53dd70569aa2ef33d35bea23
+  metadata.gz: '019855311bf85f23d10fb75d3b1c0020b52fbf2ae7083205ca69a3f15b142ee7c2ba24e9be0506c690e65b42302b347ea7dc256c596edf1069ec8a0700aad666'
+  data.tar.gz: a559d70b0f3509d361234019935a2105c4a2b96ddac5ce0df7198edff346fe83a5c7a9c889d5152fbf0a856a60edd069017c3b24f88b144eda651ab35a57b47b

data/CHANGELOG.md

@@ -1,46 +1,170 @@
 # Changelog
+
 All notable changes to this project will be documented in this file.
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [UNRELEASED]
+## [Unreleased]
+
+## [2.5.0] - 2026-02-28
+
+### Added
+
+- Exception conditions: `raises ExceptionClass` in Then blocks wraps the preceding When block in an exception assertion.
+- Exception capture: `e = raises ExceptionClass` captures the exception for further assertions in the same Then block.
+- Exception conditions work with data-driven `Where` blocks.
+
+### Changed
+
+- Renamed interaction outcome nodes from `rspock_returns` / `rspock_raises` to `rspock_stub_returns` / `rspock_stub_raises` to distinguish them from the new exception condition `rspock_raises`.
+
+## [2.4.0] - 2026-02-28
+
+### Added
+
+- Spock-style implicit assertions: every non-assignment statement in Then/Expect blocks is now an assertion — no assertion API needed.
+- Binary operator assertions: `=~`, `!~`, `>`, `<`, `>=`, `<=` with clear error messages.
+- General statement assertions: bare boolean expressions (e.g. `obj.valid?`) with the original source text in the error message.
+- Negation support: `!expr` is detected automatically and produces a clear error message.
+- `>> raises(...)` syntax for exception stubbing in interactions.
+
+### Changed
+
+- Renamed `ConditionParser` to `StatementParser` and `ConditionToAssertionTransformation` to `StatementToAssertionTransformation` for consistency with Spock's model.
+- Then and Expect block parsers now use `StatementParser` for statement classification.
+
+### Removed
+
+- `ComparisonToAssertionTransformation` — replaced by `StatementToAssertionTransformation`.
+
+## [2.3.1] - 2026-02-27
+
+### Fixed
+
+- Require `block_capture` so it is available at runtime.
+
+## [2.3.0] - 2026-02-27
+
+### Added
+
+- Interaction transformations and block identity verification via `&` operator.
+- RSpock AST node hierarchy (`Node`, `InteractionNode`, `BodyNode`, etc.) for type-safe AST handling.
+- `TestMethodParser` extracted from `TestMethodTransformation` for separation of parsing and transformation.
+
+### Changed
+
+- Restructured block classes into `Parser` namespace and converted `InteractionParser` to a class.
+- Introduced `BodyNode` and removed legacy interaction transformations.
+
+## [2.2.0] - 2026-02-25
+
+### Added
+
+- Interaction stubbing with `>>` for return value stubbing in Then block interactions.
+
+### Fixed
+
+- Pry and pry-byebug compatibility.
+- Failing test on Ruby 3+.
+- `filter_string` for `ast_transform` 2.1.4 source mapping change.
+
+## [2.1.0] - 2026-02-21
+
 ### Added
-- Interaction-based testing: Mock with expectations in the Then block.
+
+- Ruby 4.0 support.
+
+### Fixed
+
+- Codecov badge URL to use master branch.
+
+## [2.0.0] - 2026-02-21
 
 ### Changed
+
+- Minimum Ruby version bumped to 3.2.
+- Upgraded to Ruby 3.x compatibility.
+- Use `ast_transform` 2.0.0 from RubyGems.
+- CI modernization and release workflow improvements.
+
+## [1.0.0] - 2020-07-09
+
+### Added
+
+- Interaction-based testing: mock with expectations in the Then block.
+- Travis CI and code coverage.
+
+### Changed
+
 - Test names now have the test index and line number as suffix instead of prefix.
-- Cleanup transformed code output.
+- Removed unnecessary ensure block when Cleanup block is empty; moved source map wrapper to class scope.
+- Bump `ast_transform` to release 1.0.0.
 
 ### Fixed
-- Fixed source mapping for transformed assertion nodes.
 
-## [0.2.5] 2019-05-28
+- Source mapping for transformed assertion nodes.
+- Truth table generator command with proper escaping.
+
+## [0.2.5] - 2019-05-28
+
 ### Fixed
-- Fixed BacktraceFilter so that source mapping works again
 
-## [0.2.4] 2019-05-27
+- BacktraceFilter so that source mapping works again.
+
+## [0.2.4] - 2019-05-27
+
 ### Changed
-- Bump Unparser dependency from ~> 0.2.8 to ~> 0.4
 
-## [0.2.3] 2018-11-09
+- Bump Unparser dependency from `~> 0.2.8` to `~> 0.4`.
+
+## [0.2.3] - 2018-11-09
+
 ### Fixed
-- Cleanup block can now contain more than one node
 
-## [0.2.2] 2018-11-08
+- Cleanup block can now contain more than one node.
+
+## [0.2.2] - 2018-11-08
+
 ### Changed
-- Extracted ASTTransform to its own gem: `ast_transform`
 
-## [0.2.1] 2018-10-09
+- Extracted ASTTransform to its own gem: `ast_transform`.
+
+## [0.2.1] - 2018-10-09
+
 ### Added
-- _line_number_ is now displayed in the test name, and is available in test scope for debugging purposes
+
+- `_line_number_` is now displayed in the test name and available in test scope for debugging.
 
 ### Changed
-- Renamed test_index to _test_index_
 
-## [0.2.0] 2018-09-21
+- Renamed `test_index` to `_test_index_`.
+
+## [0.2.0] - 2018-09-21
+
 ### Added
+
 - Truth table generator Rake task.
 
-## [0.1.1] 2018-09-19
-### Initial Release!
+## [0.1.1] - 2018-09-18
+
+### Added
+
+- Initial release.
+
+[Unreleased]: https://github.com/rspockframework/rspock/compare/v2.5.0...HEAD
+[2.5.0]: https://github.com/rspockframework/rspock/compare/v2.4.0...v2.5.0
+[2.4.0]: https://github.com/rspockframework/rspock/compare/v2.3.1...v2.4.0
+[2.3.1]: https://github.com/rspockframework/rspock/compare/v2.3.0...v2.3.1
+[2.3.0]: https://github.com/rspockframework/rspock/compare/v2.2.0...v2.3.0
+[2.2.0]: https://github.com/rspockframework/rspock/compare/v2.1.0...v2.2.0
+[2.1.0]: https://github.com/rspockframework/rspock/compare/v2.0.0...v2.1.0
+[2.0.0]: https://github.com/rspockframework/rspock/compare/1.0.0...v2.0.0
+[1.0.0]: https://github.com/rspockframework/rspock/compare/0.2.5...1.0.0
+[0.2.5]: https://github.com/rspockframework/rspock/compare/0.2.4...0.2.5
+[0.2.4]: https://github.com/rspockframework/rspock/compare/0.2.3...0.2.4
+[0.2.3]: https://github.com/rspockframework/rspock/compare/0.2.2...0.2.3
+[0.2.2]: https://github.com/rspockframework/rspock/compare/0.2.1...0.2.2
+[0.2.1]: https://github.com/rspockframework/rspock/compare/0.2.0...0.2.1
+[0.2.0]: https://github.com/rspockframework/rspock/compare/0.1.1...0.2.0
+[0.1.1]: https://github.com/rspockframework/rspock/releases/tag/0.1.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rspock (2.3.1)
+    rspock (2.5.0)
       ast_transform (~> 2.0)
       minitest (~> 5.0)
       mocha (>= 1.0)

data/README.md

@@ -16,8 +16,11 @@ Note: RSpock is heavily inspired by Spock for the Groovy programming language.
 
 * BDD-style code blocks: Given, When, Then, Expect, Cleanup, Where
 * Data-driven testing with incredibly expressive table-based Where blocks
-* Expressive assertions: Use familiar comparison operators `==` and `!=` for assertions!
-* [Interaction-based testing](#mocking-with-interactions), i.e. `1 * object.receive("message")` in Then blocks, with optional [return value stubbing](#stubbing-return-values) via `>>` and [block forwarding verification](#block-forwarding-verification) via `&block`
+* Spock-style implicit assertions: every statement in Then/Expect blocks is an assertion (no assertion API needed)
+* Binary operator assertions: `==`, `!=`, `=~`, `!~`, `>`, `<`, `>=`, `<=` with clear error messages
+* General statement assertions: bare boolean expressions (e.g. `obj.valid?`, `list.include?(x)`) and negation (`!obj.empty?`) with source-text error messages
+* [Exception conditions](#exception-conditions): `raises ExceptionClass` in Then blocks wraps the When block in an exception assertion, with optional capture for property assertions
+* [Interaction-based testing](#mocking-with-interactions), i.e. `1 * object.receive("message")` in Then blocks, with optional [return value stubbing](#stubbing-return-values) via `>>`, [exception stubbing](#stubbing-exceptions) via `>> raises(...)`, and [block forwarding verification](#block-forwarding-verification) via `&block`
 * (Planned) BDD-style custom reporter that outputs information from Code Blocks
 * (Planned) Capture all Then block violations
 
@@ -150,15 +153,65 @@ The When block describes the stimulus to be applied to the system under test. It
 
 ```ruby
 Then "The product is added to the cart"
+!cart.products.empty?
 cart.products.size == 1
 cart.products.first == product
+cart.products.size > 0
 ```
 
-The Then block describes the response from the stimulus. Any comparison operators used in the Then block (`==` or `!=`) is transformed to assert_equal / refute_equal under the hood. By convention, the __LHS__ operand is considered the __actual__ value, while the __RHS__ operand is considered the __expected__ value.
+The Then block describes the response from the stimulus. Following Spock's core model, **every statement is an assertion** unless it's a variable assignment. No assertion API is needed.
+
+**Binary operators** (`==`, `!=`, `=~`, `!~`, `>`, `<`, `>=`, `<=`) produce clear error messages on failure. By convention, the **LHS** operand is the **actual** value and the **RHS** is the **expected** value.
+
+**General statements** (bare boolean expressions like `obj.valid?`, `list.include?(x)`) include the original source text in the error message, so you see exactly which expression failed. **Negation** (`!expr`) is detected automatically.
+
+**Variable assignments** pass through unchanged and execute in source order after the stimulus.
+
+##### Exception Conditions
+
+Use `raises` in a Then block to assert that the preceding When block raises a specific exception:
+
+```ruby
+When "Dividing by zero"
+1 / 0
+
+Then "An error is raised"
+raises ZeroDivisionError
+```
+
+To inspect the exception, capture it into a variable:
+
+```ruby
+When "Parsing bad input"
+JSON.parse("not json")
+
+Then "A parse error is raised with a message"
+e = raises JSON::ParserError
+e.message.include?("unexpected token")
+```
+
+The captured variable is available for further assertions in the same Then block. Exception conditions work with data-driven `Where` blocks as well:
+
+```ruby
+When "Parsing invalid input"
+JSON.parse(input)
+
+Then "The expected error is raised"
+raises expected_error
+
+Where
+input          | expected_error
+"not json"     | JSON::ParserError
+"{invalid"     | JSON::ParserError
+```
+
+Only **one** `raises` condition is allowed per Then block, and `raises` is **not supported** in Expect blocks (use a When + Then block instead).
 
 #### Expect Block
 
-The Expect block is useful when expressing the stimulus and the response in one statement is more natural. For example, let's compare two equivalent ways of describing some behaviour:
+The Expect block is useful when expressing the stimulus and the response in one statement is more natural. The same assertion rules apply as in Then blocks — every statement is an assertion unless it's a variable assignment.
+
+For example, let's compare two equivalent ways of describing some behaviour:
 
 ##### When + Then
 ```ruby
@@ -175,6 +228,17 @@ Expect "absolute of -2 is 2"
 -2.abs == 2
 ```
 
+The Expect block supports the full range of assertion expressions:
+
+```ruby
+Expect "string matching and predicates"
+str =~ /potato/
+str.include?("pot")
+!str.empty?
+str.length > 3
+str.length == 6
+```
+
 A good rule of thumb is using When + Then blocks to describe methods with side-effects and Expect blocks to describe purely functional methods.
 
 #### Cleanup Block
@@ -306,12 +370,12 @@ test "#publish sends a message to all subscribers" do
 end
 ```
 
-The above ___Then___ block contains 2 interactions, each of which has 4 parts: the _cardinality_, the _receiver_, the _message_ and its _arguments_. Optionally, a _return value_ can be specified using the `>>` operator, and _block forwarding_ can be verified using the `&` operator.
+The above ___Then___ block contains 2 interactions, each of which has 4 parts: the _cardinality_, the _receiver_, the _message_ and its _arguments_. Optionally, an _outcome_ can be specified using the `>>` operator (either a return value or `raises(...)` for exceptions), and _block forwarding_ can be verified using the `&` operator.
 
 ```
 1 * receiver.message('hello', &blk) >> "result"
 |   |          |       |       |       |
-|   |          |       |       |       return value (optional)
+|   |          |       |       |       outcome (optional): value or raises(...)
 |   |          |       |       block forwarding (optional)
 |   |          |       argument(s) (optional)
 |   |          message
@@ -421,6 +485,39 @@ _ * cache.fetch("key") >> expensive_result   # a variable
 
 **Note**: Without `>>`, an interaction sets up an expectation only (the method will return `nil` by default). Use `>>` when the code under test depends on the return value.
 
+#### Stubbing Exceptions
+
+When the code under test needs a collaborator to raise an exception, use `>> raises(...)` instead of a return value. This sets up the mock to raise the given exception when called.
+
+```ruby
+test "#fetch raises when the record is not found" do
+  Given
+  repository = mock
+  service = Service.new(repository)
+
+  When
+  service.fetch(42)
+
+  Then
+  1 * repository.find(42) >> raises(RecordNotFound)
+end
+```
+
+You can also pass a message or an exception instance:
+
+```ruby
+1 * repository.find(42) >> raises(RecordNotFound, "not found")  # class + message
+1 * repository.find(42) >> raises(RecordNotFound.new("not found"))  # instance
+```
+
+This works with all interaction features — cardinality, arguments, and ranges:
+
+```ruby
+(1..3) * service.call(anything) >> raises(TimeoutError)
+```
+
+**Note**: Without `raises(...)`, the `>>` operator stubs a return value. With `raises(...)`, it stubs an exception instead.
+
 #### Block Forwarding Verification
 
 When the code under test forwards a block (or proc) to a collaborator, you may want to verify that the _exact_ block was passed through. RSpock supports this with the `&` operator in interactions, performing an identity check on the block reference.
@@ -527,20 +624,24 @@ To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Releasing a New Version
 
-There are two ways to create a release. Both require that `version.rb` has already been updated and merged to main.
+There are two ways to create a release. Both require that `version.rb` has already been updated, `CHANGELOG.md` has been updated, and changes have been merged to main.
 
 ### Via GitHub UI
 
-1. Update `VERSION` in `lib/rspock/version.rb` and run `bundle install` to regenerate `Gemfile.lock`, commit, open a PR, and merge to main
-2. Go to the repo on GitHub → **Releases** → **Draft a new release**
-3. Enter a new tag (e.g. `v2.0.0`), select `main` as the target branch
-4. Add a title and release notes (GitHub can auto-generate these from merged PRs)
-5. Click **Publish release**
+1. Update `VERSION` in `lib/rspock/version.rb` and run `bundle install` to regenerate `Gemfile.lock`
+2. Move the `[Unreleased]` section in `CHANGELOG.md` to a new version heading with today's date (e.g. `## [2.4.0] - 2026-03-01`) and add a fresh empty `[Unreleased]` section above it. Update the comparison links at the bottom of the file.
+3. Commit, open a PR, and merge to main
+4. Go to the repo on GitHub → **Releases** → **Draft a new release**
+5. Enter a new tag (e.g. `v2.4.0`), select `main` as the target branch
+6. Add a title and release notes (GitHub can auto-generate these from merged PRs)
+7. Click **Publish release**
 
 ### Via CLI
 
-1. Update `VERSION` in `lib/rspock/version.rb` and run `bundle install` to regenerate `Gemfile.lock`, commit, open a PR, and merge to main
-2. Tag and push:
+1. Update `VERSION` in `lib/rspock/version.rb` and run `bundle install` to regenerate `Gemfile.lock`
+2. Move the `[Unreleased]` section in `CHANGELOG.md` to a new version heading with today's date and add a fresh empty `[Unreleased]` section above it. Update the comparison links at the bottom of the file.
+3. Commit, open a PR, and merge to main
+4. Tag and push:
    ```
    git checkout main && git pull
    git tag v2.0.0

data/lib/rspock/ast/interaction_to_mocha_mock_transformation.rb

@@ -6,11 +6,20 @@ module RSpock
   module AST
     # Transforms an :rspock_interaction node into Mocha mock setup code.
     #
-    # Input:  s(:rspock_interaction, cardinality, receiver, sym, args, return_value, block_pass)
+    # Input:  s(:rspock_interaction, cardinality, receiver, sym, args, outcome, block_pass)
     # Output: receiver.expects(:message).with(*args).times(n).returns(value)
     #
+    # The outcome node type maps directly to the Mocha chain method:
+    #   :rspock_stub_returns -> .returns(value)
+    #   :rspock_stub_raises  -> .raises(exception_class, ...)
+    #
     # When block_pass is present, wraps the expects chain with a BlockCapture.capture call.
     class InteractionToMochaMockTransformation < ASTTransform::AbstractTransformation
+      OUTCOME_METHODS = {
+        rspock_stub_returns: :returns,
+        rspock_stub_raises: :raises,
+      }.freeze
+
       def initialize(index = 0)
         @index = index
       end
@@ -21,7 +30,7 @@ module RSpock
         result = chain_call(interaction.receiver, :expects, s(:sym, interaction.message))
         result = chain_call(result, :with, *interaction.args.children) if interaction.args
         result = build_cardinality(result, interaction.cardinality)
-        result = chain_call(result, :returns, interaction.return_value) if interaction.return_value
+        result = chain_call(result, OUTCOME_METHODS.fetch(interaction.outcome.type), *interaction.outcome.children) if interaction.outcome
 
         if interaction.block_pass
           build_block_capture_setup(result, interaction.receiver, interaction.message)

data/lib/rspock/ast/node.rb

@@ -70,6 +70,25 @@ module RSpock
       end
     end
 
+    class OutcomeNode < Node
+    end
+
+    class StubReturnsNode < OutcomeNode
+      register :rspock_stub_returns
+    end
+
+    class StubRaisesNode < OutcomeNode
+      register :rspock_stub_raises
+    end
+
+    class RaisesNode < Node
+      register :rspock_raises
+
+      def exception_class = children[0]
+      def capture_var     = children[1]
+      def capture_name    = capture_var&.children&.[](0)
+    end
+
     class InteractionNode < Node
       register :rspock_interaction
 
@@ -78,10 +97,25 @@ module RSpock
       def message_sym  = children[2]
       def message      = message_sym.children[0]
       def args         = children[3]
-      def return_value = children[4]
+      def outcome      = children[4]
       def block_pass   = children[5]
     end
 
+    class BinaryStatementNode < Node
+      register :rspock_binary_statement
+
+      def lhs      = children[0]
+      def operator = children[1]
+      def rhs      = children[2]
+    end
+
+    class StatementNode < Node
+      register :rspock_statement
+
+      def expression = children[0]
+      def source     = children[1]
+    end
+
     module NodeBuilder
       include ASTTransform::TransformationHelper
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'rspock/ast/parser/block'
+require 'rspock/ast/parser/statement_parser'
 
 module RSpock
   module AST
@@ -20,6 +21,17 @@ module RSpock
         def successors
           @successors ||= [:Cleanup, :Where].freeze
         end
+
+        def to_rspock_node
+          statement_parser = StatementParser.new
+          spock_children = @children.map { |child| statement_parser.parse(child) }
+
+          if spock_children.any? { |c| c.type == :rspock_raises }
+            raise BlockError, "raises() is not supported in Expect blocks @ #{range}. Use a When + Then block instead."
+          end
+
+          s(:rspock_expect, *spock_children)
+        end
       end
     end
   end

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

@@ -7,14 +7,14 @@ module RSpock
       # Parses raw Ruby AST interaction nodes into structured :rspock_interaction nodes.
       #
       # Input:  1 * receiver.message("arg", &blk) >> "result"
-      # Output: s(:rspock_interaction, cardinality, receiver, sym, args, return_value, block_pass)
+      # Output: s(:rspock_interaction, cardinality, receiver, sym, args, outcome, block_pass)
       #
       # :rspock_interaction children:
       #   [0] cardinality  - e.g. s(:int, 1), s(:begin, s(:irange, ...)), s(:send, nil, :_)
       #   [1] receiver     - e.g. s(:send, nil, :subscriber)
       #   [2] message      - e.g. s(:sym, :receive)
       #   [3] args         - nil if no args, s(:array, *arg_nodes) otherwise
-      #   [4] return_value - nil if no >>, otherwise the value node
+      #   [4] outcome      - nil if no >>, otherwise s(:rspock_stub_returns, value) or s(:rspock_stub_raises, *args)
       #   [5] block_pass   - nil if no &, otherwise s(:block_pass, ...)
       class InteractionParser
         include RSpock::AST::NodeBuilder
@@ -35,7 +35,7 @@ module RSpock
           return node unless interaction_node?(node)
 
           if return_value_node?(node)
-            return_value = node.children[2]
+            outcome = parse_outcome(node.children[2])
             node = node.children[0]
           end
 
@@ -50,7 +50,7 @@ module RSpock
             receiver,
             s(:sym, message),
             args,
-            return_value,
+            outcome,
             block_pass
           )
         end
@@ -61,6 +61,14 @@ module RSpock
           node.type == :send && node.children[1] == :>> && interaction_node?(node.children[0])
         end
 
+        def parse_outcome(node)
+          if node.type == :send && node.children[0].nil? && node.children[1] == :raises
+            s(:rspock_stub_raises, *node.children[2..])
+          else
+            s(:rspock_stub_returns, node)
+          end
+        end
+
         def validate_cardinality(node)
           case node.type
           when *ALLOWED_CARDINALITY_NODES

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require 'rspock/ast/node'
+
+module RSpock
+  module AST
+    module Parser
+      # Classifies raw Ruby AST statements into RSpock node types for Then/Expect blocks.
+      #
+      # - Assignments pass through as raw AST (no wrapping).
+      # - 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
+
+        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)
+
+          build_statement(node)
+        end
+
+        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(:rspock_raises, exception_class, variable)
+          else
+            exception_class = node.children[2]
+            s(:rspock_raises, exception_class)
+          end
+        end
+
+        def assignment?(node)
+          ASSIGNMENT_TYPES.include?(node.type)
+        end
+
+        def binary_statement?(node)
+          node.type == :send &&
+            node.children.length == 3 &&
+            BINARY_OPERATORS.include?(node.children[1])
+        end
+
+        def build_binary_statement(node)
+          s(: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))
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'rspock/ast/parser/block'
 require 'rspock/ast/parser/interaction_parser'
+require 'rspock/ast/parser/statement_parser'
 
 module RSpock
   module AST
@@ -19,8 +20,21 @@ module RSpock
         end
 
         def to_rspock_node
-          parser = InteractionParser.new
-          spock_children = @children.map { |child| parser.parse(child) }
+          interaction_parser = InteractionParser.new
+          statement_parser = StatementParser.new
+
+          spock_children = @children.map do |child|
+            parsed = interaction_parser.parse(child)
+            next parsed unless parsed.equal?(child)
+
+            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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+require 'rspock/ast/node'
+
+module RSpock
+  module AST
+    # Transforms :rspock_binary_statement and :rspock_statement nodes into Minitest assertion calls.
+    #
+    # 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
+
+      BINARY_DISPATCH = {
+        :==  => :assert_equal,
+        :!=  => :refute_equal,
+        :=~  => :assert_match,
+        :'!~' => :refute_match,
+      }.freeze
+
+      OPERATOR_ASSERTIONS = %i[> < >= <=].freeze
+
+      def run(node)
+        case node.type
+        when :rspock_binary_statement
+          transform_binary_statement(node)
+        when :rspock_statement
+          transform_statement(node)
+        else
+          node
+        end
+      end
+
+      private
+
+      def transform_binary_statement(node)
+        lhs = node.lhs
+        op = node.operator.children[0]
+        rhs = node.rhs
+
+        if (assertion = BINARY_DISPATCH[op])
+          s(:send, nil, assertion, rhs, lhs)
+        elsif OPERATOR_ASSERTIONS.include?(op)
+          s(:send, nil, :assert_operator, lhs, s(:sym, op), rhs)
+        else
+          s(:send, nil, :assert_operator, lhs, s(:sym, op), rhs)
+        end
+      end
+
+      def transform_statement(node)
+        expr = node.expression
+        source_text = node.source.children[0]
+
+        if negated?(expr)
+          inner = expr.children[0]
+          message = "Expected \"#{source_text}\" to be false"
+          s(:send, nil, :assert_equal, s(:false), inner, s(:str, message))
+        else
+          message = "Expected \"#{source_text}\" to be true"
+          s(:send, nil, :assert_equal, s(:true), expr, s(:str, message))
+        end
+      end
+
+      def negated?(node)
+        node.type == :send && node.children[1] == :! && node.children.length == 2
+      end
+    end
+  end
+end

data/lib/rspock/ast/test_method_transformation.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'ast_transform/abstract_transformation'
 require 'rspock/ast/node'
-require 'rspock/ast/comparison_to_assertion_transformation'
+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'
@@ -14,7 +14,7 @@ module RSpock
     class TestMethodTransformation < ASTTransform::AbstractTransformation
       def initialize(block_registry, strict: true)
         @parser = Parser::TestMethodParser.new(block_registry, strict: strict)
-        @comparison_transformation = ComparisonToAssertionTransformation.new(:_test_index_, :_line_number_)
+        @statement_transformation = StatementToAssertionTransformation.new
       end
 
       def run(node)
@@ -59,7 +59,7 @@ module RSpock
             interaction_setups << setup
             then_children << assertion unless assertion.equal?(child)
           else
-            then_children << @comparison_transformation.run(child)
+            then_children << transform_statement_or_passthrough(child)
           end
         end
 
@@ -77,10 +77,19 @@ module RSpock
       end
 
       def transform_expect_block(expect_node)
-        new_children = expect_node.children.map { |child| @comparison_transformation.run(child) }
+        new_children = expect_node.children.map { |child| transform_statement_or_passthrough(child) }
         expect_node.updated(nil, new_children)
       end
 
+      def transform_statement_or_passthrough(child)
+        case child.type
+        when :rspock_binary_statement, :rspock_statement
+          @statement_transformation.run(child)
+        else
+          child
+        end
+      end
+
       # --- Build final Ruby AST ---
 
       def build_ruby_ast(method_call, method_args, body_node, where, hoisted_setups)
@@ -108,16 +117,25 @@ module RSpock
 
       def build_test_body(body_node, hoisted_setups)
         body_children = []
+        blocks = body_node.children
 
-        body_node.children.each do |block_node|
+        blocks.each_with_index do |block_node, i|
           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)
+            raises_node = find_raises_in_next_then(blocks, i)
+
+            if raises_node
+              body_children << build_assert_raises(block_node, raises_node)
+            else
+              body_children.concat(block_node.children)
+            end
           when :rspock_then, :rspock_expect
-            body_children.concat(block_node.children)
+            block_node.children.each do |child|
+              body_children << child unless child.type == :rspock_raises
+            end
           when :rspock_cleanup
             # handled below as ensure
           end
@@ -134,6 +152,31 @@ module RSpock
         MethodCallToLVarTransformation.new(:_test_index_, :_line_number_).run(ast)
       end
 
+      # --- Raises condition helpers ---
+
+      def find_raises_in_next_then(blocks, current_index)
+        next_block = blocks[current_index + 1]
+        return nil unless next_block&.type == :rspock_then
+
+        next_block.children.find { |c| c.type == :rspock_raises }
+      end
+
+      def build_assert_raises(when_node, raises_node)
+        when_body = when_node.children.length == 1 ? when_node.children[0] : s(:begin, *when_node.children)
+
+        assert_raises_call = s(:block,
+          s(:send, nil, :assert_raises, raises_node.exception_class),
+          s(:args),
+          when_body
+        )
+
+        if raises_node.capture_name
+          s(:lvasgn, raises_node.capture_name, assert_raises_call)
+        else
+          assert_raises_call
+        end
+      end
+
       # --- Where block helpers ---
 
       def build_where_iterator(data_rows)

data/lib/rspock/version.rb

@@ -1,3 +1,3 @@
 module RSpock
-  VERSION = "2.3.1"
+  VERSION = "2.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspock
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.5.0
 platform: ruby
 authors:
 - Jean-Philippe Duchesne
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-27 00:00:00.000000000 Z
+date: 2026-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -207,7 +207,6 @@ files:
 - lib/generators/templates/rspock_initializer.rb
 - lib/minitest/rspock_plugin.rb
 - lib/rspock.rb
-- lib/rspock/ast/comparison_to_assertion_transformation.rb
 - lib/rspock/ast/header_nodes_transformation.rb
 - lib/rspock/ast/interaction_to_block_identity_assertion_transformation.rb
 - lib/rspock/ast/interaction_to_mocha_mock_transformation.rb
@@ -218,10 +217,12 @@ files:
 - 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/statement_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/statement_to_assertion_transformation.rb
 - lib/rspock/ast/test_method_def_transformation.rb
 - lib/rspock/ast/test_method_dstr_transformation.rb
 - lib/rspock/ast/test_method_transformation.rb

data/lib/rspock/ast/comparison_to_assertion_transformation.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-require 'ast_transform/abstract_transformation'
-require 'rspock/ast/method_call_to_lvar_transformation'
-
-module RSpock
-  module AST
-    class ComparisonToAssertionTransformation < ASTTransform::AbstractTransformation
-      def initialize(*ignored_method_call_symbols)
-        @method_call_transformation = RSpock::AST::MethodCallToLVarTransformation.new(*ignored_method_call_symbols)
-      end
-
-      def on_send(node)
-        if node.children.count == 3 && node.children[1] == :== && ignored_method_call_node?(node)
-          transform_to_assert_equal(node)
-        elsif node.children.count == 3 && node.children[1] == :!= && ignored_method_call_node?(node)
-          transform_to_refute_equal(node)
-        else
-          node.updated(nil, process_all(node))
-        end
-      end
-
-      private
-
-      def ignored_method_call_node?(node)
-        return false unless node.is_a?(::Parser::AST::Node)
-
-        !@method_call_transformation.method_call_node?(node.children[0]) &&
-          !@method_call_transformation.method_call_node?(node.children[2])
-      end
-
-      def transform_to_assert_equal(node)
-        node.updated(nil, [nil, :assert_equal, node.children[2], node.children[0]])
-      end
-
-      def transform_to_refute_equal(node)
-        node.updated(nil, [nil, :refute_equal, node.children[2], node.children[0]])
-      end
-    end
-  end
-end