RubyGems - wreq - Versions diffs - 1.2.12 → 1.2.13 - Mend

wreq 1.2.12 → 1.2.13

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 (25) hide show

checksums.yaml +4 -4
data/Cargo.lock +1 -1
data/Cargo.toml +1 -1
data/docs/fork-safety.md +49 -32
data/docs/interrupt-handling.md +4 -3
data/lib/wreq.rb +36 -12
data/lib/wreq_ruby/body.rb +9 -6
data/lib/wreq_ruby/client.rb +18 -14
data/lib/wreq_ruby/cookie.rb +9 -0
data/lib/wreq_ruby/error.rb +7 -5
data/lib/wreq_ruby/response.rb +23 -7
data/src/arch.rs +83 -37
data/src/client/body/stream.rs +15 -24
data/src/client/req.rs +119 -122
data/src/client/resp.rs +101 -55
data/src/client.rs +78 -36
data/src/cookie.rs +47 -11
data/src/error.rs +1 -1
data/src/lib.rs +0 -2
data/src/macros.rs +0 -1
data/src/rt.rs +20 -36
data/test/fork_test.rb +30 -6
data/test/scripts/fork_safety.rb +66 -43
data/test/scripts/prefork_runtime.rb +95 -0
metadata +2 -1

data/src/client/resp.rs CHANGED Viewed

@@ -22,7 +22,10 @@ use crate::{
 /// A response from a request.
 #[magnus::wrap(class = "Wreq::Response", free_immediately, size)]
-pub struct Response {
+pub struct Response(ProcessLocal<ResponseInner>);
+/// Inner response state owned by the process that received it.
+struct ResponseInner {
     uri: Uri,
     version: Version,
     status: StatusCode,
@@ -30,7 +33,8 @@ pub struct Response {
     headers: HeaderMap,
     local_addr: Option<SocketAddr>,
     remote_addr: Option<SocketAddr>,
-    state: ProcessLocal<NativeResponseState>,
+    body: ArcSwapOption<Body>,
+    extensions: Extensions,
 }
 /// Represents the state of the HTTP response body.
@@ -41,12 +45,6 @@ enum Body {
     Reusable(Bytes),
 }
-/// Response state that may contain handles owned by the native runtime.
-struct NativeResponseState {
-    body: ArcSwapOption<Body>,
-    extensions: Extensions,
-}
 impl Response {
     /// Create a new [`Response`] instance.
     pub fn new(response: wreq::Response) -> Self {
@@ -57,7 +55,7 @@ impl Response {
         let response = HttpResponse::from(response);
         let (parts, body) = response.into_parts();
-        Response {
+        Response(ProcessLocal::new(ResponseInner {
             uri,
             local_addr,
             remote_addr,
@@ -65,23 +63,20 @@ impl Response {
             version: Version::from_ffi(parts.version),
             status: StatusCode::from(parts.status),
             headers: parts.headers,
-            state: ProcessLocal::new(NativeResponseState {
-                body: ArcSwapOption::from_pointee(Body::Streamable(body)),
-                extensions: parts.extensions,
-            }),
-        }
+            body: ArcSwapOption::from_pointee(Body::Streamable(body)),
+            extensions: parts.extensions,
+        }))
     }
     /// Internal method to get the wreq::Response, optionally streaming the body.
     fn response(&self, ruby: &Ruby, stream: bool) -> Result<wreq::Response, Error> {
-        rt::ensure_current(ruby)?;
-        let state = self.state.as_ref();
+        let state = self.0.get(ruby)?;
         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.version_mut() = state.version.into_ffi();
+            *response.status_mut() = state.status.0;
+            *response.headers_mut() = state.headers.clone();
             *response.extensions_mut() = state.extensions.clone();
             wreq::Response::from(response)
         };
@@ -92,11 +87,11 @@ impl Response {
                     return if stream {
                         Ok(build_response(body))
                     } else {
-                        let bytes = rt::try_block_on(
+                        let bytes = rt::block_on(
                             ruby,
                             BodyExt::collect(body).map_ok(|buf| buf.to_bytes()),
-                            wreq_error,
-                        )?;
+                        )?
+                        .map_err(|err| wreq_error(ruby, err))?;
                         state
                             .body
@@ -124,38 +119,66 @@ impl Response {
 impl Response {
     /// Get the response status code as a u16.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn code(&self) -> u16 {
-        self.status.0.as_u16()
+    pub fn code(ruby: &Ruby, rb_self: &Self) -> Result<u16, Error> {
+        rb_self
+            .0
+            .get(ruby)
+            .map(|response| response.status.0.as_u16())
     }
     /// Get the response status code.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn status(&self) -> StatusCode {
-        self.status
+    pub fn status(ruby: &Ruby, rb_self: &Self) -> Result<StatusCode, Error> {
+        rb_self.0.get(ruby).map(|response| response.status)
     }
     /// Get the response HTTP version.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn version(&self) -> Version {
-        self.version
+    pub fn version(ruby: &Ruby, rb_self: &Self) -> Result<Version, Error> {
+        rb_self.0.get(ruby).map(|response| response.version)
     }
     /// Get the response URL.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn url(&self) -> String {
-        self.uri.to_string()
+    pub fn url(ruby: &Ruby, rb_self: &Self) -> Result<String, Error> {
+        rb_self.0.get(ruby).map(|response| response.uri.to_string())
     }
     /// Get the content length of the response, if known.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn content_length(&self) -> Option<u64> {
-        self.content_length
+    pub fn content_length(ruby: &Ruby, rb_self: &Self) -> Result<Option<u64>, Error> {
+        rb_self.0.get(ruby).map(|response| response.content_length)
     }
     /// Get the response cookies.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     pub fn cookies(ruby: &Ruby, rb_self: &Self) -> Result<RArray, Error> {
-        let cookies = Cookie::extract_headers_cookies(&rb_self.headers);
+        let response = rb_self.0.get(ruby)?;
+        let cookies = Cookie::extract_headers_cookies(&response.headers);
         let ary = ruby.ary_new_capa(cookies.len());
         for cookie in cookies {
             ary.push(cookie)?;
@@ -164,63 +187,86 @@ impl Response {
     }
     /// Get the response headers.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn headers(&self) -> Headers {
-        Headers::from(self.headers.clone())
+    pub fn headers(ruby: &Ruby, rb_self: &Self) -> Result<Headers, Error> {
+        rb_self
+            .0
+            .get(ruby)
+            .map(|response| Headers::from(response.headers.clone()))
     }
     /// Get the local socket address, if available.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn local_addr(&self) -> Option<String> {
-        self.local_addr.map(|addr| addr.to_string())
+    pub fn local_addr(ruby: &Ruby, rb_self: &Self) -> Result<Option<String>, Error> {
+        rb_self
+            .0
+            .get(ruby)
+            .map(|response| response.local_addr.map(|addr| addr.to_string()))
     }
     /// Get the remote socket address, if available.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
     #[inline]
-    pub fn remote_addr(&self) -> Option<String> {
-        self.remote_addr.map(|addr| addr.to_string())
+    pub fn remote_addr(ruby: &Ruby, rb_self: &Self) -> Result<Option<String>, Error> {
+        rb_self
+            .0
+            .get(ruby)
+            .map(|response| response.remote_addr.map(|addr| addr.to_string()))
     }
     /// Return peer certificate data retained for this response.
-    fn tls_info(&self) -> Option<TlsInfo> {
-        self.state
-            .as_ref()
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the response belongs to a parent process.
+    fn tls_info(ruby: &Ruby, rb_self: &Self) -> Result<Option<TlsInfo>, Error> {
+        Ok(rb_self
+            .0
+            .get(ruby)?
             .extensions
             .get::<wreq::tls::TlsInfo>()
             .cloned()
-            .map(TlsInfo)
+            .map(TlsInfo))
     }
     /// Get the response body as bytes.
     pub fn bytes(ruby: &Ruby, rb_self: &Self) -> Result<Bytes, Error> {
         let response = rb_self.response(ruby, false)?;
-        rt::try_block_on(ruby, response.bytes(), wreq_error)
+        rt::block_on(ruby, response.bytes())?.map_err(|err| wreq_error(ruby, err))
     }
     ///  Get the full response text given a specific encoding.
     pub fn text(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<String, Error> {
-        rt::ensure_current(ruby)?;
         let args = scan_args::<(), (Option<String>,), (), (), (), ()>(args)?;
         let response = rb_self.response(ruby, false)?;
         match args.optional.0 {
-            Some(encoding) => {
-                rt::try_block_on(ruby, response.text_with_charset(encoding), wreq_error)
-            }
-            None => rt::try_block_on(ruby, response.text(), wreq_error),
+            Some(encoding) => rt::block_on(ruby, response.text_with_charset(encoding))?
+                .map_err(|err| wreq_error(ruby, err)),
+            None => rt::block_on(ruby, response.text())?.map_err(|err| wreq_error(ruby, err)),
         }
     }
     /// Get the response body as JSON.
     pub fn json(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
         let response = rb_self.response(ruby, false)?;
-        let json = rt::try_block_on(ruby, response.json::<Json>(), wreq_error)?;
+        let json =
+            rt::block_on(ruby, response.json::<Json>())?.map_err(|err| wreq_error(ruby, err))?;
         crate::serde::serialize(ruby, &json)
     }
     /// Yield response body chunks to the given Ruby block.
     pub fn chunks(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
-        rt::ensure_current(ruby)?;
         if !ruby.block_given() {
             return Err(no_block_given_error(ruby));
         }
@@ -241,11 +287,11 @@ impl Response {
     ///
     /// # Errors
     ///
-    /// Returns `Wreq::ForkError` before touching a body inherited from the
+    /// Returns `Wreq::ForkError` before touching a response inherited from the
     /// parent process.
     pub fn close(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
-        rt::ensure_current(ruby)?;
-        gvl::nogvl(|| rb_self.state.as_ref().body.swap(None));
+        let response = rb_self.0.get(ruby)?;
+        gvl::nogvl(|| response.body.swap(None));
         Ok(())
     }
 }

data/src/client.rs CHANGED Viewed

@@ -21,7 +21,6 @@ use crate::{
     header::{Headers, OrigHeaders, UserAgent},
     http::Method,
     options::{NativeOption, Options},
-    rt,
 };
 /// A builder for `Client`.
@@ -51,7 +50,7 @@ struct Builder {
     cookie_store: Option<bool>,
     /// Whether to use cookie store provider.
     #[serde(default)]
-    cookie_provider: NativeOption<Jar>,
+    cookie_provider: NativeOption<Obj<Jar>>,
     // ========= Timeout options =========
     /// The timeout to use for the client. (in seconds)
@@ -121,7 +120,6 @@ struct Builder {
     zstd: Option<bool>,
 }
-#[derive(Clone)]
 #[magnus::wrap(class = "Wreq::Client", free_immediately, size)]
 pub struct Client(ProcessLocal<wreq::Client>);
@@ -171,12 +169,7 @@ impl Builder {
         extract_native_option!(options, builder, user_agent);
         extract_native_option!(options, builder, headers);
         extract_native_option!(options, builder, orig_headers);
-        extract_native_option!(
-            options,
-            builder,
-            cookie_provider,
-            Obj<Jar> => |value| (*value).clone()
-        );
+        extract_native_option!(options, builder, cookie_provider);
         builder
             .proxy
             .set(Extractor::<Proxy>::try_convert(options.as_value())?.into_inner());
@@ -193,11 +186,9 @@ impl Client {
     /// # Errors
     ///
     /// Returns Ruby configuration errors from [`Builder::from_options`] or the
-    /// native fallible client builder. Extra positional arguments return
-    /// `ArgumentError`.
+    /// native fallible client builder. An inherited cookie provider returns
+    /// `Wreq::ForkError`, and extra positional arguments return `ArgumentError`.
     pub fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, magnus::Error> {
-        rt::ensure_current(ruby)?;
         Options::from_args(ruby, args, "client")?
             .map(Builder::from_options)
             .transpose()
@@ -221,12 +212,15 @@ impl Client {
     ///
     /// # Errors
     ///
-    /// Returns `Wreq::ForkError` before touching native client state when the
-    /// extension was inherited from a parent process. Maps native build
-    /// failures only after the GVL has been reacquired.
+    /// Returns `Wreq::ForkError` if the cookie provider belongs to a parent
+    /// process. Native build failures are mapped only after the GVL has been
+    /// reacquired.
     fn build(ruby: &Ruby, mut params: Builder) -> Result<wreq::Client, magnus::Error> {
-        rt::ensure_current(ruby)?;
+        let mut cookie_provider = params
+            .cookie_provider
+            .take()
+            .map(|jar| jar.clone_store(ruby))
+            .transpose()?;
         let result = gvl::nogvl(|| {
             let mut builder = wreq::Client::builder();
@@ -270,12 +264,7 @@ impl Client {
             // 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
-            );
+            apply_option!(set_if_some, builder, cookie_provider, cookie_provider);
             // TCP options.
             apply_option!(
@@ -393,9 +382,14 @@ impl Client {
         result.map_err(|err| wreq_error(ruby, err))
     }
-    /// Clone the native client handle for a request future.
-    fn native_client(&self) -> wreq::Client {
-        self.0.as_ref().clone()
+    /// Clone the native client handle in the process that created it.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the client was inherited from a parent
+    /// process.
+    fn native_client(&self, ruby: &Ruby) -> Result<wreq::Client, magnus::Error> {
+        self.0.get(ruby).cloned()
     }
 }
@@ -431,63 +425,111 @@ impl Client {
     #[inline]
     pub fn request(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
         let ((method, url), request) = extract_request!(ruby, args, (Obj<Method>, String));
-        execute_request(ruby, rb_self.native_client(), *method, url, request)
+        execute_request(ruby, rb_self.native_client(ruby)?, *method, url, request)
     }
     /// Send a GET request.
     #[inline]
     pub fn get(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
         let ((url,), request) = extract_request!(ruby, args, (String,));
-        execute_request(ruby, rb_self.native_client(), Method::GET, url, request)
+        execute_request(
+            ruby,
+            rb_self.native_client(ruby)?,
+            Method::GET,
+            url,
+            request,
+        )
     }
     /// Send a POST request.
     #[inline]
     pub fn post(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
         let ((url,), request) = extract_request!(ruby, args, (String,));
-        execute_request(ruby, rb_self.native_client(), Method::POST, url, request)
+        execute_request(
+            ruby,
+            rb_self.native_client(ruby)?,
+            Method::POST,
+            url,
+            request,
+        )
     }
     /// Send a PUT request.
     #[inline]
     pub fn put(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
         let ((url,), request) = extract_request!(ruby, args, (String,));
-        execute_request(ruby, rb_self.native_client(), Method::PUT, url, request)
+        execute_request(
+            ruby,
+            rb_self.native_client(ruby)?,
+            Method::PUT,
+            url,
+            request,
+        )
     }
     /// Send a DELETE request.
     #[inline]
     pub fn delete(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
         let ((url,), request) = extract_request!(ruby, args, (String,));
-        execute_request(ruby, rb_self.native_client(), Method::DELETE, url, request)
+        execute_request(
+            ruby,
+            rb_self.native_client(ruby)?,
+            Method::DELETE,
+            url,
+            request,
+        )
     }
     /// Send a HEAD request.
     #[inline]
     pub fn head(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
         let ((url,), request) = extract_request!(ruby, args, (String,));
-        execute_request(ruby, rb_self.native_client(), Method::HEAD, url, request)
+        execute_request(
+            ruby,
+            rb_self.native_client(ruby)?,
+            Method::HEAD,
+            url,
+            request,
+        )
     }
     /// Send an OPTIONS request.
     #[inline]
     pub fn options(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
         let ((url,), request) = extract_request!(ruby, args, (String,));
-        execute_request(ruby, rb_self.native_client(), Method::OPTIONS, url, request)
+        execute_request(
+            ruby,
+            rb_self.native_client(ruby)?,
+            Method::OPTIONS,
+            url,
+            request,
+        )
     }
     /// Send a TRACE request.
     #[inline]
     pub fn trace(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
         let ((url,), request) = extract_request!(ruby, args, (String,));
-        execute_request(ruby, rb_self.native_client(), Method::TRACE, url, request)
+        execute_request(
+            ruby,
+            rb_self.native_client(ruby)?,
+            Method::TRACE,
+            url,
+            request,
+        )
     }
     /// Send a PATCH request.
     #[inline]
     pub fn patch(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Response, magnus::Error> {
         let ((url,), request) = extract_request!(ruby, args, (String,));
-        execute_request(ruby, rb_self.native_client(), Method::PATCH, url, request)
+        execute_request(
+            ruby,
+            rb_self.native_client(ruby)?,
+            Method::PATCH,
+            url,
+            request,
+        )
     }
 }

data/src/cookie.rs CHANGED Viewed

@@ -18,6 +18,7 @@ use magnus::{
 use wreq::header::{self, HeaderMap, HeaderValue};
 use crate::{
+    arch::ProcessLocal,
     error::{header_value_error, type_error},
     gvl,
     options::{NativeOption, Options},
@@ -78,9 +79,14 @@ struct Builder {
 /// A cookie jar that can be shared with a Ruby `Wreq::Client`.
 ///
 /// Pass a populated jar as the client's `cookie_provider` option.
-#[derive(Clone, Default)]
 #[magnus::wrap(class = "Wreq::Jar", free_immediately, size)]
-pub struct Jar(pub Arc<wreq::cookie::Jar>);
+pub struct Jar(ProcessLocal<Arc<wreq::cookie::Jar>>);
+impl Default for Jar {
+    fn default() -> Self {
+        Self(ProcessLocal::new(Arc::new(wreq::cookie::Jar::default())))
+    }
+}
 // ===== impl Builder =====
@@ -309,13 +315,18 @@ impl TryConvert for Cookies {
 impl Jar {
     /// Create a new [`Jar`] with an empty cookie store.
     pub fn new() -> Self {
-        Self(Arc::new(wreq::cookie::Jar::default()))
+        Self::default()
     }
     /// Get all cookies.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the jar belongs to a parent process.
     pub fn get_all(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
         let cookies: Vec<Cookie> = rb_self
             .0
+            .get(ruby)?
             .get_all()
             .map(RawCookie::from)
             .map(Cookie)
@@ -331,28 +342,53 @@ impl Jar {
     ///
     /// # Errors
     ///
-    /// Returns `TypeError` when `cookie` is neither a [`Cookie`] nor a String.
+    /// Returns `Wreq::ForkError` when the jar belongs to a parent process, or
+    /// `TypeError` when `cookie` is neither a [`Cookie`] nor a String.
     pub fn add(&self, cookie: Value, url: String) -> Result<(), Error> {
+        let ruby = Ruby::get_with(cookie);
+        let jar = self.0.get(&ruby)?;
         if let Ok(cookie) = Obj::<Cookie>::try_convert(cookie) {
-            gvl::nogvl(|| self.0.add(cookie.clone_for_jar(), &url));
+            gvl::nogvl(|| jar.add(cookie.clone_for_jar(), &url));
             return Ok(());
         }
-        let ruby = Ruby::get_with(cookie);
         let cookie = String::try_convert(cookie)
             .map_err(|_| type_error(&ruby, "cookie must be a Wreq::Cookie or String"))?;
-        gvl::nogvl(|| self.0.add(cookie.as_ref(), &url));
+        gvl::nogvl(|| jar.add(cookie.as_ref(), &url));
         Ok(())
     }
     /// 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))
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the jar belongs to a parent process.
+    pub fn remove(ruby: &Ruby, rb_self: &Self, name: String, url: String) -> Result<(), Error> {
+        let jar = rb_self.0.get(ruby)?;
+        gvl::nogvl(|| jar.remove(name, &url));
+        Ok(())
     }
     /// Clear all cookies in this jar.
-    pub fn clear(&self) {
-        gvl::nogvl(|| self.0.clear())
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the jar belongs to a parent process.
+    pub fn clear(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        let jar = rb_self.0.get(ruby)?;
+        gvl::nogvl(|| jar.clear());
+        Ok(())
+    }
+    /// Clone the shared native store in the process that created this jar.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Wreq::ForkError` when the jar was inherited from a parent
+    /// process.
+    pub(crate) fn clone_store(&self, ruby: &Ruby) -> Result<Arc<wreq::cookie::Jar>, Error> {
+        self.0.get(ruby).cloned()
     }
 }

data/src/error.rs CHANGED Viewed

@@ -105,7 +105,7 @@ pub fn fork_error(ruby: &Ruby, owner_pid: u32, current_pid: u32) -> MagnusError
     MagnusError::new(
         ruby.get_inner(&FORK_ERROR),
         format!(
-            "wreq-ruby was loaded in process {owner_pid} and cannot be used after fork in process {current_pid}"
+            "wreq-ruby native state was created in process {owner_pid} and cannot be used after fork in process {current_pid}"
         ),
     )
 }

data/src/lib.rs CHANGED Viewed

@@ -102,7 +102,5 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     tls::include(ruby, &gem_module)?;
     client::include(ruby, &gem_module)?;
     emulate::include(ruby, &gem_module)?;
-    #[cfg(unix)]
-    rt::initialize(ruby)?;
     Ok(())
 }

data/src/macros.rs CHANGED Viewed

@@ -149,7 +149,6 @@ macro_rules! define_ruby_enum {
 macro_rules! extract_request {
     ($ruby:expr, $args:expr, $required:ty) => {{
-        crate::rt::ensure_current($ruby)?;
         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)?;