blather 0.2.3 → 0.3.0

data/README.rdoc

@@ -77,6 +77,11 @@ There are 5 different types of guards:
   #   Equivalent to stanza.body.match /exit/
   message :body => /exit/
 
+  # Hash with array (:name => [:gone, :forbidden])
+  #   Calls the key on the stanza and check for inclusion in the array
+  #   Equivalent to [:gone, :forbidden].include?(stanza.name)
+  stanza_error :name => [:gone, :fobidden]
+
   # Proc
   #   Calls the proc passing in the stanza
   #   Checks that the ID is modulo 3
@@ -90,14 +95,12 @@ There are 5 different types of guards:
 
 = TODO
 
-* Cleanup API
-* Add lambda callback ability to Iq stanzas
 * Better Documentation
-* Service Discovery (XEP-0030: http://xmpp.org/extensions/xep-0030.html)
+* Add XPath guard that passes the result to the handler
+* Add Disco the the DSL
 * PubSub (XEP-0060: http://xmpp.org/extensions/xep-0060.html)
 * More examples (Re-write XMPP4R examples into Blather)
 
 = License
 
 Please see LICENSE
-The LibXML-Ruby license can be found in its directory

data/Rakefile

@@ -18,7 +18,9 @@ begin
     gem.add_dependency 'eventmachine', '>= 0.12.6'
     gem.add_dependency 'libxml-ruby', '>= 1.1.3'
 
-    gem.files = FileList['examples/**/*', 'lib/**/*', 'ext/*'].to_a
+    gem.files = FileList['examples/**/*', 'lib/**/*', 'ext/*.{rb,c}'].to_a
+
+    gem.test_files = FileList['spec/**/*.rb']
 
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/examples/print_heirarchy.rb

@@ -0,0 +1,76 @@
+require 'blather'
+
+class Object
+  begin
+    ObjectSpace.each_object(Class.new) {}
+
+    # Exclude this class unless it's a subclass of our supers and is defined.
+    # We check defined? in case we find a removed class that has yet to be
+    # garbage collected. This also fails for anonymous classes -- please
+    # submit a patch if you have a workaround.
+    def subclasses_of(*superclasses) #:nodoc:
+      subclasses = []
+
+      superclasses.each do |sup|
+        ObjectSpace.each_object(class << sup; self; end) do |k|
+          if k != sup && (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+            subclasses << k
+          end
+        end
+      end
+
+      subclasses
+    end
+  rescue RuntimeError
+    # JRuby and any implementations which cannot handle the objectspace traversal
+    # above fall back to this implementation
+    def subclasses_of(*superclasses) #:nodoc:
+      subclasses = []
+
+      superclasses.each do |sup|
+        ObjectSpace.each_object(Class) do |k|
+          if superclasses.any? { |superclass| k < superclass } &&
+            (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+            subclasses << k
+          end
+        end
+        subclasses.uniq!
+      end
+      subclasses
+    end
+  end
+end
+
+class Hash
+  def deep_merge(second)
+    # From: http://www.ruby-forum.com/topic/142809
+    # Author: Stefan Rusterholz
+    merger = proc { |key,v1,v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+    self.merge(second, &merger)
+  end
+end
+
+handlers = {}
+(Object.subclasses_of(Blather::Stanza) + Object.subclasses_of(Blather::BlatherError)).each do |klass|
+  handlers = handlers.deep_merge klass.handler_heirarchy.inject('klass' => klass.to_s.gsub('Blather::', '')) { |h,k| {k.to_s => h} }
+end
+
+level = 0
+runner = proc do |k,v|
+  next if k == 'klass'
+
+  str = ''
+  if level > 0
+    (level - 1).times { str << '|   ' }
+    str << '|-- '
+  end
+
+  puts str+k
+  if Hash === v
+    level += 1
+    v.sort.each &runner
+    level -= 1
+  end
+end
+
+handlers.sort.each &runner

data/lib/blather.rb

@@ -26,9 +26,9 @@ $:.unshift File.join(File.dirname(__FILE__), '..')
   blather/stanza/iq
   blather/stanza/iq/query
   blather/stanza/iq/roster
-  blather/stanza/iq/disco
-  blather/stanza/iq/discos/disco_info
-  blather/stanza/iq/discos/disco_items
+  blather/stanza/disco
+  blather/stanza/disco/disco_info
+  blather/stanza/disco/disco_items
   blather/stanza/message
   blather/stanza/presence
   blather/stanza/presence/status

data/lib/blather/client.rb

@@ -1,256 +1,13 @@
-require File.join(File.dirname(__FILE__), *%w[.. blather])
-
-module Blather #:nodoc:
-
-  class Client #:nodoc:
-    attr_accessor :jid,
-                  :roster
-
-    def initialize
-      @state = :initializing
-
-      @status = Stanza::Presence::Status.new
-      @handlers = {}
-      @tmp_handlers = {}
-      @roster = Roster.new self
-
-      setup_initial_handlers
-    end
-
-    def setup(jid, password, host = nil, port = 5222)
-      @setup = [JID.new(jid), password, host, port]
-      self
-    end
-
-    def setup?
-      @setup.is_a?(Array) && !@setup.empty?
-    end
-
-    def run
-      raise 'Not setup!' unless @setup.is_a?(Array)
-      trap(:INT) { EM.stop }
-      EM.run {
-        klass = @setup[2].node ? Blather::Stream::Client : Blather::Stream::Component
-        klass.start Blather.client, *@setup
-      }
-
-    def temporary_handler(id, &handler)
-      @tmp_handlers[id] = handler
-    end
-
-    def register_handler(type, *guards, &handler)
-      @handlers[type] ||= []
-      @handlers[type] << [guards, handler]
-    end
-
-    def status
-      @status.state
-    end
-
-    def status=(state)
-      state, msg, to = state
-
-      status = Stanza::Presence::Status.new state, msg
-      status.to = to
-      @statustatus unless to
-
-      write status
-    end
-
-    def write(stanza)
-      stanza.from ||= jid if stanza.respond_to?(:from)
-      @stream.send(stanza) if @stream
-    end
-
-    def stream_started(stream)
-      @stream = stream
-
-      #retreive roster
-      if @stream.is_a?(Stream::Component)
-        @state = :ready
-        call_handler_for :ready, nil
-      else
-        write Stanza::Iq::Roster.new
-      end
-    end
-
-    def stop
-      @stream.close_connection_after_writing
-    end
-
-    def stopped
-      EM.stop
-    end
-
-    def call(stanza)
-      if handler = @tmp_handlers.delete(stanza.id)
-        handler.call stanza
-      else
-        stanza.handler_heirarchy.each do |type|
-          break if call_handler_for(type, stanza) && (stanza.is_a?(BlatherError) || stanza.type == :iq)
-        end
-      end
-    end
-
-    def call_handler_for(type, stanza)
-      if @handlers[type]
-        @handlers[type].find { |guards, handler| handler.call(stanza) unless guarded?(guards, stanza) }
-        true
-      end
-    end
-
-  protected
-    def setup_initial_handlers
-      register_handler :error do |err|
-        raise err
-      end
-
-      register_handler :iq do |iq|
-        write(StanzaError::ServiceUnavailable.new(iq, :cancel).to_node) if [:set, :get].include?(iq.type)
-      end
-
-      register_handler :status do |status|
-        roster[status.from].status = status if roster[status.from]
-      end
-
-      register_handler :roster do |node|
-        roster.process node
-        if @state == :initializing
-          @state = :ready
-          write @status
-          call_handler_for :ready, nil
-        end
-      end
-    end
-
-    ##
-    # If any of the guards returns FALSE this returns true
-    def guarded?(guards, stanza)
-      guards.find do |guard|
-        case guard
-        when Symbol
-          !stanza.__send__(guard)
-        when Array
-          # return FALSE if any item is TRUE
-          !guard.detect { |condition| !guarded?([condition], stanza) }
-        when Hash
-          # return FALSE unless any inequality is found
-          guard.find do |method, value|
-            if value.is_a?(Regexp)
-              !stanza.__send__(method).to_s.match(value)
-            else
-              stanza.__send__(method) != value
-            end
-          end
-        when Proc
-          !guard.call(stanza)
-        else
-          raise "Bad guard: #{guard.inspect}"
-        end
-      end
-    end
-
-  end #Client
-
-  def client
-    @client ||= Client.new
-  end
-  module_function :client
-end #Blather
-
-##
-# Prepare server settings
-#   setup_client [node@domain/resource], [password], [host], [port]
-# host and port are optional defaulting to the domain in the JID and 5222 respectively
-def setup_client(jid, password, host = nil, port = 5222)
-  at_exit { Blather.client.setup_client(jid, password, host, port).run }
-end
-
-def setup_component(jid, secret, host, port)
-  at_exit { Blather.client.setup_component(jid, secret, host, port).run }
-end
-
-##
-# Shutdown the connection.
-# Flushes the write buffer then stops EventMachine
-def shutdown
-  Blather.client.stop
-end
-
-##
-# Set handler for a stanza type
-def handle(stanza_type, *guards, &block)
-  Blather.client.register_handler stanza_type, *guards, &block
-end
-
-##
-# Wrapper for "handle :ready" (just a bit of syntactic sugar)
-def when_ready(&block)
-  handle :ready, &block
-end
-
-##
-# Set current status
-def status(state = nil, msg = nil)
-  Blather.client.status = state, msg
-end
-
-##
-# Direct access to the roster
-def roster
-  Blather.client.roster
-end
-
-##
-# Write data to the stream
-# Anything that resonds to #to_s can be paseed to the stream
-def write(stanza)
-  Blather.client.write(stanza)
-end
-
-##
-# Helper method to make sending basic messages easier
-#   say [jid], [msg]
-def say(to, msg)
-  Blather.client.write Blather::Stanza::Message.new(to, msg)
-end
-
-##
-# Wrapper to grab the current JID
-def jid
-  Blather.client.jid
-end
-
-##
-#
-def discover(what, who, where, &callback)
-  stanza = Blather::Stanza.class_from_registration(:query, "http://jabber.org/protocol/disco##{what}").new
-  stanza.to = who
-  stanza.node = where
-
-  Blather.client.temporary_handler stanza.id, &callback
-  write stanza
-end
-
-##
-# Checks to see if the method is part of the handlers list.
-# If so it creates a handler, otherwise it'll pass it back
-# to Ruby's method_missing handler
-def method_missing(method, *args, &block)
-  if Blather::Stanza.handler_list.include?(method)
-    handle method, *args, &block
-  else
-    super
-  end
-end
+require File.join(File.dirname(__FILE__), *%w[client dsl])
 
+include Blather::DSL
 
 at_exit do
-  unless Blather.client.setup?
+  unless client.setup?
     if ARGV.length < 2
       puts "Run with #{$0} user@server/resource password [host] [port]"
     else
-      Blather.client.setup(*ARGV).run
+      client.setup(*ARGV).run
     end
   end
 end

data/lib/blather/client/client.rb

@@ -0,0 +1,168 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. blather])
+
+module Blather #:nodoc:
+
+  class Client #:nodoc:
+    attr_accessor :jid,
+                  :roster
+
+    def initialize
+      @state = :initializing
+
+      @status = Stanza::Presence::Status.new
+      @handlers = {}
+      @tmp_handlers = {}
+      @roster = Roster.new self
+
+      setup_initial_handlers
+    end
+
+    def setup?
+      @setup.is_a? Array
+    end
+
+    def setup(jid, password, host = nil, port = nil)
+      @setup = [JID.new(jid), password]
+      @setup << host if host
+      @setup << port if port
+      self
+    end
+
+    def run
+      raise 'not setup!' unless setup?
+      trap(:INT) { EM.stop }
+      EM.run {
+        klass = @setup[0].node ? Blather::Stream::Client : Blather::Stream::Component
+        klass.start self, *@setup
+      }
+    end
+
+    def register_tmp_handler(id, &handler)
+      @tmp_handlers[id] = handler
+    end
+
+    def register_handler(type, *guards, &handler)
+      @handlers[type] ||= []
+      @handlers[type] << [guards, handler]
+    end
+
+    def status
+      @status.state
+    end
+
+    def status=(state)
+      state, msg, to = state
+
+      status = Stanza::Presence::Status.new state, msg
+      status.to = to
+      @status = status unless to
+
+      write status
+    end
+
+    def write(stanza)
+      stanza.from ||= jid if stanza.respond_to?(:from)
+      @stream.send(stanza) if @stream
+    end
+
+    def write_with_handler(stanza, &hanlder)
+      register_tmp_handler stanza.id, &handler
+      write stanza
+    end
+
+    def stream_started(stream)
+      @stream = stream
+
+      #retreive roster
+      if @stream.is_a?(Stream::Component)
+        @state = :ready
+        call_handler_for :ready, nil
+      else
+        r = Stanza::Iq::Roster.new
+        register_tmp_handler r.id do |node|
+          roster.process node
+          @state = :ready
+          write @status
+          call_handler_for :ready, nil
+        end
+        write r
+      end
+    end
+
+    def stop
+      @stream.close_connection_after_writing
+    end
+
+    def stopped
+      EM.stop
+    end
+
+    def call(stanza)
+      if handler = @tmp_handlers.delete(stanza.id)
+        handler.call stanza
+      else
+        stanza.handler_heirarchy.each do |type|
+          break if call_handler_for(type, stanza) && (stanza.is_a?(BlatherError) || stanza.type == :iq)
+        end
+      end
+    end
+
+    def call_handler_for(type, stanza)
+      if @handlers[type]
+        @handlers[type].find { |guards, handler| handler.call(stanza) unless guarded?(guards, stanza) }
+        true
+      end
+    end
+
+  protected
+    def setup_initial_handlers
+      register_handler :error do |err|
+        raise err
+      end
+
+      register_handler :iq do |iq|
+        write(StanzaError.new(iq, 'service-unavailable', :cancel).to_node) if [:set, :get].include?(iq.type)
+      end
+
+      register_handler :status do |status|
+        roster[status.from].status = status if roster[status.from]
+      end
+
+      register_handler :roster do |node|
+        roster.process node
+      end
+    end
+
+    ##
+    # If any of the guards returns FALSE this returns true
+    def guarded?(guards, stanza)
+      guards.find do |guard|
+        case guard
+        when Symbol
+          !stanza.__send__(guard)
+        when Array
+          # return FALSE if any item is TRUE
+          !guard.detect { |condition| !guarded?([condition], stanza) }
+        when Hash
+          # return FALSE unless any inequality is found
+          guard.find do |method, test|
+            value = stanza.__send__(method)
+            case test
+            when Regexp
+              !value.to_s.match(test)
+            when Array
+              !test.include? value
+            else
+              test != value
+            end
+          end
+        when Proc
+          !guard.call(stanza)
+        else
+          raise "Bad guard: #{guard.inspect}"
+        end
+      end
+    end
+
+  end #Client
+end #Blather