vigilem-core 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f7e0fb9fd7b92605d1955856208831867a90b48
+  data.tar.gz: 091edf82db552c23f118d102c0794a6aba48ad04
+SHA512:
+  metadata.gz: f9775f83362a45b3504895d8a07325e59ed645e31e398d3081e9ed9101ce8b27aa9c72f161b1421c372812416607bcd0900c29fe9225a56fe9bbf2943407eb20
+  data.tar.gz: 0809ddb3e7428936737ddcbcb1e1611cd173563376add3b2ae11b623354e06987995555950ab2aceebb5335ad084b4266c3768453221168279249dd6e198776b

data/lib/vigilem/core.rb

@@ -0,0 +1,9 @@
+
+require 'vigilem/support'
+
+# req's Core::System
+require 'vigilem/core/device'
+
+require 'vigilem/core/input_system_handler'
+
+require 'vigilem/core/event_handler'

data/lib/vigilem/core/abstract_device.rb

@@ -0,0 +1,97 @@
+require 'vigilem/support/core_ext'
+
+require 'vigilem/support/obj_space'
+
+require 'vigilem/core/hooks'
+
+require 'vigilem/support/lazy_simple_delegator'
+
+require 'vigilem/core/adapters/adapter'
+
+module Vigilem
+module Core
+  # 
+  class AbstractDevice < Support::LazySimpleDelegator
+    
+    extend Hooks
+    
+    include Adapters::Adapter
+    
+    extend Support::ObjSpace
+    
+    class << self
+      # @param [Array] args
+      # @param [Proc] block
+      def new(*args, &block)
+        ret = obj_register(super(*args, &block))
+        run_hook(:after_init, ret)
+        ret
+      end
+      
+      # 
+      # @param  [Class] base
+      # @return 
+      def inherited(base)
+        super(base)
+        hooks.select(&:inheritable?).each do |hook|
+          base.instance_eval do
+            define_method(hook.name, &hook)
+          end
+        end
+      end
+      
+    end
+    
+    Hooks::Hook.new(:after_init).bind(self)
+    
+    after_init do |dev|
+      dev.run_system_checks
+    end
+    
+    # calls all the hooks with options[:type] == :system_check
+    # @return [Array<Hook>] the hooks that ran
+    def run_system_checks
+      self.class.hooks.select {|hook| hook.options[:type] == :system_check }.map do |hook|
+        run_hook hook.name
+      end
+    end
+    
+    # the Callbacks that passed/ran
+    # @return [Array<CallBack>]
+    def settings
+      hks = self.class.hooks
+      passed_hooks = hks.select {|hk| hk.respond_to?(:passed) }
+      if _hooks_status_hash_cache_ != (nw_hash = passed_hooks.map(&:status_hash).join)
+        @settings = hks.select {|hook| setting?(hook) }.compact
+        _hooks_status_hash_cache_ = nw_hash
+      end
+      @settings
+    end
+    
+    # test whether or not a hook is a setting
+    # @param [Hook] hook the hook to test
+    # @return [TrueClass || FalseClass]
+    def setting?(hook)
+      conditional = hook.respond_to?(:passed)
+      (not conditional) or (conditional and not hook.passed.empty?)
+    end
+    
+    # if any system_checks pass this device is available
+    # @return [TrueClass || FalseClass] whether or not it's available
+    def available?
+      self.settings.any? {|name, hook| hook.options[:type] == :system_check }
+    end
+    
+    # 
+    # @param  obj
+    # @return 
+    def import(obj)
+      self.link = obj
+      __setobj__(obj)
+    end
+    
+   private
+    attr_accessor :_hooks_status_hash_cache_
+  end
+end
+end

data/lib/vigilem/core/adapters.rb

@@ -0,0 +1,2 @@
+require 'vigilem/core/adapters/adapter'
+require 'vigilem/core/adapters/buffered_adapter'

data/lib/vigilem/core/adapters/adapter.rb

@@ -0,0 +1,57 @@
+require 'forwardable'
+
+require 'thread'
+
+require 'active_support/concern'
+
+require 'vigilem/support/core_ext'
+
+require 'vigilem/core/lockable_pipeline_component'
+
+require 'vigilem/core/adapters/basic_adapter'
+
+module Vigilem
+module Core
+module Adapters
+  # 
+  module Adapter
+    
+    extend ActiveSupport::Concern
+    
+    include BasicAdapter
+    
+    include LockablePipelineComponent
+    
+    # 
+    # @param  link
+    def initialize_adapter(lnk=nil)
+      initialize_basic_adapter(lnk)
+    end
+    
+    # 
+    # 
+    module ClassMethods
+      include Forwardable
+    end
+    
+    # 
+    # @param  src
+    # @param  [Hash] opts, future use
+    # @return self
+    def attach(src, opts={})
+      self.link = src
+      self
+    end
+    
+    # 
+    # @param  src
+    # @param  [Hash] opts, future use
+    # @return link
+    def affix(src, opts={})
+      self.link = src
+    end
+    
+  end
+end
+end
+end

data/lib/vigilem/core/adapters/basic_adapter.rb

@@ -0,0 +1,43 @@
+require 'observer'
+
+module Vigilem
+module Core
+module Adapters
+  # 
+  # 
+  module BasicAdapter
+    
+    include Observable
+    
+    # 
+    # @param  lnk value to assign to @link, defaults to nil
+    def initialize_basic_adapter(lnk=nil)
+      @link = lnk
+    end
+    
+    # 
+    # @param  value
+    # @return 
+    def link=(value)
+      @link = value
+      changed
+      notify_observers('link', @link)
+      @link
+    end
+    
+    # source is more dynamic than link,
+    # i.e. and input system handler can have multiple sources
+    # or get it's info from a demultiplexer, yet have no direct #link
+    def source
+      @source || link()
+    end
+    
+   private
+    
+    # the direct item next in line
+    attr_reader :link
+    
+  end
+end
+end
+end

data/lib/vigilem/core/adapters/buffered_adapter.rb

@@ -0,0 +1,28 @@
+require 'vigilem/core/adapters/adapter'
+
+require 'vigilem/core/buffer_handler'
+
+module Vigilem
+module Core
+module Adapters
+  # 
+  module BufferedAdapter
+    
+    include Vigilem::Core::Adapters::Adapter
+    
+    include BufferHandler
+    
+    extend ActiveSupport::Concern
+    
+    #
+    # @param  lnk
+    # @param  buffer_type
+    def initialize_buffered(lnk=nil, buffer_type=[])
+      initialize_adapter(lnk)
+      initialize_buffer_handler(buffer_type)
+    end
+    
+  end
+end
+end
+end

data/lib/vigilem/core/buffer.rb

@@ -0,0 +1,151 @@
+require 'vigilem/support/core_ext'
+
+require 'vigilem/support/utils'
+
+module Vigilem
+module Core
+  # 
+  # @abstract
+  # minimum compliance #concat, #slice!, #peek
+  # buffers are typically String or Array
+  module Buffer
+    
+    # 
+    # @param  start_idx_range
+    # @param  [Integer] len
+    # @return 
+    def slice(start_idx_range, len=nil)
+      _super_check((method_name = __method__), nil, *[start_idx_range, *len]) do
+        self.deep_dup.slice!(start_idx_range, len)
+      end
+    end
+    
+    # 
+    # used because it's available on both String and Array
+    # maybe drop this in favor of shift...
+    # @param  [Integer || Range] start_idx_range
+    # @param  [Integer] len
+    # @return 
+    def slice!(start_idx_range, len=nil)
+      _super_check_fail_on_error(__method__, nil, *[start_idx_range, *len])
+    end
+    
+    # 
+    # @return 
+    def shift(n=nil)
+      _super_check(__method__, nil, *n) do
+        slice!(0, *n)
+      end
+    end
+    
+    # @todo   memoization
+    # @raise  [RuntimeError] 
+    # @return 
+    def peek
+      _super_check(__method__) do
+        if (enum = respond(:each)).respond_to? :peek
+          enum.peek
+        else
+          _super_check_fail_on_error(__method__)
+        end
+      end
+    end
+    
+    # 
+    # @param  other_ary
+    # @return 
+    def concat(other_buffer)
+      _super_check_fail_on_error(__method__, nil, other_buffer)
+    end
+    
+    # 
+    # @param  [Integer] len
+    # @return [Array<Object, Integer>] [obj #slice!ed, remainder of len]
+    def offset!(len)
+      Support::Utils.offset!(self, len)
+    end
+    
+    # 
+    # @param  [Integer] len
+    # @return [Array<Object, Integer>] [obj #slice!ed, remainder of len]
+    def offset(len)
+      Support::Utils.offset(self, len)
+    end
+    
+    # 
+    # @param  [Integer] num
+    # @raise  [ArgumentError] 
+    # @return 
+    def pop(num=nil)
+      _super_check((method_name = __method__), nil, *num) do
+        raise ArgumentError, 'negative array size' if num < 0
+        ret = slice!(-num, num)
+        if num.nil? then slice!(-num, num) else Support::Utils.unwrap_ary(ret) end
+      end
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def empty?
+      _super_check(__method__) do
+        begin
+          !!peek
+        rescue StopIteration
+          false
+        end
+      end
+    end
+    
+    # 
+    # @raise  [TypeError]
+    # @return [Buffer]
+    def deep_dup
+      _super_check(__method__) do
+        Support::Utils.deep_dup(self)
+      end
+      rescue TypeError
+        raise "#{self} does not respond_to? :slice, :deep_dup, :_dump and no :_dump_data is defined for class #{self.class}"
+    end
+    
+    # 
+    # @param  
+    # @return [DefaultBuffer]
+    def self.new(type=[])
+      require 'vigilem/core/default_buffer'
+      DefaultBuffer.new(type)
+    end
+    
+   private
+    
+    # 
+    # @param  [Symbol] method_name
+    # @param  [Proc] arg_block
+    # @param  [Array] args
+    # @raise  [RuntimeError] 
+    # @return 
+    def _super_check_fail_on_error(method_name, arg_block=nil, *args)
+      _super_check(method_name, arg_block, *args) do
+        raise NoMethodError, "This #{self.inspect} does not respond_to? :#{method_name}"
+      end
+    end
+    
+    # checks to see if the method has a super
+    # if it does, it calls it, else executes the otherwise block
+    # @param  [Symbol] method_name
+    # @param  [Proc] arg_block
+    # @param  [Array] args
+    # @param  [Proc] otherwise
+    # @return 
+    def _super_check(method_name, arg_block=nil, *args, &otherwise)
+      if (obj = respond(:__getobj__)).respond_to?(method_name)
+        obj.method(method_name).call(*args, &arg_block)
+      elsif (supa = self.class.superclass).method_defined?(method_name)
+        supa.instance_method(method_name).bind(self).call(*args, &arg_block)
+      else
+        otherwise.call
+      end
+    end
+    
+  end
+end
+end

data/lib/vigilem/core/buffer_handler.rb

@@ -0,0 +1,95 @@
+require 'monitor'
+
+require 'thread_safe'
+
+require 'vigilem/core/default_buffer'
+
+module Vigilem
+module Core
+  # 
+  module BufferHandler
+    
+    attr_accessor :buffers
+    
+    # @todo  set default buffer type to with somthing like Queue
+    # @todo  allow buffer_type argument to be a buffer object 
+    #        instead of a delegation to DefaultBuffer
+    # @param buffer_type
+    def initialize_buffer_handler(buffer_type=[])
+      (@buffers ||= ThreadSafe::Hash.new)[:default] = Buffer.new(buffer_type)
+    end
+    
+    # 
+    # @return [Monitor]
+    def semaphore
+      if defined? super
+        super
+      else
+        @semaphore ||= Monitor.new
+      end
+    end
+    
+    # 
+    # @param  [Symbol] name, defaults to :default
+    # @param  type, defaults to nil
+    # @return [Buffer]
+    def buffer(name=:default, type=nil)
+      raise "default buffer not initialised, call #initialize_buffer_handler or #buffer=" unless buffers
+      if type
+        buffers[name] ||= Buffer.new(type)
+      else
+        buffers[name]
+      end
+    end
+    
+    alias_method :inbox, :buffer
+    
+    # needed for peek
+    # @param  [Integer] len
+    # @param  [Symbol] buffer_name
+    # @param  [Proc] block
+    # @return 
+    def buffered(len, buffer_name=:default, opts={}, &block)
+      semaphore.synchronize {
+        ret, still_to_get = buffer(buffer_name, opts[:type]).offset(len)
+        if still_to_get > 0
+          src_data = Support::Utils.send_all_or_no_args(block, still_to_get)
+          called_for = src_data.slice!(0, still_to_get)
+          ret.concat(called_for)
+        end
+        ret
+      }
+    end
+    
+    # buffers the block, by taking len from the buffer
+    # and calling the block for the remaining
+    # @param  [Integer] len
+    # @param  [Symbol] buffer_name
+    # @param  [Proc] block
+    # @return 
+    def buffered!(len=nil, buffer_name=:default, opts={}, &block)
+      semaphore.synchronize {
+        ret, still_to_get = buffer(buffer_name, opts[:type]).offset!(len)
+        if still_to_get > 0
+          src_data = Support::Utils.send_all_or_no_args(block, still_to_get)
+          called_for = src_data.slice!(0, still_to_get)
+          ret.concat(called_for)
+          buffer(buffer_name).concat(src_data)
+        end
+        ret
+      }
+    end
+    
+   private 
+    
+    # 
+    # @param  set_val
+    # @return 
+    def buffer=(set_val)
+      @buffers[:default] = set_val
+    end
+    
+    alias_method :inbox=, :buffer=
+  end
+end
+end