validatable 0.1.0

Define validated data types once and share them between the frontend and backend of isomorphic Rust web applications, with plain, input, and form representations
Documentation
#[allow(dead_code)]
mod prelude_shadowed {
    pub mod std {}
    pub mod core {}
    pub struct From;
    pub struct Into;
    pub struct Option;
    pub struct Some;
    pub struct None;
    pub struct Result;
    pub struct Ok;
    pub struct Err;
    pub struct Default;

    #[derive(PartialEq, Clone, Debug, validatable::Validatable)]
    pub struct Person<F: validatable::FieldFamily> {
        pub age: validatable::Field<F, u32>,
        pub name: validatable::Field<F, String>,
        pub fixed: i32,
        pub score: validatable::Field<F, ::core::option::Option<i32>>,
    }

    #[derive(PartialEq, Clone, Debug, validatable::Validatable)]
    pub enum Choice<F: validatable::FieldFamily> {
        One(validatable::Field<F, u32>),
        Two { name: validatable::Field<F, String> },
        Three,
    }

    #[derive(PartialEq, Clone, Debug, validatable::Validatable)]
    pub struct Wrapped(pub u32);

    #[derive(PartialEq, Clone, Debug, validatable::Validatable)]
    #[validatable(custom_validate)]
    pub struct Custom<F: validatable::FieldFamily> {
        pub value: validatable::Field<F, u32>,
    }

    impl validatable::CustomValidate<Custom<validatable::Plain>> for Custom<validatable::Form> {
        fn custom_validate(&mut self) -> ::core::option::Option<Custom<validatable::Plain>> {
            <Custom<validatable::Plain> as validatable::Validatable<_, _>>::validate_from_original(
                self,
            )
        }
    }
}

#[test]
fn derive_with_prelude_shadowing() {
    use prelude_shadowed::{Choice, Person, Wrapped};

    let mut form: Person<validatable::Form> = Person {
        age: validatable::Edit::from_input("20".to_owned()),
        name: validatable::Edit::from_input("Foo".to_owned()),
        fixed: -5,
        score: validatable::Edit::from_input("".to_owned()),
    };
    let plain =
        <Person<validatable::Plain> as validatable::Validatable<_, _>>::validate_from(&mut form);
    assert_eq!(
        plain,
        Some(Person {
            age: 20,
            name: "Foo".to_owned(),
            fixed: -5,
            score: None,
        })
    );

    let _default_input = <Person<validatable::Input> as Default>::default();
    let _default_form = <Person<validatable::Form> as Default>::default();

    let plain: Person<validatable::Plain> = Person {
        age: 20,
        name: "Foo".to_owned(),
        fixed: -5,
        score: None,
    };
    let input: Person<validatable::Input> = plain.into();
    let form: Person<validatable::Form> = input.into();
    let _input: Person<validatable::Input> = form.into();

    let mut one: Choice<validatable::Form> =
        Choice::One(validatable::Edit::from_input("7".to_owned()));
    assert_eq!(
        <Choice<validatable::Plain> as validatable::Validatable<_, _>>::validate_from(&mut one),
        Some(Choice::One(7))
    );

    let mut three: Choice<validatable::Form> = Choice::Three;
    assert_eq!(
        <Choice<validatable::Plain> as validatable::Validatable<_, _>>::validate_from(&mut three),
        Some(Choice::Three)
    );

    assert_eq!(
        <Wrapped as validatable::ValidatableValue<String>>::validate_from(&"42".to_owned()),
        Ok(Wrapped(42))
    );

    let mut custom: prelude_shadowed::Custom<validatable::Form> = prelude_shadowed::Custom {
        value: validatable::Edit::from_input("42".to_owned()),
    };
    assert_eq!(
        <prelude_shadowed::Custom<validatable::Plain> as validatable::Validatable<_, _>>::validate_from(
            &mut custom
        ),
        Some(prelude_shadowed::Custom { value: 42 })
    );
}

#[test]
fn derive_without_glob_import() {
    #[derive(PartialEq, Clone, Debug, validatable::Validatable)]
    struct Person<F: validatable::FieldFamily> {
        age: validatable::Field<F, u32>,
        name: validatable::Field<F, String>,
        fixed: i32,
        score: validatable::Field<F, Option<i32>>,
    }

    #[derive(PartialEq, Clone, Debug, validatable::Validatable)]
    enum Choice<F: validatable::FieldFamily> {
        One(validatable::Field<F, u32>),
        Two { name: validatable::Field<F, String> },
        Three,
    }

    #[derive(PartialEq, Clone, Debug, validatable::Validatable)]
    struct Wrapped(u32);

    let mut form: Person<validatable::Form> = Person {
        age: validatable::Edit::from_input("20".to_owned()),
        name: validatable::Edit::from_input("Foo".to_owned()),
        fixed: -5,
        score: validatable::Edit::from_input("".to_owned()),
    };
    let plain =
        <Person<validatable::Plain> as validatable::Validatable<_, _>>::validate_from(&mut form);
    assert_eq!(
        plain,
        Some(Person {
            age: 20,
            name: "Foo".to_owned(),
            fixed: -5,
            score: None,
        })
    );

    let _default_input = <Person<validatable::Input> as std::default::Default>::default();
    let _default_form = <Person<validatable::Form> as std::default::Default>::default();

    let mut one: Choice<validatable::Form> =
        Choice::One(validatable::Edit::from_input("7".to_owned()));
    assert_eq!(
        <Choice<validatable::Plain> as validatable::Validatable<_, _>>::validate_from(&mut one),
        Some(Choice::One(7))
    );

    let mut two: Choice<validatable::Form> = Choice::Two {
        name: validatable::Edit::from_input("Bar".to_owned()),
    };
    assert_eq!(
        <Choice<validatable::Plain> as validatable::Validatable<_, _>>::validate_from(&mut two),
        Some(Choice::Two {
            name: "Bar".to_owned(),
        })
    );

    let mut three: Choice<validatable::Form> = Choice::Three;
    assert_eq!(
        <Choice<validatable::Plain> as validatable::Validatable<_, _>>::validate_from(&mut three),
        Some(Choice::Three)
    );

    assert_eq!(
        <Wrapped as validatable::ValidatableValue<String>>::validate_from(&"42".to_owned()),
        Ok(Wrapped(42))
    );
    assert_eq!(
        <Wrapped as validatable::ValidatableValue<String>>::into_input(Wrapped(42)),
        "42".to_owned()
    );
}