statemachine 0.0.3 → 0.1.0

data/CHANGES

@@ -1,5 +1,20 @@
 = StateMachine Changelog
 
+== Version 0.1.0
+
+A new way to build the statemachines
+* cleaner API for running a statemachine
+* much refactoring
+* new API for building statemachine
+* process_event accepts strings
+
+== Version 0.0.4
+
+Some minor improvements
+* Proper handling of state transition implemented, such that the proper state is set for entry and exit actions.
+* can now use State objects in addition to symbols while creating a transition
+* more compliant implementation of history state
+
 == Version 0.0.3
 
 Bug fix dealing with entry and exit actions.  The state machine's state need to be set to the entered/exited state before calling the 

data/TODO

@@ -0,0 +1,4 @@
+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.rb

@@ -1,2 +1,7 @@
+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/lib/statemachine/builder.rb

@@ -0,0 +1,111 @@
+module StateMachine
+  
+  def self.build(statemachine = nil)
+    builder = statemachine ? StatemachineBuilder.new(statemachine) : StatemachineBuilder.new
+    yield builder
+    builder.statemachine.reset
+    return builder.statemachine
+  end
+  
+  class Builder
+    attr_reader :statemachine
+    
+    def initialize(statemachine)
+      @statemachine = statemachine
+    end
+    
+    protected
+    def acquire_state_in(state_id, context)
+      return nil if state_id == nil
+      return state_id if state_id.is_a? State
+      state = nil
+      if @statemachine.has_state(state_id)
+        state = @statemachine.get_state(state_id)
+      else
+        state = State.new(state_id, context, @statemachine)
+        @statemachine.add_state(state)
+      end
+      context.start_state = state if context.start_state == nil
+      return state
+    end
+  end
+  
+  module StateBuilding
+    attr_reader :subject
+  
+    def event(event, destination_id, action = nil)
+      @subject.add(Transition.new(@subject.id, destination_id, event, action))
+    end
+    
+    def on_entry(&entry_action)
+      @subject.entry_action = entry_action
+    end
+    
+    def on_exit(&exit_action)
+      @subject.exit_action = exit_action
+    end
+  end
+  
+  module SuperstateBuilding
+    attr_reader :subject
+    
+    def state(id)
+      builder = StateBuilder.new(id, @subject, @statemachine)
+      yield builder
+    end
+
+    def superstate(id)
+      builder = SuperstateBuilder.new(id, @subject, @statemachine)
+      yield builder
+    end
+
+    def trans(origin_id, event, destination_id, action = nil)
+      origin = acquire_state_in(origin_id, @subject)
+      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
+    end
+    
+    def on_entry_of(id, &action)
+      @statemachine.get_state(id).entry_action = action
+    end
+    
+    def on_exit_of(id, &action)
+      @statemachine.get_state(id).exit_action = action
+    end
+  end
+  
+  class StateBuilder < Builder
+    include StateBuilding
+    
+    def initialize(id, superstate, statemachine)
+      super statemachine
+      @subject = acquire_state_in(id, superstate)
+    end
+  end
+
+  class SuperstateBuilder < Builder
+    include StateBuilding
+    include SuperstateBuilding
+    
+    def initialize(id, superstate, statemachine)
+      super statemachine
+      @subject = Superstate.new(id, superstate, statemachine)
+      superstate.start_state = @subject if superstate.start_state == nil
+      statemachine.add_state(@subject)
+    end
+  end
+  
+  class StatemachineBuilder < Builder
+    include SuperstateBuilding
+    
+    def initialize(statemachine = StateMachine.new)
+      super statemachine
+      @subject = @statemachine.root
+    end
+  end
+  
+end

data/lib/statemachine/proc_calling.rb

@@ -6,47 +6,12 @@ module StateMachine
       
     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
+      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

data/lib/statemachine/state.rb

@@ -6,11 +6,12 @@ module StateMachine
     
     include ProcCalling
     
-    attr_reader :id, :statemachine, :entry_action, :exit_action
-    attr_accessor :superstate
+    attr_reader :id, :statemachine, :superstate
+    attr_accessor :entry_action, :exit_action
 
-    def initialize(id, state_machine)
+    def initialize(id, superstate, state_machine)
       @id = id
+      @superstate = superstate
       @statemachine = state_machine
       @transitions = {}
     end
@@ -22,33 +23,15 @@ module StateMachine
     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}")
-      activate
       call_proc(@exit_action, args, "exit action for #{self}") if @exit_action
-      @superstate.existing(self) if @superstate
+      @superstate.substate_exiting(self) if @superstate
     end
 
     def enter(args)
       @statemachine.trace("\tentering #{self}")
-      activate
       call_proc(@entry_action, args, "entry action for #{self}") if @entry_action
     end
     
@@ -56,20 +39,14 @@ module StateMachine
       @statemachine.state = self
     end
     
-    def is_superstate?
-      return false
+    def is_concrete?
+      return true
     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/statemachine/state_machine.rb

@@ -1,44 +1,33 @@
-require 'statemachine/state'
-require 'statemachine/super_state'
-require 'statemachine/transition'
-require 'statemachine/proc_calling'
-
 module StateMachine
   
   class StateMachineException < Exception
   end
   
-  class MissingTransitionException < StateMachineException
-  end
-  
   class StateMachine
-    
     include ProcCalling
   
-    attr_reader :states, :state
-    attr_accessor :start_state, :tracer
+    attr_accessor :tracer
+    attr_reader :root
   
-    def initialize
+    def initialize(root = Superstate.new(:root, nil, self))
+      @root = root
       @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))
+    
+    def start_state
+      return @root.start_state.id
     end
   
-    def run
-      @state = @start_state
+    def reset
+      @state = @root.start_state
+      while @state and not @state.is_concrete?
+        @state = @state.start_state
+      end
+      raise StateMachineException.new("The state machine doesn't know where to start. Try setting the start_state.") if @state == nil
     end
-    alias :reset :run
-  
-    def [] (state_id)
-      return @states[state_id]
+    
+    def state
+      return @state.id
     end
     
     def state= value
@@ -50,54 +39,74 @@ module StateMachine
         @state = @states[value.to_sym]
       end
     end
-  
+    
     def process_event(event, *args)
+      event = event.to_sym
       trace "Event: #{event}"
       if @state
         transition = @state.transitions[event]
         if transition
-          transition.invoke(@state, args)
+          transition.invoke(@state, self, args)
         else
-          raise MissingTransitionException.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.  Did you forget to call run?")
+        raise StateMachineException.new("The state machine isn't in any state while processing the '#{event}' event.")
       end
     end
-  
+    
+    def trace(message)
+      @tracer.puts message if @tracer
+    end
+    
+    def get_state(id)
+      if @states.has_key? id
+        return @states[id]
+      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
+        return superstate.history
+      else
+        state = State.new(id, @root, self)
+        @states[id] = state
+        return state
+      end
+    end
+    
+    def add_state(state)
+      @states[state.id] = state
+    end
+    
+    def has_state(id)
+      if(is_history_state_id?(id))
+        return @states.has_key?(base_id(id))
+      else
+        return @states.has_key?(id)
+      end
+    end
+    
     def method_missing(message, *args)
-      if @state and @state[message]
+      if @state and @state.transitions[message]
         method = self.method(:process_event)
         params = [message.to_sym].concat(args)
-        call_proc(method, params, "method_missing")
+        method.call(*params)
       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
+    private 
+    
+    def is_history_state_id?(id)
+      return id.to_s[-2..-1] == "_H"
     end
     
-    def trace(message)
-      @tracer.puts message if @tracer
+    def base_id(history_id)
+      return history_id.to_s[0...-2].to_sym
     end
-  
+    
   end
 
 end

data/lib/statemachine/super_state.rb

@@ -3,65 +3,33 @@ module StateMachine
   class Superstate < State
   
     attr_writer :start_state
+    attr_reader :history
   
-    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)
+    def initialize(id, superstate, statemachine)
+      super(id, superstate, statemachine)
+      @start_state = nil
+      @history = nil
     end
     
-    def is_superstate?
-      return true
+    def is_concrete?
+      return false
     end
     
     def start_state
-      if @use_history and @history_state
-        return @history_state
-      else
-        return @start_state
-      end
+      return @start_state
     end
     
-    def existing(substate)
-      @history_state = substate
+    def substate_exiting(substate)
+      @history = 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