cybrid_api_id_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/server_sent_events.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin implements convenience methods for Server Sent Events streams.
+    #
+    # https://gitlab.com/os85/httpx/wikis/Server-Sent-Events
+    #
+    module ServerSentEvents
+      Message = if RUBY_VERSION >= "3.2.0" # rubocop:disable Naming/ConstantName
+        Data.define(:data, :event, :id, :retry_after) do
+          def initialize(event: nil, id: nil, retry_after: nil, **kwargs)
+            super
+          end
+        end
+      else
+        Struct.new(:data, :event, :id, :retry_after, keyword_init: true)
+      end
+
+      class << self
+        def subplugins
+          {
+            retries: ServerSentEventsRetries,
+          }
+        end
+
+        def load_dependencies(klass)
+          klass.plugin(:stream)
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :event_stream :: whether the request is a server-sent events text event stream (defaults to <tt>false</tt>).
+      module OptionsMethods
+        def option_event_stream(val)
+          val
+        end
+      end
+
+      module InstanceMethods
+        def request(*, **options)
+          options[:stream] = true if options[:event_stream]
+
+          super
+        end
+
+        def build_request(*)
+          super.tap do |request|
+            if request.options.event_stream
+              request.headers["accept"] = "text/event-stream"
+              request.headers["cache-control"] = "no-cache"
+            end
+          end
+        end
+      end
+
+      module RequestMethods
+        attr_accessor :last_server_sent_message
+
+        def initialize(*)
+          super
+
+          @last_server_sent_message = nil
+        end
+      end
+
+      module StreamResponseMethods
+        # yields each event Message as the server emits them.
+        def each_message(&block)
+          return enum_for(__method__) unless block
+
+          payload = {}
+
+          each_line do |line|
+            if line.empty?
+              if payload[:comment]
+                payload.clear
+                next
+              end
+
+              next if payload.empty?
+
+              message = Message.new(**payload)
+
+              payload.clear
+
+              @request.last_server_sent_message = message
+
+              yield message
+            else
+              type, value = line.split(": ", 2)
+
+              case type
+              when "data"
+                type = type.to_sym
+                if payload.key?(type)
+                  payload[type] << "\n" << value
+                else
+                  payload[type] = value
+                end
+              when "id", "event", "retry"
+                type = type.to_sym
+                raise_format_error(line) if payload.key?(type) || value.empty?
+
+                type = :retry_after if type == :retry # avoid using keyword
+
+                payload[type] = value
+              else
+                # skip if it's a comment
+                if line.start_with?(":")
+                  payload[:comment] = true
+                  next
+                end
+
+                raise_format_error(line)
+              end
+            end
+          end
+        end
+
+        private
+
+        def raise_format_error(line)
+          raise Error, "'#{line}': invalid or unsupported event stream format"
+        end
+      end
+
+      module ServerSentEventsRetries
+        module InstanceMethods
+          private
+
+          def prepare_to_retry(request, *)
+            super
+
+            last_message = request.last_server_sent_message
+
+            return unless last_message && last_message.id
+
+            request.headers["last-event-id"] = last_message.id
+          ensure
+            request.last_server_sent_message = nil
+          end
+
+          def when_to_retry(request, *)
+            retry_after = request.last_server_sent_message&.retry_after
+
+            retry_after.to_i / 1_000.0 if retry_after # original in milliseconds
+
+            request.last_server_sent_message&.retry_after && super
+          end
+        end
+      end
+    end
+    register_plugin(:server_sent_events, ServerSentEvents)
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/ssrf_filter.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module HTTPX
+  class ServerSideRequestForgeryError < Error; end
+
+  module Plugins
+    #
+    # This plugin adds support for preventing Server-Side Request Forgery attacks.
+    #
+    # https://gitlab.com/os85/httpx/wikis/Server-Side-Request-Forgery-Filter
+    #
+    module SsrfFilter
+      module IPAddrExtensions
+        refine IPAddr do
+          def prefixlen
+            mask_addr = @mask_addr
+            raise "Invalid mask" if mask_addr.zero?
+
+            mask_addr >>= 1 while mask_addr.nobits?(0x1)
+
+            length = 0
+            while mask_addr & 0x1 == 0x1
+              length += 1
+              mask_addr >>= 1
+            end
+
+            length
+          end
+        end
+      end
+
+      using IPAddrExtensions
+
+      # https://en.wikipedia.org/wiki/Reserved_IP_addresses
+      IPV4_BLACKLIST = [
+        IPAddr.new("0.0.0.0/8"), # Current network (only valid as source address)
+        IPAddr.new("10.0.0.0/8"), # Private network
+        IPAddr.new("100.64.0.0/10"), # Shared Address Space
+        IPAddr.new("127.0.0.0/8"), # Loopback
+        IPAddr.new("169.254.0.0/16"), # Link-local
+        IPAddr.new("172.16.0.0/12"), # Private network
+        IPAddr.new("192.0.0.0/24"), # IETF Protocol Assignments
+        IPAddr.new("192.0.2.0/24"), # TEST-NET-1, documentation and examples
+        IPAddr.new("192.88.99.0/24"), # IPv6 to IPv4 relay (includes 2002::/16)
+        IPAddr.new("192.168.0.0/16"), # Private network
+        IPAddr.new("198.18.0.0/15"), # Network benchmark tests
+        IPAddr.new("198.51.100.0/24"), # TEST-NET-2, documentation and examples
+        IPAddr.new("203.0.113.0/24"), # TEST-NET-3, documentation and examples
+        IPAddr.new("224.0.0.0/4"), # IP multicast (former Class D network)
+        IPAddr.new("240.0.0.0/4"), # Reserved (former Class E network)
+        IPAddr.new("255.255.255.255"), # Broadcast
+      ].freeze
+
+      IPV6_BLACKLIST = ([
+        IPAddr.new("::1/128"), # Loopback
+        IPAddr.new("64:ff9b::/96"), # IPv4/IPv6 translation (RFC 6052)
+        IPAddr.new("100::/64"), # Discard prefix (RFC 6666)
+        IPAddr.new("2001::/32"), # Teredo tunneling
+        IPAddr.new("2001:10::/28"), # Deprecated (previously ORCHID)
+        IPAddr.new("2001:20::/28"), # ORCHIDv2
+        IPAddr.new("2001:db8::/32"), # Addresses used in documentation and example source code
+        IPAddr.new("2002::/16"), # 6to4
+        IPAddr.new("fc00::/7"), # Unique local address
+        IPAddr.new("fe80::/10"), # Link-local address
+        IPAddr.new("ff00::/8"), # Multicast
+      ] + IPV4_BLACKLIST.flat_map do |ipaddr|
+        prefixlen = ipaddr.prefixlen
+
+        ipv4_compatible = ipaddr.ipv4_compat.mask(96 + prefixlen)
+        ipv4_mapped = ipaddr.ipv4_mapped.mask(80 + prefixlen)
+
+        [ipv4_compatible, ipv4_mapped]
+      end).freeze
+
+      class << self
+        def extra_options(options)
+          options.merge(allowed_schemes: %w[https http])
+        end
+
+        def unsafe_ip_address?(ipaddr)
+          range = ipaddr.to_range
+          return true if range.first != range.last
+
+          return IPV6_BLACKLIST.any? { |r| r.include?(ipaddr) } if ipaddr.ipv6?
+
+          IPV4_BLACKLIST.any? { |r| r.include?(ipaddr) } # then it's IPv4
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :allowed_schemes :: list of URI schemes allowed (defaults to <tt>["https", "http"]</tt>)
+      # :extra_unsafe_ranges :: A list of IP ranges (or addresses) that will be filtered, in addition to the defaults
+      # :safe_private_ranges :: A list of IP ranges (or addresses) that will not be filtered, even if they'd be filtered by default
+      module OptionsMethods
+        private
+
+        def option_allowed_schemes(value)
+          Array(value)
+        end
+
+        def option_extra_unsafe_ranges(value)
+          Array(value).map { |v| v.is_a?(IPAddr) ? v : IPAddr.new(v) }
+        end
+
+        def option_safe_private_ranges(value)
+          Array(value).map { |v| v.is_a?(IPAddr) ? v : IPAddr.new(v) }
+        end
+      end
+
+      module InstanceMethods
+        def send_requests(*requests)
+          responses = requests.map do |request|
+            next if @options.allowed_schemes.include?(request.uri.scheme)
+
+            error = ServerSideRequestForgeryError.new("#{request.uri} URI scheme not allowed")
+            error.set_backtrace(caller)
+            response = ErrorResponse.new(request, error)
+            request.response = response
+            request.emit_response(response)
+            response
+          end
+          allowed_requests = requests.select { |req| responses[requests.index(req)].nil? }
+          allowed_responses = super(*allowed_requests)
+          allowed_responses.each_with_index do |res, idx|
+            req = allowed_requests[idx]
+            responses[requests.index(req)] = res
+          end
+
+          responses
+        end
+      end
+
+      module ConnectionMethods
+        def initialize(*)
+          begin
+            super
+          rescue ServerSideRequestForgeryError => e
+            # may raise when IPs are passed as options via :addresses
+            throw(:resolve_error, e)
+          end
+        end
+
+        def addresses=(addrs)
+          addrs.reject! do |ipaddr|
+            ipaddr = ipaddr.address
+            next false if @options.safe_private_ranges&.any? { |r| r.include?(ipaddr) }
+
+            SsrfFilter.unsafe_ip_address?(ipaddr) || @options.extra_unsafe_ranges&.any? { |r| r.include?(ipaddr) }
+          end
+
+          raise ServerSideRequestForgeryError, "#{@origin.host} has no allowed IP addresses" if addrs.empty?
+
+          super
+        end
+      end
+    end
+
+    register_plugin :ssrf_filter, SsrfFilter
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/stream.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module HTTPX
+  class StreamResponse
+    attr_reader :request
+
+    def initialize(request, session)
+      @request = request
+      @options = @request.options
+      @session = session
+      @response_enum = nil
+      @buffered_chunks = []
+    end
+
+    def each(&block)
+      return enum_for(__method__) unless block
+
+      if (response_enum = @response_enum)
+        @response_enum = nil
+        # streaming already started, let's finish it
+
+        while (chunk = @buffered_chunks.shift)
+          block.call(chunk)
+        end
+
+        # consume enum til the end
+        begin
+          while (chunk = response_enum.next)
+            block.call(chunk)
+          end
+        rescue StopIteration
+          return
+        end
+      end
+
+      @request.stream = self
+
+      begin
+        @on_chunk = block
+
+        response = @session.request(@request)
+
+        response.raise_for_status
+      ensure
+        @on_chunk = nil
+      end
+    end
+
+    def each_line(&block)
+      return enum_for(__method__) unless block
+
+      line = "".b
+
+      each do |chunk|
+        line << chunk
+
+        while (idx = line.index("\n"))
+          if idx.zero?
+            yield ""
+          else
+            yield line.byteslice(0..(idx - 1))
+          end
+
+          line = line.byteslice((idx + 1)..-1)
+        end
+      end
+
+      yield line unless line.empty?
+    end
+
+    # This is a ghost method. It's to be used ONLY internally, when processing streams
+    def on_chunk(chunk)
+      raise NoMethodError unless @on_chunk
+
+      @on_chunk.call(chunk)
+    end
+
+    # simplecov:disable
+    def inspect
+      "#<#{self.class}:#{object_id}>"
+    end
+    # simplecov:enable
+
+    def to_s
+      if @request.response
+        @request.response.to_s
+      else
+        @buffered_chunks.join
+      end
+    end
+
+    private
+
+    def response
+      @request.response || begin
+        response_enum = each
+        while (chunk = response_enum.next)
+          @buffered_chunks << chunk
+          break if @request.response
+        end
+        @response_enum = response_enum
+        @request.response
+      end
+    end
+
+    def respond_to_missing?(meth, include_private)
+      if (response = @request.response)
+        response.respond_to_missing?(meth, include_private)
+      else
+        @options.response_class.method_defined?(meth) || (include_private && @options.response_class.private_method_defined?(meth))
+      end || super
+    end
+
+    def method_missing(meth, ...)
+      return super unless response.respond_to?(meth)
+
+      response.__send__(meth, ...)
+    end
+  end
+
+  module Plugins
+    #
+    # This plugin adds support for streaming a response (useful for i.e. "text/event-stream" payloads).
+    #
+    # https://gitlab.com/os85/httpx/wikis/Stream
+    #
+    module Stream
+      STREAM_REQUEST_OPTIONS = { timeout: { read_timeout: Float::INFINITY, operation_timeout: 60 }.freeze }.freeze
+
+      def self.extra_options(options)
+        options.merge(
+          stream: false,
+          timeout: { read_timeout: Float::INFINITY, operation_timeout: 60 },
+          stream_response_class: Class.new(StreamResponse, &Options::SET_TEMPORARY_NAME).freeze
+        )
+      end
+
+      # adds support for the following options:
+      #
+      # :stream :: whether the request to process should be handled as a stream (defaults to <tt>false</tt>).
+      # :stream_response_class :: Class used to build the stream response object.
+      module OptionsMethods
+        def option_stream(val)
+          val
+        end
+
+        def option_stream_response_class(value)
+          value
+        end
+
+        def extend_with_plugin_classes(pl)
+          return super unless defined?(pl::StreamResponseMethods)
+
+          @stream_response_class = @stream_response_class.dup
+          Options::SET_TEMPORARY_NAME[@stream_response_class, pl]
+          @stream_response_class.__send__(:include, pl::StreamResponseMethods) if defined?(pl::StreamResponseMethods)
+
+          super
+        end
+      end
+
+      module InstanceMethods
+        def request(*args, **options)
+          if args.first.is_a?(Request)
+            requests = args
+
+            request = requests.first
+
+            unless request.options.stream && !request.stream
+              if options[:stream]
+                warn "passing `stream: true` with a request object is not supported anymore. " \
+                     "You can instead build the request object with `stream :true`"
+              end
+              return super
+            end
+          else
+            return super unless options[:stream]
+
+            requests = build_requests(*args, options)
+
+            request = requests.first
+          end
+
+          raise Error, "only 1 response at a time is supported for streaming requests" unless requests.size == 1
+
+          @options.stream_response_class.new(request, self)
+        end
+
+        def build_request(verb, uri, params = EMPTY_HASH, options = @options)
+          return super unless params[:stream]
+
+          super(verb, uri, params, options.merge(STREAM_REQUEST_OPTIONS.merge(stream: true)))
+        end
+      end
+
+      module RequestMethods
+        attr_accessor :stream
+      end
+
+      module ResponseMethods
+        def stream
+          request = @request.root_request if @request.respond_to?(:root_request)
+          request ||= @request
+
+          request.stream
+        end
+      end
+
+      module ResponseBodyMethods
+        def initialize(*)
+          super
+          @stream = @response.stream
+        end
+
+        def write(chunk)
+          return super unless @stream
+
+          return 0 if chunk.empty?
+
+          chunk = decode_chunk(chunk)
+
+          @stream.on_chunk(chunk.dup)
+
+          chunk.bytesize
+        end
+
+        private
+
+        def transition(*)
+          return if @stream
+
+          super
+        end
+      end
+    end
+    register_plugin :stream, Stream
+  end
+end