lolsoap 0.2.0 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/lolsoap/builder.rb

@@ -52,13 +52,17 @@ module LolSoap
     # Add a tag manually, rather than through method_missing. This is so you can still
     # add tags for the very small number of tags that are also existing methods.
     def __tag__(name, *args, &block)
-      __prefixed_tag__(@type.prefix, @type.sub_type(name.to_s), name, *args, &block)
+      __prefixed_tag__(@type.element_prefix(name.to_s), @type.sub_type(name.to_s), name, *args, &block)
     end
 
     def __attribute__(name, value)
       @node[name.to_s] = value.to_s
     end
 
+    def __content__(value)
+      @node.content = value
+    end
+
     # @private
     def __prefixed_tag__(prefix, sub_type, name, *args)
       sub_node = @node.document.create_element(name.to_s, *args)

data/lib/lolsoap/envelope.rb

@@ -26,7 +26,7 @@ module LolSoap
     #     b.some 'data'
     #   end
     def body(klass = Builder)
-      builder = klass.new(input, operation.input)
+      builder = klass.new(content, input_type)
       yield builder if block_given?
       builder
     end
@@ -46,14 +46,22 @@ module LolSoap
       operation.action
     end
 
-    def input_type
+    def input
       operation.input
     end
 
-    def output_type
+    def input_type
+      input.type
+    end
+
+    def output
       operation.output
     end
 
+    def output_type
+      output.type
+    end
+
     def to_xml(options = {})
       doc.to_xml(options)
     end
@@ -73,7 +81,7 @@ module LolSoap
     private
 
     # @private
-    def input; @input; end
+    def content; @content; end
 
     # @private
     def initialize_doc
@@ -84,13 +92,13 @@ module LolSoap
 
       @header = doc.create_element 'Header'
 
-      @body  = doc.create_element 'Body'
-      @input = doc.create_element input_type.name
+      @body    = doc.create_element 'Body'
+      @content = doc.create_element input.name
 
       [root, @header, @body].each { |el| el.namespace = namespaces[soap_prefix] }
-      @input.namespace = namespaces[input_type.prefix]
+      @content.namespace = namespaces[input.prefix]
 
-      @body << @input
+      @body << @content
       root  << @header
       root  << @body
     end

data/lib/lolsoap/wsdl.rb

@@ -4,6 +4,8 @@ module LolSoap
   class WSDL
     require 'lolsoap/wsdl/operation'
     require 'lolsoap/wsdl/type'
+    require 'lolsoap/wsdl/named_type_reference'
+    require 'lolsoap/wsdl/immediate_type_reference'
     require 'lolsoap/wsdl/null_type'
     require 'lolsoap/wsdl/element'
     require 'lolsoap/wsdl/null_element'
@@ -19,6 +21,9 @@ module LolSoap
     # Hash of namespaces used in the WSDL document (keys are prefixes)
     attr_reader :namespaces
 
+    # Namespaces used by the types (a subset of #namespaces)
+    attr_reader :type_namespaces
+
     # Hash of namespace prefixes used in the WSDL document (keys are namespace URIs)
     attr_reader :prefixes
 
@@ -26,22 +31,13 @@ module LolSoap
     attr_reader :soap_version
 
     def initialize(parser)
-      @types        = load_types(parser)
-      @operations   = load_operations(parser)
-      @endpoint     = parser.endpoint
-      @namespaces   = parser.namespaces
-      @prefixes     = parser.prefixes
-      @soap_version = parser.soap_version
-    end
-
-    # Hash of operations that are supports by the SOAP service
-    def operations
-      @operations.dup
-    end
-
-    # Get a single operation
-    def operation(name)
-      @operations.fetch(name)
+      @types           = load_types(parser)
+      @operations      = load_operations(parser)
+      @endpoint        = parser.endpoint
+      @namespaces      = parser.namespaces
+      @type_namespaces = load_type_namespaces(parser)
+      @prefixes        = parser.prefixes
+      @soap_version    = parser.soap_version
     end
 
     # Hash of types declared by the service
@@ -54,9 +50,14 @@ module LolSoap
       @types.fetch(name) { NullType.new }
     end
 
-    # Namespaces used by the types (a subset of #namespaces)
-    def type_namespaces
-      Hash[@types.values.map { |type| [type.prefix, namespaces[type.prefix]] }]
+    # Hash of operations that are supports by the SOAP service
+    def operations
+      @operations.dup
+    end
+
+    # Get a single operation
+    def operation(name)
+      @operations.fetch(name)
     end
 
     def inspect
@@ -68,39 +69,75 @@ module LolSoap
 
     private
 
+    # @private
+    def load_types(parser)
+      Hash[
+        parser.types.map do |prefixed_name, type|
+          [prefixed_name, build_type(type)]
+        end
+      ]
+    end
+
     # @private
     def load_operations(parser)
       Hash[
         parser.operations.map do |k, op|
-          [k, Operation.new(self, op[:action], type(op[:input]), type(op[:output]))]
+          [k, Operation.new(self, op[:action], message_format(op[:input], parser), message_format(op[:output], parser))]
         end
       ]
     end
 
     # @private
-    def load_types(parser)
+    def load_type_namespaces(parser)
       Hash[
-        parser.types.map do |prefixed_name, type|
-          [
-            prefixed_name,
-            Type.new(
-              type[:name],
-              type[:prefix],
-              build_elements(type[:elements]),
-              type[:attributes]
-            )
-          ]
+        parser.types.merge(parser.elements).values.map do |el|
+          [el[:prefix], namespaces[el[:prefix]]]
         end
       ]
     end
 
+    # @private
+    def build_type(params)
+      Type.new(
+        params[:name],
+        params[:prefix],
+        build_elements(params[:elements]),
+        params[:attributes]
+      )
+    end
+
     # @private
     def build_elements(elements)
       Hash[
         elements.map do |name, el|
-          [name, Element.new(self, name, el[:type], el[:singular])]
+          [name, build_element(el)]
         end
       ]
     end
+
+    # @private
+    def build_element(params)
+      Element.new(
+        self,
+        params[:name],
+        params[:prefix],
+        type_reference(params[:type]),
+        params[:singular]
+      )
+    end
+
+    # @private
+    def type_reference(type)
+      if type.respond_to?(:to_str)
+        NamedTypeReference.new(type, self)
+      else
+        ImmediateTypeReference.new(build_type(type))
+      end
+    end
+
+    # @private
+    def message_format(element, parser)
+      build_element(parser.elements[element])
+    end
   end
 end

data/lib/lolsoap/wsdl/element.rb

@@ -1,24 +1,29 @@
 class LolSoap::WSDL
   class Element
-    attr_reader :name
+    attr_reader :name, :prefix, :type_reference
 
-    def initialize(wsdl, name, type_name, singular = true)
-      @wsdl      = wsdl
-      @name      = name
-      @type_name = type_name
-      @singular  = singular
+    def initialize(wsdl, name, prefix, type_reference, singular = true)
+      @wsdl           = wsdl
+      @name           = name
+      @prefix         = prefix
+      @type_reference = type_reference
+      @singular       = singular
+    end
+
+    def type
+      type_reference.type
     end
 
     def singular?
       @singular == true
     end
 
-    def type
-      @type ||= wsdl.type(@type_name)
+    def inspect
+      "<#{self.class} name=#{prefix_and_name.inspect} type=#{type.to_s.inspect}>"
     end
 
-    def inspect
-      "<#{self.class} name=#{name.inspect} type=#{@type_name.inspect}>"
+    def prefix_and_name
+      "#{prefix}:#{name}"
     end
 
     private

data/lib/lolsoap/wsdl/immediate_type_reference.rb

@@ -0,0 +1,9 @@
+class LolSoap::WSDL
+  class ImmediateTypeReference
+    attr_reader :type
+
+    def initialize(type)
+      @type = type
+    end
+  end
+end

data/lib/lolsoap/wsdl/named_type_reference.rb

@@ -0,0 +1,14 @@
+class LolSoap::WSDL
+  class NamedTypeReference
+    attr_reader :name, :wsdl
+
+    def initialize(name, wsdl)
+      @name = name
+      @wsdl = wsdl
+    end
+
+    def type
+      wsdl.type(name)
+    end
+  end
+end

data/lib/lolsoap/wsdl/type.rb

@@ -19,6 +19,10 @@ class LolSoap::WSDL
       @elements.fetch(name) { NullElement.new }
     end
 
+    def element_prefix(name)
+      @elements.fetch(name, self).prefix
+    end
+
     def sub_type(name)
       element(name).type
     end
@@ -32,9 +36,13 @@ class LolSoap::WSDL
     end
 
     def inspect
-      "<#{self.class} name=\"#{prefix}:#{name}\" " \
+      "<#{self.class} name=\"#{prefix_and_name.inspect}\" " \
         "elements=#{elements.inspect} " \
         "attributes=#{attributes.inspect}>"
     end
+
+    def prefix_and_name
+      "#{prefix}:#{name}"
+    end
   end
 end

data/lib/lolsoap/wsdl_parser.rb

@@ -3,7 +3,7 @@ require 'nokogiri'
 module LolSoap
   # @private
   class WSDLParser
-    class Type
+    class Node
       attr_reader :parser, :node, :target_namespace, :name, :prefix
 
       def initialize(parser, node, target_namespace)
@@ -17,28 +17,84 @@ module LolSoap
         "#{prefix}:#{name}"
       end
 
+      def prefix_and_name(string)
+        parser.prefix_and_name(string, target_namespace)
+      end
+    end
+
+    class Element < Node
+      def type
+        if complex_type = node.at_xpath('xs:complexType', parser.ns)
+          type = Type.new(parser, complex_type, target_namespace)
+          {
+            :elements   => type.elements,
+            :attributes => type.attributes
+          }
+        else
+          prefix_and_name(node.attr('type').to_s).join(':')
+        end
+      end
+
+      def singular
+        max_occurs.empty? || max_occurs == '1'
+      end
+
+      private
+
+      def max_occurs
+        @max_occurs ||= node.attribute('maxOccurs').to_s
+      end
+    end
+
+    class Type < Node
       def elements
-        Hash[
-          node.xpath('.//xs:element', parser.ns).map do |element|
-            max_occurs = element.attribute('maxOccurs').to_s
+        parent_elements.merge(own_elements)
+      end
+
+      def attributes
+        parent_attributes + own_attributes
+      end
+
+      def base_type
+        @base_type ||= begin
+          if extension = node.at_xpath('xs:complexContent/xs:extension/@base', parser.ns)
+            parser.type(extension.to_s)
+          end
+        end
+      end
+
+      private
 
+      def own_elements
+        Hash[
+          element_nodes.map do |element|
             [
-              prefix_and_name(element.attr('name')).last,
+              element.name,
               {
-                :type     => prefix_and_name(element.attr('type')).join(':'),
-                :singular => max_occurs.empty? || max_occurs == '1'
+                :name     => element.name,
+                :prefix   => element.prefix,
+                :type     => element.type,
+                :singular => element.singular
               }
             ]
           end
         ]
       end
 
-      def attributes
-        node.xpath('.//xs:attribute/@name', parser.ns).map(&:text)
+      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) }
       end
 
-      def prefix_and_name(string)
-        parser.prefix_and_name(string, target_namespace)
+      def parent_elements
+        base_type ? base_type.elements : {}
+      end
+
+      def own_attributes
+        node.xpath('xs:attribute/@name | */xs:extension/xs:attribute/@name', parser.ns).map(&:text)
+      end
+
+      def parent_attributes
+        base_type ? base_type.attributes : []
       end
     end
 
@@ -79,24 +135,41 @@ module LolSoap
     def types
       @types ||= begin
         types = {}
-        schemas.each do |schema|
-          target_namespace = schema.attr('targetNamespace').to_s
-
-          schema.xpath('xs:element[@name] | xs:complexType[@name]', ns).each do |node|
-            type = Type.new(self, node, target_namespace)
-
-            types[type.name_with_prefix] = {
-              :name       => type.name,
-              :prefix     => type.prefix,
-              :elements   => type.elements,
-              :attributes => type.attributes
-            }
-          end
+        each_node('xs:complexType[not(@abstract)]') do |node, target_ns|
+          type = Type.new(self, node, target_ns)
+          types[type.name_with_prefix] = {
+            :name       => type.name,
+            :prefix     => type.prefix,
+            :elements   => type.elements,
+            :attributes => type.attributes
+          }
         end
         types
       end
     end
 
+    def type(name)
+      name = prefix_and_name(name).last
+      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
+
+    def elements
+      @elements ||= begin
+        elements = {}
+        each_node('xs:element') do |node, target_ns|
+          element = Element.new(self, node, target_ns)
+          elements[element.name_with_prefix] = {
+            :name   => element.name,
+            :prefix => element.prefix,
+            :type   => element.type
+          }
+        end
+        elements
+      end
+    end
+
     def messages
       @messages ||= Hash[
         doc.xpath('/d:definitions/d:message', ns).map do |msg|
@@ -165,5 +238,15 @@ module LolSoap
 
       [prefix, name]
     end
+
+    def each_node(xpath)
+      schemas.each do |schema|
+        target_namespace = schema.attr('targetNamespace').to_s
+
+        schema.xpath(xpath, ns).each do |node|
+          yield node, target_namespace
+        end
+      end
+    end
   end
 end

data/lolsoap.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "lolsoap"
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jon Leighton"]
-  s.date = "2013-05-15"
+  s.date = "2013-06-24"
   s.description = "A library for dealing with SOAP requests and responses. We tear our hair out so you don't have to."
   s.email = "j@jonathanleighton.com"
   s.extra_rdoc_files = [
@@ -37,6 +37,8 @@ Gem::Specification.new do |s|
     "lib/lolsoap/response.rb",
     "lib/lolsoap/wsdl.rb",
     "lib/lolsoap/wsdl/element.rb",
+    "lib/lolsoap/wsdl/immediate_type_reference.rb",
+    "lib/lolsoap/wsdl/named_type_reference.rb",
     "lib/lolsoap/wsdl/null_element.rb",
     "lib/lolsoap/wsdl/null_type.rb",
     "lib/lolsoap/wsdl/operation.rb",

data/test/fixtures/stock_quote.wsdl

@@ -20,12 +20,48 @@
            </all>
          </complexType>
       </element>
-      <complexType name="xsd3:TradePriceRequest">
+      <element name="tradePriceRequest" type="TradePriceRequest" />
+      <complexType name="xsd1:TradePriceRequest">
+        <complexContent>
+          <extension base="xsd1:BaseRequest">
+            <sequence>
+              <element name="tickerSymbol" type="xs:string" maxOccurs="5"/>
+              <element name="specialTickerSymbol" type="xsd2:TickerSymbol" maxOccurs="unbounded"/>
+            </sequence>
+            <attribute name="id" type="xs:string"/>
+          </extension>
+        </complexContent>
+      </complexType>
+      <element name="xsd1:HistoricalPrice">
+        <complexType>
+          <sequence>
+            <element name="date" type="xs:date"/>
+            <element name="price" type="xs:float"/>
+          </sequence>
+        </complexType>
+      </element>
+      <element name="historicalPriceRequest" type="HistoricalPriceRequest" />
+      <complexType name="xsd1:HistoricalPriceRequest">
+        <complexContent>
+          <extension base="xsd1:BaseRequest">
+            <sequence>
+              <element name="dateRange">
+                <complexType>
+                  <sequence>
+                    <element name="startDate" maxOccurs="1" type="xs:string" />
+                    <element name="endDate" maxOccurs="1" type="xs:string" />
+                  </sequence>
+                </complexType>
+              </element>
+            </sequence>
+          </extension>
+        </complexContent>
+      </complexType>
+      <complexType abstract="true" name="BaseRequest">
         <sequence>
-          <element name="tickerSymbol" type="xs:string" maxOccurs="5"/>
-          <element name="specialTickerSymbol" type="xsd2:TickerSymbol" maxOccurs="unbounded"/>
-          <attribute name="id" type="xs:string"/>
+          <element name="accountId" type="xs:string" maxOccurs="1"/>
         </sequence>
+        <attribute name="signature" type="xs:string"/>
       </complexType>
     </schema>
 
@@ -40,18 +76,30 @@
   </types>
 
   <message name="GetLastTradePriceInput">
-    <part name="body" element="xsd1:TradePriceRequest"/>
+    <part name="body" element="xsd1:tradePriceRequest"/>
   </message>
 
   <message name="GetLastTradePriceOutput">
     <part name="body" element="xsd3:TradePrice"/>
   </message>
 
+  <message name="GetHistoricalPriceInput">
+    <part name="body" element="xsd1:historicalPriceRequest"/>
+  </message>
+
+  <message name="GetHistoricalPriceOutput">
+    <part name="body" element="xsd1:HistoricalPrice"/>
+  </message>
+
   <portType name="StockQuotePortType">
     <operation name="GetLastTradePrice">
       <input message="tns:GetLastTradePriceInput"/>
       <output message="tns:GetLastTradePriceOutput"/>
     </operation>
+    <operation name="GetHistoricalPrice">
+      <input message="tns:GetHistoricalPriceInput"/>
+      <output message="tns:GetHistoricalPriceOutput"/>
+    </operation>
   </portType>
 
   <binding name="StockQuoteSoapBinding" type="tns:StockQuotePortType">
@@ -65,6 +113,15 @@
         <soap:body use="literal"/>
       </output>
     </operation>
+    <operation name="GetHistoricalPrice">
+      <soap:operation soapAction="http://example.com/GetHistoricalPrice"/>
+      <input>
+        <soap:body use="literal"/>
+      </input>
+      <output>
+        <soap:body use="literal"/>
+      </output>
+    </operation>
   </binding>
 
   <service name="StockQuoteService">

data/test/integration/test_envelope.rb

@@ -10,7 +10,7 @@ module LolSoap
     let(:doc) { subject.doc }
 
     it 'creates an empty envelope' do
-      body = doc.at_xpath('/soap:Envelope/soap:Body/xsd1:TradePriceRequest', doc.namespaces)
+      body = doc.at_xpath('/soap:Envelope/soap:Body/xsd1:tradePriceRequest', doc.namespaces)
       body.wont_equal nil
     end
 
@@ -24,15 +24,15 @@ module LolSoap
         b.id 42
       end
 
-      el = doc.at_xpath('//xsd1:TradePriceRequest/xsd1:tickerSymbol', doc.namespaces)
+      el = doc.at_xpath('//xsd1:tradePriceRequest/xsd1:tickerSymbol', doc.namespaces)
       el.wont_equal nil
       el.text.to_s.must_equal 'LOCO2'
 
-      el = doc.at_xpath('//xsd1:TradePriceRequest/xsd1:specialTickerSymbol/xsd2:name', doc.namespaces)
+      el = doc.at_xpath('//xsd1:tradePriceRequest/xsd1:specialTickerSymbol/xsd2:name', doc.namespaces)
       el.wont_equal nil
       el.text.to_s.must_equal 'LOCOLOCOLOCO'
 
-      attr = doc.at_xpath('//xsd1:TradePriceRequest/@id', doc.namespaces)
+      attr = doc.at_xpath('//xsd1:tradePriceRequest/@id', doc.namespaces)
       attr.to_s.must_equal "42"
     end
 

data/test/integration/test_wsdl.rb

@@ -6,10 +6,10 @@ module LolSoap
     subject { WSDL.parse(File.read(TEST_ROOT + '/fixtures/stock_quote.wsdl')) }
 
     it 'should successfully parse a WSDL document' do
-      subject.operations.length.must_equal 1
+      subject.operations.length.must_equal 2
       subject.operations['GetLastTradePrice'].tap do |o|
-        o.input.must_equal  subject.types['xsd1:TradePriceRequest']
-        o.action.must_equal 'http://example.com/GetLastTradePrice'
+        o.input.name.must_equal 'tradePriceRequest'
+        o.action.must_equal     'http://example.com/GetLastTradePrice'
       end
 
       subject.types.length.must_equal 3

data/test/unit/test_builder.rb

@@ -15,6 +15,10 @@ module LolSoap
     end
     let(:type) do
       type = OpenStruct.new(:prefix => 'a')
+      def type.element_prefix(name)
+        @element_prefixes = { 'bar' => 'b' }
+        @element_prefixes.fetch(name) { 'a' }
+      end
       def type.has_attribute?(*); false; end
       def type.sub_type(name)
         @sub_types ||= { 'foo' => Object.new, 'bar' => Object.new, 'clone' => Object.new }
@@ -47,7 +51,7 @@ module LolSoap
       end
 
       it 'yields to a block, if given' do
-        expect_node_added node.namespace_scopes[1], 'bar' do
+        expect_node_added node.namespace_scopes[0], 'bar' do
           block = nil
           ret = subject.__tag__(:bar) { |b| block = b }
           block.object_id.must_equal ret.object_id
@@ -57,7 +61,7 @@ module LolSoap
 
     describe 'method missing' do
       it 'delegates to __tag__' do
-        expect_node_added node.namespace_scopes[1], 'bar', 'baz' do
+        expect_node_added node.namespace_scopes[0], 'bar', 'baz' do
           subject.bar 'baz'
         end
       end
@@ -67,6 +71,11 @@ module LolSoap
           subject.clone
         end
       end
+
+      it 'sets content' do
+        subject.__content__ 'zomg'
+        node.content.must_equal 'zomg'
+      end
     end
 
     it 'responds to anything' do
@@ -91,6 +100,5 @@ module LolSoap
         subject.__type__.must_equal type
       end
     end
-
   end
 end

data/test/unit/test_envelope.rb

@@ -106,16 +106,16 @@ module LolSoap
       end
     end
 
-    describe '#input_type' do
+    describe '#input' do
       it "returns the operation's input" do
-        subject.input_type.must_equal operation.input
+        subject.input.must_equal operation.input
       end
     end
 
     describe '#output' do
       it "returns the operation's output" do
         operation.output = 'lol'
-        subject.output_type.must_equal 'lol'
+        subject.output.must_equal 'lol'
       end
     end
 

data/test/unit/test_wsdl.rb

@@ -12,7 +12,7 @@ module LolSoap
           :operations => {
             'washHands' => {
               :action => 'urn:washHands',
-              :input  => 'bla:Brush',
+              :input  => 'bla:brush',
               :output => 'bla:Color'
             }
           },
@@ -20,30 +20,64 @@ module LolSoap
             'bla:Brush' => {
               :elements => {
                 'handleColor' => {
-                  :type     => 'bla:Color',
+                  :name     => 'handleColor',
+                  :prefix   => 'bla',
+                  :type     => {
+                    :elements => {
+                      'name' => {
+                        :name     => 'name',
+                        :prefix   => 'bla',
+                        :type     => 'xs:string',
+                        :singular => true
+                      },
+                      'hex' => {
+                        :name     => 'hex',
+                        :prefix   => 'bla',
+                        :type     => 'xs:string',
+                        :singular => true
+                      }
+                    },
+                    :attributes => []
+                  },
                   :singular => true
                 },
                 'age' => {
+                  :name     => 'age',
+                  :prefix   => 'bla',
                   :type     => 'xs:int',
                   :singular => false
                 }
               },
               :attributes => ['id'],
               :prefix => 'bla'
+            }
+         },
+         :elements => {
+            'bla:brush' => {
+              :name   => 'brush',
+              :prefix => 'bla',
+              :type   => 'bla:Brush'
             },
             'bla:Color' => {
-              :elements => {
-                'name' => {
-                  :type     => 'xs:string',
-                  :singular => true
+              :name   => 'Color',
+              :prefix => 'bla',
+              :type   => {
+                :elements => {
+                  'name' => {
+                    :name     => 'name',
+                    :prefix   => 'bla',
+                    :type     => 'xs:string',
+                    :singular => true
+                  },
+                  'hex' => {
+                    :name     => 'hex',
+                    :prefix   => 'bla',
+                    :type     => 'xs:string',
+                    :singular => true
+                  }
                 },
-                'hex' => {
-                  :type     => 'xs:string',
-                  :singular => true
-                }
-              },
-              :attributes => [],
-              :prefix => 'bla'
+                :attributes => []
+              }
             }
           }
         )
@@ -55,10 +89,13 @@ module LolSoap
         it 'returns a hash of operations' do
           subject.operations.length.must_equal 1
           subject.operations['washHands'].tap do |op|
-            op.wsdl.must_equal   subject
-            op.action.must_equal "urn:washHands"
-            op.input.must_equal  subject.types['bla:Brush']
-            op.output.must_equal subject.types['bla:Color']
+            op.wsdl.must_equal       subject
+            op.action.must_equal     'urn:washHands'
+            op.input.name.must_equal 'brush'
+            op.output.tap do |output|
+              output.is_a?(WSDL::Element).must_equal(true)
+              output.type.elements.keys.sort.must_equal %w(hex name)
+            end
           end
         end
       end
@@ -84,28 +121,26 @@ module LolSoap
 
       describe '#types' do
         it 'returns a hash of types' do
-          subject.types.length.must_equal 2
+          subject.types.length.must_equal 1
 
           subject.types['bla:Brush'].tap do |t|
             t.elements.length.must_equal 2
-            t.element('handleColor').type.must_equal subject.types['bla:Color']
+            t.element('handleColor').type.tap do |type|
+              type.is_a?(WSDL::Type).must_equal true
+              type.elements.keys.sort.must_equal %w(hex name)
+            end
+            t.element('handleColor').prefix.must_equal 'bla'
             t.element('handleColor').singular?.must_equal true
             t.element('age').type.must_equal WSDL::NullType.new
             t.element('age').singular?.must_equal false
             t.attributes.must_equal ['id']
           end
-
-          subject.types['bla:Color'].tap do |t|
-            t.elements.length.must_equal 2
-            t.element('name').type.must_equal WSDL::NullType.new
-            t.element('hex').type.must_equal WSDL::NullType.new
-          end
         end
       end
 
       describe '#type' do
         it 'returns a single type' do
-          subject.type('bla:Color').must_equal subject.types['bla:Color']
+          subject.type('bla:Brush').must_equal subject.types['bla:Brush']
         end
 
         it 'returns a null object if a type is missing' do

data/test/unit/test_wsdl_parser.rb

@@ -37,33 +37,69 @@ module LolSoap
             :prefix   => 'xsd1',
             :name     => 'TradePriceRequest',
             :elements => {
+              'accountId' => {
+                :name     => 'accountId',
+                :prefix   => 'xsd1',
+                :type     => 'xs:string',
+                :singular => true
+              },
               'tickerSymbol' => {
+                :name     => 'tickerSymbol',
+                :prefix   => 'xsd1',
                 :type     => 'xs:string',
                 :singular => false
               },
               'specialTickerSymbol' => {
+                :name     => 'specialTickerSymbol',
+                :prefix   => 'xsd1',
                 :type     => 'xsd2:TickerSymbol',
                 :singular => false
               }
             },
-            :attributes => ['id']
+            :attributes => ['signature', 'id']
           },
-          'xsd1:TradePrice' => {
+          'xsd1:HistoricalPriceRequest' => {
             :prefix   => 'xsd1',
-            :name     => 'TradePrice',
+            :name     => 'HistoricalPriceRequest',
             :elements => {
-              'price' => {
-                :type     => 'xs:float',
+              'accountId' => {
+                :name     => 'accountId',
+                :prefix   => 'xsd1',
+                :type     => 'xs:string',
+                :singular => true
+              },
+              'dateRange' => {
+                :name     => 'dateRange',
+                :prefix   => 'xsd1',
+                :type     => {
+                  :elements => {
+                    'startDate' => {
+                      :name     => 'startDate',
+                      :prefix   => 'xsd1',
+                      :type     => 'xs:string',
+                      :singular => true
+                    },
+                    'endDate' => {
+                      :name     => 'endDate',
+                      :prefix   => 'xsd1',
+                      :type     => 'xs:string',
+                      :singular => true
+                    }
+                  },
+                  :attributes => []
+                },
                 :singular => true
               }
             },
-            :attributes => []
+            :attributes => ['signature']
           },
           'xsd2:TickerSymbol' => {
             :prefix   => 'xsd2',
             :name     => 'TickerSymbol',
             :elements => {
               'name' => {
+                :name     => 'name',
+                :prefix   => 'xsd2',
                 :type     => 'xs:string',
                 :singular => true
               }
@@ -74,11 +110,66 @@ module LolSoap
       end
     end
 
+    describe '#elements' do
+      it 'returns the elements with inline types' do
+        subject.elements.must_equal({
+          "xsd1:tradePriceRequest" => {
+            :name   => "tradePriceRequest",
+            :prefix => "xsd1",
+            :type   => "xsd1:TradePriceRequest"
+          },
+          "xsd1:TradePrice" => {
+            :name   => "TradePrice",
+            :prefix => "xsd1",
+            :type   => {
+              :elements => {
+                'price' => {
+                  :name     => 'price',
+                  :prefix   => 'xsd1',
+                  :type     => 'xs:float',
+                  :singular => true
+                }
+              },
+              :attributes => []
+            }
+          },
+          "xsd1:historicalPriceRequest" => {
+            :name   => "historicalPriceRequest",
+            :prefix => "xsd1",
+            :type   => "xsd1:HistoricalPriceRequest"
+          },
+          "xsd1:HistoricalPrice" => {
+            :name   => "HistoricalPrice",
+            :prefix => "xsd1",
+            :type   => {
+              :elements => {
+                'date' => {
+                  :name     => 'date',
+                  :prefix   => 'xsd1',
+                  :type     => 'xs:date',
+                  :singular => true
+                },
+                'price' => {
+                  :name     => 'price',
+                  :prefix   => 'xsd1',
+                  :type     => 'xs:float',
+                  :singular => true
+                }
+              },
+              :attributes => []
+            }
+          }
+        })
+      end
+    end
+
     describe '#messages' do
       it 'maps message names to types' do
         subject.messages.must_equal({
-          'GetLastTradePriceInput'  => 'xsd1:TradePriceRequest',
-          'GetLastTradePriceOutput' => 'xsd1:TradePrice'
+          'GetLastTradePriceInput'   => 'xsd1:tradePriceRequest',
+          'GetLastTradePriceOutput'  => 'xsd1:TradePrice',
+          'GetHistoricalPriceInput'  => 'xsd1:historicalPriceRequest',
+          'GetHistoricalPriceOutput' => 'xsd1:HistoricalPrice'
         })
       end
     end
@@ -87,8 +178,12 @@ module LolSoap
       it 'is a hash containing input and output types' do
         subject.port_type_operations.must_equal({
           'GetLastTradePrice' => {
-            :input  => 'xsd1:TradePriceRequest',
+            :input  => 'xsd1:tradePriceRequest',
             :output => 'xsd1:TradePrice'
+          },
+          'GetHistoricalPrice' => {
+            :input  => 'xsd1:historicalPriceRequest',
+            :output => 'xsd1:HistoricalPrice'
           }
         })
       end
@@ -99,8 +194,13 @@ module LolSoap
         subject.operations.must_equal({
           'GetLastTradePrice' => {
             :action => 'http://example.com/GetLastTradePrice',
-            :input  => 'xsd1:TradePriceRequest',
+            :input  => 'xsd1:tradePriceRequest',
             :output => 'xsd1:TradePrice'
+          },
+          'GetHistoricalPrice' => {
+            :action => 'http://example.com/GetHistoricalPrice',
+            :input  => 'xsd1:historicalPriceRequest',
+            :output => 'xsd1:HistoricalPrice'
           }
         })
       end

data/test/unit/wsdl/test_element.rb

@@ -3,15 +3,18 @@ require 'lolsoap/wsdl'
 
 class LolSoap::WSDL
   describe Element do
-    let(:wsdl) { OpenStruct.new }
-    subject { Element.new(wsdl, 'foo', 'a:WashHandsRequest', true) }
+    let(:wsdl)           { MiniTest::Mock.new }
+    let(:type_reference) { MiniTest::Mock.new }
+    let(:type)           { Object.new }
 
-    describe '#type' do
-      let(:wsdl) { MiniTest::Mock.new }
+    subject { Element.new(wsdl, 'bar', 'foo', type_reference, true) }
+
+    before do
+      type_reference.expect(:type, type)
+    end
 
-      it 'ignores the namespace and gets the type from the wsdl' do
-        type = Object.new
-        wsdl.expect(:type, type, ['WashHandsRequest'])
+    describe '#type' do
+      it 'returns the type via the reference' do
         subject.type.must_equal type
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lolsoap
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-15 00:00:00.000000000 Z
+date: 2013-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -120,6 +120,8 @@ files:
 - lib/lolsoap/response.rb
 - lib/lolsoap/wsdl.rb
 - lib/lolsoap/wsdl/element.rb
+- lib/lolsoap/wsdl/immediate_type_reference.rb
+- lib/lolsoap/wsdl/named_type_reference.rb
 - lib/lolsoap/wsdl/null_element.rb
 - lib/lolsoap/wsdl/null_type.rb
 - lib/lolsoap/wsdl/operation.rb
@@ -162,7 +164,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2454390744862534994
+      hash: 413746061
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: