wreq 1.2.5-aarch64-linux → 1.2.7-aarch64-linux

data/lib/wreq_ruby/emulate.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# Profile and platform constants mirror the native enum variant names.
+# standard:disable Naming/ConstantName
+
 module Wreq
   # Browser and client fingerprint profile enumeration backed by Rust.
   #
@@ -164,6 +167,29 @@ module Wreq
       def to_s
       end
     end
+
+    unless method_defined?(:==)
+      # Value-based equality.
+      # @param other [Object]
+      # @return [Boolean]
+      def ==(other)
+      end
+    end
+
+    unless method_defined?(:eql?)
+      # Strict equality for Hash key and Set member semantics.
+      # @param other [Object]
+      # @return [Boolean]
+      def eql?(other)
+      end
+    end
+
+    unless method_defined?(:hash)
+      # Hash value consistent with {#eql?} for use as Hash keys.
+      # @return [Integer]
+      def hash
+      end
+    end
   end
 
   # Operating system platform enumeration backed by Rust.
@@ -195,6 +221,36 @@ module Wreq
       def to_s
       end
     end
+
+    unless method_defined?(:to_sym)
+      # Returns the platform as a lowercase symbol (e.g. :windows, :linux).
+      # @return [Symbol]
+      def to_sym
+      end
+    end
+
+    unless method_defined?(:==)
+      # Value-based equality.
+      # @param other [Object]
+      # @return [Boolean]
+      def ==(other)
+      end
+    end
+
+    unless method_defined?(:eql?)
+      # Strict equality for Hash key and Set member semantics.
+      # @param other [Object]
+      # @return [Boolean]
+      def eql?(other)
+      end
+    end
+
+    unless method_defined?(:hash)
+      # Hash value consistent with {#eql?} for use as Hash keys.
+      # @return [Integer]
+      def hash
+      end
+    end
   end
 
   # Emulation option wrapper.
@@ -216,19 +272,31 @@ module Wreq
   #
   # @param profile [Wreq::Profile, nil] Fingerprint profile to emulate
   # @param platform [Wreq::Platform, nil] Operating system platform to emulate
-  # @param http2 [Boolean] Whether HTTP/2 support is enabled
-  # @param headers [Boolean] Whether default emulation headers are enabled
+  # @param http2 [Boolean, nil] Whether HTTP/2 emulation is enabled; defaults
+  #   to true when omitted or nil
+  # @param headers [Boolean, nil] Whether default emulation headers are enabled;
+  #   defaults to true when omitted or nil
+  # @return [Wreq::Emulation] Configured emulation settings
+  # @raise [ArgumentError] if an option is unknown or extra arguments are given
+  # @raise [TypeError] if the option argument is not a Hash or a value has the
+  #   wrong Ruby type
   class Emulation
     # Native fields and methods are set by the extension.
     # This stub is for documentation only.
-    unless method_defined?(:new)
+    unless singleton_methods(false).include?(:new)
       # @param profile [Wreq::Profile, nil] Fingerprint profile to emulate
       # @param platform [Wreq::Platform, nil] Operating system platform to emulate
-      # @param http2 [Boolean] Whether HTTP/2 support is enabled
-      # @param headers [Boolean] Whether default emulation headers are enabled
+      # @param http2 [Boolean, nil] Whether HTTP/2 emulation is enabled; defaults
+      #   to true when omitted or nil
+      # @param headers [Boolean, nil] Whether default emulation headers are enabled;
+      #   defaults to true when omitted or nil
       # @return [Wreq::Emulation] Configured emulation settings
-      def self.new(profile: nil, platform: nil, http2: true, headers: true)
+      # @raise [ArgumentError] if an option is unknown or extra arguments are given
+      # @raise [TypeError] if an option or value has the wrong Ruby type
+      def self.new(**options)
       end
     end
   end
 end
+
+# standard:enable Naming/ConstantName

data/lib/wreq_ruby/error.rb

@@ -88,7 +88,7 @@ unless defined?(Wreq)
     #
     # @example
     #   begin
-    #     client = Wreq::Client.new(max_redirects: 3)
+    #     client = Wreq::Client.new(allow_redirects: true, max_redirects: 3)
     #     client.get("https://httpbin.io/redirect/10")
     #   rescue Wreq::RedirectError => e
     #     puts "Too many redirects: #{e.message}"
@@ -139,16 +139,14 @@ unless defined?(Wreq)
 
     # Configuration and builder errors
 
-    # Client configuration is invalid.
+    # A native client or request configuration could not be built.
     #
-    # Raised when the client is configured with invalid options.
+    # Raised when validated Ruby options cannot be represented by the native
+    # builder or request body.
     #
     # @example
     #   begin
-    #     client = Wreq::Client.new(
-    #       proxy: "invalid://proxy",
-    #       timeout: -1
-    #     )
+    #     client = Wreq::Client.new(proxy: "invalid://")
     #   rescue Wreq::BuilderError => e
     #     puts "Invalid configuration: #{e.message}"
     #   end

data/lib/wreq_ruby/http.rb

@@ -25,6 +25,43 @@ module Wreq
       TRACE = nil # @return [Wreq::Method] HTTP TRACE method
       PATCH = nil # @return [Wreq::Method] HTTP PATCH method
     end
+
+    # Returns the HTTP method token (e.g. "GET", "POST").
+    # @return [String]
+    unless method_defined?(:to_s)
+      def to_s
+      end
+    end
+
+    # Returns the HTTP method as a lowercase symbol (e.g. :get, :post).
+    # @return [Symbol]
+    unless method_defined?(:to_sym)
+      def to_sym
+      end
+    end
+
+    # Value-based equality. Returns true when both represent the same HTTP method.
+    # @param other [Object]
+    # @return [Boolean]    
+    unless method_defined?(:==)
+      def ==(other)
+      end
+    end
+
+    # Strict equality for Hash key and Set member semantics.
+    # @param other [Object]
+    # @return [Boolean]
+    unless method_defined?(:eql?)
+      def eql?(other)
+      end
+    end
+
+    # Hash value consistent with {#eql?} for use as Hash keys.
+    # @return [Integer]
+    unless method_defined?(:hash)
+      def hash
+      end
+    end
   end
 
   # HTTP version enumeration backed by Rust.
@@ -63,6 +100,21 @@ module Wreq
       def ==(other)
       end
     end
+
+    # Strict equality for Hash key and Set member semantics.
+    # @param other [Object]
+    # @return [Boolean]
+    unless method_defined?(:eql?)
+      def eql?(other)
+      end
+    end
+
+    # Hash value consistent with {#eql?} for use as Hash keys.
+    # @return [Integer]
+    unless method_defined?(:hash)
+      def hash
+      end
+    end
   end
 
   # HTTP status code wrapper.
@@ -141,6 +193,28 @@ module Wreq
       # @return [String] Status code as string
       def to_s
       end
+
+      # Returns the status code as an integer.
+      # @return [Integer] the numeric HTTP status code
+      def to_i
+      end
+
+      # Value-based equality. Only compares with other StatusCode instances.
+      # @param other [Object]
+      # @return [Boolean]
+      def ==(other)
+      end
+
+      # Strict equality for Hash key and Set member semantics.
+      # @param other [Object]
+      # @return [Boolean]
+      def eql?(other)
+      end
+
+      # Hash value consistent with {#eql?} for use as Hash keys.
+      # @return [Integer]
+      def hash
+      end
     end
   end
 end

data/lib/wreq_ruby/response.rb

@@ -127,6 +127,9 @@ unless defined?(Wreq)
 
       # Parse the response body as JSON.
       #
+      # Integral JSON numbers are returned as arbitrary-precision Ruby Integer
+      # values. Fractional and exponent-form numbers are returned as Float values.
+      #
       # @return [Object] Parsed JSON (Hash, Array, String, Integer, Float, Boolean, nil)
       # @raise [Wreq::DecodingError] if body is not valid JSON
       # @example

data/script/rust_env.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "fileutils"
+
+module Wreq
+  module RustEnv
+    WINDOWS_GNU_TARGET = "x86_64-pc-windows-gnu"
+    WINDOWS_RUBY_PLATFORM = "x64-mingw-ucrt"
+
+    # Uses the UCRT toolchain shipped with the active RubyInstaller installation.
+    def self.activate
+      unless RbConfig::CONFIG["host_os"].match?(/mingw|mswin/)
+        FileUtils.rm_f(cargo_config_path)
+        return
+      end
+
+      ruby_platform = RbConfig::CONFIG.fetch("arch")
+      unless ruby_platform == WINDOWS_RUBY_PLATFORM
+        raise "Unsupported Windows Ruby platform: #{ruby_platform}. " \
+          "Use RubyInstaller UCRT (#{WINDOWS_RUBY_PLATFORM})."
+      end
+
+      ruby_root = RbConfig::CONFIG.fetch("prefix")
+      msys_root = File.join(ruby_root, "msys64")
+      ucrt_bin = File.join(msys_root, "ucrt64", "bin")
+      msys_bin = File.join(msys_root, "usr", "bin")
+
+      validate_tools(ucrt_bin, msys_bin)
+      write_cargo_config(ucrt_bin, msys_bin)
+      ENV["CARGO_BUILD_TARGET"] = WINDOWS_GNU_TARGET
+      ENV["LIBCLANG_PATH"] = ucrt_bin
+      ENV.delete("CMAKE_GENERATOR")
+      ENV["PATH"] = [ucrt_bin, msys_bin, ENV.fetch("PATH", nil)].compact.join(File::PATH_SEPARATOR)
+    end
+
+    # Reports missing RubyInstaller packages before Cargo starts compiling.
+    def self.validate_tools(ucrt_bin, msys_bin)
+      required = %w[gcc.exe g++.exe gcc-ar.exe clang.exe libclang.dll cmake.exe]
+        .map { |tool| File.join(ucrt_bin, tool) }
+        .append(File.join(msys_bin, "make.exe"))
+      missing = required.reject { |tool| File.file?(tool) }
+      unless %w[pkgconf.exe pkg-config.exe].any? { |tool| File.file?(File.join(ucrt_bin, tool)) }
+        missing << File.join(ucrt_bin, "pkgconf.exe")
+      end
+      return if missing.empty?
+
+      raise "Missing RubyInstaller UCRT tools: #{missing.join(", ")}. " \
+        "Install the Windows build dependencies documented in " \
+        "docs/windows-gnu-tokio-crash.md."
+    end
+
+    # Generates machine-local Cargo defaults that work in command lines and IDEs.
+    def self.write_cargo_config(ucrt_bin, msys_bin)
+      config = <<~TOML
+        # Generated by script/rust_env.rb for the active RubyInstaller.
+
+        [build]
+        target = "#{WINDOWS_GNU_TARGET}"
+
+        [target.#{WINDOWS_GNU_TARGET}]
+        linker = "#{File.join(ucrt_bin, "gcc.exe")}"
+
+        [env]
+        CC_x86_64_pc_windows_gnu = { value = "#{File.join(ucrt_bin, "gcc.exe")}", force = true }
+        CXX_x86_64_pc_windows_gnu = { value = "#{File.join(ucrt_bin, "g++.exe")}", force = true }
+        AR_x86_64_pc_windows_gnu = { value = "#{File.join(ucrt_bin, "gcc-ar.exe")}", force = true }
+        CMAKE = { value = "#{File.join(ucrt_bin, "cmake.exe")}", force = true }
+        CMAKE_GENERATOR = { value = "MSYS Makefiles", force = true }
+        CMAKE_MAKE_PROGRAM = { value = "#{File.join(msys_bin, "make.exe")}", force = true }
+        LIBCLANG_PATH = { value = "#{ucrt_bin}", force = true }
+      TOML
+
+      return if File.exist?(cargo_config_path) && File.binread(cargo_config_path) == config
+
+      FileUtils.mkdir_p(File.dirname(cargo_config_path))
+      File.binwrite(cargo_config_path, config)
+    end
+
+    # Returns the ignored Cargo configuration shared by Rake and language servers.
+    def self.cargo_config_path
+      File.expand_path("../.cargo/windows.toml", __dir__)
+    end
+  end
+end

data/test/body_sender_test.rb

@@ -0,0 +1,246 @@
+require "test_helper"
+require "open3"
+require "rbconfig"
+require "socket"
+
+class BodySenderTest < Minitest::Test
+  def test_valid_capacity_creates_open_sender
+    sender = Wreq::BodySender.new(2)
+
+    refute_predicate sender, :closed?
+  ensure
+    sender&.close
+  end
+
+  def test_omitted_capacity_defaults_to_eight
+    sender = Wreq::BodySender.new
+    progress = Queue.new
+    producer = Thread.new do
+      9.times do |index|
+        sender.push(index.to_s)
+        progress << index
+      end
+      sender.close
+    end
+    producer.report_on_exception = false
+
+    assert wait_until { progress.size >= 8 }, "the default channel should buffer eight chunks"
+    assert_equal 8, progress.size
+    assert_predicate producer, :alive?, "the ninth push should wait for channel capacity"
+
+    with_request_body_server do |url, request_thread|
+      response = Wreq.post(url, body: sender)
+
+      assert_equal 200, response.code
+      assert producer.join(5), "the ninth push should finish once the request drains"
+      assert_equal "012345678", request_thread.value
+    end
+  ensure
+    producer&.kill if producer&.alive?
+    producer&.join(5)
+    sender&.close
+  end
+
+  def test_non_positive_and_excessive_capacities_raise_argument_error
+    [0, -1, 2**256].each do |capacity|
+      error = assert_raises(ArgumentError) { Wreq::BodySender.new(capacity) }
+      assert_match(/capacity/, error.message)
+    end
+  end
+
+  def test_non_integer_capacities_raise_type_error
+    [1.0, "not an integer"].each do |capacity|
+      error = assert_raises(TypeError) { Wreq::BodySender.new(capacity) }
+      assert_match(/capacity/, error.message)
+    end
+  end
+
+  def test_too_many_constructor_arguments_raise_argument_error
+    assert_raises(ArgumentError) { Wreq::BodySender.new(1, 2) }
+  end
+
+  def test_close_is_idempotent_and_updates_closed_state
+    sender = Wreq::BodySender.new
+
+    refute_predicate sender, :closed?
+    assert_nil sender.close
+    assert_predicate sender, :closed?
+    assert_nil sender.close
+  end
+
+  def test_push_after_close_raises_io_error
+    sender = Wreq::BodySender.new
+    sender.close
+
+    error = assert_raises(IOError) { sender.push("data") }
+    assert_equal "closed body sender", error.message
+  end
+
+  def test_queued_chunks_survive_close_before_request_attachment
+    sender = Wreq::BodySender.new(2)
+    sender.push("queued-")
+    sender.push("body")
+    sender.close
+
+    with_request_body_server do |url, request_thread|
+      response = Wreq.post(url, body: sender)
+
+      assert_equal 200, response.code
+      assert_equal "queued-body", request_thread.value
+    end
+  end
+
+  def test_valid_capacity_keeps_backpressure_until_request_drains
+    sender = Wreq::BodySender.new(1)
+    sender.push("first-")
+    producer = Thread.new do
+      sender.push("second")
+      sender.close
+    end
+    producer.report_on_exception = false
+
+    sleep 0.05
+    assert_predicate producer, :alive?, "the second push should wait for channel capacity"
+
+    with_request_body_server do |url, request_thread|
+      response = Wreq.post(url, body: sender)
+
+      assert_equal 200, response.code
+      assert producer.join(5), "the blocked producer should finish once the request drains"
+      assert_equal "first-second", request_thread.value
+    end
+  ensure
+    producer&.kill if producer&.alive?
+    producer&.join(5)
+    sender&.close
+  end
+
+  def test_receiver_termination_closes_sender
+    sender = Wreq::BodySender.new(1)
+    sender.push("data")
+
+    with_reset_server do |url|
+      assert_raises(StandardError) { Wreq.post(url, body: sender, timeout: 2) }
+    end
+
+    assert wait_until { sender.closed? }, "sender should close after the request drops its receiver"
+    assert_raises(IOError) { sender.push("more") }
+  ensure
+    sender&.close
+  end
+
+  def test_zero_capacity_regression_exits_subprocess_normally
+    lib_dir = File.expand_path("../lib", __dir__)
+    script = <<~RUBY
+      require "wreq"
+
+      begin
+        Wreq::BodySender.new(0)
+      rescue ArgumentError => error
+        warn "\#{error.class}: \#{error.message}"
+        exit 0
+      end
+
+      warn "zero capacity did not raise"
+      exit 2
+    RUBY
+
+    _stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-I", lib_dir, "-e", script)
+
+    assert status.success?, "subprocess failed with #{status.inspect}: #{stderr}"
+    assert_match(/ArgumentError:.*capacity/, stderr)
+    refute_match(/panicked|mpsc bounded channel/i, stderr)
+  end
+
+  private
+
+  def wait_until(timeout: 2)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+    loop do
+      return true if yield
+      return false if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+      sleep 0.01
+    end
+  end
+
+  def with_request_body_server
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    request_thread = Thread.new do
+      socket = server.accept
+      begin
+        socket.gets
+        headers = read_headers(socket)
+        body = read_request_body(socket, headers)
+        socket.write "HTTP/1.1 200 OK\r\n"
+        socket.write "Content-Length: 0\r\n"
+        socket.write "Connection: close\r\n\r\n"
+        body
+      ensure
+        socket.close unless socket.closed?
+      end
+    ensure
+      server.close unless server.closed?
+    end
+    request_thread.report_on_exception = false
+
+    yield "http://127.0.0.1:#{port}/", request_thread
+  ensure
+    server&.close unless server&.closed?
+    request_thread&.join(5)
+  end
+
+  def with_reset_server
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    thread = Thread.new do
+      socket = server.accept
+      socket.close
+    ensure
+      server.close unless server.closed?
+    end
+    thread.report_on_exception = false
+
+    yield "http://127.0.0.1:#{port}/"
+  ensure
+    server&.close unless server&.closed?
+    thread&.join(5)
+  end
+
+  def read_headers(socket)
+    headers = {}
+    while (line = socket.gets)
+      break if line == "\r\n"
+
+      name, value = line.split(":", 2)
+      headers[name.downcase] = value.strip
+    end
+    headers
+  end
+
+  def read_request_body(socket, headers)
+    if headers.fetch("transfer-encoding", "").downcase.include?("chunked")
+      read_chunked_body(socket)
+    else
+      socket.read(headers.fetch("content-length", "0").to_i)
+    end
+  end
+
+  def read_chunked_body(socket)
+    body = "".b
+    loop do
+      size_line = socket.gets or raise EOFError, "missing chunk size"
+      size = Integer(size_line.split(";", 2).first, 16)
+      break if size.zero?
+
+      body << socket.read(size)
+      raise IOError, "missing chunk terminator" unless socket.read(2) == "\r\n"
+    end
+
+    while (line = socket.gets)
+      break if line == "\r\n"
+    end
+    body
+  end
+end