serde serialize_with support

[dakaizou]

I'm submitting a feature

Description

Adds the ability to serialize a Uuid as a Simple/Urn/Braced. Uuid::parse_str deserialize them correctly, but Uuid is always serialized as Hyphenated. Users would be able to decide which format to serialize to after this PR.

Example:

#[derive(serde_derive::Serialize)]
struct Struct {
    // This will be serialize as uuid::fmt::Simple
    #[serde(serialize_with = "uuid::serde::simple")]
    id: uuid::Uuid,
}

Tests

3 new tests for the feature were added.

crate::external::serde_support::serde_tests::test_serialize_as_simple
crate::external::serde_support::serde_tests::test_serialize_as_braced
crate::external::serde_support::serde_tests::test_serialize_as_urn

Related Issue(s)

• Using de/serialize_with inside of an Option, Map, Vec serde-rs/serde#723
  Before this issue is resolved, types like Option<Uuid> require their own functions to be serialized correctly.

[KodrAus]

Nice! This looks good to me @dakaizou.

I don't think we need to do deserialize_with support, since the parser will very quickly identify the appropriate format to use. We can also add deserialize support in a non-breaking way in the future if we want to.

[KodrAus]

Actually, having another look at the existing compact module, I think we should follow the same pattern here. Instead of top-level functions in uuid::serde, let's use modules with a serialize and deserialize function in them.

[dakaizou]

... I don't think we need to do deserialize_with support, since the parser will very quickly identify the appropriate format to use. ...

This was exactly what I was thinking, since they can all be deserialized with Uuid::deserialize, I only created functions for serialization.

I think we should follow the same pattern here. Instead of top-level functions in uuid::serde, let's use modules with a serialize and deserialize function in them.

compact::deserialize only deserializes [u8; 16], so it makes sense to put them in a mod for #[serde(with="compact")].
For Simple/Braced/Urn, do you think it's better to follow the same pattern? (e.g. rejecting the Braced format from Simple's deserialize)

If not, I will just proxy the function call:

pub fn deserialize<'de, D>(deserializer: D) -> Result<crate::Uuid, D::Error>
where
    D: serde::Deserializer<'de>,
{
    serde::Deserialize::deserialize(deserializer)
}

[KodrAus]

For Simple/Braced/Urn, do you think it's better to follow the same pattern? (e.g. rejecting the Braced format from Simple's deserialize)

I think we should only parse exactly the format requested. It looks like we don't have exposed methods for specific parsers, but we could make them pub(crate) and use those for these methods. I think it'll be more performant and align better with expectations that way.

[dakaizou]

• change the return type of parse_simple and parse_hyphenated, so InvalidUuid is returned instead of ()
• create two more methods in parser: parse_braced, parsed_urn
• fix the error returned by visit_seq in Uuid::deserialize
• create simple, braced, urn mod in serde_support

[KodrAus]

Thanks for putting this together @dakaizou! This is some great work 🙂