The main use I'd have for this crate is to version config files (as described in the readme) but there doesn't currently appear to be a mechanism for attempting to attempt to parse as any version (in order to then upgrade it).

Currently it requires something along the lines of:

let x: Foo  = toml::from_str(content)
    .map(<Foo as obake::Versioned>::Versioned::Foo_v0_2_0)
    .or_else(|_| {
        toml::from_str(content)
            .map(<Foo as obake::Versioned>::Versioned::Foo_v0_1_0)
    })?
    .into();

This ofc gets a bit repetitive (the above is only 2 versions!) and while it would require a bit of special-casing, it'd be preferable for the above to be possible to derive serde traits for the Versioned enum.

Alternatively you could provide a mechanism for running a function polymorphic over its return type over each version in sequence until one returns Ok.

This could look something like:

let x = Foo::for_all_versions(toml::from_str)(content)?;

Also worth noting (as I'm sure you're away) that if you derive serde traits for the enum using #[obake(derive(Serialize, Deserialize))] it will ofc expect you to describe an version such as:

[Foo_v0_1_0]
foo = 'foo'
baz = 'x'

hi, this is a pretty nice crate :)

clippy is warning about the generated enum variant names once a struct has three or more versions. this pr is just silencing clippy at the respective place, it would be awesome to get a new release with this addition!

I believe it would be desirable to provide an alias such as:

pub type AnyVersion<T> = <T as obake::Versioned>::Versioned;

reasoning:

• less eye-sore
• "reads" better, making it easier for new users to understand
• removes redundancy of typing out "Versioned" twice, which honestly took me all of 5 minutes to get sick of :P

Willing to PR such a change but didn't want to so without first seeing if it's desirable. Name is just the first thing I thought of and ultimately not important if you have one in mind.

Hi! This library is so useful, but I'm failing to use it with serde_json. I've tried the following way:

use serde_json::json;
use obake;

#[obake::versioned]
#[obake(version("0.1.0"))]
#[obake(version("0.2.0"))]
#[obake(version("0.3.0"))]
#[obake(derive(Debug, PartialEq, serde::Serialize, serde::Deserialize))]
#[obake(serde(untagged))]
#[derive(Debug, Default, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
struct Character {
    name: String,
    age: u32,
    #[obake(cfg(">=0.2.0"))]
    height: f32,
    #[obake(cfg(">=0.3.0"))]
    weight: f32,
}

impl From<Character!["0.1.0"]> for Character!["0.2.0"] {
    fn from(old: Character!["0.1.0"]) -> Self {
        Self {
            name: old.name,
            age: old.age,
            ..Default::default()
        }
    }
}

impl From<Character!["0.2.0"]> for Character!["0.3.0"] {
    fn from(old: Character!["0.2.0"]) -> Self {
        Self {
            name: old.name,
            age: old.age,
            height: old.height,
            ..Default::default()
        }
    }
}

fn main() {}

#[cfg(test)]
mod tests {
    use serde_json::json;
    use crate::*;

    #[test]
    fn from_2_to_3() {
        let freeza_ser = serde_json::to_string_pretty(&json!({
            "name": "Freeza",
            "age": 32,
            "height": 1.53,
        })).unwrap();
        dbg!(&freeza_ser);

        let freeza: VersionedCharacter = serde_json::from_str(&freeza_ser).unwrap();
        dbg!(&freeza);
        let freeza: Character = freeza.into();
        dbg!(&freeza);

        let freeza_expected = Character {
            name: "Freeza".into(),
            age: 32,
            height: 1.53,
            weight: 0.,
        };
        assert_eq!(&freeza_expected, &freeza);
    }
}

The output is:

failures:

---- tests::from_2_to_3 stdout ----
[src/main.rs:56] &freeza_ser = "{\n  \"age\": 32,\n  \"height\": 1.53,\n  \"name\": \"Freeza\"\n}"
[src/main.rs:59] &freeza = Character_v0_1_0(
    Character_v0_1_0 {
        name: "Freeza",
        age: 32,
    },
)
[src/main.rs:61] &freeza = Character_v0_3_0 {
    name: "Freeza",
    age: 32,
    height: 0.0,
    weight: 0.0,
}
thread 'tests::from_2_to_3' panicked at 'assertion failed: `(left == right)`
  left: `Character_v0_3_0 { name: "Freeza", age: 32, height: 1.53, weight: 0.0 }`,
 right: `Character_v0_3_0 { name: "Freeza", age: 32, height: 0.0, weight: 0.0 }`', src/main.rs:69:9

So, the current behavior is that serde_json::from_str::<VersionedCharacter>(&freeza_ser) is deserializing into the first version, and I want it to deserialize like the following:

fn character_parser(serialized_data: &String) -> Character {
    if let Ok(data) = serde_json::from_str::<Character!["0.3.0"]>(&serialized_data) {
        return data;
    }

    if let Ok(data) = serde_json::from_str::<Character!["0.2.0"]>(&serialized_data) {
        let data: Character!["0.3.0"] = data.into();
        return data;
    }

    if let Ok(data) = serde_json::from_str::<Character!["0.1.0"]>(&serialized_data) {
        let data: Character!["0.2.0"] = data.into();
        let data: Character!["0.3.0"] = data.into();
        return data;
    }

    return Character::default();
}

Am I missing something crucial here? Is there any way for this lib to implement that parsing automatically?

Thank you!