use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
use chrono::{Datelike, Local, NaiveDate};
#[derive(Debug, thiserror::Error)]
pub enum StringExtError {
#[error("Invalid hex string: {0}")]
HexDecode(#[from] hex::FromHexError),
#[error("Invalid base64 string: {0}")]
Base64Decode(#[from] base64::DecodeError),
#[error("Invalid date string: {0}")]
DateParse(String),
}
pub trait StringDecodeExt {
fn parse_hex(&self) -> Result<Vec<u8>, StringExtError>;
fn parse_base64(&self) -> Result<Vec<u8>, StringExtError>;
}
impl StringDecodeExt for str {
fn parse_hex(&self) -> Result<Vec<u8>, StringExtError> {
Ok(hex::decode(self)?)
}
fn parse_base64(&self) -> Result<Vec<u8>, StringExtError> {
Ok(BASE64.decode(self)?)
}
}
pub trait StringDateExt {
fn parse_date_yymmdd(&self, future_date: bool) -> Result<NaiveDate, StringExtError>;
fn parse_date(&self, future_date: bool) -> Result<NaiveDate, StringExtError>;
fn parse_date_yymmdd_with_ref(
&self,
future_date: bool,
reference: NaiveDate,
) -> Result<NaiveDate, StringExtError>;
fn parse_date_with_ref(
&self,
future_date: bool,
reference: NaiveDate,
) -> Result<NaiveDate, StringExtError>;
}
impl StringDateExt for str {
fn parse_date_yymmdd(&self, future_date: bool) -> Result<NaiveDate, StringExtError> {
self.parse_date_yymmdd_with_ref(future_date, Local::now().naive_local().date())
}
fn parse_date(&self, future_date: bool) -> Result<NaiveDate, StringExtError> {
self.parse_date_with_ref(future_date, Local::now().naive_local().date())
}
fn parse_date_yymmdd_with_ref(
&self,
future_date: bool,
reference: NaiveDate,
) -> Result<NaiveDate, StringExtError> {
let compact: String = self.chars().filter(|c| c.is_ascii_digit()).collect();
if compact.len() != 6 {
return Err(StringExtError::DateParse(format!(
"Invalid length of compact date string: expected exactly 6 digits, got {}",
compact.len()
)));
}
let yy: i32 = compact[0..2]
.parse()
.map_err(|_| StringExtError::DateParse("Invalid year digits".to_string()))?;
let m: u32 = compact[2..4]
.parse()
.map_err(|_| StringExtError::DateParse("Invalid month digits".to_string()))?;
let d: u32 = compact[4..6]
.parse()
.map_err(|_| StringExtError::DateParse("Invalid day digits".to_string()))?;
let now = reference;
let (max_year, max_month, max_day) = if future_date {
let future_months = now.month0() as i32 + 5;
let extra_years = future_months / 12;
let future_month = (future_months % 12) as u32 + 1;
(now.year() + 20 + extra_years, future_month, now.day())
} else {
(now.year(), now.month(), now.day())
};
let mut year = yy + 2000;
if (year, m, d) > (max_year, max_month, max_day) {
year -= 100;
}
NaiveDate::from_ymd_opt(year, m, d).ok_or_else(|| {
StringExtError::DateParse(format!("Invalid date: {year:04}-{m:02}-{d:02}"))
})
}
fn parse_date_with_ref(
&self,
future_date: bool,
reference: NaiveDate,
) -> Result<NaiveDate, StringExtError> {
let raw = self.trim();
if raw.is_empty() {
return Err(StringExtError::DateParse("Empty date string".to_string()));
}
let cleaned: String = raw.chars().filter(|c| c.is_ascii_digit()).collect();
match cleaned.len() {
6 => cleaned.parse_date_yymmdd_with_ref(future_date, reference),
8 => {
let year: i32 = cleaned[0..4]
.parse()
.map_err(|_| StringExtError::DateParse("Invalid year".to_string()))?;
let month: u32 = cleaned[4..6]
.parse()
.map_err(|_| StringExtError::DateParse("Invalid month".to_string()))?;
let day: u32 = cleaned[6..8]
.parse()
.map_err(|_| StringExtError::DateParse("Invalid day".to_string()))?;
NaiveDate::from_ymd_opt(year, month, day).ok_or_else(|| {
StringExtError::DateParse(format!(
"Invalid date: {year:04}-{month:02}-{day:02}"
))
})
}
_ => Err(StringExtError::DateParse(format!(
"Unsupported date string length: {} (from '{}')",
cleaned.len(),
raw
))),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_hex_lowercase() {
let bytes = "deadbeef".parse_hex().unwrap();
assert_eq!(bytes, vec![0xDE, 0xAD, 0xBE, 0xEF]);
}
#[test]
fn parse_hex_uppercase() {
let bytes = "DEADBEEF".parse_hex().unwrap();
assert_eq!(bytes, vec![0xDE, 0xAD, 0xBE, 0xEF]);
}
#[test]
fn parse_hex_empty() {
let bytes = "".parse_hex().unwrap();
assert!(bytes.is_empty());
}
#[test]
fn parse_hex_invalid_returns_error() {
assert!("ZZZZ".parse_hex().is_err());
}
#[test]
fn parse_base64_hello() {
let bytes = "aGVsbG8=".parse_base64().unwrap();
assert_eq!(bytes, b"hello");
}
#[test]
fn parse_base64_empty() {
let bytes = "".parse_base64().unwrap();
assert!(bytes.is_empty());
}
#[test]
fn parse_base64_invalid_returns_error() {
assert!("!!!".parse_base64().is_err());
}
#[test]
fn with_ref_is_deterministic_around_threshold() {
let reference = NaiveDate::from_ymd_opt(2030, 6, 15).unwrap();
let d = "290101"
.parse_date_yymmdd_with_ref(false, reference)
.unwrap();
assert_eq!(d.year(), 2029);
let d = "310101"
.parse_date_yymmdd_with_ref(false, reference)
.unwrap();
assert_eq!(d.year(), 1931);
let d = "31-01-01".parse_date_with_ref(false, reference).unwrap();
assert_eq!(d.year(), 1931);
let d = "300616"
.parse_date_yymmdd_with_ref(false, reference)
.unwrap();
assert_eq!(d.year(), 1930);
let d = "300615"
.parse_date_yymmdd_with_ref(false, reference)
.unwrap();
assert_eq!(d.year(), 2030);
let d = "300614"
.parse_date_yymmdd_with_ref(false, reference)
.unwrap();
assert_eq!(d.year(), 2030);
}
#[test]
fn past_birth_date_1900s() {
let d = "850423".parse_date_yymmdd(false).unwrap();
assert_eq!(d.year(), 1985);
assert_eq!(d.month(), 4);
assert_eq!(d.day(), 23);
}
#[test]
fn recent_birth_date_2000s() {
let d = "050101".parse_date_yymmdd(false).unwrap();
assert_eq!(d.year(), 2005);
}
#[test]
fn strips_non_digit_characters() {
let d = "85-04-23".parse_date_yymmdd(false).unwrap();
assert_eq!(d.year(), 1985);
}
#[test]
fn too_short_returns_error() {
assert!("850".parse_date_yymmdd(false).is_err());
}
#[test]
fn invalid_month_returns_error() {
assert!("851323".parse_date_yymmdd(false).is_err());
}
#[test]
fn parse_date_yyyymmdd() {
let d = "20231231".parse_date(false).unwrap();
assert_eq!(d.year(), 2023);
assert_eq!(d.month(), 12);
assert_eq!(d.day(), 31);
}
#[test]
fn parse_date_yymmdd_six_digits() {
let d = "850423".parse_date(false).unwrap();
assert_eq!(d.year(), 1985);
}
#[test]
fn parse_date_empty_returns_error() {
assert!("".parse_date(false).is_err());
}
#[test]
fn parse_date_unsupported_length_returns_error() {
assert!("2023123".parse_date(false).is_err());
}
}