cerberus 0.6 → 0.7

data/lib/vendor/xmpp4r/lib/xmpp4r/streamparser.rb

@@ -0,0 +1,77 @@
+# =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 'rexml/parsers/sax2parser'
+require 'rexml/source'
+require 'xmpp4r/rexmladdons'
+
+module Jabber
+
+  ##
+  # The StreamParser uses REXML to parse the incoming XML stream
+  # of the Jabber protocol and fires XMPPStanza at the Connection
+  # instance.
+  #
+  class StreamParser
+    # status if the parser is started
+    attr_reader :started
+
+    ##
+    # Constructs a parser for the supplied stream (socket input)
+    #
+    # stream:: [IO] Socket input stream
+    # listener:: [Object.receive(XMPPStanza)] The listener (usually a Jabber::Protocol::Connection instance)
+    #
+    def initialize(stream, listener)
+      @stream = stream
+      @listener = listener
+      @current = nil
+    end
+
+    ##
+    # Begins parsing the XML stream and does not return until
+    # the stream closes.
+    #
+    def parse
+      @started = false
+      begin
+        parser = REXML::Parsers::SAX2Parser.new @stream
+
+        parser.listen( :start_element ) do |uri, localname, qname, attributes|
+          e = REXML::Element.new(qname)
+          e.add_attributes attributes
+          @current = @current.nil? ? e : @current.add_element(e)
+
+          if @current.name == 'stream' and !@started
+            @started = true
+            @listener.receive(@current)
+            @current = nil
+          end
+        end
+
+        parser.listen( :end_element ) do  |uri, localname, qname|
+          if qname == 'stream:stream' and @current.nil?
+            @started = false
+            @listener.parser_end
+          else
+            @listener.receive(@current) unless @current.parent
+            @current = @current.parent
+          end
+        end
+
+        parser.listen( :characters ) do | text |
+          @current.add(REXML::Text.new(text.to_s, @current.whitespace, nil, true)) if @current
+        end
+
+        parser.listen( :cdata ) do | text |
+          @current.add(REXML::CData.new(text)) if @current
+        end
+
+        parser.parse
+      rescue REXML::ParseException => e
+        @listener.parse_failure(e)
+      end
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/tune.rb

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

data/lib/vendor/xmpp4r/lib/xmpp4r/tune/helper/helper.rb

@@ -0,0 +1,58 @@
+# =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/tune/tune'
+
+module Jabber
+  module UserTune
+    ##
+    # A Helper for XEP-0118 User Tune
+    #
+    # Use this helper to send user tunes, or receive them from a
+    # specified jid. Described at http://www.xmpp.org/extensions/xep-0118.html
+    #
+    # For example:
+    # <pre>
+    # h = UserTune::Helper( @client, 'radio1@hug.hellomatty.com' )
+    # h.add_usertune_callback do |tune|
+    #   puts "Now playing: #{tune.title} by #{tune.artist}"
+    # end
+    # </pre>
+    #
+    # Also see the examples provided.
+    class Helper < PubSub::ServiceHelper
+      ##
+      # Send out the tune currently playing.
+      #
+      # track:: [Jabber::UserTune::Tune] the tune currently playing
+      def now_playing(track)
+        item = Jabber::PubSub::Item.new()
+        item.add(track)
+
+        publish_item_to(NS_USERTUNE, item)
+      end
+
+      ##
+      # Use this method to indicate that you have stopped playing
+      # a tune.
+      def stop_playing
+        now_playing(Jabber::UserTune::Tune.new())
+      end
+
+      ##
+      # Add a callback that will be invoked when a tune is received
+      # from the jid specified when you constructed the Helper.
+      def add_usertune_callback(prio = 200, ref = nil, &block)
+        add_event_callback(prio, ref) do |event|
+          tune = event.first_element('items/item/tune')
+          if tune
+            block.call(tune)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/tune/tune.rb

@@ -0,0 +1,113 @@
+# =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/xmppelement'
+require 'rexml/element'
+
+module Jabber
+  module UserTune
+    NS_USERTUNE = 'http://jabber.org/protocol/tune'
+
+    ##
+    # The <tune> XMPP element, as defined in XEP-0118 User Tune
+    #
+    # See http://www.xmpp.org/extensions/xep-0118.html - this element
+    # encapsulates metadata (artist, track etc) about a tune the user
+    # is currently playing. These are expressed as child elements
+    # such as <artist>, <title> etc which are also managed by this class.
+    #
+    # If the element has no children then it indicates that the user
+    # has stopped playing a tune. Use the Tune#playing? method to discover
+    # this?
+    class Tune < XMPPElement
+      name_xmlns 'tune', NS_USERTUNE
+      force_xmlns true
+
+      ##
+      # Construct a new <tune> element.
+      #
+      # Supply no arguments to make an
+      # empty element to indicate that tune playing has stopped.
+      #
+      # artist:: [String] the artist or performer of the song or piece
+      # title:: [String] the title of the song or piece
+      # length:: [Fixnum] the duration of the song or piece in seconds
+      # track:: [String] a unique identifier for the tune; e.g., the track number within a collection or the specific URI for the object (e.g., a stream or audio file)
+      # source:: [String] the collection (e.g., album) or other source (e.g., a band website that hosts streams or audio files)
+      # uri:: [String] a URI or URL pointing to information about the song, collection, or artist
+      # rating:: [Numeric] a number indicating how much you like this song - will be clamped into an integer 0 <= x <= 10
+      def initialize(artist = nil, title = nil, length = nil, track = nil, source = nil, uri = nil, rating = nil)
+        super()
+
+        add_element(REXML::Element.new('artist')).text = artist if artist
+
+        add_element(REXML::Element.new('title')).text = title if title
+
+        add_element(REXML::Element.new('length')).text = length.to_s if length
+
+        add_element(REXML::Element.new('track')).text = track if track
+
+        add_element(REXML::Element.new('source')).text = source if source
+
+        add_element(REXML::Element.new('uri')).text = uri if uri
+
+        if rating and rating.kind_of?(Numeric)
+          r = rating.to_i
+          r = 0 if r < 0
+          r = 10 if r > 10
+          add_element(REXML::Element.new('rating')).text = r.to_s
+        end
+      end
+
+
+      ##
+      # Returns true if a tune is currently playing, otherwise false.
+      def playing?
+        (elements.size > 0)
+      end
+
+      ##
+      # Get the artist for this tune.
+      def artist
+        first_element('artist').text if first_element('artist')
+      end
+
+      ##
+      # Get the title of this tune.
+      def title
+        first_element('title').text  if first_element('title')
+      end
+
+      ##
+      # Get the length of this tune, in seconds.
+      def length
+        first_element('length').text.to_i if first_element('length')
+      end
+
+      ##
+      # Get an identitier for this tune.
+      def track
+        first_element('track').text if first_element('track')
+      end
+
+      ##
+      # Get the source of this tune, such as an album.
+      def source
+        first_element('source').text if first_element('source')
+      end
+
+      ##
+      # Get a URI that represents this tune.
+      def uri
+        first_element('uri').text if first_element('uri')
+      end
+
+      ##
+      # Get the rating for this track
+      def rating
+        first_element('rating').text.to_i if first_element('rating')
+      end
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/vcard.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/vcard/helper/vcard.rb'
+require 'xmpp4r/vcard/iq/vcard.rb'

data/lib/vendor/xmpp4r/lib/xmpp4r/vcard/helper/vcard.rb

@@ -0,0 +1,84 @@
+# =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'
+
+module Jabber
+  module Vcard
+    ##
+    # The Vcard helper retrieves vCards
+    class Helper
+      ##
+      # Initialize a new Vcard helper
+      def initialize(stream)
+        @stream = stream
+      end
+
+      ##
+      # Retrieve vCard of an entity
+      #
+      # Raises exception upon retrieval error, please catch that!
+      # (The exception is ServerError and is raisen by
+      # Stream#send_with_id.
+      #
+      # Usage of Threads is suggested here as vCards can be very
+      # big (see <tt>/iq/vCard/PHOTO/BINVAL</tt>).
+      #
+      # jid:: [Jabber::JID] or nil (should be stripped, nil for the client's own vCard)
+      # result:: [Jabber::IqVcard] or nil (nil results may be handled as empty vCards)
+      def get(jid=nil)
+        res = nil
+        request = Iq.new(:get, jid)
+        request.from = @stream.jid  # Enable components to use this
+        request.add(IqVcard.new)
+        @stream.send_with_id(request) { |answer|
+          # No check for sender or queryns needed (see send_with_id)
+          if answer.type == :result
+            res = answer.vcard
+            true
+          else
+            false
+          end
+        }
+        res
+      end
+
+      ##
+      # Set your own vCard (Clients only)
+      #
+      # Raises exception when setting fails
+      #
+      # Usage of Threads suggested here, too. The function
+      # waits for approval from the server.
+      #
+      # iqvcard:: [Jabber::IqVcard]
+      def set(iqvcard)
+        iq = Iq.new(:set)
+        iq.add(iqvcard)
+
+        @stream.send_with_id(iq) { |answer|
+          if answer.type == :result
+            true
+          else
+            false
+          end
+        }
+      end
+
+      ##
+      # Quickly initialize a Vcard helper and get
+      # a vCard. See Vcard#get
+      def self.get(stream, jid=nil)
+        new(stream).get(jid)
+      end
+
+      ##
+      # Quickly initialize a Vcard helper and set
+      # your vCard. See Vcard#set
+      def self.set(stream, iqvcard)
+        new(stream).set(iqvcard)
+      end
+    end
+  end
+end

data/lib/vendor/xmpp4r/lib/xmpp4r/vcard/iq/vcard.rb

@@ -0,0 +1,109 @@
+# =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/base64'
+
+module Jabber
+  module Vcard
+    ##
+    # vCard container for User Information
+    # (can be specified by users themselves, mostly kept on servers)
+    # (JEP 0054)
+    class IqVcard < XMPPElement
+      name_xmlns 'vCard', 'vcard-temp'
+      force_xmlns true
+
+      ##
+      # Initialize a <vCard/> element
+      # fields:: [Hash] Initialize with keys as XPath element names and values for element texts
+      def initialize(fields=nil)
+        super()
+
+        unless fields.nil?
+          fields.each { |name,value|
+            self[name] = value
+          }
+        end
+      end
+
+      ##
+      # Get an elements/fields text
+      #
+      # vCards have too much possible children, so ask for them here
+      # and extract the result with iqvcard.element('...').text
+      # name:: [String] XPath
+      def [](name)
+        text = nil
+        each_element(name) { |child| text = child.text }
+        text
+      end
+
+      ##
+      # Set an elements/fields text
+      # name:: [String] XPath
+      # text:: [String] Value
+      def []=(name, text)
+        xe = self
+        name.split(/\//).each do |elementname|
+          # Does the children already exist?
+          newxe = nil
+          xe.each_element(elementname) { |child| newxe = child }
+
+          if newxe.nil?
+            # Create a new
+            xe = xe.add_element(elementname)
+          else
+            # Or take existing
+            xe = newxe
+          end
+        end
+        xe.text = text
+      end
+
+      ##
+      # Get vCard field names
+      #
+      # Example:
+      #  ["NICKNAME", "BDAY", "ORG/ORGUNIT", "PHOTO/TYPE", "PHOTO/BINVAL"]
+      #
+      # result:: [Array] of [String]
+      def fields
+        element_names(self).uniq
+      end
+
+      ##
+      # Get the PHOTO/BINVAL (Avatar picture) field decoded from Base64
+      # result:: [String] or [nil]
+      def photo_binval
+        if (binval = self['PHOTO/BINVAL'])
+          Base64::decode64(binval)
+        else
+          nil
+        end
+      end
+
+      private
+
+      ##
+      # Recursive helper function,
+      # returns all element names in an array, concatenated
+      # to their parent's name with a slash
+      def element_names(xe, prefix='')  # :nodoc:
+        res = []
+        xe.each_element { |child|
+          if child.kind_of?(REXML::Element)
+            children = element_names(child, "#{prefix}#{child.name}/")
+            if children == []
+              res.push("#{prefix}#{child.name}")
+            else
+              res += children
+            end
+          end
+        }
+        res
+      end
+    end
+  end
+end