state_machines-activemodel 0.9.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8bb31a6d52d73caf948365731b8670f86a57814d839c4606cd12c88b178f48f
-  data.tar.gz: c3f2f12fc7077f4fb230b08908314684fbbe7c59153cd12cc35dbacd767dd386
+  metadata.gz: ad141a5029b6489fb99da9c9ef4ad7bf2059d9947e993265225bb4ca88a0ff66
+  data.tar.gz: ef7ae48fd6d4d1f712842e2f0057158e5674b5ba59487cc3b0483c89524374e3
 SHA512:
-  metadata.gz: 8dd82a7786ea47d62fb36e04fd85be1451d1d37666702545bf9db2c0b13601d61ca65c1ab0b28844f64e7cdab82e62a1ea8221706b5d8342b003caa1fb8d9f08
-  data.tar.gz: 944d5c9ce3320e1f46e638c120ee2fcf4bd97f4c98ab3fad8e1598bc2fe2cd0a80ed2db61dc86535b551366c38108c4a007729eaeef4703e5a9e51c874921a2a
+  metadata.gz: 82b54e46bc9713fdda9c22701d4bec699c8065344bb32e10217dc730a0743b0296bb97245d38ffc8d3b18bd65c770058cb1485a723f2620d66051ce93ce4b106
+  data.tar.gz: 3ae6a52dd12a7c7ff56666fc9d691218f043ba2a0915d80262800a873589c0275a538d5b08ab956d046e23a3ba73e9c6d12ceb732ed0c75ee63d89cb77414b09

data/README.md

@@ -1,5 +1,4 @@
 ![Build Status](https://github.com/state-machines/state_machines-activemodel/actions/workflows/ruby.yml/badge.svg)
-[![Code Climate](https://codeclimate.com/github/state-machines/state_machines-activemodel.svg)](https://codeclimate.com/github/state-machines/state_machines-activemodel)
 
 # StateMachines ActiveModel Integration
 
@@ -23,7 +22,7 @@ Or install it yourself as:
 
 ## Dependencies
 
-Active Model 5.1+
+Active Model 7.1+
 
 ## Usage
 
@@ -36,19 +35,19 @@ class Vehicle
   attr_accessor :state
   define_attribute_methods [:state]
 
-  state_machine :initial => :parked do
-    before_transition :parked => any - :parked, :do => :put_on_seatbelt
-    after_transition any => :parked do |vehicle, transition|
+  state_machine initial: :parked do
+    before_transition parked: any - :parked, do: :put_on_seatbelt
+    after_transition any: :parked do |vehicle, transition|
       vehicle.seatbelt = 'off'
     end
     around_transition :benchmark
 
-    event :ignite do
-      transition :parked => :idling
+    event ignite: do
+      transition parked: :idling
     end
 
     state :first_gear, :second_gear do
-      validates_presence_of :seatbelt_on
+      validates :seatbelt_on, presence: true
     end
   end
 
@@ -62,24 +61,6 @@ class Vehicle
     ...
   end
 end
-
-class VehicleObserver < ActiveModel::Observer
-  # Callback for :ignite event *before* the transition is performed
-  def before_ignite(vehicle, transition)
-    # log message
-  end
-
-  # Generic transition callback *after* the transition is performed
-  def after_transition(vehicle, transition)
-    Audit.log(vehicle, transition)
-  end
-
-  # Generic callback after the transition fails to perform
-  def after_failure_to_transition(vehicle, transition)
-    Audit.error(vehicle, transition)
-  end
-end
-
 ```
 
 ## Contributing

data/lib/state_machines/integrations/active_model/locale.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
+# Use lazy evaluation to avoid circular dependencies with frozen default_messages
+# This ensures messages can be updated after gem loading while maintaining thread safety
 { en: {
   activemodel: {
     errors: {
       messages: {
-        invalid: StateMachines::Machine.default_messages[:invalid],
-        invalid_event: StateMachines::Machine.default_messages[:invalid_event] % ['%{state}'],
-        invalid_transition: StateMachines::Machine.default_messages[:invalid_transition] % ['%{event}']
+        invalid: lambda { |*| StateMachines::Machine.default_messages[:invalid] },
+        invalid_event: lambda { |*| StateMachines::Machine.default_messages[:invalid_event] % ['%{state}'] },
+        invalid_transition: lambda { |*| StateMachines::Machine.default_messages[:invalid_transition] % ['%{event}'] }
       }
     }
   }

data/lib/state_machines/integrations/active_model/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module StateMachines
   module Integrations
     module ActiveModel
-      VERSION = '0.9.0'
+      VERSION = '0.31.0'
     end
   end
 end

data/lib/state_machines/integrations/active_model.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/module/attribute_accessors.rb'
+require 'active_support/core_ext/module/attribute_accessors'
 require 'state_machines'
 require 'state_machines/integrations/base'
 require 'state_machines/integrations/active_model/version'
 
 module StateMachines
-  module Integrations #:nodoc:
+  module Integrations # :nodoc:
     # Adds support for integrating state machines with ActiveModel classes.
     #
     # == Examples
@@ -25,9 +27,9 @@ module StateMachines
     #     attr_accessor :state
     #     define_attribute_methods [:state]
     #
-    #     state_machine :initial => :parked do
+    #     state_machine initial: :parked do
     #       event :ignite do
-    #         transition :parked => :idling
+    #         transition parked: :idling
     #       end
     #     end
     #   end
@@ -45,7 +47,7 @@ module StateMachines
     #     include ActiveModel::Validations
     #     attr_accessor :state
     #
-    #     state_machine :action => :save do
+    #     state_machine action: :save do
     #       ...
     #     end
     #
@@ -83,7 +85,7 @@ module StateMachines
     #     state_machine do
     #       ...
     #       state :first_gear, :second_gear do
-    #         validate {|vehicle| vehicle.speed_is_legal}
+    #         validate { |vehicle| vehicle.speed_is_legal }
     #       end
     #     end
     #   end
@@ -115,38 +117,44 @@ module StateMachines
     # Beware that public event attributes mean that events can be fired
     # whenever mass-assignment is being used.  If you want to prevent malicious
     # users from tampering with events through URLs / forms, the attribute
-    # should be protected like so:
+    # should be protected using Strong Parameters in your controllers:
     #
     #   class Vehicle
-    #     include ActiveModel::MassAssignmentSecurity
     #     attr_accessor :state
     #
-    #     attr_protected :state_event
-    #     # attr_accessible ... # Alternative technique
-    #
     #     state_machine do
     #       ...
     #     end
     #   end
     #
+    #   # In your controller
+    #   def vehicle_params
+    #     params.require(:vehicle).permit(:attribute1, :attribute2) # Exclude :state_event
+    #   end
+    #
     # If you want to only have *some* events be able to fire via mass-assignment,
-    # you can build two state machines (one public and one protected) like so:
+    # you can build two state machines (one private and one public) like so:
     #
     #   class Vehicle
     #     attr_accessor :state
     #
-    #     attr_protected :state_event # Prevent access to events in the first machine
-    #
     #     state_machine do
     #       # Define private events here
     #     end
     #
     #     # Public machine targets the same state as the private machine
-    #     state_machine :public_state, :attribute => :state do
+    #     state_machine :public_state, attribute: :state do
     #       # Define public events here
     #     end
     #   end
     #
+    #   # In your controller
+    #   def vehicle_params
+    #     # Only permit events from the public state machine
+    #     params.require(:vehicle).permit(:attribute1, :attribute2, :public_state_event)
+    #     # The private state_event is not permitted
+    #   end
+    #
     # == Callbacks
     #
     # All before/after transition callbacks defined for ActiveModel models
@@ -159,7 +167,7 @@ module StateMachines
     #     include ActiveModel::Validations
     #     attr_accessor :state
     #
-    #     state_machine :initial => :parked do
+    #     state_machine initial: :parked do
     #       before_transition any => :idling do |vehicle|
     #         vehicle.put_on_seatbelt
     #       end
@@ -169,7 +177,7 @@ module StateMachines
     #       end
     #
     #       event :ignite do
-    #         transition :parked => :idling
+    #         transition parked: :idling
     #       end
     #     end
     #
@@ -181,64 +189,6 @@ module StateMachines
     # Note, also, that the transition can be accessed by simply defining
     # additional arguments in the callback block.
     #
-    # == Observers
-    #
-    # In order to hook in observer support for your application, the
-    # ActiveModel::Observing feature must be included.  This can be added by including the
-    # https://github.com/state-machines/state_machines-activemodel-observers gem in your 
-    # Gemfile. Because of the way
-    # ActiveModel observers are designed, there is less flexibility around the
-    # specific transitions that can be hooked in.  However, a large number of
-    # hooks *are* supported.  For example, if a transition for a object's
-    # +state+ attribute changes the state from +parked+ to +idling+ via the
-    # +ignite+ event, the following observer methods are supported:
-    # * before/after/after_failure_to-_ignite_from_parked_to_idling
-    # * before/after/after_failure_to-_ignite_from_parked
-    # * before/after/after_failure_to-_ignite_to_idling
-    # * before/after/after_failure_to-_ignite
-    # * before/after/after_failure_to-_transition_state_from_parked_to_idling
-    # * before/after/after_failure_to-_transition_state_from_parked
-    # * before/after/after_failure_to-_transition_state_to_idling
-    # * before/after/after_failure_to-_transition_state
-    # * before/after/after_failure_to-_transition
-    #
-    # The following class shows an example of some of these hooks:
-    #
-    #   class VehicleObserver < ActiveModel::Observer
-    #     # Callback for :ignite event *before* the transition is performed
-    #     def before_ignite(vehicle, transition)
-    #       # log message
-    #     end
-    #
-    #     # Callback for :ignite event *after* the transition has been performed
-    #     def after_ignite(vehicle, transition)
-    #       # put on seatbelt
-    #     end
-    #
-    #     # Generic transition callback *before* the transition is performed
-    #     def after_transition(vehicle, transition)
-    #       Audit.log(vehicle, transition)
-    #     end
-    #
-    #     def after_failure_to_transition(vehicle, transition)
-    #       Audit.error(vehicle, transition)
-    #     end
-    #   end
-    #
-    # More flexible transition callbacks can be defined directly within the
-    # model as described in StateMachine::Machine#before_transition
-    # and StateMachine::Machine#after_transition.
-    #
-    # To define a single observer for multiple state machines:
-    #
-    #   class StateMachineObserver < ActiveModel::Observer
-    #     observe Vehicle, Switch, Project
-    #
-    #     def after_transition(object, transition)
-    #       Audit.log(object, transition)
-    #     end
-    #   end
-    #
     # == Internationalization
     #
     # Any error message that is generated from performing invalid transitions
@@ -308,9 +258,9 @@ module StateMachines
     #     include ActiveModel::Dirty
     #     attr_accessor :state
     #
-    #     state_machine :initial => :parked do
+    #     state_machine initial: :parked do
     #       event :park do
-    #         transition :parked => :parked, ...
+    #         transition parked: :parked, ...
     #       end
     #     end
     #   end
@@ -322,7 +272,7 @@ module StateMachines
     #
     #   class Vehicle
     #     ...
-    #     state_machine :initial => :parked do
+    #     state_machine initial: :parked do
     #       before_transition all => same do |vehicle|
     #         vehicle.state_will_change!
     #
@@ -344,7 +294,7 @@ module StateMachines
     #   module StateMachine::Integrations::MyORM
     #     include ActiveModel
     #
-    #     mattr_accessor(:defaults) { :action => :persist }
+    #     mattr_accessor(:defaults) { { action: :persist } }
     #
     #     def self.matches?(klass)
     #       defined?(::MyORM::Base) && klass <= ::MyORM::Base
@@ -374,22 +324,19 @@ module StateMachines
 
       # Adds a validation error to the given object
       def invalidate(object, attribute, message, values = [])
-        if supports_validations?
-          attribute = self.attribute(attribute)
-          options = values.reduce({}) do |h, (key, value)|
-            h[key] = value
-            h
-          end
+        return unless supports_validations?
 
-          default_options = default_error_message_options(object, attribute, message)
-          object.errors.add(attribute, message, **options, **default_options)
-        end
+        attribute = self.attribute(attribute)
+        options = values.to_h
+
+        default_options = default_error_message_options(object, attribute, message)
+        object.errors.add(attribute, message, **options, **default_options)
       end
 
       # Describes the current validation errors on the given object.  If none
       # are specific, then the default error is interpeted as a "halt".
       def errors_for(object)
-        object.errors.empty? ? 'Transition halted' : object.errors.full_messages * ', '
+        object.errors.empty? ? 'Transition halted' : object.errors.full_messages.join(', ')
       end
 
       # Resets any errors previously added when invalidating the given object
@@ -398,22 +345,32 @@ module StateMachines
       end
 
       # Runs state events around the object's validation process
-      def around_validation(object)
-        object.class.state_machines.transitions(object, action, after: false).perform { yield }
+      def around_validation(object, &)
+        object.class.state_machines.transitions(object, action, after: false).perform(&)
       end
 
       protected
 
       def define_state_initializer
-        define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-          def initialize(params = {})
-            params.transform_keys! do |key|
+        define_helper :instance, <<-END_EVAL, __FILE__, __LINE__ + 1
+          def initialize(params = nil, **kwargs)
+            # Support both positional hash and keyword arguments
+            attrs = params.nil? ? kwargs : params
+          #{'  '}
+            attrs.transform_keys! do |key|
               self.class.attribute_aliases[key.to_s] || key.to_s
             end if self.class.respond_to?(:attribute_aliases)
 
-            self.class.state_machines.initialize_states(self, {}, params) { super }
+            # Call super with the appropriate arguments based on what we received
+            self.class.state_machines.initialize_states(self, {}, attrs) do
+              if params
+                super(params)
+              else
+                super(**kwargs)
+              end
+            end
           end
-        end_eval
+        END_EVAL
       end
 
       # Whether validations are supported in the integration.  Only true if
@@ -431,7 +388,7 @@ module StateMachines
 
       # Gets the terminator to use for callbacks
       def callback_terminator
-        @terminator ||= ->(result) { result == false }
+        @callback_terminator ||= ->(result) { result == false }
       end
 
       # Determines the base scope to use when looking up translations
@@ -461,7 +418,7 @@ module StateMachines
         # Generate all possible translation keys
         translations = ancestors.map { |ancestor| :"#{ancestor.model_name.to_s.underscore}.#{name}.#{group}.#{value}" }
         translations.concat(ancestors.map { |ancestor| :"#{ancestor.model_name.to_s.underscore}.#{group}.#{value}" })
-        translations.concat([:"#{name}.#{group}.#{value}", :"#{group}.#{value}", value.humanize.downcase])
+        translations.push(:"#{name}.#{group}.#{value}", :"#{group}.#{value}", value.humanize.downcase)
         I18n.translate(translations.shift, default: translations, scope: [i18n_scope(klass), :state_machines])
       end
 
@@ -475,10 +432,12 @@ module StateMachines
       def define_state_accessor
         name = self.name
 
+        return unless supports_validations?
+
         owner_class.validates_each(attribute) do |object|
           machine = object.class.state_machine(name)
           machine.invalidate(object, :state, :invalid) unless machine.states.match(object)
-        end if supports_validations?
+        end
       end
 
       # Adds hooks into validation for automatically firing events
@@ -496,7 +455,7 @@ module StateMachines
       # Creates a new callback in the callback chain, always inserting it
       # before the default Observer callbacks that were created after
       # initialization.
-      def add_callback(type, options, &block)
+      def add_callback(type, options, &)
         options[:terminator] = callback_terminator
         super
       end
@@ -504,14 +463,24 @@ module StateMachines
       # Configures new states with the built-in humanize scheme
       def add_states(*)
         super.each do |new_state|
-          new_state.human_name = ->(state, klass) { translate(klass, :state, state.name) }
+          # Only set the translation lambda if human_name is the default auto-generated value
+          # This preserves user-specified human names while still applying translations for defaults
+          default_human_name = new_state.name ? new_state.name.to_s.tr('_', ' ') : 'nil'
+          if new_state.human_name == default_human_name
+            new_state.human_name = ->(state, klass) { translate(klass, :state, state.name) }
+          end
         end
       end
 
       # Configures new event with the built-in humanize scheme
       def add_events(*)
         super.each do |new_event|
-          new_event.human_name = ->(event, klass) { translate(klass, :event, event.name) }
+          # Only set the translation lambda if human_name is the default auto-generated value
+          # This preserves user-specified human names while still applying translations for defaults
+          default_human_name = new_event.name ? new_event.name.to_s.tr('_', ' ') : 'nil'
+          if new_event.human_name == default_human_name
+            new_event.human_name = ->(event, klass) { translate(klass, :event, event.name) }
+          end
         end
       end
     end

data/lib/state_machines-activemodel.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support'
 require 'state_machines/integrations/active_model'
 

data/test/event_human_name_test.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+class EventHumanNameTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Validations
+      attr_accessor :status
+    end
+  end
+
+  def test_should_allow_custom_human_name_on_event
+    machine = StateMachines::Machine.new(@model, :status, initial: :parked) do
+      event :start, human_name: 'Start Engine' do
+        transition parked: :running
+      end
+
+      event :stop do
+        transition running: :parked
+      end
+
+      event :pause, human_name: 'Temporarily Pause' do
+        transition running: :paused
+      end
+    end
+
+    assert_equal 'Start Engine', machine.events[:start].human_name(@model)
+    assert_equal 'Temporarily Pause', machine.events[:pause].human_name(@model)
+  end
+
+  def test_should_not_override_custom_event_human_name_with_translation
+    # Set up I18n translations
+    I18n.backend.store_translations(:en, {
+                                      activemodel: {
+                                        state_machines: {
+                                          events: {
+                                            ignite: 'Translation for Ignite',
+                                            park: 'Translation for Park',
+                                            repair: 'Translation for Repair'
+                                          }
+                                        }
+                                      }
+                                    })
+
+    machine = StateMachines::Machine.new(@model, :status, initial: :parked) do
+      event :ignite, human_name: 'Custom Ignition' do
+        transition parked: :idling
+      end
+
+      event :park do
+        transition idling: :parked
+      end
+
+      event :repair, human_name: 'Custom Repair Process' do
+        transition any => :parked
+      end
+    end
+
+    # Custom human names should be preserved
+    assert_equal 'Custom Ignition', machine.events[:ignite].human_name(@model)
+    assert_equal 'Custom Repair Process', machine.events[:repair].human_name(@model)
+
+    # Event without custom human_name should use translation
+    assert_equal 'Translation for Park', machine.events[:park].human_name(@model)
+  end
+
+  def test_should_allow_custom_event_human_name_as_string
+    machine = StateMachines::Machine.new(@model, :status) do
+      event :activate, human_name: 'Turn On'
+    end
+
+    assert_equal 'Turn On', machine.events[:activate].human_name(@model)
+  end
+
+  def test_should_allow_custom_event_human_name_as_lambda
+    machine = StateMachines::Machine.new(@model, :status) do
+      event :process, human_name: ->(event, klass) { "#{klass.name}: #{event.name.to_s.capitalize} Action" }
+    end
+
+    assert_equal 'Foo: Process Action', machine.events[:process].human_name(@model)
+  end
+
+  def test_should_use_default_translation_when_no_custom_event_human_name
+    machine = StateMachines::Machine.new(@model, :status) do
+      event :idle
+    end
+
+    # Should fall back to humanized version when no translation exists
+    assert_equal 'idle', machine.events[:idle].human_name(@model)
+  end
+
+  def test_should_handle_nil_event_human_name
+    machine = StateMachines::Machine.new(@model, :status) do
+      event :wait
+    end
+
+    # Explicitly set to nil
+    machine.events[:wait].human_name = nil
+
+    # When human_name is nil, Event#human_name returns nil
+    assert_nil machine.events[:wait].human_name(@model)
+  end
+
+  def test_should_preserve_event_human_name_through_multiple_definitions
+    machine = StateMachines::Machine.new(@model, :status, initial: :draft)
+
+    # First define event with custom human name
+    machine.event :publish, human_name: 'Make Public' do
+      transition draft: :published
+    end
+
+    # Redefine the same event (this should not override the human_name)
+    machine.event :publish do
+      transition pending: :published
+    end
+
+    assert_equal 'Make Public', machine.events[:publish].human_name(@model)
+  end
+
+  def test_should_work_with_state_machine_helper_method
+    @model.class_eval do
+      state_machine :status, initial: :pending do
+        event :approve, human_name: 'Grant Approval' do
+          transition pending: :approved
+        end
+
+        event :reject do
+          transition pending: :rejected
+        end
+      end
+    end
+
+    machine = @model.state_machine(:status)
+    assert_equal 'Grant Approval', machine.events[:approve].human_name(@model)
+  end
+
+  def test_should_handle_complex_i18n_lookup_with_custom_event_human_name
+    # Set up complex I18n structure
+    I18n.backend.store_translations(:en, {
+                                      activemodel: {
+                                        state_machines: {
+                                          foo: {
+                                            status: {
+                                              events: {
+                                                submit: 'Model Specific Submit'
+                                              }
+                                            }
+                                          },
+                                          status: {
+                                            events: {
+                                              submit: 'Machine Specific Submit'
+                                            }
+                                          },
+                                          events: {
+                                            submit: 'Generic Submit'
+                                          }
+                                        }
+                                      }
+                                    })
+
+    machine = StateMachines::Machine.new(@model, :status) do
+      event :submit, human_name: 'Send for Review' do
+        transition draft: :pending
+      end
+    end
+
+    # Should use the custom human_name, not any of the I18n translations
+    assert_equal 'Send for Review', machine.events[:submit].human_name(@model)
+  end
+
+  def teardown
+    # Clear I18n translations after each test
+    I18n.backend.reload!
+  end
+end