libxml-xmlrpc 0.1.0

data/lib/xml/libxml/xmlrpc.rb

@@ -0,0 +1,18 @@
+require 'xml/libxml/xmlrpc/client'
+require 'xml/libxml/xmlrpc/parser'
+require 'xml/libxml/xmlrpc/builder'
+
+module XML
+    #
+    # XML::XMLRPC -- LibXML interface to XML-RPC
+    # 
+    # Right now, look at XML::XMLRPC::Parser, XML::XMLRPC::Builder
+    # and XML::XMLRPC::Client for docs
+    #
+    # Author:: Erik Hollensbe <erik@hollensbe.org>
+    #
+
+    module XMLRPC
+        VERSION = "0.1.0"
+    end
+end

data/lib/xml/libxml/xmlrpc/builder.rb

@@ -0,0 +1,228 @@
+require 'base64'
+
+module XML
+    module XMLRPC
+        #
+        # Class to build XML-RPC responses and calls.
+        #
+        # Example:
+        #
+        #   XML::XMLRPC::Builder.foo(1,2,3) # generates xml for method call
+        #                                   # 'foo' with arguments of int 1, 2
+        #                                   # and 3
+        #
+        #   XML::XMLRPC::Builder.response(1,2,3) # builds a response with args
+        #                                        # 1,2,3
+        #
+        #   # builds a fault response with faultCode 0 and faultString "Foo"
+        #   XML::XMLRPC::Builder.fault_response(2, "Foo") 
+        #
+        #   # builds a call called 'fault_response'
+        #   XML::XMLRPC::Builder.call('fault_response', 1, 2, 3)
+        #
+        # Notes:
+        #  * To build a Base64 object, check out the XML::XMLRPC::Builder::Base64 class.
+        #  * Date (and all other) objects must inherit directly from class
+        #    Date or be the class themselves, DateTime is an example of direct
+        #    inheritance of Date. Time (which inherits from Object) will NOT
+        #    work.
+        #  * All responses are encoded UTF-8. Be sure your strings, etc are
+        #    UTF-8 before passing them into this module.
+        #
+        module Builder
+            #
+            # Builds the appropriate XML for a methodCall.
+            # 
+            # Takes a methodname and a series of arguments.
+            # 
+            def self.call(methodname, *args)
+                methodname = methodname.to_s
+
+                output = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"
+                output += "<methodCall><methodName>#{methodname}</methodName>"
+                output += Value.generate(*args)
+                output += "</methodCall>"
+
+                return output
+            end
+
+            #
+            # Builds a response. Takes a series of response arguments.
+            #
+            def self.response(*args)
+                output = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"
+                output += "<methodResponse>"
+                output += Value.generate(*args)
+                output += "</methodResponse>"
+
+            end
+
+            #
+            # Builds a fault response. Takes a faultCode (integer) and a faultMessage (string).
+            #
+            def self.fault_response(faultCode, faultMessage)
+                output = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"
+                output += "<methodResponse>"
+                output += "<fault><value><struct>"
+                output += "<member><name>faultCode</name><value><int>#{faultCode}</int></value></member>"
+                output += "<member><name>faultString</name><value><string>#{faultMessage}</string></value></member>"
+                output += "</struct></value></fault>"
+                output += "</methodResponse>"
+            end
+
+            #
+            # Just calls #call, your method name will be the first argument and
+            # will be passed to call properly.
+            #
+            def self.method_missing(*args)
+                self.call(*args)
+            end
+        end
+
+        #
+        # Thrown when Builder encounters an error.
+        #
+        class Builder::Error < Exception
+        end
+
+        #
+        # Base64 type class. The 'Base64' module that comes with ruby does not
+        # hold anything (it's not a class), and since our parser depends on
+        # having the appropriate type to generate the right value clause, this
+        # is required for Base64 transfers.
+        # 
+        class Builder::Base64
+
+            #
+            # Takes a string.
+            #
+            def initialize(str)
+                @string = str
+            end
+
+            #
+            # Encodes the encapsulated string as Base64.
+            #
+            def encode
+                ::Base64.encode64(@string)
+            end
+        end
+
+        #
+        # Generates Values. This has several subclasses that map to
+        # core types which I will not document.
+        # 
+        # RTFS.
+        #
+
+        module Builder::Value
+
+            def self.generate(*args)
+                output = "<params>"
+                args.each do |x|
+                    output += "<param>"
+                    output += self.generate_value(x)
+                    output += "</param>"
+                end
+                output += "</params>"
+
+                return output
+            end
+
+            def self.generate_value(arg)
+                output = "<value>"
+
+                # try the superclass if the class doesn't work (this isn't
+                # perfect but is better than nothing)
+                if arg.class == Builder::Base64
+                    output += Base64.generate(arg)
+                elsif const_get(arg.class.to_s).respond_to? :generate
+                    output += const_get(arg.class.to_s).generate(arg)
+                elsif const_get(arg.class.superclass.to_s).respond_to? :generate
+                    output += const_get(arg.class.superclass.to_s).generate(arg)
+                else
+                    raise Builder::Error, "Type '#{arg.class}' is not supported by XML-RPC"
+                end
+
+                output += "</value>"
+
+                return output
+            end
+
+            module Base64
+                def self.generate(arg)
+                    "<base64>#{arg.encode}</base64>"
+                end
+            end
+
+            module Fixnum
+                def self.generate(arg)
+                    "<int>#{arg}</int>"
+                end
+            end
+
+            module String
+                def self.generate(arg)
+                    "<string>#{arg}</string>"
+                end
+            end
+
+            module Float
+                def self.generate(arg)
+                    "<double>#{arg}</double>"
+                end
+            end
+
+            module Date
+                def self.generate(arg)
+                    "<dateTime.iso8601>" + arg.strftime("%Y%m%dT%T") + "</dateTime.iso8601>"
+                end
+            end
+
+            module Array
+                def self.generate(args)
+                    output = "<array><data>"
+                    args.each do |x|
+                        output += Builder::Value.generate_value(x)
+                    end
+                    output += "</data></array>"
+
+                    return output
+                end
+            end
+
+            module Hash
+                def self.generate(args)
+                    output = "<struct>"
+                    args.each_key do |key|
+                        output += "<member>"
+                        output += "<name>#{key}</name>"
+                        output += Builder::Value.generate_value(args[key])
+                        output += "</member>"
+                    end
+                    output += "</struct>"
+                    return output
+                end
+            end
+
+            module TrueClass
+                def self.generate(arg)
+                    "<boolean>1</boolean>"
+                end
+            end
+
+            module FalseClass
+                def self.generate(arg)
+                    "<boolean>0</boolean>"
+                end
+            end
+
+            module NilClass
+                def self.generate(arg)
+                    # nil is treated as false in our spec
+                    FalseClass.generate(arg)
+                end
+            end
+        end
+    end
+end

data/lib/xml/libxml/xmlrpc/client.rb

@@ -0,0 +1,44 @@
+require 'xml/libxml/xmlrpc/parser'
+require 'xml/libxml/xmlrpc/builder'
+
+module XML
+    module XMLRPC
+        #
+        # Client is an easy-to-use XML-RPC method call and response mechanism.
+        #
+        # It will not handle redirection.
+        #
+        class Client
+            #
+            # Given an unused Net::HTTP object and a relative URL, it will post
+            # the XML-RPC information to this form after calling a method with
+            # ruby types.
+            # 
+            # See XML::XMLRPC::Builder for caveats related to Base64 handling.
+            #
+            def initialize(http, url)
+                @http = http
+                @url  = url
+            end
+
+            #
+            # See #call.
+            # 
+            def method_missing(*args)
+                self.call(*args)
+            end
+
+            #
+            # Call and recieve the response. Returns a XML::XMLRPC::Parser object.
+            #
+            # Will throw an XML::XMLRPC::RemoteCallError if the call returns a
+            # fault response.
+            #
+            def call(methodName, *args)
+                res = @http.post(@url, XML::XMLRPC::Builder.call(methodName, *args))
+                res_args = XML::XMLRPC::Parser.new(res.body)
+                return res_args
+            end
+        end
+    end
+end

data/lib/xml/libxml/xmlrpc/parser.rb

@@ -0,0 +1,259 @@
+require 'xml/libxml'
+require 'base64'
+require 'date'
+require 'stringio'
+
+module XML::XMLRPC
+    class RemoteCallError < Exception
+    end
+    class ParserError < Exception
+    end
+
+    #
+    # Spec-compliant XML-RPC parser. Converts XML-RPC types to native Ruby
+    # types.
+    #
+    # _Overview_:
+    #   <?xml version="1.0"?>
+    #     <methodResponse>
+    #         <params>
+    #             <param>
+    #                 <value><string>South Dakota</string></value>
+    #             </param>
+    #         </params>
+    #     </methodResponse> 
+    #
+    #   xml = XML::XMLRPC::Parser.new(IO or String object)
+    #   xml[0] == "South Dakota"
+    #
+    # Notes:
+    #  * Structs and Arrays are Hashes and Arrays respectively.
+    #  * Base64 is auto-decoded.
+    #  * Any interpreter-level (as opposed to syntax-level or exception
+    #    handling) crash you see in ruby is the fault of libxml, not this code.
+    #  * In a case where you're parsing a methodCall request, the method
+    #    attribute will have data. In the case where you parse a response, method
+    #    will be nil.
+    #
+    class Parser
+
+        include Enumerable
+
+        attr_reader :params
+        attr_reader :method
+
+        #
+        # Takes a String or IO object, which contains a response or call.
+        # 
+        # Parses the document immediately.
+        # 
+        def initialize(io)
+            @string = ""
+
+            if io.kind_of? String
+                @string = io
+            elsif io.kind_of? IO or io.kind_of? StringIO # stupid StringIO
+                @string = io.read
+            else
+                raise ParserError, "Argument to new must be String or IO"
+            end
+
+            @params = []
+            @method = nil
+            self.parse!
+
+            @params.freeze
+            @method.freeze
+        end
+
+        #
+        # Parses the document. Should not be required -- Parser#new already
+        # does this for you.
+        #
+        def parse!
+            document = XML::Parser.string(@string).parse
+            node = document.root
+            case node.name
+            when "methodCall"
+                @method, @params = Parser::Call.parse(node)
+            when "methodResponse"
+                @params = Parser::Response.parse(node)
+            else
+                raise ParserError, "XMLRPC is invalid - no call or response"
+            end
+        end
+
+        #
+        # Obtain param x, where x is an integer.
+        # 
+        # Same as:
+        # 
+        #   xml.params[x]
+        #
+        def [](x)
+            @params[x]
+        end
+
+        #
+        # Iterate over each parameter.
+        #
+
+        def each
+            @params.each do |x|
+                yield x
+            end
+        end
+    end
+
+    #
+    # Parse a methodCall.
+    # 
+
+    module Parser::Call
+        def self.parse(node)
+            method = node.find('/methodCall/methodName')
+            methodname = "unknown"
+            if method and method[0]
+                content = method[0].content
+                methodname = content
+            end
+
+            values = node.find('/methodCall/params/param/value')
+
+            parsed_params = Parser::ValueParser.parse(values)
+
+            return methodname, parsed_params
+        end
+    end
+
+    #
+    # Parse a methodResponse
+    #
+
+    class Parser::Response
+        def self.parse(node)
+            node.each_child do |child_node|
+                case child_node.name.downcase
+                when 'fault'
+                    # RPC call has returned an error - find the fault and GTFO
+                    value = Parser::ValueParser.parse(node.find('/methodResponse/fault/value'))
+                    raise RemoteCallError, value[0][:faultCode].to_s + ": " + value[0][:faultString]
+                when 'params'
+                    return Parser::ValueParser.parse(node.find('/methodResponse/params/param/value'))
+                end
+            end
+        end
+    end
+
+    #
+    # Parse values from a XML::Node::Set or Array of XML::Node objects.
+    #
+    # May be called recursively by ValueParser::Array or ValueParser::Struct.
+    # 
+
+    module Parser::ValueParser
+        def self.parse(values)
+            parsed_params = []
+
+            values.each do |param_value_node|
+                value = nil
+                if param_value_node
+                    param_value_node.each_child do |type|
+                        value = case type.name.downcase
+                                when /^(?:i4|int)$/
+                                    type.content.strip.to_i
+                                when 'string'
+                                    type.content
+                                when 'boolean'
+                                    if type.content.strip.to_i == 1
+                                        true
+                                    else
+                                        false
+                                    end
+                                when 'double'
+                                    type.content.strip.to_f
+                                when 'datetime.iso8601'
+                                    # Looks like this: 19980717T14:08:55
+                                    DateTime.strptime(type.content.strip, "%Y%m%dT%T")
+                                when 'base64'
+                                    Base64.decode64(type.content.strip)
+                                when 'struct'
+                                    Parser::ValueParser::Struct.parse(type)
+                                when 'array'
+                                    Parser::ValueParser::Array.parse(type)
+                                end
+
+                        break if value
+                    end
+                end
+                parsed_params.push value
+            end
+
+            return parsed_params
+        end
+    end
+
+    #
+    # Parse a 'struct' type.
+    #
+
+    module Parser::ValueParser::Struct
+        def self.parse(node)
+            # convert it to a hash with symbols as keys first.
+
+            hash = { }
+
+            node.each_child do |child_node|
+                if child_node.name == "member" 
+                    name = nil
+                    value = nil 
+
+                    child_node.each_child do |member_node|
+                        if member_node.name == "name"
+                            name = member_node.content.strip.to_sym
+                            if value
+                                hash[name] = value
+                                break
+                            end
+                        elsif member_node.name == "value"
+                            value = Parser::ValueParser.parse([member_node])[0]
+                            if name
+                                hash[name] = value
+                                break
+                            end
+                        end
+                    end
+                end
+            end 
+
+            return hash
+        end
+    end
+
+    #
+    # Parse an 'array' type.
+    # 
+
+    module Parser::ValueParser::Array
+        def self.parse(node)
+
+            value = [] 
+
+            node.each_child do |child_node|
+                if child_node.name == "data"
+                    value_nodes = []
+                    child_node.each_child do |value_node|
+                        if value_node.name == "value"
+                            value_nodes.push value_node
+                        end
+                    end
+
+                    value = Parser::ValueParser.parse(value_nodes)
+                    break # yes, first hit is last hit, so says the stay-puff't spec.
+                end
+            end
+
+            return value
+        end
+    end
+end # fin.

data/test/test_builder.rb

@@ -0,0 +1,92 @@
+require 'test/unit'
+require 'xml/libxml/xmlrpc/builder'
+require 'xml/libxml/xmlrpc/parser'
+
+class TestBuilder < Test::Unit::TestCase
+
+    def setup
+        @class = XML::XMLRPC::Builder
+    end
+
+    def test_call
+        # ugh. these sure are ugly.
+        assert_equal(@class.foo,
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>foo</methodName><params></params></methodCall>")
+        assert_equal(@class.bar,
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>bar</methodName><params></params></methodCall>")
+        assert_equal(@class.foo(1), 
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>foo</methodName><params><param><value><int>1</int></value></param></params></methodCall>")
+        assert_equal(@class.foo(1,2,3), 
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>foo</methodName><params><param><value><int>1</int></value></param><param><value><int>2</int></value></param><param><value><int>3</int></value></param></params></methodCall>")
+        assert_equal(@class.foo(nil), 
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>foo</methodName><params><param><value><boolean>0</boolean></value></param></params></methodCall>")
+        assert_equal(@class.foo(Date.civil(1978, 4, 6)), 
+             "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>foo</methodName><params><param><value><dateTime.iso8601>19780406T00:00:00</dateTime.iso8601></value></param></params></methodCall>")
+        assert_equal(@class.foo([1,2,3]), 
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>foo</methodName><params><param><value><array><data><value><int>1</int></value><value><int>2</int></value><value><int>3</int></value></data></array></value></param></params></methodCall>")
+        assert_equal(@class.foo({:Bar => 1, :Foo => 2}), 
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>foo</methodName><params><param><value><struct><member><name>Bar</name><value><int>1</int></value></member><member><name>Foo</name><value><int>2</int></value></member></struct></value></param></params></methodCall>")
+        assert_equal(@class.foo(1, [1,2,3], {:Bar => 1, :Foo => 2}), 
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>foo</methodName><params><param><value><int>1</int></value></param><param><value><array><data><value><int>1</int></value><value><int>2</int></value><value><int>3</int></value></data></array></value></param><param><value><struct><member><name>Bar</name><value><int>1</int></value></member><member><name>Foo</name><value><int>2</int></value></member></struct></value></param></params></methodCall>")
+        assert_equal(@class.foo(XML::XMLRPC::Builder::Base64.new("foo")),
+             "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodCall><methodName>foo</methodName><params><param><value><base64>Zm9v\n</base64></value></param></params></methodCall>")
+
+        # parse test. Our parser should be able to parse what we generate.
+       
+        xml = XML::XMLRPC::Parser.new(@class.foo([1,2,3], { :Bar => 1, :Foo => 2 }, XML::XMLRPC::Builder::Base64.new("foo")))
+        assert_equal(xml[0], [1,2,3])
+        assert_equal(xml[1], { :Bar => 1, :Foo => 2})
+        assert_equal(xml[2], "foo")
+        assert_equal("foo", xml.method)
+
+        # response/fault call test
+        
+        xml = XML::XMLRPC::Parser.new(@class.call('response', 1,2,3))
+        assert_equal(xml[0], 1)
+        assert_equal(xml[1], 2)
+        assert_equal(xml[2], 3) 
+        assert_equal("response", xml.method)
+
+
+        xml = XML::XMLRPC::Parser.new(@class.call('fault_response', 1,2,3))
+        assert_equal(xml[0], 1)
+        assert_equal(xml[1], 2)
+        assert_equal(xml[2], 3) 
+        assert_equal("fault_response", xml.method)
+    end
+
+    def test_response
+        assert_equal(@class.response, 
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodResponse><params></params></methodResponse>")
+        assert_equal(@class.response(nil), 
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodResponse><params><param><value><boolean>0</boolean></value></param></params></methodResponse>")
+        assert_equal(@class.fault_response(0, "foo"), 
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<methodResponse><fault><value><struct><member><name>faultCode</name><value><int>0</int></value></member><member><name>faultString</name><value><string>foo</string></value></member></struct></value></fault></methodResponse>")
+
+        # parser test
+        
+        xml = XML::XMLRPC::Parser.new(@class.response(1,2,3))
+        assert_equal(xml[0], 1)
+        assert_equal(xml[1], 2)
+        assert_equal(xml[2], 3) 
+        assert_equal(xml.method, nil)
+
+        # test faults
+        assert_raise XML::XMLRPC::RemoteCallError do 
+            xml = XML::XMLRPC::Parser.new(@class.fault_response(0, "Foo"))
+        end
+
+        e = nil
+
+        assert_nothing_raised do
+            begin
+                xml = XML::XMLRPC::Parser.new(@class.fault_response(0, "Foo"))
+            rescue XML::XMLRPC::RemoteCallError => error
+                e = error
+            end
+        end
+
+        assert_instance_of(XML::XMLRPC::RemoteCallError, e)
+        assert_equal(e.message, "0: Foo")
+    end
+end

data/test/test_parser_good.rb

@@ -0,0 +1,119 @@
+require 'test/unit'
+require 'xml/libxml/xmlrpc/parser'
+require 'stringio'
+
+class TestParserGood < Test::Unit::TestCase
+    def test_constructor
+        assert_raise XML::XMLRPC::ParserError do
+            XML::XMLRPC::Parser.new(nil)
+        end
+
+        assert_nothing_raised do 
+            XML::XMLRPC::Parser.new(File.open("test/data/big_call.xml"))
+        end
+
+        # should raise a LibXML error because there's nothing to parse
+        # XXX libxml no likey empty string.
+        assert_raise XML::Parser::ParseError do
+            XML::XMLRPC::Parser.new("asdf")
+        end
+    end
+
+    def test_datatypes
+        xml = nil
+
+        assert_nothing_raised do
+            xml = XML::XMLRPC::Parser.new(File.open("test/data/big_call.xml"))
+        end
+
+        # primitives
+        
+        assert_equal(41,    xml[0])
+        assert_equal("41",  xml[1])
+        assert_equal(true,  xml[2])
+        assert_equal(false, xml[3])
+        assert_equal(1.23,  xml[4])
+
+        # DateTime
+        assert_kind_of(DateTime, xml[5])
+        assert_equal("1998-07-17T14:08:55+00:00", xml[5].to_s)
+
+        assert_equal("monkeys", xml[6]) # base64
+
+        assert_kind_of(Array, xml[7])
+        assert_equal([xml[6], xml[5]], xml[7])
+
+        assert_kind_of(Hash, xml[8])
+        assert_equal({ :Monkeys => [xml[6], xml[5]], :Poo => xml[5]}, xml[8])
+
+        assert_equal("examples.getStateName", xml.method)
+    end
+
+    def test_response
+        xml = nil
+
+        assert_raise XML::XMLRPC::RemoteCallError do
+            xml = XML::XMLRPC::Parser.new(File.open("test/data/fail_response.xml"))
+        end
+
+        # ensure the failure message is getting sent properly
+        e = nil
+        begin
+            xml = XML::XMLRPC::Parser.new(File.open("test/data/fail_response.xml"))
+        rescue XML::XMLRPC::RemoteCallError => error
+            e = error
+        end
+
+        assert_equal("4: Too many parameters.", e.message)
+
+        assert_nothing_raised do
+            xml = XML::XMLRPC::Parser.new(File.open("test/data/good_response.xml"))
+        end
+
+        assert_equal("South Dakota", xml[0])
+    end
+
+    def test_functionality
+        xml = nil
+        assert_nothing_raised do
+            xml = XML::XMLRPC::Parser.new(File.open("test/data/big_call.xml"))
+        end
+
+        # Enumerable functionality 
+        xml.each_with_index do |x, i|
+            case i
+            when 0
+                assert_equal(41, x)
+            when 1
+                assert_equal("41", x)
+            when 2
+                assert_equal(true, x)
+            when 3
+                assert_equal(false, x)
+            when 4
+                assert_equal(1.23, x)
+            end
+            # that should be plenty.
+        end
+
+        assert(xml.include?(41))
+    end
+
+    def test_recursion
+        xml = nil
+        assert_nothing_raised do
+            xml = XML::XMLRPC::Parser.new(File.open("test/data/recursion_test.xml"))
+        end
+
+        assert_equal(
+            { 
+                :Poo     => [{
+                    :Poo     => ["monkeys", "19980717T14:08:55"],
+                    :Monkeys => ["monkeys", "19980717T14:08:55"]
+                }], 
+                :Monkeys => ["monkeys", "19980717T14:08:55"]
+            }, 
+            xml[0]
+        )
+    end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: libxml-xmlrpc
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-10-23 00:00:00 -07:00
+summary: Provides a alternative and faster XML-RPC layer through libxml's parsing framework
+require_paths: 
+- lib
+email: erik@hollensbe.org
+homepage: 
+rubyforge_project: libxml-tools
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Erik Hollensbe
+files: 
+- lib/xml
+- lib/xml/libxml
+- lib/xml/libxml/xmlrpc.rb
+- lib/xml/libxml/xmlrpc
+- lib/xml/libxml/xmlrpc/client.rb
+- lib/xml/libxml/xmlrpc/parser.rb
+- lib/xml/libxml/xmlrpc/builder.rb
+- test/test_parser_good.rb
+- test/data
+- test/test_builder.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: libxml-ruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: