MINT-core 1.0.1 → 2.0.0

data/lib/MINT-core/model/aui/AIContext.rb

@@ -0,0 +1,12 @@
+module MINT
+  class AIContext < AIOUT
+    #Todo check this
+    property :text, String
+    #has 1, :context, 'AIO'
+
+    def getSCXML
+          "#{File.dirname(__FILE__)}/aicontext.scxml"
+    end
+
+  end
+end

data/lib/MINT-core/model/aui/AIIN.rb

@@ -0,0 +1,8 @@
+module MINT
+
+
+  class AIIN < AIO
+
+ end
+
+end

data/lib/MINT-core/model/aui/AIINContinuous.rb

@@ -0,0 +1,56 @@
+module MINT
+
+
+  class AIINContinuous < AIIN
+
+    property :data, Integer
+    property :min, Integer,:default  => 0
+    property :max, Integer,:default  => 100
+
+    def getSCXML
+      "#{File.dirname(__FILE__)}/aiincontinuous.scxml"
+    end
+
+    # functions called from scxml
+
+    def publish(attribute)
+      channel_name =  create_attribute_channel_name(attribute)
+
+      redis = RedisConnector.redis
+
+      fiber = Fiber.current
+
+      redis.pubsub.psubscribe('in_channel:Interactor.AIO.AIIN.AIINContinuous.'+self.name.to_s+":*") { |key,message|
+        sync_states
+        if message.eql? "stop"
+          process_event("halt")
+        else
+          d = attribute_get(:data)
+
+          if d
+            if message.to_i > d and not (is_in?(:progressing) or is_in?(:max))# state comparison just for performance
+              process_event("progress")
+            elsif message.to_i < d and not (is_in?(:regressing) or is_in?(:min))
+              process_event("regress")
+            end
+          else
+            #  @statemachine.process_event("progress") # default progress TODO improve default handling for first data
+            process_event("progress")
+          end
+
+          attribute_set(:data,message.to_i)
+          RedisConnector.redis.publish channel_name,MultiJson.encode({:name=>self.name,:data => data})
+        end
+
+      }.callback {  fiber.resume}
+      Fiber.yield
+
+
+    end
+
+    def halt(id)
+      RedisConnector.sub.unsubscribe(self.class.create_channel_name+".#{id}")
+    end
+  end
+
+end

data/lib/MINT-core/model/aui/AIINDiscrete.rb

@@ -0,0 +1,8 @@
+module MINT
+
+
+  class AIINDiscrete < AIIN
+
+ end
+
+end

data/lib/MINT-core/model/aui/AIMultiChoice.rb

@@ -1,5 +1,4 @@
 module MINT
-  class AIMultiChoice < AIChoice
-  
+  class AIMultiChoice < AISingleChoice
   end
 end

data/lib/MINT-core/model/aui/AIMultiChoiceElement.rb

@@ -1,56 +1,9 @@
 module MINT
-  class AIMultiChoiceElement < AIINChoose
-    def initialize_statemachine
-      if @statemachine.blank?
-        @statemachine = Statemachine.build do
+  class AIMultiChoiceElement < AIChoiceElement
 
-#          superstate :AIO do # TODO not supported so far!
-          trans :initialized,:organize, :organized
-          trans :organized, :present, :p
-          trans :suspended,:present, :initialized
-
-          parallel :p do
-            statemachine :s1 do
-              superstate :presenting do
-                state :defocused do
-                  on_entry :sync_cio_to_displayed
-                end
-                state :focused do
-                  on_entry :sync_cio_to_highlighted
-                end
-                trans :defocused,:focus,:focused
-                trans :focused,:defocus, :defocused
-                trans :focused, :next, :defocused, :focus_next,  Proc.new { exists_next}
-                trans :focused, :prev, :defocused, :focus_previous, Proc.new { exists_prev}
-                trans :focused, :parent, :defocused, :focus_parent
-                event :suspend, :suspended
-              end
-            end
-            statemachine :s2 do
-              superstate :choice do
-                trans :listed, :choose, :chosen
-#                trans :chosen, :drag, :dragging
- #               trans :dragging, :drop, :chosen
-              trans :chosen, :unchoose, :listed
-
-                trans :listed,  :drag, :dragging
-                trans :dragging, :drop, :listed
-                
-                state :chosen do
-                  on_entry :sync_cio_to_selected
-                end
-
-                state :listed do
-                  on_entry :sync_cio_to_listed
-                end
-
-              end
-            end
-          end
-          #end
-        end
-      end
+    def getSCXML
+              "#{File.dirname(__FILE__)}/aimultichoiceelement.scxml"
     end
-    
+
   end
 end

data/lib/MINT-core/model/aui/AIO.rb

@@ -1,77 +1,78 @@
 module MINT
+  DataMapper::Model.raise_on_save_failure = true
 
+  class AIO < Interactor
 
-  # An abstract
-  class AIO < Element
-    property :label, String
-    property :description, Text,   :lazy => false
-    has 1, :next, self,
-        :parent_key => [ :id ],       # in the remote model (Blog)
-        :child_key  => [ :next_id ]  # local to this model (Post)
-    has 1,  :previous, self,
-        :parent_key => [ :id ],       # in the remote model (Blog)
-        :child_key  => [ :prev_id ]  # local to this model (Post)
-
-
-    belongs_to  :parent, 'AIC', # BUG figure out how to declare AIC
-                :parent_key => [ :id ],       # in the remote model (Blog)
-                :child_key  => [ :aic_id ],  # local to this model (Post)
-                :required   => true
-
-
-
-    def initialize_statemachine
-      if @statemachine.blank?
-        parser = StatemachineParser.new(self)
-        @statemachine = parser.build_from_scxml "#{File.dirname(__FILE__)}/aio.scxml"
-=begin
-@statemachine = Statemachine.build do
-
-          superstate :AIO do
-            trans :initialized,:organize, :organized
-            trans :organized, :present, :presenting
-            trans :organized, :suspend, :suspended
-            trans :suspended,:present, :presenting
-            trans :suspended, :organize, :organized
-            state :suspended do
-               on_entry :sync_cio_to_hidden
-              end
-
-            superstate :presenting do
-              on_entry :inform_parent_presenting
-              event :suspend, :suspended
-              state :defocused do
-                on_entry :sync_cio_to_displayed
-              end
-              state :focused do
-                on_entry :sync_cio_to_highlighted
-              end
-              trans :defocused,:focus,:focused
-              trans :focused,:defocus, :defocused
-              trans :focused, :next, :defocused, :focus_next,  Proc.new { exists_next}
-              trans :focused, :prev, :defocused, :focus_previous, Proc.new { exists_prev}
-              trans :focused, :parent, :defocused, :focus_parent
-
-            end
-          end
-        end
-=end
-        @statemachine.reset
-        #else
-        #@statemachine.reset
+    # TODO Links are established without Datamapper's relations because of problems with cycles and self-references (AIContainer))
+    property :parent, String
+    property :previous, String
+    property :next, String
+
+    def self.getModel
+      "aui"
+    end
+
+
+    def getSCXML
+      "#{File.dirname(__FILE__)}/aio.scxml"
+    end
+
+    def parent
+      p = super
+      if p
+        r = AIContainer.get("aui",p)
+        return r
+      else
+        nil
+      end
+    end
+
+    def parent= (p)
+      if p.nil? or p.is_a? String
+        super(p)
+      else
+        super(p.name)
+      end
+    end
+
+    def parent2str
+      parent.name      if  self.parent
+    end
+
+    def next
+      p = super
+      if p
+        AIO.get("aui",p)
+      else
+        nil
+      end
+    end
+
+    def next2str
+      self.next.name if self.next
+    end
+
+
+    def previous
+      p = super
+      if p
+        AIO.get("aui",p)
+      else
+        nil
       end
     end
 
+    def previous2str
+          previous.name if  self.previous
+        end
+
+
     # hook to inform parent about presenting state
     def inform_parent_presenting
       self.parent.child_to_presenting(self) if (self.parent)
       true
     end
 
-    def sync_event(event)
-      process_event(event, AIO_sync_callback.new)
-    end
-
     # callbacks
 
     def exists_next
@@ -82,19 +83,10 @@ module MINT
       self.previous!=nil
     end
 
-    def focus_next
-      if (self.next)
-        if self.next.process_event("focus")
-          return true
-        else
-          puts "ERRROR #{self.next.name} could not execute focus event"
-          return false
+    def exists_parent
+          self.parent!=nil
         end
-      else
-        puts "WARNING!! > no next element found!"
-        return false
-      end
-    end
+
 
     def focus_previous
       if (self.previous)
@@ -112,59 +104,20 @@ module MINT
       end
     end
 
-    def sync_cio_to_highlighted
-      cio =  MINT::CIO.first(:name=>self.name)
-      if (cio and not cio.is_in? :highlighted)
-        cio.sync_event(:highlight)
-        # cio.states=[:highlighted]
-      end
-      true
-    end
-
-    def sync_cio_to_displayed
-      cio =  MINT::CIO.first(:name=>self.name)
-      if (cio and not cio.is_in? :displayed)
-        if (cio.is_in? :suspended or cio.is_in? :positioned)
-          cio.sync_event(:display)
+    def focus_next
+      if (self.next)
+        if self.next.process_event("focus")
+          return true
         else
-          cio.sync_event(:unhighlight)
+          puts "ERRROR #{self.next.name} could not execute focus event"
+          return false
         end
-        #cio.states=[:displayed]
+      else
+        puts "WARNING!! > no next element found!"
+        return false
       end
-      true
     end
 
-    def sync_cio_to_hidden
-      cio =  MINT::CIO.first(:name=>self.name)
-      if (cio and not cio.is_in? :hidden)
-        cio.sync_event(:hide)
-        end
-      true
-    end
   end
 
-
-   class AIO_sync_callback
-    def sync_cio_to_highlighted
-      true
-    end
-
-    def sync_cio_to_displayed
-      true
-    end
-
-    def sync_cio_to_suspended
-      true
-    end
-    def inform_parent_presenting
-          true
-        end
-    def present_first_child
-      true
-    end
-
-     def present_children
-       true
-     end
-  end
-end
+end

data/lib/MINT-core/model/aui/AIOUT.rb

@@ -0,0 +1,8 @@
+module MINT
+
+
+  class AIOUT < AIO
+
+  end
+
+end

data/lib/MINT-core/model/aui/AIOUTContinuous.rb

@@ -0,0 +1,61 @@
+module MINT
+  class AIOUTContinuous < AIOUT
+
+    property :data, Integer, :default  => 0
+    property :min, Integer,:default  => 0
+    property :max, Integer,:default  => 100
+
+    def getSCXML
+      "#{File.dirname(__FILE__)}/aioutcontinuous.scxml"
+    end
+
+    PUBLISH_ATTRIBUTES += [:data]
+
+    # functions called from scxml
+
+    def data=(value)
+      super  # use original method instead of accessing @ivar directly
+      publish_update_new
+    end
+
+    def publish_update_new
+      RedisConnector.redis.publish create_attribute_channel_name('data'), self.to_json(:only => self.class::PUBLISH_ATTRIBUTES)
+    end
+
+
+    def consume(attribute)
+      @d = 0
+
+      channel_name = create_attribute_channel_name(attribute)
+      p "subscribed #{channel_name}"
+
+      redis = RedisConnector.redis
+
+      fiber = Fiber.current
+
+      redis.pubsub.subscribe(channel_name) { |message|
+        found=MultiJson.decode message
+
+        if self.name.eql? found['name']
+          if found['data']
+            @d = found['data'].to_i
+            @data = attribute_get(:data)
+
+            process_event "move"
+            restart_timeout(1,:halt)
+
+            attribute_set(:data,@d)
+            RedisConnector.redis.publish("out_channel:#{create_channel_w_name}:testuser",@data)
+          end
+        end
+      }.callback {  fiber.resume}
+      Fiber.yield
+      @d
+    end
+
+    def halt(id)
+      RedisConnector.sub.unsubscribe(self.class.create_channel_name+".#{id}")
+    end
+  end
+
+end