can_has_state 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 830a444d5fc61e931ce78814643df95ecbd3fbf3b7a7d3c6e8a7cfff2cd8d5dc
-  data.tar.gz: 4eb9957f407096c867d939f6391ff14ff53df0ec6adc36b9c60d9c58eb784d58
+  metadata.gz: 516a5676e62907d7868c5a0812c760e292b87c8c785cb246c5eb3bd2db2d7a41
+  data.tar.gz: 1e4b230a4a4c933b1db2884b2f7490439c9fb2f4f18b1ee686286decc2640903
 SHA512:
-  metadata.gz: 96a50045a8c2933b37a54b56dfd105e5f0ecb2f53fce23034d4245f6f74651e8e2b950ada2ece3985d721cbdfe124a068e68aa713a1fe2e44c4ecec4a80cdf75
-  data.tar.gz: 2a03221fe58298f25309dec5edc51e5fe14114f99c1d48d133594dc40722d647ea6a4283837c37abb75a87df8cfea166f30e6e2683f121a9ebe5745a4fb5e6d9
+  metadata.gz: cb9ef6c65385ef382a01d9f73c40da6217136f9939fea20eb6aae0183ce57f492e119302fc560f9273b2f6c2933cde3fa2c50daf3e0f13d038cf19dbfa377d5b
+  data.tar.gz: f1aee70c43b00b6ae153c63583db1d1bf4bd9adb072fa4b5adf33eecd1b4f3c1668aa1aba54438b296158ad858475a1d52333ce95f0e2e9959d1d1fb8b7d499b

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2012-2022 thomas morgan
+Copyright 2012-2023 thomas morgan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,4 +1,4 @@
-# CanHasState #
+# CanHasState
 
 
 `can_has_state` is a simplified state machine gem. It relies on ActiveModel and
@@ -10,21 +10,21 @@ Key features:
 * Simplified DSL syntax
 * Few added methods avoids clobbering up model's namespace
 * Compatible with ActionPack-style attribute value changes via  
-  `:state_column => 'new_state'`
+  `state_column: 'new_state'`
 * Use any ActiveModel-compatible persistence layer (including your own)
 
 
 
-## Installation ##
+## Installation
 
 Add it to your `Gemfile`:
 
     gem 'can_has_state'
 
 
-## DSL ##
+## DSL
 
-### ActiveRecord ###
+### ActiveRecord
 
     class Account < ActiveRecord::Base
 
@@ -43,20 +43,20 @@ Add it to your `Gemfile`:
         #   under triggers.
         #
         state :active, :initial,
-          :from => :inactive,
-          :on_enter => :update_plan_details,
-          :on_enter_deferred => :start_billing,
-          :on_exit_deferred => lambda { |r| r.stop_billing }
+          from: :inactive,
+          on_enter: :update_plan_details,
+          on_enter_deferred: :start_billing,
+          on_exit_deferred: lambda{|r| r.stop_billing }
 
         # :from restricts which states can switch to this one. Multiple "from"
-        #   states are allowed, as shown under state :deleted.
+        #   states are allowed, as shown below under `state :deleted`.
         #
         # If :from is not present, this state may be entered from any other
         #   state. To prevent ever moving to a given state (only useful if that
-        #   state is also the initial state), use :from => [] .
+        #   state is also the initial state), use `from: []`.
         #
         state :inactive,
-          :from => [:active]
+          from: [:active]
 
         # :timestamp automatically sets the current date/time when this state
         #   is entered. Both *_at and *_on (datetime and date) columns are
@@ -65,21 +65,22 @@ Add it to your `Gemfile`:
         # :require adds additional restrictions before this state can be
         #   entered. Like :on_enter/:on_exit, it can be a method name or a
         #   lambda/Proc. Multiple methods may be provided. Each method must
-        #   return a ruby true value (anything except nil or false) for the
+        #   return a ruby truthy value (anything except nil or false) for the
         #   condition to be satisfied. If any :require is not true, then the
         #   state transition is blocked.
         #
         # :message allows the validation error message to be customized. It is
         #   used when conditions for either :from or :require fail. The default
         #   message is used in the example below. %{from} and %{to} parameters
-        #   are optional, and will be the from and to states, respectively.
+        #   are optional, and will be the old (from) and new (to) values of the
+        #   state field.
         #
         state :deleted,
-          :from => [:active, :inactive],
-          :timestamp => :deleted_at,
-          :on_enter_deferred => [:delete_record, :delete_payment_info],
-          :require => lambda {|r| !r.active_services? },
-          :message => "has invalid transition from %{from} to %{to}"
+          from: [:active, :inactive],
+          timestamp: :deleted_at,
+          on_enter_deferred: [:delete_record, :delete_payment_info],
+          require: proc{ !active_services? },
+          message: "has invalid transition from %{from} to %{to}"
 
         # Custom triggers are called for certain "from" => "to" state
         #   combinations. They are especially useful for DRYing up triggers
@@ -95,8 +96,8 @@ Add it to your `Gemfile`:
         # Multiple triggers can be specified on either side of the transition
         #   or for the trigger actions:
         #
-        on [:active, :inactive] => :deleted, :trigger => [:do_one, :do_two]
-        on :active => [:inactive, :deleted], :trigger => lambda {|r| r.act }
+        on [:active, :inactive] => :deleted, trigger: [:do_one, :do_two]
+        on :active => [:inactive, :deleted], trigger: ->(r){ r.act }
 
         # If :deferred is included, and it's true, then this trigger will
         #   happen post-save, instead of pre-validation. Default pre-validation
@@ -117,15 +118,15 @@ Add it to your `Gemfile`:
         #   from = state_was   # (specifically, <state_column>_was)
         #   to   = state
         #
-        on :* => :*, :trigger => :log_state_change, :deferred=>true
-        on :* => :deleted, :trigger => :same_as_on_enter
+        on :* => :*, trigger: :log_state_change, deferred: true
+        on :* => :deleted, trigger: :same_as_on_enter
 
       end
 
     end
 
 
-### Just ActiveModel ###
+### Just ActiveModel
 
     class Account
       include CanHasState::DirtyHelper
@@ -137,12 +138,12 @@ Add it to your `Gemfile`:
 
       state_machine :account_state do
         state :active, :initial,
-          :from => :inactive
+          from: :inactive
         state :inactive,
-          :from => :active
+          from: :active
         state :deleted,
-          :from => [:active, :inactive],
-          :timestamp => :deleted_at
+          from: [:active, :inactive],
+          timestamp: :deleted_at
       end
 
     end
@@ -159,7 +160,7 @@ non-ActiveRecord persistence engine provides #after_save, then deferred triggers
 will be enabled.
 
 
-## Managing states ##
+## Managing states
 
 States are set directly via the relevant state column--no added methods.
 
@@ -186,12 +187,12 @@ collisions.
       # column is :state
       state_machine :state do
         state :active,
-          :from => :inactive,
-          :require => lambda{|r| r.payment_status=='current'}
+          from: :inactive,
+          require: lambda{|r| r.payment_status=='current'}
         state :inactive,
-          :from => :active
+          from: :active
         state :deleted,
-          :from => [:active, :inactive]
+          from: [:active, :inactive]
       end
 
       # column is :payment_status
@@ -236,7 +237,7 @@ will be called.
 
 
 
-## Notes on triggers and initial state ##
+## Using triggers on initial states
 
 `can_has_state` relies on the `ActiveModel::Dirty` module to detect when a state
 attribute has changed. In general, this shouldn't matter much to you as long as
@@ -251,6 +252,20 @@ because the initial state value changed from nil to the initial state.
 
 
 
-## Compatibility ##
+## Modifying state attributes in `before_validation`
 
-Tested with Ruby 2.3-2.6+ and ActiveSupport and ActiveModel 5.2-6.1+.
+`can_has_state`'s validation callbacks run very early, almost always before any
+Model-specific validation. This ensures that validations and normal callbacks
+see the model's attributes after any triggers have been run.
+
+This can cause problems when modifying the value of a state attribute as part of
+a callback. The most common way this shows up is receiving state validation
+errors (typically due to a `:require`), even when a `before_validation` callback
+seems to be executed.
+
+Often, the best solution is to review the modification of state attributes
+during callbacks, as the original problem can hint at code design issue. If the
+callbacks are definitely warranted, try moving your validation to the start of
+the callback chain so it runs before `can_has_state`:
+
+    before_validation :some_method, prepend: true

data/lib/can_has_state/definition.rb

@@ -1,10 +1,11 @@
 module CanHasState
   class Definition
 
-    attr_reader :column, :states, :initial_state, :triggers
+    attr_accessor :parent_context
+    attr_reader :column, :states, :triggers, :initial_state
 
-    def initialize(column_name, parent_context, &block)
-      @parent_context = parent_context
+    def initialize(column_name, model_class, &block)
+      @parent_context = model_class
       @column = column_name.to_sym
       @states = {}
       @triggers = []
@@ -12,6 +13,16 @@ module CanHasState
       @initial_state ||= @states.keys.first
     end
 
+    def initialize_dup(orig)
+      @states = @states.deep_dup
+      @triggers = @triggers.map do |t|
+        t = t.dup
+        t.state_machine = self
+        t
+      end
+      super
+    end
+
 
     def extend_machine(&block)
       instance_eval(&block)
@@ -26,111 +37,90 @@ module CanHasState
         @initial_state = state_name
       end
 
-      # TODO: turn even guards into types of triggers ... then support :guard as a trigger param
-      guards = []
+      requirements = []
       message = :invalid_transition
-      # TODO: differentiate messages for :from errors vs. :guard errors
 
       options.each do |key, val|
         case key
         when :from
-          from_vals = Array(val).map(&:to_s)
+          from_vals = Array(val).compact.map(&:to_s)
           from_vals << nil # for new records
-          guards << Proc.new do |r|
-            val_was = r.send("#{column}_was")
-            val_was &&= val_was.to_s
+          requirements << lambda do |r|
+            val_was = r.send("#{column}_was")&.to_s
             from_vals.include? val_was
           end
-        when :guard, :require
-          guards += Array(val)
+        when :require
+          requirements += Array(val)
         when :message
           message = val
         when :timestamp
-          @triggers << {:from=>["*"], :to=>[state_name], :trigger=>[Proc.new{|r| r.send("#{val}=", Time.now.utc)}]}
+          @triggers << Trigger.new(self, from: '*', to: state_name, trigger: lambda{|r| r.send("#{val}=", Time.now.utc)}, type: :timestamp)
         when :on_enter
-          @triggers << {:from=>["*"], :to=>[state_name], :trigger=>Array(val), :type=>:on_enter}
+          @triggers << Trigger.new(self, from: '*', to: state_name, trigger: val, type: :on_enter)
         when :on_enter_deferred
-          raise(ArgumentError, "use of deferred triggers requires support for #after_save callbacks") unless @parent_context.respond_to?(:after_save)
-          @triggers << {:from=>["*"], :to=>[state_name], :trigger=>Array(val), :type=>:on_enter, :deferred=>true}
+          @triggers << Trigger.new(self, from: '*', to: state_name, trigger: val, type: :on_enter, deferred: true)
         when :on_exit
-          @triggers << {:from=>[state_name], :to=>["*"], :trigger=>Array(val), :type=>:on_exit}
+          @triggers << Trigger.new(self, from: state_name, to: '*', trigger: val, type: :on_exit)
         when :on_exit_deferred
-          raise(ArgumentError, "use of deferred triggers requires support for #after_save callbacks") unless @parent_context.respond_to?(:after_save)
-          @triggers << {:from=>[state_name], :to=>["*"], :trigger=>Array(val), :type=>:on_exit, :deferred=>true}
+          @triggers << Trigger.new(self, from: state_name, to: '*', trigger: val, type: :on_exit, deferred: true)
+        else
+          raise ArgumentError, "Unknown argument #{key.inspect}"
         end
       end
 
-      @states[state_name] = {:guards=>guards, :message=>message}
+      @states[state_name] = {requirements: requirements, message: message}
     end
 
 
     def on(pairs)
       trigger  = pairs.delete :trigger
       deferred = pairs.delete :deferred
-      raise(ArgumentError, "use of deferred triggers requires support for #after_save callbacks") if deferred && !@parent_context.respond_to?(:after_save)
       pairs.each do |from, to|
-        @triggers << {:from=>Array(from).map(&:to_s), :to=>Array(to).map(&:to_s), 
-                      :trigger=>Array(trigger), :type=>:trigger, :deferred=>!!deferred}
+        @triggers << Trigger.new(self, from: from, to: to, trigger: trigger, type: :trigger, deferred: deferred)
       end
     end
 
 
 
     def known?(to)
-      to &&= to.to_s
-      @states.keys.include? to
+      to = to&.to_s
+      states.keys.include? to
     end
 
     def allow?(record, to)
-      to &&= to.to_s
+      to = to&.to_s
       return false unless known?(to)
-      states[to][:guards].all? do |g|
+      states[to][:requirements].all? do |g|
         case g
         when Proc
-          g.call record
+          if g.arity.zero?
+            record.instance_eval(&g)
+          else
+            g.call record
+          end
         when Symbol, String
           record.send g
         else
-          raise ArgumentError, "Expecing Symbol or Proc for :guard, got #{g.class} : #{g}"
+          raise ArgumentError, "Expecing Symbol or Proc for :require, got #{g.class} : #{g}"
         end
       end
     end
 
     def message(to)
-      to &&= to.to_s
+      to = to&.to_s
       states[to][:message]
     end
 
 
-    def trigger(record, from, to, deferred=false)
-      from &&= from.to_s
-      to &&= to.to_s
-      # Rails.logger.debug "Checking triggers for transition #{from} to #{to} (deferred:#{deferred.inspect})"
+    # conditions - :deferred
+    def triggers_for(from:, to:, **conditions)
+      from = from&.to_s
+      to   = to&.to_s
+      # Rails.logger.debug "Checking triggers for transition #{from.inspect} to #{to.inspect} (#{conditions.inspect})"
       @triggers.select do |trigger|
-        deferred ? trigger[:deferred] : !trigger[:deferred]
-      end.select do |trigger|
-        (trigger[:from].include?("*") || trigger[:from].include?(from)) &&
-            (trigger[:to].include?("*") || trigger[:to].include?(to))
+        trigger.matches? from: from, to: to, **conditions
       # end.each do |trigger|
-      #   Rails.logger.debug "  Matched trigger: #{trigger[:from].inspect} -- #{trigger[:to].inspect}"
-      end.each do |trigger|
-        call_triggers record, trigger
-      end
-    end
-
-
-    private
-
-    def call_triggers(record, trigger)
-      trigger[:trigger].each do |m|
-        case m
-        when Proc
-          m.call record
-        when Symbol, String
-          record.send m
-        else
-          raise ArgumentError, "Expecing Symbol or Proc for #{trigger[:type].inspect}, got #{m.class} : #{m}"
-        end
+      #   Rails.logger.debug "  Matched trigger: #{trigger.from.inspect} -- #{trigger.to.inspect}"
       end
     end
 

data/lib/can_has_state/machine.rb

@@ -5,107 +5,136 @@ module CanHasState
     module ClassMethods
 
       def state_machine(column, &block)
+        column = column.to_sym
+        raise(ArgumentError, "State machine for #{column} already exists") if state_machines.key?(column)
+
         d = Definition.new(column, self, &block)
 
         define_method "allow_#{column}?" do |to|
           state_machine_allow?(column.to_sym, to.to_s)
         end
 
-        self.state_machines += [[column.to_sym, d]]
+        self.state_machines = state_machines.merge(column => d)
+        column
       end
 
       def extend_state_machine(column, &block)
-        sm = state_machines.detect{|(col, _)| col == column}
-          # |(col, stm)|
-        raise(ArgumentError, "Unknown state machine #{column}") unless sm
-        sm[1].extend_machine(&block)
-        sm
+        column = column.to_sym
+        sm = state_machines[column] || raise(ArgumentError, "Unknown state machine #{column}")
+
+        # handle when sm is inherited from a parent class
+        if sm.parent_context != self
+          sm = sm.dup
+          sm.parent_context = self
+          self.state_machines = state_machines.merge(column => sm)
+        end
+
+        sm.extend_machine(&block)
+        column
       end
 
     end
 
     included do
-      unless method_defined? :state_machines
-        class_attribute :state_machines, :instance_writer=>false
-        self.state_machines = []
-      end
-      before_validation :can_has_initial_states
-      before_validation :can_has_state_triggers
-      validate :can_has_valid_state_machines
-      after_save :can_has_deferred_state_triggers if respond_to?(:after_save)
+      class_attribute :state_machines, instance_writer: false, default: {}
+      before_validation :set_initial_state_machine_values
+      before_validation :reset_state_triggers
+      before_validation :run_state_triggers
+      validate :validate_state_machines
+      after_save :run_deferred_state_triggers if respond_to?(:after_save)
     end
 
 
     private
 
-    def can_has_initial_states
-      state_machines.each do |(column, sm)|
+    def set_initial_state_machine_values
+      state_machines.each do |column, sm|
         if send(column).blank?
           send("#{column}=", sm.initial_state)
         end
       end
     end
 
-    def can_has_state_triggers
+    def reset_state_triggers
+      @triggers_called = {}
+    end
+
+    def run_state_triggers
       # skip triggers if any state machine isn't valid
       return if can_has_state_errors.any?
 
-      @triggers_called ||= {}
-      state_machines.each do |(column, sm)|
-        from, to = send("#{column}_was"), send(column)
-        next if from == to
+      state_machines.size.times do
+        called = false
+        state_machines.each do |column, sm|
+          from, to = send("#{column}_was"), send(column)
+          next if from == to
 
-        # skip triggers if they've already been called for this from/to transition
-        next if @triggers_called[column] == [from, to]
+          @triggers_called[column] ||= []
+          triggers = sm.triggers_for(from: from, to: to)
 
-        sm.trigger(self, from, to)
+          triggers.each do |trigger|
+            # skip trigger if it's already been called
+            next if @triggers_called[column].include? trigger
 
-        # record that triggers were called
-        @triggers_called[column] = [from, to]
+            trigger.call self
+            @triggers_called[column] << trigger
+            called = true
+          end
+        end
+        break unless called
       end
     end
 
-    def can_has_deferred_state_triggers
-      @triggers_called ||= {}
-      state_machines.each do |(column, sm)|
-        # clear record of called triggers
-        @triggers_called[column] = nil
-        
+    def run_deferred_state_triggers
+      tg = @triggers_called ||= {}
+        # if a trigger causes a circular save, @triggers_called can be reset mid-stream,
+        # causing `... << trigger` at the bottom to fail. this ensure we have a local
+        # copy that won't be reset.
+
+      state_machines.each do |column, sm|
         if respond_to?("#{column}_before_last_save") # rails 5.1+
           from, to = send("#{column}_before_last_save"), send(column)
         else
           from, to = send("#{column}_was"), send(column)
         end
         next if from == to
-        sm.trigger(self, from, to, :deferred)
+
+        tg[column] ||= []
+        triggers = sm.triggers_for(from: from, to: to, deferred: true)
+
+        triggers.each do |trigger|
+          next if tg[column].include? trigger
+
+          trigger.call self
+          tg[column] << trigger
+        end
       end
     end
 
-    def can_has_state_errors
-      err = []
-      state_machines.each do |(column, sm)|
+    def can_has_state_errors(reset: true)
+      @can_has_state_errors = {} if reset || !@can_has_state_errors
+      state_machines.each do |column, sm|
         from, to = send("#{column}_was"), send(column)
-        next if from == to
         if !sm.known?(to)
-          err << [column, :invalid_state]
+          @can_has_state_errors[column] = [:invalid_state]
+        elsif from == to
+          next
         elsif !sm.allow?(self, to) #state_machine_allow?(column, to)
-          err << [column, sm.message(to), {from: from, to: to}]
+          @can_has_state_errors[column] = [sm.message(to), {from: "'#{from}'", to: "'#{to}'"}]
         end
       end
-      err
+      @can_has_state_errors
     end
 
-    def can_has_valid_state_machines
-      can_has_state_errors.each do |(column, msg, opts)|
+    def validate_state_machines
+      can_has_state_errors(reset: false).each do |column, (msg, opts)|
         errors.add column, msg, **(opts||{})
       end
     end
 
     def state_machine_allow?(column, to)
-      sm = state_machines.detect{|(col, _)| col == column}
-        # |(col, stm)|
-      raise("Unknown state machine #{column}") unless sm
-      sm[1].allow?(self, to)
+      sm = state_machines[column.to_sym] || raise("Unknown state machine #{column}")
+      sm.allow?(self, to)
     end
 
   end

data/lib/can_has_state/trigger.rb

@@ -0,0 +1,62 @@
+module CanHasState
+  class Trigger
+
+    attr_accessor :state_machine
+    attr_reader :from, :to, :type, :deferred, :perform
+
+    def initialize(definition, from:, to:, type:, deferred: false, trigger:)
+      @state_machine = definition
+      @from          = Array(from).map{|v| v&.to_s}
+      @to            = Array(to).map{|v| v&.to_s}
+      @type          = type
+      @deferred      = !!deferred
+      @perform       = Array(trigger)
+
+      if @deferred && !state_machine.parent_context.respond_to?(:after_save)
+        raise ArgumentError, 'use of deferred triggers requires support for #after_save callbacks'
+      end
+      @perform.each do |m|
+        unless [Proc, String, Symbol].include?(m.class)
+          raise ArgumentError, "Expecing Symbol or Proc for #{@type.inspect}, got #{m.class} : #{m}"
+        end
+      end
+    end
+
+    def matches?(from:, to:, deferred: false)
+      matches_from?(from) &&
+        matches_to?(to) &&
+        matches_deferred?(deferred)
+    end
+
+    def call(record)
+      perform.each do |m|
+        case m
+        when Proc
+          if m.arity.zero?
+            record.instance_eval(&m)
+          else
+            m.call record
+          end
+        when Symbol, String
+          record.send m
+        end
+      end
+    end
+
+
+    private
+
+    def matches_from?(state)
+      from.include?('*') || from.include?(state)
+    end
+
+    def matches_to?(state)
+      to.include?('*') || to.include?(state)
+    end
+
+    def matches_deferred?(defer)
+      defer ? self.deferred : !self.deferred
+    end
+
+  end
+end

data/lib/can_has_state/version.rb

@@ -1,3 +1,3 @@
 module CanHasState
-  VERSION = '0.7.0'
+  VERSION = '0.9.0'
 end

data/lib/can_has_state.rb

@@ -1,7 +1,7 @@
-require 'active_support'
+require 'active_support/all'
 require 'active_model'
 
-%w(definition dirty_helper machine).each do |f|
+%w(definition dirty_helper machine trigger).each do |f|
   require "can_has_state/#{f}"
 end
 

data/test/can_has_state_test.rb

@@ -1,5 +1,31 @@
 require 'test_helper'
 
+class Skeleton
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+  include CanHasState::DirtyHelper
+  include CanHasState::Machine
+
+  track_dirty :state
+
+  state_machine :state do
+    state :awesome
+    state :fabulous, :initial
+  end
+
+  def self.after_save(...)
+    # dummy to allow deferred triggers
+  end
+
+  def fake_persist
+    if valid?
+      # reset dirty tracking as if we had persisted
+      changes_applied
+      true
+    end
+  end
+end
+
 class Account
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
@@ -41,21 +67,7 @@ class UserState
     state :fabulous, :initial
   end
 end
-class UserExtended
-  include ActiveModel::Validations
-  include ActiveModel::Validations::Callbacks
-  include CanHasState::Machine
-  state_machine :state do
-    state :awesome
-    state :fabulous, :initial
-  end
-  extend_state_machine :state do
-    state :incredible, :initial
-  end
-  extend_state_machine :state do
-    state :fantastic
-  end
-end
+
 class UserPreState
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
@@ -78,16 +90,36 @@ class CanHasStateTest < Minitest::Test
     assert UserState.respond_to?(:state_machines)
     assert UserState.new.respond_to?(:allow_state?)
     assert_equal 1, UserState.state_machines.size
-    sm = UserState.state_machines[0][1]
+    sm = UserState.state_machines[:state]
     assert_equal :state, sm.column
     assert_equal 2, sm.states.size
     assert_equal 0, sm.triggers.size
     assert_equal 'fabulous', sm.initial_state
   end
 
+  def test_invalid_state_option
+    assert_raises(ArgumentError) do
+      build_from_skeleton do
+        state_machine :color do
+          state :red,
+            made_up: :option
+        end
+      end
+    end
+  end
+
   def test_builder_extended
-    assert_equal 1, UserExtended.state_machines.size
-    sm = UserExtended.state_machines[0][1]
+    kl = build_from_skeleton do
+      extend_state_machine :state do
+        state :incredible, :initial
+      end
+      extend_state_machine :state do
+        state :fantastic
+      end
+    end
+
+    assert_equal 1, kl.state_machines.size
+    sm = kl.state_machines[:state]
     assert_equal :state, sm.column
     assert_equal 4, sm.states.size
     assert_equal 0, sm.triggers.size
@@ -96,7 +128,7 @@ class CanHasStateTest < Minitest::Test
 
   def test_extending
     assert_raises(ArgumentError) do
-      UserState.class_eval do
+      build_from_skeleton do
         extend_state_machine :doesnt_exist do
           state :phantom
         end
@@ -104,11 +136,34 @@ class CanHasStateTest < Minitest::Test
     end
   end
 
+  def test_extending_child_doesnt_affect_parent
+    child = build_from_skeleton do
+      attr_accessor :trigger_called
+      extend_state_machine :state do
+        on :* => :*, trigger: ->(r){ r.trigger_called = true}
+      end
+    end
+    assert_equal 0, Skeleton.state_machines[:state].triggers.size
+    assert_equal 1, child.state_machines[:state].triggers.size
+
+    m = Skeleton.new
+    m.state = 'awesome'
+    refute m.respond_to?(:trigger_called=)
+    assert m.fake_persist
+    # should not raise error calling trigger_called=
+
+    m = child.new
+    m.state = 'awesome'
+    assert m.fake_persist
+    assert_equal true, m.trigger_called
+  end
+
+
   def test_deferred_unavailable
     assert_raises(ArgumentError) do
       UserPreState.class_eval do
         state_machine :state_one do
-          state :one, on_enter_deferred: ->{ raise "Shouldn't get here" }
+          state :one, on_enter_deferred: proc{ raise "Shouldn't get here" }
         end
       end
     end
@@ -116,7 +171,7 @@ class CanHasStateTest < Minitest::Test
     assert_raises(ArgumentError) do
       UserPreState.class_eval do
         state_machine :state_two do
-          state :two, on_exit_deferred: ->{ raise "Shouldn't get here" }
+          state :two, on_exit_deferred: proc{ raise "Shouldn't get here" }
         end
       end
     end
@@ -125,7 +180,7 @@ class CanHasStateTest < Minitest::Test
       UserPreState.class_eval do
         state_machine :state_three do
           state :three
-          on :* => :*, trigger: ->{ raise "Shouldn't get here" }, deferred: true
+          on :* => :*, trigger: proc{ raise "Shouldn't get here" }, deferred: true
         end
       end
     end
@@ -134,27 +189,28 @@ class CanHasStateTest < Minitest::Test
   def test_deferred_available
     UserPreState2.class_eval do
       state_machine :state_one do
-        state :one, on_enter_deferred: ->{ puts 'Hello' }
+        state :one, on_enter_deferred: proc{ puts 'Hello' }
       end
     end
 
     UserPreState2.class_eval do
       state_machine :state_two do
-        state :two, on_exit_deferred: ->{ puts 'Hello' }
+        state :two, on_exit_deferred: proc{ puts 'Hello' }
       end
     end
 
     UserPreState2.class_eval do
       state_machine :state_three do
         state :three
-        on :* => :*, trigger: ->{ puts 'Hello' }, deferred: true
+        on :* => :*, trigger: proc{ puts 'Hello' }, deferred: true
       end
     end
   end
 
+
   def test_builder_complex
     assert_equal 1, Account.state_machines.size
-    sm = Account.state_machines[0][1]
+    sm = Account.state_machines[:account_state]
     assert_equal :account_state, sm.column
     assert_equal 4, sm.states.size
     assert_equal 2, sm.triggers.size
@@ -162,10 +218,10 @@ class CanHasStateTest < Minitest::Test
   end
 
   def test_state_builder
-    sm_acct = Account.state_machines[0][1]
-    sm_user = UserState.state_machines[0][1]
-    assert_equal 0, sm_user.states['awesome'][:guards].size
-    assert_equal 1, sm_acct.states['active'][:guards].size
+    sm_acct = Account.state_machines[:account_state]
+    sm_user = UserState.state_machines[:state]
+    assert_equal 0, sm_user.states['awesome'][:requirements].size
+    assert_equal 1, sm_acct.states['active'][:requirements].size
   end
 
 
@@ -185,6 +241,7 @@ class CanHasStateTest < Minitest::Test
     assert_equal 'inactive', a.account_state_was
   end
 
+
   def test_state_vals
     a = Account.new
     a.account_state = :inactive
@@ -200,6 +257,19 @@ class CanHasStateTest < Minitest::Test
     assert_equal ['Account state is not in a known state'], a.errors.to_a
   end
 
+  def test_state_with_invalid_default
+    kl = build_from_skeleton do
+      include ActiveModel::Attributes
+      attribute :state, :string, default: 'madeup'
+    end
+
+    m = kl.new
+    assert_equal 'madeup', m.state
+    refute m.valid?
+    assert m.errors.of_kind?(:state, :invalid_state)
+  end
+
+
   def test_triggers
     a = Account.new
     a.fake_persist
@@ -217,7 +287,63 @@ class CanHasStateTest < Minitest::Test
     assert a.undeleted, 'Expecting undeleted to be set'
   end
 
-  def test_guards
+  def test_trigger_symbol
+    kl = build_from_skeleton do
+      attr_accessor :trigger_called
+      extend_state_machine :state do
+        on :* => :*, trigger: :call_trigger
+      end
+      def call_trigger
+        self.trigger_called = true
+      end
+    end
+    a = kl.new
+    refute a.trigger_called
+
+    a.state = 'awesome'
+    assert a.fake_persist
+    assert a.trigger_called
+  end
+
+  def test_trigger_proc_arity_0
+    kl = build_from_skeleton do
+      attr_accessor :trigger_called
+      extend_state_machine :state do
+        on :* => :*, trigger: Proc.new{self.trigger_called = true}
+      end
+    end
+    a = kl.new
+    refute a.trigger_called
+
+    a.state = 'awesome'
+    assert a.fake_persist
+    assert a.trigger_called
+  end
+
+  def test_trigger_proc_arity_1
+    kl = build_from_skeleton do
+      attr_accessor :trigger_called
+      extend_state_machine :state do
+        on :* => :*, trigger: lambda{|r| r.trigger_called = true}
+      end
+    end
+    a = kl.new
+    refute a.trigger_called
+
+    a.state = 'awesome'
+    assert a.fake_persist
+    assert a.trigger_called
+  end
+
+
+  def test_transition_messagea_when_from_nil
+    a = Account.new
+    a.account_state = 'special'
+    a.validate
+    assert_match(/has an invalid transition from '' to 'special'/, a.errors.to_a.first)
+  end
+
+  def test_requirements
     a = Account.new
     a.account_state = 'deleted'
     assert a.fake_persist
@@ -238,4 +364,121 @@ class CanHasStateTest < Minitest::Test
     assert a.valid?, "Errors: #{a.errors.to_a}"
   end
 
+
+  def test_interacting_triggers
+    kl = build_from_skeleton do
+      track_dirty :mood, :outlook
+      attr_accessor :called_on_state, :called_on_mood, :called_on_outlook
+      extend_state_machine :state do
+        on :* => :awesome, trigger: proc{ self.called_on_state += 1 }
+      end
+      state_machine :mood do
+        state :happy
+        state :delighted,
+          on_enter: proc{
+            self.state = 'awesome'
+            self.outlook = 'outstanding'
+            self.called_on_mood += 1
+          }
+      end
+      state_machine :outlook do
+        state :positive
+        state :outstanding
+        on :positive => :*, trigger: proc{ self.called_on_outlook += 1 }
+      end
+      def initialize
+        @called_on_state   = 0
+        @called_on_mood    = 0
+        @called_on_outlook = 0
+      end
+    end
+    m = kl.new
+    assert m.fake_persist
+    assert_equal 0, m.called_on_mood
+    assert_equal 0, m.called_on_outlook
+    assert_equal 0, m.called_on_state
+
+    m.mood = 'delighted'
+    assert m.fake_persist
+    assert_equal 1, m.called_on_mood
+    assert_equal 1, m.called_on_outlook, 'should trigger on later state_machines'
+    assert_equal 1, m.called_on_state, 'should trigger on earlier state_machines'
+  end
+
+
+  def test_errors_resolved_in_later_callback_are_kept
+    # Triggers are skipped when the state_machine has validation errors.
+    # Whether or not to skip is decided in an early before_validation callback.
+    # Even if a later callback resolves the validation error, it's important to
+    # still bubble up the errors since triggers did not run.
+    kl = build_from_skeleton do
+      attr_accessor :have_beans, :coffee_in_hand
+      extend_state_machine :state do
+        state :incredible,
+          require: proc{ coffee_in_hand > 0 }
+      end
+      before_validation { self.coffee_in_hand += 1 if have_beans }
+      def initialize
+        @coffee_in_hand = 0
+      end
+    end
+    m = kl.new
+    m.state = 'incredible'
+    refute m.valid?
+    assert m.errors.of_kind?(:state, :invalid_transition)
+    assert_equal 0, m.coffee_in_hand
+
+    m = kl.new
+    m.have_beans = true
+    m.state = 'incredible'
+    refute m.valid?
+    assert m.errors.of_kind?(:state, :invalid_transition)
+    assert_equal 1, m.coffee_in_hand
+  end
+
+  def test_rerunning_triggers_clears_pre_callback_errors
+    # To resolve the issue above, it is possible to re-eval the state_machine
+    # and run triggers if validations now pass. This is highly discouraged as
+    # complex callback callback interactions like this should be refactored out
+    # if at all possible.
+    # Not an officially supported solution and subject to change, but
+    # documented here to show that it is (presently) possible.
+    kl = build_from_skeleton do
+      attr_accessor :have_beans, :coffee_in_hand, :we_are_incredible
+      extend_state_machine :state do
+        state :incredible,
+          require: proc{ coffee_in_hand > 0 },
+          on_enter: proc{ self.we_are_incredible = true }
+      end
+      before_validation do
+        self.coffee_in_hand += 1 if have_beans
+        run_state_triggers
+      end
+      def initialize
+        @coffee_in_hand = 0
+      end
+    end
+    m = kl.new
+    m.state = 'incredible'
+    refute m.valid?
+    assert m.errors.of_kind?(:state, :invalid_transition)
+    assert_equal 0, m.coffee_in_hand
+    refute m.we_are_incredible
+
+    m = kl.new
+    m.have_beans = true
+    m.state = 'incredible'
+    assert m.valid?
+    assert_equal 1, m.coffee_in_hand
+    assert m.we_are_incredible
+  end
+
+
+
+  def build_from_skeleton(&block)
+    Class.new(Skeleton).tap do |kl|
+      kl.class_eval(&block)
+    end
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: can_has_state
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - thomas morgan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-27 00:00:00.000000000 Z
+date: 2023-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
     - - "<"
       - !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: '5.2'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -92,6 +92,7 @@ files:
 - lib/can_has_state/locale/ja.yml
 - lib/can_has_state/machine.rb
 - lib/can_has_state/railtie.rb
+- lib/can_has_state/trigger.rb
 - lib/can_has_state/version.rb
 - lib/tasks/can_has_state_tasks.rake
 - test/can_has_state_test.rb
@@ -108,14 +109,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Super simple state machine for ActiveModel