From 46321a9a313d934d23949ccecaa358c1761fd93c Mon Sep 17 00:00:00 2001 From: mame Date: Wed, 1 Oct 2008 13:46:53 +0000 Subject: * 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 --- lib/xmlrpc/client.rb | 12 +- lib/xmlrpc/create.rb | 176 +++++++++++------------ lib/xmlrpc/httpserver.rb | 2 +- lib/xmlrpc/parser.rb | 354 +++++++++++++++++++++++------------------------ lib/xmlrpc/utils.rb | 4 +- 5 files changed, 274 insertions(+), 274 deletions(-) (limited to 'lib/xmlrpc') 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) - "" + "" 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 -- cgit v1.2.3