sekken 0.1.0

data/lib/sekken/wsdl/port.rb

@@ -0,0 +1,29 @@
+class Sekken
+  class WSDL
+    class Port
+
+      def initialize(port_node, soap_node)
+        @name     = port_node['name']
+        @binding  = port_node['binding']
+
+        @type     = soap_node.namespace.href
+        @location = soap_node['location']
+      end
+
+      attr_reader :name, :binding, :type, :location
+
+      def fetch_binding(documents)
+        binding_local = @binding.split(':').last
+
+        documents.bindings.fetch(binding_local) {
+          raise "Unable to find binding #{binding_local.inspect} for port #{@name.inspect}"
+        }
+      end
+
+      def to_hash
+        { name => { type: type, location: location } }
+      end
+
+    end
+  end
+end

data/lib/sekken/wsdl/port_type.rb

@@ -0,0 +1,38 @@
+require 'sekken/wsdl/port_type_operation'
+
+class Sekken
+  class WSDL
+    class PortType
+
+      def initialize(port_type_node)
+        @port_type_node = port_type_node
+      end
+
+      def name
+        @port_type_node['name']
+      end
+
+      def operations
+        @operations ||= operations!
+      end
+
+      private
+
+      def operations!
+        operations = {}
+
+        @port_type_node.element_children.each do |operation_node|
+          next unless operation_node.name == 'operation'
+
+          operation_name = operation_node['name']
+          operation = PortTypeOperation.new(operation_node)
+
+          operations[operation_name] = operation
+        end
+
+        operations
+      end
+
+    end
+  end
+end

data/lib/sekken/wsdl/port_type_operation.rb

@@ -0,0 +1,42 @@
+class Sekken
+  class WSDL
+    class PortTypeOperation
+
+      def initialize(operation_node)
+        @operation_node = operation_node
+
+        @name = operation_node['name']
+        @input_node = find_node('input')
+        @output_node = find_node('output')
+      end
+
+      attr_reader :name
+
+      def input
+        return @input if defined? @input
+        @input = parse_node(@input_node)
+      end
+
+      def output
+        return @output if defined? @output
+        @output = parse_node(@output_node)
+      end
+
+      private
+
+      def find_node(node_name)
+        @operation_node.element_children.find { |node| node.name == node_name }
+      end
+
+      def parse_node(node)
+        input = {}
+
+        input[:name]    = node['name']
+        input[:message] = node['message']
+
+        input
+      end
+
+    end
+  end
+end

data/lib/sekken/wsdl/service.rb

@@ -0,0 +1,55 @@
+require 'sekken/wsdl/port'
+
+class Sekken
+  class WSDL
+    class Service
+
+      def initialize(service_node)
+        @service_node = service_node
+      end
+
+      def name
+        @service_node['name']
+      end
+
+      def ports
+        @ports ||= ports!
+      end
+
+      def to_hash
+        port_hash = ports.values.inject({}) { |memo, port| memo.merge port.to_hash }
+        { name => { ports: port_hash } }
+      end
+
+      private
+
+      def ports!
+        ports = {}
+
+        @service_node.element_children.each do |port_node|
+          next unless port_node.name == 'port'
+
+          soap_node = port_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
+            address  = node.name == 'address'
+
+            (soap_1_1 || soap_1_2) && address
+          }
+
+          next unless soap_node
+
+          port_name = port_node['name']
+          port = Port.new(port_node, soap_node)
+
+          ports[port_name] = port
+        end
+
+        ports
+      end
+
+    end
+  end
+end

data/lib/sekken/xml/attribute.rb

@@ -0,0 +1,13 @@
+class Sekken
+  class XML
+    class Attribute
+
+      attr_accessor :name, :base_type, :use
+
+      def optional?
+        use == 'optional'
+      end
+
+    end
+  end
+end

data/lib/sekken/xml/element.rb

@@ -0,0 +1,82 @@
+class Sekken
+  class XML
+    class Element
+
+      def initialize
+        @children   = []
+        @attributes = {}
+        @recursive  = false
+        @singular   = true
+      end
+
+      attr_accessor :parent, :name, :namespace, :form
+
+      # Public: Whether this element is a simple type.
+      def simple_type?
+        !!base_type
+      end
+
+      # Public: Whether this element is a complex type.
+      def complex_type?
+        !simple_type?
+      end
+
+      # Public: The base name for a simple type element.
+      attr_accessor :base_type
+
+      # Public: Accessor for whether this is a single element.
+      attr_accessor :singular
+      alias_method :singular?, :singular
+
+      # Public: Whether or not this element's type is defined recursively,
+      # meaning one of this element's parents is of the same type as this element.
+      def recursive?
+        !!recursive_type
+      end
+
+      # Public: The name of the recursive type definition if any.
+      attr_accessor :recursive_type
+
+      # Private: The complex type id for this element to track recursive type definitions.
+      attr_accessor :complex_type_id
+
+      # Public: The child elements.
+      attr_accessor :children
+
+      # Public: The attributes.
+      attr_accessor :attributes
+
+      # Public: Returns this element and its children as an Array of Hashes for inspection.
+      def to_a(memo = [], stack = [])
+        new_stack = stack + [name]
+        data = { namespace: namespace, form: form, singular: singular? }
+
+        unless attributes.empty?
+          data[:attributes] = attributes.each_with_object({}) do |attribute, memo|
+            memo[attribute.name] = { optional: attribute.optional? }
+          end
+        end
+
+        if recursive?
+          data[:recursive_type] = recursive_type
+          memo << [new_stack, data]
+
+        elsif simple_type?
+          data[:type] = base_type
+          memo << [new_stack, data]
+
+        elsif complex_type?
+          memo << [new_stack, data]
+
+          children.each do |child|
+            child.to_a(memo, new_stack)
+          end
+
+        end
+
+        memo
+      end
+
+    end
+  end
+end

data/lib/sekken/xml/element_builder.rb

@@ -0,0 +1,220 @@
+require 'sekken/xml/element'
+require 'sekken/xml/attribute'
+
+class Sekken
+  class XML
+    class ElementBuilder
+
+      def initialize(schemas)
+        @logger = Logging.logger[self]
+        @schemas = schemas
+      end
+
+      def build(parts)
+        parts.map { |part|
+          case
+          when part[:type]    then build_type_element(part)
+          when part[:element] then build_element(part)
+          end
+        }.compact
+      end
+
+      private
+
+      # Private: Expects a part with a @type attribute, resolves the type
+      # and returns an Element with that type.
+      def build_type_element(part)
+        type = find_type part[:type], part[:namespaces]
+
+        element = Element.new
+        element.name = part[:name]
+        element.form = 'unqualified'
+
+        handle_type(element, type)
+        element
+      end
+
+      # Private: Expects a part with an @element attribute, resolves the element
+      # and its type and returns an Element with that type.
+      def build_element(part)
+        local, namespace = expand_qname(part[:element], part[:namespaces])
+        schema = @schemas.find_by_namespace(namespace)
+        raise "Unable to find schema for #{namespace.inspect}" unless schema
+
+        xs_element = schema.elements.fetch(local)
+        type = find_type_for_element(xs_element)
+
+        element = Element.new
+        element.name = xs_element.name
+        element.form = 'qualified'
+        element.namespace = namespace
+
+        handle_type(element, type)
+        element
+      end
+
+      def handle_type(element, type)
+        case type
+
+        when XS::ComplexType
+          element.complex_type_id = type.id
+          element.children = child_elements(element, type)
+          element.attributes = element_attributes(type)
+
+        when XS::SimpleType
+          element.base_type = type.base
+
+        when String
+          element.base_type = type
+
+        end
+      end
+
+      def handle_simple_type(attribute, type)
+        case type
+        when XS::SimpleType then attribute.base_type = type.base
+        when String         then attribute.base_type = type
+        end
+      end
+
+      def element_attributes(type)
+        type.attributes.map { |attribute|
+          attr = Attribute.new
+
+          if attribute.ref
+            local, namespace = expand_qname(attribute.ref, attribute.namespaces)
+            schema = find_schema(namespace)
+
+            if schema
+              attribute = schema.attributes[local]
+            else
+              @logger.debug("Unable to find schema for attribute@ref #{attribute.ref.inspect}")
+              next
+            end
+          end
+
+          type = find_type_for_attribute(attribute)
+          handle_simple_type(attr, type)
+
+          attr.name = attribute.name
+          attr.use = attribute.use
+
+          attr
+        }.compact
+      end
+
+      def child_elements(parent, type)
+        type.elements.map { |child_element|
+          el = Element.new
+          el.parent = parent
+
+          max_occurs = child_element['maxOccurs'].to_s
+          el.singular = max_occurs.empty? || max_occurs == '1'
+
+          if child_element.ref
+            child_element = find_element(child_element.ref, child_element.namespaces)
+            el.form = 'qualified'
+          else
+            el.form = child_element.form
+          end
+
+          el.name = child_element.name
+          el.namespace = child_element.namespace
+
+          # prevent recursion
+          if recursive_child_definition? parent, child_element
+            el.recursive_type = child_element.type
+          else
+            type = find_type_for_element(child_element)
+            handle_type(el, type)
+          end
+
+          el
+        }
+      end
+
+      # Private: Accepts an Element and figures out if its type is already defined in this
+      # elements (self) ancestors. Used to prevent recursive child element definitions.
+      def recursive_child_definition?(parent, element)
+        return false unless element.type
+
+        local, namespace = expand_qname(element.type, element.namespaces)
+        id = [namespace, local].join(':')
+
+        current_parent = parent
+
+        while current_parent
+          return true if current_parent.complex_type_id == id
+          current_parent = current_parent.parent
+        end
+
+        false
+      end
+
+      def find_type_for_element(element)
+        if element.type
+          find_type(element.type, element.namespaces)
+        else
+          element.inline_type
+        end
+      end
+
+      alias_method :find_type_for_attribute, :find_type_for_element
+
+      def find_type(qname, namespaces)
+        local, namespace = expand_qname(qname, namespaces)
+
+        # assume built-in or unknown type for unqualified type qnames for now.
+        # we could fallback to the element's default namespace. needs tests.
+        return qname unless namespace
+
+        schema = find_schema(namespace)
+
+        # custom type
+        if schema
+
+          # complex type
+          if complex_type = schema.complex_types[local]
+            complex_type
+
+          # simple type
+          elsif simple_type = schema.simple_types[local]
+            simple_type
+
+          end
+
+        # built-in or unknown type
+        else
+          qname
+
+        end
+      end
+
+      def find_element(qname, namespaces)
+        local, namespace = expand_qname(qname, namespaces)
+        @schemas.element(namespace, local)
+      end
+
+      def find_attribute(qname, namespaces)
+        local, namespace = expand_qname(qname, namespaces)
+        @schemas.attribute(namespace, local)
+      end
+
+      def find_schema(namespace)
+        @schemas.find_by_namespace(namespace)
+      end
+
+      def split_qname(qname)
+        qname.split(':').reverse
+      end
+
+      def expand_qname(qname, namespaces)
+        local, nsid = split_qname(qname)
+        namespace = namespaces["xmlns:#{nsid}"]
+
+        [local, namespace]
+      end
+
+    end
+  end
+end