MINT-core 1.0.0

data/lib/MINT-core/model/device/pointer.rb

@@ -0,0 +1,85 @@
+module MINT
+  class Pointer < Element
+    property :x, Integer, :default  => -1
+    property :y, Integer, :default  => -1
+
+    def initialize_statemachine
+      if @statemachine.blank?
+        @statemachine = Statemachine.build do
+
+          trans :disconnected,:connect, :connected
+          trans :connected, :disconnect, :disconnected
+
+          superstate :connected do
+            trans :stopped, :move, :moving
+            trans :moving,:move, :moving
+            trans :moving,:stop,:stopped
+
+            state :moving do
+              on_entry :start_timeout
+              on_exit :stop_timeout
+            end
+          end
+        end
+      end
+    end
+
+     def cache_coordinates(x,y)
+      @cached_x = x
+      @cached_y = y
+     end
+
+    def start_timeout
+      if not @timer
+        @timer = EventMachine::Timer.new(0.1) do
+          attribute_set(:x, @cached_x)
+          attribute_set(:y, @cached_y)
+
+          process_event("stop")
+
+        end
+      else
+        puts "timer already started!!!"
+      end
+    end
+    def stop_timeout
+      if @timer
+        @timer.cancel
+        @timer = nil
+      end
+    end
+    def restart_timeout
+      stop_timeout
+      start_timeout
+    end
+  end
+
+  class Pointer3D < Pointer
+    property :z, Integer, :default  => -1
+    attr_accessor :cached_x, :cached_y,:cached_z
+
+    def cache_coordinates(x,y,z=nil)
+      @cached_x = x if (x)
+      @cached_y = y if (y)
+      @cached_z = z if (z)
+    end
+
+
+
+  def start_timeout
+      if not @timer
+        @timer = EventMachine::Timer.new(0.1) do
+          attribute_set(:x, @cached_x)
+          attribute_set(:y, @cached_y)
+          attribute_set(:z, @cached_z)
+
+          process_event("stop")
+
+        end
+      else
+        puts "timer already started!!!"
+      end
+    end
+
+  end
+end

data/lib/MINT-core/model/device/wheel.rb

@@ -0,0 +1,51 @@
+module MINT
+  class Wheel < Element
+
+    def initialize_statemachine
+      if @statemachine.blank?
+        @statemachine = Statemachine.build do
+
+          trans :disconnected,:connect, :connected
+          trans :connected, :disconnect, :disconnected
+
+          superstate :connected do
+            trans :stopped,:regress, :regressing
+            trans :stopped,:progress, :progressing
+
+            trans :regressing, :regress, :regressing
+            trans :regressing, :stop, :stopped
+            trans :regressing, :progress, :progressing
+
+            trans :progressing, :progress, :progressing
+            trans :progressing, :stop, :stopped
+            trans :progressing, :regress, :regressing
+
+            state :regressing do
+              on_entry :start_timeout
+              on_exit :stop_timeout
+            end
+            state :progressing do
+              on_entry :start_timeout
+              on_exit :stop_timeout
+            end
+          end
+        end
+      end
+    end
+     def start_timeout
+        if not @timer
+          @timer = EventMachine::Timer.new(0.3) do
+            process_event("stop")
+          end
+        else
+          puts "timer already started!!!"
+        end
+      end
+      def stop_timeout
+        if @timer
+          @timer.cancel
+          @timer = nil
+        end
+      end
+  end
+end

data/lib/MINT-core/model/interactor.rb

@@ -0,0 +1,167 @@
+module MINT
+  # An {Element} is the basic abstract element of the complete MINT markup language. Nearly all  other
+  # classes are derived  from {MINT::Element} since early everything can be activated by {#state} and has 
+  # a {#name}. 
+  #
+  class Element
+    include DataMapper::Resource
+    private
+    property :id, Serial
+    property :classtype, Discriminator
+
+    # Each abstract  {Element} needs to have a name that we will use as the primary key for each model.
+    property :name, String
+
+    # States of the {Element} Reflects the actual atomic states of the interactors state machine.
+    property :states, String
+
+    # reflects all active states including abstract superstates of an interactor as a |-seperated state id list
+    property :abstract_states, String
+
+    #always contains the new atomic states that have been entered by the event that has been processed - especially useful for parallel states
+    property :new_states, String
+
+   protected
+    before :save, :save_statemachine
+
+    public
+
+    def to_dot(filename)
+       if not @statemachine
+        initialize_statemachine
+       end
+      @statemachine.to_dot(:output => filename)
+    end
+    def states
+      if not @statemachine
+        initialize_statemachine
+        recover_statemachine
+      end
+      @statemachine.states_id
+    end
+
+    def new_states
+      if attribute_get(:new_states)
+            return attribute_get(:new_states).split("|").map &:to_sym if attribute_get(:new_states).class!=Array
+        return attribute_get(:new_states)
+      else return []
+      end
+    end
+
+    def states= states
+      if not @statemachine # if called on element creation using the states hash!
+        initialize_statemachine
+      end
+      @statemachine.states=states
+      save_statemachine
+    end
+
+    def initialize(attributes = {}, &block)
+      super(attributes, &block)
+      recover_statemachine
+    end
+
+    # The sync event method is overwritten in the derived classes to prevent synchronization cycles by setting an empty callback
+    def sync_event(event)
+      process_event(event)
+    end
+
+    def process_event(event, callback=nil)
+
+      states = process_event!(event,callback)
+      if states
+        save_statemachine
+        states
+      else
+        false
+      end
+    end
+
+    def process_event!(event, callback=nil)
+      if not @statemachine
+        initialize_statemachine
+        recover_statemachine
+      end
+      if callback
+        @statemachine.context = callback
+      else
+        @statemachine.context = self
+      end
+      begin
+         old_states = @statemachine.states_id
+         old_abstract_states = @statemachine.abstract_states
+         @statemachine.process_event(event)
+         calc_new_states = @statemachine.states_id-old_states
+         calc_new_states = calc_new_states + (@statemachine.abstract_states - old_abstract_states)
+         calc_new_states = @statemachine.states_id  if calc_new_states.length==0
+        attribute_set(:new_states, calc_new_states.join('|'))
+      rescue Statemachine::TransitionMissingException
+        p "#{self.name} is in state #{self.states} and could not handle #{event}"
+        return false
+      end
+      @statemachine.states_id
+    end
+
+    def is_in?(state)
+       if not @statemachine
+        initialize_statemachine
+        recover_statemachine
+       end
+      @statemachine.In(state)
+    end
+    protected
+    def initialize_statemachine
+      if @statemachine.blank?
+        @statemachine = Statemachine.build do
+          trans :initialized, :run, :running
+          trans :running, :done, :finished
+        end
+      end
+    end
+
+    private
+
+    def save_statemachine
+       if not @statemachine
+        initialize_statemachine
+        recover_statemachine
+      end
+      attribute_set(:states, @statemachine.states_id.join('|'))
+      attribute_set(:abstract_states, @statemachine.abstract_states.concat(@statemachine.states_id).join('|'))
+      # attribute_set(:new_states,new_states) if new_states and new_states.length>0 # second condition to
+      save!
+    end
+
+    # @TODO check this for parallel states!
+    def recover_statemachine
+      if (@statemachine.blank?)
+        initialize_statemachine
+      end
+      if attribute_get(:states)
+        if attribute_get(:states).is_a? Array # @TODO this should not occur!!
+          @statemachine.states=attribute_get(:states)
+        else
+          @statemachine.states=attribute_get(:states).split('|').map &:intern
+        end
+
+      else
+        attribute_set(:states, @statemachine.states_id.join('|'))
+        attribute_set(:abstract_states, @statemachine.abstract_states.concat(@statemachine.states_id).join('|'))
+      end
+       if not attribute_get(:new_states)
+         attribute_set(:new_states, @statemachine.states_id.join('|'))
+       end
+    end
+
+    def is_set(attribute)
+      self.attribute_get(attribute)!=nil
+    end
+  end
+
+  class IR <Element
+ end
+
+  class IN < IR
+  end
+
+end

data/lib/MINT-core/model/task.rb

@@ -0,0 +1,71 @@
+module MINT
+  # TASK MODEL
+
+
+  # A {Task} defines the basic control flow object, has a {#parent} task, unless it's the root task and a textual,
+  # unstructured {#description}.
+  #
+  class Task < Element
+    #    belongs_to :parent, "Task"
+    property :description, Text
+
+    def initialize_statemachine
+      if @statemachine.blank?
+
+        @statemachine = Statemachine.build do
+          trans :initialized, :run, :running
+          trans :running, :stop, :done
+        end
+      end
+    end
+  end
+
+
+# Each {InteractionTask} is linked to one abstract interaction container
+# {MINT::AIC}
+#
+  class InteractionTask < Task
+    #   has 1, :AIC @TODO - Mappings unklar
+    belongs_to :pts, "PTS"
+  end
+
+# An {ApplicationTask} is completely executed by the computer without any human intervention
+# through it's internal processing. An {ApplicationTask} can generate or manipulate
+# Domain objects through it's internal processing. The {ApplicationTask} is used to model service
+# calls to the functional core of the application or it can enable other {Task}s if it is used to model
+# sensor information.
+#
+  class ApplicationTask < Task
+
+  end
+
+# {InputInteractionTask}s describe {Task}s realizing some interaction techniques to enable the user
+# interacting with the system. {InputInteractionTask}s include selecting objects, editing data or enabling the
+# user to control some actions explicitly through events. If an {InputInteractionTask} is  marked as synchronous
+# it has to contain at least one control object that the user can issue to proceed the {Task}.
+#
+  class InputInteractionTask < InteractionTask
+  end
+
+# {OutputInteractionTask}s present information to the user. This could be raw structured data like documents or tables
+# or multimedia output such as video or sound. [OutputInteractionTask}s read the objects that are associated with
+# the task once if the are marked as synchronous or until they get disabled by another {ApplicationTask}'s or an
+# {InputInteractionTask} if they are marked as asynchronous.
+#
+  class OutputInteractionTask < InteractionTask
+  end
+
+# A Presentation Task set {PTS} contains a set of active interaction tasks that should be presented or manipulated by the
+# user
+#
+  class PTS < Element
+    def initialize_statemachine
+      if @statemachine.blank?
+        @statemachine = Statemachine.build do
+          trans :initialized, :calculate, :calculating
+          trans :calculating, :done, :finished
+        end
+      end
+    end
+  end
+end

data/lib/MINT-core/overrides/rinda.rb

@@ -0,0 +1,34 @@
+require "rinda/tuplespace"
+
+module Rinda
+  class TupleSpace
+    def take_all(tuple)
+      read_all(tuple).each { |t|
+        take(t)
+      }
+    end
+    
+
+  end
+  
+  # fixed Templates to  support partially matching
+  class Template
+    def match(tuple)
+      return false unless tuple.respond_to?(:size)
+      return false unless tuple.respond_to?(:fetch)
+      return false unless self.size <= tuple.size
+      each do |k, v|
+        begin
+          it = tuple.fetch(k)
+        rescue
+          return false
+        end
+        next if v.nil?
+        next if v == it
+        next if v === it
+        return false
+      end
+      return true
+    end
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/MINT-core.rb'}"
+puts "Loading MINT-core gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)