MINT-statemachine 1.2.2

data/spec/sm_simple_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "simple cases:" do
+  before(:each) do
+    @sm = Statemachine::Statemachine.new
+    @sm.context = self
+    @count = 0
+    @proc = Proc.new {@count = @count + 1}
+  end
+  
+  it "reset" do
+    Statemachine.build(@sm) { |s| s.trans :start, :blah, :end, @proc }
+    @sm.process_event(:blah)
+    
+    @sm.reset
+    
+    @sm.state.should equal(:start)
+  end
+
+  it "no proc in transition" do
+     Statemachine.build(@sm) { |s| s.trans :on, :flip, :off }
+    
+    @sm.flip
+  end
+  
+end

data/spec/sm_super_state_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Turn Stile" do
+  include TurnstileStatemachine
+  
+  before(:each) do
+    create_turnstile
+    
+    @out_out_order = false
+    
+    @sm = Statemachine.build do 
+      superstate :operative do
+        trans :locked, :coin, :unlocked, Proc.new { @locked = false;true}
+        trans :unlocked, :pass, :locked, Proc.new { @locked = true ;true}
+        trans :locked, :pass, :locked, Proc.new { @alarm_status = true ;true}
+        trans :unlocked, :coin, :locked, Proc.new { @thankyou_status = true ;true}
+        event :maintain, :maintenance, Proc.new { @out_of_order = true ;true}
+      end
+      trans :maintenance, :operate, :operative, Proc.new { @out_of_order = false;true } 
+      startstate :locked
+    end
+    @sm.context = self
+  end
+
+  it "substates respond to superstate transitions" do
+    @sm.process_event(:maintain)
+    @sm.state.should equal(:maintenance)
+    @locked.should equal(true)
+    @out_of_order.should equal(true)
+  end
+
+  it "after transitions, substates respond to superstate transitions" do
+    @sm.coin
+    @sm.maintain
+    @sm.state.should equal(:maintenance)
+    @locked.should equal(false)
+    @out_of_order.should equal(true)
+  end
+
+  it "states could be redefined as superstates" do
+    @sm = Statemachine.build @sm do
+      superstate :unlocked do
+        trans :u1, :u, :u2
+        trans :u2, :e, :maintenance
+      end
+    end   
+
+    @sm.coin
+    @sm.state.should equal(:u1)
+    @sm.u
+    @sm.state.should equal(:u2)
+    @sm.coin
+    @sm.state.should equal(:locked)
+  end
+end

data/spec/sm_turnstile_spec.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Turn Stile" do
+  include TurnstileStatemachine
+  
+  before(:each) do
+    create_turnstile
+  end
+  
+  it "connections" do
+    locked_state = @sm.get_state(:locked)
+    unlocked_state = @sm.get_state(:unlocked)
+    
+    locked_state.transitions.length.should equal(2)
+    unlocked_state.transitions.length.should equal(2)
+    
+    check_transition(locked_state.transitions[:coin], :locked, :unlocked, :coin, @unlock)
+    check_transition(locked_state.transitions[:pass], :locked, :locked, :pass, @alarm)
+    check_transition(unlocked_state.transitions[:pass], :unlocked, :locked, :pass, @lock)
+    check_transition(unlocked_state.transitions[:coin], :unlocked, :locked, :coin, @thankyou)
+  end
+  
+  it "start state" do
+    @sm.reset
+    @sm.startstate.should equal(:locked)
+    @sm.state.should equal(:locked)
+  end
+  
+  it "bad event" do
+    begin
+      @sm.process_event(:blah)
+      self.should.fail_with_message("Exception expected")
+    rescue Exception => e
+      e.class.should equal(Statemachine::TransitionMissingException)
+      e.to_s.should eql("'locked' state does not respond to the 'blah' event.")
+    end
+  end
+  
+  it "locked state with a coin" do
+    @sm.process_event(:coin)
+    
+    @sm.state.should equal(:unlocked)
+    @locked.should equal(false)
+  end
+  
+  it "locked state with pass event" do
+    @sm.process_event(:pass)
+    
+    @sm.state.should equal(:locked)
+    @locked.should equal(true)
+    @alarm_status.should equal(true)
+  end
+
+  it "unlocked state with coin" do
+    @sm.process_event(:coin)
+    @sm.process_event(:coin)
+    
+    @sm.state.should equal(:locked)
+    @thankyou_status.should equal(true)
+  end
+
+  it "unlocked state with pass event" do
+    @sm.process_event(:coin)
+    @sm.process_event(:pass)
+    
+    @sm.state.should equal(:locked)
+    @locked.should equal(true)
+  end
+
+  it "events invoked via method_missing" do
+    @sm.coin
+    @sm.state.should equal(:unlocked)
+    @sm.pass
+    @sm.state.should equal(:locked)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,121 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'rubygems'
+require 'spec'
+require 'statemachine'
+
+$IS_TEST = true
+
+def check_transition(transition, origin_id, destination_id, event, action)
+  transition.should_not equal(nil)
+  transition.event.should equal(event)
+  transition.origin_id.should equal(origin_id)
+  transition.destination_id.should equal(destination_id)
+  transition.action.should eql(action)
+end
+
+module SwitchStatemachine
+
+  def create_switch
+    @status = "off"
+    @sm = Statemachine.build do
+      trans :off, :toggle, :on, Proc.new { @status = "on" }
+      trans :on, :toggle, :off, Proc.new { @status = "off" }
+    end
+    @sm.context = self
+  end
+
+end
+
+module ParallelStatemachine
+
+  def create_parallel
+
+     @cooked = "false"
+     @out_of_order = false
+
+     @sm = Statemachine.build do
+      trans :start,:go,:p
+      state :maintenance
+      parallel :p do
+        statemachine :s1 do
+          superstate :operative do
+            trans :locked, :coin, :unlocked, Proc.new {  @cooked = true;true}
+            trans :unlocked, :coin, :locked
+            event :maintain, :maintenance, Proc.new { @out_of_order = true ;true}
+          end
+        end
+        statemachine :s2 do
+          superstate :onoff do
+            trans :on, :toggle, :off
+            trans :off, :toggle, :on
+          end
+        end
+      end
+    end
+    @sm.context = self
+  end
+
+  def create_tick
+    @status = "off"
+    @sm = Statemachine.build do
+      trans :off, :toggle, :on
+      trans :on, :toggle, :off
+      state :on do
+         on_entry Proc.new { @sm.toggle;true}
+      end
+
+    end
+    @sm.context = self
+  end
+
+   def create_tome
+    @sm = Statemachine.build do
+      trans :me, :toggle, :me
+    end
+    @sm.context = self
+  end
+end
+
+
+
+module TurnstileStatemachine
+
+  def create_turnstile
+    @locked = true
+    @alarm_status = false
+    @thankyou_status = false
+    @lock = "@locked = true;true"
+    @unlock = "@locked = false;true"
+    @alarm = "@alarm_status = true;true"
+    @thankyou = "@thankyou_status = true;true"
+
+    @sm = Statemachine.build do
+      trans :locked, :coin, :unlocked, "@locked = false;true"
+      trans :unlocked, :pass, :locked, "@locked = true;true"
+      trans :locked, :pass, :locked, "@alarm_status = true;true"
+      trans :unlocked, :coin, :locked, "@thankyou_status = true;true"
+    end
+    @sm.context = self
+  end
+
+end
+
+TEST_DIR = File.expand_path(File.dirname(__FILE__) + "/../test_dir/")
+
+def test_dir(name = nil)
+  Dir.mkdir(TEST_DIR) if !File.exist?(TEST_DIR)
+  return TEST_DIR if name.nil?
+  dir = File.join(TEST_DIR, name)
+  Dir.mkdir(dir) if !File.exist?(dir)
+  return dir
+end
+
+def remove_test_dir(name)
+  system "rm -rf #{test_dir(name)}" if File.exist?(test_dir(name))
+end
+
+def load_lines(*segs)
+  filename = File.join(*segs)
+  File.should exist( filename)
+  return IO.read(filename).split("\n")
+end

data/spec/transition_spec.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Transition Calculating Exits and Entries" do
+
+  before(:each) do
+    @transition = Statemachine::Transition.new(nil, nil, nil, nil, true)
+  end
+  
+  it "to nil" do
+    @a = Statemachine::State.new("a", nil, nil)
+    exits, entries = @transition.exits_and_entries(@a, nil)
+    exits.to_s.should eql([@a].to_s)
+    entries.to_s.should eql([].to_s)
+    entries.length.should equal(0)
+  end
+  
+  it "to itself" do
+    @a = Statemachine::State.new("a", nil, nil)
+    exits, entries = @transition.exits_and_entries(@a, @a)
+    exits.to_s.should eql([@a].to_s)
+    entries.to_s.should eql([@a].to_s)
+  end
+
+  it "to friend" do
+    @a = Statemachine::State.new("a", nil, nil)
+    @b = Statemachine::State.new("b", nil, nil)
+    exits, entries = @transition.exits_and_entries(@a, @b)
+    exits.to_s.should eql([@a].to_s)
+    entries.to_s.should eql([@b].to_s)
+  end
+
+  it "to parent" do
+    @b = Statemachine::State.new("b", nil, nil)
+    @a = Statemachine::State.new("a", @b, nil)
+    exits, entries = @transition.exits_and_entries(@a, @b)
+    exits.to_s.should eql([@a, @b].to_s)
+    entries.to_s.should eql([@b].to_s)
+  end
+
+  it "to uncle" do
+    @b = Statemachine::State.new("b", nil, nil)
+    @a = Statemachine::State.new("a", @b, nil)
+    @c = Statemachine::State.new("c", nil, nil)
+    exits, entries = @transition.exits_and_entries(@a, @c)
+    exits.to_s.should eql([@a, @b].to_s)
+    entries.to_s.should eql([@c].to_s)
+  end
+
+  it "to cousin" do
+    @b = Statemachine::State.new("b", nil, nil)
+    @d = Statemachine::State.new("d", nil, nil)
+    @a = Statemachine::State.new("a", @b, nil)
+    @c = Statemachine::State.new("c", @d, nil)
+    exits, entries = @transition.exits_and_entries(@a, @c)
+    exits.to_s.should eql([@a, @b].to_s)
+    entries.to_s.should eql([@d, @c].to_s)
+  end
+  
+  it "to nephew" do
+    @b = Statemachine::State.new("b", nil, nil)
+    @c = Statemachine::State.new("c", nil, nil)
+    @a = Statemachine::State.new("a", @b, nil)
+    exits, entries = @transition.exits_and_entries(@c, @a)
+    exits.to_s.should eql([@c].to_s)
+    entries.to_s.should eql([@b,@a].to_s)
+  end
+
+  it "to sister" do
+    @c = Statemachine::State.new("c", nil, nil)
+    @a = Statemachine::State.new("a", @c, nil)
+    @b = Statemachine::State.new("b", @c, nil)
+    exits, entries = @transition.exits_and_entries(@a, @b)
+    exits.to_s.should eql([@a].to_s)
+    entries.to_s.should eql([@b].to_s)
+  end
+  
+  it "to second cousin" do
+    @c = Statemachine::State.new("c", nil, nil)
+    @b = Statemachine::State.new("b", @c, nil)
+    @a = Statemachine::State.new("a", @b, nil)
+    @e = Statemachine::State.new("e", @c, nil)
+    @d = Statemachine::State.new("d", @e, nil)
+    exits, entries = @transition.exits_and_entries(@a, @d)
+    exits.to_s.should eql([@a, @b].to_s)
+    entries.to_s.should eql([@e, @d].to_s)
+  end
+
+  it "to grandparent" do
+    @c = Statemachine::State.new("c", nil, nil)
+    @b = Statemachine::State.new("b", @c, nil)
+    @a = Statemachine::State.new("a", @b, nil)
+    exits, entries = @transition.exits_and_entries(@a, @c)
+    exits.to_s.should eql([@a, @b, @c].to_s)
+    entries.to_s.should eql([@c].to_s)
+  end
+
+  it "to parent's grandchild" do
+    @c = Statemachine::State.new("c", nil, nil)
+    @b = Statemachine::State.new("b", @c, nil)
+    @a = Statemachine::State.new("a", @b, nil) 
+    @d = Statemachine::State.new("d", @c, nil)
+    exits, entries = @transition.exits_and_entries(@d, @a)
+    exits.to_s.should eql([@d].to_s)
+    entries.to_s.should eql([@b, @a].to_s)
+  end
+  
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: MINT-statemachine
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 1
+  - 2
+  - 2
+  version: 1.2.2
+platform: ruby
+authors: 
+- Sebastian Feuerstack
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-30 00:00:00 Z
+dependencies: []
+
+description: The MINT Statemachine is a ruby library for building Finite State Machines, based on the Statemachine gem by Micah Martin.
+email: Sebastian@Feuerstack.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.rdoc
+- MINT-statemachine.gemspec
+- CHANGES
+- TODO
+- LICENSE
+- lib/statemachine/generate/java/java_statemachine.rb
+- lib/statemachine/generate/src_builder.rb
+- lib/statemachine/generate/java.rb
+- lib/statemachine/generate/dot_graph.rb
+- lib/statemachine/generate/util.rb
+- lib/statemachine/generate/dot_graph/dot_graph_statemachine.rb
+- lib/statemachine/transition.rb
+- lib/statemachine/superstate.rb
+- lib/statemachine/version.rb
+- lib/statemachine/statemachine.rb
+- lib/statemachine/stub_context.rb
+- lib/statemachine/state.rb
+- lib/statemachine/parallelstate.rb
+- lib/statemachine/action_invokation.rb
+- lib/statemachine/builder.rb
+- lib/statemachine.rb
+- spec/sm_turnstile_spec.rb
+- spec/generate/java/java_statemachine_spec.rb
+- spec/generate/dot_graph/dot_graph_stagemachine_spec.rb
+- spec/sm_odds_n_ends_spec.rb
+- spec/noodle.rb
+- spec/sm_entry_exit_actions_spec.rb
+- spec/default_transition_spec.rb
+- spec/action_invokation_spec.rb
+- spec/sm_parallel_state_spec.rb
+- spec/builder_spec.rb
+- spec/sm_activation_spec.rb
+- spec/sm_super_state_spec.rb
+- spec/transition_spec.rb
+- spec/spec_helper.rb
+- spec/sm_simple_spec.rb
+- spec/sm_action_parameterization_spec.rb
+- spec/history_spec.rb
+homepage: http://www.multi-access.de
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: MINT-Statemachine-1.2.2 - Statemachine Library for Ruby based on statemachine from http://slagyr.github.com/statemachine http://www.multi-access.de/open-source-software/third-party-software-extensions/
+test_files: 
+- spec/sm_turnstile_spec.rb
+- spec/sm_odds_n_ends_spec.rb
+- spec/sm_entry_exit_actions_spec.rb
+- spec/default_transition_spec.rb
+- spec/action_invokation_spec.rb
+- spec/sm_parallel_state_spec.rb
+- spec/builder_spec.rb
+- spec/sm_activation_spec.rb
+- spec/sm_super_state_spec.rb
+- spec/transition_spec.rb
+- spec/sm_simple_spec.rb
+- spec/sm_action_parameterization_spec.rb
+- spec/history_spec.rb