wreq 1.1.0 → 1.2.0

data/lib/wreq_ruby/response.rb

@@ -88,26 +88,16 @@ unless defined?(Wreq)
       def bytes
       end
 
-      # Get the response body as text.
-      #
-      # @return [String] Response body decoded as UTF-8 text
-      # @example
-      #   html = response.text
-      #   puts html
-      # @raise [Wreq::DecodingError] if body cannot be decoded as binary
-      def text
-      end
-
       # Get the response body as text with a specific charset.
       # This method allows you to specify a default encoding
       # to use when decoding the response body.
       # # @param default_encoding [String] Default encoding to use (e.g., "UTF-8")
       # # @return [String] Response body decoded as text using the specified encoding
       # @example
-      #   html = response.text_with_charset("ISO-8859-1")
+      #   html = response.text("ISO-8859-1")
       #   puts html
       # @raise [Wreq::DecodingError] if body cannot be decoded with the specified encoding
-      def text_with_charset(default_encoding)
+      def text(default_encoding: "UTF-8")
       end
 
       # Parse the response body as JSON.
@@ -120,14 +110,17 @@ unless defined?(Wreq)
       def json
       end
 
-      # Get a streaming iterator for the response body, yielding each chunk.
+      # Stream the response body, yielding each chunk to the given block.
       #
       # This method allows you to process large HTTP responses efficiently,
       # by yielding each chunk of the body as it arrives, without loading
       # the entire response into memory.
       #
-      # @return An iterator over response body chunks (binary String)
+      # @return [nil]
       # @yield [chunk] Each chunk of the response body as a binary String
+      # @raise [LocalJumpError] if called without a block
+      # @raise [Wreq::TimeoutError, Wreq::BodyError, Wreq::ConnectionResetError, Wreq::RequestError]
+      #   if streaming fails while reading the response body
       # @example Save response to file
       #   File.open("output.bin", "wb") do |f|
       #     response.chunks { |chunk| f.write(chunk) }
@@ -137,7 +130,7 @@ unless defined?(Wreq)
       #   response.chunks { |chunk| total += chunk.bytesize }
       #   puts "Downloaded #{total} bytes"
       #
-      # Note: The returned Receiver is only for reading response bodies, not for uploads.
+      # Exceptions raised inside the block are propagated to the caller.
       def chunks
       end
 
@@ -156,27 +149,35 @@ end
 
 module Wreq
   class Response
-    # Returns a compact string representation of the response.
+    # Returns the response body as a string.
+    #
+    # @return [String] Response body text
+    # @example
+    #   puts response.to_s
+    #   puts response
+    #   File.write("page.html", response)
+    def to_s
+      text
+    end
+
+    # Returns a compact string representation for debugging.
     #
     # Format: #<Wreq::Response STATUS content-type="..." body=SIZE>
     #
     # @return [String] Compact formatted response information
     # @example
-    #   puts response.to_s
+    #   p response
     #   # => #<Wreq::Response 200 content-type="application/json" body=456B>
-    def to_s
+    def inspect
       parts = ["#<Wreq::Response"]
 
-      # Status code
       parts << code.to_s
 
-      # Content-Type header if present
       if headers.respond_to?(:get)
         content_type = headers.get("content-type")
         parts << "content-type=#{content_type.inspect}" if content_type
       end
 
-      # Body size
       if content_length
         parts << "body=#{format_bytes(content_length)}"
       end

data/src/client/body/stream.rs

@@ -13,7 +13,7 @@ use tokio::sync::{
 };
 
 use crate::{
-    error::{memory_error, mpsc_send_error_to_magnus},
+    error::{memory_error, mpsc_send_error_to_magnus, wreq_error_to_magnus},
     rt,
 };
 
@@ -37,20 +37,15 @@ impl BodyReceiver {
     pub fn new(stream: impl Stream<Item = wreq::Result<Bytes>> + Send + 'static) -> BodyReceiver {
         BodyReceiver(Mutex::new(Box::pin(stream)))
     }
-}
 
-impl Iterator for BodyReceiver {
-    type Item = Bytes;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        rt::maybe_block_on(async {
-            self.0
-                .lock()
-                .await
-                .as_mut()
-                .next()
-                .await
-                .and_then(|r| r.ok())
+    /// 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(wreq_error_to_magnus(err)),
+                None => Ok(None),
+            }
         })
     }
 }

data/src/client/req.rs

@@ -1,19 +1,18 @@
 use std::{net::IpAddr, time::Duration};
 
-use http::{HeaderValue, header};
+use http::header;
 use magnus::{RHash, TryConvert, typed_data::Obj, value::ReprValue};
 use serde::Deserialize;
-use wreq::{
-    Client, Proxy, Version,
-    header::{HeaderMap, OrigHeaderMap},
-};
+use wreq::{Client, Proxy, Version, header::OrigHeaderMap};
 
 use super::body::{Body, Form, Json};
 use crate::{
     client::{query::Query, resp::Response},
+    cookie::Cookies,
     emulate::Emulation,
     error::wreq_error_to_magnus,
     extractor::Extractor,
+    header::Headers,
     http::Method,
     rt,
 };
@@ -46,20 +45,20 @@ pub struct Request {
     #[serde(skip)]
     version: Option<Version>,
 
+    /// The option enables default headers.
+    default_headers: Option<bool>,
+
     /// The headers to use for the request.
     #[serde(skip)]
-    headers: Option<HeaderMap>,
+    headers: Option<Headers>,
 
     /// 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>>,
+    cookies: Option<Cookies>,
 
     /// Whether to allow redirects.
     allow_redirects: Option<bool>,
@@ -105,35 +104,30 @@ pub struct Request {
 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)?;
+        let keyword = hash.as_value();
+        let mut builder: Self = serde_magnus::deserialize(ruby, keyword)?;
 
-        // 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());
+        if let Some(v) = hash.get(ruby.to_symbol(stringify!(emulation))) {
+            let obj = Obj::<Emulation>::try_convert(v)?;
+            builder.emulation = Some((*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();
+        if let Some(v) = hash.get(ruby.to_symbol(stringify!(headers))) {
+            builder.headers = Some(Headers::try_convert(v)?);
+        }
 
-        // extra proxy handling
-        builder.proxy = Extractor::<Proxy>::try_convert(kwargs)?.into_inner();
+        if let Some(v) = hash.get(ruby.to_symbol(stringify!(cookies))) {
+            builder.cookies = Some(Cookies::try_convert(v)?);
+        }
 
-        // extra body handling
-        if let Some(body) = hash.get(ruby.to_symbol("body")) {
-            builder.body = Some(Body::try_convert(body)?);
+        if let Some(v) = hash.get(ruby.to_symbol(stringify!(body))) {
+            builder.body = Some(Body::try_convert(v)?);
         }
 
+        builder.proxy = Extractor::<Proxy>::try_convert(keyword)?.into_inner();
+        builder.version = Extractor::<Version>::try_convert(keyword)?.into_inner();
+        builder.orig_headers = Extractor::<OrigHeaderMap>::try_convert(keyword)?.into_inner();
+
         Ok(builder)
     }
 }
@@ -175,7 +169,7 @@ pub fn execute_request<U: AsRef<str>>(
         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_into_inner, builder, request.headers, headers);
         apply_option!(set_if_some, builder, request.orig_headers, orig_headers);
         apply_option!(
             set_if_some,
@@ -184,6 +178,13 @@ pub fn execute_request<U: AsRef<str>>(
             default_headers
         );
 
+        // Cookies options.
+        if let Some(cookies) = request.cookies.take() {
+            for cookie in cookies.0 {
+                builder = builder.header(header::COOKIE, cookie);
+            }
+        }
+
         // Authentication options.
         apply_option!(
             set_if_some_map_ref,
@@ -197,13 +198,6 @@ pub fn execute_request<U: AsRef<str>>(
             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) => {

data/src/client/resp.rs

@@ -5,14 +5,14 @@ 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 magnus::{Error, Module, RArray, RModule, Ruby, Value, scan_args::scan_args};
 use wreq::Uri;
 
 use crate::{
     client::body::{BodyReceiver, Json},
     cookie::Cookie,
-    error::{memory_error, wreq_error_to_magnus},
-    gvl,
+    error::{memory_error, no_block_given_error, wreq_error_to_magnus},
+    gvl::{self, nogvl},
     header::Headers,
     http::{StatusCode, Version},
     rt,
@@ -173,20 +173,18 @@ impl Response {
         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> {
+    pub fn text(&self, args: &[Value]) -> Result<String, Error> {
+        let args = scan_args::<(), (Option<String>,), (), (), (), ()>(args)?;
         let response = self.response(false)?;
-        rt::try_block_on(
-            response
-                .text_with_charset(default_encoding)
-                .map_err(wreq_error_to_magnus),
-        )
+        match args.optional.0 {
+            Some(encoding) => rt::try_block_on(
+                response
+                    .text_with_charset(encoding)
+                    .map_err(wreq_error_to_magnus),
+            ),
+            None => rt::try_block_on(response.text().map_err(wreq_error_to_magnus)),
+        }
     }
 
     /// Get the response body as JSON.
@@ -201,12 +199,24 @@ impl Response {
         })
     }
 
-    /// 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)
+    /// Yield response body chunks to the given Ruby block.
+    pub fn chunks(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        if !ruby.block_given() {
+            return Err(no_block_given_error());
+        }
+
+        let receiver = nogvl(|| {
+            rb_self
+                .response(true)
+                .map(wreq::Response::bytes_stream)
+                .map(BodyReceiver::new)
+        })?;
+
+        while let Some(chunk) = receiver.next()? {
+            let _: Value = ruby.yield_value(chunk)?;
+        }
+
+        Ok(())
     }
 
     /// Close the response body, dropping any resources.
@@ -224,27 +234,23 @@ impl Drop for Response {
 }
 
 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(
+    let response = gem_module.define_class("Response", ruby.class_object())?;
+    response.define_method("code", magnus::method!(Response::code, 0))?;
+    response.define_method("status", magnus::method!(Response::status, 0))?;
+    response.define_method("version", magnus::method!(Response::version, 0))?;
+    response.define_method("url", magnus::method!(Response::url, 0))?;
+    response.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))?;
+    response.define_method("cookies", magnus::method!(Response::cookies, 0))?;
+    response.define_method("headers", magnus::method!(Response::headers, 0))?;
+    response.define_method("local_addr", magnus::method!(Response::local_addr, 0))?;
+    response.define_method("remote_addr", magnus::method!(Response::remote_addr, 0))?;
+    response.define_method("bytes", magnus::method!(Response::bytes, 0))?;
+    response.define_method("text", magnus::method!(Response::text, -1))?;
+    response.define_method("json", magnus::method!(Response::json, 0))?;
+    response.define_method("chunks", magnus::method!(Response::chunks, 0))?;
+    response.define_method("close", magnus::method!(Response::close, 0))?;
     Ok(())
 }

data/src/client.rs

@@ -12,7 +12,7 @@ use magnus::{
 use serde::Deserialize;
 use wreq::{
     Proxy,
-    header::{HeaderMap, HeaderValue, OrigHeaderMap},
+    header::{HeaderValue, OrigHeaderMap},
 };
 
 use crate::{
@@ -22,6 +22,7 @@ use crate::{
     error::wreq_error_to_magnus,
     extractor::Extractor,
     gvl,
+    header::Headers,
     http::Method,
 };
 
@@ -36,7 +37,7 @@ struct Builder {
     user_agent: Option<HeaderValue>,
     /// The headers to use for the client.
     #[serde(skip)]
-    headers: Option<HeaderMap>,
+    headers: Option<Headers>,
     /// The original headers to use for the client.
     #[serde(skip)]
     orig_headers: Option<OrigHeaderMap>,
@@ -83,7 +84,7 @@ struct Builder {
     /// 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>,
+    pool_max_size: Option<usize>,
 
     // ========= Protocol options =========
     /// Whether to use the HTTP/1 protocol only.
@@ -128,35 +129,33 @@ pub struct Client(wreq::Client);
 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());
-            }
+        let Ok(hash) = RHash::try_convert(*keyword) else {
+            return Ok(Default::default());
+        };
 
-            // extra user agent handling
-            builder.user_agent = Extractor::<HeaderValue>::try_convert(*keyword)?.into_inner();
+        let mut builder: Self = serde_magnus::deserialize(ruby, hash)?;
 
-            // 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();
+        if let Some(v) = hash.get(ruby.to_symbol(stringify!(emulation))) {
+            builder.emulation = Some((*Obj::<Emulation>::try_convert(v)?).clone());
+        }
 
-            // extra proxy handling
-            builder.proxy = Extractor::<Proxy>::try_convert(*keyword)?.into_inner();
+        if let Some(v) = hash.get(ruby.to_symbol(stringify!(headers))) {
+            builder.headers = Some(Headers::try_convert(v)?);
+        }
 
-            // 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());
-            }
+        if let Some(v) = hash.get(ruby.to_symbol(stringify!(cookie_provider))) {
+            builder.cookie_provider = Some((*Obj::<Jar>::try_convert(v)?).clone());
+        }
 
-            return Ok(builder);
+        if let Some(jar) = hash.get(ruby.to_symbol(stringify!(cookie_provider))) {
+            builder.cookie_provider = Some((*Obj::<Jar>::try_convert(jar)?).clone());
         }
 
-        Ok(Default::default())
+        builder.user_agent = Extractor::<HeaderValue>::try_convert(*keyword)?.into_inner();
+        builder.orig_headers = Extractor::<OrigHeaderMap>::try_convert(*keyword)?.into_inner();
+        builder.proxy = Extractor::<Proxy>::try_convert(*keyword)?.into_inner();
+
+        Ok(builder)
     }
 }
 
@@ -164,9 +163,9 @@ impl Builder {
 
 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)?;
+    pub fn new(ruby: &Ruby, keyword: &[Value]) -> Result<Self, magnus::Error> {
+        if let Some(keyword) = keyword.first() {
+            let mut params = Builder::new(ruby, keyword)?;
             gvl::nogvl(|| {
                 let mut builder = wreq::Client::builder();
 
@@ -177,7 +176,12 @@ impl Client {
                 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_into_inner,
+                    builder,
+                    params.headers,
+                    default_headers
+                );
                 apply_option!(set_if_some, builder, params.orig_headers, orig_headers);
 
                 // Allow redirects options.
@@ -286,7 +290,7 @@ impl Client {
                 apply_option!(set_if_some, builder, params.https_only, https_only);
 
                 // TLS options.
-                apply_option!(set_if_some, builder, params.verify, cert_verification);
+                apply_option!(set_if_some, builder, params.verify, tls_cert_verification);
 
                 // Network options.
                 apply_option!(set_if_some, builder, params.proxy, proxy);

data/src/cookie.rs

@@ -1,13 +1,14 @@
 use std::{fmt, sync::Arc, time::SystemTime};
 
+use bytes::Bytes;
 use cookie::{Cookie as RawCookie, Expiration, ParseError, time::Duration};
 use magnus::{
-    Error, Module, Object, RModule, Ruby, Value, function, method, typed_data::Obj,
-    value::ReprValue,
+    Error, Module, Object, RHash, RModule, RString, Ruby, TryConvert, Value, function, method,
+    r_hash::ForEach, typed_data::Obj, value::ReprValue,
 };
 use wreq::header::{self, HeaderMap, HeaderValue};
 
-use crate::gvl;
+use crate::{error::header_value_error_to_magnus, gvl};
 
 define_ruby_enum!(
     /// The Cookie SameSite attribute.
@@ -25,6 +26,10 @@ define_ruby_enum!(
 #[magnus::wrap(class = "Wreq::Cookie", free_immediately, size)]
 pub struct Cookie(RawCookie<'static>);
 
+/// A collection of HTTP cookies.
+#[derive(Default)]
+pub struct Cookies(pub Vec<HeaderValue>);
+
 /// A good default `CookieStore` implementation.
 ///
 /// This is the implementation used when simply calling `cookie_store(true)`.
@@ -197,6 +202,36 @@ impl fmt::Display for Cookie {
     }
 }
 
+// ===== impl Cookies =====
+
+impl TryConvert for Cookies {
+    fn try_convert(value: magnus::Value) -> Result<Self, magnus::Error> {
+        // try extract uncompressed cookies
+        if let Some(rhash) = RHash::from_value(value) {
+            let mut cookies = Vec::new();
+            rhash.foreach(|name: RString, value: RString| {
+                let cookie = format!("{name}={value}");
+                let header_value = HeaderValue::from_maybe_shared(Bytes::from(cookie))
+                    .map_err(header_value_error_to_magnus)?;
+                cookies.push(header_value);
+                Ok(ForEach::Continue)
+            })?;
+
+            return Ok(Self(cookies));
+        }
+
+        // try extract compressed cookies
+        if let Some(cookies) = RString::from_value(value) {
+            return Ok(Self(vec![
+                HeaderValue::from_maybe_shared(cookies.to_bytes())
+                    .map_err(header_value_error_to_magnus)?,
+            ]));
+        }
+
+        Ok(Self::default())
+    }
+}
+
 // ===== impl Jar =====
 
 impl Jar {
@@ -221,13 +256,14 @@ impl Jar {
     }
 
     /// Add a cookie to this jar.
-    pub fn add_cookie(&self, cookie: &Cookie, url: String) {
-        gvl::nogvl(|| self.0.add(cookie.0.clone(), &url))
-    }
+    pub fn add(&self, cookie: Value, url: String) {
+        if let Ok(cookie) = Obj::<Cookie>::try_convert(cookie) {
+            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))
+        if let Ok(cookie_str) = String::try_convert(cookie) {
+            gvl::nogvl(|| self.0.add(cookie_str.as_ref(), &url))
+        }
     }
 
     /// Remove a cookie from this jar by name and URL.
@@ -268,8 +304,7 @@ pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
     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("add", method!(Jar::add, 2))?;
     jar_class.define_method("remove", method!(Jar::remove, 2))?;
     jar_class.define_method("clear", method!(Jar::clear, 0))?;