Add support for bincode v2.0

Author: francis-spliced

Cargo.toml

@@ -29,17 +29,17 @@ homepage = "https://github.com/uuid-rs/uuid"
 name = "uuid"
 readme = "README.md"
 repository = "https://github.com/uuid-rs/uuid"
-version = "1.16.0" # remember to update html_root_url in lib.rs
+version = "1.16.1" # remember to update html_root_url in lib.rs
 rust-version = "1.63.0"
 
 [package.metadata.docs.rs]
 rustc-args = ["--cfg", "uuid_unstable"]
 rustdoc-args = ["--cfg", "uuid_unstable"]
 targets = ["x86_64-unknown-linux-gnu"]
-features = ["serde", "arbitrary", "slog", "borsh", "v1", "v3", "v4", "v5", "v6", "v7", "v8"]
+features = ["serde", "bincode", "arbitrary", "slog", "borsh", "v1", "v3", "v4", "v5", "v6", "v7", "v8"]
 
 [package.metadata.playground]
-features = ["serde", "v1", "v3", "v4", "v5", "v6", "v7", "v8"]
+features = ["serde", "bincode", "v1", "v3", "v4", "v5", "v6", "v7", "v8"]
 
 [lints.rust]
 unexpected_cfgs = { level = "allow", check-cfg = ['cfg(uuid_unstable)'] }
@@ -94,6 +94,12 @@ default-features = false
 optional = true
 version = "1.0.56"
 
+# Public: Used in trait impls on `Uuid`
+[dependencies.bincode]
+default-features = false
+optional = true
+version = "2.0.1"
+
 # Public: Used in trait impls on `Uuid`
 [dependencies.slog]
 optional = true
@@ -179,7 +185,7 @@ version = "0.3"
 optional = true
 
 [dev-dependencies.bincode]
-version = "1.0"
+version = "2.0.1"
 
 [dev-dependencies.serde_derive]
 version = "1.0.79"

src/external.rs

@@ -1,5 +1,7 @@
 #[cfg(feature = "arbitrary")]
 pub(crate) mod arbitrary_support;
+#[cfg(feature = "bincode")]
+pub(crate) mod bincode_support;
 #[cfg(feature = "borsh")]
 pub(crate) mod borsh_support;
 #[cfg(feature = "serde")]

src/external/bincode_support.rs

@@ -0,0 +1,215 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::{
+    convert::TryFrom,
+    fmt::{Braced, Hyphenated, Simple, Urn},
+    non_nil::NonNilUuid,
+    Uuid,
+};
+use bincode::{
+    de::{BorrowDecoder, Decoder},
+    enc::Encoder,
+    error::{DecodeError, EncodeError},
+    Decode, Encode,
+};
+use std::string::ToString;
+
+impl Encode for Uuid {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        Encode::encode(self.as_bytes(), encoder)
+    }
+}
+
+impl Encode for NonNilUuid {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        let uuid = Uuid::from(*self);
+
+        Encode::encode(uuid.as_bytes(), encoder)
+    }
+}
+
+impl Encode for Hyphenated {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        Encode::encode(self.as_uuid().as_bytes(), encoder)
+    }
+}
+
+impl Encode for Simple {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        Encode::encode(self.as_uuid().as_bytes(), encoder)
+    }
+}
+
+impl Encode for Urn {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        Encode::encode(self.as_uuid().as_bytes(), encoder)
+    }
+}
+
+impl Encode for Braced {
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        Encode::encode(self.as_uuid().as_bytes(), encoder)
+    }
+}
+
+impl<Context> Decode<Context> for Uuid {
+    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
+        Ok(Uuid::from_bytes(Decode::decode(decoder)?))
+    }
+}
+impl<'de, Context> bincode::BorrowDecode<'de, Context> for Uuid {
+    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
+        decoder: &mut D,
+    ) -> core::result::Result<Self, bincode::error::DecodeError> {
+        Ok(Uuid::from_bytes(Decode::decode(decoder)?))
+    }
+}
+
+impl<Context> Decode<Context> for NonNilUuid {
+    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
+        let uuid = Uuid::decode(decoder)?;
+
+        NonNilUuid::try_from(uuid).map_err(|e| DecodeError::OtherString(e.to_string()))
+    }
+}
+impl<'de, Context> bincode::BorrowDecode<'de, Context> for NonNilUuid {
+    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
+        decoder: &mut D,
+    ) -> core::result::Result<Self, bincode::error::DecodeError> {
+        let uuid = Uuid::decode(decoder)?;
+
+        NonNilUuid::try_from(uuid).map_err(|e| DecodeError::OtherString(e.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod bincode_tests {
+    use super::*;
+    use bincode::config;
+
+    #[test]
+    fn test_encode_readable_string() {
+        let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
+        let u = Uuid::parse_str(uuid_str).unwrap();
+
+        bincode::encode_to_vec(&u, config::standard())
+            .expect(&format!("Failed to encode {uuid_str}."));
+    }
+
+    #[test]
+    fn test_encode_hyphenated() {
+        let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
+        let u = Uuid::parse_str(uuid_str).unwrap();
+
+        bincode::encode_to_vec(&u, config::standard())
+            .expect(&format!("Failed to encode {uuid_str}."));
+    }
+
+    #[test]
+    fn test_encode_simple() {
+        let uuid_str = "f9168c5eceb24faab6bf329bf39fa1e4";
+        let u = Uuid::parse_str(uuid_str).unwrap();
+
+        bincode::encode_to_vec(&u, config::standard())
+            .expect(&format!("Failed to encode {uuid_str}."));
+    }
+
+    #[test]
+    fn test_encode_urn() {
+        let uuid_str = "urn:uuid:f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
+        let u = Uuid::parse_str(uuid_str).unwrap();
+
+        bincode::encode_to_vec(&u, config::standard())
+            .expect(&format!("Failed to encode {uuid_str}."));
+    }
+
+    #[test]
+    fn test_encode_braced() {
+        let uuid_str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}";
+        let u = Uuid::parse_str(uuid_str).unwrap();
+
+        bincode::encode_to_vec(&u, config::standard())
+            .expect(&format!("Failed to encode {uuid_str}."));
+    }
+
+    #[test]
+    fn test_encode_non_human_readable() {
+        let uuid_bytes = b"F9168C5E-CEB2-4F";
+        let u = Uuid::from_slice(uuid_bytes).unwrap();
+
+        bincode::encode_to_vec(&u, config::standard())
+            .expect(&format!("{:?} failed to encode.", uuid_bytes));
+    }
+
+    #[test]
+    fn test_decode() {
+        let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
+        let u = Uuid::parse_str(uuid_str).unwrap();
+
+        let bytes = bincode::encode_to_vec(&u, config::standard())
+            .expect(&format!("Failed to encode {uuid_str}."));
+
+        let (decoded_uuid, decoded_size) =
+            bincode::decode_from_slice::<Uuid, _>(&bytes, config::standard())
+                .expect(&format!("Failed to decode {bytes:?}."));
+
+        assert_eq!(u, decoded_uuid);
+        assert_eq!(16, decoded_size);
+    }
+
+    #[test]
+    fn test_decode_failure() {
+        let bytes = "hello_world".as_bytes();
+        let error = bincode::decode_from_slice::<Uuid, _>(bytes, config::standard())
+            .expect_err(&format!("Should not have been able to decode {bytes:?}."));
+
+        match error {
+            DecodeError::UnexpectedEnd { additional: 5 } => {}
+            _ => panic!("Unexpected error"),
+        }
+    }
+
+    #[test]
+    fn test_decode_non_nil_uuid() {
+        let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
+        let uuid = Uuid::parse_str(uuid_str).unwrap();
+
+        let bytes = bincode::encode_to_vec(&uuid, config::standard())
+            .expect(&format!("Failed to encode {uuid_str}."));
+
+        let (decoded_uuid, decoded_size) =
+            bincode::decode_from_slice::<NonNilUuid, _>(&bytes, config::standard()).expect(
+                &format!("Should have been able to decode {bytes:?} to NonNilUuid."),
+            );
+
+        assert_eq!(uuid, decoded_uuid);
+        assert_eq!(16, decoded_size);
+    }
+
+    #[test]
+    fn test_decode_nil_uuid() {
+        let uuid = Uuid::nil();
+
+        let bytes = bincode::encode_to_vec(&uuid, config::standard())
+            .expect(&format!("Failed to encode {}.", uuid.to_string()));
+
+        let error = bincode::decode_from_slice::<NonNilUuid, _>(&bytes, config::standard())
+            .expect_err(&format!(
+                "Should not have been able to decode {bytes:?} to NonNilUuid."
+            ));
+
+        match error {
+            DecodeError::OtherString(s) if s == "the UUID is nil" => {}
+            _ => panic!("Unexpected error"),
+        }
+    }
+}

src/lib.rs

@@ -212,7 +212,7 @@
 #![doc(
     html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
     html_favicon_url = "https://www.rust-lang.org/favicon.ico",
-    html_root_url = "https://docs.rs/uuid/1.16.0"
+    html_root_url = "https://docs.rs/uuid/1.16.1"
 )]
 
 #[cfg(any(feature = "std", test))]