statemachine 0.0.0

data/CHANGES

@@ -0,0 +1,12 @@
+= StateMachine Changelog
+
+== Version 0.0.0
+
+The first release.  Most finite state machine features are implemented
+* states
+* transitions
+* transition actions
+* super states
+* entry actions
+* exit actions
+* history state

data/Rakefile

@@ -0,0 +1,170 @@
+$:.unshift('lib')
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+# Some of the tasks are in separate files since they are also part of the website documentation
+"load File.dirname(__FILE__) + '/tasks/examples.rake'
+load File.dirname(__FILE__) + '/tasks/examples_specdoc.rake'
+load File.dirname(__FILE__) + '/tasks/examples_with_rcov.rake'
+load File.dirname(__FILE__) + '/tasks/failing_examples_with_html.rake'
+load File.dirname(__FILE__) + '/tasks/verify_rcov.rake'"
+
+PKG_NAME = "statemachine"
+PKG_VERSION   = "0.0.0"
+PKG_TAG = "0_0_0"
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'lib/**/*.rb', 
+  'spec/**/*.rb' 
+#  'examples/**/*',
+]
+
+task :default => :spec
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--diff','--color']
+#  t.rcov = true
+#  t.rcov_dir = 'doc/output/coverage'
+#  t.rcov_opts = ['--exclude', 'spec\/spec,bin\/spec']"
+end
+
+#desc 'Generate HTML documentation for website'
+#task :webgen do
+#  Dir.chdir 'doc' do
+#    output = nil
+#    IO.popen('webgen 2>&1') do |io|
+#      output = io.read
+#    end
+#    raise "ERROR while running webgen: #{output}" if output =~ /ERROR/n || $? != 0
+#  end
+#end
+
+#desc 'Generate RDoc'
+#rd = Rake::RDocTask.new do |rdoc|
+#  rdoc.rdoc_dir = 'doc/output/rdoc'
+#  rdoc.options << '--title' << 'RSpec' << '--line-numbers' << '--inline-source' << '--main' << 'README'
+#  rdoc.rdoc_files.include('README', 'CHANGES', 'EXAMPLES.rd', 'lib/**/*.rb')
+#end
+#task :rdoc => :examples_specdoc # We generate EXAMPLES.rd
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = Spec::VERSION::DESCRIPTION
+  s.description = <<-EOF
+    StateMachine is a ruby library for building Finite State Machines (FSM), also known as Finite State Automata (FSA).
+  EOF
+
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+
+#  s.has_rdoc = true
+#  s.rdoc_options = rd.options
+#  s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$|^EXAMPLES.rd$/ }.to_a
+  
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.require_path = 'lib'
+  s.autorequire = 'statemachine'
+#  s.bindir = "bin"
+#  s.executables = ["spec"]
+#  s.default_executable = "spec"
+  s.author = ["Micah Martin"]
+  s.email = "statemachine-devel@rubyforge.org"
+  s.homepage = "http://statemachine.rubyforge.org"
+  s.rubyforge_project = "statemachine"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+def egrep(pattern)
+  Dir['**/*.rb'].each do |fn|
+    count = 0
+    open(fn) do |f|
+      while line = f.gets
+        count += 1
+        if line =~ pattern
+          puts "#{fn}:#{count}:#{line}"
+        end
+      end
+    end
+  end
+end
+
+desc "Look for TODO and FIXME tags in the code"
+task :todo do
+  egrep /(FIXME|TODO|TBD)/
+end
+
+task :clobber do
+  rm_rf 'doc/output'
+end
+
+task :release => [:clobber, :verify_committed, :verify_user, :verify_password, :spec, :publish_packages, :tag, :publish_website, :publish_news]
+
+desc "Verifies that there is no uncommitted code"
+task :verify_committed do
+  IO.popen('svn stat') do |io|
+    io.each_line do |line|
+      raise "\n!!! Do a svn commit first !!!\n\n" if line =~ /^\s*M\s*/
+    end
+  end
+end
+
+desc "Creates a tag in svn"
+task :tag do
+  puts "Creating tag in SVN"
+  `svn cp svn+ssh://#{ENV['RUBYFORGE_USER']}@rubyforge.org/var/svn/statemachine/trunk svn+ssh://#{ENV['RUBYFORGE_USER']}@rubyforge.org/var/svn/statemachine/tags/#{PKG_VERSION} -m "Tag release #{PKG_TAG}"`
+  puts "Done!"
+end
+
+
+#desc "Build the website, but do not publish it"
+#task :website => [:clobber, :verify_rcov, :webgen, :failing_examples_with_html, :spec, :examples_specdoc, :rdoc]
+
+#desc "Upload Website to RubyForge"
+#task :publish_website => [:verify_user, :website] do
+#  publisher = Rake::SshDirPublisher.new(
+#    "rspec-website@rubyforge.org",
+#    "/var/www/gforge-projects/#{PKG_NAME}",
+#    "doc/output"
+#  )
+
+#  publisher.upload
+#end
+
+task :verify_user do
+  raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
+end
+
+task :verify_password do
+  raise "RUBYFORGE_PASSWORD environment variable not set!" unless ENV['RUBYFORGE_PASSWORD']
+end
+
+desc "Publish gem+tgz+zip on RubyForge. You must make sure lib/version.rb is aligned with the CHANGELOG file"
+task :publish_packages => [:verify_user, :verify_password, :package] do
+  require 'meta_project'
+  require 'rake/contrib/xforge'
+  release_files = FileList[
+    "pkg/#{PKG_FILE_NAME}.gem",
+    "pkg/#{PKG_FILE_NAME}.tgz",
+    "pkg/#{PKG_FILE_NAME}.zip"
+  ]
+
+  Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |xf|
+    # Never hardcode user name and password in the Rakefile!
+    xf.user_name = ENV['RUBYFORGE_USER']
+    xf.password = ENV['RUBYFORGE_PASSWORD']
+    xf.files = release_files.to_a
+    xf.release_name = "StateMachine #{PKG_VERSION}"
+  end
+end

data/lib/proc_calling.rb

@@ -0,0 +1,54 @@
+module StateMachine
+
+  module ProcCalling
+    
+    private
+      
+    def call_proc(proc, args, message)
+      arity = proc.arity
+      if should_call_with(arity, 0, args, message)
+        proc.call
+      elsif should_call_with(arity, 1, args, message)
+        proc.call args[0]
+      elsif should_call_with(arity, 2, args, message)
+        proc.call args[0], args[1]
+      elsif should_call_with(arity, 3, args, message)
+        proc.call args[0], args[1], args[2]
+      elsif should_call_with(arity, 4, args, message)
+        proc.call args[0], args[1], args[2], args[3]
+      elsif should_call_with(arity, 5, args, message)
+        proc.call args[0], args[1], args[2], args[3], args[4]
+      elsif should_call_with(arity, 6, args, message)
+        proc.call args[0], args[1], args[2], args[3], args[4], args[5]
+      elsif should_call_with(arity, 7, args, message)
+        proc.call args[0], args[1], args[2], args[3], args[4], args[5], args[6]
+      elsif should_call_with(arity, 8, args, message)
+        proc.call args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]
+      elsif arity < 0 and args and args.length > 8
+        proc.call args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]
+      else
+        raise StateMachineException.new("Too many arguments(#{args.length}). (#{message})")
+      end
+    end
+    
+    def should_call_with(arity, n, args, message)
+      actual = args ? args.length : 0
+      if arity == n
+        return enough_args?(actual, arity, arity, message)
+      elsif arity < 0
+        required_args = (arity * -1) - 1
+        return (actual == n and enough_args?(actual, required_args, arity, message))
+      end
+    end
+    
+    def enough_args?(actual, required, arity, message)
+      if actual >= required
+        return true
+      else
+        raise StateMachineException.new("Insufficient parameters. (#{message})")
+      end
+    end
+    
+  end
+
+end

data/lib/state.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/proc_calling'
+
+module StateMachine
+
+  class State
+    
+    include ProcCalling
+    
+    attr_reader :id, :statemachine, :entry_action, :exit_action
+    attr_accessor :superstate
+
+    def initialize(id, state_machine)
+      @id = id
+      @statemachine = state_machine
+      @transitions = {}
+    end
+
+    def add(transition)
+      @transitions[transition.event] = transition
+    end
+  
+    def transitions
+      return @superstate ? @transitions.merge(@superstate.transitions) : @transitions
+    end
+
+    def local_transitions
+      return @transitions
+    end
+
+    def [] (event)
+      return transitions[event]
+    end
+  
+    def on_entry action
+      @entry_action = action
+    end
+  
+    def on_exit action
+      @exit_action = action
+    end
+    
+    def exit(args)
+      @statemachine.trace("\texiting #{self}")
+      call_proc(@exit_action, args, "exit action for #{self}") if @exit_action
+      @superstate.existing(self) if @superstate
+    end
+
+    def enter(args)
+      @statemachine.trace("\tentering #{self}")
+      call_proc(@entry_action, args, "entry action for #{self}") if @entry_action
+    end
+    
+    def is_superstate?
+      return false
+    end
+
+    def to_s
+      return "'#{id}' state"
+    end
+
+    def add_substates(*substate_ids)
+      raise StateMachineException.new("At least one parameter is required for add_substates.") if substate_ids.length == 0
+      replacement = Superstate.new(self, @transitions, substate_ids)
+      @statemachine.replace_state(@id, replacement)
+    end
+
+  end
+  
+end

data/lib/state_machine.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/state'
+require File.dirname(__FILE__) + '/super_state'
+require File.dirname(__FILE__) + '/transition'
+require File.dirname(__FILE__) + '/proc_calling'
+
+module StateMachine
+  
+  class StateMachineException < Exception
+  end
+  
+  class MissingTransitionException < StateMachineException
+  end
+  
+  class StateMachine
+    
+    include ProcCalling
+  
+    attr_reader :states, :state, :running
+    attr_accessor :start_state, :tracer
+  
+    def initialize
+      @states = {}
+      @start_state = nil
+      @state = nil
+      @running = false
+    end
+  
+    def add(origin_id, event, destination_id, action = nil)
+      origin = acquire_state(origin_id)
+      @start_state = origin if @start_state == nil
+      destination = acquire_state(destination_id)
+      origin.add(Transition.new(origin, destination, event, action))
+    end
+  
+    def run
+      @state = @start_state
+      @running = true
+    end
+    alias :reset :run
+  
+    def [] (state_id)
+      return @states[state_id]
+    end
+    
+    def state= value
+      if @states[value]
+        @state = @states[value]
+      elsif value and @states[value.to_sym]
+        @state = @states[value.to_sym]
+      end
+    end
+  
+    def process_event(event, *args)
+      trace "Event: #{event}"
+      if @state
+        transition = @state.transitions[event]
+        if transition
+          @state = transition.invoke(@state, args)
+        else
+          raise MissingTransitionException.new("#{@state} does not respond to the '#{event}' event.")
+        end
+        @running = @state != nil
+      else
+        raise StateMachineException.new("The state machine isn't in any state.  Did you forget to call run?")
+      end
+    end
+  
+    def method_missing(message, *args)
+      if @state and @state[message]
+        method = self.method(:process_event)
+        params = [message.to_sym].concat(args)
+        call_proc(method, params, "method_missing")
+      else
+        super(message, args)
+      end
+    end
+  
+    def acquire_state(state_id)
+      return nil if state_id == nil
+      state = @states[state_id]
+      if not state
+        state = State.new(state_id, self)
+        @states[state_id] = state
+      end
+      return state
+    end
+    
+    def replace_state(state_id, replacement_state)
+      @states[state_id] = replacement_state
+      @states.values.each do |state|
+        state.local_transitions.values.each do |transition|
+          transition.destination = replacement_state if transition.destination.id == state_id
+        end
+      end
+    end
+    
+    def trace(message)
+      @tracer.puts message if @tracer
+    end
+  
+  end
+
+end

data/lib/statemachine.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/state_machine'

data/lib/super_state.rb

@@ -0,0 +1,68 @@
+module StateMachine
+
+  class Superstate < State
+  
+    attr_writer :start_state
+  
+    def initialize(state, transitions, substate_ids)
+      @id = state.id
+      @statemachine = state.statemachine
+      @transitions = transitions
+      @entry_action = state.entry_action
+      @exit_action = state.exit_action
+      @superstate = state.superstate
+      do_substate_adding(substate_ids)
+    end
+    
+    def is_superstate?
+      return true
+    end
+    
+    def start_state
+      if @use_history and @history_state
+        return @history_state
+      else
+        return @start_state
+      end
+    end
+    
+    def existing(substate)
+      @history_state = substate
+    end
+  
+    def add_substates(*substate_ids)
+      do_substate_adding(substate_ids)
+    end
+    
+    def use_history
+      @use_history = true;
+    end
+
+    def to_s
+      return "'#{id}' superstate"
+    end
+
+    private
+  
+    def do_substate_adding(substate_ids)
+      substate_ids.each do |substate_id|
+        substate = @statemachine.acquire_state(substate_id)
+        @start_state = substate if not @start_state
+        substate.superstate = self
+        check_for_substate_recursion
+      end
+    end
+  
+    def check_for_substate_recursion
+      tmp_state = @superstate
+      while tmp_state
+        if tmp_state == self
+          raise StateMachineException.new("Cyclic substates not allowed. (#{id})")
+        end 
+        tmp_state = tmp_state.superstate
+      end
+    end
+  
+  end
+
+end

data/lib/transition.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/proc_calling'
+
+module StateMachine
+
+  class Transition
+    
+    include ProcCalling
+    
+    attr_reader :origin, :event, :action
+    attr_accessor :destination
+
+    def initialize(origin, destination, event, action)
+      @origin = origin
+      @destination = destination
+      @event = event
+      @action = action
+    end
+    
+    def invoke(origin, args)
+      exits, entries = exits_and_entries(origin)
+      exits.each { |exited_state| exited_state.exit(args) }
+      
+      call_proc(@action, args, "transition action from #{origin} invoked by '#{event}' event") if @action
+
+      entries.each { |entered_state| entered_state.enter(args) }
+      
+      terminal_state = @destination
+      while terminal_state and terminal_state.is_superstate?
+        terminal_state = terminal_state.start_state
+        terminal_state.enter(args)
+      end
+      
+      return terminal_state
+    end
+    
+    def exits_and_entries(origin)
+      exits = []
+      entries = exits_and_entries_helper(exits, origin)
+      
+      return exits, entries.reverse
+    end
+  
+    def to_s
+      return "#{origin.id} ---#{event}---> #{destination.id} : #{action}"
+    end
+    
+    private
+    
+    def exits_and_entries_helper(exits, exit_state)
+      entries = entries_to_destination(exit_state)
+      return entries if entries
+      return [] if exit_state == nil
+      
+      exits << exit_state
+      exits_and_entries_helper(exits, exit_state.superstate)
+    end
+    
+    def entries_to_destination(exit_state)
+      entries = []
+      state = @destination
+      while state    
+        entries << state
+        return entries if exit_state == state.superstate
+        state = state.superstate
+      end
+      return nil
+    end
+    
+  end
+  
+end

data/spec/sm_action_parameterization_spec.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "State Machine Odds And Ends" do
+  include SwitchStateMachine
+
+  setup do
+    create_switch
+    @sm.run
+  end
+  
+  specify "action with one parameter" do
+    @sm.add(:off, :set, :on, Proc.new { |value| @status = value } )
+    @sm.set "blue"
+    @status.should_equal "blue"
+    @sm.state.id.should_be :on
+  end
+
+  specify "action with two parameters" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b| @status = [a, b].join(",") } )
+    @sm.set "blue", "green"
+    @status.should_equal "blue,green"
+    @sm.state.id.should_be :on
+  end
+
+  specify "action with three parameters" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } )
+    @sm.set "blue", "green", "red"
+    @status.should_equal "blue,green,red"
+    @sm.state.id.should_be :on
+  end
+
+  specify "action with four parameters" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d| @status = [a, b, c, d].join(",") } )
+    @sm.set "blue", "green", "red", "orange"
+    @status.should_equal "blue,green,red,orange"
+    @sm.state.id.should_be :on
+  end
+
+  specify "action with five parameters" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e| @status = [a, b, c, d, e].join(",") } )
+    @sm.set "blue", "green", "red", "orange", "yellow"
+    @status.should_equal "blue,green,red,orange,yellow"
+    @sm.state.id.should_be :on
+  end
+  
+  specify "action with six parameters" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e, f| @status = [a, b, c, d, e, f].join(",") } )
+    @sm.set "blue", "green", "red", "orange", "yellow", "indigo"
+    @status.should_equal "blue,green,red,orange,yellow,indigo"
+    @sm.state.id.should_be :on
+  end
+
+  specify "action with seven parameters" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e, f, g| @status = [a, b, c, d, e, f, g].join(",") } )
+    @sm.set "blue", "green", "red", "orange", "yellow", "indigo", "violet"
+    @status.should_equal "blue,green,red,orange,yellow,indigo,violet"
+    @sm.state.id.should_be :on
+  end
+
+  specify "action with eight parameters" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e, f, g, h| @status = [a, b, c, d, e, f, g, h].join(",") } )
+    @sm.set "blue", "green", "red", "orange", "yellow", "indigo", "violet", "ultra-violet"
+    @status.should_equal "blue,green,red,orange,yellow,indigo,violet,ultra-violet"
+    @sm.state.id.should_be :on
+  end
+  
+  specify "To many parameters" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b, c, d, e, f, g, h, i| @status = [a, b, c, d, e, f, g, h, i].join(",") } )
+    begin
+      @sm.process_event(:set, "blue", "green", "red", "orange", "yellow", "indigo", "violet", "ultra-violet", "Yikes!")
+    rescue StateMachine::StateMachineException => e
+      e.message.should_equal "Too many arguments(9). (transition action from 'off' state invoked by 'set' event)"
+    end
+  end
+  
+  specify "calling process_event with parameters" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } )
+    @sm.process_event(:set, "blue", "green", "red")
+    @status.should_equal "blue,green,red"
+    @sm.state.id.should_be :on
+  end
+
+  specify "Insufficient params" do
+    @sm.add(:off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } )
+    begin
+      @sm.set "blue", "green"
+    rescue StateMachine::StateMachineException => e
+      e.message.should_equal "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)"
+    end
+  end
+  
+  specify "infinate args" do
+    @sm.add(:off, :set, :on, Proc.new { |*a| @status = a.join(",") } )
+    @sm.set(1, 2, 3)
+    @status.should_equal "1,2,3"
+    
+    @sm.state = :off
+    @sm.set(1, 2, 3, 4, 5, 6)
+    @status.should_equal "1,2,3,4,5,6"
+  end
+  
+  specify "Insufficient params when params are infinate" do
+    @sm.add(:off, :set, :on, Proc.new { |a, *b| @status = a.to_s + ":" + b.join(",") } )
+    @sm.set(1, 2, 3)
+    @status.should_equal "1:2,3"
+    
+    @sm.state = :off
+    begin
+      @sm.set
+    rescue StateMachine::StateMachineException => e
+      e.message.should_equal "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)"
+    end
+  end
+end

data/spec/sm_entry_exit_actions_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "State Machine Entry and Exit Actions" do
+
+  setup do
+    @log = []
+    @sm = StateMachine::StateMachine.new
+    @sm.add(:off, :toggle, :on, Proc.new { @log << "on" } )
+    @sm.add(:on, :toggle, :off, Proc.new { @log << "off" } )
+    @sm.run
+  end
+
+  specify "entry action" do
+    @sm[:on].on_entry Proc.new { @log << "entered_on" }
+    
+    @sm.toggle
+    
+    @log.join(",").should_equal "on,entered_on"
+  end
+  
+  specify "exit action" do
+    @sm[:off].on_exit Proc.new { @log << "exited_off" }
+    
+    @sm.toggle
+    
+    @log.join(",").should_equal "exited_off,on"
+  end
+
+  specify "exit and entry" do
+    @sm[:off].on_exit Proc.new { @log << "exited_off" }
+    @sm[:on].on_entry Proc.new { @log << "entered_on" }
+    
+    @sm.toggle
+    
+    @log.join(",").should_equal "exited_off,on,entered_on"
+  end
+  
+  specify "entry and exit actions may be parameterized" do
+      @sm[:off].on_exit Proc.new { |a| @log << "exited_off(#{a})" }
+      @sm[:on].on_entry Proc.new { |a, b| @log << "entered_on(#{a},#{b})" }
+      
+      @sm.toggle "one", "two"
+      
+      @log.join(",").should_equal "exited_off(one),on,entered_on(one,two)"
+  end
+
+  
+  
+end

data/spec/sm_odds_n_ends_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "State Machine Odds And Ends" do
+  include SwitchStateMachine
+
+  setup do
+    create_switch
+    @sm.run
+  end
+  
+  specify "method missing delegates to super in case of no event" do
+    lambda { @sm.blah }.should_raise NoMethodError
+  end
+  
+  specify "set state with string" do
+    @sm.state.id.should_be :off
+    @sm.state = "on"
+    @sm.state.id.should_be :on
+  end
+  
+  specify "set state with symbol" do
+    @sm.state.id.should_be :off
+    @sm.state = :on
+    @sm.state.id.should_be :on
+  end
+
+end

data/spec/sm_simple_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "simple cases:" do
+  setup do
+    @sm = StateMachine::StateMachine.new
+    @count = 0
+    @proc = Proc.new {@count = @count + 1}
+  end
+  
+  specify "one transition has states" do
+    @sm.add(:on, :flip, :off, @proc)
+    
+    @sm.states.length.should_be 2
+    @sm[:on].should_not_be nil
+    @sm[:off].should_not_be nil
+  end
+    
+  specify "one trasition create connects states with transition" do
+    @sm.add(:on, :flip, :off, @proc)
+    origin = @sm[:on]
+    destination = @sm[:off]
+    
+    origin.transitions.length.should_be 1
+    destination.transitions.length.should_be 0
+    transition = origin[:flip]
+    check_transition(transition, :on, :off, :flip, @proc)
+  end
+  
+  specify "end state" do
+    @sm.add(:start, :blah, nil, @proc)
+    
+    @sm.run
+    @sm.running.should.be true
+    @sm.process_event(:blah)
+    @sm.state.should.be nil
+    @sm.running.should.be false;
+  end
+
+  specify "reset" do
+    @sm.add(:start, :blah, nil, @proc)
+    @sm.run
+    @sm.process_event(:blah)
+    
+    @sm.reset
+    
+    @sm.state.should.be @sm[:start]
+    @sm.running.should.be true
+  end
+  
+  specify "exception when state machine is not running" do
+    @sm.add(:on, :flip, :off)
+    
+    begin
+      @sm.process_event(:flip)
+    rescue StateMachine::StateMachineException => e
+      e.message.should_equal "The state machine isn't in any state.  Did you forget to call run?"
+    end
+  end
+
+  specify "no proc in transition" do
+    @sm.add(:on, :flip, :off)
+    @sm.run
+    
+    @sm.flip
+  end
+
+  
+  
+end

data/spec/sm_super_state_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "Turn Stile" do
+  include TurnstileStateMachine
+  
+  setup do
+    create_turnstile
+    
+    @out_out_order = false
+    @sm.add(:operative, :maintain, :maintenance, Proc.new { @out_of_order = true } )
+    @sm.add(:maintenance, :operate, :operative, Proc.new { @out_of_order = false } )
+    @sm[:operative].add_substates(:locked, :unlocked)
+    
+    @sm.run
+  end
+
+  specify "substates respond to superstate transitions" do
+    @sm.process_event(:maintain)
+    @sm.state.id.should_be :maintenance
+    @locked.should_be true
+    @out_of_order.should_be true
+  end
+
+  specify "after transitions, substates respond to superstate transitions" do
+    @sm.coin
+    @sm.maintain
+    @sm.state.id.should_be :maintenance
+    @locked.should_be false
+    @out_of_order.should_be true
+  end
+  
+  specify "transitions back to superstate go to history state" do
+    @sm[:operative].use_history
+    @sm.maintain
+    @sm.operate
+    @sm.state.id.should_be :locked
+    @out_of_order.should_be false
+    
+    @sm.coin
+    @sm.maintain
+    @sm.operate
+    @sm.state.id.should_be :unlocked
+  end
+  
+  specify "missing substates are added" do
+    @sm[:operative].add_substates(:blah)
+    @sm[:blah].should_not_be nil
+    @sm[:blah].superstate.id.should_be :operative
+  end
+
+  specify "recursive superstates not allowed" do
+    begin
+      @sm[:operative].add_substates(:operative)
+      self.should_fail_with_message("exception expected")
+    rescue StateMachine::StateMachineException => e
+      e.message.should_equal "Cyclic substates not allowed. (operative)"
+    end
+  end
+
+  specify "recursive superstates (2 levels) not allowed" do
+    begin
+      @sm[:operative].add_substates(:blah)
+      @sm[:blah].add_substates(:operative)
+      self.should_fail_with_message("exception expected")
+    rescue StateMachine::StateMachineException => e
+      e.message.should_equal "Cyclic substates not allowed. (blah)"
+    end
+  end
+  
+  specify "exception when add_substates called without args" do
+    begin
+      @sm[:locked].add_substates()
+      self.should_fail_with_message("exception expected")
+    rescue StateMachine::StateMachineException => e
+      e.message.should_equal "At least one parameter is required for add_substates."
+    end
+  end
+  
+  
+end

data/spec/sm_turnstile_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "Turn Stile" do
+  include TurnstileStateMachine
+  
+  setup do
+    create_turnstile
+    @sm.run
+  end
+  
+  specify "connections" do
+    @sm.states.length.should_be 2
+    locked_state = @sm[:locked]
+    unlocked_state = @sm[:unlocked]
+    
+    locked_state.transitions.length.should_be 2
+    unlocked_state.transitions.length.should_be 2
+    
+    check_transition(locked_state[:coin], :locked, :unlocked, :coin, @unlock)
+    check_transition(locked_state[:pass], :locked, :locked, :pass, @alarm)
+    check_transition(unlocked_state[:pass], :unlocked, :locked, :pass, @lock)
+    check_transition(unlocked_state[:coin], :unlocked, :locked, :coin, @thankyou)
+  end
+  
+  specify "start state" do
+    @sm.run
+    @sm.start_state.should.be @sm[:locked]
+    @sm.state.should.be @sm[:locked]
+  end
+  
+  specify "bad event" do
+    begin
+      @sm.process_event(:blah)
+      self.should.fail_with_message("Exception expected")
+    rescue Exception => e
+      e.class.should.be StateMachine::MissingTransitionException
+      e.to_s.should_equal "'locked' state does not respond to the 'blah' event."
+    end
+  end
+  
+  specify "locked state with a coin" do
+    @sm.process_event(:coin)
+    
+    @sm.state.should.be @sm[:unlocked]
+    @locked.should.be false
+  end
+  
+  specify "locked state with pass event" do
+    @sm.process_event(:pass)
+    
+    @sm.state.should.be @sm[:locked]
+    @locked.should.be true
+    @alarm.should.be true
+  end
+
+  specify "unlocked state with coin" do
+    @sm.process_event(:coin)
+    @sm.process_event(:coin)
+    
+    @sm.state.should.be @sm[:locked]
+    @thankyou_status.should.be true
+  end
+
+  specify "unlocked state with pass event" do
+    @sm.process_event(:coin)
+    @sm.process_event(:pass)
+    
+    @sm.state.should.be @sm[:locked]
+    @locked.should.be true
+  end
+
+  specify "events invoked via method_missing" do
+    @sm.coin
+    @sm.state.should.be @sm[:unlocked]
+    @sm.pass
+    @sm.state.should.be @sm[:locked]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../lib/state_machine'
+
+def check_transition(transition, origin_id, destination_id, event, action)
+  transition.should_not_be nil
+  transition.event.should_be event
+  transition.action.should_be action
+  transition.origin.id.should_be origin_id
+  transition.destination.id.should_be destination_id
+end
+
+module SwitchStateMachine
+  
+  def create_switch
+    @status = "off"
+    @sm = StateMachine::StateMachine.new
+    @sm.add(:off, :toggle, :on, Proc.new { @status = "on" } )
+    @sm.add(:on, :toggle, :off, Proc.new { @status = "off" } )
+  end
+  
+end
+
+module TurnstileStateMachine
+  
+  def create_turnstile
+    @locked = true
+    @alarm_status = false
+    @thankyou_status = false
+    @lock = Proc.new { @locked = true }
+    @unlock = Proc.new { @locked = false }
+    @alarm = Proc.new { @alarm_status = true }
+    @thankyou = Proc.new { @thankyou_status = true }
+  
+    @sm = StateMachine::StateMachine.new
+    @sm.add(:locked, :coin, :unlocked, @unlock)
+    @sm.add(:unlocked, :pass, :locked, @lock)
+    @sm.add(:locked, :pass, :locked, @alarm)
+    @sm.add(:unlocked, :coin, :locked, @thankyou)
+  end
+  
+end

data/spec/transition_spec.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/../lib/state_machine'
+
+context "Transition Calculating Exits and Entries" do
+
+  setup do
+    @a = StateMachine::State.new("a", nil)
+    @b = StateMachine::State.new("b", nil)
+    @c = StateMachine::State.new("c", nil)
+    @d = StateMachine::State.new("d", nil)
+    @e = StateMachine::State.new("e", nil)
+  end
+  
+  specify "to nil" do
+    transition = StateMachine::Transition.new(@a, nil, nil, nil)
+    exits, entries = transition.exits_and_entries(@a)
+    exits.to_s.should_equal [@a].to_s
+    entries.to_s.should_equal [].to_s
+    entries.length.should_be 0
+  end
+  
+  specify "to itself" do
+    transition = StateMachine::Transition.new(@a, @a, nil, nil)
+    exits, entries = transition.exits_and_entries(@a)
+    exits.to_s.should_equal [@a].to_s
+    entries.to_s.should_equal [@a].to_s
+  end
+
+  specify "to friend" do
+    transition = StateMachine::Transition.new(@a, @b, nil, nil)
+    exits, entries = transition.exits_and_entries(@a)
+    exits.to_s.should_equal [@a].to_s
+    entries.to_s.should_equal [@b].to_s
+  end
+
+  specify "to parent" do
+    @a.superstate = @b
+    transition = StateMachine::Transition.new(@a, @b, nil, nil)
+    exits, entries = transition.exits_and_entries(@a)
+    exits.to_s.should_equal [@a, @b].to_s
+    entries.to_s.should_equal [@b].to_s
+  end
+
+  specify "to uncle" do
+    @a.superstate = @b
+    transition = StateMachine::Transition.new(@a, @c, nil, nil)
+    exits, entries = transition.exits_and_entries(@a)
+    exits.to_s.should_equal [@a, @b].to_s
+    entries.to_s.should_equal [@c].to_s
+  end
+
+  specify "to cousin" do
+    @a.superstate = @b
+    @c.superstate = @d
+    transition = StateMachine::Transition.new(@a, @c, nil, nil)
+    exits, entries = transition.exits_and_entries(@a)
+    exits.to_s.should_equal [@a, @b].to_s
+    entries.to_s.should_equal [@d, @c].to_s
+  end
+  
+  specify "to nephew" do
+    @a.superstate = @b
+    transition = StateMachine::Transition.new(@c, @a, nil, nil)
+    exits, entries = transition.exits_and_entries(@c)
+    exits.to_s.should_equal [@c].to_s
+    entries.to_s.should_equal [@b,@a].to_s
+  end
+
+  specify "to sister" do
+    @a.superstate = @c
+    @b.superstate = @c
+    transition = StateMachine::Transition.new(@a, @b, nil, nil)
+    exits, entries = transition.exits_and_entries(@a)
+    exits.to_s.should_equal [@a].to_s
+    entries.to_s.should_equal [@b].to_s
+  end
+  
+  specify "to second cousin" do
+    @a.superstate = @b
+    @b.superstate = @c
+    @d.superstate = @e
+    @e.superstate = @c
+    transition = StateMachine::Transition.new(@a, @d, nil, nil)
+    exits, entries = transition.exits_and_entries(@a)
+    exits.to_s.should_equal [@a, @b].to_s
+    entries.to_s.should_equal [@e, @d].to_s
+  end
+
+  specify "to grandparent" do
+    @a.superstate = @b
+    @b.superstate = @c
+    transition = StateMachine::Transition.new(@a, @c, nil, nil)
+    exits, entries = transition.exits_and_entries(@a)
+    exits.to_s.should_equal [@a, @b, @c].to_s
+    entries.to_s.should_equal [@c].to_s
+  end
+  
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: statemachine
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+date: 2006-10-25 00:00:00 -05:00
+summary: RSpec-0.6.4 - BDD for Ruby http://rspec.rubyforge.org/
+require_paths: 
+- lib
+email: statemachine-devel@rubyforge.org
+homepage: http://statemachine.rubyforge.org
+rubyforge_project: statemachine
+description: StateMachine is a ruby library for building Finite State Machines (FSM), also known as Finite State Automata (FSA).
+autorequire: statemachine
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- - Micah Martin
+files: 
+- CHANGES
+- Rakefile
+- lib/proc_calling.rb
+- lib/state.rb
+- lib/state_machine.rb
+- lib/statemachine.rb
+- lib/super_state.rb
+- lib/transition.rb
+- spec/sm_action_parameterization_spec.rb
+- spec/sm_entry_exit_actions_spec.rb
+- spec/sm_odds_n_ends_spec.rb
+- spec/sm_simple_spec.rb
+- spec/sm_super_state_spec.rb
+- spec/sm_turnstile_spec.rb
+- spec/spec_helper.rb
+- spec/transition_spec.rb
+test_files: 
+- spec/sm_action_parameterization_spec.rb
+- spec/sm_entry_exit_actions_spec.rb
+- spec/sm_odds_n_ends_spec.rb
+- spec/sm_simple_spec.rb
+- spec/sm_super_state_spec.rb
+- spec/sm_turnstile_spec.rb
+- spec/transition_spec.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+