namba 0.1.0

A fast, lightweight library for parsing, validating, and formatting phone numbers
Documentation
use core::{fmt, str::FromStr};

use crate::{Error, ErrorKind};

/// A two-letter region supported by the bundled numbering plans.
#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Region([u8; 2]);

impl Region {
    /// Parses and validates a two-letter region code.
    pub fn new(value: &str) -> crate::Result<Self> {
        Self::try_from(value)
    }

    /// Returns the uppercase region code.
    pub fn as_str(&self) -> &str {
        core::str::from_utf8(&self.0).expect("region invariant")
    }
}

impl TryFrom<&str> for Region {
    type Error = Error;

    fn try_from(value: &str) -> crate::Result<Self> {
        let bytes = value.as_bytes();
        if bytes.len() != 2 || !bytes.iter().all(u8::is_ascii_alphabetic) {
            return Err(Error::new(ErrorKind::UnsupportedRegion));
        }
        let region = Self([bytes[0].to_ascii_uppercase(), bytes[1].to_ascii_uppercase()]);
        if crate::plans::calling_code(region.as_str()).is_none() {
            return Err(Error::new(ErrorKind::UnsupportedRegion));
        }
        Ok(region)
    }
}

impl AsRef<str> for Region {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl FromStr for Region {
    type Err = Error;

    fn from_str(value: &str) -> crate::Result<Self> {
        Self::try_from(value)
    }
}

impl fmt::Display for Region {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

impl fmt::Debug for Region {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_tuple("Region").field(&self.as_str()).finish()
    }
}

#[cfg(feature = "serde")]
impl serde::Serialize for Region {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Region {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let value = <std::borrow::Cow<'de, str>>::deserialize(deserializer)?;
        Self::new(&value).map_err(serde::de::Error::custom)
    }
}