Add Ruby Array -> vec coercion

This is essentially a rebase of #46 by @wagenet, updated for the new
APIs.

While it is not ideal to copy most of the time, it is perfectly safe.
Therefore we decide to add this in now to enable use cases that are
not otherwise possible while we work on a better non-copy version
(something like #100).

TODO: port the vec -> Ruby Array code from #46

Paired with @hone

Author: hone

crates/libcruby-sys/src/lib.rs

@@ -174,6 +174,7 @@ extern "C" {
     pub fn rb_sprintf(specifier: c_string, ...) -> VALUE;
     pub fn rb_inspect(value: VALUE) -> VALUE;
     pub fn rb_intern(string: c_string) -> ID;
+    pub fn rb_ary_entry(ary: VALUE, offset: isize) -> VALUE;
     pub fn rb_raise(exc: VALUE, string: c_string, ...) -> !;
 
     pub fn rb_jump_tag(state: RubyException) -> !;

examples/membership/src/lib.rs

@@ -1,59 +1,36 @@
 #[macro_use]
 extern crate helix;
 
-pub struct RubyArray<'a>(&'a [usize]);
+use helix::{Error, FromRuby};
 
 ruby! {
     reopen class Array {
-        def is_superset_of(&self, needle: RubyArray) -> bool {
-            let needle = needle.0;
+        def is_superset_of(&self, needle: Vec<u64>) -> Result<bool, Error> {
+            if needle.is_empty() { return Ok(true) }
 
-            if needle.is_empty() { return true }
+            let haystack = try!(self.as_vec());
 
-            let haystack = self.as_ref();
+            if haystack.is_empty() { return Ok(false) }
 
-            if haystack.is_empty() { return false }
-
-            let mut needle = needle.iter();
+            let mut needle = needle.into_iter();
             let mut needle_item = needle.next().unwrap();
 
             for item in haystack {
                 if item == needle_item {
                     match needle.next() {
-                        None => return true,
+                        None => return Ok(true),
                         Some(next_item) => needle_item = next_item
                     }
                 }
             }
 
-            false
+            Ok(false)
         }
     }
 }
 
-use helix::{FromRuby, CheckedValue, CheckResult, sys};
-
-impl<'a> FromRuby for RubyArray<'a> {
-    type Checked = CheckedValue<RubyArray<'a>>;
-
-    fn from_ruby(value: sys::VALUE) -> CheckResult<Self::Checked> {
-        if unsafe { sys::RB_TYPE_P(value, sys::T_ARRAY) } {
-            Ok(unsafe { CheckedValue::new(value) })
-        } else {
-            type_error!(value, "an Array of unsigned pointer-sized integers")
-        }
-    }
-
-    fn from_checked(checked: Self::Checked) -> RubyArray<'a> {
-        let value = checked.to_value();
-        let size = unsafe { sys::RARRAY_LEN(value) };
-        let ptr = unsafe { sys::RARRAY_PTR(value) };
-        RubyArray(unsafe { std::slice::from_raw_parts(ptr as *const usize, size as usize) })
-    }
-}
-
-impl AsRef<[usize]> for Array {
-    fn as_ref<'a>(&'a self) -> &'a [usize] {
-        RubyArray::from_ruby_unwrap(self.helix).0
+impl Array {
+    fn as_vec(&self) -> Result<Vec<u64>, Error> {
+        Vec::<u64>::from_ruby(self.helix).map(Vec::<u64>::from_checked)
     }
 }

src/coercions/mod.rs

@@ -1,8 +1,10 @@
-mod string;
+mod value;
 mod unit;
 mod bool;
 mod integers;
 mod float;
+mod string;
+mod vec;
 mod option;
 mod result;
 
@@ -44,8 +46,3 @@ pub trait ToRuby {
     fn to_ruby(self) -> ToRubyResult;
 }
 
-impl ToRuby for VALUE {
-    fn to_ruby(self) -> ToRubyResult {
-        Ok(self)
-    }
-}

src/coercions/value.rs

@@ -0,0 +1,20 @@
+use sys::{VALUE};
+use super::{FromRuby, CheckResult, ToRuby, ToRubyResult};
+
+impl FromRuby for VALUE {
+    type Checked = VALUE;
+
+    fn from_ruby(value: VALUE) -> CheckResult<VALUE> {
+        Ok(value)
+    }
+
+    fn from_checked(checked: VALUE) -> VALUE {
+        checked
+    }
+}
+
+impl ToRuby for VALUE {
+    fn to_ruby(self) -> ToRubyResult {
+        Ok(self)
+    }
+}

src/coercions/vec.rs

@@ -0,0 +1,32 @@
+use sys::{RARRAY_LEN, RB_TYPE_P, T_ARRAY, VALUE, rb_ary_entry};
+use super::{FromRuby, CheckResult};
+
+impl<T: FromRuby> FromRuby for Vec<T> {
+    type Checked = Vec<T::Checked>;
+
+    fn from_ruby(value: VALUE) -> CheckResult<Self::Checked> {
+        if unsafe { RB_TYPE_P(value, T_ARRAY) } {
+            let size = unsafe { RARRAY_LEN(value) };
+            let mut vec = Vec::with_capacity(size as usize);
+
+            for i in 0..size {
+                let entry = unsafe { rb_ary_entry(value, i) };
+
+                match T::from_ruby(entry) {
+                    Ok(checked) => vec.push(checked),
+                    Err(reason) => {
+                        type_error!(format!("Cannot convert element {}: {}", i, reason))
+                    }
+                }
+            }
+
+            Ok(vec)
+        } else {
+            type_error!(value, "an array")
+        }
+    }
+
+    fn from_checked(checked: Self::Checked) -> Vec<T> {
+        checked.into_iter().map(T::from_checked).collect()
+    }
+}

src/errors.rs

@@ -1,5 +1,5 @@
 use super::{Class, ToRuby};
-use std::{any};
+use std::{any, fmt};
 use sys::{VALUE, SPRINTF_TO_S, c_string, rb_eRuntimeError, rb_raise};
 
 #[derive(Copy, Clone, Debug)]
@@ -43,6 +43,21 @@ impl Error {
     }
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.message {
+            ErrorMessage::Static(c_string) => {
+                use ::std::ffi::CStr;
+                write!(f, "{}", unsafe { CStr::from_ptr(c_string) }.to_str().unwrap())
+            },
+            ErrorMessage::Dynamic(value) => {
+                use super::FromRuby;
+                write!(f, "{}", String::from_ruby_unwrap(value))
+            }
+        }
+    }
+}
+
 unsafe impl Send for Error {}
 unsafe impl Sync for Error {}