MINT-statemachine 1.2.2

data/lib/statemachine/state.rb

@@ -0,0 +1,102 @@
+module Statemachine
+
+  class State #:nodoc:
+
+    attr_reader :id, :statemachine
+    attr_accessor :entry_action, :exit_action, :superstate
+    attr_writer :default_transition
+
+    def initialize(id, superstate, state_machine)
+      @id = id
+      @superstate = superstate
+      @statemachine = state_machine
+      @transitions = {}
+    end
+
+    def add(transition)
+      @transitions[transition.event] = transition
+    end
+
+    def transitions
+      return @superstate ? @transitions.merge(@superstate.transitions) : @transitions
+    end
+
+    def non_default_transition_for(event)
+      transition = @transitions[event]
+      if @superstate
+        transition = @superstate.non_default_transition_for(event) if @superstate and @superstate.is_parallel == false and not transition
+      end
+      return transition
+    end
+
+    def default_transition
+      return @default_transition if @default_transition
+      return @superstate.default_transition if @superstate
+      return nil
+    end
+
+    def transition_for(event)
+      transition = non_default_transition_for(event)
+      transition = default_transition if not transition
+      return transition
+    end
+
+    def exit(args)
+      messenger = self.statemachine.messenger
+      message_queue = self.statemachine.message_queue
+      @statemachine.trace("\texiting #{self}")
+      @statemachine.invoke_action(@exit_action, args, "exit action for #{self}", messenger, message_queue) if @exit_action
+      @superstate.substate_exiting(self) if @superstate
+    end
+
+    def enter(args=[])
+      messenger = self.statemachine.messenger
+      message_queue = self.statemachine.message_queue
+      @statemachine.trace("\tentering #{self}")
+      @statemachine.invoke_action(@entry_action, args, "entry action for #{self}", messenger, message_queue) if @entry_action
+    end
+
+    def activate
+      @statemachine.state = self
+      if (@statemachine.is_parallel)
+       @statemachine.activation.call(self.id,@statemachine.is_parallel.abstract_states,@statemachine.is_parallel.statemachine.states_id) if @statemachine.activation
+      else
+
+        @statemachine.activation.call(self.id,@statemachine.abstract_states,@statemachine.states_id) if @statemachine.activation
+     end
+    end
+
+    def concrete?
+      return true
+    end
+
+    def resolve_startstate
+      return self
+    end
+
+    def reset
+
+    end
+
+    def to_s
+      return "'#{id}' state"
+    end
+
+    def has_superstate(id)
+      return false if not @superstate
+      return true if @superstate.id == id 
+      return @superstate.has_superstate(id)
+    end
+
+    def abstract_states
+      return [] if not superstate
+      return @superstate.abstract_states if not @superstate.is_parallel
+      []
+    end
+
+    def is_parallel
+      false
+    end
+  end
+  
+end

data/lib/statemachine/statemachine.rb

@@ -0,0 +1,279 @@
+module Statemachine
+
+  class StatemachineException < Exception
+  end
+
+  class TransitionMissingException < Exception
+  end
+
+  # Used at runtime to execute the behavior of the statemachine.
+  # Should be created by using the Statemachine.build method.
+  #
+  #   sm = Statemachine.build do
+  #     trans :locked, :coin, :unlocked
+  #     trans :unlocked, :pass, :locked:
+  #   end
+  #
+  #   sm.coin
+  #   sm.state
+  #
+  # This class will accept any method that corresponds to an event.  If the
+  # current state responds to the event, the appropriate transition will be invoked.
+  # Otherwise an exception will be raised.
+  class Statemachine
+    include ActionInvokation
+
+    # The tracer is an IO object.  The statemachine will write run time execution
+    # information to the +tracer+. Can be helpful in debugging. Defaults to nil.
+    attr_accessor :tracer
+
+    # Provides access to the +context+ of the statemachine.  The context is a object
+    # where all actions will be invoked.  This provides a way to separate logic from
+    # behavior.  The statemachine is responsible for all the logic and the context
+    # is responsible for all the behavior.
+    attr_reader :context
+
+    attr_reader :root, :states
+    attr_accessor :messenger, :message_queue, :is_parallel #:nodoc:
+    attr_accessor :activation
+
+    # Should not be called directly.  Instances of Statemachine::Statemachine are created
+    # through the Statemachine.build method.
+    def initialize(root = Superstate.new(:root, nil, self))
+      @root = root
+      @states = {}
+    end
+
+    # Returns the id of the startstate of the statemachine.
+    def startstate
+      return @root.startstate_id
+    end
+
+    # Resets the statemachine back to its starting state.
+    def reset(startstate_id=nil)
+
+      if (startstate_id and @root.is_parallel) # called when enterin a parallel state or dierctly entering a child of a parallel state from outside the parallel state
+        @state = get_state(startstate_id)
+      else
+        @state = get_state(@root.startstate_id)
+      end
+      while @state and not @state.concrete?
+        @state = get_state(@state.startstate_id)
+      end
+      raise StatemachineException.new("The state machine doesn't know where to start. Try setting the startstate.") if @state == nil
+      @state.enter
+      @states.values.each { |state|
+        state.reset if not state.is_a? Parallelstate
+      }
+    end
+
+    def context= c
+      @context = c
+
+      p = get_parallel
+      if p
+        p.context = c
+      end
+    end
+
+    #Return the id of the current state of the statemachine.
+    def state
+      return @state.id
+    end
+
+    # returns an array with the ids of the current active states of the machine.
+    def states_id(atomic = true)
+      belongs, parallel = belongs_to_parallel(@state.id)
+      if belongs
+        return parallel.states
+      else
+        return [@state.id]
+      end
+    end
+
+    # returns an array with all currently active super states
+    def abstract_states
+      @state.abstract_states
+    end
+
+    # You may change the state of the statemachine by using this method.  The parameter should be
+    # the id of the desired state.
+    def state= value
+      if value.is_a? State
+        @state = value
+      elsif @states[value]
+        @state = @states[value]
+      elsif value and @states[value.to_sym]
+        @state = @states[value.to_sym]
+      end
+    end
+
+    def states= values
+      if values.is_a? Array and values.length==1
+        self.state=self.get_state(values.first)
+      else
+        values.each do |v|
+          if @states.has_key? v
+            self.state=v
+          else
+            belongs,parallel = belongs_to_parallel(v)
+            if belongs
+              self.state=parallel.id
+              parallel.state=v
+            end
+          end
+        end
+      end
+    end
+
+    # The key method to exercise the statemachine. Any extra arguments supplied will be passed into
+    # any actions associated with the transition.
+    #
+    # Alternatively to this method, you may invoke methods, names the same as the event, on the statemachine.
+    # The advantage of using +process_event+ is that errors messages are more informative.
+    def process_event(event, *args)
+      event = event.to_sym
+      trace "Event: #{event}"
+      if @state
+        belongs, parallel = belongs_to_parallel(@state.id)
+        if belongs
+          r = parallel.process_event(event, *args)
+          return true if r
+        end
+        transition = @state.transition_for(event)
+        if transition
+          cond = true
+          if transition.cond!=true and transition.cond.is_a? Proc
+            cond = @state.statemachine.invoke_action(transition.cond, [], "condition from #{@state} invoked by '#{event}' event", nil, nil)
+          else
+            cond = instance_eval(transition.cond) if transition.cond != true and @is_parallel == nil
+          end
+          if cond
+            transition.invoke(@state, self, args)
+          end
+        else
+          raise TransitionMissingException.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.")
+      end
+    end
+
+    def trace(message) #:nodoc:
+      @tracer.puts message if @tracer
+    end
+
+    def belongs_to_parallel(id)
+      @states.each_value do |v|
+        # It doesn't belong to parallel, it is parallel
+        return [true, v] if v.id == id and v.is_a? Parallelstate
+        return [v.has_state(id),v] if v.is_a? Parallelstate
+      end
+      return [false, nil]
+    end
+
+    def get_parallel
+      @states.each_value do |v|
+        return v if v.is_a? Parallelstate
+      end
+      return false
+    end
+
+    def get_state(id) #:nodoc:
+      if @states.has_key? id
+        return @states[id]
+      elsif @is_parallel and @is_parallel.statemachine.get_state(id)
+        return @is_parallel.statemachine.states[id]
+      elsif p = get_parallel and s = p.get_state(id)
+        return s
+      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.concrete?
+        return load_history(superstate)
+      elsif @is_parallel and @is_parallel.has_state(id)
+        @is_parallel.get_state(id)
+      else
+        state = State.new(id, @root, self)
+        @states[id] = state
+        return state
+      end
+    end
+
+    def add_state(state) #:nodoc:
+      @states[state.id] = state
+    end
+
+    def remove_state(state)
+      @states.delete(state.id)
+    end
+
+    def has_state(id) #:nodoc:
+      if(is_history_state_id?(id))
+        return @states.has_key?(base_id(id))
+      else
+        return @states.has_key?(id)
+      end
+    end
+
+    def respond_to?(message)
+      return true if super(message)
+      return true if @state and @state.transition_for(message)
+      return false
+    end
+
+    def method_missing(message, *args) #:nodoc:
+      if @state and @state.transition_for(message)
+        process_event(message.to_sym, *args)
+        # method = self.method(:process_event)
+        # params = [message.to_sym].concat(args)
+        # method.call(*params)
+      else
+        begin
+          super(message, args)
+        rescue NoMethodError
+          process_event(message.to_sym, *args)
+        end
+      end
+    end
+
+    def In(id)
+      # check if it is one of the actual states
+      return true if @state.id == id
+
+      # check if it is one of the superstates
+      return true if @state.has_superstate(id)
+
+      # check if it is one of the running parallel states
+      belongs, parallel = belongs_to_parallel(@state.id)
+      if belongs
+        return parallel.In(id)
+      end
+    end
+
+    private
+
+    def is_history_state_id?(id)
+      return id.to_s[-2..-1] == "_H"
+    end
+
+    def base_id(history_id)
+      return history_id.to_s[0...-2].to_sym
+    end
+
+    def load_history(superstate)
+      100.times do
+        history = superstate.history_id ? get_state(superstate.history_id) : nil
+        raise StatemachineException.new("#{superstate} doesn't have any history yet.") if not history
+        if history.concrete?
+          return history
+        else
+          superstate = history
+        end
+      end
+      raise StatemachineException.new("No history found within 100 levels of nested superstates.")
+    end
+
+  end
+end

data/lib/statemachine/stub_context.rb

@@ -0,0 +1,26 @@
+module Statemachine
+
+  class StubContext
+
+    def initialize(options = {})
+      @verbose = options[:verbose]
+    end
+
+    attr_accessor :statemachine
+
+    def method(name)
+      super(name)
+    rescue
+      self.class.class_eval "def #{name}(*args, &block); __generic_method(:#{name}, *args, &block); end"
+      return super(name)
+    end
+
+    def __generic_method(name, *args)
+      if !defined?($IS_TEST)
+        puts "action invoked: #{name}(#{args.join(", ")}) #{block_given? ? "with block" : ""}" if @verbose
+      end
+    end
+
+  end
+
+end

data/lib/statemachine/superstate.rb

@@ -0,0 +1,53 @@
+module Statemachine
+
+  class Superstate < State #:nodoc:
+  
+    attr_accessor :startstate_id
+    attr_reader :history_id
+  
+    def initialize(id, superstate, statemachine)
+      super(id, superstate, statemachine)
+      @startstate = nil
+      @history_id = nil
+    end
+    
+    def concrete?
+      return false
+    end
+
+    def startstate
+      return @statemachine.get_state(@startstate_id)
+    end
+
+    def resolve_startstate
+      return startstate.resolve_startstate
+    end
+
+    def substate_exiting(substate)
+      @history_id = substate.id
+    end
+  
+    def add_substates(*substate_ids)
+      do_substate_adding(substate_ids)
+    end
+    
+    def default_history=(state_id)
+      @history_id = @default_history_id = state_id
+    end
+    
+    def reset
+      @history_id = @default_history_id
+    end
+
+    def to_s
+      return "'#{id}' superstate"
+    end
+
+    def abstract_states
+      return [@id] if not @superstate or @superstate.is_parallel
+      ([@id] + @superstate.abstract_states).uniq
+    end
+  
+  end
+
+end