plaid 14.11.1 → 14.12.0

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/lib/faraday/param_part.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Faraday
+  # 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::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

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/lib/faraday/parameters.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'faraday/encoders/nested_params_encoder'
+require 'faraday/encoders/flat_params_encoder'

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/lib/faraday/rack_builder.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require 'ruby2_keywords'
+require 'faraday/adapter_registry'
+
+module Faraday
+  # A Builder that processes requests into responses by passing through an inner
+  # middleware stack (heavily inspired by Rack).
+  #
+  # @example
+  #   Faraday::Connection.new(url: 'http://sushi.com') do |builder|
+  #     builder.request  :url_encoded  # Faraday::Request::UrlEncoded
+  #     builder.adapter  :net_http     # Faraday::Adapter::NetHttp
+  #   end
+  class RackBuilder
+    # Used to detect missing arguments
+    NO_ARGUMENT = Object.new
+
+    attr_accessor :handlers
+
+    # Error raised when trying to modify the stack after calling `lock!`
+    class StackLocked < RuntimeError; end
+
+    # borrowed from ActiveSupport::Dependencies::Reference &
+    # ActionDispatch::MiddlewareStack::Middleware
+    class Handler
+      REGISTRY = Faraday::AdapterRegistry.new
+
+      attr_reader :name
+
+      ruby2_keywords def initialize(klass, *args, &block)
+        @name = klass.to_s
+        REGISTRY.set(klass) if klass.respond_to?(:name)
+        @args = args
+        @block = block
+      end
+
+      def klass
+        REGISTRY.get(@name)
+      end
+
+      def inspect
+        @name
+      end
+
+      def ==(other)
+        if other.is_a? Handler
+          name == other.name
+        elsif other.respond_to? :name
+          klass == other
+        else
+          @name == other.to_s
+        end
+      end
+
+      def build(app = nil)
+        klass.new(app, *@args, &@block)
+      end
+    end
+
+    def initialize(handlers = [], adapter = nil, &block)
+      @adapter = adapter
+      @handlers = handlers
+      if block_given?
+        build(&block)
+      elsif @handlers.empty?
+        # default stack, if nothing else is configured
+        request :url_encoded
+        self.adapter Faraday.default_adapter
+      end
+    end
+
+    def build(options = {})
+      raise_if_locked
+      @handlers.clear unless options[:keep]
+      yield(self) if block_given?
+      adapter(Faraday.default_adapter) unless @adapter
+    end
+
+    def [](idx)
+      @handlers[idx]
+    end
+
+    # Locks the middleware stack to ensure no further modifications are made.
+    def lock!
+      @handlers.freeze
+    end
+
+    def locked?
+      @handlers.frozen?
+    end
+
+    ruby2_keywords def use(klass, *args, &block)
+      if klass.is_a? Symbol
+        use_symbol(Faraday::Middleware, klass, *args, &block)
+      else
+        raise_if_locked
+        raise_if_adapter(klass)
+        @handlers << self.class::Handler.new(klass, *args, &block)
+      end
+    end
+
+    ruby2_keywords def request(key, *args, &block)
+      use_symbol(Faraday::Request, key, *args, &block)
+    end
+
+    ruby2_keywords def response(key, *args, &block)
+      use_symbol(Faraday::Response, key, *args, &block)
+    end
+
+    ruby2_keywords def adapter(klass = NO_ARGUMENT, *args, &block)
+      return @adapter if klass == NO_ARGUMENT
+
+      klass = Faraday::Adapter.lookup_middleware(klass) if klass.is_a?(Symbol)
+      @adapter = self.class::Handler.new(klass, *args, &block)
+    end
+
+    ## methods to push onto the various positions in the stack:
+
+    ruby2_keywords def insert(index, *args, &block)
+      raise_if_locked
+      index = assert_index(index)
+      handler = self.class::Handler.new(*args, &block)
+      @handlers.insert(index, handler)
+    end
+
+    alias insert_before insert
+
+    ruby2_keywords def insert_after(index, *args, &block)
+      index = assert_index(index)
+      insert(index + 1, *args, &block)
+    end
+
+    ruby2_keywords def swap(index, *args, &block)
+      raise_if_locked
+      index = assert_index(index)
+      @handlers.delete_at(index)
+      insert(index, *args, &block)
+    end
+
+    def delete(handler)
+      raise_if_locked
+      @handlers.delete(handler)
+    end
+
+    # Processes a Request into a Response by passing it through this Builder's
+    # middleware stack.
+    #
+    # @param connection [Faraday::Connection]
+    # @param request [Faraday::Request]
+    #
+    # @return [Faraday::Response]
+    def build_response(connection, request)
+      app.call(build_env(connection, request))
+    end
+
+    # The "rack app" wrapped in middleware. All requests are sent here.
+    #
+    # The builder is responsible for creating the app object. After this,
+    # the builder gets locked to ensure no further modifications are made
+    # to the middleware stack.
+    #
+    # Returns an object that responds to `call` and returns a Response.
+    def app
+      @app ||= begin
+        lock!
+        to_app
+      end
+    end
+
+    def to_app
+      # last added handler is the deepest and thus closest to the inner app
+      # adapter is always the last one
+      @handlers.reverse.inject(@adapter.build) do |app, handler|
+        handler.build(app)
+      end
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        @handlers == other.handlers &&
+        @adapter == other.adapter
+    end
+
+    def dup
+      self.class.new(@handlers.dup, @adapter.dup)
+    end
+
+    # ENV Keys
+    # :http_method - a symbolized request HTTP method (:get, :post)
+    # :body   - the request body that will eventually be converted to a string.
+    # :url    - URI instance for the current request.
+    # :status           - HTTP response status code
+    # :request_headers  - hash of HTTP Headers to be sent to the server
+    # :response_headers - Hash of HTTP headers from the server
+    # :parallel_manager - sent if the connection is in parallel mode
+    # :request - Hash of options for configuring the request.
+    #   :timeout      - open/read timeout Integer in seconds
+    #   :open_timeout - read timeout Integer in seconds
+    #   :proxy        - Hash of proxy options
+    #     :uri        - Proxy Server URI
+    #     :user       - Proxy server username
+    #     :password   - Proxy server password
+    # :ssl - Hash of options for configuring SSL requests.
+    def build_env(connection, request)
+      exclusive_url = connection.build_exclusive_url(
+        request.path, request.params,
+        request.options.params_encoder
+      )
+
+      Env.new(request.http_method, request.body, exclusive_url,
+              request.options, request.headers, connection.ssl,
+              connection.parallel_manager)
+    end
+
+    private
+
+    LOCK_ERR = "can't modify middleware stack after making a request"
+
+    def raise_if_locked
+      raise StackLocked, LOCK_ERR if locked?
+    end
+
+    def raise_if_adapter(klass)
+      return unless is_adapter?(klass)
+
+      raise 'Adapter should be set using the `adapter` method, not `use`'
+    end
+
+    def adapter_set?
+      !@adapter.nil?
+    end
+
+    def is_adapter?(klass) # rubocop:disable Naming/PredicateName
+      klass <= Faraday::Adapter
+    end
+
+    ruby2_keywords def use_symbol(mod, key, *args, &block)
+      use(mod.lookup_middleware(key), *args, &block)
+    end
+
+    def assert_index(index)
+      idx = index.is_a?(Integer) ? index : @handlers.index(index)
+      raise "No such handler: #{index.inspect}" unless idx
+
+      idx
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/lib/faraday/request/authorization.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Faraday
+  class Request
+    # Request middleware for the Authorization HTTP header
+    class Authorization < Faraday::Middleware
+      unless defined?(::Faraday::Request::Authorization::KEY)
+        KEY = 'Authorization'
+      end
+
+      # @param type [String, Symbol]
+      # @param token [String, Symbol, Hash]
+      # @return [String] a header value
+      def self.header(type, token)
+        case token
+        when String, Symbol, Proc
+          token = token.call if token.is_a?(Proc)
+          "#{type} #{token}"
+        when Hash
+          build_hash(type.to_s, token)
+        else
+          raise ArgumentError,
+                "Can't build an Authorization #{type}" \
+                  "header from #{token.inspect}"
+        end
+      end
+
+      # @param type [String]
+      # @param hash [Hash]
+      # @return [String] type followed by comma-separated key=value pairs
+      # @api private
+      def self.build_hash(type, hash)
+        comma = ', '
+        values = []
+        hash.each do |key, value|
+          value = value.call if value.is_a?(Proc)
+          values << "#{key}=#{value.to_s.inspect}"
+        end
+        "#{type} #{values * comma}"
+      end
+
+      # @param app [#call]
+      # @param type [String, Symbol] Type of Authorization
+      # @param param [String, Symbol, Hash, Proc] parameter to build the Authorization header.
+      #   This value can be a proc, in which case it will be invoked on each request.
+      def initialize(app, type, param)
+        @type = type
+        @param = param
+        super(app)
+      end
+
+      # @param env [Faraday::Env]
+      def on_request(env)
+        return if env.request_headers[KEY]
+
+        env.request_headers[KEY] = self.class.header(@type, @param)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/lib/faraday/request/basic_authentication.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Faraday
+  class Request
+    # Authorization middleware for Basic Authentication.
+    class BasicAuthentication < load_middleware(:authorization)
+      # @param login [String]
+      # @param pass [String]
+      #
+      # @return [String] a Basic Authentication header line
+      def self.header(login, pass)
+        value = Base64.encode64([login, pass].join(':'))
+        value.delete!("\n")
+        super(:Basic, value)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/lib/faraday/request/instrumentation.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Faraday
+  class Request
+    # Middleware for instrumenting Requests.
+    class Instrumentation < Faraday::Middleware
+      # Options class used in Request::Instrumentation class.
+      class Options < Faraday::Options.new(:name, :instrumenter)
+        # @return [String]
+        def name
+          self[:name] ||= 'request.faraday'
+        end
+
+        # @return [Class]
+        def instrumenter
+          self[:instrumenter] ||= ActiveSupport::Notifications
+        end
+      end
+
+      # Instruments requests using Active Support.
+      #
+      # Measures time spent only for synchronous requests.
+      #
+      # @example Using ActiveSupport::Notifications to measure time spent
+      #   for Faraday requests.
+      #   ActiveSupport::Notifications
+      #     .subscribe('request.faraday') do |name, starts, ends, _, env|
+      #     url = env[:url]
+      #     http_method = env[:method].to_s.upcase
+      #     duration = ends - starts
+      #     $stderr.puts '[%s] %s %s (%.3f s)' %
+      #       [url.host, http_method, url.request_uri, duration]
+      #   end
+      # @param app [#call]
+      # @param options [nil, Hash] Options hash
+      # @option options [String] :name ('request.faraday')
+      #   Name of the instrumenter
+      # @option options [Class] :instrumenter (ActiveSupport::Notifications)
+      #   Active Support instrumenter class.
+      def initialize(app, options = nil)
+        super(app)
+        @name, @instrumenter = Options.from(options)
+                                      .values_at(:name, :instrumenter)
+      end
+
+      # @param env [Faraday::Env]
+      def call(env)
+        @instrumenter.instrument(@name, env) do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/faraday-1.8.0/lib/faraday/request/multipart.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require File.expand_path('url_encoded', __dir__)
+require 'securerandom'
+
+module Faraday
+  class Request
+    # Middleware for supporting multi-part requests.
+    class Multipart < UrlEncoded
+      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)
+        @options = options
+      end
+
+      # Checks for files in the payload, otherwise leaves everything untouched.
+      #
+      # @param env [Faraday::Env]
+      def call(env)
+        match_content_type(env) do |params|
+          env.request.boundary ||= unique_boundary
+          env.request_headers[CONTENT_TYPE] +=
+            "; boundary=#{env.request.boundary}"
+          env.body = create_multipart(env, params)
+        end
+        @app.call env
+      end
+
+      # @param env [Faraday::Env]
+      def process_request?(env)
+        type = request_type(env)
+        env.body.respond_to?(:each_key) && !env.body.empty? && (
+          (type.empty? && has_multipart?(env.body)) ||
+            (type == self.class.mime_type)
+        )
+      end
+
+      # Returns true if obj is an enumerable with values that are multipart.
+      #
+      # @param obj [Object]
+      # @return [Boolean]
+      def has_multipart?(obj) # rubocop:disable Naming/PredicateName
+        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)
+          end
+        end
+        false
+      end
+
+      # @param env [Faraday::Env]
+      # @param params [Hash]
+      def create_multipart(env, params)
+        boundary = env.request.boundary
+        parts = process_params(params) do |key, value|
+          part(boundary, key, value)
+        end
+        parts << Faraday::Parts::EpiloguePart.new(boundary)
+
+        body = Faraday::CompositeReadIO.new(parts)
+        env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
+        body
+      end
+
+      def part(boundary, key, value)
+        if value.respond_to?(:to_part)
+          value.to_part(boundary, key)
+        else
+          Faraday::Parts::Part.new(boundary, key, value)
+        end
+      end
+
+      # @return [String]
+      def unique_boundary
+        "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
+      end
+
+      # @param params [Hash]
+      # @param prefix [String]
+      # @param pieces [Array]
+      def process_params(params, prefix = nil, pieces = nil, &block)
+        params.inject(pieces || []) do |all, (key, value)|
+          if prefix
+            key = @options[:flat_encode] ? prefix.to_s : "#{prefix}[#{key}]"
+          end
+
+          case value
+          when Array
+            values = value.inject([]) { |a, v| a << [nil, v] }
+            process_params(values, key, all, &block)
+          when Hash
+            process_params(value, key, all, &block)
+          else
+            # rubocop:disable Performance/RedundantBlockCall
+            all << block.call(key, value)
+            # rubocop:enable Performance/RedundantBlockCall
+          end
+        end
+      end
+    end
+  end
+end