wasmer 0.2.0 → 0.3.0

data/src/lib.rs

@@ -1,7 +1,8 @@
 #![deny(warnings)]
 
-use rutie::{Class, Object};
+use rutie::{Class, Module, Object};
 
+pub mod error;
 pub mod instance;
 pub mod memory;
 pub mod module;
@@ -9,83 +10,108 @@ pub mod module;
 #[allow(non_snake_case)]
 #[no_mangle]
 pub extern "C" fn Init_wasmer() {
+    let mut wasmer_module = Module::from_existing("Wasmer");
+
     let instance_data_class = Class::from_existing("Object");
 
     // Declare the `Instance` Ruby class.
-    Class::new("Instance", Some(&instance_data_class)).define(|itself| {
-        // Declare the `self.new` method.
-        itself.def_self("new", instance::ruby_instance_new);
+    wasmer_module
+        .define_nested_class("Instance", Some(&instance_data_class))
+        .define(|itself| {
+            // Declare the `self.new` method.
+            itself.def_self("new", instance::ruby_instance_new);
 
-        // Declare the `exports` getter method.
-        itself.def("exports", instance::ruby_instance_exported_functions);
+            // Declare the `exports` getter method.
+            itself.def("exports", instance::ruby_instance_exported_functions);
 
-        // Declare the `memory` getter method.
-        itself.def("memory", instance::ruby_instance_memory);
-    });
+            // Declare the `memory` getter method.
+            itself.def("memory", instance::ruby_instance_memory);
+        });
 
     let exported_functions_data_class = Class::from_existing("Object");
 
     // Declare the `ExportedFunctions` Ruby class.
-    Class::new("ExportedFunctions", Some(&exported_functions_data_class)).define(|itself| {
-        // Declare the `method_missing` method.
-        itself.def(
-            "method_missing",
-            instance::ruby_exported_functions_method_missing,
-        );
-    });
+    wasmer_module
+        .define_nested_class("ExportedFunctions", Some(&exported_functions_data_class))
+        .define(|itself| {
+            // Declare the `respond_to_missing?` method.
+            itself.def(
+                "respond_to_missing?",
+                instance::ruby_exported_functions_method_exists,
+            );
+
+            // Declare the `method_missing` method.
+            itself.def(
+                "method_missing",
+                instance::ruby_exported_functions_method_missing,
+            );
+        });
 
     let module_data_class = Class::from_existing("Object");
 
     // Declare the `Module` Ruby class.
-    Class::new("Module", Some(&module_data_class)).define(|itself| {
-        // Declare the `self.validate` method.
-        itself.def_self("validate", module::ruby_module_validate);
-    });
+    wasmer_module
+        .define_nested_class("Module", Some(&module_data_class))
+        .define(|itself| {
+            // Declare the `self.validate` method.
+            itself.def_self("validate", module::ruby_module_validate);
+        });
 
     let memory_data_class = Class::from_existing("Object");
 
     // Declare the `Memory` Ruby class.
-    Class::new("Memory", Some(&memory_data_class)).define(|itself| {
-        // Declare the `view` method.
-        itself.def("uint8_view", memory::ruby_memory_uint8array);
+    wasmer_module
+        .define_nested_class("Memory", Some(&memory_data_class))
+        .define(|itself| {
+            // Declare the `grow` method.
+            itself.def("grow", memory::ruby_memory_grow);
+
+            // Declare the `view` method.
+            itself.def("uint8_view", memory::ruby_memory_uint8array);
 
-        // Declare the `view` method.
-        itself.def("int8_view", memory::ruby_memory_int8array);
+            // Declare the `view` method.
+            itself.def("int8_view", memory::ruby_memory_int8array);
 
-        // Declare the `view` method.
-        itself.def("uint16_view", memory::ruby_memory_uint16array);
+            // Declare the `view` method.
+            itself.def("uint16_view", memory::ruby_memory_uint16array);
 
-        // Declare the `view` method.
-        itself.def("int16_view", memory::ruby_memory_int16array);
+            // Declare the `view` method.
+            itself.def("int16_view", memory::ruby_memory_int16array);
 
-        // Declare the `view` method.
-        itself.def("uint32_view", memory::ruby_memory_uint32array);
+            // Declare the `view` method.
+            itself.def("uint32_view", memory::ruby_memory_uint32array);
 
-        // Declare the `view` method.
-        itself.def("int32_view", memory::ruby_memory_int32array);
-    });
+            // Declare the `view` method.
+            itself.def("int32_view", memory::ruby_memory_int32array);
+        });
 
     macro_rules! memory_view {
         ($class_name:ident in $mod_name:ident) => {
             let uint8array_data_class = Class::from_existing("Object");
 
             // Declare the `MemoryView` Ruby class.
-            Class::new(stringify!($class_name), Some(&uint8array_data_class)).define(|itself| {
-                // Declare the `bytes_per_element` getter method.
-                itself.def(
-                    "bytes_per_element",
-                    memory::view::$mod_name::ruby_memory_view_bytes_per_element,
-                );
-
-                // Declare the `length` method.
-                itself.def("length", memory::view::$mod_name::ruby_memory_view_length);
-
-                // Declare the `[]=` (set) method.
-                itself.def("[]=", memory::view::$mod_name::ruby_memory_view_set);
-
-                // Declare the `[]` (get) method.
-                itself.def("[]", memory::view::$mod_name::ruby_memory_view_get);
-            });
+            wasmer_module
+                .define_nested_class(stringify!($class_name), Some(&uint8array_data_class))
+                .define(|itself| {
+                    // Declare the `bytes_per_element` getter method.
+                    itself.def(
+                        "bytes_per_element",
+                        memory::view::$mod_name::ruby_memory_view_bytes_per_element,
+                    );
+
+                    // Declare the `length` method.
+                    itself.def("length", memory::view::$mod_name::ruby_memory_view_length);
+
+                    // Declare the `[]=` (set) method.
+                    itself.def("[]=", memory::view::$mod_name::ruby_memory_view_set);
+
+                    // Declare the `[]` (get) method.
+                    itself.def("[]", memory::view::$mod_name::ruby_memory_view_get);
+
+                    // Declare the `each` method.
+                    itself.def("each", memory::view::$mod_name::ruby_memory_view_each);
+                })
+                .include("Enumerable");
         };
     }
 

data/src/memory/mod.rs

@@ -2,18 +2,26 @@
 
 pub mod view;
 
-use crate::memory::view::{
-    int16array::{RubyMemoryView as RubyInt16Array, MEMORY_VIEW_WRAPPER as INT16ARRAY_WRAPPER},
-    int32array::{RubyMemoryView as RubyInt32Array, MEMORY_VIEW_WRAPPER as INT32ARRAY_WRAPPER},
-    int8array::{RubyMemoryView as RubyInt8Array, MEMORY_VIEW_WRAPPER as INT8ARRAY_WRAPPER},
-    uint16array::{RubyMemoryView as RubyUint16Array, MEMORY_VIEW_WRAPPER as UINT16ARRAY_WRAPPER},
-    uint32array::{RubyMemoryView as RubyUint32Array, MEMORY_VIEW_WRAPPER as UINT32ARRAY_WRAPPER},
-    uint8array::{RubyMemoryView as RubyUint8Array, MEMORY_VIEW_WRAPPER as UINT8ARRAY_WRAPPER},
+use crate::{
+    error::unwrap_or_raise,
+    memory::view::{
+        int16array::{RubyMemoryView as RubyInt16Array, MEMORY_VIEW_WRAPPER as INT16ARRAY_WRAPPER},
+        int32array::{RubyMemoryView as RubyInt32Array, MEMORY_VIEW_WRAPPER as INT32ARRAY_WRAPPER},
+        int8array::{RubyMemoryView as RubyInt8Array, MEMORY_VIEW_WRAPPER as INT8ARRAY_WRAPPER},
+        uint16array::{
+            RubyMemoryView as RubyUint16Array, MEMORY_VIEW_WRAPPER as UINT16ARRAY_WRAPPER,
+        },
+        uint32array::{
+            RubyMemoryView as RubyUint32Array, MEMORY_VIEW_WRAPPER as UINT32ARRAY_WRAPPER,
+        },
+        uint8array::{RubyMemoryView as RubyUint8Array, MEMORY_VIEW_WRAPPER as UINT8ARRAY_WRAPPER},
+    },
 };
 use lazy_static::lazy_static;
-use rutie::{class, methods, wrappable_struct, Class, Integer, Object};
+use rutie::{class, methods, wrappable_struct, AnyException, Exception, Integer, Module, Object};
 use std::rc::Rc;
 use wasmer_runtime as runtime;
+use wasmer_runtime_core::units::Pages;
 
 pub struct Memory {
     memory: Rc<runtime::Memory>,
@@ -47,6 +55,18 @@ impl Memory {
     pub fn int32_view(&self, offset: usize) -> view::int32array::MemoryView {
         view::int32array::MemoryView::new(self.memory.clone(), offset)
     }
+
+    pub fn grow(&self, number_of_pages: u32) -> Result<u32, AnyException> {
+        self.memory
+            .grow(Pages(number_of_pages))
+            .map(|previous_pages| previous_pages.0)
+            .map_err(|err| {
+                AnyException::new(
+                    "RuntimeError",
+                    Some(&format!("Failed to grow the memory: {}.", err)),
+                )
+            })
+    }
 }
 
 wrappable_struct!(Memory, MemoryWrapper, MEMORY_WRAPPER);
@@ -57,64 +77,83 @@ class!(RubyMemory);
 methods!(
     RubyMemory,
     itself,
-
     // Glue code to call the `Memory.uint8_view` method.
     fn ruby_memory_uint8array(offset: Integer) -> RubyUint8Array {
-        let offset = offset
-            .map(|offset| offset.to_i64() as usize)
-            .unwrap_or(0);
+        let offset = offset.map(|offset| offset.to_i64() as usize).unwrap_or(0);
         let memory_view = itself.get_data(&*MEMORY_WRAPPER).uint8_view(offset);
 
-        Class::from_existing("Uint8Array").wrap_data(memory_view, &*UINT8ARRAY_WRAPPER)
+        let wasmer_module = Module::from_existing("Wasmer");
+        wasmer_module
+            .get_nested_class("Uint8Array")
+            .wrap_data(memory_view, &*UINT8ARRAY_WRAPPER)
     }
 
     // Glue code to call the `Memory.int8_view` method.
     fn ruby_memory_int8array(offset: Integer) -> RubyInt8Array {
-        let offset = offset
-            .map(|offset| offset.to_i64() as usize)
-            .unwrap_or(0);
+        let offset = offset.map(|offset| offset.to_i64() as usize).unwrap_or(0);
         let memory_view = itself.get_data(&*MEMORY_WRAPPER).int8_view(offset);
 
-        Class::from_existing("Int8Array").wrap_data(memory_view, &*INT8ARRAY_WRAPPER)
+        let wasmer_module = Module::from_existing("Wasmer");
+        wasmer_module
+            .get_nested_class("Int8Array")
+            .wrap_data(memory_view, &*INT8ARRAY_WRAPPER)
     }
 
     // Glue code to call the `Memory.uint16_view` method.
     fn ruby_memory_uint16array(offset: Integer) -> RubyUint16Array {
-        let offset = offset
-            .map(|offset| offset.to_i64() as usize)
-            .unwrap_or(0);
+        let offset = offset.map(|offset| offset.to_i64() as usize).unwrap_or(0);
         let memory_view = itself.get_data(&*MEMORY_WRAPPER).uint16_view(offset);
 
-        Class::from_existing("Uint16Array").wrap_data(memory_view, &*UINT16ARRAY_WRAPPER)
+        let wasmer_module = Module::from_existing("Wasmer");
+        wasmer_module
+            .get_nested_class("Uint16Array")
+            .wrap_data(memory_view, &*UINT16ARRAY_WRAPPER)
     }
 
     // Glue code to call the `Memory.int16_view` method.
     fn ruby_memory_int16array(offset: Integer) -> RubyInt16Array {
-        let offset = offset
-            .map(|offset| offset.to_i64() as usize)
-            .unwrap_or(0);
+        let offset = offset.map(|offset| offset.to_i64() as usize).unwrap_or(0);
         let memory_view = itself.get_data(&*MEMORY_WRAPPER).int16_view(offset);
 
-        Class::from_existing("Int16Array").wrap_data(memory_view, &*INT16ARRAY_WRAPPER)
+        let wasmer_module = Module::from_existing("Wasmer");
+        wasmer_module
+            .get_nested_class("Int16Array")
+            .wrap_data(memory_view, &*INT16ARRAY_WRAPPER)
     }
 
     // Glue code to call the `Memory.uint32_view` method.
     fn ruby_memory_uint32array(offset: Integer) -> RubyUint32Array {
-        let offset = offset
-            .map(|offset| offset.to_i64() as usize)
-            .unwrap_or(0);
+        let offset = offset.map(|offset| offset.to_i64() as usize).unwrap_or(0);
         let memory_view = itself.get_data(&*MEMORY_WRAPPER).uint32_view(offset);
 
-        Class::from_existing("Uint32Array").wrap_data(memory_view, &*UINT32ARRAY_WRAPPER)
+        let wasmer_module = Module::from_existing("Wasmer");
+        wasmer_module
+            .get_nested_class("Uint32Array")
+            .wrap_data(memory_view, &*UINT32ARRAY_WRAPPER)
     }
 
     // Glue code to call the `Memory.int32_view` method.
     fn ruby_memory_int32array(offset: Integer) -> RubyInt32Array {
-        let offset = offset
-            .map(|offset| offset.to_i64() as usize)
-            .unwrap_or(0);
+        let offset = offset.map(|offset| offset.to_i64() as usize).unwrap_or(0);
         let memory_view = itself.get_data(&*MEMORY_WRAPPER).int32_view(offset);
 
-        Class::from_existing("Int32Array").wrap_data(memory_view, &*INT32ARRAY_WRAPPER)
+        let wasmer_module = Module::from_existing("Wasmer");
+        wasmer_module
+            .get_nested_class("Int32Array")
+            .wrap_data(memory_view, &*INT32ARRAY_WRAPPER)
+    }
+
+    // Glue code to call the `Memory.grow` method.
+    fn ruby_memory_grow(number_of_pages: Integer) -> Integer {
+        let number_of_pages = number_of_pages
+            .map(|number_of_pages| number_of_pages.to_i32() as u32)
+            .unwrap_or(1);
+
+        unwrap_or_raise(|| {
+            itself
+                .get_data(&*MEMORY_WRAPPER)
+                .grow(number_of_pages)
+                .map(|previous_number_of_pages| Integer::new(previous_number_of_pages as i64))
+        })
     }
 );

data/src/memory/view.rs

@@ -1,8 +1,11 @@
 //! The `TypedArray`/`MemoryView` WebAssembly classes.
 
+#[rustfmt::skip]
+
 macro_rules! memory_view {
     ($mod_name:ident over $wasm_type:ty | $bytes_per_element:expr) => {
         pub mod $mod_name {
+            use crate::error::unwrap_or_raise;
             use lazy_static::lazy_static;
             use rutie::{
                 class, methods, wrappable_struct, AnyException, Exception, Fixnum, Integer,
@@ -68,13 +71,21 @@ macro_rules! memory_view {
                         Ok(view[offset + index].get())
                     }
                 }
+
+                pub fn each(&self) {
+                    let view = self.memory.view::<$wasm_type>();
+
+                    for nth in self.offset..view.len() {
+                        let value = view[nth].get() as i64;
+                        VM::yield_object(Integer::from(value));
+                    }
+                }
             }
 
             wrappable_struct!(MemoryView, MemoryViewWrapper, MEMORY_VIEW_WRAPPER);
 
             class!(RubyMemoryView);
 
-            #[rustfmt::skip]
             methods!(
                 RubyMemoryView,
                 _itself,
@@ -91,28 +102,35 @@ macro_rules! memory_view {
 
                 // Glue code to call the `TypedArray.set` method.
                 fn ruby_memory_view_set(index: Integer, value: Integer) -> NilClass {
-                    let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
-                    memory_view
-                        .set(
-                            index.map_err(|e| VM::raise_ex(e)).unwrap().to_i32() as isize,
-                            value.map_err(|e| VM::raise_ex(e)).unwrap().to_i32() as $wasm_type,
-                        )
-                        .map_err(|e| VM::raise_ex(AnyException::new("ArgumentError", Some(&e))))
-                        .unwrap();
-
-                    NilClass::new()
+                    unwrap_or_raise(|| {
+                        let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
+
+                        memory_view
+                            .set(index?.to_i32() as isize, value?.to_i32() as $wasm_type)
+                            .map_err(|e| AnyException::new("ArgumentError", Some(&e)))?;
+
+                        Ok(NilClass::new())
+                    })
                 }
 
                 // Glue code to call the `TypedArray.get` method.
                 fn ruby_memory_view_get(index: Integer) -> Fixnum {
-                    let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
+                    unwrap_or_raise(|| {
+                        let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
+
+                        Ok(Fixnum::new(
+                            memory_view
+                                .get(index?.to_i32() as isize)
+                                .map_err(|e| AnyException::new("ArgumentError", Some(&e)))?
+                                as i64,
+                        ))
+                    })
+                }
 
-                    Fixnum::new(
-                        memory_view
-                            .get(index.map_err(|e| VM::raise_ex(e)).unwrap().to_i32() as isize)
-                            .map_err(|e| VM::raise_ex(AnyException::new("ArgumentError", Some(&e))))
-                            .unwrap() as i64,
-                    )
+                fn ruby_memory_view_each() -> RubyMemoryView {
+                    let memory_view = _itself.get_data(&*MEMORY_VIEW_WRAPPER);
+                    memory_view.each();
+                    _itself
                 }
             );
         }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wasmer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ivan Enderlin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-01 00:00:00.000000000 Z
+date: 2019-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rutie
@@ -85,9 +85,11 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- bors.toml
 - justfile
 - lib/wasmer.rb
 - lib/wasmer/version.rb
+- src/error.rs
 - src/instance.rs
 - src/lib.rs
 - src/memory/mod.rs