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))?;