ory-client 1.22.87 → 1.22.89

data/vendor/bundle/ruby/3.2.0/gems/typhoeus-1.7.1/lib/typhoeus/response/header.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Typhoeus
+  class Response
+
+    # This class represents the response header.
+    # It can be accessed like a hash.
+    # Values can be strings (normal case) or arrays of strings (for duplicates headers)
+    #
+    # @api private
+    class Header < DelegateClass(Hash)
+
+      # Create a new header.
+      #
+      # @example Create new header.
+      #   Header.new(raw)
+      #
+      # @param [ String ] raw The raw header.
+      def initialize(raw)
+        super({})
+        @raw = raw
+        @sanitized = {}
+        parse
+      end
+
+      def initialize_dup(other)
+        super
+        copy_delegate(other)
+      end
+      private :initialize_dup
+
+      def initialize_clone(other, freeze: nil)
+        if freeze.nil?
+          super(other)
+        else
+          super(other, freeze: freeze)
+        end
+        copy_delegate(other)
+      end
+      private :initialize_clone
+
+      def [](key)
+        @sanitized[convert_key(key)]
+      end
+
+      def []=(key, value)
+        # Store string keys so the delegated Hash and the case-insensitive
+        # index describe the same header set even when a caller used a symbol.
+        key = key.to_s
+        delete_underlying_key(key)
+        __getobj__[key] = value
+        @sanitized[convert_key(key)] = value
+      end
+      alias_method :store, :[]=
+
+      def merge(other)
+        merged = dup
+        merged.update(other) do |key, old, new|
+          block_given? ? yield(key, old, new) : new
+        end
+        merged
+      end
+
+      def delete(key)
+        value = self[key]
+        delete_underlying_key(key)
+        @sanitized.delete(convert_key(key))
+        value
+      end
+
+      def clear
+        __getobj__.clear
+        @sanitized.clear
+        self
+      end
+
+      def update(other)
+        other.each_pair do |key, value|
+          value = yield(key, self[key], value) if block_given? && include?(key)
+          self[key] = value
+        end
+        self
+      end
+      alias_method :merge!, :update
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def delete_if(&block)
+        return enum_for(:delete_if) unless block
+
+        super
+        rebuild_sanitized
+        self
+      end
+
+      def keep_if(&block)
+        return enum_for(:keep_if) unless block
+
+        super
+        rebuild_sanitized
+        self
+      end
+
+      def select!(&block)
+        return enum_for(:select!) unless block
+
+        result = super
+        rebuild_sanitized
+        result ? self : nil
+      end
+      alias_method :filter!, :select!
+
+      def reject!(&block)
+        return enum_for(:reject!) unless block
+
+        result = super
+        rebuild_sanitized
+        result ? self : nil
+      end
+
+      def shift
+        result = super
+        rebuild_sanitized
+        result
+      end
+
+      def compact!
+        result = super
+        rebuild_sanitized
+        result ? self : nil
+      end
+
+      def transform_keys!(*args, &block)
+        return enum_for(:transform_keys!, *args) if !block && args.empty?
+
+        super
+        rebuild_sanitized
+        self
+      end
+
+      def transform_values!(&block)
+        return enum_for(:transform_values!) unless block
+
+        super
+        rebuild_sanitized
+        self
+      end
+
+      def include?(key)
+        @sanitized.include?(convert_key(key))
+      end
+      alias_method :has_key?, :include?
+      alias_method :key?, :include?
+      alias_method :member?, :include?
+
+      def fetch(key, *extras, &block)
+        if block
+          # Hash#fetch yields the key the caller asked for, not a normalized
+          # one. Keep that behavior while looking up case-insensitively.
+          @sanitized.fetch(convert_key(key), *extras) { block.call(key) }
+        else
+          @sanitized.fetch(convert_key(key), *extras)
+        end
+      end
+
+      def dig(key, *identifiers)
+        @sanitized.dig(convert_key(key), *identifiers)
+      end
+
+      def assoc(key)
+        @sanitized.assoc(convert_key(key))
+      end
+
+      def values_at(*keys)
+        keys.map! { |key| convert_key(key) }
+        @sanitized.values_at(*keys)
+      end
+
+      def fetch_values(*indices, &block)
+        indices.map do |key|
+          converted = convert_key(key)
+          if @sanitized.key?(converted)
+            @sanitized[converted]
+          elsif block
+            block.call(key)
+          else
+            @sanitized.fetch(converted)
+          end
+        end
+      end
+
+      # Parses the raw header.
+      #
+      # @example Parse header.
+      #   header.parse
+      def parse
+        if raw.respond_to?(:each_pair)
+          raw.each_pair do |k, v|
+            process_pair(k, v)
+          end
+        elsif raw.is_a?(String)
+          raw.split(/\r?\n(?!\s)/).each do |header|
+            header.strip!
+            next if header.empty? || header.start_with?( 'HTTP/' )
+            process_line(header)
+          end
+        end
+      end
+
+      private
+
+      # Processes line and saves the result.
+      #
+      # @return [ void ]
+      def process_line(header)
+        key, value = header.split(':', 2)
+        process_pair(key.strip, (value ? value.strip.gsub(/\r?\n\s*/, ' ') : ''))
+      end
+
+      # Sets key value pair for self and @sanitized.
+      #
+      # @return [ void ]
+      def process_pair(key, value)
+        sanitized_key = convert_key(key)
+        set_value(sanitized_key, duplicate_value(value), @sanitized)
+        self[key] = @sanitized[sanitized_key]
+      end
+
+      # Sets value for key in specified hash
+      #
+      # @return [ void ]
+      def set_value(key, value, hash)
+        current_value = hash[key]
+        if current_value
+          if current_value.is_a? Array
+            current_value << value
+          else
+            hash[key] = [current_value, value]
+          end
+        else
+          hash[key] = value
+        end
+      end
+
+      # Returns the raw header or empty string.
+      #
+      # @example Return raw header.
+      #   header.raw
+      #
+      # @return [ String ] The raw header.
+      def raw
+        @raw || ''
+      end
+
+      def convert_key(key)
+        key.to_s.downcase
+      end
+
+      def duplicate_value(value)
+        case value
+        when Array
+          value.map { |nested| duplicate_value(nested) }
+        when String
+          value.dup
+        else
+          value
+        end
+      end
+
+      # DelegateClass copies only the delegated hash itself. Rebuild both
+      # hashes so later mutations cannot reach the original header. The
+      # sanitized index is built from the copied hash so both stores keep
+      # referring to the same values, as they do on the original.
+      def copy_delegate(other)
+        copy = {}
+        other.__getobj__.each do |key, value|
+          copy[key] = duplicate_value(value)
+        end
+        __setobj__(copy)
+
+        @sanitized = {}
+        copy.each do |key, value|
+          converted = convert_key(key)
+          if @sanitized.key?(converted)
+            existing = @sanitized[converted]
+            existing = [existing] unless existing.is_a?(Array)
+            existing.concat(value.is_a?(Array) ? value : [value])
+            @sanitized[converted] = existing
+          else
+            @sanitized[converted] = value
+          end
+        end
+      end
+
+      def delete_underlying_key(key)
+        converted = convert_key(key)
+        __getobj__.keys.each do |existing_key|
+          __getobj__.delete(existing_key) if convert_key(existing_key) == converted
+        end
+      end
+
+      # Rebuild the case-insensitive index after a Hash mutator that cannot be
+      # expressed through #[]=.
+      def rebuild_sanitized
+        @sanitized = {}
+        __getobj__.each do |key, value|
+          converted = convert_key(key)
+          if @sanitized.key?(converted)
+            existing = @sanitized[converted]
+            existing = [existing] unless existing.is_a?(Array)
+            existing.concat(value.is_a?(Array) ? value : [value])
+            @sanitized[converted] = existing
+          else
+            @sanitized[converted] = value
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{typhoeus-1.6.0 → typhoeus-1.7.1}/lib/typhoeus/response/informations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Typhoeus
   class Response
 
@@ -27,6 +29,17 @@ module Typhoeus
         Ethon::Curl.easy_strerror(return_code) if return_code
       end
 
+      # Returns the detailed error message from libcurl's error buffer,
+      # only available when the request was made with errorbuffer: true.
+      #
+      # @example Get error_message.
+      #   response.error_message
+      #
+      # @return [ String, nil ] The error_message.
+      def error_message
+        options[:error_message]
+      end
+
       # Return the http response body.
       #
       # @example Get response_body.
@@ -34,7 +47,8 @@ module Typhoeus
       #
       # @return [ String ] The response_body.
       def response_body
-        options[:response_body] || options[:body]
+        body = options[:response_body] || options[:body]
+        apply_content_type_charset(body)
       end
       alias :body :response_body
 
@@ -47,13 +61,13 @@ module Typhoeus
       def response_headers
         return options[:response_headers] if options[:response_headers]
         if mock? && h = options[:headers]
-            status_code = return_code || "200"
-            reason_phrase = status_code == "200" ? "OK" : "Mock Reason Phrase"
-            status_line = "HTTP/1.1 #{status_code} #{reason_phrase}"
-            actual_headers = h.map{ |k,v| [k, v.respond_to?(:join) ? v.join(',') : v] }.
-              map{ |e| "#{e.first}: #{e.last}" }
+          status_code = options[:response_code] || options[:code] || 200
+          reason_phrase = status_code.to_i == 200 ? "OK" : "Mock Reason Phrase"
+          status_line = "HTTP/1.1 #{status_code} #{reason_phrase}"
+          actual_headers = h.map{ |k,v| [k, v.respond_to?(:join) ? v.join(',') : v] }.
+            map{ |e| "#{e.first}: #{e.last}" }
 
-            [status_line, *actual_headers].join("\r\n")
+          [status_line, *actual_headers].join("\r\n")
         end
       end
 
@@ -67,7 +81,14 @@ module Typhoeus
       #
       # @return [ Integer ] The response_code.
       def response_code
-        (options[:response_code] || options[:code]).to_i
+        code = options[:response_code] || options[:code]
+        return code.to_i unless code.nil?
+
+        # A response built from raw headers, such as one returned by
+        # #redirections, has no option describing the status.
+        line = first_header_line
+        status = line && line[/\AHTTP\/\S+\s+(\d{3})/, 1]
+        status ? status.to_i : 0
       end
       alias :code :response_code
 
@@ -282,9 +303,9 @@ module Typhoeus
       #
       # @return [ Typhoeus::Header ] The response header.
       def headers
-        return Header.new(options[:headers]) if mock? && options[:headers]
-        return nil if response_headers.nil? && !defined?(@headers)
-        @headers ||= Header.new(response_headers.split("\r\n\r\n").last)
+        return @headers if defined?(@headers) && @headers
+        return nil if response_headers.nil?
+        @headers = Header.new(last_response_block)
       end
       alias :headers_hash :headers
 
@@ -297,7 +318,49 @@ module Typhoeus
       # @return [ Array<Typhoeus::Response> ] The redirections
       def redirections
         return [] unless response_headers
-        response_headers.split("\r\n\r\n")[0..-2].map{ |h| Response.new(:response_headers => h) }
+
+        http_blocks = response_blocks.select { |block| block.start_with?("HTTP/") }
+        blocks = http_blocks.empty? ? response_blocks[0..-2] : http_blocks[0..-2]
+        blocks.map { |header| Response.new(:response_headers => header) }
+      end
+
+      private
+
+      # Split the raw response headers into their header blocks.
+      #
+      # @return [ Array<String> ] The blocks.
+      def response_blocks
+        response_headers.to_s.split("\r\n\r\n")
+      end
+
+      # Return the last block that starts a new response. HTTP/1.1 trailers
+      # add a block without a status line after the response headers.
+      #
+      # @return [ String ] The response block.
+      def last_response_block
+        http_blocks = response_blocks.select { |block| block.start_with?("HTTP/") }
+        (http_blocks.empty? ? response_blocks.last : http_blocks.last).to_s
+      end
+
+      # Force the body to the charset advertised by the Content-Type
+      # header, but leave binary and already encoded bodies alone.
+      #
+      # @param [ String, nil ] body The response body.
+      #
+      # @return [ String, nil ] The response body.
+      def apply_content_type_charset(body)
+        return body unless body.is_a?(String) && !body.frozen?
+        return body unless body.encoding == Encoding::BINARY
+
+        content_type = headers && headers["Content-Type"]
+        return body unless content_type
+
+        charset = content_type.to_s[/;\s*charset\s*=\s*["']?([^"';,\s]+)/i, 1]
+        return body unless charset
+
+        body.force_encoding(Encoding.find(charset))
+      rescue ArgumentError
+        body
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/{typhoeus-1.6.0 → typhoeus-1.7.1}/lib/typhoeus/response/status.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Typhoeus
   class Response
 
@@ -56,7 +58,7 @@ module Typhoeus
       #
       # @return [ Boolean ] Return true if failure, false else.
       def failure?
-        (mock || return_code == :internal_server_error) && response_code && has_bad_response_code?
+        (mock || !return_code.nil?) && !success?
       end
 
       # Return wether the response is modified.
@@ -83,24 +85,13 @@ module Typhoeus
 
       # :nodoc:
       def first_header_line
-        @first_header_line ||= begin
-          if response_headers.to_s.include?("\r\n\r\n")
-            response_headers.to_s.split("\r\n\r\n").last.split("\r\n").first
-          else
-            response_headers.to_s.split("\r\n").first
-          end
-        end
+        @first_header_line ||= last_response_block.split("\r\n").first
       end
 
       # :nodoc:
       def has_good_response_code?
         response_code >= 200 && response_code < 300
       end
-
-      # :nodoc:
-      def has_bad_response_code?
-        !has_good_response_code?
-      end
     end
   end
 end

data/vendor/bundle/ruby/3.2.0/gems/{typhoeus-1.6.0 → typhoeus-1.7.1}/lib/typhoeus/response.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'typhoeus/response/header'
 require 'typhoeus/response/informations'
 require 'typhoeus/response/status'
@@ -47,6 +49,20 @@ module Typhoeus
       @headers = Header.new(options[:headers]) if options[:headers]
     end
 
+    # Keep duplicated responses independent. Memoization hands a copy of the
+    # leader's response to every follower, so shared options, headers, bodies,
+    # or callback results would let one request change another one's response.
+    def initialize_copy(other)
+      super
+      @options = duplicate_value(other.options)
+      @handled_response = nil
+      if other.instance_variable_defined?(:@headers)
+        headers = other.instance_variable_get(:@headers)
+        @headers = headers.dup if headers
+      end
+    end
+    private :initialize_copy
+
     # Returns whether this request is mocked
     # or not.
     #
@@ -64,5 +80,24 @@ module Typhoeus
     def handled_response
       @handled_response || self
     end
+
+    private
+
+    # Duplicate the mutable containers a response may share with its copy.
+    # Other option values are opaque and are left alone.
+    def duplicate_value(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, nested), copy|
+          copy[duplicate_value(key)] = duplicate_value(nested)
+        end
+      when Array
+        value.map { |nested| duplicate_value(nested) }
+      when String
+        value.dup
+      else
+        value
+      end
+    end
   end
 end

data/vendor/bundle/ruby/3.2.0/gems/{typhoeus-1.6.0 → typhoeus-1.7.1}/lib/typhoeus/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Typhoeus
 
   # The current Typhoeus version.
-  VERSION = '1.6.0'
+  VERSION = '1.7.1'
 end