nxt_state_machine 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c035f94c9cd82caa184fde21b45cba13ad4791b655a34f8cb5140898f7e0760a
-  data.tar.gz: a7237abef06bf937730f6f848a57e276c82dbf6d605f6a34889303402c498655
+  metadata.gz: 7e66b8a54f30382001a2c1292ac799c92335cb55835e051efb2a3d450409d67f
+  data.tar.gz: 255c9799a3732ea5ffa3b87048c5d9b6a3f185b43d1d24fb047ceefef89a9514
 SHA512:
-  metadata.gz: 67822ebb580c7398d81e6be7c228fc5de573e3ec757843a8f501ea10e7926ae14b5194ce994e79927a5557bc4bbb200f1d05e9081c470b7ac9a9d202a4cc2f21
-  data.tar.gz: 384e7c4e66c21a3b7fe6a043bc1b8936f6061605a4de0d7788f003b9982f96ecb709954c3988165936a3dad0bcfb82c5c781bc0815070ca9ad43a8d46ba1d354
+  metadata.gz: dcc9b059691980d6121fd97c2f5814bff20e717054d2c7d4b4e7e678c5b7e299906c4310ac46ebe6a11ac55b443a31248e289fd8b9858e7dbc2247341e981a83
+  data.tar.gz: 4eb4a0fdfbb88b5014c021279a89cff8638f0e01874b15da7bb45718f0de2c3050d1676ed722e6f0d537885669c43bc32c4bcfdda19319e6388325b1055dd394

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nxt_state_machine (0.1.4)
+    nxt_state_machine (0.1.5)
       activesupport
       nxt_registry (~> 0.1.3)
 

data/README.md

@@ -327,8 +327,36 @@ state_machine do
 end
 ```
 
+### ActiveRecord transaction, rollback and locks - breaking the flow by defusing errors
+
+You want to break out of your transition (which is wrapped inside a lock)? 
+You can raise an error, have everything rolled back and then have your error handler take over.
+**NOTE:** Unless you reload your model all assignments you did, previous to the error, should still be available in your
+error handler. You can also defuse errors. This means they will not cause a rollback of the transaction during the 
+transition and you can actually persist changes to your model before the defused error is raised and handled. 
+
 ### Multiple state machines in the same class
 
+```ruby
+state_machine do 
+  # ...
+  #
+  defuse CustomError, from: any_state, to: all_states        
+ 
+  event :approve do
+    transition from: %i[written submitted deleted], to: :approved do |headline:|
+      # This will be save to the database even if defused CustomError is raised after 
+      article.update!(headline: headline)
+      raise CustomError, 'This does not rollback the headline update above'
+    end
+  end
+    
+  on_error! CustomError from: any_state, to: :approved do |error, transition|
+    # You can still handle the defused Error if you want to 
+  end
+end
+```
+
 In theory you can also have multiple state_machines in the same class. To do so you have to give each 
 state_machine a name. Events need to be unique globally in order to determine which state_machine will be called. 
 You can also trigger events from one another.  
@@ -352,6 +380,7 @@ end
 
 ## TODO
 - Test implementations for Hash, AttrAccessor
+- Decide on how to include state methods in model classes
 - Thread safety spec!
 - Spec locks?
 - Explain locking in readme!

data/lib/nxt_state_machine.rb

@@ -16,6 +16,7 @@ require "nxt_state_machine/callable"
 require "nxt_state_machine/state_registry"
 require "nxt_state_machine/callback_registry"
 require "nxt_state_machine/error_callback_registry"
+require "nxt_state_machine/defuse_registry"
 require "nxt_state_machine/event_registry"
 require "nxt_state_machine/state"
 require "nxt_state_machine/event"

data/lib/nxt_state_machine/defuse_registry.rb

@@ -0,0 +1,26 @@
+module NxtStateMachine
+  class DefuseRegistry
+    include ::NxtRegistry
+
+    def register(from, to, kind)
+      Array(from).each do |from_state|
+        Array(to).each do |to_state|
+          defusing_errors = errors.from(from_state).to(to_state)
+          Array(kind).each_with_object(defusing_errors) { |error, acc| acc << error }
+        end
+      end
+    end
+
+    def resolve(transition)
+      errors.from(transition.from.enum).to(transition.to.enum)
+    end
+
+    private
+
+    def errors
+      @errors ||= registry :from do
+        nested :to, default: -> { [] }
+      end
+    end
+  end
+end

data/lib/nxt_state_machine/event.rb

@@ -23,6 +23,7 @@ module NxtStateMachine
              :any_state,
              :all_states,
              :all_states_except,
+             :defuse,
              to: :state_machine
 
     def transitions(from:, to:, &block)

data/lib/nxt_state_machine/integrations/active_record.rb

@@ -21,34 +21,21 @@ module NxtStateMachine
         end
 
         machine.set_state_with do |target, transition|
-          target.with_lock do
-            transition.run_before_callbacks
-            result = set_state(target, transition, state_attr, :save)
-            transition.run_after_callbacks
-
-            result
-          end
-        rescue StandardError => error
-          target.assign_attributes(state_attr => transition.from.to_s)
-
-          if error.is_a?(NxtStateMachine::Errors::TransitionHalted)
-            false
-          else
-            raise
-          end
+          set_state(machine, target, transition, state_attr, :save)
         end
 
         machine.set_state_with! do |target, transition|
-          target.with_lock do
-            transition.run_before_callbacks
-            result = set_state(target, transition, state_attr, :save!)
-            transition.run_after_callbacks
+          set_state(machine, target, transition, state_attr, :save!)
+        end
 
-            result
+        machine.define_singleton_method :add_state_methods_to_model do |model_class|
+          model_class.class_eval do
+            machine.states.keys.each do |state_name|
+              define_method "#{state_name}?" do
+                send(machine.options.fetch(:state_attr)) == state_name
+              end
+            end
           end
-        rescue StandardError
-          target.assign_attributes(state_attr => transition.from.to_s)
-          raise
         end
 
         machine
@@ -58,11 +45,40 @@ module NxtStateMachine
     module InstanceMethods
       private
 
-      def set_state(target, transition, state_attr, method)
+      def set_state(machine, target, transition, state_attr, save_with_method)
+        result = nil
+        defused_error = nil
+
+        target.with_lock do
+          transition.run_before_callbacks
+          result = execute_transition(target, transition, state_attr, save_with_method)
+          transition.run_after_callbacks
+
+          result
+        rescue StandardError => error
+          if machine.defuse_registry.resolve(transition).find { |error_class| error.is_a?(error_class) }
+            defused_error = error
+          else
+            raise error
+          end
+        end
+
+        raise defused_error if defused_error
+
+        result
+      rescue StandardError => error
+        target.assign_attributes(state_attr => transition.from.to_s)
+
+        raise unless save_with_method == :save && error.is_a?(NxtStateMachine::Errors::TransitionHalted)
+
+        false
+      end
+
+      def execute_transition(target, transition, state_attr, save_with_method)
         transition.execute do |block|
           result = block ? block.call : nil
           target.assign_attributes(state_attr => transition.to.to_s)
-          set_state_result = target.send(method) || halt_transition
+          set_state_result = target.send(save_with_method) || halt_transition
           block ? result : set_state_result
         end
       end

data/lib/nxt_state_machine/state_machine.rb

@@ -10,11 +10,12 @@ module NxtStateMachine
       @events = event_registry
       @callbacks = CallbackRegistry.new
       @error_callback_registry = ErrorCallbackRegistry.new
+      @defuse_registry = DefuseRegistry.new
 
       @initial_state = nil
     end
 
-    attr_reader :class_context, :transitions, :events, :options, :callbacks, :name, :error_callback_registry
+    attr_reader :class_context, :transitions, :events, :options, :callbacks, :name, :error_callback_registry, :defuse_registry
     attr_accessor :initial_state
 
     def get_state_with(method = nil, &block)
@@ -116,6 +117,10 @@ module NxtStateMachine
       callbacks.register(from, to, :after, run, block)
     end
 
+    def defuse(errors = [], from:, to:)
+      defuse_registry.register(from, to, errors)
+    end
+
     def on_error(error = StandardError, from:, to:, run: nil, &block)
       error_callback_registry.register(from, to, error, run, block)
     end

data/lib/nxt_state_machine/version.rb

@@ -1,3 +1,3 @@
 module NxtStateMachine
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_state_machine
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Andreas Robecke
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-07 00:00:00.000000000 Z
+date: 2020-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -149,6 +149,7 @@ files:
 - lib/nxt_state_machine.rb
 - lib/nxt_state_machine/callable.rb
 - lib/nxt_state_machine/callback_registry.rb
+- lib/nxt_state_machine/defuse_registry.rb
 - lib/nxt_state_machine/error_callback_registry.rb
 - lib/nxt_state_machine/errors/error.rb
 - lib/nxt_state_machine/errors/event_already_registered.rb