state_jacket 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1c5c0ff06fe58828c8984d5fad9dd05037efe01
-  data.tar.gz: 920fc4959884ca82671059d467ea32bf7dfdb6fa
+  metadata.gz: 2ec65a9c784df47f148a60d0a809321249a7293c
+  data.tar.gz: 5146e1e29bf9613094983f5df0648f7804d018ce
 SHA512:
-  metadata.gz: 6773afef2dd5fce13ac220f6b412f378a23346dda5794b44e8be28f2ccb28ffa842e9d2daffc8e91c2f105ec0b71ca56dd018db82d5836eb8fcee93416797c1a
-  data.tar.gz: c3fb9ffb3c98b38f075f4c3d158a6ab547cae5f348f111e48317d971d227d0866441f81cda4d84bad64d2e8b9711986847a3f5af953e466bf515885d0d1ae829
+  metadata.gz: af0b443f0965da9896fbbd8928926d0fe8742531c2c0043f92e73f184df5c18d5ddb5d3d35c12e5ea79548d13687e8af04fdb3739224972ac43c42475c8764bf
+  data.tar.gz: 03a364ceb0dcbe9a4b0c1b3c3d9a5fd4efbe3569430ca063f4ec762a3ad9f759f71066154f545307e42f7e3f589698926a4d90e69cc3dac576bca911cf85ea9c

data/Gemfile

@@ -1,3 +1,2 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 gemspec
-

data/Gemfile.lock

@@ -1,52 +1,70 @@
 PATH
   remote: .
   specs:
-    state_jacket (0.1.1)
+    state_jacket (1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    ast (2.3.0)
     binding_of_caller (0.7.2)
       debug_inspector (>= 0.0.1)
-    coderay (1.1.0)
-    coveralls (0.7.2)
-      multi_json (~> 1.3)
-      rest-client (= 1.6.7)
-      simplecov (>= 0.7)
-      term-ansicolor (= 1.2.2)
-      thor (= 0.18.1)
+    byebug (9.0.6)
+    coderay (1.1.1)
+    coveralls (0.8.21)
+      json (>= 1.8, < 3)
+      simplecov (~> 0.14.1)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.4)
+      tins (~> 1.6)
     debug_inspector (0.0.2)
     docile (1.1.5)
     interception (0.5)
+    json (2.1.0)
     method_source (0.8.2)
-    mime-types (2.4.3)
-    multi_json (1.10.1)
-    os (0.9.6)
-    pry (0.10.1)
+    os (1.0.0)
+    parser (2.4.0.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    pry (0.10.4)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
-    pry-rescue (1.4.1)
+    pry-byebug (3.4.2)
+      byebug (~> 9.0)
+      pry (~> 0.10)
+    pry-rescue (1.4.5)
       interception (>= 0.5)
       pry
-    pry-stack_explorer (0.4.9.1)
+    pry-stack_explorer (0.4.9.2)
       binding_of_caller (>= 0.7)
       pry (>= 0.9.11)
-    pry-test (0.5.5)
+    pry-test (0.6.4)
       os
-    rake (10.4.2)
-    rest-client (1.6.7)
-      mime-types (>= 1.16)
-    simplecov (0.9.1)
+      pry
+      pry-byebug
+      pry-rescue
+      pry-stack_explorer
+    rainbow (2.2.1)
+    rake (12.0.0)
+    rubocop (0.48.1)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    simplecov (0.14.1)
       docile (~> 1.1.0)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.8.0)
-    simplecov-html (0.8.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
     slop (3.6.0)
-    term-ansicolor (1.2.2)
-      tins (~> 0.8)
-    thor (0.18.1)
-    tins (0.13.2)
+    term-ansicolor (1.6.0)
+      tins (~> 1.0)
+    thor (0.19.4)
+    tins (1.13.2)
+    unicode-display_width (1.2.1)
 
 PLATFORMS
   ruby
@@ -54,8 +72,10 @@ PLATFORMS
 DEPENDENCIES
   coveralls
   pry
-  pry-rescue
-  pry-stack_explorer
   pry-test
   rake
+  rubocop
   state_jacket!
+
+BUNDLED WITH
+   1.14.6

data/README.md

@@ -1,4 +1,4 @@
-[![Lines of Code](http://img.shields.io/badge/lines_of_code-60-brightgreen.svg?style=flat)](http://blog.codinghorror.com/the-best-code-is-no-code-at-all/)
+[![Lines of Code](http://img.shields.io/badge/lines_of_code-130-brightgreen.svg?style=flat)](http://blog.codinghorror.com/the-best-code-is-no-code-at-all/)
 [![Code Status](http://img.shields.io/codeclimate/github/hopsoft/state_jacket.svg?style=flat)](https://codeclimate.com/github/hopsoft/state_jacket)
 [![Dependency Status](http://img.shields.io/gemnasium/hopsoft/state_jacket.svg?style=flat)](https://gemnasium.com/hopsoft/state_jacket)
 [![Build Status](http://img.shields.io/travis/hopsoft/state_jacket.svg?style=flat)](https://travis-ci.org/hopsoft/state_jacket)
@@ -7,140 +7,86 @@
 
 # StateJacket
 
-## An Intuitive [State Transition System](http://en.wikipedia.org/wiki/State_transition_system)
+## An Intuitive [State Transition System](http://en.wikipedia.org/wiki/State_transition_system) & [State Machine](https://en.wikipedia.org/wiki/Finite-state_machine)
 
-[State machines](http://en.wikipedia.org/wiki/Finite-state_machine) are awesome
-but can be pretty daunting as a system grows.
-Keeping states, transitions, & events straight can be tricky.
-StateJacket simplifies things by isolating the management of states & transitions.
-Events are left out, making it much easier to reason about what states exist
-and how they transition to other states.
+StateJacket provides an intuitive approach to building complex state machines
+by isolating the concerns of the state transition system & state machine.
 
-*The examples below are somewhat contrived, but should clearly illustrate usage.*
-
-## The Basics
-
-#### Install
+## Install
 
 ```sh
 gem install state_jacket
 ```
 
-#### Define states & transitions for a simple [turnstyle](http://en.wikipedia.org/wiki/Finite-state_machine#Example:_a_turnstile).
-
-![Turnstyle](https://raw.github.com/hopsoft/state_jacket/master/doc/turnstyle.png)
-
-```ruby
-require "state_jacket"
-
-states = StateJacket::Catalog.new
-states.add :open => [:closed, :error]
-states.add :closed => [:open, :error]
-states.add :error
-states.lock
-
-states.inspect # => {:open=>[:closed, :error], :closed=>[:open, :error], :error=>nil}
-states.transitioners # => [:open, :closed]
-states.terminators # => [:error]
-
-states.can_transition? :open => :closed # => true
-states.can_transition? :closed => :open # => true
-states.can_transition? :error => :open # => false
-states.can_transition? :error => :closed # => false
-```
-
-## Next Steps
+## Example
 
-Lets model something a bit more complex.
+Let's define states & transitions (i.e. the state transition system) & a state machine for a [turnstyle](http://en.wikipedia.org/wiki/Finite-state_machine#Example:_a_turnstile).
 
-#### Define states & transitions for a phone call.
+![Turnstyle](https://raw.github.com/hopsoft/state_jacket/master/doc/turnstyle.png)
 
-![Phone Call](https://raw.github.com/hopsoft/state_jacket/master/doc/phone-call.png)
+### State Transition System
 
 ```ruby
-require "state_jacket"
-
-states = StateJacket::Catalog.new
-states.add :idle => [:dialing]
-states.add :dialing => [:idle, :connecting]
-states.add :connecting => [:idle, :busy, :connected]
-states.add :busy => [:idle]
-states.add :connected => [:idle]
-states.lock
-
-states.transitioners # => [:idle, :dialing, :connecting, :busy, :connected]
-states.terminators # => []
-
-states.can_transition? :idle => :dialing # => true
-states.can_transition? :dialing => [:idle, :connecting] # => true
-states.can_transition? :connecting => [:idle, :busy, :connected] # => true
-states.can_transition? :busy => :idle # => true
-states.can_transition? :connected => :idle # => true
-states.can_transition? :idle => [:dialing, :connected] # => false
+system = StateJacket::StateTransitionSystem.new
+system.add :opened => [:closed, :errored]
+system.add :closed => [:opened, :errored]
+system.lock # prevent further changes
+
+system.to_h.inspect  # => {"opened"=>["closed", "errored"], "closed"=>["opened", "errored"], "errored"=>nil}
+system.transitioners # => ["opened", "closed"]
+system.terminators   # => ["errored"]
+
+system.can_transition? :opened => :closed  # => true
+system.can_transition? :closed => :opened  # => true
+system.can_transition? :errored => :opened # => false
+system.can_transition? :errored => :closed # => false
 ```
 
-## Deep Cuts
+### State Machine
 
-Lets add state awareness and behavior to another class.
-We'll reuse the turnstyle states from the example from above.
+Define the events that trigger transitions defined by the state transition system (i.e. the state machine).
 
 ```ruby
-require "state_jacket"
-
-class Turnstyle
-  attr_reader :states, :current_state
-
-  def initialize
-    @states = StateJacket::Catalog.new
-    @states.add :open => [:closed, :error]
-    @states.add :closed => [:open, :error]
-    @states.add :error
-    @states.lock
-    @current_state = :closed
-  end
+machine = StateJacket::StateMachine.new(system, state: "closed")
+machine.on :open, :closed => :opened
+machine.on :close, :opened => :closed
+machine.lock # prevent further changes
+
+machine.to_h.inspect # => {"open"=>[{"closed"=>"opened"}], "close"=>[{"opened"=>"closed"}]}
+machine.events       # => ["open", "close"]
+
+machine.state            # => "closed"
+machine.is_event? :open  # => true
+machine.is_event? :close # => true
+machine.is_event? :other # => false
+
+machine.can_trigger? :open # => true
+machine.can_trigger? :close # => false
+
+machine.state         # => "closed"
+machine.trigger :open # => "opened"
+machine.state         # => "opened"
+
+# you can also pass a block when triggering events
+machine.trigger :close do |from_state, to_state|
+  # custom logic can be placed here
+  from_state # => "opened"
+  to_state   # => "closed"
+end
 
-  def open
-    if states.can_transition? current_state => :open
-      @current_state = :open
-    else
-      raise "Can't transition from #{@current_state} to :open"
-    end
-  end
+machine.state # => "closed"
 
-  def close
-    if states.can_transition? current_state => :closed
-      @current_state = :closed
-    else
-      raise "Can't transition from #{@current_state} to :closed"
-    end
-  end
+# this is a noop because can_trigger?(:close) is false
+machine.trigger :close # => nil
 
-  def break
-    @current_state = :error
+machine.state # => "closed"
+
+begin
+  machine.trigger :open do |from_state, to_state|
+    raise # the transition isn't performed if an error occurs in the block
   end
+rescue
 end
 
-# example usage
-turnstyle = Turnstyle.new
-turnstyle.current_state # => :closed
-turnstyle.open
-turnstyle.current_state # => :open
-turnstyle.close
-turnstyle.current_state # => :closed
-turnstyle.close # => RuntimeError: Can't transition from closed to :closed
-turnstyle.open
-turnstyle.current_state # => :open
-turnstyle.open # => RuntimeError: Can't transition from open to :open
-turnstyle.break
-turnstyle.open # => RuntimeError: Can't transition from error to :open
-turnstyle.close # => RuntimeError: Can't transition from error to :closed
-```
-
-## Running the Tests
-
-```
-gem install state_jacket
-gem unpack state_jacket
-cd state_jacket-VERSION
-rake
+machine.state # => "closed"
 ```

data/Rakefile

@@ -1,9 +1,13 @@
 require "bundler/gem_tasks"
 
-task :default => [:test]
+task default: [:test]
+
+desc "Runs rubocop."
+task :rubocop do
+  exec "bundle exec rubocop -c .rubocop.yml"
+end
 
 desc "Runs the test suite."
 task :test do
   exec "bundle exec pry-test --disable-pry"
 end
-

data/lib/state_jacket.rb

@@ -1,3 +1,6 @@
-require "state_jacket/version"
-require "state_jacket/catalog"
+require_relative "./state_jacket/version"
+require_relative "./state_jacket/state_transition_system"
+require_relative "./state_jacket/state_machine"
 
+module StateJacket
+end

data/lib/state_jacket/state_machine.rb

@@ -0,0 +1,73 @@
+module StateJacket
+  class StateMachine
+    attr_reader :state
+
+    def initialize(transition_system, state:)
+      transition_system.lock
+      raise ArgumentError.new("illegal state") unless transition_system.is_state?(state)
+      @transition_system = transition_system
+      @state = state.to_s
+      @triggers = {}
+    end
+
+    def to_h
+      triggers.dup
+    end
+
+    def events
+      triggers.keys
+    end
+
+    def on(event, transitions={})
+      raise "events cannot be added after locking" if is_locked?
+      raise ArgumentError.new("event has already been added") if is_event?(event)
+      transitions.each do |from, to|
+        raise ArgumentError.new("illegal transition") unless transition_system.can_transition?(from => to)
+        triggers[event.to_s] ||= []
+        triggers[event.to_s] << { from.to_s => to.to_s }
+        triggers[event.to_s].uniq!
+      end
+    end
+
+    def trigger(event)
+      raise "must be locked before triggering events" unless is_locked?
+      raise ArgumentError.new("event not defined") unless is_event?(event)
+      transition = transition_for(event)
+      return nil unless transition
+      from = @state
+      to = transition.values.first
+      raise "current state doesn't match transition state" unless from == transition.keys.first
+      yield from, to if block_given?
+      @state = to
+    end
+
+    def lock
+      return true if is_locked?
+      triggers.freeze
+      triggers.values.map(&:freeze)
+      triggers.values.freeze
+      @locked = true
+    end
+
+    def is_locked?
+      !!@locked
+    end
+
+    def is_event?(event)
+      triggers.has_key? event.to_s
+    end
+
+    def can_trigger?(event)
+      return false unless is_locked?
+      !!transition_for(event)
+    end
+
+    private
+
+      attr_reader :transition_system, :triggers
+
+      def transition_for(event)
+        triggers[event.to_s].find { |entry| entry.keys.first == state }
+      end
+  end
+end

data/lib/state_jacket/state_transition_system.rb

@@ -0,0 +1,75 @@
+module StateJacket
+  class StateTransitionSystem
+    def initialize
+      @transitions = {}
+    end
+
+    def to_h
+      transitions.dup
+    end
+
+    def add(state)
+      raise "states cannot be added after locking" if is_locked?
+      if state.is_a?(Hash)
+        from = state.keys.first.to_s
+        transitions[from] = make_states(state.values.first)
+      else
+        transitions[state.to_s] = nil
+      end
+    end
+
+    def lock
+      return true if is_locked?
+      transitions.freeze
+      transitions.values.each { |value| value.freeze unless value.nil? }
+      @locked = true
+    end
+
+    def is_locked?
+      !!@locked
+    end
+
+    def can_transition?(from_to)
+      raise ArgumentError.new("from_to should contain a single transition") unless from_to.size == 1
+      from = from_to.keys.first.to_s
+      to = make_states(from_to.values.first)
+      allowed_states =  transitions[from] || []
+      (to & allowed_states).length == to.length
+    end
+
+    def states
+      transitions.keys
+    end
+
+    def transitioners
+      transitions.keys.select { |state| transitions[state] != nil }
+    end
+
+    def terminators
+      transitions.keys.select { |state| transitions[state] == nil }
+    end
+
+    def is_state?(state)
+      transitions.keys.include?(state.to_s)
+    end
+
+    def is_terminator?(state)
+      terminators.include?(state.to_s)
+    end
+
+    def is_transitioner?(state)
+      transitioners.include?(state.to_s)
+    end
+
+    private
+
+      attr_reader :transitions
+
+      def make_states(values)
+        values = [values.to_s] unless values.respond_to?(:map)
+        values = values.map(&:to_s)
+        values.each { |value| transitions[value] ||= nil } unless transitions.frozen?
+        values
+      end
+  end
+end

data/lib/state_jacket/version.rb

@@ -1,3 +1,3 @@
 module StateJacket
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/test/state_machine_test.rb

@@ -0,0 +1,171 @@
+require_relative "./test_helper"
+
+class StateMachineTest < PryTest::Test
+  before do
+    @transitions = StateJacket::StateTransitionSystem.new
+  end
+
+  test "new raises with invalid state" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    begin
+      StateJacket::StateMachine.new(@transitions, state: :foo)
+    rescue ArgumentError => e
+    end
+    assert e
+  end
+
+  test "new assigns state" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    machine = StateJacket::StateMachine.new(@transitions, state: :opened)
+    assert machine.state == "opened"
+  end
+
+  test "new locks the jacket" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    StateJacket::StateMachine.new(@transitions, state: :closed)
+    assert @transitions.is_locked?
+  end
+
+  test "creating an event that has an illegal transition fails" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    begin
+      machine.on :reopen, errored: :open
+    rescue StandardError => e
+    end
+    assert e
+  end
+
+  test "to_h" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    assert machine.to_h == {"open"=>[{"closed"=>"opened"}], "close"=>[{"opened"=>"closed"}]}
+  end
+
+  test "lock prevents future mutations" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    assert machine.lock
+    assert machine.is_locked?
+    begin
+      machine.on :error, closed: :opened
+    rescue StandardError => e
+    end
+    assert e
+  end
+
+  test "can't trigger events unless locked" do
+    @transitions.add opened: [:closed]
+    @transitions.add closed: [:opened]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    begin
+      machine.trigger :open
+    rescue StandardError => e
+    end
+    assert e
+  end
+
+  test "trigger event sets matching state" do
+    @transitions.add opened: [:closed]
+    @transitions.add closed: [:opened]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    machine.lock
+    machine.trigger :open
+    assert machine.state == "opened"
+    machine.trigger :close
+    assert machine.state == "closed"
+  end
+
+  test "trigger noop" do
+    @transitions.add opened: [:closed]
+    @transitions.add closed: [:opened]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    machine.lock
+    assert machine.trigger(:open) == "opened"
+    assert machine.trigger(:open).nil?
+  end
+
+  test "trigger event sets matching state with block" do
+    @transitions.add opened: [:closed]
+    @transitions.add closed: [:opened]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    machine.lock
+    machine.trigger(:open) { |from, to| "consumer logic goes here..." }
+    assert machine.state == "opened"
+    machine.trigger(:close) { |from, to| "consumer logic goes here..." }
+    assert machine.state == "closed"
+  end
+
+  test "trigger event does not set state if error in block" do
+    @transitions.add opened: [:closed]
+    @transitions.add closed: [:opened]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    machine.lock
+    machine.trigger(:open) { |from, to| raise } rescue nil
+    assert machine.state == "closed"
+  end
+
+  test "trigger event passes from/to states to block" do
+    @transitions.add opened: [:closed]
+    @transitions.add closed: [:opened]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    machine.lock
+    states = { from: nil, to: nil }
+    machine.trigger :open do |from, to|
+      states[:from] = from
+      states[:to] = to
+    end
+    assert states == { from: "closed", to: "opened" }
+  end
+
+  test "can_trigger? false unless locked" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    assert !machine.can_trigger?(:open)
+  end
+
+  test "can_trigger?" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    machine.lock
+    assert machine.can_trigger?(:open)
+  end
+
+  test "can_trigger? false" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    machine = StateJacket::StateMachine.new(@transitions, state: :closed)
+    machine.on :open, closed: :opened
+    machine.on :close, opened: :closed
+    machine.lock
+    assert !machine.can_trigger?(:close)
+  end
+end

data/test/state_transition_sytem_test.rb

@@ -0,0 +1,123 @@
+require_relative "./test_helper"
+
+class StateJacketTest < PryTest::Test
+  before do
+    @transitions = StateJacket::StateTransitionSystem.new
+  end
+
+  test "add state" do
+    @transitions.add :started
+    assert @transitions.to_h.has_key?("started")
+  end
+
+  test "terminators" do
+    @transitions.add started: [:finished]
+    @transitions.lock
+    assert @transitions.terminators == ["finished"]
+  end
+
+  test "is_terminator?" do
+    @transitions.add started: [:finished]
+    @transitions.lock
+    assert @transitions.is_terminator?(:finished)
+  end
+
+  test "transitioners" do
+    @transitions.add started: [:finished]
+    @transitions.lock
+    assert @transitions.transitioners == ["started"]
+  end
+
+  test "is_transitioner?" do
+    @transitions.add started: [:finished]
+    @transitions.lock
+    assert @transitions.is_transitioner?(:started)
+  end
+
+  test "can_transition?" do
+    @transitions.add started: [:finished]
+    @transitions.lock
+    assert @transitions.can_transition?(started: :finished)
+  end
+
+  test "is_state?" do
+    @transitions.add started: [:finished]
+    @transitions.lock
+    assert @transitions.is_state?(:started)
+    assert @transitions.is_state?(:finished)
+  end
+
+  test "lock success" do
+    @transitions.add started: [:finished]
+    begin
+      @transitions.lock
+    rescue Exception => e
+    end
+    assert e.nil?
+  end
+
+  test "states" do
+    @transitions.add started: [:finished]
+    @transitions.lock
+    assert @transitions.states == %w(finished started)
+  end
+
+  test "symbol state" do
+    @transitions.add started: [:finished]
+    assert @transitions.to_h.keys.include?("started")
+    assert @transitions.can_transition?(started: :finished)
+  end
+
+  test "string state" do
+    @transitions.add "started" => ["finished"]
+    assert @transitions.to_h.keys.include?("started")
+    assert @transitions.can_transition?("started" => "finished")
+  end
+
+  test "number state" do
+    @transitions.add 1 => [2]
+    assert @transitions.to_h.keys.include?("1")
+    assert @transitions.can_transition?(1 => 2)
+  end
+
+  test "turnstyle example" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    @transitions.lock
+    assert @transitions.transitioners.sort == ["closed", "opened"]
+    assert @transitions.terminators == ["errored"]
+    assert @transitions.can_transition?(opened: :closed)
+    assert @transitions.can_transition?(closed: :opened)
+    assert @transitions.can_transition?(errored: :opened) == false
+    assert @transitions.can_transition?(errored: :closeded) == false
+  end
+
+  test "phone call example" do
+    @transitions = StateJacket::StateTransitionSystem.new
+    @transitions.add idle: [:dialing]
+    @transitions.add dialing: [:idle, :connecting]
+    @transitions.add connecting: [:idle, :busy, :connected]
+    @transitions.add busy: [:idle]
+    @transitions.add connected: [:idle]
+    @transitions.lock
+    assert @transitions.transitioners.sort == ["busy", "connected", "connecting", "dialing", "idle"]
+    assert @transitions.terminators == []
+    assert @transitions.can_transition?(idle: :dialing)
+    assert @transitions.can_transition?(dialing: [:idle, :connecting])
+    assert @transitions.can_transition?(connecting: [:idle, :busy, :connected])
+    assert @transitions.can_transition?(busy: :idle)
+    assert @transitions.can_transition?(connected: :idle)
+    assert @transitions.can_transition?(idle: [:dialing, :connected]) == false
+  end
+
+  test "to_h" do
+    @transitions.add opened: [:closed, :errored]
+    @transitions.add closed: [:opened, :errored]
+    @transitions.lock
+    assert @transitions.to_h == {
+      "closed"  => ["opened", "errored"],
+      "errored" => nil,
+      "opened"  => ["closed", "errored"]
+    }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require "pry-test"
+require "coveralls"
+Coveralls.wear!
+SimpleCov.command_name "pry-test"
+require_relative "../lib/state_jacket"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: state_jacket
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Nathan Hopkins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-18 00:00:00.000000000 Z
+date: 2017-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Intuitively define state machine like states and transitions.
+description: 
 email:
 - natehop@gmail.com
 executables: []
@@ -79,9 +93,12 @@ files:
 - README.md
 - Rakefile
 - lib/state_jacket.rb
-- lib/state_jacket/catalog.rb
+- lib/state_jacket/state_machine.rb
+- lib/state_jacket/state_transition_system.rb
 - lib/state_jacket/version.rb
-- test/catalog_test.rb
+- test/state_machine_test.rb
+- test/state_transition_sytem_test.rb
+- test/test_helper.rb
 homepage: https://github.com/hopsoft/state_jacket
 licenses:
 - MIT
@@ -102,10 +119,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: Intuitively define state machine like states and transitions.
+summary: A simple & intuitive state machine
 test_files:
-- test/catalog_test.rb
-has_rdoc: 
+- test/state_machine_test.rb
+- test/state_transition_sytem_test.rb
+- test/test_helper.rb

data/lib/state_jacket/catalog.rb

@@ -1,72 +0,0 @@
-require "delegate"
-
-module StateJacket
-
-  # A simple class that allows users to intuitively define states and transitions.
-  class Catalog < SimpleDelegator
-    def initialize
-      @inner_hash = {}
-      super inner_hash
-    end
-
-    def add(state)
-      if state.is_a?(Hash)
-        self[state.keys.first.to_s] = state.values.first.map(&:to_s)
-      else
-        self[state.to_s] = nil
-      end
-    end
-
-    def can_transition?(from_to)
-      from = from_to.keys.first.to_s
-      to = from_to.values.first
-      to = [to] unless to.is_a?(Array)
-      to = to.map(&:to_s)
-      transitions = self[from] || []
-      (to & transitions).length == to.length
-    end
-
-    def transitioners
-      keys.select do |state|
-        self[state] != nil
-      end
-    end
-
-    def transitioner?(state)
-      transitioners.include?(state.to_s)
-    end
-
-    def terminators
-      keys.select do |state|
-        self[state] == nil
-      end
-    end
-
-    def terminator?(state)
-      terminators.include?(state.to_s)
-    end
-
-    def lock
-      values.flatten.each do |value|
-        next if value.nil?
-        if !keys.include?(value)
-          raise "Invalid StateJacket::Catalog! [#{value}] is not a first class state."
-        end
-      end
-      inner_hash.freeze
-      values.each { |value| value.freeze unless value.nil? }
-    end
-
-    def supports_state?(state)
-      keys.include?(state.to_s)
-    end
-
-    protected
-
-    attr_reader :inner_hash
-
-  end
-
-end
-
-

data/test/catalog_test.rb

@@ -1,131 +0,0 @@
-require "pry-test"
-require "coveralls"
-Coveralls.wear!
-SimpleCov.command_name "pry-test"
-require_relative "../lib/state_jacket/catalog"
-
-class CatalogTest < PryTest::Test
-  before do
-    @catalog = StateJacket::Catalog.new
-  end
-
-  test "add state" do
-    @catalog.add :start
-    assert @catalog.has_key?("start")
-  end
-
-  test "terminators" do
-    @catalog.add :start => [:finish]
-    @catalog.add :finish
-    @catalog.lock
-    assert @catalog.terminators == ["finish"]
-  end
-
-  test "terminator" do
-    @catalog.add :start => [:finish]
-    @catalog.add :finish
-    @catalog.lock
-    assert @catalog.terminator?(:finish)
-  end
-
-  test "transitioners" do
-    @catalog.add :start => [:finish]
-    @catalog.add :finish
-    @catalog.lock
-    assert @catalog.transitioners == ["start"]
-  end
-
-  test "transitioner" do
-    @catalog.add :start => [:finish]
-    @catalog.add :finish
-    @catalog.lock
-    assert @catalog.transitioner?(:start)
-  end
-
-  test "can transition" do
-    @catalog.add :start => [:finish]
-    @catalog.add :finish
-    @catalog.lock
-    assert @catalog.can_transition?(:start => :finish)
-  end
-
-  test "supports state" do
-    @catalog.add :start => [:finish]
-    @catalog.add :finish
-    @catalog.lock
-    assert @catalog.supports_state?(:start)
-    assert @catalog.supports_state?(:finish)
-  end
-
-  test "lock failure" do
-    @catalog.add :start => [:finish]
-    begin
-      @catalog.lock
-    rescue Exception => e
-    end
-    assert e.message.start_with?("Invalid StateJacket::Catalog!")
-  end
-
-  test "lock success" do
-    @catalog.add :start => [:finish]
-    @catalog.add :finish
-    begin
-      @catalog.lock
-    rescue Exception => e
-    end
-    assert e.nil?
-  end
-
-  test "symbol state" do
-    @catalog.add :start => [:finish]
-    @catalog.add :finish
-    assert @catalog.keys.include?("start")
-    assert @catalog.can_transition?(:start => :finish)
-  end
-
-  test "string state" do
-    @catalog.add "start" => ["finish"]
-    @catalog.add "finish"
-    assert @catalog.keys.include?("start")
-    assert @catalog.can_transition?("start" => "finish")
-  end
-
-  test "number state" do
-    @catalog.add 1 => [2]
-    @catalog.add 2
-    assert @catalog.keys.include?("1")
-    assert @catalog.can_transition?(1 => 2)
-  end
-
-  test "turnstyle example" do
-    @catalog.add :open => [:closed, :error]
-    @catalog.add :closed => [:open, :error]
-    @catalog.add :error
-    @catalog.lock
-    assert @catalog.transitioners == ["open", "closed"]
-    assert @catalog.terminators == ["error"]
-    assert @catalog.can_transition?(:open => :closed)
-    assert @catalog.can_transition?(:closed => :open)
-    assert @catalog.can_transition?(:error => :open) == false
-    assert @catalog.can_transition?(:error => :closed) == false
-  end
-
-  test "phone call example" do
-    @catalog = StateJacket::Catalog.new
-    @catalog.add :idle => [:dialing]
-    @catalog.add :dialing => [:idle, :connecting]
-    @catalog.add :connecting => [:idle, :busy, :connected]
-    @catalog.add :busy => [:idle]
-    @catalog.add :connected => [:idle]
-    @catalog.lock
-    assert @catalog.transitioners == ["idle", "dialing", "connecting", "busy", "connected"]
-    assert @catalog.terminators == []
-    assert @catalog.can_transition?(:idle => :dialing)
-    assert @catalog.can_transition?(:dialing => [:idle, :connecting])
-    assert @catalog.can_transition?(:connecting => [:idle, :busy, :connected])
-    assert @catalog.can_transition?(:busy => :idle)
-    assert @catalog.can_transition?(:connected => :idle)
-    assert @catalog.can_transition?(:idle => [:dialing, :connected]) == false
-  end
-
-end