vigilem-core 0.0.9

data/lib/vigilem/core/eventable.rb

@@ -0,0 +1,80 @@
+module Vigilem
+module Core
+  # @abstract 
+  # contract the ensures some common event methods are available
+  module Eventable
+    # @abstract need to override read_many_nonblock, optional synchronize
+    module ReadMethods
+      
+      # @abstract 
+      # @param  [Integer] max_number_of_events=1
+      # @return [Array]
+      def read_many_nonblock(max_number_of_events=1)
+        raise NotImplemented, 'read_many_nonblock not overridden'
+      end
+      
+      # 
+      # passes to super if exists, otherwise yield makes
+      # overwriting it optional
+      def synchronize
+        if defined?(super)
+          super
+        else
+          yield
+        end
+      end
+      
+      # reads until a specified number of events have been read
+      # @param  [Integer] number_of_events=1
+      # @return [Array]
+      def read_many(number_of_events=1)
+        synchronize {
+          until (events ||= []).size == number_of_events
+            events += read_many_nonblock(number_of_events)
+          end
+          events
+        }
+      end
+      
+      # reads one Object without blocking if source is empty
+      # @return [Object]
+      def read_one_nonblock
+        synchronize {
+          read_many_nonblock.slice!(0)
+        }
+      end
+      
+      # reads one Object and blocking if source is empty
+      # @return [Object]
+      def read_one
+        synchronize {
+          read_many.slice!(0)
+        }
+      end
+    end
+    
+    include ReadMethods
+    
+    # @abstract
+    module WriteMethods
+      # @abstract 
+      # @param  [Integer] number_of_events=1
+      def write_many_nonblock(*events)
+        raise NotImplemented, 'write_many_nonblock not overridden'
+      end
+      
+      # @abstract 
+      # @param  [Integer] number_of_events=1
+      def write_many(*events)
+        raise NotImplemented, 'write_many not overridden'
+      end
+      
+      alias_method :write_one_nonblock, :write_many_nonblock
+      alias_method :write_one, :write_many
+    end
+    
+    include WriteMethods
+    
+  end
+end
+end

data/lib/vigilem/core/hooks.rb

@@ -0,0 +1,36 @@
+require 'vigilem/core/hooks/inheritable'
+
+module Vigilem::Core
+  # 
+  # extend this
+  module Hooks
+    
+    include Inheritable
+    
+    # 
+    # @param base
+    def self.extended(base)
+      # instance_level
+      base.send(:define_method, :run_hook) do |hook_name, *args, &block|
+        self.class.hooks.find {|hook| hook.name == hook_name }.run(self, *args, &block)
+      end
+    end
+    
+    # 
+    # class level
+    # finds a hook by that name and runs it
+    # @param  hook_name the hook to find
+    # @param  [Array] args arguments to be passed to the hook 
+    # @param  [Proc] block Proc to be passed to the hook
+    # @return [Hook]
+    def run_hook(hook_name, *args, &block)
+      hooks.find {|hook| hook.name == hook_name }.run(self, *args, &block)
+    end
+    
+  end
+end
+
+Vigilem::Core::HooksBase = Vigilem::Core::Hooks
+
+require 'vigilem/core/hooks/hook'
+require 'vigilem/core/hooks/conditional_hook'

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

@@ -0,0 +1,66 @@
+module Vigilem::Core::Hooks
+  # core interface for a callback
+  # @abstract
+  module Callback
+    
+    # 
+    attr_accessor :options, :result
+    
+    # @see    CallbackProc
+    # @param  [Hash] opts
+    # @param  [Proc] block
+    # @return [CallbackProc]
+    def self.new(opts={}, &block)
+      CallbackProc.new(opts, &block)
+    end
+    
+    # evaluates the Callback in the specified context
+    # @param  context
+    # @param  [Array] args 
+    # @param  [Proc] block
+    # @return [Array]
+    def evaluate(context, *args, &block)
+      self.result = if block
+          context.define_singleton_method(:__callback__, &self)
+          ret = context.send :__callback__, *args, &block
+          context.class_eval { send :remove_method, :__callback__ }
+          ret
+        else
+          context.instance_exec(*args, &self)
+        end
+    end
+    
+    alias_method :[], :evaluate
+    
+    # calls super if defined? otherwise calls to_proc.call(*args, &block)
+    # @see    Proc#call
+    # @param  [Array] args
+    # @param  [Proc] block
+    # @return result 
+    def call(*args, &block)
+      self.result = defined?(super) ? super(*args, &block) : to_proc.call(*args, &block)
+    end
+    
+    # calls super, otherwise it's just a helper
+    # @raise  [RuntimeError]
+    # @return [Proc]; this object as a Proc
+    def to_proc
+      defined?(super) ? super : raise('must overload to_proc')
+    end
+    
+    # calls super, otherwise it's just a helpful reminder
+    # @raise  [RuntimeError]
+    # @return [Proc]; this object as a Proc
+    def binding
+      defined?(super) ? super : raise('must overload binding')
+    end
+    
+   private
+    
+    # @param  res
+    # @return res
+    def result=(res)
+      @result = res
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'vigilem/core/hooks/callback'
+
+module Vigilem::Core::Hooks
+  # like a proc but with the added benifit of being called on 
+  # in a different context essentially `instance_eval'
+  class CallbackProc < Proc
+    
+    include Callback
+    
+    # 
+    # @param  [Hash] opts for meta use
+    # @param  [Proc] block proc to be converted to a CallbackProc
+    def initialize(opts={}, &block)
+      @options = opts
+      super(&block) 
+    end
+    
+    # @return [Hash]
+    def options
+      @options ||= {}
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,62 @@
+require 'vigilem/core/hooks'
+
+module Vigilem::Core::Hooks
+  # 
+  # 
+  class ConditionalHook < Hook
+    
+    # enumerate over the callbacks
+    # @param  [Array] args
+    # @param  [Proc] block
+    # @return 
+    def enumerate(args={}, &block)
+      passed, failed = [], []
+      hook = self
+      super do |callback|
+        if hook.condition.call(*callback.options[:condition_args])
+          hook.passed << callback
+          callback.evaluate(args[:context], *args[:args], &args[:block])
+        else
+          hook.failed << callback
+        end
+      end
+    end
+    
+    # 
+    # @param  [Proc] condition 
+    # @return 
+    def condition(&condition)
+      condition ? @condition = condition : @condition ||= lambda { true }
+    end
+      
+    # 
+    # @return [Array] 
+    def passed
+      @passed ||= []
+    end
+    
+    # 
+    # @return [Array] 
+    def failed
+      @failed ||= []
+    end
+    
+    # 
+    # @return [Array<Array,Array>] 
+    def status_hash
+      [[passed, failed]].hash
+    end
+    
+    # 
+    # @return 
+    def default_body
+      @default_body ||= begin
+          hook = self
+          lambda do |*args, &block|
+            hook.callbacks << CallbackProc.new({:condition_args => args }, &block)
+          end
+        end
+    end
+    
+  end
+end

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

@@ -0,0 +1,193 @@
+require 'vigilem/core/hooks/utils'
+
+require 'vigilem/core/hooks/callback_proc'
+
+require 'vigilem/core/hooks/meta_callback'
+
+module Vigilem
+module Core::Hooks
+  # 
+  # bindable group of callbacks
+  class Hook
+    
+    attr_reader :name, :options, :owner
+    
+    # @param  hook_name
+    # @param  [Hash] options
+    # @param  [Proc] config
+    def initialize(hook_name, options={}, &config)
+      @name = hook_name
+      options[:inheritable] = true if options[:inheritable].nil?
+      (@options = options).freeze
+      @callbacks = []
+      instance_eval(&config) if block_given?
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def inheritable?
+      !!@options[:inheritable]
+    end
+    
+    # 
+    # @param  callback
+    # @return 
+    def <<(callback)
+      @callbacks << (callback.is_a?(Callback) ? callback : CallbackProc.new(&callback))
+    end
+    
+    # 
+    # @see    #<<
+    # @param  [Proc] callback
+    # @return 
+    def add(&callback)
+      self << callback
+    end
+    
+    # 
+    # @param  context
+    # @return 
+    def callbacks(context=nil)
+      if context then @callbacks.reject {|cb| Utils.callback_is_in_subclass?(context, cb) } else @callbacks end
+    end
+    
+    # 
+    # @param  [Array] args
+    # @param  [Proc] block
+    # @return [Array]
+    def call(*args, &block)
+      enumerate({:args => args, :block => block }, &on_run)
+    end
+    
+    # 
+    # @param  context
+    # @param  [Array] args
+    # @param  [Proc] block
+    # @return [Array]
+    def run(context, *args, &block)
+      enumerate({:args => args, :block => block, :context => context }, &on_run)
+    end
+    
+    alias_method :evaluate, :run
+    
+    # 
+    # 
+    # @return [Proc]
+    def default_body
+      @default_body ||= begin
+          hook = self
+          lambda do |opts={}, &block|
+            raise 'block not given' unless block
+            hook.callbacks << CallbackProc.new(opts, &block)
+          end
+        end
+    end
+    
+    # @return [String]
+    def to_s
+      "#{super().chomp('>')} #{name}>"
+    end
+    
+    # @return [Array]; [name, self]
+    def to_ary
+      [self.name, self]
+    end
+    
+    # @return {name => self}
+    def to_h
+      {self.name => self }
+    end
+    
+    # 
+    # @return [Proc]
+    def to_proc
+      body()
+    end
+    
+    # @todo   Error for name collision
+    # @param  context the object to bind this hook to
+    # @return the result of the evaluation
+    def bind(context)
+      hook, hook_body = self, body()
+      self.owner = Support::Utils.get_class(context)
+      ret = context.instance_eval do
+        define_singleton_method(hook.name, &hook_body)
+      end
+      owner.hooks << hook
+      ret
+    end
+    
+    # uses define_method instead
+    # of define_singleton_method like bind!
+    # 
+    # hmm I could have one hook that spans multiple instances, bad or good?
+    # doesn't work with @owner
+    # @param  [Class] klass
+    # @return 
+    def generate(klass)
+      hook, hook_body = self, body()
+      self.owner = klass
+      ret = klass.instance_eval do
+        define_method(hook.name, &hook_body)
+      end
+      klass.hooks << hook
+      ret
+    end
+    
+    class << self
+      
+      # 
+      # @param  [Array<Callback>] call_backs
+      # @param  [Array] args
+      # @param  [Proc] block
+      # @return [Array]
+      def enumerate(call_backs, args={}, &block)
+        call_backs.inject([]) do |results, callback|
+          mcb = MetaCallback.new(callback)
+          if block
+            yield(mcb)
+          elsif args.has_key?(:context)
+            mcb.evaluate(args[:context], *args[:args], &args[:block])
+          else
+            mcb.call(*args[:args], &args[:block])
+          end
+          results << mcb.result if mcb.ran?
+          results
+        end
+      end
+    end
+    private_class_method :enumerate
+    
+   private
+    
+    attr_writer :owner
+    
+    # 
+    # @param  [Hash] args
+    # @param  [Proc] block
+    # @return [Array]
+    def enumerate(args={}, &block)
+      self.class.send :enumerate, callbacks(args[:context]), args, &block
+    end
+    
+    # 
+    # @param  [Proc] block
+    # @return [Proc] 
+    def on_run(&block)
+      @on_run = block
+    end
+    
+    # 
+    # @param  [Proc] block
+    # @return [Proc]
+    def body(&block)
+      if block
+        @body = block
+      else
+        @body ||= default_body
+      end
+    end
+    
+  end
+end
+end