state_machines 0.40.0 → 0.100.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc7dae3a88c68f1327da47debac2546fde7c4459346dbfefaabbc4bed5dc5554
-  data.tar.gz: 2fbfc7157580635bd546b9096138677d44b58a92578d6341667a1722c91ccb66
+  metadata.gz: c2e1765c263d1be7747cf812e195b95ab82d183dbf62d83a4014bc47e34132ee
+  data.tar.gz: 35fc3eba5b2a7321436de83091467b0f9e65309356e7d948479acd46be85ee68
 SHA512:
-  metadata.gz: 4b5ba6ecdeb4dd612c6865657e0a0b590d3fa67fed522359c7b388ab88401283d953d857fc73fab2fbeb97388c5bb71b5f4e125d70366a03547aea91b991ab35
-  data.tar.gz: 07c96c5556ae74d933de3cf1b132cfda9144404361cca87c24c14694e2158e5f0437d65a4ab08b857dca8ad0c453d7fdc674abeb770c528d7ec45e4b060c8ddd
+  metadata.gz: 7b76d0c6596909901ccbeedf46b581b0fda2289466ae9c0bd402dc8b40db7d39fe74cbe7792a3b49c439e920ac6dd92c6bedfb51236155a3d0e61b0d7a84db51
+  data.tar.gz: 887b286630bd17fb51c9b00550ee3c6822fd3d1b0c2084630d4cf3e960c66abda12962e050bd09c1829e7091694d120378ad15607ba02f1f2594518b15173976

data/README.md

@@ -36,6 +36,8 @@ Below is an example of many of the features offered by this plugin, including:
 * Namespaced states
 * Transition callbacks
 * Conditional transitions
+* Coordinated state management guards
+* Asynchronous state machines (async: true)
 * State-driven instance behavior
 * Customized state values
 * Parallel events
@@ -245,6 +247,206 @@ vehicle.alarm_state_name                        # => :active
 
 vehicle.fire_events!(:ignite, :enable_alarm)    # => StateMachines:InvalidParallelTransition: Cannot run events in parallel: ignite, enable_alarm
 
+# Coordinated State Management
+
+State machines can coordinate with each other using state guards, allowing transitions to depend on the state of other state machines within the same object. This enables complex system modeling where components are interdependent.
+
+## State Guard Options
+
+### Single State Guards
+
+* `:if_state` - Transition only if another state machine is in a specific state.
+* `:unless_state` - Transition only if another state machine is NOT in a specific state.
+
+```ruby
+class TorpedoSystem
+  state_machine :bay_doors, initial: :closed do
+    event :open do
+      transition closed: :open
+    end
+
+    event :close do
+      transition open: :closed
+    end
+  end
+
+  state_machine :torpedo_status, initial: :loaded do
+    event :fire_torpedo do
+      # Can only fire torpedo if bay doors are open
+      transition loaded: :fired, if_state: { bay_doors: :open }
+    end
+
+    event :reload do
+      # Can only reload if bay doors are closed (for safety)
+      transition fired: :loaded, unless_state: { bay_doors: :open }
+    end
+  end
+end
+
+system = TorpedoSystem.new
+system.fire_torpedo  # => false (bay doors are closed)
+
+system.open_bay_doors!
+system.fire_torpedo  # => true (bay doors are now open)
+```
+
+### Multiple State Guards
+
+* `:if_all_states` - Transition only if ALL specified state machines are in their respective states.
+* `:unless_all_states` - Transition only if NOT ALL specified state machines are in their respective states.
+* `:if_any_state` - Transition only if ANY of the specified state machines are in their respective states.
+* `:unless_any_state` - Transition only if NONE of the specified state machines are in their respective states.
+
+```ruby
+class StarshipBridge
+  state_machine :shields, initial: :down
+  state_machine :weapons, initial: :offline
+  state_machine :warp_core, initial: :stable
+
+  state_machine :alert_status, initial: :green do
+    event :red_alert do
+      # Red alert if ANY critical system needs attention
+      transition green: :red, if_any_state: { warp_core: :critical, shields: :down }
+    end
+
+    event :battle_stations do
+      # Battle stations only if ALL combat systems are ready
+      transition green: :battle, if_all_states: { shields: :up, weapons: :armed }
+    end
+  end
+end
+```
+
+## Error Handling
+
+State guards provide comprehensive error checking:
+
+```ruby
+# Referencing a non-existent state machine
+event :invalid, if_state: { nonexistent_machine: :some_state }
+# => ArgumentError: State machine 'nonexistent_machine' is not defined for StarshipBridge
+
+# Referencing a non-existent state
+event :another_invalid, if_state: { shields: :nonexistent_state }
+# => ArgumentError: State 'nonexistent_state' is not defined in state machine 'shields'
+```
+
+# Asynchronous State Machines
+
+State machines can operate asynchronously for high-performance applications. This is ideal for I/O-bound tasks, such as in web servers or other concurrent environments, where you don't want a long-running state transition (like one involving a network call) to block the entire thread.
+
+This feature is powered by the [async](https://github.com/socketry/async) gem and uses `concurrent-ruby` for enterprise-grade thread safety.
+
+## Platform Compatibility
+
+**Supported Platforms:**
+* MRI Ruby (CRuby) 3.2+
+* Other Ruby engines with full Fiber scheduler support
+
+**Unsupported Platforms:**
+* JRuby - Falls back to synchronous mode with warnings
+* TruffleRuby - Falls back to synchronous mode with warnings
+
+## Basic Async Usage
+
+Enable async mode by adding `async: true` to your state machine declaration:
+
+```ruby
+class AutonomousDrone < StarfleetShip
+  # Async-enabled state machine for autonomous operation
+  state_machine :status, async: true, initial: :docked do
+    event :launch do
+      transition docked: :flying
+    end
+
+    event :land do
+      transition flying: :docked
+    end
+  end
+
+  # Mixed configuration: some machines async, others sync
+  state_machine :teleporter_status, async: true, initial: :offline do
+    event :power_up do
+      transition offline: :charging
+    end
+
+    event :teleport do
+      transition ready: :teleporting
+    end
+  end
+
+  # Weapons remain synchronous for safety
+  state_machine :weapons, initial: :disarmed do
+    event :arm do
+      transition disarmed: :armed
+    end
+  end
+end
+```
+
+## Async Event Methods
+
+Async-enabled machines automatically generate async versions of event methods:
+
+```ruby
+drone = AutonomousDrone.new
+
+# Within an Async context
+Async do
+  # Async event firing - returns Async::Task
+  task = drone.launch_async
+  result = task.wait  # => true
+
+  # Bang methods for strict error handling
+  drone.power_up_async!  # => Async::Task (raises on failure)
+
+  # Generic async event firing
+  drone.fire_event_async(:teleport)  # => Async::Task
+end
+
+# Outside Async context - raises error
+drone.launch_async  # => RuntimeError: launch_async must be called within an Async context
+```
+
+## Thread Safety
+
+Async state machines use enterprise-grade thread safety with `concurrent-ruby`:
+
+```ruby
+# Concurrent operations are automatically thread-safe
+threads = []
+10.times do
+  threads << Thread.new do
+    Async do
+      drone.launch_async.wait
+      drone.land_async.wait
+    end
+  end
+end
+threads.each(&:join)
+```
+
+## Performance Considerations
+
+* **Thread Safety**: Uses `Concurrent::ReentrantReadWriteLock` for optimal read/write performance.
+* **Memory**: Each async-enabled object gets its own mutex (lazy-loaded).
+* **Marshalling**: Objects with async state machines can be serialized (mutex excluded/recreated).
+* **Mixed Mode**: You can mix async and sync state machines in the same class.
+
+## Dependencies
+
+Async functionality requires:
+
+```ruby
+# Gemfile (automatically scoped to MRI Ruby)
+platform :ruby do
+  gem 'async', '>= 2.25.0'
+  gem 'concurrent-ruby', '>= 1.3.5'
+end
+```
+
+*Note: These gems are only installed on supported platforms. JRuby/TruffleRuby won't attempt installation.*
+
 # Human-friendly names can be accessed for states/events
 Vehicle.human_state_name(:first_gear)               # => "first gear"
 Vehicle.human_alarm_state_name(:active)             # => "active"

data/lib/state_machines/async_mode.rb

@@ -22,7 +22,7 @@ end
 
 # Load required gems with version constraints
 gem 'async', '>= 2.25.0'
-gem 'concurrent-ruby', '>= 1.3.5'  # Security is not negotiable - enterprise-grade thread safety required
+gem 'concurrent-ruby', '>= 1.3.5' # Security is not negotiable - enterprise-grade thread safety required
 
 require 'async'
 require 'concurrent-ruby'

data/lib/state_machines/branch.rb

@@ -34,6 +34,12 @@ module StateMachines
       # Build conditionals
       @if_condition = options.delete(:if)
       @unless_condition = options.delete(:unless)
+      @if_state_condition = options.delete(:if_state)
+      @unless_state_condition = options.delete(:unless_state)
+      @if_all_states_condition = options.delete(:if_all_states)
+      @unless_all_states_condition = options.delete(:unless_all_states)
+      @if_any_state_condition = options.delete(:if_any_state)
+      @unless_any_state_condition = options.delete(:unless_any_state)
 
       # Build event requirement
       @event_requirement = build_matcher(options, :on, :except_on)
@@ -88,6 +94,9 @@ module StateMachines
     def matches?(object, query = {})
       !match(object, query).nil?
     end
+    
+    # Alias for Minitest's assert_match
+    alias =~ matches?
 
     # Attempts to match the given object / query against the set of requirements
     # configured for this branch.  In addition to matching the event, from state,
@@ -182,21 +191,56 @@ module StateMachines
     # Verifies that the conditionals for this branch evaluate to true for the
     # given object. Event arguments are passed to guards that accept multiple parameters.
     def matches_conditions?(object, query, event_args = [])
-      case [query[:guard], if_condition, unless_condition]
-      in [false, _, _]
-        true
-      in [_, nil, nil]
-        true
-      in [_, if_conds, nil] if if_conds
-        Array(if_conds).all? { |condition| evaluate_method_with_event_args(object, condition, event_args) }
-      in [_, nil, unless_conds] if unless_conds
-        Array(unless_conds).none? { |condition| evaluate_method_with_event_args(object, condition, event_args) }
-      in [_, if_conds, unless_conds] if if_conds || unless_conds
-        Array(if_conds).all? { |condition| evaluate_method_with_event_args(object, condition, event_args) } &&
-          Array(unless_conds).none? { |condition| evaluate_method_with_event_args(object, condition, event_args) }
-      else
-        true
+      return true if query[:guard] == false
+
+      # Evaluate original if/unless conditions
+      if_passes = !if_condition || Array(if_condition).all? { |condition| evaluate_method_with_event_args(object, condition, event_args) }
+      unless_passes = !unless_condition || Array(unless_condition).none? { |condition| evaluate_method_with_event_args(object, condition, event_args) }
+
+      return false unless if_passes && unless_passes
+
+      # Consolidate all state guards
+      state_guards = {
+        if_state: @if_state_condition,
+        unless_state: @unless_state_condition,
+        if_all_states: @if_all_states_condition,
+        unless_all_states: @unless_all_states_condition,
+        if_any_state: @if_any_state_condition,
+        unless_any_state: @unless_any_state_condition
+      }.compact
+
+      return true if state_guards.empty?
+
+      validate_and_check_state_guards(object, state_guards)
+    end
+
+    private
+
+    def validate_and_check_state_guards(object, guards)
+      guards.all? do |guard_type, conditions|
+        case guard_type
+        when :if_state, :if_all_states
+          conditions.all? { |machine, state| check_state(object, machine, state) }
+        when :unless_state
+          conditions.none? { |machine, state| check_state(object, machine, state) }
+        when :if_any_state
+          conditions.any? { |machine, state| check_state(object, machine, state) }
+        when :unless_all_states
+          !conditions.all? { |machine, state| check_state(object, machine, state) }
+        when :unless_any_state
+          conditions.none? { |machine, state| check_state(object, machine, state) }
+        end
       end
     end
+
+    def check_state(object, machine_name, state_name)
+      machine = object.class.state_machines[machine_name]
+      raise ArgumentError, "State machine '#{machine_name}' is not defined for #{object.class.name}" unless machine
+
+      state = machine.states[state_name]
+      raise ArgumentError, "State '#{state_name}' is not defined in state machine '#{machine_name}'" unless state
+
+      state.matches?(object.send(machine_name))
+    end
   end
 end

data/lib/state_machines/eval_helpers.rb

@@ -114,12 +114,10 @@ module StateMachines
         # Input validation for string evaluation
         validate_eval_string(str)
 
-        case [block_given?, StateMachines::Transition.pause_supported?]
-        in [true, true]
-          eval(str, object.instance_eval { binding }, &block)
-        in [true, false]
-          # Support for JRuby and Truffle Ruby, which don't support binding blocks
-          # Need to check with @headius, if jruby 10 does now.
+        # Evaluate the string in the object's context
+        if block_given?
+          # TruffleRuby and some other implementations need special handling for blocks
+          # Create a temporary method to evaluate the string with block support
           eigen = class << object; self; end
           eigen.class_eval <<-RUBY, __FILE__, __LINE__ + 1
                 def __temp_eval_method__(*args, &b)
@@ -129,8 +127,8 @@ module StateMachines
           result = object.__temp_eval_method__(*args, &block)
           eigen.send(:remove_method, :__temp_eval_method__)
           result
-        in [false, _]
-          eval(str, object.instance_eval { binding })
+        else
+          object.instance_eval(str, __FILE__, __LINE__)
         end
       else
         raise ArgumentError, 'Methods must be a symbol denoting the method to call, a block to be invoked, or a string to be evaluated'

data/lib/state_machines/event.rb

@@ -104,7 +104,7 @@ module StateMachines
 
       # Only a certain subset of explicit options are allowed for transition
       # requirements
-      StateMachines::OptionsValidator.assert_valid_keys!(options, :from, :to, :except_from, :except_to, :if, :unless) if (options.keys - %i[from to on except_from except_to except_on if unless]).empty?
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :from, :to, :except_from, :except_to, :if, :unless, :if_state, :unless_state, :if_all_states, :unless_all_states, :if_any_state, :unless_any_state) if (options.keys - %i[from to on except_from except_to except_on if unless if_state unless_state if_all_states unless_all_states if_any_state unless_any_state]).empty?
 
       branches << branch = Branch.new(options.merge(on: name))
       @known_states |= branch.known_states

data/lib/state_machines/event_collection.rb

@@ -119,12 +119,12 @@ module StateMachines
       # TODO, simplify
       # First try the regular event_transition
       transition = machine.read(object, :event_transition)
-      
+
       # If not found and we have stored transitions by machine (issue #91)
       if !transition && (transitions_by_machine = object.instance_variable_get(:@_state_machine_event_transitions))
         transition = transitions_by_machine[machine.name]
       end
-      
+
       transition || if event_name = machine.read(object, :event)
                       if event = self[event_name.to_sym, :name]
                         event.transition_for(object) || begin

data/lib/state_machines/machine/async_extensions.rb

@@ -30,7 +30,7 @@ module StateMachines
 
             owner_class.include(StateMachines::AsyncMode::ThreadSafeState)
             owner_class.include(StateMachines::AsyncMode::AsyncEvents)
-            self.extend(StateMachines::AsyncMode::AsyncMachine)
+            extend(StateMachines::AsyncMode::AsyncMachine)
 
             # Extend events to generate async versions
             events.each do |event|

data/lib/state_machines/machine/class_methods.rb

@@ -31,9 +31,7 @@ module StateMachines
             machine.initial_state = options[:initial] if options.include?(:initial)
             machine.owner_class = owner_class
             # Configure async mode if requested in options
-            if options.include?(:async)
-              machine.configure_async_mode!(options[:async])
-            end
+            machine.configure_async_mode!(options[:async]) if options.include?(:async)
           end
 
           # Evaluate DSL

data/lib/state_machines/machine/configuration.rb

@@ -51,9 +51,7 @@ module StateMachines
         instance_eval(&) if block_given?
 
         # Configure async mode if requested, after owner_class is set and DSL is evaluated
-        if @async_requested
-          configure_async_mode!(true)
-        end
+        configure_async_mode!(true) if @async_requested
 
         self.initial_state = options[:initial] unless sibling_machines.any?
       end

data/lib/state_machines/machine.rb

@@ -565,8 +565,6 @@ module StateMachines
           end
         end
       else
-        # Validate string input before eval if method is a string
-        validate_eval_string(method) if method.is_a?(String)
         helper_module.class_eval(method, __FILE__, __LINE__)
       end
     end

data/lib/state_machines/test_helper.rb

@@ -749,7 +749,6 @@ module StateMachines
       has_async = object.respond_to?(async_method)
       has_async_bang = object.respond_to?(async_bang_method)
 
-      default_message = "Expected async event methods #{async_method} and #{async_bang_method} to be available for event :#{event}"
 
       if defined?(::Minitest)
         assert has_async, "Missing #{async_method} method"

data/lib/state_machines/transition.rb

@@ -30,19 +30,15 @@ module StateMachines
     # Whether the transition is only existing temporarily for the object
     attr_writer :transient
 
-    # Determines whether the current ruby implementation supports pausing and
-    # resuming transitions
-    def self.pause_supported?
-      %w[ruby maglev].include?(RUBY_ENGINE)
-    end
-
     # Creates a new, specific transition
     def initialize(object, machine, event, from_name, to_name, read_state = true) # :nodoc:
       @object = object
       @machine = machine
       @args = []
       @transient = false
-      @resume_block = nil
+      @paused_fiber = nil
+      @resuming = false
+      @continuation_block = nil
 
       @event = machine.events.fetch(event)
       @from_state = machine.states.fetch(from_name)
@@ -161,13 +157,13 @@ module StateMachines
     #   transition.perform(Time.now, run_action: false) # => Passes in additional arguments and only sets the state attribute
     def perform(*args)
       run_action = case args.last
-      in true | false
-        args.pop
-      in { run_action: }
-        args.last.delete(:run_action)
-      else
-        true
-      end
+                   in true | false
+                     args.pop
+                   in { run_action: }
+                     args.last.delete(:run_action)
+                   else
+                     true
+                   end
 
       self.args = args
 
@@ -195,14 +191,32 @@ module StateMachines
     # callbacks will not have an effect on the result.
     def run_callbacks(options = {}, &block)
       options = { before: true, after: true }.merge(options)
-      @success = false
 
-      halted = pausable { before(options[:after], &block) } if options[:before]
+      # If we have a paused fiber and we're not trying to resume (after: false),
+      # this is an idempotent call on an already-paused transition. Just return true.
+      return true if @paused_fiber&.alive? && !options[:after]
+
+      # Extract pausable options
+      pausable_options = options.key?(:fiber) ? { fiber: options[:fiber] } : {}
+
+      # Check if we're resuming from a pause
+      if @paused_fiber&.alive? && options[:after]
+        # Resume the paused fiber
+        # Don't reset @success when resuming - preserve the state from the pause
+        # Store the block for later execution
+        @continuation_block = block if block_given?
+        halted = pausable(pausable_options) { true }
+      else
+        @success = false
+        # For normal execution (not pause/resume), default to success
+        # The action block will override this if needed
+        halted = pausable(pausable_options) { before(options[:after], &block) } if options[:before]
+      end
 
       # After callbacks are only run if:
-      # * An around callback didn't halt after yielding
+      # * An around callback didn't halt after yielding OR the run failed
       # * They're enabled or the run didn't succeed
-      after if !(@before_run && halted) && (options[:after] || !@success)
+      after if (!(@before_run && halted) || !@success) && (options[:after] || !@success)
 
       @before_run
     end
@@ -266,7 +280,9 @@ module StateMachines
     # the state has already been persisted
     def reset
       @before_run = @persisted = @after_run = false
-      @paused_block = nil
+      @paused_fiber = nil
+      @resuming = false
+      @continuation_block = nil
     end
 
     # Determines equality of transitions by testing whether the object, states,
@@ -290,6 +306,38 @@ module StateMachines
       "#<#{self.class} #{%w[attribute event from from_name to to_name].map { |attr| "#{attr}=#{send(attr).inspect}" } * ' '}>"
     end
 
+    # Checks whether this transition is currently paused.
+    # Returns true if there is a paused fiber, false otherwise.
+    def paused?
+      @paused_fiber&.alive? || false
+    end
+
+    # Checks whether this transition has a paused fiber that can be resumed.
+    # Returns true if there is a paused fiber, false otherwise.
+    #
+    # Note: The actual resuming happens automatically when run_callbacks is called
+    # again on a transition with a paused fiber.
+    def resumable?
+      paused?
+    end
+
+    # Manually resumes the execution of a previously paused callback.
+    # Returns true if the transition was successfully resumed and completed,
+    # false if there was no paused fiber, and raises an exception if the
+    # transition was halted.
+    def resume!(&block)
+      return false unless paused?
+
+      # Store continuation block if provided
+      @continuation_block = block if block_given?
+
+      # Run the pausable block which will resume the fiber
+      halted = pausable { true }
+
+      # Return whether the transition completed successfully
+      !halted
+    end
+
     private
 
     # Runs a block that may get paused.  If the block doesn't pause, then
@@ -298,20 +346,97 @@ module StateMachines
     #
     # This will return true if the given block halts for a reason other than
     # getting paused.
-    def pausable
-      begin
+    #
+    # Options:
+    # * :fiber - Whether to use fiber-based execution (default: true)
+    def pausable(options = {})
+      # If fiber is disabled, use simple synchronous execution
+      if options[:fiber] == false
         halted = !catch(:halt) do
           yield
           true
         end
-      rescue StandardError => e
-        raise unless @resume_block
+        return halted
       end
 
-      if @resume_block
-        @resume_block.call(halted, e)
+      if @paused_fiber
+        # Resume the paused fiber
+        @resuming = true
+        begin
+          result = @paused_fiber.resume
+        rescue StandardError => e
+          # Clean up on exception
+          @resuming = false
+          @paused_fiber = nil
+          raise e
+        end
+        @resuming = false
+
+        # Handle different result types
+        case result
+        when Array
+          # Exception occurred inside the fiber
+          if result[0] == :error
+            # Clean up state before re-raising
+            @paused_fiber = nil
+            raise result[1]
+          end
+        else
+          # Normal flow
+          # Check if fiber is still alive after resume
+          if @paused_fiber.alive?
+            # Still paused, keep the fiber
+            true
+          else
+            # Fiber completed
+            @paused_fiber = nil
+            result == :halted
+          end
+        end
       else
-        halted
+        # Create a new fiber to run the block
+        fiber = Fiber.new do
+          # Mark that we're inside a pausable fiber
+          Thread.current[:state_machine_fiber_pausable] = true
+          begin
+            halted = !catch(:halt) do
+              yield
+              true
+            end
+            halted ? :halted : :completed
+          rescue StandardError => e
+            # Store the exception for re-raising
+            [:error, e]
+          ensure
+            # Clean up the flag
+            Thread.current[:state_machine_fiber_pausable] = false
+          end
+        end
+
+        # Run the fiber
+        result = fiber.resume
+
+        # Handle different result types
+        case result
+        when Array
+          # Exception occurred
+          if result[0] == :error
+            # Clean up state before re-raising
+            @paused_fiber = nil
+            raise result[1]
+          end
+        else
+          # Normal flow
+          # Save if paused
+          if fiber.alive?
+            @paused_fiber = fiber
+            # Return true to indicate paused (treated as halted for flow control)
+            true
+          else
+            # Fiber completed, return whether it was halted
+            result == :halted
+          end
+        end
       end
     end
 
@@ -319,34 +444,22 @@ module StateMachines
     # around callbacks when the remainder of the callback will be executed at
     # a later point in time.
     def pause
-      raise ArgumentError, 'around_transition callbacks cannot be called in multiple execution contexts in java implementations of Ruby. Use before/after_transitions instead.' unless self.class.pause_supported?
-
-      return if @resume_block
-
-      require 'continuation' unless defined?(callcc)
-      callcc do |block|
-        @paused_block = block
-        throw :halt, true
-      end
-    end
+      # Don't pause if we're in the middle of resuming
+      return if @resuming
 
-    # Resumes the execution of a previously paused callback execution.  Once
-    # the paused callbacks complete, the current execution will continue.
-    def resume
-      if @paused_block
-        halted, error = callcc do |block|
-          @resume_block = block
-          @paused_block.call
-        end
+      # Only yield if we're actually inside a fiber created by pausable
+      # We use a thread-local variable to track this
+      return unless Thread.current[:state_machine_fiber_pausable]
 
-        @resume_block = @paused_block = nil
+      Fiber.yield
 
-        raise error if error
+      # When we resume from the pause, execute the continuation block if present
+      return unless @continuation_block && !@result
 
-        !halted
-      else
-        true
-      end
+      action = { success: true }.merge(@continuation_block.call)
+      @result = action[:result]
+      @success = action[:success]
+      @continuation_block = nil
     end
 
     # Runs the machine's +before+ callbacks for this transition.  Only
@@ -356,36 +469,51 @@ module StateMachines
     # Once the callbacks are run, they cannot be run again until this transition
     # is reset.
     def before(complete = true, index = 0, &block)
-      unless @before_run
-        while callback = machine.callbacks[:before][index]
-          index += 1
+      return if @before_run
+
+      callback = machine.callbacks[:before][index]
 
+      if callback
+        # Check if callback matches this transition using branch
+        if callback.branch.matches?(object, context)
           if callback.type == :around
             # Around callback: need to handle recursively.  Execution only gets
             # paused if:
             # * The block fails and the callback doesn't run on failures OR
             # * The block succeeds, but after callbacks are disabled (in which
             #   case a continuation is stored for later execution)
-            return if catch(:cancel) do
-              callback.call(object, context, self) do
-                before(complete, index, &block)
+            callback.call(object, context, self) do
+              before(complete, index + 1, &block)
+
+              pause if @success && !complete
 
-                pause if @success && !complete
-                throw :cancel, true unless @success
-              end
+              # If the block failed (success is false), we should halt
+              # the around callback from continuing
+              throw :halt unless @success
             end
           else
             # Normal before callback
             callback.call(object, context, self)
+            # Continue with next callback
+            before(complete, index + 1, &block)
           end
+        else
+          # Skip to next callback if it doesn't match
+          before(complete, index + 1, &block)
+        end
+      else
+        # No more callbacks, execute the action block if at the end
+        if block_given?
+          action = { success: true }.merge(yield)
+          @result = action[:result]
+          @success = action[:success]
+        else
+          # No action block provided, default to success
+          @success = true
         end
 
         @before_run = true
       end
-
-      action = { success: true }.merge(block_given? ? yield : {})
-      @result = action[:result]
-      @success = action[:success]
     end
 
     # Runs the machine's +after+ callbacks for this transition.  Only
@@ -404,12 +532,9 @@ module StateMachines
     def after
       return if @after_run
 
-      # First resume previously paused callbacks
-      if resume
-        catch(:halt) do
-          type = @success ? :after : :failure
-          machine.callbacks[type].each { |callback| callback.call(object, context, self) }
-        end
+      catch(:halt) do
+        type = @success ? :after : :failure
+        machine.callbacks[type].each { |callback| callback.call(object, context, self) }
       end
 
       @after_run = true

data/lib/state_machines/transition_collection.rb

@@ -14,6 +14,9 @@ module StateMachines
     # Whether transitions should wrapped around a transaction block
     attr_reader :use_transactions
 
+    # Options passed to the collection
+    attr_reader :options
+
     # Creates a new collection of transitions that can be run in parallel.  Each
     # transition *must* be for a different attribute.
     #
@@ -26,16 +29,23 @@ module StateMachines
 
       # Determine the validity of the transitions as a whole
       @valid = all?
-      reject! { |transition| !transition }
+      reject!(&:!)
 
-      attributes = map { |transition| transition.attribute }.uniq
+      attributes = map(&:attribute).uniq
       raise ArgumentError, 'Cannot perform multiple transitions in parallel for the same state machine attribute' if attributes.length != length
 
-      StateMachines::OptionsValidator.assert_valid_keys!(options, :actions, :after, :use_transactions)
+      StateMachines::OptionsValidator.assert_valid_keys!(options, :actions, :after, :use_transactions, :fiber)
       options = { actions: true, after: true, use_transactions: true }.merge(options)
       @skip_actions = !options[:actions]
       @skip_after = !options[:after]
       @use_transactions = options[:use_transactions]
+      @options = options
+
+      # Reset transitions when creating a new collection
+      # But preserve paused transitions to allow resuming
+      each do |transition|
+        transition.reset unless transition.paused?
+      end
     end
 
     # Runs each of the collection's transitions in parallel.
@@ -104,7 +114,7 @@ module StateMachines
     # Gets the list of actions to run.  If configured to skip actions, then
     # this will return an empty collection.
     def actions
-      empty? ? [nil] : map { |transition| transition.action }.uniq
+      empty? ? [nil] : map(&:action).uniq
     end
 
     # Determines whether an event attribute be used to trigger the transitions
@@ -127,11 +137,21 @@ module StateMachines
     #
     # If any transition fails to run its callbacks, :halt will be thrown.
     def run_callbacks(index = 0, &block)
-      if transition = self[index]
-        throw :halt unless transition.run_callbacks(after: !skip_after) do
+      if (transition = self[index])
+        # Pass through any options that affect callback execution (e.g., fiber: false)
+        callback_options = { after: !skip_after }
+        callback_options[:fiber] = options[:fiber] if options.key?(:fiber)
+
+        callback_result = transition.run_callbacks(callback_options) do
           run_callbacks(index + 1, &block)
           { result: results[transition.action], success: success? }
         end
+
+        # If we're skipping after callbacks and the transition is paused,
+        # consider it successful (the pause was intentional)
+        @success = true if skip_after && transition.paused?
+
+        throw :halt unless callback_result
       else
         persist
         run_actions(&block)
@@ -141,7 +161,7 @@ module StateMachines
     # Transitions the current value of the object's states to those specified by
     # each transition
     def persist
-      each { |transition| transition.persist }
+      each(&:persist)
     end
 
     # Runs the actions for each transition.  If a block is given method, then it
@@ -163,7 +183,7 @@ module StateMachines
 
     # Rolls back changes made to the object's states via each transition
     def rollback
-      each { |transition| transition.rollback }
+      each(&:rollback)
     end
 
     # Wraps the given block with a rescue handler so that any exceptions that
@@ -202,14 +222,14 @@ module StateMachines
     # Hooks into running transition callbacks so that event / event transition
     # attributes can be properly updated
     def run_callbacks(index = 0)
-      if index == 0
+      if index.zero?
         # Clears any traces of the event attribute to prevent it from being
         # evaluated multiple times if actions are nested
         each do |transition|
           transition.machine.write(object, :event, nil)
           transition.machine.write(object, :event_transition, nil)
         end
-        
+
         # Clear stored transitions hash for new cycle (issue #91)
         if !empty? && (obj = first.object)
           obj.instance_variable_set(:@_state_machine_event_transitions, nil)
@@ -229,9 +249,9 @@ module StateMachines
         # after callbacks.
         if skip_after && success?
           each { |transition| transition.machine.write(object, :event_transition, transition) }
-          
+
           # Store transitions in a hash by machine name to avoid overwriting (issue #91)
-          if !empty?
+          unless empty?
             transitions_by_machine = object.instance_variable_get(:@_state_machine_event_transitions) || {}
             each { |transition| transitions_by_machine[transition.machine.name] = transition }
             object.instance_variable_set(:@_state_machine_event_transitions, transitions_by_machine)

data/lib/state_machines/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StateMachines
-  VERSION = '0.40.0'
+  VERSION = '0.100.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: state_machines
 version: !ruby/object:Gem::Version
-  version: 0.40.0
+  version: 0.100.0
 platform: ruby
 authors:
 - Abdelkader Boudih