Remove deprecated magnus calls in module and component (#532)

Author: jeffcharles

ext/src/ruby_api/component.rs

@@ -6,8 +6,13 @@ mod wasi_command;
 
 use super::root;
 use magnus::{
-    class, class::RClass, function, method, prelude::*, r_string::RString, value::Lazy, Error,
-    Module, Object, RModule, Ruby,
+    class::{self, RClass},
+    function, method,
+    prelude::*,
+    r_string::RString,
+    typed_data::Obj,
+    value::Lazy,
+    Error, Module, Object, RModule, Ruby,
 };
 use rb_sys::tracking_allocator::ManuallyTracked;
 use wasmtime::component::Component as ComponentImpl;
@@ -113,11 +118,11 @@ impl Component {
     /// Serialize the component.
     /// @return [String]
     /// @see .deserialize
-    pub fn serialize(&self) -> Result<RString, Error> {
-        let bytes = self.get().serialize();
+    pub fn serialize(ruby: &Ruby, rb_self: Obj<Self>) -> Result<RString, Error> {
+        let bytes = rb_self.get().serialize();
 
         bytes
-            .map(|bytes| RString::from_slice(&bytes))
+            .map(|bytes| ruby.str_from_slice(&bytes))
             .map_err(|e| error!("{:?}", e))
     }
 

ext/src/ruby_api/convert.rs

@@ -223,5 +223,5 @@ pub trait WrapWasmtimeExternType<T>
 where
     T: TypedData,
 {
-    fn wrap_wasmtime_type(&self) -> Result<T, Error>;
+    fn wrap_wasmtime_type(&self, ruby: &Ruby) -> Result<T, Error>;
 }

ext/src/ruby_api/externals.rs

@@ -214,20 +214,20 @@ impl<'a> WrapWasmtimeType<'a, Extern<'a>> for wasmtime::Extern {
 }
 
 impl WrapWasmtimeExternType<ExternType> for wasmtime::ExternType {
-    fn wrap_wasmtime_type(&self) -> Result<ExternType, Error> {
+    fn wrap_wasmtime_type(&self, ruby: &Ruby) -> Result<ExternType, Error> {
         match self {
-            wasmtime::ExternType::Func(ft) => Ok(ExternType::Func(Obj::wrap(
-                FuncType::from_inner(ft.clone()),
-            ))),
-            wasmtime::ExternType::Global(gt) => Ok(ExternType::Global(Obj::wrap(
-                GlobalType::from_inner(gt.clone()),
-            ))),
-            wasmtime::ExternType::Memory(mt) => Ok(ExternType::Memory(Obj::wrap(
-                MemoryType::from_inner(mt.clone()),
-            ))),
-            wasmtime::ExternType::Table(tt) => Ok(ExternType::Table(Obj::wrap(
-                TableType::from_inner(tt.clone()),
-            ))),
+            wasmtime::ExternType::Func(ft) => Ok(ExternType::Func(
+                ruby.obj_wrap(FuncType::from_inner(ft.clone())),
+            )),
+            wasmtime::ExternType::Global(gt) => Ok(ExternType::Global(
+                ruby.obj_wrap(GlobalType::from_inner(gt.clone())),
+            )),
+            wasmtime::ExternType::Memory(mt) => Ok(ExternType::Memory(
+                ruby.obj_wrap(MemoryType::from_inner(mt.clone())),
+            )),
+            wasmtime::ExternType::Table(tt) => Ok(ExternType::Table(
+                ruby.obj_wrap(TableType::from_inner(tt.clone())),
+            )),
             wasmtime::ExternType::Tag(_) => {
                 not_implemented!("exception handling not yet implemented")
             }

ext/src/ruby_api/module.rs

@@ -14,8 +14,8 @@ use crate::{
     helpers::{nogvl, Tmplock},
 };
 use magnus::{
-    class, function, method, rb_sys::AsRawValue, Error, Module as _, Object, RArray, RHash,
-    RString, Ruby,
+    class, function, method, rb_sys::AsRawValue, typed_data::Obj, Error, Module as _, Object,
+    RArray, RHash, RString, Ruby,
 };
 use rb_sys::{
     rb_str_locktmp, rb_str_unlocktmp, tracking_allocator::ManuallyTracked, RSTRING_LEN, RSTRING_PTR,
@@ -101,12 +101,12 @@ impl Module {
     /// Serialize the module.
     /// @return [String]
     /// @see .deserialize
-    pub fn serialize(&self) -> Result<RString, Error> {
-        let module = self.get();
+    pub fn serialize(ruby: &Ruby, rb_self: Obj<Self>) -> Result<RString, Error> {
+        let module = rb_self.get();
         let bytes = module.serialize();
 
         bytes
-            .map(|bytes| RString::from_slice(&bytes))
+            .map(|bytes| ruby.str_from_slice(&bytes))
             .map_err(|e| error!("{:?}", e))
     }
 
@@ -117,16 +117,16 @@ impl Module {
     /// @yard
     /// Returns the list of imports that this Module has and must be satisfied.
     /// @return [Array<Hash>] An array of hashes containing import information
-    pub fn imports(&self) -> Result<RArray, Error> {
-        let module = self.get();
+    pub fn imports(ruby: &Ruby, rb_self: Obj<Self>) -> Result<RArray, Error> {
+        let module = rb_self.get();
         let imports = module.imports();
 
-        let result = RArray::with_capacity(imports.len());
+        let result = ruby.ary_new_capa(imports.len());
         for import in imports {
-            let hash = RHash::new();
+            let hash = ruby.hash_new();
             hash.aset("module", import.module())?;
             hash.aset("name", import.name())?;
-            hash.aset("type", import.ty().wrap_wasmtime_type()?)?;
+            hash.aset("type", import.ty().wrap_wasmtime_type(ruby)?)?;
             result.push(hash)?;
         }
         Ok(result)