wreq 1.2.2 → 1.2.3

data/script/build_windows_gnu.ps1

@@ -0,0 +1,257 @@
+param(
+    [switch]$SkipBundleInstall,
+    [switch]$SkipToolInstall,
+    [switch]$BuildGem,
+    [switch]$TestGem,
+    [switch]$RunTests,
+    [string]$SmokeUrl = $env:WREQ_SMOKE_URL
+)
+
+$ErrorActionPreference = "Stop"
+
+$target = "x86_64-pc-windows-gnu"
+$platform = "x64-mingw-ucrt"
+$gemPattern = "pkg\wreq-*-$platform.gem"
+if ([string]::IsNullOrWhiteSpace($SmokeUrl)) {
+    $SmokeUrl = "https://httpbin.io/get"
+}
+$rubyRoot = Split-Path (Split-Path (Get-Command ruby).Source -Parent) -Parent
+$ucrt = Join-Path $rubyRoot "msys64\ucrt64"
+$ucrtBin = Join-Path $ucrt "bin"
+$msysPackages = @(
+    "mingw-w64-ucrt-x86_64-gcc",
+    "mingw-w64-ucrt-x86_64-clang",
+    "mingw-w64-ucrt-x86_64-cmake",
+    "mingw-w64-ucrt-x86_64-pkgconf"
+)
+
+function Invoke-Step {
+    param(
+        [string]$Name,
+        [scriptblock]$Command
+    )
+
+    Write-Host "==> $Name"
+    & $Command
+}
+
+function Get-MissingUcrtTools {
+    $missing = @()
+
+    if (-not (Test-Path (Join-Path $ucrtBin "gcc.exe")) -or -not (Test-Path (Join-Path $ucrtBin "g++.exe"))) {
+        $missing += "gcc/g++"
+    }
+
+    if (-not (Test-Path (Join-Path $ucrtBin "clang.exe")) -or -not (Test-Path (Join-Path $ucrtBin "libclang.dll"))) {
+        $missing += "clang/libclang"
+    }
+
+    if (-not (Test-Path (Join-Path $ucrtBin "cmake.exe"))) {
+        $missing += "cmake"
+    }
+
+    if (-not (Test-Path (Join-Path $ucrtBin "pkgconf.exe")) -and -not (Test-Path (Join-Path $ucrtBin "pkg-config.exe"))) {
+        $missing += "pkgconf"
+    }
+
+    $missing
+}
+
+function Get-LatestPlatformGem {
+    $gem = Get-ChildItem -Path $gemPattern -ErrorAction SilentlyContinue |
+        Sort-Object LastWriteTime -Descending |
+        Select-Object -First 1
+
+    if (-not $gem) {
+        throw "No Windows GNU platform gem found at '$gemPattern'. Re-run with -BuildGem first."
+    }
+
+    $gem
+}
+
+function Invoke-RubySmoke {
+    param(
+        [string]$Name,
+        [string]$Code
+    )
+
+    Write-Host "Smoke: $Name"
+    ruby -e $Code
+    if ($LASTEXITCODE -ne 0) {
+        throw "$Name failed with exit code $LASTEXITCODE."
+    }
+}
+
+Invoke-Step "Check Ruby platform" {
+    $rubyArch = & ruby -rrbconfig -e "print RbConfig::CONFIG['arch']"
+    if ($rubyArch -ne $platform) {
+        throw "Expected Ruby platform '$platform', got '$rubyArch'. Use RubyInstaller UCRT for this build."
+    }
+
+    ruby -v
+    ruby -rrbconfig -rrubygems -e "puts RbConfig::CONFIG.values_at('arch', 'host', 'CC').join(%q{ }); puts Gem::Platform.local"
+}
+
+Invoke-Step "Install Rust target" {
+    $installedTargets = @(rustup target list --installed)
+    if ($installedTargets -contains $target) {
+        Write-Host "Rust target $target already installed; skipping rustup."
+        return
+    }
+
+    rustup target add $target
+    if ($LASTEXITCODE -ne 0) {
+        throw "Failed to install Rust target $target."
+    }
+}
+
+Invoke-Step "Check MSYS2 UCRT build tools" {
+    $missing = @(Get-MissingUcrtTools)
+    if ($missing.Count -eq 0) {
+        Write-Host "MSYS2 UCRT build tools already present; skipping pacman."
+        return
+    }
+
+    if ($SkipToolInstall) {
+        throw "Missing MSYS2 UCRT build tools: $($missing -join ', '). Re-run without -SkipToolInstall or install them with ridk."
+    }
+
+    Write-Host "Missing MSYS2 UCRT build tools: $($missing -join ', ')"
+    ridk exec pacman -S --needed --noconfirm @msysPackages
+    if ($LASTEXITCODE -ne 0) {
+        $stillMissing = @(Get-MissingUcrtTools)
+        if ($stillMissing.Count -eq 0) {
+            Write-Warning "pacman returned exit code $LASTEXITCODE, but all required tools are present; continuing."
+            return
+        }
+
+        throw "Failed to install MSYS2 UCRT build tools. Missing: $($stillMissing -join ', '). If pacman cannot lock its database, close other pacman/ridk shells, run PowerShell as Administrator, or install RubyInstaller in a user-writable directory."
+    }
+}
+
+Invoke-Step "Configure Windows GNU toolchain" {
+    $env:CARGO_BUILD_TARGET = $target
+    $env:LIBCLANG_PATH = $ucrtBin
+    $env:CC_x86_64_pc_windows_gnu = Join-Path $ucrtBin "gcc.exe"
+    $env:CXX_x86_64_pc_windows_gnu = Join-Path $ucrtBin "g++.exe"
+    $env:CMAKE = Join-Path $ucrtBin "cmake.exe"
+    Remove-Item Env:\CMAKE_GENERATOR -ErrorAction SilentlyContinue
+
+    rustc -Vv
+    Write-Host "LIBCLANG_PATH=$env:LIBCLANG_PATH"
+    Write-Host "CC_x86_64_pc_windows_gnu=$env:CC_x86_64_pc_windows_gnu"
+    Write-Host "CXX_x86_64_pc_windows_gnu=$env:CXX_x86_64_pc_windows_gnu"
+    Write-Host "CMAKE=$env:CMAKE"
+}
+
+if (-not $SkipBundleInstall) {
+    Invoke-Step "Install Ruby dependencies" {
+        bundle install
+    }
+}
+
+Invoke-Step "Compile native extension" {
+    ridk exec ruby -S bundle exec rake compile
+}
+
+Invoke-Step "Verify extension loads" {
+    ruby -Ilib -rwreq -e "puts Wreq::VERSION; puts Wreq::Client.new.class"
+}
+
+if ($RunTests) {
+    Invoke-Step "Run tests" {
+        ridk exec ruby -S bundle exec rake test
+    }
+}
+
+if ($BuildGem) {
+    Invoke-Step "Build local platform gem" {
+        $rubyMinor = & ruby -e "print RUBY_VERSION[/\A\d+\.\d+/]"
+        $dest = "lib\wreq_ruby\$rubyMinor"
+        New-Item -ItemType Directory -Force $dest | Out-Null
+        Copy-Item "lib\wreq_ruby\wreq_ruby.so" (Join-Path $dest "wreq_ruby.so") -Force
+
+        ruby script/build_platform_gem.rb $platform
+    }
+}
+
+if ($TestGem) {
+    Invoke-Step "Install and smoke test platform gem" {
+        $gem = Get-LatestPlatformGem
+        $gemHome = Join-Path ([System.IO.Path]::GetTempPath()) "wreq-gem-test-$PID"
+        $gemBin = Join-Path $gemHome "bin"
+        $testDir = Join-Path ([System.IO.Path]::GetTempPath()) "wreq-gem-test-cwd-$PID"
+
+        Remove-Item -Recurse -Force $gemHome, $testDir -ErrorAction SilentlyContinue
+        New-Item -ItemType Directory -Force $gemHome, $gemBin, $testDir | Out-Null
+
+        $oldGemHome = $env:GEM_HOME
+        $oldGemPath = $env:GEM_PATH
+        $oldGemrc = $env:GEMRC
+        $oldRubyopt = $env:RUBYOPT
+        $oldRubylib = $env:RUBYLIB
+        $oldBundleGemfile = $env:BUNDLE_GEMFILE
+        $oldBundleBinPath = $env:BUNDLE_BIN_PATH
+        $oldBundlerVersion = $env:BUNDLER_VERSION
+        $oldSmokeUrl = $env:WREQ_SMOKE_URL
+        $oldWreqGemHome = $env:WREQ_GEM_HOME
+
+        try {
+            $env:GEM_HOME = $gemHome
+            $env:GEM_PATH = $gemHome
+            $env:GEMRC = ""
+            $env:RUBYOPT = ""
+            $env:RUBYLIB = ""
+            $env:BUNDLE_GEMFILE = ""
+            $env:BUNDLE_BIN_PATH = ""
+            $env:BUNDLER_VERSION = ""
+            $env:WREQ_SMOKE_URL = $SmokeUrl
+            $env:WREQ_GEM_HOME = $gemHome
+
+            gem install --norc --local --install-dir $gemHome --bindir $gemBin --no-document --force --no-user-install $gem.FullName
+            if ($LASTEXITCODE -ne 0) {
+                throw "Failed to install $($gem.FullName)."
+            }
+
+            Push-Location $testDir
+            try {
+                Invoke-RubySmoke "Load installed platform gem" @'
+STDOUT.sync = true
+STDERR.sync = true
+require "wreq"
+spec = Gem.loaded_specs.fetch("wreq")
+expected = File.expand_path(ENV.fetch("WREQ_GEM_HOME"))
+actual = File.expand_path(spec.full_gem_path)
+raise "loaded #{actual}, expected under #{expected}" unless actual.start_with?(expected)
+puts "loaded #{spec.full_name}"
+puts actual
+puts "wreq #{Wreq::VERSION}"
+'@
+
+                Invoke-RubySmoke "Request through installed platform gem" @'
+STDOUT.sync = true
+STDERR.sync = true
+require "wreq"
+client = Wreq::Client.new
+resp = client.get(ENV.fetch("WREQ_SMOKE_URL"), timeout: 20)
+puts "HTTP #{resp.code}"
+raise "unexpected status #{resp.code}" unless resp.code == 200
+'@
+            } finally {
+                Pop-Location
+            }
+        } finally {
+            $env:GEM_HOME = $oldGemHome
+            $env:GEM_PATH = $oldGemPath
+            $env:GEMRC = $oldGemrc
+            $env:RUBYOPT = $oldRubyopt
+            $env:RUBYLIB = $oldRubylib
+            $env:BUNDLE_GEMFILE = $oldBundleGemfile
+            $env:BUNDLE_BIN_PATH = $oldBundleBinPath
+            $env:BUNDLER_VERSION = $oldBundlerVersion
+            $env:WREQ_SMOKE_URL = $oldSmokeUrl
+            $env:WREQ_GEM_HOME = $oldWreqGemHome
+            Remove-Item -Recurse -Force $gemHome, $testDir -ErrorAction SilentlyContinue
+        }
+    }
+}

data/src/arch.rs

@@ -0,0 +1,33 @@
+//! Platform-specific support code.
+//!
+//! Keep this module small and focused on platform quirks that affect linking,
+//! 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.
+
+#[cfg(all(target_os = "windows", target_env = "gnu"))]
+mod windows_gnu {
+    //! Windows GNU support.
+    //!
+    //! RubyInstaller's GNU/UCRT Ruby exports some symbols with the same names as
+    //! Win32 APIs. When GNU ld links this extension against Ruby, those symbols
+    //! can shadow the real Windows APIs unless we pin the calls we care about.
+
+    #[link(name = "kernel32")]
+    unsafe extern "system" {
+        fn SleepEx(milliseconds: u32, alertable: i32) -> u32;
+    }
+
+    // RubyInstaller's GNU/UCRT Ruby exports a Ruby-aware Sleep symbol. GNU ld can
+    // bind extension calls to that symbol instead of KERNEL32!Sleep, which crashes
+    // on native worker threads that have no Ruby TLS. The linker wrapper keeps those
+    // calls on the Windows API path.
+    #[unsafe(no_mangle)]
+    pub extern "system" fn __wrap_Sleep(milliseconds: u32) {
+        // SAFETY: SleepEx is a Win32 API. Passing alertable=false matches Sleep's
+        // behavior, and any u32 duration is accepted by the API.
+        unsafe {
+            SleepEx(milliseconds, 0);
+        }
+    }
+}

data/src/client/body/stream.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use bytes::Bytes;
-use futures_util::{Stream, StreamExt, TryFutureExt};
+use futures_util::{Stream, StreamExt};
 use magnus::{Error, RString, TryConvert, Value};
 use tokio::sync::{
     Mutex,
@@ -40,13 +40,16 @@ impl BodyReceiver {
 
     /// Read the next body chunk, converting stream errors into Ruby errors.
     pub fn next(&self) -> Result<Option<Bytes>, Error> {
-        rt::try_block_on(async {
-            match self.0.lock().await.as_mut().next().await {
-                Some(Ok(data)) => Ok(Some(data)),
-                Some(Err(err)) => Err(wreq_error_to_magnus(err)),
-                None => Ok(None),
-            }
-        })
+        rt::try_block_on(
+            async {
+                match self.0.lock().await.as_mut().next().await {
+                    Some(Ok(data)) => Ok(Some(data)),
+                    Some(Err(err)) => Err(err),
+                    None => Ok(None),
+                }
+            },
+            wreq_error_to_magnus,
+        )
     }
 }
 
@@ -73,7 +76,7 @@ impl BodySender {
         let bytes = data.to_bytes();
         let inner = rb_self.0.read().unwrap();
         if let Some(ref tx) = inner.tx {
-            rt::try_block_on(tx.send(bytes).map_err(mpsc_send_error_to_magnus))?;
+            rt::try_block_on(tx.send(bytes), mpsc_send_error_to_magnus)?;
         }
         Ok(())
     }

data/src/client/req.rs

@@ -33,6 +33,7 @@ pub struct Request {
     local_address: Option<IpAddr>,
 
     /// Bind to an interface by `SO_BINDTODEVICE`.
+    #[allow(dead_code)]
     interface: Option<String>,
 
     /// The timeout to use for the request.
@@ -144,119 +145,130 @@ pub fn execute_request<U: AsRef<str>>(
     url: U,
     mut request: Request,
 ) -> Result<Response, magnus::Error> {
-    rt::try_block_on(async move {
-        let mut builder = client.request(method.into_ffi(), url.as_ref());
-
-        // Emulation options.
-        apply_option!(set_if_some_inner, builder, request.emulation, emulation);
-
-        // Version options.
-        apply_option!(
-            set_if_some_map,
-            builder,
-            request.version,
-            version,
-            Version::into_ffi
-        );
-
-        // Timeout options.
-        apply_option!(
-            set_if_some_map,
-            builder,
-            request.timeout,
-            timeout,
-            Duration::from_secs
-        );
-        apply_option!(
-            set_if_some_map,
-            builder,
-            request.read_timeout,
-            read_timeout,
-            Duration::from_secs
-        );
-
-        // Network options.
-        apply_option!(set_if_some, builder, request.proxy, proxy);
-        apply_option!(set_if_some, builder, request.local_address, local_address);
-        apply_option!(set_if_some, builder, request.interface, interface);
-
-        // Headers options.
-        apply_option!(set_if_some_into_inner, builder, request.headers, headers);
-        apply_option!(
-            set_if_some_inner,
-            builder,
-            request.orig_headers,
-            orig_headers
-        );
-        apply_option!(
-            set_if_some,
-            builder,
-            request.default_headers,
-            default_headers
-        );
-
-        // Cookies options.
-        if let Some(cookies) = request.cookies.take() {
-            for cookie in cookies.0 {
-                builder = builder.header(header::COOKIE, cookie);
+    rt::try_block_on(
+        async move {
+            let mut builder = client.request(method.into_ffi(), url.as_ref());
+
+            // Emulation options.
+            apply_option!(set_if_some_inner, builder, request.emulation, emulation);
+
+            // Version options.
+            apply_option!(
+                set_if_some_map,
+                builder,
+                request.version,
+                version,
+                Version::into_ffi
+            );
+
+            // Timeout options.
+            apply_option!(
+                set_if_some_map,
+                builder,
+                request.timeout,
+                timeout,
+                Duration::from_secs
+            );
+            apply_option!(
+                set_if_some_map,
+                builder,
+                request.read_timeout,
+                read_timeout,
+                Duration::from_secs
+            );
+
+            // Network options.
+            apply_option!(set_if_some, builder, request.proxy, proxy);
+            apply_option!(set_if_some, builder, request.local_address, local_address);
+            #[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",
+            ))]
+            apply_option!(set_if_some, builder, request.interface, interface);
+
+            // Headers options.
+            apply_option!(set_if_some_into_inner, builder, request.headers, headers);
+            apply_option!(
+                set_if_some_inner,
+                builder,
+                request.orig_headers,
+                orig_headers
+            );
+            apply_option!(
+                set_if_some,
+                builder,
+                request.default_headers,
+                default_headers
+            );
+
+            // Cookies options.
+            if let Some(cookies) = request.cookies.take() {
+                for cookie in cookies.0 {
+                    builder = builder.header(header::COOKIE, cookie);
+                }
             }
-        }
-
-        // Authentication options.
-        apply_option!(
-            set_if_some_map_ref,
-            builder,
-            request.auth,
-            auth,
-            AsRef::<str>::as_ref
-        );
-        apply_option!(set_if_some, builder, request.bearer_auth, bearer_auth);
-        if let Some(basic_auth) = request.basic_auth.take() {
-            builder = builder.basic_auth(basic_auth.0, basic_auth.1);
-        }
 
-        // Allow redirects options.
-        match request.allow_redirects {
-            Some(false) => {
-                builder = builder.redirect(wreq::redirect::Policy::none());
+            // Authentication options.
+            apply_option!(
+                set_if_some_map_ref,
+                builder,
+                request.auth,
+                auth,
+                AsRef::<str>::as_ref
+            );
+            apply_option!(set_if_some, builder, request.bearer_auth, bearer_auth);
+            if let Some(basic_auth) = request.basic_auth.take() {
+                builder = builder.basic_auth(basic_auth.0, basic_auth.1);
             }
-            Some(true) => {
-                builder = builder.redirect(
-                    request
-                        .max_redirects
-                        .take()
-                        .map(wreq::redirect::Policy::limited)
-                        .unwrap_or_default(),
-                );
-            }
-            None => {}
-        };
-
-        // Compression options.
-        apply_option!(set_if_some, builder, request.gzip, gzip);
-        apply_option!(set_if_some, builder, request.brotli, brotli);
-        apply_option!(set_if_some, builder, request.deflate, deflate);
-        apply_option!(set_if_some, builder, request.zstd, zstd);
 
-        // Query options.
-        apply_option!(set_if_some_ref, builder, request.query, query);
-
-        // Form options.
-        apply_option!(set_if_some_ref, builder, request.form, form);
-
-        // JSON options.
-        apply_option!(set_if_some_ref, builder, request.json, json);
-
-        // Body options.
-        if let Some(body) = request.body.take() {
-            builder = builder.body(wreq::Body::from(body));
-        }
+            // Allow redirects options.
+            match request.allow_redirects {
+                Some(false) => {
+                    builder = builder.redirect(wreq::redirect::Policy::none());
+                }
+                Some(true) => {
+                    builder = builder.redirect(
+                        request
+                            .max_redirects
+                            .take()
+                            .map(wreq::redirect::Policy::limited)
+                            .unwrap_or_default(),
+                    );
+                }
+                None => {}
+            };
+
+            // Compression options.
+            apply_option!(set_if_some, builder, request.gzip, gzip);
+            apply_option!(set_if_some, builder, request.brotli, brotli);
+            apply_option!(set_if_some, builder, request.deflate, deflate);
+            apply_option!(set_if_some, builder, request.zstd, zstd);
+
+            // Query options.
+            apply_option!(set_if_some_ref, builder, request.query, query);
+
+            // Form options.
+            apply_option!(set_if_some_ref, builder, request.form, form);
+
+            // JSON options.
+            apply_option!(set_if_some_ref, builder, request.json, json);
+
+            // Body options.
+            if let Some(body) = request.body.take() {
+                builder = builder.body(wreq::Body::from(body));
+            }
 
-        // Send request.
-        builder
-            .send()
-            .await
-            .map(Response::new)
-            .map_err(wreq_error_to_magnus)
-    })
+            // Send request.
+            builder.send().await.map(Response::new)
+        },
+        wreq_error_to_magnus,
+    )
 }

data/src/client/resp.rs

@@ -81,9 +81,8 @@ impl Response {
                         Ok(build_response(body))
                     } else {
                         let bytes = rt::try_block_on(
-                            BodyExt::collect(body)
-                                .map_ok(|buf| buf.to_bytes())
-                                .map_err(wreq_error_to_magnus),
+                            BodyExt::collect(body).map_ok(|buf| buf.to_bytes()),
+                            wreq_error_to_magnus,
                         )?;
 
                         self.body
@@ -170,7 +169,7 @@ impl Response {
     /// Get the response body as bytes.
     pub fn bytes(&self) -> Result<Bytes, Error> {
         let response = self.response(false)?;
-        rt::try_block_on(response.bytes().map_err(wreq_error_to_magnus))
+        rt::try_block_on(response.bytes(), wreq_error_to_magnus)
     }
 
     ///  Get the full response text given a specific encoding.
@@ -178,25 +177,18 @@ impl Response {
         let args = scan_args::<(), (Option<String>,), (), (), (), ()>(args)?;
         let response = self.response(false)?;
         match args.optional.0 {
-            Some(encoding) => rt::try_block_on(
-                response
-                    .text_with_charset(encoding)
-                    .map_err(wreq_error_to_magnus),
-            ),
-            None => rt::try_block_on(response.text().map_err(wreq_error_to_magnus)),
+            Some(encoding) => {
+                rt::try_block_on(response.text_with_charset(encoding), wreq_error_to_magnus)
+            }
+            None => rt::try_block_on(response.text(), wreq_error_to_magnus),
         }
     }
 
     /// Get the response body as JSON.
     pub fn json(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
         let response = rb_self.response(false)?;
-        rt::try_block_on(async move {
-            let json = response
-                .json::<Json>()
-                .await
-                .map_err(wreq_error_to_magnus)?;
-            serde_magnus::serialize(ruby, &json)
-        })
+        let json = rt::try_block_on(response.json::<Json>(), wreq_error_to_magnus)?;
+        serde_magnus::serialize(ruby, &json)
     }
 
     /// Yield response body chunks to the given Ruby block.

data/src/client.rs

@@ -104,6 +104,7 @@ struct Builder {
     /// Bind to a local IP Address.
     local_address: Option<IpAddr>,
     /// Bind to an interface by `SO_BINDTODEVICE`.
+    #[allow(dead_code)]
     interface: Option<String>,
 
     // ========= Compression options =========
@@ -300,6 +301,18 @@ impl Client {
                 apply_option!(set_if_some, builder, params.proxy, proxy);
                 apply_option!(set_if_true, builder, params.no_proxy, no_proxy, false);
                 apply_option!(set_if_some, builder, params.local_address, local_address);
+                #[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",
+                ))]
                 apply_option!(set_if_some, builder, params.interface, interface);
 
                 // Compression options.

data/src/emulate.rs

@@ -49,6 +49,7 @@ define_ruby_enum!(
     Chrome146,
     Chrome147,
     Chrome148,
+    Chrome149,
 
     Edge101,
     Edge122,

data/src/lib.rs

@@ -2,6 +2,7 @@
 
 #[macro_use]
 mod macros;
+mod arch;
 mod client;
 mod cookie;
 mod emulate;