api-response-presenter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 34e509264188009fe9c15dd6c38c58286b338a688e33372f1e15ab690e4f7416
+  data.tar.gz: a3365ff34ea26895b3393dccc4c450ccb6645dd7d7410931c2ba4c47e1c16690
+SHA512:
+  metadata.gz: f205f9e01e0853e9afed337b6460b3672984bb632eb2e6d7ed6ea9a41d31d9bf3e3ca2cd265f9929a856b304b4f8b2b909a470ab7e5d9ee319d6ac0725e02b68
+  data.tar.gz: 3fb35b7a9b8def679a29868f4b9cab6fd7cd9a48a653e3d5a5329b8fcbf9a72ec9bf132cee5bcc67ee3c64e54debc3c045abdcd6ce3d4c6e991e2c2c08cacc6f

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+- version: 0.0.1 
+  - date: 2024-03-10
+  - summary: Initial release

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 David Rybolovlev
+
+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,324 @@
+# api-response-presenter
+[![Gem Version](https://badge.fury.io/rb/api-response-presenter.svg)](https://badge.fury.io/rb/api-response-presenter) [![Build Status](https://app.travis-ci.com/golifox/api-response-presenter.svg?branch=main)](https://app.travis-ci.com/golifox/api-response-presenter)
+[![Coverage Status](https://coveralls.io/repos/github/golifox/api-response-presenter/badge.svg)](https://coveralls.io/github/golifox/api-response-presenter)
+[![Inline docs](https://inch-ci.org/github/golifox/api-response-presenter.svg?branch=main)](https://inch-ci.org/github/golifox/api-response-presenter)
+
+The `api-response-presenter` gem provides a flexible and easy-to-use interface for processing API responses using Faraday or
+RestClient with the possibility to configure global settings or per-instance settings. It leverages
+the `Dry::Configurable` for configurations, ensuring high performance and full test coverage.
+
+## Supported Ruby Versions
+This library oficially supports the following Ruby versions:
+- MRI `>=2.7.4`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'api-response-presenter'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install api-response-presenter
+```
+
+## Usage
+
+### Configuration
+
+You can configure api_response globally in an initializer or setup block:
+
+```ruby
+# config/initializers/api_response.rb
+
+ApiResponse.config.some_option = 'some_value'
+
+# or
+
+ApiResponse.configure do |config|
+  config.adapter = :faraday # or :rest_client, :excon, :http
+  config.monad = false
+  config.extract_from_body = ->(body) { body }
+  config.struct = nil
+  config.raw_response = false
+  config.error_json = false
+  config.default_return_value = nil
+  config.default_status = :conflict
+  config.default_error_key = :external_api_error
+  config.default_error = 'External Api error'
+
+  # dependency injection
+  config.success_processor = ApiResponse::Processor::Success
+  config.failure_processor = ApiResponse::Processor::Failure
+  config.parser = ApiResponse::Parser
+  config.options = {}
+end
+```
+
+or on instance config, provide block (see: BasicUsage).
+
+### Basic Example
+
+Here is a basic example of using api_response to process an API response:
+
+```ruby
+response = Faraday.get('https://api.example.com/data')
+result = ApiResponse::Presenter.call(response) do |config|
+  config.monad = true
+end
+
+# or 
+# Usefull for using in another libraries
+result ||= ApiResponse::Presenter.call(response, monad: true)
+
+if result.success?
+  puts "Success: #{result.success}"
+else
+  puts "Error: #{result.failure}"
+end
+
+```
+
+### Config options
+
+- `ApiResponse.config.adapter`: response adapter that you are using. 
+  - Default: `:faraday`. 
+  - Available values: `:rest_client`, `:excon`, `:http` and others. Checks that response respond to `#status` (only Faraday and Excon)
+    or `#code` (others)
+- `ApiResponse.config.monad` wrap result into [dry-monads](https://github.com/dry-rb/dry-monads) 
+  - Default: `false`
+  - Example: `ApiResponse::Presenter.call(response, monad: true) # => Success({})` or `Failure({error:, status:, error_key:})`
+  - Note: if you use `ApiResponse::Presenter.call` with monad: true, you should use `#success?` and `#failure?` methods to check result
+  - Options only for `ApiResponse.config.monad = true`:
+    - `ApiResponse.config.default_status` default status for `ApiResponse::Presenter.call` if response is not success. You can provide symbol or integer.
+      - Default: `:conflict`
+    - `ApiResponse.config.symbol_status` option for symbolize status from response (or default status if it an Integer).
+      - Default: `true`
+      - Example: `ApiResponse::Presenter.call(response, monad: true, default_status: 500, symbol_status: false) # => Failure({error:, status: 500, error_key:})`
+    - `ApiResponse.config.default_error_key` default error key for `ApiResponse::Presenter.call` if response is not success
+      - Default: `:external_api_error`
+    - `ApiResponse.config.default_error` default error message for `ApiResponse::Presenter.call` if response is not success
+      - Default: `'External Api error'`
+- `ApiResponse.config.extract_from_body` procedure that is applied to the `response.body` after it has been parsed from JSON string to Ruby hash with symbolize keys. 
+  - Default: `->(body) { body }`. 
+  - Example lambdas: `->(b) { b.first }`, `->(b) { b.slice(:id, :name) }`, `-> (b) { b.deep_stringify_keys )}`
+- `ApiResponse.config.struct` struct for pack your extracted value from body.
+  - Default: `nil`
+  - Note: packing only into classes with key value constructors (e.g. `MyAwesomeStruct.new(**attrs)`, not `Struct.new(attrs)`)
+  - Recommend to use [dry-struct](https://github.com/dry-rb/dry-struct) or [Ruby#OpenStruct](https://ruby-doc.org/stdlib-3.0.0/libdoc/ostruct/rdoc/OpenStruct.html)
+- `ApiResponse.config.raw_response` returns raw response, that you passes into class.
+    - Default: `false`
+    - Example: `ApiResponse::Presenter.call(Faraday::Response<...>, raw_response: true) # => Faraday::Response<...>`
+- `ApiResponse.config.error_json` returns error message from response body if it is JSON (parsed with symbolize keys)
+  - Default: `false`
+  - Example: `ApiResponse::Presenter.call(Response<body: "{\"error\": \"some_error\"}">, error_json: true) # => {error: "some_error"}`
+- `ApiResponse.config.default_return_value` default value for `ApiResponse::Presenter.call` if response is not success 
+  - Default: `nil`
+  - Example: `ApiResponse::Presenter.call(response, default_return_value: []) # => []`
+
+NOTE: You can override global settings on instance config, provide block (see: BasicUsage). Params options has higher priority than global settings and block settings.
+
+### Examples:
+
+#### Interactors:
+```ruby
+class ExternalApiCaller < ApplicationInteractor
+  class Response < Dry::Struct
+    attribute :data, Types::Array
+  end
+  
+  def call
+    response = RestClient.get('https://api.example.com/data') # => body: "{\"data\": [{\"id\": 1, \"name\": \"John\"}]}"
+    ApiResponse::Presenter.call(response) do |config|
+      config.adapter = :rest_client
+      config.monad = true
+      config.struct = Response
+      config.default_status = 400 # no matter what status came in fact
+      config.symbol_status = true # return :bad_request instead of 400
+      config.default_error = 'ExternalApiCaller api error' # instead of response error field (e.g. body[:error])
+    end
+  end
+end
+
+def MyController
+  def index
+    result = ExternalApiCaller.call
+    if result.success?
+      render json: result.success # => ExternalApiCaller::Response<data: [{id: 1, name: "John"}]> => {data: [{id: 1, name: "John"}]}
+    else
+      render json: {error: result.failure[:error]}, status: result.failure[:status] # => {error: "ExternalApiCaller api error"}, status: 400
+    end
+  end
+end
+```
+
+#### ExternalApi services
+
+```ruby
+
+class EmployeeApiService
+  class Employee < Dry::Struct
+    attribute :id, Types::Integer
+    attribute :name, Types::String
+  end
+
+  def self.get_employees(monad: false, adapter: :faraday, **options)
+    # or (params, presenter_options = {})
+    response = Faraday.get('https://api.example.com/data', params) # => body: "{\"data\": [{\"id\": 1, \"name\": \"John\"}]}"
+    ApiResponse::Presenter.call(response, monad: monad, adapter: adapter) do |c|
+      c.extract_from_body = ->(body) { Kaminari.paginate_array(body[:data]).page(1).per(5) }
+      c.struct = Employee
+      c.default_return_value = []
+    end
+  end
+end
+
+class MyController
+  def index
+    employees = EmployeeApiService.get_employees(page: 1, per: 5)
+    if employees.any?
+      render json: employees # => [Employee<id: 1, name: "John">] => [{id: 1, name: "John"}]
+    else
+      render json: {error: 'No employees found'}, status: 404
+    end
+  end
+end
+```
+
+
+### Customization
+
+#### Processors
+You can customize the response processing by providing a block to `ApiResponse::Presenter.call` or redefine global processors and parser:
+All of them must implement `.new(response, config: ApiResponse.config).call` method.
+You can use not default config in your processor, just pass it as a second named argument.
+
+1. Redefine `ApiResponse::Processor::Success` # contains logic for success response (status/code 100-399)
+2. Redefine `ApiResponse::Processor::Failure` # contains logic for failure response (status/code 400-599)
+3. Redefine `ApiResponse::Parser` # contains logic for parsing response body (e.g. `Oj.load(response.body)`)
+
+```ruby
+class MyClass
+  def initialize(response, config: ApiResponse.config)
+    @response = response
+    @config = config
+  end
+  
+  def call
+    # your custom logic
+  end
+end
+```
+
+or with `Dry::Initializer`
+
+```ruby
+require 'dry/initializer'
+
+class MyClass
+  extend Dry::Initializer
+  option :response
+  option :config, default: -> { ApiResponse.config }
+  
+  def call
+    # your custom logic
+  end
+end
+```
+
+You can use your custom processor or parser in `ApiResponse::Presenter.call` or redefine in global settings:
+
+```ruby
+ApiResponse.config.success_processor = MyClass
+ApiResponse.config.failure_processor = MyClass
+ApiResponse.config.parser = MyClass
+```
+
+or 
+
+```ruby
+ApiResponse::Presenter.call(response, success_processor: MyClass, failure_processor: MyClass, parser: MyClass)
+```
+
+#### Options
+
+Also you can add custom options to `ApiResponse.config.options = {}` and use it in your processor or parser:
+
+```ruby
+ApiResponse.config do |config| 
+  config.options[:my_option] = 'my_value'
+  config.options[:my_another_option] = 'my_another_value'
+end
+```
+
+or 
+    
+```ruby
+ApiResponse::Presenter.call(response, success_processor: MyClass, options: {my_option: 'my_value', my_another_option: 'my_another_value'})
+```
+
+Example:
+
+```ruby
+
+class MyCustomParser
+  attr_reader :response, :config
+
+  def initialize(response, config: ApiResponse.config)
+    @response = response
+    @config = config
+  end
+
+  def call
+    JSON.parse(response.body, symbolize_names: true) # or Oj.load(response.body, symbol_keys: true)
+  rescue JSON::ParserError => e
+    raise ::ParseError.new(e) if config.options[:raise_on_failure]
+    response.body
+  end
+end
+
+class MyCustomFailureProcessor
+  class BadRequestError < StandardError; end
+
+  attr_reader :response, :config
+
+  def initialize(response, config: ApiResponse.config)
+    @response = response
+    @config = config
+  end
+
+  def call
+    parsed_body = config.parser.new(response).call
+    raise BadRequestError.new(parsed_body) if config.options[:raise_on_failure]
+
+    {error: parsed_body, status: response.status || config.default_status, error_key: :external_api_error}
+  end
+end
+
+ApiResponse.config do |config|
+  config.failure_processor = MyCustomFailureProcessor
+  config.parser = MyCustomParser
+  config.options[:raise_on_failure] = true
+end
+
+response = Faraday.get('https://api.example.com/endpoint_that_will_fail')
+ApiResponse::Presenter.call(response) # => raise BadRequestError
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/golifox/api_response.git)
+
+## License
+See `LICENSE` file.
+
+

data/api_response_presenter.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'api_response/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'api-response-presenter'
+  s.author      = 'David Rybolovlev'
+  s.email       = 'i@golifox.ru'
+  s.license     = 'MIT'
+  s.version     = ApiResponse::VERSION.dup
+
+  s.summary     = 'Gem for presenting API responses from Faraday and RestClient.'
+  s.description = s.summary
+  s.files       = Dir['README.md', 'LICENSE', 'CHANGELOG.md', 'api_response_presenter.gemspec', 'lib/**/*.rb']
+  s.executables = []
+  s.require_paths = ['lib']
+
+  s.metadata = {'rubygems_mfa_required' => 'true'}
+
+  s.required_ruby_version = '>= 2.7.4'
+
+  s.add_runtime_dependency 'dry-configurable', '~> 1.0'
+  s.add_runtime_dependency 'dry-initializer', '~> 3.0'
+  s.add_runtime_dependency 'dry-monads', '~> 1.6'
+  s.add_runtime_dependency 'dry-types', '~> 1.5'
+  s.add_runtime_dependency 'oj', '~> 3.13'
+  s.add_runtime_dependency 'zeitwerk', '~> 2.4'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+end

data/lib/api_response/parser.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+module ApiResponse
+  class Parser
+    extend Dry::Initializer
+
+    param :response, type: Types.Interface(:body)
+    option :config, default: -> { ApiResponse.config }
+
+    def call
+      Oj.load(response.body, mode: :compat, symbol_keys: true)
+    end
+  end
+end

data/lib/api_response/presenter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ApiResponse
+  class Presenter
+    extend Dry::Initializer
+
+    param :response
+    option :config, default: -> { ApiResponse.config.dup }
+    option :options, type: Types::Hash, default: -> { {} }
+
+    def self.call(response, **options, &block)
+      new(response, options: options).call(&block)
+    end
+
+    def call(&block)
+      if block
+        Processor.call(response, config: config, options: options, &block)
+      else
+        Processor.call(response, config: config, options: options)
+      end
+    end
+  end
+end

data/lib/api_response/processor/failure.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'dry-monads'
+
+module ApiResponse
+  class Processor
+    class Failure
+      include Dry::Monads[:result]
+      extend Dry::Initializer
+
+      param :response, type: Types.Interface(:body)
+      option :config, default: -> { ApiResponse.config }
+
+      def call
+        return response if config.raw_response
+        return build_error_monad if config.monad
+
+        begin
+          return response_body if config.error_json
+        rescue StandardError
+          return config.default_return_value || response.body
+        end
+
+        config.default_return_value
+      end
+
+      private
+
+      def response_body
+        @response_body ||= config.parser.new(response, config: config).call
+      end
+
+      def build_error_monad
+        status = config.default_status || prepare_status(response)
+        error = config.default_error || response_body.fetch(:error, nil) || response_body
+        error_key = config.default_error_key || response_body.fetch(:error_key, nil)
+
+        Failure({error: error, error_key: error_key, status: status})
+      end
+
+      def prepare_status(response)
+        code = case config.adapter
+               when :faraday, :excon then response.status
+               else response&.code
+               end
+
+        prepared_default_status || prepared_response_status(code)
+      end
+
+      def prepared_response_status(code)
+        config.symbol_status ? ApiResponse::Types::STATUS_CODE_TO_SYMBOL[code.to_i] : code.to_i
+      end
+
+      def prepared_default_status
+        if config.symbol_status && config.default_status.is_a?(Integer)
+          ApiResponse::Types::SYMBOL_TO_STATUS_CODE[config.default_status]
+        else
+          config.default_status
+        end
+      end
+    end
+  end
+end

data/lib/api_response/processor/success.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'dry/monads'
+
+module ApiResponse
+  class Processor
+    class Success
+      class ExtractError < StandardError; end
+
+      class StructError < StandardError; end
+
+      include Dry::Monads[:result]
+      extend Dry::Initializer
+
+      param :response, type: Types.Interface(:body)
+      option :config, default: -> { ApiResponse.config }
+
+      def call
+        return response if config.raw_response
+
+        result = extract_from_body
+        result = build_struct(result) if config.struct
+
+        config.monad ? Success(result) : result
+      end
+
+      private
+
+      def response_body
+        @response_body ||= config.parser.new(response, config: config).call
+      end
+
+      def extract_from_body
+        config.extract_from_body.call(response_body) || response_body
+      rescue EncodingError => e
+        raise ExtractError, e.message
+      rescue StandardError
+        response.body
+      end
+
+      def build_struct(extracted)
+        case extracted
+        when Hash then config.struct.new(extracted)
+        when Array then extracted.map { |item| config.struct.new(**item) }
+        end
+      rescue StandardError => e
+        raise StructError, e.message
+      end
+    end
+  end
+end

data/lib/api_response/processor.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ApiResponse
+  class Processor
+    extend Dry::Initializer
+
+    param :response
+    option :config, default: -> { ApiResponse.config.dup }
+    option :options, default: -> { {} }
+
+    def self.call(response, options:, config: ApiResponse.config.dup, &block)
+      config = config.dup
+      yield(config) if block
+      config.update(options)
+
+      new(response, config: config, options: options).call
+    end
+
+    def call
+      processor = success? ? config.success_processor : config.failure_processor
+
+      processor.new(response, config: config).call
+    end
+
+    private
+
+    def success?
+      case config.adapter
+      when :faraday, :excon
+        response.status.to_i < 400
+      else
+        response.code.to_i < 400
+      end
+    end
+  end
+end

data/lib/api_response/types.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+
+module ApiResponse
+  module Types
+    include Dry.Types
+
+    STATUS_CODE_TO_SYMBOL = {
+      100 => :continue,
+      101 => :switching_protocols,
+      102 => :processing,
+      103 => :early_hints,
+      200 => :ok,
+      201 => :created,
+      202 => :accepted,
+      203 => :non_authoritative_information,
+      204 => :no_content,
+      205 => :reset_content,
+      206 => :partial_content,
+      207 => :multi_status,
+      208 => :already_reported,
+      226 => :im_used,
+      300 => :multiple_choices,
+      301 => :moved_permanently,
+      302 => :found,
+      303 => :see_other,
+      304 => :not_modified,
+      305 => :use_proxy,
+      306 => :'(unused)',
+      307 => :temporary_redirect,
+      308 => :permanent_redirect,
+      400 => :bad_request,
+      401 => :unauthorized,
+      402 => :payment_required,
+      403 => :forbidden,
+      404 => :not_found,
+      405 => :method_not_allowed,
+      406 => :not_acceptable,
+      407 => :proxy_authentication_required,
+      408 => :request_timeout,
+      409 => :conflict,
+      410 => :gone,
+      411 => :length_required,
+      412 => :precondition_failed,
+      413 => :payload_too_large,
+      414 => :uri_too_long,
+      415 => :unsupported_media_type,
+      416 => :range_not_satisfiable,
+      417 => :expectation_failed,
+      421 => :misdirected_request,
+      422 => :unprocessable_entity,
+      423 => :locked,
+      424 => :failed_dependency,
+      425 => :too_early,
+      426 => :upgrade_required,
+      428 => :precondition_required,
+      429 => :too_many_requests,
+      431 => :request_header_fields_too_large,
+      451 => :unavailable_for_legal_reasons,
+      500 => :internal_server_error,
+      501 => :not_implemented,
+      502 => :bad_gateway,
+      503 => :service_unavailable,
+      504 => :gateway_timeout,
+      505 => :http_version_not_supported,
+      506 => :variant_also_negotiates,
+      507 => :insufficient_storage,
+      508 => :loop_detected,
+      509 => :bandwidth_limit_exceeded,
+      510 => :not_extended,
+      511 => :network_authentication_required
+    }.freeze
+  end
+end

data/lib/api_response/version.rb

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

data/lib/api_response.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+require 'dry-configurable'
+require 'dry-initializer'
+
+module ApiResponse
+  extend Dry::Configurable
+
+  setting :adapter, default: :faraday
+  setting :monad, default: false
+  setting :extract_from_body, default: ->(b) { b }
+  setting :struct, default: nil
+  setting :raw_response, default: false
+  setting :error_json, default: false
+  setting :default_return_value, default: nil
+  setting :default_status, default: :conflict
+  setting :symbol_status, default: true
+  setting :default_error_key, default: :external_api_error
+  setting :default_error, default: 'External Api error'
+
+  setting :success_processor, default: Processor::Success
+  setting :failure_processor, default: Processor::Failure
+  setting :parser, default: Parser
+  setting :options, default: {}
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: api-response-presenter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Rybolovlev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: dry-monads
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem for presenting API responses from Faraday and RestClient.
+email: i@golifox.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- api_response_presenter.gemspec
+- lib/api_response.rb
+- lib/api_response/parser.rb
+- lib/api_response/presenter.rb
+- lib/api_response/processor.rb
+- lib/api_response/processor/failure.rb
+- lib/api_response/processor/success.rb
+- lib/api_response/types.rb
+- lib/api_response/version.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  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: 2.7.4
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Gem for presenting API responses from Faraday and RestClient.
+test_files: []