katinguele 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a7b498b556a8424590d12b89c02c985ac20036b58fcc0d8ddc47e7fd1f92695
+  data.tar.gz: e948c99ede332cb2b4a87869a3b0206ff660b3038d3d7c1d3d250dadf1c91f08
+SHA512:
+  metadata.gz: 063c0c04b98717d45b2dd7ac324942f215458638a99da5fc5e17b85869da8c51cc6ffc642635d8b8b4399f81f0908cf6d2367a5b53e91d69f7153875c850e872
+  data.tar.gz: '0686ee7f583eaba9f5f5cb4a848cf13faabaeb113a585b0edb542e584606d0caad750d8ba35b1b6ac8ee170be01f58883daa46d3cf0592bb674fae1c16973df7'

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,41 @@
+# [Katinguele][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
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'katinguele'
+```
+
+## 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/katinguele
+[code_of_conduct_page]: https://github.com/linqueta/katinguele/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/katinguele.svg?branch=master
+[travis_page]: https://travis-ci.org/linqueta/katinguele
+[code_climate_maintainability_image]: https://api.codeclimate.com/v1/badges/2b9a2174ac460c3f44ad/maintainability
+[code_climate_maintainability_page]: https://codeclimate.com/github/linqueta/katinguele/maintainability
+[code_climate_test_coverage_image]: https://api.codeclimate.com/v1/badges/2b9a2174ac460c3f44ad/test_coverage
+[code_climate_test_coverage_page]: https://codeclimate.com/github/linqueta/katinguele/test_coverage
+[gem_version_image]: https://badge.fury.io/rb/katinguele.svg
+[gem_version_page]: https://rubygems.org/gems/katinguele

data/lib/generators/katinguele/install_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module Katinguele
+  class InstallGenerator < Rails::Generators::Base
+    def create_initializer_file
+      create_file(
+        'config/initializers/katinguele.rb',
+        <<~KATINGUELE_INITIALIZER_TEXT
+          # frozen_string_literal: true
+
+          Katinguele.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

data/lib/katinguele/client/builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Katinguele
+  module Client
+    class UnknwonService < StandardError; end
+
+    module Builder
+      def self.extended(base)
+        base.send(:build_katinguele_options)
+        base.katinguele_options
+      end
+
+      def katinguele_request_options(options)
+        build_katinguele_request_options(options)
+      end
+
+      def katinguele_service(name)
+        build_katinguele_service(name)
+      end
+
+      private
+
+      def build_katinguele_options
+        define_singleton_method(:katinguele_options) { @katinguele_options ||= {} }
+      end
+
+      def build_katinguele_request_options(options = {})
+        katinguele_options[:request_options] ||= options
+        build_katinguele_request
+      end
+
+      def build_katinguele_service(name = nil)
+        katinguele_options[:service_name] ||= name
+        build_katinguele_request
+      end
+
+      def build_katinguele_request
+        Katinguele.configuration
+                  .find_service(katinguele_options[:service_name])
+                  .then { |service| handle_unknown_service!(service) }
+                  .then { |service| create_request(service) }
+                  .then { |request| katinguele_options[:request] = request }
+      end
+
+      def handle_unknown_service!(service)
+        raise UnknwonService if !service && katinguele_options[:service_name]
+
+        service
+      end
+
+      def create_request(service)
+        Katinguele.configuration.request_by(service, katinguele_options[:request_options])
+      end
+    end
+  end
+end

data/lib/katinguele/client/requester.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+module Katinguele
+  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 = {}) { katinguele_client_request(options, method) }
+          )
+        end
+      end
+
+      def katinguele_client_request(options, method)
+        request = build_final_request(options, method)
+
+        build_faraday_client(request)
+          .then { |client| build_faraday_request(request, client, method) }
+          .then { |response| Katinguele::Response.new(response) }
+          .tap  { |response| response.log if request.logger }
+          .tap  { |response| request.after!(request, response, nil) }
+      rescue Faraday::Error => e
+        response = Katinguele::Response.new(e)
+        error = Katinguele::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)
+        Katinguele.configuration
+                  .request_by(katinguele_options[:request], options)
+                  .tap do |request|
+                    request.before!(request)
+                    request.method = method
+                    request.log if request.logger
+                  end
+      end
+
+      def rescue_faraday_error?(req, res, err)
+        req.after!(req, res, err) || (err.is_a?(Katinguele::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/katinguele/client.rb

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

data/lib/katinguele/configuration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Katinguele
+  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)
+      return request.tap { request.setup!(options) } if request
+
+      Request.new(options) if options&.any?
+    end
+  end
+end

data/lib/katinguele/errors/error.rb

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

data/lib/katinguele/errors/request_error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Katinguele
+  class RequestError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      super(build_message)
+    end
+
+    def log
+      Katinguele::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/katinguele/errors/required_field_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Katinguele
+  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/katinguele/errors/timeout_error.rb

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

data/lib/katinguele/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/katinguele/logger.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Katinguele
+  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/katinguele/request.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Katinguele
+  class Request
+    ACCESSORS = %i[
+      after
+      before
+      headers
+      logger
+      open_timeout
+      params
+      path
+      payload
+      protocol
+      raise_error
+      timeout
+      url
+    ].freeze
+
+    attr_accessor(*(ACCESSORS | %i[uri method]))
+
+    def initialize(options = {})
+      setup!(options)
+    end
+
+    def log
+      Katinguele::Logger.request(self, @method.to_s.upcase)
+    end
+
+    def setup!(options = {})
+      accessors!(options || {})
+      validate!
+      build_urn!
+      handle_query_params!
+      handle_urn_params!
+    end
+
+    def before!(*params)
+      hook!(:before, params)
+    end
+
+    def after!(*params)
+      hook!(:after, params)
+    end
+
+    private
+
+    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 Katinguele::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/katinguele/request_error_factory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Katinguele
+  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/katinguele/response.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'faraday'
+
+module Katinguele
+  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 ||= faraday_response? && @original&.success?
+    end
+
+    def code
+      return if timeout?
+
+      @code ||= faraday_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
+      Katinguele::Logger.response(self)
+    end
+
+    private
+
+    def parsed_body
+      JSON.parse(faraday_response? ? @original.body : @original.response[:body], symbolize_names: true)
+    end
+
+    def faraday_response?
+      @original.is_a?(Faraday::Response)
+    end
+  end
+end

data/lib/katinguele/version.rb

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

data/lib/katinguele.rb

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

metadata

@@ -0,0 +1,229 @@
+--- !ruby/object:Gem::Specification
+name: katinguele
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- linqueta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-19 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
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !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.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+- !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
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.74.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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.6
+description: katinguele
+email:
+- lincolnrodrs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/generators/katinguele/install_generator.rb
+- lib/katinguele.rb
+- lib/katinguele/client.rb
+- lib/katinguele/client/builder.rb
+- lib/katinguele/client/requester.rb
+- lib/katinguele/configuration.rb
+- lib/katinguele/errors.rb
+- lib/katinguele/errors/error.rb
+- lib/katinguele/errors/request_error.rb
+- lib/katinguele/errors/required_field_error.rb
+- lib/katinguele/errors/timeout_error.rb
+- lib/katinguele/logger.rb
+- lib/katinguele/request.rb
+- lib/katinguele/request_error_factory.rb
+- lib/katinguele/response.rb
+- lib/katinguele/version.rb
+homepage: https://github.com/linqueta/katinguele
+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: katinguele
+test_files: []