plaid 14.10.0 → 14.12.1

data/vendor/bundle/ruby/3.0.0/gems/faraday-multipart-1.0.3/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## Unreleased
+
+*   Initial release.

data/vendor/bundle/ruby/3.0.0/gems/faraday-multipart-1.0.3/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 The Faraday Team
+
+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/vendor/bundle/ruby/3.0.0/gems/faraday-multipart-1.0.3/README.md

@@ -0,0 +1,111 @@
+# Faraday Multipart
+
+[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/lostisland/faraday-multipart/ci)](https://github.com/lostisland/faraday-multipart/actions?query=branch%3Amain)
+[![Gem](https://img.shields.io/gem/v/faraday-multipart.svg?style=flat-square)](https://rubygems.org/gems/faraday-multipart)
+[![License](https://img.shields.io/github/license/lostisland/faraday-multipart.svg?style=flat-square)](LICENSE.md)
+
+The `Multipart` middleware converts a `Faraday::Request#body` Hash of key/value pairs into a multipart form request, but
+only under these conditions:
+
+* The request's Content-Type is "multipart/form-data"
+* Content-Type is unspecified, AND one of the values in the Body responds to
+  `#content_type`.
+
+Faraday contains a couple helper classes for multipart values:
+
+* `Faraday::Multipart::FilePart` wraps binary file data with a Content-Type. The file data can be specified with a String path to a
+  local file, or an IO object.
+* `Faraday::Multipart::ParamPart` wraps a String value with a Content-Type, and optionally a Content-ID.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'faraday-multipart'
+```
+
+And then execute:
+
+```shell
+bundle install
+```
+
+Or install it yourself as:
+
+```shell
+gem install faraday-multipart
+```
+
+## Usage
+
+First of all, you'll need to add the multipart middleware to your Faraday connection:
+
+```ruby
+require 'faraday/multipart'
+
+conn = Faraday.new(...) do |f|
+  f.request :multipart
+  # ...
+end
+```
+
+Payload can be a mix of POST data and multipart values.
+
+```ruby
+# regular POST form value
+payload = { string: 'value' }
+
+# filename for this value is File.basename(__FILE__)
+payload[:file] = Faraday::Multipart::FilePart.new(__FILE__, 'text/x-ruby')
+
+# specify filename because IO object doesn't know it
+payload[:file_with_name] = Faraday::Multipart::FilePart.new(
+  File.open(__FILE__),
+  'text/x-ruby',
+  File.basename(__FILE__)
+)
+
+# Sets a custom Content-Disposition:
+# nil filename still defaults to File.basename(__FILE__)
+payload[:file_with_header] = Faraday::Multipart::FilePart.new(
+  __FILE__,
+  'text/x-ruby',
+  nil,
+  'Content-Disposition' => 'form-data; foo=1'
+)
+
+# Upload raw json with content type
+payload[:raw_data] = Faraday::Multipart::ParamPart.new(
+  { a: 1 }.to_json,
+  'application/json'
+)
+
+# optionally sets Content-ID too
+payload[:raw_with_id] = Faraday::Multipart::ParamPart.new(
+  { a: 1 }.to_json,
+  'application/json',
+  'foo-123'
+)
+
+conn.post('/', payload)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+
+Then, run `bin/test` to run the tests.
+
+To install this gem onto your local machine, run `rake build`.
+
+To release a new version, make a commit with a message such as "Bumped to 0.0.2" and then run `rake release`. See how it
+works [here](https://bundler.io/guides/creating_gem.html#releasing-the-gem).
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/lostisland/faraday-multipart).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/vendor/bundle/ruby/3.0.0/gems/faraday-multipart-1.0.3/lib/faraday/multipart/file_part.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+# multipart-post gem
+require 'composite_io'
+require 'parts'
+
+module Faraday
+  module Multipart
+    # Multipart value used to POST a binary data from a file or
+    #
+    # @example
+    #   payload = { file: Faraday::FilePart.new("file_name.ext", "content/type") }
+    #   http.post("/upload", payload)
+    #
+
+    # @!method initialize(filename_or_io, content_type, filename = nil, opts = {})
+    #
+    #   @param filename_or_io [String, IO] Either a String filename to a local
+    #     file or an open IO object.
+    #   @param content_type [String] String content type of the file data.
+    #   @param filename [String] Optional String filename, usually to add context
+    #     to a given IO object.
+    #   @param opts [Hash] Optional Hash of String key/value pairs to describethis
+    #     this uploaded file. Expected Header keys include:
+    #     * Content-Transfer-Encoding - Defaults to "binary"
+    #     * Content-Disposition - Defaults to "form-data"
+    #     * Content-Type - Defaults to the content_type argument.
+    #     * Content-ID - Optional.
+    #
+    # @return [Faraday::FilePart]
+    #
+    # @!attribute [r] content_type
+    # The uploaded binary data's content type.
+    #
+    # @return [String]
+    #
+    # @!attribute [r] original_filename
+    # The base filename, taken either from the filename_or_io or filename
+    # arguments in #initialize.
+    #
+    # @return [String]
+    #
+    # @!attribute [r] opts
+    # Extra String key/value pairs to make up the header for this uploaded file.
+    #
+    # @return [Hash]
+    #
+    # @!attribute [r] io
+    # The open IO object for the uploaded file.
+    #
+    # @return [IO]
+    FilePart = ::UploadIO
+
+    Parts = ::Parts
+
+    # Similar to, but not compatible with CompositeReadIO provided by the
+    # multipart-post gem.
+    # https://github.com/nicksieger/multipart-post/blob/master/lib/composite_io.rb
+    class CompositeReadIO
+      def initialize(*parts)
+        @parts = parts.flatten
+        @ios = @parts.map(&:to_io)
+        @index = 0
+      end
+
+      # @return [Integer] sum of the lengths of all the parts
+      def length
+        @parts.inject(0) { |sum, part| sum + part.length }
+      end
+
+      # Rewind each of the IOs and reset the index to 0.
+      #
+      # @return [void]
+      def rewind
+        @ios.each(&:rewind)
+        @index = 0
+      end
+
+      # Read from IOs in order until `length` bytes have been received.
+      #
+      # @param length [Integer, nil]
+      # @param outbuf [String, nil]
+      def read(length = nil, outbuf = nil)
+        got_result = false
+        outbuf = outbuf ? (+outbuf).replace('') : +''
+
+        while (io = current_io)
+          if (result = io.read(length))
+            got_result ||= !result.nil?
+            result.force_encoding('BINARY') if result.respond_to?(:force_encoding)
+            outbuf << result
+            length -= result.length if length
+            break if length&.zero?
+          end
+          advance_io
+        end
+        !got_result && length ? nil : outbuf
+      end
+
+      # Close each of the IOs.
+      #
+      # @return [void]
+      def close
+        @ios.each(&:close)
+      end
+
+      def ensure_open_and_readable
+        # Rubinius compatibility
+      end
+
+      private
+
+      def current_io
+        @ios[@index]
+      end
+
+      def advance_io
+        @index += 1
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/{2.6.0/gems/faraday-1.8.0/lib/faraday/request/multipart.rb → 3.0.0/gems/faraday-multipart-1.0.3/lib/faraday/multipart/middleware.rb}

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
-require File.expand_path('url_encoded', __dir__)
 require 'securerandom'
 
 module Faraday
-  class Request
+  module Multipart
     # Middleware for supporting multi-part requests.
-    class Multipart < UrlEncoded
+    class Middleware < Faraday::Request::UrlEncoded
+      DEFAULT_BOUNDARY_PREFIX = '-----------RubyMultipartPost'
+
       self.mime_type = 'multipart/form-data'
-      unless defined?(::Faraday::Request::Multipart::DEFAULT_BOUNDARY_PREFIX)
-        DEFAULT_BOUNDARY_PREFIX = '-----------RubyMultipartPost'
-      end
 
       def initialize(app = nil, options = {})
         super(app)
@@ -43,7 +41,7 @@ module Faraday
       #
       # @param obj [Object]
       # @return [Boolean]
-      def has_multipart?(obj) # rubocop:disable Naming/PredicateName
+      def has_multipart?(obj)
         if obj.respond_to?(:each)
           (obj.respond_to?(:values) ? obj.values : obj).each do |val|
             return true if val.respond_to?(:content_type) || has_multipart?(val)
@@ -59,9 +57,9 @@ module Faraday
         parts = process_params(params) do |key, value|
           part(boundary, key, value)
         end
-        parts << Faraday::Parts::EpiloguePart.new(boundary)
+        parts << Faraday::Multipart::Parts::EpiloguePart.new(boundary)
 
-        body = Faraday::CompositeReadIO.new(parts)
+        body = Faraday::Multipart::CompositeReadIO.new(parts)
         env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
         body
       end
@@ -70,7 +68,7 @@ module Faraday
         if value.respond_to?(:to_part)
           value.to_part(boundary, key)
         else
-          Faraday::Parts::Part.new(boundary, key, value)
+          Faraday::Multipart::Parts::Part.new(boundary, key, value)
         end
       end
 
@@ -95,9 +93,7 @@ module Faraday
           when Hash
             process_params(value, key, all, &block)
           else
-            # rubocop:disable Performance/RedundantBlockCall
-            all << block.call(key, value)
-            # rubocop:enable Performance/RedundantBlockCall
+            all << block.call(key, value) # rubocop:disable Performance/RedundantBlockCall
           end
         end
       end

data/vendor/bundle/ruby/3.0.0/gems/faraday-multipart-1.0.3/lib/faraday/multipart/param_part.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Faraday
+  module Multipart
+    # Multipart value used to POST data with a content type.
+    class ParamPart
+      # @param value [String] Uploaded content as a String.
+      # @param content_type [String] String content type of the value.
+      # @param content_id [String] Optional String of this value's Content-ID.
+      #
+      # @return [Faraday::ParamPart]
+      def initialize(value, content_type, content_id = nil)
+        @value = value
+        @content_type = content_type
+        @content_id = content_id
+      end
+
+      # Converts this value to a form part.
+      #
+      # @param boundary [String] String multipart boundary that must not exist in
+      #   the content exactly.
+      # @param key [String] String key name for this value.
+      #
+      # @return [Faraday::Parts::Part]
+      def to_part(boundary, key)
+        Faraday::Multipart::Parts::Part.new(boundary, key, value, headers)
+      end
+
+      # Returns a Hash of String key/value pairs.
+      #
+      # @return [Hash]
+      def headers
+        {
+          'Content-Type' => content_type,
+          'Content-ID' => content_id
+        }
+      end
+
+      # The content to upload.
+      #
+      # @return [String]
+      attr_reader :value
+
+      # The value's content type.
+      #
+      # @return [String]
+      attr_reader :content_type
+
+      # The value's content ID, if given.
+      #
+      # @return [String, nil]
+      attr_reader :content_id
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/faraday-multipart-1.0.3/lib/faraday/multipart/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Faraday
+  module Multipart
+    VERSION = '1.0.3'
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/faraday-multipart-1.0.3/lib/faraday/multipart.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'multipart/file_part'
+require_relative 'multipart/param_part'
+require_relative 'multipart/middleware'
+require_relative 'multipart/version'
+
+module Faraday
+  # Main Faraday::Multipart module.
+  module Multipart
+    Faraday::Request.register_middleware(multipart: Faraday::Multipart::Middleware)
+  end
+
+  # Aliases for Faraday v1, these are all deprecated and will be removed in v2 of this middleware
+  FilePart = Multipart::FilePart
+  ParamPart = Multipart::ParamPart
+  Parts = Multipart::Parts
+  CompositeReadIO = Multipart::CompositeReadIO
+  UploadIO = ::UploadIO
+end

data/vendor/bundle/ruby/3.0.0/gems/faraday-retry-1.0.3/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## v1.0
+
+Initial release.
+This release consists of the same middleware that was previously bundled with Faraday but removed in Faraday v2.0, plus:
+
+### Fixed
+
+*  Retry middleware `retry_block` is not called if retry will not happen due to `max_interval`, https://github.com/lostisland/faraday/pull/1350

data/vendor/bundle/ruby/3.0.0/gems/faraday-retry-1.0.3/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Mattia Giuffrida
+
+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/vendor/bundle/ruby/3.0.0/gems/faraday-retry-1.0.3/README.md

@@ -0,0 +1,161 @@
+# Faraday Retry
+
+[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/lostisland/faraday-retry/CI)](https://github.com/lostisland/faraday-retry/actions?query=branch%3Amain)
+[![Gem](https://img.shields.io/gem/v/faraday-retry.svg?style=flat-square)](https://rubygems.org/gems/faraday-retry)
+[![License](https://img.shields.io/github/license/lostisland/faraday-retry.svg?style=flat-square)](LICENSE.md)
+
+The `Retry` middleware automatically retries requests that fail due to intermittent client
+or server errors (such as network hiccups).
+By default, it retries 2 times and handles only timeout exceptions.
+It can be configured with an arbitrary number of retries, a list of exceptions to handle,
+a retry interval, a percentage of randomness to add to the retry interval, and a backoff factor.
+The middleware can also handle the [`Retry-After`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After)
+header automatically when configured with the right status codes (see below for an example).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'faraday-retry'
+```
+
+And then execute:
+
+```shell
+bundle install
+```
+
+Or install it yourself as:
+
+```shell
+gem install faraday-retry
+```
+
+## Usage
+
+This example will result in a first interval that is random between 0.05 and 0.075
+and a second interval that is random between 0.1 and 0.125.
+
+```ruby
+require 'faraday'
+require 'faraday/retry'
+
+retry_options = {
+  max: 2,
+  interval: 0.05,
+  interval_randomness: 0.5,
+  backoff_factor: 2
+}
+
+conn = Faraday.new(...) do |f|
+  f.request :retry, retry_options
+  #...
+end
+
+conn.get('/')
+```
+
+### Control when the middleware will retry requests
+
+By default, the `Retry` middleware will only retry idempotent methods and the most common network-related exceptions.
+You can change this behaviour by providing the right option when adding the middleware to your connection.
+
+#### Specify which methods will be retried
+
+You can provide a `methods` option with a list of HTTP methods.
+This will replace the default list of HTTP methods: `delete`, `get`, `head`, `options`, `put`.
+
+```ruby
+retry_options = {
+  methods: %i[get post]
+}
+```
+
+#### Specify which exceptions should trigger a retry
+
+You can provide an `exceptions` option with a list of exceptions that will replace
+the default list of network-related exceptions: `Errno::ETIMEDOUT`, `Timeout::Error`, `Faraday::TimeoutError`.
+This can be particularly useful when combined with the [RaiseError][raise_error] middleware.
+
+```ruby
+retry_options = {
+  exceptions: [Faraday::ResourceNotFound, Faraday::UnauthorizedError]
+}
+```
+
+#### Specify on which response statuses to retry
+
+By default the `Retry` middleware will only retry the request if one of the expected exceptions arise.
+However, you can specify a list of HTTP statuses you'd like to be retried. When you do so, the middleware will
+check the response `status` code and will retry the request if included in the list.
+
+```ruby
+retry_options = {
+  retry_statuses: [401, 409]
+}
+```
+
+#### Automatically handle the `Retry-After` header
+
+Some APIs, like the [Slack API](https://api.slack.com/docs/rate-limits), will inform you when you reach their API limits by replying with a response status code of `429` and a response header of `Retry-After` containing a time in seconds. You should then only retry querying after the amount of time provided by the `Retry-After` header, otherwise you won't get a response.
+
+You can automatically handle this and have Faraday pause and retry for the right amount of time by including the `429` status code in the retry statuses list:
+
+```ruby
+retry_options = {
+  retry_statuses: [429]
+}
+```
+
+#### Specify a custom retry logic
+
+You can also specify a custom retry logic with the `retry_if` option.
+This option accepts a block that will receive the `env` object and the exception raised
+and should decide if the code should retry still the action or not independent of the retry count.
+This would be useful if the exception produced is non-recoverable or if the the HTTP method called is not idempotent.
+
+**NOTE:** this option will only be used for methods that are not included in the `methods` option.
+If you want this to apply to all HTTP methods, pass `methods: []` as an additional option.
+
+```ruby
+# Retries the request if response contains { success: false }
+retry_options = {
+  retry_if: -> (env, _exc) { env.body[:success] == 'false' }
+}
+```
+
+### Call a block on every retry
+
+You can specify a block through the `retry_block` option that will be called before every retry.
+There are many different applications for this feature, spacing from instrumentation to monitoring.
+Request environment, middleware options, current number of retries and the exception is passed to the block as parameters.
+For example, you might want to keep track of the response statuses:
+
+```ruby
+response_statuses = []
+retry_options = {
+  retry_block: -> (env, options, retries, exc) { response_statuses << env.status }
+}
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+
+Then, run `bin/test` to run the tests.
+
+To install this gem onto your local machine, run `rake build`.
+
+To release a new version, make a commit with a message such as "Bumped to 0.0.2" and then run `rake release`.
+See how it works [here](https://bundler.io/guides/creating_gem.html#releasing-the-gem).
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/lostisland/faraday-retry).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+[raise_error]:  https://lostisland.github.io/faraday/middleware/raise-error

data/vendor/bundle/ruby/3.0.0/gems/faraday-retry-1.0.3/lib/faraday/retriable_response.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Faraday namespace.
+module Faraday
+  # Exception used to control the Retry middleware.
+  class RetriableResponse < Error
+  end
+end