blather 0.3.4 → 0.4.0

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

@@ -0,0 +1,63 @@
+module Blather
+class Stanza
+
+  class PubSub < Iq
+    register :pubsub_node, :pubsub, 'http://jabber.org/protocol/pubsub'
+
+    def self.import(node)
+      klass = nil
+      if pubsub = node.document.find_first('//ns:pubsub', :ns => self.registered_ns)
+        pubsub.children.each { |e| break if klass = class_from_registration(e.element_name, (e.namespace.href if e.namespace)) }
+      end
+      (klass || self).new(node[:type]).inherit(node)
+    end
+
+    ##
+    # Ensure the namespace is set to the query node
+    def self.new(type = nil, host = nil)
+      new_node = super type
+      new_node.to = host
+      new_node.pubsub
+      new_node
+    end
+
+    ##
+    # Kill the pubsub node before running inherit
+    def inherit(node)
+      remove_children :pubsub
+      super
+    end
+
+    def pubsub
+      p = find_first('ns:pubsub', :ns => self.class.registered_ns) ||
+          find_first('pubsub', :ns => self.class.registered_ns)
+
+      unless p
+        self << (p = XMPPNode.new('pubsub', self.document))
+        p.namespace = self.class.registered_ns
+      end
+      p
+    end
+  end
+
+  class PubSubItem < XMPPNode
+    def self.new(id = nil, payload = nil, document = nil)
+      new_node = super 'item', document
+      new_node.id = id
+      new_node.payload = payload if payload
+      new_node
+    end
+
+    attribute_accessor :id
+
+    def payload=(payload = nil)
+      self.content = payload
+    end
+
+    def payload
+      content.empty? ? nil : content
+    end
+  end
+
+end #Stanza
+end #Blather

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