es_cli 0.1.0

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/response/logger.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'logger'
+require 'faraday/logging/formatter'
+
+module Faraday
+  class Response
+    # Logger is a middleware that logs internal events in the HTTP request
+    # lifecycle to a given Logger object. By default, this logs to STDOUT. See
+    # Faraday::Logging::Formatter to see specifically what is logged.
+    class Logger < Middleware
+      def initialize(app, logger = nil, options = {})
+        super(app)
+        logger ||= ::Logger.new($stdout)
+        formatter_class = options.delete(:formatter) || Logging::Formatter
+        @formatter = formatter_class.new(logger: logger, options: options)
+        yield @formatter if block_given?
+      end
+
+      def call(env)
+        @formatter.request(env)
+        super
+      end
+
+      def on_complete(env)
+        @formatter.response(env)
+      end
+
+      def on_error(exc)
+        @formatter.exception(exc) if @formatter.respond_to?(:exception)
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware(logger: Faraday::Response::Logger)

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/response/raise_error.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Faraday
+  class Response
+    # RaiseError is a Faraday middleware that raises exceptions on common HTTP
+    # client or server error responses.
+    class RaiseError < Middleware
+      # rubocop:disable Naming/ConstantName
+      ClientErrorStatuses = (400...500)
+      ServerErrorStatuses = (500...600)
+      ClientErrorStatusesWithCustomExceptions = {
+        400 => Faraday::BadRequestError,
+        401 => Faraday::UnauthorizedError,
+        403 => Faraday::ForbiddenError,
+        404 => Faraday::ResourceNotFound,
+        408 => Faraday::RequestTimeoutError,
+        409 => Faraday::ConflictError,
+        422 => Faraday::UnprocessableEntityError,
+        429 => Faraday::TooManyRequestsError
+      }.freeze
+      # rubocop:enable Naming/ConstantName
+
+      DEFAULT_OPTIONS = { include_request: true, allowed_statuses: [] }.freeze
+
+      def on_complete(env)
+        return if Array(options[:allowed_statuses]).include?(env[:status])
+
+        case env[:status]
+        when *ClientErrorStatusesWithCustomExceptions.keys
+          raise ClientErrorStatusesWithCustomExceptions[env[:status]], response_values(env)
+        when 407
+          # mimic the behavior that we get with proxy requests with HTTPS
+          msg = %(407 "Proxy Authentication Required")
+          raise Faraday::ProxyAuthError.new(msg, response_values(env))
+        when ClientErrorStatuses
+          raise Faraday::ClientError, response_values(env)
+        when ServerErrorStatuses
+          raise Faraday::ServerError, response_values(env)
+        when nil
+          raise Faraday::NilStatusError, response_values(env)
+        end
+      end
+
+      # Returns a hash of response data with the following keys:
+      #   - status
+      #   - headers
+      #   - body
+      #   - request
+      #
+      # The `request` key is omitted when the middleware is explicitly
+      # configured with the option `include_request: false`.
+      def response_values(env)
+        response = {
+          status: env.status,
+          headers: env.response_headers,
+          body: env.body
+        }
+
+        # Include the request data by default. If the middleware was explicitly
+        # configured to _not_ include request data, then omit it.
+        return response unless options[:include_request]
+
+        response.merge(
+          request: {
+            method: env.method,
+            url: env.url,
+            url_path: env.url.path,
+            params: query_params(env),
+            headers: env.request_headers,
+            body: env.request_body
+          }
+        )
+      end
+
+      def query_params(env)
+        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+        env.params_encoder.decode(env.url.query)
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware(raise_error: Faraday::Response::RaiseError)

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/response.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Faraday
+  # Response represents an HTTP response from making an HTTP request.
+  class Response
+    extend Forwardable
+    extend MiddlewareRegistry
+
+    def initialize(env = nil)
+      @env = Env.from(env) if env
+      @on_complete_callbacks = []
+    end
+
+    attr_reader :env
+
+    def status
+      finished? ? env.status : nil
+    end
+
+    def reason_phrase
+      finished? ? env.reason_phrase : nil
+    end
+
+    def headers
+      finished? ? env.response_headers : {}
+    end
+
+    def_delegator :headers, :[]
+
+    def body
+      finished? ? env.body : nil
+    end
+
+    def finished?
+      !!env
+    end
+
+    def on_complete(&block)
+      if finished?
+        yield(env)
+      else
+        @on_complete_callbacks << block
+      end
+      self
+    end
+
+    def finish(env)
+      raise 'response already finished' if finished?
+
+      @env = env.is_a?(Env) ? env : Env.from(env)
+      @on_complete_callbacks.each { |callback| callback.call(@env) }
+      self
+    end
+
+    def success?
+      finished? && env.success?
+    end
+
+    def to_hash
+      {
+        status: env.status, body: env.body,
+        response_headers: env.response_headers,
+        url: env.url
+      }
+    end
+
+    # because @on_complete_callbacks cannot be marshalled
+    def marshal_dump
+      finished? ? to_hash : nil
+    end
+
+    def marshal_load(env)
+      @env = Env.from(env)
+    end
+
+    # Expand the env with more properties, without overriding existing ones.
+    # Useful for applying request params after restoring a marshalled Response.
+    def apply_request(request_env)
+      raise "response didn't finish yet" unless finished?
+
+      @env = Env.from(request_env).update(@env)
+      self
+    end
+  end
+end
+
+require 'faraday/response/json'
+require 'faraday/response/logger'
+require 'faraday/response/raise_error'

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/utils/headers.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Faraday
+  module Utils
+    # A case-insensitive Hash that preserves the original case of a header
+    # when set.
+    #
+    # Adapted from Rack::Utils::HeaderHash
+    class Headers < ::Hash
+      def self.from(value)
+        new(value)
+      end
+
+      def self.allocate
+        new_self = super
+        new_self.initialize_names
+        new_self
+      end
+
+      def initialize(hash = nil)
+        super()
+        @names = {}
+        update(hash || {})
+      end
+
+      def initialize_names
+        @names = {}
+      end
+
+      # on dup/clone, we need to duplicate @names hash
+      def initialize_copy(other)
+        super
+        @names = other.names.dup
+      end
+
+      # need to synchronize concurrent writes to the shared KeyMap
+      keymap_mutex = Mutex.new
+
+      # symbol -> string mapper + cache
+      KeyMap = Hash.new do |map, key|
+        value = if key.respond_to?(:to_str)
+                  key
+                else
+                  key.to_s.split('_') # user_agent: %w(user agent)
+                     .each(&:capitalize!) # => %w(User Agent)
+                     .join('-') # => "User-Agent"
+                end
+        keymap_mutex.synchronize { map[key] = value }
+      end
+      KeyMap[:etag] = 'ETag'
+
+      def [](key)
+        key = KeyMap[key]
+        super(key) || super(@names[key.downcase])
+      end
+
+      def []=(key, val)
+        key = KeyMap[key]
+        key = (@names[key.downcase] ||= key)
+        # join multiple values with a comma
+        val = val.to_ary.join(', ') if val.respond_to?(:to_ary)
+        super(key, val)
+      end
+
+      def fetch(key, ...)
+        key = KeyMap[key]
+        key = @names.fetch(key.downcase, key)
+        super(key, ...)
+      end
+
+      def delete(key)
+        key = KeyMap[key]
+        key = @names[key.downcase]
+        return unless key
+
+        @names.delete key.downcase
+        super(key)
+      end
+
+      def dig(key, *rest)
+        key = KeyMap[key]
+        key = @names.fetch(key.downcase, key)
+        super(key, *rest)
+      end
+
+      def include?(key)
+        @names.include? key.downcase
+      end
+
+      alias has_key? include?
+      alias member? include?
+      alias key? include?
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+
+      alias update merge!
+
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+
+      def replace(other)
+        clear
+        @names.clear
+        update other
+        self
+      end
+
+      def to_hash
+        {}.update(self)
+      end
+
+      def parse(header_string)
+        return unless header_string && !header_string.empty?
+
+        headers = header_string.split("\r\n")
+
+        # Find the last set of response headers.
+        start_index = headers.rindex { |x| x.start_with?('HTTP/') } || 0
+        last_response = headers.slice(start_index, headers.size)
+
+        last_response
+          .tap { |a| a.shift if a.first.start_with?('HTTP/') }
+          .map { |h| h.split(/:\s*/, 2) } # split key and value
+          .reject { |p| p[0].nil? } # ignore blank lines
+          .each { |key, value| add_parsed(key, value) }
+      end
+
+      protected
+
+      attr_reader :names
+
+      private
+
+      # Join multiple values with a comma.
+      def add_parsed(key, value)
+        if key?(key)
+          self[key] = self[key].to_s
+          self[key] << ', ' << value
+        else
+          self[key] = value
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/utils/params_hash.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Faraday
+  module Utils
+    # A hash with stringified keys.
+    class ParamsHash < Hash
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def include?(key)
+        super(convert_key(key))
+      end
+
+      alias has_key? include?
+      alias member? include?
+      alias key? include?
+
+      def update(params)
+        params.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+      alias merge! update
+
+      def merge(params)
+        dup.update(params)
+      end
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def merge_query(query, encoder = nil)
+        return self unless query && !query.empty?
+
+        update((encoder || Utils.default_params_encoder).decode(query))
+      end
+
+      def to_query(encoder = nil)
+        (encoder || Utils.default_params_encoder).encode(self)
+      end
+
+      private
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/utils.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'faraday/utils/headers'
+require 'faraday/utils/params_hash'
+
+module Faraday
+  # Utils contains various static helper methods.
+  module Utils
+    module_function
+
+    def build_query(params)
+      FlatParamsEncoder.encode(params)
+    end
+
+    def build_nested_query(params)
+      NestedParamsEncoder.encode(params)
+    end
+
+    def default_space_encoding
+      @default_space_encoding ||= '+'
+    end
+
+    class << self
+      attr_writer :default_space_encoding
+    end
+
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
+
+    def escape(str)
+      str.to_s.gsub(ESCAPE_RE) do |match|
+        "%#{match.unpack('H2' * match.bytesize).join('%').upcase}"
+      end.gsub(' ', default_space_encoding)
+    end
+
+    def unescape(str)
+      CGI.unescape str.to_s
+    end
+
+    DEFAULT_SEP = /[&;] */n
+
+    # Adapted from Rack
+    def parse_query(query)
+      FlatParamsEncoder.decode(query)
+    end
+
+    def parse_nested_query(query)
+      NestedParamsEncoder.decode(query)
+    end
+
+    def default_params_encoder
+      @default_params_encoder ||= NestedParamsEncoder
+    end
+
+    def basic_header_from(login, pass)
+      value = ["#{login}:#{pass}"].pack('m') # Base64 encoding
+      value.delete!("\n")
+      "Basic #{value}"
+    end
+
+    class << self
+      attr_writer :default_params_encoder
+    end
+
+    # Normalize URI() behavior across Ruby versions
+    #
+    # url - A String or URI.
+    #
+    # Returns a parsed URI.
+    def URI(url) # rubocop:disable Naming/MethodName
+      if url.respond_to?(:host)
+        url
+      elsif url.respond_to?(:to_str)
+        default_uri_parser.call(url)
+      else
+        raise ArgumentError, 'bad argument (expected URI object or URI string)'
+      end
+    end
+
+    def default_uri_parser
+      @default_uri_parser ||= Kernel.method(:URI)
+    end
+
+    def default_uri_parser=(parser)
+      @default_uri_parser = if parser.respond_to?(:call) || parser.nil?
+                              parser
+                            else
+                              parser.method(:parse)
+                            end
+    end
+
+    # Receives a String or URI and returns just
+    # the path with the query string sorted.
+    def normalize_path(url)
+      url = URI(url)
+      (url.path.start_with?('/') ? url.path : "/#{url.path}") +
+        (url.query ? "?#{sort_query_params(url.query)}" : '')
+    end
+
+    # Recursive hash update
+    def deep_merge!(target, hash)
+      hash.each do |key, value|
+        target[key] = if value.is_a?(Hash) && (target[key].is_a?(Hash) || target[key].is_a?(Options))
+                        deep_merge(target[key], value)
+                      else
+                        value
+                      end
+      end
+      target
+    end
+
+    # Recursive hash merge
+    def deep_merge(source, hash)
+      deep_merge!(source.dup, hash)
+    end
+
+    def sort_query_params(query)
+      query.split('&').sort.join('&')
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/version.rb

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

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'set'
+require 'forwardable'
+require 'faraday/version'
+require 'faraday/methods'
+require 'faraday/error'
+require 'faraday/middleware_registry'
+require 'faraday/utils'
+require 'faraday/options'
+require 'faraday/connection'
+require 'faraday/rack_builder'
+require 'faraday/parameters'
+require 'faraday/middleware'
+require 'faraday/adapter'
+require 'faraday/request'
+require 'faraday/response'
+require 'faraday/net_http'
+# This is the main namespace for Faraday.
+#
+# It provides methods to create {Connection} objects, and HTTP-related
+# methods to use directly.
+#
+# @example Helpful class methods for easy usage
+#   Faraday.get "http://faraday.com"
+#
+# @example Helpful class method `.new` to create {Connection} objects.
+#   conn = Faraday.new "http://faraday.com"
+#   conn.get '/'
+#
+module Faraday
+  CONTENT_TYPE = 'Content-Type'
+
+  class << self
+    # The root path that Faraday is being loaded from.
+    #
+    # This is the root from where the libraries are auto-loaded.
+    #
+    # @return [String]
+    attr_accessor :root_path
+
+    # Gets or sets the path that the Faraday libs are loaded from.
+    # @return [String]
+    attr_accessor :lib_path
+
+    # @overload default_adapter
+    #   Gets the Symbol key identifying a default Adapter to use
+    #   for the default {Faraday::Connection}. Defaults to `:net_http`.
+    #   @return [Symbol] the default adapter
+    # @overload default_adapter=(adapter)
+    #   Updates default adapter while resetting {.default_connection}.
+    #   @return [Symbol] the new default_adapter.
+    attr_reader :default_adapter
+
+    # Option for the default_adapter
+    #   @return [Hash] default_adapter options
+    attr_accessor :default_adapter_options
+
+    # Documented below, see default_connection
+    attr_writer :default_connection
+
+    # Tells Faraday to ignore the environment proxy (http_proxy).
+    # Defaults to `false`.
+    # @return [Boolean]
+    attr_accessor :ignore_env_proxy
+
+    # Initializes a new {Connection}.
+    #
+    # @param url [String,Hash] The optional String base URL to use as a prefix
+    #           for all requests.  Can also be the options Hash. Any of these
+    #           values will be set on every request made, unless overridden
+    #           for a specific request.
+    # @param options [Hash]
+    # @option options [String] :url Base URL
+    # @option options [Hash] :params Hash of unencoded URI query params.
+    # @option options [Hash] :headers Hash of unencoded HTTP headers.
+    # @option options [Hash] :request Hash of request options.
+    # @option options [Hash] :ssl Hash of SSL options.
+    # @option options [Hash] :proxy Hash of Proxy options.
+    # @return [Faraday::Connection]
+    #
+    # @example With an URL argument
+    #   Faraday.new 'http://faraday.com'
+    #   # => Faraday::Connection to http://faraday.com
+    #
+    # @example With an URL argument and an options hash
+    #   Faraday.new 'http://faraday.com', params: { page: 1 }
+    #   # => Faraday::Connection to http://faraday.com?page=1
+    #
+    # @example With everything in an options hash
+    #   Faraday.new url: 'http://faraday.com',
+    #               params: { page: 1 }
+    #   # => Faraday::Connection to http://faraday.com?page=1
+    def new(url = nil, options = {}, &block)
+      options = Utils.deep_merge(default_connection_options, options)
+      Faraday::Connection.new(url, options, &block)
+    end
+
+    # Documented elsewhere, see default_adapter reader
+    def default_adapter=(adapter)
+      @default_connection = nil
+      @default_adapter = adapter
+    end
+
+    def respond_to_missing?(symbol, include_private = false)
+      default_connection.respond_to?(symbol, include_private) || super
+    end
+
+    # @overload default_connection
+    #   Gets the default connection used for simple scripts.
+    #   @return [Faraday::Connection] a connection configured with
+    #   the default_adapter.
+    # @overload default_connection=(connection)
+    #   @param connection [Faraday::Connection]
+    #   Sets the default {Faraday::Connection} for simple scripts that
+    #   access the Faraday constant directly, such as
+    #   <code>Faraday.get "https://faraday.com"</code>.
+    def default_connection
+      @default_connection ||= Connection.new(default_connection_options)
+    end
+
+    # Gets the default connection options used when calling {Faraday#new}.
+    #
+    # @return [Faraday::ConnectionOptions]
+    def default_connection_options
+      @default_connection_options ||= ConnectionOptions.new
+    end
+
+    # Sets the default options used when calling {Faraday#new}.
+    #
+    # @param options [Hash, Faraday::ConnectionOptions]
+    def default_connection_options=(options)
+      @default_connection = nil
+      @default_connection_options = ConnectionOptions.from(options)
+    end
+
+    private
+
+    # Internal: Proxies method calls on the Faraday constant to
+    # .default_connection.
+    def method_missing(name, *args, &block)
+      if default_connection.respond_to?(name)
+        default_connection.send(name, *args, &block)
+      else
+        super
+      end
+    end
+  end
+
+  self.ignore_env_proxy = false
+  self.root_path = File.expand_path __dir__
+  self.lib_path = File.expand_path 'faraday', __dir__
+  self.default_adapter = :net_http
+  self.default_adapter_options = {}
+end