alogram_payrisk 0.3.3 → 0.3.4

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.2.1 → http-2-1.2.3}/lib/http/2/settings.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module HTTP2
+  MAX_HEADER_LIST_SIZE = (2 << 30) - 1
+
   # Default values for SETTINGS frame, as defined by the spec.
   SPEC_DEFAULT_CONNECTION_SETTINGS = {
     settings_header_table_size: 4096,
@@ -8,32 +10,46 @@ module HTTP2
     settings_max_concurrent_streams: Framer::MAX_STREAM_ID, # unlimited
     settings_initial_window_size: 65_535,
     settings_max_frame_size: 16_384,
-    settings_max_header_list_size: (2 << 30) - 1 # unlimited
+    settings_max_header_list_size: MAX_HEADER_LIST_SIZE # unlimited
   }.freeze
 
+  ENCODING_CONTEXT_SETTINGS = %i[huffman index table_size].freeze
+
   Settings = Struct.new(
+    # connection settings
     :settings_header_table_size,
     :settings_enable_push,
     :settings_max_concurrent_streams,
     :settings_initial_window_size,
     :settings_max_frame_size,
     :settings_max_header_list_size,
+    # encoding context settings
+    :huffman,
+    :index,
+    :table_size,
     keyword_init: true
   ) do
     def initialize(
+      # connection settings
       settings_header_table_size: 4096,
       settings_enable_push: 1,
       settings_max_concurrent_streams: 100,
       settings_initial_window_size: 65_535,
       settings_max_frame_size: 16_384,
-      settings_max_header_list_size: (2 << 30) - 1
+      settings_max_header_list_size: MAX_HEADER_LIST_SIZE,
+      # encoding context settings
+      huffman: :shorter,
+      index: :all,
+      table_size: 4096
     )
       super
     end
 
-    def each_setting
+    def connection_settings
+      return enum_for(__method__) unless block_given?
+
       each_pair do |k, v|
-        next if v == SPEC_DEFAULT_CONNECTION_SETTINGS[k]
+        next if ENCODING_CONTEXT_SETTINGS.include?(k)
 
         yield k, v
       end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.2.1 → http-2-1.2.3}/lib/http/2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP2
-  VERSION = "1.2.1"
+  VERSION = "1.2.3"
 end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.2.1 → http-2-1.2.3}/lib/http/2.rb

@@ -13,6 +13,7 @@ require "http/2/emitter"
 require "http/2/flow_buffer"
 require "http/2/header"
 require "http/2/framer"
+require "http/2/settings"
 require "http/2/connection"
 require "http/2/client"
 require "http/2/server"

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.2.1 → http-2-1.2.3}/sig/2.rbs

@@ -11,23 +11,10 @@ module HTTP2
 
   type connection_opts = Hash[Symbol, untyped]
 
-  type settings_hash = {
-    settings_header_table_size: Integer,
-    settings_enable_push: Integer,
-    settings_max_concurrent_streams:  Integer,
-    settings_initial_window_size: Integer,
-    settings_max_frame_size: Integer,
-    settings_max_header_list_size: Integer
-  }
-
   type settings_ary = Array[settings_enum]
 
   type settings_enum = Enumerable[[Symbol, Integer]]
 
-  SPEC_DEFAULT_CONNECTION_SETTINGS: settings_hash
-
-  DEFAULT_CONNECTION_SETTINGS: settings_hash
-
   DEFAULT_WEIGHT: Integer
 
   CONNECTION_PREFACE_MAGIC: String
@@ -36,6 +23,12 @@ module HTTP2
 
   RESPONSE_MANDATORY_HEADERS: Array[String]
 
+  CONNECTION_FRAME_TYPES: Array[Symbol]
+
+  STREAM_OPEN_STATES: Array[Symbol]
+
+  HEADERS_FRAME_TYPES: Array[Symbol]
+
   # Frame flags
   END_STREAM: Integer
   ACK: Integer

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.2.1 → http-2-1.2.3}/sig/connection.rbs

@@ -4,16 +4,6 @@ module HTTP2
     include Emitter
     include BufferUtils
 
-    REQUEST_MANDATORY_HEADERS: Array[String]
-
-    RESPONSE_MANDATORY_HEADERS: Array[String]
-
-    CONNECTION_FRAME_TYPES: Array[Symbol]
-
-    HEADERS_FRAME_TYPES: Array[Symbol]
-
-    STREAM_OPEN_STATES: Array[Symbol]
-
     attr_reader state: Symbol
 
     attr_reader local_window: Integer
@@ -21,8 +11,8 @@ module HTTP2
 
     alias window local_window
 
-    attr_reader remote_settings: settings_hash
-    attr_reader local_settings: settings_hash
+    attr_reader remote_settings: Settings
+    attr_reader local_settings: Settings
     attr_reader pending_settings: settings_ary
 
     attr_accessor active_stream_count: Integer
@@ -59,6 +49,10 @@ module HTTP2
 
     def closed?: () -> bool
 
+    def closing?: () -> bool
+
+    def close!: () -> void
+
     def new_stream: (**untyped) -> Stream
 
     def ping: (String) -> void
@@ -83,7 +77,7 @@ module HTTP2
 
     def connection_frame?: (frame) -> bool
 
-    def connection_management: (connection_frame frame) -> void
+    def connection_management: (frame frame) -> void
 
     def ping_management: (frame) -> void
 
@@ -95,7 +89,7 @@ module HTTP2
 
     def encode_headers: (headers_frame | push_promise_frame) -> void
 
-    def activate_stream: (id: Integer, **untyped) -> Stream
+    def activate_stream: (id: Integer, ?max_concurrent_streams: Integer, **untyped) -> Stream
 
     def verify_stream_order: (Integer id) -> void
 

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.2.1 → http-2-1.2.3}/sig/header/compressor.rbs

@@ -18,7 +18,7 @@ module HTTP2
 
       private
 
-      def initialize: (?connection_opts options) -> void
+      def initialize: (?Settings settings) -> void
 
       def huffman_string: (String str, ?String buffer) -> String
 

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.2.1 → http-2-1.2.3}/sig/header/decompressor.rbs

@@ -19,7 +19,7 @@ module HTTP2
                 | (String) -> Array[header_pair]
       private
 
-      def initialize: (?connection_opts options) -> void
+      def initialize: (?Settings settings) -> void
     end
   end
 end

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.2.1 → http-2-1.2.3}/sig/header/encoding_context.rbs

@@ -11,14 +11,12 @@ module HTTP2
 
       STATIC_NEVER: Array[Symbol]
 
-      DEFAULT_OPTIONS: context_hash
-
       UPPER: Regexp
 
 
       attr_reader table: Array[header_pair]
 
-      attr_reader options: context_hash
+      attr_reader settings: Settings
 
       attr_reader current_table_size: Integer
 
@@ -46,7 +44,7 @@ module HTTP2
 
       private
 
-      def initialize: (?connection_opts options) -> void
+      def initialize: (?Settings settings) -> void
 
       def add_to_table: (string name, string value) -> void
 

data/vendor/bundle/ruby/3.3.0/gems/{http-2-1.2.1 → http-2-1.2.3}/sig/server.rbs

@@ -1,5 +1,7 @@
 module HTTP2
   class Server < Connection
+    @origin_set: Array[String]
+    @origins_sent: bool
 
     def upgrade: (String settings, Enumerable[header_pair] headers, String body) -> void
 

data/vendor/bundle/ruby/3.3.0/gems/http-2-1.2.3/sig/settings.rbs

@@ -0,0 +1,71 @@
+module HTTP2
+  MAX_HEADER_LIST_SIZE: Integer
+
+  SPEC_DEFAULT_CONNECTION_SETTINGS: Hash[Symbol, Integer]
+
+  ENCODING_CONTEXT_SETTINGS: Array[Symbol]
+
+  type huffman_type = :always | :never | :shorter
+
+  type index_type = :all | :static | :never
+
+  # Container for all settings required for the management of an HTTP/2 connection. This
+  # includes the managemenet of the settings negotiated via the SETTINGS frame, as well as
+  # user-level configuration related with header compression.
+  class Settings # this is actually a Struct, but RBS does not support it yet
+    # connection settings (send and received in the SETTINGS frame)
+
+    # maximum size of the header compression table used to decode header blocks, in bytes.
+    attr_reader settings_header_table_size: Integer
+
+    # can be used to disable server push (set to 0)
+    attr_reader settings_enable_push: Integer
+
+    # maximum number of concurrent streams that the sender will allow.
+    attr_reader settings_max_concurrent_streams: Integer
+
+    # initial window size (in bytes) for stream-level flow control.
+    attr_reader settings_initial_window_size: Integer
+
+    # max size of for payload that the sender is willing to receive, in bytes.
+    attr_reader settings_max_frame_size: Integer
+    attr_reader settings_max_header_list_size: Integer
+
+    # encoding context settings
+
+    # controls how to use huffman encoding to encode strings. can be one of the following values:
+    #
+    # * `:always` - Always use Huffman encoding
+    # * `:never` - Do not use Huffman encoding
+    # * `:shorter` - Use Huffman when the result is strictly shorter
+    attr_reader huffman: huffman_type
+
+    # controls the configuration of the HPACK indexing tables:
+    #
+    # * `:static` - use the static table only
+    # * `:all` - use the static table and the dynamic table
+    # * `:never` - do not use any of the tables.
+    attr_reader index: index_type
+
+    # maximum dynamic table size in bytes
+    attr_reader table_size: Integer
+
+    def initialize: (
+      # connection settings
+      ?settings_header_table_size: Integer,
+      ?settings_enable_push: Integer,
+      ?settings_max_concurrent_streams: Integer,
+      ?settings_initial_window_size: Integer,
+      ?settings_max_frame_size: Integer,
+      ?settings_max_header_list_size: Integer,
+      # encoding context settings
+      ?huffman: huffman_type,
+      ?index: index_type,
+      ?table_size: Integer
+    ) -> void
+
+    # yields connection-level settings only.
+    def connection_settings: () { (Symbol, Integer) -> void } -> self
+                           | () -> Enumerable[[Symbol, Integer]]
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.8.4/doc/release_notes/1_8_2.md

@@ -0,0 +1,30 @@
+# 1.8.2
+
+## Improvements
+
+* `:proxy` plugin: allow setting `:no_proxy` option to `"*"` (or `["*"]`) to allow bypassing proxy for all requests.
+* Extending sessions with unknown options will now raise an error, instead of silently ignoring them (consistent with the initialization case now):
+
+```ruby
+session = HTTPX.with(unknown_option: 1) # will raise a HTTPX::Error: unknown option: unknown_option
+```
+
+* Use `HTTP2::Connection#closed?` internally (instead of `#state`) to check for connection state; this will, in a future release of `http-2`, seamlessly support the new `:closing` state.
+* Add missing `response` attribute reader to `HTTPX::RequestTimeoutError`.
+* Improve correctness of calling `#dup` on requests and connections.
+
+## Bugfixes
+
+* `:auth` plugin: generate token first, then set the "expires_at" timestamp (bearer tokens, specially if JWT, may carry information about when it expires).
+* `:auth` plugin: do not check for token freshness on a retry, instead force token regeneration.
+* `:retries` plugin: do not apply "retry after" delay after a ping timeout error (the ping timeout already implies a delay, so retry on a new connection should be immediate).
+* `:retries` plugin: do not retry on any HTTP/2 frame error (only on GOAWAY or PING frame errors).
+* `:persistent` plugin: do not decrement request remaining retries on ping or GOAWAY frame errors.
+* `:tracing` plugin: set connection initialization time to nil no termination (so that it doesn't get reused on persistent connections after reuse).
+* `:follow_redirects` plugin: fixed issue when a timeout error would be raised but only bubble up to the root request, not properly closing the in-flight follow up request, and leaving the request handling phase in a broken state.
+* datadog adapter: the connection initialization time is now set only on connect or first request received, the reason, making it more accurate.
+* webmock adapter: `.to_timeout` helper will make the request raise a `HTTPX::RequestTimeoutError` instead of a plain `TimeoutError` (otherwise, if using persistent sessions, it'd trigger a retry instead and mess with webmock request count bookkeeping).
+* native resolver: do not transition to `:open` if the socket was closed during resolution (which happens when an error is raised while the query bytes are buffered).
+* fix for when setting a new session callback on an ssl context object which has been frozen after the first connection attempt (done by binding the ssl context callback to an internal ivar which can be changed).
+* connection: protect against `Errno::ETIMEDOUT` errors on socket close by forcing transition to closed.
+* do not set a ping timer for HTTP/1.1 on keep alive flow, as there's no ping and the connection is reestablished.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.8.4/doc/release_notes/1_8_3.md

@@ -0,0 +1,9 @@
+# 1.8.3
+
+## Bugfixes
+
+options print a  warning instead of raising an error on unknown option
+
+the approach introduced in the previous version, of erroring on something people have been accidentally relying on, is too strict in hindsight for a patch version. This was reverted, and instead, a deprecation warning will be printed, to give time for folks to migrate.
+
+the format of options messages (exceptions and warnings) also slightly changes to wrap the option in quotes, for proper highlighting.

data/vendor/bundle/ruby/3.3.0/gems/httpx-1.8.4/doc/release_notes/1_8_4.md

@@ -0,0 +1,13 @@
+# 1.8.4
+
+## Improvements
+
+* send requests which were not sent, or were not processed by the server, when the server sends back a GOAWAY frame (which is deemed recoverable, like when there's no error), after forcing a reconnection (instead of bubbling up the GOAWAY error for all of them).
+
+## Bugfixes
+
+* `:retries` plugin: also retry requests which failed due to a RST_STREAM frame with REFUSED_STREAM error code.
+* `:retries` plugin: resend requests which were piped to a closed connection internally.
+* `:proxy` plugin: fix issue related with reconnecting inactive connections shut down by the peer, when used with the `:persistent` plugin, where the CONNECT request wasn't being sent to establish the tunnel.
+* fixed compatibility issue starting with the `json` gem 3.0.0, when calling `HTTPX::Response#json`.
+* avoid bookkepping issue in session, where the `on_response_arrived` on a request may be called more than once (which it can happen in the `:follow_redirects` plugin, where a request may have completed due to an error, while the request is waiting to be resent due to `retry-after`).

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.1 → httpx-1.8.4}/lib/httpx/adapters/webmock.rb

@@ -34,7 +34,8 @@ module WebMock
         end
 
         def build_from_webmock_response(request, webmock_response)
-          return build_error_response(request, HTTPX::TimeoutError.new(1, "Timed out")) if webmock_response.should_timeout
+          return build_error_response(request,
+                                      HTTPX::RequestTimeoutError.new(request, webmock_response, 1)) if webmock_response.should_timeout
 
           return build_error_response(request, webmock_response.exception) if webmock_response.exception
 

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.1 → 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.1 → 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.1 → 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.1 → 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
 

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

@@ -23,14 +23,35 @@ 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 = []
@@ -53,7 +74,7 @@ module HTTPX
     end
 
     def interests
-      if @connection.state == :closed
+      if @connection.closed?
         return unless @handshake_completed
 
         return if @buffer.empty?
@@ -94,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
@@ -102,7 +123,7 @@ module HTTPX
     end
 
     def empty?
-      @connection.state == :closed || @streams.empty?
+      @connection.closed? || @streams.empty?
     end
 
     def exhausted?
@@ -148,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
 
@@ -394,7 +440,14 @@ 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
@@ -431,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
@@ -441,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?