update rustler 0.23.0 -> 0.34.0

native/xler_native/src/lib.rs

@@ -1,77 +1,61 @@
-#[macro_use] extern crate rustler;
-extern crate lazy_static;
 extern crate calamine;
+extern crate lazy_static;
+extern crate rustler;
 
-use rustler::{Env, NifResult, Encoder, Term, SchedulerFlags};
-use calamine::{Reader, open_workbook_auto};
 use calamine::Error as CaError;
+use calamine::{open_workbook_auto, Reader};
 
+rustler::init!("Elixir.Xler.Native");
 mod atoms {
-    rustler_atoms! {
-        atom ok;
-        atom error;
+    rustler::atoms! {
+        ok,
+        error,
 
         // Posix
-        atom enoent; // File does not exist
-        atom eacces; // Permission denied
-        atom epipe;  // Broken pipe
-        atom eexist; // File exists
+        enoent, // File does not exist
+        eacces, // Permission denied
+        epipe,  // Broken pipe
+        eexist, // File exists
     }
 }
 
-rustler_export_nifs! {
-    "Elixir.Xler.Native",
-    [
-        ("parse", 2, parse, SchedulerFlags::DirtyCpu),
-        ("worksheets", 1, worksheets, SchedulerFlags::DirtyCpu)
-    ],
-    None
-}
+type Sheet = Vec<Vec<String>>;
+type SheetName = String;
+type Worksheets = Vec<SheetName>;
 
-fn io_error_to_term<'a>(env: Env<'a>, err: &CaError) -> Term<'a> {
+fn io_error_to_term(err: &CaError) -> String {
     let error = match err {
-        _ => format!("{}", err).encode(env),
+        _ => format!("{}", err),
     };
 
-    (atoms::error(), error).encode(env)
+    error
 }
 
-fn worksheets<'a>(env: Env<'a>, args: &[Term<'a>]) -> NifResult<Term<'a>> {
-    let filename: String = args[0].decode()?;
-
+#[rustler::nif(schedule = "DirtyCpu")]
+fn worksheets(filename: String) -> Result<Worksheets, String> {
     match open_workbook_auto(&filename) {
-        Err(ref error) => return Ok(io_error_to_term(env, error)),
-        Ok(ref inner) => Ok((atoms::ok(), inner.sheet_names().to_owned()).encode(env)),
+        Err(ref error) => Err(io_error_to_term(error)),
+        Ok(ref inner) => Ok(inner.sheet_names().to_owned()),
     }
 }
 
-
-fn parse<'a>(env: Env<'a>, args: &[Term<'a>]) -> NifResult<Term<'a>> {
-    let filename: String = args[0].decode()?;
-    let sheetname: String = args[1].decode()?;
-
+#[rustler::nif(schedule = "DirtyCpu")]
+fn parse(filename: String, sheetname: SheetName) -> Result<Sheet, String> {
     let mut excel = match open_workbook_auto(&filename) {
-        Err(ref error) => return Ok(io_error_to_term(env, error)),
+        Err(ref error) => return Err(io_error_to_term(error)),
         Ok(inner) => inner,
     };
 
     if let Some(Ok(range)) = excel.worksheet_range(&sheetname) {
-        let row: Vec<(Vec<String>)> = range
-                        .rows()
-                        .into_iter()
-                        .enumerate()
-                        .map(|(_i, col)|
-                            col
-                            .iter()
-                            .map(|c|
-                                c.to_string()
-                            )
-                            .collect::<Vec<_>>()
-                        )
-                        .collect::<Vec<_>>();
+        let row: Sheet = range
+            .rows()
+            .into_iter()
+            .enumerate()
+            .map(|(_i, col)| col.iter().map(|c| c.to_string()).collect::<Vec<_>>())
+            .collect::<Vec<_>>();
 
-        Ok((atoms::ok(), row.encode(env)).encode(env))
+        Ok(row)
     } else {
-        Ok((atoms::error(), "Couldnt find the worksheet").encode(env))
+        Err("Couldnt find the worksheet".to_string())
     }
 }