statemachine 0.1.0 → 0.2.0

data/CHANGES

@@ -1,4 +1,14 @@
-= StateMachine Changelog
+= Statemachine Changelog
+
+
+== Version 0.2.0
+
+Separation of logic from behavior.
+* Prefered builder syntax implemented
+* statemachine have a context which defines all the behavior
+* startstate can be set at any time in the builder
+* states can be declared without blocks
+* context can be set in builder
 
 == Version 0.1.0
 

data/Rakefile

@@ -15,8 +15,8 @@ load File.dirname(__FILE__) + '/tasks/failing_examples_with_html.rake'
 load File.dirname(__FILE__) + '/tasks/verify_rcov.rake'"
 
 PKG_NAME = "statemachine"
-PKG_VERSION   = StateMachine::VERSION::STRING
-PKG_TAG = StateMachine::VERSION::TAG
+PKG_VERSION   = Statemachine::VERSION::STRING
+PKG_TAG = Statemachine::VERSION::TAG
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 PKG_FILES = FileList[
   '[A-Z]*',
@@ -58,9 +58,9 @@ end
 spec = Gem::Specification.new do |s|
   s.name = PKG_NAME
   s.version = PKG_VERSION
-  s.summary = StateMachine::VERSION::DESCRIPTION
+  s.summary = Statemachine::VERSION::DESCRIPTION
   s.description = <<-EOF
-    StateMachine is a ruby library for building Finite State Machines (FSM), also known as Finite State Automata (FSA).
+    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

data/TODO

@@ -1,4 +1,3 @@
-Allow setting of start state at beginning
-Remove proc actions in favor of method names.  Statemachine will have a context in which methods will run.
+
 Implement default history
 Implement superstate end state with automatic transition

data/lib/statemachine/action_invokation.rb

@@ -0,0 +1,64 @@
+module Statemachine
+
+  module ActionInvokation
+    
+    def invoke_action(action, args, message)
+      if action.is_a? Symbol
+        invoke_method(action, args, message)
+      elsif action.is_a? Proc
+        invoke_proc(action, args, message)
+      else
+        invoke_string(action)
+      end
+    end
+    
+    private
+    
+    def invoke_method(symbol, args, message)
+      method = @context.method(symbol)
+      raise StatemachineException.new("No method '#{symbol}' for context. " + message) if not method
+      
+      parameters = params_for_block(method, args, message)
+      method.call(*parameters)
+    end
+      
+    def invoke_proc(proc, args, message)
+      parameters = params_for_block(proc, args, message)
+      @context.instance_exec(*parameters, &proc)
+    end
+    
+    def invoke_string(expression)
+      @context.instance_eval(expression)
+    end
+    
+    def params_for_block(block, args, message)
+      arity = block.arity
+      required_params = arity < 0 ? arity.abs - 1 : arity
+      
+      raise StatemachineException.new("Insufficient parameters. (#{message})") if required_params > args.length
+      
+      return arity < 0 ? args : args[0...arity]
+    end
+    
+  end
+
+end
+
+class Object
+  
+  module InstanceExecHelper; end
+  
+  include InstanceExecHelper
+  
+  def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
+    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+    InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
+    end
+    ret
+  end
+  
+end

data/lib/statemachine/builder.rb

@@ -1,8 +1,8 @@
-module StateMachine
+module Statemachine
   
-  def self.build(statemachine = nil)
+  def self.build(statemachine = nil, &block)
     builder = statemachine ? StatemachineBuilder.new(statemachine) : StatemachineBuilder.new
-    yield builder
+    builder.instance_eval(&block)
     builder.statemachine.reset
     return builder.statemachine
   end
@@ -25,7 +25,7 @@ module StateMachine
         state = State.new(state_id, context, @statemachine)
         @statemachine.add_state(state)
       end
-      context.start_state = state if context.start_state == nil
+      context.startstate_id = state_id if context.startstate_id == nil
       return state
     end
   end
@@ -37,11 +37,11 @@ module StateMachine
       @subject.add(Transition.new(@subject.id, destination_id, event, action))
     end
     
-    def on_entry(&entry_action)
+    def on_entry(entry_action)
       @subject.entry_action = entry_action
     end
     
-    def on_exit(&exit_action)
+    def on_exit(exit_action)
       @subject.exit_action = exit_action
     end
   end
@@ -49,14 +49,14 @@ module StateMachine
   module SuperstateBuilding
     attr_reader :subject
     
-    def state(id)
+    def state(id, &block)
       builder = StateBuilder.new(id, @subject, @statemachine)
-      yield builder
+      builder.instance_eval(&block) if block
     end
 
-    def superstate(id)
+    def superstate(id, &block)
       builder = SuperstateBuilder.new(id, @subject, @statemachine)
-      yield builder
+      builder.instance_eval(&block)
     end
 
     def trans(origin_id, event, destination_id, action = nil)
@@ -64,16 +64,15 @@ module StateMachine
       origin.add(Transition.new(origin_id, destination_id, event, action))
     end
     
-    def start_state(start_state_id)
-      @subject.start_state = @statemachine.get_state(start_state_id)
-      raise "Start state #{start_state_id} not found" if not @subject.start_state
+    def startstate(startstate_id)
+      @subject.startstate_id = startstate_id
     end
     
-    def on_entry_of(id, &action)
+    def on_entry_of(id, action)
       @statemachine.get_state(id).entry_action = action
     end
     
-    def on_exit_of(id, &action)
+    def on_exit_of(id, action)
       @statemachine.get_state(id).exit_action = action
     end
   end
@@ -94,7 +93,7 @@ module StateMachine
     def initialize(id, superstate, statemachine)
       super statemachine
       @subject = Superstate.new(id, superstate, statemachine)
-      superstate.start_state = @subject if superstate.start_state == nil
+      superstate.startstate_id = id if superstate.startstate_id == nil
       statemachine.add_state(@subject)
     end
   end
@@ -102,10 +101,14 @@ module StateMachine
   class StatemachineBuilder < Builder
     include SuperstateBuilding
     
-    def initialize(statemachine = StateMachine.new)
+    def initialize(statemachine = Statemachine.new)
       super statemachine
       @subject = @statemachine.root
     end
+    
+    def context(a_context)
+      @statemachine.context = a_context
+    end
   end
   
 end

data/lib/statemachine/state.rb

@@ -1,11 +1,7 @@
-require 'statemachine/proc_calling'
-
-module StateMachine
+module Statemachine
 
   class State
     
-    include ProcCalling
-    
     attr_reader :id, :statemachine, :superstate
     attr_accessor :entry_action, :exit_action
 
@@ -26,13 +22,13 @@ module StateMachine
     
     def exit(args)
       @statemachine.trace("\texiting #{self}")
-      call_proc(@exit_action, args, "exit action for #{self}") if @exit_action
+      @statemachine.invoke_action(@exit_action, args, "exit action for #{self}") if @exit_action
       @superstate.substate_exiting(self) if @superstate
     end
 
     def enter(args)
       @statemachine.trace("\tentering #{self}")
-      call_proc(@entry_action, args, "entry action for #{self}") if @entry_action
+      @statemachine.invoke_action(@entry_action, args, "entry action for #{self}") if @entry_action
     end
     
     def activate

data/lib/statemachine/state_machine.rb

@@ -1,12 +1,13 @@
-module StateMachine
+module Statemachine
   
-  class StateMachineException < Exception
+  class StatemachineException < Exception
   end
   
-  class StateMachine
-    include ProcCalling
+  class Statemachine
+    
+    include ActionInvokation
   
-    attr_accessor :tracer
+    attr_accessor :tracer, :context
     attr_reader :root
   
     def initialize(root = Superstate.new(:root, nil, self))
@@ -14,16 +15,16 @@ module StateMachine
       @states = {}
     end
     
-    def start_state
-      return @root.start_state.id
+    def startstate
+      return @root.startstate_id
     end
   
     def reset
-      @state = @root.start_state
+      @state = get_state(@root.startstate_id)
       while @state and not @state.is_concrete?
-        @state = @state.start_state
+        @state = get_state(@state.startstate_id)
       end
-      raise StateMachineException.new("The state machine doesn't know where to start. Try setting the start_state.") if @state == nil
+      raise StatemachineException.new("The state machine doesn't know where to start. Try setting the startstate.") if @state == nil
     end
     
     def state
@@ -48,10 +49,10 @@ module StateMachine
         if transition
           transition.invoke(@state, self, args)
         else
-          raise StateMachineException.new("#{@state} does not respond to the '#{event}' event.")
+          raise StatemachineException.new("#{@state} does not respond to the '#{event}' event.")
         end
       else
-        raise StateMachineException.new("The state machine isn't in any state while processing the '#{event}' event.")
+        raise StatemachineException.new("The state machine isn't in any state while processing the '#{event}' event.")
       end
     end
     
@@ -65,8 +66,8 @@ module StateMachine
       elsif(is_history_state_id?(id))
         superstate_id = base_id(id)
         superstate = @states[superstate_id]
-        raise StateMachineException.new("No history exists for #{superstate} since it is not a super state.") if superstate.is_concrete?
-        raise StateMachineException.new("#{superstate} doesn't have any history yet.") if not superstate.history
+        raise StatemachineException.new("No history exists for #{superstate} since it is not a super state.") if superstate.is_concrete?
+        raise StatemachineException.new("#{superstate} doesn't have any history yet.") if not superstate.history
         return superstate.history
       else
         state = State.new(id, @root, self)

data/lib/statemachine/super_state.rb

@@ -1,13 +1,13 @@
-module StateMachine
+module Statemachine
 
   class Superstate < State
   
-    attr_writer :start_state
+    attr_accessor :startstate_id
     attr_reader :history
   
     def initialize(id, superstate, statemachine)
       super(id, superstate, statemachine)
-      @start_state = nil
+      @startstate = nil
       @history = nil
     end
     
@@ -15,10 +15,6 @@ module StateMachine
       return false
     end
     
-    def start_state
-      return @start_state
-    end
-    
     def substate_exiting(substate)
       @history = substate
     end

data/lib/statemachine/transition.rb

@@ -1,11 +1,7 @@
-require 'statemachine/proc_calling'
-
-module StateMachine
+module Statemachine
 
   class Transition
     
-    include ProcCalling
-    
     attr_reader :origin_id, :event, :action
     attr_accessor :destination_id
 
@@ -21,11 +17,11 @@ module StateMachine
       exits, entries = exits_and_entries(origin, destination)
       exits.each { |exited_state| exited_state.exit(args) }
       
-      call_proc(@action, args, "transition action from #{origin} invoked by '#{@event}' event") if @action
+      origin.statemachine.invoke_action(@action, args, "transition action from #{origin} invoked by '#{@event}' event") if @action
       
       terminal_state = destination
       while terminal_state and not terminal_state.is_concrete?
-        terminal_state = terminal_state.start_state
+        terminal_state = statemachine.get_state(terminal_state.startstate_id)
         entries << terminal_state
       end
       terminal_state.activate if terminal_state

data/lib/statemachine/version.rb

@@ -1,17 +1,17 @@
-module StateMachine
+module Statemachine
   module VERSION
     unless defined? MAJOR
       MAJOR  = 0
-      MINOR  = 1
+      MINOR  = 2
       TINY   = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG    = "REL_" + [MAJOR, MINOR, TINY].join('_')
 
-      NAME   = "StateMachine"
+      NAME   = "Statemachine"
       URL    = "http://statemachine.rubyforge.org/"  
     
-      DESCRIPTION = "#{NAME}-#{STRING} - State Machine Library for Ruby\n#{URL}"
+      DESCRIPTION = "#{NAME}-#{STRING} - Statemachine Library for Ruby\n#{URL}"
     end
   end
 end

data/lib/statemachine.rb

@@ -1,7 +1,7 @@
+require 'statemachine/action_invokation'
 require 'statemachine/state'
 require 'statemachine/super_state'
 require 'statemachine/transition'
-require 'statemachine/proc_calling'
 require 'statemachine/state_machine'
 require 'statemachine/builder'
 require 'statemachine/version'

data/spec/action_invokation_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class Noodle
+  
+  attr_accessor :shape, :cooked
+  
+  def initialize
+    @shape = "farfalla"
+    @cooked = false
+  end
+  
+  def cook
+    @cooked = true
+  end
+  
+  def transform(shape)
+    @shape = shape
+  end
+  
+end
+
+context "Action Invokation" do
+
+  setup do
+    @noodle = Noodle.new
+  end
+  
+  specify "Proc actions" do
+    sm = Statemachine.build do |smb|
+      smb.trans :cold, :fire, :hot, Proc.new { @cooked = true } 
+    end
+    
+    sm.context = @noodle
+    sm.fire
+    
+    @noodle.cooked.should_be true
+  end
+  
+  specify "Symbol actions" do
+    sm = Statemachine.build do |smb|
+      smb.trans :cold, :fire, :hot, :cook
+      smb.trans :hot, :mold, :changed, :transform
+    end
+  
+    sm.context = @noodle
+    sm.fire
+  
+    @noodle.cooked.should_be true
+    
+    sm.mold "capellini"
+    
+    @noodle.shape.should_eql "capellini"
+  end
+
+  specify "String actions" do
+    sm = Statemachine.build do |smb|
+      smb.trans :cold, :fire, :hot, "@shape = 'fettucini'; @cooked = true"
+    end
+    sm.context = @noodle
+    
+    sm.fire
+    @noodle.shape.should_eql "fettucini"
+    @noodle.cooked.should_be true
+  end
+
+  
+  
+end

data/spec/builder_spec.rb

@@ -19,34 +19,37 @@ context "Builder" do
   end
 
   specify "Building a the switch, relaxed" do
-    sm = StateMachine.build do |b|
-      b.trans :off, :toggle, :on, Proc.new { @log << "toggle on" }
-      b.trans :on, :toggle, :off, Proc.new { @log << "toggle off" }
+    sm = Statemachine.build do
+      trans :off, :toggle, :on, Proc.new { @log << "toggle on" }
+      trans :on, :toggle, :off, Proc.new { @log << "toggle off" }
     end
+    sm.context = self
     
     check_switch sm
   end
 
   specify "Building a the switch, strict" do
-    sm = StateMachine.build do |b|
-      b.state(:off) { |s| s.event :toggle, :on, Proc.new { @log << "toggle on" } }
-      b.state(:on) { |s| s.event :toggle, :off, Proc.new { @log << "toggle off" } }
+    sm = Statemachine.build do
+      state(:off) { |s| s.event :toggle, :on, Proc.new { @log << "toggle on" } }
+      state(:on) { |s| s.event :toggle, :off, Proc.new { @log << "toggle off" } }
     end
+    sm.context = self
 
     check_switch sm
   end
 
   specify "Adding a superstate to the switch" do
-    sm = StateMachine.build do |b|
-      b.superstate :operation do |o|
-        o.event :admin, :testing, lambda { @log << "testing" }
-        o.trans :off, :toggle, :on, lambda { @log << "toggle on" }
-        o.trans :on, :toggle, :off, lambda { @log << "toggle off" }
-        o.start_state :on
+    sm = Statemachine.build do
+      superstate :operation do
+        event :admin, :testing, lambda { @log << "testing" }
+        trans :off, :toggle, :on, lambda { @log << "toggle on" }
+        trans :on, :toggle, :off, lambda { @log << "toggle off" }
+        startstate :on
       end
-      b.trans :testing, :resume, :operation, lambda { @log << "resuming" }
-      b.start_state :off
+      trans :testing, :resume, :operation, lambda { @log << "resuming" }
+      startstate :off
     end
+    sm.context = self
     
     sm.state.should_be :off
     sm.toggle
@@ -58,14 +61,15 @@ context "Builder" do
   end
   
   specify "entry exit actions" do
-    sm = StateMachine.build do |sm|
-      sm.state :off do |off|
-        off.on_entry { @log << "enter off" }
-        off.event :toggle, :on, lambda { @log << "toggle on" }
-        off.on_exit { @log << "exit off" }
+    sm = Statemachine.build do
+      state :off do
+        on_entry Proc.new { @log << "enter off" }
+        event :toggle, :on, lambda { @log << "toggle on" }
+        on_exit Proc.new { @log << "exit off" }
       end
-      sm.trans :on, :toggle, :off, lambda { @log << "toggle off" } 
+      trans :on, :toggle, :off, lambda { @log << "toggle off" } 
     end
+    sm.context = self
 
     sm.toggle
     sm.state.should_be :on
@@ -76,19 +80,20 @@ context "Builder" do
   end
   
   specify "History state" do
-    sm = StateMachine.build do |b|
-      b.superstate :operation do |o|
-        o.event :admin, :testing, lambda { @log << "testing" }
-        o.state :off do |off|
-          off.on_entry { @log << "enter off" }
-          off.event :toggle, :on, lambda { @log << "toggle on" }
+    sm = Statemachine.build do
+      superstate :operation do
+        event :admin, :testing, lambda { @log << "testing" }
+        state :off do |off|
+          on_entry Proc.new { @log << "enter off" }
+          event :toggle, :on, lambda { @log << "toggle on" }
         end
-        o.trans :on, :toggle, :off, lambda { @log << "toggle off" }
-        o.start_state :on
+        trans :on, :toggle, :off, lambda { @log << "toggle off" }
+        startstate :on
       end
-      b.trans :testing, :resume, :operation_H, lambda { @log << "resuming" }
-      b.start_state :off
+      trans :testing, :resume, :operation_H, lambda { @log << "resuming" }
+      startstate :off
     end
+    sm.context = self
     
     sm.admin
     sm.resume
@@ -98,12 +103,13 @@ context "Builder" do
   end
 
   specify "entry and exit action created from superstate builder" do
-    sm = StateMachine.build do |b|
-      b.trans :off, :toggle, :on, Proc.new { @log << "toggle on" }
-      b.on_entry_of(:off) { @log << "entering off" }
-      b.trans :on, :toggle, :off, Proc.new { @log << "toggle off" }
-      b.on_exit_of(:on) { @log << "exiting on" }
+    sm = Statemachine.build do
+      trans :off, :toggle, :on, Proc.new { @log << "toggle on" }
+      on_entry_of :off, Proc.new { @log << "entering off" }
+      trans :on, :toggle, :off, Proc.new { @log << "toggle off" }
+      on_exit_of :on, Proc.new { @log << "exiting on" }
     end
+    sm.context = self
     
     sm.toggle
     sm.toggle
@@ -115,17 +121,61 @@ context "Builder" do
   specify "superstate as startstate" do
     
     lambda do 
-      sm = StateMachine.build do |b|
-        b.superstate :mario_bros do |m|
-          m.trans :luigi, :bother, :mario
+      sm = Statemachine.build do
+        superstate :mario_bros do
+          trans :luigi, :bother, :mario
         end
       end
       
       sm.state.should_be :luigi
     end.should_not_raise(Exception)
   end
-
   
+  specify "setting the start state before any other states declared" do
+    
+    sm = Statemachine.build do
+      startstate :right
+      trans :left, :push, :middle
+      trans :middle, :push, :right
+      trans :right, :pull, :middle
+    end
+    
+    sm.state.should_be :right
+    sm.pull
+    sm.state.should_be :middle
+  end
+  
+  specify "setting start state which is in a super state" do
+    sm = Statemachine.build do
+      startstate :right
+      superstate :table do
+        event :tilt, :floor
+        trans :left, :push, :middle
+        trans :middle, :push, :right
+        trans :right, :pull, :middle
+      end
+      state :floor
+    end
+    
+    sm.state.should_be :right
+    sm.pull
+    sm.state.should_be :middle
+    sm.push
+    sm.state.should_be :right
+    sm.tilt
+    sm.state.should_be :floor
+  end
+  
+  specify "can set context" do
+    widget = Object.new
+    sm = Statemachine.build do
+      context widget
+    end
+    
+    sm.context.should_be widget
+  end
+
   
+
 end
 

data/spec/sm_action_parameterization_spec.rb

@@ -1,83 +1,83 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 context "State Machine Odds And Ends" do
-  include SwitchStateMachine
+  include SwitchStatemachine
 
   setup do
     create_switch
   end
   
   specify "action with one parameter" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |value| @status = value } }
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |value| @status = value } }
     @sm.set "blue"
     @status.should_eql "blue"
     @sm.state.should_be :on
   end
 
   specify "action with two parameters" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b| @status = [a, b].join(",") } }
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b| @status = [a, b].join(",") } }
     @sm.set "blue", "green"
     @status.should_eql "blue,green"
     @sm.state.should_be :on
   end
 
   specify "action with three parameters" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
     @sm.set "blue", "green", "red"
     @status.should_eql "blue,green,red"
     @sm.state.should_be :on
   end
 
   specify "action with four parameters" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d| @status = [a, b, c, d].join(",") } }
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d| @status = [a, b, c, d].join(",") } }
     @sm.set "blue", "green", "red", "orange"
     @status.should_eql "blue,green,red,orange"
     @sm.state.should_be :on
   end
 
   specify "action with five parameters" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e| @status = [a, b, c, d, e].join(",") } }
+    Statemachine.build(@sm) { |s| s.trans :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_eql "blue,green,red,orange,yellow"
     @sm.state.should_be :on
   end
   
   specify "action with six parameters" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e, f| @status = [a, b, c, d, e, f].join(",") } }
+    Statemachine.build(@sm) { |s| s.trans :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_eql "blue,green,red,orange,yellow,indigo"
     @sm.state.should_be :on
   end
 
   specify "action with seven parameters" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e, f, g| @status = [a, b, c, d, e, f, g].join(",") } }
+    Statemachine.build(@sm) { |s| s.trans :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_eql "blue,green,red,orange,yellow,indigo,violet"
     @sm.state.should_be :on
   end
 
   specify "action with eight parameters" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e, f, g, h| @status = [a, b, c, d, e, f, g, h].join(",") } }
+    Statemachine.build(@sm) { |s| s.trans :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_eql "blue,green,red,orange,yellow,indigo,violet,ultra-violet"
     @sm.state.should_be :on
   end
   
   specify "calling process_event with parameters" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
     @sm.process_event(:set, "blue", "green", "red")
     @status.should_eql "blue,green,red"
     @sm.state.should_be :on
   end
 
   specify "Insufficient params" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
-    lambda { @sm.set "blue", "green" }.should_raise(StateMachine::StateMachineException, 
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
+    lambda { @sm.set "blue", "green" }.should_raise(Statemachine::StatemachineException, 
       "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)")
   end
   
   specify "infinate args" do
-   StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |*a| @status = a.join(",") } }
+   Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |*a| @status = a.join(",") } }
     @sm.set(1, 2, 3)
     @status.should_eql "1,2,3"
     
@@ -87,13 +87,13 @@ context "State Machine Odds And Ends" do
   end
   
   specify "Insufficient params when params are infinate" do
-    StateMachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, *b| @status = a.to_s + ":" + b.join(",") } }
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, *b| @status = a.to_s + ":" + b.join(",") } }
     @sm.set(1, 2, 3)
     @status.should_eql "1:2,3"
     
     @sm.state = :off
    
-    lambda { @sm.set }.should_raise(StateMachine::StateMachineException, 
+    lambda { @sm.set }.should_raise(Statemachine::StatemachineException, 
       "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)")
   end
 end

data/spec/sm_entry_exit_actions_spec.rb

@@ -4,10 +4,11 @@ context "State Machine Entry and Exit Actions" do
 
   setup do
     @log = []
-    @sm = StateMachine.build do |s|
-      s.trans :off, :toggle, :on, Proc.new { @log << "on" }
-      s.trans :on, :toggle, :off, Proc.new { @log << "off" }
+    @sm = Statemachine.build do
+      trans :off, :toggle, :on, Proc.new { @log << "on" }
+      trans :on, :toggle, :off, Proc.new { @log << "off" }
     end
+    @sm.context = self
   end
 
   specify "entry action" do
@@ -54,20 +55,21 @@ context "State Machine Entry and Exit Actions" do
   end
 
   specify "current state is set prior to exit and entry actions even with super states" do
-    @sm = StateMachine::StateMachine.new
-    StateMachine.build(@sm) do |s|
-      s.superstate :off_super do |off_s|
-        off_s.on_exit {@log << @sm.state}
-        off_s.trans :off, :toggle, :on, Proc.new { @log << "on" }
-        off_s.event :toggle, :on, Proc.new { @log << "super_on" }
+    @sm = Statemachine::Statemachine.new
+    Statemachine.build(@sm) do
+      superstate :off_super do
+        on_exit Proc.new {@log << @sm.state}
+        trans :off, :toggle, :on, Proc.new { @log << "on" }
+        event :toggle, :on, Proc.new { @log << "super_on" }
       end
-      s.superstate :on_super do |on_s|
-        on_s.on_entry { @log << @sm.state }
-        on_s.trans :on, :toggle, :off, Proc.new { @log << "off" }
-        on_s.event :toggle, :off, Proc.new { @log << "super_off" }
+      superstate :on_super do
+        on_entry Proc.new { @log << @sm.state }
+        trans :on, :toggle, :off, Proc.new { @log << "off" }
+        event :toggle, :off, Proc.new { @log << "super_off" }
       end
-      s.start_state :off
+      startstate :off
     end
+    @sm.context = self
 
     @sm.toggle
     @log.join(",").should_eql "off,super_on,on"  

data/spec/sm_odds_n_ends_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 context "State Machine Odds And Ends" do
-  include SwitchStateMachine
+  include SwitchStatemachine
 
   setup do
     create_switch
@@ -33,7 +33,7 @@ end
 context "Special States" do
 
   setup do
-    @sm = StateMachine.build do |s|
+    @sm = Statemachine.build do |s|
       s.superstate :operate do |o|
         o.trans :on, :toggle, :off
         o.trans :off, :toggle, :on
@@ -42,7 +42,7 @@ context "Special States" do
       s.trans :middle, :fiddle, :operate_H
       s.trans :middle, :push, :stuck
       s.trans :middle, :dream, :on_H
-      s.start_state :middle
+      s.startstate :middle
     end
   end
   
@@ -54,13 +54,13 @@ context "Special States" do
   specify "no history allowed for concrete states" do
     lambda {
         @sm.dream
-      }.should_raise(StateMachine::StateMachineException, "No history exists for 'on' state since it is not a super state.")
+      }.should_raise(Statemachine::StatemachineException, "No history exists for 'on' state since it is not a super state.")
   end
 
   specify "error when trying to use history that doesn't exist yet" do
     lambda {
       @sm.fiddle
-      }.should_raise(StateMachine::StateMachineException, "'operate' superstate doesn't have any history yet.")
+      }.should_raise(Statemachine::StatemachineException, "'operate' superstate doesn't have any history yet.")
   end
 
 end

data/spec/sm_simple_spec.rb

@@ -2,13 +2,14 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 context "simple cases:" do
   setup do
-    @sm = StateMachine::StateMachine.new
+    @sm = Statemachine::Statemachine.new
+    @sm.context = self
     @count = 0
     @proc = Proc.new {@count = @count + 1}
   end
   
   specify "reset" do
-    StateMachine.build(@sm) { |s| s.trans :start, :blah, :end, @proc }
+    Statemachine.build(@sm) { |s| s.trans :start, :blah, :end, @proc }
     @sm.process_event(:blah)
     
     @sm.reset
@@ -17,7 +18,7 @@ context "simple cases:" do
   end
 
   specify "no proc in transition" do
-     StateMachine.build(@sm) { |s| s.trans :on, :flip, :off }
+     Statemachine.build(@sm) { |s| s.trans :on, :flip, :off }
     
     @sm.flip
   end

data/spec/sm_super_state_spec.rb

@@ -1,24 +1,25 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 context "Turn Stile" do
-  include TurnstileStateMachine
+  include TurnstileStatemachine
   
   setup do
     create_turnstile
     
     @out_out_order = false
     
-    @sm = StateMachine.build do |s|
-      s.superstate :operative do |o|
-        o.trans :locked, :coin, :unlocked, @unlock
-        o.trans :unlocked, :pass, :locked, @lock
-        o.trans :locked, :pass, :locked, @alarm
-        o.trans :unlocked, :coin, :locked, @thankyou
-        o.event :maintain, :maintenance, Proc.new { @out_of_order = true }
+    @sm = Statemachine.build do 
+      superstate :operative do
+        trans :locked, :coin, :unlocked, Proc.new { @locked = false }
+        trans :unlocked, :pass, :locked, Proc.new { @locked = true }
+        trans :locked, :pass, :locked, Proc.new { @alarm_status = true }
+        trans :unlocked, :coin, :locked, Proc.new { @thankyou_status = true }
+        event :maintain, :maintenance, Proc.new { @out_of_order = true }
       end
-      s.trans :maintenance, :operate, :operative, Proc.new { @out_of_order = false } 
-      s.start_state :locked
+      trans :maintenance, :operate, :operative, Proc.new { @out_of_order = false } 
+      startstate :locked
     end
+    @sm.context = self
   end
 
   specify "substates respond to superstate transitions" do

data/spec/sm_turnstile_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 context "Turn Stile" do
-  include TurnstileStateMachine
+  include TurnstileStatemachine
   
   setup do
     create_turnstile
@@ -22,7 +22,7 @@ context "Turn Stile" do
   
   specify "start state" do
     @sm.reset
-    @sm.start_state.should.be :locked
+    @sm.startstate.should.be :locked
     @sm.state.should.be :locked
   end
   
@@ -31,7 +31,7 @@ context "Turn Stile" do
       @sm.process_event(:blah)
       self.should.fail_with_message("Exception expected")
     rescue Exception => e
-      e.class.should.be StateMachine::StateMachineException
+      e.class.should.be Statemachine::StatemachineException
       e.to_s.should_eql "'locked' state does not respond to the 'blah' event."
     end
   end

data/spec/spec_helper.rb

@@ -6,40 +6,42 @@ require 'statemachine'
 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
+  transition.action.should_eql action
 end
 
-module SwitchStateMachine
+module SwitchStatemachine
   
   def create_switch
     @status = "off"
-    @sm = StateMachine.build do |s|
-      s.trans :off, :toggle, :on, Proc.new { @status = "on" } 
-      s.trans :on, :toggle, :off, Proc.new { @status = "off" }
+    @sm = Statemachine.build do
+      trans :off, :toggle, :on, Proc.new { @status = "on" } 
+      trans :on, :toggle, :off, Proc.new { @status = "off" }
     end
+    @sm.context = self
   end
   
 end
 
-module TurnstileStateMachine
+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 }
+    @lock = "@locked = true"
+    @unlock = "@locked = false"
+    @alarm = "@alarm_status = true"
+    @thankyou = "@thankyou_status = true"
   
-    @sm = StateMachine.build do |s|
-      s.trans :locked, :coin, :unlocked, @unlock
-      s.trans :unlocked, :pass, :locked, @lock
-      s.trans :locked, :pass, :locked, @alarm
-      s.trans :unlocked, :coin, :locked, @thankyou
+    @sm = Statemachine.build do
+      trans :locked, :coin, :unlocked, "@locked = false"
+      trans :unlocked, :pass, :locked, "@locked = true"
+      trans :locked, :pass, :locked, "@alarm_status = true"
+      trans :unlocked, :coin, :locked, "@thankyou_status = true"
     end
+    @sm.context = self
   end
   
 end

data/spec/transition_spec.rb

@@ -3,11 +3,11 @@ require File.dirname(__FILE__) + '/spec_helper'
 context "Transition Calculating Exits and Entries" do
 
   setup do
-    @transition = StateMachine::Transition.new(nil, nil, nil, nil)
+    @transition = Statemachine::Transition.new(nil, nil, nil, nil)
   end
   
   specify "to nil" do
-    @a = StateMachine::State.new("a", nil, nil)
+    @a = Statemachine::State.new("a", nil, nil)
     exits, entries = @transition.exits_and_entries(@a, nil)
     exits.to_s.should_eql [@a].to_s
     entries.to_s.should_eql [].to_s
@@ -15,90 +15,90 @@ context "Transition Calculating Exits and Entries" do
   end
   
   specify "to itself" do
-    @a = StateMachine::State.new("a", nil, nil)
+    @a = Statemachine::State.new("a", nil, nil)
     exits, entries = @transition.exits_and_entries(@a, @a)
     exits.to_s.should_eql [@a].to_s
     entries.to_s.should_eql [@a].to_s
   end
 
   specify "to friend" do
-    @a = StateMachine::State.new("a", nil, nil)
-    @b = StateMachine::State.new("b", nil, nil)
+    @a = Statemachine::State.new("a", nil, nil)
+    @b = Statemachine::State.new("b", nil, nil)
     exits, entries = @transition.exits_and_entries(@a, @b)
     exits.to_s.should_eql [@a].to_s
     entries.to_s.should_eql [@b].to_s
   end
 
   specify "to parent" do
-    @b = StateMachine::State.new("b", nil, nil)
-    @a = StateMachine::State.new("a", @b, nil)
+    @b = Statemachine::State.new("b", nil, nil)
+    @a = Statemachine::State.new("a", @b, nil)
     exits, entries = @transition.exits_and_entries(@a, @b)
     exits.to_s.should_eql [@a, @b].to_s
     entries.to_s.should_eql [@b].to_s
   end
 
   specify "to uncle" do
-    @b = StateMachine::State.new("b", nil, nil)
-    @a = StateMachine::State.new("a", @b, nil)
-    @c = StateMachine::State.new("c", nil, nil)
+    @b = Statemachine::State.new("b", nil, nil)
+    @a = Statemachine::State.new("a", @b, nil)
+    @c = Statemachine::State.new("c", nil, nil)
     exits, entries = @transition.exits_and_entries(@a, @c)
     exits.to_s.should_eql [@a, @b].to_s
     entries.to_s.should_eql [@c].to_s
   end
 
   specify "to cousin" do
-    @b = StateMachine::State.new("b", nil, nil)
-    @d = StateMachine::State.new("d", nil, nil)
-    @a = StateMachine::State.new("a", @b, nil)
-    @c = StateMachine::State.new("c", @d, nil)
+    @b = Statemachine::State.new("b", nil, nil)
+    @d = Statemachine::State.new("d", nil, nil)
+    @a = Statemachine::State.new("a", @b, nil)
+    @c = Statemachine::State.new("c", @d, nil)
     exits, entries = @transition.exits_and_entries(@a, @c)
     exits.to_s.should_eql [@a, @b].to_s
     entries.to_s.should_eql [@d, @c].to_s
   end
   
   specify "to nephew" do
-    @b = StateMachine::State.new("b", nil, nil)
-    @c = StateMachine::State.new("c", nil, nil)
-    @a = StateMachine::State.new("a", @b, nil)
+    @b = Statemachine::State.new("b", nil, nil)
+    @c = Statemachine::State.new("c", nil, nil)
+    @a = Statemachine::State.new("a", @b, nil)
     exits, entries = @transition.exits_and_entries(@c, @a)
     exits.to_s.should_eql [@c].to_s
     entries.to_s.should_eql [@b,@a].to_s
   end
 
   specify "to sister" do
-    @c = StateMachine::State.new("c", nil, nil)
-    @a = StateMachine::State.new("a", @c, nil)
-    @b = StateMachine::State.new("b", @c, nil)
+    @c = Statemachine::State.new("c", nil, nil)
+    @a = Statemachine::State.new("a", @c, nil)
+    @b = Statemachine::State.new("b", @c, nil)
     exits, entries = @transition.exits_and_entries(@a, @b)
     exits.to_s.should_eql [@a].to_s
     entries.to_s.should_eql [@b].to_s
   end
   
   specify "to second cousin" do
-    @c = StateMachine::State.new("c", nil, nil)
-    @b = StateMachine::State.new("b", @c, nil)
-    @a = StateMachine::State.new("a", @b, nil)
-    @e = StateMachine::State.new("e", @c, nil)
-    @d = StateMachine::State.new("d", @e, nil)
+    @c = Statemachine::State.new("c", nil, nil)
+    @b = Statemachine::State.new("b", @c, nil)
+    @a = Statemachine::State.new("a", @b, nil)
+    @e = Statemachine::State.new("e", @c, nil)
+    @d = Statemachine::State.new("d", @e, nil)
     exits, entries = @transition.exits_and_entries(@a, @d)
     exits.to_s.should_eql [@a, @b].to_s
     entries.to_s.should_eql [@e, @d].to_s
   end
 
   specify "to grandparent" do
-    @c = StateMachine::State.new("c", nil, nil)
-    @b = StateMachine::State.new("b", @c, nil)
-    @a = StateMachine::State.new("a", @b, nil)
+    @c = Statemachine::State.new("c", nil, nil)
+    @b = Statemachine::State.new("b", @c, nil)
+    @a = Statemachine::State.new("a", @b, nil)
     exits, entries = @transition.exits_and_entries(@a, @c)
     exits.to_s.should_eql [@a, @b, @c].to_s
     entries.to_s.should_eql [@c].to_s
   end
 
   specify "to parent's grandchild" do
-    @c = StateMachine::State.new("c", nil, nil)
-    @b = StateMachine::State.new("b", @c, nil)
-    @a = StateMachine::State.new("a", @b, nil) 
-    @d = StateMachine::State.new("d", @c, nil)
+    @c = Statemachine::State.new("c", nil, nil)
+    @b = Statemachine::State.new("b", @c, nil)
+    @a = Statemachine::State.new("a", @b, nil) 
+    @d = Statemachine::State.new("d", @c, nil)
     exits, entries = @transition.exits_and_entries(@d, @a)
     exits.to_s.should_eql [@d].to_s
     entries.to_s.should_eql [@b, @a].to_s

metadata

@@ -3,15 +3,15 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: statemachine
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2006-11-12 00:00:00 -06:00
-summary: StateMachine-0.1.0 - State Machine Library for Ruby http://statemachine.rubyforge.org/
+  version: 0.2.0
+date: 2006-11-14 00:00:00 -06:00
+summary: Statemachine-0.2.0 - Statemachine Library for Ruby http://statemachine.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).
+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
@@ -33,13 +33,14 @@ files:
 - Rakefile
 - TODO
 - lib/statemachine.rb
+- lib/statemachine/action_invokation.rb
 - lib/statemachine/builder.rb
-- lib/statemachine/proc_calling.rb
 - lib/statemachine/state.rb
 - lib/statemachine/state_machine.rb
 - lib/statemachine/super_state.rb
 - lib/statemachine/transition.rb
 - lib/statemachine/version.rb
+- spec/action_invokation_spec.rb
 - spec/builder_spec.rb
 - spec/sm_action_parameterization_spec.rb
 - spec/sm_entry_exit_actions_spec.rb
@@ -50,6 +51,7 @@ files:
 - spec/spec_helper.rb
 - spec/transition_spec.rb
 test_files: 
+- spec/action_invokation_spec.rb
 - spec/builder_spec.rb
 - spec/sm_action_parameterization_spec.rb
 - spec/sm_entry_exit_actions_spec.rb

data/lib/statemachine/proc_calling.rb

@@ -1,19 +0,0 @@
-module StateMachine
-
-  module ProcCalling
-    
-    private
-      
-    def call_proc(proc, args, message)
-      arity = proc.arity
-      required_params = arity < 0 ? arity.abs - 1 : arity
-      
-      raise StateMachineException.new("Insufficient parameters. (#{message})") if required_params > args.length
-      
-      parameters = arity < 0 ? args : args[0...arity]
-      proc.call(*parameters)
-    end
-    
-  end
-
-end