wsdl-mapper 0.0.7

data/lib/wsdl_mapper/naming/type_name.rb

@@ -0,0 +1,77 @@
+module WsdlMapper
+  module Naming
+    # Class to represent the (ruby) type name for an XML (complex or simple) type.
+    # This includes the ruby class name and module hierarchy, as well as file name + file path.
+    class TypeName
+      # @!attribute [r] class_name
+      #   @return [String] Class name of the ruby class (to generate), without enclosing modules. E.g. `"Note"` for
+      #                    `::ModuleA::ModuleB::Note`.
+      # @!attribute [r] module_path
+      #   @return [Array<String>] Hierarchy of enclosing ruby modules. E.g. ["ModuleA", "ModuleB"] for
+      #                    `::ModuleA::ModuleB::Note`.
+      # @!attribute [r] file_name
+      #   @return [String] File name where to put the ruby class into (including the '.rb' extension). E.g. "note.rb"
+      # @!attribute [r] file_path
+      #   @return [Array<String>] File path (without file name) as array, e.g. ["module_a", "module_b"]
+      # @!attribute [rw] parent
+      #   @return [TypeName] Parent {TypeName}, usually representing a module, that contains several classes.
+      attr_reader :class_name, :module_path, :file_name, :file_path
+      attr_accessor :parent
+      alias_method :module_name, :class_name
+
+      # Initialize a new instance with the given names / paths
+      #
+      # @param [String] class_name
+      # @param [Array<String>] module_path
+      # @param [String] file_name
+      # @param [Array<String>] file_path
+      def initialize(class_name, module_path, file_name, file_path)
+        @class_name = class_name
+        @module_path = module_path
+        @file_name = file_name
+        @file_path = file_path
+      end
+
+      # Returns the hierarchy of parents.
+      #
+      # @return [Array<TypeName>] List of ancestors, with the immediate {#parent} as first element. `[]` if this
+      #                           is at root level.
+      def parents
+        @parents ||= if parent.nil?
+          []
+        else
+          [parent] + parent.parents
+        end
+      end
+
+      # Returns the path necessary to require this type later on.
+      #
+      # @return [String] Full (relative) path (excluding the extension) to use in a `require` statement.
+      #                  E.g. `"module_a/module_b/note"`
+      def require_path
+        @require_path ||= File.join(*@file_path, File.basename(@file_name, '.rb'))
+      end
+
+      # Full qualified ruby class name, including enclosing modules and root module prefix, e.g.
+      # `"::ModuleA::ModuleB::Note"`
+      # @return [String]
+      def name
+        @name ||= ['', *@module_path, @class_name] * '::'
+      end
+
+      # Determines if this type name is equal to `other`. Two type names are considered
+      # equal, if their {TypeName#name} is equal.
+      # @param [TypeName] other Other type name to compare to
+      # @return [true, false]
+      def eql?(other)
+        self.class == other.class && name == other.name
+      end
+      alias_method :==, :eql?
+
+      # @!visibility private
+      def hash
+        [self.class, name].hash
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/parsing/base.rb

@@ -0,0 +1,148 @@
+require 'nokogiri'
+
+require 'wsdl_mapper/dom/name'
+require 'wsdl_mapper/parsing/logging'
+
+module WsdlMapper
+  module Parsing
+    class Base
+      include WsdlMapper::Dom
+      include Logging
+
+      TARGET_NS = 'targetNamespace'
+      NS_DECL_PREFIX = 'xmlns'
+
+      def initialize(base)
+        @base = base
+        @log_msgs = []
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      # @return [WsdlMapper::Dom::Name]
+      def self.get_name(node)
+        ns = node.namespace ? node.namespace.href : nil
+        name = node.name
+
+        Name.get ns, name
+      end
+
+      protected
+      # @param [Nokogiri::XML::Node] node
+      def parse_node(node)
+        name = get_name(node)
+
+        parser = @base.parsers[name]
+
+        if parser
+          parser.parse node
+        else
+          log_msg node, :unknown
+        end
+      end
+
+      # @param [Nokogiri::XML::Document] doc
+      def parse_namespaces(doc)
+        doc.namespaces.each do |key, ns|
+          if key == NS_DECL_PREFIX
+            @default_namespace = ns
+          else
+            code = key.sub /^#{NS_DECL_PREFIX}\:/, ''
+            @namespaces[code] = ns
+          end
+        end
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      def parse_target_namespace(node)
+        attr = node.attributes[TARGET_NS]
+        if attr
+          @target_namespace = attr.value
+        end
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      # @return [WsdlMapper::Dom::Name]
+      def get_name(node)
+        self.class.get_name node
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      def is_element?(node)
+        node.is_a? Nokogiri::XML::Element
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      def first_element(node)
+        node.children.find { |n| is_element? n }
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      def first_element!(node)
+        first_element(node) ||
+          raise(ArgumentError.new("#{node.name} has no child elements."))
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      # @param [WsdlMapper::Dom::Name] name
+      def select_nodes(node, name)
+        node.children.select { |n| is_element?(n) && name_matches?(n, name) }
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      # @param [WsdlMapper::Dom::Name] name
+      def find_node(node, name)
+        node.children.find { |n| is_element?(n) && name_matches?(n, name) }
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      # @param [WsdlMapper::Dom::Name] name
+      def name_matches?(node, name)
+        return node.name == name.name && name.ns.nil? if node.namespace.nil?
+
+        node.name == name.name && node.namespace.href == name.ns
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      # @yieldparam [Nokogiri::XML::Node] child
+      def each_element(node)
+        node.children.each do |child|
+          next unless is_element? child
+          yield child
+        end
+      end
+
+      # @param [String] name
+      # @param [Nokogiri::XML::Node] node
+      # @param [String] default_value
+      # @return [String]
+      def fetch_attribute_value(name, node, default_value = nil)
+        attr = node.attributes[name]
+        attr ? attr.value : default_value
+      end
+
+      # @param [String] name
+      # @param [Nokogiri::XML::Node] node
+      # @return [WsdlMapper::Dom::Name]
+      def parse_name_in_attribute(name, node)
+        val = fetch_attribute_value name, node
+        return unless val
+        parse_name val, node
+      end
+
+      # @param [String] name_str
+      # @return [WsdlMapper::Dom::Name]
+      def parse_name(name_str, node)
+        name, ns_code = name_str.split(':').reverse
+        ns = if ns_code.nil?
+          @base.target_namespace
+        elsif ns_code == 'xml'
+          'http://www.w3.org/XML/1998/namespace'
+        else
+          node.namespaces["xmlns:#{ns_code}"]
+        end
+
+        Name.get ns, name
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/parsing/logging.rb

@@ -0,0 +1,33 @@
+require 'logging'
+
+module WsdlMapper
+  module Parsing
+    module Logging
+
+      class LogMsg
+        def initialize(node, source, msg = '')
+          @node = node
+          @source = source
+          @node_name = node && node.name
+          @msg = msg
+        end
+
+        def to_s
+          "#{@msg}: #{@node} - #{@source.class.name}"
+        end
+      end
+
+      attr_accessor :log_msgs
+
+      # @param [Nokogiri::XML::Node] node
+      # @param [String, Symbol] msg
+      def log_msg(node, msg = '', source = self)
+        @log_msgs ||= []
+        @log_msgs << LogMsg.new(node, source, msg)
+
+        @logger ||= ::Logging.logger[self]
+        @logger.warn "#{msg} in #{node}"
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime.rb

@@ -0,0 +1,4 @@
+module WsdlMapper
+  module Runtime
+  end
+end

data/lib/wsdl_mapper/runtime/api.rb

@@ -0,0 +1,42 @@
+require 'wsdl_mapper/runtime/simpler_inspect'
+require 'wsdl_mapper/runtime/proxy'
+
+module WsdlMapper
+  module Runtime
+    class Api
+      include SimplerInspect
+
+      attr_reader :_services
+
+      # @!attribute _services
+      #   @return [Array<WsdlMapper::Runtime::Service>] All services contained in this API
+
+      # @param [WsdlMapper::Runtime::SimpleHttpBackend] backend The backend to use
+      def initialize(backend)
+        @_backend = backend
+        @_services = []
+      end
+
+      # Executes a request using the configured backend.
+      # @param [WsdlMapper::Runtime::Operation] operation Operation to call
+      # @param [Array] args Request input
+      # @return [Object] Response
+      def _call(operation, *args)
+        @_backend.dispatch operation, *args
+      end
+
+      # Executes a request async using the configured backend.
+      # @param [WsdlMapper::Runtime::Operation] operation Operation to call
+      # @param [Concurrent::Promise] args_promise Promise for request input
+      # @return [Concurrent::Promise] Promise for the response
+      def _call_async(operation, args_promise)
+        @_backend.dispatch_async operation, args_promise
+      end
+
+      # Force preloading of requires for all contained services
+      def _load_requires
+        @_services.each(&:_load_requires)
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/async_http_backend.rb

@@ -0,0 +1,72 @@
+require 'wsdl_mapper/runtime/backend_base'
+require 'concurrent'
+require 'faraday'
+
+require 'wsdl_mapper/runtime/middlewares/async_message_factory'
+require 'wsdl_mapper/runtime/middlewares/async_request_factory'
+require 'wsdl_mapper/runtime/middlewares/async_dispatcher'
+require 'wsdl_mapper/runtime/middlewares/async_response_factory'
+require 'wsdl_mapper/runtime/middlewares/async_request_logger'
+require 'wsdl_mapper/runtime/middlewares/async_response_logger'
+
+module WsdlMapper
+  module Runtime
+    # ## Middleware Stack
+    # ### Default Configuration
+    # The default stack is composed of the following middlewares:
+    # ![Diagram](/docs/file/doc/diag/async_backend.png)
+    # 1. `message.factory`: {WsdlMapper::Runtime::Middlewares::AsyncMessageFactory}
+    # 2. `request.factory`: {WsdlMapper::Runtime::Middlewares::AsyncRequestFactory}
+    # 3. `dispatcher`: {WsdlMapper::Runtime::Middlewares::AsyncDispatcher}
+    # 4. `response.factory`: {WsdlMapper::Runtime::Middlewares::AsyncResponseFactory}
+    class AsyncHttpBackend < BackendBase
+      include WsdlMapper::Runtime::Middlewares
+
+      def initialize(connection: Faraday.new, executor: nil)
+        super()
+        @executor = executor
+
+        stack.add 'message.factory', AsyncMessageFactory.new
+        stack.add 'request.factory', AsyncRequestFactory.new
+        stack.add 'dispatcher', AsyncDispatcher.new(connection)
+        stack.add 'response.factory', AsyncResponseFactory.new
+      end
+
+      # Enables request and response logging. Returns self.
+      # @param [Logger] logger Logger instance to use.
+      # @param [Logger::DEBUG, Logger::INFO, Logger::FATAL, Logger::ERROR, Logger::WARN] log_level
+      # @return [AsyncHttpBackend]
+      def enable_logging(logger = Logger.new(STDOUT), log_level: Logger::DEBUG)
+        stack.after 'request.factory', 'request.logger', AsyncRequestLogger.new(logger, log_level: log_level)
+        stack.before 'response.factory', 'response.logger', AsyncResponseLogger.new(logger, log_level: log_level)
+        self
+      end
+
+      # Disables logging by removing the logging middlewares from the stack. Returns self.
+      # @return [AsyncHttpBackend]
+      def disable_logging
+        stack.remove 'request.logger'
+        stack.remove 'response.logger'
+        self
+      end
+
+      # Takes an `operation` and arguments, wraps them in a new {Concurrent::Promise},
+      # passes them to the {#stack} and returns the response promise.
+      # @param [WsdlMapper::Runtime::Operation] operation
+      # @param [Array] args
+      # @return [Concurrent::Promise] The unscheduled response promise.
+      def dispatch(operation, *args)
+        promise = Concurrent::Promise.new(executor: @executor) { args }
+        dispatch_async operation, promise
+      end
+
+      # Passes a promise to the stack and returns the response promise.
+      # @param [WsdlMapper::Runtime::Operation] operation
+      # @param [Concurrent::Promise] promise A promise for the request arguments.
+      # @return [Concurrent::Promise] The unscheduled response promise.
+      def dispatch_async(operation, promise)
+        stack.execute([operation, promise]).last
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/backend_base.rb

@@ -0,0 +1,21 @@
+require 'uri'
+require 'wsdl_mapper/runtime/middleware_stack'
+
+module WsdlMapper
+  module Runtime
+    class BackendBase
+      attr_reader :stack
+
+      # @!attribute stack
+      #   @return [WsdlMapper::Runtime::MiddlewareStack]
+
+      def initialize
+        @stack = MiddlewareStack.new
+      end
+
+      def dispatch(operation, *input)
+        stack.execute([operation, *input]).last
+      end
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/body.rb

@@ -0,0 +1,10 @@
+module WsdlMapper
+  module Runtime
+    class Body
+      attr_accessor :fault
+
+      # @!attribute fault
+      #   @return [WsdlMapper::SvcDesc::Fault]
+    end
+  end
+end

data/lib/wsdl_mapper/runtime/errors.rb

@@ -0,0 +1,42 @@
+module WsdlMapper
+  module Runtime
+    module Errors
+      class Error < ::StandardError
+        attr_reader :cause
+
+        def initialize(msg, cause = $!)
+          super msg
+          @cause = cause
+        end
+      end
+
+      class TransportError < Error
+        attr_reader :request
+
+        def initialize(msg, cause = $!, request = nil)
+          super(msg, cause)
+          @request = request
+        end
+      end
+
+      class HTTPError < Error
+        attr_reader :request, :status
+
+        def initialize(status, msg, cause = $!, request = nil)
+          super("[#{status}] #{msg}", cause)
+          @status = status
+          @request = request
+        end
+      end
+
+      class SoapFault < Error
+        attr_reader :fault
+
+        def initialize(fault, cause = $!)
+          super fault.string, cause
+          @fault = fault
+        end
+      end
+    end
+  end
+end