f_http_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa009fca4cb5465b7a9c07e71037e15c5dffbbe97804e1b6a7ee2888cbfa771c
+  data.tar.gz: '058b8ef192570f144a44c4dac7e7f95aa401923f4176522944421b507b93e7e0'
+SHA512:
+  metadata.gz: a80d429fdc6fc7134ffeee8d6d627a87bad579dc4b29c38113e1a927e503cca3174de5d45829a0a39eb535c3c35b1193a2c3971bdad02acbfdc1cf04e305f1bc
+  data.tar.gz: e1f5e810e2fb1003fa8d503b7703699c75e2c1dc139062306b6eb1ade158cbdc1fe2273ea0cf76d772858a7cc803d61dfa2f3f4d29622d5103b5a7476f24123b

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,121 @@
+require:
+  - rubocop-rspec
+  - rubocop-performance
+
+AllCops:
+  TargetRubyVersion: 3.0
+  SuggestExtensions: false
+  NewCops: enable
+  CacheRootDirectory: tmp
+  Exclude:
+    - 'vendor/**/*'
+    - 'bin/**/*'
+    - '.git/**/*'
+    - 'examples/**/*'
+
+##### LAYOUT #####
+
+Layout/FirstArrayElementIndentation:
+  Enabled: true
+  EnforcedStyle: consistent
+
+Layout/FirstHashElementIndentation:
+  Enabled: true
+  EnforcedStyle: consistent
+
+Layout/LineLength:
+  Max: 120
+  AllowedPatterns: ['(\A|\s)#']
+
+##### STYLE #####
+
+Style/PreferredHashMethods:
+  Enabled: true
+  Safe: false
+  EnforcedStyle: verbose
+
+Style/SymbolArray:
+  Enabled: true
+  EnforcedStyle: percent
+  MinSize: 3
+
+Style/WordArray:
+  Enabled: true
+  EnforcedStyle: percent
+  MinSize: 3
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: true
+  EnforcedStyle: literal
+
+Style/LambdaCall:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+##### LINT #####
+
+Lint/MissingSuper:
+  Enabled: false
+
+##### NAMING #####
+
+Naming/InclusiveLanguage:
+  Enabled: false
+
+Naming/PredicateName:
+  ForbiddenPrefixes:
+    - is_
+    - have_
+    # allows `has_` predicate
+
+###### METRICS #####
+
+Metrics/AbcSize:
+  Enabled: true
+  Max: 22
+
+Metrics/BlockLength:
+  Enabled: true
+  CountComments: false
+  Exclude:
+    - '**/*.gemspec'
+    - 'spec/**/*'
+
+Metrics/ClassLength:
+  Max: 200
+
+Metrics/MethodLength:
+  Enabled: true
+  CountAsOne: ['array', 'heredoc']
+  Max: 20
+
+##### RSPEC #####
+
+RSpec/ContextWording:
+  Prefixes:
+    - and
+    - but
+    - when
+    - with
+    - without
+
+RSpec/ExampleLength:
+  Max: 20
+
+RSpec/FilePath:
+  CustomTransform:
+    FHTTPClient: f_http_client
+
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-02-13
+
+- Initial release
+- Add Caching strategies;
+- Add Logging strategies;
+- Add Custom parse for JSON responses;
+- Add Response and Exception processors;
+- Add Base client class;
+- Add Basic configuration;
+- Add RSpec helpers to simulate responses

data/Gemfile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in f_http_client.gemspec
+gemspec
+
+group :development do
+  gem 'f_service', github: 'Fretadao/f_service', branch: 'master'
+  gem 'rubocop'
+  gem 'rubocop-performance'
+  gem 'rubocop-rspec'
+end
+
+group :test do
+  gem 'rspec', '~> 3.0'
+  gem 'simplecov'
+  gem 'webmock'
+end
+
+group :development, :test do
+  gem 'pry'
+  gem 'pry-nav'
+  gem 'rake', '~> 13.0'
+end

data/Gemfile.lock

@@ -0,0 +1,132 @@
+GIT
+  remote: https://github.com/Fretadao/f_service.git
+  revision: 22d3e1c8bd4aa83b14f34b1af19aa4cd22b8ad8b
+  branch: master
+  specs:
+    f_service (0.2.0)
+
+PATH
+  remote: .
+  specs:
+    f_http_client (0.1.0)
+      activesupport
+      addressable
+      dry-configurable
+      dry-initializer
+      httparty
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.0.4.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    addressable (2.8.1)
+      public_suffix (>= 2.0.2, < 6.0)
+    ast (2.4.2)
+    coderay (1.1.3)
+    concurrent-ruby (1.2.2)
+    crack (0.4.5)
+      rexml
+    diff-lcs (1.5.0)
+    docile (1.4.0)
+    dry-configurable (1.0.1)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-core (1.0.0)
+      concurrent-ruby (~> 1.0)
+      zeitwerk (~> 2.6)
+    dry-initializer (3.1.1)
+    hashdiff (1.0.1)
+    httparty (0.21.0)
+      mini_mime (>= 1.0.0)
+      multi_xml (>= 0.5.2)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    json (2.6.3)
+    method_source (1.0.0)
+    mini_mime (1.1.2)
+    minitest (5.18.0)
+    multi_xml (0.6.0)
+    parallel (1.22.1)
+    parser (3.2.1.0)
+      ast (~> 2.4.1)
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-nav (1.0.0)
+      pry (>= 0.9.10, < 0.15)
+    public_suffix (5.0.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.7.0)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.45.1)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.24.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.26.0)
+      parser (>= 3.2.1.0)
+    rubocop-capybara (2.17.1)
+      rubocop (~> 1.41)
+    rubocop-performance (1.16.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rspec (2.18.1)
+      rubocop (~> 1.33)
+      rubocop-capybara (~> 2.17)
+    ruby-progressbar (1.11.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.4.2)
+    webmock (3.18.1)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+    zeitwerk (2.6.7)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  f_http_client!
+  f_service!
+  pry
+  pry-nav
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop
+  rubocop-performance
+  rubocop-rspec
+  simplecov
+  webmock
+
+BUNDLED WITH
+   2.4.6

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Fretadão
+
+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,126 @@
+# FHTTPClient
+
+Provides a basic skeleton for creating an HTTP client using the FService architecture.
+
+## Installation
+
+Add to your `.gemspec` client file `spec.add_runtime_dependency 'f_http_client'` and run `bundle install`.
+
+## Configure
+
+The gem allow the following configuration
+
+- base_uri: a URI to be used for all services for your client;
+- log_strategy: s symbol representing which logger the gem will use;
+  - null (default): means that the client will not log anything;
+  - rails: means that Rails logger will be used;
+  - any other value the gem will use a default logger which loggs at STDOUT.
+- cache
+  - strategy: Defines which cache strategy will be used;
+    - null (default): the client does not log anything;
+    - rails: the Rails.cache will be used to perform caching;
+  - expires_in: Deines in seconds how much time the cache will be kept (default 0).
+
+```rb
+module BlogClient
+  class Configuration < FHTTPClient::Configuration
+    setting :paginate do
+      setting :enabled, default: true
+      setting :per_page, :20
+    end
+  end
+end
+
+BlogClient::Configuration.configure do |config|
+  config.base_uri = 'https://jsonplaceholder.typicode.com'
+  confg.log_strategy = :rails
+
+  config.cache.strategy = :rails
+  config.cache.expires_in = 25.minutes
+  config.paginate.per_page = 50
+end
+
+
+class BlogClient::Base < FHTTPClient::Base
+  def self.config
+    BlogClient::Configuration.config
+  end
+
+  cache_expires_in 10.minutes
+end
+```
+
+## Usage
+
+Could create a class:
+
+```rb
+# frozen_string_literal: true
+
+module BlogClient
+  module Post
+    class Find < BlogClient::Base
+      private
+
+      def make_request
+        self.class.get(formatted_path, headers: headers)
+      end
+
+      def path_template
+        '/posts/%<id>s'
+      end
+
+      def headers
+        @headers.merge(content_type: 'application/json')
+      end
+    end
+  end
+end
+
+# BlogClient::Post::Find.(path_params: { id: 1 })
+#   .and_then { |response| response.parsed_response }
+#
+# => {
+#     userId: 1,
+#     id: 1,
+#     title: "How to use a FHTTPCLient Gem",
+#     body: "A great text here."
+#    }
+```
+
+Result examples:
+
+```rb
+Person::Create.(name: 'Joe Vicenzo', birthdate: '2000-01-01')
+  .and_then { |user| return redirect_to users_path(user.id) }
+  .on_failure(:unprocessable_entity) { |errors| return render_action :new, locals: { errors: errors } }
+  .on_failure(:client_error) { |errors| render_action :new, warning: errors }
+  .on_failure(:server_error) { |error| render_action :new, warning: ['Try again latter.'] }
+  .on_failure(:server_error) { |error| render_action :new, warning: ['Server is busy. Try again latter.'] }
+  .on_failure { |_error, type| render_action :new, warning: ["Unexpected error. Contact admin and talk about #{type} error."] }
+```
+
+This gem uses the gem [HTTParty](https://github.com/jnunemaker/httparty) as base to perform requests.
+Then we can use any [example](https://github.com/jnunemaker/httparty/tree/master/examples) to implements the method make_request, for GET, POST, PUT, etc.
+The class *FHTTPClient::Base* provides the following options to help building the request:
+- *headers*: can be used to provide custom headers;
+- *query*: can be used to provide querystring params;
+- *body*: can be used to provide a body when request requires this;
+- *options*: can be used provide any other option for HTTParty;
+- *path_params*, can be used to fills params which is in the request path.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Fretadao/f_http_client.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/examples/post_find.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Post
+  class Find < FHTTPClient::Base
+    base_uri 'https://jsonplaceholder.typicode.com'
+
+    private
+
+    def make_request
+      self.class.get(formatted_path, headers: headers)
+    end
+
+    def path_template
+      '/posts/%<id>s'
+    end
+
+    def headers
+      @headers.merge(content_type: 'application/json')
+    end
+  end
+end
+
+# Post::Find.(path_params: { id: 1 })
+#   .and_then { |response| response.parsed_response }
+#
+# => {
+#     userId: 1,
+#     id: 1,
+#     title: "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
+#     body: "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"
+#    }

data/lib/f_http_client/base.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  # Allows to have an http client to build a service
+  # @abstract
+  class Base < FHTTPClient::Service
+    include HTTParty
+
+    DEFAULT_SKIP_CACHE_IF = ->(response) { FHTTPClient::Cache::HTTPResponseAnalyzer.not_cacheable?(response) }
+
+    option :headers, default: -> { {} }
+    option :query, default: -> { {} }
+    option :body, default: -> { {} }
+    option :options, default: -> { {} }
+    option :path_params, default: -> { {} }
+
+    parser FHTTPClient::Parser::Response
+
+    def run
+      configure_base_uri.and_then do
+        response = make_cached_request.value!
+
+        FHTTPClient::Processor::Response.(response: response, log_strategy: log_strategy)
+      end
+    rescue StandardError => e
+      FHTTPClient::Processor::Exception.(error: e, log_strategy: log_strategy)
+        .on_failure(:uncaught_error) { raise e }
+    end
+
+    def self.config
+      raise NotImplementedError, 'Clients must implement .config'
+    end
+
+    def self.cache_strategy(strategy = nil)
+      default_options[:cache_strategy] = config.cache.strategy if default_options[:cache_strategy].nil?
+      return default_options[:cache_strategy] unless strategy
+
+      default_options[:cache_strategy] = strategy
+    end
+
+    def self.cache_expires_in(expires_in = nil)
+      default_options[:cache_expires_in] = config.cache.expires_in if default_options[:cache_expires_in].nil?
+
+      return default_options[:cache_expires_in] unless expires_in
+
+      default_options[:cache_expires_in] = expires_in
+    end
+
+    private
+
+    def configure_base_uri
+      return Success(:uri_already_configured) if self.class.base_uri.present?
+
+      return Failure(:no_base_uri_configured) if config.base_uri.blank?
+
+      self.class.base_uri(config.base_uri)
+
+      Success(:base_uri_configured)
+    end
+
+    def make_cached_request
+      FHTTPClient::Store.(
+        key: cache_key,
+        strategy: cache_strategy,
+        block: -> { make_request },
+        expires_in: cache_expires_in,
+        skip_if: skip_cache_if
+      )
+    end
+
+    def make_request
+      raise NotImplementedError, 'Clients must implement #make_request'
+    end
+
+    def path_template
+      raise NotImplementedError, 'Clients must implement #path_template'
+    end
+
+    def formatted_path
+      @formatted_path ||= format(path_template, path_params)
+    end
+
+    def cache_key
+      FHTTPClient::Cache::Key.generate(
+        self.class,
+        path: formatted_path,
+        headers: headers,
+        query: query,
+        body: body,
+        options: options
+      )
+    end
+
+    def config
+      self.class.config
+    end
+
+    def log_strategy
+      config.log_strategy
+    end
+
+    def cache_strategy
+      self.class.default_options[:cache_strategy] || config.cache.strategy
+    end
+
+    def cache_expires_in
+      self.class.default_options[:cache_expires_in] || config.cache.expires_in
+    end
+
+    def skip_cache_if
+      DEFAULT_SKIP_CACHE_IF
+    end
+  end
+end

data/lib/f_http_client/cache/http_response_analizer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Cache
+    module HTTPResponseAnalyzer
+      attr_reader :response
+
+      NOT_CACHEABLE_RESPONSES = %i[
+        server_error?
+        gateway_timeout?
+        request_timeout?
+        unauthorized?
+        too_many_requests?
+      ].freeze
+
+      class << self
+        def not_cacheable_responses
+          NOT_CACHEABLE_RESPONSES
+        end
+
+        def not_cacheable?(response)
+          not_cacheable_responses.any? do |not_cacheable_response|
+            response.public_send(not_cacheable_response)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/f_http_client/cache/key.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Cache
+    class Key
+      def self.generate(*args)
+        params = args.extract_options!
+        klass = args.first.to_s
+
+        [klass.underscore, params.compact_blank.to_query].filter_map(&:presence).join('?')
+      end
+    end
+  end
+end

data/lib/f_http_client/cache/null.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Cache
+    class Null
+      class << self
+        def fetch(_name, _options = nil)
+          yield if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/f_http_client/cache/rails.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Cache
+    RailsNotDefined = Class.new(StandardError)
+
+    class Rails
+      class << self
+        def fetch(name, options = {})
+          raise RailsNotDefined unless defined?(::Rails)
+
+          cache_entry = cache.read(name)
+
+          return cache_entry if cache_entry.present?
+          return unless block_given?
+
+          result = yield
+
+          cache.write(name, result, options) unless options[:skip_if]&.(result)
+
+          result
+        end
+
+        private
+
+        def cache
+          ::Rails.cache
+        end
+      end
+    end
+  end
+end

data/lib/f_http_client/configuration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  class Configuration
+    extend Dry::Configurable
+
+    setting :base_uri
+    setting :log_strategy, default: :null
+    setting :cache do
+      setting :strategy, default: :null
+      setting :expires_in, default: 0
+    end
+  end
+end

data/lib/f_http_client/log.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  # Allow to log a message to system log
+  #
+  # Attributes:
+  # - message: object containint the message to be logged;
+  # - level (optional): level symbol to log the message (debug, info, warn error, fatal or unknown);
+  # - tags (optional): list of tags to be added to log line.
+  #
+  # Example:
+  #   FHTTPClient::Log.(message: { name: 'Bruno' }.to_json)
+  #   FHTTPClient::Log.(message: { name: 'Bruno' }.to_json, stragegy: :rails)
+  #   FHTTPClient::Log.(message: { name: 'Bruno' }.to_json, tags: ['Response'])
+  #   FHTTPClient::Log.(message: { response: { name: 'Bruno' } }.to_json, level: :warn)
+  class Log < FHTTPClient::Service
+    LOGGERS = {
+      rails: FHTTPClient::Logger::Rails,
+      default: FHTTPClient::Logger::Default
+    }.freeze
+    private_constant :LOGGERS
+
+    option :message
+    option :strategy, default: -> { :null }
+    option :level, default: -> { :info }
+    option :tags, default: -> { [] }
+
+    def run
+      logger.tagged(*Array(tags)).public_send(level, message)
+
+      Success(:logged)
+    end
+
+    def logger
+      @logger ||= LOGGERS.fetch(strategy, FHTTPClient::Logger::Null).new
+    end
+  end
+end

data/lib/f_http_client/logger/default.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Logger
+    # A Basic logger to use when no logger is provided
+    class Default
+      def initialize(tags: [])
+        @logger = ::Logger.new($stdout)
+        @current_tags = tags
+      end
+
+      def tagged(*tags)
+        tagged = self.class.new(tags: current_tags + tags)
+        block_given? ? yield(tagged) : tagged
+      end
+
+      def debug(message) = add(::Logger::DEBUG, message)
+      def info(message) = add(::Logger::INFO, message)
+      def warn(message) = add(::Logger::WARN, message)
+      def error(message) = add(::Logger::ERROR, message)
+      def fatal(message) = add(::Logger::FATAL, message)
+      def unknown(message) = add(::Logger::UNKNOWN, message)
+
+      private
+
+      attr_reader :logger, :current_tags
+
+      def add(severity, message)
+        formatted_tags = format_tags
+        full_message = formatted_tags.empty? ? message : [format_tags, message].join(' - ')
+
+        logger.add(severity, full_message)
+      end
+
+      def format_tags
+        current_tags.map { |tag| "[#{tag}]" }.join(' ')
+      end
+    end
+  end
+end

data/lib/f_http_client/logger/null.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Logger
+    # Logs nothing
+    class Null
+      def tagged(...) = block_given? ? yield(self) : self
+      def debug(...) = nil
+      def info(...) = nil
+      def warn(...) = nil
+      def error(...) = nil
+      def fatal(...) = nil
+      def unknown(...) = nil
+    end
+  end
+end

data/lib/f_http_client/logger/rails.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Logger
+    # Logging with Rails logger
+    class Rails
+      extend Forwardable
+
+      delegate %i[tagged debug info warn error fatal unknown] => :@logger
+
+      def initialize
+        @logger = ::Rails.logger
+      end
+    end
+  end
+end

data/lib/f_http_client/parser/response.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Parser
+    # Parse a json response letting this as symbol hash
+    # Following those examples: https://github.com/jnunemaker/httparty/blob/master/examples/custom_parsers.rb
+    # And looking default formats: https://github.com/jnunemaker/httparty/blob/fb7c40303b7e6429196ef748754505768520407c/lib/httparty/parser.rb#L42
+    class Response < HTTParty::Parser
+      protected
+
+      def json
+        JSON.parse(body, quirks_mode: true, allow_nan: true, symbolize_names: true)
+      end
+    end
+  end
+end

data/lib/f_http_client/processor/exception.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Processor
+    # This Service proccess a HTTP exception generating failure result.
+    #
+    # Example:
+    #
+    # def process
+    #   error = Errno::ECONNREFUSED.new('Failed to open TCP connection to :80')
+    #   FHTTPClient::Processor::ResponseProcessor.(error: error)
+    #     .on_failure(:connection_refused) {  return 'The server has been refused the connection.' }
+    #     .on_failure { |error_message| return "Generic #{error_message}" }
+    # end
+    #
+    # proccess
+    # # => 'The server has been refused the connection.'
+    class Exception < FHTTPClient::Service
+      option :error
+      option :log_strategy, default: -> { :null }
+
+      def run
+        log_data.and_then { Failure(error_name, :exception, data: error) }
+      end
+
+      private
+
+      def error_name
+        case error.class.to_s
+        when 'Errno::ECONNREFUSED'
+          :connection_refused
+        when /timeout/i
+          :timeout
+        else
+          :uncaught_error
+        end
+      end
+
+      def log_data
+        FHTTPClient::Log.(
+          message: { error: error.class.to_s, message: error.message, backtrace: error.backtrace.join(', ') }.to_json,
+          tags: 'EXTERNAL REQUEST',
+          level: :error,
+          strategy: log_strategy
+        )
+      end
+    end
+  end
+end

data/lib/f_http_client/processor/response.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  module Processor
+    # This Service proccess a HTTP response, generating a success or failure result.
+    #
+    # Example:
+    #
+    # def process
+    #   response = OpenStruct.new(success?: false, parsed_response: {}, headers: {}, message: 'Conflict')
+    #   processor = FHTTPClient::Processor::Response.new(response: response)
+    #   processor.()
+    #     .on_success { |value| "Success! #{value.inspect}"}
+    #     .on_failure(:conflict) { |value| return "A conflict happened! #{value.inspect}"}
+    #     .on_failure(:client_error) { |value| return "An unexpected client error happened #{value.inspect}"}
+    #     .on_failure { |value| return "Generic #{value}" }
+    # end
+    #
+    # proccess
+    # # => "A conflict happened! {}"
+    class Response < FHTTPClient::Service
+      extend Forwardable
+
+      option :response
+      option :log_strategy, default: -> { :null }
+
+      STATUS_FAMILIES = {
+        200..299 => :successful,
+        400..499 => :client_error,
+        500..599 => :server_error,
+        300..399 => :redirection,
+        100..199 => :informational
+      }.freeze
+
+      private_constant :STATUS_FAMILIES
+
+      def run
+        log_data.and_then { success? ? success_response : failure_response }
+      end
+
+      private
+
+      def_delegators :@response, :headers, :success?, :parsed_response, :code
+
+      def success_response
+        Success(response_type, response_family, data: response)
+      end
+
+      def failure_response
+        Failure(response_type, response_family, data: response)
+      end
+
+      # Private:
+      # Transform HTTParty response  message in to a symbol
+      # Ex: When the request returns a 400 (Bad Request)
+      #
+      # # => :bad_request
+      def response_type
+        message.empty? ? :unknown_type : message.downcase.tr(' ', '_').to_sym
+      end
+
+      # Private:
+      # Transform HTTParty response code in to a symbol
+      # Ex: When the request returns a 400 (Bad Request)
+      #
+      # # => :client_error
+      def response_family
+        STATUS_FAMILIES
+          .find(-> { [code, :unknown_family] }) { |codes, _family| codes.cover?(code.to_i) }
+          .last
+      end
+
+      # Private
+      # Generates a HTTParty response message from a Net::HTTPRespoonse Class
+      # Examples:
+      #
+      # response_type(Net::HTTPOK)
+      # # => "OK"
+      #
+      # response_type(Net::HTTPUnprocessableEntity)
+      # # => "Unprocessable Entity"
+      def message
+        @message ||= response_class
+                     .to_s
+                     .delete_prefix('Net::HTTP')
+                     .gsub(/([A-Z]+)([A-Z][a-z])/, '\1 \2')
+                     .gsub(/([a-z])([A-Z])/, '\1 \2')
+      end
+
+      # Private
+      # Get an HTTP status error name for a status code
+      #
+      # Ex: 400
+      # # => "Net:HTTPBadRequest"
+      def response_class
+        Net::HTTPResponse::CODE_TO_OBJ[code.to_s].to_s
+      end
+
+      def log_data
+        FHTTPClient::Log.(
+          message: { request: request_log_data, response: response_log_data }.to_json,
+          strategy: log_strategy,
+          tags: 'EXTERNAL REQUEST'
+        )
+      end
+
+      def request_log_data
+        request = response.request
+        request_options = request.options
+
+        {
+          headers: request_options[:headers],
+          method: request.http_method.name.split('::').last.upcase,
+          path: request.uri.path,
+          querystring: Addressable::URI.parse(request.uri.query)&.query_values,
+          body: request_options[:body]
+        }.compact_blank
+      end
+
+      def response_log_data
+        { code: code, human_code: message, headers: headers, body: parsed_response }.compact_blank
+      end
+    end
+  end
+end

data/lib/f_http_client/rspec/support/helpers/fake_response.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FHTTPClientFakeResponse
+  def build_httparty_response(code: 200, parsed_response: {})
+    request_object = HTTParty::Request.new Net::HTTP::Get, '/'
+    response_object = Net::HTTPResponse::CODE_TO_OBJ[code.to_s].new('1.1', code, '')
+    allow(response_object).to receive(:body)
+
+    HTTParty::Response.new(request_object, response_object, -> { parsed_response })
+  end
+end
+
+RSpec.configure do |config|
+  config.include FHTTPClientFakeResponse
+end

data/lib/f_http_client/rspec/support/helpers.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/fake_response'

data/lib/f_http_client/rspec/support/support.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'support/helpers'

data/lib/f_http_client/rspec/support.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'support/helpers'

data/lib/f_http_client/rspec.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'rspec/support'

data/lib/f_http_client/service.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  # Allow defining keyword args for a class
+  #
+  # @example
+  #   class User::Create < FHTTPClient::Service
+  #     option :name
+  #     option :age
+  #     option :email, default: -> { 'guest@user.com' }
+  #
+  #     def run
+  #       Success(:created, data: "Hello #{name}! Your email is: #{email}")
+  #     end
+  #   end
+  #
+  #   User.(name: 'Matheus', age: 22)
+  #   => #<FService::Result::Success:0x0000557fae615ea8 @handled=false, @matching_types=[], @types=[:created], @value="Hello Bruno! Your email is: guest@user.com">
+  class Service < FService::Base
+    extend Dry::Initializer
+  end
+end

data/lib/f_http_client/store.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FHTTPClient
+  # Allow to log a message to system log
+  #
+  # Attributes:
+  # - strategy: symbol representing cache stragegy to be used (null or rails);
+  # - block: the lambda to have its result cached;
+  # - key: the cache key to be used to store the result;
+  # - expires_in (optional): seconds to keep the result in cache;
+  # - skip_if (optional): a block to run over the block result and decide if result caching must be persisted or skiped.
+  #
+  # Example:
+  #   FHTTPClient::Cache.(strategy: :rails, key: 'users/list?name=bruno', block: -> { make_request })
+  #   FHTTPClient::Cache.(strategy: :rails, key: 'users/list?name=bruno', block: -> { make_request }, expires_in: 15.minutes)
+  #   FHTTPClient::Cache.(strategy: :rails, key: 'users/list?name=bruno', block: -> { make_request }, skip_if: ->(response) { response.status != 200 })
+  class Store < FHTTPClient::Service
+    option :strategy
+    option :key
+    option :block
+    option :expires_in, default: -> {}
+    option :skip_if, default: -> {}
+
+    def run
+      Success(
+        :done,
+        data: cache.fetch(key, { expires_in: expires_in, skip_if: skip_if }.compact_blank, &block)
+      )
+    end
+
+    private
+
+    def cache
+      @cache ||= strategy == :rails ? FHTTPClient::Cache::Rails : FHTTPClient::Cache::Null
+    end
+  end
+end

data/lib/f_http_client/version.rb

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

data/lib/f_http_client.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'f_http_client/version'
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/string'
+require 'addressable'
+require 'dry-configurable'
+require 'dry-initializer'
+require 'forwardable'
+require 'httparty'
+require 'f_service'
+
+require 'f_http_client/configuration'
+require 'f_http_client/service'
+require 'f_http_client/store'
+require 'f_http_client/cache/http_response_analizer'
+require 'f_http_client/cache/key'
+require 'f_http_client/cache/null'
+require 'f_http_client/cache/rails'
+
+require 'f_http_client/logger/default'
+require 'f_http_client/logger/null'
+require 'f_http_client/logger/rails'
+require 'f_http_client/log'
+
+require 'f_http_client/parser/response'
+require 'f_http_client/processor/exception'
+require 'f_http_client/processor/response'
+
+require 'f_http_client/base'
+
+module FHTTPClient
+end

data/sig/f_http_client.rbs

@@ -0,0 +1,4 @@
+module FHTTPClient
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: f_http_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fretadao Tech Team
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- tech@fretadao.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- examples/post_find.rb
+- lib/f_http_client.rb
+- lib/f_http_client/base.rb
+- lib/f_http_client/cache/http_response_analizer.rb
+- lib/f_http_client/cache/key.rb
+- lib/f_http_client/cache/null.rb
+- lib/f_http_client/cache/rails.rb
+- lib/f_http_client/configuration.rb
+- lib/f_http_client/log.rb
+- lib/f_http_client/logger/default.rb
+- lib/f_http_client/logger/null.rb
+- lib/f_http_client/logger/rails.rb
+- lib/f_http_client/parser/response.rb
+- lib/f_http_client/processor/exception.rb
+- lib/f_http_client/processor/response.rb
+- lib/f_http_client/rspec.rb
+- lib/f_http_client/rspec/support.rb
+- lib/f_http_client/rspec/support/helpers.rb
+- lib/f_http_client/rspec/support/helpers/fake_response.rb
+- lib/f_http_client/rspec/support/support.rb
+- lib/f_http_client/service.rb
+- lib/f_http_client/store.rb
+- lib/f_http_client/version.rb
+- sig/f_http_client.rbs
+homepage: https://github.com/Fretadao/f_http_client
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Fretadao/f_http_client
+  source_code_uri: https://github.com/Fretadao/f_http_client
+  changelog_uri: https://github.com/Fretadao/f_http_client/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: Gem to provade a base for an HTTP client using FService architecture
+test_files: []