wasmer 0.1.1 → 1.0.0

data/crates/wasmer/src/values.rs

@@ -0,0 +1,84 @@
+use crate::{
+    error::{to_ruby_err, RubyResult, TypeError},
+    prelude::*,
+};
+use rutie::{AnyObject, Fixnum, Float, Object};
+use std::convert::TryInto;
+
+pub(crate) fn to_wasm_value((any, ty): (&AnyObject, wasmer::Type)) -> RubyResult<wasmer::Value> {
+    Ok(match ty {
+        wasmer::Type::I32 => wasmer::Value::I32(
+            any.try_convert_to::<Fixnum>()?
+                .to_u64()
+                .try_into()
+                .map_err(to_ruby_err::<TypeError, _>)?,
+        ),
+        wasmer::Type::I64 => wasmer::Value::I64(
+            any.try_convert_to::<Fixnum>()?
+                .to_u64()
+                .try_into()
+                .map_err(to_ruby_err::<TypeError, _>)?,
+        ),
+        wasmer::Type::F32 => wasmer::Value::F32(any.try_convert_to::<Float>()?.to_f64() as _),
+        wasmer::Type::F64 => wasmer::Value::F64(any.try_convert_to::<Float>()?.to_f64()),
+        _ => unimplemented!(),
+    })
+}
+
+pub(crate) fn to_ruby_object(value: &wasmer::Value) -> AnyObject {
+    match value {
+        wasmer::Value::I32(value) => Fixnum::new((*value).into()).to_any_object(),
+        wasmer::Value::I64(value) => Fixnum::new(*value).to_any_object(),
+        wasmer::Value::F32(value) => Float::new((*value).into()).to_any_object(),
+        wasmer::Value::F64(value) => Float::new(*value).to_any_object(),
+        _ => unimplemented!(),
+    }
+}
+
+#[rubyclass(module = "Wasmer")]
+pub struct Value {
+    inner: wasmer::Value,
+}
+
+impl Value {
+    pub(crate) fn inner(&self) -> &wasmer::Value {
+        &self.inner
+    }
+}
+
+#[rubymethods]
+impl Value {
+    pub fn i32(value: &Fixnum) -> RubyResult<AnyObject> {
+        Ok(Value::ruby_new(Value {
+            inner: wasmer::Value::I32(
+                value
+                    .to_u64()
+                    .try_into()
+                    .map_err(to_ruby_err::<TypeError, _>)?,
+            ),
+        }))
+    }
+
+    pub fn i64(value: &Fixnum) -> RubyResult<AnyObject> {
+        Ok(Value::ruby_new(Value {
+            inner: wasmer::Value::I64(
+                value
+                    .to_u64()
+                    .try_into()
+                    .map_err(to_ruby_err::<TypeError, _>)?,
+            ),
+        }))
+    }
+
+    pub fn f32(value: &Float) -> RubyResult<AnyObject> {
+        Ok(Value::ruby_new(Value {
+            inner: wasmer::Value::F32(value.to_f64() as _),
+        }))
+    }
+
+    pub fn f64(value: &Float) -> RubyResult<AnyObject> {
+        Ok(Value::ruby_new(Value {
+            inner: wasmer::Value::F64(value.to_f64()),
+        }))
+    }
+}

data/crates/wasmer/src/wasi.rs

@@ -0,0 +1,226 @@
+use crate::{
+    error::{to_ruby_err, unwrap_or_raise, RuntimeError, TypeError},
+    import_object::ImportObject,
+    module::Module,
+    prelude::*,
+    store::Store,
+};
+use rutie::{AnyObject, Array, Boolean, Hash, Integer, NilClass, Object, RString};
+use std::{convert::TryFrom, path::PathBuf};
+
+#[derive(Debug, Copy, Clone)]
+#[repr(u8)]
+pub enum Version {
+    Latest = 1,
+    Snapshot0 = 2,
+    Snapshot1 = 3,
+}
+
+impl Version {
+    fn to_integer(&self) -> Integer {
+        match self {
+            Self::Latest => Integer::new(1),
+            Self::Snapshot0 => Integer::new(2),
+            Self::Snapshot1 => Integer::new(3),
+        }
+    }
+}
+
+impl From<&wasmer_wasi::WasiVersion> for Version {
+    fn from(value: &wasmer_wasi::WasiVersion) -> Self {
+        match value {
+            wasmer_wasi::WasiVersion::Latest => Self::Latest,
+            wasmer_wasi::WasiVersion::Snapshot0 => Self::Snapshot0,
+            wasmer_wasi::WasiVersion::Snapshot1 => Self::Snapshot1,
+        }
+    }
+}
+
+impl Into<wasmer_wasi::WasiVersion> for Version {
+    fn into(self) -> wasmer_wasi::WasiVersion {
+        match self {
+            Self::Latest => wasmer_wasi::WasiVersion::Latest,
+            Self::Snapshot0 => wasmer_wasi::WasiVersion::Snapshot0,
+            Self::Snapshot1 => wasmer_wasi::WasiVersion::Snapshot1,
+        }
+    }
+}
+
+impl TryFrom<&Integer> for Version {
+    type Error = &'static str;
+
+    fn try_from(value: &Integer) -> Result<Self, Self::Error> {
+        Ok(match value.to_i32() {
+            1 => Version::Latest,
+            2 => Version::Snapshot0,
+            3 => Version::Snapshot1,
+            _ => return Err("Unrecognized WASI version"),
+        })
+    }
+}
+
+#[rubyclass(module = "Wasmer::Wasi")]
+pub struct StateBuilder {
+    inner: wasmer_wasi::WasiStateBuilder,
+}
+
+#[rubymethods]
+impl StateBuilder {
+    pub fn new(program_name: &RString) -> RubyResult<AnyObject> {
+        Ok(StateBuilder::ruby_new(StateBuilder {
+            inner: wasmer_wasi::WasiState::new(program_name.to_str()),
+        }))
+    }
+
+    pub fn arguments(&mut self, arguments: &Array) -> RubyResult<RubyStateBuilder> {
+        self.inner.args(
+            unsafe { arguments.to_any_object().to::<Array>() }
+                .into_iter()
+                .map(|argument| {
+                    argument
+                        .try_convert_to::<RString>()
+                        .map(|argument| argument.to_string())
+                })
+                .collect::<RubyResult<Vec<_>>>()?,
+        );
+
+        Ok(_ruby_self)
+    }
+
+    pub fn argument(&mut self, argument: &RString) -> RubyResult<RubyStateBuilder> {
+        self.inner.arg(argument.to_str());
+
+        Ok(_ruby_self)
+    }
+
+    pub fn environments(&mut self, environments: &Hash) -> RubyResult<RubyStateBuilder> {
+        let mut environment_pairs = Vec::with_capacity(environments.length());
+
+        environments.each(|key, value| {
+            unwrap_or_raise(|| {
+                environment_pairs.push((
+                    key.try_convert_to::<RString>()?.to_string(),
+                    value.try_convert_to::<RString>()?.to_string(),
+                ));
+
+                Ok(())
+            });
+        });
+
+        self.inner.envs(environment_pairs);
+
+        Ok(_ruby_self)
+    }
+
+    pub fn environment(&mut self, key: &RString, value: &RString) -> RubyResult<RubyStateBuilder> {
+        self.inner.env(key.to_str(), value.to_str());
+
+        Ok(_ruby_self)
+    }
+
+    pub fn preopen_directories(
+        &mut self,
+        preopen_directories: &Array,
+    ) -> RubyResult<RubyStateBuilder> {
+        self.inner
+            .preopen_dirs(
+                unsafe { preopen_directories.to_any_object().to::<Array>() }
+                    .into_iter()
+                    .map(|directory| {
+                        Ok(PathBuf::from(
+                            directory.try_convert_to::<RString>()?.to_string(),
+                        ))
+                    })
+                    .collect::<RubyResult<Vec<_>>>()?,
+            )
+            .map_err(to_ruby_err::<RuntimeError, _>)?;
+
+        Ok(_ruby_self)
+    }
+
+    pub fn preopen_directory(
+        &mut self,
+        preopen_directory: &RString,
+    ) -> RubyResult<RubyStateBuilder> {
+        self.inner
+            .preopen_dir(preopen_directory.to_str())
+            .map_err(to_ruby_err::<RuntimeError, _>)?;
+
+        Ok(_ruby_self)
+    }
+
+    pub fn map_directories(&mut self, map_directories: &Hash) -> RubyResult<RubyStateBuilder> {
+        let mut map_directory_pairs = Vec::with_capacity(map_directories.length());
+
+        map_directories.each(|key, value| {
+            unwrap_or_raise(|| {
+                map_directory_pairs.push((
+                    key.try_convert_to::<RString>()?.to_string(),
+                    PathBuf::from(value.try_convert_to::<RString>()?.to_str()),
+                ));
+
+                Ok(())
+            });
+        });
+
+        self.inner
+            .map_dirs(map_directory_pairs)
+            .map_err(to_ruby_err::<RuntimeError, _>)?;
+
+        Ok(_ruby_self)
+    }
+
+    pub fn map_directory(
+        &mut self,
+        alias: &RString,
+        directory: &RString,
+    ) -> RubyResult<RubyStateBuilder> {
+        self.inner
+            .map_dir(alias.to_str(), PathBuf::from(directory.to_str()))
+            .map_err(to_ruby_err::<RuntimeError, _>)?;
+
+        Ok(_ruby_self)
+    }
+
+    pub fn finalize(&mut self) -> RubyResult<AnyObject> {
+        Ok(Environment::ruby_new(Environment {
+            inner: self
+                .inner
+                .finalize()
+                .map_err(to_ruby_err::<RuntimeError, _>)?,
+        }))
+    }
+}
+
+#[rubyclass(module = "Wasmer::Wasi")]
+pub struct Environment {
+    inner: wasmer_wasi::WasiEnv,
+}
+
+#[rubymethods]
+impl Environment {
+    pub fn generate_import_object(
+        &self,
+        store: &Store,
+        wasi_version: &Integer,
+    ) -> RubyResult<AnyObject> {
+        let import_object = wasmer_wasi::generate_import_object_from_env(
+            store.inner(),
+            self.inner.clone(),
+            Version::try_from(wasi_version)
+                .map_err(to_ruby_err::<TypeError, _>)?
+                .into(),
+        );
+
+        Ok(ImportObject::ruby_new(ImportObject::raw_new(import_object)))
+    }
+}
+
+#[rubyfunction]
+pub fn get_version(module: &Module, strict: &Boolean) -> RubyResult<AnyObject> {
+    Ok(
+        wasmer_wasi::get_wasi_version(&module.inner(), strict.to_bool())
+            .map(|version| Version::from(&version).to_integer().to_any_object())
+            .unwrap_or_else(|| NilClass::new().to_any_object()),
+    )
+}

data/crates/wasmer/src/wat.rs

@@ -0,0 +1,20 @@
+use crate::{
+    error::{to_ruby_err, RuntimeError},
+    prelude::*,
+};
+use rutie::{Encoding, RString};
+
+#[rubyfunction]
+pub fn wat2wasm(wat: &RString) -> RubyResult<RString> {
+    wat::parse_str(wat.to_str())
+        .map(|bytes| RString::from_bytes(bytes.as_slice(), &Encoding::us_ascii()))
+        .map_err(to_ruby_err::<RuntimeError, _>)
+}
+
+#[rubyfunction]
+pub fn wasm2wat(bytes: &RString) -> RubyResult<RString> {
+    Ok(RString::new_utf8(
+        &wasmprinter::print_bytes(bytes.to_bytes_unchecked())
+            .map_err(to_ruby_err::<RuntimeError, _>)?,
+    ))
+}

data/justfile

@@ -1,15 +1,33 @@
 # Compile and install the Ruby extension.
 build:
 	rake build_lib
+	rake bundle_install
 
-# Run the tests.
-test:
+# Run all the tests.
+test-all: test-lib test-doc test-example
+
+# Run the tests of the library.
+test-lib:
 	rake test
 
+# Run the tests of the documentation.
+test-doc:
+	cargo test --manifest-path crates/wasmer/Cargo.toml --doc
+
+# Run the examples as tests.
+test-example:
+	for example in $(ls examples/*.rb); do \
+		ruby $example; \
+	done
+
 # Build the `.gem` file.
 gem:
 	rake build
 
+# Generate the documentation.
+doc:
+	cargo rustdoc --manifest-path crates/wasmer/Cargo.toml -- --extend-css doc/patch-rustdoc.css
+
 # Clean the project.
 clean:
 	cargo clean

data/lib/wasmer.rb

@@ -1,6 +1,32 @@
-require 'wasmer/version'
-require 'rutie'
+require "fiddle"
 
 module Wasmer
-  Rutie.new(:wasmer).init 'Init_wasmer', __dir__
+  shared_library_name = :wasmer_ruby
+  init_function = :init
+
+  shared_library_prefix =
+    case RUBY_PLATFORM
+    when /windows|mswin|mingw/ then ""
+    when /cygwin/ then "cyg"
+    else "lib"
+    end
+
+  shared_library_suffix =
+    case RUBY_PLATFORM
+    when /darwin/ then "dylib"
+    when /windows|mswin|mingw|cygwin/ then "dll"
+    else "so"
+    end
+
+  shared_library_directory = File.expand_path "../target/release/", __dir__
+  shared_library_path = File.join(
+    shared_library_directory,
+    [shared_library_prefix, shared_library_name, ".", shared_library_suffix].join()
+  )
+
+  Fiddle::Function.new(
+    Fiddle::dlopen(shared_library_path)[init_function.to_s],
+    [],
+    Fiddle::TYPE_VOIDP
+  ).call
 end

data/wasmer.gemspec

@@ -1,29 +1,25 @@
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-require "wasmer/version"
-
 Gem::Specification.new do |spec|
   spec.name          = "wasmer"
-  spec.version       = Wasmer::VERSION
-  spec.authors       = ["Ivan Enderlin"]
-  spec.email         = ["ivan.enderlin@hoa-project.net"]
+  spec.version       = "1.0.0"
+  spec.authors       = ["Wasmer Engineering Team"]
+  spec.email         = ["engineering@wasmer.io"]
 
   spec.summary       = "Run WebAssembly binaries."
   spec.description   = "Wasmer is a Ruby extension to run WebAssembly binaries."
-  spec.homepage      = "https://github.com/wasmerio/ruby-ext-wasm"
-  spec.license       = "BSD-3-Clause"
+  spec.homepage      = "https://github.com/wasmerio/wasmer-ruby"
+  spec.license       = "MIT"
 
   spec.extensions    = %w(Rakefile)
 
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(examples|tests)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(examples|tests|doc)/}) }
   end
 
   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_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "rake", "~> 13.0"
 end

metadata

@@ -1,104 +1,108 @@
 --- !ruby/object:Gem::Specification
 name: wasmer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
-- Ivan Enderlin
-autorequire: 
+- Wasmer Engineering Team
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-01 00:00:00.000000000 Z
+date: 2021-07-01 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: rutie
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.3
 - !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'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '13.0'
 description: Wasmer is a Ruby extension to run WebAssembly binaries.
 email:
-- ivan.enderlin@hoa-project.net
+- engineering@wasmer.io
 executables: []
 extensions:
 - Rakefile
 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/documentation.yml"
+- ".github/workflows/test.yml"
 - ".gitignore"
+- CHANGELOG.md
 - Cargo.lock
 - Cargo.toml
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
+- bors.toml
+- crates/rutie-derive-macros/Cargo.toml
+- crates/rutie-derive-macros/README.md
+- crates/rutie-derive-macros/src/class.rs
+- crates/rutie-derive-macros/src/function.rs
+- crates/rutie-derive-macros/src/lib.rs
+- crates/rutie-derive-macros/src/methods.rs
+- crates/rutie-derive/Cargo.toml
+- crates/rutie-derive/README.md
+- crates/rutie-derive/src/lib.rs
+- crates/rutie-derive/src/upcast.rs
+- crates/rutie-test/Cargo.toml
+- crates/rutie-test/src/lib.rs
+- crates/wasmer/Cargo.toml
+- crates/wasmer/README.md
+- crates/wasmer/src/doc.rs
+- crates/wasmer/src/error.rs
+- crates/wasmer/src/exports.rs
+- crates/wasmer/src/externals/function.rs
+- crates/wasmer/src/externals/global.rs
+- crates/wasmer/src/externals/memory.rs
+- crates/wasmer/src/externals/mod.rs
+- crates/wasmer/src/externals/table.rs
+- crates/wasmer/src/import_object.rs
+- crates/wasmer/src/instance.rs
+- crates/wasmer/src/lib.rs
+- crates/wasmer/src/memory/mod.rs
+- crates/wasmer/src/memory/views.rs
+- crates/wasmer/src/module.rs
+- crates/wasmer/src/prelude.rs
+- crates/wasmer/src/store.rs
+- crates/wasmer/src/types.rs
+- crates/wasmer/src/values.rs
+- crates/wasmer/src/wasi.rs
+- crates/wasmer/src/wat.rs
 - justfile
 - lib/wasmer.rb
-- lib/wasmer/version.rb
-- src/instance.rs
-- src/lib.rs
-- src/memory/mod.rs
-- src/memory/view.rs
-- src/module.rs
 - wasmer.gemspec
-homepage: https://github.com/wasmerio/ruby-ext-wasm
+homepage: https://github.com/wasmerio/wasmer-ruby
 licenses:
-- BSD-3-Clause
+- MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -113,8 +117,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Run WebAssembly binaries.
 test_files: []