eezee 1.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '091f04a358ff0034437fb934f267c82e74ee10109c3f9f9a89625e3cbcb464bf'
+  data.tar.gz: 413ad4f550a63cfebd4e688181369264a423f26bfa8fc2b3e1496b3c5552978c
+SHA512:
+  metadata.gz: cb1b44f8219ba5bca6b40703c066f3c3da4ff681ac5cd005599866389d9a30bccdc7b52a2e708da8fd99d8adb0846280f3d71c07a30387671a9db2b98738e331
+  data.tar.gz: 89eef48f82b9a9cd284e2332cdfc2de54a187624c961ae7f8600bbed90e6b68f8f439f6930856e30d19298ed575969531987cb70fa1df513a65cd4e335e8c111

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 Linqueta
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,282 @@
+# [Eezee][gem_page]
+
+[![Gem Version][gem_version_image]][gem_version_page]
+[![Build Status][travis_status_image]][travis_page]
+[![Maintainability][code_climate_maintainability_image]][code_climate_maintainability_page]
+[![Test Coverage][code_climate_test_coverage_image]][code_climate_test_coverage_page]
+
+The easiest HTTP client for Ruby
+
+With Eezee you can do these things:
+  * Define external services in an initializer file and use them through a simple method
+  * Take HTTP requests just extending a module and call the HTTP request method in your class/module
+  * Set before and after hooks to handle your requests, responses, and errors
+  * Handle all requests, responses, and errors in the same way
+  * Log the request, response, and errors
+  * Set general request timeout and open connection timeout
+  * Raise errors in failed requests
+  * Spend more time coding your API integrations instead defining and testing HTTP settings and clients
+
+This gem is supported for Ruby 2.6+ applications
+
+## Table of Contents
+- [Getting started](#getting-started)
+  - [Installation](#installation)
+  - [Supported HTTP Methods](#supported-http-methods)
+  - [How to take a request](#how-to-take-a-request)
+  - [Request options](#request-options)
+    - [Available Request options](#available-request-options)
+  - [Services](#services)
+    - [How a service works](#how-a-service-works)
+  - [Request](#response)
+  - [Response](#response)
+  - [Errors](#errors)
+  - [Examples](#examples)
+    - [Complete integrations](#complete-integrations)
+    - [Hooks](#hooks)
+    - [Timeout](#timeout)
+    - [Logging](#logging)
+- [Why use Eezee instead Faraday](#why-use-eezee-instead-faraday)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Getting started
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'eezee'
+```
+
+If you're on Rails you can run this line below to create the initializer:
+
+```shell
+rails generator eezee:install
+```
+
+### Supported HTTP Methods
+
+Eezee supports these HTTP methods:
+
+- GET
+- POST
+- PATCH
+- PUT
+- DELETE
+
+And here are the corresponding Eezee's HTTP methods:
+
+- get(request_options)
+- post(request_options)
+- patch(request_options)
+- put(request_options)
+- delete(request_options)
+
+OBS: The param `request_options` is optional.
+
+### How to take a request
+
+To take a request using any of these methods you just have to call the HTTP method, and if you want, you can pass the options.
+
+```ruby
+module RickMorty::Resource::Character
+  extend Eezee::Client
+
+  def self.index
+    get(url: 'rickandmortyapi.com/api', protocol: :https, path: 'character')
+  end
+
+  def self.find(id)
+    get(
+      url: 'rickandmortyapi.com/api',
+      protocol: :https,
+      path: 'character/:character_id',
+      params: { character_id: id }
+    )
+  end
+
+  def self.create(payload)
+    post(
+      url: 'rickandmortyapi.com/api',
+      protocol: :https,
+      path: 'character',
+      payload: payload
+    )
+  end
+
+  def self.update(id, payload)
+    post(
+      url: 'rickandmortyapi.com/api',
+      protocol: :https,
+      path: 'character/:character_id',
+      params: { character_id: id }
+      payload: payload
+    )
+  end
+
+  def self.destroy(id)
+    delete(
+      url: 'rickandmortyapi.com/api',
+      protocol: :https,
+      path: 'character/:character_id',
+      params: { character_id: id }
+    )
+  end
+```
+
+### Request options
+
+Request options are the request settings. They can be used to define services, request options and as a param when you take the HTTP request. For example:
+
+```ruby
+module RickMorty::Resource::Character
+  extend Eezee::Client
+
+  eezee_request_options protocol: :https,
+                             url: 'rickandmortyapi.com/api'
+                             path: 'character/:character_id'
+
+  def self.index
+    get
+  end
+
+  def self.find(id)
+    get(params: { character_id: id })
+  end
+
+  def self.update(id, payload)
+    put(
+      params: { character_id: id },
+      payload: payload,
+      after: ->(_req, res) { do_something!(res) }
+    )
+  end
+end
+```
+
+The method `eezee_request_options` can receive all of [Available Request options](#available-request-options).
+
+When the HTTP methods were called, Eezee has created a Request setting with the options defined in the module and merge with the options passed as a param in the HTTP methods.
+
+#### Available Request options
+
+Here are the list of available options and about them:
+
+| Option | Required | Default | What is it? | Example |
+|--------|----------|---------|-------------|---------|
+| `url` | Yes | `nil` | The request's url | `"rickandmortyapi.com/api"` |
+| `protocol` | No | `nil` | The request's protocol | `:https` |
+| `path` | No | `nil` | The resource's path | `"characters\:characted_id\addresses"` |
+| `headers` | No | `{}` | The request's headers. | `{ Token: "Bearer 1a8then..." }` |
+| `params` | No | `{}` | The query params. If the url or path has a nested param like `:character_id` and you pass it in the hash, this value will be replaced. In the opposite, the value will be concatenated in the url like `...?character_id=10&...`| `{ character_id: 10 }`|
+| `payload` | No | `{}` | The request's payload | `{ name: "Linqueta", gender: "male" }` |
+| `before` | No | `nil` | It's the before hook. You can pass Proc or Lambda to handle the request settings. See more in [Hooks](#hooks).  | `->(req) { merge_new_headers! }` |
+| `after` | No | `nil` | It's the after hook. You can pass Proc or Lambda to handle the request settings, response or error after the request. If it returns a valid value (different of false or `nil`) and the request raises an error, the error won't be raised to your application. See more in [Hooks](#hooks). | `->(req, res, err) { do_something! }` |
+| `timeout` | No | `nil` | If it exceeds this timeout to make whole request Eezee will raise the error `Eezee::TimeoutError` | `5` |
+| `open_timeout` | No | `nil` | If it exceed this timeout to open a connection Eezee will raise the error `Eezee::TimeoutError` | `2` |
+| `raise_error` | No | `false` | If you want that Eezee raises an error if the request has wasn't successful. See more in [Errors](#errors) | `true` |
+| `logger` | No | `false` | If you want to log the request, response, and error | `true` |
+
+### Services
+
+It's common your app has integrations with many external services and this gem has a feature to organize in one file the settings of these external service integrations and it provides an easy way to get these settings.
+
+For example, I will integrate with [Rick and Morty Api](https://rickandmortyapi.com/api/) using a service:
+
+- I'll declare it in an initializer file:
+
+```ruby
+Eezee.configure do |config|
+  config.add_service :rick_morty_api,
+                     protocol: :https,
+                     url: 'rickandmortyapi.com/api'
+end
+```
+
+- In my resource, I'll catch the service and pass other settings:
+
+```ruby
+module RickMorty::Resource::Character
+  extend Eezee::Client
+
+  eezee_service :rick_morty_api
+  eezee_request_options path: 'character/:character_id'
+
+  def self.index
+    get
+  end
+
+  def self.find(id)
+    get(params: { character_id: id })
+  end
+end
+```
+
+#### How a service works
+
+When Ruby loads a class/module and it has the method `eezee_service` declared with a service's name, by default, Eezee will try load the service and create a request base for the class/module, so, when the class/module takes a request, Eezee will create the final request instance based on request base to take the HTTP request. You can turn it lazy setting the option `lazy: true`, therefore, the final request will be created just in the HTTP request. If the service doesn't exist when Eezee search about it, it will be raised the error `Eezee::Client::UnknownService`.
+
+About the method `add_service`, you can pass all of [Available Request options](#available-request-options). The meaning of this part is to organize in one way the external services integrations.
+
+### Request
+
+Coming soon...
+
+### Response
+
+Coming soon...
+
+### Errors
+
+Coming soon...
+
+### Examples
+
+Here are some examples:
+
+#### Complete integrations
+
+Coming soon...
+
+#### Hooks
+
+Coming soon...
+
+#### Timeout
+
+Coming soon...
+
+#### Logging
+
+Coming soon...
+
+## Why use Eezee instead Faraday
+
+Coming soon...
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (git checkout -b my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin my-new-feature)
+5. Create new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License][mit_license_page].
+
+[gem_page]: https://github.com/linqueta/eezee
+[code_of_conduct_page]: https://github.com/linqueta/eezee/blob/master/CODE_OF_CONDUCT.md
+[mit_license_page]: https://opensource.org/licenses/MIT
+[contributor_convenant_page]: http://contributor-covenant.org
+[travis_status_image]: https://travis-ci.org/linqueta/eezee.svg?branch=master
+[travis_page]: https://travis-ci.org/linqueta/eezee
+[code_climate_maintainability_image]: https://api.codeclimate.com/v1/badges/b3ae18295c290b6a92a9/maintainability
+[code_climate_maintainability_page]: https://codeclimate.com/github/linqueta/eezee/maintainability
+[code_climate_test_coverage_image]: https://api.codeclimate.com/v1/badges/b3ae18295c290b6a92a9/test_coverage
+[code_climate_test_coverage_page]: https://codeclimate.com/github/linqueta/eezee/test_coverage
+[gem_version_image]: https://badge.fury.io/rb/eezee.svg
+[gem_version_page]: https://rubygems.org/gems/eezee

data/lib/eezee/client/builder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Eezee
+  module Client
+    class UnknownService < StandardError; end
+
+    module Builder
+      def self.extended(base)
+        base.send(:build_eezee_options)
+        base.send(:build_eezee_request_attributes)
+        base.eezee_options
+      end
+
+      def eezee_request_options(options)
+        build_eezee_request_options(options)
+      end
+
+      def eezee_service(name, options = {})
+        build_eezee_service(name, { lazy: false }.merge(options || {}))
+      end
+
+      private
+
+      def build_eezee_options
+        define_singleton_method(:eezee_options) { @eezee_options ||= {} }
+      end
+
+      def build_eezee_request_options(options = {})
+        eezee_options[:request_options] ||= options
+        build_eezee_request
+      end
+
+      def build_eezee_service(name = nil, options = {})
+        eezee_options[:service_name] ||= name
+        eezee_options[:service_options] ||= options
+        build_eezee_request
+      end
+
+      def build_eezee_request(force = false)
+        Eezee.configuration
+             .find_service(eezee_options[:service_name])
+             .then { |service| handle_unknown_service!(service, force) }
+             .then { |service| create_request(service, force) }
+             .then { |request| eezee_options[:request] = request }
+             .then { build_eezee_request_attributes }
+      end
+
+      def build_eezee_request_attributes
+        define_singleton_method(:eezee_request_attributes) { eezee_options&.[](:request)&.attributes || {} }
+      end
+
+      def handle_unknown_service!(service, force)
+        return unless take_request?(force)
+        raise UnknownService if !service && eezee_options[:service_name]
+
+        service
+      end
+
+      def take_request?(force)
+        !eezee_options.dig(:service_options, :lazy) || force
+      end
+
+      def create_request(service, force)
+        return unless take_request?(force)
+
+        Eezee.configuration.request_by(service, eezee_options[:request_options])
+      end
+    end
+  end
+end

data/lib/eezee/client/requester.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+module Eezee
+  module Client
+    module Requester
+      METHODS = %i[get post patch put delete].freeze
+
+      def self.extended(base)
+        METHODS.each do |method|
+          base.send(
+            :define_singleton_method,
+            method,
+            ->(options = {}) { eezee_client_request(options, method) }
+          )
+        end
+      end
+
+      def eezee_client_request(options, method)
+        request = build_final_request(options, method)
+
+        build_faraday_client(request)
+          .then { |client| build_faraday_request(request, client, method) }
+          .then { |response| Eezee::Response.new(response) }
+          .tap  { |response| response.log if request.logger }
+          .tap  { |response| request.after!(request, response, nil) }
+      rescue Faraday::Error => e
+        response = Eezee::Response.new(e)
+        error = Eezee::RequestErrorFactory.build(response)
+        error.log if request.logger
+        return response if rescue_faraday_error?(request, response, error)
+
+        raise error
+      end
+
+      def build_final_request(options, method)
+        build_eezee_request_lazy
+
+        Eezee.configuration
+             .request_by(eezee_options[:request], options)
+             .tap do |request|
+          request.before!(request)
+          request.method = method
+          request.log if request.logger
+        end
+      end
+
+      def build_eezee_request_lazy
+        return unless eezee_options.dig(:service_options, :lazy)
+
+        build_eezee_request(true)
+      end
+
+      def rescue_faraday_error?(req, res, err)
+        req.after!(req, res, err) || (err.is_a?(Eezee::TimeoutError) && !req.raise_error)
+      end
+
+      def build_faraday_request(req, client, method)
+        client.send(method) do |faraday_req|
+          faraday_req.body = req.payload.to_json if req.payload
+        end
+      end
+
+      def build_faraday_client(request)
+        Faraday.new(request.uri) do |config|
+          config.use(Faraday::Response::RaiseError) if request.raise_error
+          config.headers = request.headers if request.headers
+          config.options[:open_timeout] = request.open_timeout if request.open_timeout
+          config.options[:timeout] = request.timeout if request.timeout
+          config.adapter(Faraday.default_adapter)
+        end
+      end
+    end
+  end
+end

data/lib/eezee/client.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'client/builder'
+require_relative 'client/requester'
+
+module Eezee
+  module Client
+    def self.extended(base)
+      base.send(:extend, Builder)
+      base.send(:extend, Requester)
+    end
+  end
+end

data/lib/eezee/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Eezee
+  class Configuration
+    attr_reader :services
+
+    def initialize
+      @services = {}
+    end
+
+    def add_service(name, options)
+      return unless name && options
+
+      @services[name] = Request.new(options)
+    end
+
+    def find_service(name)
+      @services[name]
+    end
+
+    def request_by(request, options)
+      Request.new((request&.attributes || {}).merge(options || {}))
+    end
+  end
+end

data/lib/eezee/errors/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Eezee
+  class Error < StandardError
+  end
+end

data/lib/eezee/errors/request_error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Eezee
+  class RequestError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super(build_message)
+    end
+
+    def log
+      Eezee::Logger.error(self)
+    end
+
+    private
+
+    def build_message
+      "CODE: #{@response.code} - BODY: #{@response.body.to_json}"
+    end
+  end
+
+  class BadRequestError < RequestError; end
+  class UnauthorizedError < RequestError; end
+  class ForbiddenError < RequestError; end
+  class ResourceNotFoundError < RequestError; end
+  class UnprocessableEntityError < RequestError; end
+  class ClientError < RequestError; end
+  class InternalServerError < RequestError; end
+  class ServiceUnavailableError < RequestError; end
+  class ServerError < RequestError; end
+end

data/lib/eezee/errors/required_field_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Eezee
+  class RequiredFieldError < StandardError
+    attr_reader :origin, :field
+
+    def initialize(origin, field)
+      @origin = origin
+      @field = field
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      "The field #{@field} is required for #{@origin}"
+    end
+  end
+end

data/lib/eezee/errors/timeout_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Eezee
+  class TimeoutError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super(response.original)
+    end
+
+    def log
+      Eezee::Logger.error(self)
+    end
+  end
+end

data/lib/eezee/errors.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'errors/error'
+require_relative 'errors/timeout_error'
+require_relative 'errors/required_field_error'
+require_relative 'errors/request_error'

data/lib/eezee/logger.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Eezee
+  module Logger
+    module_function
+
+    def request(req, method)
+      p log("request: #{method} #{req.uri}")
+      p log("request: HEADERS: #{req.headers&.to_json}") if req.headers
+      p log("request: PAYLOAD: #{req.payload&.to_json}") if req.payload
+      nil
+    end
+
+    def response(res)
+      p log("response: SUCCESS: #{res.success?}")
+      p log("response: TIMEOUT: #{res.timeout?}")
+      p log("response: CODE: #{res.code}")
+      p log("response: BODY: #{res.body&.to_json}")
+    end
+
+    def error(err)
+      p log("error: #{err.class}")
+      p log("error: SUCCESS: #{err.response.success?}")
+      p log("error: TIMEOUT: #{err.response.timeout?}")
+      p log("error: CODE: #{err.response.code}")
+      p log("error: BODY: #{err.response.body&.to_json}")
+    end
+
+    def log(message)
+      "INFO -- #{message}"
+    end
+  end
+end

data/lib/eezee/request.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Eezee
+  class Request
+    ACCESSORS = %i[
+      after
+      before
+      headers
+      logger
+      open_timeout
+      params
+      path
+      payload
+      protocol
+      raise_error
+      timeout
+      url
+    ].freeze
+
+    DEFAULT = {
+      headers: {},
+      logger: false,
+      params: {},
+      payload: {},
+      raise_error: false
+    }.freeze
+
+    attr_accessor(*(ACCESSORS | %i[uri method]))
+
+    def initialize(options = {})
+      setup!(options)
+    end
+
+    def log
+      Eezee::Logger.request(self, @method.to_s.upcase)
+    end
+
+    def attributes
+      ACCESSORS.each_with_object({}) { |accessor, obj| obj[accessor] = send(accessor) }
+    end
+
+    def before!(*params)
+      hook!(:before, params)
+    end
+
+    def after!(*params)
+      hook!(:after, params)
+    end
+
+    private
+
+    def setup!(options = {})
+      accessors!(DEFAULT.merge(options || {}))
+      validate!
+      build_urn!
+      handle_query_params!
+      handle_urn_params!
+    end
+
+    def hook!(hook, params)
+      return unless send(hook)&.is_a?(Proc)
+
+      send(hook).call(*params[0..(send(hook).parameters.length - 1)])
+    end
+
+    def validate!
+      raise Eezee::RequiredFieldError.new(self.class, :url) unless @url
+    end
+
+    def accessors!(params)
+      params.slice(*ACCESSORS)
+            .each { |k, v| instance_variable_set("@#{k}", v) }
+    end
+
+    def build_urn!
+      @uri = [@protocol, [@url, @path].compact.join('/')].compact.join('://')
+    end
+
+    def handle_urn_params!
+      return unless @params.is_a?(Hash)
+
+      @params.filter { |k, _v| @uri.include?(":#{k}") }
+             .each   { |k, v|  @uri.gsub!(":#{k}", v.to_s) }
+             .then   { @uri.gsub!(/:[a-z_-]+/, '') }
+    end
+
+    def handle_query_params!
+      return unless @params.is_a?(Hash)
+
+      @params.reject { |k, _v| @uri.include?(":#{k}") }
+             .map    { |k, v|  "#{k}=#{v}" }
+             .then   { |array| array.join('&') }
+             .then   { |query| query unless query.empty? }
+             .then   { |query| @uri = [@uri, query].compact.join('?') }
+    end
+  end
+end

data/lib/eezee/request_error_factory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Eezee
+  class RequestErrorFactory
+    class << self
+      def build(response)
+        return TimeoutError.new(response) if response.timeout?
+
+        find_by_code(response.code).new(response)
+      end
+
+      private
+
+      def find_by_code(code)
+        case code
+        when 400      then BadRequestError
+        when 401      then UnauthorizedError
+        when 403      then ForbiddenError
+        when 404      then ResourceNotFoundError
+        when 422      then UnprocessableEntityError
+        when 400..499 then ClientError
+        when 500      then InternalServerError
+        when 503      then ServiceUnavailableError
+        when 500..599 then ServerError
+        else
+          RequestError
+        end
+      end
+    end
+  end
+end

data/lib/eezee/response.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'faraday'
+
+module Eezee
+  class Response
+    attr_reader :original
+
+    def initialize(original)
+      @original = original
+    end
+
+    def body
+      return {} if timeout?
+
+      @body ||= parsed_body
+    end
+
+    def success?
+      return false if timeout?
+
+      @success ||= success_response? && @original&.success?
+    end
+
+    def code
+      return if timeout?
+
+      @code ||= success_response? ? @original.status : @original.response[:status]
+    end
+
+    def timeout?
+      @original.is_a?(Faraday::TimeoutError) ||
+        @original.is_a?(Net::ReadTimeout)    ||
+        @original.is_a?(Faraday::ConnectionFailed)
+    end
+
+    def log
+      Eezee::Logger.response(self)
+    end
+
+    private
+
+    def parsed_body
+      JSON.parse(handled_faraday_response, symbolize_names: true)
+    end
+
+    def success_response?
+      @original.is_a?(Faraday::Response)
+    end
+
+    def handled_faraday_response
+      faraday_response.nil? || faraday_response.empty? ? '{}' : faraday_response
+    end
+
+    def faraday_response
+      success_response? ? @original.body : @original.response[:body]
+    end
+  end
+end

data/lib/eezee/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Eezee
+  VERSION = '1.0.7'
+end

data/lib/eezee.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'eezee/version'
+require 'eezee/errors'
+require 'eezee/request'
+require 'eezee/response'
+require 'eezee/request_error_factory'
+require 'eezee/logger'
+require 'eezee/configuration'
+require 'eezee/client'
+
+module Eezee
+  class << self
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+end

data/lib/generators/katinguele/install_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module Eezee
+  class InstallGenerator < Rails::Generators::Base
+    def create_initializer_file
+      create_file(
+        'config/initializers/eezee.rb',
+        <<~KATINGUELE_INITIALIZER_TEXT
+          # frozen_string_literal: true
+
+          Eezee.configure do |config|
+            # You can add your service's configuration, like:
+
+            # config.add_service :external_service_1,
+            #                    raise_error: true,
+            #                    url: ENV['EXTERNAL_SERVICE_URL_1'],
+            #                    headers: { 'Content-Type' => 'application/json' }
+
+            # config.add_service :external_service_2,
+            #                    raise_error: false,
+            #                    url: ENV['EXTERNAL_SERVICE_URL_2'],
+            #                    headers: { 'Token' => "#Token {ENV['EXTERNAL_SERVICE_TOKEN']}"}
+
+            # All available options is on README
+          end
+        KATINGUELE_INITIALIZER_TEXT
+      )
+    end
+  end
+end

metadata

@@ -0,0 +1,283 @@
+--- !ruby/object:Gem::Specification
+name: eezee
+version: !ruby/object:Gem::Version
+  version: 1.0.7
+platform: ruby
+authors:
+- linqueta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.1
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.74.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.74'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.74.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.74'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.7.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.7.6
+description: A library to execute HTTP request in an easy way
+email:
+- lincolnrodrs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/eezee.rb
+- lib/eezee/client.rb
+- lib/eezee/client/builder.rb
+- lib/eezee/client/requester.rb
+- lib/eezee/configuration.rb
+- lib/eezee/errors.rb
+- lib/eezee/errors/error.rb
+- lib/eezee/errors/request_error.rb
+- lib/eezee/errors/required_field_error.rb
+- lib/eezee/errors/timeout_error.rb
+- lib/eezee/logger.rb
+- lib/eezee/request.rb
+- lib/eezee/request_error_factory.rb
+- lib/eezee/response.rb
+- lib/eezee/version.rb
+- lib/generators/katinguele/install_generator.rb
+homepage: https://github.com/linqueta/eezee
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: The easiest HTTP client for Ruby
+test_files: []