evil-client 0.3.3 → 1.0.0

data/lib/evil/client/formatter/multipart.rb

@@ -0,0 +1,33 @@
+module Evil::Client::Formatter
+  #
+  # Utility module to format file (IO) as a part of multipart body
+  #
+  # @example
+  #   Evil::Client::Formatter::Form.call foo: { bar: :baz }
+  #   # => "foo[bar]=baz"
+  #
+  module Multipart
+    extend self
+    require_relative "part"
+
+    # Formats nested hash as a string
+    #
+    # @param  [Array<IO>] value
+    # @option opts [String] :boundary
+    # @return [String]
+    #
+    def call(*sources, boundary:, **)
+      parts = sources.flatten.map.with_index(1) do |src, num|
+        "--#{boundary}\r\n#{part(src, num)}"
+      end
+
+      [nil, nil, parts, "--#{boundary}--", nil].join("\r\n")
+    end
+
+    private
+
+    def part(source, index)
+      Part.call(source, index)
+    end
+  end
+end

data/lib/evil/client/formatter/part.rb

@@ -0,0 +1,66 @@
+module Evil::Client::Formatter
+  #
+  # Utility module to format source as a part of multipart body
+  #
+  module Part
+    extend self
+    require_relative "form"
+
+    # Formats nested hash as a string
+    #
+    # @param  [IO, #to_s] source
+    # @param  [Integer] number
+    # @return [String]
+    #
+    def call(source, number)
+      filename = extract_filename(source)
+      name     = extract_name(filename, number)
+      path     = Pathname.new(filename) if filename
+      content  = extract_content(source)
+      mime     = extract_mime(path)
+      charset  = extract_charset(content)
+      headers  = [disposition(name, filename), type(mime, charset), nil]
+
+      [*headers, content].join("\r\n")
+    end
+
+    private
+
+    def disposition(name, filename)
+      "Content-Disposition: form-data; name=\"#{name}\"".tap do |line|
+        line << "; filename=\"#{filename}\"" if filename
+      end
+    end
+
+    def type(mime, charset)
+      "Content-Type: #{mime}; charset=#{charset}"
+    end
+
+    def extract_name(filename, number)
+      filename ? filename : "Part#{number}"
+    end
+
+    def extract_content(source)
+      case source
+      when File, Tempfile then source.read
+      when StringIO       then source.string
+      when Hash           then Form.call(source)
+      else source.to_s
+      end
+    end
+
+    def extract_filename(source)
+      case source
+      when File, Tempfile then Pathname.new(source.path).basename.to_s
+      end
+    end
+
+    def extract_mime(path)
+      MIME::Types.type_for(path&.extname.to_s).first || "text/plain"
+    end
+
+    def extract_charset(content)
+      content.encoding.to_s.downcase
+    end
+  end
+end

data/lib/evil/client/formatter/text.rb

@@ -0,0 +1,21 @@
+module Evil::Client::Formatter
+  #
+  # Utility module to format data as a single text
+  #
+  module Text
+    extend self
+
+    # Formats data as a text
+    #
+    # @param  [Object] source
+    # @return [String]
+    #
+    def call(source)
+      case source
+      when File, Tempfile then source.read
+      when StringIO       then source.string
+      else source.to_s
+      end
+    end
+  end
+end

data/lib/evil/client/resolver.rb

@@ -0,0 +1,84 @@
+class Evil::Client
+  #
+  # @abstract
+  # Base class for resolvers of schema definition for a particular settings.
+  #
+  # Its every subclass responds for resolving a specific part of schema
+  # (request, middleware or response).
+  #
+  class Resolver
+    # Loads concrete implementation of the abstract resolver
+    require_relative "resolver/request"
+    require_relative "resolver/middleware"
+    require_relative "resolver/response"
+
+    # Builds and calls one-off resolver at once
+    #
+    # @param  [Object] args The arguments of current class' constructor
+    # @return [Object] resolved definition
+    #
+    def self.call(*args)
+      new(*args).send(:__call__)
+    end
+
+    # Human-friendly representation of the resolver
+    #
+    # @return [String]
+    #
+    def to_s
+      "#{@__keys__.join(' ')} from #{@__schema__} for #{@__settings__}"
+    end
+    alias_method :to_str,  :to_s
+    alias_method :inspect, :to_s
+
+    private
+
+    def initialize(schema, settings, *keys)
+      @__schema__   = schema
+      @__settings__ = settings
+      @__keys__     = keys
+    end
+
+    def __call__
+      logger = @__settings__.logger
+      yield.tap do |obj|
+        logger&.debug(self.class) { "resolved #{self} to #{obj.inspect}" }
+      end
+    rescue => err
+      logger&.error(self.class) { "failed to resolve #{self}: #{err.message}" }
+      raise
+    end
+
+    def __blocks__
+      @__blocks__ ||= [].tap do |blocks|
+        schema = @__schema__
+        loop do
+          break unless schema
+          block  = schema.definitions.dig(*@__keys__)
+          schema = schema.parent
+          blocks.unshift block if block
+        end
+      end
+    end
+
+    def __definition_error__(text)
+      DefinitionError.new(@__schema__, @__keys__, @__settings__, text)
+    end
+
+    def __symbolize_keys__(hash)
+      hash.each_with_object({}) { |(key, val), obj| obj[key.to_sym] = val }
+    end
+
+    def __stringify_keys__(hash)
+      hash.each_with_object({}) { |(key, val), obj| obj[key.to_s] = val }
+    end
+
+    def respond_to_missing?(name, *)
+      @__settings__.respond_to? name
+    end
+
+    def method_missing(*args, &block)
+      respond_to_missing?(*args) ? @__settings__.send(*args, &block) : super
+    end
+  end
+end

data/lib/evil/client/resolver/body.rb

@@ -0,0 +1,22 @@
+class Evil::Client
+  #
+  # Resolves body of the request from operation schema for given settings.
+  #
+  # It uses last (nested) definition without any coercion or validation.
+  # Formatting and validation is made later by [Evil::Client::Resolver#__call__]
+  # because it depends from both :body and :format definitions.
+  #
+  # @private
+  #
+  class Resolver::Body < Resolver
+    private
+
+    def initialize(schema, settings)
+      super(schema, settings, :body)
+    end
+
+    def __call__
+      super { instance_exec(&__blocks__.last) if __blocks__.any? }
+    end
+  end
+end

data/lib/evil/client/resolver/format.rb

@@ -0,0 +1,30 @@
+class Evil::Client
+  #
+  # Resolves request format from operation settings and schema
+  # @private
+  #
+  class Resolver::Format < Resolver
+    private
+
+    def initialize(schema, settings)
+      super schema, settings, :format
+    end
+
+    def __call__
+      super do
+        value = instance_exec(&__blocks__.last)&.to_sym if __blocks__.any?
+        value = :json if value.to_s == ""
+        raise __invalid_error__(value) unless LIST.include? value
+        value
+      end
+    end
+
+    def __invalid_error__(value)
+      __definition_error__ "Format :#{value} not supported." \
+                           " Use one of the following formats:" \
+                           " :#{LIST.join(', :')}."
+    end
+
+    LIST = %i[json yaml form text multipart].freeze
+  end
+end

data/lib/evil/client/resolver/headers.rb

@@ -0,0 +1,46 @@
+class Evil::Client
+  #
+  # Resolves headers of the request from operation settings and schema
+  # by merging headers defined by schema and all its parents.
+  # @private
+  #
+  class Resolver::Headers < Resolver
+    private
+
+    def initialize(schema, settings)
+      super schema, settings, :headers
+    end
+
+    def __call__
+      super do
+        __blocks__.map { |block| __normalize__ instance_exec(&block) }
+                  .reduce({}, :merge)
+                  .reject { |_, value| value&.empty? }
+      end
+    end
+
+    def __normalize__(headers)
+      __check__(headers)
+      keys   = __extract_keys__(headers)
+      values = __extract_values__(headers)
+      keys.zip(values).to_h
+    end
+
+    def __check__(data)
+      raise __definition_error__ "#{data} is not a hash" unless data.is_a? Hash
+    end
+
+    def __extract_keys__(data)
+      keys = data.keys.map(&:to_s)
+      wrong = keys.reject { |key| key[VALID_KEY] }.map(&:inspect)
+      return keys unless wrong.any?
+      raise __definition_error__ "inacceptable headers #{wrong.join(', ')}"
+    end
+
+    def __extract_values__(data)
+      data.values.map { |v| v.respond_to?(:map) ? v.map(&:to_s) : v.to_s }
+    end
+
+    VALID_KEY = /^.+$/
+  end
+end

data/lib/evil/client/resolver/http_method.rb

@@ -0,0 +1,34 @@
+class Evil::Client
+  #
+  # Resolves a http_method for the request from operation settings and schema
+  # @private
+  #
+  class Resolver::HttpMethod < Resolver
+    private
+
+    def initialize(schema, settings)
+      super schema, settings, :http_method
+    end
+
+    def __call__
+      super do
+        value = instance_exec(&__blocks__.last)&.to_s&.upcase if __blocks__.any?
+        raise __not_defined_error__    if value.to_s == ""
+        raise __invalid_error__(value) unless LIST.include? value
+        value
+      end
+    end
+
+    def __not_defined_error__
+      __definition_error__ "HTTP method not defined"
+    end
+
+    def __invalid_error__(value)
+      __definition_error__ "Unknown HTTP method #{value}"
+    end
+
+    # @see https://tools.ietf.org/html/rfc7231#section-4
+    # @see https://tools.ietf.org/html/rfc5789#section-2
+    LIST = %w[GET POST PUT PATCH DELETE OPTIONS HEAD TRACE CONNECT].freeze
+  end
+end

data/lib/evil/client/resolver/middleware.rb

@@ -0,0 +1,36 @@
+class Evil::Client
+  #
+  # Resolves scope/operation-specific middleware from schema for some settings
+  #
+  # New middleware are added to previously defined ones.
+  # To reset all predefined middleware, set value to nil.
+  #
+  # @private
+  #
+  class Resolver::Middleware < Resolver
+    private
+
+    def initialize(schema, settings)
+      super schema, settings, :middleware
+    end
+
+    def __call__
+      super do
+        __blocks__.map.with_object([]) do |block, obj|
+          list = __normalize__ instance_exec(&block)
+          obj.replace([]) unless list
+          obj.concat Array(list)
+        end.reverse
+      end
+    end
+
+    def __normalize__(value)
+      case value
+      when nil   then nil
+      when Class then value
+      when Array then value.flatten.compact.map { |val| __normalize__(val) }
+      else raise __definition_error__("#{value} is neither class nor array")
+      end
+    end
+  end
+end

data/lib/evil/client/resolver/query.rb

@@ -0,0 +1,39 @@
+class Evil::Client
+  #
+  # Resolves query of the request from operation settings and schema
+  # by deeply merging queries defined by schema and all its parents.
+  #
+  # @private
+  #
+  class Resolver::Query < Resolver
+    private
+
+    def initialize(schema, settings)
+      super schema, settings, :query
+    end
+
+    def __call__
+      super do
+        Hash __blocks__
+          .map { |block| __normalize__ instance_exec(&block) }
+          .reduce({}) { |left, right| __deep_merge__(left, right) }
+      end
+    end
+
+    def __normalize__(data)
+      return if data.nil?
+      raise __definition_error__("#{data} is not a hash") unless data.is_a? Hash
+      __stringify_keys__(data)
+    end
+
+    def __deep_merge__(left, right)
+      return right unless left.is_a?(Hash) && right.is_a?(Hash)
+
+      left  = __stringify_keys__(left)
+      right = __stringify_keys__(right)
+      right.keys.each { |key| left[key] = __deep_merge__ left[key], right[key] }
+
+      left
+    end
+  end
+end

data/lib/evil/client/resolver/request.rb

@@ -0,0 +1,96 @@
+class Evil::Client
+  #
+  # Resolves request schema for given settings to the minimal Rack environment
+  #
+  # @return [Hash<String, Object>]
+  # @private
+  #
+  class Resolver::Request < Resolver
+    require_relative "uri"
+    require_relative "http_method"
+    require_relative "security"
+    require_relative "headers"
+    require_relative "query"
+    require_relative "body"
+    require_relative "format"
+
+    private
+
+    def initialize(schema, settings)
+      super schema, settings, :request
+    end
+
+    def __call__
+      super { environment }
+    end
+
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/AbcSize
+    def environment
+      {
+        "REQUEST_METHOD"    => http_method,
+        "PATH_INFO"         => uri.path,
+        "SCRIPT_NAME"       => "",
+        "QUERY_STRING"      => Formatter.call(query, :form),
+        "SERVER_NAME"       => uri.host,
+        "SERVER_PORT"       => uri.port,
+        "HTTP_Variables"    => headers,
+        "rack.version"      => Rack::VERSION,
+        "rack.url_scheme"   => uri.scheme,
+        "rack.input"        => Formatter.call(body, format, boundary: boundary),
+        "rack.multithread"  => false,
+        "rack.multiprocess" => false,
+        "rack.run_once"     => false,
+        "rack.hijack?"      => false,
+        "rack.logger"       => @__settings__&.logger
+      }
+    end
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/AbcSize
+
+    def uri
+      @uri ||= Resolver::Uri.call(@__schema__, @__settings__)
+    end
+
+    def http_method
+      @http_method ||= Resolver::HttpMethod.call(@__schema__, @__settings__)
+    end
+
+    def format
+      @format ||= Resolver::Format.call(@__schema__, @__settings__)
+    end
+
+    def security
+      @security ||= Resolver::Security.call(@__schema__, @__settings__)
+    end
+
+    def headers
+      @headers ||= Resolver::Headers.call(@__schema__, @__settings__)
+                                    .merge(security.fetch(:headers, {}))
+                                    .merge("Content-Type" => content_type)
+    end
+
+    def query
+      @query ||= Resolver::Query.call(@__schema__, @__settings__)
+                                .merge(security.fetch(:query, {}))
+    end
+
+    def body
+      @body ||= Resolver::Body.call(@__schema__, @__settings__)
+    end
+
+    def boundary
+      @boundary ||= SecureRandom.hex(10)
+    end
+
+    def content_type
+      case format
+      when :text      then "text/plain"
+      when :json      then "application/json"
+      when :yaml      then "application/yaml"
+      when :form      then "application/x-www-form-urlencoded"
+      when :multipart then "multipart/form-data; boundary=#{boundary}"
+      end
+    end
+  end
+end