checkify 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fb398a2b3bac9a1ef8b2093c1fe8122611de7d42ba9d53c0b05d2e65ef13129
-  data.tar.gz: 054d9fad13402d278031a748842987984164f46f3cb52a71c76c3868cde1d624
+  metadata.gz: 57474e58be9780c71d786e3ae001a38e14b5320fa83bbdae395a7b23272aef10
+  data.tar.gz: bddf837200c5e0cb2eec5aa99ba409b67d9c7e802974e5dc7df0e9046f23c670
 SHA512:
-  metadata.gz: 6e43d7f516b7a591419dbdb834302c8a20f20842d423e659cfa9348f7271df494d0640ce863eb36c7fd1f33e40145dfc0cfbee2430539499760998bb643cb48a
-  data.tar.gz: 7559c9c422bb50c8ed3c4d7e4792b95cf1a5bd52ec5b6427147663823e064e7d219d665777c0b996473522d67cc0b25f325bd03c1059fbad62acdd136a2fedba
+  metadata.gz: 882f84f2d61afdd65c10be77f6644515941876578a73fda196dd4497e923054d869122b19b95c7d8782a95a1354832d5e51d4cca05d2e6d711f1b1cd29498df6
+  data.tar.gz: 2c5a1b32f471902158efbdb0b52a41e38cfe85c78545c03c269bbd88ad353a09f51e6987b355e799a1d0038f8dfbbefa4848ae38cbff74ffbddf088a699f587e

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.2.0 (2026-10-06)
+
+- Replace Typhoeus with Faraday 2, using Faraday's default adapter and removing the libcurl/FFI dependency.
+- Keep the per-client API, VCR recordings, multipart uploads, redirect opt-out, streamed CSV downloads, and Checkify error handling.
+- Advanced transport configuration and timeout semantics now follow Faraday; see the README migration notes.
+
 ## 0.1.0 (2026-09-05)
 
 - Initial Ruby client for Checkify's address, business, identity, communication, account, and bulk APIs.

data/README.md

@@ -4,12 +4,12 @@ Unofficial Ruby client for the [Checkify API](https://checkify.com.au/developers
 
 ## Installation
 
-Requires Ruby 3.3 or later and libcurl (normally included with macOS and Linux).
+Requires Ruby 3.3 or later. HTTP requests use Faraday and its default adapter; no libcurl installation is needed.
 
 Add to your Gemfile:
 
 ```ruby
-gem "checkify", "~> 0.1.0"
+gem "checkify", "~> 0.2.0"
 ```
 
 Then run `bundle install`.
@@ -22,8 +22,9 @@ require "checkify"
 client = Checkify::Client.new(api_key: ENV.fetch("CHECKIFY_API_KEY"))
 ```
 
-Each client has its own credentials and configuration. Requests time out after 30
-seconds by default; pass `timeout: 60` to change this (or `timeout: 0` to disable it).
+Each client has its own credentials and configuration. The default Faraday timeout
+is 30 seconds; pass `timeout: 60` to change it. The selected adapter determines how
+timeouts apply (Net::HTTP applies separate open, read, and write limits).
 For advanced configuration, pass a block:
 
 ```ruby
@@ -147,6 +148,39 @@ account.units_remaining  # => 48760
 account.usage            # => { "autocomplete" => 520, "abn" => 295, ... }
 ```
 
+## Upgrading from 0.1
+
+Version 0.2 replaces Typhoeus with Faraday 2. `Checkify::Client`, endpoint methods,
+response models, and `Checkify::ApiError` remain available. Advanced transport
+configuration changes:
+
+| Version 0.1 | Version 0.2 |
+|---|---|
+| `verify_ssl` | `ssl_verify` |
+| `ssl_ca_cert` | `ssl_ca_file` |
+| `cert_file` / `key_file` (file paths) | `ssl_client_cert` / `ssl_client_key` (OpenSSL objects) |
+| `params_encoding` | `params_encoder` (Faraday encoder) |
+| `ApiClient#build_request` returns a Typhoeus request | Returns a Faraday request |
+
+Timeouts now follow the selected Faraday adapter, rather than libcurl's total
+request deadline. `timeout: 0` no longer means an unlimited timeout with the default
+Net::HTTP adapter; use a suitable positive timeout. TLS hostname verification uses
+the adapter's default; the old `verify_ssl_host` option is removed.
+
+The gem leaves adapter selection to Faraday. Applications can set
+`Faraday.default_adapter` before creating clients, or configure a single client:
+
+```ruby
+client = Checkify::Client.new(api_key: ENV.fetch("CHECKIFY_API_KEY")) do |config|
+  config.configure_faraday_connection do |connection|
+    # Configure middleware or an adapter here after requiring its gem.
+  end
+end
+```
+
+CSV downloads stream to temporary files with adapters that support Faraday's
+streaming callback. Other adapters fall back to their buffered response.
+
 ## Bulk processing
 
 Bulk processing requires an eligible Checkify subscription. JSON input accepts strings for
@@ -248,7 +282,7 @@ responses. Business fixtures use [Bunnings Group Limited (ABN 26 008 672 179)](h
 Other examples use public addresses, Checkify's documented sample identifiers, and
 `person@example.com`. Bulk tests use explicitly simulated responses because the
 recording account does not have a bulk subscription; the multipart test verifies
-libcurl's actual HTTP upload against a local test server.
+Faraday's actual HTTP upload against a local test server.
 
 ### Recording against production
 
@@ -288,8 +322,8 @@ bundle exec rake generate
 bundle exec rake
 ```
 
-`script/generate` uses `generator/config.yaml`, applies the multipart, redirect,
-and timeout fixes to the upstream Ruby templates, regenerates the generated files
+`script/generate` uses `generator/config.yaml` and the Faraday transport template
+in `generator/templates/`, applies the shared template fixes, regenerates the generated files
 in `lib/` and `docs/`, and applies the project's lint rules. The handwritten
 `lib/checkify/client.rb`, tests, gemspec, README, and CI are preserved.
 Change the input spec or generator customization before regenerating; do not patch

data/lib/checkify/api_client.rb

@@ -15,7 +15,11 @@ require 'json'
 require 'logger'
 require 'tempfile'
 require 'time'
-require 'typhoeus'
+require 'faraday'
+require 'faraday/follow_redirects'
+require 'timeout'
+require 'faraday/multipart' if Gem::Version.new(Faraday::VERSION) >= Gem::Version.new('2.0')
+require 'marcel'
 
 
 module Checkify
@@ -43,165 +47,133 @@ module Checkify
       @@default ||= ApiClient.new
     end
 
-    # Call an API with given options.
-    #
-    # @return [Array<(Object, Integer, Hash)>] an array of 3 elements:
-    #   the data deserialized from response body (may be a Tempfile or nil), response status code and response headers.
+    # Faraday transport. Keep downloads on disk and preserve Checkify::ApiError.
     def call_api(http_method, path, opts = {})
-      request = build_request(http_method, path, opts)
-      tempfile = nil
-      (download_file(request) { tempfile = _1 }) if opts[:return_type] == 'File'
-      response = request.run
-
-      if @config.debugging
-        @config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
+      file = nil
+      result = nil
+      error_body = +''
+      download = ['File', 'Binary'].include?(opts[:return_type])
+      response = connection(opts).run_request(http_method.to_s.downcase.to_sym, nil, nil, nil) do |request|
+        build_request(http_method, path, opts, request)
+        if download
+          request.options.on_data = proc do |chunk, received, env|
+            if (200...300).cover?(env.status)
+              file ||= download_file(env.response_headers)
+              file.write(chunk)
+            else
+              error_body.clear if received == chunk.bytesize
+              error_body << chunk
+            end
+          end
+        end
       end
 
       unless response.success?
-        if response.timed_out?
-          fail ApiError.new('Connection timed out')
-        elsif response.code == 0
-          # Errors from libcurl will be made visible here
-          fail ApiError.new(:code => 0,
-                            :message => response.return_message)
-        else
-          fail ApiError.new(:code => response.code,
-                            :response_headers => response.headers,
-                            :response_body => response.body),
-               response.status_message
-        end
+        fail ApiError.new(code: response.status, response_headers: response.headers,
+                          response_body: download && !error_body.empty? ? error_body : response.body), response.reason_phrase
       end
 
-      if opts[:return_type] == 'File'
-        data = tempfile
+      if download
+        # Adapters without streaming support may return the body normally.
+        unless file
+          file = download_file(response.headers)
+          file.write(response.body.to_s)
+        end
+        file.close
+        result = config.return_binary_data ? File.binread(file.path) : file
       elsif opts[:return_type]
-        data = deserialize(response, opts[:return_type])
-      else
-        data = nil
+        config.logger.debug "HTTP response body: #{response.body}" if config.debugging
+        result = deserialize(response, opts[:return_type])
       end
-      return data, response.code, response.headers
+      return result, response.status, response.headers
+    rescue Faraday::TimeoutError
+      fail ApiError.new('Connection timed out')
+    rescue Faraday::Error => error
+      message = error.cause.is_a?(Timeout::Error) ? 'Connection timed out' : error.message
+      fail ApiError.new(code: 0, message: message)
+    ensure
+      file&.close! unless result.equal?(file)
     end
 
-    # Builds the HTTP request
-    #
-    # @param [String] http_method HTTP method/verb (e.g. POST)
-    # @param [String] path URL path (e.g. /account/new)
-    # @option opts [Hash] :header_params Header parameters
-    # @option opts [Hash] :query_params Query parameters
-    # @option opts [Hash] :form_params Query parameters
-    # @option opts [Object] :body HTTP body (JSON/XML)
-    # @return [Typhoeus::Request] A Typhoeus Request
-    def build_request(http_method, path, opts = {})
-      url = build_request_url(path, opts)
-      http_method = http_method.to_sym.downcase
-
+    # Build a request without sending it. The optional request is supplied by Faraday.
+    def build_request(http_method, path, opts = {}, request = Faraday::Request.new)
       header_params = @default_headers.merge(opts[:header_params] || {})
-      query_params = opts[:query_params] || {}
-      form_params = opts[:form_params] || {}
-      follow_location = opts.fetch(:follow_location, true)
-
+      query_params = (opts[:query_params] || {}).dup
       update_params_for_auth! header_params, query_params, opts[:auth_names]
-
-      # set ssl_verifyhosts option based on @config.verify_ssl_host (true/false)
-      _verify_ssl_host = @config.verify_ssl_host ? 2 : 0
-
-      req_opts = {
-        :method => http_method,
-        :headers => header_params,
-        :params => query_params,
-        :params_encoding => @config.params_encoding,
-        :timeout => @config.timeout,
-        :ssl_verifypeer => @config.verify_ssl,
-        :ssl_verifyhost => _verify_ssl_host,
-        :sslcert => @config.cert_file,
-        :sslkey => @config.key_file,
-        :verbose => @config.debugging,
-        :followlocation => follow_location
-      }
-
-      # set custom cert, if provided
-      req_opts[:cainfo] = @config.ssl_ca_cert if @config.ssl_ca_cert
-
-      if [:post, :patch, :put, :delete].include?(http_method)
-        req_body = build_request_body(header_params, form_params, opts[:body])
-        req_opts.update :body => req_body
-        if @config.debugging
-          @config.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
-        end
+      request.http_method = http_method.to_s.downcase.to_sym
+      request.headers = header_params
+      if [:post, :patch, :put, :delete].include?(request.http_method)
+        request.body = build_request_body(header_params, opts[:form_params] || {}, opts[:body])
       end
-
-      Typhoeus::Request.new(url, req_opts)
+      request.options = Faraday::RequestOptions.new unless request.options
+      request.options.params_encoder = config.params_encoder
+      request.options.timeout = config.timeout
+      request.params = Faraday::Utils::ParamsHash.new.merge(query_params)
+      request.url build_request_url(path, opts)
+      request
     end
 
-    # Builds the HTTP request body
-    #
-    # @param [Hash] header_params Header parameters
-    # @param [Hash] form_params Query parameters
-    # @param [Object] body HTTP body (JSON/XML)
-    # @return [String] HTTP body data in the form of string
     def build_request_body(header_params, form_params, body)
-      # http form
-      if header_params['Content-Type'] == 'application/x-www-form-urlencoded' ||
-          header_params['Content-Type'] == 'multipart/form-data'
-        data = {}
-        form_params.each do |key, value|
+      case header_params['Content-Type']
+      when 'application/x-www-form-urlencoded'
+        URI.encode_www_form(form_params)
+      when 'multipart/form-data'
+        form_params.transform_values do |value|
           case value
-          when ::File, ::Array, nil
-            # let typhoeus handle File, Array and nil parameters
-            data[key] = value
+          when ::File, ::Tempfile
+            Faraday::Multipart::FilePart.new(value, Marcel::MimeType.for(Pathname.new(value.path)), File.basename(value.path))
+          when ::Array, nil
+            value
           else
-            data[key] = value.to_s
+            value.to_s
           end
         end
-      elsif body
-        data = body.is_a?(String) ? body : body.to_json
       else
-        data = nil
+        body.is_a?(String) ? body : body&.to_json
       end
-      data
     end
 
-    # Save response body into a file in (the defined) temporary folder, using the filename
-    # from the "Content-Disposition" header if provided, otherwise a random filename.
-    # The response body is written to the file in chunks in order to handle files which
-    # size is larger than maximum Ruby String or even larger than the maximum memory a Ruby
-    # process can use.
-    #
-    # @see Configuration#temp_folder_path
-    #
-    # @return [Tempfile] the tempfile generated
-    def download_file(request)
-      tempfile = nil
-      encoding = nil
-      request.on_headers do |response|
-        content_disposition = response.headers['Content-Disposition']
-        if content_disposition && content_disposition =~ /filename=/i
-          filename = content_disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
-          prefix = sanitize_filename(filename)
-        else
-          prefix = 'download-'
-        end
-        prefix = prefix + '-' unless prefix.end_with?('-')
-        encoding = response.body.encoding
-        tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
-      end
-      request.on_body do |chunk|
-        chunk.force_encoding(encoding)
-        tempfile.write(chunk)
-      end
-      request.on_complete do
-        if !tempfile
-          fail ApiError.new("Failed to create the tempfile based on the HTTP response from the server: #{request.inspect}")
+    def download_file(headers)
+      disposition = headers['Content-Disposition'].to_s
+      filename = disposition[/filename=['"]?([^'"\s]+)['"]?/, 1]
+      prefix = filename ? sanitize_filename(filename) : 'download'
+      Tempfile.new("#{prefix}-", config.temp_folder_path, binmode: true)
+    end
+
+    def connection(opts = {})
+      multipart = opts.fetch(:header_params, {})['Content-Type'] == 'multipart/form-data'
+      follow_location = opts.fetch(:follow_location, true)
+      @connections ||= {}
+      @connections[[multipart, follow_location]] ||= build_connection(multipart: multipart, follow_location: follow_location)
+    end
+
+    def build_connection(multipart: false, follow_location: true)
+      Faraday.new(url: config.base_url, ssl: ssl_options, proxy: config.proxy) do |conn|
+        if follow_location
+          # Also cover scheme-relative URLs, which the middleware treats as local paths.
+          conn.response :follow_redirects, callback: lambda { |from, to|
+            if [from.url.scheme, from.url.host, from.url.port] != [to.url.scheme, to.url.host, to.url.port]
+              to.request_headers.delete('Authorization')
+            end
+          }
         end
-        tempfile.close
-        @config.logger.info "Temp file written to #{tempfile.path}, please copy the file to a proper folder "\
-                            "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file "\
-                            "will be deleted automatically with GC. It's also recommended to delete the temp file "\
-                            "explicitly with `tempfile.delete`"
-        yield tempfile if block_given?
+        conn.request :multipart if multipart
+        config.configure_middleware(conn)
+        config.configure_connection(conn)
+        # Faraday installs its default adapter if the application did not choose one.
       end
     end
 
+    def ssl_options
+      {
+        ca_file: config.ssl_ca_file,
+        verify: config.ssl_verify,
+        verify_mode: config.ssl_verify_mode,
+        client_cert: config.ssl_client_cert,
+        client_key: config.ssl_client_key
+      }
+    end
+
     # Check if the given MIME is a JSON MIME.
     # JSON MIME examples:
     #   application/json
@@ -387,7 +359,7 @@ module Checkify
       when :pipes
         param.join('|')
       when :multi
-        # return the array directly as typhoeus will handle it as expected
+        # return the array directly for the configured parameters encoder
         param
       else
         fail "unknown collection format: #{collection_format.inspect}"

data/lib/checkify/configuration.rb

@@ -101,7 +101,7 @@ module Checkify
     attr_accessor :temp_folder_path
 
     # The time limit for HTTP request in seconds.
-    # Default to 30 seconds; set to 0 to disable the timeout.
+    # Default to 30 seconds. Timeout behavior follows the selected Faraday adapter.
     attr_accessor :timeout
 
     # Set this to false to skip client side validation in the operation.
@@ -116,40 +116,39 @@ module Checkify
     # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
     #
     # @return [true, false]
-    attr_accessor :verify_ssl
+    attr_accessor :ssl_verify
 
     ### TLS/SSL setting
-    # Set this to false to skip verifying SSL host name
-    # Default to true.
+    # Any `OpenSSL::SSL::` constant (see https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL/SSL.html)
     #
     # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
     #
-    # @return [true, false]
-    attr_accessor :verify_ssl_host
+    attr_accessor :ssl_verify_mode
 
     ### TLS/SSL setting
     # Set this to customize the certificate file to verify the peer.
     #
     # @return [String] the path to the certificate file
-    #
-    # @see The `cainfo` option of Typhoeus, `--cert` option of libcurl. Related source code:
-    # https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/easy_factory.rb#L145
-    attr_accessor :ssl_ca_cert
+    attr_accessor :ssl_ca_file
 
     ### TLS/SSL setting
     # Client certificate file (for client certificate)
-    attr_accessor :cert_file
+    attr_accessor :ssl_client_cert
 
     ### TLS/SSL setting
     # Client private key file (for client certificate)
-    attr_accessor :key_file
+    attr_accessor :ssl_client_key
 
-    # Set this to customize parameters encoding of array parameter with multi collectionFormat.
-    # Default to nil.
+    ### Proxy setting
+    # HTTP Proxy settings
+    attr_accessor :proxy
+
+    # Set this to customize parameters encoder of array parameter.
+    # Default to nil. Faraday uses NestedParamsEncoder when nil.
     #
-    # @see The params_encoding option of Ethon. Related source code:
-    # https://github.com/typhoeus/ethon/blob/master/lib/ethon/easy/queryable.rb#L96
-    attr_accessor :params_encoding
+    # @see The params_encoder option of Faraday. Related source code:
+    # https://github.com/lostisland/faraday/tree/main/lib/faraday/encoders
+    attr_accessor :params_encoder
 
 
     attr_accessor :inject_format
@@ -167,12 +166,17 @@ module Checkify
       @api_key = {}
       @api_key_prefix = {}
       @client_side_validation = true
-      @verify_ssl = true
-      @verify_ssl_host = true
-      @cert_file = nil
-      @key_file = nil
+      @ssl_verify = true
+      @ssl_verify_mode = nil
+      @ssl_ca_file = nil
+      @ssl_client_cert = nil
+      @ssl_client_key = nil
+      @middlewares = Hash.new { |h, k| h[k] = [] }
+      @configure_connection_blocks = []
       @timeout = 30
-      @params_encoding = nil
+      # return data as binary instead of file
+      @return_binary_data = false
+      @params_encoder = nil
       @debugging = false
       @ignore_operation_servers = false
       @inject_format = false
@@ -301,5 +305,86 @@ module Checkify
 
       url
     end
+
+    # Configure Faraday connection directly.
+    #
+    # ```
+    # c.configure_faraday_connection do |conn|
+    #   conn.use Faraday::HttpCache, shared_cache: false, logger: logger
+    #   conn.response :logger, nil, headers: true, bodies: true, log_level: :debug do |logger|
+    #     logger.filter(/(Authorization: )(.*)/, '\1[REDACTED]')
+    #   end
+    # end
+    #
+    # c.configure_faraday_connection do |conn|
+    #   conn.adapter Faraday.default_adapter
+    # end
+    # ```
+    #
+    # @param block [Proc] `#call`able object that takes one arg, the connection
+    def configure_faraday_connection(&block)
+      @configure_connection_blocks << block
+    end
+
+    def configure_connection(conn)
+      @configure_connection_blocks.each do |block|
+        block.call(conn)
+      end
+    end
+
+    # Adds middleware to the stack
+    def use(*middleware)
+      set_faraday_middleware(:use, *middleware)
+    end
+
+    # Adds request middleware to the stack
+    def request(*middleware)
+      set_faraday_middleware(:request, *middleware)
+    end
+
+    # Adds response middleware to the stack
+    def response(*middleware)
+      set_faraday_middleware(:response, *middleware)
+    end
+
+    # Adds Faraday middleware setting information to the stack
+    #
+    # @example Use the `set_faraday_middleware` method to set middleware information
+    #   config.set_faraday_middleware(:request, :retry, max: 3, methods: [:get, :post], retry_statuses: [503])
+    #   config.set_faraday_middleware(:response, :logger, nil, { bodies: true, log_level: :debug })
+    #   config.set_faraday_middleware(:use, Faraday::HttpCache, store: Rails.cache, shared_cache: false)
+    #   config.set_faraday_middleware(:insert, 0, FaradayMiddleware::FollowRedirects, { standards_compliant: true, limit: 1 })
+    #   config.set_faraday_middleware(:swap, 0, Faraday::Response::Logger)
+    #   config.set_faraday_middleware(:delete, Faraday::Multipart::Middleware)
+    #
+    # @see https://github.com/lostisland/faraday/blob/v2.3.0/lib/faraday/rack_builder.rb#L92-L143
+    def set_faraday_middleware(operation, key, *args, &block)
+      unless [:request, :response, :use, :insert, :insert_before, :insert_after, :swap, :delete].include?(operation)
+        fail ArgumentError, "Invalid faraday middleware operation #{operation}. Must be" \
+                            " :request, :response, :use, :insert, :insert_before, :insert_after, :swap or :delete."
+      end
+
+      @middlewares[operation] << [key, args, block]
+    end
+    ruby2_keywords(:set_faraday_middleware) if respond_to?(:ruby2_keywords, true)
+
+    # Set up middleware on the connection
+    def configure_middleware(connection)
+      return if @middlewares.empty?
+
+      [:request, :response, :use, :insert, :insert_before, :insert_after, :swap].each do |operation|
+        next unless @middlewares.key?(operation)
+
+        @middlewares[operation].each do |key, args, block|
+          connection.builder.send(operation, key, *args, &block)
+        end
+      end
+
+      if @middlewares.key?(:delete)
+        @middlewares[:delete].each do |key, _args, _block|
+          connection.builder.delete(key)
+        end
+      end
+    end
   end
 end

data/lib/checkify/version.rb

@@ -11,5 +11,5 @@ Generator version: 7.21.0
 =end
 
 module Checkify
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: checkify
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ben Caldwell
@@ -24,25 +24,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
-  name: typhoeus
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-    - - ">="
+        version: '2.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: faraday-follow_redirects
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: marcel
+  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.1
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement