use str::from_utf8 instead of String

Main change: use `str::from_utf8` instead of `String::from_utf8`
wherever possible. This will avoid unnecessary allocations.

This also allowed direct usage of `&[u8]` instead of `Vec<u8>` in
multiple places, for additional efficiency.

Breaking Change: Removed (undocumented) `to_utf8_lossy` function since
we only plan to support valid utf8 data for ease of use. We might
introduce another serializer / deserializer that can handle arbitrary
bytes later on, but this should be clear that it uses another
implementation altogether.

Author: ofersadan85

Cargo.lock

@@ -14,7 +14,7 @@ documentation = "https://docs.rs/rediserde"
 keywords = ["resp", "redis", "serde", "serialization"]
 license-file = "LICENSE"
 
-version = "0.1.1"
+version = "0.2.0"
 edition = "2024"
 
 [dependencies]

Cargo.toml

@@ -55,7 +55,9 @@ Use this crate like any other serde-compatible crate (like `serde_json` or `serd
 
     let serialized = to_string(&person).unwrap();
     let deserialized: Person = from_str(&serialized).unwrap();
+    let deserialized_raw: Person = from_str("%2\r\n+name\r\n+Alice\r\n+age\r\n:30\r\n").unwrap();
     assert_eq!(deserialized, person);
+    assert_eq!(deserialized_raw, person);
 ```
 
 For a more complex example, see the [tests/structs.rs](tests/structs.rs) file.

README.md

@@ -66,7 +66,7 @@ impl<'de> Deserializer<'de> {
             .iter()
             .position(|&b| !b.is_ascii_digit())
             .ok_or(Error::ExpectedLength)?;
-        let length_str = String::from_utf8(self.input[..first_non_numeric].to_vec())
+        let length_str = str::from_utf8(&self.input[..first_non_numeric])
             .map_err(|_| Error::ExpectedLength)?;
         self.input = &self.input[first_non_numeric..];
         let length = length_str
@@ -75,7 +75,7 @@ impl<'de> Deserializer<'de> {
         Ok(length)
     }
 
-    fn parse_string(&mut self) -> Result<String> {
+    fn parse_string(&mut self) -> Result<&str> {
         let first = self.next_byte()?;
         let kind = RespDataKind::try_from(first).map_err(|()| Error::UnrecognizedStart)?;
         let result = match kind {
@@ -95,7 +95,7 @@ impl<'de> Deserializer<'de> {
         Ok(result)
     }
 
-    fn parse_simple_string(&mut self) -> Result<String> {
+    fn parse_simple_string(&mut self) -> Result<&str> {
         let crlf_index = self.input.windows(2).position(|w| w == CRLF);
         let result = if let Some(index) = crlf_index {
             let result = &self.input[..index];
@@ -108,20 +108,20 @@ impl<'de> Deserializer<'de> {
             return Err(Error::UnexpectedEnd);
         }
         self.expect_crlf()?;
-        Ok(String::from_utf8(result.to_vec())?)
+        Ok(str::from_utf8(result)?)
     }
 
-    fn parse_bulk_string(&mut self) -> Result<String> {
+    fn parse_bulk_string(&mut self) -> Result<&str> {
         if self.input.starts_with(b"-1\r\n") {
             self.input = &self.input[4..]; // Skip -1\r\n
-            return Ok(String::new()); // Null string
+            return Ok(""); // Null string
         }
         let length = self.expect_length()?;
         self.expect_crlf()?;
         let data = &self.input[..length];
         self.input = &self.input[length..];
         self.expect_crlf()?;
-        Ok(String::from_utf8(data.to_vec())?)
+        Ok(str::from_utf8(data)?)
     }
 
     /// Parse an number from the RESP format.
@@ -148,7 +148,7 @@ impl<'de> Deserializer<'de> {
             .iter()
             .position(|b| !VALID_NUMERIC_CHARS.contains(b))
             .ok_or(Error::UnexpectedEnd)?;
-        let value_str = String::from_utf8(self.input[..non_numeric_index].to_vec())?;
+        let value_str = str::from_utf8(&self.input[..non_numeric_index])?;
         self.input = &self.input[non_numeric_index..];
         let value = value_str.parse::<N>().map_err(|_| Error::UnexpectedByte {
             expected: "A valid integer string".to_string(),
@@ -314,15 +314,16 @@ impl<'de> serde::de::Deserializer<'de> for &mut Deserializer<'de> {
     where
         V: serde::de::Visitor<'de>,
     {
-        self.deserialize_string(visitor)
+        let s = self.parse_string()?;
+        visitor.visit_str(s)
     }
 
     fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
     where
         V: serde::de::Visitor<'de>,
     {
         let s = self.parse_string()?;
-        visitor.visit_string(s)
+        visitor.visit_string(s.to_string())
     }
 
     fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
@@ -346,9 +347,7 @@ impl<'de> serde::de::Deserializer<'de> for &mut Deserializer<'de> {
     ///
     /// As commented in `Serializer` implementation, this is a lossy
     /// representation. For example the values `Some(())` and `None` both
-    /// serialize as just `null`. Unfortunately this is typically what people
-    /// expect when working with JSON. Other formats are encouraged to behave
-    /// more intelligently if possible.
+    /// serialize as just `null`.
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
     where
         V: serde::de::Visitor<'de>,
@@ -416,7 +415,7 @@ impl<'de> serde::de::Deserializer<'de> for &mut Deserializer<'de> {
         visitor.visit_seq(seq_visitor)
     }
 
-    // Tuples look just like sequences in JSON. Some formats may be able to
+    // Tuples look just like sequences. Some formats may be able to
     // represent tuples more efficiently.
     //
     // As indicated by the length parameter, the `Deserialize` implementation
@@ -429,7 +428,7 @@ impl<'de> serde::de::Deserializer<'de> for &mut Deserializer<'de> {
         self.deserialize_seq(visitor)
     }
 
-    // Tuple structs look just like sequences in JSON.
+    // Tuple structs look just like sequences.
     fn deserialize_tuple_struct<V>(
         self,
         _name: &'static str,
@@ -502,7 +501,7 @@ impl<'de> serde::de::Deserializer<'de> for &mut Deserializer<'de> {
             | RespDataKind::VerbatimString => {
                 // Visit a unit variant.
                 let s = self.parse_string()?;
-                visitor.visit_enum(s.as_str().into_deserializer())
+                visitor.visit_enum(s.into_deserializer())
             }
             RespDataKind::Map | RespDataKind::Attributes => {
                 visitor.visit_enum(EnumDeserializer::new(self))
@@ -515,9 +514,8 @@ impl<'de> serde::de::Deserializer<'de> for &mut Deserializer<'de> {
     }
 
     // An identifier in Serde is the type that identifies a field of a struct or
-    // the variant of an enum. In JSON, struct fields and enum variants are
-    // represented as strings. In other formats they may be represented as
-    // numeric indices.
+    // the variant of an enum. Struct fields and enum variants are
+    // represented as strings.
     fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
     where
         V: serde::de::Visitor<'de>,
@@ -664,7 +662,7 @@ impl<'de> serde::de::VariantAccess<'de> for EnumDeserializer<'_, 'de> {
         ))
     }
 
-    // Newtype variants are represented in JSON as `{ NAME: VALUE }` so
+    // Newtype variants are represented as `{ NAME: VALUE }` so
     // deserialize the value here.
     fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
     where
@@ -673,7 +671,7 @@ impl<'de> serde::de::VariantAccess<'de> for EnumDeserializer<'_, 'de> {
         seed.deserialize(self.de)
     }
 
-    // Tuple variants are represented in JSON as `{ NAME: [DATA...] }` so
+    // Tuple variants are represented as `{ NAME: [DATA...] }` so
     // deserialize the sequence of data here.
     fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
     where
@@ -682,7 +680,7 @@ impl<'de> serde::de::VariantAccess<'de> for EnumDeserializer<'_, 'de> {
         serde::de::Deserializer::deserialize_seq(self.de, visitor)
     }
 
-    // Struct variants are represented in JSON as `{ NAME: { K: V, ... } }` so
+    // Struct variants are represented as `{ NAME: { K: V, ... } }` so
     // deserialize the inner map here.
     fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
     where

src/de.rs

@@ -1,4 +1,4 @@
-use std::string::FromUtf8Error;
+use std::{str::Utf8Error, string::FromUtf8Error};
 
 #[derive(Debug, Clone)]
 pub enum Error {
@@ -58,3 +58,9 @@ impl From<FromUtf8Error> for Error {
         Self::InvalidUtf8
     }
 }
+
+impl From<Utf8Error> for Error {
+    fn from(_err: Utf8Error) -> Self {
+        Self::InvalidUtf8
+    }
+}

src/error.rs

@@ -27,6 +27,9 @@
 //!
 //! let serialized = to_string(&person).unwrap();
 //! let deserialized: Person = from_str(&serialized).unwrap();
+//! let deserialized_raw: Person = from_str("%2\r\n+name\r\n+Alice\r\n+age\r\n:30\r\n").unwrap();
+//! assert_eq!(deserialized, person);
+//! assert_eq!(deserialized_raw, person);
 //! assert_eq!(deserialized, person);
 //! ```
 //!
@@ -50,7 +53,7 @@ mod ser;
 pub use de::{Deserializer, from_bytes, from_str};
 pub use error::{Error, Result};
 pub use resp::RespDataKind;
-pub use ser::{Serializer, to_bytes, to_string, to_utf8_lossy};
+pub use ser::{Serializer, to_bytes, to_string};
 
 pub const CRLF: &[u8] = b"\r\n";
 pub const CRLF_STR: &str = "\r\n";

src/lib.rs

@@ -238,9 +238,12 @@ pub enum RespDataKind {
     ///     name: "Alice".to_string(),
     ///     age: 30,
     /// };
+    ///
     /// let serialized = to_string(&person).unwrap();
     /// let deserialized: Person = from_str(&serialized).unwrap();
+    /// let deserialized_raw: Person = from_str("%2\r\n+name\r\n+Alice\r\n+age\r\n:30\r\n").unwrap();
     /// assert_eq!(deserialized, person);
+    /// assert_eq!(deserialized_raw, person);
     /// ```
     ///
     /// And an arbitrary map example:
@@ -255,8 +258,8 @@ pub enum RespDataKind {
     ///
     /// let serialized = to_string(&map).unwrap();
     /// assert_eq!(serialized, "%2\r\n$10\r\nfirst_name\r\n$5\r\nAlice\r\n$9\r\nlast_name\r\n$5\r\nSmith\r\n");
-    /// let deserialized_hashmap: HashMap<String, String> = from_str(&serialized).unwrap();
-    /// assert_eq!(deserialized_hashmap.len(), map.len()); // We only check length here because order is not guaranteed
+    /// // Note that the order of keys is not guaranteed in HashMap, so we use BTreeMap for testing
+    /// // But in principle serialization / deserialization should work with HashMap as well
     /// let deserialized_bt: BTreeMap<String, String> = from_str(&serialized).unwrap();
     /// assert_eq!(deserialized_bt.len(), 2);
     /// ```

src/resp.rs

@@ -30,15 +30,6 @@ where
     Ok(serializer.output)
 }
 
-pub fn to_utf8_lossy<T>(value: &T) -> Result<String>
-where
-    T: serde::Serialize,
-{
-    let mut serializer = Serializer::new();
-    value.serialize(&mut serializer)?;
-    Ok(String::from_utf8_lossy(&serializer.output).into_owned())
-}
-
 pub fn to_string<T>(value: &T) -> Result<String>
 where
     T: serde::Serialize,

src/ser.rs

@@ -81,5 +81,7 @@ fn simple() {
     };
     let serialized = to_string(&person).unwrap();
     let deserialized: Person = from_str(&serialized).unwrap();
+    let deserialized_raw: Person = from_str("%2\r\n+name\r\n+Alice\r\n+age\r\n:30\r\n").unwrap();
     assert_eq!(deserialized, person);
+    assert_eq!(deserialized_raw, person);
 }