state_machines-activemodel 0.10.0 → 0.31.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a37766e74933c9b284c1bea7acc586937d437222fb51371a12118cb9c28873c
-  data.tar.gz: 05d7748697762082b5cd5c6a388cfbcdb62d7f54bdaf656587c7cdc9158b78f6
+  metadata.gz: 83ec0c17ef0c2f530f146fd28b90e6474a9ff1fde5e37c07f143652d65c60375
+  data.tar.gz: 9d3c8fb5814ed1e8bf03f543aa9c25ef7ff0b8a241cb05dd20d7b64f15a039fb
 SHA512:
-  metadata.gz: 49059888466d7e77da042aa4d3b296d029d3bbaf600ef70cf514322a04c14211460527444d08fd591a8b3e38a3039b1119c3c719d06bdc6363ab03dadf83b7c0
-  data.tar.gz: 787f045227838e8ce24c6b5448d991631ef1a35c90f078582f8f2fff66470760d90d0c05f2bc56c174dcb93f4c4662b137100d06ff27e44aefca98a4d4b7f11e
+  metadata.gz: f47b157cadbf59127defff4c9f9dade32957b98d439be01963718abe482b0adf638ee8e273347e28fbef56598abbc9e91bfe4d1384f803569b42472abf190d25
+  data.tar.gz: 0cd4c365cf6d108b219bd913598b9bfe1425d7fc9cd62a86961b865cea29483480d0421af07db63daa016050135c44da7578c2cf4131e9ab23ff292b5dd75111

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
 

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

@@ -1,12 +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

@@ -3,7 +3,7 @@
 module StateMachines
   module Integrations
     module ActiveModel
-      VERSION = '0.10.0'
+      VERSION = '0.31.1'
     end
   end
 end

data/lib/state_machines/integrations/active_model.rb

@@ -8,7 +8,7 @@ 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
@@ -324,13 +324,13 @@ 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.to_h { |key, value| [key, value] }
+        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
@@ -345,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
@@ -378,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
@@ -408,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
 
@@ -422,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
@@ -443,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
@@ -451,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/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

data/test/human_name_preservation_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+class HumanNamePreservationTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Validations
+      attr_accessor :status
+    end
+  end
+
+  def test_should_preserve_custom_state_human_name_when_using_activemodel_integration
+    # This test specifically verifies that PR #38's fix works:
+    # Using ||= instead of = in add_states method
+
+    @model.class_eval do
+      state_machine :status, initial: :pending do
+        # Define a state with a custom human_name
+        state :pending, human_name: 'My Custom Pending'
+        state :approved
+      end
+    end
+
+    machine = @model.state_machine(:status)
+
+    # The custom human_name should be preserved, not overwritten by the integration
+    assert_equal 'My Custom Pending', machine.states[:pending].human_name(@model)
+  end
+
+  def test_should_preserve_custom_event_human_name_when_using_activemodel_integration
+    # This test verifies our additional fix for events:
+    # Using ||= instead of = in add_events method
+
+    @model.class_eval do
+      state_machine :status, initial: :pending do
+        event :approve, human_name: 'Grant Authorization' do
+          transition pending: :approved
+        end
+
+        event :reject do
+          transition pending: :rejected
+        end
+      end
+    end
+
+    machine = @model.state_machine(:status)
+
+    # The custom human_name should be preserved, not overwritten by the integration
+    assert_equal 'Grant Authorization', machine.events[:approve].human_name(@model)
+  end
+
+  def test_regression_issue_37_hard_coded_human_name_preserved
+    # This is the exact regression test for issue #37
+    # "Hard-coded human_name is being overwritten"
+
+    @model.class_eval do
+      state_machine :status do
+        state :pending, human_name: 'Pending Approval'
+        state :active, human_name: 'Active State'
+
+        event :activate, human_name: 'Activate Now' do
+          transition pending: :active
+        end
+      end
+    end
+
+    machine = @model.state_machine(:status)
+
+    # Both states and events should preserve their hard-coded human names
+    assert_equal 'Pending Approval', machine.states[:pending].human_name(@model)
+    assert_equal 'Active State', machine.states[:active].human_name(@model)
+    assert_equal 'Activate Now', machine.events[:activate].human_name(@model)
+  end
+end

data/test/integration_test.rb

@@ -20,7 +20,7 @@ class IntegrationTest < BaseTestCase
   end
 
   def test_should_not_match_if_class_does_not_include_active_model_features
-    refute StateMachines::Integrations::ActiveModel.matches?(new_model)
+    refute StateMachines::Integrations::ActiveModel.matches?(new_plain_model)
   end
 
   def test_should_have_no_defaults

data/test/machine_initialization_compatibility_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+class MachineInitializationCompatibilityTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Validations
+    end
+
+    @machine = StateMachines::Machine.new(@model, initial: :parked)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+  end
+
+  def test_should_accept_positional_hash_argument
+    record = @model.new({ state: 'idling' })
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_accept_keyword_arguments
+    record = @model.new(state: 'idling')
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_accept_empty_initialization
+    record = @model.new
+    assert_equal 'parked', record.state
+  end
+
+  def test_should_handle_attribute_aliases
+    @model.class_eval do
+      alias_attribute :status, :state
+    end
+
+    record = @model.new(status: 'idling')
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_prefer_positional_hash_over_keywords_when_both_present
+    # If someone accidentally provides both, positional takes precedence
+    record = @model.new({ state: 'idling' }, state: 'parked')
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_handle_empty_positional_hash
+    # Empty hash should still be treated as positional argument
+    record = @model.new({})
+    assert_equal 'parked', record.state # Gets default initial state
+  end
+
+  def test_should_use_keywords_when_empty_hash_and_keywords_present
+    # With the fix, keywords are ignored even with empty positional hash
+    record = @model.new({}, state: 'idling')
+    assert_equal 'parked', record.state # Empty hash takes precedence
+  end
+end

data/test/machine_multiple_test.rb

@@ -5,7 +5,7 @@ require 'test_helper'
 class MachineMultipleTest < BaseTestCase
   def setup
     @model = new_model do
-      model_attribute :status
+      attribute :status, :string
     end
 
     @state_machine = StateMachines::Machine.new(@model, initial: :parked, integration: :active_model)

data/test/machine_with_dirty_attribute_and_custom_attributes_during_loopback_test.rb

@@ -5,13 +5,14 @@ require 'test_helper'
 class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
   def setup
     @model = new_model do
-      include ActiveModel::Dirty
-      model_attribute :status
-      define_attribute_methods [:status]
+      attribute :status, :string
 
       def save
-        super.tap do
+        if valid?
           changes_applied
+          true
+        else
+          false
         end
       end
     end

data/test/machine_with_dirty_attribute_and_state_events_test.rb

@@ -5,12 +5,12 @@ require 'test_helper'
 class MachineWithDirtyAttributeAndStateEventsTest < BaseTestCase
   def setup
     @model = new_model do
-      include ActiveModel::Dirty
-      define_attribute_methods [:state]
-
       def save
-        super.tap do
+        if valid?
           changes_applied
+          true
+        else
+          false
         end
       end
     end

data/test/machine_with_dirty_attributes_and_custom_attribute_test.rb

@@ -5,13 +5,14 @@ require 'test_helper'
 class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
   def setup
     @model = new_model do
-      include ActiveModel::Dirty
-      model_attribute :status
-      define_attribute_methods [:status]
+      attribute :status, :string
 
       def save
-        super.tap do
+        if valid?
           changes_applied
+          true
+        else
+          false
         end
       end
     end
@@ -26,17 +27,17 @@ class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
   end
 
   def test_should_include_state_in_changed_attributes
-    assert_equal %w(status), @record.changed
+    assert_equal %w[status], @record.changed
   end
 
   def test_should_track_attribute_change
-    assert_equal %w(parked idling), @record.changes['status']
+    assert_equal %w[parked idling], @record.changes['status']
   end
 
   def test_should_not_reset_changes_on_multiple_transitions
     transition = StateMachines::Transition.new(@record, @machine, :ignite, :idling, :idling)
     transition.perform
 
-    assert_equal %w(parked idling), @record.changes['status']
+    assert_equal %w[parked idling], @record.changes['status']
   end
 end

data/test/machine_with_dirty_attributes_during_loopback_test.rb

@@ -5,12 +5,12 @@ require 'test_helper'
 class MachineWithDirtyAttributesDuringLoopbackTest < BaseTestCase
   def setup
     @model = new_model do
-      include ActiveModel::Dirty
-      define_attribute_methods [:state]
-
       def save
-        super.tap do
+        if valid?
           changes_applied
+          true
+        else
+          false
         end
       end
     end

data/test/machine_with_dirty_attributes_test.rb

@@ -5,12 +5,12 @@ require 'test_helper'
 class MachineWithDirtyAttributesTest < BaseTestCase
   def setup
     @model = new_model do
-      include ActiveModel::Dirty
-      define_attribute_methods [:state]
-
       def save
-        super.tap do
+        if valid?
           changes_applied
+          true
+        else
+          false
         end
       end
     end
@@ -25,17 +25,17 @@ class MachineWithDirtyAttributesTest < BaseTestCase
   end
 
   def test_should_include_state_in_changed_attributes
-    assert_equal %w(state), @record.changed
+    assert_equal %w[state], @record.changed
   end
 
   def test_should_track_attribute_change
-    assert_equal %w(parked idling), @record.changes['state']
+    assert_equal %w[parked idling], @record.changes['state']
   end
 
   def test_should_not_reset_changes_on_multiple_transitions
     transition = StateMachines::Transition.new(@record, @machine, :ignite, :idling, :idling)
     transition.perform
 
-    assert_equal %w(parked idling), @record.changes['state']
+    assert_equal %w[parked idling], @record.changes['state']
   end
 end

data/test/machine_with_initialized_aliased_attribute_test.rb

@@ -6,6 +6,7 @@ class MachineWithInitializedAliasedAttributeTest < BaseTestCase
   def test_should_match_original_attribute_value_with_attribute_methods
     model = new_model do
       include ActiveModel::AttributeMethods
+
       alias_attribute :custom_status, :state
     end
 
@@ -19,7 +20,16 @@ class MachineWithInitializedAliasedAttributeTest < BaseTestCase
   end
 
   def test_should_not_match_original_attribute_value_without_attribute_methods
-    model = new_model do
+    model = new_plain_model do
+      include ActiveModel::Model
+
+      attr_accessor :state
+
+      def self.alias_attribute(new_name, old_name)
+        alias_method new_name, old_name
+        alias_method "#{new_name}=", "#{old_name}="
+      end
+
       alias_attribute :custom_status, :state
     end
 
@@ -32,4 +42,3 @@ class MachineWithInitializedAliasedAttributeTest < BaseTestCase
     refute record.state?(:started)
   end
 end
-

data/test/machine_with_internationalization_test.rb

@@ -56,7 +56,7 @@ class MachineWithInternationalizationTest < BaseTestCase
 
     machine = StateMachines::Machine.new(@model)
     machine.state :parked
-    assert_equal 'shutdown', machine.state(:parked).human_name
+    assert_equal 'shutdown', machine.state(:parked).human_name(@model)
   end
 
   def test_should_allow_customized_state_key_scoped_to_class
@@ -67,7 +67,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.state :parked
 
-    assert_equal 'shutdown', machine.state(:parked).human_name
+    assert_equal 'shutdown', machine.state(:parked).human_name(@model)
   end
 
   def test_should_allow_customized_state_key_scoped_to_machine
@@ -78,7 +78,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.state :parked
 
-    assert_equal 'shutdown', machine.state(:parked).human_name
+    assert_equal 'shutdown', machine.state(:parked).human_name(@model)
   end
 
   def test_should_allow_customized_state_key_unscoped
@@ -89,7 +89,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.state :parked
 
-    assert_equal 'shutdown', machine.state(:parked).human_name
+    assert_equal 'shutdown', machine.state(:parked).human_name(@model)
   end
 
   def test_should_support_nil_state_key
@@ -99,7 +99,7 @@ class MachineWithInternationalizationTest < BaseTestCase
 
     machine = StateMachines::Machine.new(@model)
 
-    assert_equal 'empty', machine.state(nil).human_name
+    assert_equal 'empty', machine.state(nil).human_name(@model)
   end
 
   def test_should_allow_customized_event_key_scoped_to_class_and_machine
@@ -110,7 +110,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.event :park
 
-    assert_equal 'stop', machine.event(:park).human_name
+    assert_equal 'stop', machine.event(:park).human_name(@model)
   end
 
   def test_should_allow_customized_event_key_scoped_to_class
@@ -121,7 +121,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.event :park
 
-    assert_equal 'stop', machine.event(:park).human_name
+    assert_equal 'stop', machine.event(:park).human_name(@model)
   end
 
   def test_should_allow_customized_event_key_scoped_to_machine
@@ -132,7 +132,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.event :park
 
-    assert_equal 'stop', machine.event(:park).human_name
+    assert_equal 'stop', machine.event(:park).human_name(@model)
   end
 
   def test_should_allow_customized_event_key_unscoped
@@ -143,7 +143,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.event :park
 
-    assert_equal 'stop', machine.event(:park).human_name
+    assert_equal 'stop', machine.event(:park).human_name(@model)
   end
 
   def test_should_have_locale_once_in_load_path

data/test/machine_with_non_model_state_attribute_undefined_test.rb

@@ -4,9 +4,8 @@ require 'test_helper'
 
 class MachineWithNonModelStateAttributeUndefinedTest < BaseTestCase
   def setup
-    @model = new_model do
-      def initialize
-      end
+    @model = new_plain_model do
+      def initialize; end
     end
 
     @machine = StateMachines::Machine.new(@model, :status, initial: :parked, integration: :active_model)

data/test/state_human_name_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+class StateHumanNameTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Validations
+      attr_accessor :status
+    end
+  end
+
+  def test_should_allow_custom_human_name_on_state
+    machine = StateMachines::Machine.new(@model, :status, initial: :pending) do
+      state :pending, human_name: 'Awaiting Approval'
+      state :approved
+      state :rejected, human_name: 'Denied'
+    end
+
+    assert_equal 'Awaiting Approval', machine.states[:pending].human_name(@model)
+    assert_equal 'Denied', machine.states[:rejected].human_name(@model)
+  end
+
+  def test_should_not_override_custom_human_name_with_translation
+    # Set up I18n translations
+    I18n.backend.store_translations(:en, {
+                                      activemodel: {
+                                        state_machines: {
+                                          states: {
+                                            pending: 'Translation for Pending',
+                                            approved: 'Translation for Approved',
+                                            rejected: 'Translation for Rejected'
+                                          }
+                                        }
+                                      }
+                                    })
+
+    machine = StateMachines::Machine.new(@model, :status, initial: :pending) do
+      state :pending, human_name: 'Custom Pending Name'
+      state :approved
+      state :rejected, human_name: 'Custom Rejected Name'
+    end
+
+    # Custom human names should be preserved
+    assert_equal 'Custom Pending Name', machine.states[:pending].human_name(@model)
+    assert_equal 'Custom Rejected Name', machine.states[:rejected].human_name(@model)
+
+    # State without custom human_name gets default behavior (which might not use translations in this test setup)
+    # The key test is that custom human names are preserved, not overwritten
+    refute_equal 'Custom Pending Name', machine.states[:approved].human_name(@model)
+  end
+
+  def test_should_allow_custom_human_name_as_string
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :active, human_name: 'Currently Active'
+    end
+
+    assert_equal 'Currently Active', machine.states[:active].human_name(@model)
+  end
+
+  def test_should_allow_custom_human_name_as_lambda
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :processing, human_name: ->(state, klass) { "#{klass.name} is #{state.name.to_s.upcase}" }
+    end
+
+    assert_equal 'Foo is PROCESSING', machine.states[:processing].human_name(@model)
+  end
+
+  def test_should_use_default_translation_when_no_custom_human_name
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :idle
+    end
+
+    # Should fall back to humanized version when no translation exists
+    assert_equal 'idle', machine.states[:idle].human_name(@model)
+  end
+
+  def test_should_handle_nil_human_name
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :waiting
+    end
+
+    # Explicitly set to nil (should still get default behavior)
+    machine.states[:waiting].human_name = nil
+
+    # When human_name is nil, State#human_name returns nil
+    assert_nil machine.states[:waiting].human_name(@model)
+  end
+
+  def test_should_preserve_human_name_through_multiple_state_definitions
+    machine = StateMachines::Machine.new(@model, :status)
+
+    # First define state with custom human name
+    machine.state :draft, human_name: 'Work in Progress'
+
+    # Redefine the same state (this should not override the human_name)
+    machine.state :draft do
+      # Add some behavior
+    end
+
+    assert_equal 'Work in Progress', machine.states[:draft].human_name(@model)
+  end
+
+  def test_should_work_with_state_machine_helper_method
+    @model.class_eval do
+      state_machine :status, initial: :pending do
+        state :pending, human_name: 'Awaiting Review'
+        state :reviewed
+      end
+    end
+
+    machine = @model.state_machine(:status)
+    assert_equal 'Awaiting Review', machine.states[:pending].human_name(@model)
+  end
+
+  def test_should_handle_complex_i18n_lookup_with_custom_human_name
+    # Set up complex I18n structure
+    I18n.backend.store_translations(:en, {
+                                      activemodel: {
+                                        state_machines: {
+                                          foo: {
+                                            status: {
+                                              states: {
+                                                pending: 'Model Specific Pending'
+                                              }
+                                            }
+                                          },
+                                          status: {
+                                            states: {
+                                              pending: 'Machine Specific Pending'
+                                            }
+                                          },
+                                          states: {
+                                            pending: 'Generic Pending'
+                                          }
+                                        }
+                                      }
+                                    })
+
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :pending, human_name: 'Overridden Pending'
+    end
+
+    # Should use the custom human_name, not any of the I18n translations
+    assert_equal 'Overridden Pending', machine.states[:pending].human_name(@model)
+  end
+
+  def teardown
+    # Clear I18n translations after each test
+    I18n.backend.reload!
+  end
+end

data/test/test_helper.rb

@@ -11,45 +11,40 @@ I18n.enforce_available_locales = true
 
 class BaseTestCase < ActiveSupport::TestCase
   protected
-  # Creates a new ActiveModel model (and the associated table)
-  def new_model(&block)
-    # Simple ActiveModel superclass
-    parent = Class.new do
-      def self.model_attribute(name)
-        define_method(name) { instance_variable_defined?(:"@#{name}") ? instance_variable_get(:"@#{name}") : nil }
-        define_method("#{name}=") do |value|
-          send(:"#{name}_will_change!") if self.class <= ActiveModel::Dirty && value != send(name)
-          instance_variable_set("@#{name}", value)
-        end
-      end
 
-      def self.create
-        object = new
-        object.save
-        object
+  # Creates a plain model without ActiveModel features
+  def new_plain_model(&block)
+    model = Class.new do
+      def self.name
+        'Foo'
       end
+    end
 
-      def initialize(attrs = {})
-        attrs.each { |attr, value| send("#{attr}=", value) }
-      end
+    model.class_eval(&block) if block_given?
 
-      def attributes
-        @attributes ||= {}
-      end
+    model
+  end
 
-      def save
-        true
-      end
-    end
+  # Creates a new ActiveModel model (and the associated table)
+  def new_model(&block)
+    model = Class.new do
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+      include ActiveModel::Dirty
+
+      attribute :state, :string
 
-    model = Class.new(parent) do
       def self.name
         'Foo'
       end
 
-      model_attribute :state
+      def self.create
+        new.tap { |instance| instance.save if instance.respond_to?(:save) }
+      end
     end
+
     model.class_eval(&block) if block_given?
+
     model
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: state_machines-activemodel
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.31.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.100.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.100.1
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -122,9 +122,12 @@ files:
 - lib/state_machines/integrations/active_model.rb
 - lib/state_machines/integrations/active_model/locale.rb
 - lib/state_machines/integrations/active_model/version.rb
+- test/event_human_name_test.rb
+- test/human_name_preservation_test.rb
 - test/integration_test.rb
 - test/machine_by_default_test.rb
 - test/machine_errors_test.rb
+- test/machine_initialization_compatibility_test.rb
 - test/machine_multiple_test.rb
 - test/machine_with_callbacks_test.rb
 - test/machine_with_dirty_attribute_and_custom_attributes_during_loopback_test.rb
@@ -146,6 +149,7 @@ files:
 - test/machine_with_static_initial_state_test.rb
 - test/machine_with_validations_and_custom_attribute_test.rb
 - test/machine_with_validations_test.rb
+- test/state_human_name_test.rb
 - test/test_helper.rb
 homepage: https://github.com/state-machines/state_machines-activemodel
 licenses:
@@ -158,7 +162,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -169,9 +173,12 @@ rubygems_version: 3.6.7
 specification_version: 4
 summary: ActiveModel integration for State Machines
 test_files:
+- test/event_human_name_test.rb
+- test/human_name_preservation_test.rb
 - test/integration_test.rb
 - test/machine_by_default_test.rb
 - test/machine_errors_test.rb
+- test/machine_initialization_compatibility_test.rb
 - test/machine_multiple_test.rb
 - test/machine_with_callbacks_test.rb
 - test/machine_with_dirty_attribute_and_custom_attributes_during_loopback_test.rb
@@ -193,4 +200,5 @@ test_files:
 - test/machine_with_static_initial_state_test.rb
 - test/machine_with_validations_and_custom_attribute_test.rb
 - test/machine_with_validations_test.rb
+- test/state_human_name_test.rb
 - test/test_helper.rb