state_machines 0.201.0 → 0.202.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcd3d5e6fc0f3982c8ddabc40480b43375d6e323957dd392ca4b3cc10f9c0f40
-  data.tar.gz: 89556aa64bb82045527f260098dd801acce298be5ad873ed7f250805b7839c87
+  metadata.gz: e579c5afa633f1402bfd1e1a5ebd0c446ff410eb3b06940d74dce0d0e024f530
+  data.tar.gz: 629c2f403c71e966e98c5d35c64fa8ffa99caaa8e5aced5e205a569eb867e811
 SHA512:
-  metadata.gz: d44ae6b303dc577db3ed8aa70d7132521b8be94c3651fa9afe886e90c7561ebea686d1c743adc9464d08bd01d2903a4e75eabf7aa567abacab81d0b1c889fea4
-  data.tar.gz: b04cbf3f1cb69b943fdf19aa91f37b3376f976c4ed28bd08ab4aed18af6473b3508c05fe52317f10f2627660a67a3e8c3e8481a520ba2985a5c7c37316499e51
+  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

@@ -407,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
@@ -428,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]
@@ -459,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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StateMachines
-  VERSION = '0.201.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.201.0
+  version: 0.202.0
 platform: ruby
 authors:
 - Abdelkader Boudih