tp-blather 0.8.2

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

@@ -0,0 +1,161 @@
+module Blather
+class Stanza
+
+  # # Capabilities Stanza
+  #
+  # [XEP-0115 Entity Capabilities](http://xmpp.org/extensions/xep-0115.html)
+  #
+  # XMPP protocol extension for broadcasting and dynamically discovering client, device, or generic entity capabilities.
+  #
+  class Capabilities < Blather::Stanza::DiscoInfo
+    def self.new
+      super :result
+    end
+
+    # A string that is used to verify the identity and supported features of the entity.
+    #
+    # @return [String]
+    def ver
+      generate_ver identities, features
+    end
+
+    # A URI that uniquely identifies a software application, typically a URL at the
+    # website of the project or company that produces the software.
+    #
+    # @param [String] node the node URI
+    def node=(node)
+      @bare_node = node
+      super "#{node}##{ver}"
+    end
+
+    # Add an array of identities
+    # @param identities the array of identities, passed directly to Identity.new
+    def identities=(identities)
+      super identities
+      regenerate_full_node
+    end
+
+    # Add an array of features
+    # @param features the array of features, passed directly to Feature.new
+    def features=(features)
+      super features
+      regenerate_full_node
+    end
+
+    # The generated Presence::C node
+    #
+    # @return [Blather::Stanza::Presence::C]
+    def c
+      Blather::Stanza::Presence::C.new @bare_node, ver
+    end
+
+    private
+
+    def regenerate_full_node
+      self.node = @bare_node
+    end
+
+    def generate_ver_str(identities, features, forms = [])
+      # 1.  Initialize an empty string S.
+      s = ''
+
+      # 2. Sort the service discovery identities by category and
+      # then by type (if it exists) and then by xml:lang (if it
+      # exists), formatted as CATEGORY '/' [TYPE] '/' [LANG] '/'
+      # [NAME]. Note that each slash is included even if the TYPE,
+      # LANG, or NAME is not included.
+      identities.sort! do |identity1, identity2|
+        cmp_result = nil
+        [:category, :type, :xml_lang, :name].each do |field|
+          value1 = identity1.send(field)
+          value2 = identity2.send(field)
+
+          if value1 != value2
+            cmp_result = value1 <=> value2
+            break
+          end
+        end
+        cmp_result
+      end
+
+      # 3. For each identity, append the 'category/type/lang/name' to
+      # S, followed by the '<' character.
+      s += identities.collect do |identity|
+        [:category, :type, :xml_lang, :name].collect do |field|
+          identity.send(field).to_s
+        end.join('/') + '<'
+      end.join
+
+      # 4. Sort the supported service discovery features.
+      features.sort! { |feature1, feature2| feature1.var <=> feature2.var }
+
+      # 5. For each feature, append the feature to S, followed by the
+      # '<' character.
+      s += features.collect { |feature| feature.var.to_s + '<' }.join
+
+      # 6. If the service discovery information response includes
+      # XEP-0128 data forms, sort the forms by the FORM_TYPE (i.e., by
+      # the XML character data of the <value/> element).
+      forms.sort! do |form1, form2|
+        fform_type1 = form1.field 'FORM_TYPE'
+        fform_type2 = form2.field 'FORM_TYPE'
+        form_type1 = fform_type1 ? fform_type1.values.to_s : nil
+        form_type2 = fform_type2 ? fform_type2.values.to_s : nil
+        form_type1 <=> form_type2
+      end
+
+      # 7. For each extended service discovery information form:
+      forms.each do |form|
+        # 7.1. Append the XML character data of the FORM_TYPE field's
+        # <value/> element, followed by the '<' character.
+        fform_type = form.field 'FORM_TYPE'
+        form_type = fform_type ? fform_type.values.to_s : nil
+        s += "#{form_type}<"
+
+        # 7.2. Sort the fields by the value of the "var" attribute
+        fields = form.fields.sort { |field1, field2| field1.var <=> field2.var }
+
+        # 7.3. For each field:
+        fields.each do |field|
+          # 7.3.1. Append the value of the "var" attribute, followed by
+          # the '<' character.
+          s += "#{field.var}<"
+
+          # 7.3.2. Sort values by the XML character data of the <value/> element
+          # values = field.values.sort { |value1, value2| value1 <=> value2 }
+
+          # 7.3.3. For each <value/> element, append the XML character
+          # data, followed by the '<' character.
+          # s += values.collect { |value| "#{value}<" }.join
+          s += "#{field.value}<"
+        end
+      end
+      s
+    end
+
+    def generate_ver(identities, features, forms = [], hash = 'sha-1')
+      s = generate_ver_str identities, features, forms
+
+      # 9. Compute the verification string by hashing S using the
+      # algorithm specified in the 'hash' attribute (e.g., SHA-1 as
+      # defined in RFC 3174). The hashed data MUST be generated
+      # with binary output and encoded using Base64 as specified in
+      # Section 4 of RFC 4648 (note: the Base64 output MUST NOT
+      # include whitespace and MUST set padding bits to zero).
+
+      # See http://www.iana.org/assignments/hash-function-text-names
+      hash_klass = case hash
+                     when 'md2' then nil
+                     when 'md5' then Digest::MD5
+                     when 'sha-1' then Digest::SHA1
+                     when 'sha-224' then nil
+                     when 'sha-256' then Digest::SHA256
+                     when 'sha-384' then Digest::SHA384
+                     when 'sha-512' then Digest::SHA512
+                   end
+      hash_klass ? [hash_klass::digest(s)].pack('m').strip : nil
+    end
+  end # Caps
+
+end # Stanza
+end # Blather

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

@@ -0,0 +1,205 @@
+module Blather
+class Stanza
+
+  # # DiscoInfo Stanza
+  #
+  # [XEP-0030 Disco Info](http://xmpp.org/extensions/xep-0030.html#info)
+  #
+  # Disco Info node that provides or retreives information about a jabber entity
+  #
+  # @handler :disco_info
+  class DiscoInfo < Disco
+    register :disco_info, nil, 'http://jabber.org/protocol/disco#info'
+
+    # Create a new DiscoInfo stanza
+    # @param [:get, :set, :result, :error, nil] type the Iq stanza type
+    # @param [String, nil] node the name of the node the info belongs to
+    # @param [Array<Array, DiscoInfo::Identity>, nil] identities a list of
+    # identities. these are passed directly to DiscoInfo::Identity.new
+    # @param [Array<Array, DiscoInfo::Identity>, nil] features a list of
+    # features. these are passed directly to DiscoInfo::Feature.new
+    # @return [DiscoInfo] a new DiscoInfo stanza
+    def self.new(type = nil, node = nil, identities = [], features = [])
+      new_node = super type
+      new_node.node = node
+      new_node.identities = [identities]
+      new_node.features = [features]
+      new_node
+    end
+
+    # List of identity objects
+    def identities
+      query.find('//ns:identity', :ns => self.class.registered_ns).map do |i|
+        Identity.new i
+      end
+    end
+
+    # Add an array of identities
+    # @param identities the array of identities, passed directly to Identity.new
+    def identities=(identities)
+      query.find('//ns:identity', :ns => self.class.registered_ns).each &:remove
+      if identities
+        [identities].flatten.each { |i| self.query << Identity.new(i) }
+      end
+    end
+
+    # List of feature objects
+    def features
+      query.find('//ns:feature', :ns => self.class.registered_ns).map do |f|
+        Feature.new f
+      end
+    end
+
+    # Add an array of features
+    # @param features the array of features, passed directly to Feature.new
+    def features=(features)
+      query.find('//ns:feature', :ns => self.class.registered_ns).each &:remove
+      if features
+        [features].flatten.each { |f| self.query << Feature.new(f) }
+      end
+    end
+
+    # Compare two DiscoInfo objects by name, type and category
+    # @param [DiscoInfo] o the Identity object to compare against
+    # @return [true, false]
+    def eql?(o, *fields)
+      super o, *(fields + [:identities, :features])
+    end
+
+    # DiscoInfo::Identity
+    class Identity < XMPPNode
+      # Create a new DiscoInfo::Identity
+      # @overload new(node)
+      #   Imports the XML::Node to create a Identity object
+      #   @param [XML::Node] node the node object to import
+      # @overload new(opts = {})
+      #   Creates a new Identity using a hash of options
+      #   @param [Hash] opts a hash of options
+      #   @option opts [String] :name the name of the identity
+      #   @option opts [String] :type the type of the identity
+      #   @option opts [String] :category the category of the identity
+      # @overload new(name, type = nil, category = nil)
+      #   Create a new Identity by name
+      #   @param [String] name the name of the Identity
+      #   @param [String, nil] type the type of the Identity
+      #   @param [String, nil] category the category of the Identity
+      def self.new(name, type = nil, category = nil, xml_lang = nil)
+        new_node = super :identity
+
+        case name
+        when Nokogiri::XML::Node
+          new_node.inherit name
+        when Hash
+          new_node.name = name[:name]
+          new_node.type = name[:type]
+          new_node.category = name[:category]
+          new_node.xml_lang = name[:xml_lang]
+        else
+          new_node.name = name
+          new_node.type = type
+          new_node.category = category
+          new_node.xml_lang = xml_lang
+        end
+        new_node
+      end
+
+      # The Identity's category
+      # @return [Symbol, nil]
+      def category
+        read_attr :category, :to_sym
+      end
+
+      # Set the Identity's category
+      # @param [String, Symbol] category the new category
+      def category=(category)
+        write_attr :category, category
+      end
+
+      # The Identity's type
+      # @return [Symbol, nil]
+      def type
+        read_attr :type, :to_sym
+      end
+
+      # Set the Identity's type
+      # @param [String, Symbol] type the new category
+      def type=(type)
+        write_attr :type, type
+      end
+
+      # The Identity's name
+      # @return [String]
+      def name
+        read_attr :name
+      end
+
+      # Set the Identity's name
+      # @param [String] name the new name for the identity
+      def name=(name)
+        write_attr :name, name
+      end
+
+      # The Identity's xml_lang
+      # @return [String]
+      def xml_lang
+        read_attr "lang"
+      end
+
+      # Set the Identity's name
+      # @param [String] name the new name for the identity
+      def xml_lang=(xml_lang)
+        write_attr "xml:lang", xml_lang
+      end
+
+      # Compare two Identity objects by name, type and category
+      # @param [DiscoInfo::Identity] o the Identity object to compare against
+      # @return [true, false]
+      def eql?(o, *fields)
+        super o, *(fields + [:name, :type, :category, :xml_lang])
+      end
+    end # Identity
+
+    # DiscoInfo::Feature
+    class Feature < XMPPNode
+      # Create a new DiscoInfo::Feature object
+      # @overload new(node)
+      #   Create a new Feature by importing an XML::Node
+      #   @param [XML::Node] node an XML::Node to import
+      # @overload new(var)
+      #   Create a new feature by var
+      #   @param [String] var a the Feautre's var
+      # @return [DiscoInfo::Feature]
+      def self.new(var)
+        new_node = super :feature
+        case var
+        when Nokogiri::XML::Node
+          new_node.inherit var
+        else
+          new_node.var = var
+        end
+        new_node
+      end
+
+      # The Feature's var
+      # @return [String]
+      def var
+        read_attr :var
+      end
+
+      # Set the Feature's var
+      # @param [String] var the new var
+      def var=(var)
+        write_attr :var, var
+      end
+
+      # Compare two DiscoInfo::Feature objects by name, type and category
+      # @param [DiscoInfo::Feature] o the Identity object to compare against
+      # @return [true, false]
+      def eql?(o, *fields)
+        super o, *(fields + [:var])
+      end
+    end
+  end # Feature
+
+end # Stanza
+end # Blather

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

@@ -0,0 +1,134 @@
+module Blather
+class Stanza
+
+  # # DiscoItems Stanza
+  #
+  # [XEP-0030 Disco Info](http://xmpp.org/extensions/xep-0030.html#items)
+  #
+  # Disco Items node that provides or retreives items associated with a
+  # jabbery entity
+  #
+  # @handler :disco_items
+  class DiscoItems < Disco
+    register :disco_items, nil, 'http://jabber.org/protocol/disco#items'
+
+    # Create a new DiscoItems node
+    #
+    # @param [#to_s] type the IQ type
+    # @param [#to_s] node the node the items are associated with
+    # @param [Array<Blather::XMPPNode>] items an array of Disco::Items
+    # @return [Blather::Stanza::DiscoItems]
+    def self.new(type = nil, node = nil, items = [])
+      new_node = super type
+      new_node.node = node
+      new_node.items = [items]
+      new_node
+    end
+
+    # Set of items associated with the node
+    #
+    # @return [Array<Blather::Stanza::DiscoItems::Item>]
+    def items
+      query.find('//ns:item', :ns => self.class.registered_ns).map do |i|
+        Item.new i
+      end
+    end
+
+    # Add an array of items
+    # @param items the array of items, passed directly to Item.new
+    def items=(items)
+      query.find('//ns:item', :ns => self.class.registered_ns).each &:remove
+      if items
+        [items].flatten.each { |i| self.query << Item.new(i) }
+      end
+    end
+
+    # An individual Disco Item
+    class Item < XMPPNode
+      # Create a new Blather::Stanza::DiscoItems::Item
+      #
+      # @overload new(node)
+      #   Create a new Item by inheriting an existing node
+      #   @param [XML::Node] node an XML::Node to inherit from
+      # @overload new(opts)
+      #   Create a new Item through a hash of options
+      #   @param [Hash] opts a hash options
+      #   @option opts [Blather::JID, String] :jid the JID to attach to the item
+      #   @option opts [#to_s] :node the node the item is attached to
+      #   @option opts [#to_S] :name the name of the Item
+      # @overload new(jid, node = nil, name  = nil)
+      #   Create a new Item
+      #   @param [Blather::JID, String] jid the JID to attach to the item
+      #   @param [#to_s] node the node the item is attached to
+      #   @param [#to_s] name the name of the Item
+      def self.new(jid, node = nil, name = nil)
+        new_node = super :item
+
+        case jid
+        when Nokogiri::XML::Node
+          new_node.inherit jid
+        when Hash
+          new_node.jid = jid[:jid]
+          new_node.node = jid[:node]
+          new_node.name = jid[:name]
+        else
+          new_node.jid = jid
+          new_node.node = node
+          new_node.name = name
+        end
+        new_node
+      end
+
+      # Get the JID attached to the node
+      #
+      # @return [Blather::JID, nil]
+      def jid
+        (j = self[:jid]) ? JID.new(j) : nil
+      end
+
+      # Set the JID of the node
+      #
+      # @param [Blather::JID, String, nil] jid the new JID
+      def jid=(jid)
+        write_attr :jid, jid
+      end
+
+      # Get the name of the node
+      #
+      # @return [String, nil]
+      def node
+        read_attr :node
+      end
+
+      # Set the name of the node
+      #
+      # @param [String, nil] node the new node name
+      def node=(node)
+        write_attr :node, node
+      end
+
+      # Get the Item name
+      #
+      # @return [String, nil]
+      def name
+        read_attr :name
+      end
+
+      # Set the Item name
+      #
+      # @param [#to_s] name the Item name
+      def name=(name)
+        write_attr :name, name
+      end
+
+      # Compare two DiscoItems::Item objects by name, type and category
+      # @param [DiscoItems::Item] o the Identity object to compare against
+      # @return [true, false]
+      def eql?(o, *fields)
+        super o, *(fields + [:jid, :node, :name])
+      end
+    end
+  end
+
+end #Stanza
+end #Blather