statesman 3.5.0 → 6.0.0

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 = "6.0.0"
 end

data/lib/statesman.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Statesman
   autoload :Config,     "statesman/config"
   autoload :Machine,    "statesman/machine"
@@ -12,9 +14,6 @@ module Statesman
              "statesman/adapters/active_record_transition"
     autoload :ActiveRecordQueries,
              "statesman/adapters/active_record_queries"
-    autoload :Mongoid, "statesman/adapters/mongoid"
-    autoload :MongoidTransition,
-             "statesman/adapters/mongoid_transition"
   end
   require "statesman/railtie" if defined?(::Rails::Railtie)
 

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]

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -1,6 +1,19 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
+  def configure_old(klass, transition_class)
+    klass.define_singleton_method(:transition_class) { transition_class }
+    klass.define_singleton_method(:initial_state) { :initial }
+    klass.send(:include, described_class)
+  end
+
+  def configure_new(klass, transition_class)
+    klass.send(:include, described_class[transition_class: transition_class,
+                                         initial_state: :initial])
+  end
+
   before do
     prepare_model_table
     prepare_transitions_table
@@ -8,32 +21,6 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
     prepare_other_transitions_table
 
     Statesman.configure { storage_adapter(Statesman::Adapters::ActiveRecord) }
-
-    MyActiveRecordModel.send(:include, Statesman::Adapters::ActiveRecordQueries)
-    MyActiveRecordModel.class_eval do
-      def self.transition_class
-        MyActiveRecordModelTransition
-      end
-
-      def self.initial_state
-        :initial
-      end
-    end
-
-    OtherActiveRecordModel.send(:include,
-                                Statesman::Adapters::ActiveRecordQueries)
-    OtherActiveRecordModel.class_eval do
-      def self.transition_class
-        OtherActiveRecordModelTransition
-      end
-
-      def self.initial_state
-        :initial
-      end
-    end
-
-    MyActiveRecordModel.send(:has_one, :other_active_record_model)
-    OtherActiveRecordModel.send(:belongs_to, :my_active_record_model)
   end
 
   after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
@@ -59,105 +46,164 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
     model
   end
 
-  describe ".in_state" do
-    context "given a single state" do
-      subject { MyActiveRecordModel.in_state(:succeeded) }
+  shared_examples "testing methods" do
+    before do
+      if config_type == :old
+        configure_old(MyActiveRecordModel, MyActiveRecordModelTransition)
+        configure_old(OtherActiveRecordModel, OtherActiveRecordModelTransition)
+      elsif config_type == :new
+        configure_new(MyActiveRecordModel, MyActiveRecordModelTransition)
+        configure_new(OtherActiveRecordModel, OtherActiveRecordModelTransition)
+      else
+        raise "Unknown config type #{config_type}"
+      end
 
-      it { is_expected.to include model }
-      it { is_expected.to_not include other_model }
+      MyActiveRecordModel.send(:has_one, :other_active_record_model)
+      OtherActiveRecordModel.send(:belongs_to, :my_active_record_model)
     end
 
-    context "given multiple states" do
-      subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
+    describe ".in_state" do
+      context "given a single state" do
+        subject { MyActiveRecordModel.in_state(:succeeded) }
+
+        it { is_expected.to include model }
+        it { is_expected.to_not include other_model }
+      end
 
-      it { is_expected.to include model }
-      it { is_expected.to include other_model }
-    end
+      context "given multiple states" do
+        subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
 
-    context "given the initial state" do
-      subject { MyActiveRecordModel.in_state(:initial) }
+        it { is_expected.to include model }
+        it { is_expected.to include other_model }
+      end
 
-      it { is_expected.to include initial_state_model }
-      it { is_expected.to include returned_to_initial_model }
-    end
+      context "given the initial state" do
+        subject { MyActiveRecordModel.in_state(:initial) }
 
-    context "given an array of states" do
-      subject { MyActiveRecordModel.in_state(%i[succeeded failed]) }
+        it { is_expected.to include initial_state_model }
+        it { is_expected.to include returned_to_initial_model }
+      end
 
-      it { is_expected.to include model }
-      it { is_expected.to include other_model }
-    end
+      context "given an array of states" do
+        subject { MyActiveRecordModel.in_state(%i[succeeded failed]) }
 
-    context "merging two queries" do
-      subject do
-        MyActiveRecordModel.in_state(:succeeded).
-          joins(:other_active_record_model).
-          merge(OtherActiveRecordModel.in_state(:initial))
+        it { is_expected.to include model }
+        it { is_expected.to include other_model }
       end
 
-      it { is_expected.to be_empty }
+      context "merging two queries" do
+        subject do
+          MyActiveRecordModel.in_state(:succeeded).
+            joins(:other_active_record_model).
+            merge(OtherActiveRecordModel.in_state(:initial))
+        end
+
+        it { is_expected.to be_empty }
+      end
     end
-  end
 
-  describe ".not_in_state" do
-    context "given a single state" do
-      subject { MyActiveRecordModel.not_in_state(:failed) }
+    describe ".not_in_state" do
+      context "given a single state" do
+        subject { MyActiveRecordModel.not_in_state(:failed) }
 
-      it { is_expected.to include model }
-      it { is_expected.to_not include other_model }
-    end
+        it { is_expected.to include model }
+        it { is_expected.to_not include other_model }
+      end
 
-    context "given multiple states" do
-      subject(:not_in_state) { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
+      context "given multiple states" do
+        subject(:not_in_state) { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
 
-      it do
-        expect(not_in_state).to match_array([initial_state_model,
-                                             returned_to_initial_model])
+        it do
+          expect(not_in_state).to match_array([initial_state_model,
+                                               returned_to_initial_model])
+        end
       end
-    end
 
-    context "given an array of states" do
-      subject(:not_in_state) { MyActiveRecordModel.not_in_state(%i[succeeded failed]) }
+      context "given an array of states" do
+        subject(:not_in_state) { MyActiveRecordModel.not_in_state(%i[succeeded failed]) }
 
-      it do
-        expect(not_in_state).to match_array([initial_state_model,
-                                             returned_to_initial_model])
+        it do
+          expect(not_in_state).to match_array([initial_state_model,
+                                               returned_to_initial_model])
+        end
       end
     end
-  end
 
-  context "with a custom name for the transition association" do
-    before do
-      # Switch to using OtherActiveRecordModelTransition, so the existing
-      # relation with MyActiveRecordModelTransition doesn't interfere with
-      # this spec.
-      MyActiveRecordModel.send(:has_many,
-                               :custom_name,
-                               class_name: "OtherActiveRecordModelTransition")
-
-      MyActiveRecordModel.class_eval do
-        def self.transition_class
-          OtherActiveRecordModelTransition
+    context "with a custom name for the transition association" do
+      before do
+        # Switch to using OtherActiveRecordModelTransition, so the existing
+        # relation with MyActiveRecordModelTransition doesn't interfere with
+        # this spec.
+        MyActiveRecordModel.send(:has_many,
+                                 :custom_name,
+                                 class_name: "OtherActiveRecordModelTransition")
+
+        MyActiveRecordModel.class_eval do
+          def self.transition_class
+            OtherActiveRecordModelTransition
+          end
         end
       end
+
+      describe ".in_state" do
+        subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
+
+        specify { expect { query }.to_not raise_error }
+      end
     end
 
-    describe ".in_state" do
-      subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
+    context "after_commit transactional integrity" do
+      before do
+        MyStateMachine.class_eval do
+          cattr_accessor(:after_commit_callback_executed) { false }
 
-      specify { expect { query }.to_not raise_error }
+          after_transition(from: :initial, to: :succeeded, after_commit: true) do
+            # This leaks state in a testable way if transactional integrity is broken.
+            MyStateMachine.after_commit_callback_executed = true
+          end
+        end
+      end
+
+      after do
+        MyStateMachine.class_eval do
+          callbacks[:after_commit] = []
+        end
+      end
+
+      let!(:model) do
+        MyActiveRecordModel.create
+      end
+
+      # rubocop:disable RSpec/ExampleLength
+      it do
+        expect do
+          ActiveRecord::Base.transaction do
+            model.state_machine.transition_to!(:succeeded)
+            raise ActiveRecord::Rollback
+          end
+        end.to_not change(MyStateMachine, :after_commit_callback_executed)
+      end
+      # rubocop:enable RSpec/ExampleLength
     end
   end
 
+  context "using old configuration method" do
+    let(:config_type) { :old }
+
+    include_examples "testing methods"
+  end
+
+  context "using new configuration method" do
+    let(:config_type) { :new }
+
+    include_examples "testing methods"
+  end
+
   context "with no association with the transition class" do
     before do
       class UnknownModelTransition < OtherActiveRecordModelTransition; end
 
-      MyActiveRecordModel.class_eval do
-        def self.transition_class
-          UnknownModelTransition
-        end
-      end
+      configure_old(MyActiveRecordModel, UnknownModelTransition)
     end
 
     describe ".in_state" do
@@ -168,4 +214,32 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
       end
     end
   end
+
+  describe "check_missing_methods!" do
+    subject(:check_missing_methods!) { described_class.check_missing_methods!(base) }
+
+    context "when base has no missing methods" do
+      let(:base) do
+        Class.new do
+          def self.transition_class; end
+
+          def self.initial_state; end
+        end
+      end
+
+      it "does not raise an error" do
+        expect { check_missing_methods! }.to_not raise_exception(NotImplementedError)
+      end
+    end
+
+    context "when base has missing methods" do
+      let(:base) do
+        Class.new
+      end
+
+      it "raises an error" do
+        expect { check_missing_methods! }.to raise_exception(NotImplementedError)
+      end
+    end
+  end
 end

data/spec/statesman/adapters/active_record_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "timecop"
 require "statesman/adapters/shared_examples"
@@ -227,6 +229,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
             it "still has the old state" do
               allow(observer).to receive(:execute) do |phase|
                 next unless phase == :before
+
                 expect(
                   model.transitions.where(most_recent: true).first.to_state,
                 ).to eq("y")
@@ -240,6 +243,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
             it "still has the old state" do
               allow(observer).to receive(:execute) do |phase|
                 next unless phase == :after
+
                 expect(
                   model.transitions.where(most_recent: true).first.to_state,
                 ).to eq("z")

data/spec/statesman/adapters/active_record_transition_spec.rb

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

data/spec/statesman/adapters/memory_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "statesman/adapters/shared_examples"
 require "statesman/adapters/memory_transition"

data/spec/statesman/adapters/memory_transition_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "statesman/adapters/memory_transition"
 

data/spec/statesman/adapters/shared_examples.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 # All adpators must define seven methods:

data/spec/statesman/callback_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Statesman::Callback do

data/spec/statesman/config_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Statesman::Config do

data/spec/statesman/guard_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Statesman::Guard do