xmpp4r 0.5 → 0.5.5

data/lib/xmpp4r/observable/thread_store.rb

@@ -0,0 +1,65 @@
+# =XMPP4R - XMPP Library for Ruby
+#
+# This file's copyright (c) 2009 by Pablo Lorenzzoni <pablo@propus.com.br>
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+#
+# Class ThreadStore
+class ThreadStore
+  attr_reader :cycles, :max
+
+  # Create a new ThreadStore.
+  #
+  # max:: max number of threads to store (when exhausted, older threads will
+  # just be killed and discarded). Default is 100. If 0 or negative no
+  # threads will be discarded until #keep is called.
+  def initialize(max = 100)
+    @store  = []
+    @max    = max > 0 ? max : 0
+    @cycles = 0
+    @killer_thread = Thread.new do
+      loop do
+        sleep 2 while @store.empty?
+        sleep 1
+        @store.each_with_index do |thread, i|
+          th = @store.delete_at(i) if thread.nil? or ! thread.alive?
+          th = nil
+        end
+        @cycles += 1
+      end
+    end
+  end
+
+  def inspect # :nodoc:
+    sprintf("#<%s:0x%x @max=%d, @size=%d @cycles=%d>", self.class.name, __id__, @max, size, @cycles)
+  end
+
+  # Add a new thread to the ThreadStore
+  def add(thread)
+    if thread.instance_of?(Thread) and thread.respond_to?(:alive?)
+      @store << thread
+      keep(@max) if @max > 0
+    end
+  end
+
+  # Keep only the number passed of threads
+  #
+  # n:: number of threads to keep (default to @max if @max > 0)
+  def keep(n = nil)
+    if n.nil?
+      raise ArgumentError, "You need to pass the number of threads to keep!" if @max == 0
+      n = @max
+    end
+    @store.shift.kill while @store.length > n
+  end
+
+  # Kill all threads
+  def kill!
+    @store.shift.kill while @store.length > 0
+  end
+
+  # How long is our ThreadStore
+  def size; @store.length; end
+
+end # of class ThreadStore
+

data/lib/xmpp4r/pubsub/children/unsubscribe.rb

@@ -10,10 +10,11 @@ module Jabber
     # Unsubscribe
     class Unsubscribe < XMPPElement
       name_xmlns 'unsubscribe'
-      def initialize(myjid=nil,mynode=nil)
+      def initialize(myjid=nil,mynode=nil,mysubid=nil)
         super()
         jid = myjid
         node =  mynode
+        subid = mysubid
       end
 
       ##
@@ -43,6 +44,20 @@ module Jabber
       def node=(mynode)
         attributes['node'] = mynode
       end
+
+      ##
+      # shows the subid
+      # return:: [String]
+      def subid
+        attributes['subid']
+      end
+
+      ##
+      # sets the subid
+      # =:: [String]
+      def subid=(mysubid)
+        attributes['subid'] = mysubid
+      end
     end
   end
 end

data/lib/xmpp4r/pubsub/helper/servicehelper.rb

@@ -85,6 +85,20 @@ module Jabber
 
         res
       end
+
+      ##
+      # get subids for a passed node
+      # return:: [Array] of subids
+      def get_subids_for(node)
+        ret = []
+        get_subscriptions_from_all_nodes.each do |subscription|
+          if subscription.node == node
+            ret << subscription.subid
+          end
+        end
+        return ret
+      end
+
       ##
       # subscribe to a node
       # node:: [String]
@@ -113,15 +127,26 @@ module Jabber
       # subid:: [String] or nil (not supported)
       # return:: true
       def unsubscribe_from(node, subid=nil)
-        iq = basic_pubsub_query(:set)
-        unsub = PubSub::Unsubscribe.new
-        unsub.node = node
-        unsub.jid = @stream.jid.strip
-        iq.pubsub.add(unsub)
-        ret = false
-        @stream.send_with_id(iq) { |reply|
-          ret = reply.kind_of?(Jabber::Iq) and reply.type == :result
-        } # @stream.send_with_id(iq)
+        ret = []
+        if subid.nil?
+          subids = get_subids_for(node)
+        else
+          subids = [ subid ]
+        end
+        subids << nil if subids.empty?
+        subids.each do |sid|
+          iq = basic_pubsub_query(:set)
+          unsub = PubSub::Unsubscribe.new
+          unsub.node = node
+          unsub.jid = @stream.jid.strip
+          unsub.subid = sid
+          iq.pubsub.add(unsub)
+          res = false
+          @stream.send_with_id(iq) { |reply|
+            res = reply.kind_of?(Jabber::Iq) and reply.type == :result
+          } # @stream.send_with_id(iq)
+          ret << res
+        end
         ret
       end
 
@@ -129,11 +154,21 @@ module Jabber
       # gets all items from a pubsub node
       # node:: [String]
       # count:: [Fixnum]
+      # subid:: [String]
       # return:: [Hash] { id => [Jabber::PubSub::Item] }
-      def get_items_from(node, count=nil)
+      def get_items_from(node, count=nil, subid=nil)
+        if subid.nil?
+          # Hm... no subid passed. Let's see if we can provide one.
+          subids = get_subids_for(node)
+          if ! subids.empty?
+            # If more than one, sorry. We'll just respect the first.
+            subid = subids[0]
+          end
+        end
         iq = basic_pubsub_query(:get)
         items = Jabber::PubSub::Items.new
         items.max_items = count
+        items.subid = subid unless subid.nil?  # if subid is still nil, we haven't any... why bother?
         items.node = node
         iq.pubsub.add(items)
         res = nil
@@ -157,7 +192,7 @@ module Jabber
       # return:: true
       def publish_item_to(node,item)
         iq = basic_pubsub_query(:set)
-	      publish = iq.pubsub.add(REXML::Element.new('publish'))
+        publish = iq.pubsub.add(REXML::Element.new('publish'))
         publish.attributes['node'] = node
 
         if item.kind_of?(Jabber::PubSub::Item)
@@ -212,13 +247,12 @@ module Jabber
         @stream.send_with_id(iq)
       end
 
-
       ##
       # purges all items on a persistent node
       # node:: [String]
       # return:: true
       def purge_items_from(node)
-        iq = basic_pubsub_query(:set)
+        iq = basic_pubsub_query(:set, true)
         purge = REXML::Element.new('purge')
         purge.attributes['node'] = node
         iq.pubsub.add(purge)
@@ -354,7 +388,7 @@ module Jabber
             res = []
             if reply.pubsub.first_element('subscriptions').attributes['node'] == node
               reply.pubsub.first_element('subscriptions').each_element('subscription') { |subscription|
-    	        res << PubSub::Subscription.import(subscription)
+              res << PubSub::Subscription.import(subscription)
               }
             end
           end

data/lib/xmpp4r/rexmladdons.rb

@@ -25,10 +25,11 @@ module REXML
 
     ##
     # Replaces or adds a child element of name <tt>e</tt> with text <tt>t</tt>.
-    def replace_element_text(e, t)
-      el = first_element(e)
+    def replace_element_text(e, t, namespace = nil)
+      el = first_element(e, namespace)
       if el.nil?
         el = REXML::Element.new(e)
+        el.add_namespace(namespace)
         add_element(el)
       end
       if t
@@ -36,18 +37,42 @@ module REXML
       end
       self
     end
+    
+    ##
+    # Replaces or adds a child element of name <tt>e</tt> with content of <tt>t</tt>.
+    def replace_element_content(e, c, namespace = nil)
+      el = first_element(e, namespace)
+      if el.nil?
+        el = REXML::Element.new(e)
+        el.add_namespace(namespace)
+        add_element(el)
+      end
+      if c
+        el.children.each do |ch|
+          ch.remove
+        end
+        c.root.children.each do |ch|
+          el.add ch
+        end
+      end
+      self
+    end
 
     ##
     # Returns first element of name <tt>e</tt>
-    def first_element(e)
-      each_element(e) { |el| return el }
+    def first_element(e, namespace = nil)
+      if namespace
+        each_element_with_attribute("xmlns", namespace, 1, e) { |el| return el }
+      else
+        each_element(e) { |el| return el }
+      end
       return nil
     end
 
     ##
     # Returns text of first element of name <tt>e</tt>
-    def first_element_text(e)
-      el = first_element(e)
+    def first_element_text(e, namespace = nil)
+      el = first_element(e, namespace)
       if el
         return el.text
       else
@@ -55,6 +80,21 @@ module REXML
       end
     end
 
+    ##
+    # This method works like <tt>first_element_text</tt> except that it
+    # returns content of all children, not just the value of the first
+    # child text element.
+    #
+    # Returns content of first element of name <tt>e</tt>
+    def first_element_content(e, namespace = nil)
+      el = first_element(e, namespace)
+      if el
+        return el.children.join
+      else
+        return nil
+      end
+    end
+
     # This method does exactly the same thing as add(), but it can be
     # overriden by subclasses to provide on-the-fly object creations.
     # For example, if you import a REXML::Element of name 'plop', and you

data/lib/xmpp4r/roster/helper/roster.rb

@@ -229,9 +229,9 @@ module Jabber
             @presence_cbs.process(item, oldpres, pres)
           }
         else
-          oldpres = item.presence(pres.from).nil? ?
+          oldpres = item.presence_of(pres.from).nil? ?
             nil :
-            Presence.new.import(item.presence(pres.from))
+            Presence.new.import(item.presence_of(pres.from))
 
           item.add_presence(pres)
           @presence_cbs.process(item, oldpres, pres)
@@ -431,8 +431,8 @@ module Jabber
 
         ##
         # Get specific presence
-        # jid:: [JID] Full JID
-        def presence(jid)
+        # jid:: [JID] Full JID with resource
+        def presence_of(jid)
           @presences_lock.synchronize {
             @presences.each { |pres|
               return(pres) if pres.from == jid
@@ -441,15 +441,25 @@ module Jabber
           nil
         end
 
+        ##
+        # Get presence of highest-priority available resource of this person
+        #
+        # Returns <tt>nil</tt> if contact is offline
+        def presence
+          @presences_lock.synchronize {
+            @presences.select { |pres|
+              pres.type.nil?
+            }.max { |pres1, pres2| (pres1.priority || 0) <=> (pres2.priority || 0) }
+          }
+        end
+
         ##
         # Add presence and sort presences
         # (unless type is :unavailable or :error)
         #
         # This overwrites previous stanzas with the same destination
-        # JID to keep track of resources. Presence stanzas with
-        # <tt>type == :unavailable</tt> or <tt>type == :error</tt> will
-        # be deleted as this indicates that this resource has gone
-        # offline.
+        # JID to keep track of resources. Old presence stanzas with
+        # <tt>type == :unavailable</tt> will be deleted.
         #
         # If <tt>type == :error</tt> and the presence's origin has no
         # specific resource the contact is treated completely offline.
@@ -457,7 +467,7 @@ module Jabber
           @presences_lock.synchronize {
             # Delete old presences with the same JID
             @presences.delete_if do |pres|
-              pres.from == newpres.from or pres.from.resource.nil?
+              pres.from == newpres.from or pres.from.resource.nil? or pres.type == :unavailable
             end
 
             if newpres.type == :error and newpres.from.resource.nil?

data/lib/xmpp4r/sasl.rb

@@ -177,7 +177,7 @@ module Jabber
         response['nc'] = '00000001'
         response['qop'] = 'auth'
         response['digest-uri'] = "xmpp/#{@stream.jid.domain}"
-        response['response'] = response_value(@stream.jid.node, @stream.jid.domain, response['digest-uri'], password, @nonce, response['cnonce'], response['qop'], response['authzid'])
+        response['response'] = response_value(@stream.jid.node, response['realm'], response['digest-uri'], password, @nonce, response['cnonce'], response['qop'], response['authzid'])
         response.each { |key,value|
           unless %w(nc qop response charset).include? key
             response[key] = "\"#{value}\""

data/lib/xmpp4r/stream.rb

@@ -577,13 +577,13 @@ module Jabber
       # In some cases, we might lost count of some stanzas
       # (for example, if the handler raises an exception)
       # so we can't block forever.
-      while pr > 0 and n <= 1000
+      while pr > 0 and n <= 20
         @tbcbmutex.synchronize { pr = @processing }
         if pr > 0
           n += 1
           Jabber::debuglog("TRYING TO CLOSE, STILL PROCESSING #{pr} STANZAS")
           #puts("TRYING TO CLOSE, STILL PROCESSING #{pr} STANZAS")
-          Thread::pass
+          sleep 0.1
         end
       end
 

data/lib/xmpp4r/xmpp4r.rb

@@ -8,7 +8,7 @@ module Jabber
   # XMPP4R Version number.  This is the ONLY place where the version number
   # should be specified.  This constant is used to determine the version of
   # package tarballs and generated gems.
-  XMPP4R_VERSION = '0.5'
+  XMPP4R_VERSION = '0.5.5'
 end
 
 require 'xmpp4r/client'

data/test/bytestreams/tc_socks5bytestreams.rb

@@ -105,8 +105,8 @@ class SOCKS5BytestreamsTest < Test::Unit::TestCase
     target = Bytestreams::SOCKS5BytestreamsTarget.new(@server, '1', '1@a.com/1', '1@a.com/2')
 
     assert_nothing_raised do
-      Timeout::timeout(2) do
-        target.connect_timeout = 1
+      Timeout::timeout(1) do
+        target.connect_timeout = 0.5
         assert target.accept == false
       end
     end

data/test/entity_time/tc_responder.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r/entity_time/responder'
+include Jabber
+
+class EntityTime::ResponderTest < Test::Unit::TestCase
+  include ClientTester
+
+  def a_utc_time
+    Time.utc(2000,"jan",1,20,15,1) # xmlschema = "2000-01-01T20:15:01Z"
+  end
+
+  def test_entity_time_iq
+    el_time = EntityTime::IqTime.new(a_utc_time)
+
+    assert_equal('time', el_time.name, "element has wrong name")
+    assert_equal('urn:xmpp:time', el_time.namespace, "element has wrong namespace")
+
+    assert(el_time.elements["utc"], "element does not have a utc child")
+    assert_equal('2000-01-01T20:15:01Z', el_time.elements["utc"].text, "element/utc has the wrong text")
+
+    assert(el_time.elements["tzo"], "element does not have a tzo child")
+    assert_equal("+00:00", el_time.elements["tzo"].text, "element/tzo has the wrong time zone offset")
+  end
+
+=begin
+   http://xmpp.org/extensions/xep-0202.html
+   <iq type='get'
+       from='romeo@montague.net/orchard'
+       to='juliet@capulet.com/balcony'
+       id='time_1'>
+     <time xmlns='urn:xmpp:time'/>
+   </iq>
+=end
+  def test_query
+    EntityTime::Responder.new(@client)
+
+    iq = Iq.new(:get)
+    t = REXML::Element.new('time')
+    t.add_namespace('urn:xmpp:time')
+    iq.add_element(t)
+
+    reply = @server.send_with_id(iq)
+
+    assert_equal(:result, reply.type)
+    assert_equal('time', reply[0].name)
+    assert_equal('urn:xmpp:time', reply[0].namespace)
+
+    assert(reply[0].elements["utc"].has_text?, "element must have a utc time (actual time should be check here)")
+
+    tmp = Time.now
+    local_offset = Time.now.utc_offset
+    hour_offset = local_offset / 3600
+    min_offset = local_offset % 60
+    offset = "%+03d:%02d"%[hour_offset, min_offset]
+
+    assert_equal(offset, reply[0].elements["tzo"].text, "element should has an incorrect time zone offset")
+  end
+
+end