iron_admin 0.4.1 → 0.6.0

data/vendor/bundle/ruby/3.2.0/gems/faraday-2.14.1/spec/support/shared_examples/request_method.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+shared_examples 'proxy examples' do
+  it 'handles requests with proxy' do
+    res = conn.public_send(http_method, '/')
+
+    expect(res.status).to eq(200)
+  end
+
+  it 'handles proxy failures' do
+    request_stub.to_return(status: 407)
+
+    expect { conn.public_send(http_method, '/') }.to raise_error(Faraday::ProxyAuthError)
+  end
+end
+
+shared_examples 'a request method' do |http_method|
+  let(:query_or_body) { method_with_body?(http_method) ? :body : :query }
+  let(:response) { conn.public_send(http_method, '/') }
+
+  unless http_method == :head && feature?(:skip_response_body_on_head)
+    it 'retrieves the response body' do
+      res_body = 'test'
+      request_stub.to_return(body: res_body)
+      expect(conn.public_send(http_method, '/').body).to eq(res_body)
+    end
+  end
+
+  it 'handles headers with multiple values' do
+    request_stub.to_return(headers: { 'Set-Cookie' => 'name=value' })
+    expect(response.headers['set-cookie']).to eq('name=value')
+  end
+
+  it 'retrieves the response headers' do
+    request_stub.to_return(headers: { 'Content-Type' => 'text/plain' })
+    expect(response.headers['Content-Type']).to match(%r{text/plain})
+    expect(response.headers['content-type']).to match(%r{text/plain})
+  end
+
+  it 'sends user agent' do
+    request_stub.with(headers: { 'User-Agent' => 'Agent Faraday' })
+    conn.public_send(http_method, '/', nil, user_agent: 'Agent Faraday')
+  end
+
+  it 'represents empty body response as blank string' do
+    expect(response.body).to eq('')
+  end
+
+  it 'handles connection error' do
+    request_stub.disable
+    expect { conn.public_send(http_method, 'http://localhost:4') }.to raise_error(Faraday::ConnectionFailed)
+  end
+
+  on_feature :local_socket_binding do
+    it 'binds local socket' do
+      stub_request(http_method, 'http://example.com')
+
+      host = '1.2.3.4'
+      port = 1234
+      conn_options[:request] = { bind: { host: host, port: port } }
+
+      conn.public_send(http_method, '/')
+
+      expect(conn.options[:bind][:host]).to eq(host)
+      expect(conn.options[:bind][:port]).to eq(port)
+    end
+  end
+
+  # context 'when wrong ssl certificate is provided' do
+  #   let(:ca_file_path) { 'tmp/faraday-different-ca-cert.crt' }
+  #   before { conn_options.merge!(ssl: { ca_file: ca_file_path }) }
+  #
+  #   it do
+  #     expect { conn.public_send(http_method, '/') }.to raise_error(Faraday::SSLError) # do |ex|
+  #       expect(ex.message).to include?('certificate')
+  #     end
+  #   end
+  # end
+
+  on_feature :request_body_on_query_methods do
+    it 'sends request body' do
+      request_stub.with({ body: 'test' })
+      res = if query_or_body == :body
+              conn.public_send(http_method, '/', 'test')
+            else
+              conn.public_send(http_method, '/') do |req|
+                req.body = 'test'
+              end
+            end
+      expect(res.env.request_body).to eq('test')
+    end
+  end
+
+  it 'sends url encoded parameters' do
+    payload = { name: 'zack' }
+    request_stub.with({ query_or_body => payload })
+    res = conn.public_send(http_method, '/', payload)
+    if query_or_body == :query
+      expect(res.env.request_body).to be_nil
+    else
+      expect(res.env.request_body).to eq('name=zack')
+    end
+  end
+
+  it 'sends url encoded nested parameters' do
+    payload = { name: { first: 'zack' } }
+    request_stub.with({ query_or_body => payload })
+    conn.public_send(http_method, '/', payload)
+  end
+
+  # TODO: This needs reimplementation: see https://github.com/lostisland/faraday/issues/718
+  # Should raise Faraday::TimeoutError
+  it 'supports timeout option' do
+    conn_options[:request] = { timeout: 1 }
+    request_stub.to_timeout
+    exc = adapter == 'NetHttp' ? Faraday::ConnectionFailed : Faraday::TimeoutError
+    expect { conn.public_send(http_method, '/') }.to raise_error(exc)
+  end
+
+  # TODO: This needs reimplementation: see https://github.com/lostisland/faraday/issues/718
+  # Should raise Faraday::ConnectionFailed
+  it 'supports open_timeout option' do
+    conn_options[:request] = { open_timeout: 1 }
+    request_stub.to_timeout
+    exc = adapter == 'NetHttp' ? Faraday::ConnectionFailed : Faraday::TimeoutError
+    expect { conn.public_send(http_method, '/') }.to raise_error(exc)
+  end
+
+  on_feature :reason_phrase_parse do
+    it 'parses the reason phrase' do
+      request_stub.to_return(status: [200, 'OK'])
+      expect(response.reason_phrase).to eq('OK')
+    end
+  end
+
+  on_feature :compression do
+    # Accept-Encoding header not sent for HEAD requests as body is not expected in the response.
+    unless http_method == :head
+      it 'handles gzip compression' do
+        request_stub.with(headers: { 'Accept-Encoding' => /\bgzip\b/ })
+        conn.public_send(http_method, '/')
+      end
+
+      it 'handles deflate compression' do
+        request_stub.with(headers: { 'Accept-Encoding' => /\bdeflate\b/ })
+        conn.public_send(http_method, '/')
+      end
+    end
+  end
+
+  on_feature :streaming do
+    describe 'streaming' do
+      let(:streamed) { [] }
+
+      context 'when response is empty' do
+        it 'handles streaming' do
+          env = nil
+          conn.public_send(http_method, '/') do |req|
+            req.options.on_data = proc do |chunk, size, block_env|
+              streamed << [chunk, size]
+              env ||= block_env
+            end
+          end
+
+          expect(streamed).to eq([['', 0]])
+          # TODO: enable this after updating all existing adapters to the new streaming API
+          # expect(env).to be_a(Faraday::Env)
+          # expect(env.status).to eq(200)
+        end
+      end
+
+      context 'when response contains big data' do
+        before { request_stub.to_return(body: big_string) }
+
+        it 'handles streaming' do
+          env = nil
+          response = conn.public_send(http_method, '/') do |req|
+            req.options.on_data = proc do |chunk, size, block_env|
+              streamed << [chunk, size]
+              env ||= block_env
+            end
+          end
+
+          expect(response.body).to eq('')
+          check_streaming_response(streamed, chunk_size: 16 * 1024)
+          # TODO: enable this after updating all existing adapters to the new streaming API
+          # expect(env).to be_a(Faraday::Env)
+          # expect(env.status).to eq(200)
+        end
+      end
+    end
+  end
+
+  on_feature :parallel do
+    context 'with parallel setup' do
+      before do
+        @resp1 = nil
+        @resp2 = nil
+        @payload1 = { a: '1' }
+        @payload2 = { b: '2' }
+
+        request_stub
+          .with({ query_or_body => @payload1 })
+          .to_return(body: @payload1.to_json)
+
+        stub_request(http_method, remote)
+          .with({ query_or_body => @payload2 })
+          .to_return(body: @payload2.to_json)
+
+        conn.in_parallel do
+          @resp1 = conn.public_send(http_method, '/', @payload1)
+          @resp2 = conn.public_send(http_method, '/', @payload2)
+
+          expect(conn.in_parallel?).to be_truthy
+          expect(@resp1.body).to be_nil
+          expect(@resp2.body).to be_nil
+        end
+
+        expect(conn.in_parallel?).to be_falsey
+      end
+
+      it 'handles parallel requests status' do
+        expect(@resp1&.status).to eq(200)
+        expect(@resp2&.status).to eq(200)
+      end
+
+      unless http_method == :head && feature?(:skip_response_body_on_head)
+        it 'handles parallel requests body' do
+          expect(@resp1&.body).to eq(@payload1.to_json)
+          expect(@resp2&.body).to eq(@payload2.to_json)
+        end
+      end
+    end
+  end
+
+  context 'when a proxy is provided as option' do
+    before do
+      conn_options[:proxy] = 'http://env-proxy.com:80'
+    end
+
+    include_examples 'proxy examples'
+  end
+
+  context 'when http_proxy env variable is set' do
+    let(:proxy_url) { 'http://env-proxy.com:80' }
+
+    around do |example|
+      with_env 'http_proxy' => proxy_url do
+        example.run
+      end
+    end
+
+    include_examples 'proxy examples'
+
+    context 'when the env proxy is ignored' do
+      around do |example|
+        with_env_proxy_disabled(&example)
+      end
+
+      include_examples 'proxy examples'
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/faraday-2.14.1/spec/support/streaming_response_checker.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Faraday
+  module StreamingResponseChecker
+    def check_streaming_response(streamed, options = {})
+      opts = {
+        prefix: '',
+        streaming?: true
+      }.merge(options)
+
+      expected_response = opts[:prefix] + big_string
+
+      chunks, sizes = streamed.transpose
+
+      # Check that the total size of the chunks (via the last size returned)
+      # is the same size as the expected_response
+      expect(sizes.last).to eq(expected_response.bytesize)
+
+      start_index = 0
+      expected_chunks = []
+      chunks.each do |actual_chunk|
+        expected_chunk = expected_response[start_index..((start_index + actual_chunk.bytesize) - 1)]
+        expected_chunks << expected_chunk
+        start_index += expected_chunk.bytesize
+      end
+
+      # it's easier to read a smaller portion, so we check that first
+      expect(expected_chunks[0][0..255]).to eq(chunks[0][0..255])
+
+      [expected_chunks, chunks].transpose.each do |expected, actual|
+        expect(actual).to eq(expected)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/faraday-net_http-3.4.2/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Jan van der Pas
+
+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.2.0/gems/faraday-net_http-3.4.2/README.md

@@ -0,0 +1,57 @@
+# Faraday Net::HTTP adapter
+
+This gem is a [Faraday][faraday] adapter for the [Net::HTTP][net-http] library. Faraday is an HTTP client library that provides a common interface over many adapters. Every adapter is defined into it's own gem. This gem defines the adapter for `Net::HTTP` the HTTP library that's included into the standard library of Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'faraday-net_http'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install faraday-net_http
+
+## Usage
+
+```ruby
+conn = Faraday.new(...) do |f|
+  f.adapter :net_http do |http|
+    # yields Net::HTTP
+    http.verify_callback = lambda do |preverify, cert_store|
+      # do something here...
+    end
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](rubygems).
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub][repo].
+
+## License
+
+The gem is available as open source under the terms of the [license][license].
+
+## Code of Conduct
+
+Everyone interacting in the Faraday Net::HTTP adapter project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct][code-of-conduct].
+
+[faraday]: https://github.com/lostisland/faraday
+[net-http]: https://ruby-doc.org/stdlib-2.7.0/libdoc/net/http/rdoc/Net/HTTP.html
+[rubygems]: https://rubygems.org
+[repo]: https://github.com/lostisland/faraday-net_http
+[license]: https://github.com/lostisland/faraday-net_http/blob/main/LICENSE.md
+[code-of-conduct]: https://github.com/lostisland/faraday-net_http/blob/main/CODE_OF_CONDUCT.md

data/vendor/bundle/ruby/3.2.0/gems/faraday-net_http-3.4.2/lib/faraday/adapter/net_http.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+begin
+  require 'net/https'
+rescue LoadError
+  warn 'Warning: no such file to load -- net/https. ' \
+    'Make sure openssl is installed if you want ssl support'
+  require 'net/http'
+end
+require 'zlib'
+
+module Faraday
+  class Adapter
+    class NetHttp < Faraday::Adapter
+      exceptions = [
+        IOError,
+        Errno::EADDRNOTAVAIL,
+        Errno::EALREADY,
+        Errno::ECONNABORTED,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::EHOSTUNREACH,
+        Errno::EINVAL,
+        Errno::ENETUNREACH,
+        Errno::EPIPE,
+        Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError,
+        Net::ProtocolError,
+        SocketError,
+        Zlib::GzipFile::Error
+      ]
+
+      exceptions << ::OpenSSL::SSL::SSLError if defined?(::OpenSSL::SSL::SSLError)
+      exceptions << ::Net::OpenTimeout if defined?(::Net::OpenTimeout)
+
+      NET_HTTP_EXCEPTIONS = exceptions.freeze
+
+      def initialize(app = nil, opts = {}, &block)
+        @ssl_cert_store = nil
+        super(app, opts, &block)
+      end
+
+      def build_connection(env)
+        net_http_connection(env).tap do |http|
+          configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' && env[:ssl]
+          configure_request(http, env[:request])
+        end
+      end
+
+      def net_http_connection(env)
+        proxy = env[:request][:proxy]
+        port = env[:url].port || (env[:url].scheme == 'https' ? 443 : 80)
+        if proxy
+          Net::HTTP.new(env[:url].hostname, port,
+                        proxy[:uri].hostname, proxy[:uri].port,
+                        proxy[:user], proxy[:password],
+                        nil, proxy[:uri].scheme == 'https')
+        else
+          Net::HTTP.new(env[:url].hostname, port, nil)
+        end
+      end
+
+      def call(env)
+        super
+        connection(env) do |http|
+          perform_request(http, env)
+        rescue *NET_HTTP_EXCEPTIONS => e
+          raise Faraday::SSLError, e if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
+
+          raise Faraday::ConnectionFailed, e
+        end
+        @app.call env
+      rescue Timeout::Error, Errno::ETIMEDOUT => e
+        raise Faraday::TimeoutError, e
+      end
+
+      private
+
+      def create_request(env)
+        request = Net::HTTPGenericRequest.new \
+          env[:method].to_s.upcase, # request method
+          !!env[:body], # is there request body
+          env[:method] != :head, # is there response body
+          env[:url].request_uri, # request uri path
+          env[:request_headers] # request headers
+
+        if env[:body].respond_to?(:read)
+          request.body_stream = env[:body]
+        else
+          request.body = env[:body]
+        end
+        request
+      end
+
+      def perform_request(http, env)
+        if env.stream_response?
+          http_response = env.stream_response do |&on_data|
+            request_with_wrapped_block(http, env, &on_data)
+          end
+          http_response.body = nil
+        else
+          http_response = request_with_wrapped_block(http, env)
+        end
+        env.response_body = encoded_body(http_response)
+        env.response.finish(env)
+        http_response
+      end
+
+      def request_with_wrapped_block(http, env, &block)
+        # Must use Net::HTTP#start and pass it a block otherwise the server's
+        # TCP socket does not close correctly.
+        http.start do |opened_http|
+          opened_http.request create_request(env) do |response|
+            save_http_response(env, response)
+
+            response.read_body(&block) if block_given?
+          end
+        end
+      end
+
+      def save_http_response(env, http_response)
+        save_response(
+          env, http_response.code.to_i, nil, nil, http_response.message, finished: false
+        ) do |response_headers|
+          http_response.each_header do |key, value|
+            response_headers[key] = value
+          end
+        end
+      end
+
+      def configure_ssl(http, ssl)
+        http.use_ssl = true if http.respond_to?(:use_ssl=)
+
+        http.verify_mode = ssl_verify_mode(ssl)
+        http.cert_store = ssl_cert_store(ssl)
+
+        cert, *extra_chain_cert = ssl[:client_cert]
+        http.cert = cert if cert
+        http.extra_chain_cert = extra_chain_cert if extra_chain_cert.any?
+
+        http.key = ssl[:client_key] if ssl[:client_key]
+        http.ca_file = ssl[:ca_file] if ssl[:ca_file]
+        http.ca_path = ssl[:ca_path] if ssl[:ca_path]
+        http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
+        http.ssl_version = ssl[:version] if ssl[:version]
+        http.min_version = ssl[:min_version] if ssl[:min_version]
+        http.max_version = ssl[:max_version] if ssl[:max_version]
+        http.verify_hostname = ssl[:verify_hostname] if verify_hostname_enabled?(http, ssl)
+        http.ciphers = ssl[:ciphers] if ssl[:ciphers]
+      end
+
+      def configure_request(http, req)
+        if (sec = request_timeout(:read, req))
+          http.read_timeout = sec
+        end
+
+        if (sec = http.respond_to?(:write_timeout=) &&
+          request_timeout(:write, req))
+          http.write_timeout = sec
+        end
+
+        if (sec = request_timeout(:open, req))
+          http.open_timeout = sec
+        end
+
+        # Only set if Net::Http supports it, since Ruby 2.5.
+        http.max_retries = 0 if http.respond_to?(:max_retries=)
+
+        @config_block&.call(http)
+      end
+
+      def ssl_cert_store(ssl)
+        return ssl[:cert_store] if ssl[:cert_store]
+
+        # Use the default cert store by default, i.e. system ca certs
+        @ssl_cert_store ||= OpenSSL::X509::Store.new.tap(&:set_default_paths)
+      end
+
+      def ssl_verify_mode(ssl)
+        ssl[:verify_mode] || begin
+          if ssl.fetch(:verify, true)
+            OpenSSL::SSL::VERIFY_PEER
+          else
+            OpenSSL::SSL::VERIFY_NONE
+          end
+        end
+      end
+
+      def encoded_body(http_response)
+        body = http_response.body || +''
+        /\bcharset=([^;]+)/.match(http_response['Content-Type']) do |match|
+          content_charset = ::Encoding.find(match[1].strip)
+          body = body.dup if body.frozen?
+          body.force_encoding(content_charset)
+        rescue ArgumentError
+          nil
+        end
+        body
+      end
+
+      def verify_hostname_enabled?(http, ssl)
+        http.respond_to?(:verify_hostname=) && ssl.key?(:verify_hostname)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/faraday-net_http-3.4.2/lib/faraday/net_http/version.rb

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

data/vendor/bundle/ruby/3.2.0/gems/faraday-net_http-3.4.2/lib/faraday/net_http.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'faraday/adapter/net_http'
+require 'faraday/net_http/version'
+
+module Faraday
+  module NetHttp
+    Faraday::Adapter.register_middleware(net_http: Faraday::Adapter::NetHttp)
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.2.1/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'rake'
+end

data/vendor/bundle/ruby/3.2.0/gems/hashdiff-1.2.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Liu Fengyun
+
+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.