use std::fmt;
use std::str::FromStr;
use serde::{Deserialize, Serialize};
fn validate_id(s: &str) -> Result<(), IdParseError> {
if s.is_empty() || s.len() > 8 {
return Err(IdParseError {
value: s.to_owned(),
reason: "must be 1-8 characters",
});
}
if !s.chars().all(|c| c.is_ascii_alphanumeric()) {
return Err(IdParseError {
value: s.to_owned(),
reason: "must contain only alphanumeric characters (a-z, A-Z, 0-9)",
});
}
Ok(())
}
#[derive(Debug, Clone)]
pub struct IdParseError {
value: String,
reason: &'static str,
}
impl fmt::Display for IdParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "invalid ID '{}': {}", self.value, self.reason)
}
}
impl std::error::Error for IdParseError {}
pub(crate) fn generate_id() -> String {
const ALPHABET: [char; 30] = [
'2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k',
'm', 'n', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'y', 'z',
];
nanoid::nanoid!(8, &ALPHABET)
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct GoalId(String);
impl GoalId {
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
Self(generate_id())
}
pub(crate) fn new_unchecked(s: String) -> Self {
Self(s)
}
}
impl fmt::Display for GoalId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl AsRef<str> for GoalId {
fn as_ref(&self) -> &str {
&self.0
}
}
impl FromStr for GoalId {
type Err = IdParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
validate_id(s)?;
Ok(Self(s.to_owned()))
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct TaskId(String);
impl TaskId {
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
Self(generate_id())
}
#[cfg(test)]
pub(crate) fn new_unchecked(s: String) -> Self {
Self(s)
}
}
impl fmt::Display for TaskId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl AsRef<str> for TaskId {
fn as_ref(&self) -> &str {
&self.0
}
}
impl FromStr for TaskId {
type Err = IdParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
validate_id(s)?;
Ok(Self(s.to_owned()))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_generate_goal_id() {
for _ in 0..100 {
let id = GoalId::new();
let s: &str = id.as_ref();
assert_eq!(s.len(), 8);
assert!(!s.starts_with('-'));
assert!(!s.starts_with('_'));
assert!(!s.contains('-'));
assert!(!s.contains('_'));
}
}
#[test]
fn test_generate_task_id() {
for _ in 0..100 {
let id = TaskId::new();
let s: &str = id.as_ref();
assert_eq!(s.len(), 8);
assert!(!s.starts_with('-'));
assert!(!s.starts_with('_'));
assert!(!s.contains('-'));
assert!(!s.contains('_'));
}
}
#[test]
fn test_goal_id_display() {
let id = GoalId::new_unchecked("abc12345".to_string());
assert_eq!(format!("{id}"), "abc12345");
}
#[test]
fn test_task_id_display() {
let id = TaskId::new_unchecked("xyz67890".to_string());
assert_eq!(format!("{id}"), "xyz67890");
}
#[test]
fn test_goal_id_from_str() {
let id: GoalId = "test1234".parse().unwrap();
assert_eq!(id.as_ref(), "test1234");
}
#[test]
fn test_task_id_from_str() {
let id: TaskId = "test5678".parse().unwrap();
assert_eq!(id.as_ref(), "test5678");
}
#[test]
fn test_rejects_empty_string() {
assert!("".parse::<GoalId>().is_err());
assert!("".parse::<TaskId>().is_err());
}
#[test]
fn test_rejects_wrong_length() {
assert!("waytoolong123".parse::<GoalId>().is_err());
assert!("123456789".parse::<TaskId>().is_err());
}
#[test]
fn test_rejects_special_characters() {
assert!("test-123".parse::<GoalId>().is_err());
assert!("test_123".parse::<TaskId>().is_err());
assert!("test 123".parse::<GoalId>().is_err());
}
#[test]
fn test_error_message_includes_value() {
let err = "toolongid".parse::<GoalId>().unwrap_err();
assert!(err.to_string().contains("toolongid"));
assert!(err.to_string().contains("1-8 characters"));
}
#[test]
fn test_new_unchecked_bypasses_validation() {
let id = GoalId::new_unchecked("anything".to_string());
assert_eq!(id.as_ref(), "anything");
}
#[test]
fn test_legacy_mixed_case_ids_parse() {
let id1: GoalId = "t8zwaROl".parse().unwrap();
assert_eq!(id1.as_ref(), "t8zwaROl");
let id2: TaskId = "xYz9Kp2m".parse().unwrap();
assert_eq!(id2.as_ref(), "xYz9Kp2m");
let id3: GoalId = "V1StGXR8".parse().unwrap();
assert_eq!(id3.as_ref(), "V1StGXR8");
}
#[test]
fn test_from_str_preserves_case() {
let upper: GoalId = "ABCD1234".parse().unwrap();
let lower: GoalId = "abcd1234".parse().unwrap();
let mixed: GoalId = "AbCd1234".parse().unwrap();
assert_eq!(upper.as_ref(), "ABCD1234");
assert_eq!(lower.as_ref(), "abcd1234");
assert_eq!(mixed.as_ref(), "AbCd1234");
assert_ne!(upper, lower);
}
#[test]
fn test_prefix_lengths_validate() {
assert!("a".parse::<GoalId>().is_ok());
assert!("ab".parse::<GoalId>().is_ok());
assert!("abc".parse::<GoalId>().is_ok());
assert!("abcd".parse::<TaskId>().is_ok());
assert!("abcde".parse::<TaskId>().is_ok());
assert!("abcdef".parse::<TaskId>().is_ok());
assert!("abcdefg".parse::<TaskId>().is_ok());
assert!("abcdefgh".parse::<GoalId>().is_ok());
}
}