planter-core 0.0.6

use anyhow::Context;
pub use email_address::EmailAddress;
use nutype::nutype;
pub use phonenumber::PhoneNumber;

const NAME_LEN: usize = 50;

#[derive(Debug, Clone, PartialEq, Eq)]
/// Represents a person with a name and contact information.
pub struct Person {
    /// The first name of the person.
    first_name: NameString,
    /// The last name of the person.
    last_name: NameString,
    /// The email address of the person.
    email: Option<EmailAddress>,
    /// The phone number of the person.
    phone: Option<PhoneNumber>,
}

#[cfg_attr(
    feature = "serde",
    nutype(
        sanitize(trim),
        validate(not_empty, len_char_max = NAME_LEN),
        derive(Debug, Eq, PartialEq, Clone, Display, Deref, Serialize, Deserialize),
    )
)]
#[cfg_attr(
    not(feature = "serde"),
    nutype(
        sanitize(trim),
        validate(not_empty, len_char_max = NAME_LEN),
        derive(Debug, Eq, PartialEq, Clone, Display, Deref),
    )
)]
pub struct NameString(String);

impl Person {
    /// Create a new `Person` with the given name and surname.
    ///
    /// # Arguments
    /// * `name` - The first name of the person.
    /// * `surname` - The surname of the person.
    ///
    /// # Returns
    /// A new `Person` instance.
    ///
    /// # Errors
    /// Returns an error if the name or surname is empty or exceeds the maximum length.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    ///
    /// let person = Person::new("Margherita", "Hack").unwrap();
    /// ```
    pub fn new(name: impl Into<String>, surname: impl Into<String>) -> anyhow::Result<Self> {
        let name = NameString::try_new(name).context("Invalid first name")?;
        let surname = NameString::try_new(surname).context("Invalid last name")?;

        Ok(Person {
            first_name: name,
            last_name: surname,
            email: None,
            phone: None,
        })
    }

    /// Add or edit the email address of the person.
    ///
    /// # Arguments
    /// * `email` - The new email address of the person.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    /// use email_address::EmailAddress;
    /// use std::str::FromStr;
    ///
    /// let mut person = Person::new("Margherita", "Hack").unwrap();
    /// let email = EmailAddress::from_str("margherita.hack@example.com").unwrap();
    /// person.update_email(email.clone());
    /// assert_eq!(person.email(), Some(&email));
    /// ```
    pub fn update_email(&mut self, email: EmailAddress) {
        self.email = Some(email);
    }

    /// Remove the email address of the person.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    /// use email_address::EmailAddress;
    /// use std::str::FromStr;
    ///
    /// let mut person = Person::new("Margherita", "Hack").unwrap();
    /// let email = EmailAddress::from_str("margherita.hack@example.com").unwrap();
    /// person.update_email(email.clone());
    /// assert_eq!(person.email(), Some(&email));
    /// person.rm_email();
    /// assert!(person.email().is_none());
    /// ```
    pub fn rm_email(&mut self) {
        self.email = None;
    }

    /// Add or edit the phone number of the person.
    ///
    /// # Arguments
    /// * `phone` - The new phone number of the person.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    /// use std::str::FromStr;
    /// use phonenumber::PhoneNumber;
    ///
    /// let mut person = Person::new("Margherita", "Hack").unwrap();
    /// let phone = PhoneNumber::from_str("+1234567890").unwrap();
    /// person.update_phone(phone.clone());
    /// assert_eq!(person.phone(), Some(&phone));
    /// ```
    pub fn update_phone(&mut self, phone: PhoneNumber) {
        self.phone = Some(phone);
    }

    /// Remove the phone number of the person.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    /// use std::str::FromStr;
    /// use phonenumber::PhoneNumber;
    ///
    /// let mut person = Person::new("Margherita", "Hack").unwrap();
    /// let phone = PhoneNumber::from_str("+1234567890").unwrap();
    /// person.update_phone(phone.clone());
    /// assert_eq!(person.phone(), Some(&phone));
    /// person.rm_phone();
    /// assert!(person.phone().is_none());
    /// ```
    pub fn rm_phone(&mut self) {
        self.phone = None;
    }

    /// Get the phone number of the person.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    /// use phonenumber::PhoneNumber;
    /// use std::str::FromStr;
    ///
    /// let mut person = Person::new("Margherita", "Hack").unwrap();
    /// let phone = PhoneNumber::from_str("+1234567890").unwrap();
    /// person.update_phone(phone.clone());
    /// assert_eq!(person.phone(), Some(&phone));
    /// ```
    #[must_use]
    pub const fn phone(&self) -> Option<&PhoneNumber> {
        self.phone.as_ref()
    }

    /// Get the email of the person.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    /// use email_address::EmailAddress;
    /// use std::str::FromStr;
    ///
    /// let mut person = Person::new("Margherita", "Hack").unwrap();
    /// let email = EmailAddress::from_str("margherita.hack@example.com").unwrap();
    /// person.update_email(email.clone());
    /// assert_eq!(person.email(), Some(&email));
    /// ```
    #[must_use]
    pub const fn email(&self) -> Option<&EmailAddress> {
        self.email.as_ref()
    }

    /// Get the name of the person.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    ///
    /// let mut person = Person::new("Margherita", "Hack").unwrap();
    /// assert_eq!(person.full_name(), "Margherita Hack");
    /// ```
    #[must_use]
    pub fn full_name(&self) -> String {
        format!("{} {}", self.first_name, self.last_name)
    }

    /// Get the first name of the person.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    ///
    /// let person = Person::new("Margherita", "Hack").unwrap();
    /// assert_eq!(person.first_name(), "Margherita");
    /// ```
    #[must_use]
    pub fn first_name(&self) -> &str {
        &self.first_name
    }

    /// Update the first name of the person.
    ///
    /// # Errors
    ///
    /// It can return an error, if the input `name` can't be converted to
    /// `NameString`
    ///
    /// # Examples
    ///
    /// ```
    /// use planter_core::person::Person;
    ///
    /// let mut person = Person::new("Margaret", "Hack").unwrap();
    /// person.update_first_name("Margherita").unwrap();
    /// assert_eq!(person.first_name(), "Margherita");
    /// ```
    pub fn update_first_name(&mut self, name: impl Into<String>) -> anyhow::Result<()> {
        self.first_name =
            NameString::try_new(name).context("Input can't be converted into NameString.")?;
        Ok(())
    }

    /// Get the last name of the person.
    ///
    /// # Examples
    /// ```
    /// use planter_core::person::Person;
    ///
    /// let mut person = Person::new("Margherita", "Hack").unwrap();
    /// assert_eq!(person.last_name(), "Hack");
    /// ```
    #[must_use]
    pub fn last_name(&self) -> &str {
        &self.last_name
    }

    /// Update the last name of the person.
    ///
    /// # Errors
    ///
    /// It can return an error, if the input `name` can't be converted to
    /// `NameString`
    ///
    /// # Examples
    ///
    /// ```
    /// use planter_core::person::Person;
    ///
    /// let mut person = Person::new("Margherita", "Hacker").unwrap();
    /// person.update_last_name("Hack").unwrap();
    /// assert_eq!(person.last_name(), "Hack");
    /// ```
    pub fn update_last_name(&mut self, name: impl Into<String>) -> anyhow::Result<()> {
        self.last_name =
            NameString::try_new(name).context("Input can't be converted into NameString.")?;
        Ok(())
    }
}

#[cfg(feature = "serde")]
impl serde::Serialize for Person {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        use serde::ser::SerializeStruct;
        let mut s = serializer.serialize_struct("Person", 4)?;
        s.serialize_field("first_name", &*self.first_name)?;
        s.serialize_field("last_name", &*self.last_name)?;
        s.serialize_field(
            "email",
            &self.email.as_ref().map(std::string::ToString::to_string),
        )?;
        s.serialize_field(
            "phone",
            &self.phone.as_ref().map(std::string::ToString::to_string),
        )?;
        s.end()
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Person {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        use serde::de;
        use std::str::FromStr;

        #[derive(serde::Deserialize)]
        struct Helper {
            first_name: String,
            last_name: String,
            email: Option<String>,
            phone: Option<String>,
        }

        let helper = Helper::deserialize(deserializer)?;
        let first_name = NameString::try_new(helper.first_name).map_err(de::Error::custom)?;
        let last_name = NameString::try_new(helper.last_name).map_err(de::Error::custom)?;
        let email = helper
            .email
            .map(|e| email_address::EmailAddress::from_str(&e))
            .transpose()
            .map_err(de::Error::custom)?;
        let phone = helper
            .phone
            .map(|p| phonenumber::PhoneNumber::from_str(&p))
            .transpose()
            .map_err(de::Error::custom)?;
        Ok(Person {
            first_name,
            last_name,
            email,
            phone,
        })
    }
}

#[cfg(test)]
/// Test utilities for the `person` module.
pub mod test_utils {
    use std::str::FromStr;

    use email_address::EmailAddress;
    use phonenumber::PhoneNumber;
    use proptest::prelude::*;

    use crate::person::Person;

    /// Generate a random email address.
    pub fn email() -> impl Strategy<Value = EmailAddress> {
        r"[a-z]{1,10}@[a-z]{1,10}\.[a-z]{2,4}"
            .prop_map(|s: String| EmailAddress::from_str(&s).unwrap())
    }

    /// Generate a random phone number.
    pub fn phone_number() -> impl Strategy<Value = PhoneNumber> {
        r"\+39[0-9]{6,12}".prop_map(|s: String| PhoneNumber::from_str(&s).unwrap())
    }

    /// Generate a random valid name string (1-50 alpha chars).
    pub fn valid_name() -> impl Strategy<Value = String> {
        "[a-zA-Z]{1,50}"
    }

    /// Generate a random `Person` with optional email and phone.
    pub fn person() -> impl Strategy<Value = Person> {
        (
            valid_name(),
            valid_name(),
            prop::option::of(email()),
            prop::option::of(phone_number()),
        )
            .prop_map(|(first, last, email, phone)| {
                let mut p = Person::new(first, last).unwrap();
                if let Some(e) = email {
                    p.update_email(e);
                }
                if let Some(ph) = phone {
                    p.update_phone(ph);
                }
                p
            })
    }
}

#[cfg(test)]
mod tests {
    use proptest::prelude::*;

    use super::test_utils::{email, phone_number, valid_name};
    use crate::person::Person;

    proptest! {
        #[test]
        fn full_name_equals_first_last(first in valid_name(), last in valid_name()) {
            let person = Person::new(&first, &last).unwrap();
            assert_eq!(person.full_name(), format!("{} {}", first, last));
        }

        #[test]
        fn update_first_name_roundtrip(first in valid_name(), last in valid_name(), new_first in valid_name()) {
            let mut person = Person::new(&first, &last).unwrap();
            person.update_first_name(&new_first).unwrap();
            assert_eq!(person.first_name(), new_first);
        }

        #[test]
        fn update_last_name_roundtrip(first in valid_name(), last in valid_name(), new_last in valid_name()) {
            let mut person = Person::new(&first, &last).unwrap();
            person.update_last_name(&new_last).unwrap();
            assert_eq!(person.last_name(), new_last);
        }

        #[test]
        fn update_email_roundtrip(first in valid_name(), last in valid_name(), email in email()) {
            let mut person = Person::new(&first, &last).unwrap();
            person.update_email(email.clone());
            assert_eq!(person.email(), Some(&email));
            person.rm_email();
            assert!(person.email().is_none());
        }

        #[test]
        fn update_phone_roundtrip(first in valid_name(), last in valid_name(), phone in phone_number()) {
            let mut person = Person::new(&first, &last).unwrap();
            person.update_phone(phone.clone());
            assert_eq!(person.phone(), Some(&phone));
            person.rm_phone();
            assert!(person.phone().is_none());
        }

        #[test]
        fn new_rejects_empty_name(name in valid_name()) {
            assert!(Person::new("", &name).is_err());
            assert!(Person::new(&name, "").is_err());
        }

        #[test]
        fn new_rejects_long_name(first in "[a-zA-Z]{51,100}", last in valid_name()) {
            assert!(Person::new(&first, &last).is_err());
        }

        #[test]
        fn update_first_name_rejects_invalid(name in valid_name(), bad in "[a-zA-Z]{51,100}") {
            let mut person = Person::new("valid", &name).unwrap();
            assert!(person.update_first_name(&bad).is_err());
        }

        #[test]
        fn update_last_name_rejects_invalid(name in valid_name(), bad in "[a-zA-Z]{51,100}") {
            let mut person = Person::new(&name, "valid").unwrap();
            assert!(person.update_last_name(&bad).is_err());
        }
    }
}

#[cfg(all(test, feature = "serde"))]
mod serde_tests {
    use proptest::prelude::*;

    use crate::person::Person;
    use crate::person::test_utils::person;

    proptest! {
        #[test]
        fn serde_roundtrip(p in person()) {
            let json = serde_json::to_string(&p).unwrap();
            let deserialized: Person = serde_json::from_str(&json).unwrap();
            assert_eq!(p, deserialized);
        }
    }
}