jabber4r-revive 0.9.0 → 0.10.0

data/lib/jabber4r/debugger.rb

@@ -1,61 +1,61 @@
-# coding: utf-8
-
-# License: see LICENSE
-# Jabber4R - Jabber Instant Messaging Library for Ruby
-# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
-# Copyright (C) 2013  Sergey Fedorov <strech_ftf@mail.ru>
-
-require "singleton"
-require "logger"
-
-module Jabber
-  # Produces debug methods
-  #
-  # Example
-  #
-  # def warn(message)
-  #   Debug.instance.send(:warn, message)
-  # end
-  # module_function m
-  [:warn, :debug, :info].each do |m|
-    define_method(m) do |message|
-      Debugger.send(m, message)
-    end
-    module_function m
-  end
-
-  class Debugger
-    include Singleton
-
-    attr_accessor :enabled, :logger
-
-    def initialize
-      @logger  = Logger.new(STDOUT)
-      @enabled = false
-    end
-
-    class << self
-      def logger=(logger)
-        instance.logger = logger
-      end
-
-      def enable!
-        instance.enabled = true
-      end
-
-      def disable!
-        instance.enabled = false
-      end
-
-      def enabled?
-        instance.enabled
-      end
-
-      [:warn, :debug, :info].each do |m|
-        define_method(m) do |message|
-          enabled? && instance.logger.send(m, message)
-        end
-      end
-    end # class << self
-  end
+# coding: utf-8
+
+# License: see LICENSE
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+# Copyright (C) 2013  Sergey Fedorov <strech_ftf@mail.ru>
+
+require "singleton"
+require "logger"
+
+module Jabber
+  # Produces debug methods
+  #
+  # Example
+  #
+  # def warn(message)
+  #   Debug.instance.send(:warn, message)
+  # end
+  # module_function m
+  [:warn, :debug, :info].each do |m|
+    define_method(m) do |message|
+      Debugger.send(m, message)
+    end
+    module_function m
+  end
+
+  class Debugger
+    include Singleton
+
+    attr_accessor :enabled, :logger
+
+    def initialize
+      @logger  = Logger.new(STDOUT)
+      @enabled = false
+    end
+
+    class << self
+      def logger=(logger)
+        instance.logger = logger
+      end
+
+      def enable!
+        instance.enabled = true
+      end
+
+      def disable!
+        instance.enabled = false
+      end
+
+      def enabled?
+        instance.enabled
+      end
+
+      [:warn, :debug, :info].each do |m|
+        define_method(m) do |message|
+          enabled? && instance.logger.send(m, message)
+        end
+      end
+    end # class << self
+  end
 end

data/lib/jabber4r/jid.rb

@@ -3,20 +3,21 @@
 # License: see LICENSE
 # Jabber4R - Jabber Instant Messaging Library for Ruby
 # Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+# Copyright (C) 2013  Sergey Fedorov <strech_ftf@mail.ru>
 
 module Jabber
-  # The Jabber ID class is used to hold a parsed jabber identifier (account+host+resource)
+  # The Jabber ID class is used to hold a parsed jabber identifier (account+domain+resource)
   class JID
-    PATTERN = /^(?:(?<node>[^@]*)@)??(?<host>[^@\/]*)(?:\/(?<resource>.*?))?$/.freeze
+    PATTERN = /^(?:(?<node>[^@]*)@)??(?<domain>[^@\/]*)(?:\/(?<resource>.*?))?$/.freeze
 
-    # The node (account)
+    # Public: The node (account)
     attr_accessor :node
 
-    # The resource id
+    # Public: The resource id
     attr_accessor :resource
 
-    # The host name (or IP address)
-    attr_accessor :host
+    # Public: The domain indentificator (or IP address)
+    attr_accessor :domain
 
     # Public: Convert something to Jabber::JID
     #
@@ -30,34 +31,34 @@ module Jabber
     end
 
     # Constructs a JID from the supplied string of the format:
-    # node@host[/resource] (e.g. "rich_kilmer@jabber.com/laptop")
+    # node@domain[/resource] (e.g. "rich_kilmer@jabber.com/laptop")
     #
     # jid      - String the jabber id string to parse
-    # host     - String the host of jabber server (optional)
+    # domain     - String the domain of jabber server (optional)
     # resource - String the resource of jabber id (optional)
     #
     # Examples
     #
     # jid = Jabber::JID.new("strech@localhost/attach")
     # jid.node # => "strech"
-    # jid.host # => "localhost"
+    # jid.domain # => "localhost"
     # jid.resource # => "attach"
     #
     # Raises ArgumentError
     # Returns nothing
-    def initialize(jid, host = nil, resource = nil)
+    def initialize(jid, domain = nil, resource = nil)
       raise ArgumentError, "Node can't be empty" if jid.to_s.empty?
 
-      @node, @host, @resource = self.class.parse(jid)
-      @node, @host = @host, nil if @node.nil? && @host
+      @node, @domain, @resource = self.class.parse(jid)
+      @node, @domain = @domain, nil if @node.nil? && @domain
 
-      @host = host unless host.nil?
+      @domain = domain unless domain.nil?
       @resource = resource unless resource.nil?
 
-      raise ArgumentError, "Couldn't create JID without host" if @host.to_s.empty?
+      raise ArgumentError, "Couldn't create JID without domain" if @domain.to_s.empty?
     end
 
-    # Public: Evalutes whether the node, resource and host are the same
+    # Public: Evalutes whether the node, resource and domain are the same
     #
     # jid - Jabber::JID the other jabber id
     #
@@ -74,14 +75,14 @@ module Jabber
     def same?(jid)
       other_jid = self.class.to_jid(jid)
 
-      other_jid.node == node && other_jid.host == host
+      other_jid.node == node && other_jid.domain == domain
     end
 
     # Public: Strip resource from jid and return new object
     #
     # Returns Jabber::JID
     def strip
-      self.class.new(node, host)
+      self.class.new(node, domain)
     end
 
     # Public: Strip resource from jid and return the same object
@@ -97,7 +98,7 @@ module Jabber
     #
     # Returns String
     def to_s
-      ["#{node}@#{host}", resource].compact.join "/"
+      ["#{node}@#{domain}", resource].compact.join "/"
     end
 
     # Public: Override #hash to hash based on the to_s method
@@ -108,7 +109,7 @@ module Jabber
     end
 
     private
-    # Internal: Parse jid string for node, host, resource
+    # Internal: Parse jid string for node, domain, resource
     #
     # jid - String jabber id
     #

data/lib/jabber4r/protocol.rb

@@ -1,257 +1,249 @@
-# 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
-
+# 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
+    #
+    # domain:: [String] The domain being connected to
+    # return:: [String] The XML data to send
+    #
+    def self.gen_open_stream(domain)
+      return ('<?xml version="1.0" encoding="UTF-8" ?><stream:stream to="'+domain+'" xmlns="jabber:client" xmlns:stream="http://etherx.jabber.org/streams" version="1.0">')
+    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|
+              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|
+              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 |
+              @current.append_data(text) if @current
+            end
+            parser.listen( :cdata ) do | text |
+              @current.append_data(text) if @current
+            end
+            parser.parse
+          rescue REXML::ParseException => e
+            @listener.parse_failure
+          rescue Jabber::ConnectionForceCloseError => e
+            @listener.parse_failure(e)
+          end
+        end
+      end
+    end # USE_PARSER
+  end
+end
+