sprsquish-blather 0.3.4 → 0.4.0

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
 
       ##

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

@@ -8,11 +8,23 @@ class Stanza
 
     register :message
 
-    def initialize(to = nil, body = nil, type = :chat)
-      super()
-      self.to = to
-      self.type = type
-      self.body = body
+    def self.import(node)
+      klass = nil
+      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 self.new(to = nil, body = nil, type = :chat)
+      node = super(:message)
+      node.to = to
+      node.type = type
+      node.body = body
+      node
     end
 
     VALID_TYPES.each do |valid_type|
@@ -26,32 +38,9 @@ class Stanza
       super
     end
 
-    def body=(body)
-      remove_child :body
-      self << XMPPNode.new('body', body) if body
-    end
-
-    def body
-      content_from :body
-    end
-
-    def subject=(subject)
-      remove_child :subject
-      self << XMPPNode.new('subject', subject) if subject
-    end
-
-    def subject
-      content_from :subject
-    end
-
-    def thread=(thread)
-      remove_child :thread
-      self << XMPPNode.new('thread', thread) if thread
-    end
-
-    def thread
-      content_from :thread
-    end
+    content_attr_accessor :body
+    content_attr_accessor :subject
+    content_attr_accessor :thread
   end
 
 end #Stanza

data/lib/blather/stanza/presence/status.rb

@@ -9,12 +9,15 @@ class Presence
 
     register :status, :status
 
-    def initialize(state = nil, message = nil)
-      super()
-      self.state = state
-      self.message = message
+    def self.new(state = nil, message = nil)
+      node = super()
+      node.state = state
+      node.message = message
+      node
     end
 
+    attribute_helpers_for(:state, VALID_STATES)
+
     ##
     # Ensures type is nil or :unavailable
     def type=(type)
@@ -29,8 +32,7 @@ class Presence
       state = nil if state == :available
       raise ArgumentError, "Invalid Status (#{state}), use: #{VALID_STATES*' '}" if state && !VALID_STATES.include?(state)
 
-      remove_child :show
-      self << XMPPNode.new('show', state) if state
+      set_content_for :show, state
     end
 
     ##
@@ -43,23 +45,13 @@ class Presence
     # Ensure priority is between -128 and 127
     def priority=(new_priority)
       raise ArgumentError, 'Priority must be between -128 and +127' if new_priority && !(-128..127).include?(new_priority.to_i)
-
-      remove_child :priority
-      self << XMPPNode.new('priority', new_priority) if new_priority
-    end
-
-    def priority
-      content_from(:priority).to_i
+      set_content_for :priority, new_priority
+      
     end
 
-    def message=(msg)
-      remove_child :status
-      self << XMPPNode.new('status', msg) if msg
-    end
+    content_attr_reader :priority, :to_i
 
-    def message
-      content_from :status
-    end
+    content_attr_accessor :message, nil, :status
 
     ##
     # Compare status based on priority
@@ -75,4 +67,4 @@ class Presence
 
 end #Presence
 end #Stanza
-end #Blather
+end #Blather

data/lib/blather/stanza/presence/subscription.rb

@@ -5,10 +5,11 @@ class Presence
   class Subscription < Presence
     register :subscription, :subscription
 
-    def initialize(to = nil, type = nil)
-      super()
-      self.to = to
-      self.type = type
+    def self.new(to = nil, type = nil)
+      node = super()
+      node.to = to
+      node.type = type
+      node
     end
 
     def inherit(node)
@@ -24,49 +25,43 @@ class Presence
     # Create an approve stanza
     def approve!
       self.type = :subscribed
-      morph_to_reply
+      reply_if_needed!
     end
 
     ##
     # Create a refuse stanza
     def refuse!
       self.type = :unsubscribed
-      morph_to_reply
+      reply_if_needed!
     end
 
     ##
     # Create an unsubscribe stanza
     def unsubscribe!
       self.type = :unsubscribe
-      morph_to_reply
+      reply_if_needed!
     end
 
     ##
     # Create a cancel stanza
     def cancel!
       self.type = :unsubscribed
-      morph_to_reply
+      reply_if_needed!
     end
 
     ##
     # Create a request stanza
     def request!
       self.type = :subscribe
-      morph_to_reply
+      reply_if_needed!
     end
 
     def request?
       self.type == :subscribe
     end
 
-  private
-    def morph_to_reply
-      self.to = self.from if self.from
-      self.from = nil
-      self
-    end
   end #Subscription
 
 end #Presence
 end #Stanza
-end
+end

data/lib/blather/stanza/presence.rb

@@ -24,13 +24,11 @@ class Stanza
 
     ##
     # Ensure element_name is "presence" for all subclasses
-    def initialize
+    def self.new
       super :presence
     end
 
-    VALID_TYPES.each do |valid_type|
-      define_method("#{valid_type}?") { self.type == valid_type }
-    end
+    attribute_helpers_for(:type, VALID_TYPES)
 
     ##
     # Ensures type is one of :unavailable, :subscribe, :subscribed, :unsubscribe, :unsubscribed, :probe or :error
@@ -42,4 +40,4 @@ class Stanza
   end
 
 end #Stanza
-end
+end

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

@@ -0,0 +1,50 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Affiliations < PubSub
+    register :pubsub_affiliations, :affiliations, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    def self.new(type = nil, host = nil)
+      new_node = super
+      new_node.affiliations
+      new_node
+    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.registered_ns)
+      self.pubsub << (aff = XMPPNode.new('affiliations', self.document)) unless aff
+      aff
+    end
+
+    def each(&block)
+      list.each &block
+    end
+
+    def size
+      list.size
+    end
+
+    def list
+      items = affiliations.find('//ns:affiliation', :ns => self.class.registered_ns)
+      items.inject({}) do |hash, item|
+        hash[item[:affiliation].to_sym] ||= []
+        hash[item[:affiliation].to_sym] << item[:node]
+        hash
+      end
+    end
+  end #Affiliations
+
+end #PubSub
+end #Stanza
+end #Blather

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

@@ -0,0 +1,43 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Create < PubSub
+    register :pubsub_create, :create, self.registered_ns
+
+    def self.new(type = :set, host = nil, node = nil)
+      new_node = super(type, host)
+      new_node.create_node
+      new_node.configure_node
+      new_node.node = node
+      new_node
+    end
+
+    def node
+      create_node[:node]
+    end
+
+    def node=(node)
+      create_node[:node] = node
+    end
+
+    def create_node
+      unless create_node = pubsub.find_first('ns:create', :ns => self.class.registered_ns)
+        self.pubsub << (create_node = XMPPNode.new('create', self.document))
+        create_node.namespace = self.pubsub.namespace
+      end
+      create_node
+    end
+
+    def configure_node
+      unless configure_node = pubsub.find_first('ns:configure', :ns => self.class.registered_ns)
+        self.pubsub << (configure_node = XMPPNode.new('configure', self.document))
+        configure_node.namespace = self.pubsub.namespace
+      end
+      configure_node
+    end
+  end #Retract
+
+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,77 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Event < Message
+    register :pubsub_event, :event, 'http://jabber.org/protocol/pubsub#event'
+
+    ##
+    # Ensure the event_node is created
+    def self.new(type = nil)
+      node = super
+      node.event_node
+      node
+    end
+
+    ##
+    # Kill the event_node node before running inherit
+    def inherit(node)
+      event_node.remove
+      super
+    end
+
+    def node
+      !purge? ? items_node[:node] : purge_node[:node]
+    end
+
+    def retractions
+      items_node.find('ns:retract', :ns => self.class.registered_ns).map { |i| i[:id] }
+    end
+
+    def retractions?
+      !retractions.empty?
+    end
+
+    def items
+      items_node.find('ns:item', :ns => self.class.registered_ns).map { |i| PubSubItem.new(nil,nil,self.document).inherit i }
+    end
+
+    def items?
+      !items.empty?
+    end
+
+    def purge?
+      purge_node
+    end
+
+    def event_node
+      node = find_first('ns:event', :ns => self.class.registered_ns)
+      node = find_first('event', self.class.registered_ns) unless node
+      unless node
+        (self << (node = XMPPNode.new('event', self.document)))
+        node.namespace = self.class.registered_ns
+      end
+      node
+    end
+
+    def items_node
+      node = find_first('event/ns:items', :ns => self.class.registered_ns)
+      unless node
+        (self.event_node << (node = XMPPNode.new('items', self.document)))
+        node.namespace = event_node.namespace
+      end
+      node
+    end
+
+    def purge_node
+      event_node.find_first('ns:purge', :ns => self.class.registered_ns)
+    end
+
+    def subscription_ids
+      find('//ns:header[@name="SubID"]', :ns => 'http://jabber.org/protocol/shim').map { |n| n.content }
+    end
+  end
+
+end #PubSub
+end #Stanza
+end #Blather

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

@@ -0,0 +1,63 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Items < PubSub
+    register :pubsub_items, :items, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    def self.request(host, path, list = [], max = nil)
+      node = self.new :get, host
+
+      node.node = path
+      node.max_items = max
+
+      (list || []).each { |id| node.items_node << PubSubItem.new(id, nil, node.document) }
+
+      node
+    end
+
+    def self.new(type = nil, host = nil)
+      new_node = super
+      new_node.items
+      new_node
+    end
+
+    def node
+      items_node[:node]
+    end
+
+    def node=(node)
+      items_node[:node] = node
+    end
+
+    def max_items
+      items_node[:max_items].to_i if items_node[:max_items]
+    end
+
+    def max_items=(max_items)
+      items_node[:max_items] = max_items
+    end
+
+    def each(&block)
+      items.each &block
+    end
+
+    def items
+      items_node.find('ns:item', :ns => self.class.registered_ns).map { |i| PubSubItem.new(nil,nil,self.document).inherit i }
+    end
+
+    def items_node
+      unless node = self.pubsub.find_first('ns:items', :ns => self.class.registered_ns)
+        (self.pubsub << (node = XMPPNode.new('items', self.document)))
+        node.namespace = self.pubsub.namespace
+      end
+      node
+    end
+  end
+
+end #PubSub
+end #Stanza
+end #Blather

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

@@ -0,0 +1,58 @@
+module Blather
+class Stanza
+class PubSub
+
+  class Publish < PubSub
+    register :pubsub_publish, :publish, self.registered_ns
+
+    include Enumerable
+    alias_method :find, :xpath
+
+    def self.new(host = nil, node = nil, type = :set, payload = nil)
+      new_node = super(type, host)
+      new_node.node = node
+      new_node.payload = payload if payload
+      new_node
+    end
+
+    def payload=(payload)
+      payload = case payload
+      when Hash   then  payload.to_a
+      when Array  then  payload.map { |v| [nil, v] }
+      else              [[nil, payload.to_s]]
+      end
+      payload.each { |id,value| self.publish << PubSubItem.new(id, value, self.document) }
+    end
+
+    def node
+      publish[:node]
+    end
+
+    def node=(node)
+      publish[:node] = node
+    end
+
+    def publish
+      unless publish = pubsub.find_first('ns:publish', :ns => self.class.registered_ns)
+        self.pubsub << (publish = XMPPNode.new('publish', self.document))
+        publish.namespace = self.pubsub.namespace
+      end
+      publish
+    end
+
+    def items
+      publish.find('ns:item', :ns => self.class.registered_ns).map { |i| PubSubItem.new(nil,nil,self.document).inherit i }
+    end
+
+    def each(&block)
+      items.each &block
+    end
+
+    def size
+      items.size
+    end
+  end #Publish
+
+end #PubSub
+end #Stanza
+end #Blather