blather 0.6.2 → 0.7.0

data/lib/blather/stanza/presence.rb

@@ -85,27 +85,25 @@ class Stanza
     # either a Status or Subscription object is created based
     # on the type attribute.
     # If neither is found it instantiates a Presence object
-    def self.import(node) # :nodoc:
-      klass = nil
-      node.children.detect do |e|
+    def self.import(node, *decorators) # :nodoc:
+      node.children.each do |e|
         ns = e.namespace ? e.namespace.href : nil
-        klass = class_from_registration(e.element_name, ns)
+        klass = class_from_registration e.element_name, ns
+        decorators << klass if klass
       end
 
-      if klass && klass != self
-        klass.import(node)
-      else
-        klass ||= case node['type']
-          when nil, 'unavailable' then Status
-          when /subscribe/        then Subscription
-          else self
-        end
-        klass.new.inherit(node)
+      case node['type']
+      when nil, 'unavailable'
+        decorators << Status
+      when /subscribe/
+        decorators << Subscription
       end
+
+      super
     end
 
     # Ensure element_name is "presence" for all subclasses
-    def self.new
+    def self.new(*args)
       super :presence
     end
 

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

@@ -22,82 +22,78 @@ class Presence
       new_node.hash = hash
       new_node.node = node
       new_node.ver = ver
-      new_node
+      parse new_node.to_xml
     end
 
-    def self.import(node)
-      self.new.inherit(node)
-    end
-
-    # @private
-    def inherit(node)
-      inherit_attrs node.attributes
-      self
-    end
+    module InstanceMethods
 
-    # Get the name of the node
-    #
-    # @return [String, nil]
-    def node
-      c[:node]
-    end
+      # @private
+      def inherit(node)
+        c.remove
+        super
+        self
+      end
 
-    # Set the name of the node
-    #
-    # @param [String, nil] node the new node name
-    def node=(node)
-      c[:node] = node
-    end
+      # Get the name of the node
+      #
+      # @return [String, nil]
+      def node
+        c[:node]
+      end
 
-    # Get the name of the hash
-    #
-    # @return [Symbol, nil]
-    def hash
-      c[:hash].to_sym
-    end
+      # Set the name of the node
+      #
+      # @param [String, nil] node the new node name
+      def node=(node)
+        c[:node] = node
+      end
 
-    # Set the name of the hash
-    #
-    # @param [String, nil] hash the new hash name
-    def hash=(hash)
-      if hash && !VALID_HASH_TYPES.include?(hash.to_s)
-        raise ArgumentError, "Invalid Hash Type (#{hash}), use: #{VALID_HASH_TYPES*' '}"
+      # Get the name of the hash
+      #
+      # @return [Symbol, nil]
+      def hash
+        c[:hash] && c[:hash].to_sym
       end
-      c[:hash] = hash
-    end
 
-    # Get the ver
-    #
-    # @return [String, nil]
-    def ver
-      c[:ver]
-    end
+      # Set the name of the hash
+      #
+      # @param [String, nil] hash the new hash name
+      def hash=(hash)
+        if hash && !VALID_HASH_TYPES.include?(hash.to_s)
+          raise ArgumentError, "Invalid Hash Type (#{hash}), use: #{VALID_HASH_TYPES*' '}"
+        end
+        c[:hash] = hash
+      end
 
-    # Set the ver
-    #
-    # @param [String, nil] ver the new ver
-    def ver=(ver)
-      c[:ver] = ver
-    end
+      # Get the ver
+      #
+      # @return [String, nil]
+      def ver
+        c[:ver]
+      end
 
-    # C node accessor
-    # If a c node exists it will be returned.
-    # Otherwise a new node will be created and returned
-    #
-    # @return [Blather::XMPPNode]
-    def c
-      c = if self.class.registered_ns
-        find_first('ns:c', :ns => self.class.registered_ns)
-      else
-        find_first('c')
+      # Set the ver
+      #
+      # @param [String, nil] ver the new ver
+      def ver=(ver)
+        c[:ver] = ver
       end
 
-      unless c
-        (self << (c = XMPPNode.new('c', self.document)))
-        c.namespace = self.class.registered_ns
+      # C node accessor
+      # If a c node exists it will be returned.
+      # Otherwise a new node will be created and returned
+      #
+      # @return [Blather::XMPPNode]
+      def c
+        unless c = find_first('ns:c', :ns => C.registered_ns)
+          self << (c = XMPPNode.new('c', self.document))
+          c.namespace = self.class.registered_ns
+        end
+        c
       end
-      c
     end
+
+    include InstanceMethods
   end # C
 end #Presence
 end #Stanza

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

@@ -11,19 +11,23 @@ class Presence
       new_node
     end
 
-    def inherit(node)
-      muc.remove
-      super
-      self
-    end
+    module InstanceMethods
+      def inherit(node)
+        muc.remove
+        super
+        self
+      end
 
-    def muc
-      unless muc = find_first('ns:x', :ns => self.class.registered_ns)
-        self << (muc = XMPPNode.new('x', self.document))
-        muc.namespace = self.class.registered_ns
+      def muc
+        unless muc = find_first('ns:x', :ns => MUC.registered_ns)
+          self << (muc = XMPPNode.new('x', self.document))
+          muc.namespace = self.class.registered_ns
+        end
+        muc
       end
-      muc
     end
+
+    include InstanceMethods
   end # MUC
 
 end # Presence

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

@@ -4,59 +4,70 @@ module Blather
 class Stanza
 class Presence
 
-  class MUCUser < Status
+  class MUCUser < Presence
     include Blather::Stanza::MUC::MUCUserBase
 
-    def affiliation
-      item.affiliation
+    def self.decorator_modules
+      super + [Blather::Stanza::MUC::MUCUserBase]
     end
 
-    def affiliation=(val)
-      item.affiliation = val
-    end
+    register :muc_user_presence, :x, MUC_USER_NAMESPACE
 
-    def role
-      item.role
-    end
+    module InstanceMethods
 
-    def role=(val)
-      item.role = val
-    end
+      def affiliation
+        item.affiliation
+      end
 
-    def jid
-      item.jid
-    end
+      def affiliation=(val)
+        item.affiliation = val
+      end
 
-    def jid=(val)
-      item.jid = val
-    end
+      def role
+        item.role
+      end
 
-    def status_codes
-      status.map &:code
-    end
+      def role=(val)
+        item.role = val
+      end
 
-    def status_codes=(val)
-      muc_user.remove_children :status
-      val.each do |code|
-        muc_user << Status.new(code)
+      def jid
+        item.jid
       end
-    end
 
-    def item
-      if item = muc_user.find_first('ns:item', :ns => self.class.registered_ns)
-        Item.new item
-      else
-        muc_user << (item = Item.new nil, nil, nil, self.document)
-        item
+      def jid=(val)
+        item.jid = val
+      end
+
+      def status_codes
+        status.map &:code
+      end
+
+      def status_codes=(val)
+        muc_user.remove_children :status
+        val.each do |code|
+          muc_user << Status.new(code)
+        end
       end
-    end
 
-    def status
-      muc_user.find('ns:status', :ns => self.class.registered_ns).map do |status|
-        Status.new status
+      def item
+        if item = muc_user.find_first('ns:item', :ns => MUCUser.registered_ns)
+          Item.new item
+        else
+          muc_user << (item = Item.new nil, nil, nil, self.document)
+          item
+        end
+      end
+
+      def status
+        muc_user.find('ns:status', :ns => MUCUser.registered_ns).map do |status|
+          Status.new status
+        end
       end
     end
 
+    include InstanceMethods
+
     class Item < XMPPNode
       def self.new(affiliation = nil, role = nil, jid = nil, document = nil)
         new_node = super :item, document

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

@@ -93,127 +93,132 @@ class Presence
       node
     end
 
-    # Check if the state is available
-    #
-    # @return [true, false]
-    def available?
-      self.state == :available
-    end
-
-    # Check if the state is away
-    #
-    # @return [true, false]
-    def away?
-      self.state == :away
-    end
+    module InstanceMethods
 
-    # Check if the state is chat
-    #
-    # @return [true, false]
-    def chat?
-      self.state == :chat
-    end
+      # Check if the state is available
+      #
+      # @return [true, false]
+      def available?
+        self.state == :available
+      end
 
-    # Check if the state is dnd
-    #
-    # @return [true, false]
-    def dnd?
-      self.state == :dnd
-    end
+      # Check if the state is away
+      #
+      # @return [true, false]
+      def away?
+        self.state == :away
+      end
 
-    # Check if the state is xa
-    #
-    # @return [true, false]
-    def xa?
-      self.state == :xa
-    end
+      # Check if the state is chat
+      #
+      # @return [true, false]
+      def chat?
+        self.state == :chat
+      end
 
-    # Set the type attribute
-    # Ensures type is nil or :unavailable
-    #
-    # @param [<:unavailable, nil>] type the type
-    def type=(type)
-      if type && type.to_sym != :unavailable
-        raise ArgumentError, "Invalid type (#{type}). Must be nil or unavailable"
+      # Check if the state is dnd
+      #
+      # @return [true, false]
+      def dnd?
+        self.state == :dnd
       end
-      super
-    end
 
-    # Set the state
-    # Ensure state is one of :available, :away, :chat, :dnd, :xa or nil
-    #
-    # @param [<:available, :away, :chat, :dnd, :xa, nil>] state
-    def state=(state) # :nodoc:
-      state = state.to_sym if state
-      state = nil if state == :available
-      if state && !VALID_STATES.include?(state)
-        raise ArgumentError, "Invalid Status (#{state}), use: #{VALID_STATES*' '}"
+      # Check if the state is xa
+      #
+      # @return [true, false]
+      def xa?
+        self.state == :xa
       end
 
-      set_content_for :show, state
-    end
+      # Set the type attribute
+      # Ensures type is nil or :unavailable
+      #
+      # @param [<:unavailable, nil>] type the type
+      def type=(type)
+        if type && type.to_sym != :unavailable
+          raise ArgumentError, "Invalid type (#{type}). Must be nil or unavailable"
+        end
+        super
+      end
 
-    # Get the state of the status
-    #
-    # @return [<:available, :away, :chat, :dnd, :xa>]
-    def state
-      state = type || content_from(:show)
-      state = :available if state.blank?
-      state.to_sym
-    end
+      # Set the state
+      # Ensure state is one of :available, :away, :chat, :dnd, :xa or nil
+      #
+      # @param [<:available, :away, :chat, :dnd, :xa, nil>] state
+      def state=(state) # :nodoc:
+        state = state.to_sym if state
+        state = nil if state == :available
+        if state && !VALID_STATES.include?(state)
+          raise ArgumentError, "Invalid Status (#{state}), use: #{VALID_STATES*' '}"
+        end
+
+        set_content_for :show, state
+      end
 
-    # Set the priority of the status
-    # Ensures priority is between -128 and 127
-    #
-    # @param [Fixnum<-128...127>] new_priority
-    def priority=(new_priority) # :nodoc:
-      if new_priority && !(-128..127).include?(new_priority.to_i)
-        raise ArgumentError, 'Priority must be between -128 and +127'
+      # Get the state of the status
+      #
+      # @return [<:available, :away, :chat, :dnd, :xa>]
+      def state
+        state = type || content_from(:show)
+        state = :available if state.blank?
+        state.to_sym
       end
-      set_content_for :priority, new_priority
-    end
 
-    # Get the priority of the status
-    #
-    # @return [Fixnum<-128...127>]
-    def priority
-      read_content(:priority).to_i
-    end
+      # Set the priority of the status
+      # Ensures priority is between -128 and 127
+      #
+      # @param [Fixnum<-128...127>] new_priority
+      def priority=(new_priority) # :nodoc:
+        if new_priority && !(-128..127).include?(new_priority.to_i)
+          raise ArgumentError, 'Priority must be between -128 and +127'
+        end
+        set_content_for :priority, new_priority
+      end
 
-    # Get the status message
-    #
-    # @return [String, nil]
-    def message
-      read_content :status
-    end
+      # Get the priority of the status
+      #
+      # @return [Fixnum<-128...127>]
+      def priority
+        read_content(:priority).to_i
+      end
 
-    # Set the status message
-    #
-    # @param [String, nil] message
-    def message=(message)
-      set_content_for :status, message
-    end
+      # Get the status message
+      #
+      # @return [String, nil]
+      def message
+        read_content :status
+      end
 
-    # Compare status based on priority and state:
-    # unavailable status is always less valuable than others
-    # Raises an error if the JIDs aren't the same
-    #
-    # @param [Blather::Stanza::Presence::Status] o
-    # @return [true,false]
-    def <=>(o)
-      unless self.from && o.from && self.from.stripped == o.from.stripped
-        raise ArgumentError, "Cannot compare status from different JIDs: #{[self.from, o.from].inspect}"
+      # Set the status message
+      #
+      # @param [String, nil] message
+      def message=(message)
+        set_content_for :status, message
       end
 
-      if (self.type.nil? && o.type.nil?) || (!self.type.nil? && !o.type.nil?)
-        self.priority <=> o.priority
-      elsif self.type.nil? && !o.type.nil?
-        1
-      elsif !self.type.nil? && o.type.nil?
-        -1
+      # Compare status based on priority and state:
+      # unavailable status is always less valuable than others
+      # Raises an error if the JIDs aren't the same
+      #
+      # @param [Blather::Stanza::Presence::Status] o
+      # @return [true,false]
+      def <=>(o)
+        unless self.from && o.from && self.from.stripped == o.from.stripped
+          raise ArgumentError, "Cannot compare status from different JIDs: #{[self.from, o.from].inspect}"
+        end
+
+        if (self.type.nil? && o.type.nil?) || (!self.type.nil? && !o.type.nil?)
+          self.priority <=> o.priority
+        elsif self.type.nil? && !o.type.nil?
+          1
+        elsif !self.type.nil? && o.type.nil?
+          -1
+        end
       end
     end
 
+    include InstanceMethods
+
   end #Status
 
 end #Presence