Add BString implementation

Cargo.toml

@@ -21,7 +21,6 @@ rust-version = "1.36.0"
 
 [dependencies]
 serde = {version = "1", default-features = false }
-serde_bytes = { version = "0.11", default-features = false }
 itoa = {version = "1", default-features = false }
 
 [dev-dependencies]
@@ -31,9 +30,9 @@ sha1 = "0.10.1"
 [features]
 default = ["std"]
 
-std = ["serde/std", "serde_bytes/std"]
+std = ["serde/std"]
 
-alloc = ["serde/alloc", "serde_bytes/alloc"]
+alloc = ["serde/alloc"]
 
 [package.metadata.docs.rs]
 all-features = true

src/bstring.rs

@@ -0,0 +1,162 @@
+//! Byte string which helps with the deserialization.
+
+use core::{
+    borrow::{Borrow, BorrowMut},
+    cmp, fmt,
+    ops::{Deref, DerefMut},
+};
+
+use serde::{
+    de::{SeqAccess, Visitor},
+    Deserialize, Deserializer,
+};
+
+/// Byte string.
+///
+/// Bencoded "strings" are not necessarily UTF-8 encoded values.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct BString(Vec<u8>);
+
+impl AsRef<[u8]> for BString {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl AsMut<[u8]> for BString {
+    fn as_mut(&mut self) -> &mut [u8] {
+        &mut self.0
+    }
+}
+
+impl Borrow<[u8]> for BString {
+    fn borrow(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl BorrowMut<[u8]> for BString {
+    fn borrow_mut(&mut self) -> &mut [u8] {
+        &mut self.0
+    }
+}
+
+impl fmt::Debug for BString {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+impl Deref for BString {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for BString {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<'a> From<&'a [u8]> for BString {
+    fn from(value: &'a [u8]) -> Self {
+        Self(Vec::from(value))
+    }
+}
+
+impl<'a> From<&'a str> for BString {
+    fn from(value: &'a str) -> Self {
+        Self(Vec::from(value))
+    }
+}
+
+impl From<String> for BString {
+    fn from(value: String) -> Self {
+        Self(Vec::from(value))
+    }
+}
+
+impl From<Vec<u8>> for BString {
+    fn from(value: Vec<u8>) -> Self {
+        Self(value)
+    }
+}
+
+impl serde::Serialize for BString {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_bytes(&self.0)
+    }
+}
+
+struct BStringVisitor;
+
+impl<'de> Visitor<'de> for BStringVisitor {
+    type Value = BString;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("byte string")
+    }
+
+    fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
+    where
+        V: SeqAccess<'de>,
+    {
+        let capacity = cmp::min(visitor.size_hint().unwrap_or_default(), 4096);
+        let mut bytes = Vec::with_capacity(capacity);
+
+        while let Some(b) = visitor.next_element()? {
+            bytes.push(b);
+        }
+
+        Ok(BString::from(bytes))
+    }
+
+    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> {
+        Ok(BString::from(v))
+    }
+
+    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(BString::from(v))
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(BString::from(v))
+    }
+
+    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(BString::from(v))
+    }
+}
+
+impl<'de> Deserialize<'de> for BString {
+    fn deserialize<D>(deserializer: D) -> Result<BString, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_byte_buf(BStringVisitor)
+    }
+}
+
+impl BString {
+    /// Returns the inner vector.
+    #[inline]
+    #[must_use]
+    pub fn into_vec(self) -> Vec<u8> {
+        self.0
+    }
+}

src/de.rs

@@ -609,8 +609,9 @@ where
 
 #[cfg(test)]
 mod tests {
+    use crate::BString;
+
     use super::*;
-    use serde_bytes::ByteBuf;
     use serde_derive::Deserialize;
 
     #[cfg(all(feature = "alloc", not(feature = "std")))]
@@ -834,23 +835,23 @@ mod tests {
     #[test]
     fn test_deserialize_integer_as_raw_bytes() -> Result<()> {
         #[derive(Debug, PartialEq, Deserialize)]
-        struct S(ByteBuf);
+        struct S(BString);
 
         let input = "i-1234e";
         let s: S = from_slice(input.as_bytes())?;
-        let expected = S(ByteBuf::from(input.as_bytes().to_vec()));
+        let expected = S(BString::from(input.as_bytes().to_vec()));
         assert_eq!(s, expected);
         Ok(())
     }
 
     #[test]
     fn test_deserialize_list_as_raw_bytes() -> Result<()> {
         #[derive(Debug, PartialEq, Deserialize)]
-        struct S(ByteBuf);
+        struct S(BString);
 
         let input = "l4:spam4:eggse";
         let s: S = from_slice(input.as_bytes())?;
-        let expected = S(ByteBuf::from(input.as_bytes().to_vec()));
+        let expected = S(BString::from(input.as_bytes().to_vec()));
         assert_eq!(s, expected);
         Ok(())
     }
@@ -859,13 +860,13 @@ mod tests {
     fn test_deserialize_map_value_as_raw_bytes() -> Result<()> {
         #[derive(Debug, PartialEq, Deserialize)]
         struct S {
-            spam: ByteBuf,
+            spam: BString,
         }
 
         let input = "d4:spamd1:a1:bee";
         let s: S = from_slice(input.as_bytes())?;
         let expected = S {
-            spam: ByteBuf::from(b"d1:a1:be".to_vec()),
+            spam: BString::from(b"d1:a1:be".to_vec()),
         };
         assert_eq!(s, expected);
         Ok(())
@@ -874,11 +875,11 @@ mod tests {
     #[test]
     fn test_deserialize_map_as_raw_bytes() -> Result<()> {
         #[derive(Debug, PartialEq, Deserialize)]
-        struct S(ByteBuf);
+        struct S(BString);
 
         let input = "d4:spamd1:a1:bee";
         let s: S = from_slice(input.as_bytes())?;
-        let expected = S(ByteBuf::from(input.as_bytes().to_vec()));
+        let expected = S(BString::from(input.as_bytes().to_vec()));
         assert_eq!(s, expected);
         Ok(())
     }

src/lib.rs

@@ -105,6 +105,7 @@ extern crate alloc;
 #[macro_use]
 extern crate serde;
 
+mod bstring;
 mod de;
 mod error;
 
@@ -114,6 +115,8 @@ pub mod write;
 mod ser;
 pub mod value;
 
+#[doc(inline)]
+pub use bstring::BString;
 #[doc(inline)]
 pub use de::{from_slice, Deserializer};
 #[doc(inline)]

src/read.rs

@@ -50,7 +50,7 @@ pub trait Read<'a> {
 
     /// Returns the next byte but does not consume.
     ///
-    /// Repeated peeks (with no [next()][Read::next] call) should return the same byte.
+    /// Repeated peeks (with no [`next()`][Read::next] call) should return the same byte.
     fn peek(&mut self) -> Option<Result<u8>>;
 
     /// Returns the position in the stream of bytes.

src/ser.rs

@@ -636,8 +636,9 @@ impl<'a> ser::Serializer for &'a mut MapKeySerializer {
 
 #[cfg(test)]
 mod tests {
+    use crate::BString;
+
     use super::*;
-    use serde_bytes::ByteBuf;
 
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     use alloc::{format, string::String, vec};
@@ -772,7 +773,7 @@ mod tests {
 
     #[test]
     fn test_serialize_bytes() {
-        let value = ByteBuf::from(String::from("123").into_bytes());
+        let value = BString::from(String::from("123").into_bytes());
         assert_eq!(to_vec(&&value).unwrap(), String::from("3:123").into_bytes());
     }