shingara-blather 0.4.9 → 0.4.14

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

@@ -0,0 +1,147 @@
+module Blather
+class Stanza
+class Iq
+
+  # # Vcard Stanza
+  #
+  # [XEP-0054 vcard-temp](http://xmpp.org/extensions/xep-0054.html)
+  #
+  # This is a base class for any vcard based Iq stanzas. It provides a base set
+  # of methods for working with vcard stanzas
+  #
+  # @example Retrieving One's vCard
+  #     iq = Blather::Stanza::Iq::Vcard.new :get
+  #     client.write_with_handler iq do |response|
+  #       puts response.vcard
+  #     end
+  #
+  # @example Updating One's vCard
+  #     iq = Blather::Stanza::Iq::Vcard.new :set
+  #     iq.vcard['NICKNAME'] = 'Romeo'
+  #     client.write_with_handler iq do |response|
+  #       puts response
+  #     end
+  #
+  # @example Viewing Another User's vCard
+  #     iq = Blather::Stanza::Iq::Vcard.new :get, 'mercutio@example.org'
+  #     client.write_with_handler iq do |response|
+  #       puts response.vcard
+  #     end
+  #
+  # @handler :vcard
+  class Vcard < Iq
+
+    register :vcard, :vCard, 'vcard-temp'
+
+    # Overrides the parent method to ensure a vcard node is created
+    #
+    # @see Blather::Stanza::Iq.new
+    def self.new(type = nil, to = nil, id = nil)
+      node = super
+      node.vcard
+      node
+    end
+
+    # Overrides the parent method to ensure the current vcard node is destroyed
+    #
+    # @see Blather::Stanza::Iq#inherit
+    def inherit(node)
+      vcard.remove
+      super
+      self
+    end
+
+    # Find or create vcard node
+    #
+    # @return [Vcard::Vcard]
+    def vcard
+      Vcard.find_or_create self
+    end
+
+    # Replaces vcard node
+    #
+    # @param [Vcard::Vcard, XML::Node] info the stanza's new vcard node
+    #
+    # @return [Vcard::Vcard]
+    def vcard=(info)
+      vcard.remove
+      self << info
+      Vcard.find_or_create self
+    end
+
+    class Vcard < XMPPNode
+
+      VCARD_NS = 'vcard-temp'
+
+      # Create a new Vcard::Vcard object
+      #
+      # @param [XML::Node, nil] node a node to inherit from
+      #
+      # @return [Vcard::Vcard]
+      def self.new(node = nil)
+        new_node = super :vCard
+        new_node.namespace = VCARD_NS
+        new_node.inherit node if node
+        new_node
+      end
+
+      # Find or create vCard node in Vcard Iq and converts it to Vcard::Vcard
+      #
+      # @param [Vcard] parent a Vcard Iq where to find or create vCard
+      #
+      # @return [Vcard::Vcard]
+      def self.find_or_create(parent)
+        if found_vcard = parent.find_first('//ns:vCard', :ns => VCARD_NS)
+          vcard = self.new found_vcard
+          found_vcard.remove
+        else
+          vcard = self.new
+        end
+        parent << vcard
+
+        vcard
+      end
+
+      # Find the element's value by name
+      #
+      # @param [String] name the name of the element
+      #
+      # @return [String, nil]
+      def [](name)
+        name = name.split("/").map{|child| "ns:#{child}"}.join("/")
+
+        if elem = find_first(name, :ns => VCARD_NS)
+          elem.content
+        else
+          nil
+        end
+      end
+
+      # Set the element's value
+      #
+      # @param [String] name the name of the element
+      # @param [String, nil] value the new value of element
+      #
+      # @return [String, nil]
+      def []=(name, value)
+        elem = nil
+        parent = self
+
+        name.split("/").each do |child|
+          elem = parent.find_first("ns:#{child}", :ns => VCARD_NS)
+          unless elem
+            elem = XMPPNode.new(child, parent.document)
+            parent << elem
+            parent = elem
+          else
+            parent = elem
+          end
+        end
+
+        elem.content = value
+      end
+    end
+  end
+end
+end
+end

data/lib/blather/stanza/message.rb

@@ -159,6 +159,9 @@ class Stanza
   class Message < Stanza
     VALID_TYPES = [:chat, :error, :groupchat, :headline, :normal].freeze
 
+    VALID_CHAT_STATES = [:active, :composing, :gone, :inactive, :paused].freeze
+    CHAT_STATE_NS = 'http://jabber.org/protocol/chatstates'.freeze
+
     HTML_NS = 'http://jabber.org/protocol/xhtml-im'.freeze
     HTML_BODY_NS = 'http://www.w3.org/1999/xhtml'.freeze
 
@@ -172,7 +175,7 @@ class Stanza
         klass = class_from_registration(e.element_name, ns)
       end
 
-      if klass && klass != self
+      if klass && klass != self && klass != Blather::Stanza::X
         klass.import(node)
       else
         new(node[:type]).inherit(node)
@@ -189,9 +192,18 @@ class Stanza
       node.to = to
       node.type = type
       node.body = body
+      node.chat_state = :active if [:chat, :groupchat].include?(type)
       node
     end
 
+    # Overrides the parent method to ensure the current chat state is removed
+    #
+    # @see Blather::Stanza::Iq#inherit
+    def inherit(node)
+      xpath('ns:*', :ns => CHAT_STATE_NS).remove
+      super
+    end
+
     # Check if the Message is of type :chat
     #
     # @return [true, false]
@@ -262,8 +274,9 @@ class Stanza
       end
 
       unless b = h.find_first('ns:body', :ns => HTML_BODY_NS)
-        h << (b = XMPPNode.new('body', self.document))
+        b = XMPPNode.new('body', self.document)
         b.namespace = HTML_BODY_NS
+        h << b
       end
 
       b
@@ -273,7 +286,7 @@ class Stanza
     #
     # @return [String]
     def xhtml
-      self.xhtml_node.content.strip
+      self.xhtml_node.inner_html.strip
     end
 
     # Set the message xhtml
@@ -281,7 +294,7 @@ class Stanza
     #
     # @param [#to_s] valid xhtml
     def xhtml=(xhtml_body)
-      self.xhtml_node.content = Nokogiri::XML(xhtml_body).to_xhtml
+      self.xhtml_node.inner_html = Nokogiri::XML::DocumentFragment.parse(xhtml_body)
     end
 
     # Get the message subject
@@ -326,7 +339,38 @@ class Stanza
       set_content_for :thread, thread
       find_first('thread')[:parent] = parent
     end
+
+    # Returns the message's x:data form child
+    def form
+      X.find_or_create self
+    end
+
+    # Get the message chat state
+    #
+    # @return [Symbol]
+    def chat_state
+      if (elem = find_first('ns:*', :ns => CHAT_STATE_NS)) && VALID_CHAT_STATES.include?(name = elem.name.to_sym)
+        name
+      end
+    end
+
+    # Set the message chat state
+    #
+    # @param [#to_s] chat_state the message chat state. Must be one of VALID_CHAT_STATES
+    def chat_state=(chat_state)
+      if chat_state && !VALID_CHAT_STATES.include?(chat_state.to_sym)
+        raise ArgumentError, "Invalid Chat State (#{chat_state}), use: #{VALID_CHAT_STATES*' '}"
+      end
+
+      xpath('ns:*', :ns => CHAT_STATE_NS).remove
+
+      if chat_state
+        state = XMPPNode.new(chat_state, self.document)
+        state.namespace = CHAT_STATE_NS
+        self << state
+      end
+    end
   end
 
 end
-end
+end

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

@@ -193,8 +193,9 @@ class Presence
       set_content_for :status, message
     end
 
-    # Compare status based on priority
-    # raises an error if the JIDs aren't the same
+    # 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]
@@ -202,7 +203,14 @@ class Presence
       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
-      self.priority <=> o.priority
+
+      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 #Status

data/lib/blather/stanza/pubsub.rb

@@ -65,8 +65,6 @@ class Stanza
   # This fragment is found in many places throughout the pubsub spec
   # This is a convenience class to attach methods to the node
   class PubSubItem < XMPPNode
-    ATOM_NS = 'http://www.w3.org/2005/Atom'.freeze
-
     # Create a new PubSubItem
     #
     # @param [String, nil] id the id of the stanza
@@ -96,32 +94,22 @@ class Stanza
 
     # Get the item's payload
     #
-    # To get the XML representation use #entry
-    #
-    # @return [String, nil]
+    # @return [String, XMPPNode, nil]
     def payload
-      self.entry.content.empty? ? nil : content
+      children.empty? ? nil : children.to_s
     end
 
     # Set the item's payload
     #
-    # @param [String, nil] payload the payload
+    # @param [String, XMPPNode, nil] payload the payload
     def payload=(payload)
-      self.entry.content = payload
-    end
-
-    # Get or create the entry node
-    #
-    # @return [Blather::XMPPNode]
-    def entry
-      e = find_first('ns:entry', :ns => ATOM_NS) ||
-          find_first('entry', :ns => ATOM_NS)
-
-      unless e
-        self << (e = XMPPNode.new('entry', self.document))
-        e.namespace = ATOM_NS
+      children.map &:remove
+      return unless payload
+      if payload.is_a?(String)
+        self.content = payload
+      else
+        self << payload
       end
-      e
     end
   end  # PubSubItem
 

data/lib/blather/stanza/x.rb

@@ -0,0 +1,398 @@
+module Blather
+class Stanza
+  # # X Stanza
+  #
+  # [XEP-0004 Data Forms](http://xmpp.org/extensions/xep-0004.html)
+  #
+  # Data Form node that allows for semi-structured data exchange
+  #
+  # @handler :x
+  class X < XMPPNode
+    register :x, 'jabber:x:data'
+
+    VALID_TYPES = [:cancel, :form, :result, :submit].freeze
+
+    # Create a new X node
+    # @param [:cancel, :form, :result, :submit, nil] type the x:form type
+    # @param [Array<Array, X::Field>, nil] fields a list of fields.
+    # These are passed directly to X::Field.new
+    # @return [X] a new X stanza
+    def self.new(type = nil, fields = [])
+      new_node = super :x
+
+      case type
+      when Nokogiri::XML::Node
+        new_node.inherit type
+      when Hash
+        new_node.type = type[:type]
+        new_node.fields = type[:fields]
+      else
+        new_node.type = type
+        new_node.fields = fields
+      end
+      new_node
+    end
+
+    def self.find_or_create(parent)
+      if found_x = parent.find_first('//ns:x', :ns => self.registered_ns)
+        x = self.new found_x
+        found_x.remove
+      else
+        x = self.new
+      end
+      parent << x
+      x
+    end
+
+    # The Form's type
+    # @return [Symbol]
+    def type
+      read_attr :type, :to_sym
+    end
+
+    # Set the Form's type
+    # @param [:cancel, :form, :result, :submit] type the new type for the form
+    def type=(type)
+      if type && !VALID_TYPES.include?(type.to_sym)
+        raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}"
+      end
+      write_attr :type, type
+    end
+
+    # List of field objects
+    # @return [Blather::Stanza::X::Field]
+    def fields
+      self.find('ns:field', :ns => self.class.registered_ns).map do |field|
+        Field.new(field)
+      end
+    end
+
+    # Find a field by var
+    # @param var the var for the field you wish to find
+    def field(var)
+      fields.detect { |f| f.var == var }
+    end
+
+    # Add an array of fields to form
+    # @param fields the array of fields, passed directly to Field.new
+    def fields=(fields)
+      remove_children :field
+      [fields].flatten.each do |field|
+        self << (f = Field.new(field))
+        f.namespace = self.namespace
+      end
+    end
+
+    # Check if the x is of type :cancel
+    #
+    # @return [true, false]
+    def cancel?
+      self.type == :cancel
+    end
+
+    # Check if the x is of type :form
+    #
+    # @return [true, false]
+    def form?
+      self.type == :form
+    end
+
+    # Check if the x is of type :result
+    #
+    # @return [true, false]
+    def result?
+      self.type == :result
+    end
+
+    # Check if the x is of type :submit
+    #
+    # @return [true, false]
+    def submit?
+      self.type == :submit
+    end
+
+    # Retrieve the form's instructions
+    #
+    # @return [String]
+    def instructions
+      content_from 'ns:instructions', :ns => self.registered_ns
+    end
+
+    # Set the form's instructions
+    #
+    # @param [String] instructions the form's instructions
+    def instructions=(instructions)
+      self.remove_children :instructions
+      if instructions
+        self << (i = XMPPNode.new(:instructions, self.document))
+        i.namespace = self.namespace
+        i << instructions
+      end
+    end
+
+    # Retrieve the form's title
+    #
+    # @return [String]
+    def title
+      content_from 'ns:title', :ns => self.registered_ns
+    end
+
+    # Set the form's title
+    #
+    # @param [String] title the form's title
+    def title=(title)
+      self.remove_children :title
+      if title
+        self << (t = XMPPNode.new(:title))
+        t.namespace = self.namespace
+        t << title
+      end
+    end
+
+    class Field < XMPPNode
+      VALID_TYPES = [:boolean, :fixed, :hidden, :"jid-multi", :"jid-single", :"list-multi", :"list-single", :"text-multi", :"text-private", :"text-single"].freeze
+
+      # Create a new X Field
+      # @overload new(node)
+      #   Imports the XML::Node to create a Field object
+      #   @param [XML::Node] node the node object to import
+      # @overload new(opts = {})
+      #   Creates a new Field using a hash of options
+      #   @param [Hash] opts a hash of options
+      #   @option opts [String] :var the variable for the field
+      #   @option opts [:boolean, :fixed, :hidden, :"jid-multi", :"jid-single", :"list-multi", :"list-single", :"text-multi", :"text-private", :"text-single"] :type the type of the field
+      #   @option opts [String] :label the label for the field
+      #   @option [String, nil] :value the value for the field
+      #   @option [String, nil] :description the description for the field
+      #   @option [true, false, nil] :required the required flag for the field
+      #   @param [Array<Array, X::Field::Option>, nil] :options a list of field options.
+      #   These are passed directly to X::Field::Option.new
+      # @overload new(type, var = nil, label = nil)
+      #   Create a new Field by name
+      #   @param [String, nil] var the variable for the field
+      #   @param [:boolean, :fixed, :hidden, :"jid-multi", :"jid-single", :"list-multi", :"list-single", :"text-multi", :"text-private", :"text-single"] type the type of the field
+      #   @param [String, nil] label the label for the field
+      #   @param [String, nil] value the value for the field
+      #   @param [String, nil] description the description for the field
+      #   @param [true, false, nil] required the required flag for the field
+      #   @param [Array<Array, X::Field::Option>, nil] options a list of field options.
+      #   These are passed directly to X::Field::Option.new
+      def self.new(var, type = nil, label = nil, value = nil, description = nil, required = false, options = [])
+        new_node = super :field
+
+        case var
+        when Nokogiri::XML::Node
+          new_node.inherit var
+        when Hash
+          new_node.var = var[:var]
+          new_node.type = var[:type]
+          new_node.label = var[:label]
+          new_node.value = var[:value]
+          new_node.desc = var[:description]
+          new_node.required = var[:required]
+          new_node.options = var[:options]
+        else
+          new_node.var = var
+          new_node.type = type
+          new_node.label = label
+          new_node.value = value
+          new_node.desc = description
+          new_node.required = required
+          new_node.options = options
+        end
+        new_node
+      end
+
+      # The Field's type
+      # @return [String]
+      def type
+        read_attr :type
+      end
+
+      # Set the Field's type
+      # @param [#to_sym] type the new type for the field
+      def type=(type)
+        if type && !VALID_TYPES.include?(type.to_sym)
+          raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}"
+        end
+        write_attr :type, type
+      end
+
+      # The Field's var
+      # @return [String]
+      def var
+        read_attr :var
+      end
+
+      # Set the Field's var
+      # @param [String] var the new var for the field
+      def var=(var)
+        write_attr :var, var
+      end
+
+      # The Field's label
+      # @return [String]
+      def label
+        read_attr :label
+      end
+
+      # Set the Field's label
+      # @param [String] label the new label for the field
+      def label=(label)
+        write_attr :label, label
+      end
+
+      # Get the field's value
+      #
+      # @param [String]
+      def value
+        if self.namespace
+          content_from 'ns:value', :ns => self.namespace.href
+        else
+          content_from :value
+        end
+      end
+
+      # Set the field's value
+      #
+      # @param [String] value the field's value
+      def value=(value)
+        self.remove_children :value
+        if value
+          self << (v = XMPPNode.new(:value))
+          v.namespace = self.namespace
+          v << value
+        end
+      end
+
+      # Get the field's description
+      #
+      # @param [String]
+      def desc
+        if self.namespace
+          content_from 'ns:desc', :ns => self.namespace.href
+        else
+          content_from :desc
+        end
+      end
+
+      # Set the field's description
+      #
+      # @param [String] description the field's description
+      def desc=(description)
+        self.remove_children :desc
+        if description
+          self << (d = XMPPNode.new(:desc))
+          d.namespace = self.namespace
+          d << description
+        end
+      end
+
+      # Get the field's required flag
+      #
+      # @param [true, false]
+      def required?
+        !self.find_first('required').nil?
+      end
+
+      # Set the field's required flag
+      #
+      # @param [true, false] required the field's required flag
+      def required=(required)
+        self.remove_children(:required) unless required
+        self << XMPPNode.new(:required) if required
+      end
+
+      # Extract list of option objects
+      #
+      # @return [Blather::Stanza::X::Field::Option]
+      def options
+        self.find(:option).map { |f| Option.new(f) }
+      end
+
+      # Add an array of options to field
+      # @param options the array of options, passed directly to Option.new
+      def options=(options)
+        remove_children :option
+        if options
+          [options].flatten.each { |o| self << Option.new(o) }
+        end
+      end
+
+      # Compare two Field objects by type, var and label
+      # @param [X::Field] o the Field object to compare against
+      # @return [true, false]
+      def eql?(o)
+        raise "Cannot compare #{self.class} with #{o.class}" unless o.is_a?(self.class)
+        ![:type, :var, :label, :desc, :required?, :value].detect { |m| o.send(m) != self.send(m) }
+      end
+      alias_method :==, :eql?
+
+      class Option < XMPPNode
+        # Create a new X Field Option
+        # @overload new(node)
+        #   Imports the XML::Node to create a Field option object
+        #   @param [XML::Node] node the node object to import
+        # @overload new(opts = {})
+        #   Creates a new Field option using a hash of options
+        #   @param [Hash] opts a hash of options
+        #   @option opts [String] :value the value of the field option
+        #   @option opts [String] :label the human readable label for the field option
+        # @overload new(value, label = nil)
+        #   Create a new Field option by name
+        #   @param [String] value the value of the field option
+        #   @param [String, nil] label the human readable label for the field option
+        def self.new(value, label = nil)
+          new_node = super :option
+
+          case value
+          when Nokogiri::XML::Node
+            new_node.inherit value
+          when Hash
+            new_node.value = value[:value]
+            new_node.label = value[:label]
+          else
+            new_node.value = value
+            new_node.label = label
+          end
+          new_node
+        end
+
+        # The Field Option's value
+        # @return [String]
+        def value
+          if self.namespace
+            content_from 'ns:value', :ns => self.namespace.href
+          else
+            content_from :value
+          end
+        end
+
+        # Set the Field Option's value
+        # @param [String] value the new value for the field option
+        def value=(value)
+          self.remove_children :value
+          if value
+            self << (v = XMPPNode.new(:value))
+            v.namespace = self.namespace
+            v << value
+          end
+        end
+
+        # The Field Option's label
+        # @return [String]
+        def label
+          read_attr :label
+        end
+
+        # Set the Field Option's label
+        # @param [String] label the new label for the field option
+        def label=(label)
+          write_attr :label, label
+        end
+      end # Option
+    end # Field
+  end # X
+
+end #Stanza
+end