* 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

1 files changed, 177 insertions, 177 deletions

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