cybrid_api_id_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds `Content-Digest` headers to requests
+    # and can validate these headers on responses
+    #
+    # https://datatracker.ietf.org/doc/html/rfc9530
+    #
+    module ContentDigest
+      class Error < HTTPX::Error; end
+
+      # Error raised on response "content-digest" header validation.
+      class ValidationError < Error
+        attr_reader :response
+
+        def initialize(message, response)
+          super(message)
+          @response = response
+        end
+      end
+
+      class MissingContentDigestError < ValidationError; end
+      class InvalidContentDigestError < ValidationError; end
+
+      SUPPORTED_ALGORITHMS = {
+        "sha-256" => OpenSSL::Digest::SHA256,
+        "sha-512" => OpenSSL::Digest::SHA512,
+      }.freeze
+
+      class << self
+        def extra_options(options)
+          options.merge(encode_content_digest: true, validate_content_digest: false, content_digest_algorithm: "sha-256")
+        end
+      end
+
+      # add support for the following options:
+      #
+      # :content_digest_algorithm :: the digest algorithm to use. Currently supports `sha-256` and `sha-512`. (defaults to `sha-256`)
+      # :encode_content_digest :: whether a <tt>Content-Digest</tt> header should be computed for the request;
+      #                           can also be a callable object (i.e. <tt>->(req) { ... }</tt>, defaults to <tt>true</tt>)
+      # :validate_content_digest :: whether a <tt>Content-Digest</tt> header in the response should be validated;
+      #                             can also be a callable object (i.e. <tt>->(res) { ... }</tt>, defaults to <tt>false</tt>)
+      module OptionsMethods
+        private
+
+        def option_content_digest_algorithm(value)
+          raise TypeError, ":content_digest_algorithm must be one of 'sha-256', 'sha-512'" unless SUPPORTED_ALGORITHMS.key?(value)
+
+          value
+        end
+
+        def option_encode_content_digest(value)
+          value
+        end
+
+        def option_validate_content_digest(value)
+          value
+        end
+      end
+
+      module ResponseBodyMethods
+        attr_reader :content_digest_buffer
+
+        def initialize(response, options)
+          super
+
+          return unless response.headers.key?("content-digest")
+
+          should_validate = options.validate_content_digest
+          should_validate = should_validate.call(response) if should_validate.respond_to?(:call)
+
+          return unless should_validate
+
+          @content_digest_buffer = Response::Buffer.new(
+            threshold_size: @options.body_threshold_size,
+            bytesize: @length,
+            encoding: @encoding
+          )
+        end
+
+        def write(chunk)
+          @content_digest_buffer.write(chunk) if @content_digest_buffer
+          super
+        end
+
+        def close
+          if @content_digest_buffer
+            @content_digest_buffer.close
+            @content_digest_buffer = nil
+          end
+          super
+        end
+      end
+
+      module InstanceMethods
+        def build_request(*)
+          request = super
+
+          return request if request.empty?
+
+          return request if request.headers.key?("content-digest")
+
+          perform_encoding = @options.encode_content_digest
+          perform_encoding = perform_encoding.call(request) if perform_encoding.respond_to?(:call)
+
+          return request unless perform_encoding
+
+          digest = base64digest(request.body)
+          request.headers.add("content-digest", "#{@options.content_digest_algorithm}=:#{digest}:")
+
+          request
+        end
+
+        private
+
+        def fetch_response(request, _, _)
+          response = super
+          return response unless response.is_a?(Response)
+
+          perform_validation = @options.validate_content_digest
+          perform_validation = perform_validation.call(response) if perform_validation.respond_to?(:call)
+
+          validate_content_digest(response) if perform_validation
+
+          response
+        rescue ValidationError => e
+          ErrorResponse.new(request, e)
+        end
+
+        def validate_content_digest(response)
+          content_digest_header = response.headers["content-digest"]
+
+          raise MissingContentDigestError.new("response is missing a `content-digest` header", response) unless content_digest_header
+
+          digests = extract_content_digests(content_digest_header)
+
+          included_algorithms = SUPPORTED_ALGORITHMS.keys & digests.keys
+
+          raise MissingContentDigestError.new("unsupported algorithms: #{digests.keys.join(", ")}", response) if included_algorithms.empty?
+
+          content_buffer = response.body.content_digest_buffer
+
+          included_algorithms.each do |algorithm|
+            digest = SUPPORTED_ALGORITHMS.fetch(algorithm).new
+            digest_received = digests[algorithm]
+            digest_computed =
+              if content_buffer.respond_to?(:to_path)
+                content_buffer.flush
+                digest.file(content_buffer.to_path).base64digest
+              else
+                digest.base64digest(content_buffer.to_s)
+              end
+
+            raise InvalidContentDigestError.new("#{algorithm} digest does not match content",
+                                                response) unless digest_received == digest_computed
+          end
+        end
+
+        def extract_content_digests(header)
+          header.split(",").to_h do |entry|
+            algorithm, digest = entry.split("=", 2)
+            raise Error, "#{entry} is an invalid digest format" unless algorithm && digest
+
+            [algorithm, digest.byteslice(1..-2)]
+          end
+        end
+
+        def base64digest(body)
+          digest = SUPPORTED_ALGORITHMS.fetch(@options.content_digest_algorithm).new
+
+          if body.respond_to?(:read)
+            if body.respond_to?(:to_path)
+              digest.file(body.to_path).base64digest
+            else
+              raise ContentDigestError, "request body must be rewindable" unless body.respond_to?(:rewind)
+
+              buffer = Tempfile.new("httpx", encoding: Encoding::BINARY, mode: File::RDWR)
+              begin
+                IO.copy_stream(body, buffer)
+                buffer.flush
+
+                digest.file(buffer.to_path).base64digest
+              ensure
+                body.rewind
+                buffer.close
+                buffer.unlink
+              end
+            end
+          else
+            raise ContentDigestError, "base64digest for endless enumerators is not supported" if body.unbounded_body?
+
+            buffer = "".b
+            body.each { |chunk| buffer << chunk }
+
+            digest.base64digest(buffer)
+          end
+        end
+      end
+    end
+    register_plugin :content_digest, ContentDigest
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins::Cookies
+    # The HTTP Cookie.
+    #
+    # Contains the single cookie info: name, value and attributes.
+    class Cookie
+      include Comparable
+
+      # Maximum number of bytes per cookie (RFC 6265 6.1 requires 4096 at
+      # least)
+      MAX_LENGTH = 4096
+
+      attr_reader :domain, :path, :name, :value, :created_at
+
+      # assigns a new +path+ to this cookie.
+      def path=(path)
+        path = String(path)
+        @for_domain = false
+        @path = path.start_with?("/") ? path : "/"
+      end
+
+      # assigns a new +domain+ to this cookie.
+      def domain=(domain)
+        domain = String(domain)
+
+        if domain.start_with?(".")
+          @for_domain = true
+          domain = domain[1..-1]
+        end
+
+        return if domain.empty?
+
+        @domain_name = DomainName.new(domain)
+        # RFC 6265 5.3 5.
+        @for_domain = false if @domain_name.domain.nil? # a public suffix or IP address
+
+        @domain = @domain_name.hostname
+      end
+
+      # checks whether +other+ is the same cookie, i.e. name, value, domain and path are
+      # the same.
+      def ==(other)
+        @name == other.name && @value == other.value &&
+          @path == other.path && @domain == other.domain
+      end
+
+      # Compares the cookie with another.  When there are many cookies with
+      # the same name for a URL, the value of the smallest must be used.
+      def <=>(other)
+        # RFC 6265 5.4
+        # Precedence: 1. longer path  2. older creation
+        (@name <=> other.name).nonzero? ||
+          (other.path.length <=> @path.length).nonzero? ||
+          (@created_at <=> other.created_at).nonzero? || 0
+      end
+
+      def match?(name_or_options)
+        case name_or_options
+        when String
+          @name == name_or_options
+        when Hash, Array
+          name_or_options.all? { |k, v| respond_to?(k) && send(k) == v }
+        else
+          false
+        end
+      end
+
+      class << self
+        def new(cookie, *)
+          case cookie
+          when self
+            cookie
+          when Array, Hash
+            options = Hash[cookie] #: cookie_attributes
+            super(options[:name], options[:value], options)
+          else
+
+            super
+          end
+        end
+
+        # Tests if +target_path+ is under +base_path+ as described in RFC
+        # 6265 5.1.4.  +base_path+ must be an absolute path.
+        # +target_path+ may be empty, in which case it is treated as the
+        # root path.
+        #
+        # e.g.
+        #
+        #         path_match?('/admin/', '/admin/index') == true
+        #         path_match?('/admin/', '/Admin/index') == false
+        #         path_match?('/admin/', '/admin/') == true
+        #         path_match?('/admin/', '/admin') == false
+        #
+        #         path_match?('/admin', '/admin') == true
+        #         path_match?('/admin', '/Admin') == false
+        #         path_match?('/admin', '/admins') == false
+        #         path_match?('/admin', '/admin/') == true
+        #         path_match?('/admin', '/admin/index') == true
+        def path_match?(base_path, target_path)
+          base_path.start_with?("/") || (return false)
+          # RFC 6265 5.1.4
+          bsize = base_path.size
+          tsize = target_path.size
+          return bsize == 1 if tsize.zero? # treat empty target_path as "/"
+          return false unless target_path.start_with?(base_path)
+          return true if bsize == tsize || base_path.end_with?("/")
+
+          target_path[bsize] == "/"
+        end
+      end
+
+      def initialize(arg, value, attrs = nil)
+        @created_at = Time.now
+
+        @name = arg
+        @value = value
+        attr_hash = Hash.try_convert(attrs)
+
+        attr_hash.each do |key, val|
+          key = key.downcase.tr("-", "_").to_sym unless key.is_a?(Symbol)
+
+          case key
+          when :domain, :path
+            __send__(:"#{key}=", val)
+          else
+            instance_variable_set(:"@#{key}", val)
+          end
+        end if attr_hash
+
+        @path ||= "/"
+        raise ArgumentError, "name must be specified" if @name.nil?
+
+        @name = @name.to_s
+      end
+
+      def expires
+        @expires || (@created_at && @max_age ? @created_at + @max_age : nil)
+      end
+
+      def expired?(time = Time.now)
+        return false unless expires
+
+        expires <= time
+      end
+
+      # Returns a string for use in the Cookie header, i.e. `name=value`
+      # or `name="value"`.
+      def cookie_value
+        "#{@name}=#{Scanner.quote(@value.to_s)}"
+      end
+      alias_method :to_s, :cookie_value
+
+      # Tests if it is OK to send this cookie to a given `uri`.  A
+      # RuntimeError is raised if the cookie's domain is unknown.
+      def valid_for_uri?(uri)
+        # RFC 6265 5.4
+
+        return false if @secure && uri.scheme != "https"
+
+        acceptable_from_uri?(uri) && Cookie.path_match?(@path, uri.path)
+      end
+
+      private
+
+      # Tests if it is OK to accept this cookie if it is sent from a given
+      # URI/URL, `uri`.
+      def acceptable_from_uri?(uri)
+        uri = URI(uri)
+
+        host = DomainName.new(uri.host)
+
+        # RFC 6265 5.3
+        if host.hostname == @domain
+          true
+        elsif @for_domain # !host-only-flag
+          host.cookie_domain?(@domain_name)
+        else
+          @domain.nil?
+        end
+      end
+
+      module Scanner
+        RE_BAD_CHAR = /([\x00-\x20\x7F",;\\])/.freeze
+
+        module_function
+
+        def quote(s)
+          return s unless s.match(RE_BAD_CHAR)
+
+          "\"#{s.gsub(/([\\"])/, "\\\\\\1")}\""
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins::Cookies
+    # The Cookie Jar
+    #
+    # It stores and manages cookies for a session, such as i.e. evicting when expired, access methods, or
+    # initialization from parsing `Set-Cookie` HTTP header values.
+    #
+    # It closely follows the [CookieStore API](https://developer.mozilla.org/en-US/docs/Web/API/CookieStore),
+    # by implementing the same methods, with a few specific conveniences for this non-browser manipulation use-case.
+    #
+    class Jar
+      using URIExtensions
+
+      include Enumerable
+
+      def initialize_dup(orig)
+        super
+        @mtx = orig.instance_variable_get(:@mtx).dup
+        @cookies = orig.instance_variable_get(:@cookies).dup
+      end
+
+      # initializes the cookie store, either empty, or with whatever is passed as +cookies+, which
+      # can be an array of HTTPX::Plugins::Cookies::Cookie objects or hashes-or-tuples of cookie attributes.
+      def initialize(cookies = nil)
+        @mtx = Thread::Mutex.new
+        @cookies = []
+
+        cookies.each do |elem|
+          cookie = case elem
+                   when Cookie
+                     elem
+                   when Array
+                     Cookie.new(*elem)
+                   else
+                     Cookie.new(elem)
+          end
+
+          @cookies << cookie
+        end if cookies
+      end
+
+      # parses the `Set-Cookie` header value as +set_cookie+ and does the corresponding updates.
+      def parse(set_cookie)
+        SetCookieParser.call(set_cookie) do |name, value, attrs|
+          set(Cookie.new(name, value, attrs))
+        end
+      end
+
+      # returns the first HTTPX::Plugins::Cookie::Cookie instance in the store which matches either the name
+      # (when String) or all attributes (when a Hash or array of tuples) passed to +name_or_options+
+      def get(name_or_options)
+        each.find { |ck| ck.match?(name_or_options) }
+      end
+
+      # returns all HTTPX::Plugins::Cookie::Cookie instances in the store which match either the name
+      # (when String) or all attributes (when a Hash or array of tuples) passed to +name_or_options+
+      def get_all(name_or_options)
+        each.select { |ck| ck.match?(name_or_options) } # rubocop:disable Style/SelectByRegexp
+      end
+
+      # when +name+ is a HTTPX::Plugins::Cookie::Cookie, it stores it internally; when +name+ is a String,
+      # it creates a cookie with it and the value-or-attributes passed to +value_or_options+.
+
+      # optionally, +name+ can also be the attributes hash-or-array as long it contains a <tt>:name</tt> field).
+      def set(name, value_or_options = nil)
+        cookie = case name
+                 when Cookie
+                   raise ArgumentError, "there should not be a second argument" if value_or_options
+
+                   name
+                 when Array, Hash
+                   raise ArgumentError, "there should not be a second argument" if value_or_options
+
+                   Cookie.new(name)
+                 else
+                   raise ArgumentError, "the second argument is required" unless value_or_options
+
+                   Cookie.new(name, value_or_options)
+        end
+
+        synchronize do
+          # If the user agent receives a new cookie with the same cookie-name, domain-value, and path-value
+          # as a cookie that it has already stored, the existing cookie is evicted and replaced with the new cookie.
+          @cookies.delete_if { |ck| ck.name == cookie.name && ck.domain == cookie.domain && ck.path == cookie.path }
+
+          @cookies << cookie
+        end
+      end
+
+      # @deprecated
+      def add(cookie, path = nil)
+        warn "DEPRECATION WARNING: calling `##{__method__}` is deprecated. Use `#set` instead."
+        c = cookie.dup
+        c.path = path if path && c.path == "/"
+        set(c)
+      end
+
+      # deletes all cookies  in the store which match either the name (when String) or all attributes (when a Hash
+      # or array of tuples) passed to +name_or_options+.
+      #
+      # alternatively, of +name_or_options+ is an instance of HTTPX::Plugins::Cookies::Cookiem, it deletes it from the store.
+      def delete(name_or_options)
+        synchronize do
+          case name_or_options
+          when Cookie
+            @cookies.delete(name_or_options)
+          else
+            @cookies.delete_if { |ck| ck.match?(name_or_options) }
+          end
+        end
+      end
+
+      # returns the list of valid cookies which matdh the domain and path from the URI object passed to +uri+.
+      def [](uri)
+        each(uri).sort
+      end
+
+      # enumerates over all stored cookies. if +uri+ is passed, it'll filter out expired cookies and
+      # only yield cookies which match its domain and path.
+      def each(uri = nil, &blk)
+        return enum_for(__method__, uri) unless blk
+
+        return synchronize { @cookies.each(&blk) } unless uri
+
+        now = Time.now
+        tpath = uri.path
+
+        synchronize do
+          @cookies.delete_if do |cookie|
+            if cookie.expired?(now)
+              true
+            else
+              yield cookie if cookie.valid_for_uri?(uri) && Cookie.path_match?(cookie.path, tpath)
+              false
+            end
+          end
+        end
+      end
+
+      def merge(other)
+        jar_dup = dup
+
+        other.each do |elem|
+          cookie = case elem
+                   when Cookie
+                     elem
+                   when Array
+                     Cookie.new(*elem)
+                   else
+                     Cookie.new(elem)
+          end
+
+          jar_dup.set(cookie)
+        end
+
+        jar_dup
+      end
+
+      private
+
+      def synchronize(&block)
+        return yield if @mtx.owned?
+
+        @mtx.synchronize(&block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "strscan"
+require "time"
+
+module HTTPX
+  module Plugins::Cookies
+    module SetCookieParser
+      # Whitespace.
+      RE_WSP = /[ \t]+/.freeze
+
+      # A pattern that matches a cookie name or attribute name which may
+      # be empty, capturing trailing whitespace.
+      RE_NAME = /(?!#{RE_WSP})[^,;\\"=]*/.freeze
+
+      RE_BAD_CHAR = /([\x00-\x20\x7F",;\\])/.freeze
+
+      # A pattern that matches the comma in a (typically date) value.
+      RE_COOKIE_COMMA = /,(?=#{RE_WSP}?#{RE_NAME}=)/.freeze
+
+      module_function
+
+      def scan_dquoted(scanner)
+        s = +""
+
+        until scanner.eos?
+          break if scanner.skip(/"/)
+
+          if scanner.skip(/\\/)
+            s << scanner.getch
+          elsif scanner.scan(/[^"\\]+/)
+            s << scanner.matched
+          end
+        end
+
+        s
+      end
+
+      def scan_value(scanner, comma_as_separator = false)
+        value = +""
+
+        until scanner.eos?
+          if scanner.scan(/[^,;"]+/)
+            value << scanner.matched
+          elsif scanner.skip(/"/)
+            # RFC 6265 2.2
+            # A cookie-value may be DQUOTE'd.
+            value << scan_dquoted(scanner)
+          elsif scanner.check(/;/)
+            break
+          elsif comma_as_separator && scanner.check(RE_COOKIE_COMMA)
+            break
+          else
+            value << scanner.getch
+          end
+        end
+
+        value.rstrip!
+        value
+      end
+
+      def scan_name_value(scanner, comma_as_separator = false)
+        name = scanner.scan(RE_NAME)
+        name.rstrip! if name
+
+        if scanner.skip(/=/)
+          value = scan_value(scanner, comma_as_separator)
+        else
+          scan_value(scanner, comma_as_separator)
+          value = nil
+        end
+        [name, value]
+      end
+
+      def call(set_cookie)
+        scanner = StringScanner.new(set_cookie)
+
+        # RFC 6265 4.1.1 & 5.2
+        until scanner.eos?
+          start = scanner.pos
+          len = nil
+
+          scanner.skip(RE_WSP)
+
+          name, value = scan_name_value(scanner, true)
+          value = nil if name && name.empty?
+
+          attrs = {}
+
+          until scanner.eos?
+            if scanner.skip(/,/)
+              # The comma is used as separator for concatenating multiple
+              # values of a header.
+              len = (scanner.pos - 1) - start
+              break
+            elsif scanner.skip(/;/)
+              scanner.skip(RE_WSP)
+
+              aname, avalue = scan_name_value(scanner, true)
+
+              next if (aname.nil? || aname.empty?) || value.nil?
+
+              aname.downcase!
+
+              case aname
+              when "expires"
+                next unless avalue
+
+                # RFC 6265 5.2.1
+                (avalue = Time.parse(avalue)) || next
+              when "max-age"
+                next unless avalue
+                # RFC 6265 5.2.2
+                next unless /\A-?\d+\z/.match?(avalue)
+
+                avalue = Integer(avalue)
+              when "domain"
+                # RFC 6265 5.2.3
+                # An empty value SHOULD be ignored.
+                next if avalue.nil? || avalue.empty?
+              when "path"
+                # RFC 6265 5.2.4
+                # A relative path must be ignored rather than normalizing it
+                # to "/".
+                next unless avalue && avalue.start_with?("/")
+              when "secure", "httponly"
+                # RFC 6265 5.2.5, 5.2.6
+                avalue = true
+              end
+              attrs[aname] = avalue
+            end
+          end
+
+          len ||= scanner.pos - start
+
+          next if len > Cookie::MAX_LENGTH
+
+          yield(name, value, attrs) if name && !name.empty? && value
+        end
+      end
+    end
+  end
+end