vigilem-core 0.0.9

data/lib/vigilem/core/hooks/inheritable.rb

@@ -0,0 +1,24 @@
+require 'vigilem/support/core_ext'
+
+module Vigilem
+module Core
+module Hooks
+  # 
+  module Inheritable
+    
+    # 
+    # @param  base
+    def inherited(base)
+      base.extend Inheritable
+    end
+    
+    # 
+    # @return [Array]
+    def hooks
+      @hooks ||= (self.superclass.respond(:hooks) || []).select(&:inheritable?)
+    end
+    
+  end
+end
+end
+end

data/lib/vigilem/core/hooks/meta_callback.rb

@@ -0,0 +1,53 @@
+require 'delegate'
+
+module Vigilem::Core::Hooks
+  # @todo better name?
+  # CallbackProc that remebers if it has been ran/evaluated/called
+  class MetaCallback < DelegateClass(CallbackProc)
+    
+    # 
+    # @param  [CallbackProc] cbp a CallbackProc 
+    #                                to be converted to a MetaCallback
+    # @param  [Proc] block a Proc to be converted to a MetaCallback
+    def initialize(cbp=nil, &block)
+      self.ran = false
+      super(cbp || CallbackProc.new(&block))
+    end
+    
+    # 
+    # @param  context the context which to evaluate under
+    # @param  [Array] args arguments to be passed to the proc
+    # @param  [Proc] block Proc to be passed to the proc
+    # @return the result of the 
+    def evaluate(context, *args, &block)
+      self.ran = true
+      super(context, *args, &block)
+    end
+    
+    alias_method :[], :evaluate
+    
+    # 
+    # @param  [Array] args arguments to be passed to the proc
+    # @param  [Proc] block Proc to be passed to the proc
+    # @return the result of the proc
+    def call(*args, &block)
+      self.ran = true
+      super(*args, &block)
+    end
+    
+    # whether or not this proc ran
+    # @return [TrueClass || FalseClass]
+    def ran?
+      @ran
+    end
+    
+   private
+    
+    # 
+    # @param  [TrueClass || FalseClass] status
+    # @return @ran
+    def ran=(status)
+      @ran = status
+    end
+  end
+end

data/lib/vigilem/core/hooks/utils.rb

@@ -0,0 +1,23 @@
+require 'vigilem/support/utils'
+
+module Vigilem
+module Core::Hooks
+  # 
+  # utils for the Hooks
+  module Utils
+    
+    include Support::KernelUtils
+    
+    # 
+    # if context of callback is a subclass of this context
+    # @param  context
+    # @param  callback
+    # @return [FalseClass || TrueClass]
+    def callback_is_in_subclass?(context, callback)
+      get_class(callback.binding.eval('self')) < get_class(context)
+    end
+    
+    extend self
+  end
+end
+end

data/lib/vigilem/core/hub.rb

@@ -0,0 +1,50 @@
+require 'vigilem/support/obj_space'
+
+module Vigilem
+module Core
+  # copies events or messages from the system to all the 
+  # attached buffers except the link, much like a network hub
+  class Hub
+    
+    attr_reader :buffers, :group_id
+    
+    # @param group
+    def initialize(group)
+      @group_id = group
+      @buffers = []
+    end
+    
+    # 
+    # @param  [EventBuffer] buffer that will receive events from the hub
+    # @return self is expected like array
+    def add_buffer(buffer)
+      @buffers << buffer
+      self
+    end
+    
+    alias_method :<<, :add_buffer
+    
+    # 
+    # @param  [Array] msgs the messages to push out
+    # @return [Array] the buffers that got updated
+    def demux(buff, *msgs)
+      buffers.except(buff).select {|buffer| buffer.concat(msgs) unless msgs.empty? } 
+    end
+    
+    extend Support::ObjSpace
+    
+    class << self
+      
+      # 
+      # finds a hub based on a group identifier, if no Hub is found
+      # a new one is returned
+      # @param  link the link registered for a hub
+      # @return [Hub] the hub for passed in link
+      def aquire(grp_id)
+        all.find {|hub| hub.group_id == grp_id } || obj_register(new(grp_id))
+      end
+      
+    end
+  end
+end
+end

data/lib/vigilem/core/input_system_handler.rb

@@ -0,0 +1,55 @@
+require 'forwardable'
+
+require 'vigilem/support/core_ext'
+
+require 'vigilem/core/lockable_pipeline_component'
+
+require 'vigilem/core/adapters/basic_adapter'
+
+require 'vigilem/core/buffer_handler'
+
+require 'vigilem/core/transfer_agent'
+
+module Vigilem
+module Core
+  # 
+  # methods to hand the lower level bindings
+  module InputSystemHandler
+    
+    include BufferHandler
+    
+    include Adapters::BasicAdapter
+    
+    include LockablePipelineComponent
+    
+    extend Support::ObjSpace
+    
+    extend ActiveSupport::Concern
+    
+    # 
+    # @param  buffer_type
+    # @return 
+    def initialize_input_system_handler(buffer_type=[])
+      ret = initialize_buffer_handler(buffer_type)
+      InputSystemHandler.obj_register(self)
+      self.class.obj_register(self)
+      ret
+    end
+    
+    # 
+    # 
+    module ClassMethods
+      include Support::ObjSpace
+      
+      include Forwardable
+      
+      # 
+      # 
+      def self.extended(base)
+        base.extend Support::ObjSpace
+      end
+    end
+    
+  end
+end
+end

data/lib/vigilem/core/lockable_pipeline_component.rb

@@ -0,0 +1,30 @@
+require 'vigilem/support/core_ext'
+
+module Vigilem
+module Core
+  # 
+  module LockablePipelineComponent
+    
+    # 
+    # name collision with demultiplexer and bufferhandler
+    def semaphore
+      @semaphore ||= (semaphore! || Monitor.new)
+    end
+    
+    # 
+    # checks #source component for #semaphore without memoization
+    def semaphore!
+      self.respond.source.respond.semaphore
+    end
+    
+    # 
+    # 
+    def synchronize
+      semaphore.synchronize do
+        yield
+      end
+    end
+    
+  end
+end
+end

data/lib/vigilem/core/multiplexer.rb

@@ -0,0 +1,168 @@
+require 'active_support/concern'
+
+require 'vigilem/support/obj_space'
+
+require 'vigilem/support/utils'
+
+module Vigilem
+module Core
+  # 
+  # 
+  module Multiplexer
+    
+    extend Support::ObjSpace
+    
+    extend ActiveSupport::Concern
+    
+    attr_writer :inputs
+    
+    attr_accessor :out
+    
+    alias_method :output, :out
+    alias_method :output=, :out=
+    
+    # 
+    # @param  [Array<IO || Array>] in_ios_or_arrays
+    # @param  [Array<#<< || #concat>] out
+    # @return 
+    def initialize_multiplexer(in_ios_or_arrays, out=nil)
+      @inputs = in_ios_or_arrays
+      
+      @out = out
+      self.class.obj_register(self)
+      multiplexers = ::Vigilem::Core::Multiplexer.all
+      if (ties = multiplexers.flat_map {|muxer| self.intersect muxer }).any?
+        raise NotImplemented, "Multiplexers cannot share the same inputs `#{ties.inspect}'"
+      end
+      multiplexers << self
+    end
+    
+    # @todo   change name to select?
+    # @return [Array<IO> || NilClass] objects ready to be read, or nil 
+    #                                 if nothing is to be read
+    def ready?
+      if not (ios = inputs.select {|io| io.respond_to? :to_io }).empty?
+        @ready, others = IO.select(ios, nil, nil, 0)
+      end
+      @ready ||= []
+      @ready += inputs.select {|ary| ary.respond_to?(:empty?) and ary.empty? }
+    end
+    
+    # 
+    # @raise  [ArgumentError]
+    # @return [Array]
+    def __sweep__(len)
+      recursive_check(RuntimeError)
+      sweep(len)
+    end
+    
+    # 
+    # @param  [Integer] num
+    # @return 
+    def sweep(num)
+      raise NotImplemented, "#sweep method not defined on `#{self}' needs to be overriden"
+    end
+    
+    # 
+    # pushes the converted array from #sweep to #out
+    # @param  [Integer] len
+    # @return [Array]
+    def mux(len)
+      ary = __sweep__(len)
+      if out.respond_to? :concat
+        out.concat(ary)
+      elsif out.respond_to? :<<
+        ary.each {|item| out << item }
+      else
+        raise TypeError, "`#{self}'#out is `#{self.out.inspect}' and does not respond to #concat or #<<"
+      end
+      out.flush if out.respond_to? :flush
+      ary
+    end
+    
+    # 
+    # @return [Array]
+    def inputs
+      @inputs ||= []
+    end
+    
+    # adds a inputs and runs a uniq
+    # @param  [Array<IO || Array>] added_inputs
+    # @return [Array<IO || Array>] 
+    def add_inputs(*added_inputs)
+      if not added_inputs.empty?
+        (self.inputs += added_inputs).uniq! {|obj| obj.object_id }
+        recursive_check
+      end
+      self.inputs
+    end
+    
+    # 
+    # 
+    module ClassMethods
+      
+      include Support::ObjSpace
+      
+      # 
+      # @param [Module] base
+      def self.extended(base)
+        base.extend Support::ObjSpace
+      end
+      
+    end
+    
+    extend ClassMethods
+    
+    # 
+    # @see    Object#inspect
+    # @return [String]
+    def inspect
+      if out.is_a? Array  # @todo switch from regex
+        updated_out = super.gsub(/@out=.+?(\s+|>)/, "@out=#<#{out.class}:#{Support::Utils.inspect_id(out)} #{out}>\\1")
+        
+        if inputs.any? {|inp| inp.is_a? Array }
+          str_ary_bdy = inputs.map do |inp| 
+            if inp.is_a?(Array) 
+              "#<#{inp.class}:#{Support::Utils.inspect_id(inp)} #{inp}>"
+            else
+              inp
+            end
+          end.join(', ')
+          updated_out.gsub(/@inputs=.+?(\s+|>)/, "@inputs=[#{str_ary_bdy}]\\1")
+        end || updated_out
+        
+      else
+        super
+      end
+    end
+    
+    # compares the inputs to the list or multiplexer given
+    # @param  [Multiplexer || Array<IO> || Array<Array<>>] other_mux_or_ios_or_arrays
+    # @return [Array]
+    def intersect(*other_mux_or_ios_or_arrays)
+      ios, non_fileno = self.inputs.partition {|inpt| inpt.respond_to?(:fileno) }
+      ios_fn = ios.map(&:fileno)
+      
+      non_fileno.map!(&:object_id)
+      
+      ary = other_mux_or_ios_or_arrays.respond_to?(:inputs) ? other_mux_or_ios_or_arrays.inputs : other_mux_or_ios_or_arrays
+      ary.select do |inp|
+        if inp.respond_to? :fileno
+          ios_fn.include? inp.fileno
+        else
+          non_fileno.include? inp.object_id  #default compares by #hash
+        end
+      end
+    end
+    
+   private
+    # checks to make sure that an input doesn't match an output thus causing
+    # a recursive loop, raises an error if found
+    # @raise  [ArgumentError]
+    # @return 
+    def recursive_check(arg_type=ArgumentError)
+      raise arg_type, "Recursive multiplexer `#{self}' has `#{out}' as an input and output" unless intersect(out).empty?
+    end
+  end
+end
+end

data/lib/vigilem/core/pipeline.rb

@@ -0,0 +1,68 @@
+module Vigilem
+module Core
+  # 
+  # observer of components and thier connections
+  # the catch is that input_systems don;t have an entry point
+  # for determining thier source
+  class Pipeline
+    attr_reader :device
+    
+    # 
+    # @param [#link] device most likely a Core::Device
+    def initialize(device)
+      @device = device
+      rebuild
+    end
+    
+    extend Support::ObjSpace
+    
+    # get the next item that #source
+    # is pointing to
+    # @return 
+    def succ
+      @iter ||= device
+      @iter.respond(:source)
+    end
+    
+    # the start of the pipeline
+    # @return [#source]
+    def reset_iter
+      @iter = device
+    end
+    
+    # rebuilds the cache
+    # @return [Array]
+    def rebuild
+      ary = [device]
+      while current = succ
+        ary << current
+      end
+      reset_iter
+      cache = ary
+    end
+    
+    # updates the status
+    # called when a component changes it's sauce
+    # @return [TrueClass]
+    def update
+      @changed = true
+    end
+    
+    # checks whether or not this item changed
+    # @return [TrueClass || FalseClass]
+    def changed?
+      @changed ||= false
+    end
+    
+    # @return [Array] all the components in the pipeline
+    def to_a
+      changed? ? rebuild : cache
+    end
+    
+    alias_method :to_ary, :to_a
+    
+   private
+    attr_accessor :cache
+  end
+end
+end