ln-xmpp4r 0.5

data/lib/xmpp4r/jid.rb

@@ -0,0 +1,167 @@
+# =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
+  ##
+  # The JID class represents a Jabber Identifier as described by
+  # RFC3920 section 3.1.
+  #
+  # Note that you can use JIDs also for Sorting, Hash keys, ...
+  class JID
+    include Comparable
+
+    PATTERN = /^(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?$/
+
+    begin
+      require 'idn'
+      USE_STRINGPREP = true
+    rescue LoadError
+      USE_STRINGPREP = false
+    end
+
+    ##
+    # Create a new JID. If called as new('a@b/c'), parse the string and
+    # split (node, domain, resource)
+    def initialize(node = "", domain = nil, resource = nil)
+      @resource = resource
+      @domain = domain
+      @node = node
+      if @domain.nil? and @resource.nil? and @node
+        @node, @domain, @resource = @node.to_s.scan(PATTERN).first
+      end
+
+      if USE_STRINGPREP
+        @node = IDN::Stringprep.nodeprep(@node) if @node
+        @domain = IDN::Stringprep.nameprep(@domain) if @domain
+        @resource = IDN::Stringprep.resourceprep(@resource) if @resource
+      else
+        @node.downcase! if @node
+        @domain.downcase! if @domain
+      end
+
+      raise ArgumentError, 'Node too long' if (@node || '').length > 1023
+      raise ArgumentError, 'Domain too long' if (@domain || '').length > 1023
+      raise ArgumentError, 'Resource too long' if (@resource || '').length > 1023
+    end
+
+    ##
+    # Returns a string representation of the JID
+    # * ""
+    # * "domain"
+    # * "node@domain"
+    # * "domain/resource"
+    # * "node@domain/resource"
+    def to_s
+      s = @domain
+      s = "#{@node}@#{s}" if @node
+      s += "/#{@resource}" if @resource
+      return s
+    end
+
+    ##
+    # Returns a new JID with resource removed.
+    # return:: [JID]
+    def strip
+      JID.new(@node, @domain)
+    end
+    alias_method :bare, :strip
+
+    ##
+    # Removes the resource (sets it to nil)
+    # return:: [JID] self
+    def strip!
+      @resource = nil
+      self
+    end
+    alias_method :bare!, :strip!
+
+    ##
+    # Returns a hash value of the String representation
+    # (see JID#to_s)
+    def hash
+      return to_s.hash
+    end
+
+    ##
+    # Ccompare to another JID
+    #
+    # String representations are compared, see JID#to_s
+    def eql?(o)
+      to_s.eql?(o.to_s)
+    end
+
+    ##
+    # Ccompare to another JID
+    #
+    # String representations are compared, see JID#to_s
+    def ==(o)
+      to_s == o.to_s
+    end
+
+    ##
+    # Compare two JIDs,
+    # helpful for sorting etc.
+    #
+    # String representations are compared, see JID#to_s
+    def <=>(o)
+      to_s <=> o.to_s
+    end
+
+    # Get the JID's node
+    def node
+      @node
+    end
+
+    # Set the JID's node
+    def node=(v)
+      @node = v.to_s
+      if USE_STRINGPREP
+        @node = IDN::Stringprep.nodeprep(@node) if @node
+      end
+    end
+
+    # Get the JID's domain
+    def domain
+      return nil if @domain.empty?
+      @domain
+    end
+
+    # Set the JID's domain
+    def domain=(v)
+      @domain = v.to_s
+      if USE_STRINGPREP
+        @domain = IDN::Stringprep.nodeprep(@domain)
+      end
+    end
+
+    # Get the JID's resource
+    def resource
+      @resource
+    end
+
+    # Set the JID's resource
+    def resource=(v)
+      @resource = v.to_s
+      if USE_STRINGPREP
+        @resource = IDN::Stringprep.nodeprep(@resource)
+      end
+    end
+
+    # Escape JID
+    def JID::escape(jid)
+      return jid.to_s.gsub('@', '%')
+    end
+
+    # Test if jid is empty
+    def empty?
+      to_s.empty?
+    end
+
+    # Test id jid is strepped
+    def stripped?
+      @resource.nil?
+    end
+    alias_method :bared?, :stripped?
+  end
+end

data/lib/xmpp4r/last.rb

@@ -0,0 +1,2 @@
+require 'xmpp4r/last/iq/last'
+require 'xmpp4r/last/helper/helper'

data/lib/xmpp4r/last/helper/helper.rb

@@ -0,0 +1,37 @@
+# =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'
+require 'xmpp4r/last'
+
+module Jabber
+  module LastActivity
+    ##
+    # A Helper to manage discovery of Last Activity.
+    class Helper
+      def initialize(client)
+        @stream = client
+      end
+
+      ##
+      # Gets the last activity from a JID.
+      # jid:: [JID]
+      # return:: [Jabber::LastActivity::IqQueryLastActivity]
+      def get_last_activity_from(jid)
+        iq = Jabber::Iq.new(:get, jid)
+        iq.from = @stream.jid
+        iq.add(Jabber::LastActivity::IqQueryLastActivity.new)
+
+        reply = @stream.send_with_id(iq)
+
+        if reply.query && reply.query.kind_of?(IqQueryLastActivity)
+          reply.query
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/xmpp4r/last/iq/last.rb

@@ -0,0 +1,67 @@
+# =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/query'
+
+module Jabber
+  module LastActivity
+    NS_LAST_ACTIVITY = 'jabber:iq:last'
+
+    ##
+    # Class for handling Last Activity queries
+    # (XEP-0012)
+    class IqQueryLastActivity < IqQuery
+      name_xmlns 'query', NS_LAST_ACTIVITY
+
+      ##
+      # Get the number of seconds since last activity.
+      #
+      # With a bare jid, this will return the number of seconds since the
+      # client was last seen (offline user query).
+      #
+      # With a full jid, this will return the number of seconds that the
+      # client has been idle (online user query).
+      #
+      # With a server, this will return the server or component's uptime in
+      # seconds (server / component query).
+      def seconds
+        attributes['seconds'] ? attributes['seconds'].to_i : nil
+      end
+
+      ##
+      # Set the number of seconds since last activity
+      def seconds=(val)
+        attributes['seconds'] = val.to_s
+      end
+
+      ##
+      # Set the number of seconds since last activity
+      # (chaining-friendly)
+      def set_second(val)
+        self.seconds = val
+        self
+      end
+
+      ##
+      # For an offline user query, get the last status.
+      def status
+        self.text
+      end
+
+      ##
+      # For an offline user query, set the last status.
+      def status=(val)
+        self.text = val
+      end
+
+      ##
+      # For an offline user query, set the last status.
+      # (chaining-friendly)
+      def set_status(val)
+        self.status = val
+        self
+      end
+    end
+  end
+end

data/lib/xmpp4r/location.rb

@@ -0,0 +1,2 @@
+require 'xmpp4r/location/location'
+require 'xmpp4r/location/helper/helper'

data/lib/xmpp4r/location/helper/helper.rb

@@ -0,0 +1,56 @@
+# =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'
+require 'xmpp4r/pubsub'
+require 'xmpp4r/location/location'
+
+module Jabber
+  module UserLocation
+    ##
+    # A Helper for XEP-0080 User Location
+    #
+    # Use this helper to send a user's location, or receive them from a
+    # specified jid. Described at http://www.xmpp.org/extensions/xep-0080.html
+    #
+    # For example:
+    # <pre>
+    # h = UserLocation::Helper( @client, 'radio1@hug.hellomatty.com' )
+    # h.add_userlocation_callback do |location|
+    #   puts "Now in: #{location.locality}"
+    # end
+    # </pre>
+    class Helper < PubSub::ServiceHelper
+      ##
+      # Send out the current location.
+      #
+      # location:: [Jabber::UserLocation::Location] current_location
+      def current_location(location)
+        item = Jabber::PubSub::Item.new()
+        item.add(location)
+
+        publish_item_to(NS_USERLOCATION, item)
+      end
+
+      ##
+      # Use this method to indicate that you wish to stop publishing
+      # a location.
+      def stop_publishing
+        current_location(Jabber::UserLocation::Location.new())
+      end
+
+      ##
+      # Add a callback that will be invoked when a location is received
+      # from the jid specified when you constructed the Helper.
+      def add_userlocation_callback(prio = 200, ref = nil, &block)
+        add_event_callback(prio, ref) do |event|
+          location = event.first_element('items/item/location')
+          if location
+            block.call(location)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xmpp4r/location/location.rb

@@ -0,0 +1,179 @@
+# =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'
+require 'xmpp4r/xmppelement'
+require 'rexml/element'
+
+module Jabber
+  module UserLocation
+    NS_USERLOCATION = 'http://jabber.org/protocol/geoloc'
+    ALLOWABLE_ATTRIBUTES = %w(accuracy alt area bearing building country
+      datum description floor lat locality lon postalcode region room
+      speed street text timestamp uri)
+
+    ##
+    # The <geoloc> XMPP element, as defined in XEP-0080 User Location
+    #
+    # See http://xmpp.org/extensions/xep-0080.html - this element
+    # encapsulates data about a user's current location. These are
+    # expressed as child elements such as <locality>, <lat>, etc.
+    # which are also managed by this class.
+    #
+    # If the element has no children then it indicates that the user
+    # has stopped publishing their location.
+    class Location < XMPPElement
+      name_xmlns 'geoloc', NS_USERLOCATION
+      force_xmlns true
+
+      ##
+      # Construct a new <location> element.
+      #
+      # Supply no arguments to make an empty element to indicate that
+      # location is no longer being published.
+      #
+      # attributes:: [Hash] location attributes
+      def initialize(attributes = {})
+        super()
+
+        # validate attributes
+        attributes = attributes.select do |k,v|
+          ALLOWABLE_ATTRIBUTES.include?(k) && !v.nil?
+        end
+
+        attributes.each do |k,v|
+          v = x.xmlschema if v.is_a?(Time)
+          add_element(REXML::Element.new(k)).text = v.to_s
+        end
+      end
+
+
+      ##
+      # Returns true if a location is currently being published, otherwise false.
+      def published?
+        (elements.size > 0)
+      end
+
+      ##
+      # Get the accuracy attribute of this location.
+      def accuracy
+        first_element('accuracy').text if first_element('accuracy')
+      end
+
+      ##
+      # Get the alt attribute of this location.
+      def alt
+        first_element('alt').text if first_element('alt')
+      end
+
+      ##
+      # Get the area attribute of this location.
+      def area
+        first_element('area').text if first_element('area')
+      end
+
+      ##
+      # Get the bearing attribute of this location.
+      def bearing
+        first_element('bearing').text if first_element('bearing')
+      end
+
+      ##
+      # Get the building attribute of this location.
+      def building
+        first_element('building').text if first_element('building')
+      end
+
+      ##
+      # Get the country attribute of this location.
+      def country
+        first_element('country').text if first_element('country')
+      end
+
+      ##
+      # Get the datum attribute of this location.
+      def datum
+        first_element('datum').text if first_element('datum')
+      end
+
+      ##
+      # Get the description attribute of this location.
+      def description
+        first_element('description').text if first_element('description')
+      end
+
+      ##
+      # Get the floor attribute of this location.
+      def floor
+        first_element('floor').text if first_element('floor')
+      end
+
+      ##
+      # Get the lat attribute of this location.
+      def lat
+        first_element('lat').text if first_element('lat')
+      end
+
+      ##
+      # Get the locality attribute of this location.
+      def locality
+        first_element('locality').text if first_element('locality')
+      end
+
+      ##
+      # Get the lon attribute of this location.
+      def lon
+        first_element('lon').text if first_element('lon')
+      end
+
+      ##
+      # Get the postalcode attribute of this location.
+      def postalcode
+        first_element('postalcode').text if first_element('postalcode')
+      end
+
+      ##
+      # Get the region attribute of this location.
+      def region
+        first_element('region').text if first_element('region')
+      end
+
+      ##
+      # Get the room attribute of this location.
+      def room
+        first_element('room').text if first_element('room')
+      end
+
+      ##
+      # Get the speed attribute of this location.
+      def speed
+        first_element('speed').text if first_element('speed')
+      end
+
+      ##
+      # Get the street attribute of this location.
+      def street
+        first_element('street').text if first_element('street')
+      end
+
+      ##
+      # Get the text attribute of this location.
+      def text
+        first_element('text').text if first_element('text')
+      end
+
+      ##
+      # Get the timestamp attribute of this location.
+      def timestamp
+        first_element('timestamp').text if first_element('timestamp')
+      end
+
+      ##
+      # Get the uri attribute of this location.
+      def uri
+        first_element('uri').text if first_element('uri')
+      end
+    end
+  end
+end