feat: use serialize to provide Writable trait for ordered types

Author: lmmx

src/serde/value/borrowed/ordered/se.rs

@@ -7,7 +7,7 @@ mod impls;
 
 #[cfg(not(target_arch = "wasm32"))]
 use crate::to_borrowed_value;
-use crate::{Deserializer, owned::Value, tape::Node, to_owned_value};
+use crate::{cow::Cow, Deserializer, owned::Value, tape::Node, to_owned_value};
 #[cfg(not(target_arch = "wasm32"))]
 use proptest::prelude::*;
 use value_trait::prelude::*;
@@ -253,10 +253,10 @@ proptest! {
         { // we can't do 128 bit w/ serde
             use crate::{deserialize, BorrowedValue, OwnedValue};
             let mut e = encoded.clone();
-            let res: OwnedValue = deserialize(&mut e).expect("can't convert");
+            let res: OwnedValue = deserialize::<OwnedValue, String>(&mut e).expect("can't convert");
             assert_eq!(val, res);
             let mut e = encoded;
-            let res: BorrowedValue = deserialize(&mut e).expect("can't convert");
+            let res: BorrowedValue = deserialize::<BorrowedValue, Cow<'_, str>>(&mut e).expect("can't convert");
             assert_eq!(val, res);
         }
     }

src/serde/value/owned/ordered/se.rs

@@ -1008,7 +1008,7 @@ proptest! {
             let v_simd_owned = to_owned_value(d2).expect("to_owned_value failed");
             let v_simd_borrowed = to_borrowed_value(d3).expect("to_borrowed_value failed");
             assert_eq!(v_simd_borrowed, v_simd_owned);
-            let v_deserialize: OwnedValue = deserialize(d4).expect("deserialize failed");
+            let v_deserialize: OwnedValue = deserialize::<OwnedValue, String>(d4).expect("deserialize failed");
             assert_eq!(v_deserialize, v_simd_owned);
         }
 

src/tests.rs

@@ -63,7 +63,7 @@ pub use self::borrowed::{
     Value as BorrowedValue, to_value as to_borrowed_value,
     to_value_with_buffers as to_borrowed_value_with_buffers,
 };
-#[cfg(feature = "preserve_ordered")]
+#[cfg(feature = "preserve_order")]
 pub use self::borrowed::ordered::{
     Value as OrderedBorrowedValue, to_value as to_ordered_borrowed_value,
     to_value_with_buffers as to_ordered_borrowed_value_with_buffers,
@@ -72,7 +72,7 @@ pub use self::owned::{
     Value as OwnedValue, to_value as to_owned_value,
     to_value_with_buffers as to_owned_value_with_buffers,
 };
-#[cfg(feature = "preserve_ordered")]
+#[cfg(feature = "preserve_order")]
 pub use self::owned::ordered::{
     Value as OrderedOwnedValue, to_value as to_ordered_owned_value,
     to_value_with_buffers as to_ordered_owned_value_with_buffers,

src/tests/serde.rs

@@ -428,11 +428,11 @@ impl<'de> BorrowDeserializer<'de> {
         // element so we eat this
         for _ in 0..len {
             if let Node::String(key) = unsafe { self.0.next_() } {
-                #[cfg(all(not(feature = "value-no-dup-keys"), not(feature = "preserve_order")))]
+                #[cfg(not(feature = "value-no-dup-keys"))]
                 unsafe {
                     res.insert_nocheck(key.into(), self.parse());
                 };
-                #[cfg(any(feature = "value-no-dup-keys", feature = "preserve_order"))]
+                #[cfg(feature = "value-no-dup-keys")]
                 res.insert(key.into(), self.parse());
             } else {
                 unreachable!("parse_map: key not a string");
@@ -490,11 +490,11 @@ impl<'tape, 'de> BorrowSliceDeserializer<'tape, 'de> {
         // element so we eat this
         for _ in 0..len {
             if let Node::String(key) = unsafe { self.next_() } {
-                #[cfg(all(not(feature = "value-no-dup-keys"), not(feature = "preserve_order")))]
+                #[cfg(not(feature = "value-no-dup-keys"))]
                 unsafe {
                     res.insert_nocheck(key.into(), self.parse());
                 };
-                #[cfg(any(feature = "value-no-dup-keys", feature = "preserve_order"))]
+                #[cfg(feature = "value-no-dup-keys")]
                 res.insert(key.into(), self.parse());
             } else {
                 unreachable!("parse_map: key needs to be a string");
@@ -1136,59 +1136,6 @@ mod test {
         assert_eq!(result_keys, expected_keys);
     }
 
-    #[cfg(feature = "preserve_order")]
-    #[test]
-    fn preserve_order_33_keys() {
-        // halfbrown uses Vec for <=32 keys, switches to HashMap at 33+
-        // This is where order gets lost without IndexMap
-        let keys: Vec<String> = (0..33).map(|i| format!("key_{}", i)).collect();
-        let json_pairs: Vec<String> = keys.iter().map(|k| format!(r#""{}": {}"#, k, 1)).collect();
-        let json = format!("{{{}}}", json_pairs.join(", "));
-        let mut input = json.into_bytes();
-
-        let v = to_value(input.as_mut_slice()).expect("valid JSON");
-        let obj = v.as_object().expect("is object");
-        let result_keys: Vec<&str> = obj.keys().map(|k| k.as_ref()).collect();
-        let expected_keys: Vec<&str> = keys.iter().map(|s| s.as_str()).collect();
-
-        assert_eq!(result_keys, expected_keys);
-    }
-
-    #[cfg(feature = "preserve_order")]
-    #[test]
-    fn preserve_order_50_keys() {
-        // Test well past the threshold
-        let keys: Vec<String> = (0..50).map(|i| format!("key_{}", i)).collect();
-        let json_pairs: Vec<String> = keys.iter().map(|k| format!(r#""{}": {}"#, k, 1)).collect();
-        let json = format!("{{{}}}", json_pairs.join(", "));
-        let mut input = json.into_bytes();
-
-        let v = to_value(input.as_mut_slice()).expect("valid JSON");
-        let obj = v.as_object().expect("is object");
-        let result_keys: Vec<&str> = obj.keys().map(|k| k.as_ref()).collect();
-        let expected_keys: Vec<&str> = keys.iter().map(|s| s.as_str()).collect();
-
-        assert_eq!(result_keys, expected_keys);
-    }
-
-    #[cfg(feature = "preserve_order")]
-    #[test]
-    fn preserve_order_roundtrip_33_keys() {
-        let keys: Vec<String> = (0..33).map(|i| format!("key_{}", i)).collect();
-        let json_pairs: Vec<String> = keys.iter().map(|k| format!(r#""{}": {}"#, k, 1)).collect();
-        let json = format!("{{{}}}", json_pairs.join(", "));
-        let mut input = json.into_bytes();
-
-        let v = to_value(input.as_mut_slice()).expect("valid JSON");
-        let mut serialized = v.encode();
-        let v2 = to_value(unsafe { serialized.as_bytes_mut() }).expect("valid JSON");
-
-        let keys1: Vec<&str> = v.as_object().unwrap().keys().map(|k| k.as_ref()).collect();
-        let keys2: Vec<&str> = v2.as_object().unwrap().keys().map(|k| k.as_ref()).collect();
-
-        assert_eq!(keys1, keys2);
-    }
-
     // #[test]
     // fn size() {
     //     assert_eq!(std::mem::size_of::<Value>(), 24);

src/value.rs

@@ -219,8 +219,12 @@ impl<'value> From<Object<'value>> for Value<'value> {
 }
 
 #[cfg(feature = "preserve_order")]
-impl<'value> From<indexmap::IndexMap<Cow<'value, str>, Value<'value>>> for Value<'value> {
-    fn from(v: indexmap::IndexMap<Cow<'value, str>, Value<'value>>) -> Self {
-        Self::Object(Box::new(v.into_iter().collect()))
+impl<'value, K, S> From<indexmap::IndexMap<K, Value<'value>, S>> for Value<'value>
+where
+    K: Into<Cow<'value, str>>,
+    S: std::hash::BuildHasher,
+{
+    fn from(v: indexmap::IndexMap<K, Value<'value>, S>) -> Self {
+        Self::Object(Box::new(v.into_iter().map(|(k, v)| (k.into(), v)).collect()))
     }
 }

src/value/borrowed.rs

@@ -20,17 +20,22 @@
 /// a["key"] = "value".into();
 /// assert_eq!(a["key"], "value");
 /// ```
+/// Partial equality comparison impls
+pub mod cmp;
+/// From converter impls
 pub mod from;
+/// Provide Writable trait
+pub mod serialize;
 
 use crate::{Buffers, prelude::*};
-use crate::{Deserializer, Node, Result};
+use crate::{Deserializer, Node, ObjectHasher, Result};
 use crate::cow::Cow;
 use indexmap::IndexMap;
 use std::fmt;
 use std::ops::{Index, IndexMut};
 
 /// Representation of a JSON object
-pub type Object<'value> = IndexMap<Cow<'value, str>, Value<'value>, std::hash::RandomState>;
+pub type Object<'value> = IndexMap<Cow<'value, str>, Value<'value>, ObjectHasher>;
 
 /// Representation of a JSON array
 pub type Array<'value> = Vec<Value<'value>>;
@@ -74,7 +79,7 @@ pub fn to_value_with_buffers<'value>(
 
 /// Borrowed JSON-DOM Value, consider using the `ValueTrait`
 /// to access its content
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 #[cfg_attr(feature = "ordered-float", derive(Eq))]
 pub enum Value<'value> {
     /// Static values
@@ -175,7 +180,7 @@ impl<'value> ValueBuilder<'value> for Value<'value> {
     fn object_with_capacity(capacity: usize) -> Self {
         Self::Object(Box::new(Object::with_capacity_and_hasher(
             capacity,
-            std::hash::RandomState::default(),
+            ObjectHasher::default(),
         )))
     }
 }
@@ -421,7 +426,7 @@ impl<'de> BorrowDeserializer<'de> {
 
     #[cfg_attr(not(feature = "no-inline"), inline)]
     fn parse_map(&mut self, len: usize) -> Value<'de> {
-        let mut res = Object::with_capacity_and_hasher(len, std::hash::RandomState::default());
+        let mut res = Object::with_capacity_and_hasher(len, ObjectHasher::default());
 
         // Since we checked if it's empty we know that we at least have one
         // element so we eat this
@@ -931,43 +936,6 @@ mod test {
         assert_eq!(Value::default(), Value::null());
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
-    use proptest::prelude::*;
-
-    #[cfg(not(target_arch = "wasm32"))]
-    fn arb_value() -> BoxedStrategy<Value<'static>> {
-        let leaf = prop_oneof![
-            Just(Value::Static(StaticNode::Null)),
-            any::<bool>()
-                .prop_map(StaticNode::Bool)
-                .prop_map(Value::Static),
-            any::<i64>()
-                .prop_map(StaticNode::I64)
-                .prop_map(Value::Static),
-            any::<u64>()
-                .prop_map(StaticNode::U64)
-                .prop_map(Value::Static),
-            any::<f64>()
-                .prop_map(StaticNode::from)
-                .prop_map(Value::Static),
-            ".*".prop_map(Value::from),
-        ];
-        leaf.prop_recursive(
-            8,   // 8 levels deep
-            256, // Shoot for maximum size of 256 nodes
-            10,  // We put up to 10 items per collection
-            |inner| {
-                prop_oneof![
-                    // Take the inner strategy and make the two recursive cases.
-                    prop::collection::vec(inner.clone(), 0..10).prop_map(Value::from),
-                    prop::collection::hash_map(".*".prop_map(Cow::from), inner, 0..10)
-                        .prop_map(|m| m.into_iter().collect()),
-                ]
-            },
-        )
-        .boxed()
-    }
-
     #[test]
     fn preserve_order_33_keys() {
         // halfbrown uses Vec for <=32 keys, switches to HashMap at 33+