ln-xmpp4r 0.5

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

data/lib/xmpp4r/framework/bot.rb

@@ -0,0 +1,148 @@
+require 'xmpp4r/framework/base'
+
+require 'xmpp4r'
+require 'xmpp4r/roster'
+require 'xmpp4r/caps/c'
+require 'xmpp4r/discovery'
+require 'xmpp4r/xhtml'
+
+module Jabber
+  module Framework
+    ##
+    # Abstract handler methods that *may* be implemented by a deriving class:
+    # * on_message(text)
+    # * on_message_xhtml(html_body, text)
+    class Bot < Base
+      helper :roster, Roster::Helper
+      helper(:disco_default) { |cl|
+        Discovery::Responder.new(cl,
+                                 nil,
+                                 [Jabber::Discovery::Identity.new('client', 'XMPP4R Bot', 'bot')]
+                                 )
+      }
+      helper(:disco_caps) { |cl|
+        Discovery::Responder.new(cl,
+                                 "http://home.gna.org/xmpp4r/#{Jabber::XMPP4R_VERSION}",
+                                 [Jabber::Discovery::Identity.new('client', 'XMPP4R Bot', 'bot')]
+                                 )
+      }
+
+      def initialize(jid, password)
+        cl = Jabber::Client.new(jid)
+        cl.connect
+        cl.auth(password)
+
+        super(cl)
+
+        roster.add_subscription_request_callback do |item,presence|
+          if accept_subscription_from?(presence.from.strip)
+            roster.accept_subscription(presence.from.strip)
+          else
+            roster.decline_subscription(presence.from.strip)
+          end
+        end
+
+        @pep_notifications = []
+        cl.add_message_callback do |msg|
+          if msg.type != :error and msg.body
+            if (html = msg.first_element('html')) and respond_to? :on_message_xhtml
+              on_message_xhtml(html.body, msg.body)
+            elsif respond_to? :on_message
+              on_message(msg.body)
+            end
+          elsif msg.type != :error and (event = msg.first_element('event'))
+            event.each_element('items') do |items|
+              node = items.attributes['node']
+              items.each_element('item') do |item|
+                @pep_notifications.each { |notification_node,callback|
+                  if node == notification_node
+                    callback.call(msg.from, item)
+                  end
+                }
+              end
+            end
+          else
+            false
+          end
+        end
+
+        add_cap('presence')
+        add_cap(Caps::NS_CAPS)
+        add_cap('message') if respond_to? :on_message
+        add_cap(XHTML::NS_XHTML_IM) if respond_to? :on_message_xhtml
+
+        @presence_show = nil
+        @presence_status = nil
+      end
+
+      ##
+      # Add feature namespace to Capabilities Discovery
+      def add_cap(capability)
+        disco_default.add_feature(capability)
+        disco_caps.add_feature(capability)
+      end
+
+      ##
+      # Front-end for Roster::Helper#add_subscription_request_callback
+      #
+      # Can be overwritten, must return true or false
+      def accept_subscription_from?(jid)
+        true
+      end
+
+      ##
+      # Send a simple text chat message
+      def send_message(to, text)
+        msg = Message.new
+        msg.type = :chat
+        msg.to = to
+        msg.body = text
+        @stream.send(msg)
+      end
+
+      ##
+      # Send an XHTML chat message
+      # text:: [String] alternate plain text body, generated from xhtml_contents if nil
+      def send_message_xhtml(to, xhtml_contents, text=nil)
+        msg = Message.new
+        msg.type = :chat
+        msg.to = to
+        html = msg.add(XHTML::HTML.new(xhtml_contents))
+        msg.body = text ? text : html.to_text
+        @stream.send(msg)
+      end
+
+      ##
+      # Set and send a Presence
+      def set_presence(show=nil, status=nil)
+        @presence_show = show
+        @presence_status = status
+        send_presence
+      end
+
+      private
+
+      def send_presence
+        roster.wait_for_roster
+
+        # TODO: vcard photo hash
+        if @presence_show == :unavailable
+          presence = Presence.new(nil, @presence_status)
+          presence.type = :unavailable
+        else
+          presence = Presence.new(@presence_show, @presence_status)
+        end
+        presence.add(disco_caps.generate_caps)
+        @stream.send(presence)
+      end
+
+      public
+
+      def add_pep_notification(node, &callback)
+        add_cap("#{node}+notify")
+        @pep_notifications << [node, callback]
+      end
+    end
+
+  end
+end