wreq 1.0.0

data/src/client.rs

@@ -0,0 +1,392 @@
+mod body;
+mod param;
+mod query;
+mod req;
+pub mod resp;
+
+use std::{net::IpAddr, time::Duration};
+
+use magnus::{
+    Module, Object, RHash, RModule, Ruby, TryConvert, Value, function, method, typed_data::Obj,
+};
+use serde::Deserialize;
+use wreq::{
+    Proxy,
+    header::{HeaderMap, HeaderValue, OrigHeaderMap},
+};
+
+use crate::{
+    client::{req::execute_request, resp::Response},
+    cookie::Jar,
+    emulation::Emulation,
+    error::wreq_error_to_magnus,
+    extractor::Extractor,
+    gvl,
+    http::Method,
+};
+
+/// A builder for `Client`.
+#[derive(Default, Deserialize)]
+struct Builder {
+    // The emulation option for the client.
+    #[serde(skip)]
+    emulation: Option<Emulation>,
+    /// The user agent to use for the client.
+    #[serde(skip)]
+    user_agent: Option<HeaderValue>,
+    /// The headers to use for the client.
+    #[serde(skip)]
+    headers: Option<HeaderMap>,
+    /// The original headers to use for the client.
+    #[serde(skip)]
+    orig_headers: Option<OrigHeaderMap>,
+    /// Whether to use referer.
+    referer: Option<bool>,
+    /// Whether to allow redirects.
+    allow_redirects: Option<bool>,
+    /// The maximum number of redirects to follow.
+    max_redirects: Option<usize>,
+
+    // ========= Cookie options =========
+    /// Whether to use cookie store.
+    cookie_store: Option<bool>,
+    /// Whether to use cookie store provider.
+    #[serde(skip)]
+    cookie_provider: Option<Jar>,
+
+    // ========= Timeout options =========
+    /// The timeout to use for the client. (in seconds)
+    timeout: Option<u64>,
+    /// The connect timeout to use for the client. (in seconds)
+    connect_timeout: Option<u64>,
+    /// The read timeout to use for the client. (in seconds)
+    read_timeout: Option<u64>,
+
+    // ========= TCP options =========
+    /// Set that all sockets have `SO_KEEPALIVE` set with the supplied duration. (in seconds)
+    tcp_keepalive: Option<u64>,
+    /// Set the interval between TCP keepalive probes. (in seconds)
+    tcp_keepalive_interval: Option<u64>,
+    /// Set the number of retries for TCP keepalive.
+    tcp_keepalive_retries: Option<u32>,
+    /// Set an optional user timeout for TCP sockets. (in seconds)
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    tcp_user_timeout: Option<u64>,
+    /// Set that all sockets have `NO_DELAY` set.
+    tcp_nodelay: Option<bool>,
+    /// Set that all sockets have `SO_REUSEADDR` set.
+    tcp_reuse_address: Option<bool>,
+
+    // ========= Connection pool options =========
+    /// Set an optional timeout for idle sockets being kept-alive. (in seconds)
+    pool_idle_timeout: Option<u64>,
+    /// Sets the maximum idle connection per host allowed in the pool.
+    pool_max_idle_per_host: Option<usize>,
+    /// Sets the maximum number of connections in the pool.
+    pool_max_size: Option<u32>,
+
+    // ========= Protocol options =========
+    /// Whether to use the HTTP/1 protocol only.
+    http1_only: Option<bool>,
+    /// Whether to use the HTTP/2 protocol only.
+    http2_only: Option<bool>,
+    /// Whether to use HTTPS only.
+    https_only: Option<bool>,
+
+    // ========= TLS options =========
+    /// Whether to verify the SSL certificate or root certificate file path.
+    verify: Option<bool>,
+
+    // ========= Network options =========
+    /// Whether to disable the proxy for the client.
+    no_proxy: Option<bool>,
+    /// The proxy to use for the client.
+    #[serde(skip)]
+    proxy: Option<Proxy>,
+    /// Bind to a local IP Address.
+    local_address: Option<IpAddr>,
+    /// Bind to an interface by `SO_BINDTODEVICE`.
+    interface: Option<String>,
+
+    // ========= Compression options =========
+    /// Sets gzip as an accepted encoding.
+    gzip: Option<bool>,
+    /// Sets brotli as an accepted encoding.
+    brotli: Option<bool>,
+    /// Sets deflate as an accepted encoding.
+    deflate: Option<bool>,
+    /// Sets zstd as an accepted encoding.
+    zstd: Option<bool>,
+}
+
+#[derive(Clone, Default)]
+#[magnus::wrap(class = "Wreq::Client", free_immediately, size)]
+pub struct Client(wreq::Client);
+
+// ===== impl Builder =====
+
+impl Builder {
+    /// Create a new [`Builder`] from Ruby keyword arguments.
+    fn new(ruby: &magnus::Ruby, keyword: &Value) -> Result<Self, magnus::Error> {
+        if let Ok(hash) = RHash::try_convert(*keyword) {
+            let mut builder: Self = serde_magnus::deserialize(ruby, hash)?;
+            // extra emulation handling
+            if let Some(v) = hash.get(ruby.to_symbol("emulation")) {
+                let emulation_obj = Obj::<Emulation>::try_convert(v)?;
+                builder.emulation = Some((*emulation_obj).clone());
+            }
+
+            // extra user agent handling
+            builder.user_agent = Extractor::<HeaderValue>::try_convert(*keyword)?.into_inner();
+
+            // extra headers handling
+            builder.headers = Extractor::<HeaderMap>::try_convert(*keyword)?.into_inner();
+
+            // extra original headers handling
+            builder.orig_headers = Extractor::<OrigHeaderMap>::try_convert(*keyword)?.into_inner();
+
+            // extra proxy handling
+            builder.proxy = Extractor::<Proxy>::try_convert(*keyword)?.into_inner();
+
+            // extra cookie store handling
+            if let Some(jar) = hash.get(ruby.to_symbol("cookie_provider")) {
+                builder.cookie_provider = Some((*Obj::<Jar>::try_convert(jar)?).clone());
+            }
+
+            return Ok(builder);
+        }
+
+        Ok(Default::default())
+    }
+}
+
+// ===== impl Client =====
+
+impl Client {
+    /// Create a new [`Client`] with the given keyword arguments.
+    pub fn new(ruby: &Ruby, kwargs: &[Value]) -> Result<Self, magnus::Error> {
+        if let Some(kwargs) = kwargs.first() {
+            let mut params = Builder::new(ruby, kwargs)?;
+            gvl::nogvl(|| {
+                let mut builder = wreq::Client::builder();
+
+                // Emulation options.
+                apply_option!(set_if_some_inner, builder, params.emulation, emulation);
+
+                // User agent options.
+                apply_option!(set_if_some, builder, params.user_agent, user_agent);
+
+                // Default headers options.
+                apply_option!(set_if_some, builder, params.headers, default_headers);
+                apply_option!(set_if_some, builder, params.orig_headers, orig_headers);
+
+                // Allow redirects options.
+                apply_option!(set_if_some, builder, params.referer, referer);
+                apply_option!(
+                    set_if_true_with,
+                    builder,
+                    params.allow_redirects,
+                    redirect,
+                    false,
+                    params
+                        .max_redirects
+                        .take()
+                        .map(wreq::redirect::Policy::limited)
+                        .unwrap_or_default()
+                );
+
+                // Cookie options.
+                apply_option!(set_if_some, builder, params.cookie_store, cookie_store);
+                apply_option!(
+                    set_if_some_inner,
+                    builder,
+                    params.cookie_provider,
+                    cookie_provider
+                );
+
+                // TCP options.
+                apply_option!(
+                    set_if_some_map,
+                    builder,
+                    params.tcp_keepalive,
+                    tcp_keepalive,
+                    Duration::from_secs
+                );
+                apply_option!(
+                    set_if_some_map,
+                    builder,
+                    params.tcp_keepalive_interval,
+                    tcp_keepalive_interval,
+                    Duration::from_secs
+                );
+                apply_option!(
+                    set_if_some,
+                    builder,
+                    params.tcp_keepalive_retries,
+                    tcp_keepalive_retries
+                );
+                #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+                apply_option!(
+                    set_if_some_map,
+                    builder,
+                    params.tcp_user_timeout,
+                    tcp_user_timeout,
+                    Duration::from_secs
+                );
+                apply_option!(set_if_some, builder, params.tcp_nodelay, tcp_nodelay);
+                apply_option!(
+                    set_if_some,
+                    builder,
+                    params.tcp_reuse_address,
+                    tcp_reuse_address
+                );
+
+                // Timeout options.
+                apply_option!(
+                    set_if_some_map,
+                    builder,
+                    params.timeout,
+                    timeout,
+                    Duration::from_secs
+                );
+                apply_option!(
+                    set_if_some_map,
+                    builder,
+                    params.connect_timeout,
+                    connect_timeout,
+                    Duration::from_secs
+                );
+                apply_option!(
+                    set_if_some_map,
+                    builder,
+                    params.read_timeout,
+                    read_timeout,
+                    Duration::from_secs
+                );
+
+                // Pool options.
+                apply_option!(
+                    set_if_some_map,
+                    builder,
+                    params.pool_idle_timeout,
+                    pool_idle_timeout,
+                    Duration::from_secs
+                );
+                apply_option!(
+                    set_if_some,
+                    builder,
+                    params.pool_max_idle_per_host,
+                    pool_max_idle_per_host
+                );
+                apply_option!(set_if_some, builder, params.pool_max_size, pool_max_size);
+
+                // Protocol options.
+                apply_option!(set_if_true, builder, params.http1_only, http1_only, false);
+                apply_option!(set_if_true, builder, params.http2_only, http2_only, false);
+                apply_option!(set_if_some, builder, params.https_only, https_only);
+
+                // TLS options.
+                apply_option!(set_if_some, builder, params.verify, cert_verification);
+
+                // Network options.
+                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);
+                apply_option!(set_if_some, builder, params.interface, interface);
+
+                // Compression options.
+                apply_option!(set_if_some, builder, params.gzip, gzip);
+                apply_option!(set_if_some, builder, params.brotli, brotli);
+                apply_option!(set_if_some, builder, params.deflate, deflate);
+                apply_option!(set_if_some, builder, params.zstd, zstd);
+
+                builder.build().map(Client).map_err(wreq_error_to_magnus)
+            })
+        } else {
+            gvl::nogvl(|| Ok(Self(wreq::Client::new())))
+        }
+    }
+}
+
+impl Client {
+    /// Send a HTTP request.
+    #[inline]
+    pub fn request(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
+        let ((method, url), request) = extract_request!(args, (Obj<Method>, String));
+        execute_request(rb_self.0.clone(), *method, url, request)
+    }
+
+    /// Send a GET request.
+    #[inline]
+    pub fn get(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
+        let ((url,), request) = extract_request!(args, (String,));
+        execute_request(rb_self.0.clone(), Method::GET, url, request)
+    }
+
+    /// Send a POST request.
+    #[inline]
+    pub fn post(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
+        let ((url,), request) = extract_request!(args, (String,));
+        execute_request(rb_self.0.clone(), Method::POST, url, request)
+    }
+
+    /// Send a PUT request.
+    #[inline]
+    pub fn put(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
+        let ((url,), request) = extract_request!(args, (String,));
+        execute_request(rb_self.0.clone(), Method::PUT, url, request)
+    }
+
+    /// Send a DELETE request.
+    #[inline]
+    pub fn delete(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
+        let ((url,), request) = extract_request!(args, (String,));
+        execute_request(rb_self.0.clone(), Method::DELETE, url, request)
+    }
+
+    /// Send a HEAD request.
+    #[inline]
+    pub fn head(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
+        let ((url,), request) = extract_request!(args, (String,));
+        execute_request(rb_self.0.clone(), Method::HEAD, url, request)
+    }
+
+    /// Send an OPTIONS request.
+    #[inline]
+    pub fn options(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
+        let ((url,), request) = extract_request!(args, (String,));
+        execute_request(rb_self.0.clone(), Method::OPTIONS, url, request)
+    }
+
+    /// Send a TRACE request.
+    #[inline]
+    pub fn trace(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
+        let ((url,), request) = extract_request!(args, (String,));
+        execute_request(rb_self.0.clone(), Method::TRACE, url, request)
+    }
+
+    /// Send a PATCH request.
+    #[inline]
+    pub fn patch(rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
+        let ((url,), request) = extract_request!(args, (String,));
+        execute_request(rb_self.0.clone(), Method::PATCH, url, request)
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), magnus::Error> {
+    let client_class = gem_module.define_class("Client", ruby.class_object())?;
+    client_class.define_singleton_method("new", function!(Client::new, -1))?;
+    client_class.define_method("request", method!(Client::request, -1))?;
+    client_class.define_method("get", method!(Client::get, -1))?;
+    client_class.define_method("post", method!(Client::post, -1))?;
+    client_class.define_method("put", method!(Client::put, -1))?;
+    client_class.define_method("delete", method!(Client::delete, -1))?;
+    client_class.define_method("head", method!(Client::head, -1))?;
+    client_class.define_method("options", method!(Client::options, -1))?;
+    client_class.define_method("trace", method!(Client::trace, -1))?;
+    client_class.define_method("patch", method!(Client::patch, -1))?;
+
+    resp::include(ruby, gem_module)?;
+    body::include(ruby, gem_module)?;
+    Ok(())
+}

data/src/cookie.rs

@@ -0,0 +1,277 @@
+use std::{fmt, sync::Arc, time::SystemTime};
+
+use cookie::{Cookie as RawCookie, Expiration, ParseError, time::Duration};
+use magnus::{
+    Error, Module, Object, RModule, Ruby, Value, function, method, typed_data::Obj,
+    value::ReprValue,
+};
+use wreq::header::{self, HeaderMap, HeaderValue};
+
+use crate::gvl;
+
+define_ruby_enum!(
+    /// The Cookie SameSite attribute.
+    const,
+    SameSite,
+    "Wreq::SameSite",
+    cookie::SameSite,
+    Strict,
+    Lax,
+    None,
+);
+
+/// A single HTTP cookie.
+#[derive(Clone)]
+#[magnus::wrap(class = "Wreq::Cookie", free_immediately, size)]
+pub struct Cookie(RawCookie<'static>);
+
+/// A good default `CookieStore` implementation.
+///
+/// This is the implementation used when simply calling `cookie_store(true)`.
+/// This type is exposed to allow creating one and filling it with some
+/// existing cookies more easily, before creating a `Client`.
+#[derive(Clone, Default)]
+#[magnus::wrap(class = "Wreq::Jar", free_immediately, size)]
+pub struct Jar(pub Arc<wreq::cookie::Jar>);
+
+// ===== impl Cookie =====
+
+impl Cookie {
+    /// Create a new [`Cookie`].
+    pub fn new(args: &[Value]) -> Result<Self, Error> {
+        let args =
+            magnus::scan_args::scan_args::<(String, String), (), (), (), magnus::RHash, ()>(args)?;
+        #[allow(clippy::type_complexity)]
+        let keywords: magnus::scan_args::KwArgs<
+            (),
+            (
+                Option<String>,
+                Option<String>,
+                Option<u64>,
+                Option<f64>,
+                Option<bool>,
+                Option<bool>,
+                Option<Obj<SameSite>>,
+            ),
+            (),
+        > = magnus::scan_args::get_kwargs(
+            args.keywords,
+            &[],
+            &[
+                "domain",
+                "path",
+                "max_age",
+                "expires",
+                "http_only",
+                "secure",
+                "same_site",
+            ],
+        )?;
+
+        let (name, value) = args.required;
+
+        let mut cookie = RawCookie::new(name, value);
+
+        if let Some(domain) = keywords.optional.0 {
+            cookie.set_domain(domain);
+        }
+
+        if let Some(path) = keywords.optional.1 {
+            cookie.set_path(path);
+        }
+
+        if let Some(max_age) = keywords.optional.2 {
+            cookie.set_max_age(Duration::seconds(max_age as i64));
+        }
+
+        if let Some(expires) = keywords.optional.3 {
+            let duration = std::time::Duration::from_secs_f64(expires);
+            if let Some(system_time) = SystemTime::UNIX_EPOCH.checked_add(duration) {
+                cookie.set_expires(Expiration::DateTime(system_time.into()));
+            }
+        }
+
+        cookie.set_http_only(keywords.optional.4);
+        cookie.set_secure(keywords.optional.5);
+
+        if let Some(same_site) = keywords.optional.6 {
+            cookie.set_same_site(same_site.into_ffi());
+        }
+
+        Ok(Self(cookie))
+    }
+
+    /// The name of the cookie.
+    #[inline]
+    pub fn name(&self) -> &str {
+        self.0.name()
+    }
+
+    /// The value of the cookie.
+    #[inline]
+    pub fn value(&self) -> &str {
+        self.0.value()
+    }
+
+    /// Returns true if the 'HttpOnly' directive is enabled.
+    #[inline]
+    pub fn http_only(&self) -> bool {
+        self.0.http_only().unwrap_or(false)
+    }
+
+    /// Returns true if the 'Secure' directive is enabled.
+    #[inline]
+    pub fn secure(&self) -> bool {
+        self.0.secure().unwrap_or(false)
+    }
+
+    /// Returns true if  'SameSite' directive is 'Lax'.
+    #[inline]
+    pub fn same_site_lax(&self) -> bool {
+        self.0.same_site() == Some(cookie::SameSite::Lax)
+    }
+
+    /// Returns true if  'SameSite' directive is 'Strict'.
+    #[inline]
+    pub fn same_site_strict(&self) -> bool {
+        self.0.same_site() == Some(cookie::SameSite::Strict)
+    }
+
+    /// Returns the path directive of the cookie, if set.
+    #[inline]
+    pub fn path(&self) -> Option<&str> {
+        self.0.path()
+    }
+
+    /// Returns the domain directive of the cookie, if set.
+    #[inline]
+    pub fn domain(&self) -> Option<&str> {
+        self.0.domain()
+    }
+
+    /// Get the Max-Age information.
+    #[inline]
+    pub fn max_age(&self) -> Option<i64> {
+        self.0.max_age().map(|d| d.whole_seconds())
+    }
+
+    /// The cookie expiration time.
+    #[inline]
+    pub fn expires(&self) -> Option<f64> {
+        match self.0.expires() {
+            Some(Expiration::DateTime(offset)) => {
+                let system_time = SystemTime::from(offset);
+                system_time
+                    .duration_since(SystemTime::UNIX_EPOCH)
+                    .ok()
+                    .map(|d| d.as_secs_f64())
+            }
+            None | Some(Expiration::Session) => None,
+        }
+    }
+}
+
+impl Cookie {
+    /// Parse cookies from a `HeaderMap`.
+    pub fn extract_headers_cookies(headers: &HeaderMap) -> Vec<Cookie> {
+        headers
+            .get_all(header::SET_COOKIE)
+            .iter()
+            .map(Cookie::parse)
+            .flat_map(Result::ok)
+            .map(RawCookie::into_owned)
+            .map(Cookie)
+            .collect()
+    }
+
+    fn parse<'a>(value: &'a HeaderValue) -> Result<RawCookie<'a>, ParseError> {
+        std::str::from_utf8(value.as_bytes())
+            .map_err(cookie::ParseError::from)
+            .and_then(RawCookie::parse)
+    }
+}
+
+impl fmt::Display for Cookie {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+// ===== impl Jar =====
+
+impl Jar {
+    /// Create a new [`Jar`] with an empty cookie store.
+    pub fn new() -> Self {
+        Jar(Arc::new(wreq::cookie::Jar::default()))
+    }
+
+    /// Get all cookies.
+    pub fn get_all(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        let cookies: Vec<Cookie> = rb_self
+            .0
+            .get_all()
+            .map(RawCookie::from)
+            .map(Cookie)
+            .collect();
+        let ary = ruby.ary_new_capa(cookies.len());
+        for cookie in cookies {
+            ary.push(cookie)?;
+        }
+        Ok(ary.as_value())
+    }
+
+    /// Add a cookie to this jar.
+    pub fn add_cookie(&self, cookie: &Cookie, url: String) {
+        gvl::nogvl(|| self.0.add(cookie.0.clone(), &url))
+    }
+
+    /// Add a cookie str to this jar.
+    pub fn add_cookie_str(&self, cookie: String, url: String) {
+        gvl::nogvl(|| self.0.add(cookie.as_ref(), &url))
+    }
+
+    /// Remove a cookie from this jar by name and URL.
+    pub fn remove(&self, name: String, url: String) {
+        gvl::nogvl(|| self.0.remove(name, &url))
+    }
+
+    /// Clear all cookies in this jar.
+    pub fn clear(&self) {
+        gvl::nogvl(|| self.0.clear())
+    }
+}
+
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    // SameSite enum
+    let same_site_class = gem_module.define_class("SameSite", ruby.class_object())?;
+    same_site_class.const_set("Strict", SameSite::Strict)?;
+    same_site_class.const_set("Lax", SameSite::Lax)?;
+    same_site_class.const_set("None", SameSite::None)?;
+
+    // Cookie class
+    let cookie_class = gem_module.define_class("Cookie", ruby.class_object())?;
+    cookie_class.define_singleton_method("new", function!(Cookie::new, -1))?;
+    cookie_class.define_method("name", method!(Cookie::name, 0))?;
+    cookie_class.define_method("value", method!(Cookie::value, 0))?;
+    cookie_class.define_method("http_only", method!(Cookie::http_only, 0))?;
+    cookie_class.define_method("http_only?", method!(Cookie::http_only, 0))?;
+    cookie_class.define_method("secure", method!(Cookie::secure, 0))?;
+    cookie_class.define_method("secure?", method!(Cookie::secure, 0))?;
+    cookie_class.define_method("same_site_lax?", method!(Cookie::same_site_lax, 0))?;
+    cookie_class.define_method("same_site_strict?", method!(Cookie::same_site_strict, 0))?;
+    cookie_class.define_method("path", method!(Cookie::path, 0))?;
+    cookie_class.define_method("domain", method!(Cookie::domain, 0))?;
+    cookie_class.define_method("max_age", method!(Cookie::max_age, 0))?;
+    cookie_class.define_method("expires", method!(Cookie::expires, 0))?;
+
+    // Jar class
+    let jar_class = gem_module.define_class("Jar", ruby.class_object())?;
+    jar_class.define_singleton_method("new", function!(Jar::new, 0))?;
+    jar_class.define_method("get_all", method!(Jar::get_all, 0))?;
+    jar_class.define_method("add_cookie", method!(Jar::add_cookie, 2))?;
+    jar_class.define_method("add_cookie_str", method!(Jar::add_cookie_str, 2))?;
+    jar_class.define_method("remove", method!(Jar::remove, 2))?;
+    jar_class.define_method("clear", method!(Jar::clear, 0))?;
+
+    Ok(())
+}