wasmer 0.2.0 → 0.3.0

data/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 publish = false
 name = "ruby-ext-wasm"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Ivan Enderlin <ivan.enderlin@hoa-project.net>"]
 edition = "2018"
 description = "Ruby extension to run WebAssembly binaries"
@@ -15,7 +15,7 @@ name = "wasmer"
 crate-type = ["dylib"]
 
 [dependencies]
-wasmer-runtime = "0.4.0"
-wasmer-runtime-core = "0.4.0"
-rutie = "0.5.4"
+wasmer-runtime = "0.5.5"
+wasmer-runtime-core = "0.5.5"
+rutie = "0.6.0"
 lazy_static = "1.3.0"

data/README.md

@@ -10,7 +10,7 @@
   <a href="https://rubygems.org/gems/wasmer">
     <img src="https://img.shields.io/gem/v/wasmer.svg" alt="Gem"></a>
   <a href="https://rubygems.org/gems/wasmer">
-    <img src="https://img.shields.io/gem/dt/wasmer.svg" alt="Gem"></a>
+    <img src="https://img.shields.io/gem/dt/wasmer.svg" alt="Number of gem downloads"></a>
   <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
     <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="License"></a>
 </p>
@@ -61,7 +61,7 @@ Then, we can execute it in Ruby (!) with the `examples/simple.rb` file:
 require "wasmer"
 
 bytes = IO.read "simple.wasm", mode: "rb"
-instance = Instance.new bytes
+instance = Wasmer::Instance.new bytes
 puts instance.exports.sum 1, 2
 ```
 
@@ -85,7 +85,7 @@ require "wasmer"
 wasm_bytes = IO.read "my_program.wasm", mode: "rb"
 
 # Instantiates the Wasm module.
-instance = Instance.new wasm_bytes
+instance = Wasmer::Instance.new wasm_bytes
 
 # Call a function on it.
 result = instance.exports.sum 1, 2
@@ -109,7 +109,14 @@ See below for more information.
 ## The `Memory` class
 
 A WebAssembly instance has its own memory, represented by the `Memory`
-class. It is accessible by the `Instance.memory` getter.
+class. It is accessible by the `Wasmer::Instance.memory` getter.
+
+The `Memory.grow` methods allows to grow the memory by a number of
+pages (of 65kb each).
+
+```ruby
+instance.memory.grow 1
+```
 
 The `Memory` class offers methods to create views of the memory
 internal buffer, e.g. `uint8_view`, `int8_view`, `uint16_view`
@@ -159,7 +166,7 @@ require "wasmer"
 wasm_bytes = IO.read "my_program.wasm", mode: "rb"
 
 # Instantiates the Wasm module.
-instance = Instance.new wasm_bytes
+instance = Wasmer::Instance.new wasm_bytes
 
 # Call a function that returns a pointer to a string for instance.
 pointer = instance.exports.return_string
@@ -168,18 +175,12 @@ pointer = instance.exports.return_string
 memory = instance.memory.uint8_view pointer
 
 # Read the string pointed by the pointer.
-nth = 0
-string = ""
-
-while true
-  char = memory[nth]
 
-  if 0 == char
-    break
-  end
+string = ""
 
+memory.each do |char|
+  break if char == 0
   string += char.chr
-  nth += 1
 end
 
 puts string # Hello, World!
@@ -252,7 +253,7 @@ require "wasmer"
 
 wasm_bytes = IO.read "my_program.wasm", mode: "rb"
 
-if not Module.validate wasm_bytes
+if not Wasmer::Module.validate wasm_bytes
     puts "The program seems corrupted."
 end
 ```
@@ -298,7 +299,7 @@ About safety:
 
 # License
 
-The entire project is under the BSD-3-Clause license. Please read [the
+The entire project is under the MIT License. Please read [the
 `LICENSE` file][license].
 
 [license]: https://github.com/wasmerio/wasmer/blob/master/LICENSE

data/bors.toml

@@ -0,0 +1,4 @@
+status = [ "ci/circleci: build-and-test" ]
+required_approvals = 0
+timeout_sec = 900
+delete_merged_branches = true 

data/lib/wasmer/version.rb

@@ -1,3 +1,3 @@
 module Wasmer
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/src/error.rs

@@ -0,0 +1,16 @@
+//! Functions to handle error or exception correctly.
+
+use rutie::{AnyException, VM};
+
+pub fn unwrap_or_raise<Output, Function>(f: Function) -> Output
+where
+    Function: FnOnce() -> Result<Output, AnyException>,
+{
+    match f() {
+        Ok(x) => x,
+        Err(e) => {
+            VM::raise_ex(e);
+            unreachable!()
+        }
+    }
+}

data/src/instance.rs

@@ -1,14 +1,17 @@
 //! The `Instance` WebAssembly class.
 
-use crate::memory::{Memory, RubyMemory, MEMORY_WRAPPER};
+use crate::{
+    error::unwrap_or_raise,
+    memory::{Memory, RubyMemory, MEMORY_WRAPPER},
+};
 use lazy_static::lazy_static;
 use rutie::{
     class, methods,
     rubysys::{class, value::ValueType},
     types::{Argc, Value},
     util::str_to_cstring,
-    wrappable_struct, AnyException, AnyObject, Array, Class, Exception, Fixnum, Float, Object,
-    RString, Symbol, VM,
+    wrappable_struct, AnyException, AnyObject, Array, Boolean, Exception, Fixnum, Float, Module,
+    NilClass, Object, RString, Symbol,
 };
 use std::{mem, rc::Rc};
 use wasmer_runtime::{self as runtime, imports, Export};
@@ -26,18 +29,23 @@ impl ExportedFunctions {
         Self { instance }
     }
 
+    /// Check that an exported function exists.
+    pub fn respond_to_missing(&self, method_name: &str) -> bool {
+        self.instance.dyn_func(method_name).is_ok()
+    }
+
     /// Call an exported function on the given WebAssembly instance.
-    pub fn method_missing(&self, method_name: &str, arguments: Array) -> AnyObject {
-        let function = self
-            .instance
-            .dyn_func(method_name)
-            .map_err(|_| {
-                VM::raise_ex(AnyException::new(
-                    "RuntimeError",
-                    Some(&format!("Function `{}` does not exist.", method_name)),
-                ))
-            })
-            .unwrap();
+    pub fn method_missing(
+        &self,
+        method_name: &str,
+        arguments: Array,
+    ) -> Result<AnyObject, AnyException> {
+        let function = self.instance.dyn_func(method_name).map_err(|_| {
+            AnyException::new(
+                "RuntimeError",
+                Some(&format!("Function `{}` does not exist.", method_name)),
+            )
+        })?;
         let signature = function.signature();
         let parameters = signature.params();
         let number_of_parameters = parameters.len() as isize;
@@ -45,23 +53,21 @@ impl ExportedFunctions {
         let diff: isize = number_of_parameters - number_of_arguments;
 
         if diff > 0 {
-            VM::raise_ex(AnyException::new(
+            return Err(AnyException::new(
                 "ArgumentError",
                 Some(&format!(
                     "Missing {} argument(s) when calling `{}`: Expect {} argument(s), given {}.",
                     diff, method_name, number_of_parameters, number_of_arguments
                 )),
             ));
-            unreachable!();
         } else if diff < 0 {
-            VM::raise_ex(AnyException::new(
+            return Err(AnyException::new(
                 "ArgumentError",
                 Some(&format!(
                     "Given {} extra argument(s) when calling `{}`: Expect {} argument(s), given {}.",
                     diff.abs(), method_name, number_of_parameters, number_of_arguments
                 )),
             ));
-            unreachable!();
         }
 
         let mut function_arguments =
@@ -74,71 +80,66 @@ impl ExportedFunctions {
                     argument
                         .try_convert_to::<Fixnum>()
                         .map_err(|_| {
-                            VM::raise_ex(AnyException::new(
+                            AnyException::new(
                                 "TypeError",
                                 Some(&format!(
                                     "Cannot convert argument #{} to a WebAssembly i32 value.",
                                     nth + 1
                                 )),
-                            ))
-                        })
-                        .unwrap()
+                            )
+                        })?
                         .to_i32(),
                 ),
                 (Type::I64, ValueType::Fixnum) => runtime::Value::I64(
                     argument
                         .try_convert_to::<Fixnum>()
                         .map_err(|_| {
-                            VM::raise_ex(AnyException::new(
+                            AnyException::new(
                                 "TypeError",
                                 Some(&format!(
                                     "Cannot convert argument #{} to a WebAssembly i64 value.",
                                     nth + 1
                                 )),
-                            ))
-                        })
-                        .unwrap()
+                            )
+                        })?
                         .to_i64(),
                 ),
                 (Type::F32, ValueType::Float) => runtime::Value::F32(
                     argument
                         .try_convert_to::<Float>()
                         .map_err(|_| {
-                            VM::raise_ex(AnyException::new(
+                            AnyException::new(
                                 "TypeError",
                                 Some(&format!(
                                     "Cannot convert argument #{} to a WebAssembly f32 value.",
                                     nth + 1
                                 )),
-                            ))
-                        })
-                        .unwrap()
+                            )
+                        })?
                         .to_f64() as f32,
                 ),
                 (Type::F64, ValueType::Float) => runtime::Value::F64(
                     argument
                         .try_convert_to::<Float>()
                         .map_err(|_| {
-                            VM::raise_ex(AnyException::new(
+                            AnyException::new(
                                 "TypeError",
                                 Some(&format!(
                                     "Cannot convert argument #{} to a WebAssembly f64 value.",
                                     nth + 1
                                 )),
-                            ))
-                        })
-                        .unwrap()
+                            )
+                        })?
                         .to_f64(),
                 ),
                 (_, ty) => {
-                    VM::raise_ex(AnyException::new(
+                    return Err(AnyException::new(
                         "ArgumentError",
                         Some(&format!(
                             "Cannot convert argument #{} to a WebAssembly value. Only integers and floats are supported. Given `{:?}`.",
                             nth + 1,
                             ty
                         ))));
-                    unreachable!()
                 }
             };
 
@@ -147,14 +148,17 @@ impl ExportedFunctions {
 
         let results = function
             .call(function_arguments.as_slice())
-            .map_err(|e| VM::raise_ex(AnyException::new("RuntimeError", Some(&format!("{}", e)))))
-            .unwrap();
-
-        match results[0] {
-            runtime::Value::I32(result) => Fixnum::new(result as i64).into(),
-            runtime::Value::I64(result) => Fixnum::new(result).into(),
-            runtime::Value::F32(result) => Float::new(result as f64).into(),
-            runtime::Value::F64(result) => Float::new(result).into(),
+            .map_err(|e| AnyException::new("RuntimeError", Some(&format!("{}", e))))?;
+
+        if results.len() > 0 {
+            Ok(match results[0] {
+                runtime::Value::I32(result) => Fixnum::new(result as i64).into(),
+                runtime::Value::I64(result) => Fixnum::new(result).into(),
+                runtime::Value::F32(result) => Float::new(result as f64).into(),
+                runtime::Value::F64(result) => Float::new(result).into(),
+            })
+        } else {
+            Ok(NilClass::new().into())
         }
     }
 }
@@ -167,27 +171,45 @@ wrappable_struct!(
 
 class!(RubyExportedFunctions);
 
+#[rustfmt::skip]
+methods!(
+    RubyExportedFunctions,
+    itself,
+
+    // Glue code to call the `ExportedFunctions.respond_to` method.
+    fn ruby_exported_functions_method_exists(symbol: Symbol, _include_private: Boolean) -> Boolean {
+        unwrap_or_raise(|| {
+            let symbol = symbol?;
+            let instance = itself.get_data(&*EXPORTED_FUNCTIONS_WRAPPER);
+
+            Ok(Boolean::new(instance.respond_to_missing(symbol.to_str())))
+        })
+    }
+);
+
 /// Glue code to call the `ExportedFunctions.method_missing` method.
 pub extern "C" fn ruby_exported_functions_method_missing(
     argc: Argc,
     argv: *const AnyObject,
     itself: RubyExportedFunctions,
 ) -> AnyObject {
-    let arguments = Value::from(0);
+    unwrap_or_raise(|| {
+        let arguments = Value::from(0);
 
-    unsafe {
-        let argv_pointer: *const Value = mem::transmute(argv);
+        unsafe {
+            let argv_pointer: *const Value = mem::transmute(argv);
 
-        class::rb_scan_args(argc, argv_pointer, str_to_cstring("*").as_ptr(), &arguments)
-    };
+            class::rb_scan_args(argc, argv_pointer, str_to_cstring("*").as_ptr(), &arguments)
+        };
 
-    let mut arguments = Array::from(arguments);
-    let method_name = unsafe { arguments.shift().to::<Symbol>() };
-    let method_name = method_name.to_str();
+        let mut arguments = Array::from(arguments);
+        let method_name = unsafe { arguments.shift().to::<Symbol>() };
+        let method_name = method_name.to_str();
 
-    itself
-        .get_data(&*EXPORTED_FUNCTIONS_WRAPPER)
-        .method_missing(method_name, arguments)
+        itself
+            .get_data(&*EXPORTED_FUNCTIONS_WRAPPER)
+            .method_missing(method_name, arguments)
+    })
 }
 
 /// The `Instance` Ruby class.
@@ -199,20 +221,17 @@ pub struct Instance {
 impl Instance {
     /// Create a new instance of the `Instance` Ruby class.
     /// The constructor receives bytes from a string.
-    pub fn new(bytes: &[u8]) -> Self {
+    pub fn new(bytes: &[u8]) -> Result<Self, AnyException> {
         let import_object = imports! {};
-        let instance = Rc::new(
-            runtime::instantiate(bytes, &import_object)
-                .map_err(|e| {
-                    VM::raise_ex(AnyException::new(
-                        "RuntimeError",
-                        Some(&format!("Failed to instantiate the module:\n    {}", e)),
-                    ))
-                })
-                .unwrap(),
-        );
 
-        Self { instance }
+        Ok(Self {
+            instance: Rc::new(runtime::instantiate(bytes, &import_object).map_err(|e| {
+                AnyException::new(
+                    "RuntimeError",
+                    Some(&format!("Failed to instantiate the module:\n    {}", e)),
+                )
+            })?),
+        })
     }
 }
 
@@ -224,46 +243,56 @@ class!(RubyInstance);
 methods!(
     RubyInstance,
     _itself,
+
     // Glue code to call the `Instance.new` method.
     fn ruby_instance_new(bytes: RString) -> AnyObject {
-        let instance = Instance::new(
-            bytes
-                .map_err(|_| {
-                    VM::raise_ex(AnyException::new(
-                        "ArgumentError",
-                        Some("WebAssembly module must be represented by Ruby bytes only."),
-                    ))
+        unwrap_or_raise(|| {
+            let instance = Instance::new(
+                bytes
+                    .map_err(|_| {
+                        AnyException::new(
+                            "ArgumentError",
+                            Some("WebAssembly module must be represented by Ruby bytes only."),
+                        )
+                    })?
+                    .to_bytes_unchecked(),
+            )?;
+            let exported_functions = ExportedFunctions::new(instance.instance.clone());
+
+            let memory = instance
+                .instance
+                .exports()
+                .find_map(|(_, export)| match export {
+                    Export::Memory(memory) => Some(Memory::new(Rc::new(memory))),
+                    _ => None,
                 })
-                .unwrap()
-                .to_bytes_unchecked(),
-        );
-        let exported_functions = ExportedFunctions::new(instance.instance.clone());
-
-        let memory = instance
-            .instance
-            .exports()
-            .find_map(|(_, export)| match export {
-                Export::Memory(memory) => Some(Memory::new(Rc::new(memory))),
-                _ => None,
-            })
-            .ok_or_else(|| VM::raise_ex(AnyException::new("RuntimeError", Some("The WebAssembly module has no exported memory."))))
-            .unwrap();
+                .ok_or_else(|| {
+                    AnyException::new(
+                        "RuntimeError",
+                        Some("The WebAssembly module has no exported memory."),
+                    )
+                })?;
+
+            let wasmer_module = Module::from_existing("Wasmer");
 
-        let mut ruby_instance: AnyObject =
-            Class::from_existing("Instance").wrap_data(instance, &*INSTANCE_WRAPPER);
+            let mut ruby_instance: AnyObject = wasmer_module
+                .get_nested_class("Instance")
+                .wrap_data(instance, &*INSTANCE_WRAPPER);
 
-        let ruby_exported_functions: RubyExportedFunctions =
-            Class::from_existing("ExportedFunctions")
+            let ruby_exported_functions: RubyExportedFunctions = wasmer_module
+                .get_nested_class("ExportedFunctions")
                 .wrap_data(exported_functions, &*EXPORTED_FUNCTIONS_WRAPPER);
 
-        ruby_instance.instance_variable_set("@exports", ruby_exported_functions);
+            ruby_instance.instance_variable_set("@exports", ruby_exported_functions);
 
-        let ruby_memory: RubyMemory =
-            Class::from_existing("Memory").wrap_data(memory, &*MEMORY_WRAPPER);
+            let ruby_memory: RubyMemory = wasmer_module
+                .get_nested_class("Memory")
+                .wrap_data(memory, &*MEMORY_WRAPPER);
 
-        ruby_instance.instance_variable_set("@memory", ruby_memory);
+            ruby_instance.instance_variable_set("@memory", ruby_memory);
 
-        ruby_instance
+            Ok(ruby_instance)
+        })
     }
 
     // Glue code to call the `Instance.exports` getter method.