state_machines 0.200.0 → 0.202.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10897c2b3fdaea1f4728eb063c09f7996c6164f938d814dc486c746c4e91c081
-  data.tar.gz: e7e89af7bfa089d2f1a7c7324f028223e530231e808e34398a2665c11992c168
+  metadata.gz: e579c5afa633f1402bfd1e1a5ebd0c446ff410eb3b06940d74dce0d0e024f530
+  data.tar.gz: 629c2f403c71e966e98c5d35c64fa8ffa99caaa8e5aced5e205a569eb867e811
 SHA512:
-  metadata.gz: cb901d7e14ae688dbfec57c312a6edc338156dc0b239a9f56f6898443bbb3ed33e1aad85a260b5ab6c6aa21f3513fdac1e19f24b09418d8994be6f6f80a50a41
-  data.tar.gz: ca11e59b75a28e0c3a9f27fae6a9ac194082a9a1a034d1160050f21c8645f69111e6179e64c5d0048143f5d095f789207372c9d2ef3b3d2a0a07e10cd154438d
+  metadata.gz: 1bf56f62b3f6e495fc799ba48d499c0bb7325dfdb3c24d1f8aafc2c9daaade581bef63495e8562a633ee32d2ca3870e8e8131052d97bb152c793ab86f0a3c0fb
+  data.tar.gz: f2ae6e891727b60a4310160fbfa7044b4b949a8bccb9f8f80d7d3733dda6e528bf14f3449e7ab420b35d84ef971a6e6349e43a162e16b735e0be61e2ae7571be

data/lib/state_machines/async_mode/async_events.rb

@@ -114,8 +114,7 @@ module StateMachines
         end
 
         Async do
-          # Use the bang version which raises exceptions on failure
-          machine.events[event_name].fire(self, *args) || raise(StateMachines::InvalidTransition.new(self, machine, event_name))
+          fire_with_bang(machine, event_name, *args)
         end
       end
 
@@ -140,11 +139,11 @@ module StateMachines
 
         if defined?(::Async::Task) && ::Async::Task.current?
           # Already in async context, just fire directly with bang behavior
-          machine.events[event_name].fire(self, *args) || raise(StateMachines::InvalidTransition.new(self, machine, event_name))
+          fire_with_bang(machine, event_name, *args)
         else
           # Create async context and wait for result (may raise exception)
           Async do
-            machine.events[event_name].fire(self, *args) || raise(StateMachines::InvalidTransition.new(self, machine, event_name))
+            fire_with_bang(machine, event_name, *args)
           end.wait
         end
       end
@@ -199,6 +198,11 @@ module StateMachines
 
       private
 
+      # Fires the event on the given machine, raising InvalidTransition on failure
+      def fire_with_bang(machine, event_name, *)
+        machine.events[event_name].fire(self, *) || raise(StateMachines::InvalidTransition.new(self, machine, event_name))
+      end
+
       # Check if this event method should have async versions
       def async_method_for_event?(event_method)
         # Find which machine contains this event

data/lib/state_machines/machine/utilities.rb

@@ -55,6 +55,33 @@ module StateMachines
         target.method_defined?(method) || target.private_method_defined?(method)
       end
 
+      # Generates the warning message for a method conflict, including where
+      # the conflicting method was defined (when it has a Ruby source
+      # location) and which class the state machine is being defined on
+      def method_conflict_message(scope, method, defined_in)
+        scope_label = scope == :class ? 'Class' : 'Instance'
+        defined_in_name = defined_in.name && !defined_in.name.empty? ? defined_in.name : defined_in.to_s
+        location = conflicting_method_location(scope, method, defined_in)
+        location_label = location ? " at #{location[0]}:#{location[1]}" : ''
+
+        "#{scope_label} method \"#{method}\" is already defined in #{defined_in_name}#{location_label}, " \
+          'use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true. ' \
+          "Defining #{name.inspect} state machine on #{owner_class}."
+      end
+
+      # Looks up the source location of the conflicting method.  Returns nil
+      # for methods without a Ruby source (e.g. C-defined methods like
+      # Kernel#fail) and for the machine's own helper modules, where the
+      # location would just point inside this gem
+      def conflicting_method_location(scope, method, defined_in)
+        return if @helper_modules.value?(defined_in)
+
+        target = scope == :class && defined_in.is_a?(Class) ? defined_in.singleton_class : defined_in
+        target.instance_method(method).source_location
+      rescue NameError
+        nil
+      end
+
       # Pluralizes the given word using #pluralize (if available) or simply
       # adding an "s" to the end of the word
       def pluralize(word)

data/lib/state_machines/machine.rb

@@ -355,7 +355,7 @@ module StateMachines
   # module that gets included in every Object.  As a result, state_machine will
   # generate the following warning:
   #
-  #   Instance method "open" is already defined in Object, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.
+  #   Instance method "open" is already defined in Object, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true. Defining :state state machine on Vehicle.
   #
   # Even though you may not be using Kernel's implementation of the "open"
   # instance method, state_machine isn't aware of this and, as a result, stays
@@ -517,8 +517,7 @@ module StateMachines
 
       if block_given?
         if !self.class.ignore_method_conflicts && (conflicting_ancestor = owner_class_ancestor_has_method?(scope, method))
-          ancestor_name = conflicting_ancestor.name && !conflicting_ancestor.name.empty? ? conflicting_ancestor.name : conflicting_ancestor.to_s
-          warn "#{scope == :class ? 'Class' : 'Instance'} method \"#{method}\" is already defined in #{ancestor_name}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true."
+          warn method_conflict_message(scope, method, conflicting_ancestor)
         else
           name = self.name
           helper_module.class_eval do

data/lib/state_machines/state.rb

@@ -289,8 +289,8 @@ module StateMachines
     def add_predicate
       predicate_method = "#{qualified_name}?"
 
-      if machine.send(:owner_class_ancestor_has_method?, :instance, predicate_method)
-        warn_about_method_conflict(predicate_method, machine.owner_class.ancestors.first)
+      if (conflicting_ancestor = machine.send(:owner_class_ancestor_has_method?, :instance, predicate_method))
+        warn_about_method_conflict(predicate_method, conflicting_ancestor)
       elsif machine.send(:owner_class_has_method?, :instance, predicate_method)
         warn_about_method_conflict(predicate_method, machine.owner_class)
       else
@@ -308,7 +308,7 @@ module StateMachines
     def warn_about_method_conflict(method, defined_in)
       return if StateMachines::Machine.ignore_method_conflicts
 
-      warn "Instance method #{method.inspect} is already defined in #{defined_in.inspect}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true."
+      warn machine.send(:method_conflict_message, :instance, method, defined_in)
     end
   end
 end

data/lib/state_machines/transition.rb

@@ -346,6 +346,19 @@ module StateMachines
       !halted
     end
 
+    # Completes a transition whose before phase has already run by executing
+    # its after callbacks, resuming any paused around callbacks first.  Used
+    # to finish transitions that were stored for deferred completion (e.g.
+    # generated mid-action from an event attribute) once their action has
+    # succeeded.
+    def complete_deferred_after_callbacks
+      if paused?
+        run_callbacks(after: true)
+      else
+        after
+      end
+    end
+
     private
 
     # Runs a block that may get paused.  If the block doesn't pause, then
@@ -394,9 +407,7 @@ module StateMachines
       else
         # Capture current fiber's Thread.current storage to preserve object identity
         # This is needed for compatibility but has limitations with dynamic assignments
-        parent_fiber_locals = Thread.current.keys.each_with_object({}) do |key, storage|
-          storage[key] = Thread.current[key]
-        end
+        parent_fiber_locals = capture_thread_locals
 
         # Create a new fiber to run the block
         fiber = Fiber.new do
@@ -415,11 +426,7 @@ module StateMachines
             end
 
             # Export the final thread storage state along with the result
-            thread_storage = Thread.current.keys.each_with_object({}) do |key, storage|
-              storage[key] = Thread.current[key]
-            end
-
-            [halted ? :halted : :completed, thread_storage]
+            [halted ? :halted : :completed, capture_thread_locals]
           rescue StandardError => e
             # Store the exception for re-raising
             [:error, e]
@@ -446,6 +453,14 @@ module StateMachines
       end
     end
 
+    # Snapshots the current fiber's Thread.current storage, preserving object
+    # identity of the stored values
+    def capture_thread_locals
+      Thread.current.keys.each_with_object({}) do |key, storage|
+        storage[key] = Thread.current[key]
+      end
+    end
+
     # Unwraps a result returned from a pausable fiber, re-raising any exception
     # captured inside the fiber and importing its exported thread storage
     def unwrap_fiber_result(result)

data/lib/state_machines/transition_collection.rb

@@ -257,11 +257,38 @@ module StateMachines
             object.instance_variable_set(:@_state_machine_event_transitions, transitions_by_machine)
           end
         end
+
+        # Complete any transitions that other machines generated mid-action
+        # (e.g. an event attribute set in a before callback and picked up by
+        # the validation cycle) so their after callbacks run in this same
+        # action cycle instead of leaking into the next one (issue #91)
+        complete_nested_transitions unless skip_after
       else
         super
       end
     end
 
+    # Completes transitions that were stored for deferred completion by
+    # machines outside this collection while the action was running.  Their
+    # before callbacks and state persistence already happened mid-action;
+    # only their after callbacks remain.  Clears the stored references so
+    # they cannot leak into a later action cycle with stale data (issue #91).
+    def complete_nested_transitions
+      return if empty? || !success?
+
+      pending = object.instance_variable_get(:@_state_machine_event_transitions)
+      return unless pending
+
+      machines = map(&:machine)
+      pending.each_value do |transition|
+        next if machines.include?(transition.machine)
+
+        transition.machine.write(object, :event_transition, nil)
+        transition.complete_deferred_after_callbacks
+      end
+      object.instance_variable_set(:@_state_machine_event_transitions, nil)
+    end
+
     # Tracks that before callbacks have now completed
     def persist
       @before_run = true

data/lib/state_machines/version.rb

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

metadata

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