wasmer 0.3.0 → 0.4.0

data/src/instance/mod.rs

@@ -0,0 +1,141 @@
+//! The `Instance` WebAssembly class.
+
+pub mod exports;
+pub mod globals;
+
+use crate::{
+    error::unwrap_or_raise,
+    instance::{
+        exports::{ExportedFunctions, RubyExportedFunctions, EXPORTED_FUNCTIONS_WRAPPER},
+        globals::{ExportedGlobals, RubyExportedGlobals, EXPORTED_GLOBALS_WRAPPER},
+    },
+    memory::{Memory, RubyMemory, MEMORY_WRAPPER},
+};
+use lazy_static::lazy_static;
+use rutie::{
+    class, methods, wrappable_struct, AnyException, AnyObject, Exception, Module, NilClass, Object,
+    RString,
+};
+use std::rc::Rc;
+use wasmer_runtime::{self as runtime, imports, Export};
+
+/// The `Instance` Ruby class.
+pub struct Instance {
+    /// The WebAssembly instance.
+    instance: Rc<runtime::Instance>,
+}
+
+impl Instance {
+    /// Create a new instance of the `Instance` Ruby class.
+    /// The constructor receives bytes from a string.
+    pub fn new(bytes: &[u8]) -> Result<Self, AnyException> {
+        let import_object = imports! {};
+
+        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)),
+                )
+            })?),
+        })
+    }
+}
+
+wrappable_struct!(Instance, InstanceWrapper, INSTANCE_WRAPPER);
+
+class!(RubyInstance);
+
+#[rustfmt::skip]
+methods!(
+    RubyInstance,
+    _itself,
+
+    // Glue code to call the `Instance.new` method.
+    fn ruby_instance_new(bytes: RString) -> AnyObject {
+        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 exported_globals = ExportedGlobals::new(instance.instance.clone());
+            let exported_memory =
+                instance
+                    .instance
+                    .exports()
+                    .find_map(|(_, export)| match export {
+                        Export::Memory(memory) => Some(Memory::new(Rc::new(memory))),
+                        _ => None,
+                    });
+
+            let wasmer_module = Module::from_existing("Wasmer");
+
+            let mut ruby_instance: AnyObject = wasmer_module
+                .get_nested_class("Instance")
+                .wrap_data(instance, &*INSTANCE_WRAPPER);
+
+            let ruby_exported_functions: RubyExportedFunctions = wasmer_module
+                .get_nested_class("ExportedFunctions")
+                .wrap_data(exported_functions, &*EXPORTED_FUNCTIONS_WRAPPER);
+
+            let ruby_exported_globals: RubyExportedGlobals = wasmer_module
+                .get_nested_class("ExportedGlobals")
+                .wrap_data(exported_globals, &*EXPORTED_GLOBALS_WRAPPER);
+
+            ruby_instance.instance_variable_set("@exports", ruby_exported_functions);
+            ruby_instance.instance_variable_set("@globals", ruby_exported_globals);
+
+            if let Some(exported_memory) = exported_memory {
+                let ruby_exported_memory: RubyMemory = wasmer_module
+                    .get_nested_class("Memory")
+                    .wrap_data(exported_memory, &*MEMORY_WRAPPER);
+                ruby_instance.instance_variable_set("@memory", ruby_exported_memory);
+            } else {
+                ruby_instance.instance_variable_set("@memory", NilClass::new());
+            }
+
+            Ok(ruby_instance)
+        })
+    }
+
+    // Glue code to call the `Instance.exports` getter method.
+    fn ruby_instance_exported_functions() -> RubyExportedFunctions {
+        unsafe {
+            _itself
+                .instance_variable_get("@exports")
+                .to::<RubyExportedFunctions>()
+        }
+    }
+
+    // Glue code to call the `Instance.globals` getter method.
+    fn ruby_instance_exported_globals() -> RubyExportedGlobals {
+        unsafe {
+            _itself
+                .instance_variable_get("@globals")
+                .to::<RubyExportedGlobals>()
+        }
+    }
+
+    // Glue code to call the `Instance.memory` getter method.
+    fn ruby_instance_memory() -> RubyMemory {
+        unwrap_or_raise(|| {
+            let memory = _itself.instance_variable_get("@memory");
+
+            if !memory.is_nil() {
+                Ok(unsafe { memory.to::<RubyMemory>() })
+            } else {
+                Err(AnyException::new(
+                    "RuntimeError",
+                    Some("The WebAssembly module has no exported memory."),
+                ))
+            }
+        })
+    }
+);

data/src/lib.rs

@@ -24,6 +24,9 @@ pub extern "C" fn Init_wasmer() {
             // Declare the `exports` getter method.
             itself.def("exports", instance::ruby_instance_exported_functions);
 
+            // Declare the `globals` getter method.
+            itself.def("globals", instance::ruby_instance_exported_globals);
+
             // Declare the `memory` getter method.
             itself.def("memory", instance::ruby_instance_memory);
         });
@@ -37,16 +40,51 @@ pub extern "C" fn Init_wasmer() {
             // Declare the `respond_to_missing?` method.
             itself.def(
                 "respond_to_missing?",
-                instance::ruby_exported_functions_method_exists,
+                instance::exports::ruby_exported_functions_method_exists,
+            );
+
+            // Declare the `method_missing` method.
+            itself.def(
+                "method_missing",
+                instance::exports::ruby_exported_functions_method_missing,
+            );
+        });
+
+    let exported_globals_data_class = Class::from_existing("Object");
+
+    // Declare the `ExportedGlobals` Ruby class.
+    wasmer_module
+        .define_nested_class("ExportedGlobals", Some(&exported_globals_data_class))
+        .define(|itself| {
+            // Declare the `respond_to_missing?` method.
+            itself.def(
+                "respond_to_missing?",
+                instance::globals::ruby_exported_globals_method_exists,
             );
 
             // Declare the `method_missing` method.
             itself.def(
                 "method_missing",
-                instance::ruby_exported_functions_method_missing,
+                instance::globals::ruby_exported_globals_method_missing,
             );
         });
 
+    let exported_global_data_class = Class::from_existing("Object");
+
+    // Declare the `ExportedGlobal` Ruby class.
+    wasmer_module
+        .define_nested_class("ExportedGlobal", Some(&exported_global_data_class))
+        .define(|itself| {
+            // Declare the `value` getter.
+            itself.def("value", instance::globals::ruby_exported_global_get_value);
+
+            // Declare the `value` setter.
+            itself.def("value=", instance::globals::ruby_exported_global_set_value);
+
+            // Declare the `mutable` getter.
+            itself.def("mutable", instance::globals::ruby_exported_global_mutable);
+        });
+
     let module_data_class = Class::from_existing("Object");
 
     // Declare the `Module` Ruby class.

data/src/memory/mod.rs

@@ -20,8 +20,7 @@ use crate::{
 use lazy_static::lazy_static;
 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;
+use wasmer_runtime::{self as runtime, units::Pages};
 
 pub struct Memory {
     memory: Rc<runtime::Memory>,

data/wasmer.gemspec

@@ -22,8 +22,8 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = %w(lib)
 
-  spec.add_dependency "rutie", "~> 0.0.3"
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_dependency "rutie", "~> 0.0.4"
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "minitest", "~> 5.14"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wasmer
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Ivan Enderlin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-28 00:00:00.000000000 Z
+date: 2020-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rutie
@@ -16,56 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.0.4
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.14'
 description: Wasmer is a Ruby extension to run WebAssembly binaries.
 email:
 - ivan.enderlin@hoa-project.net
@@ -75,14 +75,16 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".cargo/config"
-- ".circleci/config.yml"
 - ".github/ISSUE_TEMPLATE/---bug-report.md"
 - ".github/ISSUE_TEMPLATE/---feature-request.md"
 - ".github/ISSUE_TEMPLATE/--question.md"
+- ".github/workflows/test.yml"
 - ".gitignore"
+- CHANGELOG.md
 - Cargo.lock
 - Cargo.toml
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - bors.toml
@@ -90,7 +92,9 @@ files:
 - lib/wasmer.rb
 - lib/wasmer/version.rb
 - src/error.rs
-- src/instance.rs
+- src/instance/exports.rs
+- src/instance/globals.rs
+- src/instance/mod.rs
 - src/lib.rs
 - src/memory/mod.rs
 - src/memory/view.rs

data/.circleci/config.yml

@@ -1,72 +0,0 @@
-version: 2.1
-
-# List of all jobs.
-jobs:
-  # Build and test the project the project.
-  build-and-test:
-    docker:
-      - image: circleci/ruby:latest
-    steps:
-      # Update the project.
-      - checkout
-
-      # If the cache exists, loads it.
-      - restore_cache:
-          keys:
-            - v1-linux-{{ arch }}-{{ checksum "Cargo.lock" }}
-            - v1-linux-{{ arch }}
-
-      # Install Rust.
-      - run:
-          name: Install Rust
-          command: |
-            test -d /usr/local/cargo || curl https://sh.rustup.rs -sSf | sh -s -- -y
-
-      # Install `just` used to manage the project.
-      - run:
-          name: Install just
-          command: |
-            export PATH="$HOME/.cargo/bin:$PATH"
-            test -f $HOME/.cargo/bin/just || cargo install just
-
-      # Compile the Ruby extension.
-      - run:
-          name: Compile the Ruby extension
-          command: |
-            export PATH="$HOME/.cargo/bin:$PATH"
-            just build
-
-      # Save everything in the cache (except the `just` binary).
-      - save_cache:
-          paths:
-            - /usr/local/cargo/registry
-            - target/release/.fingerprint
-            - target/release/build
-            - target/release/deps
-          key: v1-linux-{{ arch }}-{{ checksum "Cargo.lock" }}
-
-      # Run the extension test suites.
-      - run:
-          name: Test the extension
-          command: |
-            export PATH="$HOME/.cargo/bin:$PATH"
-            gem install bundler
-            just test
-
-
-# List of workflows.
-workflows:
-  version: 2
-
-  # The build workflow.
-  build:
-    jobs:
-      # Run the `build-and-test` job for the `trying` and `staging` branches, and all tags.
-      - build-and-test:
-          filters:
-            branches:
-              only:
-                - trying
-                - staging
-            tags:
-              only: /.*/