cybrid_api_organization_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/response/body.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module HTTPX
+  # Implementation of the HTTP Response body as a buffer which implements the IO writer protocol
+  # (for buffering the response payload), the IO reader protocol (for consuming the response payload),
+  # and can be iterated over (via #each, which yields the payload in chunks).
+  class Response::Body
+    # the payload encoding (i.e. "utf-8", "ASCII-8BIT")
+    attr_reader :encoding
+
+    # Array of encodings contained in the response "content-encoding" header.
+    attr_reader :encodings
+
+    attr_reader :buffer
+    protected :buffer
+
+    # initialized with the corresponding HTTPX::Response +response+ and HTTPX::Options +options+.
+    def initialize(response, options)
+      @response = response
+      @headers = response.headers
+      @options = options
+      @window_size = options.window_size
+      @max_response_body_size = options.max_response_body_size
+      @encodings = []
+      @length = 0
+      @buffer = @reader = nil
+      @state = :idle
+
+      # initialize response encoding
+      @encoding = if (enc = response.content_type.charset)
+        begin
+          Encoding.find(enc)
+        rescue ArgumentError
+          Encoding::BINARY
+        end
+      else
+        Encoding::BINARY
+      end
+
+      initialize_inflaters
+    end
+
+    def initialize_dup(other)
+      super
+
+      @buffer = other.instance_variable_get(:@buffer).dup
+    end
+
+    def closed?
+      @state == :closed
+    end
+
+    # write the response payload +chunk+ into the buffer. Inflates the chunk when required
+    # and supported.
+    def write(chunk)
+      return if @state == :closed
+
+      return 0 if chunk.empty?
+
+      chunk = decode_chunk(chunk)
+
+      raise Error, "maximum response body size exceeded" if @max_response_body_size < @length
+
+      transition(:open)
+      @buffer.write(chunk)
+
+      @response.emit(:chunk_received, chunk)
+      chunk.bytesize
+    end
+
+    # reads a chunk from the payload (implementation of the IO reader protocol).
+    def read(...)
+      return unless @buffer
+
+      unless @reader
+        rewind
+        @reader = @buffer
+      end
+
+      @reader.read(...)
+    end
+
+    # size of the decoded response payload. May differ from "content-length" header if
+    # response was encoded over-the-wire.
+    def bytesize
+      @length
+    end
+
+    # yields the payload in chunks.
+    def each
+      return enum_for(__method__) unless block_given?
+
+      begin
+        if @buffer
+          rewind
+          while (chunk = @buffer.read(@window_size))
+            yield(chunk.force_encoding(@encoding))
+          end
+        end
+      ensure
+        close
+      end
+    end
+
+    # returns the declared filename in the "contennt-disposition" header, when present.
+    def filename
+      return unless @headers.key?("content-disposition")
+
+      Utils.get_filename(@headers["content-disposition"])
+    end
+
+    # returns the full response payload as a string.
+    def to_s
+      return "".b unless @buffer
+
+      @buffer.to_s
+    end
+
+    alias_method :to_str, :to_s
+
+    # whether the payload is empty.
+    def empty?
+      @length.zero?
+    end
+
+    # copies the payload to +dest+.
+    #
+    #   body.copy_to("path/to/file")
+    #   body.copy_to(Pathname.new("path/to/file"))
+    #   body.copy_to(File.new("path/to/file"))
+    def copy_to(dest)
+      return unless @buffer
+
+      rewind
+
+      if dest.respond_to?(:path) && @buffer.respond_to?(:path)
+        FileUtils.mv(@buffer.path, dest.path)
+      else
+        IO.copy_stream(@buffer, dest)
+      end
+    ensure
+      close
+    end
+
+    # closes/cleans the buffer, resets everything
+    def close
+      if @buffer
+        @buffer.close
+        @buffer = nil
+      end
+      @length = 0
+      transition(:closed)
+    end
+
+    def ==(other)
+      super || case other
+               when Response::Body
+                 @buffer == other.buffer
+               else
+                 @buffer = other
+               end
+    end
+
+    # simplecov:disable
+    def inspect
+      "#<#{self.class}:#{object_id} " \
+        "@state=#{@state} " \
+        "@length=#{@length}>"
+    end
+    # simplecov:enable
+
+    # rewinds the response payload buffer.
+    def rewind
+      return unless @buffer
+
+      # in case there's some reading going on
+      @reader = nil
+
+      @buffer.rewind
+    end
+
+    private
+
+    # prepares inflaters for the advertised encodings in "content-encoding" header.
+    def initialize_inflaters
+      @inflaters = nil
+
+      return unless @headers.key?("content-encoding")
+
+      return unless @options.decompress_response_body
+
+      @inflaters = @headers.get("content-encoding").filter_map do |encoding|
+        next if encoding == "identity"
+
+        inflater = self.class.initialize_inflater_by_encoding(encoding, @response)
+
+        # do not uncompress if there is no decoder available. In fact, we can't reliably
+        # continue decompressing beyond that, so ignore.
+        break unless inflater
+
+        @encodings << encoding
+        inflater
+      end
+    end
+
+    # passes the +chunk+ through all inflaters to decode it.
+    def decode_chunk(chunk)
+      @inflaters.reverse_each do |inflater|
+        chunk = inflater.call(chunk)
+      end if @inflaters
+
+      @length += chunk.bytesize
+
+      chunk
+    end
+
+    # tries transitioning the body STM to the +nextstate+.
+    def transition(nextstate)
+      case nextstate
+      when :open
+        return unless @state == :idle
+
+        @buffer = Response::Buffer.new(
+          threshold_size: @options.body_threshold_size,
+          bytesize: @length,
+          encoding: @encoding
+        )
+      when :closed
+        return if @state == :closed
+      end
+
+      @state = nextstate
+    end
+
+    class << self
+      def initialize_inflater_by_encoding(encoding, response, **kwargs) # :nodoc:
+        case encoding
+        when "gzip"
+          Transcoder::GZIP.decode(response, **kwargs)
+        when "deflate"
+          Transcoder::Deflate.decode(response, **kwargs)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/response/buffer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "stringio"
+require "tempfile"
+
+module HTTPX
+  # wraps and delegates to an internal buffer, which can be a StringIO or a Tempfile.
+  class Response::Buffer < SimpleDelegator
+    attr_reader :buffer
+    protected :buffer
+
+    # initializes buffer with the +threshold_size+ over which the payload gets buffer to a tempfile,
+    # the initial +bytesize+, and the +encoding+.
+    def initialize(threshold_size:, bytesize: 0, encoding: Encoding::BINARY)
+      @threshold_size = threshold_size
+      @bytesize = bytesize
+      @encoding = encoding
+      @buffer = StringIO.new("".b)
+      super(@buffer)
+    end
+
+    def initialize_dup(other)
+      super
+
+      # create new descriptor in READ-ONLY mode
+      @buffer =
+        case other.buffer
+        when StringIO
+          StringIO.new(other.buffer.string, mode: File::RDONLY)
+        else
+          other.buffer.class.new(other.buffer.path, encoding: Encoding::BINARY, mode: File::RDONLY).tap do |temp|
+            FileUtils.copy_file(other.buffer.path, temp.path)
+          end
+        end
+    end
+
+    # size in bytes of the buffered content.
+    def size
+      @bytesize
+    end
+
+    # writes the +chunk+ into the buffer.
+    def write(chunk)
+      @bytesize += chunk.bytesize
+      try_upgrade_buffer
+      @buffer.write(chunk)
+    end
+
+    # returns the buffered content as a string.
+    def to_s
+      case @buffer
+      when StringIO
+        begin
+          @buffer.string.force_encoding(@encoding)
+        rescue ArgumentError
+          @buffer.string
+        end
+      when Tempfile
+        rewind
+        content = @buffer.read
+        begin
+          content.force_encoding(@encoding)
+        rescue ArgumentError # ex: unknown encoding name - utf
+          content
+        end
+      end
+    end
+
+    # closes the buffer.
+    def close
+      @buffer.close
+      @buffer.unlink if @buffer.respond_to?(:unlink)
+    end
+
+    def ==(other)
+      super || begin
+        return false unless other.is_a?(Response::Buffer)
+
+        buffer_pos = @buffer.pos
+        other_pos = other.buffer.pos
+        @buffer.rewind
+        other.buffer.rewind
+        begin
+          FileUtils.compare_stream(@buffer, other.buffer)
+        ensure
+          @buffer.pos = buffer_pos
+          other.buffer.pos = other_pos
+        end
+      end
+    end
+
+    private
+
+    # initializes the buffer into a StringIO, or turns it into a Tempfile when the threshold
+    # has been reached.
+    def try_upgrade_buffer
+      return unless @bytesize > @threshold_size
+
+      return if @buffer.is_a?(Tempfile)
+
+      aux = @buffer
+
+      @buffer = Tempfile.new("httpx", encoding: Encoding::BINARY, mode: File::RDWR)
+
+      if aux
+        aux.rewind
+        IO.copy_stream(aux, @buffer)
+        aux.close
+      end
+
+      __setobj__(@buffer)
+    end
+  end
+end

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

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require "objspace"
+require "stringio"
+require "tempfile"
+require "fileutils"
+require "forwardable"
+
+module HTTPX
+  # Defines a HTTP response is handled internally, with a few properties exposed as attributes.
+  #
+  # It delegates the following methods to the corresponding HTTPX::Request:
+  #
+  # * HTTPX::Request#uri
+  # * HTTPX::Request#peer_address
+  #
+  # It implements (indirectly, via the +body+) the IO write protocol to internally buffer payloads.
+  #
+  # It implements the IO reader protocol in order for users to buffer/stream it, acts as an enumerable
+  # (of payload chunks).
+  #
+  class Response
+    extend Forwardable
+    include Callbacks
+
+    # the HTTP response status code
+    attr_reader :status
+
+    # an HTTPX::Headers object containing the response HTTP headers.
+    attr_reader :headers
+
+    # a HTTPX::Response::Body object wrapping the response body. The following methods are delegated to it:
+    #
+    # * HTTPX::Response::Body#to_s
+    # * HTTPX::Response::Body#to_str
+    # * HTTPX::Response::Body#read
+    # * HTTPX::Response::Body#copy_to
+    # * HTTPX::Response::Body#close
+    attr_reader :body
+
+    # The HTTP protocol version used to fetch the response.
+    attr_reader :version
+
+    # returns the response body buffered in a string.
+    def_delegator :@body, :to_s
+
+    def_delegator :@body, :to_str
+
+    # implements the IO reader +#read+ interface.
+    def_delegator :@body, :read
+
+    # copies the response body to a different location.
+    def_delegator :@body, :copy_to
+
+    # the corresponding request uri.
+    def_delegator :@request, :uri
+
+    # the IP address of the peer server.
+    def_delegator :@request, :peer_address
+
+    # inits the instance with the corresponding +request+ to this response, an the
+    # response HTTP +status+, +version+ and HTTPX::Headers instance of +headers+.
+    def initialize(request, status, version, headers)
+      @request = request
+      @options = request.options
+      @version = version
+      @status = Integer(status)
+      @headers = @options.headers_class.new(headers)
+      @body = @options.response_body_class.new(self, @options)
+      @finished = complete?
+      @callbacks = @content_type = @content_length = nil
+    end
+
+    # dupped initialization
+    def initialize_dup(orig)
+      super
+      # if a response gets dupped, the body handle must also get dupped to prevent
+      # two responses from using the same file handle to read.
+      @body = orig.body.dup
+    end
+
+    # closes the respective +@request+ and +@body+.
+    def close
+      @request.close
+      @body.close
+    end
+
+    # merges headers defined in +h+ into the response headers.
+    def merge_headers(h)
+      @headers = @headers.merge(h)
+      @content_type = @content_length = nil
+    end
+
+    # writes +data+ chunk into the response body.
+    def <<(data)
+      @body.write(data)
+    end
+
+    # returns the HTTPX::ContentType for the response, as per what's declared in the content-type header.
+    #
+    #   response.content_type #=> #<HTTPX::ContentType:xxx @header_value="text/plain">
+    #   response.content_type.mime_type #=> "text/plain"
+    def content_type
+      @content_type ||= ContentType.new(@headers["content-type"])
+    end
+
+    # returns the response content length as advertised in the HTTP Content-Length header value.
+    def content_length
+      return @content_length if defined?(@content_length)
+
+      @content_length = @headers["content-length"]&.to_i
+    end
+
+    # returns whether the response has been fully fetched.
+    def finished?
+      @finished
+    end
+
+    # marks the response as finished, freezes the headers.
+    def finish!
+      @finished = true
+      @headers.freeze
+      @request.connection = nil
+    end
+
+    # returns whether the response contains body payload.
+    def bodyless?
+      @request.verb == "HEAD" ||
+        @status < 200 || # informational response
+        @status == 204 ||
+        @status == 205 ||
+        @status == 304 || begin
+          content_length = @headers["content-length"]
+          return false if content_length.nil?
+
+          content_length == "0"
+        end
+    end
+
+    def complete?
+      bodyless? || (@request.verb == "CONNECT" && @status == 200)
+    end
+
+    # simplecov:disable
+    def inspect
+      "#<#{self.class}:#{object_id} " \
+        "HTTP/#{version} " \
+        "@status=#{@status} " \
+        "@headers=#{@headers} " \
+        "@body=#{@body.bytesize}>"
+    end
+    # simplecov:enable
+
+    # returns an instance of HTTPX::HTTPError if the response has a 4xx or 5xx
+    # status code, or nothing.
+    #
+    #   ok_response.error #=> nil
+    #   not_found_response.error #=> HTTPX::HTTPError instance, status 404
+    def error
+      return if @status < 400
+
+      HTTPError.new(self)
+    end
+
+    # it raises the exception returned by +error+, or itself otherwise.
+    #
+    #   ok_response.raise_for_status #=> ok_response
+    #   not_found_response.raise_for_status #=> raises HTTPX::HTTPError exception
+    def raise_for_status
+      return self unless (err = error)
+
+      raise err
+    end
+
+    # decodes the response payload into a ruby object **if** the payload is valid json.
+    #
+    #   response.json #≈> { "foo" => "bar" } for "{\"foo\":\"bar\"}" payload
+    #   response.json(symbolize_names: true) #≈> { foo: "bar" } for "{\"foo\":\"bar\"}" payload
+    def json(...)
+      decode(Transcoder::JSON, ...)
+    end
+
+    # decodes the response payload into a ruby object **if** the payload is valid
+    # "application/x-www-urlencoded" or "multipart/form-data".
+    def form
+      decode(Transcoder::Form)
+    end
+
+    def xml
+      # TODO: remove at next major version.
+      warn "DEPRECATION WARNING: calling `.#{__method__}` on plain HTTPX responses is deprecated. " \
+           "Use HTTPX.plugin(:xml) sessions and call `.#{__method__}` in its responses instead."
+      require "httpx/plugins/xml"
+      decode(Plugins::XML::Transcoder)
+    end
+
+    private
+
+    # decodes the response payload using the given +transcoder+, which implements the decoding logic.
+    #
+    # +transcoder+ must implement the internal transcoder API, i.e. respond to <tt>decode(HTTPX::Response response)</tt>,
+    # which returns a decoder which responds to <tt>call(HTTPX::Response response, **kwargs)</tt>
+    def decode(transcoder, ...)
+      # TODO: check if content-type is a valid format, i.e. "application/json" for json parsing
+
+      decoder = transcoder.decode(self)
+
+      raise Error, "no decoder available for \"#{transcoder}\"" unless decoder
+
+      @body.rewind
+
+      decoder.call(self, ...)
+    end
+  end
+
+  # Helper class which decodes the HTTP "content-type" header.
+  class ContentType
+    MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}.freeze
+    CHARSET_RE   = /;\s*charset=([^;]+)/i.freeze
+
+    def initialize(header_value)
+      @header_value = header_value
+      @mime_type = @charset = nil
+      @initialized = false
+    end
+
+    # returns the mime type declared in the header.
+    #
+    #   ContentType.new("application/json; charset=utf-8").mime_type #=> "application/json"
+    def mime_type
+      return @mime_type if @initialized
+
+      load
+
+      @mime_type
+    end
+
+    # returns the charset declared in the header.
+    #
+    #   ContentType.new("application/json; charset=utf-8").charset #=> "utf-8"
+    #   ContentType.new("text/plain").charset #=> nil
+    def charset
+      return @charset if @initialized
+
+      load
+
+      @charset
+    end
+
+    private
+
+    def load
+      m = @header_value.to_s[MIME_TYPE_RE, 1]
+      m && @mime_type = m.strip.downcase
+
+      c = @header_value.to_s[CHARSET_RE, 1]
+      c && @charset = c.strip.delete('"')
+
+      @initialized = true
+    end
+  end
+
+  # Wraps an error which has happened while processing an HTTP Request. It has partial
+  # public API parity with HTTPX::Response, so users should rely on it to infer whether
+  # the returned response is one or the other.
+  #
+  #   response = HTTPX.get("https://some-domain/path") #=> response is HTTPX::Response or HTTPX::ErrorResponse
+  #   response.raise_for_status #=> raises if it wraps an error
+  class ErrorResponse
+    extend Forwardable
+
+    # the corresponding HTTPX::Request instance.
+    attr_reader :request
+
+    # the HTTPX::Response instance, when there is one (i.e. error happens fetching the response).
+    attr_reader :response
+
+    # the wrapped exception.
+    attr_reader :error
+
+    # the request uri
+    def_delegator :@request, :uri
+
+    # the IP address of the peer server.
+    def_delegator :@request, :peer_address
+
+    def initialize(request, error)
+      @request = request
+      @response = request.response if request.response.is_a?(Response)
+      @error = error
+      @options = request.options
+      @request.log_exception(@error)
+      finish!
+    end
+
+    # returns the exception full message.
+    def to_s
+      @error.full_message(highlight: false)
+    end
+
+    # closes the error resources.
+    def close
+      @response.close if @response
+    end
+
+    # always true for error responses.
+    def finished?
+      true
+    end
+
+    def finish!
+      @request.connection = nil
+    end
+
+    # raises the wrapped exception.
+    def raise_for_status
+      raise @error
+    end
+
+    # buffers lost chunks to error response
+    def <<(data)
+      return unless @response
+
+      @response << data
+    end
+  end
+end
+
+require_relative "response/body"
+require_relative "response/buffer"
+require_relative "pmatch_extensions" if RUBY_VERSION >= "2.7.0"