wreq 1.2.3-x64-mingw-ucrt

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/form.rs

@@ -0,0 +1,2 @@
+/// Alias for form parameters.
+pub type Form = crate::client::param::Params;

data/src/client/body/json.rs

@@ -0,0 +1,16 @@
+use indexmap::IndexMap;
+use serde::{Deserialize, Serialize};
+
+/// 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>),
+}

data/src/client/body/stream.rs

@@ -0,0 +1,146 @@
+use std::{
+    pin::Pin,
+    sync::RwLock,
+    task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use futures_util::{Stream, StreamExt};
+use magnus::{Error, RString, TryConvert, Value};
+use tokio::sync::{
+    Mutex,
+    mpsc::{self},
+};
+
+use crate::{
+    error::{memory_error, mpsc_send_error_to_magnus, wreq_error_to_magnus},
+    rt,
+};
+
+/// A receiver for streaming HTTP response bodies.
+pub struct BodyReceiver(Mutex<Pin<Box<dyn Stream<Item = wreq::Result<Bytes>> + Send>>>);
+
+/// A sender for streaming HTTP request bodies.
+#[magnus::wrap(class = "Wreq::BodySender", free_immediately, size)]
+pub struct BodySender(RwLock<InnerBodySender>);
+
+struct InnerBodySender {
+    tx: Option<mpsc::Sender<Bytes>>,
+    rx: Option<mpsc::Receiver<Bytes>>,
+}
+
+// ===== impl BodyReceiver =====
+
+impl BodyReceiver {
+    /// Create a new [`BodyReceiver`] instance.
+    #[inline]
+    pub fn new(stream: impl Stream<Item = wreq::Result<Bytes>> + Send + 'static) -> BodyReceiver {
+        BodyReceiver(Mutex::new(Box::pin(stream)))
+    }
+
+    /// 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(err),
+                    None => Ok(None),
+                }
+            },
+            wreq_error_to_magnus,
+        )
+    }
+}
+
+// ===== impl BodySender =====
+
+impl BodySender {
+    /// Ruby: `Wreq::Sender.new(capacity = 8)`
+    pub fn new(args: &[Value]) -> Self {
+        let capacity: usize = if let Some(v) = args.first() {
+            usize::try_convert(*v).unwrap_or(8)
+        } else {
+            8
+        };
+
+        let (tx, rx) = mpsc::channel(capacity);
+        BodySender(RwLock::new(InnerBodySender {
+            tx: Some(tx),
+            rx: Some(rx),
+        }))
+    }
+
+    /// Ruby: `push(data)` where data is String or bytes
+    pub fn push(rb_self: &Self, data: RString) -> Result<(), Error> {
+        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), mpsc_send_error_to_magnus)?;
+        }
+        Ok(())
+    }
+
+    /// Ruby: `close` to close the sender
+    pub fn close(&self) {
+        let mut inner = self.0.write().unwrap();
+        inner.tx.take();
+        inner.rx.take();
+    }
+}
+
+impl TryFrom<&BodySender> for ReceiverStream<Bytes> {
+    type Error = magnus::Error;
+
+    fn try_from(sender: &BodySender) -> Result<Self, Self::Error> {
+        sender
+            .0
+            .write()
+            .unwrap()
+            .rx
+            .take()
+            .map(ReceiverStream::new)
+            .ok_or_else(memory_error)
+    }
+}
+
+/// A wrapper around [`tokio::sync::mpsc::Receiver`] that implements [`Stream`].
+pub struct ReceiverStream<T> {
+    inner: mpsc::Receiver<T>,
+}
+
+impl<T> ReceiverStream<T> {
+    /// Create a new [`ReceiverStream`].
+    #[inline]
+    pub fn new(recv: mpsc::Receiver<T>) -> Self {
+        Self { inner: recv }
+    }
+}
+
+impl<T> Stream for ReceiverStream<T> {
+    type Item = T;
+
+    #[inline]
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.inner.poll_recv(cx)
+    }
+
+    /// Returns the bounds of the stream based on the underlying receiver.
+    ///
+    /// For open channels, it returns `(receiver.len(), None)`.
+    ///
+    /// For closed channels, it returns `(receiver.len(), Some(used_capacity))`
+    /// where `used_capacity` is calculated as `receiver.max_capacity() -
+    /// receiver.capacity()`. This accounts for any [`Permit`] that is still
+    /// able to send a message.
+    ///
+    /// [`Permit`]: struct@tokio::sync::mpsc::Permit
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if self.inner.is_closed() {
+            let used_capacity = self.inner.max_capacity() - self.inner.capacity();
+            (self.inner.len(), Some(used_capacity))
+        } else {
+            (self.inner.len(), None)
+        }
+    }
+}

data/src/client/body.rs

@@ -0,0 +1,57 @@
+mod form;
+mod json;
+mod stream;
+
+use bytes::Bytes;
+use futures_util::StreamExt;
+use magnus::{
+    Error, Module, Object, RModule, RString, Ruby, TryConvert, Value, function, method,
+    typed_data::Obj,
+};
+
+pub use self::{
+    form::Form,
+    json::Json,
+    stream::{BodyReceiver, BodySender, ReceiverStream},
+};
+
+/// Represents the body of an HTTP request.
+/// Supports text, bytes, and streaming bodies (Proc/Enumerator).
+pub enum Body {
+    /// Static bytes body
+    Bytes(Bytes),
+    /// Streaming body
+    Stream(ReceiverStream<Bytes>),
+}
+
+impl TryConvert for Body {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        if let Ok(s) = RString::try_convert(val) {
+            return Ok(Body::Bytes(s.to_bytes()));
+        }
+
+        let obj = Obj::<BodySender>::try_convert(val)?;
+        let stream = ReceiverStream::try_from(&*obj)?;
+        Ok(Body::Stream(stream))
+    }
+}
+
+impl From<Body> for wreq::Body {
+    fn from(body: Body) -> Self {
+        match body {
+            Body::Bytes(b) => wreq::Body::from(b),
+            Body::Stream(stream) => {
+                let try_stream = stream.map(Ok::<Bytes, std::io::Error>);
+                wreq::Body::wrap_stream(try_stream)
+            }
+        }
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let sender_class = gem_module.define_class("BodySender", ruby.class_object())?;
+    sender_class.define_singleton_method("new", function!(BodySender::new, -1))?;
+    sender_class.define_method("push", method!(BodySender::push, 1))?;
+    sender_class.define_method("close", magnus::method!(BodySender::close, 0))?;
+    Ok(())
+}

data/src/client/param.rs

@@ -0,0 +1,19 @@
+use indexmap::IndexMap;
+use serde::{Deserialize, Serialize};
+
+/// Represents HTTP parameters from Python as either a mapping or a sequence of key-value pairs.
+pub type Params = IndexMap<String, ParamValue>;
+
+/// Represents a single parameter value that can be automatically converted from Python types.
+#[derive(Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ParamValue {
+    /// A boolean value from Python `bool`.
+    Boolean(bool),
+    /// An integer value from Python `int`.
+    Number(isize),
+    /// A floating-point value from Python `float`.
+    Float64(f64),
+    /// A string value from Python `str`.
+    String(String),
+}

data/src/client/query.rs

@@ -0,0 +1,2 @@
+/// Alias for query parameters.
+pub type Query = super::param::Params;