nxt_state_machine 0.1.6 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77b32ce5c0f8c968180650e6497e84076803948c832e84d5c63145ff10050c46
-  data.tar.gz: 5a5f210aaf9b8f0d8278a66851f4d3be8f278a4a448975252610b3eebe292b06
+  metadata.gz: c131c9fdbce2f5a605ecdfa39a63e0ea7ef21dda4a2f9600e790e56e0c4444a0
+  data.tar.gz: 49689f892d2262705c0248c05d7b0d6612b31255fb3da130494cbe200f105d83
 SHA512:
-  metadata.gz: fbbf6e38dc538a6e5018d9839c591ddf707cc5d348c310582680e8cf588715545214ebe1b16ab70dddad63a0cfa97ab7d66121752ffc1034813128fdb0f2e1e7
-  data.tar.gz: ef95346d040eb48905820314241e67009d846c00c71725cc2ab24948db0e426d7cdddb1fd55c01d7e63a15d465d0342adf9d35f888d6c62d1d21ba596f19bd54
+  metadata.gz: e176a5b1205cbfb3d901f5c7c768971b64eea974f613d4a298430f81473c13dc3852f6e4eb021d4fd1eb98cba2fd8b9d69a4671a64b0c9a5e1f2e46cc20c7580
+  data.tar.gz: 9dff03854918e23c0c0dc9ae00c55116a4244a314f0799ce2e3c81841d257e9406cff25eb68833c6c32a99e8d4c562ff1609d22fb307c63f44a12165f47a2997

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/.ruby-version

@@ -1 +1 @@
-2.6.5
+2.7.3

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# v0.1.10 2021-07-19
+
+### Added
+
+- Transition now optionally get passed the transition object that allows to access transition arguments and options.
+
+[Compare v0.1.9...v0.1.10](https://github.com/nxt-insurance/nxt_state_machine/compare/v0.1.9...v0.1.10)
+
+
+# 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,59 @@
 PATH
   remote: .
   specs:
-    nxt_state_machine (0.1.6)
+    nxt_state_machine (0.1.10)
       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.1.3.2)
+      activesupport (= 6.1.3.2)
+    activerecord (6.1.3.2)
+      activemodel (= 6.1.3.2)
+      activesupport (= 6.1.3.2)
+    activesupport (6.1.3.2)
       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)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.9)
+    diff-lcs (1.4.4)
+    i18n (1.8.10)
       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.4)
+    nxt_registry (0.3.10)
       activesupport
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
     rake (12.3.3)
-    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)
+    rexml (3.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
     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)
-      thread_safe (~> 0.1)
-    zeitwerk (2.2.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
@@ -64,6 +66,7 @@ DEPENDENCIES
   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.
    
 
@@ -292,12 +298,27 @@ event :approve do
 
   after_transition from: %i[written submitted deleted], to: :approved, run: :call_me_back
 
-  around_transition from: any_state, to: :approved do |block|
+  around_transition from: any_state, to: :approved do |block, _transition|
     # Note that around transition callbacks get passed a proc object that you have to call 
     puts 'around transition enter' 
     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
+```
+
+In callbacks you also have access to the current transition object. Through it you also have access to the arguments
+and options that have been passed in when the transition was triggered:
+
+```ruby
+before_transition from: any_state, to: :processed do |transition|
+  puts transition.arguments # => :arg_1, :arg_2 what was passed to the process!(:arg_1, :arg_2)
+  puts transition.options # => { arg_1: 'arg 1', arg_2: 'arg 2' } what was passed to the process!(arg_1: 'arg 1', arg_2: 'arg 2')
 end
 ```
 
@@ -333,7 +354,10 @@ 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. 
+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 
@@ -351,6 +375,14 @@ state_machine do
       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 
@@ -384,14 +416,6 @@ class Article < ApplicationRecord
 end
 ``` 
 
-
-## TODO
-- Decide on how to include state methods in model classes
-- 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

@@ -25,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)
       )
@@ -75,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

@@ -11,15 +11,15 @@ module NxtStateMachine
       end
     end
 
-    def resolve(transition)
-      errors.from(transition.from.enum).to(transition.to.enum)
+    def resolve!(transition)
+      errors.from!(transition.from.enum).to!(transition.to.enum)
     end
 
     private
 
     def errors
       @errors ||= registry :from do
-        nested :to, default: -> { [] }
+        level :to, default: -> { [] }
       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,17 +7,19 @@ 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,
@@ -37,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
         )
 
@@ -49,14 +50,14 @@ module NxtStateMachine
         result = nil
         defused_error = nil
 
-        target.with_lock do
+        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) }
+          if machine.defuse_registry.resolve!(transition).find { |error_class| error.is_a?(error_class) }
             defused_error = error
           else
             raise error
@@ -65,7 +66,7 @@ module NxtStateMachine
 
         raise defused_error if defused_error
 
-        result
+        transition.run_success_callbacks || result
       rescue StandardError => error
         target.assign_attributes(state_attr => transition.from.to_s)
 
@@ -82,6 +83,16 @@ module NxtStateMachine
           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,7 +6,7 @@ module NxtStateMachine
       @options = opts
 
       @states = NxtStateMachine::StateRegistry.new
-      @transitions = Transition::Store.new
+      @transitions = []
       @events = event_registry
       @callbacks = CallbackRegistry.new
       @error_callback_registry = ErrorCallbackRegistry.new
@@ -15,7 +15,7 @@ module NxtStateMachine
       @initial_state = nil
     end
 
-    attr_reader :class_context, :transitions, :events, :options, :callbacks, :name, :error_callback_registry, :defuse_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)
@@ -89,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
 
@@ -100,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
 
@@ -117,6 +118,10 @@ 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
@@ -147,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

@@ -2,18 +2,21 @@ module NxtStateMachine
   class Transition
     include Transition::Interface
 
-    def initialize(name, event:, from:, to:, state_machine:, context:, set_state_method:, &block)
+    def initialize(name, event:, from:, to:, state_machine:, context:, set_state_method:, arguments:, options:, &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
+      @arguments = arguments
+      @options = options
+      @result = nil
     end
 
-    attr_reader :name, :from, :to, :block, :event
+    attr_reader :name, :from, :to, :block, :event, :result, :arguments, :options
 
     # This triggers the set state method
     def trigger
@@ -31,7 +34,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 +47,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
 
@@ -25,16 +25,22 @@ module NxtStateMachine
         state_machine: state_machine,
         context: context,
         event: event,
-        set_state_method: set_state_method
+        set_state_method: set_state_method,
+        arguments: args,
+        options: opts
       }
 
-      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!
         transition.send(:block=, Proc.new do
-          # if the block takes arguments we always pass the transition as the first one
-          args.prepend(transition) if block.arity > 0
+          # if the transition block takes arguments we always pass the transition itself as the first argument
+          # callbacks also get passed the transition object in case they take an argument and can access args and
+          # options passed to the transition when invoked through that transition object
+          if block.arity > 0
+            args = [transition] + args
+          end
           context.instance_exec(*args, **opts, &block)
         end)
       end

data/lib/nxt_state_machine/version.rb

@@ -1,3 +1,3 @@
 module NxtStateMachine
-  VERSION = "0.1.6"
+  VERSION = '0.1.10'
 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,7 +35,7 @@ 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", "~> 12.0"
@@ -43,4 +43,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "ruby-graphviz"
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: nxt_state_machine
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.10
 platform: ruby
 authors:
 - Andreas Robecke
 - Nils Sommer
 - Raphael Kallensee
 - Lütfi Demirci
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-03-02 00:00:00.000000000 Z
+date: 2021-07-19 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
@@ -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
@@ -166,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
@@ -177,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
@@ -187,7 +205,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/nxt-insurance/nxt_state_machine
   source_code_uri: https://github.com/nxt-insurance/nxt_state_machine
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -202,8 +220,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: A rich but straight forward state machine library
 test_files: []

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