chore: move serde_v8 to separate repo (#10909)

Now available at https://github.com/denoland/serde_v8

3 files changed, 0 insertions, 479 deletions

diff --git a/serde_v8/tests/de.rs b/serde_v8/tests/de.rs
deleted file mode 100644
index 785de6374..000000000
--- a/serde_v8/tests/de.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-use rusty_v8 as v8;
-
-use serde::Deserialize;
-
-use serde_v8::utils::{js_exec, v8_do};
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct MathOp {
-  pub a: u64,
-  pub b: u64,
-  pub operator: Option<String>,
-}
-
-#[derive(Debug, PartialEq, Deserialize)]
-enum EnumUnit {
-  A,
-  B,
-  C,
-}
-
-#[derive(Debug, PartialEq, Deserialize)]
-enum EnumPayloads {
-  UInt(u64),
-  Int(i64),
-  Float(f64),
-  Point { x: i64, y: i64 },
-  Tuple(bool, i64, ()),
-}
-
-fn dedo(
-  code: &str,
-  f: impl FnOnce(&mut v8::HandleScope, v8::Local<v8::Value>),
-) {
-  v8_do(|| {
-    let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
-    let handle_scope = &mut v8::HandleScope::new(isolate);
-    let context = v8::Context::new(handle_scope);
-    let scope = &mut v8::ContextScope::new(handle_scope, context);
-    let v = js_exec(scope, code);
-
-    f(scope, v);
-  })
-}
-
-macro_rules! detest {
-  ($fn_name:ident, $t:ty, $src:expr, $rust:expr) => {
-    #[test]
-    fn $fn_name() {
-      dedo($src, |scope, v| {
-        let rt = serde_v8::from_v8(scope, v);
-        assert!(rt.is_ok(), "from_v8(\"{}\"): {:?}", $src, rt.err());
-        let t: $t = rt.unwrap();
-        assert_eq!(t, $rust);
-      });
-    }
-  };
-}
-
-detest!(de_option_some, Option<bool>, "true", Some(true));
-detest!(de_option_null, Option<bool>, "null", None);
-detest!(de_option_undefined, Option<bool>, "undefined", None);
-detest!(de_unit_null, (), "null", ());
-detest!(de_unit_undefined, (), "undefined", ());
-detest!(de_bool, bool, "true", true);
-detest!(de_u64, u64, "32", 32);
-detest!(de_string, String, "'Hello'", "Hello".to_owned());
-detest!(de_vec_u64, Vec<u64>, "[1,2,3,4,5]", vec![1, 2, 3, 4, 5]);
-detest!(
-  de_vec_str,
-  Vec<String>,
-  "['hello', 'world']",
-  vec!["hello".to_owned(), "world".to_owned()]
-);
-detest!(
-  de_tuple,
-  (u64, bool, ()),
-  "[123, true, null]",
-  (123, true, ())
-);
-detest!(
-  de_mathop,
-  MathOp,
-  "({a: 1, b: 3, c: 'ignored'})",
-  MathOp {
-    a: 1,
-    b: 3,
-    operator: None
-  }
-);
-
-// Unit enums
-detest!(de_enum_unit_a, EnumUnit, "'A'", EnumUnit::A);
-detest!(de_enum_unit_b, EnumUnit, "'B'", EnumUnit::B);
-detest!(de_enum_unit_c, EnumUnit, "'C'", EnumUnit::C);
-
-// Enums with payloads (tuples & struct)
-detest!(
-  de_enum_payload_int,
-  EnumPayloads,
-  "({ Int: -123 })",
-  EnumPayloads::Int(-123)
-);
-detest!(
-  de_enum_payload_uint,
-  EnumPayloads,
-  "({ UInt: 123 })",
-  EnumPayloads::UInt(123)
-);
-detest!(
-  de_enum_payload_float,
-  EnumPayloads,
-  "({ Float: 1.23 })",
-  EnumPayloads::Float(1.23)
-);
-detest!(
-  de_enum_payload_point,
-  EnumPayloads,
-  "({ Point: { x: 1, y: 2 } })",
-  EnumPayloads::Point { x: 1, y: 2 }
-);
-detest!(
-  de_enum_payload_tuple,
-  EnumPayloads,
-  "({ Tuple: [true, 123, null ] })",
-  EnumPayloads::Tuple(true, 123, ())
-);
-
-#[test]
-fn de_f64() {
-  dedo("12345.0", |scope, v| {
-    let x: f64 = serde_v8::from_v8(scope, v).unwrap();
-    assert!((x - 12345.0).abs() < f64::EPSILON);
-  });
-}
-
-#[test]
-fn de_map() {
-  use std::collections::HashMap;
-
-  dedo("({a: 1, b: 2, c: 3})", |scope, v| {
-    let map: HashMap<String, u64> = serde_v8::from_v8(scope, v).unwrap();
-    assert_eq!(map.get("a").cloned(), Some(1));
-    assert_eq!(map.get("b").cloned(), Some(2));
-    assert_eq!(map.get("c").cloned(), Some(3));
-    assert_eq!(map.get("nada"), None);
-  })
-}
-
-////
-// JSON tests: serde_json::Value compatibility
-////
-
-detest!(
-  de_json_null,
-  serde_json::Value,
-  "null",
-  serde_json::Value::Null
-);
-detest!(
-  de_json_bool,
-  serde_json::Value,
-  "true",
-  serde_json::Value::Bool(true)
-);
-detest!(
-  de_json_int,
-  serde_json::Value,
-  "123",
-  serde_json::Value::Number(serde_json::Number::from(123))
-);
-detest!(
-  de_json_float,
-  serde_json::Value,
-  "123.45",
-  serde_json::Value::Number(serde_json::Number::from_f64(123.45).unwrap())
-);
-detest!(
-  de_json_string,
-  serde_json::Value,
-  "'Hello'",
-  serde_json::Value::String("Hello".to_string())
-);
-detest!(
-  de_json_vec_string,
-  serde_json::Value,
-  "['Hello', 'World']",
-  serde_json::Value::Array(vec![
-    serde_json::Value::String("Hello".to_string()),
-    serde_json::Value::String("World".to_string())
-  ])
-);
-detest!(
-  de_json_tuple,
-  serde_json::Value,
-  "[true, 'World', 123.45, null]",
-  serde_json::Value::Array(vec![
-    serde_json::Value::Bool(true),
-    serde_json::Value::String("World".to_string()),
-    serde_json::Value::Number(serde_json::Number::from_f64(123.45).unwrap()),
-    serde_json::Value::Null,
-  ])
-);
-detest!(
-  de_json_object,
-  serde_json::Value,
-  "({a: 1, b: 'hello', c: true})",
-  serde_json::Value::Object(
-    vec![
-      (
-        "a".to_string(),
-        serde_json::Value::Number(serde_json::Number::from(1)),
-      ),
-      (
-        "b".to_string(),
-        serde_json::Value::String("hello".to_string()),
-      ),
-      ("c".to_string(), serde_json::Value::Bool(true),),
-    ]
-    .drain(..)
-    .collect()
-  )
-);
diff --git a/serde_v8/tests/magic.rs b/serde_v8/tests/magic.rs
deleted file mode 100644
index 33ed394ed..000000000
--- a/serde_v8/tests/magic.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-use rusty_v8 as v8;
-
-use serde::{Deserialize, Serialize};
-
-use serde_v8::utils::{js_exec, v8_do};
-use std::convert::TryFrom;
-
-#[derive(Deserialize)]
-struct MagicOp<'s> {
-  pub a: u64,
-  pub b: u64,
-  pub c: serde_v8::Value<'s>,
-  pub operator: Option<String>,
-}
-
-#[derive(Serialize)]
-struct MagicContainer<'s> {
-  pub magic: bool,
-  pub contains: serde_v8::Value<'s>,
-}
-
-#[test]
-fn magic_basic() {
-  v8_do(|| {
-    let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
-    let handle_scope = &mut v8::HandleScope::new(isolate);
-    let context = v8::Context::new(handle_scope);
-    let scope = &mut v8::ContextScope::new(handle_scope, context);
-
-    // Decode
-    let v = js_exec(scope, "({a: 1, b: 3, c: 'abracadabra'})");
-    let mop: MagicOp = serde_v8::from_v8(scope, v).unwrap();
-    // Check string
-    let v8_value: v8::Local<v8::Value> = mop.c.into();
-    let vs = v8::Local::<v8::String>::try_from(v8_value).unwrap();
-    let s = vs.to_rust_string_lossy(scope);
-    assert_eq!(s, "abracadabra");
-
-    // Encode
-    let container = MagicContainer {
-      magic: true,
-      contains: v.into(),
-    };
-    let vc = serde_v8::to_v8(scope, container).unwrap();
-    // JSON stringify & check
-    let json = v8::json::stringify(scope, vc).unwrap();
-    let s2 = json.to_rust_string_lossy(scope);
-    assert_eq!(
-      s2,
-      r#"{"magic":true,"contains":{"a":1,"b":3,"c":"abracadabra"}}"#
-    );
-  })
-}
-
-#[test]
-fn magic_buffer() {
-  v8_do(|| {
-    // Init isolate
-    let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
-    let handle_scope = &mut v8::HandleScope::new(isolate);
-    let context = v8::Context::new(handle_scope);
-    let scope = &mut v8::ContextScope::new(handle_scope, context);
-    let global = context.global(scope);
-
-    // Simple buffer
-    let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
-    let zbuf: serde_v8::Buffer = serde_v8::from_v8(scope, v8_array).unwrap();
-    assert_eq!(&*zbuf, &[1, 2, 3, 4, 5]);
-
-    // Multi buffers
-    let v8_arrays =
-      js_exec(scope, "[new Uint8Array([1,2]), new Uint8Array([3,4,5])]");
-    let (z1, z2): (serde_v8::Buffer, serde_v8::Buffer) =
-      serde_v8::from_v8(scope, v8_arrays).unwrap();
-    assert_eq!(&*z1, &[1, 2]);
-    assert_eq!(&*z2, &[3, 4, 5]);
-
-    // Wrapped in option, like our current op-ABI
-    let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
-    let zbuf: Option<serde_v8::Buffer> =
-      serde_v8::from_v8(scope, v8_array).unwrap();
-    assert_eq!(&*zbuf.unwrap(), &[1, 2, 3, 4, 5]);
-
-    // Observe mutation in JS
-    let v8_array = js_exec(scope, "new Uint8Array([1,2,3,4,5])");
-    let mut zbuf: serde_v8::Buffer =
-      serde_v8::from_v8(scope, v8_array).unwrap();
-    let key = serde_v8::to_v8(scope, "t1").unwrap();
-    global.set(scope, key, v8_array);
-    (&mut *zbuf)[2] = 42;
-    let eq = js_exec(scope, "t1[2] === 42");
-    assert!(eq.is_true());
-
-    // Serialization
-    let buf: Vec<u8> = vec![1, 2, 3, 99, 5];
-    let zbuf: serde_v8::Buffer = buf.into();
-    let v8_value = serde_v8::to_v8(scope, zbuf).unwrap();
-    let key = serde_v8::to_v8(scope, "t2").unwrap();
-    global.set(scope, key, v8_value);
-    let eq = js_exec(scope, "t2[3] === 99");
-    assert!(eq.is_true());
-
-    // Composite Serialization
-    #[derive(serde::Serialize)]
-    struct Wrapper {
-      a: serde_v8::Buffer,
-      b: serde_v8::Buffer,
-    }
-    let buf1: Vec<u8> = vec![1, 2, 33, 4, 5];
-    let buf2: Vec<u8> = vec![5, 4, 3, 2, 11];
-    let wrapped = Wrapper {
-      a: buf1.into(),
-      b: buf2.into(),
-    };
-    let v8_value = serde_v8::to_v8(scope, wrapped).unwrap();
-    let key = serde_v8::to_v8(scope, "t3").unwrap();
-    global.set(scope, key, v8_value);
-    let eq = js_exec(scope, "t3.a[2] === 33");
-    assert!(eq.is_true());
-    let eq = js_exec(scope, "t3.b[4] === 11");
-    assert!(eq.is_true());
-  })
-}
diff --git a/serde_v8/tests/ser.rs b/serde_v8/tests/ser.rs
deleted file mode 100644
index 2ae606526..000000000
--- a/serde_v8/tests/ser.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-use rusty_v8 as v8;
-
-use serde::Serialize;
-use serde_json::json;
-use serde_v8::utils::{js_exec, v8_do};
-
-#[derive(Debug, Serialize, PartialEq)]
-struct MathOp {
-  pub a: u64,
-  pub b: u64,
-  pub operator: Option<String>,
-}
-
-// Utility JS code (obj equality, etc...)
-const JS_UTILS: &str = r#"
-// Shallow obj equality (don't use deep objs for now)
-function objEqual(a, b) {
-  const ka = Object.keys(a);
-  const kb = Object.keys(b);
-  return ka.length === kb.length && ka.every(k => a[k] === b[k]);
-}
-
-function arrEqual(a, b) {
-  return a.length === b.length && a.every((v, i) => v === b[i]);
-}
-"#;
-
-fn sercheck<T: Serialize>(val: T, code: &str) -> bool {
-  let mut equal = false;
-
-  v8_do(|| {
-    // Setup isolate
-    let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
-    let handle_scope = &mut v8::HandleScope::new(isolate);
-    let context = v8::Context::new(handle_scope);
-    let scope = &mut v8::ContextScope::new(handle_scope, context);
-
-    // Set value as "x" in global scope
-    let global = context.global(scope);
-    let v8_key = serde_v8::to_v8(scope, "x").unwrap();
-    let v8_val = serde_v8::to_v8(scope, val).unwrap();
-    global.set(scope, v8_key, v8_val);
-
-    // Load util functions
-    js_exec(scope, JS_UTILS);
-    // Execute equality check in JS (e.g: x == ...)
-    let v = js_exec(scope, code);
-    // Cast to bool
-    equal = serde_v8::from_v8(scope, v).unwrap();
-  });
-
-  equal
-}
-
-macro_rules! sertest {
-  ($fn_name:ident, $rust:expr, $src:expr) => {
-    #[test]
-    fn $fn_name() {
-      assert!(
-        sercheck($rust, $src),
-        "Expected: {} where x={:?}",
-        $src,
-        $rust,
-      );
-    }
-  };
-}
-
-sertest!(ser_option_some, Some(true), "x === true");
-sertest!(ser_option_null, None as Option<bool>, "x === null");
-sertest!(ser_unit_null, (), "x === null");
-sertest!(ser_bool, true, "x === true");
-sertest!(ser_u64, 32, "x === 32");
-sertest!(ser_f64, 12345.0, "x === 12345.0");
-sertest!(ser_string, "Hello".to_owned(), "x === 'Hello'");
-sertest!(ser_vec_u64, vec![1, 2, 3, 4, 5], "arrEqual(x, [1,2,3,4,5])");
-sertest!(
-  ser_vec_string,
-  vec!["hello".to_owned(), "world".to_owned(),],
-  "arrEqual(x, ['hello', 'world'])"
-);
-sertest!(ser_tuple, (123, true, ()), "arrEqual(x, [123, true, null])");
-sertest!(
-  ser_mathop,
-  MathOp {
-    a: 1,
-    b: 3,
-    operator: None
-  },
-  "objEqual(x, {a: 1, b: 3, operator: null})"
-);
-
-sertest!(
-  ser_map,
-  {
-    let map: std::collections::BTreeMap<&str, u32> =
-      vec![("a", 1), ("b", 2), ("c", 3)].drain(..).collect();
-    map
-  },
-  "objEqual(x, {a: 1, b: 2, c: 3})"
-);
-
-////
-// JSON tests: json!() compatibility
-////
-sertest!(ser_json_bool, json!(true), "x === true");
-sertest!(ser_json_null, json!(null), "x === null");
-sertest!(ser_json_int, json!(123), "x === 123");
-sertest!(ser_json_f64, json!(123.45), "x === 123.45");
-sertest!(ser_json_string, json!("Hello World"), "x === 'Hello World'");
-sertest!(ser_json_obj_empty, json!({}), "objEqual(x, {})");
-sertest!(
-  ser_json_obj,
-  json!({"a": 1, "b": 2, "c": true}),
-  "objEqual(x, {a: 1, b: 2, c: true})"
-);
-sertest!(
-  ser_json_vec_int,
-  json!([1, 2, 3, 4, 5]),
-  "arrEqual(x, [1,2,3,4,5])"
-);
-sertest!(
-  ser_json_vec_string,
-  json!(["Goodbye", "Dinosaurs 👋☄️"]),
-  "arrEqual(x, ['Goodbye', 'Dinosaurs 👋☄️'])"
-);
-sertest!(
-  ser_json_tuple,
-  json!([true, 42, "nabla"]),
-  "arrEqual(x, [true, 42, 'nabla'])"
-);