use crate::error::TypeError;
use serde::{self, Deserialize, Serialize};
use std::ops::Deref;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Passport(String);
impl Passport {
pub const SERIES_LEN: usize = 2;
pub const NUMBER_LEN: usize = 7;
pub const LEN: usize = Self::SERIES_LEN + Self::NUMBER_LEN;
fn validate(raw: &str) -> Result<(), PassportError> {
if raw.len() != Self::LEN {
return Err(PassportError::Length);
}
if !raw.is_ascii() {
return Err(PassportError::Format);
}
let (series, number) = raw.split_at(Self::SERIES_LEN);
if !series.bytes().all(|b| b.is_ascii_alphabetic())
|| !number.bytes().all(|b| b.is_ascii_digit())
{
return Err(PassportError::Format);
}
Ok(())
}
pub fn parse(value: impl AsRef<str>) -> Result<Self, TypeError> {
let raw = value.as_ref().trim();
Self::validate(raw)?;
Ok(Self(raw.to_ascii_uppercase()))
}
#[inline]
pub fn as_str(&self) -> &str {
&self.0
}
#[inline]
pub fn series(&self) -> &str {
&self.0[..Self::SERIES_LEN]
}
#[inline]
pub fn number(&self) -> &str {
&self.0[Self::SERIES_LEN..]
}
#[inline]
pub fn into_inner(self) -> String {
self.0
}
}
impl Deref for Passport {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl AsRef<str> for Passport {
fn as_ref(&self) -> &str {
&self.0
}
}
impl std::fmt::Display for Passport {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl TryFrom<&str> for Passport {
type Error = TypeError;
fn try_from(value: &str) -> Result<Self, TypeError> {
Self::parse(value)
}
}
impl TryFrom<String> for Passport {
type Error = TypeError;
fn try_from(value: String) -> Result<Self, TypeError> {
if value.len() == Passport::LEN && value.trim().len() == Passport::LEN && value.is_ascii() {
let is_upper = value[..Passport::SERIES_LEN]
.bytes()
.all(|b| b.is_ascii_uppercase());
if is_upper {
Passport::validate(&value)?;
return Ok(Self(value));
}
}
Self::parse(value)
}
}
impl From<Passport> for String {
fn from(value: Passport) -> Self {
value.into_inner()
}
}
impl Serialize for Passport {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str()) }
}
#[allow(unknown_lints)]
impl<'de> Deserialize<'de> for Passport {
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 PassportError {
#[error("passport length is invalid, expected {} characters", Passport::LEN)]
Length,
#[error("passport format is invalid, expected 2 letters followed by 7 digits")]
Format,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_should_create_valid_passport() {
let passport = Passport::parse("AA1234567").unwrap();
assert_eq!(passport.as_str(), "AA1234567");
}
#[test]
fn parse_should_convert_series_to_uppercase() {
let passport = Passport::parse("ab1234567").unwrap();
assert_eq!(passport.as_str(), "AB1234567");
}
#[test]
fn parse_should_trim_whitespace() {
let passport = Passport::parse(" AA1234567 ").unwrap();
assert_eq!(passport.as_str(), "AA1234567");
}
#[test]
fn should_return_series_and_number() {
let passport = Passport::parse("AA1234567").unwrap();
assert_eq!(passport.series(), "AA");
assert_eq!(passport.number(), "1234567");
}
#[test]
fn parse_should_fail_when_length_is_invalid() {
let result = Passport::parse("AA123");
assert!(matches!(
result.unwrap_err(),
TypeError::Passport(PassportError::Length)
));
}
#[test]
fn parse_should_fail_when_series_contains_numbers() {
let result = Passport::parse("A11234567");
assert!(matches!(
result.unwrap_err(),
TypeError::Passport(PassportError::Format)
));
}
#[test]
fn parse_should_fail_when_number_contains_letters() {
let result = Passport::parse("AA12345AB");
assert!(matches!(
result.unwrap_err(),
TypeError::Passport(PassportError::Format)
));
}
#[test]
fn parse_should_not_panic_on_multibyte_utf8_of_same_byte_length() {
let result = Passport::parse("a\u{00C4}234567");
assert!(matches!(
result.unwrap_err(),
TypeError::Passport(PassportError::Format)
));
}
#[test]
fn display_and_deref_should_work() {
let passport = Passport::parse("AA1234567").unwrap();
assert_eq!(format!("{}", passport), "AA1234567");
assert_eq!(passport.as_ref(), "AA1234567");
assert!(passport.starts_with("AA"));
}
#[test]
fn test_try_from_conversions() {
let passport_str = Passport::try_from("AA1234567").unwrap();
assert_eq!(passport_str.as_str(), "AA1234567");
let s1 = String::from("AA1234567");
let passport_string1 = Passport::try_from(s1).unwrap();
assert_eq!(passport_string1.as_str(), "AA1234567");
let s2 = String::from("ab1234567");
let passport_string2 = Passport::try_from(s2).unwrap();
assert_eq!(passport_string2.as_str(), "AB1234567");
}
#[test]
fn passport_should_convert_into_string() {
let passport = Passport::parse("AA1234567").unwrap();
let value: String = passport.into();
assert_eq!(value, "AA1234567");
}
#[test]
fn serde_should_support_roundtrip() {
let passport = Passport::parse("AA1234567").unwrap();
let json = serde_json::to_string(&passport).unwrap();
assert_eq!(json, "\"AA1234567\"");
let restored: Passport = serde_json::from_str(&json).unwrap();
assert_eq!(passport, restored);
}
}