wasmer 0.1.1 → 1.0.0

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)
+}

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

@@ -0,0 +1,282 @@
+use proc_macro2::{Group, Ident, Span, TokenStream, TokenTree};
+use quote::{quote, ToTokens};
+use syn::{punctuated::Punctuated, token::Colon2, *};
+
+pub fn entry(
+    _attr: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let impl_block = parse_macro_input!(input as ItemImpl);
+
+    let ty_name = match *impl_block.self_ty {
+        Type::Path(TypePath { qself: None, path }) if path.get_ident().is_some() => {
+            path.get_ident().unwrap().clone()
+        }
+
+        Type::Group(TypeGroup { elem, .. }) => match *elem {
+            Type::Path(TypePath { qself: None, path }) if path.get_ident().is_some() => {
+                path.get_ident().unwrap().clone()
+            }
+            _ => panic!("`impl` block must target a simple grouped identifier"),
+        },
+
+        _ => panic!("`impl` block must target a simple identifier, e.g. `impl T`"),
+    };
+
+    let ruby_rust_module_name = Ident::new(
+        &format!("ruby_{}", ty_name.to_string().to_lowercase()),
+        Span::call_site(),
+    );
+    let ruby_ty_name = Ident::new(&format!("Ruby{}", ty_name), ty_name.span());
+
+    let mut ruby_items = Vec::with_capacity(impl_block.items.len());
+
+    for item in impl_block.items {
+        match item {
+            ImplItem::Method(method) => {
+                if !method.attrs.is_empty() {
+                    panic!("Methods in `impl` block do not support attributes for the moment");
+                }
+
+                let method_name = method.sig.ident.to_string();
+
+                if method.sig.constness.is_some() {
+                    panic!("Method `{}` cannot be `const`", method_name);
+                }
+
+                if method.sig.asyncness.is_some() {
+                    panic!("Method `{}` cannot be `async`", method_name);
+                }
+
+                if method.sig.unsafety.is_some() {
+                    panic!("Method `{}` cannot be `unsafe`", method_name);
+                }
+
+                if method.sig.abi.is_some() {
+                    panic!("Method `{}` cannot have a different ABI", method_name);
+                }
+
+                if !method.sig.generics.params.is_empty() {
+                    panic!("Method `{}` cannot be generic", method_name);
+                }
+
+                if method.sig.variadic.is_some() {
+                    panic!("Method `{}` cannot be variadic", method_name);
+                }
+
+                let ruby_method_name = &method.sig.ident;
+                let ruby_method_block = &method.block;
+                let ruby_method_visibility = &method.vis;
+
+                let mut need_self = false;
+                let mut need_mut_self = false;
+
+                let ruby_arguments_parsing = {
+                    let (ruby_input_names, ruby_input_types): (
+                        Vec<Ident>,
+                        Vec<Punctuated<PathSegment, Colon2>>,
+                    ) = method
+                        .sig
+                        .inputs
+                        .iter()
+                        .filter_map(|input| match input {
+                            FnArg::Receiver(Receiver { mutability, .. }) => {
+                                need_self = true;
+                                need_mut_self = mutability.is_some();
+
+                                None
+                            }
+                            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 (method `{}`)",
+                                        method_name
+                                    ),
+                                },
+                                _ => panic!(
+                                    "Typed input has an unsupported form (method `{}`), it must be a reference type",
+                                    method_name
+                                ),
+                            },
+                        })
+                        .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 method `", stringify!( #ty_name ), ".", stringify!( #ruby_method_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_input_receiver = if need_mut_self {
+                    quote! { mut _ruby_self: #ruby_ty_name }
+                } else {
+                    quote! { _ruby_self: #ruby_ty_name }
+                };
+
+                let ruby_output = match method.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!("Method has not well-formed rerturned type, expect `RubyResult<T>` where `T` is a type"),
+                                },
+                                _ => panic!("Method has not well-formed returned type, expect `RubyResult<T>`"),
+                            }
+                        }
+                        _ => panic!("Method must wrap their output type inside `RubyResult<T>`"),
+                    },
+                    _ => panic!("Method must have an output of the form `RubyResult<T>`"),
+                };
+
+                let ruby_method_block = if need_self {
+                    let slf_declaration = if need_mut_self {
+                        quote! {
+                            let _slf = _ruby_self.upcast_mut();
+                        }
+                    } else {
+                        quote! {
+                            let _slf = _ruby_self.upcast();
+                        }
+                    };
+                    let block = rename_self(ruby_method_block.into_token_stream());
+
+                    quote! {
+                        #slf_declaration
+
+                        #block
+                    }
+                } else {
+                    ruby_method_block.into_token_stream()
+                };
+
+                let ruby_block_visibility = if need_mut_self {
+                    quote! { mut }
+                } else {
+                    quote! {}
+                };
+
+                ruby_items.push(quote! {
+                    #[allow(improper_ctypes_definitions)] // Not ideal but that's how Rutie works.
+                    #ruby_method_visibility extern "C" fn #ruby_method_name(
+                        argc: rutie::types::Argc,
+                        argv: *const rutie::AnyObject,
+                        #ruby_input_receiver,
+                    ) -> #ruby_output {
+                        #ruby_arguments_parsing
+
+                        let #ruby_block_visibility block = || -> Result<_, rutie::AnyException> {
+                            #ruby_method_block
+                        };
+
+                        match block() {
+                            Ok(x) => x,
+                            Err(e) => {
+                                rutie::VM::raise_ex(e);
+                                unreachable!()
+                            }
+                        }
+                    }
+                });
+            }
+
+            _ => panic!("`impl` block only supports methods for the moment"),
+        }
+    }
+
+    (quote! {
+        pub(crate) mod #ruby_rust_module_name {
+            use super::*;
+
+            #(#ruby_items)*
+        }
+    })
+    .into()
+}
+
+fn rename_self(stream: TokenStream) -> TokenStream {
+    let mut output_stream = TokenStream::new();
+
+    output_stream.extend(
+        stream
+            .into_iter()
+            .map(|token| match token {
+                TokenTree::Group(group) => {
+                    TokenTree::Group(Group::new(group.delimiter(), rename_self(group.stream())))
+                }
+                TokenTree::Ident(ident) => {
+                    if ident.to_string() == "self" {
+                        TokenTree::Ident(Ident::new("_slf", ident.span()))
+                    } else {
+                        TokenTree::Ident(ident)
+                    }
+                }
+                TokenTree::Punct(punct) => TokenTree::Punct(punct),
+                TokenTree::Literal(literal) => TokenTree::Literal(literal),
+            })
+            .collect::<Vec<TokenTree>>(),
+    );
+
+    output_stream
+}

data/crates/rutie-derive/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "rutie-derive"
+version = "0.1.0"
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+edition = "2018"
+description = "Provide useful types to complete the `rutie-derive-macros` crate"
+readme = "README.md"
+repository = "https://github.com/wasmerio/wasmer-ruby"
+keywords = ["ruby", "extension"]
+publish = false
+
+[dependencies]
+rutie = "0.8"
+rutie-derive-macros = { path = "../rutie-derive-macros", version = "0.1.0" }

data/crates/rutie-derive/README.md

@@ -0,0 +1,97 @@
+# `rutie-derive`
+
+**Note**: This is not an official project from
+[`rutie`](https://github.com/danielpclark/rutie).
+
+We try to extend `rutie` with a new Domain Specific Language (DSL for
+short) based on new procedural macros to make it easier to declare
+Ruby modules, classes, methods and functions.
+
+This crate is the front API that provides the `#[ruby*]` procedural
+macros from the `rutie-derive-macros` crate, along with some extra
+traits and implementations to make everything work magically.
+
+## Ruby class
+
+To declare a new Ruby class, use `#[rubyclass(module = "X::Y::Z")]`:
+
+```rust
+#[rubyclass(module = "Wasmer")]
+pub struct Foo;
+```
+
+It will create a new type `Foo` in Rust, and a new class `Foo` in Ruby
+inside the `Wasmer` module.
+
+### Constructor
+
+Every class has a Rust `ruby_new` associated method to create a new
+instance of this Ruby type.
+
+## Ruby methods
+
+To declare methods attached to a class, use `#[rubymethods]`:
+
+```rust
+#[rubymethods]
+impl Foo {
+    /// Constructor.
+    pub fn new() -> RubyResult<Foo> {
+        Ok(Foo::ruby_new(Foo))
+    }
+
+    // Method.
+    pub fn bar(&self, x: &Integer, y: &Integer) -> RubyResult<Integer> {
+        Ok(Integer::new(x.to_i64() + x.to_i64()))
+    }
+}
+```
+
+Ruby methods are like Rust methods:
+
+* Without a receiver (`&self`), it's a static method (`def self`),
+* With a receiver (`&self` or `&mut self`), it's a method (`def`),
+* All arguments are received by reference,
+* The returned type is required to be a `RubyResult`. The error type
+  is `AnyException`.
+
+### “Rust-defined” Ruby types
+
+Arguments can be of kind “user-defined types”, let's see:
+
+```rust
+#[rubyclass(module = "Wasmer")]
+pub struct Baz {
+    inner: i32,
+};
+
+#[rubyclass(module = "Wasmer")]
+pub struct Foo;
+
+#[rubymethods]
+impl Foo {
+    pub fn bar(&self, baz: &Baz) -> RubyResult<…> {
+        let inner = &baz.inner;
+
+        …
+    }
+}
+```
+
+## Ruby functions
+
+Just like `#[rubymethods]`, `#[rubyfunction]` will create a Ruby
+function:
+
+```rust
+#[rubyfunction]
+fn hello(who: &RString) -> RubyResult<RString> {
+    Ok(RString::new_utf8(&format!("Hello, {}!", who.to_str())))
+}
+```
+
+## License
+
+Check the license of
+[`wasmer-ruby`](https://github.com/wasmerio/wasmer-ruby/) as it is
+part of this same project.

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

@@ -0,0 +1,4 @@
+mod upcast;
+
+pub use rutie_derive_macros::{rubyclass, rubyfunction, rubymethods};
+pub use upcast::*;

data/crates/rutie-derive/src/upcast.rs

@@ -0,0 +1,47 @@
+pub trait ClassInfo {
+    type Class;
+    type RubyClass;
+}
+
+pub trait UpcastRubyClass<T> {
+    fn upcast(&self) -> &T;
+
+    fn upcast_mut(&mut self) -> &mut T;
+}
+
+macro_rules! id_impl {
+    ($ty:ty) => {
+        impl ClassInfo for $ty {
+            type Class = Self;
+            type RubyClass = Self;
+        }
+
+        impl UpcastRubyClass<$ty> for $ty {
+            fn upcast(&self) -> &$ty {
+                self
+            }
+
+            fn upcast_mut(&mut self) -> &mut $ty {
+                self
+            }
+        }
+    };
+
+    ( $( $ty:ty ),+ $(,)* ) => {
+        $( id_impl!( $ty ); )*
+    }
+}
+
+id_impl!(
+    rutie::AnyObject,
+    rutie::Array,
+    rutie::Boolean,
+    rutie::Fixnum,
+    rutie::Float,
+    rutie::Hash,
+    rutie::Integer,
+    rutie::NilClass,
+    rutie::Proc,
+    rutie::RString,
+    rutie::Symbol,
+);