evil-client 0.2.1

data/lib/evil/client/dsl/files.rb

@@ -0,0 +1,37 @@
+module Evil::Client::DSL
+  # Nested definition for attached files
+  class Files
+    # Builds a final upload schema from request options
+    #
+    # @param  [Hash<Symbol, Object>] options
+    # @return [Hash<Symbol, Object>]
+    #
+    def call(**options)
+      @mutex.synchronize do
+        @schema = []
+        instance_exec(options, &@block)
+        @schema
+      end
+    end
+
+    private
+
+    def initialize(&block)
+      @mutex = Mutex.new
+      @block = block
+    end
+
+    # ==========================================================================
+    # Helper methods that mutate files @schema
+    # ==========================================================================
+
+    def add(data, type: "text/plain", charset: "utf-8", filename: nil, **)
+      @schema << {
+        file:     data.respond_to?(:read) ? data : StringIO.new(data),
+        type:     MIME::Types[type].first,
+        charset:  charset,
+        filename: filename
+      }
+    end
+  end
+end

data/lib/evil/client/dsl/operation.rb

@@ -0,0 +1,102 @@
+module Evil::Client::DSL
+  require_relative "security"
+  require_relative "files"
+
+  # Builds a schema for single operation
+  class Operation
+    attr_reader :schema
+
+    # Builds a schema for a single operation
+    #
+    # @param  [Object] settings
+    # @param  [Proc] block A block of definitions (should accept settings)
+    # @return [Hash<Symbol, Object>]
+    #
+    def finalize(settings)
+      @mutex.synchronize do
+        @schema = @default.dup
+        instance_exec(settings, &@block) if @block
+        @schema[:middleware]&.finalize(settings)
+        @schema
+      end
+    end
+
+    private
+
+    def initialize(key, block)
+      @mutex   = Mutex.new
+      @block   = block
+      @default = { key: key, responses: {} }
+    end
+
+    # ==========================================================================
+    # Helper methods that mutate a @schema
+    # ==========================================================================
+
+    def documentation(value)
+      @schema[:doc] = value
+    end
+
+    def http_method(value)
+      @schema[:method] = value.to_s.downcase
+    end
+
+    def path
+      @schema[:path] = ->(**opts) { yield(opts).gsub(%r{\A/+|/+\z}, "") }
+    end
+
+    def security(&block)
+      @schema[:security] = Security.new(&block)
+    end
+
+    def files(&block)
+      @schema[:files]  = Files.new(&block)
+      @schema[:format] = "multipart"
+      @schema.delete :body
+    end
+
+    def body(format: "json", **options, &block)
+      @schema[:body]   = __model__(options, &block)
+      @schema[:format] = __valid_format__(format)
+      @schema.delete :files
+    end
+
+    def headers(**options, &block)
+      @schema[:headers] = __model__(options, &block)
+    end
+
+    def query(**options, &block)
+      @schema[:query] = __model__(options, &block)
+    end
+
+    def response(*statuses, raise: false, &block)
+      statuses.each do |status|
+        @schema[:responses][status] = {
+          raise:   raise,
+          coercer: block || proc { |response:, **| response }
+        }
+      end
+    end
+
+    # ==========================================================================
+    # Utilities for helpers TODO: extract to a separate module
+    # ==========================================================================
+
+    def __valid_format__(format)
+      formats = %w(json form)
+      return format.to_s if formats.include? format.to_s
+      fail ArgumentError.new "Invalid format #{format} for body." \
+                             " Use one of formats: #{formats}"
+    end
+
+    def __model__(model: nil, **, &block)
+      if model && block
+        Class.new(model, &block)
+      elsif block
+        Class.new(Evil::Client::Model, &block)
+      elsif model
+        model
+      end
+    end
+  end
+end

data/lib/evil/client/dsl/operations.rb

@@ -0,0 +1,41 @@
+module Evil::Client::DSL
+  require_relative "operation"
+
+  # Container for operations definitions
+  # Applies settings to definitions and returns a final schema
+  class Operations
+    # Adds block definition as a named operation
+    #
+    # @param [#to_sym] key
+    # @param [Proc] block
+    # @return [self]
+    #
+    def register(key, &block)
+      @schema[key] = Operation.new(key, block)
+      self
+    end
+
+    # Applies settings to all definitions and returns a final schema
+    #
+    # @param  [Object] settings
+    # @return [Hash<Symbol, Object>]
+    #
+    def finalize(settings)
+      default = @schema[nil].finalize(settings)
+      custom  = @schema.select { |key| key }
+
+      custom.each_with_object({}) do |(key, operation), hash|
+        custom = operation.finalize(settings)
+        hash[key] = default.merge(custom)
+        hash[key][:format] ||= "json"
+        hash[key][:responses] = default[:responses].merge(custom[:responses])
+      end
+    end
+
+    private
+
+    def initialize
+      @schema = { nil => Operation.new(nil, nil) }
+    end
+  end
+end

data/lib/evil/client/dsl/scope.rb

@@ -0,0 +1,34 @@
+module Evil::Client::DSL
+  # Provides a namespace for client's top-level DSL
+  class Scope
+    extend Dry::Initializer::Mixin
+    option :__scope__, default: proc {}
+
+    # Declares a method that opens new scope inside the current one
+    # An instance of new scope has access to methods of its parent
+    #
+    # @param  [#to_sym] name (:[]) The name of the new scope
+    # @return [self]
+    #
+    def self.scope(name = :[], &block)
+      klass = Class.new(Scope, &block)
+      define_method(name) do |*args, **options|
+        klass.new(*args, __scope__: self, **options)
+      end
+      self
+    end
+
+    private
+
+    private :__scope__
+
+    def respond_to_missing?(name, *)
+      __scope__.respond_to? name
+    end
+
+    def method_missing(name, *args)
+      super unless respond_to? name
+      __scope__.send(name, *args)
+    end
+  end
+end

data/lib/evil/client/dsl/security.rb

@@ -0,0 +1,57 @@
+module Evil::Client::DSL
+  # Nested definition for a security schemas
+  class Security
+    # Builds final security schema dependent on request options
+    #
+    # @param  [Hash<Symbol, Object>] options
+    # @return [Hash<Symbol, Object>]
+    #
+    def call(**options)
+      @mutex.synchronize do
+        @schema = {}
+        instance_exec(options, &@block)
+        @schema
+      end
+    end
+
+    private
+
+    def initialize(&block)
+      @mutex = Mutex.new
+      @block = block
+    end
+
+    # ==========================================================================
+    # Helper methods that mutate a security @schema
+    # ==========================================================================
+
+    # @see [https://tools.ietf.org/html/rfc7617]
+    def basic_auth(user, password)
+      token = Base64.encode64("#{user}:#{password}").delete("\n")
+      token_auth(token, prefix: "Basic")
+    end
+
+    def token_auth(token, using: :headers, prefix: nil)
+      if using == :headers
+        prefixed_token = [prefix&.to_s&.capitalize, token].compact.join(" ")
+        key_auth("authorization", prefixed_token, using: :headers)
+      else
+        key_auth("access_token", token, using: using)
+      end
+    end
+
+    def key_auth(key, value, using: :headers)
+      __validate__ using
+      @schema[using] ||= {}
+      @schema[using][key.to_s] = value
+    end
+
+    # ==========================================================================
+
+    def __validate__(part)
+      parts = %i(body query headers)
+      return if parts.include? part
+      fail ArgumentError.new("Wrong part '#{part}'. Use one of parts: #{parts}")
+    end
+  end
+end

data/lib/evil/client/middleware.rb

@@ -0,0 +1,81 @@
+class Evil::Client
+  # Builds and carries stack of middleware parameterized by settings
+  #
+  # @example
+  #   # during client definition
+  #   middleware = Evil::Client::Middleware.new do |settings|
+  #     run CustomMiddleware if settings.version > 1
+  #   end
+  #
+  #   # during client instantiation
+  #   stack = middleware.finalize(settings)
+  #   conn  = stack.wrap(connection)
+  #
+  #   # during runtime to make a request
+  #   conn.call request
+  #
+  class Middleware
+    class << self
+      require_relative "middleware/base"
+      require_relative "middleware/merge_security"
+      require_relative "middleware/normalize_headers"
+      require_relative "middleware/stringify_json"
+      require_relative "middleware/stringify_multipart"
+      require_relative "middleware/stringify_query"
+      require_relative "middleware/stringify_form"
+
+      # Middleware to be added on top of full stack (before custom ones)
+      def prepend
+        new do
+          run NormalizeHeaders
+          run MergeSecurity
+        end.finalize
+      end
+
+      # Middleware to be added on bottom of full stack
+      # (between custom stack and connection)
+      def append
+        new do
+          run StringifyQuery
+          run StringifyJson
+          run StringifyForm
+          run StringifyMultipart
+        end.finalize
+      end
+    end
+
+    # Applies client settings to build stack of middleware
+    #
+    # @param  [Object] settings
+    # @return [self]
+    #
+    def finalize(settings = nil)
+      @mutex.synchronize do
+        @stack = []
+        instance_exec(settings, &@block) if @block
+        self
+      end
+    end
+
+    # Wraps the connection instance to the current stack of middleware
+    #
+    # @param  [#call] connection
+    # @return [#call]
+    #
+    def call(other)
+      @stack.reverse.inject(other) { |a, e| e.new(a) }
+    end
+
+    private
+
+    def initialize(&block)
+      @mutex = Mutex.new
+      @block = block
+    end
+
+    def run(klass)
+      @stack << klass
+      self
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+class Evil::Client::Middleware::Base
+  def call(env)
+    @app.call build(env)
+  end
+
+  private
+
+  def initialize(app)
+    @app = app
+  end
+
+  def build(env)
+    env
+  end
+end

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

@@ -0,0 +1,16 @@
+class Evil::Client::Middleware
+  class MergeSecurity < Base
+    private
+
+    def build(env)
+      env.dup.tap do |hash|
+        security = hash.delete(:security).to_h
+        %i(headers body query).each do |key|
+          next unless security[key]
+          hash[key] ||= {}
+          hash[key].update security[key]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+class Evil::Client::Middleware
+  class NormalizeHeaders < Base
+    private
+
+    def build(env)
+      headers = Hash(env[:headers]).each_with_object({}) do |(key, val), hash|
+        hash[key.to_s.downcase] = val.to_s
+      end
+
+      env.merge headers: headers
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+class Evil::Client::Middleware
+  class StringifyForm < Base
+    private
+
+    def build(env)
+      return env unless env[:format] == "form"
+      return env if env&.fetch(:body, nil).to_h.empty?
+
+      env.dup.tap do |hash|
+        hash[:headers] ||= {}
+        hash[:headers]["content-type"] = "application/x-www-form-urlencoded"
+        hash[:body_string] = env[:body]
+                             .flat_map { |key, val| normalize(val, key) }
+                             .flat_map { |item| stringify(item) }
+                             .join("&")
+      end
+    end
+
+    def stringify(hash)
+      hash.map do |keys, val|
+        "#{keys.first}#{keys[1..-1].map { |key| "[#{key}]" }.join}=#{val}"
+      end
+    end
+
+    def normalize(value, *keys)
+      case value
+      when Hash then
+        value.flat_map { |key, val| normalize(val, *keys, key) }
+      when Array then
+        value.flat_map { |val| normalize(val, *keys, nil) }
+      else
+        [{ keys.map { |key| CGI.escape(key.to_s) } => CGI.escape(value.to_s) }]
+      end
+    end
+  end
+end