cancer 0.1.0.a1

data/lib/cancer/stream/controller.rb

@@ -0,0 +1,36 @@
+
+module Cancer
+  class Stream
+    module Controller
+      
+      def controllers
+        @controllers ||= []
+      end
+      
+      def controllers_by_name
+        @controllers_by_name ||= {}
+      end
+      
+      def install_controller(klass)
+        self.controllers.push(klass)
+        self.controllers_by_name[klass.to_s] = klass.new(self)
+        self.controllers_by_name[klass.to_s].register_with(@manager)
+        @manager.resolve_martchers! if @initialized
+      end
+      
+      def extend_controller(klass, &proc)
+        object    = self.controllers_by_name[klass.to_s]
+        raise "Controller not found #{klass}" if object.nil?
+        metaklass = (class << object ; self ; end)
+        metaklass.instance_eval(&proc)
+      end
+      
+      def controller(&proc)
+        controller = Class.new(Cancer::Controller)
+        controller.class_eval(&proc)
+        install_controller controller
+      end
+      
+    end
+  end
+end

data/lib/cancer/stream/event_helper.rb

@@ -0,0 +1,12 @@
+
+module Cancer
+  class Stream
+    module EventHelper
+      
+      def install_event_helper(mod)
+        Cancer::Events::Manager::DSL.send :include, mod
+      end
+      
+    end
+  end
+end

data/lib/cancer/stream/xep.rb

@@ -0,0 +1,52 @@
+
+module Cancer
+  class Stream
+    module XEP
+      
+      def xeps
+        @xeps ||= []
+      end
+      
+      def install_xep(name)
+        if @initialized
+          unless self.xeps.include?(name)
+            xep = Cancer::XEP.const_for(name)
+            xep.strong_dependecies.each do |dep|
+              install_xep(dep)
+            end
+            xep.enhance_stream(self)
+          end
+        else
+          self.xeps.push(name)
+        end
+      end
+      
+    private
+      
+      def enhance_stream_with_xeps!
+        xeps_by_name = self.xeps.inject({}) do |hash, xep_name|
+          hash[xep_name] = Cancer::XEP.const_for(xep_name)
+          hash
+        end
+        
+        resolver = Cancer::Dependencies::Resolver.new(:allow_reverse => false)
+        resolver.on_missing_strong_dependency do |xep_name|
+          xep = Cancer::XEP.const_for(xep_name)
+          xeps_by_name[xep_name] = xep
+          resolver.add_node(xep_name, xep)
+          install_xep(xep_name)
+        end
+        xeps_by_name.each do |xep_name, xep|
+          resolver.add_node(xep_name, xep)
+        end
+        orderd_xeps = resolver.sort(*self.xeps)
+        Cancer.logger.debug "XEPS: #{orderd_xeps.inspect}"
+        orderd_xeps.each do |xep_name|
+          xep = xeps_by_name[xep_name]
+          xep.enhance_stream(self)
+        end
+      end
+      
+    end
+  end
+end

data/lib/cancer/stream_parser.rb

@@ -0,0 +1,144 @@
+
+module Cancer
+  class StreamParser < Nokogiri::XML::SAX::Document
+    
+    def initialize(stream)
+      @stream   = stream
+      @document = nil
+      @current  = nil
+      @current_ns = nil
+    end
+    
+    ###
+    # Called when document starts parsing
+    def start_document
+    end
+    
+    ###
+    # Called when document ends parsing
+    def end_document
+    end
+    
+    ###
+    # Called at the beginning of an element
+    # +name+ is the element name
+    # +attrs+ is a list of attributes
+    # +prefix+ is the namespace prefix for the element
+    # +uri+ is the associated namespace URI
+    # +ns+ is a hash of namespace prefix:urls associated with the element
+    def start_element_namespace(name, attrs=nil, prefix=nil, uri=nil, ns=nil)
+      @document   = (@current ? @document : Nokogiri::XML::Document.new)
+      @current_ns = (@current ? @current_ns : {})
+      
+      element = Nokogiri::XML::Element.new(name, @document)
+      
+      if @current
+        @current.add_child element if @current
+      else
+        @document.root = element
+      end
+      
+      if ns
+        ns.each do |p, u|
+          @current_ns[u] = element.add_namespace(p, u)
+        end
+      end
+      
+      if uri 
+        element.namespace = @current_ns[uri] || element.add_namespace(prefix, uri)
+      end
+      
+      if attrs
+        attrs.each do |attribute|
+          element[attribute.localname] = attribute.value
+        end
+      end
+      
+      if element.named?('stream', STREAM_NS)
+        @stream.received_xml(element)
+        @current = nil
+      else
+        @current = element
+      end
+    end
+    
+    ###
+    # Called at the end of an element
+    # +name+ is the element's name
+    # +prefix+ is the namespace prefix associated with the element
+    # +uri+ is the associated namespace URI
+    def end_element_namespace name, prefix = nil, uri = nil
+      if name == 'stream' and prefix == 'stream' and @current == nil
+      else
+        if Nokogiri::XML::Document === @current.parent or @current.parent.nil?
+          @stream.received_xml(@current)
+          @current = nil
+        else
+          @current = @current.parent
+        end
+      end
+    end
+    
+    ###
+    # Characters read between a tag
+    # +string+ contains the character data
+    def characters string
+      @current << Nokogiri::XML::Text.new(string, @document) if @current
+    end
+    
+    ###
+    # Called when cdata blocks are found
+    # +string+ contains the cdata content
+    def cdata_block string
+      @current << Nokogiri::XML::CDATA.new(@document, string) if @current
+    end
+    
+    ###
+    # Called on document warnings
+    # +string+ contains the warning
+    def warning string
+    end
+    
+    ###
+    # Called on document errors
+    # +string+ contains the error
+    def error string
+    end
+    
+  end
+end
+
+class Nokogiri::XML::Node
+  def named?(name, ns=nil)
+    self.name == name and (ns.nil? or (namespace and namespace.href == ns))
+  end
+  
+  def first(xpath, ns={})
+    ns = add_xmpp_base_namespaces_to(ns)
+    element = xpath(xpath, ns).to_a.first
+    if element and block_given?
+      yield(element)
+    else
+      element
+    end
+  end
+  
+  def all(xpath, ns={}, &block)
+    ns = add_xmpp_base_namespaces_to(ns)
+    elements = xpath(xpath, ns)
+    if block_given?
+      elements.each(&block)
+    else
+      elements
+    end
+  end
+  
+private
+  
+  def add_xmpp_base_namespaces_to(ns)
+    { 'stream' => Cancer::STREAM_NS,
+      'client' => Cancer::CLIENT_NS,
+      'c'      => Cancer::CLIENT_NS }.merge(ns)
+  end
+  
+end

data/lib/cancer/support.rb

@@ -0,0 +1,27 @@
+
+module Cancer
+  module Support
+    
+    def alias_method_chain(target, feature)
+      # Strip out punctuation on predicates or bang methods since
+      # e.g. target?_without_feature is not a valid method name.
+      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+      yield(aliased_target, punctuation) if block_given?
+      
+      with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+      
+      alias_method without_method, target
+      alias_method target, with_method
+      
+      case
+        when public_method_defined?(without_method)
+          public target
+        when protected_method_defined?(without_method)
+          protected target
+        when private_method_defined?(without_method)
+          private target
+      end
+    end
+    
+  end
+end

data/lib/cancer/support/hash.rb

@@ -0,0 +1,32 @@
+
+module Cancer
+  module Support
+    module Hash
+      
+      def clean!
+        delete_if { |key, value| value.nil? }
+      end
+      
+      def clean
+        dup.clean!
+      end
+      
+      def to_options
+        self.inject({}) do |options, (key, value)|
+          options[key.to_sym] = value
+          options
+        end
+      end
+      
+      def to_options!
+        self.keys.each do |key|
+          self[key.to_sym] = self.delete(key)
+        end
+        self
+      end
+      
+    end
+    
+    ::Hash.send :include, Cancer::Support::Hash
+  end
+end

data/lib/cancer/support/string.rb

@@ -0,0 +1,22 @@
+
+module Cancer
+  module Support
+    module String
+      
+      def cmp_ioctet(other)
+        i = 0
+        loop do
+          return  0 if (self.size - i) == 0 and (other.size - i) == 0
+          return -1 if (self.size - i) == 0
+          return  1 if (other.size - i) == 0
+          c = self[i] <=> other[i]
+          return c if c != 0
+          i += 1
+        end
+      end
+      
+    end
+    
+    ::String.send :include, Cancer::Support::String
+  end
+end

data/lib/cancer/synchronized_stanza.rb

@@ -0,0 +1,79 @@
+
+module Cancer
+  module SynchronizedStanza
+    
+    def send_and_receive(stanza, *conditions, &proc)
+      lock = nil
+      @mutex.synchronize do
+        conditions.push(proc) if proc
+        lock = Cancer::SynchronizedStanza::Lock.new(*conditions)
+        @receive_locks.push(lock)
+        send(stanza)
+      end
+      r = lock.wait!
+      @receive_locks.delete(lock)
+      if r[:type] == 'error'
+        handle_stanza_errors(r)
+      else
+        return r
+      end
+    ensure
+      @receive_locks.delete(lock)
+    end
+    
+    def handle_stanza_errors(xml)
+      raise Cancer::StanzaError.build(xml)
+    end
+    
+    def handle_synchronized_stanza(xml)
+      @mutex.synchronize do
+        @receive_locks.each do |lock|
+          return true if lock.continue! xml
+        end
+      end
+      (Exception === xml)
+    end
+    
+    class Lock
+      def initialize(*conditions)
+        @mutex = Mutex.new
+        @condition = ConditionVariable.new
+        @conditions = conditions
+        @conditions.collect! do |condition|
+          case condition
+          when String then lambda { |xml| !!xml.first(condition) }
+          when Array  then lambda { |xml| !!xml.first(*condition) }
+          when Proc   then condition
+          end
+        end
+        @conditions.push(lambda { |xml| true })
+      end
+      
+      def wait!
+        raise @exception if @exception
+        return @xml if @xml
+        @mutex.synchronize do
+          @condition.wait(@mutex)
+          raise @exception if @exception
+          return @xml
+        end
+      end
+      
+      def continue!(xml)
+        @mutex.synchronize do
+          if Exception === xml
+            @exception = xml
+            @condition.signal
+            return false
+          end
+          unless @conditions.any? { |condition| FalseClass === condition.call(xml) }
+            @xml = xml
+            @condition.signal
+            return true
+          end
+        end
+      end
+    end
+    
+  end
+end

data/lib/cancer/thread_pool.rb

@@ -0,0 +1,118 @@
+
+require 'thread'
+require 'monitor'
+
+module Cancer
+  class ThreadPool < Queue
+    
+    # create a new pool and start it as well.
+    def self.start!(size=10, &proc)
+      new(size, &proc).start!
+    end
+    
+    # Build a new thread pool.
+    # @param [Fixnum] size the size of the pool
+    # @yield [job] The code to run in for each job on the queue
+    # @yieldparam [Object] job the job which needs to be processed.
+    def initialize(size=10, &proc)
+      extend MonitorMixin
+      @proc = proc
+      @empty_cond = new_cond
+      @pool = []
+      @defered_pool = []
+      @size = size
+      @num_working = 0
+      @exception_handler_proc = nil
+      super()
+    end
+    
+    # set a handler for exceptions raised inside the pool threads
+    # @yield [exception] handle exceptions in here
+    # @yieldparam [Exception] exceptions the exception that was raised in side a pool thread.
+    def on_exception(&proc)
+      @exception_handler_proc = proc
+    end
+    
+    # push a new job onto the queue.
+    def push(*args)
+      super(args)
+    end
+    
+    def rescue_any_exceptions
+      defult_handler = lambda do |e|
+        Cancer.logger.fatal e
+      end
+      
+      begin
+        yield
+      rescue Exception => e
+        begin
+          (@exception_handler_proc || defult_handler).call(e)
+        rescue Exception => e
+          defult_handler.call(e)
+        end
+      end
+    end
+    
+    # create the threads and start processing jobs.
+    def start!
+      @size.times do
+        @pool.push(Thread.new(self) do |queue|
+          Thread.current.abort_on_exception = true
+          
+          loop do
+            rescue_any_exceptions do
+              job = queue.pop
+              queue.synchronize { @num_working += 1 }
+              @proc.call(*job)
+            end
+            queue.synchronize do
+              @num_working -= 1
+              @empty_cond.signal
+            end
+          end
+          
+        end)
+      end
+      self
+    end
+    
+    # wait until the queue is empty.
+    def wait!
+      synchronize do
+        @empty_cond.wait_until do
+          ((empty?) and
+           (@num_working == 0) and
+           (@defered_pool.empty?))
+        end
+      end
+    end
+    
+    # wait until the queue is empty and then stop the pool.
+    def stop!
+      wait!
+      @pool.each { |thread| thread.kill }
+      @pool = []
+      self
+    end
+    
+    # start a thread outside the thread pool.
+    # @param args the arguments to pass to the thread
+    # @yield [*args] the block to execute inside the new thread.
+    def defer(*args, &proc)
+      @defered_pool.push(Thread.new(self, proc, args) do |queue, proc, args|
+        Thread.current.abort_on_exception = true
+        
+        rescue_any_exceptions do
+          proc.call(*args)
+        end
+        queue.synchronize do
+          @defered_pool.delete(Thread.current)
+          @empty_cond.signal
+        end
+        
+      end)
+    end
+    
+  end
+end