cybrid_api_organization_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/parser/http1.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Parser
+    class Error < Error; end
+
+    class HTTP1
+      VERSIONS = %w[1.0 1.1].freeze
+
+      attr_reader :status_code, :http_version, :headers
+
+      def initialize(observer, max_headers, max_header_value_size)
+        @observer = observer
+        @state = :idle
+        @buffer = "".b
+        @headers = {}
+        @max_headers = max_headers
+        @max_header_value_size = max_header_value_size
+        @content_length = nil
+        @_has_trailers = @upgrade = false
+      end
+
+      def <<(chunk)
+        @buffer << chunk
+        parse
+      end
+
+      def reset!
+        @state = :idle
+        @headers = {}
+        @content_length = nil
+        @_has_trailers = @upgrade = false
+        @buffer = @buffer.to_s
+      end
+
+      def upgrade?
+        @upgrade
+      end
+
+      def upgrade_data
+        @buffer.to_s
+      end
+
+      private
+
+      def parse
+        loop do
+          state = @state
+          case @state
+          when :idle
+            parse_headline
+          when :headers, :trailers
+            parse_headers
+          when :data
+            parse_data
+          end
+          return if @buffer.empty? || state == @state
+        end
+      end
+
+      def parse_headline
+        #: @type ivar @buffer: String
+        idx = @buffer.index("\n")
+        return unless idx
+
+        (m = %r{\AHTTP(?:/(\d+\.\d+))?\s+(\d\d\d)(?:\s+(.*))?}in.match(@buffer)) ||
+          raise(Error, "wrong head line format")
+        version, code, _ = m.captures
+        raise(Error, "unsupported HTTP version (HTTP/#{version})") unless version && VERSIONS.include?(version)
+
+        @http_version = version.split(".").map(&:to_i)
+        @status_code = code.to_i
+        raise(Error, "wrong status code (#{@status_code})") unless (100..599).cover?(@status_code)
+
+        @buffer = @buffer.byteslice((idx + 1)..-1)
+        nextstate(:headers)
+      end
+
+      def parse_headers
+        headers = @headers
+        buffer = @buffer
+
+        #: @type var buffer: String
+
+        while (idx = buffer.index("\n"))
+          # @type var line: String
+          line = buffer.byteslice(0..idx)
+          raise Error, "wrong header format" if line.start_with?("\s", "\t")
+
+          line.lstrip!
+          buffer = @buffer = buffer.byteslice((idx + 1)..-1)
+          if line.empty?
+            case @state
+            when :headers
+              prepare_data(headers)
+              @observer.on_headers(headers)
+              return unless @state == :headers
+
+              # state might have been reset
+              # in the :headers callback
+              nextstate(:data)
+              headers.clear
+            when :trailers
+              @observer.on_trailers(headers)
+              headers.clear
+              nextstate(:complete)
+            end
+            return
+          end
+          separator_index = line.index(":")
+          raise Error, "wrong header format" unless separator_index
+
+          # @type var key: String
+          key = line.byteslice(0..(separator_index - 1))
+
+          key.rstrip! # was lstripped previously!
+          # @type var value: String
+          value = line.byteslice((separator_index + 1)..-1)
+          value.strip!
+          raise Error, "wrong header format" if value.nil?
+
+          values = (headers[key.downcase] ||= []) << value
+
+          raise Error, "maximum header value size exceeded" if @max_header_value_size && (values.sum(&:size) > @max_header_value_size)
+
+          raise Error, "maximum number of response headers exceeded" if headers.size > @max_headers
+        end
+      end
+
+      def parse_data
+        if @buffer.respond_to?(:each)
+          # @type ivar @buffer: Transcoder::Chunker::Decoder
+          @buffer.each do |chunk|
+            @observer.on_data(chunk)
+          end
+        elsif @content_length
+          # @type ivar @buffer: String
+          data = @buffer.byteslice(0, @content_length)
+          # @type var data: String
+          @buffer = @buffer.byteslice(@content_length..-1) || "".b
+          @content_length -= data.bytesize
+          @observer.on_data(data)
+          data.clear
+        else
+          # @type ivar @buffer: String
+          @observer.on_data(@buffer)
+          @buffer.clear
+        end
+        return unless no_more_data?
+
+        @buffer = @buffer.to_s
+        if @_has_trailers
+          nextstate(:trailers)
+        else
+          nextstate(:complete)
+        end
+      end
+
+      def prepare_data(headers)
+        @upgrade = headers.key?("upgrade")
+
+        @_has_trailers = headers.key?("trailer")
+
+        if (tr_encodings = headers["transfer-encoding"])
+          tr_encodings.reverse_each do |tr_encoding|
+            tr_encoding.split(/ *, */).each do |encoding|
+              case encoding
+              when "chunked"
+                @buffer = Transcoder::Chunker::Decoder.new(@buffer.to_s, @_has_trailers)
+              end
+            end
+          end
+        else
+          @content_length = headers["content-length"][0].to_i if headers.key?("content-length")
+        end
+      end
+
+      def no_more_data?
+        if @content_length
+          @content_length <= 0
+        elsif @buffer.respond_to?(:finished?)
+          # @type ivar @buffer: Transcoder::Chunker::Decoder
+          @buffer.finished?
+        else
+          false
+        end
+      end
+
+      def nextstate(state)
+        @state = state
+        case state
+        when :headers
+          @observer.on_start
+        when :complete
+          @observer.on_complete
+          reset!
+          nextstate(:idle) unless @buffer.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "httpx/base64"
+
+module HTTPX
+  module Plugins
+    module Authentication
+      class Basic
+        def initialize(user, password, **)
+          @user = user
+          @password = password
+        end
+
+        def authenticate(*)
+          "Basic #{Base64.strict_encode64("#{@user}:#{@password}")}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "time"
+require "securerandom"
+require "digest"
+
+module HTTPX
+  module Plugins
+    module Authentication
+      class Digest
+        class Error < Error
+        end
+
+        def initialize(user, password, hashed: false, **)
+          @user = user
+          @password = password
+          @nonce = 0
+          @hashed = hashed
+        end
+
+        def can_authenticate?(authenticate)
+          authenticate && /Digest .*/.match?(authenticate)
+        end
+
+        def authenticate(request, authenticate)
+          "Digest #{generate_header(request.verb, request.path, authenticate)}"
+        rescue HTTPX::Error => e
+          response = ErrorResponse.new(request, e)
+          request.response = response
+          request.emit_response(response)
+          nil
+        end
+
+        private
+
+        def generate_header(meth, uri, authenticate)
+          # discard first token, it's Digest
+          auth_info = authenticate[/^(\w+) (.*)/, 2]
+
+          raise_format_error unless auth_info
+
+          s = StringScanner.new(auth_info)
+
+          params = {}
+          until s.eos?
+            k = s.scan_until(/=/)
+            raise_format_error unless k&.end_with?("=")
+
+            if s.peek(1) == "\""
+              s.skip("\"")
+              v = s.scan_until(/"/)
+              raise_format_error unless v&.end_with?("\"")
+
+              v = v[0..-2]
+              s.skip_until(/,/)
+            else
+              v = s.scan_until(/,|$/)
+
+              if v&.end_with?(",")
+                v = v[0..-2]
+              else
+                raise_format_error unless s.eos?
+              end
+
+              v = v[0..-2] if v&.end_with?(",")
+            end
+            params[k[0..-2]] = v
+            s.skip(/\s/)
+          end
+
+          nonce = params["nonce"]
+          nc = next_nonce
+
+          # verify qop
+          qop = params["qop"]
+
+          if qop
+            # some servers send multiple values wrapped in parentheses (i.e. "(qauth,)")
+            qop = qop[/\(?([^)]+)\)?/, 1]
+            qop = qop.split(",").map { |s| s.delete_prefix("'").delete_suffix("'") }.delete_if(&:empty?).map.first
+          end
+
+          if params["algorithm"] =~ /(.*?)(-sess)?$/
+            alg = Regexp.last_match(1)
+            raise_format_error unless alg
+            algorithm = ::Digest.const_get(alg)
+            raise Error, "unknown algorithm \"#{alg}\"" unless algorithm
+
+            sess = Regexp.last_match(2)
+          else
+            algorithm = ::Digest::MD5
+          end
+
+          if qop || sess
+            cnonce = make_cnonce
+            nc = format("%<nonce>08x", nonce: nc)
+          end
+
+          a1 = if sess
+            [
+              (@hashed ? @password : algorithm.hexdigest("#{@user}:#{params["realm"]}:#{@password}")),
+              nonce,
+              cnonce,
+            ].join ":"
+          else
+            @hashed ? @password : "#{@user}:#{params["realm"]}:#{@password}"
+          end
+
+          ha1 = algorithm.hexdigest(a1)
+          ha2 = algorithm.hexdigest("#{meth}:#{uri}")
+          request_digest = [ha1, nonce]
+          request_digest.push(nc, cnonce, qop) if qop
+          request_digest << ha2
+          request_digest = request_digest.join(":")
+
+          header = [
+            %(username="#{@user}"),
+            %(nonce="#{nonce}"),
+            %(uri="#{uri}"),
+            %(response="#{algorithm.hexdigest(request_digest)}"),
+          ]
+          header << %(realm="#{params["realm"]}") if params.key?("realm")
+          header << %(algorithm=#{params["algorithm"]}) if params.key?("algorithm")
+          header << %(cnonce="#{cnonce}") if cnonce
+          header << %(nc=#{nc})
+          header << %(qop=#{qop}) if qop
+          header << %(opaque="#{params["opaque"]}") if params.key?("opaque")
+          header.join ", "
+        end
+
+        def make_cnonce
+          ::Digest::MD5.hexdigest [
+            Time.now.to_i,
+            Process.pid,
+            SecureRandom.random_number(2**32),
+          ].join ":"
+        end
+
+        def next_nonce
+          @nonce += 1
+        end
+
+        def raise_format_error
+          raise Error, "unsupported digest header format"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "httpx/base64"
+require "ntlm"
+
+module HTTPX
+  module Plugins
+    module Authentication
+      class Ntlm
+        def initialize(user, password, domain: nil)
+          @user = user
+          @password = password
+          @domain = domain
+        end
+
+        def can_authenticate?(authenticate)
+          authenticate && /NTLM .*/.match?(authenticate)
+        end
+
+        def negotiate
+          "NTLM #{NTLM.negotiate(domain: @domain).to_base64}"
+        end
+
+        def authenticate(_req, www)
+          challenge = www[/NTLM (.*)/, 1]
+
+          challenge = Base64.decode64(challenge)
+          ntlm_challenge = NTLM.authenticate(challenge, @user, @domain, @password).to_base64
+
+          "NTLM #{ntlm_challenge}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Authentication
+      class Socks5
+        def initialize(user, password, **)
+          @user = user
+          @password = password
+        end
+
+        def can_authenticate?(*)
+          @user && @password
+        end
+
+        def authenticate(*)
+          [0x01, @user.bytesize, @user, @password.bytesize, @password].pack("CCA*CA*")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds a shim +authorization+ method to the session, which will fill
+    # the HTTP Authorization header, and another, +bearer_auth+, which fill the "Bearer " prefix
+    # in its value.
+    #
+    # https://gitlab.com/os85/httpx/wikis/Auth#auth
+    #
+    module Auth
+      def self.subplugins
+        {
+          retries: AuthRetries,
+        }
+      end
+
+      # adds support for the following options:
+      #
+      # :auth_header_value :: the token to use as a string, or a callable which returns a string when called.
+      #                       the callable is called a request, and a boolean: when true, the user must regenerate a token, otherwise it
+      #                       may probe for token freshness and return the same token.
+      # :auth_header_type :: the authentication type to use in the "authorization" header value (i.e. "Bearer", "Digest"...)
+      # :auth_header_expires_at :: timestamp at which the auth header will be discarded. should be a callable (like a proc)
+      #                            receiving the request as an argument, and should return either a Time object, or an integer (UNIX time).
+      # :auth_header_expires_in :: time (in seconds) since the first use of an auth header after which that header will be discarded.
+      # :generate_auth_value_on_retry :: callable which returns whether the request should regenerate the auth_header_value
+      #                                  when the request is retried (this option will only work if the session also loads the
+      #                                  <tt>:retries</tt> plugin).
+      module OptionsMethods
+        def option_auth_header_value(value)
+          value
+        end
+
+        def option_auth_header_type(value)
+          value
+        end
+
+        def option_auth_header_expires_at(value)
+          unless value.respond_to?(:call)
+            value = Float(value)
+            raise TypeError, "`:auth_header_expires_at` must be positive" unless value.positive?
+          end
+
+          value
+        end
+
+        def option_auth_header_expires_in(value)
+          value = Float(value)
+          raise TypeError, "`:auth_header_expires_in` must be positive" unless value.positive?
+
+          value
+        end
+
+        def option_generate_auth_value_on_retry(value)
+          raise TypeError, "`:generate_auth_value_on_retry` must be a callable" unless value.respond_to?(:call)
+
+          value
+        end
+      end
+
+      module InstanceMethods
+        def initialize(*)
+          super
+
+          @auth_header_value = @auth_header_expires_at = nil
+          @auth_header_value_mtx = Thread::Mutex.new
+          @skip_auth_header_value = false
+        end
+
+        def authorization(token = nil, auth_header_type: nil, &blk)
+          with(auth_header_type: auth_header_type, auth_header_value: token || blk)
+        end
+
+        def bearer_auth(token = nil, &blk)
+          authorization(token, auth_header_type: "Bearer", &blk)
+        end
+
+        def skip_auth_header
+          @skip_auth_header_value = true
+          yield
+        ensure
+          @skip_auth_header_value = false
+        end
+
+        def reset_auth_header_value!
+          @auth_header_value_mtx.synchronize do
+            @auth_header_value = @auth_header_expires_at = nil
+          end
+        end
+
+        private
+
+        def send_request(request, *)
+          return super if @skip_auth_header_value || request.authorized?
+
+          auth_header_value = @auth_header_value_mtx.synchronize do
+            try_invalidate_auth_header_value
+
+            @auth_header_value ||= generate_auth_token(request, false).tap do
+              set_auth_header_expires_at(request)
+            end
+          end
+
+          request.authorize(auth_header_value) if auth_header_value
+
+          super
+        end
+
+        def try_invalidate_auth_header_value
+          return unless (expires_at = @auth_header_expires_at)
+
+          return if expires_at > Time.now.utc.to_i
+
+          @auth_header_value = @auth_header_expires_at = nil
+        end
+
+        def generate_auth_token(request, should_regenerate)
+          return unless (auth_value = @options.auth_header_value)
+
+          auth_value = auth_value.call(request, should_regenerate) if dynamic_auth_token?(auth_value)
+
+          auth_value
+        end
+
+        def set_auth_header_expires_at(request)
+          @auth_header_expires_at = if (expires_in = request.options.auth_header_expires_in)
+            Time.now.to_i + expires_in
+          elsif (expires_at = request.options.auth_header_expires_at)
+            if expires_at.respond_to?(:call) && (expires_at = expires_at.call(request))
+              expires_at = expires_at.to_f
+              raise Error, "`:auth_header_expires_at` must be positive" unless expires_at.positive?
+
+              expires_at
+            end
+          end
+        end
+
+        def dynamic_auth_token?(auth_header_value)
+          auth_header_value&.respond_to?(:call)
+        end
+      end
+
+      module RequestMethods
+        attr_reader :auth_token_value
+
+        def initialize(*)
+          super
+          @auth_token_value = @auth_header_value = nil
+        end
+
+        def authorized?
+          !@auth_token_value.nil?
+        end
+
+        def unauthorize!
+          return unless (auth_value = @auth_header_value)
+
+          @headers.get("authorization").delete(auth_value)
+
+          @auth_token_value = @auth_header_value = nil
+        end
+
+        def authorize(auth_value)
+          @auth_header_value = auth_value
+          if (auth_type = @options.auth_header_type)
+            @auth_header_value = "#{auth_type} #{@auth_header_value}"
+          end
+
+          @headers.add("authorization", @auth_header_value)
+
+          @auth_token_value = auth_value
+        end
+      end
+
+      module AuthRetries
+        module InstanceMethods
+          private
+
+          def retryable_request?(request, response, options)
+            super || auth_error?(response, options)
+          end
+
+          def retryable_response?(response, options)
+            auth_error?(response, options) || super
+          end
+
+          def prepare_to_retry(request, response)
+            super
+
+            return unless auth_error?(response, request.options) ||
+                          (@options.generate_auth_value_on_retry && @options.generate_auth_value_on_retry.call(response))
+
+            # regenerate token before retry, but only if it's the first request from batch failing.
+            # otherwise, it means that the first request already passed here, so this request should
+            # use whatever was generated for it.
+            @auth_header_value_mtx.synchronize do
+              if request.auth_token_value == @auth_header_value
+                @auth_header_value = generate_auth_token(request, true)
+                set_auth_header_expires_at(request)
+              end
+            end
+
+            request.unauthorize!
+          end
+
+          def when_to_retry(request, response, *)
+            return super unless response.is_a?(Response)
+
+            # retry immediately if authentication no longer valid.
+            return if response.status == 401
+
+            super
+          end
+
+          def auth_error?(response, options)
+            response.is_a?(Response) && response.status == 401 && dynamic_auth_token?(options.auth_header_value)
+          end
+        end
+      end
+    end
+    register_plugin :auth, Auth
+  end
+end