use crate::error::TypeError;
use serde::{Deserialize, Serialize};
use std::ops::Deref;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PhoneNumber(String);
impl PhoneNumber {
pub const DIGIT_LEN: usize = 12;
pub const COUNTRY_CODE: &str = "998";
fn validate(phone: &str) -> Result<(), PhoneNumberError> {
if phone.len() != Self::DIGIT_LEN {
return Err(PhoneNumberError::Length);
}
if !phone.bytes().all(|b| b.is_ascii_digit()) {
return Err(PhoneNumberError::Format);
}
if !phone.starts_with(Self::COUNTRY_CODE) {
return Err(PhoneNumberError::Prefix);
}
Ok(())
}
pub fn parse(value: impl AsRef<str>) -> Result<Self, TypeError> {
let raw = value.as_ref().trim();
let digits = raw.strip_prefix('+').unwrap_or(raw);
Self::validate(digits)?;
Ok(Self(digits.to_owned()))
}
#[inline]
pub fn as_str(&self) -> &str {
&self.0
}
#[inline]
pub fn to_international(&self) -> String {
format!("+{}", self.0)
}
#[inline]
pub fn into_inner(self) -> String {
self.0
}
}
impl Deref for PhoneNumber {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl AsRef<str> for PhoneNumber {
fn as_ref(&self) -> &str {
&self.0
}
}
impl std::fmt::Display for PhoneNumber {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl TryFrom<&str> for PhoneNumber {
type Error = TypeError;
fn try_from(value: &str) -> Result<Self, TypeError> {
Self::parse(value)
}
}
impl TryFrom<String> for PhoneNumber {
type Error = TypeError;
fn try_from(value: String) -> Result<Self, TypeError> {
if value.starts_with('+') || value.trim().len() != value.len() {
Self::parse(value)
} else {
Self::validate(&value)?;
Ok(Self(value))
}
}
}
impl From<PhoneNumber> for String {
fn from(value: PhoneNumber) -> Self {
value.into_inner()
}
}
impl Serialize for PhoneNumber {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str()) }
}
impl<'de> Deserialize<'de> for PhoneNumber {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
Self::try_from(s).map_err(serde::de::Error::custom)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
#[non_exhaustive]
pub enum PhoneNumberError {
#[error("phone number length is invalid")]
Length,
#[error("phone number format is invalid")]
Format,
#[error("phone number must start with 998")]
Prefix,
}
#[cfg(test)]
mod tests {
use super::*;
const PHONE_NUMBER_WITH_PLUS: &str = "+998901234567";
const PHONE_NUMBER_WITHOUT_PLUS: &str = "998901234567";
#[test]
fn test_valid_with_or_without_plus() {
let phone_with_plus = PhoneNumber::parse(PHONE_NUMBER_WITH_PLUS).expect("valid phone");
let phone_without_plus =
PhoneNumber::parse(PHONE_NUMBER_WITHOUT_PLUS).expect("valid phone");
assert_eq!(phone_with_plus.as_str(), PHONE_NUMBER_WITHOUT_PLUS);
assert_eq!(phone_without_plus.as_str(), PHONE_NUMBER_WITHOUT_PLUS);
assert_eq!(
phone_without_plus.to_international().as_str(),
PHONE_NUMBER_WITH_PLUS
);
}
#[test]
fn parse_should_trim_whitespace() {
let input = " 998901234567 \n\t";
let phone = PhoneNumber::parse(input).expect("Probel bo'lsa ham parse bo'lishi kerak");
assert_eq!(phone.as_str(), PHONE_NUMBER_WITHOUT_PLUS);
}
#[test]
fn test_invalid_length() {
assert!(PhoneNumber::parse("99890123456").is_err());
assert!(PhoneNumber::parse("9989012345678").is_err());
assert!(PhoneNumber::parse("").is_err());
}
#[test]
fn test_invalid_format() {
assert!(PhoneNumber::parse("997901234567").is_err());
assert!(PhoneNumber::parse("998a01234567").is_err());
assert!(PhoneNumber::parse("998 901234567").is_err());
}
#[test]
fn test_deref_and_as_ref() {
let phone = PhoneNumber::parse(PHONE_NUMBER_WITHOUT_PLUS).unwrap();
assert_eq!(phone.len(), 12);
assert!(phone.starts_with("998"));
assert_eq!(phone.as_ref(), PHONE_NUMBER_WITHOUT_PLUS);
}
#[test]
fn test_try_from_conversions() {
let phone1 = PhoneNumber::try_from(PHONE_NUMBER_WITHOUT_PLUS).unwrap();
assert_eq!(phone1.as_str(), PHONE_NUMBER_WITHOUT_PLUS);
let s = String::from(PHONE_NUMBER_WITHOUT_PLUS);
let phone2 = PhoneNumber::try_from(s).unwrap();
assert_eq!(phone2.as_str(), PHONE_NUMBER_WITHOUT_PLUS);
let s_padded = String::from(" 998901234567 ");
let phone3 = PhoneNumber::try_from(s_padded).unwrap();
assert_eq!(phone3.as_str(), PHONE_NUMBER_WITHOUT_PLUS);
}
#[test]
fn test_display_and_into_string() {
let phone = PhoneNumber::parse(PHONE_NUMBER_WITHOUT_PLUS).unwrap();
assert_eq!(format!("{}", phone), PHONE_NUMBER_WITHOUT_PLUS);
let s: String = phone.into();
assert_eq!(s, PHONE_NUMBER_WITHOUT_PLUS);
}
#[test]
fn test_serde_serialization() {
let phone = PhoneNumber::parse(PHONE_NUMBER_WITHOUT_PLUS).unwrap();
let json = serde_json::to_string(&phone).unwrap();
assert_eq!(json, format!("\"{}\"", PHONE_NUMBER_WITHOUT_PLUS));
let deserialized: PhoneNumber = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized, phone);
let invalid_json = "\"997881234567\"";
let res: Result<PhoneNumber, _> = serde_json::from_str(invalid_json);
assert!(res.is_err());
}
#[test]
fn to_international_should_add_plus() {
let phone = PhoneNumber::parse(PHONE_NUMBER_WITHOUT_PLUS).unwrap();
assert_eq!(phone.to_international(), PHONE_NUMBER_WITH_PLUS);
}
}