MINT-statemachine 1.2.2 → 1.2.3

data/CHANGES

@@ -1,5 +1,9 @@
 = Statemachine Changelog
 
+== Version 1.2.3
+
+* Added Gemfile for bundler
+
 == Version 1.2.2
 
 * Transitions can fail

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+gem "rspec", "1.3.1"
+gem "rake","0.9.2"

data/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (0.9.2)
+    rspec (1.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (= 0.9.2)
+  rspec (= 1.3.1)

data/MINT-statemachine.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{MINT-statemachine}
-  s.version = "1.2.2"
+  s.version = "1.2.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Sebastian Feuerstack}]
@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://www.multi-access.de}
   s.require_paths = [%q{lib}]
   s.rubygems_version = %q{1.8.5}
-  s.summary = %q{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/}
+  s.summary = %q{MINT-Statemachine-1.2.3 - 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/}
   s.test_files = [%q{spec/sm_turnstile_spec.rb}, %q{spec/sm_odds_n_ends_spec.rb}, %q{spec/sm_entry_exit_actions_spec.rb}, %q{spec/default_transition_spec.rb}, %q{spec/action_invokation_spec.rb}, %q{spec/sm_parallel_state_spec.rb}, %q{spec/builder_spec.rb}, %q{spec/sm_activation_spec.rb}, %q{spec/sm_super_state_spec.rb}, %q{spec/transition_spec.rb}, %q{spec/sm_simple_spec.rb}, %q{spec/sm_action_parameterization_spec.rb}, %q{spec/history_spec.rb}]
 
   if s.respond_to? :specification_version then

data/lib/statemachine/action_invokation.rb

@@ -13,12 +13,19 @@ module Statemachine
         elsif a.is_a? Proc
           result = invoke_proc(a, args, message)
         elsif a.is_a? Array
-          result = send(a[0],a[1])
+          if a[0] == "log"
+            log("#{a[1]}")
+            result = invoke_string(a[1]) if not messenger
+          elsif a[0] == "send"
+            result = send(a[1],a[2])
+          elsif a[0] == 'invoke'
+            result = invoke_method(a[1],args, message)
+          end
         else
           log("#{a}")
-          result =invoke_string(a) if not messenger
+          result = invoke_string(a) if not messenger
         end
-        return false if result ==false
+        return false if result == false
        }
       result
     end
@@ -26,7 +33,11 @@ module Statemachine
     private
 
     def send(target,event)
-      @message_queue.send(target, event) if @message_queue
+      if @message_queue
+        @message_queue.send(target, event)
+        return true
+      end
+      false
     end
 
     def log(message)
@@ -39,6 +50,7 @@ module Statemachine
 
       parameters = params_for_block(method, args, message)
       method.call(*parameters)
+      return true
     end
 
     def invoke_proc(proc, args, message)
@@ -47,7 +59,11 @@ module Statemachine
     end
 
     def invoke_string(expression)
-      @context.instance_eval(expression)
+      if @context==nil
+        instance_eval(expression)
+      else
+        @context.instance_eval(expression)
+      end
     end
 
     def params_for_block(block, args, message)
@@ -56,7 +72,7 @@ module Statemachine
 
       raise StatemachineException.new("Insufficient parameters. (#{message})") if required_params > args.length
 
-      return arity < 0 ? args : args[0...arity]
+      arity < 0 ? args : args[0...arity]
     end
 
   end

data/lib/statemachine/builder.rb

@@ -256,13 +256,15 @@ module Statemachine
       super statemachine
       @subject = Superstate.new(id, superstate, statemachine)
       superstate.startstate_id = id if superstate.startstate_id == nil
-
       # small patch to support redefinition of already existing states without
       # loosing the already existing transformations. Used to overwrite states
       # with superstates.
-
+      if not statemachine.has_state(id)
+        statemachine.add_state(@subject)
+      end
       s = statemachine.get_state(id)
       if (s)
+        statemachine.remove_state(@subject)
         s.transitions.each {|k,v|
           @subject.add(v)
         }
@@ -320,6 +322,7 @@ module Statemachine
     def statemachine (id, &block)
       builder = StatemachineBuilder.new(Statemachine.new(@subject))
       #builder = StatemachineBuilder.new
+      builder.statemachine.is_parallel = @subject if @subject.is_a? Parallelstate
       builder.instance_eval(&block) if block
       if not @subject.is_a? Parallelstate
         # Only reset statemachine if it's the root one. Otherwise

data/lib/statemachine/parallelstate.rb

@@ -31,14 +31,8 @@ module Statemachine
     end
 
     def activate(terminal_state = nil)
-      @statemachine.state = self
-
-      @parallel_statemachines.each_with_index do |s,i|
-        s.activation = @statemachine.activation
-        s.reset(@startstate_ids[i])
-      end
       @parallel_statemachines.each do |s|
-        next if terminal_state and s.has_state(terminal_state)
+       # next if terminal_state and s.has_state(terminal_state)
         @statemachine.activation.call(s.state,self.abstract_states,self.states) if @statemachine.activation
       end
 
@@ -58,14 +52,13 @@ module Statemachine
       end
     end
 
-    def non_default_transition_for(event)
-      p "check parallel for #{event}"
+    def non_default_transition_for(event,check_superstates=true)
       transition = @transitions[event]
       return transition if transition
       
-      transition = transition_for(event)
+      transition = transition_for(event,check_superstates)
       
-      transition = @superstate.non_default_transition_for(event) if @superstate and not transition
+      transition = @superstate.non_default_transition_for(event) if check_superstates and @superstate and not transition
       return transition
     end
 
@@ -154,25 +147,42 @@ module Statemachine
     end
 
     def states
-      return @parallel_statemachines.map &:state
+      result =[]
+      @parallel_statemachines.each  do |s|
+        state = s.state
+        r,p = s.belongs_to_parallel(state)
+        if r
+          result += p.states
+        else
+          result << state
+        end
+      end
+      result
     end
 
-    def transition_for(event)
+    def transition_for(event,check_superstates=true)
       @parallel_statemachines.each do |s|
-       # puts "checke parallel #{s.id} for #{event}"
-        transition = s.get_state(s.state).non_default_transition_for(event)
+        transition = s.get_state(s.state).non_default_transition_for(event,false)
         transition = s.get_state(s.state).default_transition if not transition
         return transition if transition
       end
-      return @superstate.default_transition if @superstate
+      return @superstate.transition_for(event,check_superstates) if (@superstate and check_superstates and @superstate!=self)
 
-#      super.transition_for(event)
+      #super.transition_for(event)
     end
 
     def enter(args=[])
      # reset
-      super(args)
+      #super(args)
+        @statemachine.state = self
+
+      @parallel_statemachines.each_with_index do |s,i|
+        s.activation = @statemachine.activation
+        s.reset(@startstate_ids[i]) if not s.state
+        s.get_state(@startstate_ids[i]).enter(args)
+      end
     end
+
     def to_s
       return "'#{id}' parallel"
     end

data/lib/statemachine/state.rb

@@ -2,8 +2,8 @@ module Statemachine
 
   class State #:nodoc:
 
-    attr_reader :id, :statemachine
-    attr_accessor :entry_action, :exit_action, :superstate
+    attr_reader :statemachine
+    attr_accessor :id, :entry_action, :exit_action, :superstate
     attr_writer :default_transition
 
     def initialize(id, superstate, state_machine)
@@ -21,9 +21,9 @@ module Statemachine
       return @superstate ? @transitions.merge(@superstate.transitions) : @transitions
     end
 
-    def non_default_transition_for(event)
+    def non_default_transition_for(event,check_superstates = true)
       transition = @transitions[event]
-      if @superstate
+      if check_superstates and @superstate
         transition = @superstate.non_default_transition_for(event) if @superstate and @superstate.is_parallel == false and not transition
       end
       return transition
@@ -35,8 +35,8 @@ module Statemachine
       return nil
     end
 
-    def transition_for(event)
-      transition = non_default_transition_for(event)
+    def transition_for(event,check_superstate=true)
+      transition = non_default_transition_for(event,check_superstate)
       transition = default_transition if not transition
       return transition
     end
@@ -58,12 +58,11 @@ module Statemachine
 
     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
+     # 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?

data/lib/statemachine/statemachine.rb

@@ -78,7 +78,8 @@ module Statemachine
 
     #Return the id of the current state of the statemachine.
     def state
-      return @state.id
+      return @state.id if @state
+      nil
     end
 
     # returns an array with the ids of the current active states of the machine.
@@ -143,10 +144,8 @@ module Statemachine
         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
+          if transition.cond!=true
+             cond = @state.statemachine.invoke_action(transition.cond, [], "condition from #{@state} invoked by '#{event}' event", nil, nil)
           end
           if cond
             transition.invoke(@state, self, args)
@@ -183,17 +182,28 @@ module Statemachine
     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]
+        if @is_parallel
+          superstate = @is_parallel.get_state(superstate_id)
+        else
+          superstate = @states[superstate_id]
+        end
         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)
+      elsif @is_parallel
+        isp = @is_parallel
+        @is_parallel = nil
+        if isp.has_state(id)
+          state = isp.get_state(id)
+        elsif state = isp.statemachine.get_state(id)
+          @is_parallel = isp
+          return @is_parallel.statemachine.states[id] if @is_parallel.statemachine.states[id]
+        end
+        @is_parallel = isp
+        return state
+      elsif p = get_parallel and s = p.get_state(id)
+        return s
       else
         state = State.new(id, @root, self)
         @states[id] = state
@@ -264,7 +274,7 @@ module Statemachine
 
     def load_history(superstate)
       100.times do
-        history = superstate.history_id ? get_state(superstate.history_id) : nil
+        history = superstate.history_id ? get_state(superstate.history_id) :  get_state(superstate.startstate_id) #nil
         raise StatemachineException.new("#{superstate} doesn't have any history yet.") if not history
         if history.concrete?
           return history

data/lib/statemachine/transition.rb

@@ -23,18 +23,19 @@ module Statemachine
        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) }
+      entries.each { |entered_state| entered_state.activate(terminal_state.id)  if entered_state.is_parallel }
+      statemachine.state = terminal_state if statemachine.has_state(terminal_state.id) and statemachine.is_parallel
+
     end
 
     def exits_and_entries(origin, destination)

data/lib/statemachine/version.rb

@@ -3,7 +3,7 @@ module Statemachine
     unless defined? MAJOR
       MAJOR  = 1
       MINOR  = 2
-      TINY   = 2
+      TINY   = 3
 
       STRING = [MAJOR, MINOR, TINY].join('.')
       TAG    = "REL_" + [MAJOR, MINOR, TINY].join('_')
@@ -14,4 +14,4 @@ module Statemachine
       DESCRIPTION = "#{NAME}-#{STRING} - Statemachine Library for Ruby based on statemachine from http://slagyr.github.com/statemachine\n#{URL}"
     end
   end
-end
+end

data/spec/history_spec.rb

@@ -22,11 +22,14 @@ describe "History States" do
       }.should raise_error(Statemachine::StatemachineException, "No history exists for 'on' state since it is not a super state.")
   end
 
+  # This behaviour was changed
+=begin
   it "error when trying to use history that doesn't exist yet" do
     lambda {
       @sm.fiddle
       }.should raise_error(Statemachine::StatemachineException, "'operate' superstate doesn't have any history yet.")
   end
+=end
   
   it "reseting the statemachine resets history" do
     @sm.faddle

data/spec/sm_activation_spec.rb

@@ -87,7 +87,7 @@ describe "State Activation Callback" do
     @callback.abstract_states.last.should == [:root]
   end
 
-  it "should activate corretly on direct entry to parallel state" do
+  it "should activate correctly on direct entry to parallel state" do
     @sm = Statemachine.build do
       trans :start,:go, :unlocked
       parallel :p do

data/spec/sm_parallel_state_spec.rb

@@ -112,7 +112,7 @@ describe "Nested parallel" do
         parallel :p do
           statemachine :s1 do
             superstate :operative do
-              trans :locked, :coin, :unlocked, Proc.new {  @cooked = true }
+              trans :locked, :coin, :unlocked, Proc.new {  @cooked = true }, "In(:on)"
               trans :unlocked, :coin, :locked
               event :maintain, :maintenance, Proc.new { @out_of_order = true }
             end
@@ -128,8 +128,10 @@ describe "Nested parallel" do
     end
 
     @sm.go
-    @sm.states.should.eql? [:locked,:off]
-
+    @sm.states_id.should == [:locked,:on]
+    @sm.toggle
+    @sm.states_id.should == [:locked,:off]
+    @sm.coin
   end
 
   it "should support direct transitions into an atomic state of a parallel state set" do
@@ -156,15 +158,14 @@ describe "Nested parallel" do
     end
 
     @sm.go
-    @sm.state.should eql :p
+    @sm.state.should == :p
     @sm.states_id.should == [:unlocked,:on]
     @sm.maintain
-    @sm.state.should eql :maintenance
+    @sm.state.should == :maintenance
     @sm.states_id.should == [:maintenance]
   end
 
   it "should support leaving a parallel state by an event from a super state of the parallel state" do
-    pending ("superstates have problems with late defined events ")
     @sm = Statemachine.build do
       trans :start,:go, :unlocked
       state :maintenance
@@ -184,7 +185,7 @@ describe "Nested parallel" do
             end
           end
         end
-        event :repair, :maintenance # this one does not work, event has to be defined directly after superstate definition!
+        event :repair, :maintenance
       end
     end
 
@@ -203,5 +204,51 @@ describe "Nested parallel" do
   end
 
 
+it "should support entering a nested parallel states" do
+    @sm = Statemachine.build do
+      trans :start,:go, :unlocked
+      state :maintenance
+      superstate :test do
+        superstate :s do
+          event :m, :maintenance
+          parallel :p do
+            statemachine :s1 do
+                trans :locked, :coin, :unlocked, Proc.new {  @cooked = true }
+                trans :unlocked, :coin, :locked
+            end
+            statemachine :s2 do
+              #superstate :r2 do
+                parallel :p2 do
+                  statemachine :s21 do
+                    superstate :onoff do
+                      trans :on, :toggle, :off
+                      trans :off, :toggle, :on
+                    end
+                  end
+                  statemachine :s22 do
+                    superstate :onoff2 do
+                      trans :on2, :toggle2, :off2
+                      trans :off2, :toggle2, :on2
+                      end
+                  end
+                end
+              #end
+            end
+          end
+        end
+        event :repair, :maintenance
+      end
+    end
+
+    @sm.go
+    @sm.state.should eql :p
+    @sm.states_id.should == [:unlocked,:on,:on2]
+    @sm.toggle2
+    @sm.states_id.should == [:unlocked,:on,:off2]
+    @sm.repair
+    @sm.state.should eql :maintenance
+    @sm.states_id.should == [:maintenance]
+  end
+
 
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'rubygems'
+require "bundler/setup"
 require 'spec'
 require 'statemachine'
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: MINT-statemachine
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 1
   - 2
-  - 2
-  version: 1.2.2
+  - 3
+  version: 1.2.3
 platform: ruby
 authors: 
 - Sebastian Feuerstack
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-30 00:00:00 Z
+date: 2011-11-01 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.
@@ -27,9 +27,11 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- Gemfile
 - Rakefile
 - README.rdoc
 - MINT-statemachine.gemspec
+- Gemfile.lock
 - CHANGES
 - TODO
 - LICENSE
@@ -98,7 +100,7 @@ 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/
+summary: MINT-Statemachine-1.2.3 - 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