nxt_state_machine 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5b521a6ccdd3c6538bb1941f4cbccce8a7e83759a2f5d0c6417d2e479ee6a94
-  data.tar.gz: a79d3f8f70987524e2246650e646cef2978baf869ccd42b198e389033c0ff645
+  metadata.gz: 619dd3e81ce389fb16df746e5d940c48d48f6e2c30b2afb108a3a098aa687003
+  data.tar.gz: ee68dba22f251671e019a15f3e36bdbbb04fca5a5649e65fb1d0a43cedb60dbf
 SHA512:
-  metadata.gz: 2bc0e9e567a1cef8ba5c98e05d635491ec282f7b548a27172d9972d4ae57dbed753f93f9502560cf430405a7789cf29b12e8425a55f1dfc09e4cd79031e8957f
-  data.tar.gz: 6c0f560702961e7afa1025fb33a57ff57df0ab05ba543abef568eb7ca987dcd738586a25e06ae5b538f7b01f9b6043322c4bee19a8df9c9471f323206378e5c0
+  metadata.gz: 74cdf937fa1653f1fea76c4cf6a0fb42625b97cf1c3a08dc3ffaef34b9571400c4fc759ee002be24158c58adfeab2b5ef437d2a750b924a10dd8c5af7bccf665
+  data.tar.gz: e1af7824092bb95bfe95b88d71c05b3f8262da0a95364fde1c2a55d31da44dc96113ec31c46539757d96d4a3d112fe12b1e8ba3684bb6740fbdb77a49011004f

data/.circleci/config.yml

@@ -0,0 +1,56 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      # specify the version you desire here
+      - image: circleci/ruby:2.6.5-node
+    environment:
+      BUNDLER_VERSION: 2.0.2
+
+    working_directory: ~/repo
+
+    steps:
+      - checkout
+
+      # Download and cache dependencies
+      - restore_cache:
+          keys:
+            - v1-dependencies-{{ checksum "Gemfile.lock" }}
+            
+      - run: gem install bundler --version $BUNDLER_VERSION
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-dependencies-{{ checksum "Gemfile.lock" }}
+
+      # run tests!
+      - run:
+          name: run tests
+          command: |
+            mkdir /tmp/test-results
+            TEST_FILES="$(circleci tests glob "spec/**/*_spec.rb" | \
+              circleci tests split --split-by=timings)"
+
+            bundle exec rspec \
+              --format progress \
+              --format RspecJunitFormatter \
+              --out /tmp/test-results/rspec.xml \
+              --format progress \
+              $TEST_FILES
+
+      # collect reports
+      - store_test_results:
+          path: /tmp/test-results
+      - store_artifacts:
+          path: /tmp/test-results
+          destination: test-results

data/.editorconfig

@@ -0,0 +1,15 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+
+[*.{rb,yml,json,rake,erb}]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true

data/.ruby-version

@@ -1 +1 @@
-2.6.1
+2.6.5

data/Gemfile

@@ -2,3 +2,7 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in nxt_state_machine.gemspec
 gemspec
+
+group :test do
+  gem 'rspec_junit_formatter' # for CircleCI
+end

data/Gemfile.lock

@@ -1,31 +1,31 @@
 PATH
   remote: .
   specs:
-    nxt_state_machine (0.1.0)
+    nxt_state_machine (0.1.1)
       activesupport
       nxt_registry (~> 0.1.3)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (6.0.0)
-      activesupport (= 6.0.0)
-    activerecord (6.0.0)
-      activemodel (= 6.0.0)
-      activesupport (= 6.0.0)
-    activesupport (6.0.0)
+    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)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-      zeitwerk (~> 2.1, >= 2.1.8)
+      zeitwerk (~> 2.2)
     coderay (1.1.2)
     concurrent-ruby (1.1.5)
     diff-lcs (1.3)
     i18n (1.7.0)
       concurrent-ruby (~> 1.0)
     method_source (0.9.2)
-    minitest (5.12.2)
+    minitest (5.13.0)
     nxt_registry (0.1.3)
       activesupport
     pry (0.12.2)
@@ -45,11 +45,13 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.0)
-    sqlite3 (1.4.1)
+    rspec_junit_formatter (0.4.1)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    sqlite3 (1.4.2)
     thread_safe (0.3.6)
-    tzinfo (1.2.5)
+    tzinfo (1.2.6)
       thread_safe (~> 0.1)
-    zeitwerk (2.2.0)
+    zeitwerk (2.2.2)
 
 PLATFORMS
   ruby
@@ -61,6 +63,7 @@ DEPENDENCIES
   pry
   rake (~> 10.0)
   rspec (~> 3.0)
+  rspec_junit_formatter
   sqlite3
 
 BUNDLED WITH

data/README.md

@@ -1,3 +1,5 @@
+[![CircleCI](https://circleci.com/gh/nxt-insurance/nxt_state_machine.svg?style=svg)](https://circleci.com/gh/nxt-insurance/nxt_state_machine) [![Depfu](https://badges.depfu.com/badges/e9cb30113bbde657670ab3f5b94cfa67/count.svg)](https://depfu.com/github/nxt-insurance/nxt_state_machine?project_id=10452)
+
 # NxtStateMachine
 
 NxtStateMachine is a simple state machine library that ships with an easy to use integration for ActiveRecord.
@@ -36,9 +38,9 @@ class ArticleWorkflow
   attr_accessor :article
 
   state_machine(target: :article, state_attr: :status) do
+    # First we setup the states
     state :draft, initial: true
-    state :written
-    state :submitted
+    states :written, :submitted # define multiple states at the same time 
     state :approved
     state :published
     state :rejected
@@ -167,6 +169,16 @@ class Article < ApplicationRecord
 end
 ```
 
+You can also navigate between states 
+
+```ruby
+state.next # will give you the next state in the order they have been registered
+state.previous # will give you the previously registered state
+state.first? # first registered state?
+state.last? # last registered state?
+state.index # gives you the index of the state in the registry (can also be overwritten by passing index as an option)
+```
+
 ### Events
 
 Once you have defined your states you can define events and their transitions. Events trigger state transitions based
@@ -194,7 +206,7 @@ class Article < ApplicationRecord
       # We recommend to use keyword arguments to make events accept custom arguments
       transition from: %i[written rejected], to: :approved do |approved_at:|
         self.approved_at = approved_at
-        # NOTE: The transition is halted if this returns a falsey value
+        # NOTE: The transition is NOT halted if this returns a falsey value
       end
     end
   end
@@ -216,8 +228,12 @@ article.approve(approved_at: Time.current)
 article.approve!(approved_at: Time.current)
 ```
 
-**NOTE:** Transitions run in transactions that will be rolled back in case of an exception or if your target cannot be 
-saved due to validation errors. The state is then set back to the state before the transition! 
+**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
+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. 
 
 ### Transitions
 
@@ -255,7 +271,7 @@ Transitions can be halted in callbacks and during the transition itself simply b
 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
-behavious exactly the same way and is only a matter of structure. The only thing that defines when callbacks run is
+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.
    
 
@@ -327,10 +343,12 @@ 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
-    => This might be super flexible as we could apply these in amend / reset mode
-    => Probably would be best to have :amend_configuration and :reset_configuration methods on the state_machine 
 
 
 ## Development

data/lib/nxt_state_machine/callable.rb

@@ -13,16 +13,18 @@ module NxtStateMachine
       end
     end
 
-    def with_context(execution_context = nil)
+    def bind(execution_context = nil)
       self.context = execution_context
       ensure_context_not_missing
       self
     end
 
-    def call(*args, **opts)
+    # NOTE: allowing call(*args, **opts) is dangerous when called with a hash as an argument!
+    # It will automatically become the **opts which might not be what you want! Probably better
+    # to introduce arguments: [], options: { } or something
+    def call(*args)
       ensure_context_not_missing
 
-      args << opts
       args = args.take(arity)
 
       if method?

data/lib/nxt_state_machine/event.rb

@@ -26,7 +26,7 @@ module NxtStateMachine
 
     def transitions(from:, to:, &block)
       Array(from).each do |from_state|
-        transition = Transition.new(name, from: from_state, to: to, state_machine: state_machine, &block)
+        transition = Transition::Factory.new(name, from: from_state, to: to, state_machine: state_machine, &block)
         state_machine.transitions << transition
         event_transitions.register(from_state, transition)
       end

data/lib/nxt_state_machine/integrations/active_record.rb

@@ -21,7 +21,7 @@ module NxtStateMachine
         end
 
         machine.set_state_with do |target, transition|
-          target.transaction do
+          target.with_lock do
             transition.run_before_callbacks
             result = set_state(target, transition, state_attr, :save)
             transition.run_after_callbacks
@@ -39,7 +39,7 @@ module NxtStateMachine
         end
 
         machine.set_state_with! do |target, transition|
-          target.transaction do
+          target.with_lock do
             transition.run_before_callbacks
             result = set_state(target, transition, state_attr, :save!)
             transition.run_after_callbacks

data/lib/nxt_state_machine/integrations/hash.rb

@@ -9,21 +9,21 @@ module NxtStateMachine
           &config
         )
 
-        machine.get_state_with do |target|
-          if target[state_attr].nil?
-            target[state_attr] = initial_state.enum
+        machine.get_state_with do |current_target|
+          if current_target[state_attr].nil?
+            current_target[state_attr] = initial_state.enum
           end
 
-          target[state_attr]
+          current_target[state_attr]
         end
 
-        machine.set_state_with do |target, transition|
+        machine.set_state_with do |current_target, transition|
           transition.run_before_callbacks
-          result = set_state(target, transition, state_attr)
+          result = set_state(current_target, transition, state_attr)
           transition.run_after_callbacks
           result
         rescue StandardError => error
-          target[state_attr] = transition.from.enum
+          current_target[state_attr] = transition.from.enum
 
           if error.is_a?(NxtStateMachine::Errors::TransitionHalted)
             false
@@ -32,14 +32,14 @@ module NxtStateMachine
           end
         end
 
-        machine.set_state_with! do |target, transition|
+        machine.set_state_with! do |current_target, transition|
           transition.run_before_callbacks
-          result = set_state(target, transition, state_attr)
+          result = set_state(current_target, transition, state_attr)
           transition.run_after_callbacks
 
           result
         rescue StandardError
-          target[state_attr] = transition.from.enum
+          current_target[state_attr] = transition.from.enum
           raise
         end
 
@@ -50,10 +50,10 @@ module NxtStateMachine
     module InstanceMethods
       private
 
-      def set_state(target, transition, state_attr)
+      def set_state(current_target, transition, state_attr)
         transition.execute do |block|
           result = block ? block.call : nil
-          set_state_result = target[state_attr] = transition.to.enum || halt_transition
+          set_state_result = current_target[state_attr] = transition.to.enum || halt_transition
           block ? result : set_state_result
         end
       end
@@ -61,6 +61,7 @@ module NxtStateMachine
 
     def self.included(base)
       base.include(NxtStateMachine)
+      base.include(InstanceMethods)
       base.extend(ClassMethods)
     end
   end

data/lib/nxt_state_machine/state.rb

@@ -1,17 +1,38 @@
 module NxtStateMachine
   class State
-    def initialize(enum, machine, **opts)
+    def initialize(enum, state_machine, **opts)
       @enum = enum
-      @machine = machine
+      @state_machine = state_machine
       @initial = opts.delete(:initial)
       @transitions = []
       @options = opts.with_indifferent_access
+      @index = opts.fetch(:index)
     end
 
-    attr_accessor :enum, :initial, :transitions, :machine, :options
+    attr_accessor :enum, :initial, :index, :transitions, :state_machine, :options
 
     def to_s
       enum.to_s
     end
+
+    def previous
+      previous_index = (index - 1) % state_machine.states.size
+      key = state_machine.states.keys[previous_index]
+      state_machine.states.resolve(key)
+    end
+
+    def next
+      next_index = (index + 1) % state_machine.states.size
+      key = state_machine.states.keys[next_index]
+      state_machine.states.resolve(key)
+    end
+
+    def last?
+      index == state_machine.states.size - 1
+    end
+
+    def first?
+      index == 0
+    end
   end
 end

data/lib/nxt_state_machine/state_machine.rb

@@ -14,24 +14,24 @@ module NxtStateMachine
       @initial_state = nil
     end
 
-    attr_reader :class_context, :states, :transitions, :events, :options, :callbacks, :name, :error_callback_registry
+    attr_reader :class_context, :transitions, :events, :options, :callbacks, :name, :error_callback_registry
     attr_accessor :initial_state
 
     def get_state_with(method = nil, &block)
       method_or_block = (method || block)
-      @get_state_with ||= method_or_block && Callable.new(method_or_block) ||
+      @get_state_with ||= method_or_block ||
         raise_missing_configuration_error(:get_state_with)
     end
 
     def set_state_with(method = nil, &block)
       method_or_block = (method || block)
-      @set_state_with ||= method_or_block && Callable.new(method_or_block) ||
+      @set_state_with ||= method_or_block ||
         raise_missing_configuration_error(:set_state_with)
     end
 
     def set_state_with!(method = nil, &block)
       method_or_block = (method || block)
-      @set_state_with_bang ||= method_or_block && Callable.new(method_or_block) ||
+      @set_state_with_bang ||= method_or_block ||
         raise_missing_configuration_error(:set_state_with!)
     end
 
@@ -44,12 +44,11 @@ module NxtStateMachine
         if opts.fetch(:initial) && initial_state.present?
           raise NxtStateMachine::Errors::InitialStateAlreadyDefined, ":#{initial_state.enum} was already defined as the initial state"
         else
-          state = new_state_class(&block).new(name, self, opts)
+          state = new_state_class(&block).new(name, self, **opts.reverse_merge(index: states.size))
           states.register(name, state)
           self.initial_state = state if opts.fetch(:initial)
 
           class_context.define_method "#{name}?" do
-            # States internally are always strings
             machine.current_state_name(self) == name
           end
 
@@ -58,6 +57,13 @@ module NxtStateMachine
       end
     end
 
+    def states(*names, **opts, &block)
+      # method overloading in ruby ;-)
+      return @states unless names.any?
+
+      state(*names, **opts, &block)
+    end
+
     def transitions
       @transitions ||= events.values.flat_map(&:event_transitions)
     end
@@ -77,19 +83,20 @@ module NxtStateMachine
     end
 
     def event(name, &block)
+      name = name.to_sym
       event = Event.new(name, state_machine: self, &block)
       events.register(name, event)
 
       class_context.define_method 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.prepare(name, self, :set_state_with, *args, **opts)
+        transition.build_transition(name, self, :set_state_with, *args, **opts)
       end
 
       class_context.define_method "#{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.prepare("#{name}!", self, :set_state_with!, *args, **opts)
+        transition.build_transition("#{name}!".to_sym, self, :set_state_with!, *args, **opts)
       end
 
       class_context.define_method "can_#{name}?" do
@@ -98,8 +105,7 @@ module NxtStateMachine
     end
 
     def can_transition?(event_name, from)
-      normalized_event_name = event_name
-      event = events.resolve(normalized_event_name)
+      event = events.resolve(event_name)
       event && event.event_transitions.key?(from)
     end
 
@@ -133,6 +139,7 @@ module NxtStateMachine
       self
     end
 
+    # TODO: Everything that require context should live in some sort of proxy
     def run_before_callbacks(transition, context)
       run_callbacks(transition, :before, context)
     end
@@ -149,16 +156,16 @@ module NxtStateMachine
       current_callbacks = callbacks.resolve(transition, kind)
 
       current_callbacks.each do |callback|
-        Callable.new(callback).with_context(context).call(transition)
+        Callable.new(callback).bind(context).call(transition)
       end
     end
 
     def current_state_name(context)
-      get_state_with.with_context(context).call(target(context))
+      Callable.new(get_state_with).bind(context).call(target(context))
     end
 
     def target(context)
-      @target_method ||= options[:target] || :itself
+      @target_method ||= (options[:target] || :itself)
       context.send(@target_method)
     end
 

data/lib/nxt_state_machine/transition/around_callback_chain.rb

@@ -10,7 +10,7 @@ module NxtStateMachine
     def build(proxy)
       return proxy unless callbacks.any?
 
-      callbacks.map { |c| Callable.new(c).with_context(context) }.reverse.inject(proxy) do |previous, callback|
+      callbacks.map { |c| Callable.new(c).bind(context) }.reverse.inject(proxy) do |previous, callback|
         -> { callback.call(previous, transition) }
       end
     end

data/lib/nxt_state_machine/transition/factory.rb

@@ -0,0 +1,56 @@
+module NxtStateMachine
+  class Transition::Factory
+    include Transition::Interface
+
+    def initialize(name, from:, to:, state_machine:, &block)
+      @name = name
+      @from = state_machine.states.resolve(from)
+      @to = state_machine.states.resolve(to)
+      @state_machine = state_machine
+      @block = block
+
+      # TODO: Write a spec that verifies that transitions are unique
+      ensure_states_exist
+    end
+
+    attr_reader :name, :from, :to
+
+    # TODO: Probably would make sense if we could also define the event name to be passed in
+    # => This way we could differentiate what event triggered the callback!!!
+
+    def build_transition(event, context, set_state_method, *args, **opts)
+      options = {
+        from: from,
+        to: to,
+        state_machine: state_machine,
+        context: context,
+        event: event,
+        set_state_method: set_state_method
+      }
+
+      transition = Transition.new(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
+          context.instance_exec(*args, **opts, &block)
+        end)
+      end
+
+      transition.prepare
+    end
+
+    private
+
+    delegate :all_states, :any_states, to: :state_machine
+
+    attr_reader :block, :state_machine
+
+    def ensure_states_exist
+      raise NxtStateMachine::Errors::UnknownStateError, "No state with :#{from} registered" unless state_machine.states.key?(from.enum)
+      raise NxtStateMachine::Errors::UnknownStateError, "No state with :#{to} registered" unless state_machine.states.key?(to.enum)
+    end
+  end
+end

data/lib/nxt_state_machine/transition/interface.rb

@@ -0,0 +1,15 @@
+module NxtStateMachine
+  class Transition
+    module Interface
+      def id
+        @id ||= "#{from.to_s}_#{to.to_s}"
+      end
+
+      def transitions_from_to?(from_state, to_state)
+        from.enum.in?(Array(from_state)) && to.enum.in?(Array(to_state))
+      end
+
+      delegate :all_states, :any_states, to: :state_machine
+    end
+  end
+end

data/lib/nxt_state_machine/transition/proxy.rb

@@ -10,7 +10,7 @@ module NxtStateMachine
     def call(&block)
       proxy = if block.arity == 1
         Proc.new do
-          block.call(transition.block_proxy)
+          block.call(transition.block)
         end
       else
         block

data/lib/nxt_state_machine/transition.rb

@@ -1,54 +1,35 @@
 module NxtStateMachine
   class Transition
-    def initialize(name, from:, to:, state_machine:, &block)
+    include Transition::Interface
+
+    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)
       @state_machine = state_machine
+      @set_state_method = set_state_method
+      @context = context
       @block = block
-
-      # TODO: Write a spec that verifies that transitions are unique
-      ensure_states_exist
     end
 
-    attr_reader :name, :from, :to
-
-    # TODO: Probably would make sense if we could also define the event name to be passed in
-    # => This way we could differentiate what event triggered the callback!!!
-
-    def prepare(event, context, set_state_with_method, *args, **opts)
-      # This exposes the transition block on the transition_to_execute so it can be executed later in :set_state_with
-      current_transition = clone
-      current_transition.send(:context=, context)
-      current_transition.send(:event=, event)
-      current_transition.send(:block_proxy=, nil)
+    attr_reader :name, :from, :to, :block, :event
 
-      # block_proxy only is set when the transition accepts a block!
-      if block
-        proxy = Proc.new do
-          # if the block takes arguments we always pass the transition as the first one
-          args.prepend(current_transition) if block.arity > 0
-          context.instance_exec(*args, **opts, &block)
-        end
-
-        current_transition.send(:block_proxy=, proxy)
-      end
-
-      state_machine.send(
-        set_state_with_method
-      ).with_context(
+    def prepare
+      Callable.new(
+        state_machine.send(set_state_method)
+      ).bind(
         context
-      ).call(state_machine.target(context), current_transition)
+      ).call(state_machine.target(context), self)
     end
 
     def execute(&block)
-      # This is called on the cloned transition from above!
       Transition::Proxy.new(event, state_machine,self, context).call(&block)
     rescue StandardError => error
       callback = state_machine.find_error_callback(error, self)
       raise unless callback
 
-      Callable.new(callback).with_context(context).call(error, self)
+      Callable.new(callback).bind(context).call(error, self)
     end
 
     alias_method :with_around_callbacks, :execute
@@ -61,27 +42,9 @@ module NxtStateMachine
       state_machine.run_after_callbacks(self, context)
     end
 
-    def transitions_from_to?(from_state, to_state)
-      from.enum.in?(Array(from_state)) && to.enum.in?(Array(to_state))
-    end
-
-    def id
-      @id ||= "#{from.to_s}_#{to.to_s}"
-    end
-
-    attr_reader :block_proxy, :event
-
     private
 
-    delegate :all_states, to: :state_machine
-
-    attr_reader :block, :state_machine
-    attr_accessor :context
-    attr_writer :block_proxy, :event
-
-    def ensure_states_exist
-      raise NxtStateMachine::Errors::UnknownStateError, "No state with :#{from} registered" unless state_machine.states.key?(from.enum)
-      raise NxtStateMachine::Errors::UnknownStateError, "No state with :#{to} registered" unless state_machine.states.key?(to.enum)
-    end
+    attr_reader :state_machine, :set_state_method, :context
+    attr_writer :block
   end
 end

data/lib/nxt_state_machine/version.rb

@@ -1,3 +1,3 @@
 module NxtStateMachine
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/nxt_state_machine.rb

@@ -19,7 +19,9 @@ require "nxt_state_machine/error_callback_registry"
 require "nxt_state_machine/event_registry"
 require "nxt_state_machine/state"
 require "nxt_state_machine/event"
+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"
@@ -71,15 +73,15 @@ module NxtStateMachine
     end
 
     def state_machine(name = :default)
-      @state_machine ||= self.class.state_machines[name]
+      @state_machine ||= self.class.state_machines.resolve(name)
     end
 
     def current_state_name(name = :default)
-      state_machines[name].current_state_name(self)
+      state_machines.resolve(name).current_state_name(self)
     end
 
     def current_state(name = :default)
-      state_machines[name].states.fetch(current_state_name(name))
+      state_machines.resolve(name).states.resolve(current_state_name(name))
     end
 
     def halt_transition(*args, **opts)

data/nxt_state_machine.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{A rich but straight forward state machine library}
   spec.description   = %q{A state machine library that can be used with ActiveRecord or in plain ruby and should be easy to customize for other integrations}
-  spec.homepage      = "https://github.com/nxt-insurance"
+  spec.homepage      = "https://github.com/nxt-insurance/nxt_state_machine"
   spec.license       = "MIT"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_state_machine
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Andreas Robecke
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-03 00:00:00.000000000 Z
+date: 2020-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -133,6 +133,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
+- ".editorconfig"
 - ".gitignore"
 - ".rspec"
 - ".ruby-version"
@@ -169,16 +171,18 @@ files:
 - lib/nxt_state_machine/state_registry.rb
 - lib/nxt_state_machine/transition.rb
 - lib/nxt_state_machine/transition/around_callback_chain.rb
+- 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
 - nxt_state_machine.gemspec
-homepage: https://github.com/nxt-insurance
+homepage: https://github.com/nxt-insurance/nxt_state_machine
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.com/nxt-insurance
+  homepage_uri: https://github.com/nxt-insurance/nxt_state_machine
   source_code_uri: https://github.com/nxt-insurance/nxt_state_machine
 post_install_message: 
 rdoc_options: []
@@ -195,7 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A rich but straight forward state machine library