wsdl-mapper 0.0.7

data/lib/wsdl_mapper/svc_desc/wsdl11/description.rb

@@ -0,0 +1,86 @@
+require 'wsdl_mapper/dom/directory'
+
+module WsdlMapper
+  module SvcDesc
+    module Wsdl11
+      class Description
+        include WsdlMapper::Dom
+
+        attr_accessor :target_namespace, :name, :documentation
+
+        def initialize
+          @name = nil
+          @messages = Directory.new
+          @port_types = Directory.new
+          @bindings = Directory.new
+          @services = Directory.new
+          @schemas = []
+        end
+
+        def add_schema(schema)
+          @schemas << schema
+        end
+
+        def add_message(message)
+          @messages[message.name] = message
+        end
+
+        def add_port_type(port_type)
+          @port_types[port_type.name] = port_type
+        end
+
+        def add_service(service)
+          @services[service.name] = service
+        end
+
+        def add_binding(binding)
+          @bindings[binding.name] = binding
+        end
+
+        def each_schema(&block)
+          @schemas.each(&block)
+        end
+
+        def each_message(&block)
+          @messages.each_value(&block)
+        end
+
+        def each_port_type(&block)
+          @port_types.each_value(&block)
+        end
+
+        def each_service(&block)
+          @services.each_value(&block)
+        end
+
+        def each_binding(&block)
+          @bindings.each_value(&block)
+        end
+
+        def get_message(name)
+          @messages[name]
+        end
+
+        def get_port_type(name)
+          @port_types[name]
+        end
+
+        def get_binding(name)
+          @bindings[name]
+        end
+
+        def get_service(name)
+          @services[name]
+        end
+
+        def get_type(name)
+          @schemas.lazy.map { |s| s.get_type(name) }.reject(&:nil?).first
+        end
+
+        def get_element(name)
+          @schemas.lazy.map { |s| s.get_element(name) }.reject(&:nil?).first
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/svc_desc/wsdl11/message.rb

@@ -0,0 +1,32 @@
+require 'wsdl_mapper/svc_desc/wsdl11/base'
+
+module WsdlMapper
+  module SvcDesc
+    module Wsdl11
+      class Message < Base
+        class Part < Base
+          attr_accessor :element_name, :type_name, :element, :type
+        end
+
+        attr_reader :parts
+
+        def initialize(name)
+          super name
+          @parts = WsdlMapper::Dom::Directory.new
+        end
+
+        def add_part(part)
+          @parts[part.name] = part
+        end
+
+        def each_part(&block)
+          @parts.each_value(&block)
+        end
+
+        def get_part(name)
+          @parts[name]
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/svc_desc/wsdl11/port_type.rb

@@ -0,0 +1,63 @@
+require 'wsdl_mapper/svc_desc/wsdl11/base'
+
+module WsdlMapper
+  module SvcDesc
+    module Wsdl11
+      class PortType < Base
+        class Operation < Base
+          attr_accessor :input, :output, :faults, :type
+
+          def initialize(name)
+            super name
+            @faults = WsdlMapper::Dom::Directory.new
+          end
+
+          def add_fault(fault)
+            @faults[fault.name] = fault
+          end
+
+          def each_fault(&block)
+            @faults.each_value(&block)
+          end
+
+          def get_fault(name)
+            @faults[name]
+          end
+        end
+
+        class InputOutput < Base
+          attr_accessor :message_name, :message
+        end
+
+        def initialize(name)
+          super name
+          @operations = WsdlMapper::Dom::Directory.new do |_|
+            []
+          end
+        end
+
+        def each_operation(&block)
+          @operations.each_value.to_a.flatten.each(&block)
+        end
+
+        def add_operation(operation)
+          @operations[operation.name] << operation
+        end
+
+        def get_operations(name)
+          @operations[name]
+        end
+
+        def get_operation(name)
+          @operations[name].first
+        end
+
+        def find_operation(name, input_name, output_name)
+          get_operations(name).find do |op|
+            op.input.name == input_name && op.output.name == output_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/svc_desc/wsdl11/service.rb

@@ -0,0 +1,27 @@
+require 'wsdl_mapper/svc_desc/wsdl11/base'
+
+module WsdlMapper
+  module SvcDesc
+    module Wsdl11
+      class Service < Base
+        class Port < Base
+          attr_accessor :binding_name, :address_location
+          attr_accessor :binding
+        end
+
+        def initialize(name)
+          super name
+          @ports = WsdlMapper::Dom::Directory.new
+        end
+
+        def add_port(port)
+          @ports[port.name] = port
+        end
+
+        def each_port(&block)
+          @ports.each_value(&block)
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/svc_desc_parsing/binding_parser.rb

@@ -0,0 +1,198 @@
+require 'wsdl_mapper/svc_desc_parsing/parser_base'
+require 'wsdl_mapper/svc_desc/wsdl11/binding'
+
+module WsdlMapper
+  module SvcDescParsing
+    class BindingParser < ParserBase
+      def parse(node)
+        name = parse_name_in_attribute 'name', node
+
+        binding = Binding.new name
+        binding.type_name = parse_name_in_attribute 'type', node
+
+        success = true
+        each_element node do |child|
+          success = parse_binding_child(child, binding) && success
+        end
+
+        @base.description.add_binding(binding) if success
+      end
+
+      def parse_binding_child(node, binding)
+        case get_name node
+        when OPERATION
+          parse_binding_operation node, binding
+        when Soap::BINDING
+          parse_soap_binding node, binding
+        when Soap12::BINDING
+          log_msg node, :unsupported
+          return false
+        when Http::BINDING
+          log_msg node, :unsupported
+          return false
+        when DOCUMENTATION
+          @base.parse_documentation node, binding
+        else
+          log_msg node, :unknown
+          return false
+        end
+      end
+
+      def parse_soap_binding(node, binding)
+        binding.style = fetch_attribute_value 'style', node
+        binding.transport = fetch_attribute_value 'transport', node
+      end
+
+      def parse_binding_operation(node, binding)
+        name = parse_name_in_attribute 'name', node
+
+        operation = Binding::Operation.new name
+
+        each_element node do |child|
+          parse_operation_child child, operation
+        end
+
+        binding.add_operation operation
+      end
+
+      def parse_operation_child(node, operation)
+        case get_name node
+        when INPUT
+          parse_operation_input node, operation
+        when OUTPUT
+          parse_operation_output node, operation
+        when FAULT
+          parse_operation_fault node, operation
+        when Soap::OPERATION
+          parse_operation_soap_action node, operation
+        when Soap12::OPERATION
+          log_msg node, :unsupported
+        when Http::OPERATION
+          log_msg node, :unsupported
+        when DOCUMENTATION
+          @base.parse_documentation node, operation
+        else
+          log_msg node, :unknown
+        end
+      end
+
+      def parse_operation_soap_action(node, operation)
+        operation.soap_action = fetch_attribute_value 'soapAction', node
+      end
+
+      def parse_operation_input(node, operation)
+        name = parse_name_in_attribute 'name', node
+        input = Binding::InputOutput.new name
+
+        each_element node do |child|
+          parse_input_output_child child, input
+        end
+
+        operation.input = input
+      end
+
+      def parse_input_output_child(node, in_out)
+        case get_name node
+        when Soap::HEADER
+          in_out.add_header parse_header node
+        when Soap::BODY
+          in_out.body = parse_body node
+        when Soap12::HEADER
+          log_msg node, :unsupported
+        when Soap12::BODY
+          log_msg node, :unsupported
+        when DOCUMENTATION
+          @base.parse_documentation node, in_out
+        else
+          log_msg node, :unknown
+        end
+      end
+
+      def parse_body(node)
+        body = Binding::Body.new
+        body.use = fetch_attribute_value 'use', node
+        body.encoding_styles = fetch_attribute_value('encodingStyle', node, '').split ' '
+        body.namespace = fetch_attribute_value 'namespace', node
+        body.part_names = fetch_attribute_value('parts', node, '').split(' ').map { |s| parse_name(s, node) }
+        body
+      end
+
+      def parse_header(node)
+        header = Binding::Header.new
+        header.use = fetch_attribute_value 'use', node
+        header.message_name = parse_name_in_attribute 'message', node
+        header.part_name = parse_name_in_attribute 'part', node
+        header.encoding_styles = fetch_attribute_value('encodingStyle', node, '').split ' '
+        header.namespace = fetch_attribute_value 'namespace', node
+
+        each_element node do |child|
+          parse_header_child child, header
+        end
+
+        header
+      end
+
+      def parse_header_child(node, header)
+        case get_name node
+        when Soap::HEADER_FAULT
+          parse_header_fault node, header
+        when DOCUMENTATION
+          @base.parse_documentation node, header
+        else
+          log_msg node, :unknown
+        end
+      end
+
+      def parse_header_fault(node, header)
+        header_fault = Binding::HeaderFault.new
+        header_fault.use = fetch_attribute_value 'use', node
+        header_fault.message_name = parse_name_in_attribute 'message', node
+        header_fault.part_name = parse_name_in_attribute 'part', node
+        header_fault.encoding_styles = fetch_attribute_value('encodingStyle', node, '').split ' '
+        header_fault.namespace = fetch_attribute_value 'namespace', node
+
+        header.add_header_fault header_fault
+      end
+
+      def parse_operation_output(node, operation)
+        name = parse_name_in_attribute 'name', node
+        output = Binding::InputOutput.new name
+
+        each_element node do |child|
+          parse_input_output_child child, output
+        end
+
+        operation.output = output
+      end
+
+      def parse_operation_fault(node, operation)
+        name = parse_name_in_attribute 'name', node
+        fault = Binding::Fault.new name
+
+        each_element node do |child|
+          parse_fault_child child, fault
+        end
+
+        operation.add_fault fault
+      end
+
+      def parse_fault_child(node, fault)
+        case get_name node
+        when Soap::FAULT
+          parse_soap_fault node, fault
+        when DOCUMENTATION
+          @base.parse_documentation node, fault
+        else
+          log_msg node, :unknown
+        end
+      end
+
+      def parse_soap_fault(node, fault)
+        name = parse_name_in_attribute 'name', node
+        soap_fault = Binding::SoapFault.new name
+        soap_fault.use = fetch_attribute_value 'use', node
+        fault.soap_fault = soap_fault
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/svc_desc_parsing/http.rb

@@ -0,0 +1,14 @@
+require 'wsdl_mapper/dom/name'
+
+module WsdlMapper
+  module SvcDescParsing
+    module Http
+      include WsdlMapper::Dom
+
+      NS = 'http://schemas.xmlsoap.org/wsdl/http/'.freeze
+      BINDING = Name.get NS, 'binding'
+      OPERATION = Name.get NS, 'operation'
+      ADDRESS = Name.get NS, 'address'
+    end
+  end
+end

data/lib/wsdl_mapper/svc_desc_parsing/linker.rb

@@ -0,0 +1,126 @@
+require 'wsdl_mapper/dom_parsing/linker'
+require 'wsdl_mapper/dom/schema'
+
+module WsdlMapper
+  module SvcDescParsing
+    # The Linker creates pointers between the different components of a WSDL schema,
+    # e.g. links service.port -> binding, portType
+    class Linker
+
+      # @param [WsdlMapper::SvcDesc::Wsdl11::Description] description
+      def initialize(description)
+        @description = description
+      end
+
+      def link
+        schema = WsdlMapper::Dom::Schema.new
+        @description.each_schema do |s|
+          schema.add_import s.target_namespace, s
+        end
+        schema_linker = WsdlMapper::DomParsing::Linker.new schema
+        schema_linker.link
+
+        link_messages
+        link_port_types
+        link_bindings
+        link_services
+
+        [@description, schema]
+      end
+
+      private
+      def link_bindings
+        @description.each_binding do |b|
+          b.type = @description.get_port_type b.type_name
+
+          b.each_operation do |op|
+            link_binding_operation b, op
+          end
+        end
+      end
+
+      def link_binding_operation(b, op)
+        op.target = b.type.find_operation op.name, op.input.name, op.output.name
+
+        link_binding_operation_input op
+        link_binding_operation_output op
+        link_binding_operation_faults op
+      end
+
+      def link_binding_operation_faults(op)
+        op.each_fault do |fault|
+          fault.target = op.target.get_fault fault.name
+        end
+      end
+
+      def link_binding_operation_output(op)
+        op.output.target = op.target.output
+        op.output.message = op.target.output.message
+        op.output.each_header do |header|
+          if header.message_name
+            header.message = @description.get_message header.message_name
+            header.part = header.message.get_part header.part_name
+          end
+          header.each_header_fault do |header_fault|
+            header_fault.message = @description.get_message header_fault.message_name
+            header_fault.part = header_fault.message.get_part header_fault.part_name
+          end
+        end
+        op.output.body.parts = op.output.body.part_names.map do |pn|
+          op.output.message.get_part pn
+        end
+      end
+
+      def link_binding_operation_input(op)
+        op.input.target = op.target.input
+        op.input.message = op.target.input.message
+        op.input.each_header do |header|
+          if header.message_name
+            header.message = @description.get_message header.message_name
+            header.part = header.message.get_part header.part_name
+          end
+          header.each_header_fault do |header_fault|
+            header_fault.message = @description.get_message header_fault.message_name
+            header_fault.part = header_fault.message.get_part header_fault.part_name
+          end
+        end
+        op.input.body.parts = op.input.body.part_names.map do |pn|
+          op.input.message.get_part pn
+        end
+      end
+
+      def link_services
+        @description.each_service do |svc|
+          svc.each_port do |p|
+            p.binding = @description.get_binding p.binding_name
+          end
+        end
+      end
+
+      def link_port_types
+        @description.each_port_type do |pt|
+          pt.each_operation do |op|
+            op.input.message = @description.get_message op.input.message_name
+            op.output.message = @description.get_message op.output.message_name
+
+            op.each_fault do |fault|
+              fault.message = @description.get_message fault.message_name
+            end
+          end
+        end
+      end
+
+      def link_messages
+        @description.each_message do |msg|
+          msg.each_part do |part|
+            if part.element_name
+              part.element = @description.get_element part.element_name
+            elsif part.type_name
+              part.type = @description.get_type part.type_name
+            end
+          end
+        end
+      end
+    end
+  end
+end