pass compilation + make a test which don't pass

ron-rs · Jan 6, 2025 · 17c0441 · 17c0441
1 parent 325e8a7
commit 17c0441
Show file tree

Hide file tree

Showing 5 changed files with 84 additions and 46 deletions.
diff --git a/src/de/value.rs b/src/de/value.rs
@@ -1,4 +1,4 @@
-use std::fmt;
+use std::{borrow::Cow, fmt};
 
 use serde::{
     de::{Error, MapAccess, SeqAccess, Visitor},
@@ -220,7 +220,7 @@ impl<'de> Visitor<'de> for ValueVisitor {
     where
         A: MapAccess<'de>,
     {
-        let mut res: Map = Map::new();
+        let mut res: Map<Value> = Map::new();
 
         #[cfg(feature = "indexmap")]
         if let Some(cap) = map.size_hint() {

diff --git a/src/lib.rs b/src/lib.rs
@@ -1,3 +1,4 @@
+#![allow(warnings)]
 #![deny(clippy::correctness)]
 #![deny(clippy::suspicious)]
 #![deny(clippy::complexity)]

diff --git a/src/ser/value.rs b/src/ser/value.rs
@@ -7,16 +7,16 @@ impl Serialize for Value {
     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(ref number) => Serialize::serialize(number, serializer),
-            Value::Option(Some(ref o)) => serializer.serialize_some(o.as_ref()),
+        match self {
+            Value::Bool(b) => serializer.serialize_bool(*b),
+            Value::Char(c) => serializer.serialize_char(*c),
+            Value::Map(m) => Serialize::serialize(m, serializer),
+            Value::Number(number) => Serialize::serialize(number, serializer),
+            Value::Option(Some(o)) => serializer.serialize_some(o.as_ref()),
             Value::Option(None) => serializer.serialize_none(),
-            Value::String(ref s) => serializer.serialize_str(s),
-            Value::Bytes(ref b) => serializer.serialize_bytes(b),
-            Value::List(ref s) => Serialize::serialize(s, serializer),
+            Value::String(s) => serializer.serialize_str(s),
+            Value::Bytes(b) => serializer.serialize_bytes(b),
+            Value::List(s) => Serialize::serialize(s, serializer),
             Value::Unit => serializer.serialize_unit(),
             Value::Struct(name, map) => {
                 // serializer.serialize_struct(name, len)
@@ -37,40 +37,50 @@ impl Serialize for Value {
                 // https://github.com/serde-rs/json/blob/master/src/value/ser.rs
 
                 match name {
-                    Some(name) => {
-                        let mut state = serializer.serialize_struct("", map.len())?;
+                    Some(name) => match name {
+                        std::borrow::Cow::Borrowed(a) => {
+                            let mut state = serializer.serialize_struct(a, map.len())?;
 
-                        for (k, v) in map {
-                            state.serialize_field(&k, &v)?;
-                        }
+                            for (k, v) in &map.0 {
+                                match k {
+                                    std::borrow::Cow::Borrowed(a) => {
+                                        state.serialize_field(a, &v)?;
+                                    }
+                                    std::borrow::Cow::Owned(_) => todo!(),
+                                }
+                            }
 
-                        state.end()
-                    }
+                            state.end()
+                        }
+                        std::borrow::Cow::Owned(_) => todo!(),
+                    },
                     None => {
                         todo!()
+                        // let mut state = serializer.serialize_struct("", map.len())?;
+
+                        // for (k, v) in map {
+                        //     state.serialize_field(&k, &v)?;
+                        // }
+
+                        // state.end()
                     }
                 }
             }
-            Value::Tuple(name, vec) => match name {
-                Some(name) => {
-                    let mut state = serializer.serialize_tuple_struct("", vec.len())?;
+            Value::Tuple(vec) => {
+                let mut state = serializer.serialize_tuple(vec.len())?;
 
-                    for v in vec {
-                        state.serialize_field(&v)?;
-                    }
-
-                    state.end()
+                for v in vec {
+                    state.serialize_element(&v)?;
                 }
-                None => {
-                    let mut state = serializer.serialize_tuple(vec.len())?;
-
-                    for v in vec {
-                        state.serialize_element(&v)?;
-                    }
 
-                    state.end()
-                }
-            },
+                state.end()
+            }
+            Value::UnitStructOrEnumVariant(cow) => todo!(),
+            Value::UnitEnumVariant(cow) => todo!(),
+            Value::UnitStruct(cow) => todo!(),
+            Value::StructOrEnumVariant(cow, map) => todo!(),
+            Value::EnumVariant(cow, map) => todo!(),
+            Value::EnumTuple(cow, vec) => todo!(),
         }
     }
 }
diff --git a/src/value/map.rs b/src/value/map.rs
@@ -17,20 +17,20 @@ use super::Value;
 /// to preserve the order of the parsed map.
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(transparent)]
-pub struct Map<Key: Ord>(pub(crate) MapInner<Key>);
+pub struct Map<Key: Ord + Hash>(pub(crate) MapInner<Key>);
 
 #[cfg(not(feature = "indexmap"))]
 type MapInner<Key> = std::collections::BTreeMap<Key, Value>;
 #[cfg(feature = "indexmap")]
 type MapInner<Key> = indexmap::IndexMap<Key, Value>;
 
-impl<Key: Ord> Default for Map<Key> {
+impl<Key: Ord + Hash> Default for Map<Key> {
     fn default() -> Self {
         Self(Default::default())
     }
 }
 
-impl<Key: Ord> Map<Key> {
+impl<Key: Ord + Hash> Map<Key> {
     /// Creates a new, empty [`Map`].
     #[must_use]
     pub fn new() -> Self {
@@ -122,7 +122,7 @@ impl<Key: Ord> Map<Key> {
     }
 }
 
-impl<Key: Ord> Index<&Key> for Map<Key> {
+impl<Key: Ord + Hash> Index<&Key> for Map<Key> {
     type Output = Value;
 
     #[allow(clippy::expect_used)]
@@ -131,14 +131,14 @@ impl<Key: Ord> Index<&Key> for Map<Key> {
     }
 }
 
-impl<Key: Ord> IndexMut<&Key> for Map<Key> {
+impl<Key: Ord + Hash> IndexMut<&Key> for Map<Key> {
     #[allow(clippy::expect_used)]
     fn index_mut(&mut self, index: &Key) -> &mut Self::Output {
         self.get_mut(index).expect("no entry found for key")
     }
 }
 
-impl<Key: Ord> IntoIterator for Map<Key> {
+impl<Key: Ord + Hash> IntoIterator for Map<Key> {
     type Item = (Key, Value);
 
     type IntoIter = <MapInner<Key> as IntoIterator>::IntoIter;
@@ -148,7 +148,7 @@ impl<Key: Ord> IntoIterator for Map<Key> {
     }
 }
 
-impl<Key: Ord, K: Into<Key>, V: Into<Value>> FromIterator<(K, V)> for Map<Key> {
+impl<Key: Ord + Hash, K: Into<Key>, V: Into<Value>> FromIterator<(K, V)> for Map<Key> {
     fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
         Map(iter
             .into_iter()
@@ -158,22 +158,22 @@ impl<Key: Ord, K: Into<Key>, V: Into<Value>> FromIterator<(K, V)> for Map<Key> {
 }
 
 /// Note: equality is only given if both values and order of values match
-impl<Key: Ord> PartialEq for Map<Key> {
+impl<Key: Ord + Hash> PartialEq for Map<Key> {
     fn eq(&self, other: &Map<Key>) -> bool {
         self.cmp(other).is_eq()
     }
 }
 
 /// Note: equality is only given if both values and order of values match
-impl<Key: Ord> Eq for Map<Key> {}
+impl<Key: Ord + Hash> Eq for Map<Key> {}
 
-impl<Key: Ord> PartialOrd for Map<Key> {
+impl<Key: Ord + Hash> PartialOrd for Map<Key> {
     fn partial_cmp(&self, other: &Map<Key>) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl<Key: Ord> Ord for Map<Key> {
+impl<Key: Ord + Hash> Ord for Map<Key> {
     fn cmp(&self, other: &Map<Key>) -> Ordering {
         self.iter().cmp(other.iter())
     }

diff --git a/src/value/mod.rs b/src/value/mod.rs
@@ -201,6 +201,14 @@ impl<'de> Deserializer<'de> for Value {
                 }
             }
             Value::Unit => visitor.visit_unit(),
+            Value::Tuple(vec) => todo!(),
+            Value::UnitStructOrEnumVariant(cow) => todo!(),
+            Value::UnitEnumVariant(cow) => todo!(),
+            Value::UnitStruct(cow) => todo!(),
+            Value::StructOrEnumVariant(cow, map) => todo!(),
+            Value::Struct(cow, map) => todo!(),
+            Value::EnumVariant(cow, map) => todo!(),
+            Value::EnumTuple(cow, vec) => todo!(),
         }
     }
 }
@@ -514,6 +522,24 @@ mod tests {
         );
     }
 
+    #[test]
+    fn empty_struct() {
+        #[derive(Debug, Deserialize, PartialEq)]
+        struct A {}
+        assert_same::<A>("A()");
+    }
+
+    #[test]
+    fn simple_enum() {
+        #[derive(Debug, Deserialize, PartialEq)]
+        enum A {
+            A,
+        }
+
+        assert_same::<A>("A");
+    }
+
+    #[ignore = ""]
     #[test]
     fn test() {
         #[derive(Serialize)]
@@ -548,6 +574,7 @@ mod tests {
         assert_eq!(ron_str, ron_str2);
     }
 
+    #[ignore = ""]
     #[test]
     fn test2() {
         #[derive(Serialize)]