xmpp4r 0.3.1 → 0.3.2

data/lib/xmpp4r/streamparser.rb

@@ -10,7 +10,7 @@ module Jabber
 
   ##
   # The StreamParser uses REXML to parse the incoming XML stream
-  # of the Jabber protocol and fires XMLStanzas at the Connection
+  # of the Jabber protocol and fires XMPPStanza at the Connection
   # instance.
   #
   class StreamParser
@@ -21,7 +21,7 @@ module Jabber
     # Constructs a parser for the supplied stream (socket input)
     #
     # stream:: [IO] Socket input stream
-    # listener:: [Object.receive(XMLStanza)] The listener (usually a Jabber::Protocol::Connection instance)
+    # listener:: [Object.receive(XMPPStanza)] The listener (usually a Jabber::Protocol::Connection instance)
     #
     def initialize(stream, listener)
       @stream = stream

data/lib/xmpp4r/vcard/iq/vcard.rb

@@ -10,13 +10,15 @@ module Jabber
     # vCard container for User Information
     # (can be specified by users themselves, mostly kept on servers)
     # (JEP 0054)
-    class IqVcard < REXML::Element
+    class IqVcard < XMPPElement
+      name_xmlns 'vCard', 'vcard-temp'
+      force_xmlns true
+
       ##
       # Initialize a <vCard/> element
       # fields:: [Hash] Initialize with keys as XPath element names and values for element texts
       def initialize(fields=nil)
-        super("vCard")
-        add_namespace('vcard-temp')
+        super()
 
         unless fields.nil?
           fields.each { |name,value|
@@ -25,13 +27,6 @@ module Jabber
         end
       end
 
-      ##
-      # element:: [REXML::Element] to import
-      # result:: [IqVcard] with all attributes and children copied from element
-      def IqVcard.import(element)
-        IqVcard::new.import(element)
-      end
-
       ##
       # Get an elements/fields text
       #
@@ -95,8 +90,6 @@ module Jabber
         }
         res
       end
-
-      Iq.add_elementclass('vCard', IqVcard)
     end
   end
 end

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

@@ -2,7 +2,7 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 
-require 'callbacks'
+require 'xmpp4r/callbacks'
 require 'xmpp4r/version/iq/version'
 
 module Jabber
@@ -57,6 +57,7 @@ module Jabber
               answer.query.set_iname(name).set_version(version).set_os(os)
 
               @stream.send(answer)
+              true
             }
             @versioncbs.process(iq, replyblock)
           else

data/lib/xmpp4r/version/iq/version.rb

@@ -13,25 +13,15 @@ module Jabber
     # Notice that according to JEP 0092 only the <os/> element can be omitted,
     # <name/> (iname) and <version/> must be present
     class IqQueryVersion < IqQuery
+      name_xmlns 'query', 'jabber:iq:version'
+
       ##
       # Create a new <query xmlns='jabber:iq:version'/> element
-      def initialize(iname='', version='', os=nil)
+      def initialize(iname=nil, version=nil, os=nil)
         super()
-        add_namespace('jabber:iq:version')
-        set_iname(iname)
-        set_version(version)
-        set_os(os)
-      end
-
-      ##
-      # Import an element,
-      # deletes <name/>, <version/> and <os/> elements first
-      # xe:: [REXML::Element]
-      def import(xe)
-        delete_element('name')
-        delete_element('version')
-        delete_element('os')
-        super
+        set_iname(iname) if iname
+        set_version(version) if version
+        set_os(os) if os
       end
 
       ##
@@ -111,8 +101,6 @@ module Jabber
         self
       end
     end
-
-    IqQuery.add_namespaceclass('jabber:iq:version', IqQueryVersion)
   end
 end
 

data/lib/xmpp4r/x.rb

@@ -2,7 +2,7 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 
-require 'xmpp4r/rexmladdons'
+require 'xmpp4r/xmppelement'
 
 module Jabber
   ##
@@ -10,34 +10,28 @@ module Jabber
   #
   # These elements may occur as "attachments"
   # in [Message] and [Presence] stanzas
-  class X < REXML::Element
-    @@namespace_classes = {}
-
-    ##
-    # Initialize a <x/> element
-    #
-    # Does nothing more than setting the element's name to 'x'
-    def initialize
-      super("x")
-    end
+  class X < XMPPElement
+    name_xmlns 'x'
+    force_xmlns true
+  end
 
+  module XParent
     ##
-    # Create a new [X] from an XML-Element
-    # element:: [REXML::Element] to import, will be automatically converted if namespace appropriate
-    def X.import(element)
-      if @@namespace_classes.has_key?(element.namespace)
-        @@namespace_classes[element.namespace]::new.import(element)
-      else
-        X::new.import(element)
+    # Get the first <x/> element in this stanza, or nil if none found.
+    # wanted_xmlns:: [String] Optional, find the first <x/> element having this xmlns,
+    # wanted_xmlns can also be a derivate of XMPPElement from which the namespace will be taken
+    # result:: [REXML::Element] or nil
+    def x(wanted_xmlns=nil)
+      if wanted_xmlns.kind_of? Class and wanted_xmlns.ancestors.include? XMPPElement
+        wanted_xmlns = wanted_xmlns.new.namespace
       end
-    end
-
-    ##
-    # Add a class by namespace for automatic X conversion (see X.import)
-    # ns:: [String] Namespace (e.g. 'jabber:x:delay')
-    # xclass:: [X] x class derived from X
-    def X.add_namespaceclass(ns, xclass)
-      @@namespace_classes[ns] = xclass
+      
+        each_element('x') { |x|
+        if wanted_xmlns.nil? or wanted_xmlns == x.namespace
+          return x
+        end
+      }
+      nil
     end
   end
 end

data/lib/xmpp4r/xmpp4r.rb

@@ -8,7 +8,7 @@
 # a simple debug logging support.
 module Jabber
   # XMPP4R Version number
-  XMPP4R_VERSION = '0.3.1'
+  XMPP4R_VERSION = '0.3.2'
 end
 
 require 'xmpp4r/client'

data/lib/xmpp4r/xmppelement.rb

@@ -0,0 +1,152 @@
+# =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/
+
+require 'xmpp4r/rexmladdons'
+
+module Jabber
+  class NoNameXmlnsRegistered < RuntimeError
+    def initialize(klass)
+      super "Class #{klass} has not set name and xmlns"
+    end
+  end
+
+  ##
+  # This class represents an XML element and provides functionality
+  # for automatic casting of XML element classes according to their
+  # element name and namespace.
+  #
+  # Deriving classes must met these criteria:
+  # * The element name and namespace must be specified by calling
+  #   the name_xmlns class method
+  # * The class constructor must be callable with no mandatory parameter
+  class XMPPElement < REXML::Element
+    @@name_xmlns_classes = {}
+    @@force_xmlns = false
+
+    ##
+    # Specify XML element name and xmlns for a deriving class,
+    # this pair and the class will be added to a global pool
+    #
+    # If the namespace is nil the class is a "wildcard class"
+    # matching elements with any xmlns if no other class with
+    # that namespace was defined
+    def self.name_xmlns(name, xmlns=nil)
+      @@name_xmlns_classes[[name, xmlns]] = self
+    end
+
+    ##
+    # Set whether this element is always built with an xmlns attribute
+    def self.force_xmlns(force)
+      @@force_xmlns = force
+    end
+
+    ##
+    # Whether this element is always built with an xmlns attribute
+    def self.force_xmlns?
+      @@force_xmlns
+    end
+
+    ##
+    # Find the name and namespace for a given class.
+    # This class must have registered these two values
+    # by calling name_xmlns at definition time.
+    #
+    # Raises an exception if none was found
+    # klass:: [Class]
+    # result:: [String, String] name and namespace
+    def self.name_xmlns_for_class(klass)
+      klass.ancestors.each do |klass1|
+        @@name_xmlns_classes.each do |name_xmlns,k|
+          if klass1 == k
+            return name_xmlns
+          end
+        end
+      end
+
+      raise NoNameXmlnsRegistered.new(klass)
+    end
+
+    ##
+    # Find a class for given name and namespace
+    # name:: [String]
+    # xmlns:: [String]
+    # result:: A descendant of XMPPElement or REXML::Element
+    def self.class_for_name_xmlns(name, xmlns)
+      if @@name_xmlns_classes.has_key? [name, xmlns]
+        @@name_xmlns_classes[[name, xmlns]]
+      elsif @@name_xmlns_classes.has_key? [name, nil]
+        @@name_xmlns_classes[[name, nil]]
+      else
+        REXML::Element
+      end
+    end
+
+    ##
+    # Import another REXML::Element descendant to:
+    # * Either an element class that registered with
+    #   name and xmlns before
+    # * Or if none was found to the class itself
+    #   (you may call this class method on a deriving class)
+    def self.import(element)
+      klass = class_for_name_xmlns(element.name, element.namespace)
+      if klass != self and klass.ancestors.include?(self)
+        klass.new.import(element)
+      else
+        self.new.import(element)
+      end
+    end
+
+    ##
+    # Initialize this element, which will then be initialized
+    # with the name registered with name_xmlns.
+    def initialize(*arg)
+      if arg.empty?
+        name, xmlns = self.class::name_xmlns_for_class(self.class)
+        super(name)
+        if self.class::force_xmlns?
+          add_namespace(xmlns)
+        end
+      else
+        super
+      end
+    end
+
+    ##
+    # Add a child element which will be imported according to the
+    # child's name and xmlns
+    # element:: [REXML::Element] Child
+    # result:: [REXML::Element or descendant of XMPPElement] New child
+    def typed_add(element)
+      if element.kind_of? REXML::Element
+        element_ns = (element.namespace.to_s == '') ? namespace : element.namespace
+
+        klass = XMPPElement::class_for_name_xmlns(element.name, element_ns)
+        if klass != element.class
+          element = klass.import(element)
+        end
+      end
+
+      super(element)
+    end
+
+    def parent=(new_parent)
+      if parent and parent.namespace('') == namespace('') and attributes['xmlns'].nil?
+        add_namespace parent.namespace('')
+      end
+
+      super
+
+      if new_parent and new_parent.namespace('') == namespace('')
+        delete_namespace
+      end
+    end
+
+    def clone
+      cloned = self.class.new
+      cloned.add_attributes self.attributes.clone
+      cloned.context = @context
+      cloned
+    end
+  end
+end

data/lib/xmpp4r/{xmlstanza.rb → xmppstanza.rb}

@@ -2,18 +2,19 @@
 # License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
 # Website::http://home.gna.org/xmpp4r/
 
-require 'xmpp4r/jid'
+require 'xmpp4r/xmppelement'
 require 'xmpp4r/error'
+require 'xmpp4r/jid'
 
 module Jabber
   ##
   # root class of all Jabber XML elements
-  class XMLStanza < REXML::Element
+  class XMPPStanza < XMPPElement
     ##
     # Compose a response by doing the following:
-    # * Create a new XMLStanza of the same subclass
+    # * Create a new XMPPStanza of the same subclass
     #   with the same element-name
-    # * Import xmlstanza if import is true
+    # * Import xmppstanza if import is true
     # * Swap 'to' and 'from'
     # * Copy 'id'
     # * Does not take care about the type
@@ -23,33 +24,20 @@ module Jabber
     # another error on the other side, which could be leading to a
     # ping-pong effect quickly!
     #
-    # xmlstanza:: [XMLStanza] source
+    # xmppstanza:: [XMPPStanza] source
     # import:: [true or false] Copy attributes and children of source
-    # result:: [XMLStanza] answer stanza
-    def XMLStanza.answer(xmlstanza, import=true)
-      x = xmlstanza.class::new
+    # result:: [XMPPStanza] answer stanza
+    def XMPPStanza.answer(xmppstanza, import=true)
+      x = xmppstanza.class::new
       if import
-        x.import(xmlstanza)
+        x.import(xmppstanza)
       end
-      x.from = xmlstanza.to
-      x.to = xmlstanza.from
-      x.id = xmlstanza.id
+      x.from = xmppstanza.to
+      x.to = xmppstanza.from
+      x.id = xmppstanza.id
       x
     end
 
-    ##
-    # Add a sub-element
-    #
-    # Will be converted to [Error] if named "error"
-    # element:: [REXML::Element] to add
-    def typed_add(element)
-      if element.kind_of?(REXML::Element) && (element.name == 'error')
-        super(Error::import(element))
-      else
-        super(element)
-      end
-    end
-
     ##
     # Return the first <tt><error/></tt> child
     def error
@@ -57,11 +45,11 @@ module Jabber
     end
 
     ##
-    # Compose a response of this XMLStanza
-    # (see XMLStanza.answer)
-    # result:: [XMLStanza] New constructed stanza
+    # Compose a response of this XMPPStanza
+    # (see XMPPStanza.answer)
+    # result:: [XMPPStanza] New constructed stanza
     def answer(import=true)
-      XMLStanza.answer(self, import)
+      XMPPStanza.answer(self, import)
     end
 
     ##

data/setup.rb

@@ -1,3 +1,4 @@
+#!/usr/bin/env ruby
 #
 # setup.rb
 #

data/test/bytestreams/tc_ibb.rb

@@ -7,6 +7,7 @@ require File::dirname(__FILE__) + '/../lib/clienttester'
 
 require 'xmpp4r'
 require 'xmpp4r/bytestreams'
+require 'xmpp4r/semaphore'
 include Jabber
 
 class IBBTest < Test::Unit::TestCase
@@ -71,10 +72,9 @@ class IBBTest < Test::Unit::TestCase
   
   def test_ibb_pingpong
     ignored_stanzas = 0
-    wait = Mutex.new
-    wait.lock
-    @server.add_message_callback { ignored_stanzas += 1; wait.unlock }
-    @server.add_iq_callback { ignored_stanzas += 1; wait.unlock }
+    wait = Semaphore.new
+    @server.add_message_callback { ignored_stanzas += 1; wait.run }
+    @server.add_iq_callback { ignored_stanzas += 1; wait.run }
 
 
     target = Bytestreams::IBBTarget.new(@server, '1', nil, '1@a.com/1')
@@ -96,7 +96,7 @@ class IBBTest < Test::Unit::TestCase
     @client.send("<iq from='1@a.com/1' type='set'>
                     <close xmlns='http://jabber.org/protocol/ibb' sid='another session id'/>
                   </iq>")
-    wait.lock
+    wait.wait
     assert_equal(1, ignored_stanzas)
 
 
@@ -107,12 +107,12 @@ class IBBTest < Test::Unit::TestCase
     @client.send("<message from='1@a.com/1' type='error'>
                     <data xmlns='http://jabber.org/protocol/ibb' sid='another session id' seq='0'/>
                   </message>")
-    wait.lock
+    wait.wait
     assert_equal(2, ignored_stanzas)
     @client.send("<iq from='1@a.com/1' type='set'>
                     <close xmlns='http://jabber.org/protocol/ibb' sid='another session id'/>
                   </iq>")
-    wait.lock
+    wait.wait
     assert_equal(3, ignored_stanzas)
 
 
@@ -133,7 +133,7 @@ class IBBTest < Test::Unit::TestCase
 
     assert_equal(3, ignored_stanzas)
   end
-  
+
   def test_ibb_error
     target = Bytestreams::IBBTarget.new(@server, '1', nil, '1@a.com/1')
     initiator = Bytestreams::IBBInitiator.new(@client, '1', nil, '1@a.com/1')