alogram_payrisk 0.3.2 → 0.3.4

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/buffer.rb

@@ -46,6 +46,11 @@ module HTTPX
       def_delegator :@buffer, :<<
     end
 
+    def initialize_dup(other)
+      super
+      @buffer = other.instance_variable_get(:@buffer).dup
+    end
+
     def full?
       @buffer.bytesize >= @limit
     end

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/callbacks.rb

@@ -14,9 +14,9 @@ module HTTPX
       end
     end
 
-    def emit(type, *args)
+    def emit(type, ...)
       log { "emit #{type.inspect} callbacks" } if respond_to?(:log)
-      callbacks(type).delete_if { |pr| :delete == pr.call(*args) } # rubocop:disable Style/YodaCondition
+      callbacks(type).delete_if { |pr| :delete == pr.call(...) } # rubocop:disable Style/YodaCondition
     end
 
     def callbacks_for?(type)

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/chainable.rb

@@ -13,8 +13,8 @@ module HTTPX
     end
 
     # delegates to the default session (see HTTPX::Session#request).
-    def request(*args, **options)
-      branch(default_options).request(*args, **options)
+    def request(...)
+      branch(default_options).request(...)
     end
 
     def accept(type)

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/connection/http1.rb

@@ -29,7 +29,7 @@ module HTTPX
       @version = [1, 1]
       @pending = []
       @requests = []
-      @request = nil
+      @callbacks = @request = nil
       @handshake_completed = @pipelining = false
     end
 
@@ -162,18 +162,12 @@ module HTTPX
 
       return unless request
 
-      begin
-        request.log(color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
-        request.log(level: 2, color: :green) { "-> #{log_redact_body(chunk.inspect)}" }
+      request.log(color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
+      request.log(level: 2, color: :green) { "-> #{log_redact_body(chunk.inspect)}" }
 
-        response = request.response
+      response = request.response
 
-        response << chunk
-      rescue StandardError => e
-        error_response = ErrorResponse.new(request, e)
-        request.response = error_response
-        dispatch(request)
-      end
+      response << chunk
     end
 
     def on_complete
@@ -416,7 +410,7 @@ module HTTPX
     end
 
     def capitalized(field)
-      UPCASED[field] || field.split("-").map(&:capitalize).join("-")
+      UPCASED.fetch(field) { field.split("-").map(&:capitalize).join("-") }
     end
   end
 end

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/connection/http2.rb

@@ -23,20 +23,42 @@ module HTTPX
     end
 
     class GoawayError < Error
-      def initialize(code = :no_error)
+      UNRECOVERABLE_ERRORS = %i[settings_timeout inadequate_security].freeze
+
+      def initialize(code, last_stream_id)
+        @code = code
+        @last_stream_id = last_stream_id
         super(0, code)
       end
+
+      def last_stream_id
+        return Float::INFINITY if unrecoverable?
+
+        @last_stream_id
+      end
+
+      def unrecoverable?
+        UNRECOVERABLE_ERRORS.include?(@code)
+      end
+    end
+
+    class RstStreamError < Error
+    end
+
+    class RefusedStreamError < RstStreamError
     end
 
     attr_reader :streams, :pending
 
     def initialize(buffer, options)
+      @callbacks = nil
       @options = options
       @settings = @options.http2_settings
       @pending = []
       @streams = {}
       @drains = {}
       @pings = []
+      @streams_to_close_after_receive = []
       @buffer = buffer
       @handshake_completed = false
       @wait_for_handshake = @settings.key?(:wait_for_handshake) ? @settings.delete(:wait_for_handshake) : true
@@ -52,7 +74,7 @@ module HTTPX
     end
 
     def interests
-      if @connection.state == :closed
+      if @connection.closed?
         return unless @handshake_completed
 
         return if @buffer.empty?
@@ -93,7 +115,7 @@ module HTTPX
     end
 
     def close
-      unless @connection.state == :closed
+      unless @connection.closed?
         @connection.goaway
         emit(:timeout, @options.timeout[:close_handshake_timeout])
       end
@@ -101,7 +123,7 @@ module HTTPX
     end
 
     def empty?
-      @connection.state == :closed || @streams.empty?
+      @connection.closed? || @streams.empty?
     end
 
     def exhausted?
@@ -110,6 +132,12 @@ module HTTPX
 
     def <<(data)
       @connection << data
+
+      while (stream, request, error = @streams_to_close_after_receive.shift)
+        # these streams were marked for cancellation due to errors found while processing the
+        # data received by the peer.
+        emit_stream_error(stream, request, error)
+      end
     end
 
     def send(request, head = false)
@@ -128,7 +156,7 @@ module HTTPX
     rescue ::HTTP2::Error::StreamLimitExceeded
       @pending.unshift(request)
       false
-    rescue StandardError => e
+    rescue ::HTTP2::Error::Error, ArgumentError => e
       emit(:error, request, e)
     end
 
@@ -141,18 +169,43 @@ module HTTPX
     end
 
     def handle_error(ex, request = nil)
-      if ex.is_a?(OperationTimeoutError) && !@handshake_completed && @connection.state != :closed
-        @connection.goaway(:settings_timeout, "closing due to settings timeout")
-        emit(:close_handshake)
-        settings_ex = SettingsTimeoutError.new(ex.timeout, ex.message)
-        settings_ex.set_backtrace(ex.backtrace)
-        ex = settings_ex
-      end
-      while (req, _ = @streams.shift)
+      last_stream_id = Float::INFINITY
+      case ex
+      when OperationTimeoutError
+        if !@handshake_completed && @connection.state != :closed
+          @connection.goaway(:settings_timeout, "closing due to settings timeout")
+          emit(:close_handshake)
+          settings_ex = SettingsTimeoutError.new(ex.timeout, ex.message)
+          settings_ex.set_backtrace(ex.backtrace)
+          ex = settings_ex
+        end
+      when GoawayError
+        last_stream_id = ex.last_stream_id
+      end
+
+      inflight_unprocessed_requests = [] #: Array[Request]
+
+      while (req, stream = @streams.shift)
         next if request && request == req
 
+        if stream.id > last_stream_id
+          req.transition(:idle)
+          # unprocessed request
+          inflight_unprocessed_requests << req
+
+          next
+        end
+
         emit(:error, req, ex)
       end
+
+      if ex.is_a?(GoawayError) && !ex.unrecoverable?
+        # resend unprocessed requests on a different connection
+        @pending.unshift(*inflight_unprocessed_requests) if inflight_unprocessed_requests.any?
+        emit(:exhausted, ex) if @pending.any?
+        return
+      end
+
       while (req = @pending.shift)
         next if request && request == req
 
@@ -333,6 +386,8 @@ module HTTPX
       @streams[request] = stream
 
       handle(request, stream) if request.expects?
+    rescue HTTPX::Error => e
+      @streams_to_close_after_receive << [stream, request, e]
     end
 
     def on_stream_trailers(stream, request, response, h)
@@ -345,7 +400,18 @@ module HTTPX
     def on_stream_data(stream, request, data)
       request.log(level: 1, color: :green) { "#{stream.id}: <- DATA: #{data.bytesize} bytes..." }
       request.log(level: 2, color: :green) { "#{stream.id}: <- #{log_redact_body(data.inspect)}" }
+
+      return unless request.response
+
       request.response << data
+    rescue HTTPX::Error => e
+      if stream.state == :closing
+        # there won't be any more chunks to process after this one.
+        emit_stream_error(stream, request, e)
+      else
+        # defer until the last chunk from the payload is processed.
+        @streams_to_close_after_receive << [stream, request, e]
+      end
     end
 
     def on_stream_refuse(stream, request, error)
@@ -374,18 +440,26 @@ module HTTPX
         when :http_1_1_required
           emit(:error, request, error)
         else
-          ex = Error.new(stream.id, error)
+          ex =
+            case error
+            when :refused_stream
+              RefusedStreamError.new(stream.id, error)
+            else
+              RstStreamError.new(stream.id, error)
+            end
+
           ex.set_backtrace(caller)
           response = ErrorResponse.new(request, ex)
           request.response = response
           emit(:response, request, response)
         end
       else
-        response = request.response
-        if response && response.is_a?(Response) && response.status == 421
-          emit(:error, request, :http_1_1_required)
-        else
-          emit(:response, request, response)
+        if (response = request.response)
+          if response.is_a?(Response) && response.status == 421
+            emit(:error, request, :http_1_1_required)
+          else
+            emit(:response, request, response)
+          end
         end
       end
       send(@pending.shift) unless @pending.empty?
@@ -410,8 +484,8 @@ module HTTPX
       send_pending
     end
 
-    def on_close(_last_frame, error, _payload)
-      is_connection_closed = @connection.state == :closed
+    def on_close(last_stream_id, error, _payload)
+      is_connection_closed = @connection.closed?
       if error
         @buffer.clear if is_connection_closed
         case error
@@ -420,12 +494,11 @@ module HTTPX
             emit(:error, request, error)
           end
         else
-          ex = GoawayError.new(error)
+          ex = GoawayError.new(error, last_stream_id)
           ex.set_backtrace(caller)
 
           handle_error(ex)
           teardown
-
         end
       end
       return unless is_connection_closed && @streams.empty?
@@ -509,6 +582,12 @@ module HTTPX
       emit(:pong)
     end
 
+    def emit_stream_error(stream, request, error)
+      teardown(request)
+      stream.close
+      emit(:error, request, error)
+    end
+
     def teardown(request = nil)
       if request
         @drains.delete(request)

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/connection.rb

@@ -36,21 +36,25 @@ module HTTPX
 
     def_delegator :@write_buffer, :empty?
 
-    attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session, :sibling
+    attr_reader :type, :io, :origin, :origins, :state, :pending, :options, :ssl_session, :sibling,
+                :read_buffer, :write_buffer
 
     attr_writer :current_selector
 
     attr_accessor :current_session, :family
 
-    protected :ssl_session, :sibling
+    protected :ssl_session, :sibling, :read_buffer, :write_buffer
 
     def initialize(uri, options)
       @current_session = @current_selector = @max_concurrent_requests =
                            @parser = @sibling = @coalesced_connection = @altsvc_connection =
-                                                  @ping_timer = @family = @io = @ssl_session =
-                                                                            @timeout = @connected_at = @response_received_at = nil
+                                                  @callbacks = @ping_timer = @family =
+                                                                 @io = @ssl_session = @timeout = @connected_at = @response_received_at = nil
 
-      @exhausted = @cloned = @main_sibling = false
+      @exhausted = @cloned = @main_sibling =
+                     # variable used to gate against a potential endless loop where the peer continuously closes the connection with
+                     # GOAWAY frames without ever processing a request.
+                     @previously_exhausted_with_error = false
 
       @options = Options.new(options)
       @type = initialize_type(uri, @options)
@@ -76,6 +80,29 @@ module HTTPX
       self.addresses = @options.addresses if @options.addresses
     end
 
+    # dupped initialization
+    def initialize_dup(orig)
+      super
+      @callbacks = @parser = @sibling = @coalesced_connection = @altsvc_connection = nil
+      @origins = orig.origins.dup
+      @read_buffer = orig.read_buffer.dup
+      @write_buffer = orig.write_buffer.dup
+      @inflight = 0
+      @pending = []
+      transition(:idle)
+
+      if @io
+        # initialize new IO object with the same set of addresses
+        addresses = @io.addresses
+        @io = nil
+        self.addresses = addresses
+      end
+
+      return unless @current_session && @current_selector
+
+      @current_session.pin(self, @current_selector)
+    end
+
     def peer
       @origin
     end
@@ -148,11 +175,11 @@ module HTTPX
 
     def merge(connection)
       @origins |= connection.instance_variable_get(:@origins)
-      if @ssl_session.nil? && connection.ssl_session
-        @ssl_session = connection.ssl_session
-        @io.session_new_cb do |sess|
-          @ssl_session = sess
-        end if @io
+      if @ssl_session.nil? && (ssl_session = connection.ssl_session)
+        @ssl_session = ssl_session
+        # the socket only needs the merged session if it can still resume it,
+        # i.e. if TLS hasn't been negotiated yet.
+        @io.ssl_session = ssl_session if @io.is_a?(SSL) && !@io.connected?
       end
       connection.purge_pending do |req|
         req.transition(:idle)
@@ -161,15 +188,17 @@ module HTTPX
     end
 
     def purge_pending(&block)
-      pendings = []
       if @parser
         pending = @parser.pending
         @inflight -= pending.size
-        pendings << pending
+        pending.reject! do |req|
+          block.call(req)
+          true
+        end
       end
-      pendings << @pending
-      pendings.each do |pending|
-        pending.reject!(&block)
+      @pending.reject! do |req|
+        block.call(req)
+        true
       end
     end
 
@@ -203,7 +232,7 @@ module HTTPX
       return @parser.interests if @parser
 
       nil
-    rescue StandardError => e
+    rescue Error => e
       on_error(e)
       nil
     end
@@ -215,6 +244,8 @@ module HTTPX
     def call
       case @state
       when :idle
+        return if no_more_requests?
+
         connect
 
         # when opening the tcp or ssl socket fails
@@ -222,7 +253,7 @@ module HTTPX
 
         consume
       when :closed
-        return if @pending.empty?
+        return if no_more_requests?
 
         # there are pending requests to send, restart the state machine.
         idling
@@ -247,10 +278,14 @@ module HTTPX
         consume
       end
       nil
-    rescue IOError => e
+    rescue Errno::ECONNRESET,
+           Errno::EINVAL,
+           SocketError,
+           IOError,
+           TLSError => e
       @write_buffer.clear
       on_io_error(e)
-    rescue StandardError => e
+    rescue Error => e
       @write_buffer.clear
       on_error(e)
     rescue Exception => e # rubocop:disable Lint/RescueException
@@ -258,6 +293,10 @@ module HTTPX
       raise e
     end
 
+    def initial_call
+      call
+    end
+
     def close
       transition(:active) if @state == :inactive
 
@@ -314,6 +353,11 @@ module HTTPX
       # (example: HTTP/1 parser disabling pipelining)
       return if @state == :idle && @pending.any?
 
+      if @ping_timer
+        @ping_timer.cancel
+        @ping_timer = nil
+      end
+
       parser = @parser
 
       if parser && parser.respond_to?(:max_concurrent_requests)
@@ -324,7 +368,6 @@ module HTTPX
       end
 
       transition(:closing)
-
       transition(:closed)
     end
 
@@ -433,6 +476,11 @@ module HTTPX
 
     def on_io_error(e)
       on_error(e)
+
+      # do not force close if parser resets the connection.
+      # can happen i.e. when HTTP/1.1 pipelining is disabled.
+      return if @state == :idle && @pending.any?
+
       force_close(true)
     end
 
@@ -456,7 +504,7 @@ module HTTPX
       reset
     end
 
-    # :nocov:
+    # simplecov:disable
     def inspect
       "#<#{self.class}:#{object_id} " \
         "@origin=#{@origin} " \
@@ -464,7 +512,7 @@ module HTTPX
         "@pending=#{@pending.size} " \
         "@io=#{@io}>"
     end
-    # :nocov:
+    # simplecov:enable
 
     private
 
@@ -490,7 +538,7 @@ module HTTPX
           # * the number of pending requests
           # * the number of inflight requests
           # * whether the write buffer has bytes (i.e. for close handshake)
-          if @pending.empty? && @inflight.zero? && @write_buffer.empty?
+          if no_more_requests? && @write_buffer.empty?
             no_more_requests_loop_check if @parser && @parser.pending.any?
 
             # terminate if an altsvc connection has been established
@@ -540,7 +588,7 @@ module HTTPX
             break if @state == :closing || @state == :closed
 
             # exit #consume altogether if all outstanding requests have been dealt with
-            if @pending.empty? && @inflight.zero? && @write_buffer.empty? # rubocop:disable Style/Next
+            if no_more_requests? && @write_buffer.empty? # rubocop:disable Style/Next
               no_more_requests_loop_check if @parser && @parser.pending.any?
 
               # terminate if an altsvc connection has been established
@@ -666,6 +714,7 @@ module HTTPX
         AltSvc.emit(request, response) do |alt_origin, origin, alt_params|
           build_altsvc_connection(alt_origin, origin, alt_params)
         end
+        @previously_exhausted_with_error = false
         @response_received_at = Utils.now
         @no_more_requests_counter = 0
         @inflight -= 1
@@ -681,9 +730,19 @@ module HTTPX
       parser.on(:promise) do |request, stream|
         request.emit(:promise, parser, stream)
       end
-      parser.on(:exhausted) do
+      parser.on(:exhausted) do |error|
         enqueue_pending_requests_from_parser(parser)
 
+        if error
+          if @previously_exhausted_with_error
+            @previously_exhausted_with_error = false
+            on_error(error)
+            next
+          else
+            @previously_exhausted_with_error = true
+          end
+        end
+
         @exhausted = true
         parser.close
 
@@ -753,14 +812,19 @@ module HTTPX
            Errno::ECONNRESET,
            Errno::EADDRNOTAVAIL,
            Errno::EHOSTUNREACH,
-           Errno::EINVAL,
            Errno::ENETUNREACH,
+           Errno::EHOSTDOWN,
+           Errno::ENETDOWN,
+           Errno::EINVAL,
            Errno::EPIPE,
            Errno::ENOENT,
            SocketError,
            IOError => e
       on_connect_error(e)
-    rescue TLSError, ::HTTP2::Error::ProtocolError, ::HTTP2::Error::HandshakeError => e
+    rescue TLSError,
+           Errno::ETIMEDOUT,
+           ::HTTP2::Error::ProtocolError,
+           ::HTTP2::Error::HandshakeError => e
       # connect errors, exit gracefully
       handle_error(e)
       handle_connect_error(e) if connecting?
@@ -957,9 +1021,12 @@ module HTTPX
 
       parser.ping
 
+      return unless parser.waiting_for_ping?
+
       ping_timeout = @options.timeout[:ping_timeout]
 
       @ping_timer = @current_selector.after(ping_timeout) do
+        log(level: 3) { "ping timeout expired..." }
         error = PingTimeoutError.new(ping_timeout, "Timed out after #{ping_timeout} seconds")
         on_error(error)
       end
@@ -986,6 +1053,11 @@ module HTTPX
                    "along with debug logs"
     end
 
+    # true when there are no more pending nor inflight (in parser) requests
+    def no_more_requests?
+      @pending.empty? && @inflight.zero?
+    end
+
     # recover internal state and emit all relevant error responses when +error+ was raised.
     # this takes an optiona +request+ which may have already been handled and can be opted out
     # in the state recovery process.
@@ -1099,13 +1171,14 @@ module HTTPX
         end
 
         timer = selector.after(timeout, callback)
-        request.active_timeouts << label
+        timer.label = label
+        request.active_timeouts << timer
 
         Array(finish_events).each do |event|
           # clean up request timeouts if the connection errors out
           request.set_timeout_callback(event) do
             timer.cancel
-            request.active_timeouts.delete(label)
+            request.active_timeouts.delete(timer)
           end
         end
       end

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/errors.rb

@@ -43,6 +43,9 @@ module HTTPX
     # The HTTPX::Request request object this exception refers to.
     attr_reader :request
 
+    # The response object this exception refers to.
+    attr_reader :response
+
     # initializes the exception with the +request+ and +response+ it refers to, and the
     # +timeout+ causing the error, and the
     def initialize(request, response, timeout)

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/headers.rb

@@ -140,12 +140,12 @@ module HTTPX
       @headers.to_s
     end
 
-    # :nocov:
+    # simplecov:disable
     def inspect
       "#<#{self.class}:#{object_id} " \
         "#{to_hash.inspect}>"
     end
-    # :nocov:
+    # simplecov:enable
 
     # this is internal API and doesn't abide to other public API
     # guarantees, like downcasing strings.