sprsquish-blather 0.3.4 → 0.4.0

data/lib/blather/stream.rb

@@ -1,6 +1,11 @@
 module Blather
 
   class Stream < EventMachine::Connection
+    class NoConnection < RuntimeError; end
+
+    STREAM_NS = 'http://etherx.jabber.org/streams'
+    attr_accessor :jid, :password
+
     ##
     # Start the stream between client and server
     #   [client] must be an object that will respond to #call and #jid=
@@ -10,9 +15,35 @@ module Blather
     #   [port] (optional) must be the port to connect to. defaults to 5222
     def self.start(client, jid, pass, host = nil, port = 5222)
       jid = JID.new jid
-      host ||= jid.domain
+      if host
+        connect host, port, self, client, jid, pass
+      else
+        require 'resolv'
+        srv = []
+        Resolv::DNS.open { |dns| srv = dns.getresources("_xmpp-client._tcp.#{jid.domain}", Resolv::DNS::Resource::IN::SRV) }
+        if srv.empty?
+          connect jid.domain, port, self, client, jid, pass
+        else
+          srv.sort! { |a,b| (a.priority != b.priority) ? (a.priority <=> b.priority) : (b.weight <=> a.weight) }
+          conn = nil
+          srv.each { |r| break unless (conn = connect(r.target.to_s, r.port, self, client, jid, pass)) === false }
+          conn
+        end
+      end
+    end
 
-      EM.connect host, port, self, client, jid, pass
+    ##
+    # Attempt a connection
+    # Stream will raise +NoConnection+ if it receives #unbind before #post_init
+    # this catches that and returns false prompting for another attempt
+    def self.connect(host, port, conn, client, jid, pass)
+      EM.connect host, port, conn, client, jid, pass
+    rescue NoConnection
+      false
+    end
+
+    [:started, :stopped, :ready, :negotiating].each do |state|
+      define_method("#{state}?") { @state == state }
     end
 
     ##
@@ -21,73 +52,53 @@ module Blather
     #   responds to #to_s
     def send(stanza)
       #TODO Queue if not ready
-      LOG.debug "SENDING: (#{caller[1]}) #{stanza}"
+      Blather.logger.debug "SENDING: (#{caller[1]}) #{stanza}"
       send_data stanza.respond_to?(:to_xml) ? stanza.to_xml : stanza.to_s
     end
 
-    ##
-    # True if the stream is in the stopped state
-    def stopped?
-      @state == :stopped
-    end
-
-    ##
-    # True when the stream is in the negotiation phase.
-    def negotiating?
-      ![:stopped, :ready].include? @state
-    end
-
-    ##
-    # True when the stream is ready
-    #   The stream is ready immediately after receiving <stream:stream>
-    #   and before any feature negotion. Once feature negoation starts
-    #   the stream will not be ready until all negotations have completed
-    #   successfully.
-    def ready?
-      @state == :ready
-    end
-
     ##
     # Called by EM.connect to initialize stream variables
     def initialize(client, jid, pass) # :nodoc:
       super()
 
       @error = nil
-      @client = client
+      @receiver = @client = client
 
       self.jid = jid
-      @pass = pass
-
-      @to = @jid.domain
+      @to = self.jid.domain
+      @password = pass
     end
 
     ##
     # Called when EM completes the connection to the server
     # this kicks off the starttls/authorize/bind process
     def connection_completed # :nodoc:
-#      @keepalive = EM::Timer.new(60) { send_data ' ' }
-      @state = :stopped
-      dispatch
+#      @keepalive = EM::PeriodicTimer.new(60) { send_data ' ' }
+      start
     end
 
     ##
     # Called by EM with data from the wire
     def receive_data(data) # :nodoc:
-      LOG.debug "\n#{'-'*30}\n"
-      LOG.debug "<< #{data}"
-      @parser.receive_data data
+      Blather.logger.debug "\n#{'-'*30}\n"
+      Blather.logger.debug "<< #{data}"
+      @parser << data
 
-    rescue ParseWarning => e
-      @client.receive_data e
     rescue ParseError => e
       @error = e
-      send "<stream:error><xml-not-well-formed xmlns='urn:ietf:params:xml:ns:xmpp-streams'/></stream:error>"
+      send "<stream:error><xml-not-well-formed xmlns='#{StreamError::STREAM_ERR_NS}'/></stream:error>"
       stop
     end
 
+    def post_init
+      @connected = true
+    end
+
     ##
     # Called by EM when the connection is closed
     def unbind # :nodoc:
+      raise NoConnection unless @connected
+
 #      @keepalive.cancel
       @state = :stopped
       @client.receive_data @error if @error
@@ -97,54 +108,41 @@ module Blather
     ##
     # Called by the parser with parsed nodes
     def receive(node) # :nodoc:
-      LOG.debug "RECEIVING (#{node.element_name}) #{node}"
+      Blather.logger.debug "RECEIVING (#{node.element_name}) #{node}"
       @node = node
 
-      if @node.find_first('//stream:error', :stream => 'http://etherx.jabber.org/streams')
-        handle_stream_error
-        return
-      end
-
-      case @node.element_name
-      when 'stream'
-        @state = :ready if @state == :stopped
-
-      when 'stream:end'
-        stop
-
-      when 'features'
-        @features = @node.children
-        @state = :features
-        dispatch
-
-      else
-        dispatch
-
+      if @node.namespace && @node.namespace.prefix == 'stream'
+        case @node.element_name
+        when 'stream'
+          @state = :ready if @state == :stopped
+          return
+        when 'error'
+          handle_stream_error
+          return
+        when 'end'
+          stop
+          return
+        when 'features'
+          @state = :negotiating
+          @receiver = Features.new(
+            self,
+            proc { ready! },
+            proc { |err| @error = err; stop }
+          )
+        end
       end
+      @receiver.receive_data @node.to_stanza
     end
 
     ##
     # Ensure the JID gets attached to the client
     def jid=(new_jid) # :nodoc:
-      LOG.debug "NEW JID: #{new_jid}"
+      Blather.logger.debug "NEW JID: #{new_jid}"
       @jid = JID.new new_jid
       @client.jid = @jid
     end
 
   protected
-    ##
-    # Dispatch based on current state
-    def dispatch
-      __send__ @state
-    end
-
-    ##
-    # Start the stream
-    #   Each time the stream is started or re-started we need to kill off the old
-    #   parser so as not to confuse it
-    def start
-    end
-
     ##
     # Stop the stream
     def stop
@@ -154,105 +152,15 @@ module Blather
       end
     end
 
-    ##
-    # Called when @state == :stopped to start the stream
-    #   Counter intuitive, I know
-    def stopped
-      start
-    end
-
-    ##
-    # Called when @state == :ready
-    #   Simply passes the stanza to the client
-    def ready
-      @client.receive_data @node.to_stanza
-    end
-
     def handle_stream_error
-      @error = StreamError.import @node
+      @error = StreamError.import(@node)
       stop
-      @state = :error
     end
 
-    ##
-    # Called when @state == :features
-    #   Runs through the list of features starting each one in turn
-    def features
-      feature = @features.first
-      LOG.debug "FEATURE: #{feature}"
-      @state = case feature ? feature.namespaces.default.href : nil
-      when 'urn:ietf:params:xml:ns:xmpp-tls'      then :establish_tls
-      when 'urn:ietf:params:xml:ns:xmpp-sasl'     then :authenticate_sasl
-      when 'urn:ietf:params:xml:ns:xmpp-bind'     then :bind_resource
-      when 'urn:ietf:params:xml:ns:xmpp-session'  then :establish_session
-      else :ready
-      end
-
-      # Dispatch to the individual feature methods unless
-      # feature negotiation is complete
-      dispatch unless ready?
-    end
-
-    ##
-    # Start TLS
-    def establish_tls
-      unless @tls
-        @tls = TLS.new self
-        # on success destroy the TLS object and restart the stream
-        @tls.on_success { LOG.debug "TLS: SUCCESS"; @tls = nil; start }
-        # on failure stop the stream
-        @tls.on_failure { |err| LOG.debug "TLS: FAILURE"; @error = err; stop }
-
-        @node = @features.shift
-      end
-      @tls.handle @node
-    end
-
-    ##
-    # Authenticate via SASL
-    def authenticate_sasl
-      unless @sasl
-        @sasl = SASL.new(self, @jid, @pass)
-        # on success destroy the SASL object and restart the stream
-        @sasl.on_success { LOG.debug "SASL SUCCESS"; @sasl = nil; start }
-        # on failure set the error and stop the stream
-        @sasl.on_failure { |err| LOG.debug "SASL FAIL"; @error = err; stop }
-
-        @node = @features.shift
-      end
-      @sasl.handle @node
-    end
-
-    ##
-    # Bind to the resource provided by either the client or the server
-    def bind_resource
-      unless @resource
-        @resource = Resource.new self, @jid
-        # on success destroy the Resource object, set the jid, continue along the features dispatch process
-        @resource.on_success { |jid| LOG.debug "RESOURCE: SUCCESS"; @resource = nil; self.jid = jid; @state = :features; dispatch }
-        # on failure end the stream
-        @resource.on_failure { |err| LOG.debug "RESOURCE: FAILURE"; @error = err; stop }
-
-        @node = @features.shift
-      end
-      @resource.handle @node
-    end
-
-    ##
-    # Establish the session between client and server
-    def establish_session
-      unless @session
-        @session = Session.new self, @to
-        # on success destroy the session object, let the client know the stream has been started
-        # then continue the features dispatch process
-        @session.on_success { LOG.debug "SESSION: SUCCESS"; @session = nil; @client.post_init; @state = :features; dispatch }
-        # on failure end the stream
-        @session.on_failure { |err| LOG.debug "SESSION: FAILURE"; @error = err; stop }
-
-        @node = @features.shift
-      end
-      @session.handle @node
+    def ready!
+      @state = :started
+      @receiver = @client
+      @client.post_init
     end
   end
-
 end

data/lib/blather/xmpp_node.rb

@@ -4,13 +4,13 @@ module Blather
   # Base XML Node
   # All XML classes subclass XMPPNode
   # it allows the addition of helpers
-  class XMPPNode < XML::Node
+  class XMPPNode < Nokogiri::XML::Node
     BASE_NAMES = %w[presence message iq].freeze
 
     @@registrations = {}
 
-    class_inheritable_accessor  :ns,
-                                :name
+    class_inheritable_accessor  :registered_ns,
+                                :registered_name
 
     ##
     # Lets a subclass register itself
@@ -19,9 +19,9 @@ module Blather
     # up the class name of the object to instantiate when a new
     # stanza is received
     def self.register(name, ns = nil)
-      self.name = name.to_s
-      self.ns = ns
-      @@registrations[[self.name, self.ns]] = self
+      self.registered_name = name.to_s
+      self.registered_ns = ns
+      @@registrations[[self.registered_name, self.registered_ns]] = self
     end
 
     ##
@@ -36,7 +36,7 @@ module Blather
     # of that class and imports all the <tt>node</tt>'s attributes
     # and children into it.
     def self.import(node)
-      klass = class_from_registration(node.element_name, node.namespace)
+      klass = class_from_registration(node.element_name, (node.namespace.href if node.namespace))
       if klass && klass != self
         klass.import(node)
       else
@@ -55,16 +55,18 @@ module Blather
     #   end
     #
     #   n = Node.new
-    #   n.attributes[:type] = 'foo'
+    #   n[:type] = 'foo'
     #   n.type == :foo
-    #   n.attributes[:name] = 'bar'
+    #   n[:name] = 'bar'
     #   n.name == 'bar'
     def self.attribute_reader(*syms)
       opts = syms.last.is_a?(Hash) ? syms.pop : {}
+      convert_str = "val.#{opts[:call]} if val" if opts[:call]
       syms.flatten.each do |sym|
         class_eval(<<-END, __FILE__, __LINE__)
           def #{sym}
-            attributes[:#{sym}]#{".to_sym unless attributes[:#{sym}].blank?" unless opts[:to_sym] == false}
+            val = self[:#{sym}]
+            #{convert_str}
           end
         END
       end
@@ -79,13 +81,13 @@ module Blather
     #
     #   n = Node.new
     #   n.type = 'foo'
-    #   n.attributes[:type] == 'foo'
+    #   n[:type] == 'foo'
     def self.attribute_writer(*syms)
       syms.flatten.each do |sym|
         next if sym.is_a?(Hash)
         class_eval(<<-END, __FILE__, __LINE__)
           def #{sym}=(value)
-            attributes[:#{sym}] = value
+            self[:#{sym}] = value
           end
         END
       end
@@ -110,14 +112,74 @@ module Blather
       attribute_writer *syms
     end
 
+    ##
+    # Provides a content reader helper that returns the content of a node
+    # +method+ is the method to create
+    # +conversion+ is a method to call on the content before sending it back
+    # +node+ is the name of the content node (this defaults to the method name)
+    #
+    #   class Node
+    #     content_attr_reader :body
+    #     content_attr_reader :type, :to_sym
+    #     content_attr_reader :id, :to_i, :identity
+    #   end
+    #
+    #   n = Node.new 'foo'
+    #   n.to_s == "<foo><body>foobarbaz</body><type>error</type><identity>1000</identity></foo>"
+    #   n.body == 'foobarbaz'
+    #   n.type == :error
+    #   n.id == 1000
+    def self.content_attr_reader(method, conversion = nil, node = nil)
+      node ||= method
+      conversion = "val.#{conversion} if val.respond_to?(:#{conversion})" if conversion
+      class_eval(<<-END, __FILE__, __LINE__)
+        def #{method}
+          val = content_from :#{node}
+          #{conversion}
+        end
+      END
+    end
+
+    ##
+    # Provides a content writer helper that creates or updates the content of a node
+    # +method+ is the method to create
+    # +node+ is the name of the node to create (defaults to the method name)
+    #
+    #   class Node
+    #     content_attr_writer :body
+    #     content_attr_writer :id, :identity
+    #   end
+    #
+    #   n = Node.new 'foo'
+    #   n.body = 'thebodytext'
+    #   n.id = 'id-text'
+    #   n.to_s == '<foo><body>thebodytext</body><identity>id-text</identity></foo>'
+    def self.content_attr_writer(method, node = nil)
+      node ||= method
+      class_eval(<<-END, __FILE__, __LINE__)
+        def #{method}=(val)
+          set_content_for :#{node}, val
+        end
+      END
+    end
+
+    ##
+    # Provides a quick way of building +content_attr_reader+ and +content_attr_writer+
+    # for the same method and node
+    def self.content_attr_accessor(method, conversion = nil, node = nil)
+      content_attr_reader method, conversion, node
+      content_attr_writer method, node
+    end
+
     ##
     # Automatically sets the namespace registered by the subclass
-    def initialize(name = nil, content = nil)
-      name ||= self.class.name
-      content = content.to_s if content
+    def self.new(name = nil, doc = nil)
+      name ||= self.registered_name
 
-      super name.to_s, content
-      self.namespace = self.class.ns unless BASE_NAMES.include?(name.to_s)
+      node = super name.to_s, (doc || Nokogiri::XML::Document.new)
+      node.document.root = node unless doc
+      node.namespace = self.registered_ns unless BASE_NAMES.include?(name.to_s)
+      node
     end
 
     ##
@@ -126,80 +188,79 @@ module Blather
       self.class.import self
     end
 
+    alias_method :nokogiri_namespace=, :namespace=
     def namespace=(namespaces)
       case namespaces
-      when XML::Namespace
-        self.namespaces.namespace = namespaces
+      when Nokogiri::XML::Namespace
+        self.nokogiri_namespace = namespaces
       when String
-        self.namespaces.namespace = XML::Namespace.new(self, nil, namespaces)
+        self.add_namespace nil, namespaces
       when Hash
+        if ns = namespaces.delete(nil)
+          self.add_namespace nil, ns
+        end
         namespaces.each do |p, n|
-          self.namespaces.namespace = XML::Namespace.new(self, p, n)
+          ns = self.add_namespace p, n
+          self.nokogiri_namespace = ns
         end
       end
     end
 
-    def namespace(prefix = nil)
-      (ns = namespaces.find_by_prefix(prefix)) ? ns.href : nil
+    def namespace_href
+      namespace.href if namespace
     end
 
     ##
     # Remove a child with the name and (optionally) namespace given
     def remove_child(name, ns = nil)
-      name = name.to_s
-      self.detect { |n| n.remove! if n.element_name == name && (!ns || n.namespace == ns) }
+      child = xpath(name, ns).first
+      child.remove if child
     end
 
     ##
     # Remove all children with a given name
     def remove_children(name)
-      name = name.to_s
-      self.find(name).each { |n| n.remove! }
+      xpath("./*[local-name()='#{name}']").remove
     end
 
     ##
     # Pull the content from a child
-    def content_from(name)
-      name = name.to_s
-      (child = self.detect { |n| n.element_name == name }) ? child.content : nil
+    def content_from(name, ns = nil)
+      child = xpath(name, ns).first
+      child.content if child
     end
 
     ##
-    # Create a copy
-    def copy(deep = true)
-      copy = self.class.new.inherit(self)
-      copy.element_name = self.element_name
-      copy
+    # Sets the content for the specified node.
+    # If the node exists it is updated. If not a new node is created
+    # If the node exists and the content is nil, the node will be removed entirely
+    def set_content_for(node, content = nil)
+      if content
+        child = xpath(node).first
+        self << (child = XMPPNode.new(node, self.document)) unless child
+        child.content = content
+      else
+        remove_child node
+      end
     end
 
+    alias_method :copy, :dup
+
     ##
     # Inherit all of <tt>stanza</tt>'s attributes and children
     def inherit(stanza)
+      set_namespace stanza.namespace if stanza.namespace
       inherit_attrs stanza.attributes
-      stanza.children.each { |c| self << c.copy(true) }
+      stanza.children.each { |c| self << c.dup }
       self
     end
 
     ##
     # Inherit only <tt>stanza</tt>'s attributes
     def inherit_attrs(attrs)
-      attrs.each  { |a| attributes[a.name] = a.value }
+      attrs.each  { |name, value| self[name] = value }
       self
     end
-
-    ##
-    # Turn itself into an XML string and remove all whitespace between nodes
-    def to_xml
-      # TODO: Fix this for HTML nodes (and any other that might require whitespace)
-      to_s.gsub(">\n<", '><')
-    end
-
-    ##
-    # Override #find to work when a node isn't attached to a document
-    def find(what, nslist = nil)
-      what = what.to_s
-      (self.doc ? super(what, nslist) : select { |i| i.element_name == what })
-    end
   end #XMPPNode
 
-end
+end

data/lib/blather.rb

@@ -1,14 +1,13 @@
 # Require the necessary files
-require File.join(File.dirname(__FILE__), *%w[.. ext push_parser])
 %w[
   rubygems
   eventmachine
-  xml/libxml
+  nokogiri
   digest/md5
   logger
 
   blather/core_ext/active_support
-  blather/core_ext/libxml
+  blather/core_ext/nokogiri
 
   blather/errors
   blather/errors/sasl_error
@@ -31,20 +30,44 @@ require File.join(File.dirname(__FILE__), *%w[.. ext push_parser])
   blather/stanza/presence/status
   blather/stanza/presence/subscription
 
+  blather/stanza/pubsub
+  blather/stanza/pubsub/affiliations
+  blather/stanza/pubsub/create
+  blather/stanza/pubsub/event
+  blather/stanza/pubsub/items
+  blather/stanza/pubsub/publish
+  blather/stanza/pubsub/retract
+  blather/stanza/pubsub/subscribe
+  blather/stanza/pubsub/subscription
+  blather/stanza/pubsub/subscriptions
+  blather/stanza/pubsub/unsubscribe
+
+  blather/stanza/pubsub_owner
+  blather/stanza/pubsub_owner/delete
+  blather/stanza/pubsub_owner/purge
+
   blather/stream
   blather/stream/client
   blather/stream/component
-  blather/stream/stream_handler
   blather/stream/parser
-  blather/stream/resource
-  blather/stream/sasl
-  blather/stream/session
-  blather/stream/tls
+  blather/stream/features
+  blather/stream/features/resource
+  blather/stream/features/sasl
+  blather/stream/features/session
+  blather/stream/features/tls
 ].each { |r| require r }
 
-XML.indent_tree_output = false
-
 module Blather
-  LOG = Logger.new($stdout) unless const_defined?(:LOG)
-  LOG.level = Logger::INFO
+  @@logger = nil
+  def self.logger
+    unless @@logger
+      self.logger = Logger.new($stdout)
+      self.logger.level = Logger::INFO
+    end
+    @@logger
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+  end
 end