antw-simple_state 0.2.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Anthony Williams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.markdown

@@ -0,0 +1,224 @@
+# SimpleState
+
+Yet another state machine library for Ruby.
+
+## Why _another_ state machine library?
+
+There are several existing implementations of state machines in Ruby, notably
+[pluginaweek/state_machine][pluginaweek], [rubyist/aasm][rubyist] and
+[ryan-allen/workflow][ryanallen]. However, all felt rather heavy and
+cumbersome, when all I really needed was a lightweight means for setting the
+state of a class instance, and transitioning from one state to another.
+
+There is no explicit support for adding your own code to customise
+transitions, nor is there any support for callbacks or event guards (although
+you can still do similar things fairly trivially). It's called **Simple**State
+for a reason! The library adds some helper methods to your class, keeps track
+of the valid states, makes sure that a transition is permitted, and that's
+about it.
+
+## Why use SimpleState?
+
+<ul style="margin-top: 1em">
+  <li>Lightweight.</li>
+  <li>method_missing isn't used. ;)</li>
+  <li>No dependencies.</li>
+  <li>No extensions to core classes.</li>
+  <li>Tested on Ruby 1.8.6 (p383), 1.8.7 (p174), 1.9.1 (p243), and JRuby
+    1.3.1.</li>
+  <li>Uses an API similar to Workflow, which I find to be more logical than
+    that in the acts_as_state_machine family.</li>
+</ul>
+
+## Why use something else?
+
+<ul style="margin-top: 1em">
+  <li>The three libraries mentioned above make available, as part of their
+    DSL, a means of customising events/transitions with your own code.
+    SimpleState makes no such provision, however you can mimic the behaviour
+    quite easily as documented in example 3, below.</li>
+  <li>Similarly, some other libraries provide the ability to add guard
+    conditions -- a condition which must be satisfied before a transition
+    can take place. SimpleState also does explicitly support this, however it
+    is possible by adapting example 3.
+  <li>SimpleState forces you to use an attribute called `state` - other
+    libraries let you choose whatever name you want.</li>
+  <li>Uses a class variable to keep track of transitions - doesn't lend itself
+    all that well to subclassing your state machines.</li>
+</ul>
+
+If SimpleState's limitations are too much for you, then you are probably
+better off choosing one of the other libraries instead.
+
+## Examples
+
+### Example 1: Basic usage
+
+    require 'rubygems'
+    require 'simple_state'
+
+    class SimpleStateMachine
+      extend SimpleState  # Adds state_machine method to this class.
+
+      state_machine do
+        state :not_started do
+          event :start,  :transitions_to => :started
+        end
+
+        state :started do
+          event :finish, :transitions_to => :finished
+          event :cancel, :transitions_to => :cancelled
+        end
+
+        state :finished
+        state :cancelled
+      end
+    end
+
+SimpleState makes one assumption: that the first call to `state` in the
+`state_machine` block is the default state; every instance of
+SimpleStateMachine will begin with the state `:not_started`.
+
+_Note: if you define `#initialize` in your class, you should ensure that you
+call `super` or the default state won't get set._
+
+The above example declares four states: `not_started`, `started`, `finished`
+and `cancelled`. If your instance is in the `not_started` state it may
+transition to the `started` state by calling `SimpleStateMachine#start!`. Once
+`started` it can then transition to `finished` or `cancelled` using
+`SimpleStateMachine#finish!` and `SimpleStateMachine#cancel!`.
+
+Along with the bang methods for changing an instance's state, there are
+predicate methods which will return true or false depending on the current
+state of the instance.
+
+    instance = SimpleStateMachine.new  # Initial state will be :not_started
+
+    instance.not_started? # => true
+    instance.started?     # => false
+    instance.finished?    # => false
+    instance.cancelled?   # => false
+
+    instance.start!
+
+    instance.not_started? # => false
+    instance.started?     # => true
+    instance.finished?    # => false
+    instance.cancelled?   # => false
+
+    # etc...
+
+### Example 2: Events in multiple states
+
+It is possible for the same event to be used in multiple states:
+
+    state :not_started do
+      event :start,  :transitions_to => :started
+      event :cancel, :transitions_to => :cancelled  # <--
+    end
+
+    state :started do
+      event :finish, :transitions_to => :finished
+      event :cancel, :transitions_to => :cancelled  # <--
+    end
+
+... or for the event to do something different depending on the object's
+current state:
+
+    state :not_started do
+      event :start,  :transitions_to => :started
+      event :cancel, :transitions_to => :cancelled_before_start  # <--
+    end
+
+    state :started do
+      event :finish, :transitions_to => :finished
+      event :cancel, :transitions_to => :cancelled               # <--
+    end
+
+    state :finished
+    state :cancelled
+    state :cancelled_before_start
+
+### Example 3: Customising event transitions
+
+If the built in event methods aren't sufficient and you need to do extra stuff
+to your class during a particular event, you can simply override the method;
+the original method is available via `super`:
+
+    class OverriddenEvent
+      extend SimpleState
+
+      state_machine do
+        state :start do
+          event :start, :transitions_to => :started
+        end
+
+        state :started
+      end
+
+      def start!
+        puts "Before super() : state=#{self.state}"
+        ret = super
+        puts "After super() : state=#{self.state}"
+        ret
+      end
+    end
+
+    OverriddenEvent.new.start!
+    # => Before super() : state=start
+    # => After super() : state=finished
+    # => :started
+
+If the event transition isn't valid, super will simply return false, otherwise
+it will return the symbol representing the new state.
+
+    def start!
+      if new_state = super
+        puts "Started! The new state is #{self.state}"
+      else
+        puts "Could not start!"
+      end
+
+      new_state
+    end
+
+    machine = OverriddenEvent.new
+    machine.start!
+    => Started! The new state is finished
+    => :started
+
+    machine.start!
+    => Could not start!
+    => false
+
+If you need to know whether a transition will be permitted before you call
+super(), SimpleState provides `#event_permitted?`, expecting you to provide a
+symbol representing the event.
+
+    machine.event_permitted?(:start)
+    # => true|false
+
+This also provides an easy means for creating guard conditions:
+
+    def start!
+      if event_permitted?(:start) && SomeExternalService.can_start?(self)
+        super
+      end
+    end
+
+## ORM Integration
+
+SimpleState should play nicely with your ORM of choice. When an object's state
+is set, `YourObject#state=` is called with a symbol representing the state.
+Simply add a string/enum property called `state` to your DataMapper class, or
+a `state` field to your ActiveRecord database and things should be fine. I
+confess to having no familiarity with Sequel, but I don't foresee any
+difficulty there either.
+
+## License
+
+SimpleState is released under the MIT License; see LICENSE for details.
+
+[pluginaweek]: http://github.com/pluginaweek/state_machine (pluginaweek's state_machine library)
+[rubyist]: http://github.com/rubyist/aasm (rubyist's aasm library)
+[ryanallen]: http://github.com/ryan-allen/workflow (ryan-allen's Workflow library)

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "simple_state"
+    gem.platform    = Gem::Platform::RUBY
+    gem.summary     = 'A *very simple* state machine implementation.'
+    gem.description = gem.summary
+    gem.email       = "anthony@ninecraft.com"
+    gem.homepage    = "http://github.com/antw/simple_state"
+    gem.authors     = ["Anthony Williams"]
+
+    gem.extra_rdoc_files = %w(README.markdown LICENSE)
+
+    gem.files = %w(LICENSE README.markdown Rakefile VERSION.yml) +
+                Dir.glob("{lib,spec}/**/*")
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install " \
+       "technicalpickles-jeweler -s http://gems.github.com"
+end
+
+# rDoc =======================================================================
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'simple_state'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# rSpec & rcov ===============================================================
+
+desc "Run all examples (or a specific spec with TASK=xxxx)"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_opts  = ["-c -f s"]
+  t.spec_files = begin
+    if ENV["TASK"]
+      ENV["TASK"].split(',').map { |task| "spec/**/#{task}_spec.rb" }
+    else
+      FileList['spec/**/*_spec.rb']
+    end
+  end
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec:rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.spec_opts = ['-c -f s']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 2
+:patch: 1

data/lib/simple_state.rb

@@ -0,0 +1,14 @@
+module SimpleState
+  class Error < StandardError; end
+  class ArgumentError < Error; end
+
+  ##
+  # Sets up a state machine on the current class.
+  #
+  def state_machine(&blk)
+    Builder.new(self).build(&blk)
+  end
+end
+
+require 'simple_state/builder'
+require 'simple_state/mixins'

data/lib/simple_state/builder.rb

@@ -0,0 +1,150 @@
+module SimpleState
+  ##
+  # Responsible for taking a state machine block and building the methods.
+  #
+  # The builder is run whenever you call +state_machine+ on a class and does
+  # a number of things.
+  #
+  #   * Firstly, it adds a :state reader if one is not defined, and a
+  #     _private_ :state writer.
+  #
+  #   * It adds a +states+ method to the class, used for easily accessing
+  #     the list of states for the class, and the events belonging to each
+  #     state (and the state that the event transitions to).
+  #
+  #   * Four internal methods +initial_state+, +initial_state=+,
+  #     +_determine_new_state+ and +_valid_transition+ which are used
+  #     internally by SimpleState for aiding the transition from one state to
+  #     another.
+  #
+  class Builder
+    def initialize(klass)
+      @klass = klass
+    end
+
+    ##
+    # Trigger for building the state machine methods.
+    #
+    def build(&blk)
+      @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        include ::SimpleState::Mixins
+      RUBY
+
+      # Create an anonymous module which will be added to the state machine
+      # class's inheritance chain.
+      mod = @mod = Module.new
+      mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.inspect
+          "SimpleState::#{@klass}AnonMixin"
+        end
+
+        # Handles the change of state.
+        # @api private
+        def _change_state_using_event!(event)
+          self.state = self.class._determine_new_state(self.state, event)
+        end
+
+        # Returns if the passed event is permitted with the instance in it's
+        # current state.
+        # @api public
+        def event_permitted?(event)
+          self.class._event_permitted?(self.state, event)
+        end
+
+        # Returns true if the given symbol matches the current state.
+        # @api public
+        def in_state?(state)
+          self.state == state
+        end
+      RUBY
+
+      # Declare the state machine rules.
+      instance_eval(&blk)
+
+      # Insert the anonymous module.
+      @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        include mod
+      RUBY
+    end
+
+    ##
+    # Defines a new state.
+    #
+    # @param [Symbol] name
+    #   The name of the state.
+    # @param [Block] &blk
+    #   An optional block for defining transitions for the state. If no block
+    #   is given, the state will be an end-point.
+    #
+    def state(name, &blk)
+      @klass.states[name] = []
+      @klass.initial_state ||= name
+
+      @mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name}?           # def prepared?
+          in_state?(:#{name})  #   self.state == :prepared
+        end                    # end
+      RUBY
+
+      # Define transitions for this state.
+      StateBuilder.new(@klass, @mod, name).build(&blk) if blk
+    end
+
+    ##
+    # Responsible for building events for a given state.
+    #
+    class StateBuilder
+      def initialize(klass, mod, state)
+        @klass, @module, @state = klass, mod, state
+      end
+
+      ##
+      # Specialises a state by defining events.
+      #
+      # @param [Block]  &blk
+      #   An block for defining transitions for the state.
+      #
+      def build(&blk)
+        instance_eval(&blk)
+      end
+
+      ##
+      # Defines an event and transition.
+      #
+      # @param [Symbol] event_name A name for this event.
+      # @param [Hash]   opts       An options hash for customising the event.
+      #
+      def event(event, opts = {})
+        unless opts[:transitions_to].kind_of?(Symbol)
+          raise ArgumentError, 'You must declare a :transitions_to state ' \
+                               'when defining events'
+        end
+
+        # Keep track of valid transitions for this state.
+        @klass.states[@state].push([event, opts[:transitions_to]])
+
+        unless @module.method_defined?(:"#{event}!")
+          # Example:
+          #
+          # def process!
+          #   if event_permitted?(:process)
+          #     _change_state_using_event!(:process)
+          #   else
+          #     false
+          #   end
+          # end
+          @module.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{event}!
+              if event_permitted?(:#{event})
+                _change_state_using_event!(:#{event})
+              else
+                false
+              end
+            end
+          RUBY
+        end
+      end # def event
+    end # StateBuilder
+
+  end # Builder
+end # SimpleState

data/lib/simple_state/mixins.rb

@@ -0,0 +1,65 @@
+module SimpleState
+  module Mixins
+    def self.included(klass)
+      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        attr_reader :state unless method_defined?(:state)
+        @@states = {}
+        @@initial_state = nil
+
+        unless method_defined?(:state=)
+          attr_writer :state
+          private :state=
+        end
+
+        extend  Singleton
+        include Instance
+      RUBY
+    end
+
+    ##
+    # Defines singleton methods which are mixed in to a class when
+    # state_machine is called.
+    #
+    module Singleton
+      # @api private
+      def states
+        class_variable_get(:@@states)
+      end
+
+      # @api public
+      def initial_state=(state)
+        class_variable_set(:@@initial_state, state)
+      end
+
+      # @api public
+      def initial_state
+        class_variable_get(:@@initial_state)
+      end
+
+      # @api private
+      def _determine_new_state(current, to)
+        states[current] && (t = states[current].assoc(to)) && t.last
+      end
+
+      # @api private
+      def _event_permitted?(current, to)
+        states[current] and not states[current].assoc(to).nil?
+      end
+    end
+
+    ##
+    # Defines instance methods which are mixed in to a class when
+    # state_machine is called.
+    #
+    module Instance
+      ##
+      # Set the initial value for the state machine after calling the original
+      # initialize method.
+      #
+      def initialize(*args, &blk)
+        super
+        self.state = self.class.initial_state
+      end
+    end # Instance
+  end # Mixins
+end # SimpleState

data/spec/builder_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+# Basic State Machine ========================================================
+
+describe SimpleState::Builder do
+  before(:each) do
+    @c = state_class do
+      state :prepared
+      state :processed
+    end
+  end
+
+  it 'should add a private state writer' do
+    @c.private_methods.map { |m| m.to_sym }.should include(:state=)
+  end
+
+  it 'should add a state reader' do
+    @c.methods.map { |m| m.to_sym }.should include(:state)
+  end
+
+  describe 'when defining states with no events' do
+    it 'should create a predicate' do
+      methods = @c.methods.map { |m| m.to_sym }
+      methods.should include(:prepared?)
+      methods.should include(:processed?)
+    end
+
+    it 'should add the state to register' do
+      @c.class.states.keys.should include(:prepared)
+      @c.class.states.keys.should include(:processed)
+    end
+  end
+end
+
+# State Machine with Events ==================================================
+
+describe 'when defining a state with an event' do
+  before(:each) do
+    @evented_state = state_class do
+      state :prepared do
+        event :process,           :transitions_to => :processed
+        event :processing_failed, :transitions_to => :failed
+      end
+
+      state :processed
+    end
+  end
+
+  it 'should add a bang method for the transition' do
+    @evented_state.methods.map { |m| m.to_sym }.should \
+      include(:process!)
+    @evented_state.methods.map { |m| m.to_sym }.should \
+      include(:processing_failed!)
+  end
+
+  it 'should add the state to register' do
+    @evented_state.class.states.keys.should include(:prepared)
+    @evented_state.class.states.keys.should include(:processed)
+  end
+
+  it 'should raise an argument error if no :transitions_to is provided' do
+    lambda {
+      Class.new do
+        extend SimpleState
+        state_machine do
+          state(:prepared) { event :process }
+        end
+      end
+    }.should raise_error(SimpleState::ArgumentError)
+  end
+end

data/spec/event_methods_spec.rb

@@ -0,0 +1,227 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe 'Generated event methods' do
+
+  it 'should permit the use of super when overriding them' do
+    @c = Class.new do
+      attr_reader :called
+
+      extend SimpleState
+
+      state_machine do
+        state :begin do
+          event :go, :transitions_to => :finished
+        end
+
+        state :finished
+      end
+
+      def go!
+        @called = true
+        super()
+      end
+    end.new
+
+    @c.should be_begin
+    lambda { @c.go! }.should_not raise_error(NoMethodError)
+    @c.should be_finished
+    @c.called.should be_true
+  end
+
+  # Event Validation =========================================================
+
+  describe 'when the transition is valid' do
+    before(:each) do
+      @c = state_class do
+        state :begin do
+          event :go, :transitions_to => :state_one
+        end
+
+        state :state_one
+      end
+    end
+
+    it 'should return the new state' do
+      @c.go!.should == :state_one
+    end
+
+    it 'should transition the instance to the new state' do
+      @c.go!
+      @c.should be_state_one
+    end
+  end
+
+  describe 'when the transition is not valid' do
+    before(:each) do
+      @c = state_class do
+        state :begin do
+          event :go, :transitions_to => :state_one
+        end
+
+        state :state_one do
+          event :go_again, :transitions_to => :state_two
+        end
+
+        state :state_two
+      end
+    end
+
+    it 'should return false' do
+      @c.go_again!.should be_false
+    end
+
+    it "should not change the instance's state" do
+      @c.go_again!
+      @c.should be_begin
+    end
+  end
+
+  # Multiple Paths Definition ================================================
+
+  describe 'when mulitple states share the same event' do
+    before(:each) do
+      @path = state_class do
+        state :begin do
+          event :s1, :transitions_to => :state_one
+          event :s2, :transitions_to => :state_two
+        end
+
+        state :state_one do
+          event :go, :transitions_to => :state_three
+        end
+
+        state :state_two do
+          event :go, :transitions_to => :state_four
+        end
+
+        state :state_three
+        state :state_four
+      end
+    end
+
+    it 'should transition to state_three if currently in state_one' do
+      @path.s1!
+      @path.go!
+      @path.should be_state_three
+    end
+
+    it 'should transition to state_four if current in state_two' do
+      @path.s2!
+      @path.go!
+      @path.should be_state_four
+    end
+  end
+
+end
+
+# Test full workflow =========================================================
+# This tests all the possible transition permutations of a state machine.
+
+describe 'Generated event methods (integration)' do
+  before(:each) do
+    @c = state_class do
+      state :prepared do
+        event :requires_decompress, :transitions_to => :requires_decompress
+        event :invalid_extension,   :transitions_to => :halted
+        event :processed,           :transitions_to => :processed
+        event :processing_failed,   :transitions_to => :halted
+      end
+
+      state :processed do
+        event :stored,              :transitions_to => :stored
+        event :store_failed,        :transitions_to => :halted
+      end
+
+      state :requires_decompress do
+        event :decompressed,        :transitions_to => :complete
+        event :decompress_failed,   :transitions_to => :halted
+      end
+
+      state :stored do
+        event :cleaned,             :transitions_to => :complete
+      end
+
+      state :halted do
+        event :cleaned,             :transitions_to => :failed
+      end
+
+      state :failed
+      state :complete
+    end
+  end
+
+  it 'should successfully change the state to complete via the ' \
+           'intermediate states' do
+
+    # begin -> processed -> stored -> complete
+
+    @c.should be_prepared
+
+    @c.processed!.should == :processed
+    @c.should be_processed
+
+    @c.stored!.should    == :stored
+    @c.should be_stored
+
+    @c.cleaned!.should   == :complete
+    @c.should be_complete
+  end
+
+  it 'should successfully change the state to complete via successful ' \
+     'decompress' do
+
+    # begin -> requires_decompress -> complete
+
+    @c.requires_decompress!.should == :requires_decompress
+    @c.should be_requires_decompress
+
+    @c.decompressed!.should == :complete
+    @c.should be_complete
+  end
+
+  it 'should successfully change the state to failed via failed decompress' do
+    # begins -> requires_decompress -> halted -> failed
+
+    @c.requires_decompress!.should == :requires_decompress
+    @c.should be_requires_decompress
+
+    @c.decompress_failed!.should == :halted
+    @c.should be_halted
+
+    @c.cleaned!.should == :failed
+    @c.should be_failed
+  end
+
+  it 'should successfully change the state to failed via invalid extension' do
+    # begins -> halted -> failed
+
+    @c.invalid_extension!.should == :halted
+    @c.should be_halted
+
+    @c.cleaned!.should == :failed
+    @c.should be_failed
+  end
+
+  it 'should successfully change the state to failed via failed processing' do
+    # begins -> halted -> failed
+
+    @c.processing_failed!.should == :halted
+    @c.should be_halted
+
+    @c.cleaned!.should == :failed
+    @c.should be_failed
+  end
+
+  it 'should successfully change the state to failed via failed storage' do
+    # begins -> processed -> halted -> failed
+
+    @c.processed!.should == :processed
+    @c.should be_processed
+
+    @c.store_failed!.should == :halted
+    @c.should be_halted
+
+    @c.cleaned!.should == :failed
+    @c.should be_failed
+  end
+end

data/spec/mixins_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe SimpleState::Mixins::Instance do
+  describe '#initialize' do
+    it 'should set the initial state' do
+      c = state_class do
+        state :begin
+        state :finish
+      end
+
+      c.state.should == :begin
+    end
+
+    it 'should call the original #initialize' do
+      parent = Class.new do
+        attr_reader :called
+
+        def initialize
+          @called = true
+        end
+      end
+
+      child = Class.new(parent) do
+        extend SimpleState
+        state_machine do
+          state :begin
+        end
+      end
+
+      child.new.called.should be_true
+      child.new.state.should == :begin
+    end
+
+    it 'should have separate state machines for each class' do
+      class_one = state_class do
+        state :one
+      end
+
+      class_two = state_class do
+        state :two
+      end
+
+      class_one.class.states.keys.should == [:one]
+      class_two.class.states.keys.should == [:two]
+    end
+  end
+end

data/spec/predicate_methods_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe SimpleState, 'generated predicate methods' do
+  before(:each) do
+    @predicate_test = state_class do
+      state :state_one
+      state :state_two
+      state :state_three
+    end
+  end
+
+  it 'should return true if the current state matches the predicate' do
+    @predicate_test.should be_state_one
+  end
+
+  it 'should return false if the current state does not match the predicate' do
+    @predicate_test.should_not be_state_two
+    @predicate_test.should_not be_state_three
+  end
+
+  it 'should permit the use of super when overriding them' do
+    @c = Class.new do
+      attr_reader :called
+
+      extend SimpleState
+
+      state_machine do
+        state :begin
+      end
+
+      def begin?
+        @called = true
+        super()
+      end
+    end.new
+
+    lambda { @c.begin? }.should_not raise_error(NoMethodError)
+    @c.called.should be_true
+  end
+end

data/spec/simple_state_spec.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "SimpleState" do
+  it "should add a state_machine method to the class" do
+    Class.new { extend SimpleState }.methods.map do |m|
+      # Ruby 1.9 compat.
+      m.to_sym
+    end.should include(:state_machine)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'spec'
+
+# $LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'simple_state'
+
+##
+# Creates an anonymous class which uses SimpleState.
+#
+def state_class(&blk)
+  Class.new do
+    extend SimpleState
+    state_machine(&blk)
+  end.new
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: antw-simple_state
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Anthony Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-21 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A *very simple* state machine implementation.
+email: anthony@ninecraft.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION.yml
+- lib/simple_state.rb
+- lib/simple_state/builder.rb
+- lib/simple_state/mixins.rb
+- spec/builder_spec.rb
+- spec/event_methods_spec.rb
+- spec/mixins_spec.rb
+- spec/predicate_methods_spec.rb
+- spec/simple_state_spec.rb
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/antw/simple_state
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A *very simple* state machine implementation.
+test_files: 
+- spec/builder_spec.rb
+- spec/event_methods_spec.rb
+- spec/mixins_spec.rb
+- spec/predicate_methods_spec.rb
+- spec/simple_state_spec.rb
+- spec/spec_helper.rb