tdiary 5.2.1 → 5.2.2

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Faraday
+  # Used to setup URLs, params, headers, and the request body in a sane manner.
+  #
+  # @example
+  #   @connection.post do |req|
+  #     req.url 'http://localhost', 'a' => '1' # 'http://localhost?a=1'
+  #     req.headers['b'] = '2' # Header
+  #     req.params['c']  = '3' # GET Param
+  #     req['b']         = '2' # also Header
+  #     req.body = 'abc'
+  #   end
+  #
+  # @!attribute http_method
+  #   @return [Symbol] the HTTP method of the Request
+  # @!attribute path
+  #   @return [URI, String] the path
+  # @!attribute params
+  #   @return [Hash] query parameters
+  # @!attribute headers
+  #   @return [Faraday::Utils::Headers] headers
+  # @!attribute body
+  #   @return [Hash] body
+  # @!attribute options
+  #   @return [RequestOptions] options
+  #
+  # rubocop:disable Style/StructInheritance
+  class Request < Struct.new(:http_method, :path, :params, :headers, :body, :options)
+    # rubocop:enable Style/StructInheritance
+
+    extend MiddlewareRegistry
+
+    # @param request_method [String]
+    # @yield [request] for block customization, if block given
+    # @yieldparam request [Request]
+    # @return [Request]
+    def self.create(request_method)
+      new(request_method).tap do |request|
+        yield(request) if block_given?
+      end
+    end
+
+    # Replace params, preserving the existing hash type.
+    #
+    # @param hash [Hash] new params
+    def params=(hash)
+      if params
+        params.replace hash
+      else
+        super
+      end
+    end
+
+    # Replace request headers, preserving the existing hash type.
+    #
+    # @param hash [Hash] new headers
+    def headers=(hash)
+      if headers
+        headers.replace hash
+      else
+        super
+      end
+    end
+
+    # Update path and params.
+    #
+    # @param path [URI, String]
+    # @param params [Hash, nil]
+    # @return [void]
+    def url(path, params = nil)
+      if path.respond_to? :query
+        if (query = path.query)
+          path = path.dup
+          path.query = nil
+        end
+      else
+        anchor_index = path.index('#')
+        path = path.slice(0, anchor_index) unless anchor_index.nil?
+        path, query = path.split('?', 2)
+      end
+      self.path = path
+      self.params.merge_query query, options.params_encoder
+      self.params.update(params) if params
+    end
+
+    # @param key [Object] key to look up in headers
+    # @return [Object] value of the given header name
+    def [](key)
+      headers[key]
+    end
+
+    # @param key [Object] key of header to write
+    # @param value [Object] value of header
+    def []=(key, value)
+      headers[key] = value
+    end
+
+    # Marshal serialization support.
+    #
+    # @return [Hash] the hash ready to be serialized in Marshal.
+    def marshal_dump
+      {
+        http_method: http_method,
+        body: body,
+        headers: headers,
+        path: path,
+        params: params,
+        options: options
+      }
+    end
+
+    # Marshal serialization support.
+    # Restores the instance variables according to the +serialised+.
+    # @param serialised [Hash] the serialised object.
+    def marshal_load(serialised)
+      self.http_method = serialised[:http_method]
+      self.body = serialised[:body]
+      self.headers = serialised[:headers]
+      self.path = serialised[:path]
+      self.params = serialised[:params]
+      self.options = serialised[:options]
+    end
+
+    # @return [Env] the Env for this Request
+    def to_env(connection)
+      Env.new(http_method, body, connection.build_exclusive_url(path, params),
+              options, headers, connection.ssl, connection.parallel_manager)
+    end
+  end
+end
+
+require 'faraday/request/authorization'
+require 'faraday/request/instrumentation'
+require 'faraday/request/json'
+require 'faraday/request/url_encoded'

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Faraday
+  class Response
+    # Parse response bodies as JSON.
+    class Json < Middleware
+      def initialize(app = nil, parser_options: nil, content_type: /\bjson$/, preserve_raw: false)
+        super(app)
+        @parser_options = parser_options
+        @content_types = Array(content_type)
+        @preserve_raw = preserve_raw
+      end
+
+      def on_complete(env)
+        process_response(env) if parse_response?(env)
+      end
+
+      private
+
+      def process_response(env)
+        env[:raw_body] = env[:body] if @preserve_raw
+        env[:body] = parse(env[:body])
+      rescue StandardError, SyntaxError => e
+        raise Faraday::ParsingError.new(e, env[:response])
+      end
+
+      def parse(body)
+        ::JSON.parse(body, @parser_options || {}) unless body.strip.empty?
+      end
+
+      def parse_response?(env)
+        process_response_type?(env) &&
+          env[:body].respond_to?(:to_str)
+      end
+
+      def process_response_type?(env)
+        type = response_type(env)
+        @content_types.empty? || @content_types.any? do |pattern|
+          pattern.is_a?(Regexp) ? type.match?(pattern) : type == pattern
+        end
+      end
+
+      def response_type(env)
+        type = env[:response_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware(json: Faraday::Response::Json)

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

@@ -0,0 +1,33 @@
+# 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
+    end
+  end
+end
+
+Faraday::Response.register_middleware(logger: Faraday::Response::Logger)

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

@@ -0,0 +1,64 @@
+# 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).freeze
+      ServerErrorStatuses = (500...600).freeze
+      # rubocop:enable Naming/ConstantName
+
+      def on_complete(env)
+        case env[:status]
+        when 400
+          raise Faraday::BadRequestError, response_values(env)
+        when 401
+          raise Faraday::UnauthorizedError, response_values(env)
+        when 403
+          raise Faraday::ForbiddenError, response_values(env)
+        when 404
+          raise Faraday::ResourceNotFound, 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 409
+          raise Faraday::ConflictError, response_values(env)
+        when 422
+          raise Faraday::UnprocessableEntityError, 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
+
+      def response_values(env)
+        {
+          status: env.status,
+          headers: env.response_headers,
+          body: env.body,
+          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.3.0/lib/faraday/response.rb

@@ -0,0 +1,90 @@
+# 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
+      }
+    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.3.0/lib/faraday/utils/headers.rb

@@ -0,0 +1,139 @@
+# 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, *args, &block)
+        key = KeyMap[key]
+        key = @names.fetch(key.downcase, key)
+        super(key, *args, &block)
+      end
+
+      def delete(key)
+        key = KeyMap[key]
+        key = @names[key.downcase]
+        return unless key
+
+        @names.delete key.downcase
+        super(key)
+      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)
+        self[key] ? self[key] << ', ' << value : self[key] = value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'base64'
+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 .~_-]/.freeze
+
+    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.freeze
+
+    # 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 = Base64.encode64("#{login}:#{pass}")
+      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.3.0/lib/faraday/version.rb

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