ln-xmpp4r 0.5

data/lib/xmpp4r/streamparser.rb

@@ -0,0 +1,85 @@
+# =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)
+
+          # Handling <stream:stream> not only when it is being
+          # received as a top-level tag but also as a child of the
+          # top-level element itself. This way, we handle stream
+          # restarts (ie. after SASL authentication).
+          if @current.name == 'stream' and @current.parent.nil?
+            @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( :end_document ) do
+          raise Jabber::ServerDisconnected, "Server Disconnected!"
+        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/xmpp4r/test/listener_mocker.rb

@@ -0,0 +1,118 @@
+module Jabber
+  module Test
+    class ListenerMocker
+      
+      class << self
+        attr_accessor :with_socket_mocked_callback_proc
+      end
+      
+      def self.with_socket_mocked(callback_proc)
+        TCPSocket.class_eval{ ListenerMocker.with_socket_mocked_callback_proc = callback_proc }
+        TCPSocket.class_eval do
+          alias_method :initialize_old, :initialize
+          def initialize(*args)
+            initialize_old(*args) if ListenerMocker.with_socket_mocked_callback_proc.call(args)
+          end
+        end
+        yield
+      ensure
+        TCPSocket.class_eval do
+          if method_defined?(:initialize_old)
+            alias_method :initialize, :initialize_old
+          end
+        end
+      end
+      
+      class << self
+        attr_accessor :mock_clients, :tracker_of_callers
+      end
+      
+      def self.mocker_proc
+        Proc.new do      
+          attr_accessor :messagecbs, :connected
+          ListenerMocker.mock_clients ||= {}
+          ListenerMocker.tracker_of_callers ||= {}
+      
+          def connect
+            Jabber::debuglog("(in mock) connected #{@jid.bare}")
+            self.connected = true          
+          end
+      
+          def close!
+            ListenerMocker.mock_clients[@jid.bare.to_s] = nil
+            ListenerMocker.tracker_of_callers[@jid.bare.to_s] = nil
+            self.connected = false
+          end
+      
+          def auth(password)
+            auth_nonsasl(password)
+          end
+      
+          def auth_nonsasl(password, digest=true)
+            Jabber::debuglog("(in mock) authed #{@jid.bare}") 
+      
+            if(ListenerMocker.mock_clients[@jid.bare.to_s])
+              #raise a stack trace about multiple clients
+              raise "\n\n ---> READ ME: this is actualy 2 stack traces: <---- \n\n"+
+              "There is already a client connected on that jid #{@jid.bare.to_s}. "+
+              "The mock library cannot support multiple listeners connected as the same user! originally called in:\n"+
+              ListenerMocker.tracker_of_callers[@jid.bare.to_s].backtrace.join("\n")+"\n\n second trace: \n"
+            else
+              #store a stack trace so that next time we have multiple client, we can alert about it...
+              begin
+                throw "just saving a stack trace"
+              rescue => e
+                ListenerMocker.tracker_of_callers[@jid.bare.to_s] = e
+              end
+            end
+
+            ListenerMocker.mock_clients[@jid.bare.to_s] = self
+            true
+          end
+      
+          def send(xml, &block)
+            Jabber::debuglog("(in mock) sending #{xml} #{xml.class}")
+            if(xml.is_a?(Jabber::Message))
+              xml.from = @jid
+              # unless xml.to
+              #   raise "no jid!"
+              # end
+              if ListenerMocker.mock_clients[xml.to.bare.to_s]
+                Jabber::debuglog("(in mock) to #{xml.to.bare.to_s}")
+                ListenerMocker.mock_clients[xml.to.bare.to_s].messagecbs.process(xml)
+              else
+                Jabber::debuglog("(in mock) no client listening as #{xml.to.bare.to_s}")
+              end
+            end
+          end          
+      
+          def is_connected?
+            self.connected
+          end                
+        end    
+      end
+      
+      def self.mock_out_all_connections
+        Jabber::Reliable::Connection.class_eval(&Jabber::Test::ListenerMocker.mocker_proc)
+      end
+  
+      def self.mock_out(listener)
+        listener.instance_eval do
+          class << self
+            def setup_connection
+              super
+              @connection.instance_eval do
+                class << self
+                  self.class_eval(&Jabber::Test::ListenerMocker.mocker_proc)
+                end
+              end
+            end
+          end
+        end
+    
+        listener
+      end
+  
+    end
+  end
+end

data/lib/xmpp4r/tune.rb

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

data/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/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/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/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