lolsoap 0.1.4 → 0.2.0

data/README.md

@@ -36,7 +36,9 @@ client = LolSoap::Client.new(File.read('lolapi.wsdl'))
 request = client.request('getLols')
 
 # Populate the request with some data. Namespacing is taken care of
-# using the type data from the WSDL.
+# using the type data from the WSDL. The WSDL also tells us whether
+# a given name (e.g. lolFactor below) should be treated as an
+# attribute or a sub-element.
 request.body do |b|
   b.lolFactor '11'
   b.lolDuration 'lolever'
@@ -65,10 +67,11 @@ p response.body_hash
 
 ## Bugs/Features ##
 
-* SOAP 1.1 is not supported. Patches to add support will be considered
-  if they don't add too much extra complexity.
 * WSSE is not supported.
 * Assumes that you are able to supply a WSDL document for the service.
+* Some of the finer details of namespace handling may be glossed over.
+  This is just pragmatism; patches to improve namespace handling are
+  welcome.
 
 ## Overview ##
 
@@ -100,6 +103,24 @@ The others:
 
 Development sponsored by [Loco2](http://loco2.com/).
 
+## Changelog ##
+
+### 0.2 ###
+
+* SOAP 1.1 support
+* Better handling of namespaces in the XML schema. You should now be
+  able to have two types a:foo and b:foo and it will Just Work. This
+  introduces some API incompatibilities with version 1.1. Specifically,
+  `LolSoap::WSDL#types` is now keyed based on a prefixed type name
+  rather than an unprefixed type name. This shouldn't affect you if
+  you're not using `LolSoap::WSDL#types` directly.
+* Add support for building attributes with `LolSoap::Builder` based on
+  the XML Schema information.
+
+### 0.1 ###
+
+Initial release
+
 ## License ##
 
 (The MIT License)

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.2.0

data/lib/lolsoap/builder.rb

@@ -55,6 +55,10 @@ module LolSoap
       __prefixed_tag__(@type.prefix, @type.sub_type(name.to_s), name, *args, &block)
     end
 
+    def __attribute__(name, value)
+      @node[name.to_s] = value.to_s
+    end
+
     # @private
     def __prefixed_tag__(prefix, sub_type, name, *args)
       sub_node = @node.document.create_element(name.to_s, *args)
@@ -88,6 +92,13 @@ module LolSoap
 
     private
 
-    alias method_missing __tag__
+    # alias method_missing __tag__
+    def method_missing(name, *args, &block)
+      if @type.has_attribute?(name.to_s)
+        __attribute__(name, *args)
+      else
+        __tag__(name, *args, &block)
+      end
+    end
   end
 end

data/lib/lolsoap/envelope.rb

@@ -6,10 +6,10 @@ module LolSoap
     attr_reader :wsdl, :operation, :doc
 
     # @private
-    SOAP_PREFIX    = 'soap'
+    SOAP_1_1 = 'http://schemas.xmlsoap.org/soap/envelope/'
 
     # @private
-    SOAP_NAMESPACE = 'http://www.w3.org/2003/05/soap-envelope'
+    SOAP_1_2 = 'http://www.w3.org/2003/05/soap-envelope'
 
     def initialize(wsdl, operation, doc = Nokogiri::XML::Document.new)
       @wsdl      = wsdl
@@ -54,16 +54,20 @@ module LolSoap
       operation.output
     end
 
-    def to_xml
-      doc.to_xml
+    def to_xml(options = {})
+      doc.to_xml(options)
     end
 
     def soap_prefix
-      SOAP_PREFIX
+      'soap'
     end
 
     def soap_namespace
-      SOAP_NAMESPACE
+      soap_version == '1.2' ? SOAP_1_2 : SOAP_1_1
+    end
+
+    def soap_version
+      wsdl.soap_version
     end
 
     private

data/lib/lolsoap/fault.rb

@@ -11,16 +11,29 @@ module LolSoap
       request.soap_namespace
     end
 
+    def soap_version
+      request.soap_version
+    end
+
     def code
-      node.at_xpath('./soap:Code/soap:Value', 'soap' => soap_namespace).text.to_s
+      node.at_xpath(
+        soap_version == '1.2' ? './soap:Code/soap:Value' : './soap:faultcode',
+        'soap' => soap_namespace
+      ).text.to_s
     end
 
     def reason
-      node.at_xpath('./soap:Reason/soap:Text', 'soap' => soap_namespace).text.to_s
+      node.at_xpath(
+        soap_version == '1.2' ? './soap:Reason/soap:Text' : './soap:faultstring',
+        'soap' => soap_namespace
+      ).text.to_s
     end
 
     def detail
-      node.at_xpath('./soap:Detail/*', 'soap' => soap_namespace).to_xml
+      node.at_xpath(
+        soap_version == '1.2' ? './soap:Detail/*' : './soap:detail/*',
+        'soap' => soap_namespace
+      ).to_xml
     end
   end
 end

data/lib/lolsoap/request.rb

@@ -1,10 +1,12 @@
 module LolSoap
   # Represents a HTTP request containing a SOAP Envelope
   class Request
-    attr_reader :envelope
+    attr_reader   :envelope
+    attr_accessor :xml_options
 
     def initialize(envelope)
-      @envelope = envelope
+      @envelope    = envelope
+      @xml_options = {}
     end
 
     # @see Envelope#body
@@ -22,6 +24,11 @@ module LolSoap
       envelope.soap_namespace
     end
 
+    # The SOAP version in use
+    def soap_version
+      envelope.soap_version
+    end
+
     # URL to be POSTed to
     def url
       envelope.endpoint
@@ -40,7 +47,11 @@ module LolSoap
     # The MIME type of the request. This is always application/soap+xml,
     # but it could be overridden in a subclass.
     def mime
-      'application/soap+xml'
+      if soap_version == '1.1'
+        'text/xml'
+      else
+        'application/soap+xml'
+      end
     end
 
     # The charset of the request. This is always UTF-8, but it could be
@@ -66,7 +77,7 @@ module LolSoap
 
     # The content to be sent in the HTTP request
     def content
-      @content ||= envelope.to_xml
+      @content ||= envelope.to_xml(xml_options)
     end
   end
 end

data/lib/lolsoap/wsdl/element.rb

@@ -9,14 +9,14 @@ class LolSoap::WSDL
       @singular  = singular
     end
 
-    def type
-      @type ||= wsdl.type(@type_name.split(':').last)
-    end
-
     def singular?
       @singular == true
     end
 
+    def type
+      @type ||= wsdl.type(@type_name)
+    end
+
     def inspect
       "<#{self.class} name=#{name.inspect} type=#{@type_name.inspect}>"
     end

data/lib/lolsoap/wsdl/type.rb

@@ -1,12 +1,14 @@
+require 'set'
+
 class LolSoap::WSDL
   class Type
-    attr_reader :name, :namespace
+    attr_reader :name, :prefix
 
-    def initialize(wsdl, name, namespace, elements)
-      @wsdl      = wsdl
-      @name      = name
-      @namespace = namespace
-      @elements  = elements
+    def initialize(name, prefix, elements, attributes)
+      @name       = name
+      @prefix     = prefix
+      @elements   = elements
+      @attributes = Set.new(attributes)
     end
 
     def elements
@@ -21,18 +23,18 @@ class LolSoap::WSDL
       element(name).type
     end
 
-    def prefix
-      wsdl.prefixes[namespace]
+    def attributes
+      @attributes.to_a
     end
 
-    def inspect
-      "<#{self.class} " \
-      "name=#{(prefix + ':' + name).inspect} " \
-      "elements=#{elements.inspect}>"
+    def has_attribute?(name)
+      @attributes.include?(name)
     end
 
-    private
-
-    def wsdl; @wsdl; end
+    def inspect
+      "<#{self.class} name=\"#{prefix}:#{name}\" " \
+        "elements=#{elements.inspect} " \
+        "attributes=#{attributes.inspect}>"
+    end
   end
 end

data/lib/lolsoap/wsdl.rb

@@ -13,75 +13,83 @@ module LolSoap
       new(WSDLParser.parse(raw))
     end
 
-    attr_reader :parser
+    # The SOAP endpoint URL
+    attr_reader :endpoint
+
+    # Hash of namespaces used in the WSDL document (keys are prefixes)
+    attr_reader :namespaces
+
+    # Hash of namespace prefixes used in the WSDL document (keys are namespace URIs)
+    attr_reader :prefixes
+
+    # The version of SOAP detected.
+    attr_reader :soap_version
 
     def initialize(parser)
-      @parser = 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
-      load_operations.dup
+      @operations.dup
     end
 
     # Get a single operation
     def operation(name)
-      load_operations[name]
+      @operations.fetch(name)
     end
 
     # Hash of types declared by the service
     def types
-      load_types.dup
+      @types.dup
     end
 
     # Get a single type, or a NullType if the type doesn't exist
     def type(name)
-      load_types.fetch(name) { NullType.new }
-    end
-
-    # The SOAP endpoint URL
-    def endpoint
-      parser.endpoint
-    end
-
-    # Hash of namespaces used in the WSDL document (keys are prefixes)
-    def namespaces
-      parser.namespaces
-    end
-
-    # Hash of namespace prefixes used in the WSDL document (keys are namespace URIs)
-    def prefixes
-      namespaces.invert
+      @types.fetch(name) { NullType.new }
     end
 
     # Namespaces used by the types (a subset of #namespaces)
     def type_namespaces
-      Hash[parser.types.map { |k, t| [prefixes[t[:namespace]], t[:namespace]] }]
+      Hash[@types.values.map { |type| [type.prefix, namespaces[type.prefix]] }]
     end
 
     def inspect
       "<#{self.class} " \
-      "namespaces=#{namespaces.inspect} " \
-      "operations=#{operations.keys.inspect} " \
-      "types=#{types.keys.inspect}>"
+      "namespaces=#{@namespaces.inspect} " \
+      "operations=#{@operations.keys.inspect} " \
+      "types=#{@types.keys.inspect}>"
     end
 
     private
 
     # @private
-    def load_operations
-      @operations ||= Hash[
+    def load_operations(parser)
+      Hash[
         parser.operations.map do |k, op|
-          [k, Operation.new(self, op[:action], type(op[:input][:name]), type(op[:output][:name]))]
+          [k, Operation.new(self, op[:action], type(op[:input]), type(op[:output]))]
         end
       ]
     end
 
     # @private
-    def load_types
-      @types ||= Hash[
-        parser.types.map do |name, type|
-          [name, Type.new(self, name, type[:namespace], build_elements(type[:elements]))]
+    def load_types(parser)
+      Hash[
+        parser.types.map do |prefixed_name, type|
+          [
+            prefixed_name,
+            Type.new(
+              type[:name],
+              type[:prefix],
+              build_elements(type[:elements]),
+              type[:attributes]
+            )
+          ]
         end
       ]
     end

data/lib/lolsoap/wsdl_parser.rb

@@ -3,11 +3,47 @@ require 'nokogiri'
 module LolSoap
   # @private
   class WSDLParser
-    NS = {
-      :wsdl      => 'http://schemas.xmlsoap.org/wsdl/',
-      :soap      => 'http://schemas.xmlsoap.org/wsdl/soap12/',
-      :xmlschema => 'http://www.w3.org/2001/XMLSchema'
-    }
+    class Type
+      attr_reader :parser, :node, :target_namespace, :name, :prefix
+
+      def initialize(parser, node, target_namespace)
+        @parser           = parser
+        @node             = node
+        @target_namespace = target_namespace
+        @prefix, @name    = prefix_and_name(node.attr('name'))
+      end
+
+      def name_with_prefix
+        "#{prefix}:#{name}"
+      end
+
+      def elements
+        Hash[
+          node.xpath('.//xs:element', parser.ns).map do |element|
+            max_occurs = element.attribute('maxOccurs').to_s
+
+            [
+              prefix_and_name(element.attr('name')).last,
+              {
+                :type     => prefix_and_name(element.attr('type')).join(':'),
+                :singular => max_occurs.empty? || max_occurs == '1'
+              }
+            ]
+          end
+        ]
+      end
+
+      def attributes
+        node.xpath('.//xs:attribute/@name', parser.ns).map(&:text)
+      end
+
+      def prefix_and_name(string)
+        parser.prefix_and_name(string, target_namespace)
+      end
+    end
+
+    SOAP_1_1 = 'http://schemas.xmlsoap.org/wsdl/soap/'
+    SOAP_1_2 = 'http://schemas.xmlsoap.org/wsdl/soap12/'
 
     attr_reader :doc
 
@@ -27,79 +63,76 @@ module LolSoap
       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 ||= doc.at_xpath(
-        '/d:definitions/d:service/d:port/soap:address/@location',
-        'd' => NS[:wsdl], 'soap' => NS[:soap]
-      ).to_s
+      @endpoint ||= doc.at_xpath('/d:definitions/d:service/d:port/s:address/@location', ns).to_s
+    end
+
+    def schemas
+      doc.xpath('/d:definitions/d:types/xs:schema', ns)
     end
 
     def types
       @types ||= begin
-        types = doc.xpath(
-          '/d:definitions/d:types/s:schema/s:element[@name]',
-          '/d:definitions/d:types/s:schema/s:complexType[@name]',
-          'd' => NS[:wsdl], 's' => NS[:xmlschema]
-        )
-        Hash[
-          types.map do |type|
-            namespace = type.at_xpath('ancestor::s:schema/@targetNamespace', 's' => NS[:xmlschema]).to_s
-            elements  = type.xpath('.//s:element', 's' => NS[:xmlschema])
-            name      = type.attribute('name').to_s
-
-            [
-              name,
-              {
-                :name      => name,
-                :namespace => namespace,
-                :elements  => Hash[elements.map { |e| [e.attribute('name').to_s, element_hash(e)] }]
-              }
-            ]
+        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
-        ]
+        end
+        types
       end
     end
 
     def messages
       @messages ||= Hash[
-        doc.xpath('/d:definitions/d:message', 'd' => NS[:wsdl]).map do |msg|
-          element = msg.at_xpath('./d:part/@element', 'd' => NS[:wsdl]).to_s
-          [msg.attribute('name').to_s, types[element.split(':').last]]
+        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(':')]
         end
       ]
     end
 
     def port_type_operations
       @port_type_operations ||= Hash[
-        doc.xpath('/d:definitions/d:portType/d:operation', 'd' => NS[:wsdl]).map do |op|
-          input  = op.at_xpath('./d:input/@message',  'd' => NS[:wsdl]).to_s.split(':').last
-          output = op.at_xpath('./d:output/@message', 'd' => NS[:wsdl]).to_s.split(':').last
+        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, { :name => name, :input => messages[input], :output => messages[output] }]
+          [name, { :input => messages.fetch(input), :output => messages.fetch(output) }]
         end
       ]
     end
 
     def operations
       @operations ||= begin
-        binding = doc.at_xpath(
-          '/d:definitions/d:service/d:port/soap:address/../@binding',
-          'd' => NS[:wsdl], 'soap' => NS[:soap]
-        ).to_s.split(':').last
+        binding = doc.at_xpath('/d:definitions/d:service/d:port/s:address/../@binding', ns).to_s.split(':').last
 
         Hash[
-          doc.xpath("/d:definitions/d:binding[@name='#{binding}']/d:operation", 'd' => NS[:wsdl]).map do |op|
+          doc.xpath("/d:definitions/d:binding[@name='#{binding}']/d:operation", ns).map do |op|
             name   = op.attribute('name').to_s
-            action = op.at_xpath('./soap:operation/@soapAction', 'soap' => NS[:soap]).to_s
+            action = op.at_xpath('./s:operation/@soapAction', ns).to_s
 
             [
               name,
               {
-                :name   => name,
                 :action => action,
-                :input  => port_type_operations[name][:input],
-                :output => port_type_operations[name][:output]
+                :input  => port_type_operations.fetch(name)[:input],
+                :output => port_type_operations.fetch(name)[:output]
               }
             ]
           end
@@ -107,15 +140,30 @@ module LolSoap
       end
     end
 
-    private
+    def soap_version
+      @soap_version ||= namespaces.values.include?(SOAP_1_2) ? '1.2' : '1.1'
+    end
 
-    def element_hash(el)
-      max_occurs = el.attribute('maxOccurs').to_s
-      {
-        :name     => el.attribute('name').to_s,
-        :type     => el.attribute('type').to_s,
-        :singular => max_occurs.empty? || max_occurs == '1'
+    def ns
+      @ns ||= {
+        'd'  => 'http://schemas.xmlsoap.org/wsdl/',
+        'xs' => 'http://www.w3.org/2001/XMLSchema',
+        's'  => soap_version == '1.2' ? SOAP_1_2 : SOAP_1_1
       }
     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))
+      else
+        name   = prefix
+        prefix = prefixes.fetch(default_namespace)
+      end
+
+      [prefix, name]
+    end
   end
 end

data/lolsoap.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "lolsoap"
-  s.version = "0.1.4"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jon Leighton"]
-  s.date = "2012-05-17"
+  s.date = "2013-05-15"
   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 = [
@@ -45,6 +45,7 @@ Gem::Specification.new do |s|
     "lolsoap.gemspec",
     "test/fixtures/stock_quote.wsdl",
     "test/fixtures/stock_quote_fault.xml",
+    "test/fixtures/stock_quote_fault_soap_1_1.xml",
     "test/fixtures/stock_quote_response.xml",
     "test/helper.rb",
     "test/integration/test_client.rb",
@@ -67,7 +68,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/loco2/lolsoap"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.15"
+  s.rubygems_version = "1.8.24"
   s.summary = "A library for dealing with SOAP requests and responses."
 
   if s.respond_to? :specification_version then

data/test/fixtures/stock_quote.wsdl

@@ -6,22 +6,25 @@
              xmlns:xsd1="http://example.com/stockquote.xsd"
              xmlns:xsd2="http://example.com/stockquote2.xsd"
              xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/"
+             xmlns:xs="http://www.w3.org/2001/XMLSchema"
              xmlns="http://schemas.xmlsoap.org/wsdl/">
 
   <types>
     <schema targetNamespace="http://example.com/stockquote.xsd"
+            xmlns:xsd3="http://example.com/stockquote.xsd"
             xmlns="http://www.w3.org/2001/XMLSchema">
       <element name="TradePrice">
          <complexType>
            <all>
-             <element name="price" type="float"/>
+             <element name="xsd3:price" type="xs:float"/>
            </all>
          </complexType>
       </element>
-      <complexType name="TradePriceRequest">
+      <complexType name="xsd3:TradePriceRequest">
         <sequence>
-          <element name="tickerSymbol" type="string" maxOccurs="5"/>
+          <element name="tickerSymbol" type="xs:string" maxOccurs="5"/>
           <element name="specialTickerSymbol" type="xsd2:TickerSymbol" maxOccurs="unbounded"/>
+          <attribute name="id" type="xs:string"/>
         </sequence>
       </complexType>
     </schema>
@@ -30,7 +33,7 @@
             xmlns="http://www.w3.org/2001/XMLSchema">
       <complexType name="TickerSymbol">
         <sequence>
-          <element name="name" type="string" maxOccurs="1"/>
+          <element name="name" type="xs:string" maxOccurs="1"/>
         </sequence>
       </complexType>
     </schema>
@@ -41,7 +44,7 @@
   </message>
 
   <message name="GetLastTradePriceOutput">
-    <part name="body" element="xsd1:TradePrice"/>
+    <part name="body" element="xsd3:TradePrice"/>
   </message>
 
   <portType name="StockQuotePortType">