* lib/xmlrpc, lib/rexml, test/ruby/test_array.rb,

  test/ruby/test_unicode_escape.rb, test/scanf/test_scanf.rb,
  test/rss/rss-assertions.rb: fix indentation to remove warning.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19657 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

5 files changed, 274 insertions, 274 deletions

diff --git a/lib/xmlrpc/client.rb b/lib/xmlrpc/client.rb
index 278855e01d..9d0a8bbaf0 100644
--- a/lib/xmlrpc/client.rb
+++ b/lib/xmlrpc/client.rb
@@ -605,16 +605,16 @@ module XMLRPC
     class Proxy
 
       def initialize(server, prefix, args=[], meth=:call, delim=".")
-	@server = server
-	@prefix = prefix ? prefix + delim : ""
-	@args   = args 
+        @server = server
+        @prefix = prefix ? prefix + delim : ""
+        @args   = args 
         @meth   = meth
       end
 
       def method_missing(mid, *args)
-	pre = @prefix + mid.to_s
-	arg = @args + args
-	@server.send(@meth, pre, *arg)
+        pre = @prefix + mid.to_s
+        arg = @args + args
+        @server.send(@meth, pre, *arg)
       end
 
     end # class Proxy
diff --git a/lib/xmlrpc/create.rb b/lib/xmlrpc/create.rb
index 3c2bbd24e6..530d229f66 100644
--- a/lib/xmlrpc/create.rb
+++ b/lib/xmlrpc/create.rb
@@ -15,11 +15,11 @@ module XMLRPC
 
     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,19 +27,19 @@ 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}/>" 
         else
@@ -61,27 +61,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
@@ -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
@@ -144,23 +144,23 @@ module XMLRPC
     def methodResponse(is_ret, *params)
 
       if is_ret 
-	resp = params.collect do |param|
-	  @writer.ele("param", conv2value(param))
-	end
+        resp = params.collect do |param|
+          @writer.ele("param", conv2value(param))
+        end
      
-	resp = [@writer.ele("params", *resp)]
+        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
@@ -177,11 +177,11 @@ module XMLRPC
     #
     def conv2value(param)
 
-	val = case param
-	when Fixnum 
-	  @writer.tag("i4", param.to_s)
+        val = case param
+        when Fixnum 
+          @writer.tag("i4", param.to_s)
 
-	when Bignum
+        when Bignum
           if Config::ENABLE_BIGINT
             @writer.tag("i4", param.to_s)
           else
@@ -191,14 +191,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 Symbol 
-	  @writer.tag("string", param.to_s)
+        when Symbol 
+          @writer.tag("string", param.to_s)
 
-	when String 
-	  @writer.tag("string", param)
+        when String 
+          @writer.tag("string", param)
 
         when NilClass
           if Config::ENABLE_NIL_CREATE
@@ -207,51 +207,51 @@ 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 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) 
+        when XMLRPC::Base64
+          @writer.tag("base64", param.encoded) 
 
-	else 
+        else 
           if Config::ENABLE_MARSHALLING and param.class.included_modules.include? XMLRPC::Marshallable
             # convert Ruby object into Hash
             ret = {"___class___" => param.class.name}
@@ -274,9 +274,9 @@ module XMLRPC
               raise "Wrong type!"
             end
           end
-	end
-	 
-	@writer.ele("value", val)
+        end
+         
+        @writer.ele("value", val)
     end
 
     def wrong_type(value)
diff --git a/lib/xmlrpc/httpserver.rb b/lib/xmlrpc/httpserver.rb
index 9afb5fd5ec..020e6cbcd9 100644
--- a/lib/xmlrpc/httpserver.rb
+++ b/lib/xmlrpc/httpserver.rb
@@ -156,7 +156,7 @@ private
     # 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
 
diff --git a/lib/xmlrpc/parser.rb b/lib/xmlrpc/parser.rb
index 6d10fde9d9..2cf0530c9f 100644
--- a/lib/xmlrpc/parser.rb
+++ b/lib/xmlrpc/parser.rb
@@ -160,11 +160,11 @@ module XMLRPC
     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
@@ -174,11 +174,11 @@ module XMLRPC
       # 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
 
@@ -189,190 +189,190 @@ module XMLRPC
                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
       #
       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
       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 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 +380,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
+        nodeMustBe(node, "value")
+        nodes = node.childNodes.to_a.size
         if nodes == 0 
           return ""
         elsif nodes > 1 
-	  raise "wrong xml-rpc (size)"
+          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 :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"              
             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
@@ -635,34 +635,34 @@ module XMLRPC
       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
@@ -676,21 +676,21 @@ 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
+        removeWhitespacesAndComments(doc)
+        doc
       end
 
     end # class NQXMLTreeParser
@@ -715,7 +715,7 @@ module XMLRPC
 
         def parse(str)
           parser = REXML::Document.parse_stream(str, self)
-       end
+        end
       end 
 
     end
diff --git a/lib/xmlrpc/utils.rb b/lib/xmlrpc/utils.rb
index f0966fee40..4c2b63c9c6 100644
--- a/lib/xmlrpc/utils.rb
+++ b/lib/xmlrpc/utils.rb
@@ -37,7 +37,7 @@ module XMLRPC
     def create
       # if set_writer was not already called then call it now
       if @create.nil? then
-	set_writer(Config::DEFAULT_WRITER.new)
+        set_writer(Config::DEFAULT_WRITER.new)
       end
       @create
     end
@@ -45,7 +45,7 @@ module XMLRPC
     def parser
       # if set_parser was not already called then call it now
       if @parser.nil? then
-	set_parser(Config::DEFAULT_PARSER.new)
+        set_parser(Config::DEFAULT_PARSER.new)
       end
       @parser
     end