blather 0.2.1 → 0.2.2

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

@@ -0,0 +1,59 @@
+module Blather
+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
+    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 }
+    end
+
+    def node=(node)
+      query.attributes[:node] = node
+    end
+
+    def node
+      query.attributes[:node]
+    end
+
+    class Item < XMPPNode
+      def initialize(jid, node = nil, name = nil)
+        super :item
+
+        if jid.is_a?(XML::Node)
+          self.inherit jid
+        else
+          self.jid = jid
+          self.node = node
+          self.name = name
+        end
+      end
+
+      def jid
+        (j = attributes[:jid]) ? JID.new(j) : nil
+      end
+      attribute_writer :jid
+
+      attribute_accessor :node, :name, :to_sym => false      
+    end
+
+    def eql?(other)
+      other.kind_of?(self.class) &&
+      other.jid == self.jid &&
+      other.node == self.node &&
+      other.name == self.name
+    end
+  end
+
+end #Stanza
+end #Blather

data/lib/blather/stanza/iq.rb

@@ -4,22 +4,34 @@ class Stanza
   ##
   # Base Iq stanza
   class Iq < Stanza
+    VALID_TYPES = [:get, :set, :result, :error]
+
     register :iq
 
     def self.import(node)
-      raise "Import missmatch #{[node.element_name, self.name].inspect}" if node.element_name != self.name.to_s
+      raise(ArgumentError, "Import missmatch #{[node.element_name, self.name].inspect}") if node.element_name != self.name.to_s
       klass = nil
-      node.each { |e| break if klass = class_from_registration(e.element_name, e.xmlns) }
-      (klass || self).new(node['type']).inherit(node)
+      node.children.each { |e| break if klass = class_from_registration(e.element_name, e.namespace) }
+      (klass || self).new(node.attributes[:type]).inherit(node)
     end
 
     def initialize(type = nil, to = nil, id = nil)
       super :iq
-      self.xmlns = nil
       self.type = type || :get
       self.to = to
       self.id = id if id
     end
+
+    VALID_TYPES.each do |valid_type|
+      define_method("#{valid_type}?") { self.type == valid_type }
+    end
+
+    ##
+    # Ensures type is :get, :set, :result or :error
+    def type=(type)
+      raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}" if type && !VALID_TYPES.include?(type.to_sym)
+      super
+    end
   end
 
 end #Stanza

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

@@ -9,14 +9,13 @@ class Iq
     # Ensure the namespace is set to the query node
     def initialize(type = nil)
       super
-      query.xmlns = self.class.xmlns
+      query.namespace = self.class.ns
     end
 
     ##
     # Kill the query node before running inherit
     def inherit(node)
       query.remove!
-      @query = nil
       super
     end
 
@@ -24,7 +23,9 @@ class Iq
     # Query node accessor
     # This will ensure there actually is a query node
     def query
-      (self << (q = XMPPNode.new('query'))) unless q = find_first('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
     end
 
@@ -39,8 +40,9 @@ class Iq
     ##
     # A query reply should have type set to "result"
     def reply!
-      self.type = :result
       super
+      self.type = :result
+      self
     end
   end #Query
 

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

@@ -5,27 +5,42 @@ class Iq
   class Roster < Query
     register :roster, nil, 'jabber:iq:roster'
 
+    ##
+    # Any new items are added to the query
     def initialize(type = nil, item = nil)
-      super(type)
+      super type
       query << item if item
     end
 
+    ##
+    # Inherit the XMPPNode to create a proper Roster object.
+    # Creates RosterItem objects out of each roster item as well.
     def inherit(node)
+      # remove the current set of nodes
       items.each { |i| i.remove! }
-      @items = nil
       super
+      # transmogrify nodes into RosterItems
       items.each { |i| query << RosterItem.new(i); i.remove! }
-      @items = nil
       self
     end
 
+    ##
+    # Roster items
     def items
-      query.find('item')#.map { |g| RosterItem.new g }
+      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) }
     end
 
     class RosterItem < XMPPNode
+      ##
+      # [jid] may be either a JID or XMPPNode. 
+      # [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')
+        super :item
+
         if jid.is_a?(XML::Node)
           self.inherit jid
         else
@@ -36,49 +51,34 @@ class Iq
         end
       end
 
+      ##
+      # Roster item's JID
       def jid
-        (j = attributes['jid']) ? JID.new(j) : nil
-      end
-
-      def jid=(jid)
-        attributes['jid'] = jid
-      end
-
-      def name
-        attributes['name']
-      end
-
-      def name=(name)
-        attributes['name'] = name
+        (j = attributes[:jid]) ? JID.new(j) : nil
       end
+      attribute_writer :jid
 
-      def subscription
-        attributes['subscription'].to_sym if attributes['subscription']
-      end
-
-      def subscription=(subscription)
-        attributes['subscription'] = subscription
-      end
+      attribute_accessor :name, :to_sym => false
 
-      def ask
-        attributes['ask'].to_sym if attributes['ask']
-      end
-
-      def ask=(ask)
-        attributes['ask'] = ask
-      end
+      attribute_accessor :subscription, :ask
 
+      ##
+      # The groups roster item belongs to
       def groups
-        @groups ||= find('group').map { |g| g.content }
+        find(:group).map { |g| g.content }
       end
 
-      def groups=(grps)
-        find('group').each { |g| g.remove! }
-        @groups = nil
-
-        grps.uniq.each { |g| add_node XMPPNode.new('group', g.to_s) } if grps
+      ##
+      # 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
       end
 
+      ##
+      # Convert the roster item to a proper stanza all wrapped up
+      # This facilitates new subscriptions
       def to_stanza
         Roster.new(:set, self)
       end

data/lib/blather/stanza/pubsub.rb

@@ -0,0 +1,33 @@
+module Blather
+class Stanza
+
+  class PubSub < Iq
+    register :pubsub, :pubsub, 'http://jabber.org/protocol/pubsub'
+
+    ##
+    # Ensure the namespace is set to the query node
+    def initialize(type = nil, host = nil)
+      super type
+      self.to = host
+      pubsub.namespace = self.class.ns unless pubsub.namespace
+    end
+
+    ##
+    # Kill the pubsub node before running inherit
+    def inherit(node)
+      pubsub.remove!
+      super
+    end
+
+    def pubsub
+      unless p = find_first('//pubsub', Stanza::PubSub::Affiliations.ns)
+        p = XMPPNode.new('pubsub')
+        p.namespace = self.class.ns
+        self << p
+      end
+      p
+    end
+  end
+
+end #Stanza
+end #Blather

data/lib/blather/stanza/pubsub/affiliations.rb

@@ -0,0 +1,52 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Affiliations < PubSub
+    register :pubsub_affiliations, :pubsub_affiliations, self.ns
+
+    include Enumerable
+
+    def initialize(type = nil, host = nil)
+      super
+      affiliations
+    end
+
+    ##
+    # Kill the affiliations node before running inherit
+    def inherit(node)
+      affiliations.remove!
+      super
+    end
+
+    def affiliations
+      aff = pubsub.find_first('//pubsub_ns:affiliations', :pubsub_ns => self.class.ns)
+      (self.pubsub << (aff = XMPPNode.new('affiliations'))) unless aff
+      aff
+    end
+
+    def [](affiliation)
+      list[affiliation]
+    end
+
+    def each(&block)
+      list.each &block
+    end
+
+    def size
+      list.size
+    end
+
+    def list
+      items = affiliations.find('//pubsub_ns:affiliation', :pubsub_ns => self.class.ns)
+      items.inject({}) do |hash, item|
+        hash[item.attributes[:affiliation].to_sym] ||= []
+        hash[item.attributes[:affiliation].to_sym] << item.attributes[:node]
+        hash
+      end
+    end
+  end #Affiliations
+
+end #PubSub
+end #Stanza
+end #Blather

data/lib/blather/stanza/pubsub/errors.rb

@@ -0,0 +1,9 @@
+module Blather
+class Stanza
+
+  class PubSubErrors < PubSub
+    attribute_accessor :node, :to_sym => false
+  end
+
+end #Stanza
+end #Blather

data/lib/blather/stanza/pubsub/event.rb

@@ -0,0 +1,21 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Event < Message
+    register :pubsub_event, nil, 'http://jabber.org/protocol/pubsub#event'
+
+    def items
+    end
+
+    class Item
+      attribute_accessor :id, :node, :to_sym => false
+
+      alias_method :payload, :content
+      alias_method :payload=, :content=
+    end
+  end
+
+end #PubSub
+end #Stanza
+end #Blather

data/lib/blather/stanza/pubsub/items.rb

@@ -0,0 +1,59 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Items < PubSub
+    register :pubsub_items, :pubsub_items, self.ns
+
+    include Enumerable
+
+    def self.request(host, path, list = [], max = nil)
+      node = self.new :get, host
+
+      node.items.attributes[:node] = path
+      node.items.attributes[:max_items] = max
+
+      (list || []).each do |id|
+        item = XMPPNode.new 'item'
+        item.attributes[:id] = id
+        node.items << item
+      end
+
+      node
+    end
+
+    def initialize(type = nil, host = nil)
+      super
+      items
+    end
+
+    ##
+    # Kill the items node before running inherit
+    def inherit(node)
+      items.remove!
+      super
+    end
+
+    def [](id)
+      items[id]
+    end
+
+    def each(&block)
+      items.each &block
+    end
+
+    def size
+      items.size
+    end
+
+    def items
+      items = pubsub.find_first('//items', self.class.ns)
+      items = pubsub.find_first('//pubsub_ns:items', :pubsub_ns => self.class.ns) unless items
+      (self.pubsub << (items = XMPPNode.new('items'))) unless items
+      items
+    end
+  end
+
+end #PubSub
+end #Stanza
+end #Blather

data/lib/blather/stanza/pubsub/owner.rb

@@ -0,0 +1,9 @@
+module Blather
+class Stanza
+
+  class PubSubOwner < PubSub
+    attribute_accessor :node, :to_sym => false
+  end
+
+end #Stanza
+end #Blather

data/lib/blather/stanza/pubsub/subscriptions.rb

@@ -0,0 +1,57 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Subscriptions < PubSub
+    register :pubsub_subscriptions, :pubsub_subscriptions, self.ns
+
+    include Enumerable
+
+    ##
+    # Ensure the namespace is set to the query node
+    def initialize(type = nil, host = nil)
+      super type
+      self.to = host
+      subscriptions
+    end
+
+    ##
+    # Kill the pubsub node before running inherit
+    def inherit(node)
+      subscriptions.remove!
+      super
+    end
+
+    def subscriptions
+      aff = pubsub.find_first('//pubsub_ns:subscriptions', :pubsub_ns => self.class.ns)
+      (self.pubsub << (aff = XMPPNode.new('subscriptions'))) unless aff
+      aff
+    end
+
+    def [](subscription)
+      list[subscription]
+    end
+
+    def each(&block)
+      list.each &block
+    end
+
+    def size
+      list.size
+    end
+
+    def list
+      @subscription_list ||= begin
+        items = subscriptions.find('//pubsub_ns:subscription', :pubsub_ns => self.class.ns)
+        items.inject({}) do |hash, item|
+          hash[item.attributes[:subscription].to_sym] ||= []
+          hash[item.attributes[:subscription].to_sym] << item.attributes[:node]
+          hash
+        end
+      end
+    end
+  end #Subscriptions
+
+end #PubSub
+end #Stanza
+end #Blather