tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.3.0/examples/client_spec.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-# Requires Ruby with rspec and faraday gems.
-# rspec client_spec.rb
-
-require 'faraday'
-require 'json'
-
-# Example API client
-class Client
-  def initialize(conn)
-    @conn = conn
-  end
-
-  def httpbingo(jname, params: {})
-    res = @conn.get("/#{jname}", params)
-    data = JSON.parse(res.body)
-    data['origin']
-  end
-end
-
-RSpec.describe Client do
-  let(:stubs)  { Faraday::Adapter::Test::Stubs.new }
-  let(:conn)   { Faraday.new { |b| b.adapter(:test, stubs) } }
-  let(:client) { Client.new(conn) }
-
-  it 'parses origin' do
-    stubs.get('/ip') do |env|
-      # optional: you can inspect the Faraday::Env
-      expect(env.url.path).to eq('/ip')
-      [
-        200,
-        { 'Content-Type': 'application/javascript' },
-        '{"origin": "127.0.0.1"}'
-      ]
-    end
-
-    # uncomment to trigger stubs.verify_stubbed_calls failure
-    # stubs.get('/unused') { [404, {}, ''] }
-
-    expect(client.httpbingo('ip')).to eq('127.0.0.1')
-    stubs.verify_stubbed_calls
-  end
-
-  it 'handles 404' do
-    stubs.get('/api') do
-      [
-        404,
-        { 'Content-Type': 'application/javascript' },
-        '{}'
-      ]
-    end
-    expect(client.httpbingo('api')).to be_nil
-    stubs.verify_stubbed_calls
-  end
-
-  it 'handles exception' do
-    stubs.get('/api') do
-      raise Faraday::ConnectionFailed
-    end
-
-    expect { client.httpbingo('api') }.to raise_error(Faraday::ConnectionFailed)
-    stubs.verify_stubbed_calls
-  end
-
-  context 'When the test stub is run in strict_mode' do
-    let(:stubs) { Faraday::Adapter::Test::Stubs.new(strict_mode: true) }
-
-    it 'verifies the all parameter values are identical' do
-      stubs.get('/api?abc=123') do
-        [
-          200,
-          { 'Content-Type': 'application/javascript' },
-          '{"origin": "127.0.0.1"}'
-        ]
-      end
-
-      # uncomment to raise Stubs::NotFound
-      # expect(client.httpbingo('api', params: { abc: 123, foo: 'Kappa' })).to eq('127.0.0.1')
-      expect(client.httpbingo('api', params: { abc: 123 })).to eq('127.0.0.1')
-      stubs.verify_stubbed_calls
-    end
-  end
-
-  context 'When the Faraday connection is configured with FlatParamsEncoder' do
-    let(:conn) { Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) { |b| b.adapter(:test, stubs) } }
-
-    it 'handles the same multiple URL parameters' do
-      stubs.get('/api?a=x&a=y&a=z') { [200, { 'Content-Type' => 'application/json' }, '{"origin": "127.0.0.1"}'] }
-
-      # uncomment to raise Stubs::NotFound
-      # expect(client.httpbingo('api', params: { a: %w[x y] })).to eq('127.0.0.1')
-      expect(client.httpbingo('api', params: { a: %w[x y z] })).to eq('127.0.0.1')
-      stubs.verify_stubbed_calls
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.3.0/examples/client_test.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-# Requires Ruby with test-unit and faraday gems.
-# ruby client_test.rb
-
-require 'faraday'
-require 'json'
-require 'test/unit'
-
-# Example API client
-class Client
-  def initialize(conn)
-    @conn = conn
-  end
-
-  def httpbingo(jname, params: {})
-    res = @conn.get("/#{jname}", params)
-    data = JSON.parse(res.body)
-    data['origin']
-  end
-end
-
-# Example API client test
-class ClientTest < Test::Unit::TestCase
-  def test_httpbingo_name
-    stubs = Faraday::Adapter::Test::Stubs.new
-    stubs.get('/api') do |env|
-      # optional: you can inspect the Faraday::Env
-      assert_equal '/api', env.url.path
-      [
-        200,
-        { 'Content-Type': 'application/javascript' },
-        '{"origin": "127.0.0.1"}'
-      ]
-    end
-
-    # uncomment to trigger stubs.verify_stubbed_calls failure
-    # stubs.get('/unused') { [404, {}, ''] }
-
-    cli = client(stubs)
-    assert_equal '127.0.0.1', cli.httpbingo('api')
-    stubs.verify_stubbed_calls
-  end
-
-  def test_httpbingo_not_found
-    stubs = Faraday::Adapter::Test::Stubs.new
-    stubs.get('/api') do
-      [
-        404,
-        { 'Content-Type': 'application/javascript' },
-        '{}'
-      ]
-    end
-
-    cli = client(stubs)
-    assert_nil cli.httpbingo('api')
-    stubs.verify_stubbed_calls
-  end
-
-  def test_httpbingo_exception
-    stubs = Faraday::Adapter::Test::Stubs.new
-    stubs.get('/api') do
-      raise Faraday::ConnectionFailed
-    end
-
-    cli = client(stubs)
-    assert_raise Faraday::ConnectionFailed do
-      cli.httpbingo('api')
-    end
-    stubs.verify_stubbed_calls
-  end
-
-  def test_strict_mode
-    stubs = Faraday::Adapter::Test::Stubs.new(strict_mode: true)
-    stubs.get('/api?abc=123') do
-      [
-        200,
-        { 'Content-Type': 'application/javascript' },
-        '{"origin": "127.0.0.1"}'
-      ]
-    end
-
-    cli = client(stubs)
-    assert_equal '127.0.0.1', cli.httpbingo('api', params: { abc: 123 })
-
-    # uncomment to raise Stubs::NotFound
-    # assert_equal '127.0.0.1', cli.httpbingo('api', params: { abc: 123, foo: 'Kappa' })
-    stubs.verify_stubbed_calls
-  end
-
-  def test_non_default_params_encoder
-    stubs = Faraday::Adapter::Test::Stubs.new(strict_mode: true)
-    stubs.get('/api?a=x&a=y&a=z') do
-      [
-        200,
-        { 'Content-Type': 'application/javascript' },
-        '{"origin": "127.0.0.1"}'
-      ]
-    end
-    conn = Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) do |builder|
-      builder.adapter :test, stubs
-    end
-
-    cli = Client.new(conn)
-    assert_equal '127.0.0.1', cli.httpbingo('api', params: { a: %w[x y z] })
-
-    # uncomment to raise Stubs::NotFound
-    # assert_equal '127.0.0.1', cli.httpbingo('api', params: { a: %w[x y] })
-    stubs.verify_stubbed_calls
-  end
-
-  def client(stubs)
-    conn = Faraday.new do |builder|
-      builder.adapter :test, stubs
-    end
-    Client.new(conn)
-  end
-end

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

@@ -1,268 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # @example
-    #   test = Faraday::Connection.new do
-    #     use Faraday::Adapter::Test do |stub|
-    #       # Define matcher to match the request
-    #       stub.get '/resource.json' do
-    #         # return static content
-    #         [200, {'Content-Type' => 'application/json'}, 'hi world']
-    #       end
-    #
-    #       # response with content generated based on request
-    #       stub.get '/showget' do |env|
-    #         [200, {'Content-Type' => 'text/plain'}, env[:method].to_s]
-    #       end
-    #
-    #       # A regular expression can be used as matching filter
-    #       stub.get /\A\/items\/(\d+)\z/ do |env, meta|
-    #         # in case regular expression is used, an instance of MatchData
-    #         # can be received
-    #         [200,
-    #          {'Content-Type' => 'text/plain'},
-    #          "showing item: #{meta[:match_data][1]}"
-    #         ]
-    #       end
-    #
-    #       # You can set strict_mode to exactly match the stubbed requests.
-    #       stub.strict_mode = true
-    #     end
-    #   end
-    #
-    #   resp = test.get '/resource.json'
-    #   resp.body # => 'hi world'
-    #
-    #   resp = test.get '/showget'
-    #   resp.body # => 'get'
-    #
-    #   resp = test.get '/items/1'
-    #   resp.body # => 'showing item: 1'
-    #
-    #   resp = test.get '/items/2'
-    #   resp.body # => 'showing item: 2'
-    class Test < Faraday::Adapter
-      attr_accessor :stubs
-
-      # A stack of Stubs
-      class Stubs
-        class NotFound < StandardError
-        end
-
-        def initialize(strict_mode: false)
-          # { get: [Stub, Stub] }
-          @stack = {}
-          @consumed = {}
-          @strict_mode = strict_mode
-          @stubs_mutex = Monitor.new
-          yield(self) if block_given?
-        end
-
-        def empty?
-          @stack.empty?
-        end
-
-        # @param env [Faraday::Env]
-        def match(env)
-          request_method = env[:method]
-          return false unless @stack.key?(request_method)
-
-          stack = @stack[request_method]
-          consumed = (@consumed[request_method] ||= [])
-
-          @stubs_mutex.synchronize do
-            stub, meta = matches?(stack, env)
-            if stub
-              removed = stack.delete(stub)
-              consumed << removed unless removed.nil?
-              return stub, meta
-            end
-          end
-          matches?(consumed, env)
-        end
-
-        def get(path, headers = {}, &block)
-          new_stub(:get, path, headers, &block)
-        end
-
-        def head(path, headers = {}, &block)
-          new_stub(:head, path, headers, &block)
-        end
-
-        def post(path, body = nil, headers = {}, &block)
-          new_stub(:post, path, headers, body, &block)
-        end
-
-        def put(path, body = nil, headers = {}, &block)
-          new_stub(:put, path, headers, body, &block)
-        end
-
-        def patch(path, body = nil, headers = {}, &block)
-          new_stub(:patch, path, headers, body, &block)
-        end
-
-        def delete(path, headers = {}, &block)
-          new_stub(:delete, path, headers, &block)
-        end
-
-        def options(path, headers = {}, &block)
-          new_stub(:options, path, headers, &block)
-        end
-
-        # Raises an error if any of the stubbed calls have not been made.
-        def verify_stubbed_calls
-          failed_stubs = []
-          @stack.each do |method, stubs|
-            next if stubs.empty?
-
-            failed_stubs.concat(
-              stubs.map do |stub|
-                "Expected #{method} #{stub}."
-              end
-            )
-          end
-          raise failed_stubs.join(' ') unless failed_stubs.empty?
-        end
-
-        # Set strict_mode. If the value is true, this adapter tries to find matched requests strictly,
-        # which means that all of a path, parameters, and headers must be the same as an actual request.
-        def strict_mode=(value)
-          @strict_mode = value
-          @stack.each do |_method, stubs|
-            stubs.each do |stub|
-              stub.strict_mode = value
-            end
-          end
-        end
-
-        protected
-
-        def new_stub(request_method, path, headers = {}, body = nil, &block)
-          normalized_path, host =
-            if path.is_a?(Regexp)
-              path
-            else
-              [
-                Faraday::Utils.normalize_path(path),
-                Faraday::Utils.URI(path).host
-              ]
-            end
-          path, query = normalized_path.respond_to?(:split) ? normalized_path.split('?') : normalized_path
-          headers = Utils::Headers.new(headers)
-
-          stub = Stub.new(host, path, query, headers, body, @strict_mode, block)
-          (@stack[request_method] ||= []) << stub
-        end
-
-        # @param stack [Hash]
-        # @param env [Faraday::Env]
-        def matches?(stack, env)
-          stack.each do |stub|
-            match_result, meta = stub.matches?(env)
-            return stub, meta if match_result
-          end
-          nil
-        end
-      end
-
-      # Stub request
-      class Stub < Struct.new(:host, :path, :query, :headers, :body, :strict_mode, :block) # rubocop:disable Style/StructInheritance
-        # @param env [Faraday::Env]
-        def matches?(env)
-          request_host = env[:url].host
-          request_path = Faraday::Utils.normalize_path(env[:url].path)
-          request_headers = env.request_headers
-          request_body = env[:body]
-
-          # meta is a hash used as carrier
-          # that will be yielded to consumer block
-          meta = {}
-          [(host.nil? || host == request_host) &&
-            path_match?(request_path, meta) &&
-            params_match?(env) &&
-            (body.to_s.size.zero? || request_body == body) &&
-            headers_match?(request_headers), meta]
-        end
-
-        def path_match?(request_path, meta)
-          if path.is_a?(Regexp)
-            !!(meta[:match_data] = path.match(request_path))
-          else
-            path == request_path
-          end
-        end
-
-        # @param env [Faraday::Env]
-        def params_match?(env)
-          request_params = env[:params]
-          params = env.params_encoder.decode(query) || {}
-
-          if strict_mode
-            return Set.new(params) == Set.new(request_params)
-          end
-
-          params.keys.all? do |key|
-            request_params[key] == params[key]
-          end
-        end
-
-        def headers_match?(request_headers)
-          if strict_mode
-            headers_with_user_agent = headers.dup.tap do |hs|
-              # NOTE: Set User-Agent in case it's not set when creating Stubs.
-              #       Users would not want to set Faraday's User-Agent explicitly.
-              hs[:user_agent] ||= Connection::USER_AGENT
-            end
-            return Set.new(headers_with_user_agent) == Set.new(request_headers)
-          end
-
-          headers.keys.all? do |key|
-            request_headers[key] == headers[key]
-          end
-        end
-
-        def to_s
-          "#{path} #{body}"
-        end
-      end
-
-      def initialize(app, stubs = nil, &block)
-        super(app)
-        @stubs = stubs || Stubs.new
-        configure(&block) if block
-      end
-
-      def configure
-        yield(stubs)
-      end
-
-      # @param env [Faraday::Env]
-      def call(env)
-        super
-
-        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
-        env[:params] = env.params_encoder.decode(env[:url].query) || {}
-        stub, meta = stubs.match(env)
-
-        unless stub
-          raise Stubs::NotFound, "no stubbed request for #{env[:method]} "\
-                                 "#{env[:url]} #{env[:body]}"
-        end
-
-        block_arity = stub.block.arity
-        status, headers, body =
-          if block_arity >= 0
-            stub.block.call(*[env, meta].take(block_arity))
-          else
-            stub.block.call(env, meta)
-          end
-        save_response(env, status, body, headers)
-
-        @app.call(env)
-      end
-    end
-  end
-end
-
-Faraday::Adapter.register_middleware(test: Faraday::Adapter::Test)

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

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Base class for all Faraday adapters. Adapters are
-  # responsible for fulfilling a Faraday request.
-  class Adapter
-    extend MiddlewareRegistry
-
-    CONTENT_LENGTH = 'Content-Length'
-
-    # This module marks an Adapter as supporting parallel requests.
-    module Parallelism
-      attr_writer :supports_parallel
-
-      def supports_parallel?
-        @supports_parallel
-      end
-
-      def inherited(subclass)
-        super
-        subclass.supports_parallel = supports_parallel?
-      end
-    end
-
-    extend Parallelism
-    self.supports_parallel = false
-
-    def initialize(_app = nil, opts = {}, &block)
-      @app = ->(env) { env.response }
-      @connection_options = opts
-      @config_block = block
-    end
-
-    # Yields or returns an adapter's configured connection. Depends on
-    # #build_connection being defined on this adapter.
-    #
-    # @param env [Faraday::Env, Hash] The env object for a faraday request.
-    #
-    # @return The return value of the given block, or the HTTP connection object
-    #         if no block is given.
-    def connection(env)
-      conn = build_connection(env)
-      return conn unless block_given?
-
-      yield conn
-    end
-
-    # Close any persistent connections. The adapter should still be usable
-    # after calling close.
-    def close
-      # Possible implementation:
-      #   @app.close if @app.respond_to?(:close)
-    end
-
-    def call(env)
-      env.clear_body if env.needs_body?
-      env.response = Response.new
-    end
-
-    private
-
-    def save_response(env, status, body, headers = nil, reason_phrase = nil)
-      env.status = status
-      env.body = body
-      env.reason_phrase = reason_phrase&.to_s&.strip
-      env.response_headers = Utils::Headers.new.tap do |response_headers|
-        response_headers.update headers unless headers.nil?
-        yield(response_headers) if block_given?
-      end
-
-      env.response.finish(env) unless env.parallel?
-      env.response
-    end
-
-    # Fetches either a read, write, or open timeout setting. Defaults to the
-    # :timeout value if a more specific one is not given.
-    #
-    # @param type [Symbol] Describes which timeout setting to get: :read,
-    #                      :write, or :open.
-    # @param options [Hash] Hash containing Symbol keys like :timeout,
-    #                       :read_timeout, :write_timeout, :open_timeout, or
-    #                       :timeout
-    #
-    # @return [Integer, nil] Timeout duration in seconds, or nil if no timeout
-    #                        has been set.
-    def request_timeout(type, options)
-      key = TIMEOUT_KEYS.fetch(type) do
-        msg = "Expected :read, :write, :open. Got #{type.inspect} :("
-        raise ArgumentError, msg
-      end
-      options[key] || options[:timeout]
-    end
-
-    TIMEOUT_KEYS = {
-      read: :read_timeout,
-      open: :open_timeout,
-      write: :write_timeout
-    }.freeze
-  end
-end
-
-require 'faraday/adapter/test'