ory-client 1.22.86 → 1.22.88

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/easy/options.rb

@@ -0,0 +1,369 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+
+    # This module contains the logic and knowledge about the
+    # available options on easy.
+    module Options
+      CALLBACK_TYPES = [:callback, :debug_callback, :progress_callback, :xferinfo_callback].freeze
+
+      # Ethon installs these callbacks on every handle. Clearing the option must
+      # restore Ethon's callback instead of leaving libcurl's default writer
+      # active, which would send response bytes to the process's stdout or
+      # stderr.
+      CALLBACK_DEFAULTS = {
+        :writefunction => :body_write_callback,
+        :headerfunction => :header_write_callback,
+        :debugfunction => :debug_callback
+      }.freeze
+
+      attr_reader :url
+
+      def url=(value)
+        # libcurl copies the URL, but the accessor must describe the exact
+        # string libcurl received. Snapshot it so later caller mutations cannot
+        # make #url disagree with the handle, and assign it only once libcurl
+        # accepts the value. Do this before touching the URL handle so a
+        # rejected value cannot leave it detached.
+        snapshot = value.nil? ? nil : value.to_s
+        snapshot = snapshot.dup.freeze if snapshot && !snapshot.frozen?
+
+        previous_curlu = @curlu
+        if previous_curlu
+          Curl.set_option(:curlu, nil, handle)
+          @curlu = nil
+        end
+
+        begin
+          Curl.set_option(:url, snapshot, handle)
+        rescue Exception
+          # Detaching the URL handle was only necessary to install the new
+          # value. Put it back when that value was rejected.
+          if previous_curlu
+            Curl.set_option(:curlu, previous_curlu, handle)
+            @curlu = previous_curlu
+          end
+          raise
+        end
+        @url = snapshot
+        value
+      end
+
+      def escape=( b )
+        @escape = b
+      end
+
+      def escape?
+        return true if !defined?(@escape) || @escape.nil?
+        @escape
+      end
+
+      def multipart=(b)
+        @multipart = b
+      end
+
+      def multipart?
+        !!@multipart
+      end
+
+      def multipart_form=(form)
+        self.httppost = form ? form.first.read_pointer : nil
+        @multipart_form = form
+      rescue Errors::UnsupportedOption
+        # CURLOPT_HTTPPOST is compiled out of builds configured with
+        # --disable-form-api. Clearing is all that can happen there, because
+        # building a form needs the form API itself.
+        raise if form
+
+        @multipart_form = form
+      end
+
+      # Enables or disables libcurl's error buffer (CURLOPT_ERRORBUFFER),
+      # which holds a more detailed error description than #return_message.
+      # Read it with #error_message.
+      #
+      # @example Enable the error buffer.
+      #   easy.errorbuffer = true
+      #
+      # @param [ Boolean ] value True to enable, false to disable.
+      #
+      # @return [ Boolean ] The value.
+      def errorbuffer=(value)
+        if value
+          @error_buffer ||= FFI::MemoryPointer.new(:char, Curl.easy_options(nil)[:errorbuffer][:opts])
+          @error_buffer.put_char(0, 0)
+          Curl.set_option(:errorbuffer, @error_buffer, handle)
+          handle.error_buffer = @error_buffer
+        else
+          Curl.set_option(:errorbuffer, nil, handle)
+          handle.error_buffer = nil
+        end
+        @error_buffer_enabled = !!value
+        value
+      end
+
+      # Returns the error message libcurl stored in the error buffer during
+      # the last transfer, or nil if it is empty or #errorbuffer= isn't enabled.
+      #
+      # @example Get the error message.
+      #   easy.error_message
+      #
+      # @return [ String, nil ] The error message.
+      def error_message
+        return unless @error_buffer_enabled
+        message = @error_buffer.read_string
+        message unless message.empty?
+      end
+
+      # Enables or disables libcurl's progress callback invocation. libcurl
+      # requires CURLOPT_NOPROGRESS to be 0 before it calls a progress
+      # callback, so remember the value to restore it when the native handle
+      # is replaced.
+      #
+      # @example Enable progress callbacks.
+      #   easy.noprogress = 0
+      #
+      # @param [ Boolean, Integer ] value The value to set.
+      #
+      # @return [ Boolean, Integer ] The value.
+      def noprogress=(value)
+        Curl.set_option(:noprogress, value, handle)
+        @noprogress_value = value
+        value
+      end
+
+      # CURLOPT_TLSAUTH_TYPE and CURLOPT_PROXY_TLSAUTH_TYPE take a string, not
+      # an enum. Normalize the historical symbol API and libcurl's required
+      # "SRP" spelling.
+      def tlsauth_type=(value)
+        Curl.set_option(:tlsauth_type, tlsauth_type_value(value), handle)
+        value
+      end
+
+      def proxy_tlsauth_type=(value)
+        Curl.set_option(:proxy_tlsauth_type, tlsauth_type_value(value), handle)
+        value
+      end
+
+      # Options whose value is used to bound a retained body. Their setters
+      # have to keep the body length and the native size in sync.
+      POSTFIELD_OPTIONS = [:postfields, :postfieldsize, :postfieldsize_large, :copypostfields].freeze
+
+      Curl.easy_options(nil).each do |opt, props|
+        # These setters are defined below because libcurl does not copy the
+        # CURLOPT_POSTFIELDS string and the size must stay inside its buffer.
+        next if POSTFIELD_OPTIONS.include?(opt)
+
+        method_name = "#{opt}=".freeze
+        unless method_defined? method_name
+          if CALLBACK_TYPES.include?(props[:type])
+            default_callback = CALLBACK_DEFAULTS[opt]
+            define_method(method_name) do |value|
+              native_value = value
+              native_value = send(default_callback) if value.nil? && default_callback
+              Curl.set_option(opt, native_value, handle)
+              # Do not retain Ethon's internal callback as if the caller had
+              # assigned it; a duplicate must install its own callback.
+              retain_callback(opt, value)
+              value
+            end
+          elsif props[:type] == :blob
+            define_method(method_name) do |value|
+              Curl.set_option(opt, value, handle)
+              if value
+                (@blobs ||= {})[opt] = value
+              elsif @blobs
+                @blobs.delete(opt)
+              end
+              value
+            end
+          elsif props[:type] == :curl_slist
+            # libcurl keeps the list pointer, so retain the wrapper in case it
+            # owns the native list. Clearing the option can release it.
+            define_method(method_name) do |value|
+              Curl.set_option(opt, value, handle)
+              if value
+                (@slists ||= {})[opt] = value
+              elsif @slists
+                @slists.delete(opt)
+              end
+              value
+            end
+          else
+            define_method(method_name) do |value|
+              Curl.set_option(opt, value, handle)
+              value
+            end
+          end
+        end
+        next if props[:type] != :callback || method_defined?(opt)
+        define_method(opt) do |&block|
+          send(method_name, block)
+          nil
+        end
+      end
+
+      # libcurl does not copy CURLOPT_POSTFIELDS, so keep an immutable snapshot
+      # of the bytes alive for as long as the handle may reference it. The
+      # native option takes a pointer, which lets the body contain NUL bytes.
+      # Retain the buffer only once the option was accepted. Mutating a caller's
+      # string afterwards may reallocate it, so libcurl must not point at that
+      # buffer.
+      #
+      # CURLOPT_POSTFIELDSIZE survives between requests. Updating it here keeps
+      # libcurl from reading an earlier, larger body length out of the new
+      # buffer.
+      def postfields=(value)
+        if value.nil?
+          Curl.set_option(:postfields, nil, handle)
+          @postfields = nil
+          @postfields_pointer = nil
+          @postfield_body_size = nil
+          # -1 is libcurl's default: the body ends at the first NUL.
+          Curl.set_option(:postfieldsize, -1, handle)
+          @postfieldsize_value = -1
+        else
+          string = value.to_s
+          string = string.dup.freeze unless string.frozen?
+          pointer = FFI::MemoryPointer.new(:char, string.bytesize + 1)
+          pointer.put_bytes(0, string)
+          pointer.put_char(string.bytesize, 0)
+          Curl.set_option(:postfields, pointer, handle)
+          @postfields = string
+          @postfields_pointer = pointer
+          @postfield_body_size = string.bytesize
+          Curl.set_option(:postfieldsize, string.bytesize, handle)
+          @postfieldsize_value = string.bytesize
+        end
+        value
+      end
+
+      # libcurl copies CURLOPT_COPYPOSTFIELDS, so the Ruby string does not have
+      # to stay alive. An explicit, smaller CURLOPT_POSTFIELDSIZE still selects
+      # a prefix. A larger size would make libcurl read past the copied buffer,
+      # which is how a stale size from a previous body leaked memory into the
+      # request.
+      def copypostfields=(value)
+        if value.nil?
+          Curl.set_option(:copypostfields, nil, handle)
+          @postfields = nil
+          @postfields_pointer = nil
+          @postfield_body_size = nil
+          # Clear the size too: libcurl fails the request when a non-zero size
+          # is paired with the NULL body left by COPYPOSTFIELDS.
+          Curl.set_option(:postfieldsize, -1, handle)
+          @postfieldsize_value = -1
+          return value
+        end
+
+        string = value.to_s
+        size = @postfieldsize_value
+        if size && size >= 0
+          if @postfield_body_size == size
+            # The size still describes the body that is being replaced. Keeping
+            # it would truncate a longer copy or read past a shorter one.
+            size = nil
+          elsif size > string.bytesize
+            raise Errors::InvalidValue.new(:copypostfields, value)
+          end
+        end
+
+        if size.nil? || size < 0
+          Curl.set_option(:postfieldsize, string.bytesize, handle)
+          @postfieldsize_value = string.bytesize
+        end
+        Curl.set_option(:copypostfields, string, handle)
+        @postfields = nil
+        @postfields_pointer = nil
+        @postfield_body_size = string.bytesize
+        value
+      end
+
+      # CURLOPT_POSTFIELDSIZE and CURLOPT_POSTFIELDSIZE_LARGE bound the bytes
+      # libcurl reads from CURLOPT_POSTFIELDS. Letting them exceed the retained
+      # buffer makes libcurl send adjacent process memory.
+      def postfieldsize=(value)
+        set_postfieldsize(:postfieldsize, value)
+      end
+
+      def postfieldsize_large=(value)
+        set_postfieldsize(:postfieldsize_large, value)
+      end
+
+      # Observe libcurl debug messages without replacing Ethon's internal
+      # debug callback. The block receives the native CURL_DEBUGFUNCTION
+      # arguments and is called only when verbose mode is enabled.
+      #
+      # @example Observe debug messages.
+      #   easy.debugfunction { |handle, type, data, size, user_data| }
+      #
+      # @param [ Block ] block The block to execute, or no block to clear it.
+      def debugfunction(&block)
+        @user_debug_callback = block
+        nil
+      end
+
+      private
+
+      # Validate the size against the body Ethon currently knows about before
+      # handing it to libcurl.
+      def set_postfieldsize(option, value)
+        size = value.nil? ? nil : Ethon::Curls::Options.integer_value(option, value)
+        if @postfield_body_size && size && size > @postfield_body_size
+          raise Errors::InvalidValue.new(option, value)
+        end
+
+        Curl.set_option(option, value, handle)
+        @postfieldsize_value = size unless value.nil?
+        value
+      end
+
+      def initialize_copy(other)
+        super
+        @procs = @procs.dup if @procs
+        @blobs = @blobs.dup if @blobs
+        @slists = @slists.dup if @slists
+        @on_complete = @on_complete.dup if @on_complete
+        @on_headers = @on_headers.dup if @on_headers
+        @on_body = @on_body.dup if @on_body
+        @on_progress = @on_progress.dup if @on_progress
+        @headers = @headers.dup.freeze if @headers
+      end
+
+      def tlsauth_type_value(value)
+        case value.to_s.downcase
+        when "", "none"
+          nil
+        when "srp"
+          "SRP"
+        else
+          value
+        end
+      end
+
+      def retain_callback(option, callback)
+        if option == :readfunction
+          # A callback installed directly by the user does not describe the
+          # retained body and must not be replaced when the Easy is duplicated.
+          unless callback && callback.equal?(@read_callback)
+            @request_body = nil
+            @request_body_start = nil
+          end
+          @read_callback = callback
+        end
+
+        # Setting the option that backs on_progress replaces or clears the
+        # internal callback. Other progress options lose to XFERINFOFUNCTION.
+        if option == @internal_progress_option
+          @progress_source = callback ? :custom : nil
+        end
+
+        if callback.nil?
+          @procs.delete(option) if @procs
+        else
+          (@procs ||= {})[option] = callback
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/easy/queryable.rb

@@ -5,11 +5,51 @@ module Ethon
     # This module contains logic about building
     # query parameters for url or form.
     module Queryable
+      # Marker for the [filename, content type, path] tuple produced for a
+      # file value. It stays an Array for compatibility, but lets a form tell a
+      # file upload apart from a plain array value (including the arrays kept
+      # intact by params_encoding :none).
+      class FileInfo < ::Array
+        def initialize(filename, content_type, path)
+          super(3)
+          self[0] = filename
+          self[1] = content_type
+          self[2] = path
+        end
+      end
+
+      attr_reader :escape, :params_encoding
+
+      def escape=(value)
+        @to_s = nil
+        @escape = value
+      end
+
+      def params_encoding=(value)
+        @query_pairs = nil
+        @to_s = nil
+        @params_encoding = value
+      end
 
-      # :nodoc:
-      def self.included(base)
-        base.send(:attr_accessor, :escape)
-        base.send(:attr_accessor, :params_encoding)
+      # Loads mime-types on first use rather than when ethon is required:
+      # its registry costs megabytes in every process, while only file
+      # uploads need it. Concurrent first calls are safe, `require` is.
+      #
+      # @return [ Boolean ] True if mime-types could be loaded.
+      def self.mime_types_available?
+        return @mime_types_available unless @mime_types_available.nil?
+
+        @mime_types_available = begin
+          require 'mime/types/columnar'
+          true
+        rescue LoadError
+          begin
+            require 'mime/types'
+            true
+          rescue LoadError
+            false
+          end
+        end
       end
 
       # Return wether there are elements in params or not.
@@ -19,7 +59,9 @@ module Ethon
       #
       # @return [ Boolean ] True if params is empty, else false.
       def empty?
-        @params.empty?
+        # Build the pairs instead of asking @params directly: params may be a
+        # String or a scalar, and only the pairs describe what is sent.
+        query_pairs.empty?
       end
 
       # Return the string representation of params.
@@ -60,7 +102,11 @@ module Ethon
       #
       # @return [ Array ] The array of query pairs.
       def build_query_pairs(hash)
-        return [hash] if hash.is_a?(String)
+        if hash.is_a?(String)
+          # An empty string describes no pairs. Treating it as one would make
+          # #empty? false and leave a stray "?" or "&" in the url.
+          return hash.empty? ? [] : [hash]
+        end
 
         pairs = []
         recursively_generate_pairs(hash, nil, pairs)
@@ -77,17 +123,17 @@ module Ethon
       # @return [ Array ] Array of informations.
       def file_info(file)
         filename = File.basename(file.path)
-        [
+        FileInfo.new(
           filename,
           mime_type(filename),
           File.expand_path(file.path)
-        ]
+        )
       end
 
       private
 
       def mime_type(filename)
-        if defined?(MIME) && t = MIME::Types.type_for(filename).first
+        if Queryable.mime_types_available? && defined?(MIME) && t = MIME::Types.type_for(filename).first
           t.to_s
         else
           'application/octet-stream'
@@ -132,12 +178,11 @@ module Ethon
         end
       end
 
-    def encode_multi_array_pairs(h, prefix, pairs)
-      h.each_with_index do |v, i|
-        key = prefix
-        pairs_for(v, key, pairs)
+      def encode_multi_array_pairs(h, prefix, pairs)
+        h.each do |v|
+          pairs_for(v, prefix, pairs)
+        end
       end
-    end
 
       def pairs_for(v, key, pairs)
         case v

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/easy/response_callbacks.rb

@@ -69,9 +69,30 @@ module Ethon
       # @example Execute on_completes.
       #   request.complete
       def complete
-        headers unless @response_headers.empty?
-        if defined?(@on_complete) and not @on_complete.nil?
-          @on_complete.each{ |callback| callback.call(self) }
+        if @completing
+          raise Errors::EthonError, "Easy is already completing; wait for the callbacks to finish"
+        end
+
+        error = nil
+        response_body_io = @response_body_io
+        begin
+          @completing = true
+          headers unless @response_headers.empty?
+          if defined?(@on_complete) and not @on_complete.nil?
+            @on_complete.each{ |callback| callback.call(self) }
+          end
+        rescue Exception => exception
+          error = exception
+          raise
+        ensure
+          @completing = false
+          begin
+            finish_response_body_io(response_body_io)
+          rescue Exception
+            # A failed close or flush must not hide the error that caused the
+            # teardown, or a callback error that is about to be raised.
+            raise unless error || @callback_error
+          end
         end
       end
 
@@ -120,16 +141,16 @@ module Ethon
       #
       # @return [ Object ] If there are no on_body callbacks, returns the symbol :unyielded.
       def body(chunk)
-        if defined?(@on_body) and not @on_body.nil?
-          result = nil
-          @on_body.each do |callback|
-            result = callback.call(chunk, self)
-            break if result == :abort
-          end
-          result
-        else
-          :unyielded
+        # Merely reading #on_body creates an empty list. It must not change
+        # whether the response body is buffered.
+        return :unyielded if !defined?(@on_body) || @on_body.nil? || @on_body.empty?
+
+        result = nil
+        @on_body.each do |callback|
+          result = callback.call(chunk, self)
+          break if result == :abort
         end
+        result
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/easy/share.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Share
+      attr_reader :share
+
+      # Attach a curl share handle.
+      #
+      # @param [ Ethon::Curl::Share, nil ] share The share handle.
+      #
+      # @raise [ TypeError ] If share is not a share handle.
+      #
+      # @return [ Ethon::Curl::Share, nil ] The share handle.
+      def share=(share)
+        unless share.nil? || share.is_a?(Curl::Share)
+          raise TypeError, "expected an Ethon::Curl::Share, got #{share.class}"
+        end
+
+        share.check_pid! if share
+        Curl.set_option(:share, share, handle)
+        @share = share
+        share
+      end
+    end
+
+    include Share
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/easy/url.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Url
+      attr_reader :curlu
+
+      # Install a URL handle as the request target.
+      #
+      # @param [ Ethon::Curl::Url, nil ] url The URL handle.
+      #
+      # @raise [ TypeError ] If url is not a URL handle.
+      #
+      # @return [ Ethon::Curl::Url, nil ] The URL handle.
+      def curlu=(url)
+        unless url.nil? || url.is_a?(Curl::Url)
+          raise TypeError, "expected an Ethon::Curl::Url, got #{url.class}"
+        end
+
+        url.check_pid! if url
+        Curl.set_option(:curlu, url, handle)
+        if url
+          Curl.set_option(:url, nil, handle)
+          @url = nil
+        end
+        @curlu = url
+        url
+      end
+    end
+
+    include Url
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/easy/util.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy # :nodoc:
+
+    # This module contains small helpers.
+    #
+    # @api private
+    module Util
+
+      # Escapes zero bytes in strings.
+      #
+      # @example Escape zero bytes.
+      #   Util.escape_zero_byte("1\0")
+      #   #=> "1\\0"
+      #
+      # @param [ Object ] value The value to escape.
+      #
+      # @return [ String, Object ] Escaped String if
+      #   zero byte found, original object if not.
+      def escape_zero_byte(value)
+        return value unless value.to_s.include?(0.chr)
+        value.to_s.gsub(0.chr, '\\\0')
+      end
+
+      # Rejects header lines libcurl would send verbatim as extra headers.
+      #
+      # @example Validate a header line.
+      #   Util.validate_header_line(:headers, "X-Test: 1")
+      #
+      # @param [ Symbol ] option The option name used in the error.
+      # @param [ String ] line The header line.
+      #
+      # @raise [ Errors::InvalidValue ] If the line contains CR, LF, or NUL.
+      #
+      # @return [ String ] The validated line.
+      def validate_header_line(option, line)
+        if line.include?("\r") || line.include?("\n") || line.include?("\0")
+          raise Errors::InvalidValue.new(option, line)
+        end
+
+        line
+      end
+
+      extend self
+    end
+  end
+end