blather 0.4.14 → 0.4.15

data/lib/blather/roster_item.rb

@@ -90,7 +90,7 @@ module Blather
     #
     # @param [Blather::Stanza::Status] the new status
     def status=(presence)
-      @statuses.delete_if { |s| s.from == presence.from }
+      @statuses.delete_if { |s| s.from == presence.from || s.state == :unavailable }
       @statuses << presence
       @statuses.sort!
     end
@@ -102,7 +102,7 @@ module Blather
       top = if resource
         @statuses.detect { |s| s.from.resource == resource }
       else
-        @statuses.first
+        @statuses.last
       end
     end
 

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

@@ -75,7 +75,7 @@ class Stanza
       #   @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)
+      def self.new(name, type = nil, category = nil, xml_lang = nil)
         new_node = super :identity
 
         case name
@@ -85,10 +85,12 @@ class Stanza
           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
@@ -129,6 +131,18 @@ class Stanza
         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]
@@ -139,7 +153,8 @@ class Stanza
 
         o.name == self.name &&
         o.type == self.type &&
-        o.category == self.category
+        o.category == self.category &&
+        o.xml_lang == self.xml_lang
       end
       alias_method :==, :eql?
     end # Identity

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

@@ -0,0 +1,83 @@
+module Blather
+class Stanza
+class Iq
+  NS_IBB = 'http://jabber.org/protocol/ibb'
+
+  # # 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
+
+    # 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
+
+    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
+
+    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
+
+    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/s5b.rb

@@ -0,0 +1,205 @@
+module Blather
+class Stanza
+class Iq
+  NS_S5B = 'http://jabber.org/protocol/bytestreams'
+
+  # # SOCKS5 Bytestreams Stanza
+  #
+  # [XEP-0065: SOCKS5 Bytestreams](http://xmpp.org/extensions/xep-0065.html)
+  #
+  # @handler :s5b_open
+  class S5b < Query
+    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
+
+    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
+
+    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

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

@@ -0,0 +1,410 @@
+require 'time' # For Time#xmlschema
+
+module Blather
+class Stanza
+class Iq
+
+  # # Si Stanza
+  #
+  # [XEP-0096: SI File Transfer](http://xmpp.org/extensions/xep-0096.html)
+  #
+  # This is a base class for any si based Iq stanzas. It provides a base set
+  # of methods for working with si stanzas
+  #
+  # @example Basic file transfer acceptance
+  #     client.register_handler :file_transfer do |iq|
+  #       transfer = Blather::FileTransfer.new(client, iq)
+  #       transfer.accept(Blather::FileTransfer::SimpleFileReceiver, "/path/to/#{iq.si.file["name"]}", iq.si.file["size"].to_i)
+  #     end
+  #
+  # @example Basic file transfer refusal
+  #     client.register_handler :file_transfer do |iq|
+  #       transfer = Blather::FileTransfer.new(client, iq)
+  #       transfer.decline
+  #     end
+  #
+  # @example File transfer acceptance by in-band bytestreams with custom handler
+  #     client.register_handler :file_transfer do |iq|
+  #       transfer = Blather::FileTransfer.new(client, iq)
+  #       transfer.allow_ibb = true
+  #       transfer.allow_s5b = false
+  #       transfer.accept(MyFileReceiver, iq)
+  #     end
+  #
+  # @handler :file_transfer
+  class Si < Iq
+    NS_SI = 'http://jabber.org/protocol/si'
+    register :file_transfer, :si, NS_SI
+
+    # Overrides the parent method to ensure a si node is created
+    #
+    # @see Blather::Stanza::Iq.new
+    def self.new(type = :set)
+      node = super
+      node.si
+      node
+    end
+
+    # Overrides the parent method to ensure the current si node is destroyed
+    #
+    # @see Blather::Stanza::Iq#inherit
+    def inherit(node)
+      si.remove
+      super
+    end
+
+    # Find or create si node
+    #
+    # @return [Si::Si]
+    def si
+      Si.find_or_create self
+    end
+
+    # Replaces si node
+    #
+    # @param [Si::Si, XML::Node] node the stanza's new si node
+    #
+    # @return [Si::Si]
+    def si=(node)
+      si.remove
+      self << node
+      Si.find_or_create self
+    end
+
+    # Overrides the parent method to ensure the current si node is destroyed
+    #
+    # @see Blather::Stanza#reply
+    def reply
+      reply = Stanza::Iq::Si.import super
+      reply.si.remove
+      reply
+    end
+
+    class Si < XMPPNode
+      # Create a new Si::Si object
+      #
+      # @param [XML::Node, nil] node a node to inherit from
+      #
+      # @return [Si::Si]
+      def self.new(node = nil)
+        new_node = super :si
+        new_node.namespace = NS_SI
+        new_node.inherit node if node
+        new_node
+      end
+
+      # Find or create si node in Si Iq and converts it to Si::Si
+      #
+      # @param [Si] parent a Si Iq where to find or create si
+      #
+      # @return [Si::Si]
+      def self.find_or_create(parent)
+        if found_si = parent.find_first('//ns:si', :ns => NS_SI)
+          si = self.new found_si
+          found_si.remove
+        else
+          si = self.new
+        end
+        parent << si
+
+        si
+      end
+
+      # Get the id of the stream
+      #
+      # @return [String, nil]
+      def id
+        read_attr :id
+      end
+
+      # Set the id
+      #
+      # @param [String, nil] id the id of the stream
+      def id=(id)
+        write_attr :id, id
+      end
+
+      # Get the MIME type of the stream
+      #
+      # @return [String, nil]
+      def mime_type
+        read_attr 'mime-type'
+      end
+
+      # Set the MIME type
+      #
+      # @param [String, nil] type the MIME type of the stream
+      def mime_type=(type)
+        write_attr 'mime-type', type
+      end
+
+      # Get the profile of the stream
+      #
+      # @return [String, nil]
+      def profile
+        read_attr :profile
+      end
+
+      # Set the profile
+      #
+      # @param [String, nil] profile the profile of the stream
+      def profile=(profile)
+        write_attr :profile, profile
+      end
+
+      # Find or create file node
+      #
+      # @return [Si::Si::File]
+      def file
+        File.find_or_create self
+      end
+
+      # Find or create feature node
+      #
+      # @return [Si::Si::Feature]
+      def feature
+        Feature.find_or_create self
+      end
+
+      class Feature < XMPPNode
+        register :feature, 'http://jabber.org/protocol/feature-neg'
+
+        # Create a new Si::Si::Feature object
+        #
+        # @param [XML::Node, nil] node a node to inherit from
+        #
+        # @return [Si::Si::Feature]
+        def self.new(node = nil)
+          new_node = super :feature
+          new_node.namespace = self.registered_ns
+          new_node.inherit node if node
+          new_node
+        end
+
+        # Find or create feature node in si node and converts it to Si::Si::Feature
+        #
+        # @param [Si::Si] parent a si node where to find or create feature
+        #
+        # @return [Si::Si::Feature]
+        def self.find_or_create(parent)
+          if found_feature = parent.find_first('//ns:feature', :ns => self.registered_ns)
+            feature = self.new found_feature
+            found_feature.remove
+          else
+            feature = self.new
+          end
+          parent << feature
+
+          feature
+        end
+
+        # Find or create x node
+        #
+        # @return [Stanza::X]
+        def x
+          Stanza::X.find_or_create self
+        end
+      end
+
+      class File < XMPPNode
+        register :file, 'http://jabber.org/protocol/si/profile/file-transfer'
+
+        # Create a new Si::Si::File object
+        #
+        # @param [XML::Node, nil] node a node to inherit from
+        #
+        # @return [Si::Si::File]
+        def self.new(name = nil, size = nil)
+          new_node = super :file
+
+          case name
+          when Nokogiri::XML::Node
+            new_node.inherit name
+          else
+            new_node.name = name
+            new_node.size = size
+          end
+          new_node
+        end
+
+        # Find or create file node in si node and converts it to Si::Si::File
+        #
+        # @param [Si::Si] parent a si node where to find or create file
+        #
+        # @return [Si::Si::File]
+        def self.find_or_create(parent)
+          if found_file = parent.find_first('//ns:file', :ns => self.registered_ns)
+            file = self.new found_file
+            found_file.remove
+          else
+            file = self.new
+          end
+          parent << file
+
+          file
+        end
+
+        # Get the filename
+        #
+        # @return [String, nil]
+        def name
+          read_attr :name
+        end
+
+        # Set the filename
+        #
+        # @param [String, nil] name the name of the file
+        def name=(name)
+          write_attr :name, name
+        end
+
+        # Get the hash
+        #
+        # @return [String, nil]
+        def hash
+          read_attr :hash
+        end
+
+        # Set the hash
+        #
+        # @param [String, nil] hash the MD5 hash of the file
+        def hash=(hash)
+          write_attr :hash, hash
+        end
+
+        # Get the date
+        #
+        # @return [Time, nil]
+        def date
+          begin
+            Time.xmlschema(read_attr(:date))
+          rescue ArgumentError
+            nil
+          end
+        end
+
+        # Set the date
+        #
+        # @param [Time, nil] date the last modification time of the file
+        def date=(date)
+          write_attr :date, (date ? date.xmlschema : nil)
+        end
+
+        # Get the size
+        #
+        # @return [Fixnum, nil]
+        def size
+          if (s = read_attr(:size)) && (s =~ /^\d+$/)
+            s.to_i
+          else
+            nil
+          end
+        end
+
+        # Set the size
+        #
+        # @param [Fixnum, nil] size the size, in bytes, of the file
+        def size=(size)
+          write_attr :size, size
+        end
+
+        # Get the desc
+        #
+        # @return [String, nil]
+        def desc
+          content_from 'ns:desc', :ns => self.class.registered_ns
+        end
+
+        # Set the desc
+        #
+        # @param [String, nil] desc the description of the file
+        def desc=(desc)
+          set_content_for :desc, desc
+        end
+
+        # Find or create range node
+        #
+        # @return [Si::Si::File::Range]
+        def range
+          Range.find_or_create self
+        end
+      end
+
+      class Range < XMPPNode
+        register :range, 'http://jabber.org/protocol/si/profile/file-transfer'
+
+        # Create a new Si::Si::File::Range object
+        #
+        # @param [XML::Node, nil] node a node to inherit from
+        #
+        # @return [Si::Si::File::Range]
+        def self.new(offset = nil, length = nil)
+          new_node = super :range
+
+          case offset
+          when Nokogiri::XML::Node
+            new_node.inherit offset
+          else
+            new_node.offset = offset
+            new_node.length = length
+          end
+          new_node
+        end
+        # Find or create range node in file node and converts it to Si::Si::File::Range
+        #
+        # @param [Si::Si::File] parent a file node where to find or create range
+        #
+        # @return [Si::Si::File::Range]
+        def self.find_or_create(parent)
+          if found_range = parent.find_first('//ns:range', :ns => self.registered_ns)
+            range = self.new found_range
+            found_range.remove
+          else
+            range = self.new
+          end
+          parent << range
+
+          range
+        end
+
+        # Get the offset
+        #
+        # @return [Fixnum, nil]
+        def offset
+          if (o = read_attr(:offset)) && (o =~ /^\d+$/)
+            o.to_i
+          else
+            nil
+          end
+        end
+
+        # Set the offset
+        #
+        # @param [Fixnum, nil] offset the position, in bytes, to start transferring the file data from
+        def offset=(offset)
+          write_attr :offset, offset
+        end
+
+        # Get the length
+        #
+        # @return [Fixnum, nil]
+        def length
+          if (l = read_attr(:length)) && (l =~ /^\d+$/)
+            l.to_i
+          else
+            nil
+          end
+        end
+
+        # Set the length
+        #
+        # @param [Fixnum, nil] length the number of bytes to retrieve starting at offset
+        def length=(length)
+          write_attr :length, length
+        end
+      end
+    end
+  end
+end
+end
+end