rubysl-xmlrpc 1.0.0 → 2.0.0

data/lib/xmlrpc/httpserver.rb

@@ -1,21 +1,19 @@
-#
-# Implements a simple HTTP-server by using John W. Small's (jsmall@laser.net) 
-# ruby-generic-server.
-# 
 # Copyright (C) 2001, 2002, 2003 by Michael Neumann (mneumann@ntecs.de)
 #
-# $Id: httpserver.rb 11708 2007-02-12 23:01:19Z shyouhei $
+# $Id$
 #
 
 
 require "gserver"
 
+# Implements a simple HTTP-server by using John W. Small's (jsmall@laser.net)
+# ruby-generic-server: GServer.
 class HttpServer < GServer
 
   ##
-  # handle_obj specifies the object, that receives calls to request_handler
-  # and ip_auth_handler 
-  def initialize(handle_obj, port = 8080, host = DEFAULT_HOST, maxConnections = 4, 
+  # +handle_obj+ specifies the object, that receives calls from +request_handler+
+  # and +ip_auth_handler+
+  def initialize(handle_obj, port = 8080, host = DEFAULT_HOST, maxConnections = 4,
                  stdlog = $stdout, audit = true, debug = true)
     @handler = handle_obj
     super(port, host, maxConnections, stdlog, audit, debug)
@@ -23,19 +21,16 @@ class HttpServer < GServer
 
 private
 
-  # Constants -----------------------------------------------
-  
   CRLF        = "\r\n"
   HTTP_PROTO  = "HTTP/1.0"
   SERVER_NAME = "HttpServer (Ruby #{RUBY_VERSION})"
 
+  # Default header for the server name
   DEFAULT_HEADER = {
     "Server" => SERVER_NAME
   }
 
-  ##
-  # Mapping of status code and error message
-  #
+  # Mapping of status codes and error messages
   StatusCodeMapping = {
     200 => "OK",
     400 => "Bad Request",
@@ -45,28 +40,26 @@ private
     500 => "Internal Server Error"
   }
 
-  # Classes -------------------------------------------------
-  
   class Request
     attr_reader :data, :header, :method, :path, :proto
-    
+
     def initialize(data, method=nil, path=nil, proto=nil)
       @header, @data = Table.new, data
       @method, @path, @proto = method, path, proto
     end
-    
+
     def content_length
       len = @header['Content-Length']
       return nil if len.nil?
-      return len.to_i 
+      return len.to_i
     end
-    
+
   end
-  
+
   class Response
     attr_reader   :header
     attr_accessor :body, :status, :status_message
-    
+
     def initialize(status=200)
       @status = status
       @status_message = nil
@@ -74,15 +67,12 @@ private
     end
   end
 
-
-  ##
-  # a case-insensitive Hash class for HTTP header
-  #
+  # A case-insensitive Hash class for HTTP header
   class Table
     include Enumerable
 
     def initialize(hash={})
-      @hash = hash 
+      @hash = hash
       update(hash)
     end
 
@@ -103,17 +93,17 @@ private
       @hash.each {|k,v| yield k.capitalize, v }
     end
 
+    # Output the Hash table for the HTTP header
     def writeTo(port)
       each { |k,v| port << "#{k}: #{v}" << CRLF }
     end
   end # class Table
 
 
-  # Helper Methods ------------------------------------------
-
-  def http_header(header=nil)
+  # Generates a Hash with the HTTP headers
+  def http_header(header=nil) # :doc:
     new_header = Table.new(DEFAULT_HEADER)
-    new_header.update(header) unless header.nil? 
+    new_header.update(header) unless header.nil?
 
     new_header["Connection"] = "close"
     new_header["Date"]       = http_date(Time.now)
@@ -121,13 +111,16 @@ private
     new_header
   end
 
-  def http_date( aTime )
+  # Returns a string which represents the time as rfc1123-date of HTTP-date
+  def http_date( aTime ) # :doc:
     aTime.gmtime.strftime( "%a, %d %b %Y %H:%M:%S GMT" )
   end
 
-  def http_resp(status_code, status_message=nil, header=nil, body=nil)
+  # Returns a string which includes the status code message as,
+  # http headers, and body for the response.
+  def http_resp(status_code, status_message=nil, header=nil, body=nil) # :doc:
     status_message ||= StatusCodeMapping[status_code]
-    
+
     str = ""
     str << "#{HTTP_PROTO} #{status_code} #{status_message}" << CRLF
     http_header(header).writeTo(str)
@@ -136,9 +129,11 @@ private
     str
   end
 
-  # Main Serve Loop -----------------------------------------
-  
-  def serve(io)  
+  # Handles the HTTP request and writes the response back to the client, +io+.
+  #
+  # If an Exception is raised while handling the request, the client will receive
+  # a 500 "Internal Server Error" message.
+  def serve(io) # :doc:
     # perform IP authentification
     unless @handler.ip_auth_handler(io)
       io << http_resp(403, "Forbidden")
@@ -149,28 +144,28 @@ private
     if io.gets =~ /^(\S+)\s+(\S+)\s+(\S+)/
       request = Request.new(io, $1, $2, $3)
     else
-      io << http_resp(400, "Bad Request") 
+      io << http_resp(400, "Bad Request")
       return
     end
-     
+
     # parse HTTP headers
     while (line=io.gets) !~ /^(\n|\r)/
       if line =~ /^([\w-]+):\s*(.*)$/
-	request.header[$1] = $2.strip
+        request.header[$1] = $2.strip
       end
     end
 
-    io.binmode    
+    io.binmode
     response = Response.new
 
     # execute request handler
     @handler.request_handler(request, response)
-   
+
     # write response back to the client
     io << http_resp(response.status, response.status_message,
-                    response.header, response.body) 
+                    response.header, response.body)
 
-  rescue Exception => e
+  rescue Exception
     io << http_resp(500, "Internal Server Error")
   end
 

data/lib/xmlrpc/marshal.rb

@@ -1,9 +1,7 @@
 #
-# Marshalling of XML-RPC methodCall and methodResponse
-# 
 # Copyright (C) 2001, 2002, 2003 by Michael Neumann (mneumann@ntecs.de)
 #
-# $Id: marshal.rb 11708 2007-02-12 23:01:19Z shyouhei $
+# $Id$
 #
 
 require "xmlrpc/parser"
@@ -11,13 +9,12 @@ require "xmlrpc/create"
 require "xmlrpc/config"
 require "xmlrpc/utils"
 
-module XMLRPC
+module XMLRPC # :nodoc:
 
+  # Marshalling of XMLRPC::Create#methodCall and XMLRPC::Create#methodResponse
   class Marshal
     include ParserWriterChooseMixin
 
-    # class methods -------------------------------
-   
     class << self
 
       def dump_call( methodName, *params )
@@ -41,8 +38,6 @@ module XMLRPC
 
     end # class self
 
-    # instance methods ----------------------------
-
     def initialize( parser = nil, writer = nil )
       set_parser( parser )
       set_writer( writer )
@@ -52,20 +47,16 @@ module XMLRPC
       create.methodCall( methodName, *params )
     end
 
-    def dump_response( param ) 
+    def dump_response( param )
       create.methodResponse( ! param.kind_of?( XMLRPC::FaultException ) , param )
     end
 
-    ##
-    # returns [ methodname, params ]
-    #
+    # Returns <code>[ methodname, params ]</code>
     def load_call( stringOrReadable )
       parser.parseMethodCall( stringOrReadable )
     end
 
-    ##
-    # returns paramOrFault
-    #
+    # Returns +paramOrFault+
     def load_response( stringOrReadable )
       parser.parseMethodResponse( stringOrReadable )[1]
     end
@@ -73,4 +64,3 @@ module XMLRPC
   end # class Marshal
 
 end
-

data/lib/xmlrpc/parser.rb

@@ -1,9 +1,6 @@
-#
-# Parser for XML-RPC call and response
-# 
 # Copyright (C) 2001, 2002, 2003 by Michael Neumann (mneumann@ntecs.de)
 #
-# $Id: parser.rb 13771 2007-10-24 23:04:42Z jeg2 $
+# $Id$
 #
 
 
@@ -12,7 +9,6 @@ require "xmlrpc/base64"
 require "xmlrpc/datetime"
 
 
-# add some methods to NQXML::Node
 module NQXML
   class Node
 
@@ -49,42 +45,62 @@ module NQXML
   end # class Node
 end # module NQXML
 
-module XMLRPC
+module XMLRPC # :nodoc:
 
+  # Raised when the remote procedure returns a fault-structure, which has two
+  # accessor-methods +faultCode+ an Integer, and +faultString+ a String.
   class FaultException < StandardError
     attr_reader :faultCode, :faultString
 
-    alias message faultString
-
+    # Creates a new XMLRPC::FaultException instance.
+    #
+    # +faultString+ is passed to StandardError as the +msg+ of the Exception.
     def initialize(faultCode, faultString)
       @faultCode   = faultCode
       @faultString = faultString
+      super(@faultString)
     end
-    
-    # returns a hash
+
+    # The +faultCode+ and +faultString+ of the exception in a Hash.
     def to_h
       {"faultCode" => @faultCode, "faultString" => @faultString}
     end
   end
 
+  # Helper class used to convert types.
   module Convert
+
+    # Converts a String to an Integer
+    #
+    # See also String.to_i
     def self.int(str)
       str.to_i
     end
 
+    # Converts a String to +true+ or +false+
+    #
+    # Raises an exception if +str+ is not +0+ or +1+
     def self.boolean(str)
       case str
       when "0" then false
       when "1" then true
       else
-        raise "RPC-value of type boolean is wrong" 
+        raise "RPC-value of type boolean is wrong"
       end
     end
 
+    # Converts a String to a Float
+    #
+    # See also String.to_f
     def self.double(str)
       str.to_f
     end
 
+    # Converts a the given +str+ to a +dateTime.iso8601+ formatted date.
+    #
+    # Raises an exception if the String isn't in +dateTime.iso8601+ format.
+    #
+    # See also, XMLRPC::DateTime
     def self.dateTime(str)
       case str
       when /^(-?\d\d\d\d)-?(\d\d)-?(\d\d)T(\d\d):(\d\d):(\d\d)(?:Z|([+-])(\d\d):?(\d\d))?$/
@@ -115,14 +131,18 @@ module XMLRPC
       end
     end
 
+    # Decodes the given +str+ using XMLRPC::Base64.decode
     def self.base64(str)
       XMLRPC::Base64.decode(str)
     end
 
+    # Converts the given +hash+ to a marshalled object.
+    #
+    # Returns the given +hash+ if an exception occurs.
     def self.struct(hash)
-      # convert to marhalled object
+      # convert to marshalled object
       klass = hash["___class___"]
-      if klass.nil? or Config::ENABLE_MARSHALLING == false 
+      if klass.nil? or Config::ENABLE_MARSHALLING == false
         hash
       else
         begin
@@ -130,10 +150,10 @@ module XMLRPC
           klass.split("::").each {|const| mod = mod.const_get(const.strip)}
 
           obj = mod.allocate
-          
+
           hash.delete "___class___"
-          hash.each {|key, value| 
-            obj.instance_variable_set("@#{ key }", value) if key =~ /^([\w_][\w_0-9]*)$/
+          hash.each {|key, value|
+            obj.instance_variable_set("@#{ key }", value) if key =~ /^([a-zA-Z_]\w*)$/
           }
           obj
         rescue
@@ -142,12 +162,21 @@ module XMLRPC
       end
     end
 
+    # Converts the given +hash+ to an XMLRPC::FaultException object by passing
+    # the +faultCode+ and +faultString+ attributes of the Hash to
+    # XMLRPC::FaultException.new
+    #
+    # Raises an Exception if the given +hash+ doesn't meet the requirements.
+    # Those requirements being:
+    # * 2 keys
+    # * <code>'faultCode'</code> key is an Integer
+    # * <code>'faultString'</code> key is a String
     def self.fault(hash)
-      if hash.kind_of? Hash and hash.size == 2 and 
-        hash.has_key? "faultCode" and hash.has_key? "faultString" and 
+      if hash.kind_of? Hash and hash.size == 2 and
+        hash.has_key? "faultCode" and hash.has_key? "faultString" and
         hash["faultCode"].kind_of? Integer and hash["faultString"].kind_of? String
 
-        XMLRPC::FaultException.new(hash["faultCode"], hash["faultString"]) 
+        XMLRPC::FaultException.new(hash["faultCode"], hash["faultString"])
       else
         raise "wrong fault-structure: #{hash.inspect}"
       end
@@ -155,224 +184,221 @@ module XMLRPC
 
   end # module Convert
 
+  # Parser for XML-RPC call and response
   module XMLParser
 
     class AbstractTreeParser
 
       def parseMethodResponse(str)
-	methodResponse_document(createCleanedTree(str))
+        methodResponse_document(createCleanedTree(str))
       end
 
       def parseMethodCall(str)
-	methodCall_document(createCleanedTree(str))
+        methodCall_document(createCleanedTree(str))
       end
 
       private
 
-      #
-      # remove all whitespaces but in the tags i4, int, boolean....
+      # Removes all whitespaces but in the tags i4, i8, int, boolean....
       # and all comments
-      #
       def removeWhitespacesAndComments(node)
-	remove = []
-	childs = node.childNodes.to_a
-	childs.each do |nd|
-	  case _nodeType(nd)
-	  when :TEXT
+        remove = []
+        childs = node.childNodes.to_a
+        childs.each do |nd|
+          case _nodeType(nd)
+          when :TEXT
             # TODO: add nil?
-            unless %w(i4 int boolean string double dateTime.iso8601 base64).include? node.nodeName
+            unless %w(i4 i8 int boolean string double dateTime.iso8601 base64).include? node.nodeName
 
-               if node.nodeName == "value" 
+               if node.nodeName == "value"
                  if not node.childNodes.to_a.detect {|n| _nodeType(n) == :ELEMENT}.nil?
-                   remove << nd if nd.nodeValue.strip == "" 
+                   remove << nd if nd.nodeValue.strip == ""
                  end
                else
                  remove << nd if nd.nodeValue.strip == ""
                end
-	    end
-	  when :COMMENT
-	    remove << nd
-	  else
-	    removeWhitespacesAndComments(nd)
-	  end 
-	end
+            end
+          when :COMMENT
+            remove << nd
+          else
+            removeWhitespacesAndComments(nd)
+          end
+        end
 
-	remove.each { |i| node.removeChild(i) }
+        remove.each { |i| node.removeChild(i) }
       end
 
 
       def nodeMustBe(node, name)
-	cmp = case name
-	when Array 
-	  name.include?(node.nodeName)
-	when String
-	  name == node.nodeName
-	else
-	  raise "error"
-	end  
+        cmp = case name
+        when Array
+          name.include?(node.nodeName)
+        when String
+          name == node.nodeName
+        else
+          raise "error"
+        end
 
-	if not cmp then
-	  raise "wrong xml-rpc (name)"
-	end
+        if not cmp then
+          raise "wrong xml-rpc (name)"
+        end
 
-	node
+        node
       end
 
-      #
-      # returns, when successfully the only child-node
-      #
+      # Returns, when successfully the only child-node
       def hasOnlyOneChild(node, name=nil)
-	if node.childNodes.to_a.size != 1
-	  raise "wrong xml-rpc (size)"
-	end
-	if name != nil then
-	  nodeMustBe(node.firstChild, name)
-	end
+        if node.childNodes.to_a.size != 1
+          raise "wrong xml-rpc (size)"
+        end
+        if name != nil then
+          nodeMustBe(node.firstChild, name)
+        end
       end
 
 
       def assert(b)
-	if not b then
-	  raise "assert-fail" 
-	end
+        if not b then
+          raise "assert-fail"
+        end
       end
 
-      # the node `node` has empty string or string
+      # The node `node` has empty string or string
       def text_zero_one(node)
-	nodes = node.childNodes.to_a.size
+        nodes = node.childNodes.to_a.size
 
-	if nodes == 1
-	  text(node.firstChild)
-	elsif nodes == 0
-	  ""
-	else
-	  raise "wrong xml-rpc (size)"
-	end
+        if nodes == 1
+          text(node.firstChild)
+        elsif nodes == 0
+          ""
+        else
+          raise "wrong xml-rpc (size)"
+        end
       end
-     
+
 
       def integer(node)
-	#TODO: check string for float because to_i returnsa
-	#      0 when wrong string
-	 nodeMustBe(node, %w(i4 int))    
-	hasOnlyOneChild(node)
-	
-	Convert.int(text(node.firstChild))
+        #TODO: check string for float because to_i returnsa
+        #      0 when wrong string
+         nodeMustBe(node, %w(i4 i8 int))
+        hasOnlyOneChild(node)
+
+        Convert.int(text(node.firstChild))
       end
 
       def boolean(node)
-	nodeMustBe(node, "boolean")    
-	hasOnlyOneChild(node)
-	
+        nodeMustBe(node, "boolean")
+        hasOnlyOneChild(node)
+
         Convert.boolean(text(node.firstChild))
       end
 
       def v_nil(node)
         nodeMustBe(node, "nil")
-	assert( node.childNodes.to_a.size == 0 )
+        assert( node.childNodes.to_a.size == 0 )
         nil
       end
 
       def string(node)
-	nodeMustBe(node, "string")    
-	text_zero_one(node)
+        nodeMustBe(node, "string")
+        text_zero_one(node)
       end
 
       def double(node)
-	#TODO: check string for float because to_f returnsa
-	#      0.0 when wrong string
-	nodeMustBe(node, "double")    
-	hasOnlyOneChild(node)
-	
-	Convert.double(text(node.firstChild))
+        #TODO: check string for float because to_f returnsa
+        #      0.0 when wrong string
+        nodeMustBe(node, "double")
+        hasOnlyOneChild(node)
+
+        Convert.double(text(node.firstChild))
       end
 
       def dateTime(node)
-	nodeMustBe(node, "dateTime.iso8601")
-	hasOnlyOneChild(node)
-	
+        nodeMustBe(node, "dateTime.iso8601")
+        hasOnlyOneChild(node)
+
         Convert.dateTime( text(node.firstChild) )
       end
 
       def base64(node)
-	nodeMustBe(node, "base64")
-	#hasOnlyOneChild(node)
-	 
+        nodeMustBe(node, "base64")
+        #hasOnlyOneChild(node)
+
         Convert.base64(text_zero_one(node))
       end
 
       def member(node)
-	nodeMustBe(node, "member")
-	assert( node.childNodes.to_a.size == 2 ) 
+        nodeMustBe(node, "member")
+        assert( node.childNodes.to_a.size == 2 )
 
-	[ name(node[0]), value(node[1]) ]
+        [ name(node[0]), value(node[1]) ]
       end
 
       def name(node)
-	nodeMustBe(node, "name")
-	#hasOnlyOneChild(node)
-	text_zero_one(node) 
+        nodeMustBe(node, "name")
+        #hasOnlyOneChild(node)
+        text_zero_one(node)
       end
 
       def array(node)
-	nodeMustBe(node, "array")
-	hasOnlyOneChild(node, "data") 
-	data(node.firstChild)  
+        nodeMustBe(node, "array")
+        hasOnlyOneChild(node, "data")
+        data(node.firstChild)
       end
 
       def data(node)
-	nodeMustBe(node, "data")
+        nodeMustBe(node, "data")
 
-	node.childNodes.to_a.collect do |val|
-	  value(val)
-	end 
+        node.childNodes.to_a.collect do |val|
+          value(val)
+        end
       end
 
       def param(node)
-	nodeMustBe(node, "param")
-	hasOnlyOneChild(node, "value")
-	value(node.firstChild) 
+        nodeMustBe(node, "param")
+        hasOnlyOneChild(node, "value")
+        value(node.firstChild)
       end
- 
+
       def methodResponse(node)
-	nodeMustBe(node, "methodResponse")
-	hasOnlyOneChild(node, %w(params fault))
-	child = node.firstChild
+        nodeMustBe(node, "methodResponse")
+        hasOnlyOneChild(node, %w(params fault))
+        child = node.firstChild
 
-	case child.nodeName
-	when "params"
-	  [ true, params(child,false) ] 
-	when "fault"
-	  [ false, fault(child) ]
-	else
-	  raise "unexpected error"
-	end
+        case child.nodeName
+        when "params"
+          [ true, params(child,false) ]
+        when "fault"
+          [ false, fault(child) ]
+        else
+          raise "unexpected error"
+        end
 
       end
 
       def methodName(node)
-	nodeMustBe(node, "methodName")
-	hasOnlyOneChild(node)
-	text(node.firstChild) 
+        nodeMustBe(node, "methodName")
+        hasOnlyOneChild(node)
+        text(node.firstChild)
       end
 
       def params(node, call=true)
-	nodeMustBe(node, "params")
+        nodeMustBe(node, "params")
 
-	if call 
-	  node.childNodes.to_a.collect do |n|
-	    param(n)
-	  end
-	else # response (only one param)
-	  hasOnlyOneChild(node)
-	  param(node.firstChild)
-	end
+        if call
+          node.childNodes.to_a.collect do |n|
+            param(n)
+          end
+        else # response (only one param)
+          hasOnlyOneChild(node)
+          param(node.firstChild)
+        end
       end
 
       def fault(node)
-	nodeMustBe(node, "fault")
-	hasOnlyOneChild(node, "value")
-	f = value(node.firstChild) 
+        nodeMustBe(node, "fault")
+        hasOnlyOneChild(node, "value")
+        f = value(node.firstChild)
         Convert.fault(f)
       end
 
@@ -380,76 +406,76 @@ module XMLRPC
 
       # _nodeType is defined in the subclass
       def text(node)
-	assert( _nodeType(node) == :TEXT )
-	assert( node.hasChildNodes == false )
-	assert( node.nodeValue != nil )
+        assert( _nodeType(node) == :TEXT )
+        assert( node.hasChildNodes == false )
+        assert( node.nodeValue != nil )
 
-	node.nodeValue.to_s
+        node.nodeValue.to_s
       end
 
       def struct(node)
-	nodeMustBe(node, "struct")    
+        nodeMustBe(node, "struct")
 
-	hash = {}
-	node.childNodes.to_a.each do |me|
-	  n, v = member(me)  
-	  hash[n] = v
-	end 
+        hash = {}
+        node.childNodes.to_a.each do |me|
+          n, v = member(me)
+          hash[n] = v
+        end
 
         Convert.struct(hash)
-     end
+      end
 
 
       def value(node)
-	nodeMustBe(node, "value")
-	nodes = node.childNodes.to_a.size
-        if nodes == 0 
+        nodeMustBe(node, "value")
+        nodes = node.childNodes.to_a.size
+        if nodes == 0
           return ""
-        elsif nodes > 1 
-	  raise "wrong xml-rpc (size)"
+        elsif nodes > 1
+          raise "wrong xml-rpc (size)"
         end
 
-	child = node.firstChild
+        child = node.firstChild
 
-	case _nodeType(child)
-	when :TEXT
+        case _nodeType(child)
+        when :TEXT
           text_zero_one(node)
-	when :ELEMENT
-	  case child.nodeName
-	  when "i4", "int"        then integer(child)
-	  when "boolean"          then boolean(child)
-	  when "string"           then string(child)
-	  when "double"           then double(child)
-	  when "dateTime.iso8601" then dateTime(child)
-	  when "base64"           then base64(child)
-	  when "struct"           then struct(child)
-	  when "array"            then array(child) 
-          when "nil"              
+        when :ELEMENT
+          case child.nodeName
+          when "i4", "i8", "int"  then integer(child)
+          when "boolean"          then boolean(child)
+          when "string"           then string(child)
+          when "double"           then double(child)
+          when "dateTime.iso8601" then dateTime(child)
+          when "base64"           then base64(child)
+          when "struct"           then struct(child)
+          when "array"            then array(child)
+          when "nil"
             if Config::ENABLE_NIL_PARSER
               v_nil(child)
             else
               raise "wrong/unknown XML-RPC type 'nil'"
             end
-	  else 
-	    raise "wrong/unknown XML-RPC type"
-	  end
-	else
-	  raise "wrong type of node"
-	end
+          else
+            raise "wrong/unknown XML-RPC type"
+          end
+        else
+          raise "wrong type of node"
+        end
 
       end
 
       def methodCall(node)
-	nodeMustBe(node, "methodCall")
-	assert( (1..2).include?( node.childNodes.to_a.size ) ) 
-	name = methodName(node[0])
-
-	if node.childNodes.to_a.size == 2 then
-	  pa = params(node[1])
-	else # no parameters given
-	  pa = []
-	end
-	[name, pa]
+        nodeMustBe(node, "methodCall")
+        assert( (1..2).include?( node.childNodes.to_a.size ) )
+        name = methodName(node[0])
+
+        if node.childNodes.to_a.size == 2 then
+          pa = params(node[1])
+        else # no parameters given
+          pa = []
+        end
+        [name, pa]
       end
 
     end # module TreeParserMixin
@@ -461,7 +487,7 @@ module XMLRPC
         raise "No valid method response!" if parser.method_name != nil
         if parser.fault != nil
           # is a fault structure
-          [false, parser.fault] 
+          [false, parser.fault]
         else
           # is a normal return value
           raise "Missing return value!" if parser.params.size == 0
@@ -508,7 +534,7 @@ module XMLRPC
           @value = nil
         when "nil"
           raise "wrong/unknown XML-RPC type 'nil'" unless Config::ENABLE_NIL_PARSER
-          @value = :nil 
+          @value = :nil
         when "array"
           @val_stack << @values
           @values = []
@@ -517,7 +543,7 @@ module XMLRPC
           @name = []
 
           @structs << @struct
-          @struct = {} 
+          @struct = {}
         end
       end
 
@@ -526,7 +552,7 @@ module XMLRPC
         case name
         when "string"
           @value = @data
-        when "i4", "int"
+        when "i4", "i8", "int"
           @value = Convert.int(@data)
         when "boolean"
           @value = Convert.boolean(@data)
@@ -538,7 +564,7 @@ module XMLRPC
           @value = Convert.base64(@data)
         when "value"
           @value = @data if @value.nil?
-          @values << (@value == :nil ? nil : @value) 
+          @values << (@value == :nil ? nil : @value)
         when "array"
           @value = @values
           @values = @val_stack.pop
@@ -548,9 +574,9 @@ module XMLRPC
           @name = @names.pop
           @struct = @structs.pop
         when "name"
-          @name[0] = @data 
+          @name[0] = @data
         when "member"
-          @struct[@name[0]] = @values.pop 
+          @struct[@name[0]] = @values.pop
 
         when "param"
           @params << @values[0]
@@ -560,7 +586,7 @@ module XMLRPC
           @fault = Convert.fault(@values[0])
 
         when "methodName"
-          @method_name = @data 
+          @method_name = @data
         end
 
         @data = nil
@@ -576,7 +602,6 @@ module XMLRPC
 
     end # module StreamParserMixin
 
-    # ---------------------------------------------------------------------------
     class XMLStreamParser < AbstractStreamParser
       def initialize
         require "xmlparser"
@@ -585,14 +610,14 @@ module XMLRPC
         }
       end
     end # class XMLStreamParser
-    # ---------------------------------------------------------------------------
+
     class NQXMLStreamParser < AbstractStreamParser
       def initialize
         require "nqxml/streamingparser"
         @parser_class = XMLRPCParser
       end
 
-      class XMLRPCParser 
+      class XMLRPCParser
         include StreamParserMixin
 
         def parse(str)
@@ -614,59 +639,59 @@ module XMLRPC
       end # class XMLRPCParser
 
     end # class NQXMLStreamParser
-    # ---------------------------------------------------------------------------
+
     class XMLTreeParser < AbstractTreeParser
 
       def initialize
         require "xmltreebuilder"
 
-        # The new XMLParser library (0.6.2+) uses a slightly different DOM implementation. 
+        # The new XMLParser library (0.6.2+) uses a slightly different DOM implementation.
         # The following code removes the differences between both versions.
-        if defined? XML::DOM::Builder 
+        if defined? XML::DOM::Builder
           return if defined? XML::DOM::Node::DOCUMENT # code below has been already executed
           klass = XML::DOM::Node
-          klass.const_set("DOCUMENT", klass::DOCUMENT_NODE)
-          klass.const_set("TEXT", klass::TEXT_NODE)
-          klass.const_set("COMMENT", klass::COMMENT_NODE)
-          klass.const_set("ELEMENT", klass::ELEMENT_NODE)
+          klass.const_set(:DOCUMENT, klass::DOCUMENT_NODE)
+          klass.const_set(:TEXT, klass::TEXT_NODE)
+          klass.const_set(:COMMENT, klass::COMMENT_NODE)
+          klass.const_set(:ELEMENT, klass::ELEMENT_NODE)
         end
       end
 
       private
 
       def _nodeType(node)
-	tp = node.nodeType
-	if tp == XML::SimpleTree::Node::TEXT then :TEXT
-	elsif tp == XML::SimpleTree::Node::COMMENT then :COMMENT 
-	elsif tp == XML::SimpleTree::Node::ELEMENT then :ELEMENT 
-	else :ELSE
-	end
+        tp = node.nodeType
+        if tp == XML::SimpleTree::Node::TEXT then :TEXT
+        elsif tp == XML::SimpleTree::Node::COMMENT then :COMMENT
+        elsif tp == XML::SimpleTree::Node::ELEMENT then :ELEMENT
+        else :ELSE
+        end
       end
 
 
       def methodResponse_document(node)
-	assert( node.nodeType == XML::SimpleTree::Node::DOCUMENT )
-	hasOnlyOneChild(node, "methodResponse")
-	
-	methodResponse(node.firstChild)
+        assert( node.nodeType == XML::SimpleTree::Node::DOCUMENT )
+        hasOnlyOneChild(node, "methodResponse")
+
+        methodResponse(node.firstChild)
       end
 
       def methodCall_document(node)
-	assert( node.nodeType == XML::SimpleTree::Node::DOCUMENT )
-	hasOnlyOneChild(node, "methodCall")
-	
-	methodCall(node.firstChild)
+        assert( node.nodeType == XML::SimpleTree::Node::DOCUMENT )
+        hasOnlyOneChild(node, "methodCall")
+
+        methodCall(node.firstChild)
       end
 
       def createCleanedTree(str)
-	doc = XML::SimpleTreeBuilder.new.parse(str)
-	doc.documentElement.normalize
-	removeWhitespacesAndComments(doc)
-	doc
+        doc = XML::SimpleTreeBuilder.new.parse(str)
+        doc.documentElement.normalize
+        removeWhitespacesAndComments(doc)
+        doc
       end
 
     end # class XMLParser
-    # ---------------------------------------------------------------------------
+
     class NQXMLTreeParser < AbstractTreeParser
 
       def initialize
@@ -676,32 +701,32 @@ module XMLRPC
       private
 
       def _nodeType(node)
-	node.nodeType
+        node.nodeType
       end
 
       def methodResponse_document(node)
-	methodResponse(node)
+        methodResponse(node)
       end
 
       def methodCall_document(node)
-	methodCall(node)
+        methodCall(node)
       end
 
       def createCleanedTree(str)
-        doc = ::NQXML::TreeParser.new(str).document.rootNode 
-	removeWhitespacesAndComments(doc)
-	doc
+        doc = ::NQXML::TreeParser.new(str).document.rootNode
+        removeWhitespacesAndComments(doc)
+        doc
       end
 
     end # class NQXMLTreeParser
-    # ---------------------------------------------------------------------------
+
     class REXMLStreamParser < AbstractStreamParser
       def initialize
         require "rexml/document"
         @parser_class = StreamListener
       end
 
-      class StreamListener 
+      class StreamListener
         include StreamParserMixin
 
         alias :tag_start :startElement
@@ -714,12 +739,12 @@ module XMLRPC
         end
 
         def parse(str)
-          parser = REXML::Document.parse_stream(str, self)
-       end
-      end 
+          REXML::Document.parse_stream(str, self)
+        end
+      end
 
     end
-    # ---------------------------------------------------------------------------
+
     class XMLScanStreamParser < AbstractStreamParser
       def initialize
         require "xmlscan/parser"
@@ -743,7 +768,7 @@ module XMLRPC
         end
 
         alias :on_stag :startElement
- 	alias :on_etag :endElement
+        alias :on_etag :endElement
 
         def on_stag_end(name); end
 
@@ -751,7 +776,7 @@ module XMLRPC
           startElement(name)
           endElement(name)
         end
-       
+
         def on_chardata(str)
           character(str)
         end
@@ -784,16 +809,16 @@ module XMLRPC
         # valid_name?
         # valid_chardata?
         # valid_char?
-        # parse_error  
+        # parse_error
 
       end
     end
-    # ---------------------------------------------------------------------------
+
     XMLParser   = XMLTreeParser
     NQXMLParser = NQXMLTreeParser
 
-    Classes = [XMLStreamParser, XMLTreeParser, 
-               NQXMLStreamParser, NQXMLTreeParser, 
+    Classes = [XMLStreamParser, XMLTreeParser,
+               NQXMLStreamParser, NQXMLTreeParser,
                REXMLStreamParser, XMLScanStreamParser]
 
     # yields an instance of each installed parser