stativus 0.0.1

data/README.rdoc

@@ -0,0 +1,54 @@
+= stativus-rb
+
+		by Mike Ball
+		http://github.com/onkis/stativus-rb
+
+== DESCRIPTION:
+	A port of the stativus.js statechart library.  Primarly designed to work with
+	ruby motion projects
+	
+== USAGE:
+
+	#create statechart
+	statechart = Stativus.Statechart.new
+
+	#To Define a state
+	class MyState < Stativus::State
+		def enter
+			#do your enter state stuff here
+		end
+		
+		def exit
+			#do your exit stuff here
+		end
+		
+		#actions
+		def my_action
+			self.goto_state('Another')
+		end
+	end
+	#add state to statechart
+	#TODO: make this more automagic this is ruby...
+	statechart.add_state(MyState)
+	
+	#start the statechart
+	statechart.start('MyState') #pass the initial state
+	
+	Look in the tests directory to see more examples of
+	* parallel substates
+	* send_event
+	* parent => child relationship definitions
+	
+== INSTALL:
+
+gem install stativus
+
+== LICENSE:
+
+Copyright (c) 2012 Mike Ball
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/stativus.rb

@@ -0,0 +1,590 @@
+module Stativus
+  class State
+    attr_accessor :global_concurrent_state, 
+                  :local_concurrent_state, 
+                  :statechart,
+                  :has_concurrent_substates,
+                  :parent_state,
+                  :initial_substate,
+                  :substates,
+                  :states,
+                  :history
+  
+    def initialize(statechart)
+      @statechart = statechart
+      @substates = []
+      
+      @has_concurrent_substates = self.respond_to?(:_has_concurrent_substates) ? self._has_concurrent_substates : false
+      @global_concurrent_state = self.respond_to?(:_global_concurrent_state) ? self._global_concurrent_state : DEFAULT_TREE
+      @states = self.respond_to?(:_states) ? self._states : []
+      @initial_substate = self.respond_to?(:_initial_substate) ? self._initial_substate : nil
+      @parent_state = self.respond_to?(:_parent_state) ? self._parent_state : nil      
+    end
+  
+  
+    def goto_state(name)
+      sc = @statechart
+      if(sc) 
+        sc.goto_state(name, @global_concurrent_state, @local_concurrent_state)
+      else 
+        raise "State has no statechart. Therefore no gotoState"
+      end
+    end
+  
+    def goto_history_state(name)
+      sc = @statechart
+      if(sc) 
+        sc.gotoHistroyState(name, @global_concurrent_state, @local_concurrent_state)
+      else 
+        raise "State has no statechart. Therefore no History State"
+      end
+    end
+  
+    def send_event(evt, *args)
+      sc = @statechart
+      if(sc) 
+        sc.send_event(evt, args) 
+      else 
+        raise "can't send event cause state doesn't have a statechart"
+      end
+    end
+    alias :send_action :send_event
+
+    #
+    # My ruby foo is weak and i really with there was another way to setup
+    # data on a class other than calling send :define_method then checking
+    # for the existence of this method...
+    def self.has_concurrent_substates(value)
+      send :define_method, :_has_concurrent_substates do
+        return value
+      end
+    end
+    
+    def self.global_concurrent_state(state)
+      send :define_method, :_global_concurrent_state do
+        return state
+      end
+    end
+  
+    def self.states(*states)
+      send :define_method, :_states do
+        return states
+      end
+    end
+    
+    def self.initial_substate(state)
+      send :define_method, :_initial_substate do
+        return state
+      end
+    end
+    
+    def self.parent_state(state)
+      send :define_method, :_parent_state do
+        return state
+      end
+    end
+  
+    def name
+      return self.class.to_s
+    end
+    
+    def to_s
+      return self.class.to_s
+    end
+  
+  end
+
+  DEFAULT_TREE = "default"
+  SUBSTATE_DELIM = "SUBSTATE:"
+  class Statechart
+    attr_accessor :all_states,
+                  :states_with_concurrent_substates,
+                  :current_subtrees,
+                  :current_state,
+                  :goto_state_locked,
+                  :send_event_locked,
+                  :pending_state_transitions,
+                  :pending_events,
+                  :active_subtrees
+  
+    def initialize()
+      @all_states = {}
+      @all_states[DEFAULT_TREE] = {}
+      @states_with_concurrent_substates = {}
+      @current_subsates = {}
+      @current_state = {}
+      @current_state[DEFAULT_TREE] = nil
+      @goto_state = false
+      @send_event_locked = false
+      @pending_state_transitions = []
+      @pending_events = []
+      @active_subtrees = {}
+      @goto_state_locked = false
+    end
+  
+    def add_state(state_class)
+      state = state_class.new(self)
+      tree = state.global_concurrent_state
+      parent_state = state.parent_state
+      current_tree = @states_with_concurrent_substates[tree]
+    
+      if(state.has_concurrent_substates)
+        obj = @states_with_concurrent_substates[tree] || {}
+        obj[state.name] = true
+        @states_with_concurrent_substates[tree] = obj
+      end
+    
+      if(parent_state and current_tree and current_tree[parent_state])
+        parent_state = @all_states[tree][parent_state]
+        if(parent_state)
+          parent_state.substates.push(state.name)
+        end
+      end
+    
+      obj = @all_states[tree] || {}
+    
+      obj[state.name] = state
+    
+      sub_states = state.states || []
+      
+      sub_states.each do |sub_state|
+        sub_state.parent_state = state
+        sub_state.global_concurrent_state = tree
+        add_state(sub_state)
+      end
+    end #add_state
+  
+    # call this in your programs main
+    # state is the initial state of the application
+    # in the default tree
+    def start(state)
+      @in_initial_setup = true
+      self.goto_state(state, DEFAULT_TREE)
+      @in_initial_setup = false
+      flush_pending_events
+    end
+  
+    def goto_state(requested_state_name, tree, concurrent_tree=nil)
+      all_states = @all_states[tree]
+     
+      #First, find the current tree off of the concurrentTree, then the main tree
+      curr_state = concurrent_tree ? @current_state[concurrent_tree] : @current_state[tree]
+      
+      requested_state = all_states[requested_state_name]
+
+      # if the current state is the same as the requested state do nothing
+      return if(check_all_current_states(requested_state, concurrent_tree || tree))
+      
+      
+      if(@goto_state_locked)
+        #There is a state transition currently happening. Add this requested
+        #state transition to the queue of pending state transitions. The req
+        #will be invoked after the current state transition is finished
+        @pending_state_transitions.push({
+          :requested_state => requested_state_name,
+          :tree => tree
+        })
+        return
+      end
+      # Lock for the current state transition, so that it all gets sorted out
+      # in the right order
+      @goto_state_locked = true
+      
+      # Get the parent states for the current state and the registered state.
+      # we will use them to find the commen parent state
+      enter_states = parent_states_with_root(requested_state)
+      exit_states = curr_state ? parent_states_with_root(curr_state) : []
+      #
+      # continue by finding the common parent state for the current and 
+      # requested states:
+      #
+      # At most, this takes O(m^2) time, where m is the maximum depth from the 
+      # root of the tree to either the requested state or the current state.
+      # Will always be less than or equal to O(n^2), where n is the number
+      # of states in the tree
+      enter_match_index = nil
+      exit_match_index = 0
+      exit_states.each_index do |idx|
+        exit_match_index = idx
+        enter_match_index = enter_states.index(exit_states[idx])
+        break if(enter_match_index != nil)    
+      end
+      
+      # In the case where we don't find a common parent state, we 
+      # must enter from the root state
+      enter_match_index = enter_states.length()-1 if(enter_match_index == nil)
+    
+      #setup the enter state sequence
+      @enter_states = enter_states
+      @enter_state_match_index = enter_match_index
+      @enter_state_concurrent_tree = concurrent_tree
+      @enter_state_tree = tree
+      
+      # Now, we will exit all the underlying states till we reach the common
+      # parent state. We do not exit the parent state because we transition
+      # within it.
+      @exit_state_stack = []
+      full_exit_from_substates(tree, curr_state) if(curr_state != nil and curr_state.has_concurrent_substates)
+      
+      if exit_match_index == nil || exit_match_index-1 < 0
+        exit_match_index = 0 
+      else
+        0.upto(exit_match_index-1) do |i|
+          @exit_state_stack.push(exit_states[i])
+        end
+      end
+      
+      #Now that we have the full stack of states to exit
+      #we can exit them...
+      
+      unwind_exit_state_stack();
+      
+    end #end goto_state
+    
+    def send_event(evt, *args)
+      
+      # We want to prevent any events from occurring until
+      # we have completed the state transitions and events
+      if @in_initial_setup or @goto_state_locked or @send_event_locked
+        @pending_events.push({
+          :evt => evt,
+          :args => args
+        })
+        return
+      end
+      
+      @send_event_locked = true
+      
+      structure_crawl(evt, args)
+      
+      # Now, that the states have a chance to process the first action
+      # we can go ahead and flush the queued events
+      @send_event_locked = false;
+      
+      flush_pending_events() unless @in_initial_setup      
+        
+    end
+    #
+    # Private functions
+    #
+    private
+    
+    def structure_crawl(evt, args)
+      current_states = @current_state
+      ss = Stativus::SUBSTATE_DELIM
+      
+      for tree in current_states.keys
+        next unless tree
+        handled = false
+        s_tree = nil
+        responder = current_states[tree]
+        
+        next if(!responder or tree.slice(0, ss.length()) == ss)
+        
+        all_states = @all_states[tree]
+        
+        next unless all_states
+        
+        a_trees = @active_subtrees[tree] || []
+        
+        #0.upto(a_trees.length()-1) do |i|
+        a_trees.each do |s_tree|
+          #s_tree = a_trees[i]
+          s_responder = current_states[s_tree]
+          tmp = handled ? [true, true] : cascade_events(evt, args, s_responder, all_states, s_tree)
+          handled = tmp[0]
+          #if (DEBUG_MODE) found = tmp[1];
+        end
+        if(not handled)
+          tmp = cascade_events(evt, args, responder, all_states, nil)
+          handled = tmp[0]
+          # if (DEBUG_MODE){ 
+          #   if (!found) found = tmp[1];
+          # }
+          
+        end        
+        # if (DEBUG_MODE){
+        #   if(!found) console.log(['ACTION/EVENT:{'+evt+'} with', args.length || 0, 'argument(s)','found NO state to handle this'].join(' '));
+        # }
+      end
+    end
+    
+    def cascade_events(evt, args, responder, all_states, tree)
+      
+      found = false
+      handled = nil
+      if(tree)
+        trees = tree.split('=>')
+        ss_name = trees.last
+      end
+      
+      while(not handled and responder)
+        if(responder.respond_to?(evt))
+          method = responder.method(evt)
+          #if (DEBUG_MODE) console.log(['EVENT:',responder.name,'fires','['+evt+']', 'with', args.length || 0, 'argument(s)'].join(' '));
+          if(method.arity != 0)
+            handled = method.call(args)
+          else
+            handled = method.call()
+          end
+          #ruby has implict returns therefore you actually
+          #have to explicitly return true
+          handled = handled == false ? false : true
+          found = true
+        end
+        
+        #check to see if we're at the end of the tree
+        return [handled, found] if(tree and ss_name == responder.name)
+        responder = (!handled && responder.parent_state) ? all_states[responder.parent_state] : nil
+      end
+      
+      return [handled, found]
+    end
+    # this function exits all items next on the exit state stack
+    def unwind_exit_state_stack
+      @exit_state_stack = @exit_state_stack || []
+      state_to_exit = @exit_state_stack.shift
+      
+      if state_to_exit
+        if(state_to_exit.respond_to?(:will_exit_state))
+          
+          state_restart = {
+            :statechart => self,
+            :start => state_to_exit
+          }
+          #todo : i'm pretty sure this won't work as written...
+          state_restart[:restart] = Proc.new {
+            #if(debugMode) puts ['RESTART: after async processing on,', self[:start].name, 'is about to fully exit'].join(' ')
+            @statechart.full_exit(state_restart[:start])
+          }
+          delay_for_async = state_to_exit.will_exit_state(state_restart)
+        end
+        full_exit(state_to_exit) unless delay_for_async
+      else
+        @exit_state_stack = nil
+        initiate_enter_state_sequence
+      end
+    end
+    
+    def full_exit(state)
+      return unless state
+      exit_state_handled = false
+      state.exit if(state.respond_to?(:exit))
+      state.did_exit_state if(state.respond_to?(:did_exit_state))
+      #todo: if (DEBUG_MODE) console.log('EXIT: '+state.name);
+      unwind_exit_state_stack
+    end
+    
+    def full_enter(state)
+      return unless state
+      enter_state_handled = false
+      #if (DEBUG_MODE) console.log('ENTER: '+state.name);
+      state.enter if state.respond_to?(:enter)
+      state.did_enter_state if state.respond_to?(:did_enter_state)
+      unwind_enter_state_stack()
+    end
+      
+    
+    def full_exit_from_substates(tree, stop_state)
+      
+      return if(!tree || !stop_state)
+      
+      all_states = @all_states[tree]
+      curr_states = @current_state
+      @exit_state_stack = @exit_state_stack || []
+      
+      stop_state.substates.each do |state|
+        substate_tree = [SUBSTATE_DELIM, tree, stop_state.name, state].join("=>")
+        curr_state = curr_states[substate_tree]
+        
+        while(curr_state and curr_state != stop_state)
+          exit_state_handled = false
+          @exit_state_stack.unshift(curr_state)
+          
+          #check to see if it has substates
+          full_exit_from_substates(tree, curr_state) if(curr_state.has_concurrent_substates)
+          
+          #up to the next parent
+          curr = curr_state.parent_state
+          curr_state = all_states[curr]
+        end
+        
+      end
+      
+    end
+    
+    def initiate_enter_state_sequence
+      enter_states = @enter_states
+      enter_match_index = @enter_state_match_index
+      concurrent_tree = @enter_state_concurrent_tree
+      tree = @enter_state_tree
+      all_states = @all_states[tree]
+      
+      #initalize the enter state stack
+      @enter_state_stack = @enter_state_stack || []
+      
+      # Finally, from the common parent state, but not including the parent state,
+      # enter the sub states down to the requested state. If the requested state
+      # has an initial sub state, then we must enter it too
+      i = enter_match_index - 1
+      curr_state = enter_states[i]
+      if(curr_state)
+        cascade_enter_substates(curr_state, enter_states, 
+                                (i-1), concurrent_tree || tree, all_states)
+      end
+      
+      #once, we have fully hydrated the Enter State Stack, we must actually async unwind it 
+      unwind_enter_state_stack
+      
+      #cleanup
+      @enter_states = @enter_state_match_index = @enter_state_concurrent_tree = 
+      @enter_state_tree = nil
+      
+    end
+    
+    def cascade_enter_substates(start, required_states, index, tree, all_states)
+      return unless start
+      name = start.name
+      @enter_state_stack.push(start)
+      @current_state[tree] = start
+      start.local_concurrent_state = tree
+      if(start.has_concurrent_substates)
+        tree = start.global_concurrent_state || DEFAULT_TREE
+        next_tree = [SUBSTATE_DELIM,tree,name].join("=>")
+        start.history = start.history || {}
+        substates = start.substates || []
+        substates.each do |x|
+          next_tree = tree +"=>"+x
+          curr_state = all_states[x]
+          
+          # Now, we have to push the item onto the active subtrees for
+          # the base tree for later use of the events.
+          b_tree = curr_state.global_concurrent_state || DEFAULT_TREE
+          a_trees = active_subtrees[b_tree] || []
+          a_trees.unshift(next_tree)
+          @active_subtrees[b_tree] = a_trees
+          index -=1 if(index > -1 && required_states[index] == curr_state)
+          cascade_enter_substates(curr_state, required_states, index, next_tree, all_states)
+        end
+        return
+      else
+        curr_state = required_states[index]
+        if(curr_state and curr_state.is_a?(State))
+          parent_state = all_states[curr_state.parent_state]
+          if(parent_state)
+            if(parent_state.has_concurrent_substates)
+              parent_state.history[tree] = curr_state.name
+            else
+              parent_state.history = current_state.name
+            end
+          end #end parent state
+          
+          index -=1 if(index > -1 && required_states[index] == curr_state)
+          cascade_enter_substates(curr_state, required_states, index, tree, all_states)
+        else
+          curr_state = all_states[start.initial_substate]
+          cascade_enter_substates(curr_state, required_states, index, tree, all_states)
+        end
+      end
+  
+    end
+        
+    def unwind_enter_state_stack
+
+      @exit_state_stack = @exit_state_stack || []
+      state_to_enter = @enter_state_stack.shift()
+      
+      if state_to_enter
+        if state_to_enter.respond_to?(:will_enter_state)
+          
+          state_restart = {
+            :statechart => self,
+            :start => state_to_enter
+          }
+          state_restart[:restart] = Proc.new{
+            #if (DEBUG_MODE) console.log(['RESTART: after async processing on,', this._start.name, 'is about to fully enter'].join(' '));
+            @statechart.full_enter(state_restart[:state_to_enter])
+          }
+          delay_for_async = state_to_enter.will_enter_state(state_restart)
+          # if (DEBUG_MODE) {
+          #   if (delayForAsync) { console.log('ASYNC: Delayed enter '+stateToEnter.name); }
+          #   else { console.warn('ASYNC: Didn\'t return \'true\' willExitState on '+stateToEnter.name+' which is needed if you want async'); }
+          # }
+        end
+        full_enter(state_to_enter) unless delay_for_async
+      
+      else  
+        @enter_state_stack = nil
+        # Ok, we're done with the current state transition. Make sure to unlock
+        # the goToState and let other pending state transitions
+        @goto_state_locked = false
+        more = flush_pending_state_transitions
+        # Once pending state transitions are flushed then go ahead and start flush
+        # pending actions
+        flush_pending_events if not more and not @in_initial_setup
+      end
+    end
+    
+    def flush_pending_state_transitions
+      pending = @pending_state_transitions.shift
+      return false unless pending
+      goto_state(pending.requested_state, pending.tree)
+      return true
+    end
+    
+    def flush_pending_events
+      pending_event = @pending_events.shift()
+      return if(pending_event == nil)
+      self.send_event(pending_event.evt, pending_event.args)
+    end
+    
+    def check_all_current_states(requested_state, tree)
+      current_states = @current_state[tree] || []
+      
+      if(current_states == requested_state)
+        return true
+      elsif(current_states.class == String and requested_state == @all_states[tree][current_states])
+        return true
+      elsif(current_states.class == Array and current_states.include?(requested_state))
+        return true
+      else
+        return false
+      end
+    end
+    
+    # returns the state object for a passed name and tree
+    # was called _parentStateObject in js
+    def state_object(name, tree)
+      if(name && tree && @all_states[tree] && @all_states[tree][name])
+        return @all_states[tree][name]
+      end
+    end
+    
+    # 
+    # returns an array of all the parent states of the passed state
+    #
+    def parent_states(state)
+      ret = []
+      curr = state
+      
+      ret.push(curr)
+      curr = state_object(curr.parent_state, curr.global_concurrent_state)
+      
+      while(curr)
+        ret.push(curr)
+        curr = state_object(curr.parent_state, curr.global_concurrent_state)
+      end
+      
+      return ret
+    end
+    
+    # creates an array of all a states parent states
+    # ending with a string of "root" to indcate the
+    # root state
+    def parent_states_with_root(state)
+      ret = parent_states(state)
+      ret.push('root')
+      return ret
+    end
+  end #end class
+end #end module

data/tests/add_state.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require  Dir.pwd()+'/tests/test_states'
+class AddState < Test::Unit::TestCase
+  def setup
+    @statechart = Stativus::Statechart.new
+
+    @statechart.add_state(A)
+    @statechart.add_state(B)
+    @statechart.add_state(C)
+    
+    @statechart.start("B")
+    @statechart.goto_state("B", Stativus::DEFAULT_TREE)
+    @statechart.goto_state("C", Stativus::DEFAULT_TREE)
+    @default_tree = @statechart.all_states[Stativus::DEFAULT_TREE]
+  end #end setup
+  
+  
+  def test_states_were_added
+    assert(true, "Sanity check")
+    assert_equal(1, @statechart.all_states.keys.length, "should have one tree")
+    assert_equal(3, @statechart.all_states[Stativus::DEFAULT_TREE].keys.length, 
+                  "should have 3 states in default tree")
+    
+    
+    assert_instance_of(A, @default_tree["A"], "should have an A")
+    assert_instance_of(B, @default_tree["B"], "should have an B")
+    assert_instance_of(C, @default_tree["C"], "should have an C")
+  end
+  
+  def test_state_has_proper_settings
+    a = @default_tree["A"]
+    b = @default_tree["B"]
+    assert(a.has_concurrent_substates, "a should have concurrent sub states")
+    assert_equal("A", b.parent_state, "a is the parent of B")
+    assert_equal(["B", "C"], a.substates, "a should have 2 substates")
+    
+  end
+
+
+end

data/tests/complex_states.rb

@@ -0,0 +1,67 @@
+class First < Stativus::State
+  has_concurrent_substates true
+  
+  def test_event
+    self.goto_state('Second')
+  end
+  
+end
+
+class FirstFirst < Stativus::State
+  parent_state "First"
+  initial_substate "FirstFirstFirst"
+  
+  def test_event
+  end
+end
+
+class FirstSecond < Stativus::State
+  parent_state "First"
+  inital_substate "FirstSecondFirst"
+  
+  def test_event
+  end
+end
+
+class FirstFirstFirst < Stativus::State
+  parent_state "FirstFirst"
+  
+  def test_event
+    self.goto_state('FirstFirstSecond')
+  end
+end
+
+class FirstFirstSecond < Stativus::State
+  parent_state "FirstFirst"
+  
+  def test_event
+  end
+end
+
+class FirstSecondSecond < Stativus::State
+  parent_state 'FirstSecond'
+  def test_event
+  end
+end
+
+class Second < Stativus::State
+  initial_substate "SecondFirst"
+  def test_event
+  end
+end
+
+class SecondFirst < Stativus::State
+  parent_state "Second"
+  def test_event
+  end
+end
+
+class SecondSecond < Stativus::State
+  parent_state "Second"
+  
+  def test_event
+  end
+end
+
+
+

data/tests/events.rb

@@ -0,0 +1,94 @@
+require 'test/unit'
+
+
+$state_transitions = []
+
+module AllEnterExit
+  def enter
+    #puts "ENT: "+self.name
+    $state_transitions.push "ENT: "+self.name
+  end
+  
+  def exit
+    #puts "EXT: "+self.name
+    $state_transitions.push "EXT: "+self.name
+  end
+  
+  def test_event
+    $state_transitions.push("EVT: "+self.name+".test_event")
+    return false
+  end
+  
+end
+
+
+class Application < Stativus::State
+  include AllEnterExit
+  initial_substate "SubApplication"
+end
+
+class SubApplication < Stativus::State
+  include AllEnterExit
+  parent_state "Application"
+  has_concurrent_substates true
+end
+
+class First < Stativus::State
+  include AllEnterExit
+  parent_state "SubApplication"
+  initial_substate "FirstFirst"
+end
+
+class FirstFirst < Stativus::State
+  include AllEnterExit
+  parent_state "First"
+  
+  def test_event(*args)
+    $state_transitions.push('EVT: '+self.name+'.test_event')
+    self.goto_state("FirstSecond")
+    return true
+  end
+end
+
+class FirstSecond < Stativus::State
+  include AllEnterExit
+  parent_state "First"
+end
+
+class Second < Stativus::State
+  include AllEnterExit
+  parent_state "SubApplication"
+end
+
+
+
+
+class Events < Test::Unit::TestCase
+  def setup
+    @statechart = Stativus::Statechart.new
+
+    @statechart.add_state(Application)
+    @statechart.add_state(SubApplication)
+    @statechart.add_state(First)
+    @statechart.add_state(FirstFirst)
+    @statechart.add_state(FirstSecond)
+    @statechart.add_state(Second)
+        
+    @statechart.start("Application")
+    
+    #state_transitions = []
+
+  end #end setup
+  
+  def test_event_propagation
+    expected_events = ['EVT','EVT', 'EXT', 'ENT', 'EVT', 'EVT', 'EVT', 'EVT', 'EVT']
+    $state_transitions = []
+    @statechart.send_event('test_event')
+    #puts $state_transitions
+    assert_equal(4, $state_transitions.length(), "4 transitions after first event")
+    @statechart.send_event('test_event')
+    #puts "second time"
+    #puts $state_transitions
+    assert_equal(9, $state_transitions.length(), "9 transitions after second event")
+  end
+end

data/tests/test_states.rb

@@ -0,0 +1,28 @@
+class A < Stativus::State
+  has_concurrent_substates true
+  def enter
+    puts "enered A. I have concurrent substates"
+  end
+end
+
+class B < Stativus::State
+  parent_state "A"
+  def enter
+    puts "entered B"
+  end
+
+  def exit
+    puts "exited B"
+  end
+end
+
+class C < Stativus::State
+  parent_state "A"
+  def enter
+    puts "entered C"
+  end
+
+  def exit
+    puts "exited C"
+  end
+end

data/tests/tests.rb

@@ -0,0 +1,4 @@
+require './lib/stativus.rb'
+#require './tests/complex_states.rb'
+require './tests/add_state.rb'
+require './tests/events.rb'

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: stativus
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mike Ball
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70289451304540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70289451304540
+description: ! "Stativus provides a way to define state in a client facing application.
+  \nIt is a port of the stativus.js library."
+email: mike.ball3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- lib/stativus.rb
+- README.rdoc
+- tests/add_state.rb
+- tests/complex_states.rb
+- tests/events.rb
+- tests/test_states.rb
+- tests/tests.rb
+homepage: http://github.com/onkis/stativus-rb
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: a ruby statechart library
+test_files:
+- tests/add_state.rb
+- tests/complex_states.rb
+- tests/events.rb
+- tests/test_states.rb
+- tests/tests.rb