ory-client 1.22.86 → 1.22.88

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

@@ -93,6 +93,18 @@ module Ethon
         # @param [ easy ] easy the easy to setup.
         def setup(easy)
           @easy = easy
+          easy.customrequest = nil
+          # A reused handle keeps the previous transfer's method and body
+          # options. Clear them before applying this request so a stale
+          # upload body cannot win over the body configured below.
+          # CURLOPT_POSTFIELDS selects POST even when cleared, so clear it
+          # before the method flags to leave the handle on GET.
+          easy.postfields = nil
+          easy.readfunction = nil
+          Curl.set_option(:upload, false, easy.handle)
+          Curl.set_option(:httpget, false, easy.handle)
+          Curl.set_option(:nobody, false, easy.handle)
+          Curl.set_option(:post, false, easy.handle)
 
           # Order is important, @easy will be used to provide access to options
           # relevant to the following operations (like whether or not to escape
@@ -100,6 +112,12 @@ module Ethon
           easy.set_attributes(options)
 
           set_form(easy) unless form.empty?
+          if form.empty?
+            easy.multipart_form = nil
+            # Clear any MIME body left over from an earlier request (or copied
+            # by Easy#dup) so this request does not inherit it.
+            easy.mime = nil if Ethon::Curl.respond_to?(:mime_init)
+          end
 
           if params.empty?
             easy.url = url
@@ -118,11 +136,15 @@ module Ethon
           params.escape = easy.escape?
           params.params_encoding = params_encoding
 
-          base_url, base_params = url.split('?')
+          url_without_fragment, fragment_separator, fragment = url.partition('#')
+          fragment = fragment_separator.empty? ? nil : "#{fragment_separator}#{fragment}"
+          base_url, query_separator, base_params = url_without_fragment.partition('?')
+
           base_url << '?'
-          base_url << base_params.to_s
-          base_url << '&' if base_params
+          base_url << base_params
+          base_url << '&' if query_separator == '?' && !base_params.empty?
           base_url << params.to_s
+          base_url << fragment.to_s
 
           easy.url = base_url
         end

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

@@ -16,7 +16,11 @@ module Ethon
         # @param [ Easy ] easy The easy to setup.
         def setup(easy)
           super
-          easy.customrequest = "GET" unless form.empty?
+          if form.empty?
+            easy.httpget = true
+          else
+            easy.customrequest = "GET"
+          end
         end
       end
     end

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

@@ -16,6 +16,7 @@ module Ethon
         def setup(easy)
           super
           if form.empty?
+            easy.multipart_form = nil
             easy.postfieldsize = 0
             easy.copypostfields = ""
           end

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

@@ -18,9 +18,16 @@ module Ethon
           form.params_encoding = params_encoding
           if form.multipart?
             form.escape = false
-            form.materialize
-            easy.httppost = form.first.read_pointer
+            if Ethon::Curl.respond_to?(:mime_init)
+              easy.multipart_form = nil
+              easy.mime = form.mime
+            else
+              form.materialize
+              easy.multipart_form = form
+            end
           else
+            easy.multipart_form = nil
+            easy.mime = nil if Ethon::Curl.respond_to?(:mime_init)
             form.escape = easy.escape?
             easy.postfieldsize = form.to_s.bytesize
             easy.copypostfields = form.to_s

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Http
+
+      # This module contains logic about setting up a PUT body.
+      module Putable
+        # Set things up when form is provided.
+        # Deals with multipart forms.
+        #
+        # @example Setup.
+        #   put.set_form(easy)
+        #
+        # @param [ Easy ] easy The easy to setup.
+        def set_form(easy)
+          easy.url ||= url
+          form.params_encoding = params_encoding
+          if form.multipart?
+            form.escape = false
+            if Ethon::Curl.respond_to?(:mime_init)
+              easy.multipart_form = nil
+              easy.mime = form.mime
+            else
+              form.materialize
+              easy.multipart_form = form
+            end
+            easy.customrequest = "PUT"
+          else
+            easy.multipart_form = nil
+            easy.mime = nil if Ethon::Curl.respond_to?(:mime_init)
+            easy.upload = true
+            form.escape = easy.escape?
+            easy.infilesize = form.to_s.bytesize
+            easy.set_read_callback(form.to_s)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,18 @@ module Ethon
     # This module contains logic about making valid HTTP requests.
     module Http
 
+      # Built-in request actions. Custom verbs must not resolve to helper
+      # modules or classes that happen to live in this namespace.
+      ACTION_CLASSES = {
+        "get" => Get,
+        "head" => Head,
+        "post" => Post,
+        "put" => Put,
+        "delete" => Delete,
+        "patch" => Patch,
+        "options" => Options
+      }.freeze
+
       # Set specified options in order to make a HTTP request.
       # Look at {Ethon::Easy::Options Options} to see what you can
       # provide in the options hash.
@@ -54,12 +66,12 @@ module Ethon
       #
       # @return [ Easy::Ethon::Actionable ] The request instance.
       def fabricate(url, action_name, options)
-        constant_name = action_name.to_s.capitalize
+        action_class = ACTION_CLASSES[action_name.to_s.downcase]
 
-        if Ethon::Easy::Http.const_defined?(constant_name)
-          Ethon::Easy::Http.const_get(constant_name).new(url, options)
+        if action_class
+          action_class.new(url, options)
         else
-          Ethon::Easy::Http::Custom.new(constant_name.upcase, url, options)
+          Ethon::Easy::Http::Custom.new(action_name.to_s.upcase, url, options)
         end
       end
 

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

@@ -3,13 +3,52 @@ module Ethon
   class Easy
 
     # This module contains the methods to return informations
-    # from the easy handle. See http://curl.haxx.se/libcurl/c/curl_easy_getinfo.html
+    # from the easy handle. See https://curl.se/libcurl/c/curl_easy_getinfo.html
     # for more information.
     module Informations
 
       # Holds available informations and their type, which is needed to
       # request the informations from libcurl.
       AVAILABLE_INFORMATIONS = {
+        # The _T variants use curl_off_t and do not lose precision for large
+        # values or long-running transfers.
+        :size_upload_t => :off_t,
+        :size_download_t => :off_t,
+        :speed_download_t => :off_t,
+        :speed_upload_t => :off_t,
+        :filetime_t => :off_t,
+        :content_length_download_t => :off_t,
+        :content_length_upload_t => :off_t,
+        :total_time_t => :off_t,
+        :namelookup_time_t => :off_t,
+        :connect_time_t => :off_t,
+        :pretransfer_time_t => :off_t,
+        :starttransfer_time_t => :off_t,
+        :redirect_time_t => :off_t,
+        :appconnect_time_t => :off_t,
+        :retry_after => :off_t,
+        :xfer_id => :off_t,
+        :conn_id => :off_t,
+        :queue_time_t => :off_t,
+        :posttransfer_time_t => :off_t,
+        :earlydata_sent_t => :off_t,
+        :size_delivered => :off_t,
+
+        # Connection/request metadata.
+        :http_version => :long,
+        :httpauth_used => :long,
+        :proxyauth_used => :long,
+        :proxy_ssl_verifyresult => :long,
+        :proxy_error => :long,
+        :used_proxy => :long,
+        :scheme => :string,
+        :effective_method => :string,
+        :referer => :string,
+        :cainfo => :string,
+        :capath => :string,
+        :activesocket => :socket,
+        :tls_ssl_ptr => :ptr,
+
         # Return the available HTTP auth methods.
         :httpauth_avail => :long,
 
@@ -95,10 +134,20 @@ module Ethon
         :speed_download => :double
       }
 
+      LIST_INFORMATIONS = [:ssl_engines, :cookielist].freeze
+
       AVAILABLE_INFORMATIONS.each do |name, type|
         eval %Q|def #{name}; Curl.send(:get_info_#{type}, :#{name}, handle); end|
       end
 
+      LIST_INFORMATIONS.each do |name|
+        define_method(name) { Curl.get_info_slist(name, handle) }
+      end
+
+      def certinfo
+        Curl.get_info_certinfo(:certinfo, handle)
+      end
+
       # Returns true if this curl version supports zlib.
       #
       # @example Return wether zlib is supported.
@@ -107,7 +156,7 @@ module Ethon
       # @return [ Boolean ] True if supported, else false.
       # @deprecated Please use the static version instead
       def supports_zlib?
-        Kernel.warn("Ethon: Easy#supports_zlib? is deprecated and will be removed, please use Easy#.")
+        Kernel.warn("Ethon: Easy#supports_zlib? is deprecated and will be removed, please use Easy.supports_zlib? instead.")
         Easy.supports_zlib?
       end
 

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Mime
+      attr_reader :mime
+
+      # Install a MIME structure as the request body.
+      #
+      # @param [ Ethon::Curl::Mime, nil ] mime The MIME structure.
+      #
+      # @raise [ TypeError ] If mime is not a MIME structure.
+      #
+      # @return [ Ethon::Curl::Mime, nil ] The MIME structure.
+      def mime=(mime)
+        unless mime.nil? || mime.is_a?(Curl::Mime)
+          raise TypeError, "expected an Ethon::Curl::Mime, got #{mime.class}"
+        end
+
+        mime.check_pid! if mime
+        Curl.set_option(:mimepost, mime, handle)
+        @mime = mime
+        mime
+      end
+      alias mimepost= mime=
+    end
+
+    include Mime
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    class Mirror
+      attr_reader :options
+      alias_method :to_hash, :options
+
+      # Raw pointers cannot be marshaled and point into native state that can
+      # go away when the handle is reset. Applications serialize a mirror (for
+      # example as a cached Typhoeus response), so leave them on the Easy.
+      INFORMATIONS_TO_MIRROR = Informations::AVAILABLE_INFORMATIONS.
+          reject { |_, type| type == :ptr }.keys +
+          [:return_code, :response_headers, :response_body, :debug_info, :error_message]
+
+      INFORMATIONS_TO_LOG = [:effective_url, :response_code, :return_code, :total_time]
+
+      # Credentials embedded in the URL are not useful in logs and may end up
+      # in a log aggregator. Keep the scheme and host so the line is still
+      # identifiable, but replace the userinfo.
+      URL_CREDENTIALS = %r{\A([a-z][a-z0-9+.-]*://)[^/?#@]*@}i
+
+      def self.from_easy(easy)
+        options = {}
+        INFORMATIONS_TO_MIRROR.each do |info|
+          options[info] = easy.send(info)
+        end
+        new(options)
+      end
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def log_informations
+        Hash[*INFORMATIONS_TO_LOG.map do |info|
+          value = options[info]
+          if info == :effective_url && value.is_a?(String)
+            value = value.sub(URL_CREDENTIALS, "\\1[REDACTED]@")
+          end
+          [info, value]
+        end.flatten]
+      end
+
+      INFORMATIONS_TO_MIRROR.each do |info|
+        define_method(info) { options[info] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    # This module contains the logic to prepare and perform
+    # an easy.
+    module Operations
+      # Returns a pointer to the curl easy handle.
+      #
+      # @example Return the handle.
+      #   easy.handle
+      #
+      # @return [ Ethon::Curl::EasyHandle ] The owned wrapper around the curl
+      #   easy handle. It is an FFI::Pointer subclass.
+      def handle
+        raise Errors::EthonError, "Easy has been cleaned up" if @cleaned_up
+
+        @handle ||= create_handle
+        handle = @handle
+        handle.check_pid!
+        handle.owner ||= self
+        handle
+      end
+
+      # Sets a pointer to the curl easy handle.
+      #
+      # Raw pointers are wrapped in an owned {Curl::EasyHandle}, so the
+      # handle is registered for fork safety and freed by this Easy. Assigning
+      # nil installs a fresh handle. Assigning a different handle installs
+      # Ethon's response callbacks and replays callbacks previously assigned to
+      # this Easy, then frees the handle it replaces when this Easy owned it.
+      #
+      # Request options that are not replayed are cleared, because the
+      # replacement handle does not have them. Read them before replacing the
+      # handle if they are needed again.
+      #
+      # @param [ ::FFI::Pointer, Curl::EasyHandle, nil ] h Easy handle that will
+      #   be assigned.
+      def handle=(h)
+        assign_handle(h, true)
+      end
+
+      # Perform the easy request.
+      #
+      # @example Perform the request.
+      #   easy.perform
+      #
+      # @return [ Symbol ] The return code.
+      def perform
+        ensure_not_performing!
+        # curl_easy_perform must not drive a handle that is owned by a multi.
+        ensure_not_attached_to_multi!
+        # Touch the handle before changing transfer state so a cleaned up or
+        # forked handle cannot truncate a response file or reset the previous
+        # result while raising.
+        handle
+
+        prepare_response_body_io
+        reset_transfer_state
+        clear_callback_error
+        # Only the destination that belongs to this transfer may be finished.
+        # A completion callback can install the next transfer's destination.
+        response_body_io = @response_body_io
+        @performing = true
+
+        error = nil
+        begin
+          code = Curl.easy_perform(handle)
+          @return_code = code
+          if Ethon.logger.debug?
+            Ethon.logger.debug { "ETHON: performed #{log_inspect}" }
+          end
+          # Make the complete response visible before on_complete runs. An
+          # owned file is closed by the ensure below after the callbacks.
+          begin
+            flush_response_body_io
+          rescue Exception
+            # A callback error already failed this transfer; a flush error is
+            # secondary and must not hide it.
+            raise_callback_error
+            raise
+          end
+          complete
+          raise_callback_error
+          # on_complete may reset the Easy, which clears @return_code. Return
+          # the result of the transfer that just ran.
+          code
+        rescue Exception => exception
+          error = exception
+          raise
+        ensure
+          @performing = false
+          begin
+            finish_response_body_io(response_body_io)
+          rescue Exception
+            # Keep the exception that interrupted the transfer or completion.
+            raise unless error
+          end
+        end
+      end
+
+      # Clean up the easy.
+      #
+      # Cleanup is terminal: the native handle is freed and the Easy cannot be
+      # used again. Reusing it raises Ethon::Errors::EthonError.
+      #
+      # Cleanup is allowed from an on_complete callback: the transfer has
+      # finished and a Multi detaches the handle before running its callbacks.
+      # Cleanup from body, header, and progress callbacks is rejected because
+      # those run inside libcurl.
+      #
+      # @example Perform clean up.
+      #   easy.cleanup
+      #
+      # @return the result of the free which is nil
+      def cleanup
+        ensure_not_in_transfer!
+        ensure_not_attached_to_multi!
+
+        # Resolve the handle first: cleanup must not clear the response body if
+        # the handle is unusable (cleaned up or inherited across a fork).
+        handle_to_free = handle
+        begin
+          clear_response_body_io
+        ensure
+          # Free the native handle even when closing the response body fails.
+          begin
+            handle_to_free.free
+          ensure
+            clear_native_state
+            @handle = nil
+            @cleaned_up = true
+          end
+        end
+      end
+
+      # Prepare the easy. Options, headers and callbacks
+      # were set.
+      #
+      # @example Prepare easy.
+      #   easy.prepare
+      #
+      # @deprecated It is no longer necessary to call prepare.
+      def prepare
+        Ethon.logger.warn(
+          "ETHON: It is no longer necessary to call "+
+          "Easy#prepare. It's going to be removed "+
+          "in future versions."
+        )
+      end
+
+      private
+
+      # Allocate the native handle. Kept separate so #handle= can replace a
+      # handle and install the callbacks before the next option setter runs.
+      def create_handle
+        Curl.check_pid!
+        pointer = Curl.easy_init
+        raise NoMemoryError, "curl_easy_init failed" if pointer.null?
+        Curl::EasyHandle.new(pointer)
+      end
+
+      # Reapply options Ethon installed on the old handle. These are not user
+      # request options: without them #error_message and progress callbacks
+      # silently stop working on the replacement.
+      def restore_handle_options
+        if @error_buffer_enabled && @error_buffer
+          Curl.set_option(:errorbuffer, @error_buffer, @handle)
+          @handle.error_buffer = @error_buffer
+          # Do not report the previous transfer's error from the new handle.
+          @error_buffer.put_char(0, 0)
+        end
+        self.noprogress = @noprogress_value unless @noprogress_value.nil?
+      end
+
+      # Install a handle and, unless the native duplicate already carries the
+      # request options, clear the Ruby-side state that belonged to the handle
+      # it replaces.
+      def assign_handle(h, clear_state)
+        raise Errors::EthonError, "Easy has been cleaned up" if @cleaned_up
+
+        ensure_not_performing!
+        ensure_not_attached_to_multi!
+
+        previous = @handle
+        @handle =
+          case h
+          when nil
+            # Create the replacement now so it gets Ethon's callbacks even
+            # before an option setter or #perform touches it.
+            create_handle
+          when Curl::EasyHandle
+            h.check_pid!
+            # Two Easies must not share one owned wrapper: whichever cleans up
+            # first invalidates the handle for the other.
+            if h.owner && !h.owner.equal?(self)
+              raise ArgumentError, "easy handle is already owned by another Ethon handle"
+            end
+            h
+          when Curl::OwnedPointer
+            raise TypeError, "expected an easy handle, got #{h.class}"
+          when ::FFI::Pointer
+            raise ArgumentError, "cannot assign a null easy handle" if h.null?
+
+            Curl::EasyHandle.new(h)
+          else
+            raise TypeError, "expected an easy handle pointer, got #{h.class}"
+          end
+        @handle.owner = self if @handle
+
+        replaced = @handle && !@handle.equal?(previous)
+        if replaced
+          # A replacement handle has no Ethon callbacks or Ethon-managed
+          # options, so its response would otherwise not be collected. Retained
+          # user callbacks are replayed on top of the internal ones.
+          install_callbacks(@handle)
+          restore_handle_options
+          restore_callbacks_on(self)
+        end
+        release_replaced_handle(previous)
+        # Free the old handle before dropping the Ruby references it owned.
+        clear_replaced_handle_state if replaced && clear_state
+        @handle
+      end
+
+      # The replacement handle does not have the old handle's request options.
+      # Clear the Ruby-side state so the accessors do not describe options the
+      # new handle never received. Callbacks, the error buffer, and the
+      # progress setting are replayed by #assign_handle and stay in place.
+      def clear_replaced_handle_state
+        @url = nil
+        @headers = nil
+        @header_list = nil
+        @postfields = nil
+        @postfields_pointer = nil
+        @postfield_body_size = nil
+        @postfieldsize_value = nil
+        @curlu = nil
+        @mime = nil
+        @multipart_form = nil
+        @slists = nil
+        @blobs = nil
+        @share = nil
+        @escape = nil
+        @multipart = nil
+        reset_transfer_state
+        clear_callback_error
+      end
+
+      # Free the handle this Easy owned before the replacement. A handle owned
+      # by another Easy (the source of #dup) must stay alive for its owner.
+      def release_replaced_handle(previous)
+        return unless previous
+        return if previous.equal?(@handle)
+        return unless previous.owner.equal?(self)
+
+        previous.free
+      end
+
+      # Drop references to native data and callbacks once the handle is gone.
+      def clear_native_state
+        @body_write_callback = nil
+        @header_write_callback = nil
+        @debug_callback = nil
+        @progress_callback = nil
+        @read_callback = nil
+        @request_body = nil
+        @request_body_start = nil
+        @postfields = nil
+        @postfields_pointer = nil
+        @postfield_body_size = nil
+        @postfieldsize_value = nil
+        @header_list = nil
+        @multipart_form = nil
+        @mime = nil
+        @curlu = nil
+        @blobs = nil
+        @slists = nil
+        @procs = nil
+        @on_complete = nil
+        @on_headers = nil
+        @on_body = nil
+        @on_progress = nil
+        @progress_source = nil
+        @internal_progress_option = nil
+        @user_debug_callback = nil
+        @share = nil
+        @error_buffer = nil
+        @error_buffer_enabled = nil
+        @noprogress_value = nil
+      end
+
+      def ensure_not_performing!
+        if @completing
+          raise Errors::EthonError, "Easy is currently completing; wait for the callbacks to finish"
+        end
+        if @performing
+          raise Errors::EthonError, "Easy is currently performing; wait for the transfer to finish"
+        end
+      end
+
+      # Resetting is safe from a completion callback: the transfer has already
+      # finished and the handle no longer belongs to a Multi. A reset from a
+      # body, header, or progress callback still runs inside libcurl.
+      def ensure_not_in_transfer!
+        return if @completing
+
+        ensure_not_performing!
+      end
+
+      def ensure_not_attached_to_multi!
+        return unless defined?(@multi) && @multi
+
+        raise Errors::EthonError, "Easy is still attached to a Multi; remove it first"
+      end
+    end
+  end
+end