feat: use serialize to provide Writable trait for ordered types

Author: lmmx

src/serde/value/borrowed/ordered/se.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/serde/value/owned/ordered/se.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

@@ -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+

src/value/borrowed.rs

@@ -0,0 +1,188 @@
+use super::Value;
+use crate::OrderedOwnedValue as OwnedValue;
+use crate::prelude::*;
+
+#[allow(clippy::cast_sign_loss, clippy::default_trait_access)]
+impl PartialEq for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Static(s1), Self::Static(s2)) => s1 == s2,
+            (Self::String(v1), Self::String(v2)) => v1.eq(v2),
+            (Self::Array(v1), Self::Array(v2)) => v1.eq(v2),
+            (Self::Object(v1), Self::Object(v2)) => v1.eq(v2),
+            _ => false,
+        }
+    }
+}
+
+impl<'value, T> PartialEq<&T> for Value<'value>
+where
+    Value<'value>: PartialEq<T>,
+{
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &&T) -> bool {
+        self == *other
+    }
+}
+
+impl PartialEq<OwnedValue> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &OwnedValue) -> bool {
+        // We only need to implement this once
+        other.eq(self)
+    }
+}
+
+impl PartialEq<()> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, _other: &()) -> bool {
+        self.is_null()
+    }
+}
+
+impl PartialEq<bool> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &bool) -> bool {
+        self.as_bool().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<str> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &str) -> bool {
+        self.as_str().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<&str> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &&str) -> bool {
+        self == *other
+    }
+}
+
+impl PartialEq<String> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &String) -> bool {
+        self.as_str().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<i8> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &i8) -> bool {
+        self.as_i8().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<i16> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &i16) -> bool {
+        self.as_i16().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<i32> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &i32) -> bool {
+        self.as_i32().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<i64> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &i64) -> bool {
+        self.as_i64().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<i128> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &i128) -> bool {
+        self.as_i128().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<u8> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &u8) -> bool {
+        self.as_u8().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<u16> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &u16) -> bool {
+        self.as_u16().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<u32> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &u32) -> bool {
+        self.as_u32().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<u64> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &u64) -> bool {
+        self.as_u64().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<usize> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &usize) -> bool {
+        self.as_usize().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<u128> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &u128) -> bool {
+        self.as_u128().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<f32> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &f32) -> bool {
+        self.as_f32().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl PartialEq<f64> for Value<'_> {
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &f64) -> bool {
+        self.as_f64().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl<'v, T> PartialEq<&[T]> for Value<'v>
+where
+    Value<'v>: PartialEq<T>,
+{
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &&[T]) -> bool {
+        self.as_array().is_some_and(|t| t.eq(other))
+    }
+}
+
+impl<'v, K, T, S> PartialEq<std::collections::HashMap<K, T, S>> for Value<'v>
+where
+    K: AsRef<str> + std::hash::Hash + Eq,
+    Value<'v>: PartialEq<T>,
+    S: std::hash::BuildHasher,
+{
+    #[cfg_attr(not(feature = "no-inline"), inline)]
+    fn eq(&self, other: &std::collections::HashMap<K, T, S>) -> bool {
+        self.as_object().is_some_and(|object| {
+            object.len() == other.len()
+                && other
+                    .iter()
+                    .all(|(key, value)| object.get(key.as_ref()).is_some_and(|v| *v == *value))
+        })
+    }
+}