MINT-core 1.0.1 → 2.0.0

data/lib/MINT-core/mapping/complementary.rb

@@ -1,100 +0,0 @@
-module MINT
-
-
-  class ComplementaryCallMethod < ExecuteOnStateChange
-    def initialize(source_model,state,conditions,execute)
-      super(source_model,state,self.method(:executeWithConditions),nil)
-      @original_execute = execute
-      @conditions = conditions
-      p "initialized #{conditions.inspect}"
-    end
-
-    # TODO basic condition checker still without consideration of time span :-(
-    def checkConditions
-      p "in check AND cond #{@conditions.inspect}"
-      result = nil
-      @conditions.each do |model,state|
-        result=model.first( :abstract_states=> /(^|\|)#{Regexp.quote(state)}/)
-        if result.nil?
-          puts "Received #{@state} notify for model #{@source_model} but condition state #{state} of model #{model} not true"
-          return false
-        end
-      end
-      return result
-    end
-
-    def  executeWithConditions(result)
-      p "Catched "
-      result = checkConditions
-      if result
-        p "executing #{@original_execute} on #{result.inspect}"
-        @original_execute.call result
-      end
-    end
-
-  end
-
-  class ComplementarySendEvent< ComplementaryCallMethod
-    def initialize(source_model,state,conditions,execute)
-      super(source_model,state,conditions,execute)
-    end
-
-    def  executeWithConditions(result)
-      p "Catched "
-      result = checkConditions
-      if result
-        p "executing #{@original_execute} on #{result.inspect}"
-        p result.process_event(@original_execute)
-      end
-    end
-  end
-
-  class ComplementarySendEvents< ComplementaryCallMethod
-    def initialize(source_model,state,conditions,execute)
-      super(source_model,state,conditions,execute)
-    end
-
-    def  executeWithConditions(result)
-      publish_events(@original_execute)
-    end
-
-  end
-
-  class ComplementaryOR<ComplementarySendEvent
-    def initialize(source_model,state,conditions,execute)
-      super(source_model,state,conditions,execute)
-    end
-
-    def checkConditions
-      p "in check OR cond #{@conditions.inspect}"
-      result = nil
-      @conditions.each do |model,state|
-        state.each do |s|
-          result=model.first( :abstract_states=> /(^|\|)#{Regexp.quote(s)}/)
-          if not result.nil?
-            return result
-          end
-        end
-
-      end
-      return false
-    end
-  end
-
-  class ComplementaryMethodCall < ComplementarySendEvent
-    def initialize(source_model,state,conditions,execute,callback)
-      super(source_model,state,conditions,execute)
-      @callback= callback
-    end
-    def  executeWithConditions(result)
-      p "Catched "
-      result = checkConditions
-      if result
-        p "executing #{@orginal_execute} on #{result.inspect}"
-        r = result.process_event(@orginal_execute)
-        @callback.call r
-      end
-    end
-
-  end
-end

data/lib/MINT-core/mapping/on_state_change.rb

@@ -1,65 +0,0 @@
-
-module MINT
-
-  # Basic mapping that observes state changes of elements in a model agents model.
-  #
-  class ExecuteOnStateChange < Mapping
-    attr_reader :state
-
-    def initialize(source_model,state,execute, initial=nil)
-      super(source_model,"write",execute,initial)
-      if (not state.is_a? Array)
-        @state = [state.to_s]
-      else
-        @state = state.map &:to_s
-      end
-    end
-
-    def execute
-      # query existing state
-      if @initial
-        results = @source_model.all({ :abstract_states=> /(^|\|)#{Regexp.quote(@state.first)}/})
-        p "Found results by read: #{results.inspect}"
-        results.each do |result|
-          call_if_result_matches result, @initial
-        end
-      end
-      #register for further events
-      #observer = agent.storage.notify 'write', {"_model_"=> @source_model.to_s} + @conditions
-
-      p "registered for model #{@source_model} writes on state #{@state}"
-      @source_model.notify("write", {  :new_states=> /(^|\|)#{Regexp.quote(@state.first)}/},self.method(:check_cond))
-
-    end
-
-    def check_cond(result)
-      call_if_result_matches(result,@execute)
-    end
-
-    def call_if_result_matches(result,method)
-      return if not result
-      states_to_check = Array.new @state
-      states_to_check.shift # we already hav checked for the first state
-      states_to_check.each do |state|
-        return false if not result.abstract_states =~/(^|\|)#{Regexp.quote(state)}/
-      end
-      method.call result
-      true
-    end
-
-  end
-
-  class ExecuteEventOnStateChange < ExecuteOnStateChange
-    def initialize(source_model,state,selector,event)
-      super(source_model,state,self.method(:process_event),nil)
-      @selector = selector
-      @event = event
-    end
-
-    def process_event(result)
-      @selector.each do |element|
-        element.process_event(@event)
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-module MINT
-  class AIC < AIOUTDiscrete
-    #    belongs_to :task @TODO - Mappings unklar
-    has n, :childs, 'AIO',
-        :parent_key => [ :id ],      # local to this model (Blog)
-        :child_key  => [ :aic_id ]  # in the remote model (Post)
-    has 1, :entry, 'AIO'
-
-    def initialize_statemachine
-      super
-      parser = StatemachineParser.new(self)
-      @statemachine = parser.build_from_scxml "#{File.dirname(__FILE__)}/aic.scxml"
-=begin
-@statemachine = Statemachine.build do
-        superstate :AIC 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, :present_children]
-            on_exit :hide_children
-            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
-            trans :focused, :child, :defocused, :focus_child
-
-          end
-        end
-      end
-=end
-    end
-
-    def hide_children
-      if (self.childs)
-        self.childs.each do |c|
-          c.process_event("suspend")
-        end
-
-      end
-    end
-
-    def present_children
-      if (self.childs)
-        self.childs.each do |c|
-          c.process_event("present")
-        end
-
-      end
-    end
-
-
-    def  focus_child
-      if (self.childs && self.childs.first)
-        self.childs.first.process_event("focus")
-      else
-        return nil # TODO not working, find abbruchbedingung!!!
-      end
-    end
-
-
-    # hook that is called from a child if it enters presenting state
-    def child_to_presenting(child)
-      true
-    end
-
-  end
-
-
-end

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

@@ -1,65 +0,0 @@
-module MINT
-  class AIChoice < AIC
-    def initialize_statemachine
-      if @statemachine.blank?
-        parser = StatemachineParser.new(self)
-        @statemachine = parser.build_from_scxml "#{File.dirname(__FILE__)}/aichoice.scxml"
-=begin
-@statemachine = Statemachine.build do
-          trans :initialized,:organize, :organized
-          trans :organized, :present, :p_t
-          trans :organized, :suspend, :suspended
-          trans :suspended, :present, :p_t
-          trans :suspended, :organize, :organized
-          state :suspended do
-            on_entry :sync_cio_to_hidden
-          end
-
-          superstate :p_t do     # TODO artificial superstate required to get following event working!
-            event :suspend, :suspended
-            parallel :p do
-              statemachine :s1 do
-                superstate :presenting do
-                on_entry :present_children
-                on_exit :hide_children
-                  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
-                  trans :focused, :child, :defocused, :focus_child
-
-                end
-              end
-              statemachine :s2 do
-                superstate :l do
-                  trans :listing, :drop, :listing, :add_element, "In(:focused)"
-                end
-              end
-            end
-          end
-        end
-=end
-      @statemachine.reset
-      end
-    end
-    def add_element
-      #if self.is_in? :focused
-        f = AISingleChoiceElement.first(:new_states=> /#{Regexp.quote("dragging")}/)
-        self.childs << f
-        self.childs.save
-        f.process_event(:drop)
-        f.process_event(:focus)
-        self.process_event(:defocus)
-        f.destroy
-      #end
-    end
-  end
-
-end

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

@@ -1,54 +0,0 @@
-module MINT
-  class AIINChoose_sync_callback < AIO_sync_callback
-     def initialize(element)
-       @element=element
-     end
-     def sync_cio_to_listed
-       true
-     end
-
-     def sync_cio_to_selected
-       true
-     end
-
-
-
-     def unchoose_others
-       aios = @element.parent.childs.all(:states=>/\bchosen\b/)
-       aios.each do |aio|
-         aio.process_event("unchoose") if aio.is_in? :chosen
-       end
-       true
-     end
-   end
-
-   class AIINChoose < AIINDiscrete
-
-     def sync_event(event)
-       process_event(event, AIINChoose_sync_callback.new(self))
-     end
-     def sync_cio_to_selected
-       cio =  MINT::Selectable.first(:name=>self.name)
-       if (cio and not cio.is_in? :selected)
-         cio.sync_event(:select)
-       end
-       true
-     end
-
-     def sync_cio_to_listed
-       cio =  MINT::Selectable.first(:name=>self.name)
-       if (cio and not cio.is_in? :listed)
-         cio.sync_event(:listed)
-       end
-       true
-     end
-
-     def unchoose_others
-       aios = self.parent.childs.all(:states=>/\bchosen\b/)
-       aios.each do |aio|
-         aio.process_event("unchoose")
-       end
-     end
-   end
-
-end

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

@@ -1,43 +0,0 @@
-module MINT
-
-  class AIOUTDiscrete < AIOUT
-    def initialize_statemachine
-      if @statemachine.blank?
-        @statemachine = Statemachine.build do
-          trans :initialized,:organize, :organized
-          trans :organized, :present, :p
-          trans :suspended,:present, :p, :present_children
-          state :suspended do
-            on_entry :sync_cio_to_hidden
-          end
-
-          superstate :p_t do     # TODO artificial superstate required to get following event working!
-            event :suspend, :suspended, :hide_children
-            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
-                end
-              end
-              statemachine :s2 do
-                superstate :l do
-                  trans :listing, :update, :listing, :sync_cio_to_updated
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/MINT-core/model/aui/aic.scxml

@@ -1,50 +0,0 @@
-<scxml initial="initialized" name="AIC" version="0.9" xmlns="http://www.w3.org/2005/07/scxml"><!--   node-size-and-position x=0.0 y=0.0 w=370.0 h=270.0  -->
- <state id="organized"><!--   node-size-and-position x=10.0 y=100.0 w=70.0 h=20.0  -->
-  <transition event="suspend" target="suspended"><!--   edge-path [suspended]  x=134.0 y=97.0  --></transition>
-  <transition event="present" target="presenting"><!--   edge-path [presenting]  x=50.0 y=160.0  --></transition>
- </state>
- <state id="presenting" initial="defocused"><!--   node-size-and-position x=80.0 y=130.0 w=280.0 h=130.0  -->
-  <onentry>
-   <invoke src="inform_parent_presenting" type="x-mint"></invoke>
-   <invoke src="present_children" type="x-mint"></invoke>
-  </onentry>
-  <onexit>
-   <invoke src="hide_children" type="x-mint"></invoke>
-  </onexit>
-  <transition event="suspend" target="suspended"><!--   edge-path [suspended]  x=184.0 y=107.0  --></transition>
-  <state id="focused"><!--   node-size-and-position x=210.0 y=50.0 w=60.0 h=20.0  -->
-   <onentry>
-    <invoke src="sync_cio_to_highlighted" type="x-mint"></invoke>
-   </onentry>
-   <transition event="defocus" target="defocused"><!--   edge-path [defocused]  x=240.0 y=40.0 x=50.0 y=40.0 pointx=0.0 pointy=0.0 offsetx=-5.0 offsety=0.0  --></transition>
-   <transition cond="exists_next" event="next" target="defocused">
-    <invoke src="focus_next" type="x-mint"></invoke>
-<!--   edge-path [defocused]  x=240.0 y=90.0 x=50.0 y=90.0  --></transition>
-   <transition cond="exists_prev" event="prev" target="defocused">
-    <invoke src="focus_previous" type="x-mint"></invoke>
-<!--   edge-path [defocused]  x=240.0 y=100.0 x=50.0 y=100.0  --></transition>
-   <transition event="parent" target="defocused">
-    <invoke src="focus_parent" type="x-mint"></invoke>
-<!--   edge-path [defocused]  x=240.0 y=120.0 x=50.0 y=120.0  --></transition>
-   <transition event="child" target="defocused">
-    <invoke src="focus_child" type="x-mint"></invoke>
-<!--   edge-path [defocused]  x=240.0 y=110.0 x=50.0 y=110.0  --></transition>
-  </state>
-  <state id="defocused"><!--   node-size-and-position x=20.5 y=50.0 w=60.0 h=20.0  -->
-   <onentry>
-    <invoke src="sync_cio_to_displayed" type="x-mint"></invoke>
-   </onentry>
-   <transition event="focus" target="focused"><!--   edge-path [focused]  x=140.0 y=60.0  --></transition>
-  </state>
- </state>
- <state id="suspended"><!--   node-size-and-position x=194.5 y=47.0 w=60.0 h=20.0  -->
-  <onentry>
-   <invoke src="sync_cio_to_hidden" type="x-mint"></invoke>
-  </onentry>
-  <transition event="present" target="presenting"><!--   edge-path [presenting]  x=254.0 y=107.0  --></transition>
-  <transition event="organize" target="organized"><!--   edge-path [organized]  x=114.0 y=67.0  --></transition>
- </state>
- <state id="initialized"><!--   node-size-and-position x=10.5 y=30.0 w=70.0 h=20.0  -->
-  <transition event="organize" target="organized"></transition>
- </state>
-</scxml>