wasmer 0.4.0 → 0.5.0

data/Cargo.toml

@@ -1,20 +1,7 @@
-[package]
-publish = false
-name = "ruby-ext-wasm"
-version = "0.4.0"
-authors = ["Ivan Enderlin <ivan.enderlin@hoa-project.net>"]
-edition = "2018"
-description = "Ruby extension to run WebAssembly binaries"
-readme = "README.md"
-repository = "https://github.com/wasmerio/ruby-ext-wasm"
-keywords = ["ruby", "extension", "webassembly"]
-categories = ["wasm"]
-
-[lib]
-name = "wasmer"
-crate-type = ["dylib"]
-
-[dependencies]
-wasmer-runtime = "0.14"
-rutie = "0.7"
-lazy_static = "1.4"
+[workspace]
+members = [
+    "crates/rutie-derive",
+    "crates/rutie-derive-macros",
+    "crates/rutie-test",
+    "crates/wasmer",
+]

data/Gemfile

@@ -3,7 +3,6 @@ source "https://rubygems.org"
 gemspec
 
 group :test do
-  gem 'minitest', '~> 5.10'
-  gem 'minitest-reporters', '~> 1.1'
-  gem 'color_pound_spec_reporter', '~> 0.0.6'
+  gem 'minitest', '~> 5.14'
+  gem 'minitest-reporters', '~> 1.4'
 end

data/README.md

@@ -0,0 +1 @@
+./crates/wasmer/README.md

data/Rakefile

@@ -1,21 +1,22 @@
-require "rbconfig"
 require "bundler/gem_tasks"
 require "rake/testtask"
 
 desc 'Build the Rust extension'
 task :build_lib do
-  sh 'cargo build --release'
+  sh 'cargo build --release --manifest-path crates/wasmer/Cargo.toml'
 end
 
 desc 'Install the bundle'
 task :bundle_install do
+  sh 'bundle config set --local path "vendor/bundle"'
   sh 'bundle install'
+  sh 'cd vendor/bundle && ln -f -s ruby/*/gems/rutie-*/ rutie'
 end
 
 Rake::TestTask.new(test: [:bundle_install, :build_lib]) do |t|
   t.libs << "tests"
   t.libs << "lib"
-  t.test_files = FileList["tests/**/*_test.rb"]
+  t.test_files = FileList["tests/*_test.rb"]
 end
 
 task :default => :test

data/crates/rutie-derive-macros/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "rutie-derive-macros"
+version = "0.1.0"
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+edition = "2018"
+description = "Procedural macros on top of `rutie` to write Ruby extensions faster and safer"
+readme = "README.md"
+repository = "https://github.com/wasmerio/wasmer-ruby"
+keywords = ["ruby", "extension"]
+publish = false
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "1.0", features = ["full"] }
+quote = "1.0"
+paste = "1.0"
+proc-macro2 = "1.0"

data/crates/rutie-derive-macros/README.md

@@ -0,0 +1,4 @@
+# `rutie-derive-macros`
+
+That's the backend of the `rutie-derive` crate. Check the
+documentation there.

data/crates/rutie-derive-macros/src/class.rs

@@ -0,0 +1,156 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{
+    parse_macro_input, AttributeArgs, Data, DataStruct, DeriveInput, Generics, Ident, Lit, Meta,
+    MetaNameValue, NestedMeta,
+};
+
+pub fn entry(
+    attr: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let cloned_input = input.clone();
+    let derive_input = parse_macro_input!(cloned_input as DeriveInput);
+    let arguments = parse_macro_input!(attr as AttributeArgs);
+
+    if arguments.is_empty() {
+        panic!("The `rubyclass` procedural macro must have a `module` argument, e.g. `#[rubyclass(module = \"foo\")`");
+    }
+
+    let mut ruby_module = None;
+
+    for argument in arguments.iter() {
+        match argument {
+            NestedMeta::Meta(Meta::NameValue(MetaNameValue {
+                path: name,
+                lit: Lit::Str(value),
+                ..
+            })) if name.is_ident("module") => {
+                ruby_module = Some(value.value());
+            }
+
+            argument => panic!(
+                "Unexpected argument `{:?}` from the `rubyclass` procedural macro",
+                argument
+            ),
+        }
+    }
+
+    let derived = match derive_input.data {
+        Data::Struct(ref struct_data) => derive_for_struct(
+            &derive_input.ident,
+            struct_data,
+            &derive_input.generics,
+            ruby_module.expect("The `module` argument of the `rubyclass` procedural macro is missing, e.g. `#[rubyclass(module = \"foo\")]`"),
+        ),
+
+        Data::Enum(_) => panic!("enums are not yet supported"),
+
+        Data::Union(_) => panic!("unions are not yet supported"),
+    };
+
+    let input = TokenStream::from(input);
+
+    (quote! { #input #derived }).into()
+}
+
+fn derive_for_struct(
+    struct_name: &Ident,
+    _data: &DataStruct,
+    generics: &Generics,
+    ruby_module: String,
+) -> proc_macro2::TokenStream {
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    let span = struct_name.span();
+    let wrapper_struct_name = Ident::new(&format!("{}Wrapper", struct_name), span);
+    let wrapper_const_name = Ident::new(
+        &format!("{}_WRAPPER", struct_name.to_string().to_uppercase()),
+        span,
+    );
+    let ruby_struct_name = Ident::new(&format!("Ruby{}", struct_name), span);
+    let ruby_sub_module_hack = Ident::new(
+        &format!("ruby_{}_hack", struct_name.to_string().to_lowercase()),
+        span,
+    );
+
+    let mut ruby_module_parts = ruby_module.split("::");
+    let ruby_module = ruby_module_parts.next().unwrap();
+    let ruby_nested_modules = ruby_module_parts.collect::<Vec<_>>();
+
+    quote! {
+        // Create the `XXXWrapper` wrapper class.
+        //
+        // Do that in a specific module because `wrappable_struct` must be imported to work correctly.
+        mod #ruby_sub_module_hack {
+            use super::*; // to get `lazy_static`, imported by the user.
+            use rutie::{wrappable_struct};
+
+            wrappable_struct!(#struct_name, #wrapper_struct_name, #wrapper_const_name);
+        }
+
+        pub use #ruby_sub_module_hack::*;
+
+        // Implement the `RubyXXX` class.
+        rutie::class!(#ruby_struct_name);
+
+        // Implement `rutie::VerifiedObject` so that we can cast from
+        // `RubyXXX` to `XXX` with `rutie::Object::try_convert_to`.
+        impl #impl_generics rutie::VerifiedObject for #ruby_struct_name #ty_generics
+        #where_clause
+        {
+            fn is_correct_type<T>(object: &T) -> bool
+            where T: rutie::Object
+            {
+                object.class() == rutie::Module::from_existing(#ruby_module)
+                    #(
+                        .get_nested_module(#ruby_nested_modules)
+                    ),*
+                    .get_nested_class(stringify!(#struct_name))
+            }
+
+            fn error_message() -> &'static str {
+                concat!("Error converting to `", stringify!(#ruby_struct_name), "`")
+            }
+        }
+
+        // Implement custom `rutie_derive::ClassInfo` for `XXX`.
+        impl rutie_derive::ClassInfo for #struct_name {
+            type Class = #struct_name;
+            type RubyClass = #ruby_struct_name;
+        }
+
+        // Implement custom `rutie_derive::ClassInfo` for `RubyXXX`.
+        impl rutie_derive::ClassInfo for #ruby_struct_name {
+            type Class = #struct_name;
+            type RubyClass = #ruby_struct_name;
+        }
+
+        // Allow to unwrap from `RubyXXX` to `XXX`.
+        impl #impl_generics rutie_derive::UpcastRubyClass<#struct_name #ty_generics> for #ruby_struct_name
+        #where_clause
+        {
+            fn upcast(&self) -> &#struct_name {
+                rutie::Object::get_data(self, &*#wrapper_const_name)
+            }
+
+            fn upcast_mut(&mut self) -> &mut #struct_name {
+                rutie::Object::get_data_mut(self, &*#wrapper_const_name)
+            }
+        }
+
+        // Temporary helper to instantiate a `RubyXXX` with a `XXX`.
+        impl #impl_generics #struct_name #ty_generics
+        #where_clause
+        {
+            pub(crate) fn ruby_new(this: Self) -> rutie::AnyObject {
+                rutie::Module::from_existing(#ruby_module)
+                    #(
+                        .get_nested_module(#ruby_nested_modules)
+                    ),*
+                    .get_nested_class(stringify!(#struct_name))
+                    .wrap_data(this, &*#wrapper_const_name)
+            }
+        }
+    }
+}

data/crates/rutie-derive-macros/src/function.rs

@@ -0,0 +1,178 @@
+use proc_macro2::Ident;
+use quote::quote;
+use syn::{punctuated::Punctuated, token::Colon2, *};
+
+pub fn entry(
+    _attr: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let function = parse_macro_input!(input as ItemFn);
+
+    if !function.attrs.is_empty() {
+        panic!("Functions in `#[rubyfunction]` do not support attributes for the moment");
+    }
+
+    let function_name = function.sig.ident.to_string();
+
+    if function.sig.constness.is_some() {
+        panic!("Function `{}` cannot be `const`", function_name);
+    }
+
+    if function.sig.asyncness.is_some() {
+        panic!("Function `{}` cannot be `async`", function_name);
+    }
+
+    if function.sig.unsafety.is_some() {
+        panic!("Function `{}` cannot be `unsafe`", function_name);
+    }
+
+    if function.sig.abi.is_some() {
+        panic!("Function `{}` cannot have a different ABI", function_name);
+    }
+
+    if !function.sig.generics.params.is_empty() {
+        panic!("Function `{}` cannot be generic", function_name);
+    }
+
+    if function.sig.variadic.is_some() {
+        panic!("Function `{}` cannot be variadic", function_name);
+    }
+
+    let ruby_function_name = &function.sig.ident;
+    let ruby_function_block = &function.block;
+    let ruby_function_visibility = &function.vis;
+
+    let ruby_arguments_parsing = {
+        let (ruby_input_names, ruby_input_types): (
+            Vec<Ident>,
+            Vec<Punctuated<PathSegment, Colon2>>,
+        ) = function
+            .sig
+            .inputs
+            .iter()
+            .filter_map(|input| match input {
+                FnArg::Typed(PatType { pat, ty, .. }) => match (&**pat, &**ty) {
+                    (
+                        Pat::Ident(ident),
+                        Type::Reference(TypeReference { elem, .. }),
+                    ) => match &**elem {
+                        Type::Path(TypePath {
+                            qself: None,
+                            path: Path { segments: ty, .. },
+                        }) => Some((ident.ident.clone(), ty.clone())),
+                        _ => panic!(
+                            "Typed input has an unsupported form (function `{}`)",
+                            function_name
+                        ),
+                    },
+                    _ => panic!(
+                        "Typed input has an unsupported form (function `{}`), it must be a reference type",
+                        function_name
+                    ),
+                },
+
+                FnArg::Receiver(..) => unreachable!(),
+            })
+            .unzip();
+
+        if ruby_input_names.is_empty() {
+            quote! {}
+        } else {
+            quote! {
+                let ( #( #ruby_input_names ),* ) =
+                {
+                    let arguments = rutie::util::parse_arguments(argc, argv);
+                    let mut argument_nth = 0;
+
+                    (
+                        #(
+                            {
+                                let argument = arguments
+                                    .get(argument_nth)
+                                    .ok_or_else(|| {
+                                        <rutie::AnyException as rutie::Exception>::new(
+                                            "ArgumentError",
+                                            Some(&format!(concat!("Argument #{} (`", stringify!( #ruby_input_types ), "`) of function `", stringify!( #ruby_function_name ), "` is missing"), argument_nth)),
+                                        )
+                                    })
+                                    .and_then(|argument| {
+                                        <rutie::AnyObject as rutie::Object>
+                                            ::try_convert_to::<< #ruby_input_types as rutie_derive::ClassInfo>::RubyClass>(argument)
+                                    })
+                                    .unwrap_or_else(|error| {
+                                        rutie::VM::raise_ex(error);
+                                        unreachable!()
+                                    });
+
+                                argument_nth += 1;
+
+                                argument
+                            }
+                        ),*
+                    )
+                };
+
+                let ( #( #ruby_input_names ),* ) =
+                    (
+                        #(
+                            rutie_derive::UpcastRubyClass::<
+                                    <
+                                            < #ruby_input_types as rutie_derive::ClassInfo>::RubyClass as rutie_derive::ClassInfo
+                                            >::Class
+                                    >::upcast(&#ruby_input_names)
+                        ),*
+                    );
+            }
+        }
+    };
+
+    let ruby_output = match function.sig.output {
+        ReturnType::Type(_, ty) => match *ty {
+            Type::Path(TypePath {
+                qself: None,
+                path:
+                    Path {
+                        leading_colon: None,
+                        segments,
+                    },
+            }) if segments.first().unwrap().ident.to_string() == "RubyResult" => {
+                match &segments.first().unwrap().arguments {
+                    PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+                        args,
+                        ..
+                    }) => match args.first().unwrap() {
+                        GenericArgument::Type(ty) => ty.clone(),
+                        _ => panic!("Function has not well-formed rerturned type, expect `RubyResult<T>` where `T` is a type"),
+                    },
+                    _ => panic!("Function has not well-formed returned type, expect `RubyResult<T>`"),
+                }
+            }
+            _ => panic!("Function must wrap their output type inside `RubyResult<T>`"),
+        },
+        _ => panic!("Function must have an output of the form `RubyResult<T>`"),
+    };
+
+    (quote! {
+        #[allow(improper_ctypes_definitions)] // Not ideal but that's how Rutie works.
+        #ruby_function_visibility extern "C" fn #ruby_function_name(
+            argc: rutie::types::Argc,
+            argv: *const rutie::AnyObject,
+            _: rutie::AnyObject,
+        ) -> #ruby_output {
+            #ruby_arguments_parsing
+
+            let block = || -> Result<_, rutie::AnyException> {
+                #ruby_function_block
+            };
+
+            match block() {
+                Ok(x) => x,
+                Err(e) => {
+                    rutie::VM::raise_ex(e);
+                    unreachable!()
+                }
+            }
+        }
+    })
+    .into()
+}

data/crates/rutie-derive-macros/src/lib.rs

@@ -0,0 +1,27 @@
+mod class;
+mod function;
+mod methods;
+
+#[proc_macro_attribute]
+pub fn rubyclass(
+    attr: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    class::entry(attr, input)
+}
+
+#[proc_macro_attribute]
+pub fn rubymethods(
+    attr: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    methods::entry(attr, input)
+}
+
+#[proc_macro_attribute]
+pub fn rubyfunction(
+    attr: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    function::entry(attr, input)
+}