This is an automated email from the ASF dual-hosted git repository.

erickguan pushed a commit to branch ruby-binding-io
in repository https://gitbox.apache.org/repos/asf/opendal.git

commit a6af860f4556be08d1a236cd20153df201919b56
Author: Erick Guan <297343+erickg...@users.noreply.github.com>
AuthorDate: Fri Aug 29 22:37:45 2025 +0200

    chore(bindings/ruby): remove deprecations
---
 bindings/ruby/src/capability.rs    |  5 ++--
 bindings/ruby/src/io.rs            | 60 +++++++++++++++++++++++---------------
 bindings/ruby/src/lib.rs           | 17 +++++------
 bindings/ruby/src/lister.rs        |  6 ++--
 bindings/ruby/src/metadata.rs      |  5 ++--
 bindings/ruby/src/middlewares.rs   | 12 ++++----
 bindings/ruby/src/operator.rs      |  5 ++--
 bindings/ruby/src/operator_info.rs |  5 ++--
 8 files changed, 62 insertions(+), 53 deletions(-)

diff --git a/bindings/ruby/src/capability.rs b/bindings/ruby/src/capability.rs
index 1df438cf1..accbf1456 100644
--- a/bindings/ruby/src/capability.rs
+++ b/bindings/ruby/src/capability.rs
@@ -15,7 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use magnus::class;
 use magnus::method;
 use magnus::prelude::*;
 use magnus::Error;
@@ -98,8 +97,8 @@ define_accessors!(Capability, {
 });
 
 // includes class into the Ruby module
-pub fn include(gem_module: &RModule) -> Result<(), Error> {
-    let class = gem_module.define_class("Capability", class::object())?;
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let class = gem_module.define_class("Capability", ruby.class_object())?;
     bind_methods_to_ruby!(class, {
         stat,
         stat_with_if_match,
diff --git a/bindings/ruby/src/io.rs b/bindings/ruby/src/io.rs
index c1a2d5a90..645cbf6d1 100644
--- a/bindings/ruby/src/io.rs
+++ b/bindings/ruby/src/io.rs
@@ -29,7 +29,6 @@ use std::io::Seek;
 use std::io::SeekFrom;
 use std::io::Write;
 
-use magnus::class;
 use magnus::io::FMode;
 use magnus::method;
 use magnus::prelude::*;
@@ -77,8 +76,8 @@ struct IoHandle {
     encoding_flags: i32,
 }
 
-pub fn format_io_error(err: std::io::Error) -> Error {
-    Error::new(exception::runtime_error(), err.to_string())
+pub fn format_io_error(ruby: &Ruby, err: std::io::Error) -> Error {
+    Error::new(ruby.exception_runtime_error(), err.to_string())
 }
 
 impl Io {
@@ -102,15 +101,15 @@ impl Io {
                 FileState::Reader(
                     operator
                         .reader(&path)
-                        .map_err(format_magnus_error)?
+                        .map_err(|err| format_magnus_error(ruby, err))?
                         .into_std_read(..)
-                        .map_err(format_magnus_error)?,
+                        .map_err(|err| format_magnus_error(ruby, err))?,
                 )
             } else if fmode.contains(FMode::WRITE) {
                 FileState::Writer(
                 operator
                     .writer(&path)
-                    .map_err(format_magnus_error)?
+                    .map_err(|err| format_magnus_error(ruby, err))?
                     .into_std_write(),
             )
         } else {
@@ -160,10 +159,10 @@ impl Io {
     /// @def close
     /// Close streams.
     /// @return [nil]
-    fn close(&self) -> Result<(), Error> {
-        let mut handle = self.0.borrow_mut();
+    fn close(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        let mut handle = rb_self.0.borrow_mut();
         if let FileState::Writer(writer) = &mut handle.state {
-            writer.close().map_err(format_io_error)?;
+            writer.close().map_err(|err| format_io_error(ruby, err))?;
         }
         handle.state = FileState::Closed;
         Ok(())
@@ -185,10 +184,10 @@ impl Io {
     /// @def close_write
     /// Closes the write stream.
     /// @return [nil]
-    fn close_write(&self) -> Result<(), Error> {
-        let mut handle = self.0.borrow_mut();
+    fn close_write(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        let mut handle = rb_self.0.borrow_mut();
         if let FileState::Writer(writer) = &mut handle.state {
-            writer.close().map_err(format_io_error)?;
+            writer.close().map_err(|err| format_io_error(ruby, err))?;
             handle.state = FileState::Closed;
         }
         Ok(())
@@ -246,7 +245,9 @@ impl Io {
                         ));
                     }
                     let mut bs = vec![0; size as usize];
-                    let n = reader.read(&mut bs).map_err(format_io_error)?;
+                    let n = reader
+                        .read(&mut bs)
+                        .map_err(|err| format_io_error(ruby, err))?;
                     if n == 0 && size > 0 {
                         // when called at end of file, read(positive_integer) 
returns nil.
                         None
@@ -257,15 +258,18 @@ impl Io {
                 }
                 None => {
                     let mut buffer = Vec::new();
-                    reader.read_to_end(&mut buffer).map_err(format_io_error)?;
+                    reader
+                        .read_to_end(&mut buffer)
+                        .map_err(|err| format_io_error(ruby, err))?;
                     Some(buffer.into())
                 }
             };
 
             // when provided the buffer parameter, append read buffer
             if let (Some(output_buffer), Some(inner)) =
-                (option_output_buffer.as_mut(), buffer.as_ref()) {
-                    output_buffer.cat(inner);
+                (option_output_buffer.as_mut(), buffer.as_ref())
+            {
+                output_buffer.cat(inner);
             }
 
             Ok(buffer)
@@ -287,7 +291,9 @@ impl Io {
 
         if let FileState::Reader(reader) = &mut handle.state {
             let mut buffer = String::new();
-            let size = reader.read_line(&mut buffer).map_err(format_io_error)?;
+            let size = reader
+                .read_line(&mut buffer)
+                .map_err(|err| format_io_error(ruby, err))?;
             if size == 0 {
                 return Err(Error::new(
                     ruby.exception_eof_error(),
@@ -314,7 +320,9 @@ impl Io {
 
         if let FileState::Writer(writer) = &mut handle.state {
             let bytes_written = bs.len();
-            writer.write_all(bs.as_bytes()).map_err(format_io_error)?;
+            writer
+                .write_all(bs.as_bytes())
+                .map_err(|err| format_io_error(ruby, err))?;
             Ok(bytes_written)
         } else {
             Err(Error::new(
@@ -354,7 +362,9 @@ impl Io {
                 }
                 1 => {
                     // SEEK_CUR - relative to current position
-                    let position = 
reader.stream_position().map_err(format_io_error)?;
+                    let position = reader
+                        .stream_position()
+                        .map_err(|err| format_io_error(ruby, err))?;
                     if offset < 0 && (-offset as u64) > position {
                         return Err(Error::new(
                             ruby.exception_runtime_error(),
@@ -365,7 +375,9 @@ impl Io {
                 }
                 2 => {
                     // SEEK_END
-                    let end_pos = 
reader.seek(SeekFrom::End(0)).map_err(format_io_error)?;
+                    let end_pos = reader
+                        .seek(SeekFrom::End(0))
+                        .map_err(|err| format_io_error(ruby, err))?;
                     if offset < 0 && (-offset as u64) > end_pos {
                         return Err(Error::new(
                             ruby.exception_runtime_error(),
@@ -397,7 +409,9 @@ impl Io {
         let mut handle = rb_self.0.borrow_mut();
 
         match &mut handle.state {
-            FileState::Reader(reader) => 
Ok(reader.stream_position().map_err(format_io_error)?),
+            FileState::Reader(reader) => Ok(reader
+                .stream_position()
+                .map_err(|err| format_io_error(ruby, err))?),
             FileState::Writer(_) => Err(Error::new(
                 ruby.exception_runtime_error(),
                 "I/O operation failed for reading on write only file.",
@@ -430,8 +444,8 @@ impl Io {
 /// automatically track such objects. Therefore, it is critical to work within 
Magnus's safety
 /// guidelines when integrating Rust objects with Ruby. Read more in the 
Magnus documentation:
 /// [Magnus Safety Documentation](https://github.com/matsadler/magnus#safety).
-pub fn include(gem_module: &RModule) -> Result<(), Error> {
-    let class = gem_module.define_class("IO", class::object())?;
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let class = gem_module.define_class("IO", ruby.class_object())?;
     class.define_method("binmode", method!(Io::binary_mode, 0))?;
     class.define_method("binmode?", method!(Io::is_binary_mode, 0))?;
     class.define_method("close", method!(Io::close, 0))?;
diff --git a/bindings/ruby/src/lib.rs b/bindings/ruby/src/lib.rs
index 481153b0f..e38006209 100644
--- a/bindings/ruby/src/lib.rs
+++ b/bindings/ruby/src/lib.rs
@@ -17,7 +17,6 @@
 
 use std::sync::LazyLock;
 
-use magnus::exception;
 use magnus::function;
 use magnus::Error;
 use magnus::Ruby;
@@ -41,21 +40,21 @@ static RUNTIME: LazyLock<tokio::runtime::Runtime> = 
LazyLock::new(|| {
         .unwrap()
 });
 
-pub fn format_magnus_error(err: ocore::Error) -> Error {
-    Error::new(exception::runtime_error(), err.to_string())
+pub fn format_magnus_error(ruby: &Ruby, err: ocore::Error) -> Error {
+    Error::new(ruby.exception_runtime_error(), err.to_string())
 }
 
 /// Apache OpenDALâ„¢ Ruby binding
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let gem_module = ruby.define_module("OpenDAL")?;
-    let _ = operator::include(&gem_module);
-    let _ = metadata::include(&gem_module);
-    let _ = capability::include(&gem_module);
-    let _ = io::include(&gem_module);
+    let _ = operator::include(ruby, &gem_module);
+    let _ = metadata::include(ruby, &gem_module);
+    let _ = capability::include(ruby, &gem_module);
+    let _ = io::include(ruby, &gem_module);
     let _ = lister::include(ruby, &gem_module);
-    let _ = operator_info::include(&gem_module);
-    let _ = middlewares::include(&gem_module);
+    let _ = operator_info::include(ruby, &gem_module);
+    let _ = middlewares::include(ruby, &gem_module);
 
     Ok(())
 }
diff --git a/bindings/ruby/src/lister.rs b/bindings/ruby/src/lister.rs
index fc3885e36..fab413bdc 100644
--- a/bindings/ruby/src/lister.rs
+++ b/bindings/ruby/src/lister.rs
@@ -26,7 +26,7 @@ use std::sync::Arc;
 use std::sync::Mutex;
 
 use magnus::block::Yield;
-use magnus::class;
+
 use magnus::method;
 use magnus::prelude::*;
 use magnus::Error;
@@ -126,12 +126,12 @@ impl Lister {
 }
 
 pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
-    let entry_class = gem_module.define_class("Entry", class::object())?;
+    let entry_class = gem_module.define_class("Entry", ruby.class_object())?;
     entry_class.define_method("path", method!(Entry::path, 0))?;
     entry_class.define_method("name", method!(Entry::name, 0))?;
     entry_class.define_method("metadata", method!(Entry::metadata, 0))?;
 
-    let lister_class = gem_module.define_class("Lister", class::object())?;
+    let lister_class = gem_module.define_class("Lister", ruby.class_object())?;
     lister_class
         .include_module(ruby.module_enumerable())
         .map_err(|err| Error::new(ruby.exception_runtime_error(), 
err.to_string()))?;
diff --git a/bindings/ruby/src/metadata.rs b/bindings/ruby/src/metadata.rs
index 32ff89d51..073fad77a 100644
--- a/bindings/ruby/src/metadata.rs
+++ b/bindings/ruby/src/metadata.rs
@@ -22,7 +22,6 @@
 #![allow(rustdoc::invalid_html_tags, reason = "YARD's syntax for 
documentation")]
 #![allow(rustdoc::bare_urls, reason = "YARD's syntax for documentation")]
 
-use magnus::class;
 use magnus::method;
 use magnus::prelude::*;
 use magnus::Error;
@@ -96,8 +95,8 @@ impl Metadata {
     }
 }
 
-pub fn include(gem_module: &RModule) -> Result<(), Error> {
-    let class = gem_module.define_class("Metadata", class::object())?;
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let class = gem_module.define_class("Metadata", ruby.class_object())?;
     class.define_method("mode", method!(Metadata::mode, 0))?;
     class.define_method(
         "content_disposition",
diff --git a/bindings/ruby/src/middlewares.rs b/bindings/ruby/src/middlewares.rs
index 4054382dd..0e5c14499 100644
--- a/bindings/ruby/src/middlewares.rs
+++ b/bindings/ruby/src/middlewares.rs
@@ -19,7 +19,6 @@ use std::sync::Arc;
 use std::sync::Mutex;
 use std::time::Duration;
 
-use magnus::class;
 use magnus::method;
 use magnus::prelude::*;
 use magnus::Error;
@@ -145,21 +144,22 @@ impl TimeoutMiddleware {
     }
 }
 
-pub fn include(gem_module: &RModule) -> Result<(), Error> {
-    let retry = gem_module.define_class("RetryMiddleware", class::object())?;
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let retry = gem_module.define_class("RetryMiddleware", 
ruby.class_object())?;
     retry.define_singleton_method("new", function!(RetryMiddleware::new, 0))?;
     retry.define_method("apply_to", method!(RetryMiddleware::apply_to, 1))?;
 
-    let concurrent_limit = 
gem_module.define_class("ConcurrentLimitMiddleware", class::object())?;
+    let concurrent_limit =
+        gem_module.define_class("ConcurrentLimitMiddleware", 
ruby.class_object())?;
     concurrent_limit
         .define_singleton_method("new", 
function!(ConcurrentLimitMiddleware::new, 1))?;
     concurrent_limit.define_method("apply_to", 
method!(ConcurrentLimitMiddleware::apply_to, 1))?;
 
-    let throttle_middleware = gem_module.define_class("ThrottleMiddleware", 
class::object())?;
+    let throttle_middleware = gem_module.define_class("ThrottleMiddleware", 
ruby.class_object())?;
     throttle_middleware.define_singleton_method("new", 
function!(ThrottleMiddleware::new, 2))?;
     throttle_middleware.define_method("apply_to", 
method!(ThrottleMiddleware::apply_to, 1))?;
 
-    let timeout_middleware = gem_module.define_class("TimeoutMiddleware", 
class::object())?;
+    let timeout_middleware = gem_module.define_class("TimeoutMiddleware", 
ruby.class_object())?;
     timeout_middleware.define_singleton_method("new", 
function!(TimeoutMiddleware::new, 2))?;
     timeout_middleware.define_method("apply_to", 
method!(TimeoutMiddleware::apply_to, 1))?;
 
diff --git a/bindings/ruby/src/operator.rs b/bindings/ruby/src/operator.rs
index 5d91f74a9..0709a4e36 100644
--- a/bindings/ruby/src/operator.rs
+++ b/bindings/ruby/src/operator.rs
@@ -25,7 +25,6 @@
 use std::collections::HashMap;
 use std::str::FromStr;
 
-use magnus::class;
 use magnus::method;
 use magnus::prelude::*;
 use magnus::scan_args::get_kwargs;
@@ -290,8 +289,8 @@ impl Operator {
     }
 }
 
-pub fn include(gem_module: &RModule) -> Result<(), Error> {
-    let class = gem_module.define_class("Operator", class::object())?;
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let class = gem_module.define_class("Operator", ruby.class_object())?;
     class.define_singleton_method("new", function!(Operator::new, 2))?;
     class.define_method("read", method!(Operator::read, 1))?;
     class.define_method("write", method!(Operator::write, 2))?;
diff --git a/bindings/ruby/src/operator_info.rs 
b/bindings/ruby/src/operator_info.rs
index 1d207cd25..1fa40db02 100644
--- a/bindings/ruby/src/operator_info.rs
+++ b/bindings/ruby/src/operator_info.rs
@@ -20,7 +20,6 @@
     reason = "YARD's syntax for documentation"
 )]
 
-use magnus::class;
 use magnus::method;
 use magnus::prelude::*;
 use magnus::Error;
@@ -73,8 +72,8 @@ impl OperatorInfo {
     }
 }
 
-pub fn include(gem_module: &RModule) -> Result<(), Error> {
-    let class = gem_module.define_class("OperatorInfo", class::object())?;
+pub fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let class = gem_module.define_class("OperatorInfo", ruby.class_object())?;
     class.define_method("scheme", method!(OperatorInfo::scheme, 0))?;
     class.define_method("root", method!(OperatorInfo::root, 0))?;
     class.define_method("name", method!(OperatorInfo::name, 0))?;

Reply via email to