jabber4r-revive 0.9.0

data/lib/jabber4r/protocol/presence.rb

@@ -0,0 +1,160 @@
+# coding: utf-8
+
+# License: see LICENSE
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+
+module Jabber::Protocol
+  ##
+  # The presence class is used to construct presence messages to
+  # send to the Jabber service.
+  #
+  class Presence
+    attr_accessor :to, :from, :id, :type
+
+    # The state to show (chat, xa, dnd, away)
+    attr_accessor :show
+
+    # The status message
+    attr_accessor :status
+    attr_accessor :priority
+
+    ##
+    # Constructs a Presence object w/the supplied id
+    #
+    # id:: [String] The message ID
+    # show:: [String] The state to show
+    # status:: [String] The status message
+    #
+    def initialize(id, show=nil, status=nil)
+      @id = id
+      @show = show if show
+      @status = status if status
+    end
+
+    ##
+    # Generate a presence object for initial presence notification
+    #
+    # id:: [String] The message ID
+    # show:: [String] The state to show
+    # status:: [String] The status message
+    # return:: [Jabber::Protocol::Presence] The newly created Presence object
+    #
+    def self.gen_initial(id, show=nil, status=nil)
+      Presence.new(id, show, status)
+    end
+
+    ##
+    # Generate a presence object w/show="normal" (normal availability)
+    #
+    # id:: [String] The message ID
+    # status:: [String=nil] The status message
+    # return:: [Jabber::Protocol::Presence] The newly created Presence object
+    #
+    def self.gen_normal(id, status=nil)
+      Presence.new(id, "normal", status)
+    end
+
+    ##
+    # Generate a presence object w/show="chat" (free for chat)
+    #
+    # id:: [String] The message ID
+    # status:: [String=nil] The status message
+    # return:: [Jabber::Protocol::Presence] The newly created Presence object
+    #
+    def self.gen_chat(id, status=nil)
+      Presence.new(id, "chat", status)
+    end
+
+    ##
+    # Generate a presence object w/show="xa" (extended away)
+    #
+    # id:: [String] The message ID
+    # status:: [String=nil] The status message
+    # return:: [Jabber::Protocol::Presence] The newly created Presence object
+    #
+    def self.gen_xa(id, status=nil)
+      Presence.new(id, "xa", status)
+    end
+
+    ##
+    # Generate a presence object w/show="dnd" (do not disturb)
+    #
+    # id:: [String] The message ID
+    # status:: [String=nil] The status message
+    # return:: [Jabber::Protocol::Presence] The newly created Presence object
+    #
+    def self.gen_dnd(id, status=nil)
+      Presence.new(id, "dnd", status)
+    end
+
+    ##
+    # Generate a presence object w/show="away" (away from resource)
+    #
+    # id:: [String] The message ID
+    # status:: [String=nil] The status message
+    # return:: [Jabber::Protocol::Presence] The newly created Presence object
+    #
+    def self.gen_away(id, status=nil)
+      Presence.new(id, "away", status)
+    end
+
+    ##
+    # Generate a presence object w/show="unavailable" (not free for chat)
+    #
+    # id:: [String] The message ID
+    # status:: [String=nil] The status message
+    # return:: [Jabber::Protocol::Presence] The newly created Presence object
+    #
+    def self.gen_unavailable(id, status=nil)
+      p = Presence.new(id)
+      p.type="unavailable"
+      p
+    end
+
+    def self.gen_new_subscription(to)
+      p = Presence.new(Jabber.gen_random_id)
+      p.type = "subscribe"
+      p.to = to
+      p
+    end
+
+    def self.gen_accept_subscription(id, jid)
+      p = Presence.new(id)
+      p.type = "subscribed"
+      p.to = jid
+      p
+    end
+
+    def self.gen_accept_unsubscription(id, jid)
+      p = Presence.new(id)
+      p.type = "unsubscribed"
+      p.to = jid
+      p
+    end
+
+    ##
+    # Generates the xml representation of this Presence object
+    #
+    # return:: [String] The presence XML message to send the Jabber service
+    #
+    def to_xml
+      e = XMLElement.new("presence")
+      e.add_attribute("id", @id) if @id
+      e.add_attribute("from", @from) if @from
+      e.add_attribute("to", @to) if @to
+      e.add_attribute("type", @type) if @type
+      e.add_child("show").add_data(@show) if @show
+      e.add_child("status").add_data(@status) if @status
+      e.add_child("priority") if @priority
+      e.to_s
+    end
+
+    ##
+    # see _to_xml
+    #
+    def to_s
+      to_xml
+    end
+  end
+end

data/lib/jabber4r/protocol/xml_element.rb

@@ -0,0 +1,144 @@
+# coding: utf-8
+
+# License: see LICENSE
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+
+module Jabber::Protocol
+  ##
+  # Utility class to create valid XML strings
+  #
+  class XMLElement
+
+    # The parent XMLElement
+    attr_accessor :parent
+
+    ##
+    # Construct an XMLElement for the supplied tag and attributes
+    #
+    # tag:: [String] XML tag
+    # attributes:: [Hash = {}] The attribute hash[attribute]=value
+    def initialize(tag, attributes={})
+      @tag = tag
+      @elements = []
+      @attributes = attributes
+      @data = ""
+    end
+
+    ##
+    # Adds an attribute to this element
+    #
+    # attrib:: [String] The attribute name
+    # value:: [String] The attribute value
+    # return:: [Jabber::Protocol::XMLElement] self for chaining
+    #
+    def add_attribute(attrib, value)
+      @attributes[attrib]=value
+      self
+    end
+
+    ##
+    # Adds data to this element
+    #
+    # data:: [String] The data to add
+    # return:: [Jabber::Protocol::XMLElement] self for chaining
+    #
+    def add_data(data)
+      @data += data.to_s
+      self
+    end
+
+    ##
+    # Sets the namespace for this tag
+    #
+    # ns:: [String] The namespace
+    # return:: [Jabber::Protocol::XMLElement] self for chaining
+    #
+    def set_namespace(ns)
+      @tag+=":#{ns}"
+      self
+    end
+
+    ##
+    # Adds cdata to this element
+    #
+    # cdata:: [String] The cdata to add
+    # return:: [Jabber::Protocol::XMLElement] self for chaining
+    #
+    def add_cdata(cdata)
+      @data += "<![CDATA[#{cdata.to_s}]]>"
+      self
+    end
+
+    ##
+    # Returns the parent element
+    #
+    # return:: [Jabber::Protocol::XMLElement] The parent XMLElement
+    #
+    def to_parent
+      @parent
+    end
+
+    ##
+    # Adds a child to this element of the supplied tag
+    #
+    # tag:: [String] The element tag
+    # attributes:: [Hash = {}] The attributes hash[attribute]=value
+    # return:: [Jabber::Protocol::XMLElement] newly created child element
+    #
+    def add_child(tag, attributes={})
+      child = XMLElement.new(tag, attributes)
+      child.parent = self
+      @elements << child
+      return child
+    end
+
+    ##
+    # Adds arbitrary XML data to this object
+    #
+    # xml:: [String] the xml to add
+    #
+    def add_xml(xml)
+      @xml = xml
+    end
+
+    ##
+    # Recursively builds the XML string by traversing this element's
+    # children.
+    #
+    # format:: [Boolean] True to pretty-print (format) the output string
+    # indent:: [Integer = 0] The indent level (recursively more)
+    #
+    def to_xml(format, indent=0)
+      result = ""
+      result += " "*indent if format
+      result += "<#{@tag}"
+      @attributes.each {|attrib, value| result += (' '+attrib.to_s+'="'+value.to_s+'"') }
+      if @data=="" and @elements.size==0
+        result +="/>"
+        result +="\n" if format
+        return result
+      end
+      result += ">"
+      result += "\n" if format and @data==""
+      result += @data if @data!=""
+      @elements.each {|element| result+=element.to_xml(format, indent+4)}
+      result += @xml if not @xml.nil?
+      result += " "*indent if format and @data==""
+      result+="</#{@tag}>"
+      result+="\n" if format
+      return result
+    end
+
+    ##
+    # Climbs to the top of this elements parent tree and then returns
+    # the to_xml XML string.
+    #
+    # return:: [String] The XML string of this element (from the topmost parent).
+    #
+    def to_s
+      return @parent.to_s if @parent
+      return to_xml(true)
+    end
+  end
+end

data/lib/jabber4r/protocol.rb

@@ -0,0 +1,257 @@
+# coding: utf-8
+
+# License: see LICENSE
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+
+require "singleton"
+require "socket"
+
+module Jabber
+  class JabberConnectionException < RuntimeError
+    attr_reader :data
+
+    def initialize(writing, data)
+      @writing = writing
+      @data = data
+    end
+
+    def writing?
+      @writing
+    end
+  end
+
+  ##
+  # The Protocol module contains helper methods for constructing
+  # Jabber protocol elements and classes that implement protocol
+  # elements.
+  #
+  module Protocol
+
+    USE_PARSER = :rexml # either :rexml or :xmlparser
+
+    ##
+    # The parser to use for stream processing.  The current
+    # available parsers are:
+    #
+    # * Jabber::Protocol::ExpatJabberParser uses XMLParser
+    # * Jabber::Protocol::REXMLJabberParser uses REXML
+    #
+    # return:: [Class] The parser class
+    #
+    def Protocol.Parser
+      if USE_PARSER==:xmlparser
+        Jabber::Protocol::ExpatJabberParser
+      else
+        Jabber::Protocol::REXMLJabberParser
+      end
+    end
+
+    ##
+    # Generates an open stream XML element
+    #
+    # host:: [String] The host being connected to
+    # return:: [String] The XML data to send
+    #
+    def self.gen_open_stream(host)
+      return ('<?xml version="1.0" encoding="UTF-8" ?><stream:stream to="'+host+'" xmlns="jabber:client" xmlns:stream="http://etherx.jabber.org/streams">')
+    end
+
+    ##
+    # Generates an close stream XML element
+    #
+    # return:: [String] The XML data to send
+    #
+    def self.gen_close_stream
+      return "</stream:stream>"
+    end
+
+    if USE_PARSER == :xmlparser
+      require 'xmlparser'
+      ##
+      # The ExpatJabberParser uses XMLParser (expat) to parse the incoming XML stream
+      # of the Jabber protocol and fires ParsedXMLElements at the Connection
+      # instance.
+      #
+      class ExpatJabberParser
+
+        # status if the parser is started
+        attr_reader :started
+
+        ##
+        # Constructs a parser for the supplied stream (socket input)
+        #
+        # stream:: [IO] Socket input stream
+        # listener:: [#receive(ParsedXMLElement)] The listener (usually a Jabber::Protocol::Connection instance
+        #
+        def initialize(stream, listener)
+          @stream = stream
+          def @stream.gets
+            super(">")
+          end
+          @listener = listener
+        end
+
+        ##
+        # Begins parsing the XML stream and does not return until
+        # the stream closes.
+        #
+        def parse
+          @started = false
+
+          parser = XMLParser.new("UTF-8")
+          def parser.unknownEncoding(e)
+            raise "Unknown encoding #{e.to_s}"
+          end
+          def parser.default
+          end
+
+          begin
+            parser.parse(@stream) do |type, name, data|
+              begin
+              case type
+                when XMLParser::START_ELEM
+                  case name
+                    when "stream:stream"
+                      openstream = ParsedXMLElement.new(name)
+                      data.each {|key, value| openstream.add_attribute(key, value)}
+                      @listener.receive(openstream)
+                      @started = true
+                    else
+                      if @current.nil?
+                        @current = ParsedXMLElement.new(name.clone)
+                      else
+                        @current = @current.add_child(name.clone)
+                      end
+                      data.each {|key, value| @current.add_attribute(key.clone, value.clone)}
+                  end
+                when XMLParser::CDATA
+                  @current.append_data(data.clone) if @current
+                when XMLParser::END_ELEM
+                  case name
+                    when "stream:stream"
+                      @started = false
+                    else
+                      @listener.receive(@current) unless @current.element_parent
+                      @current = @current.element_parent
+                  end
+              end
+              rescue
+                puts  "Error #{$!}"
+              end
+            end
+          rescue XMLParserError
+            line = parser.line
+            print "XML Parsing error(#{line}): #{$!}\n"
+          end
+        end
+      end
+    else # USE REXML
+      require 'rexml/document'
+      require 'rexml/parsers/sax2parser'
+      require 'rexml/source'
+
+      ##
+      # The REXMLJabberParser uses REXML to parse the incoming XML stream
+      # of the Jabber protocol and fires ParsedXMLElements at the Connection
+      # instance.
+      #
+      class REXMLJabberParser
+        # 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(ParsedXMLElement)] The listener (usually a Jabber::Protocol::Connection instance
+        #
+        def initialize(stream, listener)
+          @stream = stream
+
+          # this hack fixes REXML version "2.7.3" and "2.7.4"
+          if REXML::Version=="2.7.3" || REXML::Version=="2.7.4"
+            def @stream.read(len=nil)
+              len = 100 unless len
+              super(len)
+            end
+            def @stream.gets(char=nil)
+              super(">")
+            end
+            def @stream.readline(char=nil)
+              super(">")
+            end
+            def @stream.readlines(char=nil)
+              super(">")
+            end
+          end
+
+          @listener = listener
+          @current = nil
+        end
+
+        ##
+        # Begins parsing the XML stream and does not return until
+        # the stream closes.
+        #
+        def parse
+          #puts "PARSE"
+          @started = false
+          begin
+            parser = REXML::Parsers::SAX2Parser.new @stream
+
+            parser.listen(:end_document) do
+              raise Jabber::ConnectionForceCloseError
+            end
+
+            parser.listen( :start_element ) do |uri, localname, qname, attributes|
+              puts "START ELEMENT"
+              case qname
+              when "stream:stream"
+                openstream = ParsedXMLElement.new(qname)
+                attributes.each { |attr, value| openstream.add_attribute(attr, value) }
+                @listener.receive(openstream)
+                      @started = true
+              else
+                if @current.nil?
+                  @current = ParsedXMLElement.new(qname)
+                else
+                  @current = @current.add_child(qname)
+                end
+                attributes.each { |attr, value| @current.add_attribute(attr, value) }
+              end
+            end
+            parser.listen( :end_element ) do  |uri, localname, qname|
+              puts "END ELEMENT"
+              case qname
+              when "stream:stream"
+                @started = false
+              else
+                @listener.receive(@current) unless @current.element_parent
+                @current = @current.element_parent
+              end
+            end
+            parser.listen( :characters ) do | text |
+              puts "CHARACTERS"
+              @current.append_data(text) if @current
+            end
+            parser.listen( :cdata ) do | text |
+              puts "CDATA"
+              @current.append_data(text) if @current
+            end
+            parser.parse
+          rescue REXML::ParseException => e
+            puts "FAIL"
+
+            puts e.backtrace.join "\n"
+            puts e.message
+            @listener.parse_failure
+          rescue Jabber::ConnectionForceCloseError => e
+            @listener.parse_failure(e)
+          end
+        end
+      end
+    end # USE_PARSER
+  end
+end
+