Vendor dependencies for 0.3.0 release

vendor/ron/src/ser/tests.rs

@@ -0,0 +1,147 @@
+use serde_derive::Serialize;
+
+use super::to_string;
+
+#[derive(Serialize)]
+struct EmptyStruct1;
+
+#[derive(Serialize)]
+struct EmptyStruct2 {}
+
+#[derive(Serialize)]
+struct MyStruct {
+    x: f32,
+    y: f32,
+}
+
+#[derive(Serialize)]
+enum MyEnum {
+    A,
+    B(bool),
+    C(bool, f32),
+    D { a: i32, b: i32 },
+}
+
+#[test]
+fn test_empty_struct() {
+    assert_eq!(to_string(&EmptyStruct1).unwrap(), "()");
+    assert_eq!(to_string(&EmptyStruct2 {}).unwrap(), "()");
+}
+
+#[test]
+fn test_struct() {
+    let my_struct = MyStruct { x: 4.0, y: 7.0 };
+
+    assert_eq!(to_string(&my_struct).unwrap(), "(x:4.0,y:7.0)");
+
+    #[derive(Serialize)]
+    struct NewType(i32);
+
+    assert_eq!(to_string(&NewType(42)).unwrap(), "(42)");
+
+    #[derive(Serialize)]
+    struct TupleStruct(f32, f32);
+
+    assert_eq!(to_string(&TupleStruct(2.0, 5.0)).unwrap(), "(2.0,5.0)");
+}
+
+#[test]
+fn test_option() {
+    assert_eq!(to_string(&Some(1u8)).unwrap(), "Some(1)");
+    assert_eq!(to_string(&None::<u8>).unwrap(), "None");
+}
+
+#[test]
+fn test_enum() {
+    assert_eq!(to_string(&MyEnum::A).unwrap(), "A");
+    assert_eq!(to_string(&MyEnum::B(true)).unwrap(), "B(true)");
+    assert_eq!(to_string(&MyEnum::C(true, 3.5)).unwrap(), "C(true,3.5)");
+    assert_eq!(to_string(&MyEnum::D { a: 2, b: 3 }).unwrap(), "D(a:2,b:3)");
+}
+
+#[test]
+fn test_array() {
+    let empty: [i32; 0] = [];
+    assert_eq!(to_string(&empty).unwrap(), "()");
+    let empty_ref: &[i32] = &empty;
+    assert_eq!(to_string(&empty_ref).unwrap(), "[]");
+
+    assert_eq!(to_string(&[2, 3, 4i32]).unwrap(), "(2,3,4)");
+    assert_eq!(to_string(&(&[2, 3, 4i32] as &[i32])).unwrap(), "[2,3,4]");
+}
+
+#[test]
+fn test_slice() {
+    assert_eq!(to_string(&[0, 1, 2, 3, 4, 5][..]).unwrap(), "[0,1,2,3,4,5]");
+    assert_eq!(to_string(&[0, 1, 2, 3, 4, 5][1..4]).unwrap(), "[1,2,3]");
+}
+
+#[test]
+fn test_vec() {
+    assert_eq!(to_string(&vec![0, 1, 2, 3, 4, 5]).unwrap(), "[0,1,2,3,4,5]");
+}
+
+#[test]
+fn test_map() {
+    use std::collections::HashMap;
+
+    let mut map = HashMap::new();
+    map.insert((true, false), 4);
+    map.insert((false, false), 123);
+
+    let s = to_string(&map).unwrap();
+    s.starts_with('{');
+    s.contains("(true,false):4");
+    s.contains("(false,false):123");
+    s.ends_with('}');
+}
+
+#[test]
+fn test_string() {
+    assert_eq!(to_string(&"Some string").unwrap(), "\"Some string\"");
+}
+
+#[test]
+fn test_char() {
+    assert_eq!(to_string(&'c').unwrap(), "'c'");
+}
+
+#[test]
+fn test_escape() {
+    assert_eq!(to_string(&r#""Quoted""#).unwrap(), r#""\"Quoted\"""#);
+}
+
+#[test]
+fn test_byte_stream() {
+    use serde_bytes;
+
+    let small: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    assert_eq!(
+        to_string(&small).unwrap(),
+        "(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)"
+    );
+
+    let large = vec![255u8; 64];
+    let large = serde_bytes::Bytes::new(&large);
+    assert_eq!(
+        to_string(&large).unwrap(),
+        concat!(
+            "\"/////////////////////////////////////////",
+            "////////////////////////////////////////////w==\""
+        )
+    );
+}
+
+#[test]
+fn rename() {
+    #[derive(Serialize, Debug, PartialEq)]
+    enum Foo {
+        #[serde(rename = "2d")]
+        D2,
+        #[serde(rename = "triangle-list")]
+        TriangleList,
+    }
+
+    assert_eq!(to_string(&Foo::D2).unwrap(), "r#2d");
+    assert_eq!(to_string(&Foo::TriangleList).unwrap(), "r#triangle-list");
+}

vendor/ron/src/ser/value.rs

@@ -0,0 +1,23 @@
+use serde::ser::{Serialize, Serializer};
+
+use crate::value::{Number, Value};
+
+impl Serialize for Value {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            Value::Bool(b) => serializer.serialize_bool(b),
+            Value::Char(c) => serializer.serialize_char(c),
+            Value::Map(ref m) => Serialize::serialize(m, serializer),
+            Value::Number(Number::Float(ref f)) => serializer.serialize_f64(f.get()),
+            Value::Number(Number::Integer(i)) => serializer.serialize_i64(i),
+            Value::Option(Some(ref o)) => serializer.serialize_some(o.as_ref()),
+            Value::Option(None) => serializer.serialize_none(),
+            Value::String(ref s) => serializer.serialize_str(s),
+            Value::Seq(ref s) => Serialize::serialize(s, serializer),
+            Value::Unit => serializer.serialize_unit(),
+        }
+    }
+}