use crate::error::TypeError;
use serde::{self, Deserialize, Serialize};
use std::ops::Deref;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Pinfl(String);
impl Pinfl {
pub const LEN: usize = 14;
fn validate(pinfl: &str) -> Result<(), PinflError> {
if pinfl.len() != Self::LEN {
return Err(PinflError::Length);
}
if !pinfl.bytes().all(|b| b.is_ascii_digit()) {
return Err(PinflError::Format);
}
Ok(())
}
pub fn parse(value: impl AsRef<str>) -> Result<Self, TypeError> {
let pinfl = value.as_ref().trim();
Self::validate(pinfl)?;
Ok(Self(pinfl.to_owned()))
}
#[inline]
pub fn as_str(&self) -> &str {
&self.0
}
#[inline]
pub fn into_inner(self) -> String {
self.0
}
}
impl Deref for Pinfl {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl AsRef<str> for Pinfl {
fn as_ref(&self) -> &str {
&self.0
}
}
impl std::fmt::Display for Pinfl {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl TryFrom<&str> for Pinfl {
type Error = TypeError;
fn try_from(value: &str) -> Result<Self, TypeError> {
Self::parse(value)
}
}
impl TryFrom<String> for Pinfl {
type Error = TypeError;
fn try_from(value: String) -> Result<Self, TypeError> {
let trimmed_len = value.trim().len();
if trimmed_len == value.len() {
Self::validate(&value)?;
Ok(Self(value))
} else {
Self::parse(value.trim())
}
}
}
impl From<Pinfl> for String {
fn from(value: Pinfl) -> Self {
value.into_inner()
}
}
impl Serialize for Pinfl {
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 Pinfl {
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 PinflError {
#[error("pinfl length is invalid, expected 14 digits")]
Length,
#[error("pinfl format is incorrect, expected only digits")]
Format,
}
#[cfg(test)]
mod tests {
use super::*;
const VALID_PINFL: &str = "12345678901234";
#[test]
fn test_valid_pinfl_parse() {
let pinfl = Pinfl::parse(VALID_PINFL).expect("Valid PINFL parse bo'lishi kerak");
assert_eq!(pinfl.as_str(), VALID_PINFL);
}
#[test]
fn test_pinfl_trim_whitespace() {
let input = " 12345678901234 \n\t";
let pinfl = Pinfl::parse(input).expect("Probel bo'lsa ham parse bo'lishi kerak");
assert_eq!(pinfl.as_str(), VALID_PINFL);
}
#[test]
fn test_invalid_length() {
assert!(Pinfl::parse("1234567890123").is_err());
assert!(Pinfl::parse("123456789012345").is_err());
assert!(Pinfl::parse("").is_err());
}
#[test]
fn test_invalid_format() {
assert!(Pinfl::parse("1234567890123a").is_err());
assert!(Pinfl::parse("123456789012-4").is_err());
assert!(Pinfl::parse("12345 67890123").is_err());
}
#[test]
fn test_deref_and_as_ref() {
let pinfl = Pinfl::parse(VALID_PINFL).unwrap();
assert_eq!(pinfl.len(), 14);
assert!(pinfl.starts_with("123"));
assert_eq!(pinfl.as_ref(), VALID_PINFL);
}
#[test]
fn test_try_from_conversions() {
let pinfl1 = Pinfl::try_from(VALID_PINFL).unwrap();
assert_eq!(pinfl1.as_str(), VALID_PINFL);
let s = String::from(VALID_PINFL);
let pinfl2 = Pinfl::try_from(s).unwrap();
assert_eq!(pinfl2.as_str(), VALID_PINFL);
let s_padded = String::from(" 12345678901234 ");
let pinfl3 = Pinfl::try_from(s_padded).unwrap();
assert_eq!(pinfl3.as_str(), VALID_PINFL);
}
#[test]
fn test_display_and_into_string() {
let pinfl = Pinfl::parse(VALID_PINFL).unwrap();
assert_eq!(format!("{}", pinfl), VALID_PINFL);
let s: String = pinfl.into();
assert_eq!(s, VALID_PINFL);
}
#[test]
fn test_serde_serialization() {
let pinfl = Pinfl::parse(VALID_PINFL).unwrap();
let json = serde_json::to_string(&pinfl).unwrap();
assert_eq!(json, format!("\"{}\"", VALID_PINFL));
let deserialized: Pinfl = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized, pinfl);
let invalid_json = "\"12345\"";
let res: Result<Pinfl, _> = serde_json::from_str(invalid_json);
assert!(res.is_err());
}
}