state_machines 0.50.0 → 0.100.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 247ae1ee6fa7beb6ac29a68dfd400ea41a3923b973d842a5adb2ef78960b3266
-  data.tar.gz: 7240a29d3d87740ade0d0197e9c4c0192176023f23e453d1ba659e8be905afef
+  metadata.gz: c2e1765c263d1be7747cf812e195b95ab82d183dbf62d83a4014bc47e34132ee
+  data.tar.gz: 35fc3eba5b2a7321436de83091467b0f9e65309356e7d948479acd46be85ee68
 SHA512:
-  metadata.gz: 26e8c0a197cdc254c4157a57e3bcfabfef87240280555ae623d993e30ccb68ba6433e911da171f60beb0e756af54aa60ff18395c9d49c6719a06b22bd895bdca
-  data.tar.gz: 9dfbdceba5b428f415dfeeba91995ab52640282b2b6c2fb92dea266c97677263331706e6b37f09a6280dc3f578da27dae1f5ade628a655342e46c565ddbe05db
+  metadata.gz: 7b76d0c6596909901ccbeedf46b581b0fda2289466ae9c0bd402dc8b40db7d39fe74cbe7792a3b49c439e920ac6dd92c6bedfb51236155a3d0e61b0d7a84db51
+  data.tar.gz: 887b286630bd17fb51c9b00550ee3c6822fd3d1b0c2084630d4cf3e960c66abda12962e050bd09c1829e7091694d120378ad15607ba02f1f2594518b15173976

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

@@ -94,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,

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_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.50.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.50.0
+  version: 0.100.0
 platform: ruby
 authors:
 - Abdelkader Boudih