simplestate 1.0.6 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98120d72e903183f217fc3f3b3ab4e4ef41f3aa8
-  data.tar.gz: 1c02dc9ec7c5830b9701a86e23593aa9fd1810df
+  metadata.gz: de2abc1192e14cd5e30017a8e650f25821def00a
+  data.tar.gz: a3ee59402a6bf2780a345873fbfdd605570a7c3a
 SHA512:
-  metadata.gz: 9348c67eb908105f981aea17d1998d6ed535e5bb613b790e6558169481615610a3ac71b0c648f0db8f842f7549aed870208d6056edb4f21ec65f23308f4e649e
-  data.tar.gz: ccee6da7323d35f86f36c55a6d905866ebe544f574ad3d981e2fa3637c6d20d7b403b352527334363e2611868fb573de7760d59a9c16c5d205c3482fa0a7a441
+  metadata.gz: 9d59c31bfabcd9379ea482c780516093b2fe42d261ae96054d6683d98d5325e397d72332e4b4084591332628e38999542e8aa7dfeae5b29e32f55a704b605e0f
+  data.tar.gz: 9fb22a378838a4240f3145356fc12d54667a0d9fa30d9f8d420cc181a021288782024c03e411cffa41a4610f4eb7e42f54e886bd8cdabe30bf6268eaaf154c58

data/.gitattributes

@@ -1,17 +1,17 @@
-# Auto detect text files and perform LF normalization
-* text=auto
-
-# Custom for Visual Studio
-*.cs     diff=csharp
-
-# Standard to msysgit
-*.doc	 diff=astextplain
-*.DOC	 diff=astextplain
-*.docx diff=astextplain
-*.DOCX diff=astextplain
-*.dot  diff=astextplain
-*.DOT  diff=astextplain
-*.pdf  diff=astextplain
-*.PDF	 diff=astextplain
-*.rtf	 diff=astextplain
-*.RTF	 diff=astextplain
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Custom for Visual Studio
+*.cs     diff=csharp
+
+# Standard to msysgit
+*.doc	 diff=astextplain
+*.DOC	 diff=astextplain
+*.docx diff=astextplain
+*.DOCX diff=astextplain
+*.dot  diff=astextplain
+*.DOT  diff=astextplain
+*.pdf  diff=astextplain
+*.PDF	 diff=astextplain
+*.rtf	 diff=astextplain
+*.RTF	 diff=astextplain

data/.travis.yml

@@ -1,7 +1,7 @@
-language: ruby
-rvm:
-  - "1.9.2"
-  - "1.9.3"
-  - "2.2.3"
-  - rbx
-before_install: gem install bundler -v 1.11.2
+language: ruby
+rvm:
+  - "2.1.0"
+  - "2.2.3"
+  - "2.3.1"
+  - rbx
+before_install: gem install bundler -v 1.11.2

data/CHANGE_NOTES.md

@@ -0,0 +1,47 @@
+#### SimpleState version 2.0.0
+Ruby version requirement has changed to: __>= 2.1.0__ . (Ruby 2.0.0 can be used with some minor modification: Default values must be provided for all keyword arguments.)
+
+State:
+States are represented as 'singleton' instances of their respective classes and are referenced by their symbolized names.
+
+StateHolder:
+The alternative syntax 'start\_in' to specify the initial state to the state holder is no longer supported.
+The setter __#hx\_size\_limit=__ is no longer supported.
+The method __#set\_current\_state__ is no longer supported. This bypassed the transition logic and could lead to an inaccurate state history.
+__#start__ is provided to put the state\_holder in it's initial state. This must be called after creation of the stateholder and the associated states. The stateholder will not respond to events until this is called.
+
+StateHistory:
+This has been added to separate the responsibility for management of state history from StateHolder.
+
+
+
+#### SimpleState version 1.0.0
+A state holder tracks the history of state transitions in an array accessed via __#state_history__. The array size defaults to 5. The last item in the array will be the most recent previous state instance. The size may be set at holder creation in the opts hash (:hx\_size\_limit). The history size limit has a getter and a setter defined as well. (__#hx\_size\_limit=__  and  __#hx\_size\_limit__).
+
+```ruby
+class Button < StateHolder
+  ...
+  def prior_state
+    state_history.last.class
+  end
+end
+
+ # Then in tests for example:
+def setup
+  @button = Button.new(start_in: Off, color: 'Red', hz_size_limit: 3)
+end
+
+def test_a_button_returns_its_last_prior_state
+  @button.press # Curr state: On,  Prior state: Off
+  @button.press # Curr state: Off, Prior state: On
+  assert_equal On, @button.prior_state
+end
+```
+
+Please note that the State instance method, __#previous\_state\_class__, has been removed in this release.
+
+
+
+#### SimpleState version 0.3.0
+The 0.3.0 version contained a serious code smell: A state was expected to know about the history of state transitions. However, a state should know only the states to which it may transition and it's holder to support triggering those transitions. Knowlege of the transition history belongs with the state holder, if it is tracked at all.
+

data/README.md

@@ -1,188 +1,185 @@
-[![Gem Version](https://badge.fury.io/rb/simplestate.svg)](https://badge.fury.io/rb/simplestate) [![Build Status](https://travis-ci.org/dpneumo/simplestate.svg?branch=master)](https://travis-ci.org/dpneumo/simplestate)
-[![Code Climate](https://codeclimate.com/github/dpneumo/simplestate/badges/gpa.svg)](https://codeclimate.com/github/dpneumo/simplestate)
-
-# Simplestate
-````ruby
-class Button < StateHolder
-  def initialize(opts={})
-    super
-  end
-end
-
-class Off < State
-  def press; transition_to(On); end
-  private
-    def enter
-      # send_message_to_log("entering off state")
-      # turn_light_off
-    end
-
-    def exit
-      # send_message_to_log("leaving off state")
-    end
-end
-
-class On < State
-  def press; transition_to(Off); end
-  private
-    def enter
-      # send_message_to_log("entering on state")
-      # turn_light_on
-    end
-
-    def exit
-      # send_message_to_log("leaving on state")
-    end
-end
-
-button = Button.new(start_in: Off)
-button.press    #=> current_state: On
-button.press    #=> current_state: Off
-````
-# Description
-Simplestate arose out of a desire for a very low ceremony mechanism to implement a state machine. SimpleDelegator (delegate.rb) is used to implement this. Because SimpleDelegator supports dynamically swapping the object to which methods are delegated, it provides a good base for Simplestate.
-
-The StateHolder class provides the required functionality for a basic state machine: methods to set the initial state and to transition to a new state. To complement this a State class is provided to serve as ancestor to the states of the state machine. A State instance stores a reference to the state holder and a __#transition_to__ method which simply calls the state holder's __#transition_to__.
-
-StateHolder and State are not expected to be used directly. Rather, they are intended to be inherited from. The child state holder should provide methods not specific to its current state. A child state should provide methods specific to that state. The public methods of a child state act as receivers of event messages via delegation from the state holder. Such events may cause effects that are managed by the current state and may also cause transition to a new state. State change logic is expected to be held within the current state. Two private methods, __#enter__ and __#exit__, *must* be provided by each state. These are called by the state holder __#transition_to__ method at the appropriate points in the state life cycle. Neither __#enter__ nor __#exit__ nor any other private method of a state are intended to be called by a user of the state holder.
-
-For convenience StateHolder provides instance methods, __#current_state__ and __#set_new_state__, to provide easy access to the underlying methods, __\_\_getobj\_\___ and __\_\_setobj\_\___, of SimpleDelegator. A method to retrieve the history of state transitions from the state holder, __#state_history__, is also provided. Since the transition history could grow quite large that history is limited to the last 5 transitions by default. The history size limit may be changed via __#hx_size_limit__. That limit may be changed at any time. Changes to the limit will take effect at the next state transition.
-
-Simplestate does not provide a DSL for specifying the events, states and allowed state transitions. That logic must be specified within each state. Neither does Simplestate provide any mechanism for serialization. There is no "magic" here. It is just a couple of PORO's. As such, it is very easy to see and to reason about what is happening within Simplestate. It should not be too difficult to add serialization support to Simplestate.
-
-As an aside, I have looked into providing the Simplestate functionality via a module. However, I found that the SimpleDelegator class provides delegation via a mechanism that makes a module based Simplestate implementation very difficult to achieve. The complexity of that implementation seemed to be not worth the effort. I think the [StatePattern](https://github.com/dcadenas/state_pattern) gem by Daniel Cadenas, the inspiration for Simplestate, ran into just this problem. I chose to avoid that issue by relying solely on inheritance.
-
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'simplestate'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install simplestate
-
-## Usage
-
-#### State Holder
-Inherit from StateHolder to create the class of the object that will hold states. You *must* call super if you provide an initialize method in your holder class:
-
-```ruby
-class Button < StateHolder
-  attr_reader :color
-  def initialize(opts={})
-    @color = opts.fetch :color
-    super
-  end
-
-  # button methods here
-end
-```
-
-Creation of a StateHolder instance *must* specify the initial state class. StateHolder expects to receive the initial state class in an opts hash at creation:
-
-```ruby
-button = Button.new(initial_state_class: Off)
-```
-or use this alternate syntax:
-
-```ruby
-button = Button.new(start_in: Off)
-```
-If you want to set additional attributes at creation of a new button, do so within the opts hash when new is called. Set the attribute from the opts hash in initialize.
-
-```ruby
-button = Button.new(start_in: Off, color: 'Red')
-```
-
-#### States
-
-Inherit from State to create a class to provide specific state behaviors:
-
-```ruby
-class Off < State
-  def press
-    transition_to(On)
-    holder.messages << "#{holder.name} is on"
-  end
-
-  def name
-    'Off'
-  end
-
-private
-  def enter
-    holder.messages << "Entered the Off state"
-  end
-
-  def exit
-    holder.messages << "Exited the Off state"
-  end
-end
-```
-The subclassed state must provide *private* __#enter__ and __#exit__ methods. Any other state methods intended to be available via a method call on the state holder must be public. __#enter__ and __#exit__ will always be called appropriately during state transitions.
-
-A state has access to methods on the state holder via __#holder__:
-
-```ruby
-holder.a_special_holder_method
-```
-
-#### version 1.0.0
-A state holder tracks the history of state transitions in an array accessed via __#state_history__. The array size defaults to 5. The last item in the array will be the most recent previous state instance. The size may be set at holder creation in the opts hash (:hx_size_limit). The history size limit has a getter and a setter defined as well. (__#hx_size_limit=__  and  __#hx_size_limit__).
-
-```ruby
-class Button < StateHolder
-  ...
-  def prior_state
-    state_history.last.class
-  end
-end
-
- # Then in tests for example:
-def setup
-  @button = Button.new(start_in: Off, color: 'Red', hz_size_limit: 3)
-end
-
-def test_a_button_returns_its_last_prior_state
-  @button.press # Curr state: On,  Prior state: Off
-  @button.press # Curr state: Off, Prior state: On
-  assert_equal On, @button.prior_state
-end
-```
-
-Please note that the State instance method, __#previous_state_class__, has been removed in this release.
-
-#### version 0.3.0
-The 0.3.0 version contained a serious code smell: A state was expected to know about the history of state transitions. However, a state should know only the states to which it may transition and it's holder to support triggering those transitions. Knowlege of the transition history belongs with the state holder, if it is tracked at all.
-
-#### usage example
-The button module (test/dummys/button.rb) provides an example of the usage of Simplestate. Tests of this are provided in simplestate_test.rb.
-
-## Alternatives
-
-If a DSL is desired, complex state functionality is required, events may arrive asynchronously from multiple sources, or state machine functionality must be provided via inclusion of a module rather than via inheritance then Simplestate is probably not appropriate. Consider looking at the [Statemachine](https://github.com/pluginaweek/state_machine), [AASM](https://github.com/aasm/aasm) or [Workflow](https://github.com/geekq/workflow) gems. [The Ruby Toolbox](https://www.ruby-toolbox.com/categories/state_machines.html) provides links to several other statemachine implementations.
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-StateHolderInterfaceTest and StateInterfaceTest are provided to verify that your state holder and state instances respond to the minimum required method calls for each. Simply include these in the tests of your decendents of StateHolder and State and in any dummies of these classes you may use in your tests.
-
-To install this gem onto your local machine, run `bundle exec rake install`.
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/dpneumo/simplestate. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+[![Gem Version](https://badge.fury.io/rb/simplestate.svg)](https://badge.fury.io/rb/simplestate) [![Build Status](https://travis-ci.org/dpneumo/simplestate.svg?branch=master)](https://travis-ci.org/dpneumo/simplestate)
+[![Code Climate](https://codeclimate.com/github/dpneumo/simplestate/badges/gpa.svg)](https://codeclimate.com/github/dpneumo/simplestate)
+
+## Ruby Version requirement: >= 2.1.0
+
+# Simplestate
+```ruby
+class Button < StateHolder
+  attr_reader :name
+  def initialize(initial_state: :Off, state_history: StateHistory.new, opts: {})
+    @name = opts.fetch :name
+    super
+  end
+
+  def transition_to(state)
+    super(state)
+  end
+
+  def prior_state
+    history[-2] || :NullState
+  end
+end
+
+class Off < State
+  def press
+    transition_to(:On)
+  end
+
+  private
+    def enter
+      buzz
+      # turn_light_off
+    end
+
+    def exit
+    end
+
+    def buzz(sec: 0.5)
+      # sound buzzer for sec seconds
+    end
+end
+
+class On < State
+  def press
+    transition_to(:Off)
+  end
+
+  private
+    def enter
+      flash(3)
+      # turn_button_light_on
+    end
+
+    def exit
+    end
+
+    def flash(n)
+      # n.times { turn_button_light_on_then_off }
+    end
+end
+
+button = Button.new(initial_state: :Off)
+on_state =  On.new(holder: button)
+off_state = Off.new(holder: button)
+
+button.start    #=> current_state: Off
+button.press    #=> current_state: On
+button.press    #=> current_state: Off
+```
+# Description
+Simplestate arose out of a desire for a very low ceremony mechanism to implement a state machine. SimpleDelegator (delegate.rb) is used to implement this. Because SimpleDelegator supports dynamically swapping the object to which methods are delegated, it provides a good base for Simplestate.
+
+The current version (2.0.0) is a rewrite of SimpleState. State logic is provided via instances of the appropriate subclasses of State. A state is referenced via a symbol created by symbolizing the state's name. The State class maintains a list of state instances available for transitions in a hash keyed on the state symbols. This is an incomplete variant of the singleton pattern. It solved some issues I was having with the previous version of SimpleState, but please use some care. For example, there is no logic to actually prevent creation of more than one instance of a given State subclass. Doing this would likely create bugs that will eventually bite you. :-(
+
+The StateHolder class provides the required functionality for a basic state machine: methods to set the initial state and to transition to a new state. To complement this a State class is provided to serve as ancestor to the states of the state holder. A State instance stores a reference to the state holder and a private __#transition\_to__ method which simply calls the state holder’s __#transition\_to__.
+
+StateHolder and State are not expected to be used directly. Rather, they are intended to be the ancestors of the actual state holder and states. A state should provide only methods that are unique to it. Methods that are not specific to a state should be provided by the state holder. The public methods of a child state act as receivers of event messages via delegation from the state holder. Such events may cause effects that are managed by the current state and may also cause transition to a new state. State change logic is expected to be held within the current state. Two private methods, __#enter__ and __#exit__, *must* be provided by each state. These are called by the state holder __#transition_to__ method at the appropriate points in the state life cycle. Neither __#enter__ nor __#exit__ nor any other private method of a state are intended to be called by a user of the state holder. To avoid potentially stepping on the user's code __#enter__ and __#exit__ are called with __\_\_send\_\___.
+
+For convenience StateHolder provides instance methods, __#current_state__, __#history__, and __#hx_size_limit__ to provide easy access to the underlying method, __\_\_getobj\_\___ of SimpleDelegator, and to the read methods of the StateHistory container. The StateHistory container holds a list of the most recent state transitions from the state holder. Because the transition history could grow quite large that history is limited to the last 10 transitions by default. The history size limit may be changed via __#hx_size_limit__ at creation of the state holder. That limit may NOT be changed later
+
+Simplestate does not provide a DSL for specifying the events, states and allowed state transitions. That logic must be specified within each state. Neither does Simplestate provide any mechanism for serialization. There is no "magic" here. It is just a couple of PORO's. As such, it is very easy to see and to reason about what is happening within Simplestate. It should not be too difficult to add serialization support to Simplestate.
+
+As an aside, I have looked into providing the Simplestate functionality via a module. However, I found that the SimpleDelegator class provides delegation via a mechanism that makes a module based Simplestate implementation very difficult to achieve. The complexity of that implementation seemed to be not worth the effort. I think the [StatePattern](https://github.com/dcadenas/state_pattern) gem by Daniel Cadenas, the inspiration for Simplestate, ran into just this problem. I chose to avoid that issue by relying solely on inheritance.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'simplestate'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install simplestate
+
+## Usage
+
+#### State Holder
+Inherit from StateHolder to create the class of the object that will hold states. You may provide a default initial_state. You *must* call super if you provide an initialize method in your holder class:
+
+```ruby
+class Button < StateHolder
+  attr_reader :color
+  def initialize( initial_state: :Off, opts: {} )
+    @color = opts.fetch :color
+    super
+  end
+
+  # button methods here
+end
+```
+
+Creation of a StateHolder instance *must* specify the initial state. StateHolder expects to receive the initial state as a symbol based on the state name. The name case is preserved in creating the symbol.:
+
+```ruby
+button = Button.new( initial_state: :Off )
+```
+If you want to set additional attributes at creation of a new button, do so within the opts hash when new is called. Set the attribute from the opts hash in initialize.
+
+```ruby
+button = Button.new( initial_state: :Off,
+                     opts: {color: 'Red'} )
+```
+
+#### States
+
+Inherit from State to create a class to provide specific state behaviors:
+
+```ruby
+class Off < State
+  def press
+    transition_to(:On)
+  end
+
+  def name
+    'Off'
+  end
+
+private
+  def enter
+  end
+
+  def exit
+  end
+end
+```
+The subclassed state must provide *private* __#enter__ and __#exit__ methods. Any other state methods intended to be available via a method call on the state holder must be public. The private methods, __#enter__ and __#exit__, will always be called appropriately during state transitions.
+
+A state has access to methods on the state holder via __#holder__:
+
+```ruby
+holder.specialmethod
+```
+
+However, since a state should have minimal knowledge about the inner workings of it's holder, it is best to limit calls to holder to __#transition\_to__.
+
+#### Usage Example
+The button module (test/dummys/button.rb) provides an example of the usage of Simplestate. Tests of this are provided in button\_test.rb.
+
+## Alternatives
+
+If a DSL is desired, complex state functionality is required, events may arrive asynchronously from multiple sources, or state machine functionality must be provided via inclusion of a module rather than via inheritance then Simplestate is probably not appropriate. Consider looking at the [Statemachine](https://github.com/pluginaweek/state\_machine), [AASM](https://github.com/aasm/aasm) or [Workflow](https://github.com/geekq/workflow) gems. [The Ruby Toolbox](https://www.ruby-toolbox.com/categories/state\_machines.html) provides links to several other statemachine implementations.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+StateHolderInterfaceTest and StateInterfaceTest are provided to verify that your state holder and state instances respond to the minimum required method calls for each. Simply include these in the tests of your decendents of StateHolder and State and in any dummies of these classes you may use in your tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dpneumo/simplestate. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/button_irb_session.txt

@@ -0,0 +1,8 @@
+[loco@bear simplestate]$ irb
+irb(main):001:0> require_relative 'test/dummys/button'      => true
+irb(main):002:0> launcher = Runner.new                      => #<Runner:0x007ff16b8de4d8 ...
+irb(main):003:0> launcher.launch_sequence_begin             => true
+irb(main):004:0> launcher.launch_is_go                      => true
+irb(main):005:0> launcher.launch                            => true
+irb(main):006:0> launcher.launch_button.state_history.list  => [:NullState, :Off, :On, :Off]
+irb(main):007:0> launcher.launch_button.current_state.name  => "Off"

data/lib/simplestate/null_state.rb

@@ -0,0 +1,33 @@
+class NullState
+  # Simplifies call via super to SimpleDelegator during StateHolder#new
+  # Avoid chicken and egg problem by mimicing rather than inheriting from State
+
+  attr_reader :holder
+  def initialize(holder: nil, opts: {})
+    @holder = holder
+    State.list[self.symbol]= self
+  end
+
+  def self.list
+    {}
+  end
+
+  def name
+    'NullState'
+  end
+  alias :to_s :name
+
+  def symbol
+    :NullState
+  end
+
+  private
+    def transition_to(state)
+    end
+
+    def enter
+    end
+
+    def exit
+    end
+end

data/lib/simplestate/state.rb

@@ -1,19 +1,36 @@
-class State
-  attr_reader :holder
-  def initialize(holder)
-    @holder = holder
-  end
-
-private
-  def transition_to(new_state_class)
-    holder.transition_to(new_state_class)
-  end
-
-  def enter
-    raise NotImplementedError, "need to define #enter."
-  end
-
-  def exit
-    raise NotImplementedError, "need to define #exit."
-  end
-end
+class State
+  @list = {}
+
+  def self.list
+    @list
+  end
+
+
+  attr_reader :holder
+  def initialize(holder:, opts: {})
+    @holder = holder
+    State.list[self.symbol]= self
+  end
+
+  def name
+    'State'
+  end
+  alias :to_s :name
+
+  def symbol
+    name.to_sym
+  end
+
+  private
+    def transition_to(state)
+      holder.transition_to(state)
+    end
+
+    def enter
+      raise NotImplementedError, "#enter was called on an instance of State either directly or via super."
+    end
+
+    def exit
+      raise NotImplementedError, "#exit was called on an instance of State either directly or via super."
+    end
+end

data/lib/simplestate/state_history.rb

@@ -0,0 +1,18 @@
+class StateHistory
+  attr_reader :hx_size_limit
+
+  def initialize(hx_size_limit: 10)
+    @hx_size_limit = hx_size_limit
+    @container = []
+  end
+
+  def <<(state_symbol)
+    @container << state_symbol
+    @container = @container.last(hx_size_limit)
+    self
+  end
+
+  def list
+    @container
+  end
+end

data/lib/simplestate/state_holder.rb

@@ -1,42 +1,49 @@
-class StateHolder < SimpleDelegator
-  attr_reader :beginning, :state_history
-  attr_accessor :hx_size_limit
-  def initialize(opts={})
-    @beginning = initial_state_class(opts)
-    @hx_size_limit = opts.fetch :hx_size_limit, 5
-    @state_history = []
-    super(NilState.new(nil))
-    transition_to beginning
-  end
-
-  def transition_to(new_state_class)
-    update_state_history
-    current_state.send(:exit)
-    set_new_state(new_state_class)
-    current_state.send(:enter)
-  end
-
-  def current_state
-    __getobj__
-  end
-
-  def set_new_state(new_state_class)
-    self.current_state = new_state_class.new(self)
-  end
-
-private
-  def current_state=(state)
-    __setobj__(state)
-  end
-
-  def update_state_history
-    @state_history << current_state
-    @state_history = @state_history.last(hx_size_limit)
-  end
-
-  def initial_state_class(opts)
-    isc = opts.fetch :start_in,
-                     (opts.fetch :initial_state_class, nil)
-    isc ? isc : raise(ArgumentError, "initial state class is missing.")
-  end
-end
+class StateHolder < SimpleDelegator
+  attr_reader :initial_state, :state_history
+
+  def initialize(initial_state:, state_history: StateHistory.new, opts: {})
+    @initial_state = initial_state
+    @state_history = state_history
+
+    super(NullState.new)
+  end
+
+  def start
+    state_history << current_state.symbol
+    transition_to(initial_state)
+  end
+
+  def transition_to(state)
+    leave_old_state
+    enter_new_state(state)
+  end
+
+  # Convenience methods
+  def current_state
+    __getobj__
+  end
+
+  def history
+    state_history.list
+  end
+
+  def hx_size_limit
+    state_history.hx_size_limit
+  end
+
+  private
+    def leave_old_state
+      current_state.__send__(:exit)
+    end
+
+    def enter_new_state(state)
+      self.current_state = state
+      state_history << current_state.symbol
+      current_state.__send__(:enter)
+    end
+
+    def current_state=(state)
+      state_obj = State.list[state]
+      __setobj__(state_obj)
+    end
+end

data/lib/simplestate/version.rb

@@ -1,3 +1,3 @@
-module Simplestate
-  VERSION = "1.0.6"
-end
+module Simplestate
+  VERSION = "2.0.2"
+end

data/lib/simplestate.rb

@@ -1,5 +1,7 @@
-require "delegate"
-require "simplestate/version"
-require "simplestate/state_holder"
-require "simplestate/state"
-require "simplestate/nil_state"
+require "delegate"
+require "simplestate/version"
+require "simplestate/state_holder"
+require "simplestate/state_history"
+require "simplestate/state"
+require "simplestate/null_state"
+

data/simplestate.gemspec

@@ -1,41 +1,41 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'simplestate/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "simplestate"
-  spec.version       = Simplestate::VERSION
-  spec.authors       = ["Mitchell C Kuppinger"]
-  spec.email         = ["dpneumo@gmail.com"]
-
-  spec.summary       = %q{A SimpleDelegator based implementation of the State Pattern}
-  spec.description   = %q{Provides a base State class and a subclassed SimpleDelegator modified to provide state pattern support.}
-  spec.homepage      = "https://github.com/dpneumo/simplestate"
-  spec.license       = "MIT"
-
-  # This gem will work with 1.9.2 or greater...
-  spec.required_ruby_version = '>= 1.9.2'
-
-  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
-  # delete this section to allow pushing this gem to any host.
-  if spec.respond_to?(:metadata)
-    spec.metadata['allowed_push_host'] = "https://rubygems.org"
-  else
-    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
-  end
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
-
-  # Uncomment these to make pry available in testing
-  # Also make necessary changes in test_helper.rb
-  #spec.add_development_dependency "pry"
-  #spec.add_development_dependency "pry-byebug"
-end
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'simplestate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "simplestate"
+  spec.version       = Simplestate::VERSION
+  spec.authors       = ["Mitchell C Kuppinger"]
+  spec.email         = ["dpneumo@gmail.com"]
+
+  spec.summary       = %q{A SimpleDelegator based implementation of the State Pattern}
+  spec.description   = %q{Provides a base State class and a subclassed SimpleDelegator modified to provide state pattern support.}
+  spec.homepage      = "https://github.com/dpneumo/simplestate"
+  spec.license       = "MIT"
+
+  # This gem will work with 2.1.0 or greater...
+  spec.required_ruby_version = '>= 2.1.0'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", ">= 1.11"
+  spec.add_development_dependency "rake", ">= 10.0"
+  spec.add_development_dependency "minitest", ">= 5.0"
+
+  # Uncomment these to make pry available in testing
+  # Also make necessary changes in test_helper.rb
+  #spec.add_development_dependency "pry"
+  #spec.add_development_dependency "pry-byebug"
+end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: simplestate
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 2.0.2
 platform: ruby
 authors:
 - Mitchell C Kuppinger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-25 00:00:00.000000000 Z
+date: 2016-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
 description: Provides a base State class and a subclassed SimpleDelegator modified
@@ -63,6 +63,7 @@ files:
 - ".gitattributes"
 - ".gitignore"
 - ".travis.yml"
+- CHANGE_NOTES.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -70,9 +71,11 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- button_irb_session.txt
 - lib/simplestate.rb
-- lib/simplestate/nil_state.rb
+- lib/simplestate/null_state.rb
 - lib/simplestate/state.rb
+- lib/simplestate/state_history.rb
 - lib/simplestate/state_holder.rb
 - lib/simplestate/version.rb
 - simplestate.gemspec
@@ -89,7 +92,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/simplestate/nil_state.rb

@@ -1,11 +0,0 @@
-class NilState < State
-  def initialize(holder)
-  end
-
-private
-  def enter
-  end
-
-  def exit
-  end
-end