sekken 0.1.0

data/lib/sekken/importer.rb

@@ -0,0 +1,77 @@
+require 'nokogiri'
+require 'sekken/wsdl/document'
+
+class Sekken
+  class Importer
+
+    def initialize(resolver, documents, schemas)
+      @logger = Logging.logger[self]
+
+      @resolver = resolver
+      @documents = documents
+      @schemas = schemas
+    end
+
+    def import(location)
+      @import_locations = []
+
+      @logger.info("Resolving WSDL document #{location.inspect}.")
+      import_document(location) do |document|
+        @documents << document
+        @schemas.push(document.schemas)
+      end
+
+      # resolve xml schema imports
+      import_schemas do |schema_location|
+        @logger.info("Resolving XML schema import #{schema_location.inspect}.")
+
+        import_document(schema_location) do |document|
+          @schemas.push(document.schemas)
+        end
+      end
+    end
+
+    private
+
+    def import_document(location, &block)
+      if @import_locations.include? location
+        @logger.info("Skipping already imported location #{location.inspect}.")
+        return
+      end
+
+      xml = @resolver.resolve(location)
+      @import_locations << location
+
+      document = WSDL::Document.new Nokogiri.XML(xml), @schemas
+      block.call(document)
+
+      # resolve wsdl imports
+      document.imports.each do |import_location|
+        @logger.info("Resolving WSDL import #{import_location.inspect}.")
+        import_document(import_location, &block)
+      end
+    end
+
+    def import_schemas
+      @schemas.each do |schema|
+        schema.imports.each do |namespace, schema_location|
+          next unless schema_location
+
+          unless absolute_url? schema_location
+            @logger.warn("Skipping XML Schema import #{schema_location.inspect}.")
+            next
+          end
+
+          # TODO: also skip if the schema was already imported
+
+          yield(schema_location)
+        end
+      end
+    end
+
+    def absolute_url?(location)
+      location =~ Resolver::URL_PATTERN
+    end
+
+  end
+end

data/lib/sekken/message.rb

@@ -0,0 +1,135 @@
+require 'builder'
+
+class Sekken
+  class Message
+
+    ATTRIBUTE_PREFIX = '_'
+
+    def initialize(envelope, parts)
+      @logger = Logging.logger[self]
+
+      @envelope = envelope
+      @parts = parts
+    end
+
+    def build(message)
+      builder = Builder::XmlMarkup.new(indent: 2, margin: 2)
+
+      build_elements(@parts, message.dup, builder)
+      builder.target!
+    end
+
+    private
+
+    def build_elements(elements, message, xml)
+      elements.each do |element|
+        name = element.name
+        symbol_name = name.to_sym
+
+        value = extract_value(name, symbol_name, message)
+
+        if value == :unspecified
+          @logger.debug("Skipping (optional?) element #{symbol_name.inspect} with no value.")
+          next
+        end
+
+        tag = [symbol_name]
+
+        if element.form == 'qualified'
+          nsid = @envelope.register_namespace(element.namespace)
+          tag.unshift(nsid)
+        end
+
+        case
+          when element.simple_type?
+            build_simple_type_element(element, xml, tag, value)
+
+          when element.complex_type?
+            build_complex_type_element(element, xml, tag, value)
+
+        end
+      end
+    end
+
+    def build_simple_type_element(element, xml, tag, value)
+      if element.singular?
+        if value.kind_of? Array
+          raise ArgumentError, "Unexpected Array for the #{tag.last.inspect} simple type"
+        end
+        if value.is_a? Hash
+          attributes, value = extract_attributes(value)
+          xml.tag! *tag, value[tag[1]], attributes
+        else
+          xml.tag! *tag, value
+        end
+      else
+        unless value.kind_of? Array
+          raise ArgumentError, "Expected an Array of values for the #{tag.last.inspect} simple type"
+        end
+
+        value.each do |val|
+          xml.tag! *tag, val
+        end
+      end
+    end
+
+    def build_complex_type_element(element, xml, tag, value)
+      if element.singular?
+        unless value.kind_of? Hash
+          raise ArgumentError, "Expected a Hash for the #{tag.last.inspect} complex type"
+        end
+
+        build_complex_tag(element, tag, value, xml)
+      else
+        unless value.kind_of? Array
+          raise ArgumentError, "Expected an Array of Hashes for the #{tag.last.inspect} complex type"
+        end
+
+        value.each do |val|
+          build_complex_tag(element, tag, val, xml)
+        end
+      end
+    end
+
+    def build_complex_tag(element, tag, value, xml)
+      attributes, value = extract_attributes(value)
+      children = element.children
+
+      if children.count > 0
+        xml.tag! *tag, attributes do |xml|
+          build_elements(children, value, xml)
+        end
+      elsif value && value[tag[1]]
+        xml.tag! *tag, value[tag[1]], attributes
+      else
+        xml.tag! *tag, attributes
+      end
+    end
+
+    # Private: extracts the value from the message by name or symbol_name.
+    # Respects nil values and returns a special symbol for actual missing values.
+    def extract_value(name, symbol_name, message)
+      if message.include? name
+        message[name]
+      elsif message.include? symbol_name
+        message[symbol_name]
+      else
+        :unspecified
+      end
+    end
+
+    def extract_attributes(hash)
+      attributes = {}
+
+      hash.dup.each do |k, v|
+        next unless k.to_s[0, 1] == ATTRIBUTE_PREFIX
+
+        attributes[k.to_s[1..-1]] = v
+        hash.delete(k)
+      end
+
+      [attributes, hash]
+    end
+
+  end
+end

data/lib/sekken/operation.rb

@@ -0,0 +1,100 @@
+require 'sekken/response'
+require 'sekken/envelope'
+require 'sekken/example_message'
+
+class Sekken
+  class Operation
+
+    ENCODING = 'UTF-8'
+
+    CONTENT_TYPE = {
+      '1.1' => 'text/xml;charset=%s',
+      '1.2' => 'application/soap+xml;charset=%s'
+    }
+
+    def initialize(operation, wsdl, http)
+      @operation = operation
+      @wsdl = wsdl
+      @http = http
+
+      @endpoint = operation.endpoint
+      @soap_version = operation.soap_version
+      @soap_action = operation.soap_action
+      @encoding = ENCODING
+    end
+
+    # Public: Accessor for the SOAP endpoint.
+    attr_accessor :endpoint
+
+    # Public: Accessor for the SOAP version.
+    attr_accessor :soap_version
+
+    # Public: Accessor for the SOAPAction HTTP header.
+    attr_accessor :soap_action
+
+    # Public: Accessor for the encoding. Defaults to 'UTF-8'.
+    attr_accessor :encoding
+
+    # Public: Returns a Hash of HTTP headers to send.
+    def http_headers
+      return @http_headers if @http_headers
+      headers = {}
+
+      headers['SOAPAction']   = %{"#{soap_action}"} if soap_action
+      headers['Content-Type'] = CONTENT_TYPE[soap_version] % encoding
+
+      @http_headers = headers
+    end
+
+    # Public: Sets the Hash of HTTP headers.
+    attr_writer :http_headers
+
+    # Public: Sets the request header Hash.
+    attr_accessor :header
+
+    # Public: Create an example request header Hash.
+    def example_header
+      ExampleMessage.build(@operation.input.header_parts)
+    end
+
+    # Public: Sets the request body Hash.
+    attr_accessor :body
+
+    # Public: Create an example request body Hash.
+    def example_body
+      ExampleMessage.build(@operation.input.body_parts)
+    end
+
+    # Public: Returns the input body parts used to build the request body.
+    def body_parts
+      @operation.input.body_parts.inject([]) { |memo, part| memo + part.to_a }
+    end
+
+    # Public: Build the request XML for this operation.
+    def build
+      Envelope.new(@operation, header, body).to_s
+    end
+
+    # Public: Sets the request envelope XML. Use in place of body().
+    attr_accessor :xml_envelope
+
+    # Public: Call the operation.
+    def call
+      message = (xml_envelope != nil ? xml_envelope : build)
+
+      raw_response = @http.post(endpoint, http_headers, message)
+      Response.new(raw_response)
+    end
+
+    # Public: Returns the input style for this operation.
+    def input_style
+      @input_style ||= @operation.input_style
+    end
+
+    # Public: Returns the output style for this operation.
+    def output_style
+      @output_style ||= @operation.output_style
+    end
+
+  end
+end

data/lib/sekken/resolver.rb

@@ -0,0 +1,20 @@
+class Sekken
+  class Resolver
+
+    URL_PATTERN = /^http[s]?:/
+    XML_PATTERN = /^</
+
+    def initialize(http)
+      @http = http
+    end
+
+    def resolve(location)
+      case location
+        when URL_PATTERN then @http.get(location)
+        when XML_PATTERN then location
+        else                  File.read(location)
+      end
+    end
+
+  end
+end

data/lib/sekken/response.rb

@@ -0,0 +1,50 @@
+require "nori"
+
+class Sekken
+  class Response
+
+    def initialize(raw_response)
+      @raw_response = raw_response
+    end
+
+    def raw
+      @raw_response
+    end
+
+    def body
+      hash[:envelope][:body]
+    end
+    alias to_hash body
+
+    def header
+      hash[:envelope][:header]
+    end
+
+    def hash
+      @hash ||= nori.parse(raw)
+    end
+
+    def doc
+      @doc ||= Nokogiri.XML(raw)
+    end
+
+    def xpath(path, namespaces = nil)
+      doc.xpath(path, namespaces || xml_namespaces)
+    end
+
+    private
+
+    def nori
+      return @nori if @nori
+
+      nori_options = {
+        strip_namespaces: true,
+        convert_tags_to: lambda { |tag| tag.snakecase.to_sym }
+      }
+
+      non_nil_nori_options = nori_options.reject { |_, value| value.nil? }
+      @nori = Nori.new(non_nil_nori_options)
+    end
+
+  end
+end

data/lib/sekken/version.rb

@@ -0,0 +1,5 @@
+class Sekken
+
+  VERSION = '0.1.0'
+
+end

data/lib/sekken/wsdl.rb

@@ -0,0 +1,86 @@
+require 'sekken/wsdl/operation'
+require 'sekken/wsdl/document_collection'
+require 'sekken/xs/schema_collection'
+require 'sekken/resolver'
+require 'sekken/importer'
+
+class Sekken
+  class WSDL
+
+    def initialize(wsdl, http)
+      @documents = WSDL::DocumentCollection.new
+      @schemas = XS::SchemaCollection.new
+
+      resolver = Resolver.new(http)
+      importer = Importer.new(resolver, @documents, @schemas)
+      importer.import(wsdl)
+    end
+
+    # Public: Returns the DocumentCollection.
+    attr_reader :documents
+
+    # Public: Returns the SchemaCollection.
+    attr_reader :schemas
+
+    # Public: Returns the name of the service.
+    def service_name
+      @documents.service_name
+    end
+
+    # Public: Returns a Hash of services and ports defined by the WSDL.
+    def services
+      @documents.services.values.inject({}) { |memo, service| memo.merge service.to_hash }
+    end
+
+    # Public: Returns an Hash of operation names to Operations by service and port name.
+    def operations(service_name, port_name)
+      verify_service_and_port_exist! service_name, port_name
+
+      port = @documents.service_port(service_name, port_name)
+      binding = port.fetch_binding(@documents)
+
+      binding.operations.keys
+    end
+
+    # Public: Returns an Operation by service, port and operation name.
+    def operation(service_name, port_name, operation_name)
+      verify_operation_exists! service_name, port_name, operation_name
+
+      port = @documents.service_port(service_name, port_name)
+      endpoint = port.location
+
+      binding = port.fetch_binding(@documents)
+      binding_operation = binding.operations.fetch(operation_name)
+
+      port_type = binding.fetch_port_type(@documents)
+      port_type_operation = port_type.operations.fetch(operation_name)
+
+      Operation.new(operation_name, endpoint, binding_operation, port_type_operation, self)
+    end
+
+    private
+
+    # Private: Raises a useful error in case the operation does not exist.
+    def verify_operation_exists!(service_name, port_name, operation_name)
+      operations = operations(service_name, port_name)
+
+      unless operations.include? operation_name
+        raise ArgumentError, "Unknown operation #{operation_name.inspect} for " \
+                             "service #{service_name.inspect} and port #{port_name.inspect}.\n" \
+                             "You may want to try one of #{operations.inspect}."
+      end
+    end
+
+    # Private: Raises a useful error in case the service or port does not exist.
+    def verify_service_and_port_exist!(service_name, port_name)
+      service = services[service_name]
+      port = service[:ports][port_name] if service
+
+      unless port
+        raise ArgumentError, "Unknown service #{service_name.inspect} or port #{port_name.inspect}.\n" \
+                             "Here is a list of known services and port:\n" + services.inspect
+      end
+    end
+
+  end
+end