cybrid_api_organization_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/cookies.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin implements a persistent cookie jar for the duration of a session.
+    #
+    # https://gitlab.com/os85/httpx/wikis/Cookies
+    #
+    module Cookies
+      def self.load_dependencies(*)
+        require "httpx/plugins/cookies/jar"
+        require "httpx/plugins/cookies/cookie"
+        require "httpx/plugins/cookies/set_cookie_parser"
+      end
+
+      module InstanceMethods
+        extend Forwardable
+
+        def_delegator :@options, :cookies
+
+        def initialize(options = {}, &blk)
+          super({ cookies: Jar.new }.merge(options), &blk)
+        end
+
+        def wrap
+          return super unless block_given?
+
+          super do |session|
+            old_cookies_jar = @options.cookies.dup
+            begin
+              yield session
+            ensure
+              @options = @options.merge(cookies: old_cookies_jar)
+            end
+          end
+        end
+
+        def build_request(*)
+          request = super
+          request.headers.set_cookie(request.options.cookies[request.uri])
+          request
+        end
+
+        # factory method to return a Jar to the user, which can then manipulate
+        # externally to the session.
+        def make_jar(...)
+          Jar.new(...)
+        end
+
+        private
+
+        def set_request_callbacks(request)
+          super
+          request.on(:response) do |response|
+            next unless response && response.respond_to?(:headers) && (set_cookie = response.headers["set-cookie"])
+
+            log { "cookies: set-cookie is over #{Cookie::MAX_LENGTH}" } if set_cookie.bytesize > Cookie::MAX_LENGTH
+
+            @options.cookies.parse(set_cookie)
+          end
+        end
+      end
+
+      module HeadersMethods
+        def set_cookie(cookies)
+          return if cookies.empty?
+
+          header_value = cookies.sort.join("; ")
+
+          add("cookie", header_value)
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :cookies :: cookie jar for the session (can be a Hash, an Array, an instance of HTTPX::Plugins::Cookies::CookieJar)
+      module OptionsMethods
+        private
+
+        def option_headers(*)
+          value = super
+
+          merge_cookie_in_jar(value.delete("cookie"), @cookies) if defined?(@cookies) && value.key?("cookie")
+
+          value
+        end
+
+        def option_cookies(value)
+          jar = value.is_a?(Jar) ? value : Jar.new(value)
+
+          merge_cookie_in_jar(@headers.delete("cookie"), jar) if defined?(@headers) && @headers.key?("cookie")
+
+          jar
+        end
+
+        def merge_cookie_in_jar(cookies, jar)
+          cookies.each do |ck|
+            ck.split(/ *; */).each do |cookie|
+              name, value = cookie.split("=", 2)
+              jar.set(name, value)
+            end
+          end
+        end
+      end
+    end
+    register_plugin :cookies, Cookies
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/digest_auth.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds helper methods to implement HTTP Digest Auth (https://datatracker.ietf.org/doc/html/rfc7616)
+    #
+    # https://gitlab.com/os85/httpx/wikis/Auth#digest-auth
+    #
+    module DigestAuth
+      class << self
+        def extra_options(options)
+          options.merge(max_concurrent_requests: 1)
+        end
+
+        def load_dependencies(klass)
+          require_relative "auth/digest"
+          klass.plugin(:auth)
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :digest :: instance of HTTPX::Plugins::Authentication::Digest, used to authenticate requests in the session.
+      module OptionsMethods
+        private
+
+        def option_digest(value)
+          raise TypeError, ":digest must be a #{Authentication::Digest}" unless value.is_a?(Authentication::Digest)
+
+          value
+        end
+      end
+
+      module InstanceMethods
+        def digest_auth(user, password, hashed: false)
+          with(digest: Authentication::Digest.new(user, password, hashed: hashed))
+        end
+
+        private
+
+        def send_requests(*requests)
+          requests.flat_map do |request|
+            digest = request.options.digest
+
+            next super(request) unless digest
+
+            probe_response = wrap { super(request).first }
+
+            return [probe_response] * requests.size unless probe_response.is_a?(Response)
+
+            if probe_response.status == 401 && digest.can_authenticate?(probe_response.headers["www-authenticate"])
+              request.transition(:idle)
+
+              if (auth_header = digest.authenticate(request, probe_response.headers["www-authenticate"]))
+                request.authorize(auth_header)
+              end
+
+              next(request.response) if request.response
+
+              super(request)
+            else
+              probe_response
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin :digest_auth, DigestAuth
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/expect.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin makes all HTTP/1.1 requests with a body send the "Expect: 100-continue".
+    #
+    # https://gitlab.com/os85/httpx/wikis/Expect#expect
+    #
+    module Expect
+      EXPECT_TIMEOUT = 2
+      NOEXPECT_STORE_MUTEX = Thread::Mutex.new
+
+      class Store
+        def initialize
+          @store = []
+          @mutex = Thread::Mutex.new
+        end
+
+        def include?(host)
+          @mutex.synchronize { @store.include?(host) }
+        end
+
+        def add(host)
+          @mutex.synchronize { @store << host }
+        end
+
+        def delete(host)
+          @mutex.synchronize { @store.delete(host) }
+        end
+      end
+
+      class << self
+        def no_expect_store
+          return Ractor.store_if_absent(:httpx_no_expect_store) { Store.new } if Utils.in_ractor?
+
+          @no_expect_store ||= NOEXPECT_STORE_MUTEX.synchronize do
+            @no_expect_store || Store.new
+          end
+        end
+
+        def extra_options(options)
+          options.merge(expect_timeout: EXPECT_TIMEOUT)
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :expect_timeout :: time (in seconds) to wait for a 100-expect response,
+      #                    before retrying without the Expect header (defaults to <tt>2</tt>).
+      # :expect_threshold_size :: min threshold (in bytes) of the request payload to enable the 100-continue negotiation on.
+      module OptionsMethods
+        private
+
+        def option_expect_timeout(value)
+          seconds = Float(value)
+          raise TypeError, ":expect_timeout must be positive" unless seconds.positive?
+
+          seconds
+        end
+
+        def option_expect_threshold_size(value)
+          bytes = Integer(value)
+          raise TypeError, ":expect_threshold_size must be positive" unless bytes.positive?
+
+          bytes
+        end
+      end
+
+      module RequestMethods
+        def initialize(*)
+          super
+
+          @informational_status = nil
+
+          return if @body.empty?
+
+          threshold = @options.expect_threshold_size
+          return if threshold && !@body.unbounded_body? && @body.bytesize < threshold
+
+          return if Expect.no_expect_store.include?(origin)
+
+          @headers["expect"] = "100-continue"
+        end
+
+        def response=(response)
+          if response.is_a?(Response) &&
+             response.status == 100 &&
+             !@headers.key?("expect") &&
+             (@state == :body || @state == :done)
+
+            # if we're past this point, this means that we just received a 100-Continue response,
+            # but the request doesn't have the expect flag, and is already flushing (or flushed) the body.
+            #
+            # this means that expect was deactivated for this request too soon, i.e. response took longer.
+            #
+            # so we have to reactivate it again.
+            @headers["expect"] = "100-continue"
+            @informational_status = 100
+            Expect.no_expect_store.delete(origin)
+          end
+          super
+        end
+      end
+
+      module ConnectionMethods
+        def send_request_to_parser(request)
+          super
+
+          return unless request.headers["expect"] == "100-continue"
+
+          expect_timeout = request.options.expect_timeout
+
+          return if expect_timeout.nil? || expect_timeout.infinite?
+
+          set_request_timeout(:expect_timeout, request, expect_timeout, :expect, %i[body response]) do
+            # expect timeout expired
+            if request.state == :expect && !request.expects?
+              Expect.no_expect_store.add(request.origin)
+              request.headers.delete("expect")
+              consume
+            end
+          end
+        end
+      end
+
+      module InstanceMethods
+        def fetch_response(request, selector, options)
+          response = super
+
+          return unless response
+
+          if response.is_a?(Response) && response.status == 417 && request.headers.key?("expect")
+            response.close
+            request.headers.delete("expect")
+            request.transition(:idle)
+            send_request(request, selector, options)
+
+            # recalling itself, in case an error was triggered by the above, and we can
+            # verify retriability again.
+            return fetch_response(request, selector, options)
+          end
+
+          response
+        end
+      end
+    end
+    register_plugin :expect, Expect
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/fiber_concurrency.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    # This plugin makes a session reuse the same selector across all fibers in a given thread.
+    #
+    # This enables integration with fiber scheduler implementations such as [async](https://github.com/async).
+    #
+    # # https://gitlab.com/os85/httpx/wikis/Fiber-Concurrency
+    #
+    module FiberConcurrency
+      def self.subplugins
+        {
+          h2c: FiberConcurrencyH2C,
+          stream: FiberConcurrencyStream,
+        }
+      end
+
+      module InstanceMethods
+        private
+
+        def send_request(request, *)
+          request.set_context!
+
+          super
+        end
+
+        def get_current_selector
+          super(&nil) || begin
+            return unless block_given?
+
+            default = yield
+
+            set_current_selector(default)
+
+            default
+          end
+        end
+      end
+
+      module RequestMethods
+        # the execution context (fiber) this request was sent on.
+        attr_reader :context
+
+        def initialize(*)
+          super
+          @context = nil
+        end
+
+        # sets the execution context for this request. the default is the current fiber.
+        def set_context!
+          @context ||= Fiber.current # rubocop:disable Naming/MemoizedInstanceVariableName
+        end
+
+        # checks whether the current execution context is the one where the request was created.
+        def current_context?
+          @context == Fiber.current
+        end
+
+        def complete!(response = @response)
+          @context = nil
+          super
+        end
+      end
+
+      module ConnectionMethods
+        def current_context?
+          @pending.any?(&:current_context?) || (
+            @sibling && @sibling.pending.any?(&:current_context?)
+          )
+        end
+
+        def initial_call
+          return unless current_context?
+
+          super
+        end
+
+        def interests
+          return if connecting? && @pending.none?(&:current_context?)
+
+          super
+        end
+
+        def on_io_error(e)
+          return super unless e.is_a?(IOError) && e.message.include?("stream closed in another thread")
+
+          # @fiber-switch-guard
+          # sockets closed during fiber scheduler switches are raised in separate fibers than the fiber the
+          # socket may be used in. this check verifies that this is actually about this socket.
+          return unless to_io.closed?
+
+          if @state == :closing
+            # @fiber-switch-guard
+            # if the connection is reused across fibers, the socket may have been closed in the other fiber
+            # and switched here during the process, so continue what it was doing and transition to closed
+            # via #call.
+            call
+          elsif !backlog?
+            super
+          end
+        end
+
+        def on_connect_error(e)
+          return super unless e.is_a?(IOError) && e.message.include?("stream closed in another thread")
+
+          # @fiber-switch-guard
+          # sockets closed during fiber scheduler switches are raised in separate fibers than the fiber the
+          # socket may be used in. this check verifies that this is actually about this socket.
+          return unless to_io.closed? && !backlog?
+
+          super
+        end
+
+        private
+
+        # checks whether the connection has any pending request (which the connection itself may
+        # have stored, or it may be somewhere in the parser).
+        def backlog?
+          @pending.any? ||
+            (@parser && (@parser.pending.any? || @parser.requests.any?))
+        end
+      end
+
+      module HTTP1Methods
+        def interests
+          request = @request || @requests.first
+
+          return unless request
+
+          return unless request.current_context? || @requests.any?(&:current_context?) || @pending.any?(&:current_context?)
+
+          super
+        end
+      end
+
+      module HTTP2Methods
+        def initialize(*)
+          super
+          @contexts = Hash.new { |hs, k| hs[k] = Set.new }
+        end
+
+        def interests
+          if @connection.state == :connected && @handshake_completed && !@contexts.key?(Fiber.current)
+            return :w unless @pings.empty?
+
+            return
+          end
+
+          super
+        end
+
+        def send(request, *)
+          add_to_context(request)
+
+          super
+        end
+
+        private
+
+        def on_close(_, error, _)
+          if error == :http_1_1_required
+            # remove all pending requests context
+            @pending.each do |req|
+              clear_from_context(req)
+            end
+          end
+
+          super
+        end
+
+        def on_stream_close(_, request, error)
+          clear_from_context(request) if error != :stream_closed && @streams.key?(request)
+
+          super
+        end
+
+        def teardown(request = nil)
+          super
+
+          if request
+            clear_from_context(request)
+          else
+            @contexts.clear
+          end
+        end
+
+        def add_to_context(request)
+          @contexts[request.context] << request
+        end
+
+        def clear_from_context(request)
+          requests = @contexts[request.context]
+
+          requests.delete(request)
+
+          @contexts.delete(request.context) if requests.empty?
+        end
+      end
+
+      module ResolverNativeMethods
+        def initial_call
+          return unless @queries.values.any?(&:current_context?) || @connections.any?(&:current_context?)
+
+          super
+        end
+
+        def calculate_interests
+          return if @queries.empty?
+
+          return unless @queries.values.any?(&:current_context?) || @connections.any?(&:current_context?)
+
+          super
+        end
+
+        def disconnect
+          return unless @connections.all?(&:current_context?)
+
+          super
+        end
+
+        def on_io_error(e)
+          # TODO: return super if this is not stream clsed in another thread
+
+          log { "IO Erroring: #{e.message}, current:#{@name}, queries:#{@queries.size}" }
+          return unless @name
+
+          super
+        end
+      end
+
+      module ResolverSystemMethods
+        def initial_call
+          return unless current_context?
+
+          super
+        end
+
+        def interests
+          return unless current_context?
+
+          super
+        end
+
+        private
+
+        def current_context?
+          @queries.any? { |_, conn| conn.current_context? }
+        end
+      end
+
+      module FiberConcurrencyH2C
+        module HTTP2Methods
+          def upgrade(request, *)
+            @contexts[request.context] << request
+
+            super
+          end
+        end
+      end
+
+      module FiberConcurrencyStream
+        module StreamResponseMethods
+          def close
+            unless @request.current_context?
+              @request.close
+
+              return
+            end
+
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin :fiber_concurrency, FiberConcurrency
+  end
+end