sekken 0.1.0

data/lib/sekken/wsdl/binding.rb

@@ -0,0 +1,64 @@
+require 'sekken/wsdl/binding_operation'
+
+class Sekken
+  class WSDL
+    class Binding
+
+      def initialize(binding_node)
+        @binding_node = binding_node
+
+        @name = binding_node['name']
+        @port_type = binding_node['type']
+
+        if soap_node = find_soap_node
+          @style = soap_node['style'] || 'document'
+          @transport = soap_node['transport']
+        end
+      end
+
+      attr_reader :name, :port_type, :style, :transport
+
+      def fetch_port_type(documents)
+        port_type_local = @port_type.split(':').last
+
+        documents.port_types.fetch(port_type_local) {
+          raise "Unable to find portType #{port_type_local.inspect} for binding #{@name.inspect}"
+        }
+      end
+
+      def operations
+        @operations ||= operations!
+      end
+
+      private
+
+      def operations!
+        operations = {}
+
+        @binding_node.element_children.each do |operation_node|
+          next unless operation_node.name == 'operation'
+
+          operation_name = operation_node['name']
+          operation = BindingOperation.new(operation_node, :style => @style)
+
+          operations[operation_name] = operation
+        end
+
+        operations
+      end
+
+      def find_soap_node
+        @binding_node.element_children.find { |node|
+          namespace = node.namespace.href
+
+          soap_1_1 = namespace == Sekken::NS_SOAP_1_1
+          soap_1_2 = namespace == Sekken::NS_SOAP_1_2
+          binding  = node.name == 'binding'
+
+          (soap_1_1 || soap_1_2) && binding
+        }
+      end
+
+    end
+  end
+end

data/lib/sekken/wsdl/binding_operation.rb

@@ -0,0 +1,85 @@
+class Sekken
+  class WSDL
+    class BindingOperation
+
+      def initialize(operation_node, defaults = {})
+        @operation_node = operation_node
+
+        if soap_operation_node = find_soap_operation_node
+          namespace = soap_operation_node.first
+          node = soap_operation_node.last
+
+          @soap_namespace = namespace
+          @soap_action = node['soapAction']
+          @style = node['style'] || defaults[:style]
+        end
+      end
+
+      attr_reader :soap_action, :style, :soap_namespace
+
+      def name
+        @operation_node['name']
+      end
+
+      # TODO: maybe use proper classes to clean this up.
+      def input_headers
+        return @input_headers if @input_headers
+        input_headers = []
+
+        if header_nodes = find_input_child_nodes('header')
+          header_nodes.each do |header_node|
+            input_headers << {
+              encoding_style: header_node['encodingStyle'],
+              namespace:      header_node['namespace'],
+              use:            header_node['use'],
+              message:        header_node['message'],
+              part:           header_node['part']
+            }
+          end
+        end
+
+        @input_headers = input_headers
+      end
+
+      # TODO: maybe use proper classes to clean this up.
+      def input_body
+        return @input_body if @input_body
+        input_body = {}
+
+        if body_node = find_input_child_nodes('body').first
+          input_body = {
+            encoding_style: body_node['encodingStyle'],
+            namespace:      body_node['namespace'],
+            use:            body_node['use']
+          }
+        end
+
+        @input_body = input_body
+      end
+
+      private
+
+      def find_input_child_nodes(child_name)
+        input_node = @operation_node.element_children.find { |node| node.name == 'input' }
+        return unless input_node
+
+        input_node.element_children.select { |node| node.name == child_name }
+      end
+
+      def find_soap_operation_node
+        @operation_node.element_children.each do |node|
+          namespace = node.namespace.href
+
+          soap_1_1  = namespace == Sekken::NS_SOAP_1_1
+          soap_1_2  = namespace == Sekken::NS_SOAP_1_2
+          operation = node.name == 'operation'
+
+          return [namespace, node] if (soap_1_1 || soap_1_2) && operation
+        end
+
+        nil
+      end
+
+    end
+  end
+end

data/lib/sekken/wsdl/document.rb

@@ -0,0 +1,83 @@
+require 'sekken/xs/schema'
+require 'sekken/wsdl/message'
+require 'sekken/wsdl/port_type'
+require 'sekken/wsdl/binding'
+require 'sekken/wsdl/service'
+
+class Sekken
+  class WSDL
+    class Document
+
+      def initialize(document, schemas)
+        @document = document
+        @schemas = schemas
+
+        @messages, @bindings, @port_types, @services = {}, {}, {}, {}
+
+        collect_sections(
+          'message'  => { :collection => @messages,   :container => Message  },
+          'binding'  => { :collection => @bindings,   :container => Binding  },
+          'portType' => { :collection => @port_types, :container => PortType },
+          'service'  => { :collection => @services,   :container => Service  }
+        )
+      end
+
+      attr_reader :messages, :port_types, :bindings, :services
+
+      def service_name
+        @document.root['name']
+      end
+
+      def target_namespace
+        @document.root['targetNamespace']
+      end
+
+      def schemas
+        schema_nodes.map { |node| XS::Schema.new(node, @schemas) }
+      end
+
+      def imports
+        imports = []
+
+        @document.root.xpath('wsdl:import', 'wsdl' => Sekken::NS_WSDL).each do |node|
+          location = node['location']
+          imports << location if location
+        end
+
+        imports
+      end
+
+      private
+
+      def collect_sections(mapping)
+        section_types = mapping.keys
+
+        @document.root.element_children.each do |node|
+          section_type = node.name
+          next unless section_types.include? section_type
+
+          node_name = node['name']
+          type_mapping = mapping.fetch(section_type)
+
+          collection = type_mapping[:collection]
+          container = type_mapping[:container]
+
+          collection[node_name] = container.new(node)
+        end
+      end
+
+      def schema_nodes
+        @schema_nodes ||= schema_nodes! || []
+      end
+
+      def schema_nodes!
+        root = @document.root
+        return [root] if root.name == 'schema'
+
+        types = root.at_xpath('wsdl:types', 'wsdl' => Sekken::NS_WSDL)
+        types.element_children if types
+      end
+
+    end
+  end
+end

data/lib/sekken/wsdl/document_collection.rb

@@ -0,0 +1,61 @@
+require 'uri'
+
+class Sekken
+  class WSDL
+    class DocumentCollection
+      include Enumerable
+
+      def initialize
+        @documents = []
+      end
+
+      def <<(document)
+        @documents << document
+      end
+
+      def each(&block)
+        @documents.each(&block)
+      end
+
+      def service_name
+        @service_name ||= first.service_name
+      end
+
+      def messages
+        @messages ||= collect_sections { |document| document.messages }
+      end
+
+      def port_types
+        @port_types ||= collect_sections { |document| document.port_types }
+      end
+
+      def bindings
+        @bindings ||= collect_sections { |document| document.bindings }
+      end
+
+      def services
+        @services ||= collect_sections { |document| document.services }
+      end
+
+      # Public: Returns a port by service and port name.
+      def service_port(service_name, port_name)
+        service = services.fetch(service_name)
+        service.ports.fetch(port_name)
+      end
+
+      private
+
+      def collect_sections
+        result = {}
+
+        each do |document|
+          sections = yield document
+          result.merge! sections
+        end
+
+        result
+      end
+
+    end
+  end
+end

data/lib/sekken/wsdl/input_output.rb

@@ -0,0 +1,84 @@
+class Sekken
+  class WSDL
+
+    class Input
+
+      def initialize(binding_operation, port_type_operation, wsdl)
+        @binding_operation = binding_operation
+        @port_type_operation = port_type_operation
+        @wsdl = wsdl
+
+        build_parts
+      end
+
+      # Public: Returns the header part Elements.
+      attr_reader :header_parts
+
+      # Public: Returns the body part Elements.
+      attr_reader :body_parts
+
+      private
+
+      def build_parts
+        body_parts = collect_body_parts
+        header_parts = collect_header_parts
+
+        # remove explicit header parts from the body parts
+        header_part_names = header_parts.map { |part| part[:name] }
+        body_parts.reject! { |part| header_part_names.include? part[:name] }
+
+        @header_parts = XML::ElementBuilder.new(@wsdl.schemas).build(header_parts)
+        @body_parts = XML::ElementBuilder.new(@wsdl.schemas).build(body_parts)
+      end
+
+      def collect_body_parts
+        find_message(message_name).parts
+      end
+
+      def message_name
+        @port_type_operation.input[:message]
+      end
+
+      def collect_header_parts
+        parts = []
+
+        headers.each do |header|
+          next unless header[:message] && header[:part]
+          message_parts = find_message(header[:message]).parts
+
+          # only add the single header part from the message
+          parts << message_parts.find { |part| part[:name] == header[:part] }
+        end
+
+        parts
+      end
+
+      def headers
+        @binding_operation.input_headers
+      end
+
+      def find_message(qname)
+        local = qname.split(':').last
+
+        @wsdl.documents.messages[local] or
+          raise "Unable to find message #{qname.inspect}"
+      end
+
+    end
+
+    class Output < Input
+
+      private
+
+      def message_name
+        @port_type_operation.output[:message]
+      end
+
+      def headers
+        @binding_operation.output_headers
+      end
+
+    end
+
+  end
+end

data/lib/sekken/wsdl/message.rb

@@ -0,0 +1,38 @@
+class Sekken
+  class WSDL
+    class Message
+
+      def initialize(message_node)
+        @message_node = message_node
+      end
+
+      def name
+        @message_node['name']
+      end
+
+      def parts
+        @parts ||= parts!
+      end
+
+      private
+
+      def parts!
+        parts = []
+
+        @message_node.element_children.each do |part|
+          next unless part.name == 'part'
+
+          parts << {
+            :name       => part['name'],
+            :type       => part['type'],
+            :element    => part['element'],
+            :namespaces => part.namespaces
+          }
+        end
+
+        parts
+      end
+
+    end
+  end
+end

data/lib/sekken/wsdl/operation.rb

@@ -0,0 +1,47 @@
+require 'sekken/wsdl/input_output'
+require 'sekken/xml/element_builder'
+
+class Sekken
+  class WSDL
+    class Operation
+
+      def initialize(name, endpoint, binding_operation, port_type_operation, wsdl)
+        @name = name
+        @endpoint = endpoint
+        @binding_operation = binding_operation
+        @port_type_operation = port_type_operation
+        @wsdl = wsdl
+      end
+
+      attr_reader :name, :endpoint, :binding_operation, :port_type_operation
+
+      def soap_action
+        @binding_operation.soap_action
+      end
+
+      def soap_version
+        case @binding_operation.soap_namespace
+        when Sekken::NS_SOAP_1_1 then '1.1'
+        when Sekken::NS_SOAP_1_2 then '1.2'
+        end
+      end
+
+      def input
+        @input ||= Input.new(@binding_operation, @port_type_operation, @wsdl)
+      end
+
+      def output
+        @output ||= Output.new(@binding_operation, @port_type_operation, @wsdl)
+      end
+
+      def input_style
+        "#{@binding_operation.style}/#{@binding_operation.input_body[:use]}"
+      end
+
+      def output_style
+        "#{@binding_operation.style}/#{@binding_operation.output[:body][:use]}"
+      end
+
+    end
+  end
+end