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/active_support/inheritable_attributes.rb

@@ -0,0 +1,117 @@
+# 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

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.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/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