cancer 0.1.0.a1

data/lib/cancer/events/abstract_event.rb

@@ -0,0 +1,10 @@
+
+module Cancer
+  module Events
+    
+    # The abstract base class for all events.
+    class AbstractEvent
+    end
+    
+  end
+end

data/lib/cancer/events/base_matchers.rb

@@ -0,0 +1,63 @@
+
+module Cancer
+  module Events
+    
+    # The abstract base class for all event matchers.
+    class Matcher
+      
+      # test if an event macthes the matcher.
+      # @param [Cancer::Events::AbstractEvent] event the event to test
+      # @return [true, false] returns true if the event matches self. otherwise it returns false.
+      def match?(event)
+        true
+      end
+      
+      # matches any events which exclusivly match self or other.
+      # @param [Cancer::Events::Matcher] other the other macther
+      # @return [Cancer::Events::XorMatcher] the new matcher
+      def ^(other)
+        Cancer::Events::XorMatcher.new(self, other)
+      end
+      
+      # matches any events which match self or other.
+      # @param [Cancer::Events::Matcher] other the other macther
+      # @return [Cancer::Events::OrMatcher] the new matcher
+      def |(other)
+        Cancer::Events::OrMatcher.new(self, other)
+      end
+      
+      # matches any events which match self and other.
+      # @param [Cancer::Events::Matcher] other the other macther
+      # @return [Cancer::Events::AndMatcher] the new matcher
+      def &(other)
+        Cancer::Events::AndMatcher.new(self, other)
+      end
+      
+      # matches any events which match not self
+      # @return [Cancer::Events::NotMatcher] the new matcher
+      def invert!
+        Cancer::Events::NotMatcher.new(self)
+      end
+      
+    end
+    
+    class UnaryMatcher < Cancer::Events::Matcher
+      def initialize(a)
+        @a = a
+      end
+    end
+    
+    class BinaryMatcher < Cancer::Events::Matcher
+      def initialize(a, b)
+        @a, @b = a, b
+      end
+    end
+    
+    class AnyMatcher < Cancer::Events::Matcher
+      def match?(event)
+        true
+      end
+    end
+    
+  end
+end

data/lib/cancer/events/binary_matchers.rb

@@ -0,0 +1,30 @@
+
+module Cancer
+  module Events
+    
+    class OrMatcher < Cancer::Events::BinaryMatcher
+      def match?(event)
+        @a.match?(event) or @b.match?(event)
+      end
+    end
+    
+    class XorMatcher < Cancer::Events::BinaryMatcher
+      def match?(event)
+        @a.match?(event) ^ @b.match?(event)
+      end
+    end
+    
+    class AndMatcher < Cancer::Events::BinaryMatcher
+      def match?(event)
+        @a.match?(event) and @b.match?(event)
+      end
+    end
+    
+    class NotMatcher < Cancer::Events::UnaryMatcher
+      def match?(event)
+        !@a.match?(event)
+      end
+    end
+    
+  end
+end

data/lib/cancer/events/eventable.rb

@@ -0,0 +1,92 @@
+
+module Cancer
+  module Events
+    module Eventable
+      
+      def self.included(base)
+        base.extend Cancer::Events::Eventable::ClassMethods
+      end
+      
+      def event_manager
+        @manager
+      end
+      
+      def on(method, *args, &proc)
+        matcher, options = *args
+        if Hash === matcher and options.nil?
+          matcher, options = options, matcher
+        end
+        matcher = (matcher || proc)
+        handler = @manager.on(matcher, method(method.to_sym), options)
+        registered_handlers.push(handler)
+      end
+      
+      def fire!(*args)
+        @manager.fire!(*args)
+      end
+      
+      def register_with(manager)
+        raise "can only register with a single manager!" if @manager
+        @manager = manager
+        self.class.send(:evented_methods).each do |(m, condition, options)|
+          m = m.bind(self)
+          handler = @manager.on(condition, m, options)
+          registered_handlers.push(handler)
+        end
+        self
+      end
+      
+      def unregister!
+        registered_handlers.each do |handler|
+          @manager.unregister_handler(handler)
+        end
+        @manager = nil
+      end
+      
+      def registered_handlers
+        @registered_handlers ||= []
+      end
+      
+      module ClassMethods
+        def register_new_instance_with(manager, *args, &proc)
+          register_instance_with new(*args, &proc)
+        end
+        
+        def register_instance_with(manager, instance)
+          instance.register_with manager
+        end
+        
+      private
+        
+        def evented_methods
+          @evented_methods ||= (super rescue [])
+        end
+        
+        def method_added(m)
+          if @event_options
+            private m
+            @event_options[:priority] ||= @default_handler_priority if @default_handler_priority
+            evented_methods.push([instance_method(m), @event_condition, @event_options])
+            @event_condition = nil
+            @event_options = nil
+          end
+        end
+        
+        def priority(priority)
+          @default_handler_priority = priority.to_i
+        end
+        
+        def on(*args, &proc)
+          matcher, options = *args
+          if Hash === matcher and options.nil?
+            matcher, options = options, matcher
+          end
+          matcher = (matcher || proc)
+          @event_condition = matcher
+          @event_options   = options || {}
+        end
+      end
+      
+    end
+  end
+end

data/lib/cancer/events/exception_events.rb

@@ -0,0 +1,28 @@
+
+module Cancer
+  module Events
+    
+    class ExceptionMatcher < Cancer::Events::Matcher
+      
+      def initialize(klass, message=nil)
+        @klass = klass
+        @message = message
+      end
+      
+      def match?(event)
+        ((ExceptionEvent === event) and
+         (@klass === event.exception) and
+         (@message ? (@message === event.exception.message) : true))
+      end
+      
+    end
+    
+    class ExceptionEvent < Cancer::Events::AbstractEvent
+      attr_reader :exception
+      def initialize(exception)
+        @exception = exception
+      end
+    end
+    
+  end
+end

data/lib/cancer/events/handler.rb

@@ -0,0 +1,33 @@
+
+module Cancer
+  module Events
+    class Handler
+      
+      attr_reader :proc, :options
+      
+      def initialize(proc, options={})
+        @options = { :mode => :inline, :priority => 200 }.merge(options || {})
+        @proc    = proc
+        @mutex   = Mutex.new
+      end
+      
+      def run(manager, event)
+        case @proc.arity
+        when 0 then @proc.call()
+        when 1 then @proc.call(event)
+        end
+      end
+      
+      def <=>(other)
+        raise TypeError, 'no an EventHandler' unless Cancer::Events::Handler === other
+        cmp = @options[:priority] <=> other.options[:priority]
+        (cmp == 0 ? (@options[:sequence] <=> other.options[:sequence]) : cmp)
+      end
+      
+      def single_use?
+        !!@options[:single_use]
+      end
+      
+    end
+  end
+end

data/lib/cancer/events/manager.rb

@@ -0,0 +1,130 @@
+
+module Cancer
+  module Events
+    class Manager
+      
+      # Build a new event manager
+      # @option options [Fixnum] :size the size of the thread pool
+      def initialize(options={})
+        @matchers = []
+        @queue    = Cancer::ThreadPool.new(options[:size] || 10) do |event|
+          handle_event(event)
+        end
+        @queue.on_exception do |e|
+          fire!(Cancer::Events::ExceptionEvent, e)
+        end
+      end
+      
+      def use(app, *args, &proc)
+        raise TypeError unless app.included_modules.include?(Cancer::Events::Eventable)
+        app.register_new_instance_with(self, *args, &proc)
+      end
+      
+      def on(matcher, proc=nil, options={}, &block)
+        options ||= {}
+        
+        options = options.merge(:sequence => @matchers.size)
+        handler = Cancer::Events::Handler.new(proc || block, options)
+        @matchers.push([matcher, handler])
+        @matchers.sort! { |(ma, ha), (mb, hb)| ha <=> hb }
+        handler
+      end
+      
+      def resolve_martchers!
+        @matchers.each do |pair|
+          pair[0] = case pair[0]
+          when Cancer::Events::Matcher then pair[0]
+          when Proc                    then pair[0].call(DSL.new)
+          end
+        end
+      end
+      
+      def unregister_handler(handler)
+        @matchers.delete_if do |m,h|
+          h == handler
+        end
+      end
+      
+      def fire!(event_or_class, *args)
+        event = (Class === event_or_class ? event_or_class.new(*args) : event_or_class)
+        @queue.push(event)
+      end
+      
+      def deferred(*args, &proc)
+        @queue.defer(*args, &proc)
+      end
+      
+      def start!
+        @queue.start!
+      end
+      
+      def stop!
+        @queue.stop!
+      end
+      
+      def handle_event(event)
+        Thread.current[:event] = event
+        @matchers.dup.each do |pair|
+          matcher, handler = *pair
+          next if matcher.nil?
+          Thread.current[:event_matcher] = matcher
+          Thread.current[:event_handler] = handler
+          if matcher.match?(event)
+            should_break = !no_break? do
+              handler.run(self, event)
+            end
+            
+            if Thread.current[:remove_current_handler] or handler.single_use?
+              @matchers.delete(pair)
+              Thread.current[:remove_current_handler] = false
+            end
+            
+            if should_break
+              break
+            end
+          end
+        end
+      end
+      
+      def no_break?
+        !!catch(:halt) do 
+          catch(:skip) do
+            yield
+          end
+          true
+        end
+      end
+      
+      def self.remove_current_handler!
+        Thread.current[:remove_current_handler] = true
+      end
+      
+      class DSL
+        def xpath(xpath, ns=nil)
+          Cancer::Events::XPathMatcher.new(xpath, ns)
+        end
+        
+        def name(name)
+          Cancer::Events::NamedMatcher.new(name)
+        end
+        
+        def exception(klass, message=nil)
+          Cancer::Events::ExceptionMatcher.new(klass, message)
+        end
+        
+        def not(matcher)
+          matcher.invert!
+        end
+        
+        def any
+          Cancer::Events::AnyMatcher.new()
+        end
+        
+        def proc(proc=nil, &block)
+          Cancer::Events::ProcMatcher.new(proc || block)
+        end
+      end
+      
+    end
+  end
+end

data/lib/cancer/events/named_events.rb

@@ -0,0 +1,25 @@
+
+module Cancer
+  module Events
+    
+    class NamedMatcher < Cancer::Events::Matcher
+      
+      def initialize(name)
+        @name = name.to_sym
+      end
+      
+      def match?(event)
+        NamedEvent === event and @name === event.name
+      end
+      
+    end
+    
+    class NamedEvent < Cancer::Events::AbstractEvent
+      attr_reader :name
+      def initialize(name)
+        @name = name.to_sym
+      end
+    end
+    
+  end
+end

data/lib/cancer/events/proc_matcher.rb

@@ -0,0 +1,16 @@
+
+module Cancer
+  module Events
+    class ProcMatcher < Cancer::Events::Matcher
+      
+      def initialize(proc=nil, &block)
+        @proc = proc || block
+      end
+      
+      def match?(event)
+        !!@proc.call(event)
+      end
+      
+    end
+  end
+end

data/lib/cancer/events/xml_events.rb

@@ -0,0 +1,44 @@
+
+module Cancer
+  module Events
+    class XPathMatcher < Cancer::Events::Matcher
+      
+      def initialize(xpath, ns=nil)
+        @xpath, @ns = xpath, ns
+      end
+      
+      def match?(event)
+        Cancer::Events::XMLEvent === event and !event.xml.xpath(@xpath, @ns).empty?
+      end
+      
+    end
+    
+    class XMLEvent < Cancer::Events::AbstractEvent
+      attr_reader :xml
+      def initialize(xml)
+        @xml = xml
+      end
+      
+      def sender
+        @xml[:from].to_jid if @xml[:from]
+      end
+      
+      def receiver
+        @xml[:to].to_jid if @xml[:to]
+      end
+      
+      def id
+        @xml[:id].to_s if @xml[:id]
+      end
+      
+      def type
+        @xml[:type].to_s if @xml[:type]
+      end
+    end
+    
+    class StanzaEvent < Cancer::Events::XMLEvent
+      alias_method :stanza, :xml
+    end
+    
+  end
+end