nxt_state_machine 0.1.4 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c035f94c9cd82caa184fde21b45cba13ad4791b655a34f8cb5140898f7e0760a
-  data.tar.gz: a7237abef06bf937730f6f848a57e276c82dbf6d605f6a34889303402c498655
+  metadata.gz: 6128e445380f2ed2b836b4c23ed58556efd2ff0728add08c2cbd45e97812e068
+  data.tar.gz: 05c8861e99afefec3c654366050b225d7a93c10ff984e508cd14d6345b1d0ff3
 SHA512:
-  metadata.gz: 67822ebb580c7398d81e6be7c228fc5de573e3ec757843a8f501ea10e7926ae14b5194ce994e79927a5557bc4bbb200f1d05e9081c470b7ac9a9d202a4cc2f21
-  data.tar.gz: 384e7c4e66c21a3b7fe6a043bc1b8936f6061605a4de0d7788f003b9982f96ecb709954c3988165936a3dad0bcfb82c5c781bc0815070ca9ad43a8d46ba1d354
+  metadata.gz: d3038d32da3a7bfa5a49b4537e7c6f163259ddd0f3d2b48a05bfa838021350f648d75bfc493125529c9e1374dc34aa2c9abe94325790fe4ba82a09f01e2afdc8
+  data.tar.gz: 64178102f125d3b180f31b1a0bbebd766226b44351bbef906d907cc6339f2ff213c743c51b52238706827cfd597e410b828eb0824f8a4747f363c9b2b79a0ce9

data/.circleci/config.yml

@@ -16,11 +16,17 @@ jobs:
     steps:
       - checkout
 
+      - run:
+          name: Install apt dependencies
+          command: |
+            sudo apt update -q \
+            && sudo apt upgrade -q \
+            && sudo apt install -qq graphviz
       # Download and cache dependencies
       - restore_cache:
           keys:
             - v1-dependencies-{{ checksum "Gemfile.lock" }}
-            
+
       - run: gem install bundler --version $BUNDLER_VERSION
 
       - run:
@@ -53,4 +59,4 @@ jobs:
           path: /tmp/test-results
       - store_artifacts:
           path: /tmp/test-results
-          destination: test-results
+          destination: test-results

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# v0.1.9 2020-09-23
+
+### Added
+
+- Allow to toggle locking of transitions for active record adapter per event or globally 
+
+[Compare v0.1.8...v0.1.9](https://github.com/nxt-insurance/nxt_state_machine/compare/v0.1.8...v0.1.9)
+
+
+# v0.1.8 2020-0-05
+
+### Added
+
+- [internal] Allow to draw state machine graph with rake task 
+
+[Compare v0.1.7...v0.1.8](https://github.com/nxt-insurance/nxt_state_machine/compare/v0.1.7...v0.1.8)

data/Gemfile.lock

@@ -1,57 +1,60 @@
 PATH
   remote: .
   specs:
-    nxt_state_machine (0.1.4)
+    nxt_state_machine (0.1.9)
       activesupport
-      nxt_registry (~> 0.1.3)
+      nxt_registry (~> 0.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (6.0.2.1)
-      activesupport (= 6.0.2.1)
-    activerecord (6.0.2.1)
-      activemodel (= 6.0.2.1)
-      activesupport (= 6.0.2.1)
-    activesupport (6.0.2.1)
+    activemodel (6.0.3.3)
+      activesupport (= 6.0.3.3)
+    activerecord (6.0.3.3)
+      activemodel (= 6.0.3.3)
+      activesupport (= 6.0.3.3)
+    activesupport (6.0.3.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-      zeitwerk (~> 2.2)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.5)
-    diff-lcs (1.3)
-    i18n (1.8.2)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.4.4)
+    i18n (1.8.5)
       concurrent-ruby (~> 1.0)
-    method_source (0.9.2)
-    minitest (5.14.0)
-    nxt_registry (0.1.4)
+    method_source (1.0.0)
+    minitest (5.14.2)
+    nxt_registry (0.3.2)
       activesupport
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rake (10.5.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (12.3.3)
+    rexml (3.2.4)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
       rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.0)
-      rspec-support (~> 3.9.0)
-    rspec-expectations (3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.0)
+    rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
-    rspec-support (3.9.0)
+    rspec-support (3.9.3)
     rspec_junit_formatter (0.4.1)
       rspec-core (>= 2, < 4, != 2.12.0)
+    ruby-graphviz (1.2.5)
+      rexml
     sqlite3 (1.4.2)
     thread_safe (0.3.6)
-    tzinfo (1.2.6)
+    tzinfo (1.2.7)
       thread_safe (~> 0.1)
-    zeitwerk (2.2.2)
+    zeitwerk (2.4.0)
 
 PLATFORMS
   ruby
@@ -61,9 +64,10 @@ DEPENDENCIES
   bundler (~> 2.0)
   nxt_state_machine!
   pry
-  rake (~> 10.0)
+  rake (~> 12.0)
   rspec (~> 3.0)
   rspec_junit_formatter
+  ruby-graphviz
   sqlite3
 
 BUNDLED WITH

data/README.md

@@ -83,6 +83,10 @@ class ArticleWorkflow
         puts 'around transition exit'
       end
 
+      on_success from: any_state, to: :approved do |transition|
+        # This is the last callback in the chain - It runs outside of the active record transaction
+      end
+
       on_error CustomError from: any_state, to: :approved do |error, transition|
       end
     end
@@ -237,12 +241,14 @@ article.approve(approved_at: Time.current)
 article.approve!(approved_at: Time.current)
 ```
 
-**NOTE:** Transitions run in transactions that acquire a lock to prevent concurrency issues. Transactions will be 
-rolled back in case of an exception or if your target cannot be saved due to validation errors. 
-The state is set back to the state before the transition! If you try to transitions on records with unpersisted changes
+**NOTE:** Transitions run in transactions that acquire a lock to prevent concurrency issues per default. 
+Transactions will be rolled back in case of an exception or if your target cannot be saved due to validation errors. 
+The state is set back to the state before the transition! If you try to transition on records with unpersisted changes
 you will get a `RuntimeError: Locking a record with unpersisted changes is not supported.` error saying something
 like `Use :save to persist the changes, or :reload to discard them explicitly.` since it's not possible to acquire a 
-lock on modified records. 
+lock on modified records. You can also switch of locking and transactions for events by passing in the `lock_transitions: false` 
+option when defining an event or globally on the state machine with the `lock_transitions: false` option. Currently 
+there is no option to toggle locking at runtime.   
 
 ### Transitions
 
@@ -277,10 +283,10 @@ Transitions can be halted in callbacks and during the transition itself simply b
 
 ### Callbacks
 
-You can register `before_transition`, `around_transition` and `after_transition` callbacks. By defining the 
-:from and :to states you decide on which transitions the callback actually runs. Around callbacks need to call the
-proc object that they get passed in. Registering callbacks inside an event block or on the state_machine top level
-behaves exactly the same way and is only a matter of structure. The only thing that defines when callbacks run is
+You can register `before_transition`, `around_transition`, `after_transition` and `on_success` callbacks. 
+By defining the :from and :to states you decide on which transitions the callback actually runs. Around callbacks need 
+to call the proc object that they get passed in. Registering callbacks inside an event block or on the state_machine top
+level behaves exactly the same way and is only a matter of structure. The only thing that defines when callbacks run is
 the :from and :to parameters with which they are registered.
    
 
@@ -298,6 +304,11 @@ event :approve do
     block.call  
     puts 'around transition exit'
   end
+
+  # Use this to trigger another event after the transaction around the transition completed 
+  on_success from: any_state, to: :approved do |transition|
+    # This is the last callback in the chain - It runs outside of the active record transaction
+  end
 end
 ```
 
@@ -327,7 +338,53 @@ state_machine do
 end
 ```
 
-### Multiple state machines in the same class
+### 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. You can 
+also switch off locking (and transactions) for events by passing the `lock_transitions: false` option when defining an event. This
+can also by set globally for a state_machine by passing the `lock_transitions: false` option when setting up the state 
+machine.  
+
+```ruby
+state_machine do 
+  # ...
+  #
+  defuse CustomError, from: any_state, to: all_states        
+ 
+  event :approve do
+    # You can also defuse on event level 
+    # defuse CustomError, from: %i[written submitted deleted], to: :approved 
+
+    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
+
+  event :approve_without_lock, lock_transitions: false do
+    transition from: %i[written submitted deleted], to: :approved do |headline:|
+      # This will be saved to the database because the event does not wrap the transition in a transaction 
+      article.update!(headline: headline)
+      raise StandardError, '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 
+    # You should probably reload your model here to not accidentally save changes that 
+    # were made to the model during the transition before a non defused error was raised 
+    article.reload
+    # The error callback does not run inside the transaction. No more strings attached here. 
+    # You can now persist changes to your model again. 
+    article.update!(error: error.message)   
+  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. 
@@ -349,17 +406,6 @@ class Article < ApplicationRecord
 end
 ``` 
 
-
-## TODO
-- Test implementations for Hash, AttrAccessor
-- Thread safety spec!
-- Spec locks?
-- Explain locking in readme!
-- Should we clone machines for each context?
-- What about inheritance? => What would be the expected behaviour? (dup vs. no dup)
-    => Might also make sense to walk the ancestors chain and collect configure blocks
-
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -3,4 +3,4 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

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"
@@ -24,19 +25,19 @@ require "nxt_state_machine/transition/interface"
 require "nxt_state_machine/transition"
 require "nxt_state_machine/transition/factory"
 require "nxt_state_machine/transition/proxy"
-require "nxt_state_machine/transition/store"
 require "nxt_state_machine/transition/around_callback_chain"
 require "nxt_state_machine/state_machine"
 require "nxt_state_machine/integrations/active_record"
 require "nxt_state_machine/integrations/attr_accessor"
 require "nxt_state_machine/integrations/hash"
+require "nxt_state_machine/graph"
 
 module NxtStateMachine
   module ClassMethods
     include NxtRegistry
 
     def state_machine(name = :default, **opts, &config)
-      state_machines.resolve!(name) || state_machines.register(
+      state_machines.resolve(name) || state_machines.register(
         name,
         StateMachine.new(name, self, state_machine_event_registry, **opts).configure(&config)
       )
@@ -74,15 +75,15 @@ module NxtStateMachine
     end
 
     def state_machine(name = :default)
-      @state_machine ||= self.class.state_machines.resolve(name)
+      @state_machine ||= self.class.state_machines.resolve!(name)
     end
 
     def current_state_name(name = :default)
-      state_machines.resolve(name).current_state_name(self)
+      state_machines.resolve!(name).current_state_name(self)
     end
 
     def current_state(name = :default)
-      state_machines.resolve(name).states.resolve(current_state_name(name))
+      state_machines.resolve!(name).states.resolve!(current_state_name(name))
     end
 
     def halt_transition(*args, **opts)

data/lib/nxt_state_machine/callback_registry.rb

@@ -8,13 +8,13 @@ module NxtStateMachine
 
       Array(from).each do |from_state|
         Array(to).each do |to_state|
-          callbacks.from(from_state).to(to_state).kind(kind) << method_or_block
+          callbacks.from!(from_state).to!(to_state).kind!(kind) << method_or_block
         end
       end
     end
 
-    def resolve(transition, kind = nil)
-      all_callbacks = callbacks.from(transition.from.enum).to(transition.to.enum)
+    def resolve!(transition, kind = nil)
+      all_callbacks = callbacks.from!(transition.from.enum).to!(transition.to.enum)
       return all_callbacks unless kind
 
       all_callbacks.kind(kind)
@@ -24,8 +24,8 @@ module NxtStateMachine
 
     def callbacks
       @callbacks ||= registry :from do
-        nested :to do
-          nested :kind, default: -> { [] } do
+        level :to do
+          level :kind, default: -> { [] } do
             attrs :before, :after
           end
         end

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
+        level :to, default: -> { [] }
+      end
+    end
+  end
+end

data/lib/nxt_state_machine/error_callback_registry.rb

@@ -29,8 +29,8 @@ module NxtStateMachine
 
     def callbacks
       @callbacks ||= registry :from do
-        nested :to do
-          nested :error, transform_keys: false, call: false
+        level :to do
+          level :error, transform_keys: false, call: false
         end
       end
     end

data/lib/nxt_state_machine/event.rb

@@ -7,22 +7,25 @@ module NxtStateMachine
       @name = name
       @event_transitions = registry("#{name} event transitions")
       @names = Event::Names.build(name)
+      @options = options.with_indifferent_access
 
       configure(&block)
 
       ensure_event_has_transitions
     end
 
-    attr_reader :name, :state_machine, :event_transitions, :names
+    attr_reader :name, :state_machine, :event_transitions, :names, :options
 
     delegate :before_transition,
              :after_transition,
              :around_transition,
+             :on_success,
              :on_error,
              :on_error!,
              :any_state,
              :all_states,
              :all_states_except,
+             :defuse,
              to: :state_machine
 
     def transitions(from:, to:, &block)
@@ -36,7 +39,11 @@ module NxtStateMachine
     alias_method :transition, :transitions
 
     def transitions_from?(state)
-      event_transitions.resolve!(state).present?
+      event_transitions.resolve(state).present?
+    end
+
+    def to_s
+      "#{self.class.name}[:#{name}]"
     end
 
     private

data/lib/nxt_state_machine/graph.rb

@@ -0,0 +1,76 @@
+module NxtStateMachine
+  class Graph
+    def initialize(state_machines, **options)
+      @state_machines = state_machines
+      @options = default_options.merge(**options)
+    end
+
+    def draw
+      require 'ruby-graphviz'
+
+      state_machines.each do |_, state_machine|
+        add_nodes(state_machine)
+        add_edges(state_machine)
+      end
+
+      filename = File.join(options[:path], "#{options[:name]}.#{options[:format]}")
+
+      graph.output options[:format] => filename
+
+      puts '----------------------------------------------'
+      puts 'Please run the following to open the generated file:'
+      puts "open '#{filename}'"
+      puts '----------------------------------------------'
+
+      graph
+    end
+
+    private
+
+    attr_reader :options, :state_machines
+
+    def graph
+      @graph ||= ::GraphViz.new(
+        'G',
+        rankdir: options[:orientation] == 'landscape' ? 'LR' : 'TB',
+        ratio: options[:ratio]
+      )
+    end
+
+    def add_nodes(state_machine)
+      state_machine.states.values.each do |state|
+        add_node(state)
+      end
+    end
+
+    def add_node(state)
+      node_options = {
+        label: state.to_s,
+        width: '1',
+        height: '1',
+        shape: 'ellipse'
+      }
+
+      graph.add_nodes(state.to_s, node_options)
+    end
+
+    def add_edges(state_machine)
+      state_machine.events.values.each do |event|
+        event.event_transitions.values.each do |transition|
+          graph.add_edges(transition.from.to_s, transition.to.to_s, label: event.name)
+        end
+      end
+    end
+
+    def default_options
+      {
+        name: 'state_machine',
+        path: '.',
+        orientation: 'landscape',
+        ratio: 'fill',
+        format: 'png',
+        font: 'Helvetica'
+      }
+    end
+  end
+end

data/lib/nxt_state_machine/integrations/active_record.rb

@@ -1,11 +1,12 @@
 module NxtStateMachine
   module ActiveRecord
     module ClassMethods
-      def state_machine(name = :default, state_attr: :state, target: nil, &config)
+      def state_machine(name = :default, state_attr: :state, target: nil, lock_transitions: true, &config)
         machine = super(
           name,
           state_attr: state_attr,
           target: target,
+          lock_transitions: lock_transitions,
           &config
         )
 
@@ -21,34 +22,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,14 +46,53 @@ 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
+
+        with_conditional_lock(target, transition.event) 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
+
+        transition.run_success_callbacks || 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
+
+      def with_conditional_lock(target, event, &block)
+        return block.call unless lock_transition?(event)
+
+        target.with_lock { block.call }
+      end
+
+      def lock_transition?(event)
+        event.options.fetch(:lock_transitions) { state_machine.options.fetch(:lock_transitions) }
+      end
     end
 
     def self.included(base)

data/lib/nxt_state_machine/integrations/attr_accessor.rb

@@ -22,7 +22,7 @@ module NxtStateMachine
           result = set_state(target, transition, state_attr)
           transition.run_after_callbacks
 
-          result
+          transition.run_success_callbacks || result
         rescue StandardError => error
           target.send("#{state_attr}=", transition.from.enum)
 
@@ -38,7 +38,7 @@ module NxtStateMachine
           result = set_state(target, transition, state_attr)
           transition.run_after_callbacks
 
-          result
+          transition.run_success_callbacks || result
         rescue StandardError
           target.send("#{state_attr}=", transition.from.enum)
           raise

data/lib/nxt_state_machine/integrations/hash.rb

@@ -21,7 +21,7 @@ module NxtStateMachine
           transition.run_before_callbacks
           result = set_state(current_target, transition, state_attr)
           transition.run_after_callbacks
-          result
+          transition.run_success_callbacks || result
         rescue StandardError => error
           current_target[state_attr] = transition.from.enum
 
@@ -37,7 +37,7 @@ module NxtStateMachine
           result = set_state(current_target, transition, state_attr)
           transition.run_after_callbacks
 
-          result
+          transition.run_success_callbacks || result
         rescue StandardError
           current_target[state_attr] = transition.from.enum
           raise

data/lib/nxt_state_machine/state_machine.rb

@@ -6,15 +6,16 @@ module NxtStateMachine
       @options = opts
 
       @states = NxtStateMachine::StateRegistry.new
-      @transitions = Transition::Store.new
+      @transitions = []
       @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, :events, :options, :callbacks, :name, :error_callback_registry, :defuse_registry
     attr_accessor :initial_state
 
     def get_state_with(method = nil, &block)
@@ -88,8 +89,9 @@ module NxtStateMachine
       Event::Names.set_state_method_map(name).each do |event_name, set_state_method|
         class_context.define_method event_name do |*args, **opts|
           event.state_machine.can_transition!(name, event.state_machine.current_state_name(self))
-          transition = event.event_transitions.resolve(event.state_machine.current_state_name(self))
-          transition.build_transition(event_name, self, set_state_method, *args, **opts)
+          transition = event.event_transitions.resolve!(event.state_machine.current_state_name(self))
+          # Transition is build every time and thus should be thread safe!
+          transition.build_transition(event, self, set_state_method, *args, **opts)
         end
       end
 
@@ -99,7 +101,7 @@ module NxtStateMachine
     end
 
     def can_transition?(event_name, from)
-      event = events.resolve(event_name)
+      event = events.resolve!(event_name)
       event && event.event_transitions.key?(from)
     end
 
@@ -116,6 +118,14 @@ module NxtStateMachine
       callbacks.register(from, to, :after, run, block)
     end
 
+    def on_success(from:, to:, run: nil, &block)
+      callbacks.register(from, to, :success, 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
@@ -142,16 +152,23 @@ module NxtStateMachine
       run_callbacks(transition, :after, context)
     end
 
+    def run_success_callbacks(transition, context)
+      run_callbacks(transition, :success, context)
+    end
+
     def find_error_callback(error, transition)
       error_callback_registry.resolve(error, transition)
     end
 
     def run_callbacks(transition, kind, context)
-      current_callbacks = callbacks.resolve(transition, kind)
+      current_callbacks = callbacks.resolve!(transition, kind)
+      return unless current_callbacks.any?
 
       current_callbacks.each do |callback|
         Callable.new(callback).bind(context).call(transition)
       end
+
+      true
     end
 
     def current_state_name(context)

data/lib/nxt_state_machine/transition.rb

@@ -5,15 +5,16 @@ module NxtStateMachine
     def initialize(name, event:, from:, to:, state_machine:, context:, set_state_method:, &block)
       @name = name
       @event = event
-      @from = state_machine.states.resolve(from)
-      @to = state_machine.states.resolve(to)
+      @from = state_machine.states.resolve!(from)
+      @to = state_machine.states.resolve!(to)
       @state_machine = state_machine
       @set_state_method = set_state_method
       @context = context
       @block = block
+      @result = nil
     end
 
-    attr_reader :name, :from, :to, :block, :event
+    attr_reader :name, :from, :to, :block, :event, :result
 
     # This triggers the set state method
     def trigger
@@ -31,7 +32,7 @@ module NxtStateMachine
 
     # This must be used in set_state method to actually execute the transition within the around callback chain
     def execute(&block)
-      Transition::Proxy.new(event, state_machine,self, context).call(&block)
+      self.result = Transition::Proxy.new(event, state_machine,self, context).call(&block)
     end
 
     alias_method :with_around_callbacks, :execute
@@ -44,9 +45,13 @@ module NxtStateMachine
       state_machine.run_after_callbacks(self, context)
     end
 
+    def run_success_callbacks
+      state_machine.run_success_callbacks(self, context)
+    end
+
     private
 
     attr_reader :state_machine, :set_state_method, :context
-    attr_writer :block
+    attr_writer :block, :result
   end
 end

data/lib/nxt_state_machine/transition/around_callback_chain.rb

@@ -18,7 +18,7 @@ module NxtStateMachine
     private
 
     def callbacks
-      @callbacks ||= state_machine.callbacks.resolve(transition).kind(:around)
+      @callbacks ||= state_machine.callbacks.resolve!(transition).kind(:around)
     end
 
     attr_reader :transition, :context, :state_machine

data/lib/nxt_state_machine/transition/factory.rb

@@ -4,8 +4,8 @@ module NxtStateMachine
 
     def initialize(name, from:, to:, state_machine:, &block)
       @name = name
-      @from = state_machine.states.resolve(from)
-      @to = state_machine.states.resolve(to)
+      @from = state_machine.states.resolve!(from)
+      @to = state_machine.states.resolve!(to)
       @state_machine = state_machine
       @block = block
 
@@ -28,7 +28,7 @@ module NxtStateMachine
         set_state_method: set_state_method
       }
 
-      transition = Transition.new(name, **options)
+      transition = Transition.new(event.name, **options)
 
       if block
         # if the transition takes a block we make it available through a proxy on the transition itself!

data/lib/nxt_state_machine/version.rb

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

data/lib/railtie.rb

@@ -0,0 +1,8 @@
+class Railtie < Rails::Railtie
+  railtie_name :nxt_state_machine
+
+  rake_tasks do
+    path = File.expand_path(__dir__)
+    Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+  end
+end

data/lib/tasks/draw_graph.rake

@@ -0,0 +1,8 @@
+namespace :graph do
+  desc 'draw the graph of a state machine'
+  task :draw, [:state_machine_class] => [:environment] do |_, args|
+    state_machine_class = Object.const_get(args.fetch(:state_machine_class))
+    state_machine = state_machine_class.state_machine
+    NxtStateMachine::Graph.new(state_machine).draw
+  end
+end

data/nxt_state_machine.gemspec

@@ -35,12 +35,13 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activesupport"
-  spec.add_dependency "nxt_registry", "~> 0.1.3"
+  spec.add_dependency "nxt_registry", "~> 0.3.0"
 
   spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "ruby-graphviz"
 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.9
 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-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -33,14 +33,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.3
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.3
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -61,14 +61,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -125,6 +125,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A state machine library that can be used with ActiveRecord or in plain
   ruby and should be easy to customize for other integrations
 email:
@@ -139,6 +153,7 @@ files:
 - ".rspec"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -149,6 +164,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
@@ -165,6 +181,7 @@ files:
 - lib/nxt_state_machine/event.rb
 - lib/nxt_state_machine/event/names.rb
 - lib/nxt_state_machine/event_registry.rb
+- lib/nxt_state_machine/graph.rb
 - lib/nxt_state_machine/integrations/active_record.rb
 - lib/nxt_state_machine/integrations/attr_accessor.rb
 - lib/nxt_state_machine/integrations/hash.rb
@@ -176,9 +193,11 @@ files:
 - lib/nxt_state_machine/transition/factory.rb
 - lib/nxt_state_machine/transition/interface.rb
 - lib/nxt_state_machine/transition/proxy.rb
-- lib/nxt_state_machine/transition/store.rb
 - lib/nxt_state_machine/version.rb
+- lib/railtie.rb
+- lib/tasks/draw_graph.rake
 - nxt_state_machine.gemspec
+- state_machine.png
 homepage: https://github.com/nxt-insurance/nxt_state_machine
 licenses:
 - MIT

data/lib/nxt_state_machine/transition/store.rb

@@ -1,19 +0,0 @@
-module NxtStateMachine
-  class Transition::Store < Array
-    def <<(transition)
-      ensure_transition_unique(transition)
-      super
-    end
-
-    alias_method :add, :<<
-
-    private
-
-    def ensure_transition_unique(transition)
-      return unless find { |other| other.from.enum == transition.from.enum && other.to.enum == transition.to.enum }
-
-      raise NxtStateMachine::Errors::TransitionAlreadyRegistered,
-            "A transition from :#{transition.from.enum} to :#{transition.to.enum} was already registered"
-    end
-  end
-end