statesman 4.1.3 → 4.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ad6e72cd43e5b54c25a618524a51aa2029d50a60
-  data.tar.gz: dd974b992be7e1a764f1b0b58613fe1dbf2951f9
+SHA256:
+  metadata.gz: 7445e509f7b9bafc381522bfbdbedac811430da81375bb767472f92386218140
+  data.tar.gz: 176143a22965d91c30957bfa7744089947e4269046fac188b89550d737b7cbb8
 SHA512:
-  metadata.gz: ac91aa0a9d34410eda08fab8eded5fba9efc280617dad18eb93c6ed91c8ca46f8a34c3e13f5c7d5ca3797053551e4a514b9bcb1d6433cf7fb9ca2d29bf3da423
-  data.tar.gz: 6223d5ca89126a28905943f0b9e91bef5d5c1c2090e3effb6e78b3849a2c7c01c24069f1171307ae0fb4d3c2757dede80f6a04239f21c0bba7f50af1e6c80fe3
+  metadata.gz: afec82cb24e537055105b34d1468f55b4fc220d7dffe49627910fdc7be7e61fbeb044b2e36f53bb111a9c7aeab23cc77b7828c0ac8b3bba167ac461246becc40
+  data.tar.gz: d98cf49966c4bb635b98798b44ecab0e5ad77714c794580eeb13939cbff7ab7dfd308de8041e6b95a0a1b56e5e364813896ade88b50422a87ecb00b7294745c0

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## v4.1.4, 11th November 2019
+
+- Reverts the breaking changes from [PR#358](https://github.com/gocardless/statesman/pull/358) & `v4.1.3` that where included in the last minor release. If you have changed your code to work with these changes `v5.0.0` will be a copy of `v4.1.3` with a bugfix applied.
+
 ## v4.1.3, 6th November 2019
 
 - Add accessible from / to state attributes on the `TransitionFailedError` to avoid parsing strings [@ahjmorton](https://github.com/gocardless/statesman/pull/367)

data/README.md

@@ -30,7 +30,7 @@ protection.
 To get started, just add Statesman to your `Gemfile`, and then run `bundle`:
 
 ```ruby
-gem 'statesman', '~> 3.4.1'
+gem 'statesman', '~> 4.1.4'
 ```
 
 ## Usage
@@ -76,16 +76,22 @@ Then, link it to your model:
 
 ```ruby
 class Order < ActiveRecord::Base
-  has_many :order_transitions, autosave: false
+  include Statesman::Adapters::ActiveRecordQueries
 
-  include Statesman::Adapters::ActiveRecordQueries[
-    transition_class: OrderTransition,
-    initial_state: :pending
-  ]
+  has_many :order_transitions, autosave: false
 
   def state_machine
     @state_machine ||= OrderStateMachine.new(self, transition_class: OrderTransition)
   end
+
+  def self.transition_class
+    OrderTransition
+  end
+
+  def self.initial_state
+    :pending
+  end
+  private_class_method :initial_state
 end
 ```
 
@@ -351,34 +357,43 @@ callback code throws an exception, it will not be caught.)
 
 A mixin is provided for the ActiveRecord adapter which adds scopes to easily
 find all models currently in (or not in) a given state. Include it into your
-model and passing in `transition_class` and `initial_state` as options.
-
-In 4.1.1 and below, these two options had to be defined as methods on the model,
-but 4.2.0 and above allow this style of configuration as well. The old method
-pollutes the model with extra class methods, and is deprecated, to be removed
-in 5.0.0.
+model and define `transition_class` and `initial_state` class methods:
 
 ```ruby
 class Order < ActiveRecord::Base
-  has_many :order_transitions, autosave: false
-  include Statesman::Adapters::ActiveRecordQueries[
-    transition_class: OrderTransition,
-    initial_state: OrderStateMachine.initial_state
-  ]
+  include Statesman::Adapters::ActiveRecordQueries
+
+  def self.transition_class
+    OrderTransition
+  end
+  private_class_method :transition_class
+
+  def self.initial_state
+    OrderStateMachine.initial_state
+  end
+  private_class_method :initial_state
 end
 ```
 
 If the transition class-name differs from the association name, you will also
-need to pass `transition_name` as an option:
+need to define a corresponding `transition_name` class method:
 
 ```ruby
 class Order < ActiveRecord::Base
   has_many :transitions, class_name: "OrderTransition", autosave: false
-  include Statesman::Adapters::ActiveRecordQueries[
-    transition_class: OrderTransition,
-    initial_state: OrderStateMachine.initial_state,
-    transition_name: :transitions
-  ]
+
+  def self.transition_name
+    :transitions
+  end
+
+  def self.transition_class
+    OrderTransition
+  end
+
+  def self.initial_state
+    OrderStateMachine.initial_state
+  end
+  private_class_method :initial_state
 end
 ```
 

data/lib/statesman/adapters/active_record_queries.rb

@@ -1,122 +1,51 @@
 module Statesman
   module Adapters
     module ActiveRecordQueries
-      def self.check_missing_methods!(base)
-        missing_methods = %i[transition_class initial_state].
-          reject { |_method| base.respond_to?(:method) }
-        return if missing_methods.none?
-
-        raise NotImplementedError,
-              "#{missing_methods.join(', ')} method(s) should be defined on " \
-              "the model. Alternatively, use the new form of `extend " \
-              "Statesman::Adapters::ActiveRecordQueries[" \
-              "transition_class: MyTransition, " \
-              "initial_state: :some_state]`"
-      end
-
       def self.included(base)
-        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),
-          ),
-        )
+        base.extend(ClassMethods)
       end
 
-      def self.[](**args)
-        ClassMethods.new(**args)
-      end
-
-      class ClassMethods < Module
-        def initialize(**args)
-          @args = args
-        end
-
-        def included(base)
-          ensure_inheritance(base)
-
-          query_builder = QueryBuilder.new(base, **@args)
-
-          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
+      module ClassMethods
+        def in_state(*states)
+          states = states.flatten.map(&:to_s)
 
-        private
-
-        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
+          joins(most_recent_transition_join).
+            where(states_where(most_recent_transition_alias, states), states)
         end
 
-        def define_in_state(base, query_builder)
-          base.define_singleton_method(:in_state) do |*states|
-            states = states.flatten.map(&:to_s)
+        def not_in_state(*states)
+          states = states.flatten.map(&:to_s)
 
-            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.map(&:to_s)
-
-            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 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
+          joins(most_recent_transition_join).
+            where("NOT (#{states_where(most_recent_transition_alias, states)})",
+                  states)
         end
 
         def most_recent_transition_join
           "LEFT OUTER JOIN #{model_table} AS #{most_recent_transition_alias}
-             ON #{model.table_name}.id =
+             ON #{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_class
+          raise NotImplementedError, "A transition_class method should be " \
+                                     "defined on the model"
+        end
+
+        def initial_state
+          raise NotImplementedError, "An initial_state method should be " \
+                                     "defined on the model"
+        end
 
         def transition_name
-          @transition_name || transition_class.table_name.to_sym
+          transition_class.table_name.to_sym
         end
 
         def transition_reflection
-          model.reflect_on_all_associations(:has_many).each do |value|
+          reflect_on_all_associations(:has_many).each do |value|
             return value if value.klass == transition_class
           end
 
@@ -133,9 +62,18 @@ 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_alias ||
-            "most_recent_#{transition_name.to_s.singularize}"
+          "most_recent_#{transition_name.to_s.singularize}"
         end
 
         def db_true

data/lib/statesman/version.rb

@@ -1,3 +1,3 @@
 module Statesman
-  VERSION = "4.1.3".freeze
+  VERSION = "4.1.4".freeze
 end

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -1,17 +1,6 @@
 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
@@ -19,6 +8,32 @@ 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) } }
@@ -44,164 +59,105 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
     model
   end
 
-  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
+  describe ".in_state" do
+    context "given a single state" do
+      subject { MyActiveRecordModel.in_state(:succeeded) }
 
-      MyActiveRecordModel.send(:has_one, :other_active_record_model)
-      OtherActiveRecordModel.send(:belongs_to, :my_active_record_model)
+      it { is_expected.to include model }
+      it { is_expected.to_not include other_model }
     end
 
-    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
+    context "given multiple states" do
+      subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
 
-      context "given multiple states" do
-        subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
-
-        it { is_expected.to include model }
-        it { is_expected.to include other_model }
-      end
-
-      context "given the initial state" do
-        subject { MyActiveRecordModel.in_state(:initial) }
-
-        it { is_expected.to include initial_state_model }
-        it { is_expected.to include returned_to_initial_model }
-      end
-
-      context "given an array of states" do
-        subject { MyActiveRecordModel.in_state(%i[succeeded failed]) }
-
-        it { is_expected.to include model }
-        it { is_expected.to include other_model }
-      end
+      it { is_expected.to include model }
+      it { is_expected.to include other_model }
+    end
 
-      context "merging two queries" do
-        subject do
-          MyActiveRecordModel.in_state(:succeeded).
-            joins(:other_active_record_model).
-            merge(OtherActiveRecordModel.in_state(:initial))
-        end
+    context "given the initial state" do
+      subject { MyActiveRecordModel.in_state(:initial) }
 
-        it { is_expected.to be_empty }
-      end
+      it { is_expected.to include initial_state_model }
+      it { is_expected.to include returned_to_initial_model }
     end
 
-    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
+    context "given an array of states" do
+      subject { MyActiveRecordModel.in_state(%i[succeeded failed]) }
 
-      context "given multiple states" do
-        subject(:not_in_state) { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
+      it { is_expected.to include model }
+      it { is_expected.to include other_model }
+    end
 
-        it do
-          expect(not_in_state).to match_array([initial_state_model,
-                                               returned_to_initial_model])
-        end
+    context "merging two queries" do
+      subject do
+        MyActiveRecordModel.in_state(:succeeded).
+          joins(:other_active_record_model).
+          merge(OtherActiveRecordModel.in_state(:initial))
       end
 
-      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])
-        end
-      end
+      it { is_expected.to be_empty }
     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
-          end
-        end
-      end
-
-      describe ".in_state" do
-        subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
+  describe ".not_in_state" do
+    context "given a single state" do
+      subject { MyActiveRecordModel.not_in_state(:failed) }
 
-        specify { expect { query }.to_not raise_error }
-      end
+      it { is_expected.to include model }
+      it { is_expected.to_not include other_model }
     end
 
-    context "after_commit transactional integrity" do
-      before do
-        MyStateMachine.class_eval do
-          cattr_accessor(:after_commit_callback_executed) { false }
+    context "given multiple states" do
+      subject(:not_in_state) { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
 
-          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
+      it do
+        expect(not_in_state).to match_array([initial_state_model,
+                                             returned_to_initial_model])
       end
+    end
 
-      let!(:model) do
-        MyActiveRecordModel.create
-      end
+    context "given an array of states" do
+      subject(:not_in_state) { MyActiveRecordModel.not_in_state(%i[succeeded failed]) }
 
-      # 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)
+        expect(not_in_state).to match_array([initial_state_model,
+                                             returned_to_initial_model])
       end
-      # rubocop:enable RSpec/ExampleLength
     end
   end
 
-  context "using old configuration method" do
-    let(:config_type) { :old }
-
-    include_examples "testing methods"
-  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
+        end
+      end
+    end
 
-  context "using new configuration method" do
-    let(:config_type) { :new }
+    describe ".in_state" do
+      subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
 
-    include_examples "testing methods"
+      specify { expect { query }.to_not raise_error }
+    end
   end
 
   context "with no association with the transition class" do
     before do
       class UnknownModelTransition < OtherActiveRecordModelTransition; end
 
-      configure_old(MyActiveRecordModel, UnknownModelTransition)
+      MyActiveRecordModel.class_eval do
+        def self.transition_class
+          UnknownModelTransition
+        end
+      end
     end
 
     describe ".in_state" do
@@ -212,4 +168,38 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
       end
     end
   end
+
+  context "after_commit transactional integrity" do
+    before do
+      MyStateMachine.class_eval do
+        cattr_accessor(:after_commit_callback_executed) { false }
+
+        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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statesman
 version: !ruby/object:Gem::Version
-  version: 4.1.3
+  version: 4.1.4
 platform: ruby
 authors:
 - GoCardless
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-06 00:00:00.000000000 Z
+date: 2019-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ammeter
@@ -292,7 +292,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: A statesman-like state machine library