evil-client 0.3.3 → 1.0.0

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

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

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

@@ -1,20 +0,0 @@
-class Evil::Client::Middleware
-  class MergeSecurity < Base
-    def call(env, schema, options)
-      super build(env), schema, options
-    end
-
-    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

@@ -1,17 +0,0 @@
-class Evil::Client::Middleware
-  class NormalizeHeaders < Base
-    def call(env, schema, options)
-      super build(env), schema, options
-    end
-
-    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

@@ -1,40 +0,0 @@
-class Evil::Client::Middleware
-  class StringifyForm < Base
-    def call(env, schema, options)
-      super build(env), schema, options
-    end
-
-    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

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

@@ -1,19 +0,0 @@
-class Evil::Client::Middleware
-  class StringifyJson < Base
-    def call(env, schema, options)
-      super build(env), schema, options
-    end
-
-    private
-
-    def build(env)
-      return env unless env[:format] == "json"
-
-      env.dup.tap do |hash|
-        hash[:headers] ||= {}
-        hash[:headers]["content-type"] = "application/json"
-        hash[:body_string] = JSON.generate(env[:body].to_h)
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-class Evil::Client::Middleware
-  class StringifyMultipart < Base
-    require_relative "stringify_multipart/part"
-
-    def call(env, schema, options)
-      super build(env), schema, options
-    end
-
-    private
-
-    def build(env)
-      return env unless env[:format] == "multipart"
-
-      env.dup.tap do |hash|
-        bound = SecureRandom.hex(10)
-        hash[:headers] ||= {}
-        hash[:headers]["content-type"] = \
-          "multipart/form-data; boundary=#{bound}"
-        hash[:body_string] = body_string(hash[:files], bound)
-      end
-    end
-
-    def body_string(list, bound)
-      return if list.empty?
-      [nil, nil, parts(list, bound), "--#{bound}--", nil].join("\r\n")
-    end
-
-    def parts(list, bound)
-      list.map.with_index { |item, index| part(bound, index + 1, item) }
-    end
-
-    def part(bound, index, data)
-      "--#{bound}\r\n#{Part.new(name: "AttachedFile#{index}", **data)}"
-    end
-  end
-end

data/lib/evil/client/middleware/stringify_multipart/part.rb

@@ -1,36 +0,0 @@
-class Evil::Client::Middleware::StringifyMultipart
-  # Takes a file with its options and builds a part of multipart body
-  class Part
-    extend Dry::Initializer::Mixin
-    option :file
-    option :type,     default: proc { MIME::Types["text/plain"].first }
-    option :charset,  default: proc { "utf-8" }
-    option :name,     default: proc { "AttachedFile" }
-    option :filename, default: proc { default_filename }
-
-    def to_s
-      [content_disposition, content_type, nil, content].join("\r\n")
-    end
-
-    private
-
-    def default_filename
-      return Pathname.new(file.path).basename if file.respond_to? :path
-      "#{SecureRandom.hex(10)}.#{type.preferred_extension}"
-    end
-
-    def content_disposition
-      "Content-Disposition: form-data;" \
-      " name=\"#{name}\";" \
-      " filename=\"#{filename}\""
-    end
-
-    def content_type
-      "Content-Type: #{type}; charset=#{charset}"
-    end
-
-    def content
-      file.respond_to?(:read) ? file.read : file
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-class Evil::Client::Middleware
-  class StringifyQuery < Base
-    def call(env, schema, options)
-      super build(env), schema, options
-    end
-
-    private
-
-    def build(env)
-      return env if env&.fetch(:query, nil).to_h.empty?
-      string = env[:query].flat_map { |key, val| normalize(val, key) }
-                          .flat_map { |hash| stringify(hash) }
-                          .join("&")
-
-      env.merge(query_string: string)
-    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

data/lib/evil/client/operation.rb

@@ -1,34 +0,0 @@
-class Evil::Client
-  # Carries a final schema for a single operation along with shared connection,
-  # and uses it to send requests to the server
-  class Operation
-    require_relative "operation/request"
-    require_relative "operation/response"
-
-    extend Dry::Initializer::Mixin
-    param :schema
-    param :connection
-
-    # Builds and sends a request and returns a response proccessed by schema
-    #
-    # @param  [IO, nil] file
-    # @param  [Hash<Symbol, Object>] options
-    # @return [Object]
-    #
-    def call(**options)
-      env   = request.build(options)
-      array = connection.call(env, schema, options)
-      response.handle(array)
-    end
-
-    private
-
-    def request
-      @request ||= Request.new(schema)
-    end
-
-    def response
-      @response ||= Response.new(schema)
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-class Evil::Client::Operation
-  # Builds a request env from user options by applying schema validations
-  class Request
-    extend Dry::Initializer::Mixin
-    param :schema
-
-    # Builds an env
-    #
-    # @param  [IO, nil] file (nil)
-    # @param  [Hash<Symbol, Object>] options
-    # @return [Hash]
-    #
-    def build(options)
-      {
-        format:      schema[:format],
-        http_method: schema[:method].call(options),
-        path:        schema[:path].call(options),
-        security:    schema[:security]&.call(options),
-        files:       schema[:files]&.call(options),
-        query:       schema[:query]&.new(options).to_h,
-        body:        schema[:body]&.new(options).to_h,
-        headers:     schema[:headers]&.new(options).to_h
-      }
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-class Evil::Client::Operation
-  require_relative "response_error"
-  require_relative "unexpected_response_error"
-
-  # Processes rack responses using an operation's schema
-  class Response
-    extend Dry::Initializer::Mixin
-    param :schema
-
-    # Processes rack responses returned by [Dry::Cluent::Connection]
-    #
-    # @param  [Array] array Rack-compatible array of response data
-    # @return [Object]
-    #
-    # @raise [Evil::Client::ResponseError] when needed by the schema
-    # @raise [Evil::Client::UnexpectedResponseError]
-    #   when a response cannot be processed
-    #
-    def handle(response)
-      status, _, body = response
-      body = body.any? ? body.join("\n") : nil
-
-      handlers(status).each do |handler|
-        data = handler[:coercer][body] rescue next
-        raise ResponseError.new(schema, status, data) if handler[:raise]
-        return data
-      end
-
-      raise UnexpectedResponseError.new(schema, status, body)
-    end
-
-    private
-
-    def handlers(status)
-      list = schema[:responses].values.select { |item| item[:status] == status }
-      list.reject { |item| item[:raise] } + list.select { |item| item[:raise] }
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-class Evil::Client::Operation
-  class ResponseError < RuntimeError
-    attr_reader :status, :data
-
-    private
-
-    def initialize(schema, status, data)
-      @status = status
-      @data   = data
-      super "Response to operation '#{schema[:key]}' has http status #{status}"
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-class Evil::Client::Operation
-  class UnexpectedResponseError < RuntimeError
-    attr_reader :status, :data
-
-    private
-
-    def initialize(schema, status, data)
-      @status = status
-      @data   = data
-
-      message = "Response to operation '#{schema[:key]}'" \
-                " with http status #{status} and body #{data}" \
-                " cannot be processed."
-      message << " See #{schema[:doc]} for details." if schema[:doc]
-
-      super message
-    end
-  end
-end

data/spec/features/instantiation_spec.rb

@@ -1,68 +0,0 @@
-RSpec.describe "instantiation" do
-  # see Test::Client definition in `/spec/support/test_client.rb`
-  let(:client)    { Test::Client.new subdomain, options }
-  let(:subdomain) { "foo" }
-  let(:options)   { { version: 3, user: "bar", password: "baz", token: "qux" } }
-
-  context "with valid settings:" do
-    it "is accepted" do
-      expect(client).to be_kind_of Test::Client
-    end
-  end
-
-  context "with settings that still conforms to contract:" do
-    let(:options) { { user: "bar" } }
-
-    it "is accepted" do
-      expect(client).to be_kind_of Test::Client
-    end
-  end
-
-  context "with unexpected param settings:" do
-    let(:client) { Test::Client.new(subdomain, subdomain, **options) }
-
-    it "is rejected" do
-      expect { client }.to raise_error(ArgumentError)
-    end
-  end
-
-  context "with missing param settings:" do
-    let(:client) { Test::Client.new(**options) }
-
-    it "is rejected" do
-      expect { client }.to raise_error(StandardError)
-    end
-  end
-
-  context "with a broken contract for param:" do
-    let(:subdomain) { 1 }
-
-    it "is rejected" do
-      expect { client }.to raise_error(TypeError)
-    end
-  end
-
-  context "with unexpected option settings:" do
-    before { options[:foo] = "bar" }
-
-    it "is accepted" do
-      expect { client }.not_to raise_error
-    end
-  end
-
-  context "with missing option settings:" do
-    before { options.delete :user }
-
-    it "is rejected" do
-      expect { client }.to raise_error(ArgumentError)
-    end
-  end
-
-  context "with a broken contract for option:" do
-    before { options[:user] = 1 }
-
-    it "is rejected" do
-      expect { client }.to raise_error(TypeError)
-    end
-  end
-end

data/spec/features/middleware_spec.rb

@@ -1,79 +0,0 @@
-RSpec.describe "middleware" do
-  before do
-    class Test::UpdateRequest
-      def initialize(app)
-        @app = app
-      end
-
-      def call(_env, schema, options)
-        env = {
-          path: "data/1",
-          http_method: "get",
-          format: "form",
-          headers: { "baz" => "BAZ" },
-          query: { "bar" => "baz" },
-          body: { "qux" => 2 }
-        }
-
-        @app.call env, schema, options
-      end
-    end
-
-    class Test::UpdateResponse
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env, *params)
-        response = @app.call(env, *params)
-        response[2] = ["Hi!"]
-        response
-      end
-    end
-
-    class Test::Client < Evil::Client
-      connection do |settings|
-        run Test::UpdateRequest
-        run Test::UpdateResponse if settings.version > 2
-      end
-
-      operation :find do
-        path { "some" }
-        http_method :post
-        response :success, 200, format: :plain
-      end
-    end
-
-    stub_request(:any, //)
-  end
-
-  it "updates requests" do
-    request = a_request(:get, "https://foo.example.com/api/v3/data/1?bar=baz")
-      .with do |req|
-        expect(req.body).to eq "qux=2"
-        expect(req.headers).to include "Baz" => "BAZ"
-      end
-
-    Test::Client.new("foo", version: 3, user: "bar").operations[:find].call
-
-    expect(request).to have_been_made
-  end
-
-  it "updates responses" do
-    response = \
-      Test::Client.new("foo", version: 3, user: "bar")
-      .operations[:find]
-      .call
-
-    expect(response).to eq "Hi!"
-  end
-
-  it "depends on settings" do
-    response = \
-      Test::Client.new("foo", version: 1, user: "bar")
-      .operations[:find]
-      .call
-
-    expect(response).to be_nil
-  end
-end