xmpp4r 0.5 → 0.5.5

data/lib/xmpp4r/observable/observable_thing.rb

@@ -0,0 +1,191 @@
+# =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 was based on Observable module from Ruby.
+module ObservableThing
+  require 'xmpp4r/observable/thread_store'
+
+  # Adds an observer for some "thing".
+  #
+  # thing:: what will be observed.
+  # observer:: the observer.
+  # func:: the observer method that will be called (default: :update).
+  def add_observer(thing, observer, func = :update)
+    @things = {} unless defined? @things
+    @things[thing] = {} unless ! @things[thing].nil?
+    unless observer.respond_to? func
+      raise NoMethodError, "observer does not respond to `#{func.to_s}'"
+    end
+    @things[thing][observer] = func unless @things[thing].include?(observer)
+  end
+
+  # Deletes an observer for some "thing".
+  #
+  # thing:: what has been observed.
+  # observer:: the observer.
+  def delete_observer(thing, observer)
+    @things[thing].delete observer if defined? @things and ! @things[thing].nil?
+  end
+
+  # Delete observers for some "thing".
+  #
+  # thing:: what has been observed (if nil, deletes all observers).
+  def delete_observers(thing = nil)
+    if thing.nil?
+      @things.clear if defined? @things
+    else
+      @things[thing].clear if defined? @things and ! @things[thing].nil?
+    end
+  end
+
+  # Count the number of observers for some "thing".
+  #
+  # thing:: what has been observed (if nil, count all observers).
+  def count_observers(thing = nil)
+    return 0 if ! defined? @things
+    size = 0
+    if thing.nil?
+      @things.each { |thing, hash|
+        size += hash.size
+      }
+    else
+      size = @things[thing].size unless @things[thing].nil?
+    end
+    size
+  end
+
+  # Count the number of notifications for some "thing".
+  #
+  # thing:: what has been observed.
+  def count_notifications(thing)
+    return 0 if (! defined?(@things_counter)) or (! @things_counter.include?(thing))
+    @things_counter[thing]
+  end
+
+  # Change the state of some "thing".
+  #
+  # thing:: what will have the state changed.
+  # state:: the state (default = true).
+  def changed(thing, state = true)
+    @things_state = {} unless defined? @things_state
+    @things_state[thing] = state
+  end
+
+  # Check the state of some "thing".
+  #
+  # thing: what to have its state checked.
+  def changed?(thing)
+    if defined? @things_state and @things_state[thing]
+      true
+    else
+      false
+    end
+  end
+
+  # Notify all observers of "thing" about something. This will only be
+  # enforced if the state of that "thing" is true. Also, if the observer
+  # returns the Symbol :delete_me, it will be deleted after being notified.
+  #
+  # thing:: what has been observed.
+  # args:: notification to be sent to the observers of "thing".
+  def notify_observers(thing, *arg)
+    if changed?(thing)
+      if defined? @things and ! @things[thing].nil?
+        @things[thing].each { |observer, func|
+          increase_counter(thing)
+          @thread_store = ThreadStore.new if ! defined? @thread_store
+          @thread_store.add Thread.new {
+            if observer.send(func, thing, *arg) == :delete_me
+              delete_observer(thing, observer)
+            end
+          }
+        }
+      end
+      changed(thing, false)
+    end
+  end
+
+  # Is there pending notifications?
+  def pending_notifications?
+    return false if ! defined? @thread_store
+    @thread_store.size > 0
+  end
+
+  # Wait all notifications
+  def wait_notifications
+    sleep 1 while pending_notifications?
+  end
+
+  private
+  def increase_counter(thing)
+    @things_counter = {} unless defined? @things_counter
+    @things_counter[thing] = 0 unless @things_counter.include?(thing)
+    @things_counter[thing] += 1
+  end
+end
+
+# QObserver - simple observer-to-queue class
+class QObserver
+  require 'thread'
+
+  def initialize
+    @queues = Hash.new
+  end
+
+  def inspect
+    h = {}
+    @queues.each do |q, queue|
+      h[q] = queue.size
+    end
+    if h.length > 0
+      sprintf("#<%s:0x%x size=%s>", self.class.name, __id__, h.inspect)
+    else
+      sprintf("#<%s:0x%x>", self.class.name, __id__)
+    end
+  end  
+
+  # Return the queues we have registered
+  def queues
+    @queues.keys
+  end
+
+  # Received something in this queue?
+  #
+  # q:: queue
+  def received?(q)
+    @queues.include?(q) and ! @queues[q].empty?
+  end
+
+  # Get the contents of the queue in an array (or pass each item to the
+  # given block.
+  #
+  # q:: queue
+  def received(q)
+    return nil if ! @queues.include?(q)
+    if block_given?
+      yield @queues[q].deq while ! @queues[q].empty?
+    else
+      a = []
+      a << @queues[q].deq while ! @queues[q].empty?
+      return a
+    end
+  end
+
+  # Get the size of a given queue
+  #
+  # q:: queue
+  def size(q)
+    @queues[q].size rescue 0
+  end
+
+  # update method for our Observer
+  #
+  # thing:: what to be updated
+  def update(thing, *args)
+    @queues[thing] = Queue.new if ! @queues.include?(thing)
+    @queues[thing].enq args
+  end
+end

data/lib/xmpp4r/observable/pubsub.rb

@@ -0,0 +1,211 @@
+# =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/pubsub'
+require 'xmpp4r/pubsub/helper/servicehelper'
+require 'xmpp4r/pubsub/helper/nodebrowser'
+require 'xmpp4r/pubsub/helper/nodehelper'
+
+module Jabber
+class Observable
+  # Jabber::Observable::PubSub - Convenience subclass to deal with PubSub
+  class PubSub
+    class NoService < StandardError; end #:nodoc:
+
+    class AlreadySet < StandardError; end #:nodoc:
+
+    # Creates a new PubSub object
+    #
+    # observable:: points a Jabber::Observable object
+    def initialize(observable)
+      @observable = observable
+
+      @helper = @service_jid = nil
+      @disco = Jabber::Discovery::Helper.new(@observable.client)
+      attach!
+    end
+
+    def attach!
+      begin
+        domain = Jabber::JID.new(@observable.jid).domain
+        @service_jid = "pubsub." + domain
+        set_service(@service_jid)
+      rescue
+        @helper = @service_jid = nil
+      end
+      return has_service?
+    end
+
+    def inspect  #:nodoc:
+      if has_service?
+        sprintf("#<%s:0x%x @service_jid=%s>", self.class.name, __id__, @service_jid)
+      else
+        sprintf("#<%s:0x%x @has_service?=false>", self.class.name, __id__)
+      end
+    end
+
+    # Checks if the PubSub service is set
+    def has_service?
+      ! @helper.nil?
+    end
+
+    # Sets the PubSub service. Just one service is allowed. If nil, reset.
+    def set_service(service)
+      if service.nil?
+        @helper = @service_jid = nil
+      else
+        raise NotConnected, "You are not connected" if ! @observable.connected?
+        raise AlreadySet, "You already have a PubSub service (#{@service_jid})." if has_service?
+        @helper = Jabber::PubSub::ServiceHelper.new(@observable.client, service)
+        @service_jid = service
+
+        @helper.add_event_callback do |event|
+          @observable.changed(:event)
+          @observable.notify_observers(:event, event)
+        end
+      end
+    end
+
+    # Subscribe to a node.
+    def subscribe_to(node)
+      raise_noservice if ! has_service?
+      @helper.subscribe_to(node) unless is_subscribed_to?(node)
+    end
+
+    # Unsubscribe from a node.
+    def unsubscribe_from(node)
+      raise_noservice if ! has_service?
+      @helper.unsubscribe_from(node)
+    end
+
+    # Return the subscriptions we have in the configured PubSub service.
+    def subscriptions
+      raise_noservice if ! has_service?
+      @helper.get_subscriptions_from_all_nodes()
+    end
+
+    # Create a PubSub node (Lots of options still have to be encoded!)
+    def create_node(node)
+      raise_noservice if ! has_service?
+      begin
+        @helper.create_node(node)
+      rescue => e
+        raise e
+        return nil
+      end
+      @my_nodes << node if defined? @my_nodes
+      node
+    end
+
+    # Return an array of nodes I own
+    def my_nodes
+      if ! defined? @my_nodes
+        ret = []
+        subscriptions.each do |sub|
+           ret << sub.node if sub.attributes['affiliation'] == 'owner'
+        end
+        @my_nodes = ret
+      end
+      return @my_nodes
+    end
+
+    # Return true if a given node exists
+    def node_exists?(node)
+      ret = []
+      if ! defined? @existing_nodes or ! @existing_nodes.include?(node)
+        # We'll renew @existing_nodes if we haven't got it the first time
+        reply = @disco.get_items_for(@service_jid)
+        reply.items.each do |item|
+          ret << item.node
+        end
+        @existing_nodes = ret
+      end
+      return @existing_nodes.include?(node)
+    end
+
+    # Returns an array of nodes I am subscribed to
+    def subscribed_nodes
+      ret = []
+      subscriptions.each do |sub|
+        next if sub.node.nil?
+        ret << sub.node if sub.attributes['subscription'] == 'subscribed' and ! my_nodes.include?(sub.node)
+      end
+      return ret
+    end
+
+    # Return true if we're subscribed to that node
+    def is_subscribed_to?(node)
+      ret = false
+      subscriptions.each do |sub|
+        ret = true if sub.node == node and sub.attributes['subscription'] == 'subscribed'
+      end
+      return ret
+    end
+
+    # Delete a PubSub node (Lots of options still have to be encoded!)
+    def delete_node(node)
+      raise_noservice if ! has_service?
+      begin
+        @helper.delete_node(node)
+      rescue => e
+        raise e
+        return nil
+      end
+      @my_nodes.delete(node) if defined? @my_nodes
+      node
+    end
+
+    # Publish an Item. This infers an item of Jabber::PubSub::Item kind is passed
+    def publish_item(node, item)
+      raise_noservice if ! has_service?
+      @helper.publish_item_to(node, item)
+    end
+
+    # Publish Simple Item. This is an item with one element and some text to it.
+    def publish_simple_item(node, text)
+      raise_noservice if ! has_service?
+
+      item = Jabber::PubSub::Item.new
+      xml = REXML::Element.new('value')
+      xml.text = text
+      item.add(xml)
+      publish_item(node, item)
+    end
+
+    # Publish atom Item. This is an item with one atom entry with title, body and time.
+    def publish_atom_item(node, title, body, time = Time.now)
+      raise_noservice if ! has_service?
+
+      item = Jabber::PubSub::Item.new
+      entry = REXML::Element.new('entry')
+      entry.add_namespace("http://www.w3.org/2005/Atom")
+      mytitle = REXML::Element.new('title')
+      mytitle.text = title
+      entry.add(mytitle)
+      mybody = REXML::Element.new('body')
+      mybody.text = body
+      entry.add(mybody)
+      published = REXML::Element.new("published")
+      published.text = time.utc.iso8601
+      entry.add(published)
+      item.add(entry)
+      publish_item(node, item)
+    end
+
+    # Get items from a node
+    def get_items_from(node, count = nil)
+      raise_noservice if ! has_service?
+      @helper.get_items_from(node, count)
+    end
+
+    private
+
+    def raise_noservice #:nodoc:
+      raise NoService, "Have you forgot to call #set_service ?"
+    end
+  end # of class PubSub
+end # of class Observable
+end # of module Jabber

data/lib/xmpp4r/observable/subscription.rb

@@ -0,0 +1,57 @@
+# =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::Subscriptions - convenience class to deal with
+  # Presence subscriptions
+  #
+  # observable:: points to a Jabber::Observable object
+  class Subscriptions
+    def initialize(observable)
+      @observable = observable
+      @accept = true
+    end
+
+    # Ask the users specified by jids for authorization (i.e., ask them to add
+    # you to their contact list), unless already in the contact list.
+    #
+    # Because the authorization process depends on the other user accepting your
+    # request, results are notified to observers of :new_subscription.
+    def add(*jids)
+      @observable.contacts(*jids).each do |contact|
+        next if subscribed_to?(contact)
+        contact.ask_for_authorization!
+      end
+    end
+
+    # Remove the jabber users specified by jids from the contact list.
+    def remove(*jids)
+      @observable.contacts(*jids).each do |contact|
+        contact.unsubscribe!
+      end
+    end
+
+    # Returns true if this Jabber account is subscribed to status updates for
+    # the jabber user jid, false otherwise.
+    def subscribed_to?(jid)
+      @observable.contacts(jid).each do |contact|
+        return contact.subscribed?
+      end
+    end
+
+    # Returns true if auto-accept subscriptions is enabled (default), false otherwise.
+    def accept?
+      @accept
+    end
+
+    # Change whether or not subscriptions are automatically accepted.
+    def accept=(accept_status)
+      @accept = accept_status
+    end
+  end # of class Subscription
+end # of class Observable
+end # of module Jabber
+