wreq 1.2.3-x64-mingw-ucrt

data/src/http.rs

@@ -0,0 +1,142 @@
+use magnus::{Error, Module, RModule, Ruby, TryConvert, Value, method, typed_data::Inspect};
+
+define_ruby_enum!(
+    /// An HTTP version.
+    const,
+    Version,
+    "Wreq::Version",
+    wreq::Version,
+    HTTP_09,
+    HTTP_10,
+    HTTP_11,
+    HTTP_2,
+    HTTP_3,
+);
+
+define_ruby_enum!(
+    /// An HTTP method.
+    Method,
+    "Wreq::Method",
+    wreq::Method,
+    GET,
+    HEAD,
+    POST,
+    PUT,
+    DELETE,
+    OPTIONS,
+    TRACE,
+    PATCH,
+);
+
+/// HTTP status code.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[magnus::wrap(class = "Wreq::StatusCode", free_immediately, size)]
+pub struct StatusCode(pub wreq::StatusCode);
+
+// ===== impl Version =====
+
+impl Version {
+    /// Convert version to string.
+    #[inline]
+    pub fn to_s(&self) -> String {
+        self.into_ffi().inspect()
+    }
+
+    /// Value-based equality for Ruby (`==`).
+    #[inline]
+    pub fn equals(&self, other: Value) -> bool {
+        <&Version>::try_convert(other)
+            .map(|other| *self == *other)
+            .unwrap_or(false)
+    }
+}
+
+impl TryConvert for Version {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        <&Version>::try_convert(value).cloned()
+    }
+}
+
+// ===== impl StatusCode =====
+
+impl StatusCode {
+    /// Return the status code as an integer.
+    #[inline]
+    pub const fn as_int(&self) -> u16 {
+        self.0.as_u16()
+    }
+
+    /// Check if status is within 100-199.
+    #[inline]
+    pub fn is_informational(&self) -> bool {
+        self.0.is_informational()
+    }
+
+    /// Check if status is within 200-299.
+    #[inline]
+    pub fn is_success(&self) -> bool {
+        self.0.is_success()
+    }
+
+    /// Check if status is within 300-399.
+    #[inline]
+    pub fn is_redirection(&self) -> bool {
+        self.0.is_redirection()
+    }
+
+    /// Check if status is within 400-499.
+    #[inline]
+    pub fn is_client_error(&self) -> bool {
+        self.0.is_client_error()
+    }
+
+    /// Check if status is within 500-599.
+    #[inline]
+    pub fn is_server_error(&self) -> bool {
+        self.0.is_server_error()
+    }
+
+    /// Convert status code to string.
+    #[inline]
+    pub fn to_s(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+impl From<wreq::StatusCode> for StatusCode {
+    fn from(status: wreq::StatusCode) -> Self {
+        Self(status)
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let method_class = gem_module.define_class("Method", ruby.class_object())?;
+    method_class.const_set("GET", Method::GET)?;
+    method_class.const_set("POST", Method::POST)?;
+    method_class.const_set("PUT", Method::PUT)?;
+    method_class.const_set("DELETE", Method::DELETE)?;
+    method_class.const_set("PATCH", Method::PATCH)?;
+    method_class.const_set("HEAD", Method::HEAD)?;
+    method_class.const_set("TRACE", Method::TRACE)?;
+    method_class.const_set("OPTIONS", Method::OPTIONS)?;
+
+    let version_class = gem_module.define_class("Version", ruby.class_object())?;
+    version_class.const_set("HTTP_09", Version::HTTP_09)?;
+    version_class.const_set("HTTP_10", Version::HTTP_10)?;
+    version_class.const_set("HTTP_11", Version::HTTP_11)?;
+    version_class.const_set("HTTP_2", Version::HTTP_2)?;
+    version_class.const_set("HTTP_3", Version::HTTP_3)?;
+    version_class.define_method("to_s", method!(Version::to_s, 0))?;
+    version_class.define_method("==", method!(Version::equals, 1))?;
+
+    let status_code_class = gem_module.define_class("StatusCode", ruby.class_object())?;
+    status_code_class.define_method("as_int", method!(StatusCode::as_int, 0))?;
+    status_code_class.define_method("informational?", method!(StatusCode::is_informational, 0))?;
+    status_code_class.define_method("success?", method!(StatusCode::is_success, 0))?;
+    status_code_class.define_method("redirection?", method!(StatusCode::is_redirection, 0))?;
+    status_code_class.define_method("client_error?", method!(StatusCode::is_client_error, 0))?;
+    status_code_class.define_method("server_error?", method!(StatusCode::is_server_error, 0))?;
+    status_code_class.define_method("to_s", method!(StatusCode::to_s, 0))?;
+
+    Ok(())
+}

data/src/lib.rs

@@ -0,0 +1,98 @@
+#![allow(clippy::wrong_self_convention)]
+
+#[macro_use]
+mod macros;
+mod arch;
+mod client;
+mod cookie;
+mod emulate;
+mod error;
+mod extractor;
+mod gvl;
+mod header;
+mod http;
+mod rt;
+
+use magnus::{Error, Module, Ruby, Value};
+
+use crate::client::{Client, resp::Response};
+
+const RUBY_MODULE_NAME: &str = "Wreq";
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Send a HTTP request.
+#[inline]
+pub fn request(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::request(&Client::default(), args)
+}
+
+/// Send a GET request.
+#[inline]
+pub fn get(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::get(&Client::default(), args)
+}
+
+/// Send a POST request.
+#[inline]
+pub fn post(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::post(&Client::default(), args)
+}
+
+/// Send a PUT request.
+#[inline]
+pub fn put(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::put(&Client::default(), args)
+}
+
+/// Send a DELETE request.
+#[inline]
+pub fn delete(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::delete(&Client::default(), args)
+}
+
+/// Send a HEAD request.
+#[inline]
+pub fn head(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::head(&Client::default(), args)
+}
+
+/// Send an OPTIONS request.
+#[inline]
+pub fn options(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::options(&Client::default(), args)
+}
+
+/// Send a TRACE request.
+#[inline]
+pub fn trace(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::trace(&Client::default(), args)
+}
+
+/// Send a PATCH request.
+#[inline]
+pub fn patch(args: &[Value]) -> Result<Response, magnus::Error> {
+    Client::patch(&Client::default(), args)
+}
+
+/// wreq ruby binding
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let gem_module = ruby.define_module(RUBY_MODULE_NAME)?;
+    gem_module.const_set("VERSION", VERSION)?;
+    gem_module.define_module_function("request", magnus::function!(request, -1))?;
+    gem_module.define_module_function("get", magnus::function!(get, -1))?;
+    gem_module.define_module_function("post", magnus::function!(post, -1))?;
+    gem_module.define_module_function("put", magnus::function!(put, -1))?;
+    gem_module.define_module_function("delete", magnus::function!(delete, -1))?;
+    gem_module.define_module_function("head", magnus::function!(head, -1))?;
+    gem_module.define_module_function("options", magnus::function!(options, -1))?;
+    gem_module.define_module_function("trace", magnus::function!(trace, -1))?;
+    gem_module.define_module_function("patch", magnus::function!(patch, -1))?;
+    http::include(ruby, &gem_module)?;
+    header::include(ruby, &gem_module)?;
+    cookie::include(ruby, &gem_module)?;
+    client::include(ruby, &gem_module)?;
+    emulate::include(ruby, &gem_module)?;
+    error::include(ruby);
+    Ok(())
+}

data/src/macros.rs

@@ -0,0 +1,123 @@
+macro_rules! apply_option {
+    (set_if_some, $builder:expr, $option:expr, $method:ident) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method(value);
+        }
+    };
+    (set_if_some_ref, $builder:expr, $option:expr, $method:ident) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method(&value);
+        }
+    };
+    (set_if_some_inner, $builder:expr, $option:expr, $method:ident) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method(value.0);
+        }
+    };
+    (set_if_some_into_inner, $builder:expr, $option:expr, $method:ident) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method(value.0.into_inner());
+        }
+    };
+    (set_if_some_map, $builder:expr, $option:expr, $method:ident, $transform:expr) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method($transform(value));
+        }
+    };
+    (set_if_some_map_ref, $builder:expr, $option:expr, $method:ident, $transform:expr) => {
+        if let Some(value) = $option.take() {
+            $builder = $builder.$method($transform(&value));
+        }
+    };
+    (set_if_true, $builder:expr, $option:expr, $method:ident, $default:expr) => {
+        if $option.unwrap_or($default) {
+            $builder = $builder.$method();
+        }
+    };
+    (set_if_true_with, $builder:expr, $option:expr, $method:ident, $default:expr, $value:expr) => {
+        if $option.unwrap_or($default) {
+            $builder = $builder.$method($value);
+        }
+    };
+}
+
+macro_rules! define_ruby_enum {
+    ($(#[$meta:meta])* $enum_type:ident, $ruby_class:expr, $ffi_type:ty, $($variant:ident),* $(,)?) => {
+        define_ruby_enum!($(#[$meta])* $enum_type, $ruby_class, $ffi_type, $( ($variant, $variant) ),*);
+    };
+
+    ($(#[$meta:meta])* const, $enum_type:ident, $ruby_class:expr, $ffi_type:ty, $($variant:ident),* $(,)?) => {
+        define_ruby_enum!($(#[$meta])* const, $enum_type, $ruby_class, $ffi_type, $( ($variant, $variant) ),*);
+    };
+
+    ($(#[$meta:meta])* $enum_type:ident, $ruby_class:expr, $ffi_type:ty, $(($rust_variant:ident, $ffi_variant:ident)),* $(,)?) => {
+        $(#[$meta])*
+        #[magnus::wrap(class = $ruby_class, free_immediately, size)]
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+        #[allow(non_camel_case_types)]
+        #[allow(clippy::upper_case_acronyms)]
+        pub enum $enum_type {
+            $($rust_variant),*
+        }
+
+        impl $enum_type {
+            pub fn into_ffi(self) -> $ffi_type {
+                match self {
+                    $(<$enum_type>::$rust_variant => <$ffi_type>::$ffi_variant,)*
+                }
+            }
+
+            #[allow(dead_code)]
+            pub fn from_ffi(ffi: $ffi_type) -> Self {
+                #[allow(unreachable_patterns)]
+                match ffi {
+                    $(<$ffi_type>::$ffi_variant => <$enum_type>::$rust_variant,)*
+                    _ => unreachable!(),
+                }
+            }
+        }
+    };
+
+    ($(#[$meta:meta])* const, $enum_type:ident, $ruby_class:expr, $ffi_type:ty, $(($rust_variant:ident, $ffi_variant:ident)),* $(,)?) => {
+        $(#[$meta])*
+        #[magnus::wrap(class = $ruby_class, free_immediately, size)]
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+        #[allow(non_camel_case_types)]
+        #[allow(clippy::upper_case_acronyms)]
+        pub enum $enum_type {
+            $($rust_variant),*
+        }
+
+        impl $enum_type {
+            pub const fn into_ffi(self) -> $ffi_type {
+                match self {
+                    $(<$enum_type>::$rust_variant => <$ffi_type>::$ffi_variant,)*
+                }
+            }
+
+            #[allow(dead_code)]
+            pub const fn from_ffi(ffi: $ffi_type) -> Self {
+                #[allow(unreachable_patterns)]
+                match ffi {
+                    $(<$ffi_type>::$ffi_variant => <$enum_type>::$rust_variant,)*
+                    _ => unreachable!(),
+                }
+            }
+        }
+    };
+}
+
+macro_rules! ruby {
+    () => {
+        magnus::Ruby::get().expect("Failed to get Ruby VM instance")
+    };
+}
+
+macro_rules! extract_request {
+    ($args:expr, $required:ty) => {{
+        let args = magnus::scan_args::scan_args::<$required, (), (), (), magnus::RHash, ()>($args)?;
+        let required = args.required;
+        let request = crate::client::req::Request::new(&ruby!(), args.keywords)?;
+        (required, request)
+    }};
+}

data/src/rt.rs

@@ -0,0 +1,46 @@
+use std::sync::LazyLock;
+
+use tokio::runtime::{Builder, Runtime};
+
+use crate::{error::interrupt_error, gvl};
+
+static RUNTIME: LazyLock<Runtime> = LazyLock::new(|| {
+    let mut builder = Builder::new_multi_thread();
+
+    builder
+        .enable_all()
+        .build()
+        .expect("Failed to initialize Tokio runtime")
+});
+
+enum BlockOnError<E> {
+    Interrupted,
+    Future(E),
+}
+
+/// Block on a future to completion on the global Tokio runtime.
+///
+/// The future runs without Ruby's GVL, so it must not construct Ruby objects or
+/// Ruby exceptions. Convert Rust errors back into Ruby errors after the GVL has
+/// been reacquired.
+pub fn try_block_on<F, T, E, M>(future: F, map_err: M) -> Result<T, magnus::Error>
+where
+    F: Future<Output = Result<T, E>>,
+    M: FnOnce(E) -> magnus::Error,
+{
+    let result = gvl::nogvl_cancellable(|flag| {
+        RUNTIME.block_on(async move {
+            tokio::select! {
+                biased;
+                _ = flag.cancelled() => Err(BlockOnError::Interrupted),
+                result = future => result.map_err(BlockOnError::Future),
+            }
+        })
+    });
+
+    match result {
+        Ok(value) => Ok(value),
+        Err(BlockOnError::Interrupted) => Err(interrupt_error()),
+        Err(BlockOnError::Future(err)) => Err(map_err(err)),
+    }
+}

data/test/client_cookie_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ClientCookieProviderTest < Minitest::Test
+  HOST = HTTPBIN_URL
+
+  def setup
+    @jar = Wreq::Jar.new
+    @client = Wreq::Client.new(
+      cookie_store: true,
+      cookie_provider: @jar,
+      allow_redirects: true
+    )
+  end
+
+  def test_custom_jar_captures_set_cookie_and_sends_back
+    # starts empty
+    assert_kind_of Array, @jar.get_all
+    assert_equal 0, @jar.get_all.length
+
+    # server sets cookie; client follows redirect; jar should store it
+    res1 = @client.get("#{HOST}/cookies/set?foo=bar")
+    assert_equal 200, res1.code
+
+    names = @jar.get_all.map(&:name)
+    assert_includes names, "foo"
+
+    # subsequent request should send the stored cookie automatically
+    res2 = @client.get("#{HOST}/cookies")
+    assert_equal 200, res2.code
+    cookies = httpbin_cookies(res2.json)
+    assert_kind_of Hash, cookies
+    assert_equal "bar", httpbin_fetch(cookies, "foo")
+  end
+
+  def test_prepopulated_jar_is_used_by_client
+    # pre-populate jar
+    @jar.add("pref=1; Path=/", "#{HOST}/")
+
+    res = @client.get("#{HOST}/cookies")
+    assert_equal 200, res.code
+    cookies = httpbin_cookies(res.json)
+    assert_equal "1", httpbin_fetch(cookies, "pref")
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,136 @@
+require "test_helper"
+
+class ClientTest < Minitest::Test
+  def setup
+    @client = Wreq::Client.new
+  end
+
+  def test_client_creation
+    refute_nil @client
+    assert_instance_of Wreq::Client, @client
+  end
+
+  def test_client_with_configuration
+    client = Wreq::Client.new(
+      timeout: 30,
+      headers: {"User-Agent" => "wreq-ruby/test"}
+    )
+    refute_nil client
+    assert_instance_of Wreq::Client, client
+  end
+
+  def test_get_request
+    response = @client.get("#{HTTPBIN_URL}/get")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_post_request
+    response = @client.post("#{HTTPBIN_URL}/post",
+      json: {test: "wreq-ruby"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_put_request
+    response = @client.put("#{HTTPBIN_URL}/put",
+      json: {data: "test"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_delete_request
+    response = @client.delete("#{HTTPBIN_URL}/delete")
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_patch_request
+    response = @client.patch("#{HTTPBIN_URL}/patch",
+      json: {update: "field"})
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_request_with_query_params
+    response = @client.get("#{HTTPBIN_URL}/get",
+      query: {"param" => "value"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "param"
+  end
+
+  def test_request_with_form_data
+    response = @client.post("#{HTTPBIN_URL}/post",
+      form: {"field" => "value"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "field"
+  end
+
+  def test_request_with_raw_body
+    response = @client.post("#{HTTPBIN_URL}/post",
+      body: "raw content",
+      headers: {"Content-Type" => "text/plain"})
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "raw content"
+  end
+
+  def test_basic_authentication
+    response = @client.get("#{HTTPBIN_URL}/basic-auth/user/pass",
+      basic_auth: ["user", "pass"])
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_bearer_authentication
+    response = @client.get("#{HTTPBIN_URL}/bearer",
+      bearer_auth: "test-token")
+    refute_nil response
+    assert_equal 200, response.code
+    assert_includes response.text, "test-token"
+  end
+
+  def test_redirect_following
+    response = @client.get("#{HTTPBIN_URL}/redirect/1",
+      allow_redirects: true)
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_redirect_blocking
+    response = @client.get("#{HTTPBIN_URL}/redirect/1",
+      allow_redirects: false)
+    refute_nil response
+    assert_equal 302, response.code
+  end
+
+  def test_gzip_compression
+    response = @client.get("#{HTTPBIN_URL}/gzip", gzip: true)
+    refute_nil response
+    assert_equal 200, response.code
+  end
+
+  def test_timeout_handling
+    # Test that short timeouts properly raise exceptions
+    assert_raises(Wreq::TimeoutError) do
+      @client.get("#{HTTPBIN_URL}/delay/10", timeout: 1)
+    end
+
+    # Test that reasonable timeouts work normally
+    start_time = Time.now
+    response = @client.get("#{HTTPBIN_URL}/delay/1", timeout: 5)
+    elapsed = Time.now - start_time
+
+    refute_nil response
+    assert_equal 200, response.code
+    assert elapsed < 5, "Request should complete within timeout"
+  end
+
+  def test_status_codes
+    response = @client.get("#{HTTPBIN_URL}/status/404")
+    refute_nil response
+    assert_equal 404, response.code
+  end
+end