wasmer 0.4.0 → 0.5.0

data/crates/rutie-test/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "rutie-test"
+version = "0.1.0"
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+edition = "2018"
+description = "Helpers to test code written with `rutie`."
+readme = "README.md"
+repository = "https://github.com/wasmerio/wasmer-ruby"
+keywords = ["ruby", "extension"]
+publish = false

data/crates/rutie-test/src/lib.rs

@@ -0,0 +1,38 @@
+#[macro_export]
+macro_rules! test_ruby {
+    ($code:expr) => {
+        use rutie::VM;
+
+        let code = format!(
+            r#"
+root = File.expand_path("../..", ENV["CARGO_MANIFEST_DIR"])
+
+Dir.chdir(root)
+
+$LOAD_PATH.unshift(File.expand_path("lib", root))
+
+require "wasmer"
+
+class AssertionError < RuntimeError
+end
+
+def assert &block
+  raise AssertionError unless yield
+end
+
+{code}
+"#,
+            code = $code
+        );
+
+        VM::init();
+        VM::init_loadpath();
+
+        match VM::eval(&code) {
+            Ok(value) => assert!(true),
+            Err(err) => panic!("{:?}", err),
+        }
+    };
+}
+
+pub fn foo() {}

data/crates/wasmer/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "wasmer"
+version = "0.5.0"
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+edition = "2018"
+description = "Ruby extension to run WebAssembly binaries"
+readme = "README.md"
+repository = "https://github.com/wasmerio/wasmer-ruby"
+keywords = ["ruby", "extension", "webassembly"]
+categories = ["wasm"]
+publish = false
+
+[lib]
+name = "wasmer_ruby"
+crate-type = ["dylib", "rlib"]
+
+[dependencies]
+wasmer = "1.0"
+wasmer-wasi = "1.0"
+rutie = "0.8"
+rutie-derive = { path = "../rutie-derive", version = "0.1.0" }
+lazy_static = "1.4"
+wat = "1.0"
+wasmprinter = "0.2"
+
+[dev-dependencies]
+rutie-test = { path = "../rutie-test", version = "0.1.0" }

data/crates/wasmer/README.md

@@ -0,0 +1,228 @@
+<div align="center">
+  <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmer logo">
+  </a>
+  
+  <h1>Wasmer Ruby</h1>
+  
+  <p>
+    <a href="https://github.com/wasmerio/wasmer-ruby/actions?query=workflow%3A%22Build+and+Test%22">
+      <img src="https://github.com/wasmerio/wasmer-ruby/workflows/Build%20and%20Test/badge.svg" alt="Build Status">
+    </a>
+    <a href="https://github.com/wasmerio/wasmer-ruby/blob/master/LICENSE">
+      <img src="https://img.shields.io/github/license/wasmerio/wasmer-ruby.svg" alt="License">
+    </a>
+    <a href="https://rubygems.org/gems/wasmer">
+      <img src="https://img.shields.io/gem/v/wasmer.svg" alt="Wasmer on RubyGem">
+    </a> 
+    <a href="https://rubygems.org/gems/wasmer">
+      <img src="https://img.shields.io/gem/dt/wasmer.svg" alt="Number of downloads">
+    </a> 
+    <a href="https://wasmerio.github.io/wasmer-ruby/wasmer_ruby/index.html">
+      <img src="https://img.shields.io/badge/documentation-API-f06" alt="API Documentation">
+    </a> 
+  </p>
+
+  <h3>
+    <a href="https://wasmer.io/">Website</a>
+    <span> • </span>
+    <a href="https://docs.wasmer.io">Docs</a>
+    <span> • </span>
+    <a href="https://slack.wasmer.io/">Slack Channel</a>
+  </h3>
+</div>
+
+<hr/>
+
+A complete and mature WebAssembly runtime for Ruby based on
+[Wasmer](https://github.com/wasmerio/wasmer).
+
+Features
+
+  * **Easy to use**: The `wasmer` API mimics the standard WebAssembly API,
+  * **Fast**: `wasmer` executes the WebAssembly modules as fast as
+    possible, close to **native speed**,
+  * **Safe**: All calls to WebAssembly will be fast, but more
+    importantly, completely safe and sandboxed.
+
+**Documentation**: [browse the detailed API
+documentation](https://wasmerio.github.io/wasmer-ruby/wasmer_ruby/index.html)
+full of examples.
+
+**Examples** as tutorials: [browser the `examples/`
+directory](https://github.com/wasmerio/wasmer-ruby/tree/master/examples),
+it's the best place for a complete introduction!
+
+# Quick Introduction
+
+The `wasmer` package brings the required API to execute WebAssembly
+modules. In a nutshell, `wasmer` compiles the WebAssembly module into
+compiled code, and then executes it. `wasmer` is designed to work in
+various environments and platforms. To achieve this, Wasmer (the
+original runtime) provides multiple engines and multiple
+compilers.
+
+Succinctly, an _engine_ is responsible to drive the _compilation_ (by
+using a _compiler_) and the _execution_ of a WebAssembly
+module. Wasmer comes with many engines and compilers, but for the Ruby
+extension, it only provides the JIT engine with the Cranelift
+compiler. It is subject to change in the future where the user will
+have the choice to select its own engine and compiler.
+
+## Install
+
+To install the `wasmer` Ruby gem, just run this command in your shell:
+
+```sh
+$ gem install wasmer
+```
+
+And you're ready to get fun!
+
+[View the `wasmer` gem on RubyGems][wasmer-gem].
+
+> Note: [Rust][rust] is required to install the Ruby library (Cargo
+—the build tool for Rust— is used to compile the extension). See [how
+to install Rust][install-rust].
+
+## Example
+
+We highly recommend to read the
+[`examples/`](https://github.com/wasmerio/wasmer-ruby/tree/master/examples)
+directory, which contains a sequence of examples/tutorials. It's the
+best place to learn by reading examples.
+
+But for the most eager of you, and we know you're numerous you
+mischievous, there is a quick toy program in
+`examples/appendices/simple.rs`, written in Rust:
+
+```rust
+#[no_mangle]
+pub extern fn sum(x: i32, y: i32) -> i32 {
+    x + y
+}
+```
+
+After compilation to WebAssembly, the
+[`examples/appendices/simple.wasm`](https://github.com/wasmerio/wasmer-ruby/blob/master/examples/appendices/simple.wasm)
+binary file is generated.
+
+Then, we can execute it in Ruby:
+
+```ruby
+require "wasmer"
+
+# Let's define the store, that holds the engine, that holds the compiler.
+store = Wasmer::Store.new
+
+# Let's compile the module to be able to execute it!
+module_ = Wasmer::Module.new store, IO.read("simple.wasm", mode: "rb")
+
+# Now the module is compiled, we can instantiate it.
+instance = Wasmer::Instance.new module_, nil
+
+# Call the exported `sum` function.
+result = instance.exports.sum.(5, 37)
+
+puts result # 42!
+```
+
+And then, finally, enjoy by running:
+
+```sh
+$ ruby examples/appendices/simple.rb
+```
+
+## Development
+
+The Ruby extension is written in [Rust][rust], with [`rutie`][rutie].
+
+First, you need to install Rust and Ruby. We will not make you the
+affront to explain to you how to install Ruby (if you really need,
+check [`rbenv`][rbenv]). For Rust though, we advice to use
+[`rustup`][rustup], then:
+
+```sh
+$ rustup install stable
+```
+
+Then, after installing [`just`][just], you can simply run:
+
+```sh
+$ just build
+```
+
+The supported Ruby versions are:
+
+* Ruby 2.6,
+* Ruby 2.7,
+* Ruby 3.0.
+
+### Extensions to `rutie`
+
+This project provides extensions to `rutie`, through the
+`rutie-derive` and `rutie-derive-macros` crates (see the `crates/`
+directory). Those crates aim at enhancing `rutie` by providing a
+better “Domain Specific Language” (DSL for short) to declare Ruby
+modules, classes, methods and functions. It's not perfect but it does
+a good job for the moment. Contributions on that front are welcomed
+too!
+
+### Testing
+
+Running the `test` recipe will automatically build and run all the
+tests. It includes library tests, along with documentation tests.
+
+```sh
+$ just test
+```
+
+### Documentation
+
+To generate the documentation, run the following command:
+
+```sh
+$ just doc
+```
+
+All the examples in the documentation are automatically run as tests,
+called doctests. To run the doctests, run `just test`.
+
+## What is WebAssembly?
+
+Quoting [the WebAssembly site][wasm]:
+
+> WebAssembly (abbreviated Wasm) is a binary instruction format for a
+> stack-based virtual machine. Wasm is designed as a portable target
+> for compilation of high-level languages like C/C++/Rust, enabling
+> deployment on the web for client and server applications.
+
+About speed:
+
+> WebAssembly aims to execute at native speed by taking advantage of
+> [common hardware
+> capabilities](https://webassembly.org/docs/portability/#assumptions-for-efficient-execution)
+> available on a wide range of platforms.
+
+About safety:
+
+> WebAssembly describes a memory-safe, sandboxed [execution
+> environment](https://webassembly.org/docs/semantics/#linear-memory) […].
+
+[wasm]: https://webassembly.org/
+
+## License
+
+The entire project is under the MIT License. Please read [the
+`LICENSE` file][license].
+
+[license]: https://github.com/wasmerio/wasmer/blob/master/LICENSE
+
+[Wasmer]: https://github.com/wasmerio/wasmer
+[rust]: https://www.rust-lang.org/
+[install-rust]: https://www.rust-lang.org/tools/install
+[wasmer-gem]: https://rubygems.org/gems/wasmer
+[rutie]: https://github.com/danielpclark/rutie
+[rbenv]: https://github.com/rbenv/rbenv
+[rustup]: https://rustup.rs/
+[just]: https://github.com/casey/just/

data/crates/wasmer/src/doc.rs

@@ -0,0 +1,1512 @@
+macro_rules! x {
+    () => {
+        unimplemented!("This code exists only for documentation purposes");
+    };
+}
+
+/// Declare Ruby native types. It's only for documentation purposes.
+pub mod Ruby {
+    /// A native Ruby boolean.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// true
+    /// # "#); }
+    /// ```
+    pub struct Boolean;
+
+    /// A native Ruby integer.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// 42
+    /// # "#); }
+    /// ```
+    pub struct Integer;
+
+    /// A native Ruby float.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// 4.2
+    /// # "#); }
+    /// ```
+    pub struct Float;
+
+    /// A native Ruby string.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// "hello"
+    /// # "#); }
+    /// ```
+    pub struct String;
+
+    /// A native Ruby array.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// [1, "two", 3.0]
+    /// # "#); }
+    /// ```
+    pub struct Array<T>;
+
+    /// A native Ruby hash.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// {"foo": 42, "bar": 153}
+    /// # "#); }
+    /// ```
+    pub struct Hash<K, V>;
+
+    /// Represents any kind of object.
+    pub struct Any;
+}
+
+/// The `Wasmer` module provides the entire Wasmer API to manipulate
+/// the WebAssembly runtime.
+pub mod Wasmer {
+    use crate::doc::Ruby::*;
+
+    /// A WebAssembly type.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// Wasmer::Type::I32
+    /// # "#); }
+    /// ```
+    #[allow(non_camel_case_types)]
+    pub enum Type {
+        I32,
+        I64,
+        F32,
+        F64,
+        V128,
+        EXTERN_REF,
+        FUNC_REF,
+    }
+
+    /// Represents the signature of a function that is either
+    /// implemented in WebAssembly module or exposed to WebAssembly by
+    /// the host.
+    ///
+    /// WebAssembly functions can have 0 or more parameters and results.
+    pub struct FunctionType;
+
+    impl FunctionType {
+        /// Creates a new `FunctionType`.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// function_type = Wasmer::FunctionType.new(
+        ///     [Wasmer::Type::I32, Wasmer::Type::I64],
+        ///     [Wasmer::Type::I32]
+        /// )
+        /// # "#); }
+        /// ```
+        pub fn new(params: Array<Type>, results: Array<Type>) -> Self {
+            x!()
+        }
+
+        /// Returns the parameters.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// function_type = Wasmer::FunctionType.new(
+        ///     [Wasmer::Type::I32, Wasmer::Type::I64],
+        ///     [Wasmer::Type::I32]
+        /// )
+        ///
+        /// assert { function_type.params == [Wasmer::Type::I32, Wasmer::Type::I64] }
+        /// # "#); }
+        /// ```
+        pub fn params(&self) -> Array<Type> {
+            x!()
+        }
+
+        /// Returns the results.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// function_type = Wasmer::FunctionType.new(
+        ///     [Wasmer::Type::I32, Wasmer::Type::I64],
+        ///     [Wasmer::Type::I32]
+        /// )
+        ///
+        /// assert { function_type.results == [Wasmer::Type::I32] }
+        /// # "#); }
+        /// ```
+        pub fn results(&self) -> Array<Type> {
+            x!()
+        }
+    }
+
+    /// A descriptor for a WebAssembly memory type.
+    ///
+    /// Memories are described in units of pages (64Kb) and represent
+    /// contiguous chunks of addressable memory.
+    pub struct MemoryType;
+
+    impl MemoryType {
+        /// Creates a new `MemoryType`.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// memory_type = Wasmer::MemoryType.new 1, 3, true
+        /// # "#); }
+        /// ```
+        pub fn new(minimum: Integer, maximum: Option<Integer>, shared: Boolean) -> Self {
+            x!()
+        }
+
+        /// Returns the minimum size of the memory.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// memory_type = Wasmer::MemoryType.new 1, 3, true
+        ///
+        /// assert { memory_type.minimum == 1 }
+        /// # "#); }
+        /// ```
+        pub fn minimum(&self) -> Integer {
+            x!()
+        }
+
+        /// Returns the maximum size of the memory of any.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// memory_type = Wasmer::MemoryType.new 1, 3, true
+        ///
+        /// assert { memory_type.maximum == 3 }
+        /// # "#); }
+        /// ```
+        pub fn maximum(&self) -> Option<Integer> {
+            x!()
+        }
+
+        /// Returns whether the memory is shared or not.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// memory_type = Wasmer::MemoryType.new 1, 3, true
+        ///
+        /// assert { memory_type.shared? }
+        /// # "#); }
+        /// ```
+        pub fn shared(&self) -> Integer {
+            x!()
+        }
+    }
+
+    /// A descriptor for a WebAssembly global.
+    pub struct GlobalType;
+
+    impl GlobalType {
+        /// Creates a new `GlobalType`.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// global_type = Wasmer::GlobalType.new Wasmer::Type::I32, true
+        /// # "#); }
+        /// ```
+        pub fn new(r#type: Type, mutable: Boolean) -> Self {
+            x!()
+        }
+
+        /// Returns the type of the global.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// global_type = Wasmer::GlobalType.new Wasmer::Type::I32, true
+        ///
+        /// assert { global_type.type == Wasmer::Type::I32 }
+        /// # "#); }
+        /// ```
+        pub fn r#type(&self) -> Type {
+            x!()
+        }
+
+        /// Returns whether the global is mutable.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// global_type = Wasmer::GlobalType.new Wasmer::Type::I32, true
+        ///
+        /// assert { global_type.mutable? }
+        /// # "#); }
+        /// ```
+        pub fn mutable(&self) -> Boolean {
+            x!()
+        }
+    }
+
+    /// A descriptor for a table in a WebAssembly module.
+    ///
+    /// Tables are contiguous chunks of a specific element, typically
+    /// a funcref or externref. The most common use for tables is a
+    /// function table through which call_indirect can invoke other
+    /// functions.
+    pub struct TableType;
+
+    impl TableType {
+        /// Creates a new `TableType`.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// table_type = Wasmer::TableType.new Wasmer::Type::I32, 7, 42
+        /// # "#); }
+        /// ```
+        pub fn new(r#type: Type, minimum: Integer, maximum: Option<Integer>) -> Self {
+            x!()
+        }
+
+        /// Returns the type of table.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// table_type = Wasmer::TableType.new Wasmer::Type::I32, 7, 42
+        ///
+        /// assert { table_type.type == Wasmer::Type::I32 }
+        /// # "#); }
+        /// ```
+        pub fn r#type(&self) -> Type {
+            x!()
+        }
+
+        /// Returns the minimum size of the table.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// table_type = Wasmer::TableType.new Wasmer::Type::I32, 7, 42
+        ///
+        /// assert { table_type.minimum == 7 }
+        /// # "#); }
+        /// ```
+        pub fn minimum(&self) -> Integer {
+            x!()
+        }
+
+        /// Returns the maximum size of the table if any.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// table_type = Wasmer::TableType.new Wasmer::Type::I32, 7, 42
+        ///
+        /// assert { table_type.maximum == 42 }
+        /// # "#); }
+        /// ```
+        pub fn maximum(&self) -> Option<Integer> {
+            x!()
+        }
+    }
+
+    /// Represents the type of a module's export (not to be confused
+    /// with an export of an instance). It is usually built from the
+    /// [`Module::exports`] getter.
+    pub struct ExportType;
+
+    impl ExportType {
+        /// Creates a new `ExportType`.
+        ///
+        /// `type` must be of type [`FunctionType`], [`MemoryType`],
+        /// [`GlobalType`] or [`TableType`].
+        ///
+        /// # Example
+        ///
+        /// ```rust,ignore
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// export_type = Wasmer::ExportType.new "foo", Wasmer::Function.new([Wasmer::Type::I32], [])
+        /// # "#); }
+        /// ```
+        pub fn new(name: String, r#type: Any) -> Self {
+            x!()
+        }
+
+        /// Returns the name of the export.
+        ///
+        /// # Example
+        ///
+        /// ```rust,ignore
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// export_type = Wasmer::ExportType.new "foo", Wasmer::Function.new([Wasmer::Type::I32], [])
+        ///
+        /// assert { export_type.name == "foo" }
+        /// # "#); }
+        /// ```
+        pub fn name(&self) -> String {
+            x!()
+        }
+
+        /// Returns the type of the export.
+        ///
+        /// # Example
+        ///
+        /// ```rust,ignore
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// export_type = Wasmer::ExportType.new "foo", Wasmer::Function.new([Wasmer::Type::I32], [])
+        ///
+        /// assert { export_type.type == Wasmer::Type::I32 }
+        /// # "#); }
+        /// ```
+        pub fn r#type(&self) -> Type {
+            x!()
+        }
+    }
+
+    /// Represents the type of a module's import. It is usually built
+    /// from the [`Module::imports`] getter.
+    pub struct ImportType;
+
+    impl ImportType {
+        /// Creates a new `ImportType`.
+        ///
+        /// `type` must be of type [`FunctionType`], [`MemoryType`],
+        /// [`GlobalType`] or [`TableType`].
+        ///
+        /// # Example
+        ///
+        /// ```rust,ignore
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// import_type = Wasmer::ImportType.new "foo", "bar", Wasmer::Function.new([Wasmer::Type::I32], [])
+        /// # "#); }
+        /// ```
+        pub fn new(module: String, name: String, r#type: Any) -> Self {
+            x!()
+        }
+
+        /// Returns the module's name of the import.
+        ///
+        /// # Example
+        ///
+        /// ```rust,ignore
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// import_type = Wasmer::ImportType.new "foo", "bar", Wasmer::Function.new([Wasmer::Type::I32], [])
+        /// # "#); }
+        ///
+        /// assert { import_type.module == "foo" }
+        /// ```
+        pub fn module(&self) -> String {
+            x!()
+        }
+
+        /// Returns the name of the import.
+        ///
+        /// # Example
+        ///
+        /// ```rust,ignore
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// import_type = Wasmer::ImportType.new "foo", "bar", Wasmer::Function.new([Wasmer::Type::I32], [])
+        /// # "#); }
+        ///
+        /// assert { import_type.name == "bar" }
+        /// ```
+        pub fn name(&self) -> String {
+            x!()
+        }
+
+        /// Returns the type of the import.
+        ///
+        /// # Example
+        ///
+        /// ```rust,ignore
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// import_type = Wasmer::ImportType.new "foo", "bar", Wasmer::Function.new([Wasmer::Type::I32], [])
+        /// # "#); }
+        ///
+        /// assert { import_type.type == Wasmer::Type::I32 }
+        /// ```
+        pub fn r#type(&self) -> Type {
+            x!()
+        }
+    }
+
+    /// The store represents all global state that can be manipulated
+    /// by WebAssembly programs. It consists of the runtime
+    /// representation of all instances of functions, tables,
+    /// memories, and globals that have been allocated during the
+    /// lifetime of the abstract machine.
+    ///
+    /// The `Store` holds the engine (that is —amongst many things— used
+    /// to compile the WebAssembly bytes into a valid module
+    /// artifact), in addition to the Tunables (that are used to
+    /// create the memories, tables and globals). For the moment, it's
+    /// not possible to tweak the engines and the compilers.
+    ///
+    /// Specification: <https://webassembly.github.io/spec/core/exec/runtime.html#store>
+    ///
+    /// # Example
+    ///
+    /// Use the store with the default engine and the default compiler:
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// store = Wasmer::Store.new
+    /// # "#); }
+    /// ```
+    pub struct Store;
+
+    impl Store {
+        /// Creates a new `Store`.
+        pub fn new() -> Self {
+            x!()
+        }
+    }
+
+    /// A WebAssembly module contains stateless WebAssembly code that has
+    /// already been compiled and can be instantiated multiple times.
+    ///
+    /// Creates a new WebAssembly `Module` given the configuration in the
+    /// store.
+    ///
+    /// If the provided bytes are not WebAssembly-like (start with
+    /// b"\0asm"), this function will try to to convert the bytes assuming
+    /// they correspond to the WebAssembly text format.
+    ///
+    /// # Security
+    ///
+    /// Before the code is compiled, it will be validated using the store
+    /// features.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// store = Wasmer::Store.new
+    ///
+    /// ## Let's compile WebAssembly from bytes.
+    /// wasm_bytes = "\x00asm\x01\x00\x00\x00";
+    /// module_ = Wasmer::Module.new store, wasm_bytes
+    ///
+    /// ## Let's compile WebAssembly from WAT.
+    /// module_ = Wasmer::Module.new store, "(module)"
+    /// # "#); }
+    /// ```
+    pub struct Module;
+
+    impl Module {
+        /// Validates a new WebAssembly Module given the configuration
+        /// in the [`Store`].
+        ///
+        /// This validation is normally pretty fast and checks the
+        /// enabled WebAssembly features in the Store engine to assure
+        /// deterministic validation of the `Module`.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// wasm_bytes = "\x00asm\x01\x00\x00\x00";
+        /// Wasmer::Module.validate Wasmer::Store.new, wasm_bytes
+        /// # "#); }
+        /// ```
+        pub fn validate(store: Store, bytes: String) -> Boolean {
+            x!()
+        }
+
+        /// Creates a new [`Module`].
+        pub fn new(store: Store, bytes: String) -> Self {
+            x!()
+        }
+
+        /// Get or set the current name of the module.
+        ///
+        /// This name is normally set in the WebAssembly bytecode by
+        /// some compilers, but can be also overwritten.
+        ///
+        /// Not all modules have a name.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// store = Wasmer::Store.new
+        ///
+        /// ## Module with an existing name.
+        /// assert { Wasmer::Module.new(store, "(module $moduleName)").name == "moduleName" }
+        ///
+        /// ## Module with no name.
+        /// assert { Wasmer::Module.new(store, "(module)").name.nil? }
+        ///
+        /// ## Change the module's name.
+        /// module_ = Wasmer::Module.new store, "(module $moduleName)"
+        /// module_.name = "hello"
+        ///
+        /// assert { module_.name == "hello" }
+        /// # "#); }
+        /// ```
+        pub fn name(&self, name: String) {
+            x!()
+        }
+
+        /// Returns a list of [`ExportType`] objects, which represents
+        /// all the exports of this module.
+        ///
+        /// The order of the exports is guaranteed to be the same as
+        /// in the WebAssembly bytecode.
+        ///
+        /// # Example
+        ///
+        /// See the [`ExportType`] class to learn more.
+        pub fn exports(&self) -> Array<ExportType> {
+            x!()
+        }
+
+        /// Returns a list of [`ImportType`] objects, which represents
+        /// all the imports of this module.
+        ///
+        /// The order of the imports is guaranteed to be the same as
+        /// in the WebAssembly bytecode.
+        ///
+        /// # Example
+        ///
+        /// See the [`ImportType`] class to learn more.
+        pub fn imports(&self) -> Array<ImportType> {
+            x!()
+        }
+
+        /// Get the custom sections of the module given a `name`.
+        ///
+        /// # Important
+        ///
+        /// Following the WebAssembly specification, one name can have
+        /// multiple custom sections. That's why a list of bytes is
+        /// returned rather than bytes.
+        ///
+        /// Consequently, the empty list represents the absence of a
+        /// custom section for the given name.
+        ///
+        /// # Example
+        ///
+        /// ```rust,ignore
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// bytes = IO.read "custom_sections.wasm", mode: "rb"
+        /// module_ = Wasmer::Module.new Wasmer::Store.new, bytes
+        ///
+        /// assert { module_.custom_sections("easter_egg") == ["Wasmer"] }
+        /// assert { module_.custom_sections("hello") == ["World!"] }
+        /// assert { module_.custom_sections("foo") == [] }
+        /// # "#); }
+        /// ```
+        pub fn custom_sections(&self, name: String) -> Array<String> {
+            x!()
+        }
+
+        /// Serializes a module into a binary representation that the
+        /// engine can later process via [`Module::deserialize`].
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// module_ = Wasmer::Module.new Wasmer::Store.new, "(module)"
+        /// assert { module_.serialize.is_a?(String) }
+        /// # "#); }
+        /// ```
+        pub fn serialize(&self) -> String {
+            x!()
+        }
+
+        /// Deserializes a serialized module binary into a Module.
+        ///
+        /// **Note**: the module has to be serialized before with the
+        /// serialize method.
+        ///
+        /// # Safety
+        ///
+        /// This function is inherently unsafe as the provided bytes:
+        ///
+        /// 1. Are going to be deserialized directly into Rust objects.
+        /// 2. Contains the function assembly bodies and, if
+        ///    intercepted, a malicious actor could inject code into
+        ///    executable memory.
+        ///
+        /// And as such, the deserialize method is unsafe.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// store = Wasmer::Store.new
+        ///
+        /// serialized_module = Wasmer::Module.new(
+        ///   store,
+        ///   (<<~WAST)
+        ///   (module
+        ///     (func (export "function") (param i32 i64)))
+        ///   WAST
+        /// ).serialize
+        ///
+        /// module_ = Wasmer::Module.deserialize store, serialized_module
+        /// serialized_module = nil
+        ///
+        /// exports = module_.exports
+        ///
+        /// assert { exports.length() == 1 }
+        /// assert { exports[0].name == "function" }
+        /// assert { exports[0].type.is_a?(Wasmer::FunctionType) }
+        /// assert { exports[0].type.params == [Wasmer::Type::I32, Wasmer::Type::I64] }
+        /// assert { exports[0].type.results == [] }
+        /// # "#); }
+        /// ```
+        pub fn deserialize(bytes: String) -> Self {
+            x!()
+        }
+    }
+
+    /// A WebAssembly instance is a stateful, executable instance of a
+    /// WebAssembly [`Module`].
+    ///
+    /// Instance objects contain all the exported WebAssembly
+    /// functions, memories, tables and globals that allow interacting
+    /// with WebAssembly.
+    ///
+    /// Specification:
+    /// <https://webassembly.github.io/spec/core/exec/runtime.html#module-instances>
+    ///
+    /// # Examples
+    ///
+    /// Example without an import object. The following creates a
+    /// module with a sum exported function that sum two integers.
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// module_ = Wasmer::Module.new(
+    ///   Wasmer::Store.new,
+    ///   (<<~WAST)
+    ///   (module
+    ///     (type (func (param i32 i32) (result i32)))
+    ///     (func (type 0)
+    ///       local.get 0
+    ///       local.get 1
+    ///       i32.add)
+    ///     (export "sum" (func 0)))
+    ///   WAST
+    /// )
+    /// instance = Wasmer::Instance.new module_, nil
+    ///
+    /// assert { instance.exports.sum.(1, 2) == 3 }
+    /// # "#); }
+    /// ```
+    ///
+    /// Example with an import object. The following creates a module
+    /// that (i) imports a sum function from the `math` namespace, and
+    /// (ii) exports an `add_one` function that adds 1 to any given
+    /// integer (by using the `math.sum` function).
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// def sum(x, y)
+    ///   x + y
+    /// end
+    ///
+    /// store = Wasmer::Store.new
+    /// module_ = Wasmer::Module.new(
+    ///   store,
+    ///   (<<~WAST)
+    ///   (module
+    ///     (import "math" "sum" (func $sum (param i32 i32) (result i32)))
+    ///     (func (export "add_one") (param i32) (result i32)
+    ///       local.get 0
+    ///       i32.const 1
+    ///       call $sum))
+    ///   WAST
+    /// )
+    ///
+    /// import_object = Wasmer::ImportObject.new
+    /// import_object.register(
+    ///   "math",
+    ///   {
+    ///     :sum => Wasmer::Function.new(
+    ///        store,
+    ///        method(:sum),
+    ///        Wasmer::FunctionType.new([Wasmer::Type::I32, Wasmer::Type::I32], [Wasmer::Type::I32])
+    ///     )
+    ///   }
+    /// )
+    ///
+    /// instance = Wasmer::Instance.new module_, import_object
+    ///
+    /// assert { instance.exports.add_one.(1) == 2 }
+    /// # "#); }
+    /// ```
+    pub struct Instance;
+
+    impl Instance {
+        /// Creates a new `Instance`.
+        pub fn new(module: Module, import_object: ImportObject) -> Self {
+            x!()
+        }
+
+        /// Returns all the exported entities.
+        pub fn exports(&self) -> Exports {
+            x!()
+        }
+    }
+
+    /// Represents all the exports of an instance. It is built by [`Instance::exports`].
+    ///
+    /// Exports can be of kind [`Function`], [`Global`], [`Table`], or [`Memory`].
+    pub struct Exports;
+
+    impl Exports {
+        /// Returns the number of exports.
+        pub fn length(&self) -> Integer {
+            x!()
+        }
+
+        /// Returns either a [`Function`], a [`Memory`], a [`Global`],
+        /// or a [`Table`] if the name for the export exists.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// module_ = Wasmer::Module.new(
+        ///   Wasmer::Store.new,
+        ///   (<<~WAST)
+        ///   (module
+        ///     (func (export "func") (param i32 i64))
+        ///     (global (export "glob") i32 (i32.const 7))
+        ///     (table (export "tab") 0 funcref)
+        ///     (memory (export "mem") 1))
+        ///   WAST
+        /// )
+        /// instance = Wasmer::Instance.new module_, nil
+        /// exports = instance.exports
+        ///
+        /// assert { exports.respond_to? :func }
+        /// assert { exports.respond_to? :glob }
+        /// assert { exports.respond_to? :tab }
+        /// assert { exports.respond_to? :mem }
+        /// assert { not(exports.respond_to? :foo) }
+        ///
+        /// assert { exports.func.is_a?(Wasmer::Function) }
+        /// assert { exports.mem.is_a?(Wasmer::Memory) }
+        /// assert { exports.glob.is_a?(Wasmer::Global) }
+        /// assert { exports.tab.is_a?(Wasmer::Table) }
+        /// # "#); }
+        /// ```
+        pub fn method_missing(name: String) -> Any {
+            x!()
+        }
+    }
+
+    /// An `ImportObject` represents all of the import data used when
+    /// instantiating a WebAssembly module.
+    ///
+    /// # Example
+    ///
+    /// Importing a function, `math.sum`, and call it through the
+    /// exported `add_one` function:
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// def sum(x, y)
+    ///   x + y
+    /// end
+    ///
+    /// store = Wasmer::Store.new
+    /// module_ = Wasmer::Module.new(
+    ///   store,
+    ///   (<<~WAST)
+    ///   (module
+    ///     (import "math" "sum" (func $sum (param i32 i32) (result i32)))
+    ///     (func (export "add_one") (param i32) (result i32)
+    ///       local.get 0
+    ///       i32.const 1
+    ///       call $sum))
+    ///   WAST
+    /// )
+    ///
+    /// import_object = Wasmer::ImportObject.new
+    /// import_object.register(
+    ///   "math",
+    ///   {
+    ///     :sum => Wasmer::Function.new(
+    ///       store,
+    ///       method(:sum),
+    ///       Wasmer::FunctionType.new([Wasmer::Type::I32, Wasmer::Type::I32], [Wasmer::Type::I32])
+    ///     )
+    ///   }
+    /// )
+    ///
+    /// instance = Wasmer::Instance.new module_, import_object
+    ///
+    /// assert { instance.exports.add_one.(1) == 2 }
+    /// # "#); }
+    /// ```
+    ///
+    /// Importing a memory:
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// store = Wasmer::Store.new
+    /// module_ = Wasmer::Module.new(
+    ///   store,
+    ///   (<<~WAST)
+    ///   (module
+    ///     (import "env" "memory" (memory $memory 1))
+    ///     (func (export "increment")
+    ///       i32.const 0
+    ///       i32.const 0
+    ///       i32.load    ;; load 0
+    ///       i32.const 1
+    ///       i32.add     ;; add 1
+    ///       i32.store   ;; store at 0
+    ///       ))
+    ///   WAST
+    /// )
+    ///
+    /// memory = Wasmer::Memory.new store, Wasmer::MemoryType.new(1, nil, false)
+    /// view = memory.uint8_view(0)
+    ///
+    /// import_object = Wasmer::ImportObject.new
+    /// import_object.register(
+    ///   "env",
+    ///   {
+    ///     :memory => memory,
+    ///   }
+    /// )
+    ///
+    /// instance = Wasmer::Instance.new module_, import_object
+    ///
+    /// assert { view[0] == 0 }
+    ///
+    /// instance.exports.increment.()
+    /// assert { view[0] == 1 }
+    ///
+    /// instance.exports.increment.()
+    /// assert { view[0] == 2 }
+    /// # "#); }
+    /// ```
+    ///
+    /// Importing a global:
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// store = Wasmer::Store.new
+    /// module_ = Wasmer::Module.new(
+    ///   store,
+    ///   (<<~WAST)
+    ///     (module
+    ///       (import "env" "global" (global $global (mut i32)))
+    ///       (func (export "read_g") (result i32)
+    ///         global.get $global)
+    ///       (func (export "write_g") (param i32)
+    ///         local.get 0
+    ///         global.set $global))
+    ///   WAST
+    /// )
+    ///
+    /// global = Wasmer::Global.new store, Wasmer::Value.i32(7), true
+    ///
+    /// import_object = Wasmer::ImportObject.new
+    /// import_object.register(
+    ///   "env",
+    ///   {
+    ///     :global => global
+    ///   }
+    /// )
+    ///
+    /// instance = Wasmer::Instance.new module_, import_object
+    ///
+    /// assert { instance.exports.read_g.() == 7 }
+    ///
+    /// global.value = 153
+    /// assert { instance.exports.read_g.() == 153 }
+    ///
+    /// instance.exports.write_g.(11)
+    /// assert { global.value == 11 }
+    /// # "#); }
+    /// ```
+    ///
+    /// etc.
+    pub struct ImportObject;
+
+    impl ImportObject {
+        /// Creates a new `ImportObject`.
+        pub fn new() -> Self {
+            x!()
+        }
+
+        /// Checks whether the import object contains a specific
+        /// namespace.
+        pub fn contains_namespace(&self, namespace_name: String) -> Boolean {
+            x!()
+        }
+
+        /// Registers a set of [`Function`], [`Memory`], [`Global`] or
+        /// [`Table`] to a particular namespace.
+        ///
+        /// See the [`ImportObject`]'s documentation to see more
+        /// examples.
+        pub fn register(&self, namespace_name: String, namespace: Hash<String, Any>) {
+            x!()
+        }
+    }
+
+    /// Represents a WebAssembly function instance.
+    ///
+    /// A function instance is the runtime representation of a
+    /// function. It effectively is a closure of the original function
+    /// (defined in either the host or the WebAssembly module) over
+    /// the runtime [`Instance`] of its originating [`Module`].
+    ///
+    /// The module instance is used to resolve references to other
+    /// definitions during executing of the function.
+    ///
+    /// Specification:
+    /// <https://webassembly.github.io/spec/core/exec/runtime.html#function-instances>
+    ///
+    /// Note that the function can be invoked/called by the host only
+    /// when it is an exported function (see [`Exports`] to see an
+    /// example).
+    ///
+    /// # Example
+    ///
+    /// To build a `Function`, we need its type. `Function`
+    /// understands `Symbol`, `Proc`, and `Lambda`.
+    ///
+    /// First, a function through a symbol:
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// def foo(x)
+    ///   x + 1
+    /// end
+    ///
+    /// function = Wasmer::Function.new(
+    ///   Wasmer::Store.new,
+    ///   ## A symbol.
+    ///   method(:foo),
+    ///   Wasmer::FunctionType.new([Wasmer::Type::I32], [])
+    /// )
+    /// # "#); }
+    /// ```
+    ///
+    /// Second, a function through a proc as a lambda:
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// function = Wasmer::Function.new(
+    ///   Wasmer::Store.new,
+    ///   ## A lambda.
+    ///   -> (x) { x + 1 },
+    ///   Wasmer::FunctionType.new([Wasmer::Type::I32], [])
+    /// )
+    /// # "#); }
+    /// ```
+    ///
+    /// Third, a function through a proc:
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// function = Wasmer::Function.new(
+    ///   Wasmer::Store.new,
+    ///   ## A proc.
+    ///   Proc.new { |x| x + 1 },
+    ///   Wasmer::FunctionType.new([Wasmer::Type::I32], [])
+    /// )
+    /// # "#); }
+    /// ```
+    pub struct Function;
+
+    impl Function {
+        /// Creates a new `Function`. The `function` can be of kind
+        /// `Symbol`, `Proc` or `Lambda`.
+        pub fn new(store: Store, function: Any, function_type: FunctionType) -> Self {
+            x!()
+        }
+
+        /// Calls the function with arguments. It returns zero or more results.
+        pub fn call(x0: Any, x1: Any, x2: Any, etc: Any) -> Any {
+            x!()
+        }
+
+        /// Returns the function type.
+        pub fn r#type(&self) -> FunctionType {
+            x!()
+        }
+    }
+
+    /// A WebAssembly memory instance.
+    ///
+    /// A memory instance is the runtime representation of a linear
+    /// memory. It consists of a vector of bytes and an optional
+    /// maximum size.
+    ///
+    /// The length of the vector always is a multiple of the
+    /// WebAssembly page size, which is defined to be the constant
+    /// 65536 – abbreviated 64Ki. Like in a memory type, the maximum
+    /// size in a memory instance is given in units of this page size.
+    ///
+    /// A memory created by the host or in WebAssembly code will be
+    /// accessible and mutable from both host and WebAssembly.
+    ///
+    /// Specification: <https://webassembly.github.io/spec/core/exec/runtime.html#memory-instances>
+    ///
+    /// # Example
+    ///
+    /// Creates a [`Memory`] from scratch:
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// store = Wasmer::Store.new
+    /// memory_type = Wasmer::MemoryType.new 3, 10, true
+    /// memory = Wasmer::Memory.new store, memory_type
+    ///
+    /// assert { memory.size == 3 }
+    /// # "#); }
+    /// ```
+    ///
+    /// Gets a memory from the exports of an instance:
+    ///
+    /// ```rust,ignore
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// module_ = Wasmer::Module.new Wasmer::Store.new, wasm_bytes
+    /// instance = Wasmer::Instance.new module, nil
+    ///
+    /// memory = instance.exports.memory
+    /// # "#); }
+    /// ```
+    pub struct Memory;
+
+    impl Memory {
+        /// Creates a new `Memory`.
+        pub fn new(store: Store, memory_type: MemoryType) -> Self {
+            x!()
+        }
+
+        /// Returns the memory type.
+        pub fn r#type(&self) -> MemoryType {
+            x!()
+        }
+
+        /// Returns the size (in pages) of the memory.
+        pub fn size(&self) -> Integer {
+            x!()
+        }
+
+        /// Returns the size (in bytes) of the memory.
+        pub fn data_size(&self) -> Integer {
+            x!()
+        }
+
+        /// Grows memory by the specified amount of WebAssembly pages.
+        ///
+        /// # Example
+        ///
+        /// ```rust,ignore
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// memory = instance.exports.memory
+        /// old_memory_size = memory.data_size
+        ///
+        /// memory.grow 1
+        ///
+        /// memory_size = memory.data_size
+        ///
+        /// assert { memory_size == 1179648 }
+        /// assert { memory_size - old_memory_size == 65536 }
+        /// # "#); }
+        /// ```
+        pub fn grow(&self, number_of_pages: Integer) -> Integer {
+            x!()
+        }
+
+        /// Creates a read-and-write view over the memory data where
+        /// elements are of kind `uint8`.
+        pub fn uint8_view(&self) -> Uint8View {
+            x!()
+        }
+
+        /// Creates a read-and-write view over the memory data where
+        /// elements are of kind `int8`.
+        pub fn int8_view(&self) -> Int8View {
+            x!()
+        }
+
+        /// Creates a read-and-write view over the memory data where
+        /// elements are of kind `uint16`.
+        pub fn uint16_view(&self) -> Uint16View {
+            x!()
+        }
+
+        /// Creates a read-and-write view over the memory data where
+        /// elements are of kind `int16`.
+        pub fn int16_view(&self) -> Int16View {
+            x!()
+        }
+
+        /// Creates a read-and-write view over the memory data where
+        /// elements are of kind `uint32`.
+        pub fn uint32_view(&self) -> Uint32View {
+            x!()
+        }
+
+        /// Creates a read-and-write view over the memory data where
+        /// elements are of kind `int32`.
+        pub fn int32_view(&self) -> Int32View {
+            x!()
+        }
+    }
+
+    pub struct Uint8View;
+    pub struct Int8View;
+    pub struct Uint16View;
+    pub struct Int16View;
+    pub struct Uint32View;
+    pub struct Int32View;
+
+    /// Represents a WebAssembly global instance.
+    ///
+    /// A global instance is the runtime representation of a global
+    /// variable. It consists of an individual value and a flag
+    /// indicating whether it is mutable.
+    ///
+    /// Specification: <https://webassembly.github.io/spec/core/exec/runtime.html#global-instances>
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// store = Wasmer::Store.new
+    /// global = Wasmer::Global.new store, Wasmer::Value.i32(42), false
+    ///
+    /// assert { global.value == 42 }
+    ///
+    /// type = global.type
+    ///
+    /// assert { type.type == Wasmer::Type::I32 }
+    /// assert { type.mutable? == false }
+    /// # "#); }
+    /// ```
+    pub struct Global;
+
+    impl Global {
+        /// Creates a new `Global`.
+        pub fn new(store: Store, value: Value, mutable: Boolean) -> Self {
+            x!()
+        }
+
+        /// Returns whether the global is muable.
+        pub fn mutable(&self) -> Boolean {
+            x!()
+        }
+
+        /// Get or set a new value to the global if mutable.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// store = Wasmer::Store.new
+        /// global = Wasmer::Global.new store, Wasmer::Value.i32(42), true
+        ///
+        /// assert { global.value == 42 }
+        ///
+        /// type = global.type
+        ///
+        /// assert { type.type == Wasmer::Type::I32 }
+        /// assert { type.mutable? == true }
+        ///
+        /// global.value = 153
+        ///
+        /// assert { global.value == 153 }
+        /// # "#); }
+        /// ```
+        pub fn value(&self, value: Any) -> Any {
+            x!()
+        }
+
+        /// Returns the global type.
+        pub fn r#type(&self) -> GlobalType {
+            x!()
+        }
+    }
+
+    /// A WebAssembly table instance.
+    ///
+    /// The Table class is an array-like structure representing a
+    /// WebAssembly table, which stores function references.
+    ///
+    /// A table created by the host or in WebAssembly code will be
+    /// accessible and mutable from both host and WebAssembly.
+    ///
+    /// Specification: <https://webassembly.github.io/spec/core/exec/runtime.html#table-instances>
+    pub struct Table;
+
+    impl Table {
+        /// Creates a new `Table`.
+        pub fn new(store: Store, table_type: TableType, initia_value: Value) -> Self {
+            x!()
+        }
+    }
+
+    /// Represents a WebAssembly value of a specific type.
+    ///
+    /// Most of the time, the types for WebAssembly values will be
+    /// inferred. When it's not possible, the `Value` class is
+    /// necessary.
+    pub struct Value;
+
+    impl Value {
+        /// Creates a new `Value` containing a `int32`.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// Wasmer::Value.i32(7)
+        /// # "#); }
+        /// ```
+        pub fn i32(value: Integer) -> Self {
+            x!()
+        }
+
+        /// Creates a new `Value` containing a `int64`.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// Wasmer::Value.i64(7)
+        /// # "#); }
+        /// ```
+        pub fn i64(value: Integer) -> Self {
+            x!()
+        }
+
+        /// Creates a new `Value` containing a `float32`.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// Wasmer::Value.f32(4.2)
+        /// # "#); }
+        /// ```
+        pub fn f32(value: Float) -> Self {
+            x!()
+        }
+
+        /// Creates a new `Value` containing a `float64`.
+        ///
+        /// # Example
+        ///
+        /// ```rust
+        /// # fn main() { rutie_test::test_ruby!(r#"
+        /// Wasmer::Value.f64(4.2)
+        /// # "#); }
+        /// ```
+        pub fn f64(value: Float) -> Self {
+            x!()
+        }
+    }
+
+    /// Wasmer's [WASI] implementation.
+    ///
+    /// From the user perspective, WASI is a bunch of imports. To
+    /// generate the appropriated imports, you can use
+    /// [`StateBuilder`](Wasi::StateBuilder) to build an
+    /// [`Environment`](Wasi::Environment). This environment holds the
+    /// WASI memory, and can be used to generate a valid
+    /// [`ImportObject`]. This last one can be passed to [`Instance`]
+    /// to instantiate a [`Module`] that needs WASI support.
+    ///
+    /// [WASI]: https://github.com/WebAssembly/WASI
+    ///
+    /// # Example
+    ///
+    /// ```rust,ignore
+    /// # fn main() { rutie_test::test_ruby!(r#"
+    /// store = Wasmer::Store.new
+    /// module_ = Wasmer::Module.new store, bytes
+    ///
+    /// ## Get the WASI version.
+    /// wasi_version = Wasmer::Wasi::get_version module_, true
+    ///
+    /// ## Build a WASI environment for the imports.
+    /// wasi_env = Wasmer::Wasi::StateBuilder.new("test-program")
+    ///              .argument("--foo")
+    ///              .environments({"ABC" => "DEF", "X" => "YZ"})
+    ///              .map_directory("the_host_directory", ".")
+    ///              .finalize
+    ///
+    /// ## Generate an `ImportObject` for the WASI environment.
+    /// import_object = wasi_env.generate_import_object store, wasi_version
+    ///
+    /// ## Now we are ready to instantiate the module.
+    /// instance = Wasmer::Instance.new module_, import_object
+    ///
+    /// # Here we go, let's start the program.
+    /// instance.exports._start.()
+    /// # "#); }
+    /// ```
+    pub mod Wasi {
+        use super::*;
+        use crate::doc::Ruby::*;
+
+        /// Represents a WASI version.
+        #[allow(non_camel_case_types)]
+        pub enum Version {
+            LATEST_VERSION,
+            SNAPSHOT0,
+            SNAPSHOT1,
+        }
+
+        /// Convenient builder API for configuring WASI.
+        ///
+        /// Use the constructor to pass the arguments, environments,
+        /// preopen directories and map directories, or use the
+        /// associated methods to build the state step-by-steps.
+        pub struct StateBuilder;
+
+        impl StateBuilder {
+            pub fn new(program_name: String) -> Self {
+                x!()
+            }
+
+            /// Adds an argument.
+            ///
+            /// Arguments must not contain the nul (`0x0`) byte.
+            pub fn argument(&mut self, argument: String) -> Self {
+                x!()
+            }
+
+            /// Adds multiple arguments.
+            ///
+            /// Arguments must not contain the nul (`0x0`) byte.
+            pub fn arguments(&mut self, arguments: Array<String>) -> Self {
+                x!()
+            }
+
+            /// Add an environment variable pair.
+            ///
+            /// Environment variable keys and values must not contain
+            /// the byte `=` (`0x3d`) or null (`0x0`).
+            pub fn environment(&mut self, key: String, value: String) -> Self {
+                x!()
+            }
+
+            /// Add environment variable pairs.
+            ///
+            /// Environment variable keys and values must not contain
+            /// the byte `=` (`0x3d`) or null (`0x0`).
+            pub fn environments(&mut self, pairs: Hash<String, String>) -> Self {
+                x!()
+            }
+
+            /// Preopen a directory with a different name exposed to the WASI.
+            ///
+            /// This opens the given directories at the virtual root,
+            /// `/`, and allows the WASI module to read and write to the
+            /// given directories.
+            pub fn preopen_directory(&mut self, alias: String, value: String) -> Self {
+                x!()
+            }
+
+            /// Preopen directories with a different name exposed to the WASI.
+            ///
+            /// This opens the given directories at the virtual root,
+            /// `/`, and allows the WASI module to read and write to the
+            /// given directories.
+            pub fn preopen_directories(&mut self, pairs: Hash<String, String>) -> Self {
+                x!()
+            }
+
+            /// Preopen a directory with a different name exposed to the WASI.
+            pub fn map_directory(&mut self, alias: String, value: String) -> Self {
+                x!()
+            }
+
+            /// Preopen directories with a different name exposed to the WASI.
+            pub fn map_directories(&mut self, pairs: Hash<String, String>) -> Self {
+                x!()
+            }
+
+            /// Produces a WASI [`Environment`] based on this state builder.
+            pub fn finalize(&mut self) -> Environment {
+                x!()
+            }
+        }
+
+        /// The environment provided to the WASI imports.
+        ///
+        /// To build it, use [`StateBuilder`]. See
+        /// [`StateBuilder::finalize`] to learn more.
+        pub struct Environment;
+
+        impl Environment {
+            /// Create an [`ImportObject`] with an existing
+            /// [`Environment`]. The import object will be different
+            /// according to the WASI version.
+            ///
+            /// Use the [`Version`] enum to use a specific WASI
+            /// version, or use [`get_version`] to read the WASI
+            /// version from a [`Module`].
+            pub fn generate_import_object(
+                &self,
+                store: Store,
+                wasi_version: Version,
+            ) -> ImportObject {
+                x!()
+            }
+        }
+
+        /// Detect the version of WASI being used based on the import
+        /// namespaces.
+        ///
+        /// A strict detection expects that all imports live in a
+        /// single WASI namespace. A non-strict detection expects that
+        /// at least one WASI namespace exits to detect the
+        /// version. Note that the strict detection is faster than the
+        /// non-strict one.
+        pub fn get_version(module: Module, strict: Boolean) -> Version {
+            x!()
+        }
+    }
+}