statesman 7.4.0 → 12.1.0

data/lib/statesman/adapters/active_record.rb

@@ -7,19 +7,15 @@ module Statesman
     class ActiveRecord
       JSON_COLUMN_TYPES = %w[json jsonb].freeze
 
-      def self.database_supports_partial_indexes?
+      def self.database_supports_partial_indexes?(model)
         # Rails 3 doesn't implement `supports_partial_index?`
-        if ::ActiveRecord::Base.connection.respond_to?(:supports_partial_index?)
-          ::ActiveRecord::Base.connection.supports_partial_index?
+        if model.connection.respond_to?(:supports_partial_index?)
+          model.connection.supports_partial_index?
         else
-          ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+          model.connection.adapter_name.casecmp("postgresql").zero?
         end
       end
 
-      def self.adapter_name
-        ::ActiveRecord::Base.connection.adapter_name.downcase
-      end
-
       def initialize(transition_class, parent_model, observer, options = {})
         serialized = serialized?(transition_class)
         column_type = transition_class.columns_hash["metadata"].sql_type
@@ -42,11 +38,17 @@ module Statesman
       def create(from, to, metadata = {})
         create_transition(from.to_s, to.to_s, metadata)
       rescue ::ActiveRecord::RecordNotUnique => e
-        raise TransitionConflictError, e.message if transition_conflict_error? e
+        if transition_conflict_error? e
+          # The history has the invalid transition on the end of it, which means
+          # `current_state` would then be incorrect. We force a reload of the history to
+          # avoid this.
+          transitions_for_parent.reload
+          raise TransitionConflictError, e.message
+        end
 
         raise
       ensure
-        @last_transition = nil
+        reset
       end
 
       def history(force_reload: false)
@@ -62,23 +64,30 @@ module Statesman
       def last(force_reload: false)
         if force_reload
           @last_transition = history(force_reload: true).last
+        elsif instance_variable_defined?(:@last_transition)
+          @last_transition
         else
-          @last_transition ||= history.last
+          @last_transition = history.last
+        end
+      end
+
+      def reset
+        if instance_variable_defined?(:@last_transition)
+          remove_instance_variable(:@last_transition)
         end
       end
 
       private
 
-      # rubocop:disable Metrics/MethodLength
       def create_transition(from, to, metadata)
         transition = transitions_for_parent.build(
           default_transition_attributes(to, metadata),
         )
 
-        ::ActiveRecord::Base.transaction(requires_new: true) do
+        transition_class.transaction(requires_new: true) do
           @observer.execute(:before, from, to, transition)
 
-          if mysql_gaplock_protection?
+          if mysql_gaplock_protection?(transition_class.connection)
             # We save the transition first with most_recent falsy, then mark most_recent
             # true after to avoid letting MySQL acquire a next-key lock which can cause
             # deadlocks.
@@ -106,7 +115,6 @@ module Statesman
 
         transition
       end
-      # rubocop:enable Metrics/MethodLength
 
       def default_transition_attributes(to, metadata)
         {
@@ -118,8 +126,8 @@ module Statesman
       end
 
       def add_after_commit_callback(from, to, transition)
-        ::ActiveRecord::Base.connection.add_transaction_record(
-          ActiveRecordAfterCommitWrap.new do
+        transition_class.connection.add_transaction_record(
+          ActiveRecordAfterCommitWrap.new(transition_class.connection) do
             @observer.execute(:after_commit, from, to, transition)
           end,
         )
@@ -132,7 +140,7 @@ module Statesman
       # Sets the given transition most_recent = t while unsetting the most_recent of any
       # previous transitions.
       def update_most_recents(most_recent_id = nil)
-        update = build_arel_manager(::Arel::UpdateManager)
+        update = build_arel_manager(::Arel::UpdateManager, transition_class)
         update.table(transition_table)
         update.where(most_recent_transitions(most_recent_id))
         update.set(build_most_recents_update_all_values(most_recent_id))
@@ -140,20 +148,33 @@ module Statesman
         # MySQL will validate index constraints across the intermediate result of an
         # update. This means we must order our update to deactivate the previous
         # most_recent before setting the new row to be true.
-        update.order(transition_table[:most_recent].desc) if mysql_gaplock_protection?
+        if mysql_gaplock_protection?(transition_class.connection)
+          update.order(transition_table[:most_recent].desc)
+        end
 
-        ::ActiveRecord::Base.connection.update(update.to_sql)
+        transition_class.connection.update(update.to_sql(transition_class))
       end
 
       def most_recent_transitions(most_recent_id = nil)
         if most_recent_id
-          transitions_of_parent.and(
+          concrete_transitions_of_parent.and(
             transition_table[:id].eq(most_recent_id).or(
               transition_table[:most_recent].eq(true),
             ),
           )
         else
-          transitions_of_parent.and(transition_table[:most_recent].eq(true))
+          concrete_transitions_of_parent.and(transition_table[:most_recent].eq(true))
+        end
+      end
+
+      def concrete_transitions_of_parent
+        if transition_sti?
+          transitions_of_parent.and(
+            transition_table[transition_class.inheritance_column].
+              eq(transition_class.name),
+          )
+        else
+          transitions_of_parent
         end
       end
 
@@ -200,7 +221,7 @@ module Statesman
         if most_recent_id
           Arel::Nodes::Case.new.
             when(transition_table[:id].eq(most_recent_id)).then(db_true).
-            else(not_most_recent_value).to_sql
+            else(not_most_recent_value).to_sql(transition_class)
         else
           Arel::Nodes::SqlLiteral.new(not_most_recent_value)
         end
@@ -210,26 +231,21 @@ module Statesman
       # change in Arel as we move into Rails >6.0.
       #
       # https://github.com/rails/rails/commit/7508284800f67b4611c767bff9eae7045674b66f
-      def build_arel_manager(manager)
+      def build_arel_manager(manager, engine)
         if manager.instance_method(:initialize).arity.zero?
           manager.new
         else
-          manager.new(::ActiveRecord::Base)
+          manager.new(engine)
         end
       end
 
       def next_sort_key
-        (last && last.sort_key + 10) || 10
+        (last && (last.sort_key + 10)) || 10
       end
 
       def serialized?(transition_class)
-        if ::ActiveRecord.respond_to?(:gem_version) &&
-            ::ActiveRecord.gem_version >= Gem::Version.new("4.2.0.a")
-          transition_class.type_for_attribute("metadata").
-            is_a?(::ActiveRecord::Type::Serialized)
-        else
-          transition_class.serialized_attributes.include?("metadata")
-        end
+        transition_class.type_for_attribute("metadata").
+          is_a?(::ActiveRecord::Type::Serialized)
       end
 
       def transition_conflict_error?(err)
@@ -240,7 +256,7 @@ module Statesman
       end
 
       def unique_indexes
-        ::ActiveRecord::Base.connection.
+        transition_class.connection.
           indexes(transition_class.table_name).
           select do |index|
             next unless index.unique
@@ -252,13 +268,18 @@ module Statesman
           end
       end
 
-      def parent_join_foreign_key
-        association =
-          parent_model.class.
-            reflect_on_all_associations(:has_many).
-            find { |r| r.name.to_s == @association_name.to_s }
+      def transition_sti?
+        transition_class.column_names.include?(transition_class.inheritance_column)
+      end
 
-        association_join_primary_key(association)
+      def parent_association
+        parent_model.class.
+          reflect_on_all_associations(:has_many).
+          find { |r| r.name.to_s == @association_name.to_s }
+      end
+
+      def parent_join_foreign_key
+        association_join_primary_key(parent_association)
       end
 
       def association_join_primary_key(association)
@@ -292,34 +313,42 @@ module Statesman
         return nil if column.nil?
 
         [
-          column, ::ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+          column, default_timezone == :utc ? Time.now.utc : Time.now
         ]
       end
 
-      def mysql_gaplock_protection?
-        Statesman.mysql_gaplock_protection?
+      def default_timezone
+        # Rails 7 deprecates ActiveRecord::Base.default_timezone
+        # in favour of ActiveRecord.default_timezone
+        if ::ActiveRecord.respond_to?(:default_timezone)
+          return ::ActiveRecord.default_timezone
+        end
+
+        ::ActiveRecord::Base.default_timezone
+      end
+
+      def mysql_gaplock_protection?(connection)
+        Statesman.mysql_gaplock_protection?(connection)
       end
 
       def db_true
-        value = ::ActiveRecord::Base.connection.type_cast(
-          true,
-          transition_class.columns_hash["most_recent"],
-        )
-        ::ActiveRecord::Base.connection.quote(value)
+        transition_class.connection.quote(type_cast(true))
       end
 
       def db_false
-        value = ::ActiveRecord::Base.connection.type_cast(
-          false,
-          transition_class.columns_hash["most_recent"],
-        )
-        ::ActiveRecord::Base.connection.quote(value)
+        transition_class.connection.quote(type_cast(false))
       end
 
       def db_null
         Arel::Nodes::SqlLiteral.new("NULL")
       end
 
+      # Type casting against a column is deprecated and will be removed in Rails 6.2.
+      # See https://github.com/rails/arel/commit/6160bfbda1d1781c3b08a33ec4955f170e95be11
+      def type_cast(value)
+        transition_class.connection.type_cast(value)
+      end
+
       # Check whether the `most_recent` column allows null values. If it doesn't, set old
       # records to `false`, otherwise, set them to `NULL`.
       #
@@ -337,9 +366,9 @@ module Statesman
     end
 
     class ActiveRecordAfterCommitWrap
-      def initialize(&block)
+      def initialize(connection, &block)
         @callback = block
-        @connection = ::ActiveRecord::Base.connection
+        @connection = connection
       end
 
       def self.trigger_transactional_callbacks?

data/lib/statesman/adapters/active_record_queries.rb

@@ -39,7 +39,7 @@ module Statesman
         end
 
         def included(base)
-          ensure_inheritance(base)
+          ensure_inheritance(base) if base.respond_to?(:subclasses) && base.subclasses.any?
 
           query_builder = QueryBuilder.new(base, **@args)
 
@@ -49,6 +49,14 @@ module Statesman
 
           define_in_state(base, query_builder)
           define_not_in_state(base, query_builder)
+
+          define_method(:reload) do |*a|
+            instance = super(*a)
+            if instance.respond_to?(:state_machine, true)
+              instance.send(:state_machine).reset
+            end
+            instance
+          end
         end
 
         private
@@ -95,18 +103,18 @@ module Statesman
         def states_where(states)
           if initial_state.to_s.in?(states.map(&:to_s))
             "#{most_recent_transition_alias}.to_state IN (?) OR " \
-            "#{most_recent_transition_alias}.to_state IS NULL"
+              "#{most_recent_transition_alias}.to_state IS NULL"
           else
             "#{most_recent_transition_alias}.to_state IN (?) AND " \
-            "#{most_recent_transition_alias}.to_state IS NOT NULL"
+              "#{most_recent_transition_alias}.to_state IS NOT NULL"
           end
         end
 
         def most_recent_transition_join
           "LEFT OUTER JOIN #{model_table} AS #{most_recent_transition_alias} " \
-             "ON #{model.table_name}.id = " \
-                  "#{most_recent_transition_alias}.#{model_foreign_key} " \
-             "AND #{most_recent_transition_alias}.most_recent = #{db_true}"
+            "ON #{model.table_name}.#{model_primary_key} = " \
+            "#{most_recent_transition_alias}.#{model_foreign_key} " \
+            "AND #{most_recent_transition_alias}.most_recent = #{db_true}"
         end
 
         private
@@ -127,6 +135,10 @@ module Statesman
                 "and #{transition_class}."
         end
 
+        def model_primary_key
+          transition_reflection.active_record_primary_key
+        end
+
         def model_foreign_key
           transition_reflection.foreign_key
         end
@@ -141,7 +153,7 @@ module Statesman
         end
 
         def db_true
-          ::ActiveRecord::Base.connection.quote(true)
+          model.connection.quote(true)
         end
       end
     end

data/lib/statesman/adapters/active_record_transition.rb

@@ -10,7 +10,11 @@ module Statesman
       extend ActiveSupport::Concern
 
       included do
-        serialize :metadata, JSON
+        if ::ActiveRecord.gem_version >= Gem::Version.new("7.1")
+          serialize :metadata, coder: JSON
+        else
+          serialize :metadata, JSON
+        end
 
         class_attribute :updated_timestamp_column
         self.updated_timestamp_column = DEFAULT_UPDATED_TIMESTAMP_COLUMN

data/lib/statesman/adapters/memory.rb

@@ -37,10 +37,14 @@ module Statesman
         @history
       end
 
+      def reset
+        @history = []
+      end
+
       private
 
       def next_sort_key
-        (last && last.sort_key + 10) || 10
+        (last && (last.sort_key + 10)) || 10
       end
     end
   end

data/lib/statesman/adapters/type_safe_active_record_queries.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Statesman
+  module Adapters
+    module TypeSafeActiveRecordQueries
+      def configure_state_machine(args = {})
+        transition_class = args.fetch(:transition_class)
+        initial_state = args.fetch(:initial_state)
+
+        include(
+          ActiveRecordQueries::ClassMethods.new(
+            transition_class: transition_class,
+            initial_state: initial_state,
+            most_recent_transition_alias: try(:most_recent_transition_alias),
+            transition_name: try(:transition_name),
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/statesman/callback.rb

@@ -40,11 +40,11 @@ module Statesman
     end
 
     def matches_from_state(from, to)
-      (from == self.from && (to.nil? || self.to.empty?))
+      from == self.from && (to.nil? || self.to.empty?)
     end
 
     def matches_to_state(from, to)
-      ((from.nil? || self.from.nil?) && self.to.include?(to))
+      (from.nil? || self.from.nil?) && self.to.include?(to)
     end
 
     def matches_both_states(from, to)

data/lib/statesman/config.rb

@@ -15,17 +15,10 @@ module Statesman
       @adapter_class = adapter_class
     end
 
-    def mysql_gaplock_protection?
-      return @mysql_gaplock_protection unless @mysql_gaplock_protection.nil?
-
+    def mysql_gaplock_protection?(connection)
       # If our adapter class suggests we're using mysql, enable gaplock protection by
       # default.
-      enable_mysql_gaplock_protection if mysql_adapter?(adapter_class)
-      @mysql_gaplock_protection
-    end
-
-    def enable_mysql_gaplock_protection
-      @mysql_gaplock_protection = true
+      mysql_adapter?(connection)
     end
 
     private
@@ -34,7 +27,7 @@ module Statesman
       adapter_name = adapter_name(adapter_class)
       return false unless adapter_name
 
-      adapter_name.start_with?("mysql")
+      adapter_name.downcase.start_with?("mysql", "trilogy")
     end
 
     def adapter_name(adapter_class)

data/lib/statesman/exceptions.rb

@@ -2,9 +2,13 @@
 
 module Statesman
   class InvalidStateError < StandardError; end
+
   class InvalidTransitionError < StandardError; end
+
   class InvalidCallbackError < StandardError; end
+
   class TransitionConflictError < StandardError; end
+
   class MissingTransitionAssociation < StandardError; end
 
   class TransitionFailedError < StandardError
@@ -24,13 +28,15 @@ module Statesman
   end
 
   class GuardFailedError < StandardError
-    def initialize(from, to)
+    def initialize(from, to, callback)
       @from = from
       @to = to
+      @callback = callback
       super(_message)
+      set_backtrace(callback.source_location.join(":")) if callback&.source_location
     end
 
-    attr_reader :from, :to
+    attr_reader :from, :to, :callback
 
     private
 
@@ -48,8 +54,8 @@ module Statesman
 
     def _message(transition_class_name)
       "#{transition_class_name}#metadata is not serialized. If you " \
-      "are using a non-json column type, you should `include " \
-      "Statesman::Adapters::ActiveRecordTransition`"
+        "are using a non-json column type, you should `include " \
+        "Statesman::Adapters::ActiveRecordTransition`"
     end
   end
 
@@ -62,9 +68,9 @@ module Statesman
 
     def _message(transition_class_name)
       "#{transition_class_name}#metadata column type cannot be json " \
-      "and serialized simultaneously. If you are using a json " \
-      "column type, it is not necessary to `include " \
-      "Statesman::Adapters::ActiveRecordTransition`"
+        "and serialized simultaneously. If you are using a json " \
+        "column type, it is not necessary to `include " \
+        "Statesman::Adapters::ActiveRecordTransition`"
     end
   end
 end

data/lib/statesman/guard.rb

@@ -6,7 +6,7 @@ require_relative "exceptions"
 module Statesman
   class Guard < Callback
     def call(*args)
-      raise GuardFailedError.new(from, to) unless super(*args)
+      raise GuardFailedError.new(from, to, callback) unless super(*args)
     end
   end
 end

data/lib/statesman/machine.rb

@@ -42,6 +42,17 @@ module Statesman
         states << name
       end
 
+      def remove_state(state_name)
+        state_name = state_name.to_s
+
+        remove_transitions(from: state_name)
+        remove_transitions(to: state_name)
+        remove_callbacks(from: state_name)
+        remove_callbacks(to: state_name)
+
+        @states.delete(state_name.to_s)
+      end
+
       def successors
         @successors ||= {}
       end
@@ -70,6 +81,20 @@ module Statesman
         successors[from] += to
       end
 
+      def remove_transitions(from: nil, to: nil)
+        raise ArgumentError, "Both from and to can't be nil!" if from.nil? && to.nil?
+        return if successors.nil?
+
+        if from.present?
+          @successors[from.to_s].delete(to.to_s) if to.present?
+          @successors.delete(from.to_s) if to.nil? || successors[from.to_s].empty?
+        elsif to.present?
+          @successors.
+            transform_values! { |to_states| to_states - [to.to_s] }.
+            filter! { |_from_state, to_states| to_states.any? }
+        end
+      end
+
       def before_transition(options = {}, &block)
         add_callback(callback_type: :before, callback_class: Callback,
                      from: options[:from], to: options[:to], &block)
@@ -151,6 +176,33 @@ module Statesman
           callback_class.new(from: from, to: to, callback: block)
       end
 
+      def remove_callbacks(from: nil, to: nil)
+        raise ArgumentError, "Both from and to can't be nil!" if from.nil? && to.nil?
+        return if callbacks.nil?
+
+        @callbacks.transform_values! do |callbacks|
+          filter_callbacks(callbacks, from: from, to: to)
+        end
+      end
+
+      def filter_callbacks(callbacks, from: nil, to: nil)
+        callbacks.filter_map do |callback|
+          next if callback.from == from && to.nil?
+
+          if callback.to.include?(to) && (from.nil? || callback.from == from)
+            next if callback.to == [to]
+
+            callback = Statesman::Callback.new({
+              from: callback.from,
+              to: callback.to - [to],
+              callback: callback.callback,
+            })
+          end
+
+          callback
+        end
+      end
+
       def validate_callback_type_and_class(callback_type, callback_class)
         raise ArgumentError, "missing keyword: callback_type" if callback_type.nil?
         raise ArgumentError, "missing keyword: callback_class" if callback_class.nil?
@@ -181,12 +233,20 @@ module Statesman
     def initialize(object,
                    options = {
                      transition_class: Statesman::Adapters::MemoryTransition,
+                     initial_transition: false,
                    })
       @object = object
       @transition_class = options[:transition_class]
       @storage_adapter = adapter_class(@transition_class).new(
         @transition_class, object, self, options
       )
+
+      if options[:initial_transition]
+        if history.empty? && self.class.initial_state
+          @storage_adapter.create(nil, self.class.initial_state)
+        end
+      end
+
       send(:after_initialize) if respond_to? :after_initialize
     end
 
@@ -209,6 +269,10 @@ module Statesman
       @storage_adapter.last(force_reload: force_reload)
     end
 
+    def last_transition_to(state)
+      history.reverse.find { |transition| transition.to_state.to_sym == state.to_sym }
+    end
+
     def can_transition_to?(new_state, metadata = {})
       validate_transition(from: current_state,
                           to: new_state,
@@ -257,6 +321,10 @@ module Statesman
       false
     end
 
+    def reset
+      @storage_adapter.reset
+    end
+
     private
 
     def adapter_class(transition_class)

data/lib/statesman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Statesman
-  VERSION = "7.4.0"
+  VERSION = "12.1.0"
 end

data/lib/statesman.rb

@@ -6,7 +6,7 @@ module Statesman
   autoload :Callback,   "statesman/callback"
   autoload :Guard,      "statesman/guard"
   autoload :Utils,      "statesman/utils"
-  autoload :Version,    "statesman/version"
+  autoload :VERSION,    "statesman/version"
   module Adapters
     autoload :Memory,       "statesman/adapters/memory"
     autoload :ActiveRecord, "statesman/adapters/active_record"
@@ -14,6 +14,8 @@ module Statesman
              "statesman/adapters/active_record_transition"
     autoload :ActiveRecordQueries,
              "statesman/adapters/active_record_queries"
+    autoload :TypeSafeActiveRecordQueries,
+             "statesman/adapters/type_safe_active_record_queries"
   end
   require "statesman/railtie" if defined?(::Rails::Railtie)
 
@@ -32,10 +34,8 @@ module Statesman
     @storage_adapter || Adapters::Memory
   end
 
-  def self.mysql_gaplock_protection?
-    return @mysql_gaplock_protection unless @mysql_gaplock_protection.nil?
-
-    @mysql_gaplock_protection = config.mysql_gaplock_protection?
+  def self.mysql_gaplock_protection?(connection)
+    config.mysql_gaplock_protection?(connection)
   end
 
   def self.config