gmcmillan-xmpp4r 0.5

data/lib/xmpp4r/entity_time.rb

@@ -0,0 +1,6 @@
+# =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/entity_time/iq'
+require 'xmpp4r/entity_time/responder'

data/lib/xmpp4r/entity_time/iq.rb

@@ -0,0 +1,45 @@
+# =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 'time'
+
+module Jabber::EntityTime
+  NS_TIME = 'urn:xmpp:time'
+
+  class IqTime < Jabber::IqQuery
+    name_xmlns 'time', NS_TIME
+
+    def initialize(time=nil)
+      super()
+      set_time(time)
+    end
+
+    def set_time(time=nil)
+      time ||= Time.now
+
+      tzo = self.add_element('tzo')
+      tzo.add_text(time_zone_offset(time))
+
+      utc = self.add_element('utc')
+      utc.add_text(utc_time(time))
+    end
+
+    private
+    def utc_time(time)
+      raise ArgumentError, 'invalid time object' unless time.respond_to?(:utc)
+      time.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+    end
+
+    def time_zone_offset(time)
+      raise ArgumentError, 'invalid time object' unless time.respond_to?(:utc_offset)
+
+      sec_offset = time.utc_offset
+      h_offset = sec_offset.to_i / 3600
+      m_offset = sec_offset.abs % 60
+
+      "%+03d:%02d"%[h_offset, m_offset]
+    end
+
+  end # /IqTime
+end # /Jabber::EntityTime

data/lib/xmpp4r/entity_time/responder.rb

@@ -0,0 +1,57 @@
+# =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/entity_time/iq'
+
+module Jabber::EntityTime
+  ##
+  # XEP 202 Entity Time implementation
+  #
+  # @see http://xmpp.org/extensions/xep-0202.html
+  #
+  # @example
+  # <iq type='get'
+  #     from='romeo@montague.net/orchard'
+  #     to='juliet@capulet.com/balcony'
+  #     id='time_1'>
+  #   <time xmlns='urn:xmpp:time'/>
+  # </iq>
+  #
+  class Responder
+
+    CALLBACK_PRIORITY = 180
+
+    ##
+    # +to_s+ allows the responder to be added to another responder as a feature
+    def to_s
+      NS_TIME
+    end
+
+    def initialize(stream)
+      @stream = stream
+
+      stream.add_iq_callback(CALLBACK_PRIORITY, self) do |iq|
+        iq_callback(iq)
+      end
+    end # /initialize
+
+    def iq_callback(iq)
+      if iq.type == :get &&
+          iq.first_element('time') &&
+          iq.first_element('time').namespace === NS_TIME
+
+        answer = iq.answer(false)
+        answer.type = :result
+        answer.add(IqTime.new(Time.now))
+
+        @stream.send(answer)
+
+        return true
+      end
+
+      false
+    end
+
+  end # /Responder
+end # /Jabber::EntityTime

data/lib/xmpp4r/errors.rb

@@ -0,0 +1,284 @@
+# =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
+
+  # CUSTOM ERROR CLASSES
+
+  # All of our custom errors are superclassed by JabberError < StandardError
+  class JabberError < StandardError; end
+
+  # A client-side only argument error
+  class ArgumentError < JabberError; end
+
+  # Server disconnected us
+  class ServerDisconnected < JabberError; end
+  
+  ##
+  # An error returned from the server
+  #
+  # e.g. This exception can be raised by helpers when they
+  # receive a server reply with <tt>type='error'</tt>
+  #
+  # The ServerError carries a Jabber::ErrorResponse element
+  #
+  class ServerError < JabberError #:nodoc:
+
+    ##
+    # The error element which caused this exception
+    attr_reader :error
+
+    ##
+    # Initialize a ServerError by passing an ErrorResponse instance
+    # error:: [Error]
+    def initialize(error)
+      @error = error
+    end
+
+    ##
+    # Sample output:
+    # 'subscription-required: Please subscribe first'
+    def to_s
+      "#{@error.error}: #{@error.text}"
+    end
+  end
+
+  class ClientAuthenticationFailure < JabberError; end
+
+  class ComponentAuthenticationFailure < JabberError; end
+
+  class NoNameXmlnsRegistered < JabberError
+    def initialize(klass)
+      super "Class #{klass} has not set name and xmlns"
+    end
+  end
+
+  class SOCKS5Error < JabberError; end
+
+  class InvalidChatState < JabberError; end
+
+  ##
+  # A class used to build/parse <error/> elements.
+  # Look at XEP-0086 for explanation:
+  # http://www.xmpp.org/extensions/xep-0086.html
+  #
+  # FIXME : XEP-0086 is officially deprecated.  What effect does that have on this class? Any?
+  #
+  class ErrorResponse < XMPPElement
+    name_xmlns 'error'
+
+    ##
+    # errorcondition:: [nil] or [String] of the following:
+    # * "bad-request"
+    # * "conflict"
+    # * "feature-not-implemented"
+    # * "forbidden"
+    # * "gone"
+    # * "internal-server-error"
+    # * "item-not-found"
+    # * "jid-malformed"
+    # * "not-acceptable"
+    # * "not-allowed"
+    # * "not-authorized"
+    # * "payment-required"
+    # * "recipient-unavailable"
+    # * "redirect"
+    # * "registration-required"
+    # * "remote-server-not-found"
+    # * "remote-server-timeout"
+    # * "resource-constraint"
+    # * "service-unavailable"
+    # * "subscription-required"
+    # * "undefined-condition"
+    # * "unexpected-request"
+    # Will raise an [Exception] if not [nil] and none of the above
+    #
+    # Also sets type and code to appropriate values according to errorcondition
+    #
+    # text: [nil] or [String] ErrorResponse text
+    def initialize(errorcondition=nil, text=nil)
+      if errorcondition.nil?
+        super()
+        set_text(text) unless text.nil?
+      else
+        errortype = nil
+        errorcode = nil
+        @@Errors.each { |cond,type,code|
+          if errorcondition == cond
+            errortype = type
+            errorcode = code
+          end
+        }
+
+        if errortype.nil? || errorcode.nil?
+          raise ArgumentError, "Unknown error condition when initializing ErrorReponse"
+        end
+
+        super()
+        set_error(errorcondition)
+        set_type(errortype)
+        set_code(errorcode)
+        set_text(text) unless text.nil?
+      end
+    end
+
+    ##
+    # Get the 'Legacy error code' or nil
+    # result:: [Integer] Error code
+    def code
+      if attributes['code']
+        attributes['code'].to_i
+      else
+        nil
+      end
+    end
+
+    ##
+    # Set the 'Legacy error code' or nil
+    # i:: [Integer] Error code
+    def code=(i)
+      if i.nil?
+        attributes['code'] = nil
+      else
+        attributes['code'] = i.to_s
+      end
+    end
+
+    ##
+    # Set the 'Legacy error code' (chaining-friendly)
+    def set_code(i)
+      self.code = i
+      self
+    end
+
+    ##
+    # Get the 'XMPP error condition'
+    #
+    # This can be anything that possess the specific namespace,
+    # checks don't apply here
+    def error
+      name = nil
+      each_element { |e| name = e.name if (e.namespace == 'urn:ietf:params:xml:ns:xmpp-stanzas') && (e.name != 'text') }
+      name
+    end
+
+    ##
+    # Set the 'XMPP error condition'
+    #
+    # One previous element with that namespace will be deleted before
+    #
+    # s:: [String] Name of the element to be added,
+    # namespace will be added automatically, checks don't apply here
+    def error=(s)
+      xe = nil
+      each_element { |e| xe = e if (e.namespace == 'urn:ietf:params:xml:ns:xmpp-stanzas') && (e.name != 'text') }
+      unless xe.nil?
+        delete_element(xe)
+      end
+
+      add_element(s).add_namespace('urn:ietf:params:xml:ns:xmpp-stanzas')
+    end
+
+    ##
+    # Set the 'XMPP error condition' (chaining-friendly)
+    def set_error(s)
+      self.error = s
+      self
+    end
+
+    ##
+    # Get the errors <text/> element text
+    # result:: [String] or nil
+    def text
+      first_element_text('text') || super
+    end
+
+    ##
+    # Set the errors <text/> element text
+    # (Previous <text/> elements will be deleted first)
+    # s:: [String] <text/> content or [nil] if no <text/> element
+    def text=(s)
+      delete_elements('text')
+
+      unless s.nil?
+        e = add_element('text')
+        e.add_namespace('urn:ietf:params:xml:ns:xmpp-stanzas')
+        e.text = s
+      end
+    end
+
+    ##
+    # Set the errors <text/> element text (chaining-friendly)
+    def set_text(s)
+      self.text = s
+      self
+    end
+
+    ##
+    # Get the type of error
+    # (meaning how to proceed)
+    # result:: [Symbol] or [nil] as following:
+    # * :auth
+    # * :cancel
+    # * :continue
+    # * :modify
+    # * :wait
+    def type
+      case attributes['type']
+        when 'auth' then :auth
+        when 'cancel' then :cancel
+        when 'continue' then :continue
+        when 'modify' then :modify
+        when 'wait' then :wait
+        else nil
+      end
+    end
+
+    ##
+    # Set the type of error (see ErrorResponse#type)
+    def type=(t)
+      case t
+        when :auth then attributes['type'] = 'auth'
+        when :cancel then attributes['type'] = 'cancel'
+        when :continue then attributes['type'] = 'continue'
+        when :modify then attributes['type'] = 'modify'
+        when :wait then attributes['type'] = 'wait'
+        else attributes['type'] = nil
+      end
+    end
+
+    ##
+    # Set the type of error (chaining-friendly)
+    def set_type(t)
+      self.type = t
+      self
+    end
+
+    ##
+    # Possible XMPP error conditions, types and codes (XEP-0086)
+    @@Errors = [['bad-request', :modify, 400],
+                ['conflict', :cancel, 409],
+                ['feature-not-implemented', :cancel, 501],
+                ['forbidden', :auth, 403],
+                ['gone', :modify, 302],
+                ['internal-server-error', :wait, 500],
+                ['item-not-found', :cancel, 404],
+                ['jid-malformed', :modify, 400],
+                ['not-acceptable', :modify, 406],
+                ['not-allowed', :cancel, 405],
+                ['not-authorized', :auth, 401],
+                ['payment-required', :auth, 402],
+                ['recipient-unavailable', :wait, 404],
+                ['redirect', :modify, 302],
+                ['registration-required', :auth, 407],
+                ['remote-server-not-found', :cancel, 404],
+                ['remote-server-timeout', :wait, 504],
+                ['resource-constraint', :wait, 500],
+                ['service-unavailable', :cancel, 503],
+                ['subscription-required', :auth, 407],
+                ['undefined-condition', nil, 500],
+                ['unexpected-request', :wait, 400]]
+  end
+
+end

data/lib/xmpp4r/feature_negotiation.rb

@@ -0,0 +1,5 @@
+# =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/feature_negotiation/iq/feature.rb'

data/lib/xmpp4r/feature_negotiation/iq/feature.rb

@@ -0,0 +1,28 @@
+# =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/iq'
+require 'xmpp4r/dataforms/x/data'
+
+module Jabber
+  module FeatureNegotiation
+    ##
+    # Feature negotiation,
+    # can appear as direct child to Iq
+    # or as child of IqSi
+    class IqFeature < XMPPElement
+      name_xmlns 'feature', 'http://jabber.org/protocol/feature-neg'
+
+      ##
+      # First <x/> child with xmlns='jabber:x:data'
+      def x
+        res = nil
+        each_element('x') { |e|
+          res = e if e.namespace == 'jabber:x:data'
+        }
+        res
+      end
+    end
+  end
+end

data/lib/xmpp4r/framework/base.rb

@@ -0,0 +1,55 @@
+require 'thread'
+
+module Jabber
+  module Framework
+    class Base
+
+      def self.helper(name, klass=nil, &factory)
+        if klass.nil? and factory.nil?
+          raise "helper #{name} needs a class or factory"
+        end
+
+        define_method(name) do
+          @helpers_lock.synchronize do
+            if @helpers[name]
+              @helpers[name]
+            else
+              if factory
+                @helpers[name] = instance_eval { factory.call(@stream) }
+              elsif klass
+                @helpers[name] = klass.new(@stream)
+              else
+                raise
+                end
+            end
+          end
+        end
+      end
+
+      attr_accessor :stream
+
+      def initialize(stream)
+        @stream = stream
+        @helpers = {}
+        @helpers_lock = Mutex.new
+
+        # Catch all unhandled iq stanzas (lowest priority)
+        @stream.add_iq_callback(-1000, self, &method(:on_unhandled_iq))
+      end
+
+      def on_unhandled_iq(iq)
+        if iq.type == :get or iq.type == :set
+          answer = iq.answer(true)
+          answer.type = :error
+          answer.add(ErrorResponse.new('feature-not-implemented'))
+          @stream.send(answer)
+
+          true
+        else
+          false
+        end
+      end
+
+    end
+  end
+end