MINT-statemachine 1.2.2

data/lib/statemachine/transition.rb

@@ -0,0 +1,76 @@
+module Statemachine
+
+  class Transition #:nodoc:
+
+    attr_reader :origin_id, :event, :action
+    attr_accessor :destination_id, :cond
+
+    def initialize(origin_id, destination_id, event, action, cond)
+      @origin_id = origin_id
+      @destination_id = destination_id
+      @event = event
+      @action = action
+      @cond = cond
+    end
+
+    def invoke(origin, statemachine, args)
+      destination = statemachine.get_state(@destination_id)
+      exits, entries = exits_and_entries(origin, destination)
+      exits.each { |exited_state| exited_state.exit(args) }
+      messenger = origin.statemachine.messenger
+      message_queue = origin.statemachine.message_queue
+
+       if @action # changed this if statement to return if action fails
+        if not origin.statemachine.invoke_action(@action, args, "transition action from #{origin} invoked by '#{@event}' event", messenger, message_queue)
+          raise StatemachineException.new("Transition to state #{destination.id} failed because action for event #{@event} return false.")
+          return
+        end
+      end
+
+#      origin.statemachine.invoke_action(@action, args, "transition action from #{origin} invoked by '#{@event}' event", messenger, message_queue) if @action
+
+      terminal_state = entries.last
+      entries.each { |entered_state| entered_state.activate(terminal_state.id) if entered_state.is_parallel }
+
+      terminal_state.activate if terminal_state and not terminal_state.is_parallel
+
+      entries.each { |entered_state| entered_state.enter(args) }
+    end
+
+    def exits_and_entries(origin, destination)
+     # return [], [] if origin == destination
+      exits = []
+      entries = exits_and_entries_helper(exits, origin, destination)
+      return exits, entries.reverse
+    end
+
+    def to_s
+      return "#{@origin_id} ---#{@event}---> #{@destination_id} : #{action} if #{cond}"
+    end
+
+    private
+
+    def exits_and_entries_helper(exits, exit_state, destination)
+      entries = entries_to_destination(exit_state, destination)
+      return entries if entries
+      return [] if exit_state == nil
+
+      exits << exit_state
+      exits_and_entries_helper(exits, exit_state.superstate, destination)
+    end
+
+    def entries_to_destination(exit_state, destination)
+      return nil if destination.nil?
+      entries = []
+      state = destination.resolve_startstate
+      while state
+        entries << state
+        return entries if exit_state == state.superstate
+        state = state.superstate
+      end
+      return nil
+    end
+
+  end
+
+end

data/lib/statemachine/version.rb

@@ -0,0 +1,17 @@
+module Statemachine
+  module VERSION #:nodoc:
+    unless defined? MAJOR
+      MAJOR  = 1
+      MINOR  = 2
+      TINY   = 2
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+      TAG    = "REL_" + [MAJOR, MINOR, TINY].join('_')
+
+      NAME   = "MINT-Statemachine"
+      URL    = "http://www.multi-access.de/open-source-software/third-party-software-extensions/"  
+    
+      DESCRIPTION = "#{NAME}-#{STRING} - Statemachine Library for Ruby based on statemachine from http://slagyr.github.com/statemachine\n#{URL}"
+    end
+  end
+end

data/spec/action_invokation_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/spec_helper'
+#require 'statemachine'
+#require 'lib/statemachine/action_invokation.rb'
+require "noodle"
+
+describe "Action Invokation" do
+
+  before(:each) do
+    @noodle = Noodle.new
+  end
+  
+  it "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 equal(true)
+  end
+  
+  it "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 equal(true)
+    
+    sm.mold "capellini"
+    
+    @noodle.shape.should eql("capellini")
+  end
+
+  it "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 equal(true)
+  end
+
+  it "Multiple Proc actions" do
+    sm = Statemachine.build do |smb|
+      smb.trans :cold, :fire, :hot, [Proc.new { @cooked = true }, Proc.new { @tasty = true }]
+    end
+
+    sm.context = @noodle
+    sm.fire
+
+    @noodle.cooked.should equal(true)
+    @noodle.tasty.should equal(true)
+  end
+
+  it "Multiple Symbol actions" do
+    sm = Statemachine.build do |smb|
+      smb.trans :cold, :fire, :hot, [:cook, :good]
+    end
+
+    sm.context = @noodle
+    sm.fire
+
+    @noodle.cooked.should equal(true)
+    @noodle.tasty.should equal(true)
+  end
+
+  it "Multiple actions" do
+    sm = Statemachine.build do |smb|
+      smb.trans :cold, :fire, :hot, [:cook, Proc.new { @tasty = true }, "@shape = 'fettucini'"]
+    end
+
+    sm.context = @noodle
+    sm.fire
+
+    @noodle.cooked.should equal(true)
+    @noodle.tasty.should equal(true)
+    @noodle.shape.should eql("fettucini")
+  end
+
+  it "No actions" do
+    sm = Statemachine.build do |smb|
+      smb.trans :cold, :fire, :hot
+    end
+
+    sm.context = @noodle
+    sm.fire
+
+    @noodle.cooked.should == false
+    @noodle.tasty.should == false
+    @noodle.shape.should =="farfalla"
+  end
+
+
+end

data/spec/builder_spec.rb

@@ -0,0 +1,243 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Builder" do
+
+  before(:each) do
+    @log = []
+  end
+
+  def check_switch(sm)
+    sm.state.should equal(:off)
+    
+    sm.toggle
+    @log[0].should eql("toggle on")
+    sm.state.should equal(:on)
+    
+    sm.toggle
+    @log[1].should eql("toggle off")
+    sm.state.should equal(:off)
+  end
+
+  it "Building a the switch, relaxed" do
+    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
+
+  it "Building a the switch, strict" do
+    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
+
+  it "Adding a superstate to the switch" do
+    the_context = self
+    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
+      trans :testing, :resume, :operation, lambda { @log << "resuming" }
+      startstate :off
+      context the_context
+    end
+    
+    sm.state.should equal(:off)
+    sm.toggle
+    sm.admin
+    sm.state.should equal(:testing)
+    sm.resume
+    sm.state.should equal(:on)
+    @log.join(",").should eql("toggle on,testing,resuming")
+  end
+  
+  it "entry exit actions" do
+    the_context = self
+    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
+      trans :on, :toggle, :off, lambda { @log << "toggle off" } 
+      context the_context
+    end
+
+    sm.toggle
+    sm.state.should equal(:on)
+    sm.toggle
+    sm.state.should equal(:off)
+
+    @log.join(",").should eql("enter off,exit off,toggle on,toggle off,enter off")
+  end
+  
+  it "History state" do
+    the_context = self
+    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
+        trans :on, :toggle, :off, lambda { @log << "toggle off" }
+        startstate :on
+      end
+      trans :testing, :resume, :operation_H, lambda { @log << "resuming" }
+      startstate :off
+      context the_context
+    end
+    
+    sm.admin
+    sm.resume
+    sm.state.should equal(:off)
+    
+    @log.join(",").should eql("enter off,testing,resuming,enter off")
+  end
+
+  it "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.toggle
+    sm.toggle
+    
+    @log.join(",").should eql("entering off,toggle on,exiting on,toggle off,entering off")
+    
+  end
+
+  it "superstate as startstate" do
+    
+    lambda do 
+      sm = Statemachine.build do
+        superstate :mario_bros do
+          trans :luigi, :bother, :mario
+        end
+      end
+      
+      sm.state.should equal(:luigi)
+    end.should_not raise_error(Exception)
+  end
+  
+  it "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 equal(:right)
+    sm.pull
+    sm.state.should equal(:middle)
+  end
+  
+  it "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 equal(:right)
+    sm.pull
+    sm.state.should equal(:middle)
+    sm.push
+    sm.state.should equal(:right)
+    sm.tilt
+    sm.state.should equal(:floor)
+  end
+  
+  it "can set context" do
+    widget = Object.new
+    sm = Statemachine.build do
+      context widget
+    end
+    
+    sm.context.should be(widget)
+  end
+
+  it "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
+
+  it "should have an on_event" do
+    sm = Statemachine.build do
+      startstate :start 
+      state :start do
+        on_event :go, :transition_to => :new_state
+      end
+    end
+    sm.go
+    sm.state.should == :new_state
+  end
+  
+  it "should trigger actions using on_event" do
+    sm = Statemachine.build do
+      startstate :start
+      state :start do
+        on_event :go, :transition_to => :new_state, :and_perform => :action
+      end
+    end
+    object = mock("context")
+    object.stub(:action) { true }
+    sm.context = object
+    object.should_receive(:action)
+
+    sm.go
+  end
+  
+  it "should have a transition_from" do
+    sm = Statemachine.build do
+      transition_from :start, :on_event => :go, :transition_to => :new_state
+    end
+    
+    sm.go
+    sm.state.should == :new_state
+  end
+  
+  it "should trigger actions on transition_from" do
+    sm = Statemachine.build do
+      transition_from :start, :on_event => :go, :transition_to => :new_state, :and_perform => :action
+    end
+    object = mock("context")
+    object.stub(:action) { true }
+    sm.context = object
+    object.should_receive(:action)
+
+    sm.go
+  end
+end
+

data/spec/default_transition_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Default Transition" do
+
+  before(:each) do
+    @sm = Statemachine.build do
+      trans :default_state, :start, :test_state
+      
+      state :test_state do
+        default   :default_state
+      end
+    end
+  end
+  
+  it "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
+  
+  it "Should go to the default_state with any event" do
+    @sm.start
+    @sm.fake_event
+    
+    @sm.state.should eql(:default_state)
+  end
+  
+  it "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
+  
+  it "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
+  
+  it "superstate transitions do not go to the default state" do
+    @sm = Statemachine.build do
+      superstate :test_superstate do
+        event :not_default, :not_default_state
+        
+        state :start_state do 
+          default :default_state
+        end
+        
+        state :default_state
+      end
+      
+      startstate :start_state
+    end
+    
+    @sm.state = :start_state
+    @sm.not_default
+    @sm.state.should eql(:not_default_state)
+  end
+
+  it "should use not use superstate's default before using it's own default" do
+    @sm = Statemachine.build do
+      superstate :super do
+        default :super_default
+        state :base do
+          default :base_default
+        end
+      end
+      state :super_default
+      state :base_default
+      startstate :base
+    end
+    
+    @sm.blah
+    @sm.state.should eql(:base_default)
+  end
+
+  it "should be marshalable" do
+    dump = Marshal.dump(@sm)
+    loaded = Marshal.load(dump)
+    loaded.state.should eql(:default_state)
+  end
+
+  
+  
+end