statesman 3.5.0 → 7.4.0

data/lib/statesman/adapters/active_record_queries.rb

@@ -1,51 +1,124 @@
+# frozen_string_literal: true
+
 module Statesman
   module Adapters
     module ActiveRecordQueries
+      def self.check_missing_methods!(base)
+        missing_methods = %i[transition_class initial_state].
+          reject { |m| base.respond_to?(m) }
+        return if missing_methods.none?
+
+        raise NotImplementedError,
+              "#{missing_methods.join(', ')} method(s) should be defined on " \
+              "the model. Alternatively, use the new form of `include " \
+              "Statesman::Adapters::ActiveRecordQueries[" \
+              "transition_class: MyTransition, " \
+              "initial_state: :some_state]`"
+      end
+
       def self.included(base)
-        base.extend(ClassMethods)
+        check_missing_methods!(base)
+
+        base.include(
+          ClassMethods.new(
+            transition_class: base.transition_class,
+            initial_state: base.initial_state,
+            most_recent_transition_alias: base.try(:most_recent_transition_alias),
+            transition_name: base.try(:transition_name),
+          ),
+        )
       end
 
-      module ClassMethods
-        def in_state(*states)
-          states = states.flatten.map(&:to_s)
+      def self.[](**args)
+        ClassMethods.new(**args)
+      end
 
-          joins(most_recent_transition_join).
-            where(states_where(most_recent_transition_alias, states), states)
+      class ClassMethods < Module
+        def initialize(**args)
+          @args = args
         end
 
-        def not_in_state(*states)
-          states = states.flatten.map(&:to_s)
+        def included(base)
+          ensure_inheritance(base)
 
-          joins(most_recent_transition_join).
-            where("NOT (#{states_where(most_recent_transition_alias, states)})",
-                  states)
-        end
+          query_builder = QueryBuilder.new(base, **@args)
 
-        def most_recent_transition_join
-          "LEFT OUTER JOIN #{model_table} AS #{most_recent_transition_alias}
-             ON #{table_name}.id =
-                  #{most_recent_transition_alias}.#{model_foreign_key}
-             AND #{most_recent_transition_alias}.most_recent = #{db_true}"
+          base.define_singleton_method(:most_recent_transition_join) do
+            query_builder.most_recent_transition_join
+          end
+
+          define_in_state(base, query_builder)
+          define_not_in_state(base, query_builder)
         end
 
         private
 
-        def transition_class
-          raise NotImplementedError, "A transition_class method should be " \
-                                     "defined on the model"
+        def ensure_inheritance(base)
+          klass = self
+          existing_inherited = base.method(:inherited)
+          base.define_singleton_method(:inherited) do |subclass|
+            existing_inherited.call(subclass)
+            subclass.send(:include, klass)
+          end
+        end
+
+        def define_in_state(base, query_builder)
+          base.define_singleton_method(:in_state) do |*states|
+            states = states.flatten
+
+            joins(most_recent_transition_join).
+              where(query_builder.states_where(states), states)
+          end
+        end
+
+        def define_not_in_state(base, query_builder)
+          base.define_singleton_method(:not_in_state) do |*states|
+            states = states.flatten
+
+            joins(most_recent_transition_join).
+              where("NOT (#{query_builder.states_where(states)})", states)
+          end
+        end
+      end
+
+      class QueryBuilder
+        def initialize(model, transition_class:, initial_state:,
+                       most_recent_transition_alias: nil,
+                       transition_name: nil)
+          @model = model
+          @transition_class = transition_class
+          @initial_state = initial_state
+          @most_recent_transition_alias = most_recent_transition_alias
+          @transition_name = transition_name
         end
 
-        def initial_state
-          raise NotImplementedError, "An initial_state method should be " \
-                                     "defined on the model"
+        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"
+          else
+            "#{most_recent_transition_alias}.to_state IN (?) AND " \
+            "#{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}"
         end
 
+        private
+
+        attr_reader :model, :transition_class, :initial_state
+
         def transition_name
-          transition_class.table_name.to_sym
+          @transition_name || transition_class.table_name.to_sym
         end
 
         def transition_reflection
-          reflect_on_all_associations(:has_many).each do |value|
+          model.reflect_on_all_associations(:has_many).each do |value|
             return value if value.klass == transition_class
           end
 
@@ -62,18 +135,9 @@ module Statesman
           transition_reflection.table_name
         end
 
-        def states_where(temporary_table_name, states)
-          if initial_state.to_s.in?(states.map(&:to_s))
-            "#{temporary_table_name}.to_state IN (?) OR " \
-            "#{temporary_table_name}.to_state IS NULL"
-          else
-            "#{temporary_table_name}.to_state IN (?) AND " \
-            "#{temporary_table_name}.to_state IS NOT NULL"
-          end
-        end
-
         def most_recent_transition_alias
-          "most_recent_#{transition_name.to_s.singularize}"
+          @most_recent_transition_alias ||
+            "most_recent_#{transition_name.to_s.singularize}"
         end
 
         def db_true

data/lib/statesman/adapters/active_record_transition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json"
 
 module Statesman

data/lib/statesman/adapters/memory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json"
 
 module Statesman

data/lib/statesman/adapters/memory_transition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Statesman
   module Adapters
     class MemoryTransition

data/lib/statesman/callback.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "exceptions"
 
 module Statesman

data/lib/statesman/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json"
 require_relative "exceptions"
 
@@ -12,5 +14,31 @@ module Statesman
     def storage_adapter(adapter_class)
       @adapter_class = adapter_class
     end
+
+    def mysql_gaplock_protection?
+      return @mysql_gaplock_protection unless @mysql_gaplock_protection.nil?
+
+      # 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
+    end
+
+    private
+
+    def mysql_adapter?(adapter_class)
+      adapter_name = adapter_name(adapter_class)
+      return false unless adapter_name
+
+      adapter_name.start_with?("mysql")
+    end
+
+    def adapter_name(adapter_class)
+      adapter_class.respond_to?(:adapter_name) && adapter_class&.adapter_name
+    end
   end
 end

data/lib/statesman/exceptions.rb

@@ -1,12 +1,44 @@
+# frozen_string_literal: true
+
 module Statesman
   class InvalidStateError < StandardError; end
   class InvalidTransitionError < StandardError; end
   class InvalidCallbackError < StandardError; end
-  class GuardFailedError < StandardError; end
-  class TransitionFailedError < StandardError; end
   class TransitionConflictError < StandardError; end
   class MissingTransitionAssociation < StandardError; end
 
+  class TransitionFailedError < StandardError
+    def initialize(from, to)
+      @from = from
+      @to = to
+      super(_message)
+    end
+
+    attr_reader :from, :to
+
+    private
+
+    def _message
+      "Cannot transition from '#{from}' to '#{to}'"
+    end
+  end
+
+  class GuardFailedError < StandardError
+    def initialize(from, to)
+      @from = from
+      @to = to
+      super(_message)
+    end
+
+    attr_reader :from, :to
+
+    private
+
+    def _message
+      "Guard on transition from: '#{from}' to '#{to}' returned false"
+    end
+  end
+
   class UnserializedMetadataError < StandardError
     def initialize(transition_class_name)
       super(_message(transition_class_name))

data/lib/statesman/guard.rb

@@ -1,13 +1,12 @@
+# frozen_string_literal: true
+
 require_relative "callback"
 require_relative "exceptions"
 
 module Statesman
   class Guard < Callback
     def call(*args)
-      unless super(*args)
-        raise GuardFailedError,
-              "Guard on transition from: '#{from}' to '#{to}' returned false"
-      end
+      raise GuardFailedError.new(from, to) unless super(*args)
     end
   end
 end

data/lib/statesman/machine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "version"
 require_relative "exceptions"
 require_relative "guard"
@@ -46,10 +48,12 @@ module Statesman
 
       def callbacks
         @callbacks ||= {
-          before:       [],
-          after:        [],
+          before: [],
+          after: [],
+          after_transition_failure: [],
+          after_guard_failure: [],
           after_commit: [],
-          guards:       [],
+          guards: [],
         }
       end
 
@@ -83,6 +87,16 @@ module Statesman
                      from: options[:from], to: options[:to], &block)
       end
 
+      def after_transition_failure(options = {}, &block)
+        add_callback(callback_type: :after_transition_failure, callback_class: Callback,
+                     from: options[:from], to: options[:to], &block)
+      end
+
+      def after_guard_failure(options = {}, &block)
+        add_callback(callback_type: :after_guard_failure, callback_class: Callback,
+                     from: options[:from], to: options[:to], &block)
+      end
+
       def validate_callback_condition(options = { from: nil, to: nil })
         from = to_s_or_nil(options[:from])
         to   = array_to_s_or_nil(options[:to])
@@ -219,6 +233,17 @@ module Statesman
       @storage_adapter.create(initial_state, new_state, metadata)
 
       true
+    rescue TransitionFailedError => e
+      execute_on_failure(:after_transition_failure, initial_state, new_state, e)
+      raise
+    rescue GuardFailedError => e
+      execute_on_failure(:after_guard_failure, initial_state, new_state, e)
+      raise
+    end
+
+    def execute_on_failure(phase, initial_state, new_state, exception)
+      callbacks = callbacks_for(phase, from: initial_state, to: new_state)
+      callbacks.each { |cb| cb.call(@object, exception) }
     end
 
     def execute(phase, initial_state, new_state, transition)
@@ -265,10 +290,7 @@ module Statesman
       to   = to_s_or_nil(options[:to])
 
       successors = self.class.successors[from] || []
-      unless successors.include?(to)
-        raise TransitionFailedError,
-              "Cannot transition from '#{from}' to '#{to}'"
-      end
+      raise TransitionFailedError.new(from, to) unless successors.include?(to)
 
       # Call all guards, they raise exceptions if they fail
       guards_for(from: from, to: to).each do |guard|

data/lib/statesman/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Statesman
   class Railtie < ::Rails::Railtie
     railtie_name :statesman

data/lib/statesman/utils.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Statesman
   module Utils
     def self.rails_major_version

data/lib/statesman/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Statesman
-  VERSION = "3.5.0".freeze
+  VERSION = "7.4.0"
 end

data/lib/tasks/statesman.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :statesman do
   desc "Set most_recent to false for old transitions and to true for the "\
        "latest one. Safe to re-run"
@@ -19,7 +21,7 @@ namespace :statesman do
     batch_size = 500
 
     parent_class.find_in_batches(batch_size: batch_size) do |models|
-      ActiveRecord::Base.transaction do
+      ActiveRecord::Base.transaction(requires_new: true) do
         if Statesman::Adapters::ActiveRecord.database_supports_partial_indexes?
           # Set all transitions' most_recent to FALSE
           transition_class.where(parent_fk => models.map(&:id)).

data/spec/fixtures/add_constraints_to_most_recent_for_bacon_transitions_with_partial_index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddConstraintsToMostRecentForBaconTransitions < ActiveRecord::Migration
   disable_ddl_transaction!
 

data/spec/fixtures/add_constraints_to_most_recent_for_bacon_transitions_without_partial_index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddConstraintsToMostRecentForBaconTransitions < ActiveRecord::Migration
   disable_ddl_transaction!
 

data/spec/fixtures/add_most_recent_to_bacon_transitions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddMostRecentToBaconTransitions < ActiveRecord::Migration
   def up
     add_column :bacon_transitions, :most_recent, :boolean, null: true

data/spec/generators/statesman/active_record_transition_generator_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "support/generators_shared_examples"
 require "generators/statesman/active_record_transition_generator"

data/spec/generators/statesman/migration_generator_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "support/generators_shared_examples"
 require "generators/statesman/migration_generator"

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "statesman"
 require "sqlite3"
 require "mysql2"
@@ -20,36 +22,7 @@ RSpec.configure do |config|
   config.order = "random"
 
   def connection_failure
-    if defined?(Moped)
-      Moped::Errors::ConnectionFailure
-    else
-      Mongo::Error::NoServerAvailable
-    end
-  end
-
-  if config.exclusion_filter[:mongo]
-    puts "Skipping Mongo tests"
-  else
-    require "mongoid"
-
-    # Try a mongo connection at the start of the suite and raise if it fails
-    begin
-      Mongoid.configure do |mongo_config|
-        if defined?(Moped)
-          mongo_config.connect_to("statesman_test")
-          mongo_config.sessions["default"]["options"]["max_retries"] = 2
-        else
-          mongo_config.connect_to("statesman_test", server_selection_timeout: 2)
-        end
-      end
-      # Attempting a mongo operation will trigger 2 retries then throw an
-      # exception if mongo is not running.
-      Mongoid.purge!
-    rescue connection_failure => error
-      puts "The spec suite requires MongoDB to be installed and running locally"
-      puts "Mongo dependent specs can be filtered with rspec --tag '~mongo'"
-      raise(error)
-    end
+    Moped::Errors::ConnectionFailure if defined?(Moped)
   end
 
   if config.exclusion_filter[:active_record]