rubysl-xmlrpc 1.0.0 → 2.0.0

data/lib/xmlrpc/config.rb

@@ -1,36 +1,38 @@
 #
-# $Id: config.rb 11708 2007-02-12 23:01:19Z shyouhei $
+# $Id$
 # Configuration file for XML-RPC for Ruby
 #
 
-module XMLRPC
+module XMLRPC # :nodoc:
 
   module Config
 
-    DEFAULT_WRITER = XMLWriter::Simple            # or XMLWriter::XMLParser
-    
-    # available parser:
-    #   * XMLParser::NQXMLTreeParser
-    #   * XMLParser::NQXMLStreamParser
-    #   * XMLParser::XMLTreeParser
-    #   * XMLParser::XMLStreamParser (fastest)
-    #   * XMLParser::REXMLStreamParser
-    #   * XMLParser::XMLScanStreamParser
+    # or XMLWriter::XMLParser
+    DEFAULT_WRITER = XMLWriter::Simple
+
+    # === Available parsers
+    #
+    # * XMLParser::NQXMLTreeParser
+    # * XMLParser::NQXMLStreamParser
+    # * XMLParser::XMLTreeParser
+    # * XMLParser::XMLStreamParser (fastest)
+    # * XMLParser::REXMLStreamParser
+    # * XMLParser::XMLScanStreamParser
     DEFAULT_PARSER = XMLParser::REXMLStreamParser
 
-    # enable <nil/> tag
+    # enable <code><nil/></code> tag
     ENABLE_NIL_CREATE    = false
     ENABLE_NIL_PARSER    = false
-    
-    # allows integers greater than 32-bit if true
+
+    # allows integers greater than 32-bit if +true+
     ENABLE_BIGINT        = false
 
     # enable marshalling ruby objects which include XMLRPC::Marshallable
-    ENABLE_MARSHALLING   = true 
+    ENABLE_MARSHALLING   = true
 
     # enable multiCall extension by default
     ENABLE_MULTICALL     = false
-    
+
     # enable Introspection extension by default
     ENABLE_INTROSPECTION = false
 

data/lib/xmlrpc/create.rb

@@ -1,25 +1,23 @@
 #
-# Creates XML-RPC call/response documents
-# 
 # Copyright (C) 2001, 2002, 2003 by Michael Neumann (mneumann@ntecs.de)
 #
-# $Id: create.rb 11818 2007-02-23 03:45:55Z knu $
+# $Id$
 #
 
 require "date"
 require "xmlrpc/base64"
 
-module XMLRPC
+module XMLRPC # :nodoc:
 
   module XMLWriter
 
     class Abstract
       def ele(name, *children)
-	element(name, nil, *children)
+        element(name, nil, *children)
       end
 
       def tag(name, txt)
-	element(name, nil, text(txt))
+        element(name, nil, text(txt))
       end
     end
 
@@ -27,21 +25,21 @@ module XMLRPC
     class Simple < Abstract
 
       def document_to_str(doc)
-	doc
+        doc
       end
 
       def document(*params)
-	params.join("")
+        params.join("")
       end
 
       def pi(name, *params)
-	"<?#{name} " + params.join(" ") + " ?>"
+        "<?#{name} " + params.join(" ") + " ?>"
       end
 
       def element(name, attrs, *children)
-	raise "attributes not yet implemented" unless attrs.nil?
+        raise "attributes not yet implemented" unless attrs.nil?
         if children.empty?
-          "<#{name}/>" 
+          "<#{name}/>"
         else
           "<#{name}>" + children.join("") + "</#{name}>"
         end
@@ -61,27 +59,27 @@ module XMLRPC
     class XMLParser < Abstract
 
       def initialize
-	require "xmltreebuilder"
+        require "xmltreebuilder"
       end
 
       def document_to_str(doc)
-	doc.to_s
+        doc.to_s
       end
 
       def document(*params)
-	XML::SimpleTree::Document.new(*params) 
+        XML::SimpleTree::Document.new(*params)
       end
 
       def pi(name, *params)
-	XML::SimpleTree::ProcessingInstruction.new(name, *params)
+        XML::SimpleTree::ProcessingInstruction.new(name, *params)
       end
 
       def element(name, attrs, *children)
-	XML::SimpleTree::Element.new(name, attrs, *children)
+        XML::SimpleTree::Element.new(name, attrs, *children)
       end
 
       def text(txt)
-	XML::SimpleTree::Text.new(txt)
+        XML::SimpleTree::Text.new(txt)
       end
 
     end # class XMLParser
@@ -100,6 +98,8 @@ module XMLRPC
 
   end # module XMLWriter
 
+  # Creates XML-RPC call/response documents
+  #
   class Create
 
     def initialize(xml_writer = nil)
@@ -111,20 +111,20 @@ module XMLRPC
       name = name.to_s
 
       if name !~ /[a-zA-Z0-9_.:\/]+/
-	raise ArgumentError, "Wrong XML-RPC method-name"
+        raise ArgumentError, "Wrong XML-RPC method-name"
       end
 
       parameter = params.collect do |param|
-	@writer.ele("param", conv2value(param))
+        @writer.ele("param", conv2value(param))
       end
 
       tree = @writer.document(
-	       @writer.pi("xml", 'version="1.0"'),
-	       @writer.ele("methodCall",   
-		 @writer.tag("methodName", name),
-		 @writer.ele("params", *parameter)    
-	       )
-	     )
+               @writer.pi("xml", 'version="1.0"'),
+               @writer.ele("methodCall",
+                 @writer.tag("methodName", name),
+                 @writer.ele("params", *parameter)
+               )
+             )
 
       @writer.document_to_str(tree) + "\n"
     end
@@ -132,56 +132,51 @@ module XMLRPC
 
 
     #
-    # generates a XML-RPC methodResponse document
+    # Generates a XML-RPC methodResponse document
     #
-    # if is_ret == false then the params array must
+    # When +is_ret+ is +false+ then the +params+ array must
     # contain only one element, which is a structure
     # of a fault return-value.
-    # 
-    # if is_ret == true then a normal 
-    # return-value of all the given params is created.
+    #
+    # When +is_ret+ is +true+ then a normal
+    # return-value of all the given +params+ is created.
     #
     def methodResponse(is_ret, *params)
 
-      if is_ret 
-	resp = params.collect do |param|
-	  @writer.ele("param", conv2value(param))
-	end
-     
-	resp = [@writer.ele("params", *resp)]
+      if is_ret
+        resp = params.collect do |param|
+          @writer.ele("param", conv2value(param))
+        end
+
+        resp = [@writer.ele("params", *resp)]
       else
-	if params.size != 1 or params[0] === XMLRPC::FaultException 
-	  raise ArgumentError, "no valid fault-structure given"
-	end
-	resp = @writer.ele("fault", conv2value(params[0].to_h))
+        if params.size != 1 or params[0] === XMLRPC::FaultException
+          raise ArgumentError, "no valid fault-structure given"
+        end
+        resp = @writer.ele("fault", conv2value(params[0].to_h))
       end
 
-	
+
       tree = @writer.document(
-	       @writer.pi("xml", 'version="1.0"'),
-	       @writer.ele("methodResponse", resp) 
-	     )
+               @writer.pi("xml", 'version="1.0"'),
+               @writer.ele("methodResponse", resp)
+             )
 
       @writer.document_to_str(tree) + "\n"
     end
 
 
 
-    #####################################
     private
-    #####################################
 
     #
-    # converts a Ruby object into
-    # a XML-RPC <value> tag
+    # Converts a Ruby object into a XML-RPC <code><value></code> tag
     #
-    def conv2value(param)
-
-	val = case param
-	when Fixnum 
-	  @writer.tag("i4", param.to_s)
+    def conv2value(param) # :doc:
 
-	when Bignum
+        val = case param
+        when Fixnum, Bignum
+          # XML-RPC's int is 32bit int, and Fixnum also may be beyond 32bit
           if Config::ENABLE_BIGINT
             @writer.tag("i4", param.to_s)
           else
@@ -191,14 +186,14 @@ module XMLRPC
               raise "Bignum is too big! Must be signed 32-bit integer!"
             end
           end
-	when TrueClass, FalseClass
-	  @writer.tag("boolean", param ? "1" : "0")
+        when TrueClass, FalseClass
+          @writer.tag("boolean", param ? "1" : "0")
 
-	when String 
-	  @writer.tag("string", param)
+        when Symbol
+          @writer.tag("string", param.to_s)
 
-	when Symbol 
-	  @writer.tag("string", param.to_s)
+        when String
+          @writer.tag("string", param)
 
         when NilClass
           if Config::ENABLE_NIL_CREATE
@@ -207,55 +202,56 @@ module XMLRPC
             raise "Wrong type NilClass. Not allowed!"
           end
 
-	when Float
-	  @writer.tag("double", param.to_s)
-
-	when Struct
-	  h = param.members.collect do |key| 
-	    value = param[key]
-	    @writer.ele("member", 
-	      @writer.tag("name", key.to_s),
-	      conv2value(value) 
-	    )
-	  end
-
-	  @writer.ele("struct", *h) 
-
-	when Hash
-	  # TODO: can a Hash be empty?
-	  
-	  h = param.collect do |key, value|
-	    @writer.ele("member", 
-	      @writer.tag("name", key.to_s),
-	      conv2value(value) 
-	    )
-	  end
-
-	  @writer.ele("struct", *h) 
-
-	when Array
-	  # TODO: can an Array be empty?
-	  a = param.collect {|v| conv2value(v) }
-	  
-	  @writer.ele("array", 
-	    @writer.ele("data", *a)
-	  )
-
-	when Time, Date, ::DateTime
-	  @writer.tag("dateTime.iso8601", param.strftime("%Y%m%dT%H:%M:%S"))  
-
-	when XMLRPC::DateTime
-	  @writer.tag("dateTime.iso8601", 
-	    format("%.4d%02d%02dT%02d:%02d:%02d", *param.to_a))
-   
-	when XMLRPC::Base64
-	  @writer.tag("base64", param.encoded) 
-
-	else 
+        when Float
+          raise "Wrong value #{param}. Not allowed!" unless param.finite?
+          @writer.tag("double", param.to_s)
+
+        when Struct
+          h = param.members.collect do |key|
+            value = param[key]
+            @writer.ele("member",
+              @writer.tag("name", key.to_s),
+              conv2value(value)
+            )
+          end
+
+          @writer.ele("struct", *h)
+
+        when Hash
+          # TODO: can a Hash be empty?
+
+          h = param.collect do |key, value|
+            @writer.ele("member",
+              @writer.tag("name", key.to_s),
+              conv2value(value)
+            )
+          end
+
+          @writer.ele("struct", *h)
+
+        when Array
+          # TODO: can an Array be empty?
+          a = param.collect {|v| conv2value(v) }
+
+          @writer.ele("array",
+            @writer.ele("data", *a)
+          )
+
+        when Time, Date, ::DateTime
+          @writer.tag("dateTime.iso8601", param.strftime("%Y%m%dT%H:%M:%S"))
+
+        when XMLRPC::DateTime
+          @writer.tag("dateTime.iso8601",
+            format("%.4d%02d%02dT%02d:%02d:%02d", *param.to_a))
+
+        when XMLRPC::Base64
+          @writer.tag("base64", param.encoded)
+
+        else
           if Config::ENABLE_MARSHALLING and param.class.included_modules.include? XMLRPC::Marshallable
             # convert Ruby object into Hash
             ret = {"___class___" => param.class.name}
-            param.instance_variables.each {|v| 
+            param.instance_variables.each {|v|
               name = v[1..-1]
               val = param.instance_variable_get(v)
 
@@ -266,24 +262,24 @@ module XMLRPC
               end
             }
             return conv2value(ret)
-          else 
+          else
             ok, pa = wrong_type(param)
             if ok
               return conv2value(pa)
-            else 
+            else
               raise "Wrong type!"
             end
           end
-	end
-	 
-	@writer.ele("value", val)
+        end
+
+        @writer.ele("value", val)
     end
 
     def wrong_type(value)
       false
     end
 
-    
+
   end # class Create
 
 end # module XMLRPC

data/lib/xmlrpc/datetime.rb

@@ -1,115 +1,95 @@
-=begin
-= xmlrpc/datetime.rb
-Copyright (C) 2001, 2002, 2003 by Michael Neumann (mneumann@ntecs.de)
-
-Released under the same term of license as Ruby.
-
-= Classes
-* ((<XMLRPC::DateTime>))
-
-= XMLRPC::DateTime
-== Description
-This class is important to handle XMLRPC (('dateTime.iso8601')) values,
-correcly, because normal UNIX-dates (class (({Date}))) only handle dates 
-from year 1970 on, and class (({Time})) handles dates without the time
-component. (({XMLRPC::DateTime})) is able to store a XMLRPC 
-(('dateTime.iso8601')) value correctly.
-
-== Class Methods
---- XMLRPC::DateTime.new( year, month, day, hour, min, sec )
-    Creates a new (({XMLRPC::DateTime})) instance with the
-    parameters ((|year|)), ((|month|)), ((|day|)) as date and 
-    ((|hour|)), ((|min|)), ((|sec|)) as time.
-    Raises (({ArgumentError})) if a parameter is out of range, or ((|year|)) is not
-    of type (({Integer})).
-    
-== Instance Methods
---- XMLRPC::DateTime#year
---- XMLRPC::DateTime#month
---- XMLRPC::DateTime#day
---- XMLRPC::DateTime#hour
---- XMLRPC::DateTime#min
---- XMLRPC::DateTime#sec
-    Return the value of the specified date/time component.
-
---- XMLRPC::DateTime#mon
-    Alias for ((<XMLRPC::DateTime#month>)).
-
---- XMLRPC::DateTime#year=( value )
---- XMLRPC::DateTime#month=( value )
---- XMLRPC::DateTime#day=( value )
---- XMLRPC::DateTime#hour=( value )
---- XMLRPC::DateTime#min=( value )
---- XMLRPC::DateTime#sec=( value )
-    Set ((|value|)) as the new date/time component.
-    Raises (({ArgumentError})) if ((|value|)) is out of range, or in the case
-    of (({XMLRPC::DateTime#year=})) if ((|value|)) is not of type (({Integer})).
-
---- XMLRPC::DateTime#mon=( value )
-    Alias for ((<XMLRPC::DateTime#month=>)).
-
---- XMLRPC::DateTime#to_time
-    Return a (({Time})) object of the date/time which (({self})) represents.
-    If the (('year')) is below 1970, this method returns (({nil})), 
-    because (({Time})) cannot handle years below 1970.
-    The used timezone is GMT.
-
---- XMLRPC::DateTime#to_date
-    Return a (({Date})) object of the date which (({self})) represents.
-    The (({Date})) object do ((*not*)) contain the time component (only date).
-
---- XMLRPC::DateTime#to_a
-    Returns all date/time components in an array.
-    Returns (({[year, month, day, hour, min, sec]})).
-=end
-
+#
+# xmlrpc/datetime.rb
+# Copyright (C) 2001, 2002, 2003 by Michael Neumann (mneumann@ntecs.de)
+#
+# Released under the same term of license as Ruby.
+#
 require "date"
 
-module XMLRPC
+module XMLRPC # :nodoc:
 
+# This class is important to handle XMLRPC +dateTime.iso8601+ values,
+# correcly, because normal UNIX-dates, ie: Date, only handle dates
+# from year 1970 on, and ruby's native Time class handles dates without the
+# time component.
+#
+# XMLRPC::DateTime is able to store a XMLRPC +dateTime.iso8601+ value correctly.
 class DateTime
-  
+
+  # Return the value of the specified date/time component.
   attr_reader :year, :month, :day, :hour, :min, :sec
 
+  # Set +value+ as the new date/time component.
+  #
+  # Raises ArgumentError if the given +value+ is out of range, or in the case
+  # of XMLRPC::DateTime#year= if +value+ is not of type Integer.
   def year= (value)
     raise ArgumentError, "date/time out of range" unless value.is_a? Integer
     @year = value
   end
 
+  # Set +value+ as the new date/time component.
+  #
+  # Raises an ArgumentError if the given +value+ isn't between 1 and 12.
   def month= (value)
     raise ArgumentError, "date/time out of range" unless (1..12).include? value
     @month = value
   end
 
+  # Set +value+ as the new date/time component.
+  #
+  # Raises an ArgumentError if the given +value+ isn't between 1 and 31.
   def day= (value)
     raise ArgumentError, "date/time out of range" unless (1..31).include? value
     @day = value
   end
 
+  # Set +value+ as the new date/time component.
+  #
+  # Raises an ArgumentError if the given +value+ isn't between 0 and 24.
   def hour= (value)
     raise ArgumentError, "date/time out of range" unless (0..24).include? value
     @hour = value
   end
 
+  # Set +value+ as the new date/time component.
+  #
+  # Raises an ArgumentError if the given +value+ isn't between 0 and 59.
   def min= (value)
     raise ArgumentError, "date/time out of range" unless (0..59).include? value
     @min = value
   end
 
+  # Set +value+ as the new date/time component.
+  #
+  # Raises an ArgumentError if the given +value+ isn't between 0 and 59.
   def sec= (value)
     raise ArgumentError, "date/time out of range" unless (0..59).include? value
     @sec = value
   end
 
+  # Alias for XMLRPC::DateTime#month.
   alias mon  month
-  alias mon= month= 
- 
+  # Alias for XMLRPC::DateTime#month=.
+  alias mon= month=
+
 
+  # Creates a new XMLRPC::DateTime instance with the
+  # parameters +year+, +month+, +day+ as date and
+  # +hour+, +min+, +sec+ as time.
+  #
+  # Raises an ArgumentError if a parameter is out of range,
+  # or if +year+ is not of the Integer type.
   def initialize(year, month, day, hour, min, sec)
     self.year, self.month, self.day = year, month, day
     self.hour, self.min, self.sec   = hour, min, sec
   end
- 
+
+  # Return a Time object of the date/time which represents +self+.
+  # If the <code>@year</code> is below 1970, this method returns +nil+,
+  # because Time cannot handle years below 1970.
+  #
+  # The timezone used is GMT.
   def to_time
     if @year >= 1970
       Time.gm(*to_a)
@@ -118,16 +98,23 @@ class DateTime
     end
   end
 
+  # Return a Date object of the date which represents +self+.
+  #
+  # The Date object do _not_ contain the time component (only date).
   def to_date
     Date.new(*to_a[0,3])
   end
 
+  # Returns all date/time components in an array.
+  #
+  # Returns +[year, month, day, hour, min, sec]+.
   def to_a
     [@year, @month, @day, @hour, @min, @sec]
   end
 
+  # Returns whether or not all date/time components are an array.
   def ==(o)
-    Array(self) == Array(o)
+    self.to_a == Array(o) rescue false
   end
 
 end
@@ -138,5 +125,5 @@ end # module XMLRPC
 
 =begin
 = History
-    $Id: datetime.rb 11708 2007-02-12 23:01:19Z shyouhei $
+    $Id$
 =end