stepper_motor 0.1.16 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b94d7f405351309bd1fbda83b352031795cbee87aad100d412d847e3d03543c
-  data.tar.gz: 59ecde85caacac0c7e65f6a0c527676bac4700b84fa39ce55443e81592023738
+  metadata.gz: 2b4b58accbed9841696bb2d0296335863b71b26b9a33a457028cc4c834ec1fec
+  data.tar.gz: c0f6e6fda44e9d8c7808743e425a059e2a8c1196fc4fcd1fcb6240521d8b5bbf
 SHA512:
-  metadata.gz: 5305f1f98eb8b8c630e45309280fae524ec458d15a75362e647a36e22fd29ca0fe1a7ecbbba186ed60f33b64b7b6b875e66878280e21a6a3196473652b82f098
-  data.tar.gz: 2e6db70cf8ad6b844c4d7a38eab6f087f785b1a112f446844e25d6d943bffd3f3b71da6bd7baa69c7249a7978a5538d2572235b3f90475b01af8be0d07074cfd
+  metadata.gz: 2b3aa12d9c21cf9f5e8246bce6fa8d88bfaeea046ad434ada641c7c0e1ce62cba173584fd4c836c6e70d98468f1ebc70ce93ea0246fb40ed3992ea45a97328f2
+  data.tar.gz: ae3fb23fc0f81f3a92e63abf6a6b444a801421c388ed3ef3a7e6ff23562a74bca218d3b257cb7a6dfa896e383d4e093bd990f67209f4ca41936598db91e680a9

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [0.1.18] - 2025-06-20
+
+- Add `cancel_if` at Journey class level for blanket journey cancellation conditions. This makes it very easy to abort journeys across multiple steps.
+
+## [0.1.17] - 2025-06-20
+
+- Mandate Ruby 3.1+ because we are using 3.x syntax and there are shenanigans with sqlite3 gem version and locking. Compatibility with 2.7 can be assured but is too much hassle at the moment.
+  If you need this compatibility, feel free to implement it or contact me for a quote.
+  
 ## [0.1.16] - 2025-06-20
 
 - Add `skip!` flow control method to skip the current (or next) step and move on to the subsequent step, or finish the journey.

data/lib/stepper_motor/conditional.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module StepperMotor
+  # A wrapper for conditional logic that can be evaluated against an object.
+  # This class encapsulates different types of conditions (booleans, symbols, callables, arrays)
+  # and provides a unified interface for checking if a condition is satisfied by a given object.
+  # It handles negation and ensures proper context when evaluating conditions.
+  class Conditional
+    def initialize(condition, negate: false)
+      @condition = condition
+      @negate = negate
+      validate_condition
+    end
+
+    def satisfied_by?(object)
+      result = case @condition
+      when Array
+        @condition.all? { |c| Conditional.new(c).satisfied_by?(object) }
+      when Symbol
+        !!object.send(@condition)
+      when Conditional
+        @condition.satisfied_by?(object)
+      else
+        if @condition.respond_to?(:call)
+          !!object.instance_exec(&@condition)
+        else
+          !!@condition
+        end
+      end
+
+      @negate ? !result : result
+    end
+
+    private
+
+    def validate_condition
+      unless [true, false, nil].include?(@condition) || @condition.is_a?(Symbol) || @condition.is_a?(Array) || @condition.is_a?(Conditional) || @condition.respond_to?(:call)
+        raise ArgumentError, "condition must be a boolean, nil, Symbol, Array, Conditional or a callable object, but was a #{@condition.inspect}"
+      end
+    end
+  end
+end

data/lib/stepper_motor/journey.rb

@@ -47,6 +47,9 @@ module StepperMotor
     # @return [Array<StepperMotor::Step>] the step definitions defined so far
     class_attribute :step_definitions, default: []
 
+    # @return [Array<StepperMotor::Conditional>] the cancel_if conditions defined for this journey class
+    class_attribute :cancel_if_conditions, default: []
+
     belongs_to :hero, polymorphic: true, optional: true
 
     STATES = %w[ready paused performing canceled finished]
@@ -92,19 +95,8 @@ module StepperMotor
         raise StepConfigurationError, "Either skip_if: or if: can be specified, but not both"
       end
       if additional_step_definition_options.key?(:if)
-        if_condition = additional_step_definition_options.delete(:if)
-        # Convert if: to skip_if: by negating either the actual value or the return value of the callable
-        # if: truthy means perform, skip_if: truthy means "skip"
-        additional_step_definition_options[:skip_if] = case if_condition
-        when true, false, nil
-          !if_condition
-        when Symbol
-          # For symbols, we need to create a proc that negates the result
-          -> { !send(if_condition) }
-        else
-          # For callables, we need to create a proc that negates the result
-          -> { !instance_exec(&if_condition) }
-        end
+        # Convert if: to skip_if:
+        additional_step_definition_options[:skip_if] = StepperMotor::Conditional.new(additional_step_definition_options.delete(:if), negate: true)
       end
 
       wait = if wait && after
@@ -166,6 +158,41 @@ module StepperMotor
       self.class.lookup_step_definition(by_step_name)
     end
 
+    # Defines a condition that will cause the journey to cancel if satisfied.
+    # This works like Rails' `etag` - it's class-inheritable and appendable.
+    # Multiple `cancel_if` calls can be made to a Journey definition.
+    # All conditions are evaluated after setting the state to `performing`.
+    # If any condition is satisfied, the journey will cancel.
+    #
+    # @param condition_arg [TrueClass, FalseClass, Symbol, Proc, Array, Conditional] the condition to check
+    # @param condition_blk [Proc] a block that will be evaluated as a condition
+    # @return [void]
+    def self.cancel_if(condition_arg = :__no_argument_given__, &condition_blk)
+      # Check if neither argument nor block is provided
+      if condition_arg == :__no_argument_given__ && !condition_blk
+        raise ArgumentError, "cancel_if requires either a condition argument or a block"
+      end
+
+      # Check if both argument and block are provided
+      if condition_arg != :__no_argument_given__ && condition_blk
+        raise ArgumentError, "cancel_if accepts either a condition argument or a block, but not both"
+      end
+
+      # Select the condition: positional argument takes precedence if not sentinel
+      condition = if condition_arg != :__no_argument_given__
+        condition_arg
+      else
+        condition_blk
+      end
+
+      conditional = StepperMotor::Conditional.new(condition)
+
+      # As per Rails docs: you need to be aware when using class_attribute with mutable structures
+      # as Array or Hash. In such cases, you don't want to do changes in place. Instead use setters.
+      # See https://apidock.com/rails/v7.1.3.2/Class/class_attribute
+      self.cancel_if_conditions = cancel_if_conditions + [conditional]
+    end
+
     # Performs the next step in the journey. Will check whether any other process has performed the step already
     # and whether the record is unchanged, and will then lock it and set the state to 'performimg'.
     #
@@ -188,6 +215,14 @@ module StepperMotor
         performing!
         after_locking_for_step(next_step_name)
       end
+
+      # Check cancel_if conditions after setting state to performing
+      if cancel_if_conditions.any? { |conditional| conditional.satisfied_by?(self) }
+        logger.info { "cancel_if condition satisfied, canceling journey" }
+        cancel!
+        return
+      end
+
       current_step_name = next_step_name
 
       if current_step_name

data/lib/stepper_motor/step.rb

@@ -36,12 +36,7 @@ class StepperMotor::Step
     @wait = wait
     @seq = seq
     @on_exception = on_exception # TODO: Validate?
-    @skip_if_condition = skip_if
-
-    # Validate the skip_if condition
-    if ![true, false, nil].include?(@skip_if_condition) && !@skip_if_condition.is_a?(Symbol) && !@skip_if_condition.respond_to?(:call)
-      raise ArgumentError, "skip_if: condition must be a boolean, nil, Symbol or a callable object, but was a #{@skip_if_condition.inspect}"
-    end
+    @skip_if_condition = StepperMotor::Conditional.new(skip_if)
   end
 
   # Checks if the step should be skipped based on the skip_if condition
@@ -49,14 +44,7 @@ class StepperMotor::Step
   # @param journey[StepperMotor::Journey] the journey to check the condition for
   # @return [Boolean] true if the step should be skipped, false otherwise
   def should_skip?(journey)
-    case @skip_if_condition
-    when true, false, nil
-      !!@skip_if_condition
-    when Symbol
-      journey.send(@skip_if_condition) # Allow private methods
-    else
-      journey.instance_exec(&@skip_if_condition)
-    end
+    @skip_if_condition.satisfied_by?(journey)
   end
 
   # Performs the step on the passed Journey, wrapping the step with the required context.

data/lib/stepper_motor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StepperMotor
-  VERSION = "0.1.16"
+  VERSION = "0.1.18"
 end

data/lib/stepper_motor.rb

@@ -13,6 +13,7 @@ module StepperMotor
 
   autoload :Journey, File.dirname(__FILE__) + "/stepper_motor/journey.rb"
   autoload :Step, File.dirname(__FILE__) + "/stepper_motor/step.rb"
+  autoload :Conditional, File.dirname(__FILE__) + "/stepper_motor/conditional.rb"
 
   autoload :BaseJob, File.dirname(__FILE__) + "/stepper_motor/base_job.rb"
   autoload :PerformStepJob, File.dirname(__FILE__) + "/stepper_motor/perform_step_job.rb"

data/manual/MANUAL.md

@@ -515,6 +515,123 @@ It is possible to store instance variables on the `Journey` instance, but they d
 > This means that the volatile state such as instance variables is not going to be available between steps. Always assume that
 > the `Journey` you are inside of does not have any instance variables set by previous steps and has just been freshly loaded from the database.
 
+### Blanket step conditions with `cancel_if`
+
+In addition to conditional steps that can be skipped, you can define blanket conditions that apply to all steps in a journey using `cancel_if`. These conditions are evaluated after the journey's state is set to `performing` but before any step execution begins. If any `cancel_if` condition is satisfied, the entire journey is canceled immediately.
+
+`cancel_if` works like Rails' `etag` - it's class-inheritable and appendable. You can call `cancel_if` multiple times in a journey definition, and all conditions will be evaluated.
+
+#### Using blocks with `cancel_if`
+
+The most common way to use `cancel_if` is with a block that gets evaluated in the context of the journey:
+
+```ruby
+class UserOnboardingJourney < StepperMotor::Journey
+  cancel_if { hero.deactivated? }
+  cancel_if { hero.account_closed? }
+
+  step :send_welcome_email do
+    WelcomeMailer.welcome(hero).deliver_later
+  end
+
+  step :send_premium_offer, wait: 2.days do
+    PremiumOfferMailer.exclusive_offer(hero).deliver_later
+  end
+
+  step :complete_onboarding, wait: 7.days do
+    hero.update!(onboarding_completed_at: Time.current)
+  end
+end
+```
+
+In this example, if the user becomes deactivated or closes their account at any point during the onboarding journey, the entire journey will be canceled and no further steps will be executed.
+
+#### Using positional arguments with `cancel_if`
+
+You can also pass conditions directly as arguments to `cancel_if`:
+
+```ruby
+class PaymentProcessingJourney < StepperMotor::Journey
+  cancel_if :payment_canceled?
+  cancel_if { hero.amount > 10000 }  # Cancel if amount exceeds limit
+
+  step :validate_payment do
+    PaymentValidator.validate(hero)
+  end
+
+  step :process_payment do
+    PaymentProcessor.charge(hero)
+  end
+
+  step :send_confirmation do
+    PaymentConfirmationMailer.confirm(hero).deliver_later
+  end
+
+  private
+
+  def payment_canceled?
+    hero.canceled_at.present?
+  end
+end
+```
+
+#### Supported condition types
+
+`cancel_if` accepts the same types of conditions as `skip_if`:
+
+* **Symbols**: Method names that return a boolean
+* **Blocks**: Callable blocks that return a boolean
+* **Booleans**: Literal `true` or `false` values
+* **Arrays**: Arrays of conditions (all must be true)
+* **Procs/Lambdas**: Callable objects
+* **Conditional objects**: `StepperMotor::Conditional` instances
+* **Nil**: Treated as `false` (doesn't cancel)
+
+#### Multiple `cancel_if` conditions
+
+You can define multiple `cancel_if` conditions, and any one of them being satisfied will cancel the journey:
+
+```ruby
+class EmailCampaignJourney < StepperMotor::Journey
+  cancel_if { hero.unsubscribed? }
+  cancel_if { hero.bounced? }
+  cancel_if { hero.complained? }
+  cancel_if { hero.deactivated? }
+
+  step :send_initial_email do
+    CampaignMailer.initial(hero).deliver_later
+  end
+
+  step :send_follow_up, wait: 3.days do
+    CampaignMailer.follow_up(hero).deliver_later
+  end
+
+  step :send_final_reminder, wait: 7.days do
+    CampaignMailer.final_reminder(hero).deliver_later
+  end
+end
+```
+
+#### Inheritance and appendability
+
+`cancel_if` conditions are class-inheritable and appendable, just like Rails' `etag`:
+
+```ruby
+class BaseJourney < StepperMotor::Journey
+  cancel_if { hero.deactivated? }
+end
+
+class PremiumUserJourney < BaseJourney
+  cancel_if { hero.subscription_expired? }  # Adds to parent's conditions
+
+  step :send_premium_content do
+    PremiumContentMailer.send_content(hero).deliver_later
+  end
+end
+```
+
+In this example, `PremiumUserJourney` will cancel if either the user is deactivated (from the parent class) or if their subscription has expired (from the child class).
+
 
 ### Waiting for the start of the step
 

data/rbi/stepper_motor.rbi

@@ -2,7 +2,7 @@
 # StepperMotor is a module for building multi-step flows where steps are sequential and only
 # ever progress forward. The building block of StepperMotor is StepperMotor::Journey
 module StepperMotor
-  VERSION = T.let("0.1.16", T.untyped)
+  VERSION = T.let("0.1.18", T.untyped)
   PerformStepJobV2 = T.let(StepperMotor::PerformStepJob, T.untyped)
   RecoverStuckJourneysJobV1 = T.let(StepperMotor::RecoverStuckJourneysJob, T.untyped)
 
@@ -124,6 +124,10 @@ module StepperMotor
     sig { returns(T.untyped) }
     def step_definitions; end
 
+    # _@return_ — the cancel_if conditions defined for this journey class
+    sig { returns(T::Array[StepperMotor::Conditional]) }
+    def cancel_if_conditions; end
+
     # sord duck - #to_f looks like a duck type, replacing with untyped
     # sord warn - ActiveSupport::Duration wasn't able to be resolved to a constant in this project
     # sord duck - #to_f looks like a duck type, replacing with untyped
@@ -173,6 +177,18 @@ module StepperMotor
     sig { params(by_step_name: T.untyped).returns(T.untyped) }
     def lookup_step_definition(by_step_name); end
 
+    # Defines a condition that will cause the journey to cancel if satisfied.
+    # This works like Rails' `etag` - it's class-inheritable and appendable.
+    # Multiple `cancel_if` calls can be made to a Journey definition.
+    # All conditions are evaluated after setting the state to `performing`.
+    # If any condition is satisfied, the journey will cancel.
+    # 
+    # _@param_ `condition_arg` — the condition to check
+    # 
+    # _@param_ `condition_blk` — a block that will be evaluated as a condition
+    sig { params(condition_arg: T.any(TrueClass, FalseClass, Symbol, Proc, T::Array[T.untyped], Conditional), condition_blk: T.untyped).void }
+    def self.cancel_if(condition_arg = :__no_argument_given__, &condition_blk); end
+
     # Performs the next step in the journey. Will check whether any other process has performed the step already
     # and whether the record is unchanged, and will then lock it and set the state to 'performimg'.
     # 
@@ -359,6 +375,25 @@ module StepperMotor
   class BaseJob < ActiveJob::Base
   end
 
+  # A wrapper for conditional logic that can be evaluated against an object.
+  # This class encapsulates different types of conditions (booleans, symbols, callables, arrays)
+  # and provides a unified interface for checking if a condition is satisfied by a given object.
+  # It handles negation and ensures proper context when evaluating conditions.
+  class Conditional
+    # sord omit - no YARD type given for "condition", using untyped
+    # sord omit - no YARD type given for "negate:", using untyped
+    sig { params(condition: T.untyped, negate: T.untyped).void }
+    def initialize(condition, negate: false); end
+
+    # sord omit - no YARD type given for "object", using untyped
+    sig { params(object: T.untyped).returns(T::Boolean) }
+    def satisfied_by?(object); end
+
+    # sord omit - no YARD return type given, using untyped
+    sig { returns(T.untyped) }
+    def validate_condition; end
+  end
+
   module TestHelper
     # Allows running a given Journey to completion, skipping across the waiting periods.
     # This is useful to evaluate all side effects of a Journey. The helper will ensure

data/sig/stepper_motor.rbs

@@ -112,6 +112,9 @@ module StepperMotor
     # _@see_ `Journey.step_definitions`
     def step_definitions: () -> untyped
 
+    # _@return_ — the cancel_if conditions defined for this journey class
+    def cancel_if_conditions: () -> ::Array[StepperMotor::Conditional]
+
     # sord duck - #to_f looks like a duck type, replacing with untyped
     # sord warn - ActiveSupport::Duration wasn't able to be resolved to a constant in this project
     # sord duck - #to_f looks like a duck type, replacing with untyped
@@ -155,6 +158,17 @@ module StepperMotor
     # _@see_ `Journey.lookup_step_definition`
     def lookup_step_definition: (untyped by_step_name) -> untyped
 
+    # Defines a condition that will cause the journey to cancel if satisfied.
+    # This works like Rails' `etag` - it's class-inheritable and appendable.
+    # Multiple `cancel_if` calls can be made to a Journey definition.
+    # All conditions are evaluated after setting the state to `performing`.
+    # If any condition is satisfied, the journey will cancel.
+    # 
+    # _@param_ `condition_arg` — the condition to check
+    # 
+    # _@param_ `condition_blk` — a block that will be evaluated as a condition
+    def self.cancel_if: (?(TrueClass | FalseClass | Symbol | Proc | ::Array[untyped] | Conditional) condition_arg) -> void
+
     # Performs the next step in the journey. Will check whether any other process has performed the step already
     # and whether the record is unchanged, and will then lock it and set the state to 'performimg'.
     # 
@@ -320,6 +334,22 @@ module StepperMotor
   class BaseJob < ActiveJob::Base
   end
 
+  # A wrapper for conditional logic that can be evaluated against an object.
+  # This class encapsulates different types of conditions (booleans, symbols, callables, arrays)
+  # and provides a unified interface for checking if a condition is satisfied by a given object.
+  # It handles negation and ensures proper context when evaluating conditions.
+  class Conditional
+    # sord omit - no YARD type given for "condition", using untyped
+    # sord omit - no YARD type given for "negate:", using untyped
+    def initialize: (untyped condition, ?negate: untyped) -> void
+
+    # sord omit - no YARD type given for "object", using untyped
+    def satisfied_by?: (untyped object) -> bool
+
+    # sord omit - no YARD return type given, using untyped
+    def validate_condition: () -> untyped
+  end
+
   module TestHelper
     # Allows running a given Journey to completion, skipping across the waiting periods.
     # This is useful to evaluate all side effects of a Journey. The helper will ensure

data/stepper_motor.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.summary = "Effortless step workflows that embed nicely inside Rails"
   spec.description = "Step workflows for Rails/ActiveRecord"
   spec.homepage = "https://steppermotor.dev"
-  spec.required_ruby_version = ">= 2.7.0"
+  spec.required_ruby_version = ">= 3.1.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 

data/test/stepper_motor/journey/cancel_if_test.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class CancelIfTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+  include SideEffects::TestHelper
+
+  test "cancel_if with block condition cancels journey when true" do
+    canceling_journey = create_journey_subclass do
+      cancel_if { true }
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if with block condition does not cancel journey when false" do
+    canceling_journey = create_journey_subclass do
+      cancel_if { false }
+
+      step do
+        SideEffects.touch! "should run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_produced_side_effects("should run") do
+      journey.perform_next_step!
+    end
+    assert journey.finished?
+  end
+
+  test "cancel_if with boolean argument cancels journey when true" do
+    canceling_journey = create_journey_subclass do
+      cancel_if true
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if with boolean argument does not cancel journey when false" do
+    canceling_journey = create_journey_subclass do
+      cancel_if false
+
+      step do
+        SideEffects.touch! "should run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_produced_side_effects("should run") do
+      journey.perform_next_step!
+    end
+    assert journey.finished?
+  end
+
+  test "cancel_if with symbol argument calls method on journey" do
+    canceling_journey = create_journey_subclass do
+      cancel_if :should_cancel?
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+
+      def should_cancel?
+        true
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if with symbol method call in block" do
+    canceling_journey = create_journey_subclass do
+      cancel_if { should_cancel? }
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+
+      def should_cancel?
+        true
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if with array argument cancels when all conditions are true" do
+    canceling_journey = create_journey_subclass do
+      cancel_if [true, true]
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if with array argument does not cancel when any condition is false" do
+    canceling_journey = create_journey_subclass do
+      cancel_if [true, false]
+
+      step do
+        SideEffects.touch! "should run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_produced_side_effects("should run") do
+      journey.perform_next_step!
+    end
+    assert journey.finished?
+  end
+
+  test "cancel_if with proc argument evaluates proc in journey context" do
+    proc_condition = -> { true }
+
+    canceling_journey = create_journey_subclass do
+      cancel_if proc_condition
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if with conditional object works correctly" do
+    conditional = StepperMotor::Conditional.new(true)
+
+    canceling_journey = create_journey_subclass do
+      cancel_if conditional
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if with nil argument does not cancel journey" do
+    canceling_journey = create_journey_subclass do
+      cancel_if nil
+
+      step do
+        SideEffects.touch! "should run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_produced_side_effects("should run") do
+      journey.perform_next_step!
+    end
+    assert journey.finished?
+  end
+
+  test "multiple cancel_if calls are all evaluated" do
+    canceling_journey = create_journey_subclass do
+      cancel_if false
+      cancel_if true
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if conditions are evaluated after setting state to performing" do
+    canceling_journey = create_journey_subclass do
+      cancel_if { performing? }
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = canceling_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if with no arguments and no block raises error" do
+    assert_raises(ArgumentError, "cancel_if requires either a condition argument or a block") do
+      create_journey_subclass do
+        cancel_if
+      end
+    end
+  end
+
+  test "cancel_if with both argument and block raises error" do
+    assert_raises(ArgumentError, "cancel_if accepts either a condition argument or a block, but not both") do
+      create_journey_subclass do
+        cancel_if true do
+          false
+        end
+      end
+    end
+  end
+
+  test "cancel_if conditions are class-inheritable" do
+    parent_journey = create_journey_subclass do
+      cancel_if true
+    end
+
+    child_journey = create_journey_subclass(parent_journey) do
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = child_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+
+  test "cancel_if conditions are appendable in subclasses" do
+    parent_journey = create_journey_subclass do
+      cancel_if false
+    end
+
+    child_journey = create_journey_subclass(parent_journey) do
+      cancel_if true
+
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = child_journey.create!
+    assert journey.ready?
+
+    assert_no_side_effects { journey.perform_next_step! }
+    assert journey.canceled?
+  end
+end

data/test/stepper_motor/wrap_conditional_test.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class WrapConditionalTest < ActiveSupport::TestCase
+  # Validate the skip_if condition
+  # if ![true, false, nil].include?(@skip_if_condition) && !@skip_if_condition.is_a?(Symbol) && !@skip_if_condition.respond_to?(:call)
+  #   raise ArgumentError, "skip_if: condition must be a boolean, nil, Symbol or a callable object, but was a #{@skip_if_condition.inspect}"
+  # end
+
+  test "wraps true without negate" do
+    conditional = StepperMotor::Conditional.new(true)
+    assert_equal true, conditional.satisfied_by?(nil)
+    assert_equal true, conditional.satisfied_by?("something")
+  end
+
+  test "wraps true with negate" do
+    conditional = StepperMotor::Conditional.new(true, negate: true)
+    assert_equal false, conditional.satisfied_by?(nil)
+    assert_equal false, conditional.satisfied_by?("something")
+  end
+
+  test "wraps false without negate" do
+    conditional = StepperMotor::Conditional.new(false)
+    assert_equal false, conditional.satisfied_by?(nil)
+    assert_equal false, conditional.satisfied_by?("something")
+  end
+
+  test "wraps false with negate" do
+    conditional = StepperMotor::Conditional.new(false, negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+    assert_equal true, conditional.satisfied_by?("something")
+  end
+
+  test "wraps nil without negate" do
+    conditional = StepperMotor::Conditional.new(nil)
+    assert_equal false, conditional.satisfied_by?(nil)
+    assert_equal false, conditional.satisfied_by?("something")
+  end
+
+  test "wraps nil with negate" do
+    conditional = StepperMotor::Conditional.new(nil, negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+    assert_equal true, conditional.satisfied_by?("something")
+  end
+
+  test "wraps multiple without negate" do
+    conditional = StepperMotor::Conditional.new([true, true])
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([true, false])
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([false, false])
+    assert_equal false, conditional.satisfied_by?(nil)
+  end
+
+  test "wraps multiple with proc" do
+    conditional = StepperMotor::Conditional.new([true, -> { true }])
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([true, -> { false }])
+    assert_equal false, conditional.satisfied_by?(nil)
+  end
+
+  test "wraps multiple with negate" do
+    conditional = StepperMotor::Conditional.new([true, true], negate: true)
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([true, false], negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([false, false], negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+  end
+
+  test "wraps callable without negate" do
+    conditional = StepperMotor::Conditional.new(-> { :foo })
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> {})
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> { false })
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> { true })
+    assert_equal true, conditional.satisfied_by?(nil)
+  end
+
+  test "wraps callable with negate" do
+    conditional = StepperMotor::Conditional.new(-> { :foo }, negate: true)
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> {}, negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> { false }, negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> { true }, negate: true)
+    assert_equal false, conditional.satisfied_by?(nil)
+  end
+
+  class Doer
+    def should_do?
+      true
+    end
+  end
+
+  class NotDoer
+    def should_do?
+      false
+    end
+  end
+
+  test "wraps method without negate" do
+    doer = Doer.new
+
+    conditional = StepperMotor::Conditional.new(:should_do?)
+    assert_equal true, conditional.satisfied_by?(doer)
+
+    not_doer = NotDoer.new
+    assert_equal false, conditional.satisfied_by?(not_doer)
+  end
+
+  test "wraps method with negate" do
+    doer = Doer.new
+
+    conditional = StepperMotor::Conditional.new(:should_do?, negate: true)
+    assert_equal false, conditional.satisfied_by?(doer)
+
+    not_doer = NotDoer.new
+    assert_equal true, conditional.satisfied_by?(not_doer)
+  end
+
+  test "wraps conditional without negate" do
+    inner_conditional = StepperMotor::Conditional.new(true)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional)
+
+    assert_equal true, outer_conditional.satisfied_by?(nil)
+    assert_equal true, outer_conditional.satisfied_by?("something")
+  end
+
+  test "wraps conditional with negate" do
+    inner_conditional = StepperMotor::Conditional.new(true)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional, negate: true)
+
+    assert_equal false, outer_conditional.satisfied_by?(nil)
+    assert_equal false, outer_conditional.satisfied_by?("something")
+  end
+
+  test "wraps negated conditional without negate" do
+    inner_conditional = StepperMotor::Conditional.new(true, negate: true)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional)
+
+    assert_equal false, outer_conditional.satisfied_by?(nil)
+    assert_equal false, outer_conditional.satisfied_by?("something")
+  end
+
+  test "wraps negated conditional with negate" do
+    inner_conditional = StepperMotor::Conditional.new(true, negate: true)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional, negate: true)
+
+    assert_equal true, outer_conditional.satisfied_by?(nil)
+    assert_equal true, outer_conditional.satisfied_by?("something")
+  end
+
+  test "wraps conditional with method" do
+    doer = Doer.new
+    inner_conditional = StepperMotor::Conditional.new(:should_do?)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional)
+
+    assert_equal true, outer_conditional.satisfied_by?(doer)
+
+    not_doer = NotDoer.new
+    assert_equal false, outer_conditional.satisfied_by?(not_doer)
+  end
+
+  test "wraps conditional with method and negate" do
+    doer = Doer.new
+    inner_conditional = StepperMotor::Conditional.new(:should_do?)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional, negate: true)
+
+    assert_equal false, outer_conditional.satisfied_by?(doer)
+
+    not_doer = NotDoer.new
+    assert_equal true, outer_conditional.satisfied_by?(not_doer)
+  end
+end

data/test/test_helper.rb

@@ -32,11 +32,12 @@ module JourneyDefinitionHelper
     super
   end
 
-  def create_journey_subclass(&blk)
+  def create_journey_subclass(parent_class = nil, &blk)
     # https://stackoverflow.com/questions/4113479/dynamic-class-definition-with-a-class-name
     random_component = @class_names_rng.hex(8)
     random_name = "JourneySubclass_#{random_component}"
-    klass = Class.new(StepperMotor::Journey, &blk)
+    parent_class ||= StepperMotor::Journey
+    klass = Class.new(parent_class, &blk)
     Object.const_set(random_name, klass)
     @dynamic_class_names << random_name
     klass

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stepper_motor
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.1.18
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -236,6 +236,7 @@ files:
 - lib/generators/stepper_motor_migration_005.rb.erb
 - lib/stepper_motor.rb
 - lib/stepper_motor/base_job.rb
+- lib/stepper_motor/conditional.rb
 - lib/stepper_motor/cyclic_scheduler.rb
 - lib/stepper_motor/delete_completed_journeys_job.rb
 - lib/stepper_motor/forward_scheduler.rb
@@ -309,6 +310,7 @@ files:
 - test/stepper_motor/cyclic_scheduler_test.rb
 - test/stepper_motor/forward_scheduler_test.rb
 - test/stepper_motor/housekeeping_job_test.rb
+- test/stepper_motor/journey/cancel_if_test.rb
 - test/stepper_motor/journey/exception_handling_test.rb
 - test/stepper_motor/journey/flow_control_test.rb
 - test/stepper_motor/journey/idempotency_test.rb
@@ -320,6 +322,7 @@ files:
 - test/stepper_motor/recover_stuck_journeys_job_test.rb
 - test/stepper_motor/recovery_test.rb
 - test/stepper_motor/test_helper_test.rb
+- test/stepper_motor/wrap_conditional_test.rb
 - test/stepper_motor_test.rb
 - test/test_helper.rb
 homepage: https://steppermotor.dev
@@ -337,7 +340,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="