blather 0.3.4 → 0.4.0

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

@@ -14,12 +14,12 @@ module Blather
     # that inherits Stanza can register a callback for itself
     # which is added to a list and iterated over when looking for
     # a callback to use
-    def self.register(type, name = nil, ns = nil)
-      @@handler_list << type
+    def self.register(handler, name = nil, ns = nil)
+      @@handler_list << handler
       self.handler_heirarchy ||= []
-      self.handler_heirarchy.unshift type
+      self.handler_heirarchy.unshift handler
 
-      name = name || self.name || type
+      name = name || self.registered_name || handler
       super name, ns
     end
 
@@ -44,24 +44,32 @@ module Blather
     ##
     # Automatically set the stanza's ID
     # and attach it to a document so XPath searching works
-    def initialize(name = nil)
-      super
-      XML::Document.new.root = self
-      self.name = name.to_s if name
-      self.id = self.class.next_id
+    def self.new(name = nil)
+      node = super
+      node.name = name.to_s if name
+      node
     end
 
     ##
-    # Helper method to ask the object if it's an error
-    def error?
-      self.type == :error
+    # Helper method to generate stanza guard methods
+    #
+    # attribute_helpers_for(:type, [:subscribe, :unsubscribe])
+    #
+    # This generates "subscribe?" and "unsubscribe?" methods that return
+    # true if self.type == :subscribe or :unsubscribe, respectively.
+    def self.attribute_helpers_for(attr, values)
+      [values].flatten.each do |v|
+        define_method("#{v}?") { __send__(attr) == v }
+      end
     end
 
+    attribute_helpers_for(:type, :error)
+
     ##
     # Copies itself then swaps from and to
     # then returns the new stanza
     def reply
-      self.copy(true).reply!
+      self.dup.reply!
     end
 
     ##
@@ -71,23 +79,23 @@ module Blather
       self
     end
 
-    attribute_accessor :id, :to_sym => false
+    attribute_accessor :id
 
     attribute_writer :to, :from
 
     ##
     # returns:: JID created from the "to" value of the stanza
     def to
-      JID.new(attributes[:to]) if attributes[:to]
+      JID.new(self[:to]) if self[:to]
     end
 
     ##
     # returns:: JID created from the "from" value of the stanza
     def from
-      JID.new(attributes[:from]) if attributes[:from]
+      JID.new(self[:from]) if self[:from]
     end
 
-    attribute_accessor :type
+    attribute_accessor :type, :call => :to_sym
 
     ##
     # Transform the stanza into a stanza error
@@ -96,5 +104,14 @@ module Blather
     def as_error(name, type, text = nil, extras = [])
       StanzaError.new self, name, type, text, extras
     end
+
+    protected
+    def reply_if_needed!
+      unless @reversed_endpoints
+        reply!
+        @reversed_endpoints = true
+      end
+      self
+    end
   end
-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/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/iq.rb

@@ -9,17 +9,22 @@ class Stanza
     register :iq
 
     def self.import(node)
-      raise(ArgumentError, "Import missmatch #{[node.element_name, self.name].inspect}") if node.element_name != self.name.to_s
       klass = nil
-      node.children.each { |e| break if klass = class_from_registration(e.element_name, e.namespace) }
-      (klass || self).new(node.attributes[:type]).inherit(node)
+      node.children.each { |e| break if klass = class_from_registration(e.element_name, (e.namespace.href if e.namespace)) }
+
+      if klass && klass != self
+        klass.import(node)
+      else
+        new(node[:type]).inherit(node)
+      end
     end
 
-    def initialize(type = nil, to = nil, id = nil)
-      super :iq
-      self.type = type || :get
-      self.to = to
-      self.id = id if id
+    def self.new(type = nil, to = nil, id = nil)
+      node = super :iq
+      node.type = type || :get
+      node.to = to
+      node.id = id || self.next_id
+      node
     end
 
     VALID_TYPES.each do |valid_type|

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
 

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

@@ -7,9 +7,10 @@ class Iq
 
     ##
     # Any new items are added to the query
-    def initialize(type = nil, item = nil)
-      super type
-      query << item if item
+    def self.new(type = nil, item = nil)
+      node = super type
+      node.query << item if item
+      node
     end
 
     ##
@@ -17,19 +18,17 @@ class Iq
     # Creates RosterItem objects out of each roster item as well.
     def inherit(node)
       # remove the current set of nodes
-      items.each { |i| i.remove! }
+      remove_children :item
       super
       # transmogrify nodes into RosterItems
-      items.each { |i| query << RosterItem.new(i); i.remove! }
+      items.each { |i| query << RosterItem.new(i); i.remove }
       self
     end
 
     ##
     # Roster items
     def items
-      items = query.find('//item', self.class.ns)
-      items = query.find('//query_ns:item', :query_ns => self.class.ns) if items.empty?
-      items.map { |i| RosterItem.new(i) }
+      query.find('//ns:item', :ns => self.class.registered_ns).map { |i| RosterItem.new(i) }
     end
 
     class RosterItem < XMPPNode
@@ -38,42 +37,54 @@ class Iq
       # [name] name alias of the given JID
       # [subscription] subscription type
       # [ask] ask subscription sub-state
-      def initialize(jid = nil, name = nil, subscription = nil, ask = nil)
-        super :item
+      def self.new(jid = nil, name = nil, subscription = nil, ask = nil)
+        new_node = super :item
 
-        if jid.is_a?(XML::Node)
-          self.inherit jid
+        case jid
+        when Nokogiri::XML::Node
+          new_node.inherit jid
+        when Hash
+          new_node.jid = jid[:jid]
+          new_node.name = jid[:name]
+          new_node.subscription = jid[:subscription]
+          new_node.ask = jid[:ask]
         else
-          self.jid = jid
-          self.name = name
-          self.subscription = subscription
-          self.ask = ask
+          new_node.jid = jid
+          new_node.name = name
+          new_node.subscription = subscription
+          new_node.ask = ask
         end
+        new_node
       end
 
       ##
       # Roster item's JID
       def jid
-        (j = attributes[:jid]) ? JID.new(j) : nil
+        (j = self[:jid]) ? JID.new(j) : nil
       end
       attribute_writer :jid
 
-      attribute_accessor :name, :to_sym => false
+      attribute_accessor :name
 
-      attribute_accessor :subscription, :ask
+      attribute_accessor :subscription, :ask, :call => :to_sym
 
       ##
       # The groups roster item belongs to
       def groups
-        find(:group).map { |g| g.content }
+        find('child::*[local-name()="group"]').map { |g| g.content }
       end
 
       ##
       # Set the roster item's groups
       # must be an array
       def groups=(new_groups)
-        find(:group).each { |g| g.remove! }
-        new_groups.uniq.each { |g| self << XMPPNode.new(:group, g) } if new_groups
+        remove_children :group
+        if new_groups
+          new_groups.uniq.each do |g|
+            self << (group = XMPPNode.new(:group, self.document))
+            group.content = g
+          end
+        end
       end
 
       ##