lolsoap 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3681b9eceff632682da6150a24165ce5602e29f8
-  data.tar.gz: 6fd0baf415e478dc90541ca8f35ccbbbcf7686ed
+  metadata.gz: 581a7842c694777a4af6b960f266eaebbf9e9431
+  data.tar.gz: 095e4cd38b1e59af2ff5514a560725f02d21b867
 SHA512:
-  metadata.gz: 5f483f1121e5e187591ccad41044bfac1312c049d24486f781e99125c143717527571d2c1c9c8de554198c441ed1d2776f02eb2bbebdf7ef761cf12c4ff484c9
-  data.tar.gz: aeef28d7bf905ee29f35ce754bbea3754aa0ef2946183cb3f9802d536283ed8e039446a8f84c28e114947da5350a539f18f91a594af61624ac495f6cbe146930
+  metadata.gz: d26800dfb89edd5bb9378a280d6be073d57ff8e273d1865b7b5cfde5ab5d83c9d3f757bb71df2213987c57c741947985d76127ea1e629b3c5e4cff963bcbd4e1
+  data.tar.gz: 44a08cfc2ecc91f15bcc54a442d37b912fe831d8a1bb013503efc52d392d2e04f2b0a5d4afeb684c28cbced4734048358544bef0b03195b566ee96966c95017e

data/README.md

@@ -114,6 +114,16 @@ Development sponsored by [Loco2](http://loco2.com/).
 
 ## Changelog ##
 
+### 0.7 ###
+
+* Added support for element references in type definitions
+* Added support for operations with multipart header/body
+* Added support for multipart messages in WSDL
+
+### 0.6 ###
+
+* Support SOAP Header types
+
 ### 0.5 ###
 
 * Generate our own namespace prefixes rather than using ones from the

data/lib/lolsoap/envelope.rb

@@ -26,14 +26,14 @@ module LolSoap
     #     b.some 'data'
     #   end
     def body(klass = Builder)
-      builder = klass.new(body_content, input_body_type)
+      builder = klass.new(body_content, input_body_content_type)
       yield builder if block_given?
       builder
     end
 
     # Build the header of the envelope
     def header(klass = Builder)
-      builder = klass.new(header_content, input_header_type)
+      builder = klass.new(header_content, input_header_content_type)
       yield builder if block_given?
       builder
     end
@@ -54,16 +54,24 @@ module LolSoap
       input.header
     end
 
-    def input_header_type
-      input_header && input_header.type
+    def input_header_content
+      input_header.content
+    end
+
+    def input_header_content_type
+      input_header.content_type
     end
 
     def input_body
       input.body
     end
 
-    def input_body_type
-      input_body.type
+    def input_body_content
+      input_body.content
+    end
+
+    def input_body_content_type
+      input_body.content_type
     end
 
     def output
@@ -82,8 +90,12 @@ module LolSoap
       output.body
     end
 
-    def output_body_type
-      output_body.type
+    def output_body_content
+      output_body.content
+    end
+
+    def output_body_content_type
+      output_body.content_type
     end
 
     def to_xml(options = {})
@@ -105,7 +117,7 @@ module LolSoap
     private
 
     # @private
-    def header_content; @header_content || @header; end
+    def header_content; @header_content; end
 
     # @private
     def body_content; @body_content; end
@@ -117,24 +129,29 @@ module LolSoap
       namespaces = Hash[wsdl.namespaces.map { |prefix, uri| [prefix, root.add_namespace(prefix, uri)] }]
       namespaces[soap_prefix] = root.add_namespace(soap_prefix, soap_namespace)
 
-      @header = doc.create_element 'Header'
-      if input_header
-        @header_content = doc.create_element input_header.name
+      @header = doc.create_element input_header.name
+      @body   = doc.create_element input_body.name
+
+      [root, @header, @body].each { |el| el.namespace = namespaces[soap_prefix] }
+
+      if input_header_content
+        @header_content = doc.create_element input_header_content.name
+        @header_content.namespace = namespaces[input_header_content.prefix]
         @header << @header_content
       else
-        @header_content = nil
+        @header_content = @header
       end
 
-      body = doc.create_element 'Body'
-      @body_content = doc.create_element input_body.name
-
-      [root, @header, body].each { |el| el.namespace = namespaces[soap_prefix] }
-      @header_content.namespace = namespaces[input_header.prefix] if @header_content
-      @body_content.namespace = namespaces[input_body.prefix]
+      if input_body_content
+        @body_content = doc.create_element input_body_content.name
+        @body_content.namespace = namespaces[input_body_content.prefix]
+        @body << @body_content
+      else
+        @body_content = @body
+      end
 
-      body << @body_content
       root << @header
-      root << body
+      root << @body
     end
   end
 end

data/lib/lolsoap/request.rb

@@ -36,12 +36,12 @@ module LolSoap
 
     # The type of the element sent in the request body
     def input_type
-      envelope.input_body_type
+      envelope.input_body_content_type
     end
 
     # The type of the element that will be received in the response body
     def output_type
-      envelope.output_body_type
+      envelope.output_body_content_type
     end
 
     # The MIME type of the request. This is always application/soap+xml,

data/lib/lolsoap/version.rb

@@ -1,3 +1,3 @@
 module LolSoap
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

data/lib/lolsoap/wsdl/operation_io_part.rb

@@ -0,0 +1,25 @@
+class LolSoap::WSDL
+  class OperationIOPart < Element
+    def initialize(wsdl, name, type_reference)
+      super(wsdl, name, 'soap', type_reference)
+    end
+
+    def single_part?
+      type.elements.size == 1
+    end
+
+    def content
+      if single_part?
+        type.element(type.elements.keys.first)
+      end
+    end
+
+    def content_type
+      if content
+        content.type
+      else
+        type
+      end
+    end
+  end
+end

data/lib/lolsoap/wsdl.rb

@@ -10,6 +10,7 @@ module LolSoap
     require 'lolsoap/wsdl/null_type'
     require 'lolsoap/wsdl/element'
     require 'lolsoap/wsdl/null_element'
+    require 'lolsoap/wsdl/operation_io_part'
 
     # Create a new instance by parsing a raw string of XML
     def self.parse(raw)
@@ -114,7 +115,7 @@ module LolSoap
     def build_type(params)
       Type.new(
         params[:name],
-        prefix(params.fetch(:namespace)),
+        params[:prefix] || prefix(params.fetch(:namespace)),
         build_elements(params.fetch(:elements)),
         params.fetch(:attributes)
       )
@@ -152,9 +153,35 @@ module LolSoap
     # @private
     def build_io(io, parser)
       OperationIO.new(
-        io[:header] && build_element(parser.elements[io[:header]]),
-        build_element(parser.elements[io[:body]])
+        build_io_part('Header', io[:header], parser),
+        build_io_part('Body', io[:body], parser)
       )
     end
+
+    # @private
+    def build_io_part(name, elements, parser)
+      OperationIOPart.new(
+        self,
+        name,
+        type_reference(io_part_type(name, elements, parser))
+      )
+    end
+
+    # @private
+    def io_part_type(name, elements, parser)
+      return unless elements.any?
+
+      {
+        :name       => name,
+        :prefix     => 'soap',
+        :elements   => Hash[
+          elements.map { |el|
+            element = parser.elements.fetch(el)
+            [element[:name], element]
+          }
+        ],
+        :attributes => []
+      }
+    end
   end
 end

data/lib/lolsoap/wsdl_parser.rb

@@ -4,6 +4,8 @@ require 'cgi'
 module LolSoap
   # @private
   class WSDLParser
+    class ParseError < StandardError; end
+
     class Node
       attr_reader :parser, :node, :target_namespace, :name, :namespace
 
@@ -44,6 +46,31 @@ module LolSoap
       end
     end
 
+    class ReferencedElement
+      attr_reader :reference, :element
+
+      def initialize(reference, element)
+        @reference = reference
+        @element   = element
+      end
+
+      def name
+        element.name
+      end
+
+      def namespace
+        element.namespace
+      end
+
+      def type
+        element.type
+      end
+
+      def singular
+        reference.singular
+      end
+    end
+
     class Type < Node
       def elements
         parent_elements.merge(own_elements)
@@ -81,7 +108,12 @@ module LolSoap
 
       def element_nodes
         node.xpath('*/xs:element | */*/xs:element | xs:complexContent/xs:extension/*/xs:element | xs:complexContent/xs:extension/*/*/xs:element', parser.ns).map { |el|
-          Element.new(parser, el, target_namespace)
+          element = Element.new(parser, el, target_namespace)
+          if reference = el.attribute('ref')
+            ReferencedElement.new(element, parser.element(reference.to_s))
+          else
+            element
+          end
         }
       end
 
@@ -115,33 +147,61 @@ module LolSoap
       end
 
       def input
-        @input ||= OperationIO.new(
-          header(:input),
-          port_type_operation[:input]
-        )
+        @input ||= operation_io(:input)
       end
 
       def output
-        @output ||= OperationIO.new(
-          header(:output),
-          port_type_operation[:output]
-        )
+        @output ||= operation_io(:output)
       end
 
-      private
-
       def port_type_operation
         parser.port_type_operations.fetch(name)
       end
 
-      def header(direction)
-        if msg = node.at_xpath("./d:#{direction}/s:header/@message", parser.ns)
-          parser.messages.fetch(msg.to_s.split(':').last)
-        end
+      private
+
+      def operation_io(direction)
+        OperationIO.new(parser, self, node.at_xpath("d:#{direction}", parser.ns))
       end
     end
 
-    class OperationIO < Struct.new(:header, :body)
+    class OperationIO < Struct.new(:parser, :operation, :node)
+      def name
+        node.name
+      end
+
+      def header
+        @header ||= part_elements(:header)
+      end
+
+      def body
+        @body ||= part_elements(:body)
+      end
+
+      private
+
+      def operation_message
+        operation.port_type_operation[name.to_sym]
+      end
+
+      def part_elements(name)
+        nodes = node.xpath("s:#{name}", parser.ns)
+        return [] unless nodes
+
+        nodes.map { |node|
+          parts = parser.messages.fetch((node['message'] || operation_message).to_s.split(':').last)
+
+          parts.fetch(node['parts'] || node['part']) do |part_name|
+            if parts.size == 1
+              if name == :body
+                parts.values.first
+              end
+            else
+              raise ParseError, "Can't determine which part of #{message_name} to use as #{operation.name} #{self.name} #{name}"
+            end
+          end
+        }.compact
+      end
     end
 
     SOAP_1_1 = 'http://schemas.xmlsoap.org/wsdl/soap/'
@@ -182,11 +242,7 @@ module LolSoap
     end
 
     def type(name)
-      name = name.split(":").last
-      if node = doc.at_xpath("//xs:complexType[@name='#{name}']", ns)
-        target_namespace = node.at_xpath('parent::xs:schema/@targetNamespace', ns).to_s
-        Type.new(self, node, target_namespace)
-      end
+      find_node name, Type, 'complexType'
     end
 
     def elements
@@ -204,23 +260,38 @@ module LolSoap
       end
     end
 
+    def element(name)
+      find_node name, Element, 'element'
+    end
+
     def messages
       @messages ||= Hash[
-        doc.xpath('/d:definitions/d:message', ns).map do |msg|
-          part = msg.at_xpath("d:part", ns)
-          [msg.attribute('name').to_s, namespace_and_name(part, part['element'])]
-        end
+        doc.xpath('/d:definitions/d:message', ns).map { |msg|
+          [
+            msg.attribute('name').to_s,
+            Hash[
+              msg.xpath('d:part', ns).map { |part|
+                [
+                  part.attribute('name').to_s,
+                  namespace_and_name(part, part['element'])
+                ]
+              }
+            ]
+          ]
+        }
       ]
     end
 
     def port_type_operations
       @port_type_operations ||= Hash[
         doc.xpath('/d:definitions/d:portType/d:operation', ns).map do |op|
-          input  = op.at_xpath('./d:input/@message',  ns).to_s.split(':').last
-          output = op.at_xpath('./d:output/@message', ns).to_s.split(':').last
-          name   = op.attribute('name').to_s
-
-          [name, { :input => messages.fetch(input), :output => messages.fetch(output) }]
+          [
+            op.attribute('name').to_s,
+            {
+              :input  => op.at_xpath('./d:input/@message',  ns).to_s,
+              :output => op.at_xpath('./d:output/@message', ns).to_s
+            }
+          ]
         end
       ]
     end
@@ -285,6 +356,13 @@ module LolSoap
         end
       end
     end
+
+    def find_node(name, node_class, selector)
+      name = name.split(":").last
+      if node = doc.at_xpath("//xs:#{selector}[@name='#{name}']", ns)
+        target_namespace = node.at_xpath('parent::xs:schema/@targetNamespace', ns).to_s
+        node_class.new(self, node, target_namespace)
+      end
+    end
   end
 end
-

data/test/fixtures/stock_quote.wsdl

@@ -27,19 +27,25 @@
            </all>
          </complexType>
       </element>
-      <element name="tradePriceRequestHeader">
+      <element name="specialTickerSymbol" type="xsd2:TickerSymbol"/>
+      <element name="authentication">
         <sequence>
           <element name="username" type="xs:string"/>
           <element name="password" type="xs:string"/>
         </sequence>
       </element>
+      <element name="tradePriceRequestHeader">
+        <sequence>
+          <element name="requestID" type="xs:string"/>
+        </sequence>
+      </element>
       <element name="tradePriceRequest" type="xsd1:TradePriceRequest" />
       <complexType name="xsd1:TradePriceRequest" abstract="false">
         <complexContent>
           <extension base="xsd1:BaseRequest">
             <sequence>
               <element name="tickerSymbol" type="xs:string" maxOccurs="5"/>
-              <element name="specialTickerSymbol" type="xsd2:TickerSymbol" maxOccurs="unbounded"/>
+              <element ref="tns:specialTickerSymbol" maxOccurs="unbounded"/>
             </sequence>
             <attribute name="id" type="xs:string"/>
           </extension>
@@ -90,9 +96,11 @@
 
   <message name="GetLastTradePriceInputHeader">
     <part name="header" element="xsd1:tradePriceRequestHeader"/>
+    <part name="header2" element="xsd1:authentication"/>
   </message>
 
   <message name="GetLastTradePriceInput">
+    <part name="foo" xmlns:foo="http://example.com/stockquote.xsd" element="xs:string"/>
     <part name="body" xmlns:foo="http://example.com/stockquote.xsd" element="foo:tradePriceRequest"/>
   </message>
 
@@ -124,8 +132,9 @@
     <operation name="GetLastTradePrice">
       <soap:operation soapAction="http://example.com/GetLastTradePrice"/>
       <input>
-        <soap:header use="literal" message="GetLastTradePriceInputHeader" />
-        <soap:body use="literal"/>
+        <soap:header use="literal" message="GetLastTradePriceInputHeader" part="header" />
+        <soap:header use="literal" message="GetLastTradePriceInputHeader" part="header2" />
+        <soap:body use="literal" parts="body"/>
       </input>
       <output>
         <soap:body use="literal"/>

data/test/integration/test_envelope.rb

@@ -37,11 +37,13 @@ module LolSoap
     end
 
     it 'creates some header' do
-      subject.header do |h|
-        h['ns0'].username 'LOCO2'
+      subject.header do |header|
+        header.authentication do |auth|
+          auth['ns0'].username 'LOCO2'
+        end
       end
 
-      el = doc.at_xpath('/soap:Envelope/soap:Header/ns0:tradePriceRequestHeader/ns0:username', doc.namespaces)
+      el = doc.at_xpath('/soap:Envelope/soap:Header/ns0:authentication/ns0:username', doc.namespaces)
       el.wont_equal nil
       el.text.to_s.must_equal 'LOCO2'
     end

data/test/integration/test_wsdl.rb

@@ -8,14 +8,24 @@ module LolSoap
     it 'should successfully parse a WSDL document' do
       subject.operations.length.must_equal 2
       subject.operations.fetch('GetLastTradePrice').tap do |o|
-        o.input.header.name.must_equal 'tradePriceRequestHeader'
-        o.input.body.name.must_equal 'tradePriceRequest'
+        o.input.header.tap do |header|
+          header.name.must_equal 'Header'
+          header.content.must_equal nil
+          header.content_type.elements.keys.size.must_equal 2
+          header.content_type.elements.keys.first.must_equal 'tradePriceRequestHeader'
+          header.content_type.elements.keys.last.must_equal 'authentication'
+        end
+        o.input.body.name.must_equal 'Body'
+        o.input.body.content.name.must_equal 'tradePriceRequest'
         o.action.must_equal 'http://example.com/GetLastTradePrice'
       end
 
       subject.operations.fetch('GetHistoricalPrice').tap do |o|
-        o.input.header.must_equal nil
-        o.input.body.name.must_equal 'historicalPriceRequest'
+        o.input.header.name.must_equal 'Header'
+        o.input.header.content.must_equal nil
+        o.input.header.content_type.class.must_equal WSDL::NullType
+        o.input.body.name.must_equal 'Body'
+        o.input.body.content.name.must_equal 'historicalPriceRequest'
       end
 
       subject.types.length.must_equal 4

data/test/unit/test_envelope.rb

@@ -11,7 +11,15 @@ module LolSoap
     end
 
     let(:operation) do
-      OpenStruct.new(:input => OpenStruct.new(:body => OpenStruct.new(:prefix => 'ns0', :name => 'WashHandsRequest')))
+      OpenStruct.new(
+        :input => OpenStruct.new(
+          :header => OpenStruct.new(:name => 'Header'),
+          :body   => OpenStruct.new(
+            :name    => 'Body',
+            :content => OpenStruct.new(:prefix => 'ns0', :name => 'WashHandsRequest')
+          )
+        )
+      )
     end
 
     subject { Envelope.new(wsdl, operation) }

data/test/unit/test_request.rb

@@ -44,5 +44,13 @@ module LolSoap
         subject.mime.must_equal 'text/xml'
       end
     end
+
+    describe '#output_type' do
+      it 'returns output body content type' do
+        content_type = Object.new
+        envelope.output_body_content_type = content_type
+        subject.output_type.must_equal content_type
+      end
+    end
   end
 end

data/test/unit/test_response.rb

@@ -4,7 +4,14 @@ require 'lolsoap/response'
 
 module LolSoap
   describe Response do
-    let(:request) { OpenStruct.new(:soap_namespace => Envelope::SOAP_1_2, :soap_version => '1.2', :output => Object.new) }
+    let(:request) {
+      OpenStruct.new(
+        :soap_namespace => Envelope::SOAP_1_2,
+        :soap_version   => '1.2',
+        :output_type    => Object.new
+      )
+    }
+
     let(:doc) { Nokogiri::XML(File.read(TEST_ROOT + '/fixtures/stock_quote_response.xml')) }
 
     subject { Response.new(request, doc) }
@@ -25,7 +32,7 @@ module LolSoap
       it 'builds a hash from the body node' do
         builder = OpenStruct.new(:output => Object.new)
         builder_klass = MiniTest::Mock.new
-        builder_klass.expect(:new, builder, [subject.body, request.output])
+        builder_klass.expect(:new, builder, [subject.body, request.output_type])
 
         subject.body_hash(builder_klass).must_equal builder.output
       end

data/test/unit/test_wsdl.rb

@@ -13,8 +13,14 @@ module LolSoap
           :operations => {
             'washHands' => {
               :action => 'urn:washHands',
-              :input  => { :body => [namespace, 'brush'] },
-              :output => { :body => [namespace, 'Color'] }
+              :input  => {
+                :header => [],
+                :body   => [[namespace, 'brush']]
+              },
+              :output => {
+                :header => [],
+                :body   => [[namespace, 'Color']]
+              }
             }
           },
           :types => {
@@ -94,10 +100,35 @@ module LolSoap
           subject.operations['washHands'].tap do |op|
             op.wsdl.must_equal subject
             op.action.must_equal 'urn:washHands'
-            op.input.body.name.must_equal 'brush'
-            op.output.tap do |output|
-              output.body.is_a?(WSDL::Element).must_equal(true)
-              output.body.type.elements.keys.sort.must_equal %w(hex name)
+
+            op.input.header.tap do |header|
+              header.is_a?(WSDL::OperationIOPart).must_equal(true)
+              header.name.must_equal 'Header'
+              header.content.must_equal nil
+            end
+
+            op.input.body.tap do |body|
+              body.is_a?(WSDL::OperationIOPart).must_equal(true)
+              body.name.must_equal 'Body'
+              body.content.is_a?(WSDL::Element).must_equal(true)
+              body.content.name.must_equal 'brush'
+            end
+
+            op.output.header.tap do |header|
+              header.is_a?(WSDL::OperationIOPart).must_equal(true)
+              header.name.must_equal 'Header'
+              header.content.must_equal nil
+            end
+
+            op.output.body.tap do |body|
+              body.is_a?(WSDL::OperationIOPart).must_equal(true)
+              body.name.must_equal 'Body'
+
+              body.content.tap do |content|
+                content.is_a?(WSDL::Element).must_equal(true)
+                content.name.must_equal 'Color'
+                content.type.elements.keys.sort.must_equal %w(hex name)
+              end
             end
           end
         end

data/test/unit/test_wsdl_parser.rb

@@ -110,6 +110,11 @@ module LolSoap
     describe '#elements' do
       it 'returns the elements with inline types' do
         subject.elements.must_equal({
+          [namespace, "authentication"] => {
+            :name      => "authentication",
+            :namespace => namespace,
+            :type      => nil
+          },
           [namespace, "tradePriceRequestHeader"] => {
             :name      => "tradePriceRequestHeader",
             :namespace => namespace,
@@ -136,6 +141,11 @@ module LolSoap
               :attributes => []
             }
           },
+          [namespace, "specialTickerSymbol"] => {
+            :name      => "specialTickerSymbol",
+            :namespace => namespace,
+            :type      => [namespace2, 'TickerSymbol']
+          },
           [namespace, "historicalPriceRequest"] => {
             :name      => "historicalPriceRequest",
             :namespace => namespace,
@@ -168,47 +178,71 @@ module LolSoap
     end
 
     describe '#messages' do
-      it 'maps message names to types' do
+      it 'maps message names to part names and corresponding types' do
         subject.messages.must_equal({
-          'GetLastTradePriceInputHeader' => [namespace, 'tradePriceRequestHeader'],
-          'GetLastTradePriceInput'       => [namespace, 'tradePriceRequest'],
-          'GetLastTradePriceOutput'      => [namespace, 'TradePrice'],
-          'GetHistoricalPriceInput'      => [namespace, 'historicalPriceRequest'],
-          'GetHistoricalPriceOutput'     => [namespace, 'HistoricalPrice']
+          'GetLastTradePriceInputHeader' => {
+            'header'  => [namespace, 'tradePriceRequestHeader'],
+            'header2' => [namespace, 'authentication']
+          },
+          'GetLastTradePriceInput'       => {
+            'foo'  => [xs, 'string'],
+            'body' => [namespace, 'tradePriceRequest']
+          },
+          'GetLastTradePriceOutput'      => {
+            'body' => [namespace, 'TradePrice']
+          },
+          'GetHistoricalPriceInput'      => {
+            'body' => [namespace, 'historicalPriceRequest']
+          },
+          'GetHistoricalPriceOutput'     => {
+            'body' => [namespace, 'HistoricalPrice']
+          }
         })
       end
     end
 
     describe '#port_type_operations' do
-      it 'is a hash containing input and output types' do
+      it 'maps operations to messages' do
         subject.port_type_operations.must_equal({
           'GetLastTradePrice' => {
-            :input  => [namespace, 'tradePriceRequest'],
-            :output => [namespace, 'TradePrice']
+            :input  => 'tns:GetLastTradePriceInput',
+            :output => 'tns:GetLastTradePriceOutput',
           },
           'GetHistoricalPrice' => {
-            :input  => [namespace, 'historicalPriceRequest'],
-            :output => [namespace, 'HistoricalPrice']
+            :input  => 'tns:GetHistoricalPriceInput',
+            :output => 'tns:GetHistoricalPriceOutput'
           }
         })
       end
     end
 
     describe '#operations' do
-      it 'is a hash of operations with their action and input type' do
+      it 'maps operations to actions, input and output parts' do
         subject.operations.must_equal({
           'GetLastTradePrice' => {
             :action => 'http://example.com/GetLastTradePrice',
             :input  => {
-              header: [namespace, 'tradePriceRequestHeader'],
-              body:   [namespace, 'tradePriceRequest']
+              header: [
+                [namespace, 'tradePriceRequestHeader'],
+                [namespace, 'authentication']
+              ],
+              body:   [[namespace, 'tradePriceRequest']]
             },
-            :output => { header: nil, body: [namespace, 'TradePrice'] }
+            :output => {
+              header: [],
+              body:   [[namespace, 'TradePrice']]
+            }
           },
           'GetHistoricalPrice' => {
             :action => 'http://example.com/GetHistoricalPrice',
-            :input  => { header: nil, body: [namespace, 'historicalPriceRequest'] },
-            :output => { header: nil, body: [namespace, 'HistoricalPrice'] }
+            :input  => {
+              header: [],
+              body:   [[namespace, 'historicalPriceRequest']]
+            },
+            :output => {
+              header: [],
+              body:   [[namespace, 'HistoricalPrice']]
+            }
           }
         })
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lolsoap
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Jon Leighton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-12 00:00:00.000000000 Z
+date: 2015-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -112,6 +112,7 @@ files:
 - lib/lolsoap/wsdl/null_type.rb
 - lib/lolsoap/wsdl/operation.rb
 - lib/lolsoap/wsdl/operation_io.rb
+- lib/lolsoap/wsdl/operation_io_part.rb
 - lib/lolsoap/wsdl/type.rb
 - lib/lolsoap/wsdl_parser.rb
 - lolsoap.gemspec