evil-client 0.3.3 → 1.0.0

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

@@ -1,16 +0,0 @@
-module Evil::Client::DSL
-  class Headers < Base
-    def call(schema)
-      merge schema, headers: coercer
-    end
-
-    private
-
-    attr_reader :model, :block
-
-    def initialize(model: Evil::Struct, &block)
-      @model = model
-      @block = block
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Evil::Client::DSL
-  class HttpMethod < Base
-    def call(schema)
-      merge schema, method: http_method
-    end
-
-    private
-
-    attr_reader :block, :string
-
-    def initialize(string = nil, &block)
-      @string = string.to_s.downcase
-      @block  = block
-    end
-
-    def http_method
-      if block
-        ->(opts) { block.call(opts).to_s.downcase }
-      else
-        proc { string }
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-module Evil::Client::DSL
-  class Operation
-    attr_reader :schema
-
-    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 = nil, &block)
-      @schema = HttpMethod[schema, value, &block]
-    end
-
-    def path(value = nil, &block)
-      @schema = Path[schema, value, &block]
-    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(model: Evil::Struct, &block)
-      @schema = Headers[schema, model: model, &block]
-    end
-
-    def query(model: Evil::Struct, &block)
-      @schema = Query[schema, model: model, &block]
-    end
-
-    def responses(options = {}, &block)
-      Responses.new(self, options, &block)
-    end
-
-    def response(name, status, **options, &block)
-      @schema[:responses][name] = Response[status, block: block, **options]
-    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
-      raise 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::Struct, &block)
-      elsif model
-        model
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-module Evil::Client::DSL
-  # 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 }
-
-      schema = 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
-
-      Verifier.call(schema)
-    end
-
-    private
-
-    def initialize
-      @schema = { nil => Operation.new(nil, nil) }
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Evil::Client::DSL
-  # Adds path settings to the operation's schema
-  class Path < Base
-    def call(schema)
-      merge schema, path: path
-    end
-
-    private
-
-    SLASHES = %r{\A/+|/+\z}
-
-    attr_reader :block, :value
-
-    def initialize(value = nil, &block)
-      @value = value.to_s.gsub(SLASHES, "")
-      @block = block
-    end
-
-    def path
-      if block then ->(opts) { block.call(opts).to_s.gsub(SLASHES, "") }
-      else          ->(_) { value }
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Evil::Client::DSL
-  class Query < Base
-    def call(schema)
-      merge schema, query: coercer
-    end
-
-    private
-
-    attr_reader :model, :block
-
-    def initialize(model: nil, &block)
-      @model = model
-      @block = block
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module Evil::Client::DSL
-  # Builds a schema for response processor
-  class Response
-    extend Dry::Initializer::Mixin
-    param  :status
-    option :raise,  default: proc { false }
-    option :format, default: proc {}
-    option :model,  default: proc { nil }
-    option :block,  default: proc { nil }
-
-    def self.[](*args)
-      new(*args).to_h
-    end
-
-    def to_h
-      { status: status.to_i, coercer: coercer, raise: raise }
-    end
-
-    private
-
-    def json?
-      format.to_s == "json"
-    end
-
-    def arity
-      block&.arity
-    end
-
-    def coercer
-      handlers = [parser, processor, wrapper, finalizer].compact
-      proc { |body| handlers.inject(body) { |obj, handler| handler.call(obj) } }
-    end
-
-    def parser
-      proc { |body| JSON.parse(body) } if json?
-    end
-
-    def wrapper
-      return unless json?
-      proc { |data| data.is_a?(Hash) ? data : { data: data } }
-    end
-
-    def processor
-      return unless block&.arity == 1
-      block
-    end
-
-    def addon
-      return unless arity == 0
-      proc { |klass| klass.instance_eval(&block) }
-    end
-
-    def finalizer
-      case [model.nil?, addon.nil?]
-      when [false, true]  then model
-      when [false, false] then Class.new(model).tap(&addon)
-      when [true,  false] then Class.new(Evil::Struct).tap(&addon)
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-class Evil::Client::DSL::Responses
-  # Add settings shared by several responses
-  #
-  # @param [#to_sym] name
-  # @param [#to_i]   status
-  # @param [Hash<Symbol, Object>] options
-  # @param [Proc] block
-  #
-  def response(name, status, **options, &block)
-    @client.send :response, name, status, @options.merge(options), &block
-  end
-
-  # Add settings shared by several responses
-  #
-  # @param [Hash<Symbol, Object>] options
-  # @param [Proc] block
-  #
-  def responses(**options, &block)
-    self.class.new(@client, @options.merge(options), &block)
-  end
-
-  private
-
-  def initialize(client, **options, &block)
-    @client  = client
-    @options = options
-    instance_eval(&block)
-  end
-end

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

@@ -1,27 +0,0 @@
-module Evil::Client::DSL
-  # Provides a namespace for client's top-level DSL
-  class Scope
-    extend Dry::Initializer::Mixin
-    option :__scope__, default: proc {}, reader: :private
-
-    # 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
-
-    def method_missing(name, *args)
-      __scope__.send(name, *args)
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-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
-      raise ArgumentError.new "Wrong part '#{part}'. Use one of parts: #{parts}"
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module Evil::Client::DSL
-  SchemaError = Class.new(StandardError)
-
-  # Verifies a final schema
-  class Verifier
-    def self.call(schema)
-      new(schema).call
-    end
-
-    def call
-      @schema.each do |key, schema|
-        check_path(key, schema)
-        check_method(key, schema)
-      end
-    end
-
-    private
-
-    def initialize(schema)
-      @schema = schema
-    end
-
-    def check_path(key, schema)
-      return if schema[:path]
-      raise SchemaError,
-            "Path definition is missed for operation :#{key}"
-    end
-
-    def check_method(key, schema)
-      return if schema[:method]
-      raise SchemaError,
-            "HTTP method definition is missed for operation :#{key}"
-    end
-  end
-end

data/lib/evil/client/middleware.rb

@@ -1,81 +0,0 @@
-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