sprsquish-blather 0.3.4 → 0.4.0

data/lib/blather/core_ext/active_support.rb

@@ -1,120 +1,4 @@
-# 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|
-      next if sym.is_a?(Hash)
-      class_eval <<-EOS
-        def self.#{sym}
-          read_inheritable_attribute(:#{sym})
-        end
-
-        def #{sym}
-          self.class.#{sym}
-        end
-      EOS
-    end
-  end
-
-  def class_inheritable_writer(*syms)
-    syms.each do |sym|
-      class_eval <<-EOS
-        def self.#{sym}=(obj)
-          write_inheritable_attribute(:#{sym}, obj)
-        end
-      EOS
-    end
-  end
-
-  def class_inheritable_array_writer(*syms)
-    syms.each do |sym|
-      class_eval <<-EOS
-        def self.#{sym}=(obj)
-          write_inheritable_array(:#{sym}, obj)
-        end
-      EOS
-    end
-  end
-
-  def class_inheritable_hash_writer(*syms)
-    syms.each do |sym|
-      class_eval <<-EOS
-        def self.#{sym}=(obj)
-          write_inheritable_hash(:#{sym}, obj)
-        end
-      EOS
-    end
-  end
-
-  def class_inheritable_accessor(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_writer(*syms)
-  end
-
-  def class_inheritable_array(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_array_writer(*syms)
-  end
-
-  def class_inheritable_hash(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_hash_writer(*syms)
-  end
-
-  def inheritable_attributes
-    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
-  end
-
-  def write_inheritable_attribute(key, value)
-    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-      @inheritable_attributes = {}
-    end
-    inheritable_attributes[key] = value
-  end
-
-  def write_inheritable_array(key, elements)
-    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
-  end
-
-  def write_inheritable_hash(key, hash)
-    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
-  end
-
-  def read_inheritable_attribute(key)
-    inheritable_attributes[key]
-  end
-
-  def reset_inheritable_attributes
-    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-  end
-
-  private
-    # Prevent this constant from being created multiple times
-    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
-
-    def inherited_with_inheritable_attributes(child)
-      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
-
-      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-      else
-        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
-          memo.update(key => value.duplicable? ? value.dup : value)
-        end
-      end
-
-      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
-    end
-
-    alias inherited_without_inheritable_attributes inherited
-    alias inherited inherited_with_inheritable_attributes
-end #Class
+require File.join(File.dirname(__FILE__), 'active_support', 'inheritable_attributes')
 
 class Object # :nodoc:
   def duplicable?; true; end

data/lib/blather/core_ext/nokogiri.rb

@@ -0,0 +1,35 @@
+module Nokogiri # :nodoc:
+module XML
+
+  class Node
+    alias_method :element_name, :name
+    alias_method :element_name=, :name=
+
+    alias_method :attr_set, :[]=
+    def []=(name, value)
+      name = name.to_s
+      value.nil? ? remove_attribute(name) : attr_set(name, value.to_s)
+    end
+
+#    alias_method :attr_get, :[]
+#    def [](name)
+#      attr_get name.to_s
+#    end
+
+    alias_method :nokogiri_xpath, :xpath
+    def xpath(*paths)
+      paths[0] = paths[0].to_s
+      if paths.size > 1 && (namespaces = paths.pop).is_a?(Hash)
+        paths << namespaces.inject({}) { |h,v| h[v[0].to_s] = v[1]; h }
+      end
+      nokogiri_xpath *paths
+    end
+    alias_method :find, :xpath
+
+    def find_first(*paths)
+      xpath(*paths).first
+    end
+  end
+
+end #XML
+end #Blather

data/lib/blather/errors/sasl_error.rb

@@ -1,6 +1,8 @@
 module Blather
 
 class SASLError < BlatherError
+  SASL_ERR_NS = 'urn:ietf:params:xml:ns:xmpp-sasl'
+
   class_inheritable_accessor :err_name
   @@registrations = {}
 
@@ -16,7 +18,7 @@ class SASLError < BlatherError
   end
 
   def name
-    @node.children.first.element_name.gsub('-', '_').to_sym if @node
+    @node.find_first('err_ns:*', :err_ns => SASL_ERR_NS).element_name.gsub('-', '_').to_sym if @node
   end
 end #SASLError
 

data/lib/blather/errors/stanza_error.rb

@@ -4,6 +4,7 @@ module Blather
 # Stanza errors
 # RFC3920 Section 9.3 (http://xmpp.org/rfcs/rfc3920.html#stanzas-error)
 class StanzaError < BlatherError
+  STANZA_ERR_NS = 'urn:ietf:params:xml:ns:xmpp-stanzas'
   VALID_TYPES = [:cancel, :continue, :modify, :auth, :wait]
 
   register :stanza_error
@@ -19,9 +20,9 @@ class StanzaError < BlatherError
 
     error_node = node.find_first '//*[local-name()="error"]'
 
-    name = error_node.find_first('child::*[name()!="text"]', 'urn:ietf:params:xml:ns:xmpp-stanzas').element_name
+    name = error_node.find_first('child::*[name()!="text"]', STANZA_ERR_NS).element_name
     type = error_node['type']
-    text = node.find_first '//err_ns:text', :err_ns => 'urn:ietf:params:xml:ns:xmpp-stanzas'
+    text = node.find_first 'descendant::*[name()="text"]', STANZA_ERR_NS
     text = text.content if text
 
     extras = error_node.find("descendant::*[name()!='text' and name()!='#{name}']").map { |n| n }
@@ -59,27 +60,19 @@ class StanzaError < BlatherError
   # Creates an XML node from the error
   def to_node
     node = self.original.reply
+    node.type = 'error'
+    node << (error_node = XMPPNode.new('error'))
 
-    error_node = XMPPNode.new 'error'
-    err = XMPPNode.new(@name)
+    error_node << (err = XMPPNode.new(@name, error_node.document))
     err.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
-    error_node << err
 
     if self.text
-      text = XMPPNode.new('text')
+      error_node << (text = XMPPNode.new('text', error_node.document))
       text.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
-      text << self.text
-      error_node << text
-    end
-
-    self.extras.each do |extra|
-      extra_copy = extra.copy
-      extra_copy.namespace = extra.namespace
-      error_node << extra_copy
+      text.content = self.text
     end
 
-    node << error_node
-    node.type = 'error'
+    self.extras.each { |extra| error_node << extra.dup }
     node
   end
 
@@ -90,7 +83,7 @@ class StanzaError < BlatherError
   end
 
   def inspect # :nodoc:
-    "Stanza Error (#{@name}): #{self.text}"
+    "Stanza Error (#{@name}): #{self.text} [#{self.extras}]"
   end
   alias_method :to_s, :inspect # :nodoc:
 end #StanzaError

data/lib/blather/errors/stream_error.rb

@@ -4,6 +4,8 @@ module Blather
 # Stream Errors
 # RFC3920 Section 9.3 (http://xmpp.org/rfcs/rfc3920.html#streams-error-rules)
 class StreamError < BlatherError
+  STREAM_ERR_NS = 'urn:ietf:params:xml:ns:xmpp-streams'
+
   register :stream_error
 
   attr_reader :text, :extras
@@ -12,11 +14,12 @@ class StreamError < BlatherError
   # Factory method for instantiating the proper class
   # for the error
   def self.import(node)
-    name = node.find_first('descendant::*[name()!="text"]', 'urn:ietf:params:xml:ns:xmpp-streams').element_name
-    text = node.find_first '//err_ns:text', :err_ns => 'urn:ietf:params:xml:ns:xmpp-streams'
+    name = node.find_first('descendant::*[name()!="text"]', STREAM_ERR_NS).element_name
+
+    text = node.find_first 'descendant::*[name()="text"]', STREAM_ERR_NS
     text = text.content if text
 
-    extras = node.find("descendant::*[name()!='text' and name()!='#{name}']").map { |n| n }
+    extras = node.find("descendant::*[namespace-uri()!='#{STREAM_ERR_NS}']").map { |n| n }
 
     self.new name, text, extras
   end
@@ -41,22 +44,16 @@ class StreamError < BlatherError
   def to_node
     node = XMPPNode.new('stream:error')
 
-    err = XMPPNode.new(@name)
+    node << (err = XMPPNode.new(@name, node.document))
     err.namespace = 'urn:ietf:params:xml:ns:xmpp-streams'
-    node << err
 
     if self.text
-      text = XMPPNode.new('text')
+      node << (text = XMPPNode.new('text', node.document))
       text.namespace = 'urn:ietf:params:xml:ns:xmpp-streams'
-      text << self.text
-      node << text
+      text.content = self.text
     end
 
-    self.extras.each do |extra|
-      extra_copy = extra.copy
-      extra_copy.namespace = extra.namespace
-      node << extra_copy
-    end
+    self.extras.each { |extra| node << extra.dup }
     node
   end
 
@@ -67,7 +64,7 @@ class StreamError < BlatherError
   end
 
   def inspect # :nodoc:
-    "Stream Error (#{@name}): #{self.text}"
+    "Stream Error (#{@name}): #{self.text}" + (self.extras.empty? ? '' : " [#{self.extras}]")
   end
   alias_method :to_s, :inspect # :nodoc:
 end #StreamError

data/lib/blather/errors.rb

@@ -34,31 +34,14 @@ module Blather
     end
   end
 
-  ##
-  # TLS negotiations broke down
-  class TLSFailure < BlatherError
-    register :tls_failure
-  end
-
-  class ParseWarning < BlatherError
-    register :parse_warning
-    attr_reader :libxml_error, :message
-
-    def initialize(err)
-      @libxml_error = err
-      @message = err.to_s
-    end
-  end
-
   ##
   # Something bad happened while parsing the incoming stream
   class ParseError < BlatherError
     register :parse_error
-    attr_reader :libxml_error, :message
+    attr_reader :message
 
-    def initialize(err)
-      @libxml_error = err
-      @message = err.to_s
+    def initialize(msg)
+      @message = msg.to_s
     end
   end
 end

data/lib/blather/jid.rb

@@ -83,6 +83,7 @@ module Blather
     def <=>(o)
       to_s <=> o.to_s
     end
+    alias_method :eql?, :==
 
     ##
     # Test if JID is stripped

data/lib/blather/roster.rb

@@ -71,6 +71,15 @@ module Blather
       @items.dup
     end
 
+    ##
+    # A hash of items keyed by group
+    def grouped
+      self.inject(Hash.new{|h,k|h[k]=[]}) do |hash, item|
+        item[1].groups.each { |group| hash[group] << item[1] }
+        hash
+      end
+    end
+
   private
     def self.key(jid)
       JID.new(jid).stripped.to_s

data/lib/blather/roster_item.rb

@@ -13,6 +13,11 @@ module Blather
     attr_accessor :name,
                   :groups
 
+    def self.new(item)
+      return item if item.is_a?(self)
+      super
+    end
+
     ##
     # item:: can be a JID, String (a@b) or a Stanza
     def initialize(item)
@@ -29,7 +34,7 @@ module Blather
         self.name         = item[:name]
         self.subscription = item[:subscription]
         self.ask          = item[:ask]
-        item.groups.each { |g| self.groups << g }
+        item.groups.each { |g| @groups << g }
       end
 
       @groups = [nil] if @groups.empty?

data/lib/blather/stanza/disco/disco_info.rb

@@ -7,64 +7,76 @@ class Stanza
   class DiscoInfo < Disco
     register :disco_info, nil, 'http://jabber.org/protocol/disco#info'
 
-    def initialize(type = nil, node = nil, identities = [], features = [])
-      super type
-
-      self.node = node
-
-      [identities].flatten.each do |id|
-        query << (id.is_a?(Identity) ? id : Identity.new(id[:name], id[:type], id[:category]))
-      end
-
-      [features].flatten.each do |feature|
-        query << (feature.is_a?(Feature) ? feature : Feature.new(feature))
-      end
+    def self.new(type = nil, node = nil, identities = [], features = [])
+      new_node = super type
+      new_node.node = node
+      [identities].flatten.each { |id|      new_node.query << Identity.new(id)      }
+      [features].flatten.each   { |feature| new_node.query << Feature.new(feature)  }
+      new_node
     end
 
     ##
     # List of identity objects
     def identities
-      identities = query.find('identity')
-      identities = query.find('query_ns:identity', :query_ns => self.class.ns) if identities.empty?
-      identities.map { |i| Identity.new i }
+      query.find('//query_ns:identity', :query_ns => self.class.registered_ns).map { |i| Identity.new i }
     end
 
     ##
     # List of feature objects
     def features
-     features = query.find('feature')
-     features = query.find('query_ns:feature', :query_ns => self.class.ns) if features.empty?
-     features.map { |i| Feature.new i }
+      query.find('//query_ns:feature', :query_ns => self.class.registered_ns).map { |i| Feature.new i }
     end
 
     class Identity < XMPPNode
-      attribute_accessor :category, :type
-      attribute_accessor :name, :to_sym => false
+      attribute_accessor :category, :type, :call => :to_sym
+      attribute_accessor :name
 
-      def initialize(name, type = nil, category = nil)
-        super :identity
+      def self.new(name, type = nil, category = nil)
+        new_node = super :identity
 
-        if name.is_a?(XML::Node)
-          self.inherit name
+        case name
+        when Nokogiri::XML::Node
+          new_node.inherit name
+        when Hash
+          new_node.name = name[:name]
+          new_node.type = name[:type]
+          new_node.category = name[:category]
         else
-          self.name = name
-          self.type = type
-          self.category = category
+          new_node.name = name
+          new_node.type = type
+          new_node.category = category
         end
+        new_node
       end
+
+      def eql?(o)
+        raise "Cannot compare #{self.class} with #{o.class}" unless o.is_a?(self.class)
+        o.name == self.name &&
+        o.type == self.type &&
+        o.category == self.category
+      end
+      alias_method :==, :eql?
     end
 
     class Feature < XMPPNode
-      attribute_accessor :var, :to_sym => false
+      attribute_accessor :var
 
-      def initialize(var)
-        super :feature
-        if var.is_a?(XML::Node)
-          self.inherit var
+      def self.new(var)
+        new_node = super :feature
+        case var
+        when Nokogiri::XML::Node
+          new_node.inherit var
         else
-          self.var = var
+          new_node.var = var
         end
+        new_node
+      end
+
+      def eql?(o)
+        raise "Cannot compare #{self.class} with #{o.class}" unless o.is_a?(self.class)
+        o.var == self.var
       end
+      alias_method :==, :eql?
     end
   end
 

data/lib/blather/stanza/disco/disco_items.rb

@@ -4,47 +4,58 @@ class Stanza
   class DiscoItems < Disco
     register :disco_items, nil, 'http://jabber.org/protocol/disco#items'
 
-    def initialize(type = nil, node = nil, items = [])
-      super type
-      self.node = node
-      [items].flatten.each do |item|
-        query << (item.is_a?(Item) ? item : Item.new(item[:jid], item[:node], item[:name]))
-      end
+    def self.new(type = nil, node = nil, items = [])
+      new_node = super type
+      new_node.node = node
+      [items].flatten.each { |item| new_node.query << Item.new(item) }
+      new_node
     end
 
     def items
-      items = query.find('item')
-      items = query.find('query_ns:item', :query_ns => self.class.ns) if items.empty?
-      items.map { |i| Item.new i }
+      query.find('//query_ns:item', :query_ns => self.class.registered_ns).map { |i| Item.new i }
     end
 
     def node=(node)
-      query.attributes[:node] = node
+      query[:node] = node
     end
 
     def node
-      query.attributes[:node]
+      query[:node]
     end
 
     class Item < XMPPNode
-      def initialize(jid, node = nil, name = nil)
-        super :item
-
-        if jid.is_a?(XML::Node)
-          self.inherit jid
+      def self.new(jid, node = nil, name = nil)
+        new_node = super :item
+
+        case jid
+        when Nokogiri::XML::Node
+          new_node.inherit jid
+        when Hash
+          new_node.jid = jid[:jid]
+          new_node.node = jid[:node]
+          new_node.name = jid[:name]
         else
-          self.jid = jid
-          self.node = node
-          self.name = name
+          new_node.jid = jid
+          new_node.node = node
+          new_node.name = name
         end
+        new_node
       end
 
       def jid
-        (j = attributes[:jid]) ? JID.new(j) : nil
+        (j = self[:jid]) ? JID.new(j) : nil
       end
       attribute_writer :jid
 
-      attribute_accessor :node, :name, :to_sym => false      
+      attribute_accessor :node, :name
+
+      def eql?(o)
+        raise "Cannot compare #{self.class} with #{o.class}" unless o.is_a?(self.class)
+        o.jid == self.jid &&
+        o.node == self.node &&
+        o.name == self.name
+      end
+      alias_method :==, :eql?
     end
   end
 

data/lib/blather/stanza/disco.rb

@@ -2,7 +2,13 @@ module Blather
 class Stanza
 
   class Disco < Iq::Query
-    attribute_accessor :node, :to_sym => false
+    def node
+      query[:node]
+    end
+
+    def node=(node)
+      query[:node] = node
+    end
   end
 
 end #Stanza

data/lib/blather/stanza/iq/query.rb

@@ -6,16 +6,17 @@ class Iq
     register :query, :query
 
     ##
-    # Ensure the namespace is set to the query node
-    def initialize(type = nil)
-      super
-      query.namespace = self.class.ns
+    # Ensure the query node is created
+    def self.new(type = nil)
+      node = super
+      node.query
+      node
     end
 
     ##
     # Kill the query node before running inherit
     def inherit(node)
-      query.remove!
+      query.remove
       super
     end
 
@@ -23,9 +24,16 @@ class Iq
     # Query node accessor
     # This will ensure there actually is a query node
     def query
-      q = find_first('query')
-      q = find_first('//query_ns:query', :query_ns => self.class.ns) if !q && self.class.ns
-      (self << (q = XMPPNode.new('query'))) unless q
+      q = if self.class.registered_ns
+        find_first('query_ns:query', :query_ns => self.class.registered_ns)
+      else
+        find_first('query')
+      end
+
+      unless q
+        (self << (q = XMPPNode.new('query', self.document)))
+        q.namespace = self.class.registered_ns
+      end
       q
     end