evil-client 0.3.3 → 1.0.0

data/docs/responses.md

@@ -1,66 +0,0 @@
-For every operation you have to describe all expected responses and how they should be processed.
-
-Use the `response` method with anexpected http response status(es):
-
-```ruby
-operation :find_cat do
-  # ...
-  response 200, 201
-end
-```
-
-This definition tells a client to accept responses with given statuses, and to return an instance of `Rack::Response`.
-
-```ruby
-client.operations[:find_cat].call
-# => #<Rack::Response @code=200 ...>
-```
-
-## Data Coersion
-
-Instead of returning a raw rack response, you can coerce it using a block. The block will take 3 options, namely the response, its body and headers:
-
-```ruby
-operation :find_cat do |settings| # remember that you have access to settings
-  # ...
-  response 200 do |response:, body:, headers:|
-    JSON.parse(body) if settings.format == "json"
-  end
-end
-
-# later at a runtime
-client.operations[:find_cat].call
-# => { name: "Bastet", age: 10 }
-```
-
-
-
-## Raising Exceptions
-
-When processing responces with error statuses you may need to raise an exception instead of returning values. Do this using option `raise: true` 
-
-```ruby
-operation :find_cat do
-  # ...
-  response 422, raise: true
-end
-```
-
-This time the operation will raise a `Evil::Client::ResponseError` (inherited from the `RuntimeError`). The exception carries a rack response:
-
-```ruby
-begin
-  client.operations[:find_cat].call
-rescue Evil::Client::ResponseError => error
-  error.response
-  # => #<Rack::Response @code=422 ...>
-end
-```
-
-Like before, you can add a block to handle the response. In this case an exception will carry a result of the block.
-
-## Unexpected Responses
-
-In case the server responded with undefined status, the operation raises `Evil::Client::UnexpectedResponseError` (inherited from the `RuntimeError`) that carries a rack response just like the `Evil::Client::ResponseError` before.
-
-Notice that you can declare default responses using anonymous `operation {}` syntax. Only those responces that are declared neither by default, nor for a specific operation, will cause unexpected response behaviour.

data/docs/security.md

@@ -1,102 +0,0 @@
-Use `security` declaration for the authorization schema. Inside the block you have access to 3 methods:
-* `basic_auth`
-* `token_auth`
-* `key_auth`
-
-## Basic Authentication
-
-Use `basic_auth(login, password)` to define [basic authentication following RFC-7617][basic_auth]:
-
-```ruby
-operation :find_cat do |settings|
-  security do
-    basic_auth settings.login, settings.password
-  end
-end
-```
-
-This declaration with add a header `"Authentication" => "Basic {encoded token}"` to every request. The header is added independenlty of declaration for other [headers][headers].
-
-## Token Authentication
-
-The command `token_auth(token, **options)` allows you to insert a customizable token to any part of the request. Unlike `basic_auth`, you need to provide the token (build, encrypt etc.) by hand.
-
-```ruby
-operation :find_cat do |settings|
-  security do
-    token_auth settings.token
-  end
-end
-```
-
-By default the token is added to `"Authentication" => {token}` header of the request. You can prepend it with a necessary prefix. For example, you can define a [Bearer token authentication following RFC-6750][bearer]:
-
-```ruby
-operation :find_cat do |settings|
-  security do
-    token_auth settings.token, prefix: "Bearer"
-  end
-end
-```
-
-Instead of headers, you can send a token in either request body, or a query. In this case the token will be sent under `access_key` ignoring a prefix:
-
-```ruby
-operation :find_cat do |settings|
-  path { "/cats" }
-  security do
-    token_auth settings.token, using: :query
-  end
-end
-
-# will send a request to "../cats?access_key={token}"
-```
-
-## Authentication Using Arbitrary Key
-
-The most customizeable option is to authenticate requests with an arbitrary key. This time key-value pair will be added to the selected part (`headers`, `body`, or `query`) of the request:
-
-```ruby
-operation :find_cat do |settings|
-  path { "/cats" }
-  security do
-    key_auth :accss_key, settings.token, using: :query
-  end
-end
-```
-
-## Authentication Using Several Schemes
-
-You can define several schemes for the same request. All of them will be applied at once:
-
-```ruby
-operation :find_cat do |settings|
-  security do
-    basic_auth settings.login, settings.password
-    token_auth settings.token, using: :query
-  end
-end
-```
-
-Moreover, you can declare shared authentication by default, and either update, or reload it for a specific operation:
-
-```ruby
-operation do |settings|
-  security { basic_auth settings.login, settings.password }
-end
-
-operation :find_cat do |settings|
-  security { token_auth settings.token, using: :query } # added to default security
-end
-
-operation :find_cats do |settings|
-  security { token_auth settings.token } # reloads default "Authentication" header
-end
-```
-
-
-[basic_auth]: https://tools.ietf.org/html/rfc7617
-[bearer]: https://tools.ietf.org/html/rfc6750
-[headers]:
-[body]:
-[query]:

data/docs/settings.md

@@ -1,32 +0,0 @@
-Use `settings` to parameterize an instance of the client.
-
-Inside the block you can define both `param`s and `option`s for a client constructor. See [dry-initializer docs][dry-initializer] for detailed description of the methods' syntax.
-
-```ruby
-require "evil-client"
-require "dry-types"
-
-class CatsClient < Evil::Client
-  settings do
-    param  :roor_url
-    option :version,  type: Dry::Types["coercible.int"], default: proc { 1 }
-    option :login,    type: Dry::Types["strict.string"] # required
-    option :password, type: Dry::Types["strict.string"] # required
-  end
-end
-```
-
-Now you can initialize a client:
-
-```ruby
-client = CatsClient.new "https://cats.example.com",
-                        login: "cats_lover",
-                        password: "purr"
-```
-
-A container with assigned settings will be passed to blocks declaring [base_url][base_url], [connection][connection], and [operations][operation].
-
-[base_url]:
-[connection]:
-[operation]:
-[dry-initializer]: http://dry-rb.org/gems/dry-initializer

data/lib/evil/client/connection/net_http.rb

@@ -1,57 +0,0 @@
-require "net/http"
-require "net/https"
-
-class Evil::Client
-  class Connection
-    # Net::HTTP based implementation of [Evil::Client::Connection]
-    class NetHTTP < Connection
-      # Sends a request to the remote uri,
-      # and returns rack-compatible response
-      #
-      # @param  [Hash] env Middleware environment with keys:
-      #   :http_method, :path, :query_string, :body_string, :headers
-      # @return [Array] Rack-compatible response [status, body, headers]
-      #
-      def call(env, *)
-        request = build_request(env)
-        Net::HTTP.start base_uri.host, base_uri.port, opts do |http|
-          handle http.request(request)
-        end
-      end
-
-      private
-
-      def opts
-        @opts ||= {}.tap { |hash| hash[:use_ssl] = base_uri.scheme == "https" }
-      end
-
-      def build_request(env)
-        type, path, query, body, headers = parse_env(env)
-
-        sender = build_sender(type)
-        uri    = build_uri(path, query)
-
-        sender.new(uri).tap do |request|
-          request.body = body
-          headers.each { |key, value| request[key] = value }
-        end
-      end
-
-      def parse_env(env)
-        env.values_at :http_method, :path, :query_string, :body_string, :headers
-      end
-
-      def build_sender(type)
-        Net::HTTP.const_get type.capitalize
-      end
-
-      def build_uri(path, query)
-        base_uri.merge(URI.encode(path)).tap { |uri| uri.query = query }
-      end
-
-      def handle(response)
-        [response.code.to_i, Hash(response.header), Array(response.body)]
-      end
-    end
-  end
-end

data/lib/evil/client/dsl.rb

@@ -1,127 +0,0 @@
-class Evil::Client
-  # Defines a DSL to customize class-level settings of the specific client
-  module DSL
-    require_relative "dsl/base"
-    require_relative "dsl/files"
-    require_relative "dsl/headers"
-    require_relative "dsl/http_method"
-    require_relative "dsl/path"
-    require_relative "dsl/query"
-    require_relative "dsl/response"
-    require_relative "dsl/responses"
-    require_relative "dsl/security"
-    require_relative "dsl/verifier"
-    require_relative "dsl/operation"
-    require_relative "dsl/operations"
-    require_relative "dsl/scope"
-
-    # Adds [#operations] to a specific client's instances
-    def self.extended(klass)
-      klass.include Dry::Initializer.define -> do
-        param :settings
-        param :base_url
-        param :operations
-      end
-    end
-
-    # Helper to define params and options a for a client's constructor
-    #
-    # @example
-    #   class MyClient < Evil::Client
-    #   end
-    #
-    #   MyClient.new "https://foo.com", user: "bar", token: "baz"
-    #
-    # @param  [Proc] block
-    # @return [self]
-    #
-    def settings(&block)
-      return self unless block
-      schema[:settings] = Class.new { include Dry::Initializer.define(&block) }
-      self
-    end
-
-    # Helper to define base url of the server
-    #
-    # @param [#to_s] value
-    # @return [self]
-    #
-    def base_url(&block)
-      return self unless block
-      schema[:base_url] = block
-      self
-    end
-
-    # Helper specify a connection to be used by a client
-    #
-    # @param  [#to_sym] type (nil)
-    #   The specific type of connection. Uses NetHTTP by default.
-    # @return [self]
-    #
-    def connection(type = nil, &block)
-      schema[:connection] = Connection[type]
-      schema[:middleware] = Middleware.new(&block)
-      self
-    end
-
-    # Helper to declare operation, either default or specific
-    #
-    # @param  [#to_sym] name (nil)
-    # @param  [Proc] block
-    # @return [self]
-    #
-    def operation(name = nil, &block)
-      schema[:operations].register(name, &block)
-      self
-    end
-
-    # Helper to define scopes of the client's top-level DSL
-    #
-    # @param  [#to_sym] name (:[])
-    # @param  [Proc] block
-    # @return [self]
-    #
-    def scope(name = :[], &block)
-      klass = Class.new(Scope, &block)
-      define_method(name) do |*args, **options|
-        klass.new(*args, __scope__: self, **options)
-      end
-      self
-    end
-
-    # Takes constructor arguments and builds a final schema for an instance
-    # (All the instantiation magics goes here)
-    #
-    # @param  [Object] *args
-    # @return [Hash<Symbol, Object>]
-    #
-    def new(*args)
-      settings   = schema[:settings].new(*args)
-      base_url   = schema[:base_url].call(settings)
-      middleware = schema[:middleware].finalize(settings)
-      operations = schema[:operations].finalize(settings)
-      client     = schema[:connection].new URI(base_url)
-      connection = Middleware.prepend.(middleware.(Middleware.append.(client)))
-
-      data = operations.each_with_object({}) do |(key, schema), hash|
-        hash[key] = Evil::Client::Operation.new schema, connection
-      end
-
-      super(settings, base_url, data)
-    end
-
-    private
-
-    BASE_URL = proc { raise NotImplementedError.new "Base url is not defined" }
-
-    def schema
-      @schema ||= {
-        settings:   Class.new,
-        base_url:   BASE_URL,
-        connection: Connection[nil],
-        middleware: Middleware.new,
-        operations: Operations.new
-      }
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module Evil::Client::DSL
-  class Base
-    def self.[](schema, *args, &block)
-      new(*args, &block).call(schema)
-    end
-
-    def call(schema)
-      schema
-    end
-
-    private
-
-    def merge(source, target)
-      target.inject(source) do |obj, (key, val)|
-        obj.merge key => (Hash === val ? merge(obj.fetch(key, {}), val) : val)
-      end
-    end
-
-    def coercer
-      @coercer ||= if    @model && @block then Class.new(@model, &@block)
-                   elsif @block           then Class.new(Evil::Struct, &@block)
-                   elsif @model           then @model
-                   end
-    end
-  end
-end

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

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