tp-blather 0.8.2

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

@@ -0,0 +1,86 @@
+module Blather
+class Stanza
+class Iq
+  # # In-Band Bytestreams Stanza
+  #
+  # [XEP-0047: In-Band Bytestreams](http://xmpp.org/extensions/xep-0047.html)
+  #
+  # @handler :ibb_open
+  # @handler :ibb_data
+  # @handler :ibb_close
+  class Ibb < Iq
+    # @private
+    NS_IBB = 'http://jabber.org/protocol/ibb'
+
+    # Overrides the parent method to remove open, close and data nodes
+    #
+    # @see Blather::Stanza#reply
+    def reply
+      reply = super
+      reply.remove_children :open
+      reply.remove_children :close
+      reply.remove_children :data
+      reply
+    end
+
+    # An Open stanza to
+    class Open < Ibb
+      register :ibb_open, :open, NS_IBB
+
+      # Find open node
+      #
+      # @return [Nokogiri::XML::Element]
+      def open
+        find_first('ns:open', :ns => NS_IBB)
+      end
+
+      # Get the sid of the file transfer
+      #
+      # @return [String]
+      def sid
+        open['sid']
+      end
+
+    end
+
+    # A Data stanza
+    class Data < Ibb
+      register :ibb_data, :data, NS_IBB
+
+      # Find data node
+      #
+      # @return [Nokogiri::XML::Element]
+      def data
+        find_first('ns:data', :ns => NS_IBB)
+      end
+
+      # Get the sid of the file transfer
+      #
+      # @return [String]
+      def sid
+        data['sid']
+      end
+    end
+
+    # A Close stanza
+    class Close < Ibb
+      register :ibb_close, :close, NS_IBB
+
+      # Find close node
+      #
+      # @return [Nokogiri::XML::Element]
+      def close
+        find_first('ns:close', :ns => NS_IBB)
+      end
+
+      # Get the sid of the file transfer
+      #
+      # @return [String]
+      def sid
+        close['sid']
+      end
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,50 @@
+module Blather
+class Stanza
+class Iq
+
+  # # Ping Stanza
+  #
+  # [XEP-0199: XMPP Ping](http://xmpp.org/extensions/xep-0199.html)
+  #
+  # This is a base class for any Ping based Iq stanzas.
+  #
+  # @handler :ping
+  class Ping < Iq
+    # @private
+    register :ping, :ping, 'urn:xmpp:ping'
+
+    # Overrides the parent method to ensure a ping node is created
+    #
+    # @see Blather::Stanza::Iq.new
+    def self.new(type = :get, to = nil, id = nil)
+      node = super
+      node.ping
+      node
+    end
+
+    # Overrides the parent method to ensure the current ping node is destroyed
+    #
+    # @see Blather::Stanza::Iq#inherit
+    def inherit(node)
+      ping.remove
+      super
+    end
+
+    # Ping node accessor
+    # If a ping node exists it will be returned.
+    # Otherwise a new node will be created and returned
+    #
+    # @return [Balather::XMPPNode]
+    def ping
+      p = find_first 'ns:ping', :ns => self.class.registered_ns
+
+      unless p
+        (self << (p = XMPPNode.new('ping', self.document)))
+        p.namespace = self.class.registered_ns
+      end
+      p
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,53 @@
+module Blather
+class Stanza
+class Iq
+
+  # # Query Stanza
+  #
+  # This is a base class for any query based Iq stanzas. It provides a base set
+  # of methods for working with query stanzas
+  #
+  # @handler :query
+  class Query < Iq
+    register :query, :query
+
+    # Overrides the parent method to ensure a query node is created
+    #
+    # @see Blather::Stanza::Iq.new
+    def self.new(type = nil)
+      node = super
+      node.query
+      node
+    end
+
+    # Overrides the parent method to ensure the current query node is destroyed
+    #
+    # @see Blather::Stanza::Iq#inherit
+    def inherit(node)
+      query.remove
+      super
+    end
+
+    # Query node accessor
+    # If a query node exists it will be returned.
+    # Otherwise a new node will be created and returned
+    #
+    # @return [Balather::XMPPNode]
+    def query
+      q = if self.class.registered_ns
+        find_first('query_ns:query', :query_ns => self.class.registered_ns)
+      else
+        find_first('query')
+      end
+
+      unless q
+        (self << (q = XMPPNode.new('query', self.document)))
+        q.namespace = self.class.registered_ns
+      end
+      q
+    end
+  end #Query
+
+end #Iq
+end #Stanza
+end

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

@@ -0,0 +1,185 @@
+module Blather
+class Stanza
+class Iq
+
+  # # Roster Stanza
+  #
+  # [RFC 3921 Section 7 - Roster Management](http://xmpp.org/rfcs/rfc3921.html#roster)
+  #
+  # @handler :roster
+  class Roster < Query
+    register :roster, nil, 'jabber:iq:roster'
+
+    # Create a new roster stanza and (optionally) load it with an item
+    #
+    # @param [<Blather::Stanza::Iq::VALID_TYPES>] type the stanza type
+    # @param [Blather::XMPPNode] item a roster item
+    def self.new(type = nil, item = nil)
+      node = super type
+      node.query << item if item
+      node
+    end
+
+    # Inherit the XMPPNode to create a proper Roster object.
+    # Creates RosterItem objects out of each roster item as well.
+    #
+    # @param [Blather::XMPPNode] node a node to inherit
+    def inherit(node)
+      # remove the current set of nodes
+      remove_children :item
+      super
+      # transmogrify nodes into RosterItems
+      items.each { |i| query << RosterItem.new(i); i.remove }
+      self
+    end
+
+    # The list of roster items
+    #
+    # @return [Array<Blather::Stanza::Iq::Roster::RosterItem>]
+    def items
+      query.find('//ns:item', :ns => self.class.registered_ns).map do |i|
+        RosterItem.new i
+      end
+    end
+
+    # # RosterItem Fragment
+    #
+    # Individual roster items.
+    # This is a convenience class to attach methods to the node
+    class RosterItem < XMPPNode
+
+      register :item, Roster.registered_ns
+
+      # Create a new RosterItem
+      # @overload new(XML::Node)
+      #   Create a RosterItem by inheriting a node
+      #   @param [XML::Node] node an xml node to inherit
+      # @overload new(opts)
+      #   Create a RosterItem through a hash of options
+      #   @param [Hash] opts the options
+      #   @option opts [Blather::JID, String, nil] :jid the JID of the item
+      #   @option opts [String, nil] :name the alias to give the JID
+      #   @option opts [Symbol, nil] :subscription the subscription status of
+      #   the RosterItem must be one of
+      #   Blather::RosterItem::VALID_SUBSCRIPTION_TYPES
+      #   @option opts [:subscribe, nil] :ask the ask value of the RosterItem
+      #   @option opts [Array<#to_s>] :groups the group names the RosterItem is a member of
+      # @overload new(jid = nil, name = nil, subscription = nil, ask = nil)
+      #   @param [Blather::JID, String, nil] jid the JID of the item
+      #   @param [String, nil] name the alias to give the JID
+      #   @param [Symbol, nil] subscription the subscription status of the
+      #   RosterItem must be one of
+      #   Blather::RosterItem::VALID_SUBSCRIPTION_TYPES
+      #   @param [:subscribe, nil] ask the ask value of the RosterItem
+      #   @param [Array<#to_s>] groups the group names the RosterItem is a member of
+      def self.new(jid = nil, name = nil, subscription = nil, ask = nil, groups = nil)
+        new_node = super :item
+
+        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]
+          new_node.groups = jid[:groups]
+        else
+          new_node.jid = jid
+          new_node.name = name
+          new_node.subscription = subscription
+          new_node.ask = ask
+          new_node.groups = groups
+        end
+        new_node
+      end
+
+      # Get the JID attached to the item
+      #
+      # @return [Blather::JID, nil]
+      def jid
+        (j = self[:jid]) ? JID.new(j) : nil
+      end
+
+      # Set the JID of the item
+      #
+      # @param [Blather::JID, String, nil] jid the new JID
+      def jid=(jid)
+        write_attr :jid, (jid.nil?) ? nil : JID.new(jid).stripped
+      end
+
+      # Get the item name
+      #
+      # @return [String, nil]
+      def name
+        read_attr :name
+      end
+
+      # Set the item name
+      #
+      # @param [#to_s] name the name of the item
+      def name=(name)
+        write_attr :name, name
+      end
+
+      # Get the subscription value of the item
+      #
+      # @return [<:both, :from, :none, :remove, :to>]
+      def subscription
+        read_attr :subscription, :to_sym
+      end
+
+      # Set the subscription value of the item
+      #
+      # @param [<:both, :from, :none, :remove, :to>] subscription
+      def subscription=(subscription)
+        write_attr :subscription, subscription
+      end
+
+      # Get the ask value of the item
+      #
+      # @return [<:subscribe, nil>]
+      def ask
+        read_attr :ask, :to_sym
+      end
+
+      # Set the ask value of the item
+      #
+      # @param [<:subscribe, nil>] ask
+      def ask=(ask)
+        write_attr :ask, ask
+      end
+
+      # The groups roster item belongs to
+      #
+      # @return [Array<String>]
+      def groups
+        find('child::*[local-name()="group"]').map { |g| g.content }
+      end
+
+      # Set the roster item's groups
+      #
+      # @param [Array<#to_s>] new_groups an array of group names
+      def groups=(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
+
+      # Convert the roster item to a proper stanza all wrapped up
+      # This facilitates new subscriptions
+      #
+      # @return [Blather::Stanza::Iq::Roster]
+      def to_stanza
+        Roster.new(:set, self)
+      end
+    end #RosterItem
+  end #Roster
+
+end #Iq
+end #Stanza
+end

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

@@ -0,0 +1,208 @@
+module Blather
+class Stanza
+class Iq
+  # # SOCKS5 Bytestreams Stanza
+  #
+  # [XEP-0065: SOCKS5 Bytestreams](http://xmpp.org/extensions/xep-0065.html)
+  #
+  # @handler :s5b_open
+  class S5b < Query
+    # @private
+    NS_S5B = 'http://jabber.org/protocol/bytestreams'
+
+    register :s5b_open, :query, NS_S5B
+
+    # Overrides the parent method to remove query node
+    #
+    # @see Blather::Stanza#reply
+    def reply
+      reply = super
+      reply.remove_children :query
+      reply
+    end
+
+    # Get the sid of the file transfer
+    #
+    # @return [String]
+    def sid
+      query['sid']
+    end
+
+    # Get the used streamhost
+    #
+    # @return [S5b::StreamHostUsed]
+    def streamhost_used
+      StreamHostUsed.new query.find_first('.//ns:streamhost-used', :ns => self.class.registered_ns)
+    end
+
+    # Set the used streamhost
+    #
+    # @param [Blather::JID, String, nil] jid the jid of the used streamhost
+    def streamhost_used=(jid)
+      query.find('.//ns:streamhost-used', :ns => self.class.registered_ns).remove
+
+      if jid
+        query << StreamHostUsed.new(jid)
+      end
+    end
+
+    # Get the streamhosts
+    #
+    # @return [Array<S5b::StreamHost>]
+    def streamhosts
+      query.find('.//ns:streamhost', :ns => self.class.registered_ns).map do |s|
+        StreamHost.new s
+      end
+    end
+
+    # Set the streamhosts
+    #
+    # @param streamhosts the array of streamhosts, passed directly to StreamHost.new
+    def streamhosts=(streamhosts)
+      query.find('.//ns:streamhost', :ns => self.class.registered_ns).remove
+      if streamhosts
+        [streamhosts].flatten.each { |s| self.query << StreamHost.new(s) }
+      end
+    end
+
+    # StreamHost Stanza
+    class StreamHost < XMPPNode
+      register 'streamhost', NS_S5B
+
+      # Create a new S5b::StreamHost
+      #
+      # @overload new(node)
+      #   Create a new StreamHost by inheriting an existing node
+      #   @param [XML::Node] node an XML::Node to inherit from
+      # @overload new(opts)
+      #   Create a new StreamHost through a hash of options
+      #   @param [Hash] opts a hash options
+      #   @option opts [Blather::JID, String] :jid the JID of the StreamHost
+      #   @option opts [#to_s] :host the host the StreamHost
+      #   @option opts [#to_s] :port the post of the StreamHost
+      # @overload new(jid, host = nil, port = nil)
+      #   Create a new StreamHost
+      #   @param [Blather::JID, String] jid the JID of the StreamHost
+      #   @param [#to_s] host the host the StreamHost
+      #   @param [#to_s] port the post of the StreamHost
+      def self.new(jid, host = nil, port = nil)
+        new_node = super 'streamhost'
+
+        case jid
+        when Nokogiri::XML::Node
+          new_node.inherit jid
+        when Hash
+          new_node.jid = jid[:jid]
+          new_node.host = jid[:host]
+          new_node.port = jid[:port]
+        else
+          new_node.jid = jid
+          new_node.host = host
+          new_node.port = port
+        end
+        new_node
+      end
+
+      # Get the jid of the streamhost
+      #
+      # @return [Blather::JID, nil]
+      def jid
+        if j = read_attr(:jid)
+          JID.new(j)
+        else
+          nil
+        end
+      end
+
+      # Set the jid of the streamhost
+      #
+      # @param [Blather::JID, String, nil]
+      def jid=(j)
+        write_attr :jid, (j ? j.to_s : nil)
+      end
+
+      # Get the host address of the streamhost
+      #
+      # @return [String, nil]
+      def host
+        read_attr :host
+      end
+
+      # Set the host address of the streamhost
+      #
+      # @param [String, nil]
+      def host=(h)
+        write_attr :host, h
+      end
+
+      # Get the port of the streamhost
+      #
+      # @return [Fixnum, nil]
+      def port
+        if p = read_attr(:port)
+          p.to_i
+        else
+          nil
+        end
+      end
+
+      # Set the port of the streamhost
+      #
+      # @param [String, Fixnum, nil]
+      def port=(p)
+        write_attr :port, p
+      end
+    end
+
+    # Stream host used stanza
+    class StreamHostUsed < XMPPNode
+      register 'streamhost-used', NS_S5B
+
+      # Create a new S5b::StreamHostUsed
+      #
+      # @overload new(node)
+      #   Create a new StreamHostUsed by inheriting an existing node
+      #   @param [XML::Node] node an XML::Node to inherit from
+      # @overload new(opts)
+      #   Create a new StreamHostUsed through a hash of options
+      #   @param [Hash] opts a hash options
+      #   @option opts [Blather::JID, String] :jid the JID of the StreamHostUsed
+      # @overload new(jid)
+      #   Create a new StreamHostUsed
+      #   @param [Blather::JID, String] jid the JID of the StreamHostUsed
+      def self.new(jid)
+        new_node = super 'streamhost-used'
+
+        case jid
+        when Nokogiri::XML::Node
+          new_node.inherit jid
+        when Hash
+          new_node.jid = jid[:jid]
+        else
+          new_node.jid = jid
+        end
+        new_node
+      end
+
+      # Get the jid of the used streamhost
+      #
+      # @return [Blather::JID, nil]
+      def jid
+        if j = read_attr(:jid)
+          JID.new(j)
+        else
+          nil
+        end
+      end
+
+      # Set the jid of the used streamhost
+      #
+      # @param [Blather::JID, String, nil]
+      def jid=(j)
+        write_attr :jid, (j ? j.to_s : nil)
+      end
+    end
+  end
+end
+end
+end