xmpp4r 0.3.1 → 0.3.2

data/lib/xmpp4r/bytestreams/iq/bytestreams.rb

@@ -4,12 +4,14 @@
 
 module Jabber
   module Bytestreams
+    NS_BYTESTREAMS = 'http://jabber.org/protocol/bytestreams'
+
     ##
     # Class for accessing <query/> elements with
     # xmlns='http://jabber.org/protocol/bytestreams'
     # in <iq/> stanzas.
     class IqQueryBytestreams < IqQuery
-      NS_BYTESTREAMS = 'http://jabber.org/protocol/bytestreams'
+      name_xmlns 'query', NS_BYTESTREAMS
 
       ##
       # Initialize such a <query/>
@@ -17,21 +19,10 @@ module Jabber
       # mode:: [Symbol] :tcp or :udp
       def initialize(sid=nil, mode=nil)
         super()
-        add_namespace(IqQueryBytestreams::NS_BYTESTREAMS)
         self.sid = sid
         self.mode = mode
       end
 
-      def typed_add(xe)
-        if xe.kind_of?(REXML::Element) and xe.name == 'streamhost'
-          super StreamHost.new.import(xe)
-        elsif xe.kind_of?(REXML::Element) and xe.name == 'streamhost-used'
-          super StreamHostUsed.new.import(xe)
-        else
-          super xe
-        end
-      end
-
       ##
       # Session-ID
       def sid
@@ -87,19 +78,20 @@ module Jabber
       end
     end
 
-    IqQuery.add_namespaceclass(IqQueryBytestreams::NS_BYTESTREAMS, IqQueryBytestreams)
 
     ##
     # <streamhost/> element, normally appear
     # as children of IqQueryBytestreams
-    class StreamHost < REXML::Element
+    class StreamHost < XMPPElement
+      name_xmlns 'streamhost', NS_BYTESTREAMS
+
       ##
       # Initialize a <streamhost/> element
       # jid:: [JID]
       # host:: [String] Hostname or IP address
       # port:: [Fixnum] Port number
       def initialize(jid=nil, host=nil, port=nil)
-        super('streamhost')
+        super()
         self.jid = jid
         self.host = host
         self.port = port
@@ -158,9 +150,11 @@ module Jabber
     ##
     # <streamhost-used/> element, normally appears
     # as child of IqQueryBytestreams
-    class StreamHostUsed < REXML::Element
+    class StreamHostUsed < XMPPElement
+      name_xmlns 'streamhost-used', NS_BYTESTREAMS
+
       def initialize(jid=nil)
-        super('streamhost-used')
+        super()
         self.jid = jid
       end
 

data/lib/xmpp4r/bytestreams/iq/si.rb

@@ -8,34 +8,22 @@ require 'xmpp4r/feature_negotiation/iq/feature'
 
 module Jabber
   module Bytestreams
+    PROFILE_FILETRANSFER = 'http://jabber.org/protocol/si/profile/file-transfer'
+
     ##
     # Iq child 'si' for Stream-Initiation
-    class IqSi < REXML::Element
-      PROFILE_FILETRANSFER = 'http://jabber.org/protocol/si/profile/file-transfer'
+    class IqSi < XMPPElement
+      name_xmlns 'si', 'http://jabber.org/protocol/si'
+      force_xmlns true
 
       def initialize(id=nil, profile=nil, mime_type=nil)
-        super('si')
+        super()
 
-        add_namespace 'http://jabber.org/protocol/si'
         self.id = id
         self.profile = profile
         self.mime_type = mime_type
       end
 
-      def IqSi.import(element)
-        IqSi::new.import(element)
-      end
-
-      def typed_add(element)
-        if element.kind_of?(REXML::Element) and element.name == 'file'
-          super IqSiFile.new.import(element)
-        elsif element.kind_of?(REXML::Element) and element.name == 'feature'
-          super FeatureNegotiation::IqFeature.new.import(element)
-        else
-          super element
-        end
-      end
-
       ##
       # Session ID of this stream
       def id
@@ -87,27 +75,19 @@ module Jabber
       end
     end
 
-    Iq.add_elementclass('si', IqSi)
 
     ##
     # File-transfer meta-information,
     # may appear as <file/> in IqSi
-    class IqSiFile < REXML::Element
+    class IqSiFile < XMPPElement
+      name_xmlns 'file', PROFILE_FILETRANSFER
+
       def initialize(fname=nil, size=nil)
-        super 'file'
-        add_namespace IqSi::PROFILE_FILETRANSFER
+        super()
         self.fname = fname
         self.size = size
       end
 
-      def typed_add(element)
-        if element.kind_of?(REXML::Element) and element.name == 'range'
-          super IqSiFileRange.new.import(element)
-        else
-          super element
-        end
-      end
-
       ##
       # Get filename (attribute 'name')
       def fname
@@ -189,9 +169,10 @@ module Jabber
 
     ##
     # Information for ranged transfers
-    class IqSiFileRange < REXML::Element
+    class IqSiFileRange < XMPPElement
+      name_xmlns 'range', PROFILE_FILETRANSFER
       def initialize(offset=nil, length=nil)
-        super('range')
+        super()
 
         self.offset = offset
         self.length = length

data/lib/xmpp4r/callbacks.rb

@@ -0,0 +1,124 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+module Jabber
+  ##
+  # This class manages a list of callbacks.
+  #
+  # ==Callbacks management and priority
+  #
+  # Callbacks are managed by the class CallbackList. When they are added, a
+  # priority (just a number or anything Comparable with other priorities) is
+  # specified. The biggest the priority is, the earliest the callback will be
+  # considered.
+  #
+  # Callbacks are processed for a given set of objects as long as they return
+  # false. If you want to stop processing, you must return true. Example :
+  #  cbl = CallbackList::new
+  #  c1 = false
+  #  c2 = false
+  #  c3 = false
+  #  cbl.add(10) { c1 = true; 1 }
+  #  cbl.add(5) { c2 = true; true }
+  #  cbl.add(0) { c3 = true }
+  #  cbl.process('aa')
+  #  puts "#{c1} #{c2} #{c3}"
+  # This example would display "true true false" as callbacks processing was
+  # stopped after the second callback returned true.
+  #
+  # In XMPP4R, callbacks' priorities are quite normalized since we want to be
+  # able to "cascade" callbacks in a clean way. Here are values your code should
+  # take into account :
+  # 
+  # >= 200::  logging & debugging callbacks. Those callbacks should not consume
+  #           elements.
+  # 100-199:: Where Helpers register their callbacks. The normal value is 100,
+  #           and Helpers shouldn't register something else unless there's a
+  #           very good reason to.
+  # < 100::   all those numbers are normally available for your application.
+  #           That's enough, don't you think ?
+  class CallbackList
+
+    # Create a new list of callbacks
+    def initialize
+      @list = []
+    end
+
+    ##
+    # Add a callback to the list
+    #
+    # List will be sorted afterwards
+    #
+    # prio:: [Integer] the callback's priority, the higher, the sooner.
+    # ref:: [String] the callback's reference
+    # block:: [Block] a block to execute
+    # return:: [Jabber::CallbackList] The list, for chaining
+    def add(prio = 0, ref = nil, proc = nil, &block)
+      block = proc if proc
+      @list.push(Callback::new(prio, ref, block))
+      @list.sort! { |a, b| b.priority <=> a.priority }
+      self
+    end
+
+    ##
+    # Delete a callback by reference
+    # ref:: [String] the reference of the callback to delete
+    # return:: [CallBackList] The list, for chaining
+    def delete(ref)
+      @list.delete_if { |item| item.ref == ref }
+      self
+    end
+
+    ##
+    # Number of elements in the list
+    # return:: [Integer] The number of elements
+    def length
+      @list.length
+    end
+
+    ##
+    # Process an element through all my callbacks. returns e.consumed?
+    # e:: [Object] The elements to pass to the callback. You can pass
+    # several, but of course, you block must know how to handle them.
+    # return:: [Boolean] true if the element has been consumed
+    def process(*e)
+      # If somebody adds a new callback the list will get modified
+      # and sorted(!) while still iterating through it. So we use a
+      # local copy of @list. Any freshly added callback will receive
+      # the next stanzas, not the current.
+      list = @list.dup
+
+      # process through callbacks
+      list.each do |item|
+        return true if item.block.call(*e) == true
+      end
+      false
+    end
+  end
+
+  # This class is used to store callbacks inside CallbackList. See the
+  # CallbackList class for more detailed explanations.
+  class Callback
+
+    # The Callback's priority
+    attr_reader :priority
+
+    # The Callback's reference, using for deleting purposes
+    attr_reader :ref
+
+    # The Callback's block to execute 
+    attr_reader :block
+
+    ##
+    # Create a new callback
+    # priority:: [Integer] the callback's priority. The higher, the sooner it
+    # will be executed
+    # ref:: [String] The callback's reference
+    def initialize(priority = 0, ref = nil, block = Proc::new {})
+      @priority = priority
+      @ref = ref
+      @block = block
+    end
+  end
+end

data/lib/xmpp4r/client.rb

@@ -23,9 +23,7 @@ module Jabber
     attr_reader :jid
 
     ##
-    # Create a new Client. If threaded mode is activated, callbacks are called
-    # as soon as messages are received; If it isn't, you have to call
-    # Stream#process from time to time.
+    # Create a new Client.
     #
     # Remember to *always* put a resource in your JID unless the server can do SASL.
     def initialize(jid, threaded = true)
@@ -137,8 +135,7 @@ module Jabber
       stop
       start
       # And wait for features - again
-      @features_lock.lock
-      @features_lock.unlock
+      @features_sem.wait
 
       # Resource binding (RFC3920 - 7)
       if @stream_features.has_key? 'bind'

data/lib/xmpp4r/command/helper/responder.rb

@@ -0,0 +1,53 @@
+module Jabber
+
+  module Command
+
+    ##
+    # The Responder Helper handles the low-level stuff of the
+    # Ad-hoc commands (JEP 0050).
+    class Responder
+
+      ##
+      # Initialize a Responder
+      def initialize(stream)
+        @stream = stream
+        @commandsdiscocbs = CallbackList.new
+        @commandexeccbs = CallbackList.new
+
+        stream.add_iq_callback(180, self) { |iq|
+          iq_callback(iq)
+        }
+      end
+
+      ##
+      # Add a callback for <query> stanzas asking for the list
+      # of ad-hoc commands
+      def add_commands_disco_callback(priority = 0, ref = nil, &block)
+        @commandsdiscocbs.add(priority, ref, block)
+      end
+
+      ##
+      # Add a callback for <command> stanzas asking for the execution
+      # of an ad-hoc command
+      def add_commands_exec_callback(priority = 0, ref = nil, &block)
+        @commandexeccbs.add(priority, ref, block)
+      end
+
+      ##
+      # Handles <iq> stanzas and execute callbacks
+      def iq_callback(iq)
+        if iq.type == :get
+          if iq.query.kind_of?(Jabber::Discovery::IqQueryDiscoItems) &&
+             iq.query.node == "http://jabber.org/protocol/commands"
+            @commandsdiscocbs.process(iq)
+          end
+        elsif iq.type == :set && iq.command
+          @commandexeccbs.process(iq)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/xmpp4r/command/iq/command.rb

@@ -0,0 +1,154 @@
+require 'xmpp4r/iq'
+
+module Jabber
+  
+  module Command
+
+    ##
+    # Class for handling ad-hoc commands
+    # (JEP 0050)
+    #
+    # A command is uniquely identified by its node attribute.
+    class IqCommand < Iq
+      name_xmlns 'command', 'http://jabber.org/protocol/commands'
+
+      def initialize(node=nil, action=nil)
+        super()
+        set_node(node)
+        set_action(action)
+      end
+
+      ##
+      # Get the node of the Command stanza
+      # result:: [String] or nil
+      def node
+        attributes['node']
+      end
+
+      ##
+      # Set the node of the Command stanza
+      # v:: [String] or nil
+      def node=(v)
+        attributes['node'] = v
+      end
+
+      ##
+      # Set the node of the Command stanza (chaining-friendly)
+      # v:: [String] or nil
+      def set_node(v)
+        self.node = v
+        self
+      end
+
+      ##
+      # Get the sessionid of the Command stanza
+      # result:: [String] or nil
+      def sessionid
+        attributes['sessionid']
+      end
+
+      ##
+      # Set the sessionid of the Command stanza
+      # v:: [String] or nil
+      def sessionid=(v)
+        attributes['sessionid'] = v
+      end
+
+      ##
+      # Set the sessionid of the Command stanza (chaining-friendly)
+      # v:: [String] or nil
+      def set_sessionid(v)
+        self.sessionid = v
+        self
+      end
+
+      ##
+      # Get the action of the Command stanza
+      #
+      # The following Symbols are allowed:
+      # * :execute
+      # * :cancel
+      # * :prev
+      # * :next
+      # * :complete
+      # return:: [Symbol] or nil
+      def action
+        case attributes['action']
+          when 'execute' then :execute
+          when 'cancel' then :cancel
+          when 'prev' then :prev
+          when 'next' then :next
+          when 'complete' then :complete
+          else nil
+        end
+      end
+
+      ##
+      # Set the action of the Command stanza (see IqCommand#action for details)
+      # v:: [Symbol] or nil
+      def action=(v)
+        attributes['action'] = case v
+          when :execute then 'execute'
+          when :cancel then 'cancel'
+          when :prev then 'prev'
+          when :next then 'next'
+          when :complete then 'complete'
+          else nil
+        end
+      end
+
+      ##
+      # Set the action of the Command stanza (chaining-friendly)
+      # v:: [Symbol] or nil
+      def set_action(v)
+        self.action = v
+        self
+      end
+
+      ##
+      # Get the status of the Command stanza
+      #
+      # The following Symbols are allowed:
+      # * :executing
+      # * :completed
+      # * :canceled
+      # return:: [Symbol] or nil
+      def status
+        case attributes['status']
+          when 'executing' then :executing
+          when 'completed' then :completed
+          when 'canceled' then :canceled
+          else nil
+        end
+      end
+
+      ##
+      # Set the status of the Command stanza (see IqCommand#status for details)
+      # v:: [Symbol] or nil
+      def status=(v)
+        attributes['status'] = case v
+          when :executing then 'executing'
+          when :completed then 'completed'
+          when :canceled then 'canceled'
+          else nil
+        end
+      end
+
+      ##
+      # Set the status of the Command stanza (chaining-friendly)
+      # v:: [Symbol] or nil
+      def set_status(v)
+        self.status = v
+        self
+      end
+
+      ##
+      # Get the actions allowed
+      # return:: [REXML::Element] or nil
+      def actions
+        first_element('actions')
+      end
+
+    end
+  end
+end