sprsquish-blather 0.1 → 0.2.3

data/lib/blather/client.rb

@@ -1,81 +1,256 @@
-require File.join(File.dirname(__FILE__), %w[.. blather])
+require File.join(File.dirname(__FILE__), *%w[.. blather])
 
-module Blather
-
-  class Client
-    @@callbacks = {}
-    @@status = nil
+module Blather #:nodoc:
 
+  class Client #:nodoc:
     attr_accessor :jid,
                   :roster
 
-    def send_data(data)
-      @stream.send data
+    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
+      @status.state
     end
 
-    def set_status(state = nil, msg = nil, to = nil)
-      status = Presence::Status.new state, msg
+    def status=(state)
+      state, msg, to = state
+
+      status = Stanza::Presence::Status.new state, msg
       status.to = to
-      @@status = status unless to
+      @statustatus unless to
+
+      write status
+    end
 
-      send_data status
+    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
+
+      #retreive roster
+      if @stream.is_a?(Stream::Component)
+        @state = :ready
+        call_handler_for :ready, nil
+      else
+        write Stanza::Iq::Roster.new
+      end
     end
 
-    def call(stanza)
-      stanza.callback_heirarchy.each { |type| break if callback(type, stanza) }
+    def stop
+      @stream.close_connection_after_writing
     end
 
-    # Default response to an Iq 'get' or 'set' is 'service-unavailable'/'cancel'
-    def receive_iq(iq)
-      send_data(ErrorStanza.new_from(iq, 'service-unavailable', 'cancel').reply!) if [:set, :get].include?(iq.type)
+    def stopped
+      EM.stop
     end
 
-    def receive_roster(node)
-      if !@roster && node.type == :result
-        self.roster = Roster.new(@stream, node)
-        register_callback(:status, -128) { |_, status| roster[status.from].status = status if roster[status.from]; false }
-        set_status
-      elsif node.type == :set
-        roster.process node
+    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 self.register_callback(type, priority = 0, &callback)
-      @@callbacks[type] ||= []
-      @@callbacks[type] << Callback.new(priority, &callback)
-      @@callbacks[type].sort!
+    def call_handler_for(type, stanza)
+      if @handlers[type]
+        @handlers[type].find { |guards, handler| handler.call(stanza) unless guarded?(guards, stanza) }
+        true
+      end
     end
 
-    def register_callback(type, priority = 0, &callback)
-      self.class.register_callback(type, priority = 0, &callback)
-    end
+  protected
+    def setup_initial_handlers
+      register_handler :error do |err|
+        raise err
+      end
 
-    def self.status(state = nil, msg = nil)
-      @@status = Presence::Status.new state, msg
-    end
+      register_handler :iq do |iq|
+        write(StanzaError::ServiceUnavailable.new(iq, :cancel).to_node) if [:set, :get].include?(iq.type)
+      end
 
-    def callback(type, stanza)
-      complete = false
-      (@@callbacks[type] || []).each { |callback| break if complete = callback.call(self, stanza) }
+      register_handler :status do |status|
+        roster[status.from].status = status if roster[status.from]
+      end
 
-      method = "receive_#{type}"
-      complete = __send__(method, stanza) if !complete && respond_to?(method)
-      complete
+      register_handler :roster do |node|
+        roster.process node
+        if @state == :initializing
+          @state = :ready
+          write @status
+          call_handler_for :ready, nil
+        end
+      end
     end
 
-    def retreive_roster
-      send_data Iq::Roster.new
+    ##
+    # 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
+
+
+at_exit do
+  unless Blather.client.setup?
+    if ARGV.length < 2
+      puts "Run with #{$0} user@server/resource password [host] [port]"
+    else
+      Blather.client.setup(*ARGV).run
+    end
+  end
 end

data/lib/blather/{core/sugar.rb → core_ext/active_support.rb}

@@ -1,16 +1,9 @@
-module LibXML
-  module XML
-
-    class Attributes
-      def remove(name)
-        name = name.to_s
-        self.each { |a| a.remove! or break if a.name == name }
-      end
-    end #Attributes
-
-  end #XML
-end #LibXML
+# Thanks to Rails ActiveSupport for everything in this file
 
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
 class Class # :nodoc:
   def class_inheritable_reader(*syms)
     syms.each do |sym|
@@ -123,20 +116,38 @@ class Class # :nodoc:
     alias inherited inherited_with_inheritable_attributes
 end #Class
 
-class Object
+class Object # :nodoc:
   def duplicable?; true; end
+  def blank?; respond_to?(:empty?) ? empty? : !self; end
+  def present?; !blank?; end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+  def extract_options!; last.is_a?(::Hash) ? pop : {}; end
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?; self !~ /\S/; end
 end
 
 class NilClass #:nodoc:
   def duplicable?; false; end
+  def blank?; true; end
 end
 
 class FalseClass #:nodoc:
   def duplicable?; false; end
+  def blank?; true; end
 end
 
 class TrueClass #:nodoc:
   def duplicable?; false; end
+  def blank?; false; end
 end
 
 class Symbol #:nodoc:
@@ -145,4 +156,5 @@ end
 
 class Numeric #:nodoc:
   def duplicable?; false; end
+  def blank?; false; end
 end

data/lib/blather/core_ext/libxml.rb

@@ -0,0 +1,28 @@
+module LibXML # :nodoc:
+  module XML # :nodoc:
+
+    class Node
+      alias_method :element_name, :name
+      alias_method :element_name=, :name=
+    end
+
+    class Attributes
+      # Helper method for removing attributes
+      def remove(name)
+        attribute = get_attribute(name.to_s)
+        attribute.remove! if attribute
+      end
+
+      alias_method :old_hash_set, :[]= # :nodoc:
+      def []=(name, val)
+        val.nil? ? remove(name.to_s) : old_hash_set(name.to_s, val.to_s)
+      end
+
+      alias_method :old_hash_get, :[] # :nodoc:
+      def [](name)
+        old_hash_get name.to_s
+      end
+    end #Attributes
+
+  end #XML
+end #LibXML

data/lib/blather/errors/sasl_error.rb

@@ -0,0 +1,87 @@
+module Blather
+
+class SASLError < BlatherError
+  class_inheritable_accessor :err_name
+  @@registrations = {}
+
+  register :sasl_error
+
+  ##
+  # Register the handler and type to simplify importing
+  def self.register(handler, err_name)
+    super handler
+    self.err_name = err_name
+    @@registrations[err_name] = self
+  end
+
+  ##
+  # Retreive an error class from a given name
+  def self.class_from_registration(err_name)
+    @@registrations[err_name.to_s] || self
+  end
+
+  ##
+  # Factory to create the proper error object from an error node
+  def self.import(node)
+    err_name = node.children.first.element_name
+    class_from_registration(err_name).new
+  end
+
+  ##
+  # XMPP defined error name
+  def err_name
+    self.class.err_name
+  end
+
+  ##
+  # The receiving entity acknowledges an <abort/> element sent by the initiating entity; sent in reply to the <abort/> element.
+  class Aborted < SASLError
+    register :sasl_aborted_error, 'aborted'
+  end
+
+  ##
+  # The data provided by the initiating entity could not be processed because the [BASE64] encoding is incorrect
+  # (e.g., because the encoding does not adhere to the definition in Section 3 of [BASE64]); sent in reply to a <response/>
+  # element or an <auth/> element with initial response data.
+  class IncorrectEncoding < SASLError
+    register :sasl_incorrect_encoding_error, 'incorrect-encoding'
+  end
+  
+  ##
+  # The authzid provided by the initiating entity is invalid, either because it is incorrectly formatted or because the
+  # initiating entity does not have permissions to authorize that ID; sent in reply to a <response/> element or an <auth/>
+  # element with initial response data.
+  class InvalidAuthzid < SASLError
+    register :sasl_invalid_authzid_error, 'invalid-authzid'
+  end
+  
+  ##
+  # The initiating entity did not provide a mechanism or requested a mechanism that is not supported by the receiving entity;
+  # sent in reply to an <auth/> element.
+  class InvalidMechanism < SASLError
+    register :sasl_invalid_mechanism_error, 'invalid-mechanism'
+  end
+  
+  ##
+  # The mechanism requested by the initiating entity is weaker than server policy permits for that initiating entity; sent in
+  # reply to a <response/> element or an <auth/> element with initial response data.
+  class MechanismTooWeak < SASLError
+    register :sasl_mechanism_too_weak_error, 'mechanism-too-weak'
+  end
+  
+  ##
+  # The authentication failed because the initiating entity did not provide valid credentials (this includes but is not limited
+  # to the case of an unknown username); sent in reply to a <response/> element or an <auth/> element with initial response data.
+  class NotAuthorized < SASLError
+    register :sasl_not_authorized_error, 'not-authorized'
+  end
+  
+  ##
+  # The authentication failed because of a temporary error condition within the receiving entity; sent in reply to an <auth/>
+  # element or <response/> element.
+  class TemporaryAuthFailure < SASLError
+    register :sasl_temporary_auth_failure_error, 'temporary-auth-failure'
+  end
+end #SASLError
+
+end #Blather