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/webdav.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin implements convenience methods for performing WEBDAV requests.
+    #
+    # https://gitlab.com/os85/httpx/wikis/WebDav
+    #
+    module WebDav
+      def self.configure(klass)
+        klass.plugin(:xml)
+      end
+
+      module InstanceMethods
+        def copy(src, dest)
+          request("COPY", src, headers: { "destination" => @options.origin.merge(dest) })
+        end
+
+        def move(src, dest)
+          request("MOVE", src, headers: { "destination" => @options.origin.merge(dest) })
+        end
+
+        def lock(path, timeout: nil, &blk)
+          headers = {}
+          headers["timeout"] = if timeout && timeout.positive?
+            "Second-#{timeout}"
+          else
+            "Infinite, Second-4100000000"
+          end
+          xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" \
+                "<D:lockinfo xmlns:D=\"DAV:\">" \
+                "<D:lockscope><D:exclusive/></D:lockscope>" \
+                "<D:locktype><D:write/></D:locktype>" \
+                "<D:owner>null</D:owner>" \
+                "</D:lockinfo>"
+          response = request("LOCK", path, headers: headers, xml: xml)
+
+          return response unless response.is_a?(Response)
+
+          return response unless blk && response.status == 200
+
+          lock_token = response.headers["lock-token"]
+
+          begin
+            blk.call(response)
+          ensure
+            unlock(path, lock_token)
+          end
+
+          response
+        end
+
+        def unlock(path, lock_token)
+          request("UNLOCK", path, headers: { "lock-token" => lock_token })
+        end
+
+        def mkcol(dir)
+          request("MKCOL", dir)
+        end
+
+        def propfind(path, xml = nil)
+          body = case xml
+                 when :acl
+                   '<?xml version="1.0" encoding="utf-8" ?><D:propfind xmlns:D="DAV:"><D:prop><D:owner/>' \
+                   "<D:supported-privilege-set/><D:current-user-privilege-set/><D:acl/></D:prop></D:propfind>"
+                 when nil
+                   '<?xml version="1.0" encoding="utf-8"?><DAV:propfind xmlns:DAV="DAV:"><DAV:allprop/></DAV:propfind>'
+                 else
+                   xml
+          end
+
+          request("PROPFIND", path, headers: { "depth" => "1" }, xml: body)
+        end
+
+        def proppatch(path, xml)
+          body = "<?xml version=\"1.0\"?>" \
+                 "<D:propertyupdate xmlns:D=\"DAV:\" xmlns:Z=\"http://ns.example.com/standards/z39.50/\">#{xml}</D:propertyupdate>"
+          request("PROPPATCH", path, xml: body)
+        end
+        # %i[ orderpatch acl report search]
+      end
+    end
+    register_plugin(:webdav, WebDav)
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin supports request XML encoding/response decoding using the nokogiri gem.
+    #
+    # https://gitlab.com/os85/httpx/wikis/XML
+    #
+    module XML
+      MIME_TYPES = %r{\b(application|text)/(.+\+)?xml\b}.freeze
+      module Transcoder
+        module_function
+
+        class Encoder
+          def initialize(xml)
+            @raw = xml
+          end
+
+          def content_type
+            charset = @raw.respond_to?(:encoding) && @raw.encoding ? @raw.encoding.to_s.downcase : "utf-8"
+            "application/xml; charset=#{charset}"
+          end
+
+          def bytesize
+            @raw.to_s.bytesize
+          end
+
+          def to_s
+            @raw.to_s
+          end
+        end
+
+        def encode(xml)
+          Encoder.new(xml)
+        end
+
+        def decode(response)
+          content_type = response.content_type.mime_type
+
+          raise HTTPX::Error, "invalid form mime type (#{content_type})" unless MIME_TYPES.match?(content_type)
+
+          Nokogiri::XML.method(:parse)
+        end
+      end
+
+      class << self
+        def load_dependencies(*)
+          require "nokogiri"
+        end
+      end
+
+      module ResponseMethods
+        # decodes the response payload into a Nokogiri::XML::Node object **if** the payload is valid
+        # "application/xml" (requires the "nokogiri" gem).
+        def xml
+          decode(Transcoder)
+        end
+      end
+
+      module RequestBodyClassMethods
+        #   ..., xml: Nokogiri::XML::Node #=> xml encoder
+        def initialize_body(params)
+          if (xml = params.delete(:xml))
+            # @type var xml: Nokogiri::XML::Node | String
+            return Transcoder.encode(xml)
+          end
+
+          super
+        end
+      end
+    end
+
+    register_plugin(:xml, XML)
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module ResponsePatternMatchExtensions
+    def deconstruct
+      [@status, @headers, @body]
+    end
+
+    def deconstruct_keys(_keys)
+      { status: @status, headers: @headers, body: @body }
+    end
+  end
+
+  module ErrorResponsePatternMatchExtensions
+    def deconstruct
+      [@error]
+    end
+
+    def deconstruct_keys(_keys)
+      { error: @error }
+    end
+  end
+
+  module HeadersPatternMatchExtensions
+    def deconstruct
+      to_a
+    end
+  end
+
+  Headers.include HeadersPatternMatchExtensions
+  Response.include ResponsePatternMatchExtensions
+  ErrorResponse.include ErrorResponsePatternMatchExtensions
+end

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

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "httpx/selector"
+require "httpx/connection"
+require "httpx/connection/http2"
+require "httpx/connection/http1"
+require "httpx/resolver"
+
+module HTTPX
+  class Pool
+    using URIExtensions
+
+    POOL_TIMEOUT = 5
+
+    # Sets up the connection pool with the given +options+, which can be the following:
+    #
+    # :max_connections:: the maximum number of connections held in the pool.
+    # :max_connections_per_origin :: the maximum number of connections held in the pool pointing to a given origin.
+    # :pool_timeout :: the number of seconds to wait for a connection to a given origin (before raising HTTPX::PoolTimeoutError)
+    #
+    def initialize(options)
+      @max_connections = options.fetch(:max_connections, Float::INFINITY)
+      @max_connections_per_origin = options.fetch(:max_connections_per_origin, Float::INFINITY)
+      @pool_timeout = options.fetch(:pool_timeout, POOL_TIMEOUT)
+      @resolvers = Hash.new { |hs, resolver_type| hs[resolver_type] = [] }
+      @resolver_mtx = Thread::Mutex.new
+      @connections = []
+      @connection_mtx = Thread::Mutex.new
+      @connections_counter = 0
+      @max_connections_cond = ConditionVariable.new
+      @origin_counters = Hash.new(0)
+      @origin_conds = Hash.new { |hs, orig| hs[orig] = ConditionVariable.new }
+    end
+
+    # connections returned by this function are not expected to return to the connection pool.
+    def pop_connection
+      @connection_mtx.synchronize do
+        drop_connection
+      end
+    end
+
+    # opens a connection to the IP reachable through +uri+.
+    # Many hostnames are reachable through the same IP, so we try to
+    # maximize pipelining by opening as few connections as possible.
+    #
+    def checkout_connection(uri, options)
+      return checkout_new_connection(uri, options) if options.io
+
+      @connection_mtx.synchronize do
+        acquire_connection(uri, options) || begin
+          if @connections_counter == @max_connections
+            # this takes precedence over per-origin
+
+            expires_at = Utils.now + @pool_timeout
+
+            loop do
+              @max_connections_cond.wait(@connection_mtx, @pool_timeout)
+
+              if (conn = acquire_connection(uri, options))
+                return conn
+              end
+
+              # if one can afford to create a new connection, do it
+              break unless @connections_counter == @max_connections
+
+              # if no matching usable connection was found, the pool will make room and drop a closed connection.
+              if (conn = @connections.find { |c| c.state == :closed })
+                drop_connection(conn)
+                break
+              end
+
+              # happens when a condition was signalled, but another thread snatched the available connection before
+              # context was passed back here.
+              next if Utils.now < expires_at
+
+              raise PoolTimeoutError.new(@pool_timeout,
+                                         "Timed out after #{@pool_timeout} seconds while waiting for a connection")
+            end
+
+          end
+
+          if @origin_counters[uri.origin] == @max_connections_per_origin
+
+            expires_at = Utils.now + @pool_timeout
+
+            loop do
+              @origin_conds[uri.origin].wait(@connection_mtx, @pool_timeout)
+
+              if (conn = acquire_connection(uri, options))
+                return conn
+              end
+
+              # happens when a condition was signalled, but another thread snatched the available connection before
+              # context was passed back here.
+              next if Utils.now < expires_at
+
+              raise(PoolTimeoutError.new(@pool_timeout,
+                                         "Timed out after #{@pool_timeout} seconds while waiting for a connection to #{uri.origin}"))
+            end
+          end
+
+          @connections_counter += 1
+          @origin_counters[uri.origin] += 1
+
+          checkout_new_connection(uri, options)
+        end
+      end
+    end
+
+    def checkin_connection(connection)
+      return if connection.options.io
+
+      @connection_mtx.synchronize do
+        if connection.coalesced? || connection.state == :idle
+          # when connections coalesce
+          drop_connection(connection)
+
+          return
+        end
+
+        @connections << connection
+
+        @max_connections_cond.signal
+        @origin_conds[connection.origin.to_s].signal
+      end
+    end
+
+    def checkout_mergeable_connection(connection)
+      return if connection.options.io
+
+      @connection_mtx.synchronize do
+        idx = @connections.find_index do |ch|
+          ch != connection && ch.mergeable?(connection)
+        end
+        @connections.delete_at(idx) if idx
+      end
+    end
+
+    def reset_resolvers
+      @resolver_mtx.synchronize { @resolvers.clear }
+    end
+
+    def checkout_resolver(options)
+      resolver_type = options.resolver_class
+
+      @resolver_mtx.synchronize do
+        resolvers = @resolvers[resolver_type]
+
+        idx = resolvers.find_index do |res|
+          res.options.resolver_options_match?(options)
+        end
+        resolvers.delete_at(idx) if idx
+      end || checkout_new_resolver(resolver_type, options)
+    end
+
+    def checkin_resolver(resolver)
+      if resolver.is_a?(Resolver::Multi)
+        resolver_class = resolver.resolvers.first.class
+      else
+        resolver_class = resolver.class
+
+        resolver = resolver.multi
+      end
+
+      # a multi requires all sub-resolvers being closed in order to be
+      # correctly checked back in.
+      return unless resolver.closed?
+
+      @resolver_mtx.synchronize do
+        resolvers = @resolvers[resolver_class]
+
+        resolvers << resolver unless resolvers.include?(resolver)
+      end
+    end
+
+    # simplecov:disable
+    def inspect
+      "#<#{self.class}:#{object_id} " \
+        "@max_connections=#{@max_connections} " \
+        "@max_connections_per_origin=#{@max_connections_per_origin} " \
+        "@pool_timeout=#{@pool_timeout} " \
+        "@connections=#{@connections.size}>"
+    end
+    # simplecov:enable
+
+    private
+
+    def acquire_connection(uri, options)
+      idx = @connections.find_index do |connection|
+        connection.match?(uri, options)
+      end
+
+      return unless idx
+
+      @connections.delete_at(idx)
+    end
+
+    def checkout_new_connection(uri, options)
+      connection = options.connection_class.new(uri, options)
+      connection.log(level: 2) { "created connection##{connection.object_id} in pool##{object_id}" }
+      connection
+    end
+
+    def checkout_new_resolver(resolver_type, options)
+      resolver = if resolver_type.multi?
+        Resolver::Multi.new(resolver_type, options)
+      else
+        resolver_type.new(options)
+      end
+      resolver.log(level: 2) { "created resolver##{resolver.object_id} in pool##{object_id}" }
+      resolver
+    end
+
+    # drops and returns the +connection+ from the connection pool; if +connection+ is <tt>nil</tt> (default),
+    # the first available connection from the pool will be dropped.
+    def drop_connection(connection = nil)
+      if connection
+        @connections.delete(connection)
+      else
+        connection = @connections.shift
+
+        return unless connection
+      end
+
+      @connections_counter -= 1
+      @origin_conds.delete(connection.origin) if (@origin_counters[connection.origin.to_s] -= 1).zero?
+
+      connection
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Punycode
+    module_function
+
+    begin
+      require "idnx"
+
+      def encode_hostname(hostname)
+        Idnx.to_punycode(hostname)
+      end
+    rescue LoadError
+      def encode_hostname(hostname)
+        warn "#{hostname} cannot be converted to punycode. Install the " \
+             "\"idnx\" gem: https://github.com/HoneyryderChuck/idnx"
+
+        hostname
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module HTTPX
+  # Implementation of the HTTP Request body as a delegator which iterates (responds to +each+) payload chunks.
+  class Request::Body < SimpleDelegator
+    class << self
+      def new(h, options, body: nil, **params)
+        case body
+        when self
+          # request derives its options from body
+          body.options = options.merge(params)
+          body
+        when nil
+          super(h, options, **params)
+        else
+          super
+        end
+      end
+    end
+
+    attr_accessor :options
+
+    # inits the instance with the request +headers+, +options+ and +params+, which contain the payload definition.
+    # it wraps the given body with the appropriate encoder on initialization.
+    #
+    #   ..., json: { foo: "bar" }) #=> json encoder
+    #   ..., form: { foo: "bar" }) #=> form urlencoded encoder
+    #   ..., form: { foo: Pathname.open("path/to/file") }) #=> multipart urlencoded encoder
+    #   ..., form: { foo: File.open("path/to/file") }) #=> multipart urlencoded encoder
+    #   ..., form: { body: "bla") }) #=> raw data encoder
+    def initialize(h, options, **params)
+      @headers = h
+      @body = self.class.initialize_body(params)
+      @options = options.merge(params)
+
+      if @body
+        if @options.compress_request_body && @headers.key?("content-encoding")
+
+          @headers.get("content-encoding").each do |encoding|
+            @body = self.class.initialize_deflater_body(@body, encoding)
+          end
+        end
+
+        @headers["content-type"] ||= @body.content_type
+        @headers["content-length"] = @body.bytesize unless unbounded_body?
+      end
+
+      super(@body)
+    end
+
+    # consumes and yields the request payload in chunks.
+    def each(&block)
+      return enum_for(__method__) unless block
+      return if @body.nil?
+
+      body = stream(@body)
+      if body.respond_to?(:read)
+        while (chunk = body.read(16_384))
+          block.call(chunk)
+        end
+        # TODO: use copy_stream once bug is resolved: https://bugs.ruby-lang.org/issues/21131
+        # IO.copy_stream(body, ProcIO.new(block))
+      elsif body.respond_to?(:each)
+        body.each(&block)
+      else
+        block[body.to_s]
+      end
+    end
+
+    def close
+      @body.close if @body.respond_to?(:close)
+    end
+
+    # if the +@body+ is rewindable, it rewinnds it.
+    def rewind
+      return if empty?
+
+      @body.rewind if @body.respond_to?(:rewind)
+    end
+
+    # return +true+ if the +body+ has been fully drained (or does nnot exist).
+    def empty?
+      return true if @body.nil?
+      return false if chunked?
+
+      @body.bytesize.zero?
+    end
+
+    # returns the +@body+ payload size in bytes.
+    def bytesize
+      return 0 if @body.nil?
+
+      @body.bytesize
+    end
+
+    # sets the body to yield using chunked trannsfer encoding format.
+    def stream(body)
+      return body unless chunked?
+
+      Transcoder::Chunker.encode(body.enum_for(:each))
+    end
+
+    # returns whether the body yields infinitely.
+    def unbounded_body?
+      return @unbounded_body if defined?(@unbounded_body)
+
+      @unbounded_body = !@body.nil? && (chunked? || @body.bytesize == Float::INFINITY)
+    end
+
+    # returns whether the chunked transfer encoding header is set.
+    def chunked?
+      @headers["transfer-encoding"] == "chunked"
+    end
+
+    # sets the chunked transfer encoding header.
+    def chunk!
+      @headers.add("transfer-encoding", "chunked")
+    end
+
+    # simplecov:disable
+    def inspect
+      "#<#{self.class}:#{object_id} " \
+        "#{unbounded_body? ? "stream" : "@bytesize=#{bytesize}"}>"
+    end
+    # simplecov:enable
+
+    class << self
+      def initialize_body(params)
+        if (body = params.delete(:body))
+          # @type var body: bodyIO
+          Transcoder::Body.encode(body)
+        elsif (form = params.delete(:form))
+          if Transcoder::Multipart.multipart?(form)
+            # @type var form: Transcoder::Multipart::multipart_input
+            Transcoder::Multipart.encode(form)
+          else
+            # @type var form: Transcoder::urlencoded_input
+            Transcoder::Form.encode(form)
+          end
+        elsif (json = params.delete(:json))
+          # @type var body: _ToJson
+          Transcoder::JSON.encode(json)
+        end
+      end
+
+      # returns the +body+ wrapped with the correct deflater accordinng to the given +encodisng+.
+      def initialize_deflater_body(body, encoding)
+        case encoding
+        when "gzip"
+          Transcoder::GZIP.encode(body)
+        when "deflate"
+          Transcoder::Deflate.encode(body)
+        when "identity"
+          body
+        else
+          body
+        end
+      end
+    end
+  end
+end