MINT-scxml 1.0.0

data/statemachines/aui/AIOUTContinous.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'statemachine'
+
+module MINT
+   class AIOUTContinous
+     def initialize_statemachine
+       if @statemachine.blank?
+         @statemachine = Statemachine.build do
+            superstate :AIOUTContinous do
+              trans :initialized, :organize, :organized
+              trans :organized, :present, :presenting
+              trans :suspended, :organize, :organized
+
+              superstate :presenting do
+                event :suspend, :suspended
+
+                trans :defocused, :focus, :focused
+                trans :defocused, :next, :focused, :focus_next
+                trans :defocused, :prev, :focused, :focus_prev
+                trans :defocused, :parent, :focused, :focus_parent
+
+                superstate :focused do
+                  event :defocus, :defocused
+
+                  trans :waiting, :progress, :progressing
+                  trans :waiting, :regress, :regressing
+
+                  superstate :moving do
+                    event :halt, :waiting
+
+                    trans :progressing, :regress, :regressing
+                    trans :regressing, :progress, :progressing
+                  end
+                end
+              end
+            end
+         end
+       end
+     end
+   end
+end

data/statemachines/aui/AISingleChoice.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'statemachine'
+
+module MINT
+   class AISingleChoice
+     def initialize_statemachine
+       if @statemachine.blank?
+         @statemachine = Statemachine.build do
+            superstate :AISingleChoice do
+              trans :initialized, :organize, :organized
+              trans :organized, :present, :presenting
+              trans :suspended, :organize, :organized
+
+              superstate :presenting do
+                event :suspend, :suspended
+
+                parallel :p do
+                  statemachine :s1 do
+                    trans :listing, :drop, :dropped, :drop_all_dragging, In(:focused)
+                    # TODO how to implement transitions without events
+                    # trans :dropped, nil , :listing, :unfocus_self
+                  end
+                  statemachine :s2 do
+                    superstate :presentingAIC do
+                      event :suspend, :suspended
+
+                      trans :defocused, :focus, :focused
+                      trans :defocused, :next, :focused, :focus_next
+                      trans :defocused, :prev, :focused, :focus_prev
+                      trans :defocused, :parent, :focused, :focus_parent
+                      trans :defocused, :child, :focused, :focus_child
+                      trans :focused, :defocus, :defocused
+                    end
+                  end
+                end
+              end
+            end
+         end
+       end
+     end
+   end
+end

data/statemachines/aui/AISingleChoiceElement.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'statemachine'
+
+module MINT
+   class AISingleChoiceElement
+     def initialize_statemachine
+       if @statemachine.blank?
+         @statemachine = Statemachine.build do
+            superstate :AISingleChoiceElement do
+              trans :initialized, :organize, :organized
+              trans :organized, :present, :presenting_H
+              trans :suspended, :organize, :organized
+
+              superstate :presenting do
+                event :suspend, :suspended
+
+                parallel :p do
+                  statemachine :s1 do
+                    superstate :selection do
+                      trans :unchosen, :choose, :chosen, :all_unchoose, In(:focused)
+                      trans :chosen, :unchoose, :unchosen
+                    end
+                  end
+                  statemachine :s2 do
+                    superstate :presentingAIChoiceElement do
+                      event :suspend, :suspended
+
+                      trans :defocused, :focus, :focused
+                      trans :defocused, :next, :focused, :focus_next
+                      trans :defocused, :prev, :focused, :focus_prev
+                      trans :defocused, :parent, :focused, :focus_parent
+                      trans :focused, :defocus, :defocused
+                      trans :focused, :drag, :dragging, :self_choose, In(:unchosen)
+                      trans :focused, :drag, :dragging, nil, In(:chosen)
+                      trans :dragging, :drop, :defocused
+                    end
+                  end
+                end
+              end
+            end
+         end
+       end
+     end
+   end
+end

data/statemachines/aui/aio.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'statemachine'
+
+module MINT
+   class AIO
+     def initialize_statemachine
+       if @statemachine.blank?
+         @statemachine = Statemachine.build do
+            superstate :AIO do
+              trans :initialized, :organize, :organized
+              trans :organized, :present, :presenting
+              trans :suspended, :organize, :organized
+
+              superstate :presenting do
+                event :suspend, :suspended
+
+                trans :defocused, :focus, :focused
+                trans :defocused, :next, :focused, :focus_next
+                trans :defocused, :prev, :focused, :focus_prev
+                trans :defocused, :parent, :focused, :focus_parent
+                trans :focused, :defocus, :defocused
+              end
+            end
+         end
+       end
+     end
+   end
+end

data/statemachines/specs/AICommand_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "AICommand" do
+  before (:each) do
+    @statemachine = Statemachine.build do
+        superstate :AICommand do
+          trans :initialized, :organize, :organized
+          trans :organized, :present, :presenting
+          trans :suspended, :organize, :organized
+
+          superstate :presenting do
+             event :suspend, :suspended
+
+             trans :defocused, :focus, :focused_H
+             trans :defocused, :next, :focused_H#, :focus_next
+             trans :defocused, :prev, :focused_H#, :focus_prev
+             trans :defocused, :parent, :focused_H#, :focus_parent
+
+             superstate :focused do
+               event :defocus, :defocused
+
+               trans :deactivated, :activate, :activated
+               trans :activated, :deactivate, :deactivated
+             end
+          end
+         end
+    end
+  end
+
+  it "should enter the nested superstate :focused" do
+      @statemachine.organize
+      @statemachine.present
+      @statemachine.focus
+      @statemachine.state.should == :deactivated
+  end
+
+  it "should support transitions inside :focused" do
+      @statemachine.organize
+      @statemachine.present
+      @statemachine.focus
+      @statemachine.activate
+      @statemachine.state.should == :activated
+      @statemachine.deactivate
+      @statemachine.state.should == :deactivated
+  end
+
+  it "should leave the superstate :focused and return to the same point it left" do
+      @statemachine.organize
+      @statemachine.present
+      @statemachine.focus
+      @statemachine.activate
+      @statemachine.state.should == :activated
+      @statemachine.defocus
+      @statemachine.state.should == :defocused
+      @statemachine.focus
+      @statemachine.state.should == :activated
+  end
+end

data/statemachines/specs/AIINContinous_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "AIINContinous" do
+  before (:each) do
+    @statemachine = Statemachine.build do
+      superstate :AIINContinous do
+        trans :initialized, :organize, :organized
+        trans :organized, :present, :presenting
+        trans :suspended, :organize, :organized
+
+        superstate :presenting do
+          event :suspend, :suspended
+
+          trans :defocused, :focus, :focused
+          trans :defocused, :next, :focused, :focus_next
+          trans :defocused, :prev, :focused, :focus_prev
+          trans :defocused, :parent, :focused, :focus_parent
+
+          superstate :focused do
+            event :defocus, :defocused
+
+            # TODO how to implement the sensitivity condition?
+            trans :waiting, :decrease, :decreasing#, nil, (x1<x0-sensitivy)
+            trans :waiting, :increase, :increasing#, nil, (x1>x0-sensitivy)
+            trans :increasing, :decrease, :decreasing#, nil, (x1<x0-sensitivy)
+            trans :decreasing, :increase, :increasing#, nil, (x1>x0-sensitivy)
+
+            # TODO how to implement transitions without events
+            #trans :decreasing, nil, :waiting, nil, (Dt>tmax)
+            #trans :increasing, nil, :waiting, nil, (Dt>tmax)
+          end
+         end
+      end
+    end
+  end
+
+
+  it "should enter the nested superstate :focused" do
+      @statemachine.organize
+      @statemachine.present
+      @statemachine.focus
+      @statemachine.state.should == :waiting
+  end
+
+  it "should support transitions inside :focused" do
+      @statemachine.organize
+      @statemachine.present
+      @statemachine.focus
+      @statemachine.increase
+      @statemachine.state.should == :increasing
+      @statemachine.decrease
+      @statemachine.state.should == :decreasing
+  end
+
+  #TODO implement test for spontaneous transitions
+=begin
+  it "should support spontaneous transitions" do
+  end
+=end
+
+end

data/statemachines/specs/AIMultiChoiceElement_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "AIMultiChoiceElement" do
+  before (:each) do
+    @statemachine = Statemachine.build do
+      superstate :AIMultiChoiceElement do
+        trans :initialized, :organize, :organized
+        trans :organized, :present, :presenting_H
+        trans :suspended, :organize, :organized
+
+        superstate :presenting do
+          event :suspend, :suspended
+          parallel :p do
+            statemachine :s1 do
+              superstate :selection do
+                # TODO make In() work
+                trans :unchosen, :choose, :chosen#, nil, In(:focused)
+                trans :chosen, :unchoose, :unchosen
+              end
+            end
+            statemachine :s2 do
+              superstate :presentingAIChoiceElement do
+                event :suspend, :suspended
+
+                trans :defocused, :focus, :focused
+                trans :defocused, :next, :focused, :focus_next
+                trans :defocused, :prev, :focused, :focus_prev
+                trans :defocused, :parent, :focused, :focus_parent
+                trans :focused, :defocus, :defocused
+                #would the implementation of "if" be like this?
+                # TODO make In() work
+                trans :focused, :drag, :dragging#, :self_choose, In(:unchosen)
+                trans :focused, :drag, :dragging#, nil, In(:chosen)
+                trans :dragging, :drop, :defocused
+              end
+            end
+          end
+        end
+      end
+   end
+  end
+
+  it "should enter :presenting" do
+    @statemachine.organize
+    @statemachine.present
+    @statemachine.states_id.should == [:unchosen, :defocused]
+  end
+
+    it "should support parallel transitions" do
+    @statemachine.organize
+    @statemachine.present
+    @statemachine.focus
+    @statemachine.choose
+    @statemachine.states_id.should == [:chosen, :focused]
+  end
+
+  it "should leave :presenting and return to the proper states" do
+    @statemachine.organize
+    @statemachine.present
+    @statemachine.focus
+    @statemachine.choose
+    @statemachine.states_id.should == [:chosen, :focused]
+    @statemachine.suspend
+    @statemachine.state.should == :suspended
+    @statemachine.organize
+    @statemachine.present
+  end
+
+  #TODO implement test to check if In() is working
+end

data/statemachines/specs/AIMultiChoice_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "AIMultiChoice" do
+  before (:each) do
+    @statemachine = Statemachine.build do
+      superstate :AIMultiChoice do
+        trans :initialized, :organize, :organized
+        trans :organized, :present, :presenting
+        trans :suspended, :organize, :organized
+
+        superstate :presenting do
+          event :suspend, :suspended
+            parallel :p do
+              statemachine :s1 do
+                # TODO make In() work
+                trans :listing, :drop, :dropped#, nil, In(:focused)#, :drop_all_dragging, In(:focused)
+                trans :listing, :choose_all, :choosing
+                trans :listing, :unchoose_all, :unchoosing
+                # TODO how to implement transitions without events
+                # trans :dropped, nil, :listing, :unfocus_self
+                # trans :choosing, nil, :listing, :choose_all_childs
+                # trans :unchoosing, nil, :listing, :unchoose_all_childs
+              end
+              statemachine :s2 do
+                superstate :presentingAIC do
+                  event :suspend, :suspended
+
+                  trans :defocused, :focus, :focused
+                  trans :defocused, :next, :focused#, :focus_next
+                  trans :defocused, :prev, :focused#, :focus_prev
+                  trans :defocused, :parent, :focused#, :focus_parent
+                  trans :defocused, :child, :focused#, :focus_child
+                  trans :focused, :defocus, :defocused
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+  it "should support parallel transitions" do
+    @statemachine.organize
+    @statemachine.present
+    @statemachine.states_id.should == [:listing, :defocused]
+    @statemachine.choose_all
+    @statemachine.focus
+    @statemachine.states_id.should == [:choosing, :focused]
+    @statemachine.defocus
+    @statemachine.states_id.should == [:choosing, :defocused]
+  end
+
+  # TODO implement test to check if In() is working
+  # TODO implement test for spontaneous transitions
+
+end

data/statemachines/specs/AIOUTContinous_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "AIINContinous" do
+  before (:each) do
+    @statemachine = Statemachine.build do
+      superstate :AIOUTContinous do
+        trans :initialized, :organize, :organized
+        trans :organized, :present, :presenting
+        trans :suspended, :organize, :organized
+
+        superstate :presenting do
+          event :suspend, :suspended
+
+          trans :defocused, :focus, :focused
+          trans :defocused, :next, :focused, :focus_next
+          trans :defocused, :prev, :focused, :focus_prev
+          trans :defocused, :parent, :focused, :focus_parent
+
+          superstate :focused do
+            event :defocus, :defocused
+
+            trans :waiting, :progress, :progressing
+            trans :waiting, :regress, :regressing
+
+            superstate :moving do
+              event :halt, :waiting
+
+              trans :progressing, :regress, :regressing
+              trans :regressing, :progress, :progressing
+            end
+          end
+        end
+      end
+   end
+  end
+
+
+  it "should enter the nested superstate :focused" do
+      @statemachine.organize
+      @statemachine.present
+      @statemachine.focus
+      @statemachine.state.should == :waiting
+  end
+
+  it "should support transitions inside :focused" do
+      @statemachine.organize
+      @statemachine.present
+      @statemachine.focus
+      @statemachine.progress
+      @statemachine.state.should == :progressing
+  end
+
+  it "should support transitions inside :moving" do
+      @statemachine.organize
+      @statemachine.present
+      @statemachine.focus
+      @statemachine.progress
+      @statemachine.state.should == :progressing
+      @statemachine.regress
+      @statemachine.state.should == :regressing
+  end
+
+  it "should leave :moving" do
+      @statemachine.organize
+      @statemachine.present
+      @statemachine.focus
+      @statemachine.progress
+      @statemachine.halt
+      @statemachine.state.should == :waiting
+   end
+end