iron_admin 0.4.1 → 0.6.0

data/vendor/bundle/ruby/3.2.0/gems/faraday-2.14.1/lib/faraday/rack_builder.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+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://httpbingo.org') 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
+
+      def initialize(klass, *args, **kwargs, &block)
+        @name = klass.to_s
+        REGISTRY.set(klass) if klass.respond_to?(:name)
+        @args = args
+        @kwargs = kwargs
+        @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, **@kwargs, &@block)
+      end
+    end
+
+    def initialize(&block)
+      @adapter = nil
+      @handlers = []
+      build(&block)
+    end
+
+    def initialize_dup(original)
+      super
+      @adapter = original.adapter
+      @handlers = original.handlers.dup
+    end
+
+    def build
+      raise_if_locked
+      block_given? ? yield(self) : request(:url_encoded)
+      adapter(Faraday.default_adapter, **Faraday.default_adapter_options) 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
+
+    def use(klass, ...)
+      if klass.is_a? Symbol
+        use_symbol(Faraday::Middleware, klass, ...)
+      else
+        raise_if_locked
+        raise_if_adapter(klass)
+        @handlers << self.class::Handler.new(klass, ...)
+      end
+    end
+
+    def request(key, ...)
+      use_symbol(Faraday::Request, key, ...)
+    end
+
+    def response(...)
+      use_symbol(Faraday::Response, ...)
+    end
+
+    def adapter(klass = NO_ARGUMENT, *args, **kwargs, &block)
+      return @adapter if klass == NO_ARGUMENT || klass.nil?
+
+      klass = Faraday::Adapter.lookup_middleware(klass) if klass.is_a?(Symbol)
+      @adapter = self.class::Handler.new(klass, *args, **kwargs, &block)
+    end
+
+    ## methods to push onto the various positions in the stack:
+
+    def insert(index, ...)
+      raise_if_locked
+      index = assert_index(index)
+      handler = self.class::Handler.new(...)
+      @handlers.insert(index, handler)
+    end
+
+    alias insert_before insert
+
+    def insert_after(index, ...)
+      index = assert_index(index)
+      insert(index + 1, ...)
+    end
+
+    def swap(index, ...)
+      raise_if_locked
+      index = assert_index(index)
+      @handlers.delete_at(index)
+      insert(index, ...)
+    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!
+        ensure_adapter!
+        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
+
+    # 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"
+    MISSING_ADAPTER_ERROR = "An attempt to run a request with a Faraday::Connection without adapter has been made.\n" \
+                            "Please set Faraday.default_adapter or provide one when initializing the connection.\n" \
+                            'For more info, check https://lostisland.github.io/faraday/usage/.'
+
+    def raise_if_locked
+      raise StackLocked, LOCK_ERR if locked?
+    end
+
+    def raise_if_adapter(klass)
+      return unless klass <= Faraday::Adapter
+
+      raise 'Adapter should be set using the `adapter` method, not `use`'
+    end
+
+    def ensure_adapter!
+      raise MISSING_ADAPTER_ERROR unless @adapter
+    end
+
+    def adapter_set?
+      !@adapter.nil?
+    end
+
+    def use_symbol(mod, key, ...)
+      use(mod.lookup_middleware(key), ...)
+    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/3.2.0/gems/faraday-2.14.1/lib/faraday/request/authorization.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Faraday
+  class Request
+    # Request middleware for the Authorization HTTP header
+    class Authorization < Faraday::Middleware
+      KEY = 'Authorization'
+
+      # @param app [#call]
+      # @param type [String, Symbol] Type of Authorization
+      # @param params [Array<String, Proc, #call>] parameters to build the Authorization header.
+      #   If the type is `:basic`, then these can be a login and password pair.
+      #   Otherwise, a single value is expected that will be appended after the type.
+      #   This value can be a proc or an object responding to `.call`, in which case
+      #   it will be invoked on each request.
+      def initialize(app, type, *params)
+        @type = type
+        @params = params
+        super(app)
+      end
+
+      # @param env [Faraday::Env]
+      def on_request(env)
+        return if env.request_headers[KEY]
+
+        env.request_headers[KEY] = header_from(@type, env, *@params)
+      end
+
+      private
+
+      # @param type [String, Symbol]
+      # @param env [Faraday::Env]
+      # @param params [Array]
+      # @return [String] a header value
+      def header_from(type, env, *params)
+        if type.to_s.casecmp('basic').zero? && params.size == 2
+          Utils.basic_header_from(*params)
+        elsif params.size != 1
+          raise ArgumentError, "Unexpected params received (got #{params.size} instead of 1)"
+        else
+          value = params.first
+          if (value.is_a?(Proc) && value.arity == 1) || (value.respond_to?(:call) && value.method(:call).arity == 1)
+            value = value.call(env)
+          elsif value.is_a?(Proc) || value.respond_to?(:call)
+            value = value.call
+          end
+          "#{type} #{value}"
+        end
+      end
+    end
+  end
+end
+
+Faraday::Request.register_middleware(authorization: Faraday::Request::Authorization)

data/vendor/bundle/ruby/3.2.0/gems/faraday-2.14.1/lib/faraday/request/instrumentation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Faraday
+  class Request
+    # Middleware for instrumenting Requests.
+    class Instrumentation < Faraday::Middleware
+      # Options class used in Request::Instrumentation class.
+      Options = Faraday::Options.new(:name, :instrumenter) do
+        remove_method :name
+        # @return [String]
+        def name
+          self[:name] ||= 'request.faraday'
+        end
+
+        remove_method :instrumenter
+        # @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
+
+Faraday::Request.register_middleware(instrumentation: Faraday::Request::Instrumentation)

data/vendor/bundle/ruby/3.2.0/gems/faraday-2.14.1/lib/faraday/request/json.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Faraday
+  class Request
+    # Request middleware that encodes the body as JSON.
+    #
+    # Processes only requests with matching Content-type or those without a type.
+    # If a request doesn't have a type but has a body, it sets the Content-type
+    # to JSON MIME-type.
+    #
+    # Doesn't try to encode bodies that already are in string form.
+    class Json < Middleware
+      MIME_TYPE = 'application/json'
+      MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}
+
+      def on_request(env)
+        match_content_type(env) do |data|
+          env[:body] = encode(data)
+        end
+      end
+
+      private
+
+      def encode(data)
+        if options[:encoder].is_a?(Array) && options[:encoder].size >= 2
+          options[:encoder][0].public_send(options[:encoder][1], data)
+        elsif options[:encoder].respond_to?(:dump)
+          options[:encoder].dump(data)
+        else
+          ::JSON.generate(data)
+        end
+      end
+
+      def match_content_type(env)
+        return unless process_request?(env)
+
+        env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+        yield env[:body] unless env[:body].respond_to?(:to_str)
+      end
+
+      def process_request?(env)
+        type = request_type(env)
+        body?(env) && (type.empty? || type.match?(MIME_TYPE_REGEX))
+      end
+
+      def body?(env)
+        body = env[:body]
+        case body
+        when true, false
+          true
+        when nil
+          # NOTE: nil can be converted to `"null"`, but this middleware doesn't process `nil` for the compatibility.
+          false
+        else
+          !(body.respond_to?(:to_str) && body.empty?)
+        end
+      end
+
+      def request_type(env)
+        type = env[:request_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end
+
+Faraday::Request.register_middleware(json: Faraday::Request::Json)

data/vendor/bundle/ruby/3.2.0/gems/faraday-2.14.1/lib/faraday/request/url_encoded.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Faraday
+  class Request
+    # Middleware for supporting urlencoded requests.
+    class UrlEncoded < Faraday::Middleware
+      unless defined?(::Faraday::Request::UrlEncoded::CONTENT_TYPE)
+        CONTENT_TYPE = 'Content-Type'
+      end
+
+      class << self
+        attr_accessor :mime_type
+      end
+      self.mime_type = 'application/x-www-form-urlencoded'
+
+      # Encodes as "application/x-www-form-urlencoded" if not already encoded or
+      # of another type.
+      #
+      # @param env [Faraday::Env]
+      def call(env)
+        match_content_type(env) do |data|
+          params = Faraday::Utils::ParamsHash[data]
+          env.body = params.to_query(env.params_encoder)
+        end
+        @app.call env
+      end
+
+      # @param env [Faraday::Env]
+      # @yield [request_body] Body of the request
+      def match_content_type(env)
+        return unless process_request?(env)
+
+        env.request_headers[CONTENT_TYPE] ||= self.class.mime_type
+        return if env.body.respond_to?(:to_str) || env.body.respond_to?(:read)
+
+        yield(env.body)
+      end
+
+      # @param env [Faraday::Env]
+      #
+      # @return [Boolean] True if the request has a body and its Content-Type is
+      #                   urlencoded.
+      def process_request?(env)
+        type = request_type(env)
+        env.body && (type.empty? || (type == self.class.mime_type))
+      end
+
+      # @param env [Faraday::Env]
+      #
+      # @return [String]
+      def request_type(env)
+        type = env.request_headers[CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end
+
+Faraday::Request.register_middleware(url_encoded: Faraday::Request::UrlEncoded)

data/vendor/bundle/ruby/3.2.0/gems/faraday-2.14.1/lib/faraday/request.rb

@@ -0,0 +1,139 @@
+# 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 [String] body
+  # @!attribute options
+  #   @return [RequestOptions] options
+  Request = Struct.new(:http_method, :path, :params, :headers, :body, :options) do
+    extend MiddlewareRegistry
+
+    alias_method :member_get, :[]
+    private :member_get
+    alias_method :member_set, :[]=
+    private :member_set
+
+    # @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
+
+    remove_method :params=
+    # Replace params, preserving the existing hash type.
+    #
+    # @param hash [Hash] new params
+    def params=(hash)
+      if params
+        params.replace hash
+      else
+        member_set(:params, hash)
+      end
+    end
+
+    remove_method :headers=
+    # Replace request headers, preserving the existing hash type.
+    #
+    # @param hash [Hash] new headers
+    def headers=(hash)
+      if headers
+        headers.replace hash
+      else
+        member_set(:headers, hash)
+      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.2.0/gems/faraday-2.14.1/lib/faraday/response/json.rb

@@ -0,0 +1,74 @@
+# 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
+
+        process_parser_options
+      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)
+        return if body.strip.empty?
+
+        decoder, method_name = @decoder_options
+
+        decoder.public_send(method_name, body, @parser_options || {})
+      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
+
+      def process_parser_options
+        @decoder_options = @parser_options&.delete(:decoder)
+
+        @decoder_options =
+          if @decoder_options.is_a?(Array) && @decoder_options.size >= 2
+            @decoder_options.slice(0, 2)
+          elsif @decoder_options&.respond_to?(:load) # rubocop:disable Lint/RedundantSafeNavigation
+            # In some versions of Rails, `nil` responds to `load` - hence the safe navigation check above
+            [@decoder_options, :load]
+          else
+            [::JSON, :parse]
+          end
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware(json: Faraday::Response::Json)