wsdl-mapper 0.0.7

data/lib/wsdl_mapper/runtime/middlewares/simple_request_logger.rb

@@ -0,0 +1,18 @@
+require 'wsdl_mapper/runtime/middlewares/abstract_logger'
+
+module WsdlMapper
+  module Runtime
+    module Middlewares
+      class SimpleRequestLogger < AbstractLogger
+        def call(operation, request)
+          log "Request for #{operation.name}"
+          log "POST #{request.url}"
+          log "SOAP-Action: #{request.message.action}"
+          log request.xml
+
+          [operation, request]
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/middlewares/simple_response_factory.rb

@@ -0,0 +1,26 @@
+require 'wsdl_mapper/runtime/response'
+
+module WsdlMapper
+  module Runtime
+    module Middlewares
+      class SimpleResponseFactory
+        # Deserializes the `http_response` body. It relies on {WsdlMapper::Runtime::Operation#output_d10r} to return the proper output
+        # deserializer for this operation.
+        # @param [WsdlMapper::Runtime::Operation] operation
+        # @param [Faraday::Response] http_response
+        # @return [Array<WsdlMapper::Runtime::Operation, WsdlMapper::Runtime::Response>]
+        def call(operation, http_response)
+          response = WsdlMapper::Runtime::Response.new http_response.status, http_response.body, http_response.headers
+          deserialize_envelope operation, response
+
+          [operation, response]
+        end
+
+        protected
+        def deserialize_envelope(operation, response)
+          response.envelope = operation.output_d10r.from_xml response.body
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/middlewares/simple_response_logger.rb

@@ -0,0 +1,16 @@
+require 'wsdl_mapper/runtime/middlewares/abstract_logger'
+
+module WsdlMapper
+  module Runtime
+    module Middlewares
+      class SimpleResponseLogger < AbstractLogger
+        def call(operation, response)
+          log "Response for #{operation.name}"
+          log response.body
+
+          [operation, response]
+        end
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/operation.rb

@@ -0,0 +1,90 @@
+require 'wsdl_mapper/svc_desc/envelope'
+require 'wsdl_mapper/runtime/message'
+
+module WsdlMapper
+  module Runtime
+    # @abstract
+    # noinspection RubyUnusedLocalVariable
+    class Operation
+      attr_reader :name, :operation_name
+
+      # @param [WsdlMapper::Runtime::Api] api
+      # @param [WsdlMapper::Runtime::Service] service
+      # @param [WsdlMapper::Runtime::Port] port
+      def initialize(api, service, port)
+        @api = api
+        @service = service
+        @port = port
+        @soap_action = nil
+        @name = nil
+        @operation_name = nil
+        @requires = []
+        @loaded = false
+      end
+
+      # @abstract
+      # @param [Hash<Symbol, Object>] header Keyword arguments for the corresponding input message header
+      # @param [Hash<Symbol, Object>] body Keyword arguments for the corresponding input message body
+      def new_input(header: {}, body: {})
+        load_requires
+        nil
+      end
+
+      # @abstract
+      # @param [Hash<Symbol, Object>] header Keyword arguments for the corresponding output message header
+      # @param [Hash<Symbol, Object>] body Keyword arguments for the corresponding output message body
+      def new_output(header: {}, body: {})
+        load_requires
+        nil
+      end
+
+      # @return [WsdlMapper::SvcDesc::Envelope]
+      # @param [WsdlMapper::Runtime::Header] header
+      # @param [WsdlMapper::Runtime::Body] body
+      def new_envelope(header, body)
+        WsdlMapper::SvcDesc::Envelope.new(header: header, body: body)
+      end
+
+      # @param [WsdlMapper::Runtime::Header] header
+      # @param [WsdlMapper::Runtime::Body] body
+      # @return [WsdlMapper::Runtime::Message]
+      def new_message(header, body)
+        Message.new(@port._soap_address, @soap_action, new_envelope(header, body))
+      end
+
+      # @abstract
+      # @return [WsdlMapper::Runtime::InputS8r] The serializer for this operations input message
+      def input_s8r
+        load_requires
+      end
+
+      # @abstract
+      # @return [WsdlMapper::Runtime::OutputS8r] The serializer for this operations output message
+      def output_s8r
+        load_requires
+      end
+
+      # @abstract
+      # @return [WsdlMapper::Runtime::InputD10r] The deserializer for this operations input message
+      def input_d10r
+        load_requires
+      end
+
+      # @abstract
+      # @return [WsdlMapper::Runtime::OutputD10r] The deserializer for this operations output message
+      def output_d10r
+        load_requires
+      end
+
+      # Dynamically loads the required classes (API types and serializers)
+      def load_requires
+        return if @loaded
+
+        @requires.each do |req|
+          require req
+        end
+        @loaded = true
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/output_s8r.rb

@@ -0,0 +1,9 @@
+require 'wsdl_mapper/runtime/s8r_base'
+
+module WsdlMapper
+  module Runtime
+    class OutputS8r < S8rBase
+    end
+  end
+end
+

data/lib/wsdl_mapper/runtime/port.rb

@@ -0,0 +1,30 @@
+require 'wsdl_mapper/runtime/simpler_inspect'
+
+module WsdlMapper
+  module Runtime
+    class Port
+      include SimplerInspect
+
+      attr_reader :_soap_address, :_operations
+
+      # @!attribute _operations
+      #   @return [Array<WsdlMapper::Runtime::Operation>] All operations contained in this port
+      # @!attribute _soap_address
+      #   @return [String] URL of the SOAP service
+
+      # @param [WsdlMapper::Runtime::Api] api The API this port belongs to
+      # @param [WsdlMapper::Runtime::Service] service The service this port belongs to
+      def initialize(api, service)
+        @_api = api
+        @_service = service
+        @_soap_address = nil
+        @_operations = []
+      end
+
+      # Force preloading of requires for all contained operations
+      def _load_requires
+        @_operations.each(&:load_requires)
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/proxy.rb

@@ -0,0 +1,12 @@
+module WsdlMapper
+  module Runtime
+    class Proxy
+      # @param [WsdlMapper::Runtime::Api] api
+      # @param [WsdlMapper::Runtime::Port] port
+      def initialize(api, port)
+        @_api = api
+        @_port = port
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/request.rb

@@ -0,0 +1,35 @@
+module WsdlMapper
+  module Runtime
+    class Request
+      attr_reader :message, :http_headers
+      attr_accessor :url, :xml
+
+      # @!attribute message
+      #   @return [WsdlMapper::Runtime::Message] The message to send
+      # @!attribute http_headers
+      #   @return [Hash] A hash of HTTP headers to set
+      # @!attribute url
+      #   @return [String] URL of the SOAP service
+      # @!attribute xml
+      #   @return [String] The serialized `message`
+
+      # @param [WsdlMapper::Runtime::Message] message
+      def initialize(message)
+        @message = message
+        @http_headers = {}
+      end
+
+      # Adds an HTTP header to the request
+      # @param [String] key
+      # @param [String] value
+      def add_http_header(key, value)
+        @http_headers[key] = value
+      end
+
+      # @return [true, false]
+      def https?
+        @url.scheme == 'https'
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/response.rb

@@ -0,0 +1,27 @@
+module WsdlMapper
+  module Runtime
+    class Response
+      attr_reader :status, :body, :http_headers
+      attr_accessor :envelope
+
+      # @!attribute status
+      #   @return [Fixnum]
+      # @!attribute body
+      #   @return [String]
+      # @!attribute http_headers
+      #   @return [Hash]
+      # @!attribute envelope
+      #   @return [WsdlMapper::SvcDesc::Envelope] The deserialized body
+
+      # @param [Fixnum] status HTTP response code
+      # @param [String] body HTTP response body
+      # @param [Hash] http_headers HTTP response headers
+      def initialize(status, body, http_headers)
+        @status = status
+        @body = body
+        @http_headers = http_headers
+      end
+    end
+  end
+end
+

data/lib/wsdl_mapper/runtime/s8r_base.rb

@@ -0,0 +1,57 @@
+require 'wsdl_mapper/serializers/serializer_core'
+require 'nokogiri/xml/node/save_options'
+
+module WsdlMapper
+  module Runtime
+    class S8rBase
+      # @param [WsdlMapper::Serializers::TypeDirectory] type_directory
+      # @param [String] default_namespace Specify a `default_namespace` to skip namespace prefixes
+      def initialize(type_directory, default_namespace = nil)
+        @type_directory = type_directory
+        @default_namespace = default_namespace
+      end
+
+      # Serializes the `envelope` and returns an XML string
+      # @param [WsdlMapper::SvcDesc::Envelope] envelope
+      # @return [String] `envelope` serialized as XML
+      def to_xml(envelope)
+        to_doc(envelope).to_xml save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+      end
+
+      # Serializes the `envelope` and returns a {Nokogiri::XML::Document}
+      # @param [WsdlMapper::SvcDesc::Envelope] envelope
+      # @return [Nokogiri::XML::Document] XML document containing the encoded `envelope`
+      def to_doc(envelope)
+        core = WsdlMapper::Serializers::SerializerCore.new resolver: @type_directory, default_namespace: @default_namespace
+        build core, envelope
+        core.to_doc
+      end
+
+      # Serializes the `envelope` using `x`
+      # @param [WsdlMapper::Serializers::SerializerCore] x Serializer instance to use
+      # @param [WsdlMapper::SvcDesc::Envelope] envelope
+      def build(x, envelope)
+        x.complex(nil, ['http://schemas.xmlsoap.org/soap/envelope/', 'Envelope'], []) do |x|
+          build_header(x, envelope.header)
+          build_body(x, envelope.body)
+        end
+      end
+
+      # @abstract
+      # @param [WsdlMapper::Serializers::SerializerCore] x Serializer instance to use
+      # @param [WsdlMapper::Runtime::Header] header
+      # noinspection RubyUnusedLocalVariable
+      def build_header(x, header)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      # @param [WsdlMapper::Serializers::SerializerCore] x Serializer instance to use
+      # @param [WsdlMapper::Runtime::Body] body
+      # noinspection RubyUnusedLocalVariable
+      def build_body(x, body)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/service.rb

@@ -0,0 +1,25 @@
+require 'wsdl_mapper/runtime/simpler_inspect'
+
+module WsdlMapper
+  module Runtime
+    class Service
+      include SimplerInspect
+
+      attr_reader :_ports
+
+      # @!attribute _ports
+      #   @return [Array<WsdlMapper::Runtime::Port>] All ports contained in this service
+
+      # @param [WsdlMapper::Runtime::Api] api
+      def initialize(api)
+        @_api = api
+        @_ports = []
+      end
+
+      # Force preloading of requires for all contained ports
+      def _load_requires
+        @_ports.each(&:_load_requires)
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/simple_http_backend.rb

@@ -0,0 +1,34 @@
+require 'faraday'
+
+require 'wsdl_mapper/runtime/backend_base'
+
+require 'wsdl_mapper/runtime/middlewares/simple_message_factory'
+require 'wsdl_mapper/runtime/middlewares/simple_request_factory'
+require 'wsdl_mapper/runtime/middlewares/simple_dispatcher'
+require 'wsdl_mapper/runtime/middlewares/simple_response_factory'
+
+module WsdlMapper
+  module Runtime
+    # ## Middleware Stack
+    # ### Default Configuration
+    # The default stack is composed of the following middlewares:
+    # ![Diagram](/docs/file/doc/diag/simple_http_backend.png)
+    # 1. `message.factory`: {WsdlMapper::Runtime::Middlewares::SimpleMessageFactory}
+    # 2. `request.factory`: {WsdlMapper::Runtime::Middlewares::SimpleRequestFactory}
+    # 3. `dispatcher`: {WsdlMapper::Runtime::Middlewares::SimpleDispatcher}
+    # 4. `response.factory`: {WsdlMapper::Runtime::Middlewares::SimpleResponseFactory}
+    #
+    # ## Customization
+    class SimpleHttpBackend < BackendBase
+      include WsdlMapper::Runtime::Middlewares
+
+      def initialize(connection: Faraday.new)
+        super()
+        stack.add 'message.factory', SimpleMessageFactory.new
+        stack.add 'request.factory', SimpleRequestFactory.new
+        stack.add 'dispatcher', SimpleDispatcher.new(connection)
+        stack.add 'response.factory', SimpleResponseFactory.new
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/simpler_inspect.rb

@@ -0,0 +1,19 @@
+module WsdlMapper
+  module Runtime
+    # This module contains a non-recursive implementation of {#inspect} to prevent
+    # pollution of an `irb` console with 20000 lines of inspect
+    module SimplerInspect
+      def inspect
+        vars = instance_variables.map do |iv|
+          next if iv.to_s[0, 2] == '@_'
+
+          val = instance_variable_get iv
+          "#{iv}: #{val}"
+        end
+        vars = vars.compact * ', '
+
+        "#<#{self.class.name} #{vars}>"
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/s8r_generation/facade.rb

@@ -0,0 +1,12 @@
+require 'wsdl_mapper/generation/facade'
+require 'wsdl_mapper/s8r_generation/s8r_generator'
+
+module WsdlMapper
+  module S8rGeneration
+    class Facade < WsdlMapper::Generation::Facade
+      def generator_class
+        WsdlMapper::S8rGeneration::S8rGenerator
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/s8r_generation/s8r_generator.rb

@@ -0,0 +1,276 @@
+require 'wsdl_mapper/naming/default_namer'
+require 'wsdl_mapper/generation/result'
+require 'wsdl_mapper/generation/default_formatter'
+require 'wsdl_mapper/generation/type_to_generate'
+require 'wsdl_mapper/generation/default_module_generator'
+require 'wsdl_mapper/dom/complex_type'
+require 'wsdl_mapper/dom/simple_type'
+require 'wsdl_mapper/generation/base'
+
+module WsdlMapper
+  module S8rGeneration
+    class S8rGenerator < ::WsdlMapper::Generation::Base
+      include WsdlMapper::Generation
+
+      attr_reader :context
+
+      def initialize(context,
+        skip_modules: false,
+        namer: WsdlMapper::Naming::DefaultNamer.new,
+        formatter_factory: DefaultFormatter,
+        module_generator_factory: DefaultModuleGenerator)
+
+        super(context)
+
+        @namer = namer
+        @formatter_factory = formatter_factory
+        @module_generator = module_generator_factory.new self
+        @type_directory_name = namer.get_s8r_type_directory_name
+        @serializer_name = namer.get_global_s8r_name
+        @skip_modules = skip_modules
+      end
+
+      def generate(schema)
+        result = Result.new schema: schema
+
+        generate_type_directory schema, result
+        generate_serializer_factory schema, result
+
+        schema.each_type do |type|
+          generate_type type, result
+        end
+
+        unless @skip_modules
+          result.module_tree.each do |module_node|
+            @module_generator.generate module_node, result
+          end
+        end
+
+        result
+      end
+
+      protected
+      def generate_serializer_factory(schema, result)
+        modules = get_module_names @serializer_name
+
+        file_for @serializer_name, result do |f|
+          f.requires 'wsdl_mapper/serializers/serializer_factory',
+            @type_directory_name.require_path
+
+          f.in_modules modules do
+            args = [@type_directory_name.name]
+            args << "default_namespace: #{schema.target_namespace.inspect}" if schema.target_namespace
+            f.assignment @serializer_name.class_name, "::WsdlMapper::Serializers::SerializerFactory.new(#{args * ', '})"
+          end
+        end
+      end
+
+      def generate_type_directory(schema, result)
+        modules = get_module_names @type_directory_name
+
+        file_for @type_directory_name, result do |f|
+          f.requires 'wsdl_mapper/serializers/type_directory'
+
+          f.in_modules modules do
+            f.block_assignment @type_directory_name.class_name, '::WsdlMapper::Serializers::TypeDirectory.new', [] do
+              schema.each_type do |type|
+                generate_type_directory_entry f, type, result
+              end
+              schema.each_element do |element|
+                generate_element_entry f, element, result
+              end
+            end
+          end
+        end
+      end
+
+      def generate_element_entry(f, element, _result)
+        type_name = @namer.get_type_name get_type_name element.type
+        type_class_name = type_name.name.inspect
+
+        f.call :register_element, type_class_name, generate_name(element.name)
+      end
+
+      def generate_type_directory_entry(f, type, _result)
+        type_name = @namer.get_type_name get_type_name type
+        s8r_name = @namer.get_s8r_name get_type_name type
+        type_class_name = type_name.name.inspect
+        require_path = s8r_name.require_path.inspect
+        s8r_class_name = s8r_name.name.inspect
+
+        f.call :register_type, type_class_name, require_path, s8r_class_name
+      end
+
+      def generate_type(type, result)
+        name = @namer.get_s8r_name get_type_name type
+        modules = get_module_names name
+
+        type_file_for name, result do |f|
+          ttg = TypeToGenerate.new type, name
+          f.requires @type_directory_name.require_path
+
+          f.in_modules modules do
+            f.in_class ttg.name.class_name do
+              def_build_method f, ttg
+            end
+          end
+
+          f.call "#{@type_directory_name.name}.register_serializer", name.name.inspect, "#{name.name}.new"
+        end
+      end
+
+      def def_simple_build_method_body(f, ttg)
+        type_name = generate_name ttg.type.name
+        f.block "x.simple(#{type_name}, name)", ['x'] do
+          root_type = ttg.type.root.name.name
+          f.call 'x.text_builtin', 'obj', root_type.inspect
+        end
+      end
+
+      def def_complex_build_method_body(f, ttg)
+        f.literal_array 'attributes', collect_attributes(ttg)
+        type_name = generate_name ttg.type.name
+        f.block "x.complex(#{type_name}, name, attributes)", ['x'] do
+          if ttg.type.simple_content?
+            write_content_statement f, ttg
+          elsif ttg.type.soap_array?
+            write_soap_array_statements f, ttg
+          else
+            write_property_statements f, ttg
+          end
+        end
+      end
+
+      def write_content_statement(f, ttg)
+        content_name = @namer.get_content_name ttg.type
+        type = ttg.type.base.name.name
+        f.call 'x.text_builtin', "obj.#{content_name.attr_name}", type.inspect
+      end
+
+      def write_property_statements(f, ttg)
+        types = ttg.type.bases << ttg.type
+        types.each do |type|
+          type.each_property do |prop|
+            if prop.array?
+              write_property_array_statement f, prop
+            else
+              write_property_statement f, prop
+            end
+          end
+        end
+      end
+
+      def collect_attributes(ttg)
+        if ttg.type.soap_array?
+          soap_array_attributes(ttg)
+        else
+          ttg.type.each_attribute.map do |attr|
+            attr_name = generate_name attr.name
+            accessor_name = @namer.get_attribute_name(attr).attr_name
+            type = attr.type.root.name.name.inspect
+
+            "[#{attr_name}, obj.#{accessor_name}, #{type}]"
+          end
+        end
+      end
+
+      def write_soap_array_statements(f, ttg)
+        item_name = generate_name WsdlMapper::Dom::Name.get(ttg.type.name.ns, @namer.get_soap_array_item_name(ttg.type))
+        f.block 'obj.each', ['itm'] do
+          write_soap_array_item_statement(f, ttg.type, item_name)
+        end
+      end
+
+      def write_soap_array_item_statement(f, type, item_name)
+        case type.soap_array_type
+        when ::WsdlMapper::Dom::BuiltinType
+          write_value_builtin_statement f, item_name, 'itm', type.soap_array_type_name.name.inspect
+        when ::WsdlMapper::Dom::ComplexType
+          type_name = @namer.get_type_name type.soap_array_type
+          f.statement "x.get(#{type_name.name.inspect}).build(x, itm, #{item_name})"
+        when ::WsdlMapper::Dom::SimpleType
+          type_name = @namer.get_type_name type.soap_array_type
+          f.statement "x.get(#{type_name.name.inspect}).build(x, itm, #{item_name})"
+        end
+      end
+
+      def soap_array_attributes(ttg)
+        # Use String#inspect to get the proper escaping, but cut off the last quotemark and append the array length
+        ns = ttg.type.soap_array_type_name.ns.inspect
+        name = ttg.type.soap_array_type_name.name.inspect[0..-2] + "[\#{obj.length}]\""
+        # TODO: what about its namespace?
+        [
+          %<[[x.soap_enc, "arrayType"], [#{ns}, #{name}], "string"]>
+        ]
+      end
+
+      def write_property_array_statement(f, prop)
+        name = "obj.#{@namer.get_property_name(prop).attr_name}.each"
+        f.block name, ['itm'] do
+          case prop.type
+          when ::WsdlMapper::Dom::BuiltinType
+            write_builtin_property_statement f, prop, 'itm'
+          when ::WsdlMapper::Dom::ComplexType
+            write_complex_property_statement f, prop, 'itm'
+          when ::WsdlMapper::Dom::SimpleType
+            write_simple_property_statement f, prop, 'itm'
+          end
+        end
+      end
+
+      def write_property_statement(f, prop)
+        name = "obj.#{@namer.get_property_name(prop).attr_name}"
+        case prop.type
+        when ::WsdlMapper::Dom::BuiltinType
+          write_builtin_property_statement f, prop, name
+        when ::WsdlMapper::Dom::ComplexType
+          write_complex_property_statement f, prop, name
+        when ::WsdlMapper::Dom::SimpleType
+          write_simple_property_statement f, prop, name
+        end
+      end
+
+      def write_simple_property_statement(f, prop, var_name)
+        element_name = generate_name prop.name
+        type_name = @namer.get_type_name get_type_name prop.type
+        f.statement "x.get(#{type_name.name.inspect}).build(x, #{var_name}, #{element_name})"
+      end
+
+      def write_complex_property_statement(f, prop, var_name)
+        element_name = generate_name prop.name
+        type_name = @namer.get_type_name get_type_name prop.type
+        f.statement "x.get(#{type_name.name.inspect}).build(x, #{var_name}, #{element_name})"
+      end
+
+      def get_s8r_name(prop)
+        if prop.type.name
+          @namer.get_s8r_name prop.type
+        else
+          @namer.get_s8r_name @namer.get_inline_type prop
+        end
+      end
+
+      def write_builtin_property_statement(f, prop, name)
+        type = prop.type_name.name.inspect
+        element_name = generate_name prop.name
+        write_value_builtin_statement(f, element_name, name, type)
+      end
+
+      def write_value_builtin_statement(f, element_name, name, type)
+        f.statement "x.value_builtin(#{element_name}, #{name}, #{type})"
+      end
+
+      def def_build_method(f, ttg)
+        f.in_def 'build', :x, :obj, :name do
+          f.statement 'return if obj.nil?'
+          case ttg.type
+          when ::WsdlMapper::Dom::ComplexType
+            def_complex_build_method_body f, ttg
+          when ::WsdlMapper::Dom::SimpleType
+            def_simple_build_method_body f, ttg
+          end
+        end
+      end
+    end
+  end
+end