lolsoap 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70c9d43e10a4416609eb3eb5a9af91f71f279c3f
-  data.tar.gz: edebdbc665e6f41416241807e6166669f4504de4
+  metadata.gz: d15ac33320b9b7a7f32e1fd15e111ba323683c75
+  data.tar.gz: d9fdcb8040c0e9e714b0512f73c69c15ca70d686
 SHA512:
-  metadata.gz: 13e9cee35f6f3beee983e302df03902ad407e1a9a9f0d41dde9fe3ed00564c1b7f997a192fd3f352225378f57f8db295f2dc1351a45f0ee29f143b40f3412fcc
-  data.tar.gz: d54666737a235460e8165b410475cc62d62d7352a3f605530bc71cab1fc6ff5c4ce968346ebe171212447518f57d82035bc7f9c5fb7ac8f9724fcd736b46f403
+  metadata.gz: b4b2624bb3b81de8109863c618d1c9a11146f2394b908da4ffa1a3737ad9cd624e5a206f14262d23b454f9a1d9576ef1d1bfc3713101f49b020ee76f19f00428
+  data.tar.gz: 62efc9d01ee3e439b115aa9c7eb10c293036d353aa849a999fd9ecfd676c88ae0a483c976b320f1d974dea42923092655716212b4c6d185c24892a96d2019710

data/README.md

@@ -114,6 +114,12 @@ Development sponsored by [Loco2](http://loco2.com/).
 
 ## Changelog ##
 
+### 0.5 ###
+
+* Generate our own namespace prefixes rather than using ones from the
+  WSDL document. This fixes issues with WSDLs that use the same prefix
+  to denote different namespaces in different places.
+
 ### 0.4 ###
 
 * Don't raise an exception on when a SOAP fault is detected. Whether or

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.5.0

data/lib/lolsoap/envelope.rb

@@ -87,7 +87,7 @@ module LolSoap
     def initialize_doc
       doc.root = root = doc.create_element('Envelope')
 
-      namespaces = Hash[wsdl.type_namespaces.map { |prefix, uri| [prefix, root.add_namespace(prefix, uri)] }]
+      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'

data/lib/lolsoap/wsdl/named_type_reference.rb

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

data/lib/lolsoap/wsdl/operation.rb

@@ -1,9 +1,10 @@
 class LolSoap::WSDL
   class Operation
-    attr_reader :wsdl, :action, :input, :output
+    attr_reader :wsdl, :name, :action, :input, :output
 
-    def initialize(wsdl, action, input, output)
+    def initialize(wsdl, name, action, input, output)
       @wsdl   = wsdl
+      @name   = name
       @action = action
       @input  = input
       @output = output
@@ -11,6 +12,7 @@ class LolSoap::WSDL
 
     def inspect
       "<#{self.class} " \
+      "name=#{name.inspect} " \
       "action=#{action.inspect} " \
       "input=#{input.inspect}>"
     end

data/lib/lolsoap/wsdl/type.rb

@@ -36,7 +36,7 @@ class LolSoap::WSDL
     end
 
     def inspect
-      "<#{self.class} name=\"#{prefix_and_name.inspect}\" " \
+      "<#{self.class} name=\"#{prefix_and_name}\" " \
         "elements=#{elements.inspect} " \
         "attributes=#{attributes.inspect}>"
     end

data/lib/lolsoap/wsdl.rb

@@ -18,41 +18,37 @@ module LolSoap
     # The SOAP endpoint URL
     attr_reader :endpoint
 
-    # 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)
+    # Hash of generated prefixes to namespaces
     attr_reader :prefixes
 
+    # Hash of namespaces to generated prefixes
+    attr_reader :namespaces
+
     # The version of SOAP detected.
     attr_reader :soap_version
 
     def initialize(parser)
-      @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
+      @prefixes     = generate_prefixes(parser)
+      @namespaces   = prefixes.invert
+      @types        = load_types(parser)
+      @operations   = load_operations(parser)
+      @endpoint     = parser.endpoint
+      @soap_version = parser.soap_version
     end
 
     # Hash of types declared by the service
     def types
-      @types.dup
+      Hash[@types.values.map { |t| [t.name, t] }]
     end
 
     # Get a single type, or a NullType if the type doesn't exist
-    def type(name)
-      @types.fetch(name) { NullType.new }
+    def type(namespace, name)
+      @types.fetch([namespace, name]) { NullType.new }
     end
 
-    # Hash of operations that are supports by the SOAP service
+    # Hash of operations that are supported by the SOAP service
     def operations
-      @operations.dup
+      Hash[@operations.values.map { |o| [o.name, o] }]
     end
 
     # Get a single operation
@@ -60,11 +56,16 @@ module LolSoap
       @operations.fetch(name)
     end
 
+    # Get the prefix for a namespace
+    def prefix(namespace)
+      prefixes.fetch namespace
+    end
+
     def inspect
       "<#{self.class} " \
-      "namespaces=#{@namespaces.inspect} " \
-      "operations=#{@operations.keys.inspect} " \
-      "types=#{@types.keys.inspect}>"
+      "namespaces=#{namespaces.inspect} " \
+      "operations=#{operations.inspect} " \
+      "types=#{types.inspect}>"
     end
 
     private
@@ -72,8 +73,8 @@ module LolSoap
     # @private
     def load_types(parser)
       Hash[
-        parser.types.map do |prefixed_name, type|
-          [prefixed_name, build_type(type)]
+        parser.types.map do |id, type|
+          [id, build_type(type)]
         end
       ]
     end
@@ -82,27 +83,33 @@ module LolSoap
     def load_operations(parser)
       Hash[
         parser.operations.map do |k, op|
-          [k, Operation.new(self, op[:action], message_format(op[:input], parser), message_format(op[:output], parser))]
+          [k, Operation.new(self, k, op[:action], message_format(op[:input], parser), message_format(op[:output], parser))]
         end
       ]
     end
 
     # @private
-    def load_type_namespaces(parser)
-      Hash[
-        parser.types.merge(parser.elements).values.map do |el|
-          [el[:prefix], namespaces[el[:prefix]]]
+    def generate_prefixes(parser)
+      prefixes = {}
+      index    = 0
+
+      parser.types.merge(parser.elements).values.each do |el|
+        unless prefixes[el[:namespace]]
+          prefixes[el[:namespace]] = "ns#{index}"
+          index += 1
         end
-      ]
+      end
+
+      prefixes
     end
 
     # @private
     def build_type(params)
       Type.new(
         params[:name],
-        params[:prefix],
-        build_elements(params[:elements]),
-        params[:attributes]
+        prefix(params.fetch(:namespace)),
+        build_elements(params.fetch(:elements)),
+        params.fetch(:attributes)
       )
     end
 
@@ -120,7 +127,7 @@ module LolSoap
       Element.new(
         self,
         params[:name],
-        params[:prefix],
+        prefix(params[:namespace]),
         type_reference(params[:type]),
         params[:singular]
       )
@@ -128,16 +135,16 @@ module LolSoap
 
     # @private
     def type_reference(type)
-      if type.respond_to?(:to_str)
-        NamedTypeReference.new(type, self)
+      if type.is_a?(Array)
+        NamedTypeReference.new(*type, self)
       else
-        ImmediateTypeReference.new(build_type(type))
+        ImmediateTypeReference.new(type ? build_type(type) : NullType.new)
       end
     end
 
     # @private
     def message_format(element, parser)
-      build_element(parser.elements[element])
+      build_element(parser.elements.fetch(element))
     end
   end
 end

data/lib/lolsoap/wsdl_parser.rb

@@ -5,21 +5,17 @@ module LolSoap
   # @private
   class WSDLParser
     class Node
-      attr_reader :parser, :node, :target_namespace, :name, :prefix
+      attr_reader :parser, :node, :target_namespace, :name, :namespace
 
       def initialize(parser, node, target_namespace)
         @parser           = parser
         @node             = node
         @target_namespace = target_namespace
-        @prefix, @name    = prefix_and_name(node.attr('name'))
+        @namespace, @name = parser.namespace_and_name(node, node.attr('name').to_s, target_namespace)
       end
 
-      def name_with_prefix
-        "#{prefix}:#{name}"
-      end
-
-      def prefix_and_name(string)
-        parser.prefix_and_name(string, target_namespace)
+      def id
+        [namespace, name]
       end
     end
 
@@ -29,10 +25,11 @@ module LolSoap
           type = Type.new(parser, complex_type, target_namespace)
           {
             :elements   => type.elements,
+            :namespace  => type.namespace,
             :attributes => type.attributes
           }
-        else
-          prefix_and_name(node.attr('type').to_s).join(':')
+        elsif type = node.attr('type')
+          parser.namespace_and_name(node, type, target_namespace)
         end
       end
 
@@ -72,10 +69,10 @@ module LolSoap
             [
               element.name,
               {
-                :name     => element.name,
-                :prefix   => element.prefix,
-                :type     => element.type,
-                :singular => element.singular
+                :name      => element.name,
+                :namespace => element.namespace,
+                :type      => element.type,
+                :singular  => element.singular
               }
             ]
           end
@@ -83,7 +80,9 @@ module LolSoap
       end
 
       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) }
+        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 parent_elements
@@ -112,19 +111,6 @@ module LolSoap
       @doc = doc
     end
 
-    def namespaces
-      @namespaces ||= begin
-        namespaces = Hash[doc.collect_namespaces.map { |k, v| [k.sub(/^xmlns:/, ''), v] }]
-        namespaces.delete('xmlns')
-        namespaces
-      end
-    end
-
-    # We invert the hash in a deterministic way so that the results are repeatable.
-    def prefixes
-      @prefixes ||= Hash[namespaces.sort_by { |k, v| k }.uniq { |k, v| v }].invert
-    end
-
     def endpoint
       @endpoint ||= CGI.unescape(doc.at_xpath('/d:definitions/d:service/d:port/s:address/@location', ns).to_s)
     end
@@ -138,9 +124,9 @@ module LolSoap
         types = {}
         each_node('xs:complexType[not(@abstract="true")]') do |node, target_ns|
           type = Type.new(self, node, target_ns)
-          types[type.name_with_prefix] = {
+          types[type.id] = {
             :name       => type.name,
-            :prefix     => type.prefix,
+            :namespace  => type.namespace,
             :elements   => type.elements,
             :attributes => type.attributes
           }
@@ -150,7 +136,7 @@ module LolSoap
     end
 
     def type(name)
-      name = prefix_and_name(name).last
+      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)
@@ -162,10 +148,10 @@ module LolSoap
         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
+          elements[element.id] = {
+            :name      => element.name,
+            :namespace => element.namespace,
+            :type      => element.type
           }
         end
         elements
@@ -176,7 +162,7 @@ module LolSoap
       @messages ||= Hash[
         doc.xpath('/d:definitions/d:message', ns).map do |msg|
           element = msg.at_xpath('./d:part/@element', ns).to_s
-          [msg.attribute('name').to_s, prefix_and_name(element).join(':')]
+          [msg.attribute('name').to_s, namespace_and_name(msg, element)]
         end
       ]
     end
@@ -227,18 +213,16 @@ module LolSoap
       }
     end
 
-    def prefix_and_name(prefixed_name, default_namespace = nil)
-      prefix, name = prefixed_name.to_s.split(':')
-
-      if name
-        # Ensure we always use the same prefix for a given namespace
-        prefix = prefixes.fetch(namespaces.fetch(prefix))
+    def namespace_and_name(node, prefixed_name, default_namespace = nil)
+      if prefixed_name.include? ':'
+        prefix, name = prefixed_name.split(':')
+        namespace = node.namespaces.fetch("xmlns:#{prefix}")
       else
-        name   = prefix
-        prefix = prefixes.fetch(default_namespace)
+        name      = prefixed_name
+        namespace = default_namespace
       end
 
-      [prefix, name]
+      [namespace, name]
     end
 
     def each_node(xpath)

data/lolsoap.gemspec

@@ -2,15 +2,15 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: lolsoap 0.4.2 ruby lib
+# stub: lolsoap 0.5.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "lolsoap"
-  s.version = "0.4.2"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jon Leighton"]
-  s.date = "2013-12-09"
+  s.date = "2013-12-10"
   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 = [

data/test/fixtures/stock_quote.wsdl

@@ -23,11 +23,11 @@
       <element name="TradePrice">
          <complexType>
            <all>
-             <element name="xsd3:price" type="Price"/>
+             <element name="Price" type="xsd3:price"/>
            </all>
          </complexType>
       </element>
-      <element name="tradePriceRequest" type="TradePriceRequest" />
+      <element name="tradePriceRequest" type="xsd1:TradePriceRequest" />
       <complexType name="xsd1:TradePriceRequest" abstract="false">
         <complexContent>
           <extension base="xsd1:BaseRequest">
@@ -47,7 +47,7 @@
           </sequence>
         </complexType>
       </element>
-      <element name="historicalPriceRequest" type="HistoricalPriceRequest" />
+      <element name="historicalPriceRequest" type="xsd1:HistoricalPriceRequest" />
       <complexType name="xsd1:HistoricalPriceRequest">
         <complexContent>
           <extension base="xsd1:BaseRequest">
@@ -87,7 +87,7 @@
   </message>
 
   <message name="GetLastTradePriceOutput">
-    <part name="body" element="xsd3:TradePrice"/>
+    <part name="body" element="xsd1:TradePrice"/>
   </message>
 
   <message name="GetHistoricalPriceInput">

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/ns0:tradePriceRequest', doc.namespaces)
       body.wont_equal nil
     end
 
@@ -24,24 +24,24 @@ module LolSoap
         b.id 42
       end
 
-      el = doc.at_xpath('//xsd1:tradePriceRequest/xsd1:tickerSymbol', doc.namespaces)
+      el = doc.at_xpath('//ns0:tradePriceRequest/ns0: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('//ns0:tradePriceRequest/ns0:specialTickerSymbol/ns1: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('//ns0:tradePriceRequest/@id', doc.namespaces)
       attr.to_s.must_equal "42"
     end
 
     it 'creates some header' do
       subject.header do |h|
-        h['xsd1'].verySpecialBoolean true
+        h['ns0'].verySpecialBoolean true
       end
 
-      el = doc.at_xpath('/soap:Envelope/soap:Header/xsd1:verySpecialBoolean', doc.namespaces)
+      el = doc.at_xpath('/soap:Envelope/soap:Header/ns0:verySpecialBoolean', doc.namespaces)
       el.wont_equal nil
       el.text.to_s.must_equal 'true'
     end

data/test/integration/test_wsdl.rb

@@ -7,14 +7,14 @@ module LolSoap
 
     it 'should successfully parse a WSDL document' do
       subject.operations.length.must_equal 2
-      subject.operations['GetLastTradePrice'].tap do |o|
+      subject.operations.fetch('GetLastTradePrice').tap do |o|
         o.input.name.must_equal 'tradePriceRequest'
         o.action.must_equal     'http://example.com/GetLastTradePrice'
       end
 
       subject.types.length.must_equal 4
-      subject.types['xsd1:TradePriceRequest'].tap do |t|
-        t.prefix.must_equal 'xsd1'
+      subject.types.fetch('TradePriceRequest').tap do |t|
+        t.prefix.must_equal 'ns0'
       end
     end
 

data/test/unit/test_envelope.rb

@@ -5,25 +5,25 @@ module LolSoap
   describe Envelope do
     let(:wsdl) do
       OpenStruct.new(
-        :type_namespaces => { 'foo' => 'http://example.com/foo' },
-        :soap_version    => '1.2'
+        :namespaces   => { 'ns0' => 'http://example.com/foo' },
+        :soap_version => '1.2'
       )
     end
 
     let(:operation) do
-      OpenStruct.new(:input => OpenStruct.new(:prefix => 'foo', :name => 'WashHandsRequest'))
+      OpenStruct.new(:input => OpenStruct.new(:prefix => 'ns0', :name => 'WashHandsRequest'))
     end
 
     subject { Envelope.new(wsdl, operation) }
 
     let(:doc) { subject.doc }
     let(:header) { doc.at_xpath('/soap:Envelope/soap:Header', doc.namespaces) }
-    let(:input) { doc.at_xpath('/soap:Envelope/soap:Body/foo:WashHandsRequest', doc.namespaces) }
+    let(:input) { doc.at_xpath('/soap:Envelope/soap:Body/ns0:WashHandsRequest', doc.namespaces) }
 
     it 'has a skeleton SOAP envelope structure when first created' do
       doc.namespaces.must_equal(
         'xmlns:soap' => Envelope::SOAP_1_2,
-        'xmlns:foo'  => 'http://example.com/foo'
+        'xmlns:ns0'  => 'http://example.com/foo'
       )
 
       header.wont_equal nil

data/test/unit/test_wsdl.rb

@@ -5,6 +5,7 @@ module LolSoap
   describe WSDL do
     describe 'with a doc that can be parsed' do
       let(:namespace) { 'http://lolsoap.api/bla' }
+      let(:xs)        { "http://www.w3.org/2001/XMLSchema" }
 
       let(:parser) do
         OpenStruct.new(
@@ -12,70 +13,72 @@ module LolSoap
           :operations => {
             'washHands' => {
               :action => 'urn:washHands',
-              :input  => 'bla:brush',
-              :output => 'bla:Color'
+              :input  => [namespace, 'brush'],
+              :output => [namespace, 'Color']
             }
           },
           :types => {
-            'bla:Brush' => {
+            [namespace, 'Brush'] => {
+              :name => 'Brush',
               :elements => {
                 'handleColor' => {
-                  :name     => 'handleColor',
-                  :prefix   => 'bla',
-                  :type     => {
+                  :name      => 'handleColor',
+                  :namespace => namespace,
+                  :type      => {
                     :elements => {
                       'name' => {
-                        :name     => 'name',
-                        :prefix   => 'bla',
-                        :type     => 'xs:string',
-                        :singular => true
+                        :name      => 'name',
+                        :namespace => namespace,
+                        :singular  => true
                       },
                       'hex' => {
-                        :name     => 'hex',
-                        :prefix   => 'bla',
-                        :type     => 'xs:string',
-                        :singular => true
+                        :name      => 'hex',
+                        :namespace => namespace,
+                        :type      => [xs, "string"],
+                        :singular  => true
                       }
                     },
+                    :namespace  => namespace,
                     :attributes => []
                   },
                   :singular => true
                 },
                 'age' => {
-                  :name     => 'age',
-                  :prefix   => 'bla',
-                  :type     => 'xs:int',
-                  :singular => false
+                  :name      => 'age',
+                  :namespace => namespace,
+                  :type      => [xs, "int"],
+                  :singular  => false
                 }
               },
               :attributes => ['id'],
-              :prefix => 'bla'
+              :namespace  => namespace
             }
          },
          :elements => {
-            'bla:brush' => {
-              :name   => 'brush',
-              :prefix => 'bla',
-              :type   => 'bla:Brush'
+            [namespace, 'brush'] => {
+              :name      => 'brush',
+              :namespace => namespace,
+              :type      => [namespace, 'Brush']
             },
-            'bla:Color' => {
-              :name   => 'Color',
-              :prefix => 'bla',
-              :type   => {
+            [namespace, 'Color'] => {
+              :name      => 'Color',
+              :namespace => namespace,
+              :type      => {
                 :elements => {
                   'name' => {
-                    :name     => 'name',
-                    :prefix   => 'bla',
-                    :type     => 'xs:string',
-                    :singular => true
+                    :name      => 'name',
+                    :namespace => namespace,
+                    :type      => [xs, "string"],
+                    :singular  => true
                   },
                   'hex' => {
-                    :name     => 'hex',
-                    :prefix   => 'bla',
-                    :type     => 'xs:string',
-                    :singular => true
+                    :name      => 'hex',
+                    :namespace => namespace,
+                    :type      => [xs, "string"],
+                    :singular  => true
                   }
                 },
+                :namespace  => namespace,
                 :attributes => []
               }
             }
@@ -115,7 +118,7 @@ module LolSoap
 
       describe '#namespaces' do
         it 'returns a namespaces hash' do
-          subject.namespaces.must_equal({ 'bla' => namespace })
+          subject.namespaces.must_equal({ 'ns0' => namespace })
         end
       end
 
@@ -123,13 +126,13 @@ module LolSoap
         it 'returns a hash of types' do
           subject.types.length.must_equal 1
 
-          subject.types['bla:Brush'].tap do |t|
+          subject.types['Brush'].tap do |t|
             t.elements.length.must_equal 2
             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').prefix.must_equal 'ns0'
             t.element('handleColor').singular?.must_equal true
             t.element('age').type.must_equal WSDL::NullType.new
             t.element('age').singular?.must_equal false
@@ -140,18 +143,11 @@ module LolSoap
 
       describe '#type' do
         it 'returns a single type' do
-          subject.type('bla:Brush').must_equal subject.types['bla:Brush']
+          subject.type(namespace, 'Brush').must_equal subject.types.fetch('Brush')
         end
 
         it 'returns a null object if a type is missing' do
-          subject.type('FooBar').must_equal WSDL::NullType.new
-        end
-      end
-
-      describe '#type_namespaces' do
-        it 'returns only the namespaces that are used by types' do
-          parser.namespaces['foo'] = 'bar'
-          subject.type_namespaces.must_equal 'bla' => namespace
+          subject.type(namespace, 'FooBar').must_equal WSDL::NullType.new
         end
       end
     end

data/test/unit/test_wsdl_parser.rb

@@ -7,23 +7,13 @@ module LolSoap
       File.read(TEST_ROOT + '/fixtures/stock_quote.wsdl')
     end
 
-    let(:doc) { Nokogiri::XML(raw_doc) }
+    let(:doc)        { Nokogiri::XML(raw_doc) }
+    let(:namespace)  { "http://example.com/stockquote.xsd" }
+    let(:namespace2) { "http://example.com/stockquote2.xsd" }
+    let(:xs)         { "http://www.w3.org/2001/XMLSchema"  }
 
     subject { WSDLParser.new(doc) }
 
-    describe '#namespaces' do
-      it 'returns the namespaces used' do
-        subject.namespaces.must_equal({
-          'tns'  => 'http://example.com/stockquote.wsdl',
-          'xsd1' => 'http://example.com/stockquote.xsd',
-          'xsd2' => 'http://example.com/stockquote2.xsd',
-          'xsd3' => 'http://example.com/stockquote.xsd',
-          'soap' => 'http://schemas.xmlsoap.org/wsdl/soap12/',
-          'xs'   => 'http://www.w3.org/2001/XMLSchema'
-        })
-      end
-    end
-
     describe '#endpoint' do
       it 'returns the SOAP 1.2 service endpoint' do
         subject.endpoint.must_equal 'http://example.com/stockquote'
@@ -33,63 +23,64 @@ module LolSoap
     describe '#types' do
       it 'returns the types, with attributes and namespace' do
         subject.types.must_equal({
-          'xsd1:Price' => {
-            :prefix     => 'xsd1',
+          [namespace, 'Price'] => {
             :name       => 'Price',
+            :namespace  => namespace,
             :elements   => {},
             :attributes => ['currency']
           },
-          'xsd1:TradePriceRequest' => {
-            :prefix   => 'xsd1',
-            :name     => 'TradePriceRequest',
+          [namespace, 'TradePriceRequest'] => {
+            :name      => 'TradePriceRequest',
+            :namespace => namespace,
             :elements => {
               'accountId' => {
-                :name     => 'accountId',
-                :prefix   => 'xsd1',
-                :type     => 'xs:string',
-                :singular => true
+                :name      => 'accountId',
+                :namespace => namespace,
+                :type      => [xs, "string"],
+                :singular  => true
               },
               'tickerSymbol' => {
-                :name     => 'tickerSymbol',
-                :prefix   => 'xsd1',
-                :type     => 'xs:string',
-                :singular => false
+                :name      => 'tickerSymbol',
+                :namespace => namespace,
+                :type      => [xs, "string"],
+                :singular  => false
               },
               'specialTickerSymbol' => {
-                :name     => 'specialTickerSymbol',
-                :prefix   => 'xsd1',
-                :type     => 'xsd2:TickerSymbol',
-                :singular => false
+                :name      => 'specialTickerSymbol',
+                :namespace => namespace,
+                :type      => [namespace2, 'TickerSymbol'],
+                :singular  => false
               }
             },
             :attributes => ['signature', 'id']
           },
-          'xsd1:HistoricalPriceRequest' => {
-            :prefix   => 'xsd1',
-            :name     => 'HistoricalPriceRequest',
+          [namespace, 'HistoricalPriceRequest'] => {
+            :name      => 'HistoricalPriceRequest',
+            :namespace => namespace,
             :elements => {
               'accountId' => {
-                :name     => 'accountId',
-                :prefix   => 'xsd1',
-                :type     => 'xs:string',
-                :singular => true
+                :name      => 'accountId',
+                :namespace => namespace,
+                :type      => [xs, "string"],
+                :singular  => true
               },
               'dateRange' => {
-                :name     => 'dateRange',
-                :prefix   => 'xsd1',
-                :type     => {
-                  :elements => {
+                :name      => 'dateRange',
+                :namespace => namespace,
+                :type      => {
+                  :namespace => namespace,
+                  :elements  => {
                     'startDate' => {
-                      :name     => 'startDate',
-                      :prefix   => 'xsd1',
-                      :type     => 'xs:string',
-                      :singular => true
+                      :name      => 'startDate',
+                      :namespace => namespace,
+                      :type      => [xs, "string"],
+                      :singular  => true
                     },
                     'endDate' => {
-                      :name     => 'endDate',
-                      :prefix   => 'xsd1',
-                      :type     => 'xs:string',
-                      :singular => true
+                      :name      => 'endDate',
+                      :namespace => namespace,
+                      :type      => [xs, "string"],
+                      :singular  => true
                     }
                   },
                   :attributes => []
@@ -99,15 +90,15 @@ module LolSoap
             },
             :attributes => ['signature']
           },
-          'xsd2:TickerSymbol' => {
-            :prefix   => 'xsd2',
-            :name     => 'TickerSymbol',
-            :elements => {
+          [namespace2, 'TickerSymbol'] => {
+            :name      => 'TickerSymbol',
+            :namespace => namespace2,
+            :elements  => {
               'name' => {
-                :name     => 'name',
-                :prefix   => 'xsd2',
-                :type     => 'xs:string',
-                :singular => true
+                :name      => 'name',
+                :namespace => namespace2,
+                :type      => [xs, "string"],
+                :singular  => true
               }
             },
             :attributes => []
@@ -119,47 +110,49 @@ module LolSoap
     describe '#elements' do
       it 'returns the elements with inline types' do
         subject.elements.must_equal({
-          "xsd1:tradePriceRequest" => {
-            :name   => "tradePriceRequest",
-            :prefix => "xsd1",
-            :type   => "xsd1:TradePriceRequest"
+          [namespace, "tradePriceRequest"] => {
+            :name      => "tradePriceRequest",
+            :namespace => namespace,
+            :type      => [namespace, "TradePriceRequest"]
           },
-          "xsd1:TradePrice" => {
-            :name   => "TradePrice",
-            :prefix => "xsd1",
-            :type   => {
+          [namespace, "TradePrice"] => {
+            :name      => "TradePrice",
+            :namespace => namespace,
+            :type      => {
+              :namespace => namespace,
               :elements => {
-                'price' => {
-                  :name     => 'price',
-                  :prefix   => 'xsd1',
-                  :type     => 'xsd1:Price',
-                  :singular => true
+                'Price' => {
+                  :name      => 'Price',
+                  :namespace => namespace,
+                  :type      => [namespace, 'price'],
+                  :singular  => true
                 }
               },
               :attributes => []
             }
           },
-          "xsd1:historicalPriceRequest" => {
-            :name   => "historicalPriceRequest",
-            :prefix => "xsd1",
-            :type   => "xsd1:HistoricalPriceRequest"
+          [namespace, "historicalPriceRequest"] => {
+            :name      => "historicalPriceRequest",
+            :namespace => namespace,
+            :type      => [namespace, "HistoricalPriceRequest"]
           },
-          "xsd1:HistoricalPrice" => {
-            :name   => "HistoricalPrice",
-            :prefix => "xsd1",
-            :type   => {
+          [namespace, "HistoricalPrice"] => {
+            :name      => "HistoricalPrice",
+            :namespace => namespace,
+            :type      => {
+              :namespace => namespace,
               :elements => {
                 'date' => {
-                  :name     => 'date',
-                  :prefix   => 'xsd1',
-                  :type     => 'xs:date',
-                  :singular => true
+                  :name      => 'date',
+                  :namespace => namespace,
+                  :type      => [xs, 'date'],
+                  :singular  => true
                 },
                 'price' => {
-                  :name     => 'price',
-                  :prefix   => 'xsd1',
-                  :type     => 'xs:float',
-                  :singular => true
+                  :name      => 'price',
+                  :namespace => namespace,
+                  :type      => [xs, 'float'],
+                  :singular  => true
                 }
               },
               :attributes => []
@@ -172,10 +165,10 @@ module LolSoap
     describe '#messages' do
       it 'maps message names to types' do
         subject.messages.must_equal({
-          'GetLastTradePriceInput'   => 'xsd1:tradePriceRequest',
-          'GetLastTradePriceOutput'  => 'xsd1:TradePrice',
-          'GetHistoricalPriceInput'  => 'xsd1:historicalPriceRequest',
-          'GetHistoricalPriceOutput' => 'xsd1:HistoricalPrice'
+          'GetLastTradePriceInput'   => [namespace, 'tradePriceRequest'],
+          'GetLastTradePriceOutput'  => [namespace, 'TradePrice'],
+          'GetHistoricalPriceInput'  => [namespace, 'historicalPriceRequest'],
+          'GetHistoricalPriceOutput' => [namespace, 'HistoricalPrice']
         })
       end
     end
@@ -184,12 +177,12 @@ module LolSoap
       it 'is a hash containing input and output types' do
         subject.port_type_operations.must_equal({
           'GetLastTradePrice' => {
-            :input  => 'xsd1:tradePriceRequest',
-            :output => 'xsd1:TradePrice'
+            :input  => [namespace, 'tradePriceRequest'],
+            :output => [namespace, 'TradePrice']
           },
           'GetHistoricalPrice' => {
-            :input  => 'xsd1:historicalPriceRequest',
-            :output => 'xsd1:HistoricalPrice'
+            :input  => [namespace, 'historicalPriceRequest'],
+            :output => [namespace, 'HistoricalPrice']
           }
         })
       end
@@ -200,13 +193,13 @@ module LolSoap
         subject.operations.must_equal({
           'GetLastTradePrice' => {
             :action => 'http://example.com/GetLastTradePrice',
-            :input  => 'xsd1:tradePriceRequest',
-            :output => 'xsd1:TradePrice'
+            :input  => [namespace, 'tradePriceRequest'],
+            :output => [namespace, 'TradePrice']
           },
           'GetHistoricalPrice' => {
             :action => 'http://example.com/GetHistoricalPrice',
-            :input  => 'xsd1:historicalPriceRequest',
-            :output => 'xsd1:HistoricalPrice'
+            :input  => [namespace, 'historicalPriceRequest'],
+            :output => [namespace, 'HistoricalPrice']
           }
         })
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lolsoap
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Jon Leighton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-09 00:00:00.000000000 Z
+date: 2013-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -162,3 +162,4 @@ signing_key:
 specification_version: 4
 summary: A library for dealing with SOAP requests and responses.
 test_files: []
+has_rdoc: