lolsoap 0.1.0

data/lib/lolsoap/errors.rb

@@ -0,0 +1,15 @@
+module LolSoap
+  class Error < StandardError; end
+
+  class FaultRaised < Error
+    attr_reader :fault
+
+    def initialize(fault)
+      @fault = fault
+    end
+
+    def message
+      "#{fault.reason}\n#{fault.detail}"
+    end
+  end
+end

data/lib/lolsoap/fault.rb

@@ -0,0 +1,26 @@
+module LolSoap
+  class Fault
+    attr_reader :request, :node
+
+    def initialize(request, node)
+      @request = request
+      @node    = node
+    end
+
+    def soap_namespace
+      request.soap_namespace
+    end
+
+    def code
+      node.at_xpath('./soap:Code/soap:Value', 'soap' => soap_namespace).text.to_s
+    end
+
+    def reason
+      node.at_xpath('./soap:Reason/soap:Text', 'soap' => soap_namespace).text.to_s
+    end
+
+    def detail
+      node.at_xpath('./soap:Detail/*', 'soap' => soap_namespace).to_xml
+    end
+  end
+end

data/lib/lolsoap/hash_builder.rb

@@ -0,0 +1,48 @@
+module LolSoap
+  # Turns an XML node into a hash data structure. Works out which elements
+  # are supposed to be collections based on the type information.
+  class HashBuilder
+    attr_reader :node, :type
+
+    def initialize(node, type)
+      @node = node
+      @type = type
+    end
+
+    def output
+      if children.any?
+        children_hash
+      else
+        node.text.to_s
+      end
+    end
+
+    def children
+      @children ||= node.children.select(&:element?)
+    end
+
+    private
+
+    # @private
+    def children_hash
+      hash = {}
+      children.each do |child|
+        element = type.element(child.name)
+        output  = self.class.new(child, element.type).output
+
+        if Array === hash[child.name] || !element.singular?
+          hash[child.name] ||= []
+          hash[child.name] << output
+        else
+          if hash.include?(child.name)
+            hash[child.name] = [hash[child.name]]
+            hash[child.name] << output
+          else
+            hash[child.name] = output
+          end
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/lolsoap/request.rb

@@ -0,0 +1,54 @@
+module LolSoap
+  # Represents a HTTP request containing a SOAP Envelope
+  class Request
+    attr_reader :envelope
+
+    def initialize(envelope)
+      @envelope = envelope
+    end
+
+    # @see Envelope#body
+    def body(&block)
+      envelope.body(&block)
+    end
+
+    # @see Envelope#header
+    def header(&block)
+      envelope.header(&block)
+    end
+
+    # Namespace used for SOAP envelope tags
+    def soap_namespace
+      envelope.soap_namespace
+    end
+
+    # URL to be POSTed to
+    def url
+      envelope.endpoint
+    end
+
+    # The type of the element sent in the request body
+    def input_type
+      envelope.input_type
+    end
+
+    # The type of the element that will be received in the response body
+    def output_type
+      envelope.output_type
+    end
+
+    # Headers that must be set when making the request
+    def headers
+      {
+        'Content-Type'   => 'application/soap+xml;charset=UTF-8',
+        'Content-Length' => content.bytesize.to_s,
+        'SOAPAction'     => envelope.action
+      }
+    end
+
+    # The content to be sent in the HTTP request
+    def content
+      @content ||= envelope.to_xml
+    end
+  end
+end

data/lib/lolsoap/response.rb

@@ -0,0 +1,50 @@
+require 'lolsoap/errors'
+require 'lolsoap/fault'
+require 'lolsoap/hash_builder'
+require 'nokogiri'
+
+module LolSoap
+  class Response
+    attr_reader :request, :doc
+
+    # Create a new instance from a raw XML string
+    def self.parse(request, raw)
+      new(request, Nokogiri::XML::Document.parse(raw))
+    end
+
+    def initialize(request, doc)
+      @request = request
+      @doc     = doc
+
+      raise FaultRaised.new(fault) if fault
+    end
+
+    # Namespace used for SOAP Envelope tags
+    def soap_namespace
+      request.soap_namespace
+    end
+
+    # The XML node for the body of the envelope
+    def body
+      @body ||= doc.at_xpath('/soap:Envelope/soap:Body/*', 'soap' => soap_namespace)
+    end
+
+    # Convert the body node to a Hash, using WSDL type data to determine the structure
+    def body_hash(builder = HashBuilder)
+      builder.new(body, request.output_type).output
+    end
+
+    # The XML node for the header of the envelope
+    def header
+      @header ||= doc.at_xpath('/soap:Envelope/soap:Header', 'soap' => soap_namespace)
+    end
+
+    # SOAP fault, if any (an exception will be raised in the initializer, if there is one)
+    def fault
+      @fault ||= begin
+        node = doc.at_xpath('/soap:Envelope/soap:Body/soap:Fault', 'soap' => soap_namespace)
+        Fault.new(request, node) if node
+      end
+    end
+  end
+end

data/lib/lolsoap/wsdl.rb

@@ -0,0 +1,98 @@
+require 'lolsoap/wsdl_parser'
+
+module LolSoap
+  class WSDL
+    require 'lolsoap/wsdl/operation'
+    require 'lolsoap/wsdl/type'
+    require 'lolsoap/wsdl/null_type'
+    require 'lolsoap/wsdl/element'
+    require 'lolsoap/wsdl/null_element'
+
+    # Create a new instance by parsing a raw string of XML
+    def self.parse(raw)
+      new(WSDLParser.parse(raw))
+    end
+
+    attr_reader :parser
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    # Hash of operations that are supports by the SOAP service
+    def operations
+      load_operations.dup
+    end
+
+    # Get a single operation
+    def operation(name)
+      load_operations[name]
+    end
+
+    # Hash of types declared by the service
+    def types
+      load_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
+    end
+
+    # Namespaces used by the types (a subset of #namespaces)
+    def type_namespaces
+      Hash[parser.types.map { |k, t| [prefixes[t[:namespace]], t[:namespace]] }]
+    end
+
+    def inspect
+      "<LolSoap::WSDL " \
+      "namespaces=#{namespaces.inspect} " \
+      "operations=#{operations.keys.inspect} " \
+      "types=#{types.keys.inspect}>"
+    end
+
+    private
+
+    # @private
+    def load_operations
+      @operations ||= Hash[
+        parser.operations.map do |k, op|
+          [k, Operation.new(self, op[:action], type(op[:input][:name]), type(op[:output][:name]))]
+        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]))]
+        end
+      ]
+    end
+
+    # @private
+    def build_elements(elements)
+      Hash[
+        elements.map do |name, el|
+          [name, Element.new(self, name, el[:type], el[:singular])]
+        end
+      ]
+    end
+  end
+end

data/lib/lolsoap/wsdl/element.rb

@@ -0,0 +1,28 @@
+class LolSoap::WSDL
+  class Element
+    attr_reader :name
+
+    def initialize(wsdl, name, type_name, singular = true)
+      @wsdl      = wsdl
+      @name      = name
+      @type_name = type_name
+      @singular  = singular
+    end
+
+    def type
+      wsdl.type(@type_name.split(':').last)
+    end
+
+    def singular?
+      @singular == true
+    end
+
+    def inspect
+      "<LolSoap::WSDL::Element name=#{name.inspect} type=#{@type_name.inspect}>"
+    end
+
+    private
+
+    def wsdl; @wsdl; end
+  end
+end

data/lib/lolsoap/wsdl/null_element.rb

@@ -0,0 +1,15 @@
+class LolSoap::WSDL
+  class NullElement
+    def type
+      NullType.new
+    end
+
+    def singular?
+      true
+    end
+
+    def ==(other)
+      self.class === other
+    end
+  end
+end

data/lib/lolsoap/wsdl/null_type.rb

@@ -0,0 +1,19 @@
+class LolSoap::WSDL
+  class NullType
+    def prefix
+      nil
+    end
+
+    def elements
+      {}
+    end
+
+    def element(name)
+      NullType.new
+    end
+
+    def ==(other)
+      self.class === other
+    end
+  end
+end

data/lib/lolsoap/wsdl/operation.rb

@@ -0,0 +1,18 @@
+class LolSoap::WSDL
+  class Operation
+    attr_reader :wsdl, :action, :input, :output
+
+    def initialize(wsdl, action, input, output)
+      @wsdl   = wsdl
+      @action = action
+      @input  = input
+      @output = output
+    end
+
+    def inspect
+      "<LolSoap::WSDL::Operation " \
+      "action=#{action.inspect} " \
+      "input=#{input.inspect}>"
+    end
+  end
+end

data/lib/lolsoap/wsdl/type.rb

@@ -0,0 +1,38 @@
+class LolSoap::WSDL
+  class Type
+    attr_reader :name, :namespace
+
+    def initialize(wsdl, name, namespace, elements)
+      @wsdl      = wsdl
+      @name      = name
+      @namespace = namespace
+      @elements  = elements
+    end
+
+    def elements
+      @elements.dup
+    end
+
+    def element(name)
+      @elements.fetch(name) { NullElement.new }
+    end
+
+    def sub_type(name)
+      element(name).type
+    end
+
+    def prefix
+      wsdl.prefixes[namespace]
+    end
+
+    def inspect
+      "<LolSoap::WSDL::Type " \
+      "name=#{(prefix + ':' + name).inspect} " \
+      "elements=#{elements.inspect}>"
+    end
+
+    private
+
+    def wsdl; @wsdl; end
+  end
+end

data/lib/lolsoap/wsdl_parser.rb

@@ -0,0 +1,121 @@
+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'
+    }
+
+    attr_reader :doc
+
+    def self.parse(raw)
+      new(Nokogiri::XML::Document.parse(raw))
+    end
+
+    def initialize(doc)
+      @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
+
+    def endpoint
+      @endpoint ||= doc.at_xpath(
+        '/d:definitions/d:service/d:port/soap:address/@location',
+        'd' => NS[:wsdl], 'soap' => NS[:soap]
+      ).to_s
+    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)] }]
+              }
+            ]
+          end
+        ]
+      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]]
+        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
+          name   = op.attribute('name').to_s
+
+          [name, { :name => name, :input => messages[input], :output => messages[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
+
+        Hash[
+          doc.xpath("/d:definitions/d:binding[@name='#{binding}']/d:operation", 'd' => NS[:wsdl]).map do |op|
+            name   = op.attribute('name').to_s
+            action = op.at_xpath('./soap:operation/@soapAction', 'soap' => NS[:soap]).to_s
+
+            [
+              name,
+              {
+                :name   => name,
+                :action => action,
+                :input  => port_type_operations[name][:input],
+                :output => port_type_operations[name][:output]
+              }
+            ]
+          end
+        ]
+      end
+    end
+
+    private
+
+    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'
+      }
+    end
+  end
+end