wreq 1.2.5 → 1.2.7

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/src/arch.rs

@@ -4,6 +4,28 @@
 //! ABI boundaries, or OS APIs used by the Rust extension. Normal HTTP client
 //! behavior should stay in the client/runtime modules so platform workarounds
 //! do not leak into the rest of the binding.
+#![allow(unsafe_code)]
+
+/// Whether the native client exposes TCP user-timeout configuration.
+pub(crate) const SUPPORTS_TCP_USER_TIMEOUT: bool = cfg!(any(
+    target_os = "android",
+    target_os = "fuchsia",
+    target_os = "linux"
+));
+
+/// Whether the native client exposes network-interface binding.
+pub(crate) const SUPPORTS_INTERFACE: bool = cfg!(any(
+    target_os = "android",
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "solaris",
+    target_os = "tvos",
+    target_os = "visionos",
+    target_os = "watchos",
+));
 
 #[cfg(all(target_os = "windows", target_env = "gnu"))]
 mod windows_gnu {

data/src/client/body/form.rs

@@ -1,2 +1,4 @@
+//! Form request body conversion.
+
 /// Alias for form parameters.
 pub type Form = crate::client::param::Params;

data/src/client/body/json.rs

@@ -1,16 +1,49 @@
-use indexmap::IndexMap;
-use serde::{Deserialize, Serialize};
+//! JSON conversion at the Ruby request and response boundary.
+//!
+//! Request values are converted from Ruby into an owned [`Json`] tree before
+//! network I/O. Response bodies are deserialized into the same tree by wreq and
+//! then converted back into Ruby values.
+//!
+//! The underlying `serde_json` configuration preserves object insertion order
+//! and arbitrary-size integer tokens in both directions.
 
-/// Represents a JSON value for HTTP requests.
-/// Supports objects, arrays, numbers, strings, booleans, and null.
-#[derive(Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum Json {
-    Object(IndexMap<String, Json>),
-    Boolean(bool),
-    Number(isize),
-    Float(f64),
-    String(String),
-    Null(Option<isize>),
-    Array(Vec<Json>),
+use ::serde::{Deserialize, Serialize};
+use magnus::{Error, Ruby, TryConvert, Value};
+
+use crate::{error::json_serialization_error, serde::deserialize_json};
+
+/// An owned JSON tree shared by request and response conversion.
+///
+/// This wrapper keeps the configured `serde_json::Value` representation private
+/// so callers use the same precision and ordering behavior in both directions.
+#[derive(Deserialize, Serialize)]
+#[serde(transparent)]
+pub struct Json(serde_json::Value);
+
+/// Convert supported Ruby request values into an owned JSON tree.
+///
+/// Supported values are `Hash`, `Array`, `String`, `Symbol`, `Integer`, finite
+/// `Float`, booleans, and `nil`. Hash keys must be strings or symbols. Arrays
+/// and hashes are limited to 100 nesting levels, which also bounds cyclic input.
+/// Unsupported values are reported as `Wreq::BuilderError` before network I/O.
+impl TryConvert for Json {
+    fn try_convert(value: Value) -> Result<Self, Error> {
+        let ruby = Ruby::get_with(value);
+        deserialize_json(&ruby, value)
+            .map(Self)
+            .map_err(|error| json_serialization_error(&ruby, error))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Json;
+
+    #[test]
+    fn preserves_number_precision_and_object_order() {
+        let source = br#"{"second":115792089237316195423570985008687907853269984665640564039457584007913129639936,"first":1}"#;
+        let json: Json = serde_json::from_slice(source).unwrap();
+
+        assert_eq!(source, serde_json::to_vec(&json).unwrap().as_slice());
+    }
 }