RubyGems - wreq - Versions diffs - 1.0.0 - Mend

wreq 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (59) hide show

checksums.yaml +7 -0
data/Cargo.toml +54 -0
data/Gemfile +17 -0
data/LICENSE +201 -0
data/README.md +150 -0
data/Rakefile +90 -0
data/build.rs +9 -0
data/examples/body.rb +42 -0
data/examples/client.rb +33 -0
data/examples/emulation_request.rb +37 -0
data/examples/headers.rb +27 -0
data/examples/proxy.rb +113 -0
data/examples/send_stream.rb +85 -0
data/examples/stream.rb +14 -0
data/examples/thread_interrupt.rb +83 -0
data/extconf.rb +7 -0
data/lib/wreq.rb +313 -0
data/lib/wreq_ruby/body.rb +36 -0
data/lib/wreq_ruby/client.rb +516 -0
data/lib/wreq_ruby/cookie.rb +144 -0
data/lib/wreq_ruby/emulation.rb +186 -0
data/lib/wreq_ruby/error.rb +159 -0
data/lib/wreq_ruby/header.rb +197 -0
data/lib/wreq_ruby/http.rb +132 -0
data/lib/wreq_ruby/response.rb +208 -0
data/script/build_platform_gem.rb +34 -0
data/src/client/body/form.rs +2 -0
data/src/client/body/json.rs +16 -0
data/src/client/body/stream.rs +148 -0
data/src/client/body.rs +57 -0
data/src/client/param.rs +19 -0
data/src/client/query.rs +2 -0
data/src/client/req.rs +251 -0
data/src/client/resp.rs +250 -0
data/src/client.rs +392 -0
data/src/cookie.rs +277 -0
data/src/emulation.rs +317 -0
data/src/error.rs +147 -0
data/src/extractor.rs +199 -0
data/src/gvl.rs +154 -0
data/src/header.rs +177 -0
data/src/http.rs +127 -0
data/src/lib.rs +97 -0
data/src/macros.rs +118 -0
data/src/rt.rs +47 -0
data/test/client_cookie_test.rb +46 -0
data/test/client_test.rb +136 -0
data/test/cookie_test.rb +166 -0
data/test/emulation_test.rb +21 -0
data/test/error_handling_test.rb +89 -0
data/test/header_test.rb +290 -0
data/test/module_methods_test.rb +75 -0
data/test/request_parameters_test.rb +175 -0
data/test/request_test.rb +234 -0
data/test/response_test.rb +69 -0
data/test/stream_test.rb +81 -0
data/test/test_helper.rb +9 -0
data/wreq.gemspec +68 -0
metadata +112 -0

data/src/client/req.rs ADDED Viewed

@@ -0,0 +1,251 @@
+use std::{net::IpAddr, time::Duration};
+use http::{HeaderValue, header};
+use magnus::{RHash, TryConvert, typed_data::Obj, value::ReprValue};
+use serde::Deserialize;
+use wreq::{
+    Client, Proxy, Version,
+    header::{HeaderMap, OrigHeaderMap},
+};
+use super::body::{Body, Form, Json};
+use crate::{
+    client::{query::Query, resp::Response},
+    emulation::Emulation,
+    error::wreq_error_to_magnus,
+    extractor::Extractor,
+    http::Method,
+    rt,
+};
+/// The parameters for a request.
+#[derive(Default, Deserialize)]
+#[non_exhaustive]
+pub struct Request {
+    /// The emulation option for the request.
+    #[serde(skip)]
+    emulation: Option<Emulation>,
+    /// The proxy to use for the request.
+    #[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>,
+    /// The timeout to use for the request.
+    timeout: Option<u64>,
+    /// The read timeout to use for the request.
+    read_timeout: Option<u64>,
+    /// The HTTP version to use for the request.
+    #[serde(skip)]
+    version: Option<Version>,
+    /// The headers to use for the request.
+    #[serde(skip)]
+    headers: Option<HeaderMap>,
+    /// The original headers to use for the request.
+    #[serde(skip)]
+    orig_headers: Option<OrigHeaderMap>,
+    /// The option enables default headers.
+    default_headers: Option<bool>,
+    /// The cookies to use for the request.
+    #[serde(skip)]
+    cookies: Option<Vec<HeaderValue>>,
+    /// Whether to allow redirects.
+    allow_redirects: Option<bool>,
+    /// The maximum number of redirects to follow.
+    max_redirects: Option<usize>,
+    /// 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>,
+    /// The authentication to use for the request.
+    auth: Option<String>,
+    /// The bearer authentication to use for the request.
+    bearer_auth: Option<String>,
+    /// The basic authentication to use for the request.
+    basic_auth: Option<(String, Option<String>)>,
+    /// The query parameters to use for the request.
+    query: Option<Query>,
+    /// The form parameters to use for the request.
+    form: Option<Form>,
+    /// The JSON body to use for the request.
+    json: Option<Json>,
+    /// The body to use for the request.
+    #[serde(skip)]
+    body: Option<Body>,
+}
+impl Request {
+    /// Create a new [`Request`] from Ruby keyword arguments.
+    pub fn new(ruby: &magnus::Ruby, hash: RHash) -> Result<Self, magnus::Error> {
+        let kwargs = hash.as_value();
+        let mut builder: Self = serde_magnus::deserialize(ruby, kwargs)?;
+        // 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 version handling
+        builder.version = Extractor::<Version>::try_convert(kwargs)?.into_inner();
+        // extra headers handling
+        builder.headers = Extractor::<HeaderMap>::try_convert(kwargs)?.into_inner();
+        // extra original headers handling
+        builder.orig_headers = Extractor::<OrigHeaderMap>::try_convert(kwargs)?.into_inner();
+        // extra cookies handling
+        builder.cookies = Extractor::<Vec<HeaderValue>>::try_convert(kwargs)?.into_inner();
+        // extra proxy handling
+        builder.proxy = Extractor::<Proxy>::try_convert(kwargs)?.into_inner();
+        // extra body handling
+        if let Some(body) = hash.get(ruby.to_symbol("body")) {
+            builder.body = Some(Body::try_convert(body)?);
+        }
+        Ok(builder)
+    }
+}
+pub fn execute_request<U: AsRef<str>>(
+    client: Client,
+    method: Method,
+    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, builder, request.version, version);
+        // 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, builder, request.headers, headers);
+        apply_option!(set_if_some, builder, request.orig_headers, orig_headers);
+        apply_option!(
+            set_if_some,
+            builder,
+            request.default_headers,
+            default_headers
+        );
+        // 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);
+        }
+        // Cookies options.
+        if let Some(cookies) = request.cookies.take() {
+            for cookie in cookies {
+                builder = builder.header(header::COOKIE, cookie);
+            }
+        }
+        // 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)
+    })
+}

data/src/client/resp.rs ADDED Viewed

@@ -0,0 +1,250 @@
+use std::{net::SocketAddr, sync::Arc};
+use arc_swap::ArcSwapOption;
+use bytes::Bytes;
+use futures_util::TryFutureExt;
+use http::{Extensions, HeaderMap, response::Response as HttpResponse};
+use http_body_util::BodyExt;
+use magnus::{Error, Module, RArray, RModule, Ruby, Value, block::Yield};
+use wreq::Uri;
+use crate::{
+    client::body::{BodyReceiver, Json},
+    cookie::Cookie,
+    error::{memory_error, wreq_error_to_magnus},
+    gvl,
+    header::Headers,
+    http::{StatusCode, Version},
+    rt,
+};
+/// A response from a request.
+#[magnus::wrap(class = "Wreq::Response", free_immediately, size)]
+pub struct Response {
+    uri: Uri,
+    version: Version,
+    status: StatusCode,
+    content_length: Option<u64>,
+    headers: HeaderMap,
+    local_addr: Option<SocketAddr>,
+    remote_addr: Option<SocketAddr>,
+    body: ArcSwapOption<Body>,
+    extensions: Extensions,
+}
+/// Represents the state of the HTTP response body.
+enum Body {
+    /// The body can be streamed once (not yet buffered).
+    Streamable(wreq::Body),
+    /// The body has been fully read into memory and can be reused.
+    Reusable(Bytes),
+}
+impl Response {
+    /// Create a new [`Response`] instance.
+    pub fn new(response: wreq::Response) -> Self {
+        let uri = response.uri().clone();
+        let content_length = response.content_length();
+        let local_addr = response.local_addr();
+        let remote_addr = response.remote_addr();
+        let response = HttpResponse::from(response);
+        let (parts, body) = response.into_parts();
+        Response {
+            uri,
+            local_addr,
+            remote_addr,
+            content_length,
+            extensions: parts.extensions,
+            version: Version::from_ffi(parts.version),
+            status: StatusCode::from(parts.status),
+            headers: parts.headers,
+            body: ArcSwapOption::from_pointee(Body::Streamable(body)),
+        }
+    }
+    /// Internal method to get the wreq::Response, optionally streaming the body.
+    fn response(&self, stream: bool) -> Result<wreq::Response, Error> {
+        let build_response = |body: wreq::Body| -> wreq::Response {
+            let mut response = HttpResponse::new(body);
+            *response.version_mut() = self.version.into_ffi();
+            *response.status_mut() = self.status.0;
+            *response.headers_mut() = self.headers.clone();
+            *response.extensions_mut() = self.extensions.clone();
+            wreq::Response::from(response)
+        };
+        if let Some(arc) = self.body.swap(None) {
+            match Arc::try_unwrap(arc) {
+                Ok(Body::Streamable(body)) => {
+                    return if stream {
+                        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),
+                        )?;
+                        self.body
+                            .store(Some(Arc::new(Body::Reusable(bytes.clone()))));
+                        Ok(build_response(wreq::Body::from(bytes)))
+                    };
+                }
+                Ok(Body::Reusable(bytes)) => {
+                    self.body
+                        .store(Some(Arc::new(Body::Reusable(bytes.clone()))));
+                    if !stream {
+                        return Ok(build_response(wreq::Body::from(bytes)));
+                    }
+                }
+                _ => {}
+            };
+        }
+        Err(memory_error())
+    }
+}
+impl Response {
+    /// Get the response status code as a u16.
+    #[inline]
+    pub fn code(&self) -> u16 {
+        self.status.0.as_u16()
+    }
+    /// Get the response status code.
+    #[inline]
+    pub fn status(&self) -> StatusCode {
+        self.status
+    }
+    /// Get the response HTTP version.
+    #[inline]
+    pub fn version(&self) -> Version {
+        self.version
+    }
+    /// Get the response URL.
+    #[inline]
+    pub fn url(&self) -> String {
+        self.uri.to_string()
+    }
+    /// Get the content length of the response, if known.
+    #[inline]
+    pub fn content_length(&self) -> Option<u64> {
+        self.content_length
+    }
+    /// Get the response cookies.
+    pub fn cookies(ruby: &Ruby, rb_self: &Self) -> Result<RArray, Error> {
+        let cookies = Cookie::extract_headers_cookies(&rb_self.headers);
+        let ary = ruby.ary_new_capa(cookies.len());
+        for cookie in cookies {
+            ary.push(cookie)?;
+        }
+        Ok(ary)
+    }
+    /// Get the response headers.
+    #[inline]
+    pub fn headers(&self) -> Headers {
+        Headers::from(self.headers.clone())
+    }
+    /// Get the local socket address, if available.
+    #[inline]
+    pub fn local_addr(&self) -> Option<String> {
+        self.local_addr.map(|addr| addr.to_string())
+    }
+    /// Get the remote socket address, if available.
+    #[inline]
+    pub fn remote_addr(&self) -> Option<String> {
+        self.remote_addr.map(|addr| addr.to_string())
+    }
+    /// 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))
+    }
+    /// Get the response body as a UTF-8 string.
+    pub fn text(&self) -> Result<String, Error> {
+        let response = self.response(false)?;
+        rt::try_block_on(response.text().map_err(wreq_error_to_magnus))
+    }
+    ///  Get the full response text given a specific encoding.
+    pub fn text_with_charset(&self, default_encoding: String) -> Result<String, Error> {
+        let response = self.response(false)?;
+        rt::try_block_on(
+            response
+                .text_with_charset(default_encoding)
+                .map_err(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)
+        })
+    }
+    /// Get a chunk iterator for the response body.
+    pub fn chunks(&self) -> Result<Yield<BodyReceiver>, Error> {
+        self.response(true)
+            .map(wreq::Response::bytes_stream)
+            .map(BodyReceiver::new)
+            .map(Yield::Iter)
+    }
+    /// Close the response body, dropping any resources.
+    #[inline]
+    pub fn close(&self) {
+        gvl::nogvl(|| self.body.swap(None));
+    }
+}
+impl Drop for Response {
+    fn drop(&mut self) {
+        // Ensure body is dropped in GVL
+        self.body.swap(None);
+    }
+}
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let response_class = gem_module.define_class("Response", ruby.class_object())?;
+    response_class.define_method("code", magnus::method!(Response::code, 0))?;
+    response_class.define_method("status", magnus::method!(Response::status, 0))?;
+    response_class.define_method("version", magnus::method!(Response::version, 0))?;
+    response_class.define_method("url", magnus::method!(Response::url, 0))?;
+    response_class.define_method(
+        "content_length",
+        magnus::method!(Response::content_length, 0),
+    )?;
+    response_class.define_method("cookies", magnus::method!(Response::cookies, 0))?;
+    response_class.define_method("headers", magnus::method!(Response::headers, 0))?;
+    response_class.define_method("local_addr", magnus::method!(Response::local_addr, 0))?;
+    response_class.define_method("remote_addr", magnus::method!(Response::remote_addr, 0))?;
+    response_class.define_method("bytes", magnus::method!(Response::bytes, 0))?;
+    response_class.define_method("text", magnus::method!(Response::text, 0))?;
+    response_class.define_method(
+        "text_with_charset",
+        magnus::method!(Response::text_with_charset, 1),
+    )?;
+    response_class.define_method("json", magnus::method!(Response::json, 0))?;
+    response_class.define_method("chunks", magnus::method!(Response::chunks, 0))?;
+    response_class.define_method("close", magnus::method!(Response::close, 0))?;
+    Ok(())
+}