statemachine 0.2.0 → 0.3.0

data/CHANGES

@@ -1,5 +1,25 @@
 = Statemachine Changelog
 
+== Version 0.3.0
+
+Feature enhancements
+* added default transitions
+* added default history for superstates
+* the context method in the builder will set the context's statemachine variable if the context respond_to?(:statemachine=)
+
+Behavior Fixes
+* the entry action of the startstate is called when the statemachine starts or is reset.
+* resetting the statemachine will reset the history state for each superstate.
+
+== Version 0.2.2
+
+Minor plugin update
+* introduced before_event and after_event hooks for controllers
+
+== Version 0.2.1
+
+Rails Plugin.
+* Rails plugin introduced
 
 == Version 0.2.0
 

data/README

@@ -0,0 +1,38 @@
+= Statemachine Gem
+
+This Ruby Library enables simple creation of full-features Finite Statemachines. 
+ 
+== API
+
+Where to start:
+
+* Statemachine.build
+* Statemachine::SuperstateBuilding
+* Statemachine::StateBuilding
+* Statemachine::Statemachine
+	
+== Documentation
+
+Some documentation is available here in this RDOC documentation.  
+You may also find useful documentation on the Statemachine website: http://statemachine.rubyforge.org
+
+A detailed tutorial and overview of Finite State Machines and this library can be found
+at http://blog.8thlight.com/articles/2006/11/17/understanding-statemachines-part-1-states-and-transitions.
+	
+== License
+
+Copyright (C) 2006  Micah Martin
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

data/Rakefile

@@ -7,13 +7,6 @@ require 'rake/rdoctask'
 require 'spec/rake/spectask'
 require 'statemachine'
 
-# Some of the tasks are in separate files since they are also part of the website documentation
-"load File.dirname(__FILE__) + '/tasks/examples.rake'
-load File.dirname(__FILE__) + '/tasks/examples_specdoc.rake'
-load File.dirname(__FILE__) + '/tasks/examples_with_rcov.rake'
-load File.dirname(__FILE__) + '/tasks/failing_examples_with_html.rake'
-load File.dirname(__FILE__) + '/tasks/verify_rcov.rake'"
-
 PKG_NAME = "statemachine"
 PKG_VERSION   = Statemachine::VERSION::STRING
 PKG_TAG = Statemachine::VERSION::TAG
@@ -22,7 +15,6 @@ PKG_FILES = FileList[
   '[A-Z]*',
   'lib/**/*.rb', 
   'spec/**/*.rb' 
-#  'examples/**/*',
 ]
 
 task :default => :spec
@@ -30,52 +22,26 @@ task :default => :spec
 desc "Run all specs"
 Spec::Rake::SpecTask.new do |t|
   t.spec_files = FileList['spec/**/*_spec.rb']
-#  t.spec_opts = ['--diff','--color']
-#  t.rcov = true
-#  t.rcov_dir = 'doc/output/coverage'
-#  t.rcov_opts = ['--exclude', 'spec\/spec,bin\/spec']"
 end
 
-#desc 'Generate HTML documentation for website'
-#task :webgen do
-#  Dir.chdir 'doc' do
-#    output = nil
-#    IO.popen('webgen 2>&1') do |io|
-#      output = io.read
-#    end
-#    raise "ERROR while running webgen: #{output}" if output =~ /ERROR/n || $? != 0
-#  end
-#end
-
-#desc 'Generate RDoc'
-#rd = Rake::RDocTask.new do |rdoc|
-#  rdoc.rdoc_dir = 'doc/output/rdoc'
-#  rdoc.options << '--title' << 'RSpec' << '--line-numbers' << '--inline-source' << '--main' << 'README'
-#  rdoc.rdoc_files.include('README', 'CHANGES', 'EXAMPLES.rd', 'lib/**/*.rb')
-#end
-#task :rdoc => :examples_specdoc # We generate EXAMPLES.rd
+desc 'Generate RDoc'
+rd = Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc/website/output/rdoc'
+  rdoc.options << '--title' << 'Statemachine' << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include('README', 'CHANGES', 'lib/**/*.rb')
+end
+task :rdoc
 
 spec = Gem::Specification.new do |s|
   s.name = PKG_NAME
   s.version = PKG_VERSION
   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).
-  EOF
-
+  s.description = "Statemachine is a ruby library for building Finite State Machines (FSM), also known as Finite State Automata (FSA)."
   s.files = PKG_FILES.to_a
   s.require_path = 'lib'
-
-#  s.has_rdoc = true
-#  s.rdoc_options = rd.options
-#  s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$|^EXAMPLES.rd$/ }.to_a
-  
   s.test_files = Dir.glob('spec/*_spec.rb')
   s.require_path = 'lib'
   s.autorequire = 'statemachine'
-#  s.bindir = "bin"
-#  s.executables = ["spec"]
-#  s.default_executable = "spec"
   s.author = "Micah Martin"
   s.email = "statemachine-devel@rubyforge.org"
   s.homepage = "http://statemachine.rubyforge.org"

data/TODO

@@ -1,3 +1,4 @@
 
-Implement default history
-Implement superstate end state with automatic transition
+
+Maybe:
+Implement superstate endstate with automatic transition

data/lib/statemachine.rb

@@ -1,7 +1,25 @@
+#--
+# Copyright (C) 2006  Micah Martin
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
 require 'statemachine/action_invokation'
 require 'statemachine/state'
-require 'statemachine/super_state'
+require 'statemachine/superstate'
 require 'statemachine/transition'
-require 'statemachine/state_machine'
+require 'statemachine/statemachine'
 require 'statemachine/builder'
 require 'statemachine/version'

data/lib/statemachine/action_invokation.rb

@@ -1,6 +1,6 @@
 module Statemachine
 
-  module ActionInvokation
+  module ActionInvokation #:nodoc:
     
     def invoke_action(action, args, message)
       if action.is_a? Symbol

data/lib/statemachine/builder.rb

@@ -1,13 +1,36 @@
 module Statemachine
-  
+
+  # The starting point for building instances of Statemachine.  
+  # The block passed in should contain all the declarations for all 
+  # states, events, and actions with in the statemachine.
+  # 
+  # Sample: Turnstyle
+  # 
+  #   sm = Statemachine.build do
+  #     trans :locked, :coin, :unlocked, :unlock
+  #     trans :unlocked, :pass, :locked, :lock
+  #   end
+  #   
+  # An optional statemachine paramter may be passed in to modify
+  # an existing statemachine instance.
+  #
+  # Actions:
+  # Where ever an action paramter is used, it may take on one of three forms:
+  #   1. Symbols: will execute a method by the same name on the _context_
+  #   2. String: Ruby code that will be executed within the binding of the _context_
+  #   3. Proc: Will be executed within the binding of the _context_
+  #
+  # See Statemachine::SuperstateBuilding
+  # See Statemachine::StateBuilding
+  #
   def self.build(statemachine = nil, &block)
     builder = statemachine ? StatemachineBuilder.new(statemachine) : StatemachineBuilder.new
     builder.instance_eval(&block)
     builder.statemachine.reset
     return builder.statemachine
   end
-  
-  class Builder
+
+  class Builder #:nodoc:
     attr_reader :statemachine
     
     def initialize(statemachine)
@@ -29,54 +52,164 @@ module Statemachine
       return state
     end
   end
-  
+
+  # The builder module used to declare states.
   module StateBuilding
     attr_reader :subject
   
+    # Declares that the state responds to the spcified event.
+    # The +event+ paramter should be a Symbol.  
+    # The +destination_id+, which should also be a Symbol, is the id of the state 
+    # that will event will transition into.
+    # 
+    # The 3rd +action+ paramter is optional
+    #   
+    #   sm = Statemachine.build do
+    #     state :locked do
+    #       event :coin, :unlocked, :unlock
+    #     end
+    #   end
+    #   
     def event(event, destination_id, action = nil)
       @subject.add(Transition.new(@subject.id, destination_id, event, action))
     end
     
+    # Declare the entry action for the state.
+    #
+    #   sm = Statemachine.build do
+    #     state :locked do
+    #       on_entry :lock
+    #     end
+    #   end
+    #
     def on_entry(entry_action)
       @subject.entry_action = entry_action
     end
-    
+
+    # Declare the exit action for the state.
+    #
+    #   sm = Statemachine.build do
+    #     state :locked do
+    #       on_exit :unlock
+    #     end
+    #   end
+    #
     def on_exit(exit_action)
       @subject.exit_action = exit_action
     end
+    
+    # Declare a default transition for the state.  Any event that is not already handled
+    # by the state will be handled by this transition.
+    #
+    #   sm = Statemachine.build do
+    #     state :locked do
+    #       default :unlock, :action
+    #     end
+    #   end
+    #    
+    def default(destination_id, action = nil)
+      @subject.default_transition = Transition.new(@subject.id, destination_id, nil, action)
+    end
   end
   
+  # The builder module used to declare superstates.
   module SuperstateBuilding
     attr_reader :subject
-    
+   
+    # Define a state within the statemachine or superstate.
+    # 
+    #   sm = Statemachine.build do
+    #     state :locked do
+    #       #define the state
+    #     end
+    #   end
+    #
     def state(id, &block)
       builder = StateBuilder.new(id, @subject, @statemachine)
       builder.instance_eval(&block) if block
     end
-
+    
+    # Define a superstate within the statemachine or superstate.
+    # 
+    #   sm = Statemachine.build do
+    #     superstate :operational do
+    #       #define superstate
+    #     end
+    #   end
+    #
     def superstate(id, &block)
       builder = SuperstateBuilder.new(id, @subject, @statemachine)
       builder.instance_eval(&block)
     end
-
+    
+    # Declares a transition within the superstate or statemachine.  
+    # The +origin_id+, a Symbol, identifies the starting state for this transition.  The state 
+    # identified by +origin_id+ will be created within the statemachine or superstate which this
+    # transition is declared.   
+    # The +event+ paramter should be a Symbol.  
+    # The +destination_id+, which should also be a Symbol, is the id of the state that will 
+    # event will transition into.  This method will not create destination states within the 
+    # current statemachine of superstate.  If the state destination state should exist here,
+    # that declare with with the +state+ method or declare a transition starting at the state.
+    # 
+    #   sm = Statemachine.build do
+    #     trans :locked, :coin, :unlocked, :unlock
+    #   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
     
+    # Specifies the startstate for the statemachine or superstate.  The state must 
+    # exist within the scope.
+    # 
+    # sm = Statemachine.build do
+    #   startstate :locked
+    # end
+    #
     def startstate(startstate_id)
       @subject.startstate_id = startstate_id
     end
     
+    # Allows the declaration of entry actions without using the +state+ method.  +id+ is identifies
+    # the state to which the entry action will be added.
+    # 
+    #   sm = Statemachine.build do
+    #     trans :locked, :coin, :unlocked
+    #     on_entry_of :unlocked, :unlock
+    #   end
+    #
     def on_entry_of(id, action)
       @statemachine.get_state(id).entry_action = action
     end
     
+    # Allows the declaration of exit actions without using the +state+ method.  +id+ is identifies
+    # the state to which the exit action will be added.
+    # 
+    #   sm = Statemachine.build do
+    #     trans :locked, :coin, :unlocked
+    #     on_exit_of :locked, :unlock
+    #   end
+    #
     def on_exit_of(id, action)
       @statemachine.get_state(id).exit_action = action
     end
+    
+    # Used to specify the default state held by the history pseudo state of the superstate.  
+    # 
+    #   sm = Statemachine.build do
+    #     superstate :operational do
+    #       default_history :state_id
+    #     end
+    #   end
+    #
+    def default_history(id)
+      @subject.default_history = @statemachine.get_state(id)
+    end
   end
   
+  # Builder class used to define states. Creates by SuperstateBuilding#state
   class StateBuilder < Builder
     include StateBuilding
     
@@ -85,7 +218,8 @@ module Statemachine
       @subject = acquire_state_in(id, superstate)
     end
   end
-
+  
+  # Builder class used to define superstates. Creates by SuperstateBuilding#superstate
   class SuperstateBuilder < Builder
     include StateBuilding
     include SuperstateBuilding
@@ -98,6 +232,7 @@ module Statemachine
     end
   end
   
+  # Created by Statemachine.build as the root context for building the statemachine.
   class StatemachineBuilder < Builder
     include SuperstateBuilding
     
@@ -106,8 +241,17 @@ module Statemachine
       @subject = @statemachine.root
     end
     
+    # Used the set the context of the statemahine within the builder.
+    # 
+    #   sm = Statemachine.build do
+    #     ...
+    #     context MyContext.new
+    #   end
+    #
+    # Statemachine.context may also be used.
     def context(a_context)
       @statemachine.context = a_context
+      a_context.statemachine = @statemachine if a_context.respond_to?(:statemachine=)
     end
   end
   

data/lib/statemachine/state.rb

@@ -1,9 +1,9 @@
 module Statemachine
 
-  class State
+  class State #:nodoc:
     
     attr_reader :id, :statemachine, :superstate
-    attr_accessor :entry_action, :exit_action
+    attr_accessor :entry_action, :exit_action, :default_transition
 
     def initialize(id, superstate, state_machine)
       @id = id
@@ -20,13 +20,20 @@ module Statemachine
       return @superstate ? @transitions.merge(@superstate.transitions) : @transitions
     end
     
+    def transition_for(event)
+      transition = @transitions[event]
+      transition = @default_transition if not transition
+      transition = @superstate.transition_for(event) if @superstate and not transition
+      return transition 
+    end
+    
     def exit(args)
       @statemachine.trace("\texiting #{self}")
       @statemachine.invoke_action(@exit_action, args, "exit action for #{self}") if @exit_action
       @superstate.substate_exiting(self) if @superstate
     end
 
-    def enter(args)
+    def enter(args=[])
       @statemachine.trace("\tentering #{self}")
       @statemachine.invoke_action(@entry_action, args, "entry action for #{self}") if @entry_action
     end
@@ -38,6 +45,9 @@ module Statemachine
     def is_concrete?
       return true
     end
+    
+    def reset
+    end
 
     def to_s
       return "'#{id}' state"

data/lib/statemachine/{state_machine.rb → statemachine.rb}

@@ -3,34 +3,66 @@ module Statemachine
   class StatemachineException < 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 respons to the event, the appropriate transtion will be invoked.
+  # Otherwise an exception will be raised.
   class Statemachine
-    
     include ActionInvokation
   
-    attr_accessor :tracer, :context
-    attr_reader :root
+    # 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_accessor :context
+    
+    attr_reader :root #:nodoc:
   
+    # 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
       @state = get_state(@root.startstate_id)
       while @state and not @state.is_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 }
     end
     
+    # Return the id of the current state of the statemachine.
     def state
       return @state.id
     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
@@ -41,11 +73,16 @@ module Statemachine
       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
-        transition = @state.transitions[event]
+        transition = @state.transition_for(event)
         if transition
           transition.invoke(@state, self, args)
         else
@@ -56,11 +93,11 @@ module Statemachine
       end
     end
     
-    def trace(message)
+    def trace(message) #:nodoc:
       @tracer.puts message if @tracer
     end
     
-    def get_state(id)
+    def get_state(id) #:nodoc:
       if @states.has_key? id
         return @states[id]
       elsif(is_history_state_id?(id))
@@ -76,11 +113,11 @@ module Statemachine
       end
     end
     
-    def add_state(state)
+    def add_state(state) #:nodoc:
       @states[state.id] = state
     end
     
-    def has_state(id)
+    def has_state(id) #:nodoc:
       if(is_history_state_id?(id))
         return @states.has_key?(base_id(id))
       else
@@ -88,8 +125,8 @@ module Statemachine
       end
     end
     
-    def method_missing(message, *args)
-      if @state and @state.transitions[message]
+    def method_missing(message, *args) #:nodoc:
+      if @state and @state.transition_for(message)
         method = self.method(:process_event)
         params = [message.to_sym].concat(args)
         method.call(*params)

data/lib/statemachine/{super_state.rb → superstate.rb}

@@ -1,6 +1,6 @@
 module Statemachine
 
-  class Superstate < State
+  class Superstate < State #:nodoc:
   
     attr_accessor :startstate_id
     attr_reader :history
@@ -22,6 +22,14 @@ module Statemachine
     def add_substates(*substate_ids)
       do_substate_adding(substate_ids)
     end
+    
+    def default_history=(state)
+      @history = @default_history = state
+    end
+    
+    def reset
+      @history = @default_history
+    end
 
     def to_s
       return "'#{id}' superstate"

data/lib/statemachine/transition.rb

@@ -1,6 +1,6 @@
 module Statemachine
 
-  class Transition
+  class Transition #:nodoc:
     
     attr_reader :origin_id, :event, :action
     attr_accessor :destination_id

data/lib/statemachine/version.rb

@@ -1,8 +1,8 @@
 module Statemachine
-  module VERSION
+  module VERSION #:nodoc:
     unless defined? MAJOR
       MAJOR  = 0
-      MINOR  = 2
+      MINOR  = 3
       TINY   = 0
 
       STRING = [MAJOR, MINOR, TINY].join('.')

data/spec/builder_spec.rb

@@ -39,6 +39,7 @@ context "Builder" do
   end
 
   specify "Adding a superstate to the switch" do
+    the_context = self
     sm = Statemachine.build do
       superstate :operation do
         event :admin, :testing, lambda { @log << "testing" }
@@ -48,8 +49,8 @@ context "Builder" do
       end
       trans :testing, :resume, :operation, lambda { @log << "resuming" }
       startstate :off
+      context the_context
     end
-    sm.context = self
     
     sm.state.should_be :off
     sm.toggle
@@ -61,6 +62,7 @@ context "Builder" do
   end
   
   specify "entry exit actions" do
+    the_context = self
     sm = Statemachine.build do
       state :off do
         on_entry Proc.new { @log << "enter off" }
@@ -68,18 +70,19 @@ context "Builder" do
         on_exit Proc.new { @log << "exit off" }
       end
       trans :on, :toggle, :off, lambda { @log << "toggle off" } 
+      context the_context
     end
-    sm.context = self
 
     sm.toggle
     sm.state.should_be :on
     sm.toggle
     sm.state.should_be :off
 
-    @log.join(",").should_eql "exit off,toggle on,toggle off,enter off"
+    @log.join(",").should_eql "enter off,exit off,toggle on,toggle off,enter off"
   end
   
   specify "History state" do
+    the_context = self
     sm = Statemachine.build do
       superstate :operation do
         event :admin, :testing, lambda { @log << "testing" }
@@ -92,29 +95,30 @@ context "Builder" do
       end
       trans :testing, :resume, :operation_H, lambda { @log << "resuming" }
       startstate :off
+      context the_context
     end
-    sm.context = self
     
     sm.admin
     sm.resume
     sm.state.should_be :off
     
-    @log.join(",").should_eql "testing,resuming,enter off"
+    @log.join(",").should_eql "enter off,testing,resuming,enter off"
   end
 
   specify "entry and exit action created from superstate builder" do
+    the_context = self
     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" }
+      context the_context
     end
-    sm.context = self
     
     sm.toggle
     sm.toggle
     
-    @log.join(",").should_eql "toggle on,exiting on,toggle off,entering off"
+    @log.join(",").should_eql "entering off,toggle on,exiting on,toggle off,entering off"
     
   end
 
@@ -172,10 +176,22 @@ context "Builder" do
       context widget
     end
     
-    sm.context.should_be widget
+    sm.context.should be(widget)
   end
 
-  
+  specify "statemachine will be set on context if possible" do
+    class Widget
+      attr_accessor :statemachine
+    end
+    widget = Widget.new
+    
+    sm = Statemachine.build do
+      context widget
+    end
+    
+    sm.context.should be(widget)
+    widget.statemachine.should be(sm)
+  end
 
 end
 

data/spec/default_transition_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "Default Transition" do
+
+  setup do
+    @sm = Statemachine.build do
+      trans :default_state, :start, :test_state
+      
+      state :test_state do
+        default   :default_state
+      end
+    end
+  end
+  
+  specify "the default transition is set" do
+    test_state = @sm.get_state(:test_state)
+    test_state.default_transition.should_not be(nil)
+    test_state.transition_for(:fake_event).should_not be(nil)
+  end
+  
+  specify "Should go to the default_state with any event" do
+    @sm.start
+    @sm.fake_event
+    
+    @sm.state.should eql(:default_state)
+  end
+  
+  specify "default transition can have actions" do
+    me = self
+    @sm = Statemachine.build do
+      trans :default_state, :start, :test_state
+      
+      state :test_state do
+        default :default_state, :hi
+      end
+      context me
+    end
+    
+    @sm.start
+    @sm.blah
+    
+    @sm.state.should eql(:default_state)
+    @hi.should eql(true)
+  end
+  
+  def hi
+    @hi = true
+  end
+  
+  specify "superstate supports the default" do
+    @sm = Statemachine.build do
+      superstate :test_superstate do
+        default :default_state
+        
+        state :start_state
+        state :default_state
+      end
+      
+      startstate :start_state
+    end
+    
+    @sm.blah
+    @sm.state.should eql(:default_state)
+  end
+end

data/spec/history_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context "History States" do
+
+  setup do
+    @sm = Statemachine.build do
+      superstate :operate do
+        trans :on, :toggle, :off
+        trans :off, :toggle, :on
+        event :fiddle, :middle
+      end
+      trans :middle, :fiddle, :operate_H
+      trans :middle, :dream, :on_H
+      trans :middle, :faddle, :on
+      startstate :middle
+    end
+  end
+  
+  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.")
+  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.")
+  end
+  
+  specify "reseting the statemachine resets history" do
+    @sm.faddle
+    @sm.fiddle
+    @sm.get_state(:operate).history.id.should eql(:on)
+    
+    @sm.reset
+    @sm.get_state(:operate).history.should eql(nil)
+  end
+  
+end
+
+context "History Default" do
+  
+  setup do    
+    @sm = Statemachine.build do
+      superstate :operate do
+        trans :on, :toggle, :off
+        trans :off, :toggle, :on
+        event :fiddle, :middle
+        default_history :on
+      end
+      trans :middle, :fiddle, :operate_H
+      startstate :middle
+      trans :middle, :faddle, :on
+    end
+  end
+  
+  specify "default history" do
+    @sm.fiddle
+    @sm.state.should eql(:on)
+  end
+  
+  specify "reseting the statemachine resets history" do
+    @sm.faddle
+    @sm.toggle
+    @sm.fiddle
+    @sm.get_state(:operate).history.id.should eql(:off)
+    
+    @sm.reset
+    @sm.get_state(:operate).history.id.should eql(:on)
+  end
+
+end
+

data/spec/sm_entry_exit_actions_spec.rb

@@ -59,12 +59,12 @@ context "State Machine Entry and Exit Actions" do
     Statemachine.build(@sm) do
       superstate :off_super do
         on_exit Proc.new {@log << @sm.state}
-        trans :off, :toggle, :on, Proc.new { @log << "on" }
+        state :off
         event :toggle, :on, Proc.new { @log << "super_on" }
       end
       superstate :on_super do
         on_entry Proc.new { @log << @sm.state }
-        trans :on, :toggle, :off, Proc.new { @log << "off" }
+        state :on
         event :toggle, :off, Proc.new { @log << "super_off" }
       end
       startstate :off
@@ -83,6 +83,17 @@ context "State Machine Entry and Exit Actions" do
     @sm.state.should_be :off
   end
 
+  specify "startstate's entry action should be called when the statemachine starts" do
+    the_context = self
+    @sm = Statemachine.build do
+      trans :a, :b, :c
+      on_entry_of :a, Proc.new { @log << "entering a" }
+      context the_context
+    end
+    
+    @log.join(",").should eql("entering a")
+  end
+
   
   
 end

data/spec/sm_odds_n_ends_spec.rb

@@ -28,40 +28,15 @@ context "State Machine Odds And Ends" do
     @sm.state.should_be :on
   end
 
-end
-
-context "Special States" do
-
-  setup do
-    @sm = Statemachine.build do |s|
-      s.superstate :operate do |o|
-        o.trans :on, :toggle, :off
-        o.trans :off, :toggle, :on
-        o.event :fiddle, :middle
-      end
-      s.trans :middle, :fiddle, :operate_H
-      s.trans :middle, :push, :stuck
-      s.trans :middle, :dream, :on_H
-      s.startstate :middle
-    end
-  end
-  
   specify "states without transitions are valid" do
+    @sm = Statemachine.build do
+      trans :middle, :push, :stuck
+      startstate :middle
+    end
+    
     @sm.push
     @sm.state.should_be :stuck
   end
-  
-  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.")
-  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.")
-  end
 
 end
 

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.1
 specification_version: 1
 name: statemachine
 version: !ruby/object:Gem::Version 
-  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/
+  version: 0.3.0
+date: 2007-04-18 00:00:00 -05:00
+summary: Statemachine-0.3.0 - Statemachine Library for Ruby http://statemachine.rubyforge.org/
 require_paths: 
 - lib
 email: statemachine-devel@rubyforge.org
@@ -25,23 +25,27 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Micah Martin
 files: 
 - CHANGES
 - LICENSE
 - Rakefile
+- README
 - TODO
 - lib/statemachine.rb
 - lib/statemachine/action_invokation.rb
 - lib/statemachine/builder.rb
 - lib/statemachine/state.rb
-- lib/statemachine/state_machine.rb
-- lib/statemachine/super_state.rb
+- lib/statemachine/statemachine.rb
+- lib/statemachine/superstate.rb
 - lib/statemachine/transition.rb
 - lib/statemachine/version.rb
 - spec/action_invokation_spec.rb
 - spec/builder_spec.rb
+- spec/default_transition_spec.rb
+- spec/history_spec.rb
 - spec/sm_action_parameterization_spec.rb
 - spec/sm_entry_exit_actions_spec.rb
 - spec/sm_odds_n_ends_spec.rb
@@ -53,6 +57,8 @@ files:
 test_files: 
 - spec/action_invokation_spec.rb
 - spec/builder_spec.rb
+- spec/default_transition_spec.rb
+- spec/history_spec.rb
 - spec/sm_action_parameterization_spec.rb
 - spec/sm_entry_exit_actions_spec.rb
 - spec/sm_odds_n_ends_spec.rb