address issue with mutable borrow using get_value_index (#115)

* use get_value_at to look up argument
* implement ExtractArgFromJs that uses borrow instead of mut borrow

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "node-bindgen"
-version = "4.0.1"
+version = "4.1.0"
 authors = ["Fluvio Contributors <[email protected]>"]
 edition = "2018"
 description = "easy way to write nodejs module using rust"
@@ -16,9 +16,9 @@ build = ["nj-build"]
 
 [dependencies]
 nj-sys = { path = "nj-sys", version = "3.0.0", optional = true }
-nj-core = { path = "nj-core", version = "4.0.0", optional = true  }
+nj-core = { path = "nj-core", version = "4.1.0", optional = true  }
 nj-build = { path = "nj-build", version = "0.2.1", optional = true }
-nj-derive = { path = "nj-derive", version = "2.1.1", optional = true}
+nj-derive = { path = "nj-derive", version = "3.0.0", optional = true}
 
 [workspace]
 members = [

examples/array/src/lib.rs

@@ -1,25 +1,17 @@
-
-
 use node_bindgen::derive::node_bindgen;
 
-
-
 /// create array and fill with increase value
 #[node_bindgen]
 fn make_array(count: i32) -> Vec<i32> {
-
     let mut array = vec![];
     for i in 0..count {
         array.push(i);
     }
     array
 }
 
-
 /// sum array of values
 #[node_bindgen]
 fn sum_array(array: Vec<i32>) -> i32 {
-
-   array.iter().sum()
+    array.iter().sum()
 }
-

examples/async-cb/Cargo.toml

@@ -9,6 +9,7 @@ edition = "2018"
 crate-type = ["cdylib"]
 
 [dependencies]
+log = "0.4.8"
 node-bindgen = { path = "../.."}
 fluvio-future = { version = "0.1.0",features=["timer"]}
 

examples/async-cb/src/lib.rs

@@ -3,23 +3,17 @@ use std::time::Duration;
 use fluvio_future::timer::sleep;
 use node_bindgen::derive::node_bindgen;
 
-
 #[node_bindgen]
-async fn basic<F: Fn(f64,f64)>( seconds: i32, cb: F) {
-
+async fn basic<F: Fn(f64, f64)>(seconds: i32, cb: F) {
     sleep(Duration::from_secs(1)).await;
-    cb(seconds as f64,(seconds*2) as f64);
-
+    cb(seconds as f64, (seconds * 2) as f64);
 }
 
-
 #[node_bindgen]
-async fn hello<F: Fn(f64,String)>( seconds: i32, cb: F) {
-
-  //  println!("sleeping");
+async fn hello<F: Fn(f64, String)>(seconds: i32, cb: F) {
+    //  println!("sleeping");
     sleep(Duration::from_secs(seconds as u64)).await;
-//    println!("woke from time");
-
-    cb(10.0,"hello world".to_string());
+    //    println!("woke from time");
 
-}
+    cb(10.0, "hello world".to_string());
+}

examples/async-cb/test_cb.js

@@ -3,15 +3,15 @@ const assert = require('assert');
 
 
 addon.hello(1,function(val,msg){
-  assert.equal(val,10);
-  assert.equal(msg,"hello world");
+  assert.strictEqual(val,10);
+  assert.strictEqual(msg,"hello world");
   console.log("callback test succeed");
 });
 
 
 addon.basic(10,function(val,val2){
-  assert.equal(val,10);
-  assert.equal(val2,20);
+  assert.strictEqual(val,10);
+  assert.strictEqual(val2,20);
   console.log("callback test succeed");
 });
 

examples/bigint/src/lib.rs

@@ -5,7 +5,7 @@ use node_bindgen::core::bigint::BigInt;
 #[node_bindgen]
 fn multiply_big_int(arg: BigInt) -> BigInt {
     println!("bigint arg: {}", arg);
-    arg*2
+    arg * 2
 }
 
 // Test that we can go across the FFI without screwing up the bits.
@@ -19,7 +19,7 @@ fn do_nothing(arg: BigInt) -> BigInt {
 #[node_bindgen]
 fn go_negative(arg: BigInt) -> BigInt {
     println!("bigint arg: {}", arg);
-    -1*arg
+    -1 * arg
 }
 
 // Test out that we can return a u64 which is automatically converted to a bigint.

examples/buffer/src/lib.rs

@@ -4,84 +4,76 @@ use node_bindgen::derive::node_bindgen;
 use node_bindgen::core::buffer::ArrayBuffer;
 use node_bindgen::core::NjError;
 
-
 #[derive(Serialize)]
 struct MyStruct {
     a: String,
-    b: i32
+    b: i32,
 }
 
 /// byte array buffer from json bytes
 #[node_bindgen]
-fn test(b: i32) -> Result<ArrayBuffer,NjError> {
-
+fn test(b: i32) -> Result<ArrayBuffer, NjError> {
     let my_struct = MyStruct {
         a: "b".to_string(),
-        b
+        b,
     };
 
     let json_string = serde_json::to_vec(&my_struct)
-        .map_err(|err| NjError::Other(format!("serialization error: {}",err.to_string())))?;
+        .map_err(|err| NjError::Other(format!("serialization error: {}", err.to_string())))?;
 
     Ok(ArrayBuffer::new(json_string))
 }
 
-
 use node_bindgen::core::val::JsEnv;
 use node_bindgen::core::TryIntoJs;
 use node_bindgen::core::val::JsObject;
 use node_bindgen::sys::napi_value;
 
 struct Record {
     buffer: ArrayBuffer,
-    comment: String
+    comment: String,
 }
 
-
 impl TryIntoJs for Record {
-
     /// serialize into json object
-    fn try_to_js(self, js_env: &JsEnv) -> Result<napi_value,NjError> {
-
+    fn try_to_js(self, js_env: &JsEnv) -> Result<napi_value, NjError> {
         // create JSON
         let mut json = JsObject::create(js_env)?;
 
-        json.set_property("buffer",self.buffer.try_to_js(js_env)?)?;
-        json.set_property("comment",js_env.create_string_utf8(&self.comment)?)?;
-        
+        json.set_property("buffer", self.buffer.try_to_js(js_env)?)?;
+        json.set_property("comment", js_env.create_string_utf8(&self.comment)?)?;
+
         json.try_to_js(js_env)
     }
 }
 
-
-
 /// create byte array and wrap in side another json obj
 #[node_bindgen]
-fn test2(b: i32) -> Result<Record,NjError> {
-
+fn test2(b: i32) -> Result<Record, NjError> {
     let my_struct = MyStruct {
         a: "b".to_string(),
-        b
+        b,
     };
 
     let json_string = serde_json::to_vec(&my_struct)
-        .map_err(|err| NjError::Other(format!("serialization error: {}",err.to_string())))?;
+        .map_err(|err| NjError::Other(format!("serialization error: {}", err.to_string())))?;
 
     Ok(Record {
         buffer: ArrayBuffer::new(json_string),
-        comment: "array buffer is cool!".to_owned()
+        comment: "array buffer is cool!".to_owned(),
     })
 }
 
-
-
-
-
 #[node_bindgen]
-fn test3(data: &[u8]) -> Result<String,NjError> {
-
+fn test3(data: &[u8]) -> Result<String, NjError> {
     let message = String::from_utf8(data.to_vec())?;
-    Ok(format!("reply {}",message))
+    Ok(format!("reply {}", message))
 }
 
+#[node_bindgen]
+fn test4(first: &[u8], second: &[u8]) -> Result<String, NjError> {
+    let message1 = String::from_utf8(first.to_vec())?;
+    let message2 = String::from_utf8(second.to_vec())?;
 
+    Ok(format!("{} {}", message1, message2))
+}

examples/buffer/test.js

@@ -18,3 +18,4 @@ assert.deepStrictEqual(JSON.parse(Buffer.from(record.buffer)), { a: 'b', b: 10 }
 
 
 assert.strictEqual(addon.test3(Buffer.from("hello")),"reply hello");
+assert.strictEqual(addon.test4(Buffer.from("hello"),Buffer.from("world")),"hello world");

examples/cb/build.rs

@@ -1,4 +1,3 @@
 fn main() {
-
     node_bindgen::build::configure();
-}
+}

examples/cb/src/lib.rs

@@ -7,17 +7,15 @@ fn hello<F: Fn(String)>(first: f64, second: F) {
     second(msg);
 }
 
-
 #[node_bindgen]
-fn example<F: Fn(i32)>(cb: F,second: i32) {        
-    cb(second*2)
+fn example<F: Fn(i32)>(cb: F, second: i32) {
+    cb(second * 2)
 }
 
 /*
 #[node_bindgen]
-fn sum<F: Fn(i32) -> String>(cb: F,second: i32) -> String {        
+fn sum<F: Fn(i32) -> String>(cb: F,second: i32) -> String {
     let message = cb(second*2);
     format!("my message: {}",message)
 }
 */
-

examples/cb/test.js

@@ -7,7 +7,7 @@ addon.hello(2,function(msg){
 });
 
 assert.throws( () => addon.hello(2),{
-  message: 'expected argument of type: callback'
+  message: 'expected argument of type: callback at: 1'
 }); 
 
 addon.example(function(val){

examples/class-async/build.rs

@@ -1,4 +1,3 @@
 fn main() {
-
     node_bindgen::build::configure();
-}
+}