vigilem-core 0.0.9

data/lib/vigilem/core/default_buffer.rb

@@ -0,0 +1,45 @@
+require 'delegate'
+
+require 'vigilem/core/buffer'
+
+module Vigilem
+module Core
+  # 
+  class DefaultBuffer < ::SimpleDelegator
+    include Buffer
+    
+    # 
+    # @param [#slice!] type
+    def initialize(type=[])
+      super(type)
+    end
+    
+    # like new except type is not optional
+    # and passes through an object that is 
+    # already of self type
+    # @param  type
+    # @return [DefaultBuffer]
+    def self.wrap(type)
+      if type.is_a? self      
+        type
+      else
+        new(type)
+      end
+    end
+    
+    # 
+    # @param  other_obj
+    # @return [TrueClass || FalseClass]
+    def ==(other_obj)
+      super(other_obj) || 
+        __getobj__ == other_obj.respond.__getobj__
+    end
+    
+    # 
+    # @return [String]
+    def inspect
+      "#<#{self.class}:0x#{object_id} #{super}>"
+    end
+  end
+end
+end

data/lib/vigilem/core/demultiplexer.rb

@@ -0,0 +1,225 @@
+require 'observer'
+
+require 'thread_safe'
+
+require 'vigilem/support/core_ext'
+
+require 'vigilem/support/obj_space'
+
+require 'vigilem/support/lazy_simple_delegator'
+
+require 'vigilem/core/multiplexer'
+
+module Vigilem
+module Core
+  # #shift's from input and distributes it to the 
+  # observers
+  class Demultiplexer
+    include Observable
+    
+    extend Support::ObjSpace
+    
+    attr_accessor :input
+    
+    alias_method :source, :input
+    alias_method :source=, :input=
+    
+    # 
+    # @param  [Array<Array<observer_object, Hash{@see #add_observer}>>] observers
+    # @param  [(Buffer) #slice!] input_source
+    def self.new(input_source=nil, observers=[])
+      obj_register(super(input_source, observers))
+    end
+    
+    # 
+    # @param  [Array<Array<observer_object, Hash{@see #add_observer}>>] observers
+    # @param  [(Buffer) #shift] input_source
+    def initialize(input_source=nil, observers=[])
+      @input = input_source
+      
+      add_observers(observers)
+    end
+    
+    # the peers without the Delegators
+    # @return [Array]
+    def observers
+      _observers.map {|obj| obj.respond(:peel) || obj }
+    end
+    
+    alias_method :outputs, :observers
+    
+    # 
+    # @return [Array]
+    def _observers
+      (@observer_peers ||= ThreadSafe::Hash.new).keys
+    end
+    
+    alias_method :_outputs, :_observers
+    
+    # @see    Observable#add_observer
+    # @param  [Hash] event_opts
+    # @option :func
+    # @option :type [Integer]
+    # @option :types [Array<Integer>]
+    # @option :device_name [Regexp]
+    # @option :device_names [Array<Regexp>]
+    # @option :device [File]
+    # @option :devices [Array<File>]
+    # @return [Array] [event_opts]
+    def add_observer(observer, event_opts={})
+      observer = Support::LazySimpleDelegator.new(observer).use_strict_eql if observer.is_a? Array
+      _observers
+      unless observer.respond_to?(event_opts[:func] ||= :update)
+        raise NoMethodError, "observer does not respond to `#{func.to_s}'"
+      end
+      @observer_peers[observer] = event_opts
+    end
+    
+    alias_method :add_output, :add_observer
+    
+    # @see    Observable#add_observer
+    # @param  [Array<Array<observer_object, Hash{@see add_observer}>>]
+    # @return [Array]
+    def add_observers(observers_and_opts)
+      observers_and_opts.map do |(obs, hsh)|
+        add_observer(*[obs, hsh].compact)
+      end
+    end
+    
+    alias_method :add_outputs, :add_observers
+    
+    # 
+    # @see    Object#inspect
+    # @return [String]
+    def inspect
+      if input.is_a? Array  # @todo switch from regex
+        super.gsub(/@input=.+?(\s+|>)/, "@input=#<#{input.class}:#{Support::Utils.inspect_id(input)} #{input}>\\1")
+      else
+        super
+      end
+    end
+    
+    # 
+    # @return [Monitor]
+    def semaphore
+      if defined? super
+        super
+      else
+        @semaphore ||= Monitor.new
+      end
+    end
+    
+    # gets events from input and notifies_observers
+    # @param  [Integer] max_number_of_events
+    # @return 
+    def demux(max_number_of_events=1)
+      semaphore.synchronize {
+        events = input.shift(max_number_of_events)
+        changed
+        notify_observers(*events)
+      }
+    end
+    
+    # 
+    # @see    Observable#notify_observers
+    # @param  [Array]
+    # @return [TrueClass || FalseClass]
+    def notify_observers(*events)
+      if defined? @observer_state and @observer_state
+        if defined? @observer_peers
+          @observer_peers.each do |k, event_opts|
+            filtered = self.class.filter_events(events, event_opts)
+            k.send event_opts[:func], filtered unless filtered.empty?
+          end
+        end
+        @observer_state = false
+      end
+    end
+    
+    alias_method :sweep, :notify_observers
+    alias_method :notify_outputs, :notify_observers
+    
+    # 
+    # @param  [Array] events
+    # @param  [Hash{@see #add_observer}] event_opts
+    # @return [Array]
+    def filter_events(events, event_opts)
+      self.class.filter_events(events, event_opts)
+    end
+    
+    class << self
+      
+      # 
+      # @param  base
+      # @return 
+      def inherited(base)
+        base.extend Support::ObjSpace
+      end
+      
+      # 
+      # @param  [Array<#metadata, #type>] events
+      # @param  [Hash{@see #add_observer}] event_opts
+      # @return [Array]
+      def filter_events(events, event_opts)
+        events.select do |event|
+          opts = event_opts.select {|k,v| event_option_names.include? k }
+          if opts.empty?
+            event
+          else
+            opts.all? do |opt,v|
+              opt_vals = [v].flatten
+              case opt.to_s
+              when /^devices?$/
+                opt_vals.any? do |dev| 
+                  if (src = event.metadata[:source])
+                    File.identical?(dev, src)
+                  end
+                end
+              when /^device_names?$/
+                opt_vals.any? {|dev_name| event.metadata[:source].respond.name =~ dev_name }
+              when /^types?$/
+                opt_vals.any? {|ev_type| event.type == ev_type }
+              end
+            end
+            
+          end # else
+          
+        end
+      end
+      
+      # like first_or_new
+      # @return [Demultiplexer]
+      def acquire(input_source=nil, observers=[], &block)
+        found = all.find(&block)
+        if found
+          found.add_observers(observers)
+        else
+          new(input_source, observers)
+        end
+      end
+      
+      # 
+      # @return [Hash]
+      def same_source_check
+        all.group_by do |dem| 
+          dem.respond(:fileno) || dem
+        end.select {|k, v| v.size > 1 }
+      end
+      
+      # 
+      # @return [Array<Symbol>]
+      def event_option_names
+        @event_option_names ||=  option_names - [:func]
+      end
+      
+      # 
+      # @return [Array<Symbol>]
+      def option_names
+        @options ||= [:func, :type, :types, :device_name, :device_names, :device, :devices]
+      end
+      
+    end
+  end
+  
+end
+end

data/lib/vigilem/core/device.rb

@@ -0,0 +1,43 @@
+require 'vigilem/core/abstract_device'
+
+require 'vigilem/core/hooks'
+
+require 'vigilem/core/system'
+
+module Vigilem
+module Core
+  # 
+  # hooks for loading the pipeline
+  # errors when no :system_check has passed
+  # @todo more configurable facade so not all methods from
+  #       underlying object get through
+  class Device < AbstractDevice
+    
+    # 
+    # @param  [Array] args
+    # @param  [Proc] config
+    # @return 
+    def self.new(*args, &config)
+      if block_given?
+        (ret = Class.new(self)).instance_eval(&config)
+        ret
+      else
+        super(*args)
+      end
+    end
+    
+    Hooks::ConditionalHook.new(:on_os, :type => :system_check) do
+      condition {|name_or_regex| System.check[:os].call(name_or_regex) }
+    end.bind(self)
+    
+    Hooks::ConditionalHook.new(:on_input_system, :type => :system_check) do
+      condition {|name_or_regex| System.check[:input_system].call(name_or_regex) }
+    end.bind(self)
+    
+    after_init do |dev|
+      raise 'Device not compatible on this system' unless dev.available?
+    end
+    
+  end
+end
+end

data/lib/vigilem/core/event_handler.rb

@@ -0,0 +1,156 @@
+require 'forwardable'
+
+require 'active_support/concern'
+
+module Vigilem
+module Core
+  # 
+  # 
+  module EventHandler
+    
+    extend Forwardable
+    
+    extend ActiveSupport::Concern
+    
+    # 
+    # 
+    module Utils
+      
+      # 
+      # @param  [#to_s] namespace
+      # @return [String] 
+      def snakecase_class_name(namespace)
+        namespace.to_s.split('::').last.snakecase
+      end
+      
+      # 
+      # @param  [Symbol] sym
+      # @return [TrueClass || FalseClass]
+      def respond_to?(sym, include_all=false)
+        on_format?(sym.to_s) || super(sym, include_all)
+      end
+      
+      # does the string passed in start with 'on_'
+      # @param  [String] str
+      # @return [TrueClass || FalseClass]
+      def on_format?(str)
+        str.start_with?('on_')
+      end
+      
+      # converts a "on_String" => :String
+      # @param  [String] on_name
+      # @return [Symbol]
+      def type_from_on_format(on_name)
+        on_name.split('on_', 2).last.to_sym
+      end
+    end
+    
+    include Utils
+    extend Utils
+    
+    module ClassMethods
+      
+      include Utils
+      
+      # @todo   Fuzzy is_a? Hash key lookup
+      # @return [Hash]
+      def type_handles
+        @type_handles ||= {} 
+      end
+      
+      # 
+      # sets the default_handler, if called without a block, just
+      # assigns the default handler to a "default"
+      # @param  [Proc] block
+      # @return [Proc]
+      def default_handler(&block)
+        type_handles.default = (block || lambda {|*args, &block| })
+      end
+      
+      # @todo module_function
+      # configures how this event handler handles an event
+      # @param  type
+      # @return [Proc] the block given/registered
+      def on(type, opts={}, &block)
+        type_name = snakecase_class_name(type)
+        on_method = send(:_define_register, type, type_name)
+        type_handles[type] = send(:_define_handler, type_name, &block)
+        on_method.call(&block)
+      end
+      
+      alias_method :register_handle, :on
+      
+     private
+      
+      # defines `on_#{event_type}'
+      # @param   type
+      # @param  [String] type_name
+      # @param  [Proc] block
+      # @return [Method]
+      def _define_register(type, type_name)
+        define_singleton_method(on_method_name = :"on_#{type_name}") {|opts={}, &blk| type_handles[type] = blk }
+        define_method(on_method_name) {|opts={}, &blk| self.class.send(on_method_name, opts, &blk) }
+        method(on_method_name)
+      end
+      
+      # defines `handle_#{event_type}'
+      # @param  [String] type
+      # @param  [Proc] block
+      # @return [Proc]
+      def _define_handler(type_name, &block)
+        define_method(handler_name = :"handle_#{type_name}", &block)
+        block
+      end
+      
+    end
+    
+    # 
+    # @return [Hash]
+    def type_handles
+      self.class.type_handles
+    end
+    
+    # to trigger the handling, either use handle(event, opts={}) or handle_#{type}
+    # configures how this event handler handles an event
+    # @param  [#to_s] type
+    # @return [Proc] the block given/registered
+    def on(type, &block)
+      define_singleton_method(on_method_name = :"on_#{class_name = snakecase_class_name(type)}") {|&blk| type_handles[type] = blk }
+      ret = send on_method_name, &block
+      define_singleton_method(handler_name = :"handle_#{class_name}", &type_handles[type])
+      ret
+    end
+    alias_method :register_handle, :on
+    
+    # 
+    # @param  event, the event to handle
+    # @param  [Array] 
+    # @return results of the Proc registered to the type_handless
+    def handle(event, *args, &block)
+      if handler = type_handles[event.class]
+        handler.call(event, *args, &block)
+      end
+    end
+    
+    # 
+    # @param  event, the event to handle
+    # @param  [Array] 
+    # @return results of the Proc registered to the type_handless 
+    def handle!(event, *args, &block)
+      if ret = handle(event, *args, &block)
+        ret
+      else
+        raise NotImplementedError, "No handler found for #{key.class}:#{key},#{block} and no default handler set"
+      end
+    end
+    
+    #
+    # @param  [Proc]
+    # @return 
+    def default_handler(&block)
+      self.class.default_handler(&block)
+    end
+    
+  end
+end
+end