xmpp4r 0.5 → 0.5.5

data/lib/xmpp4r/message.rb

@@ -100,6 +100,52 @@ module Jabber
       self
     end
 
+    ##
+    # Returns the message's xhtml body, or nil.
+    # This is the message's xhtml-text content.
+    def xhtml_body
+      html = first_element('html', 'http://jabber.org/protocol/xhtml-im')
+
+      if html
+        html.first_element_content('body', 'http://www.w3.org/1999/xhtml')
+      else
+        first_element_content('body', 'http://www.w3.org/1999/xhtml')
+      end
+    end
+
+    ##
+    # Sets the message's xhtml body
+    #
+    # b:: [String] xhtml body to set (Note: must be a valid xhtml)
+    def xhtml_body=(b)
+      begin
+        b = REXML::Document.new("<root>#{b}</root>")
+      rescue REXML::ParseException
+        raise ArgumentError, "Body is not a valid xhtml. Have you forgot to close some tag?"
+      end
+      
+      html = first_element('html', 'http://jabber.org/protocol/xhtml-im')
+      
+      if html
+        html.replace_element_content('body', b, 'http://www.w3.org/1999/xhtml')
+      else
+        el = REXML::Element.new('html')
+        el.add_namespace('http://jabber.org/protocol/xhtml-im')
+        el.replace_element_content('body', b, 'http://www.w3.org/1999/xhtml')
+        add_element(el)
+      end
+    end
+
+    ##
+    # Sets the message's xhtml body
+    #
+    # b:: [String] xhtml body to set (Note: must be a valid xhtml)
+    # return:: [REXML::Element] self for chaining
+    def set_xhtml_body(b)
+      self.xhtml_body = b
+      self
+    end
+
     ##
     # sets the message's subject
     #

data/lib/xmpp4r/muc/helper/mucclient.rb

@@ -68,8 +68,9 @@ module Jabber
       # fails.
       # jid:: [JID] room@component/nick
       # password:: [String] Optional password
+      # opts:: [Hash] If the parameter :history => false is passed then you will receive no history messages after initial presence
       # return:: [MUCClient] self (chain-able)
-      def join(jid, password=nil)
+      def join(jid, password=nil, opts={})
         if active?
           raise "MUCClient already active"
         end
@@ -83,6 +84,12 @@ module Jabber
         pres.from = @my_jid
         xmuc = XMUC.new
         xmuc.password = password
+
+        if !opts[:history]
+          history = REXML::Element.new( 'history').tap {|h| h.add_attribute('maxstanzas','0') }
+          xmuc.add_element history
+        end
+
         pres.add(xmuc)
 
         # We don't use Stream#send_with_id here as it's unknown

data/lib/xmpp4r/observable.rb

@@ -0,0 +1,9 @@
+# =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/
+
+require 'xmpp4r/observable/thread_store.rb'
+require 'xmpp4r/observable/observable_thing.rb'
+require 'xmpp4r/observable/helper.rb'

data/lib/xmpp4r/observable/contact.rb

@@ -0,0 +1,61 @@
+# =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/
+#
+module Jabber
+class Observable
+  # Jabber::Observable::Contact - Convenience subclass to deal with Contacts
+  class Contact
+
+    # Creates a new Jabber::Observable::Contact
+    #
+    # jid:: jid to be used
+    # observable:: observable to be used
+    def initialize(jid, observable)
+      @jid = jid.respond_to?(:resource) ? jid : JID.new(jid)
+      @observable = observable
+    end
+
+    # Returns the stripped version of the JID
+    def jid; @jid.strip; end
+
+    def inspect #:nodoc:
+      sprintf("#<%s:0x%x @jid=%s>", self.class.name, __id__, @jid.to_s)
+    end
+
+    # Are e subscribed?
+    def subscribed?
+      [:to, :both].include?(subscription)
+    end
+
+    # Get the subscription from the roster_item
+    def subscription
+      items = @observable.roster.items
+      return false unless items.include?(jid)
+      items[jid].subscription
+    end
+
+    # Send a request asking for authorization
+    def ask_for_authorization!
+      request!(:subscribe)
+    end
+
+    # Sends a request asking for unsubscription
+    def unsubscribe!
+      request!(:unsubscribe)
+    end
+
+    private
+
+    # Really send the request.
+    def request!(type)
+      request = Jabber::Presence.new.set_type(type)
+      request.to = jid
+      @observable.send!(request)
+    end
+
+  end # of class Contact
+end # of class Observable
+end # of module Jabber

data/lib/xmpp4r/observable/helper.rb

@@ -0,0 +1,389 @@
+# =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/
+#
+# This is the helper for xmpp4r/observable, and was based on XMPP4R-Observable
+# by Pablo Lorenzoni <pablo@propus.com.br>.
+require 'time'
+require 'xmpp4r'
+require 'xmpp4r/roster'
+require 'xmpp4r/observable/contact'
+require 'xmpp4r/observable/pubsub'
+require 'xmpp4r/observable/subscription'
+module Jabber
+
+class NotConnected < StandardError; end #:nodoc:
+
+# Jabber::Observable - Creates observable Jabber Clients
+class Observable
+
+  # This is what actually makes our object Observable.
+  include ObservableThing
+
+  attr_reader :subs, :pubsub, :jid, :auto
+
+  # Create a new Jabber::Observable client. You will be automatically connected
+  # to the Jabber server and your status message will be set to the string
+  # passed in as the status_message argument.
+  #
+  # jabber = Jabber::Observable.new("me@example.com", "password", nil, "Talk to me - Please!")
+  #
+  # jid:: your jid (either a string or a JID object)
+  # password:: your password
+  # status:: your status. Check Jabber::Observable#status for documentation
+  # status_message:: some funny string
+  # host:: the server host (if different from the one in the jid)
+  # port:: the server port (default: 5222)
+  def initialize(jid, password, status=nil, status_message="Available", host=nil, port=5222)
+
+    # Basic stuff
+    @jid = jid.respond_to?(:resource) ? jid : Jabber::JID.new(jid)
+    @password = password
+    @host = host
+    @port = port
+
+    # Message dealing
+    @delivered_messages = 0
+    @deferred_messages = Queue.new
+    start_deferred_delivery_thread
+
+    # Connection stuff
+    @connect_mutex = Mutex.new
+    @client = nil
+    @roster = nil
+    @disconnected = false
+
+    # Tell everybody I am here
+    status(status, status_message)
+
+    # Subscription Accessor
+    @subs = Jabber::Observable::Subscriptions.new(self)
+
+    # PubSub Accessor
+    @pubsub = Jabber::Observable::PubSub.new(self)
+
+    # Auto Observer placeholder
+    @auto = nil
+
+    # Our contacts Hash
+    @contacts = Hash.new
+  end
+
+  def inspect # :nodoc:
+    sprintf("#<%s:0x%x @jid=%s, @delivered_messages=%d, @deferred_messages=%d, @observer_count=%s, @notification_count=%s, @pubsub=%s>", self.class.name, __id__, @jid, @delivered_messages, @deferred_messages.length, observer_count.inspect, notification_count.inspect, @pubsub.inspect)
+  end
+
+  # Count the registered observers in each thing
+  def observer_count
+    h = {}
+    [ :message, :presence, :iq, :new_subscription, :subscription_request, :event ].each do |thing|
+      h[thing] = count_observers(thing)
+    end
+    h
+  end
+
+  # Count the notifications really sent for each thing
+  def notification_count
+    h = {}
+    [ :message, :presence, :iq, :new_subscription, :subscription_request, :event ].each do |thing|
+      h[thing] = count_notifications(thing)
+    end
+    h
+  end
+
+  # Attach an auto-observer based on QObserver
+  def attach_auto_observer
+    raise StandardError, "Already attached." unless @auto.nil?
+
+    @auto = QObserver.new
+    [ :message, :presence, :iq, :new_subscription, :subscription_request, :event ].each do |thing|
+      self.add_observer(thing, @auto)
+    end
+  end
+
+  # Dettach the auto-observer
+  def dettach_auto_observer
+    raise StandardError, "Not attached." if @auto.nil?
+
+    [ :message, :presence, :iq, :new_subscription, :subscription_request, :event ].each do |thing|
+      self.delete_observer(thing, @auto)
+    end
+    @auto = nil
+  end
+
+  # Send a message to jabber user jid.
+  #
+  # jid:: jid of the recipient
+  # message:: what is to be delivered (either a string or a Jabber::Message)
+  # type:: can be either one of:
+  #   * :normal: a normal message.
+  #   * :chat (default): a one-to-one chat message.
+  #   * :groupchat: a group-chat message.
+  #   * :headline: a "headline" message.
+  #   * :error: an error message.
+  #
+  # If the recipient is not in your contacts list, the message will be queued
+  # for later delivery, and the Contact will be automatically asked for
+  # authorization (see Jabber::Observable#add).
+  def deliver(jid, message, type=nil)
+    contacts(jid).each do |contact|
+      # Check if we're subscribed to contact
+      if @subs.subscribed_to?(contact)
+        # Yes! we are!
+        if message.instance_of?(Jabber::Message)
+          msg = message
+          msg.to = contact.jid
+          msg.type = type unless type.nil?   # Let's keep the Jabber::Message type unless passed
+        else
+          msg = Jabber::Message.new(contact.jid)
+          msg.body = message
+          msg.type = type.nil? ? :chat : type
+        end
+        @delivered_messages += 1
+        send!(msg)
+      else
+        # No... Let's add it and defer the delivery.
+        @subs.add(contact.jid)
+        deliver_deferred(contact.jid, message, type)
+      end
+    end
+  end
+
+  # Set your presence, with a message.
+  #
+  # presence:: any of these:
+  #   * nil: online.
+  #   * :chat: free for chat.
+  #   * :away: away from the computer.
+  #   * :dnd: do not disturb.
+  #   * :xa: extended away.
+  # message:: a string that you wish your contacts see when you change your presence.
+  def status(presence, message)
+    @status_message = message
+    @presence = presence
+    send!(Jabber::Presence.new(@presence, @status_message))
+  end
+
+  # Transform a passed list of contacts in one or more Jabber::Observable::Contact objects.
+  #
+  # contact:: one of more jids of contacts
+  def contacts(*contact)
+    ret = []
+    contact.each do |c|
+      jid = c.to_s
+      # Do we already have it?
+      if ! @contacts.include?(jid)
+        # Nope.
+        @contacts[jid] = c.instance_of?(Jabber::Observable::Contact) ? c : Jabber::Observable::Contact.new(c, self)
+      end
+      ret << @contacts[jid]
+    end
+    ret
+  end
+
+  # Returns true if the Jabber client is connected to the Jabber server,
+  # false otherwise.
+  def connected?
+    @client.respond_to?(:is_connected?) && @client.is_connected?
+  end
+
+  # Pass the underlying Roster helper.
+  def roster
+    return @roster unless @roster.nil?
+    @roster = Jabber::Roster::Helper.new(client)
+  end
+
+  # Pass the underlying Jabber client.
+  def client
+    connect! unless connected?
+    @client
+  end
+
+  # Send a Jabber stanza over-the-wire.
+  #
+  # msg:: the stanza to be sent.
+  def send!(msg)
+    retries = 0
+    max = 4
+    begin
+      retries += 1
+      client.send(msg)
+    rescue Errno::ECONNRESET => e
+      # Connection reset. Sleep progressively and retry until success or exhaustion.
+      sleep ((retries^2) * 60) + 30
+      disconnect
+      reconnect
+      retry unless retries > max
+      raise e
+    rescue Errno::EPIPE, IOError => e
+      # Some minor error. Sleep 2 seconds and retry until success or exhaustion.
+      sleep 2
+      disconnect
+      reconnect
+      retry unless retries > max
+      raise e
+    end
+  end
+
+  # Use this to force the client to reconnect after a disconnect.
+  def reconnect
+    @disconnected = false
+    connect!
+  end
+
+  # Use this to force the client to disconnect and not automatically
+  # reconnect.
+  def disconnect
+    disconnect!(false)
+  end
+
+  # Queue messages for delivery once a user has accepted our authorization
+  # request. Works in conjunction with the deferred delivery thread.
+  #
+  # You can use this method if you want to manually add friends and still
+  # have the message queued for later delivery.
+  def deliver_deferred(jid, message, type)
+    msg = {:to => jid, :message => message, :type => type, :time => Time.now}
+    @deferred_messages.enq msg
+  end
+
+  # Sets the maximum time to wait for a message to be delivered (in
+  # seconds). It will be removed of the queue afterwards.
+  def deferred_max_wait=(seconds)
+    @deferred_max_wait = seconds
+  end
+
+  # Get the maximum time to wait for a message to be delivered. Default: 600
+  # seconds (10 minutes).
+  def deferred_max_wait
+    @deferred_max_wait || 600
+  end
+
+  private
+
+  # Create the infrastructure for connection and do it.
+  #
+  # Note that we use a Mutex to prevent double connection attempts and will
+  # raise a SecurityError if that happens.
+  def connect!
+    raise RuntimeError, "Connections disabled - use Jabber::Observable::reconnect() to reconnect." if @disconnected
+    raise SecurityError, "Connection attempt while already trying to connect!" if @connect_mutex.locked?
+
+    @connect_mutex.synchronize do
+      # Assure we're not connected.
+      disconnect!(false) if connected?
+
+      # Connection
+      jid = Jabber::JID.new(@jid)
+      my_client = Jabber::Client.new(jid)
+      my_client.connect(@host, @port)
+      my_client.auth(@password)
+      @roster = nil
+      @client = my_client
+
+      # Post-connect
+      register_default_callbacks
+      status(@presence, @status_message)
+      if @pubsub.nil?
+        @pubsub = Jabber::Observable::PubSub.new(self)
+      else
+        @pubsub.attach!
+      end
+    end
+  end
+
+  # Really disconnect the client
+  #
+  # auto_reconnect:: Sets the flag for auto-reconnection
+  def disconnect!(auto_reconnect = true)
+    if connected?
+      client.close
+    end
+    @roster = nil
+    @client = nil
+    @pubsub.set_service(nil)
+    @disconnected = auto_reconnect
+  end
+
+  # This will register callbacks for every "thing" we made observable.
+  #
+  # The observable things we register here are :message, :presence, :iq,
+  # :new_subscription, and :subscription_request
+  #
+  # Note we can also observe :event, but that is dealt with in
+  # Jabber::Observable::PubSub
+  def register_default_callbacks
+
+    # The three basic "things": :message, :presence and :iq
+    # (note that :presence is based on roster)
+    client.add_message_callback do |message|
+      unless message.body.nil?
+        changed(:message)
+        notify_observers(:message, message)
+      end
+    end
+
+    roster.add_presence_callback do |roster_item, old_presence, new_presence|
+      simple_jid = roster_item.jid.strip.to_s
+      presence = case new_presence.type
+                 when nil then new_presence.show || :online
+                 when :unavailable then :unavailable
+                 else
+                   nil
+                 end
+
+      changed(:presence)
+      notify_observers(:presence, simple_jid, presence, new_presence)
+    end
+
+    client.add_iq_callback do |iq|
+      changed(:iq)
+      notify_observers(:iq, iq)
+    end
+
+    # We'll also expose roster's :new_subscription and :subscription_request
+    roster.add_subscription_callback do |roster_item, presence|
+      if presence.type == :subscribed
+        changed(:new_subscription)
+        notify_observers(:new_subscription, [roster_item, presence])
+      end
+    end
+
+    roster.add_subscription_request_callback do |roster_item, presence|
+      roster.accept_subscription(presence.from) if @subs.accept?
+      changed(:subscription_request)
+      notify_observers(:subscription_request, [roster_item, presence])
+    end
+  end
+
+  # Starts the deferred delivery thread
+  #
+  # This will monitor the @deferred_messages queue and try to deliver messages.
+  def start_deferred_delivery_thread
+    return if ! @deferred_delivery_thread.nil? and @deferred_delivery_thread.alive?
+
+    @deferred_delivery_thread = Thread.new do
+      loop do 
+        # Check the queue every 10 seconds. Effectivelly block if nothing is queued.
+        sleep 10 while @deferred_messages.empty?
+
+        # Hm... something has been queued
+        message = @deferred_messages.deq
+        if @subs.subscribed_to?(message[:to])
+          # Great! We're subscribed!
+          deliver(message[:to], message[:message], message[:type])
+        else
+          # Still not subscribed. Enqueue it again (unless deferred_max_wait was reached)
+          @deferred_messages.enq message unless Time.now > (deferred_max_wait + message[:time])
+        end
+
+        # Wait 5 seconds between every message still in the queue
+        sleep 5
+      end
+    end
+  end
+end # of class Observable
+end # of module Jabber
+