use std::borrow::Borrow;
use std::cmp::Ordering;
use std::fmt;
use std::hash::{Hash, Hasher};
use std::str::FromStr;
use std::sync::Arc;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
pub const MIN_USECASE_NAME_LENGTH: usize = 3;
pub const MAX_USECASE_NAME_LENGTH: usize = 64;
const INVALID_LENGTH: &str = "invalid usecase name: must be 3-64 ASCII characters long";
const INVALID_CHAR: &str = "invalid usecase name: expected ASCII letters, digits, '_' or '-'";
#[derive(Clone)]
enum Repr {
Static(&'static str),
Dynamic(Arc<str>),
}
#[derive(Clone)]
pub struct Usecase(Repr);
impl Usecase {
pub fn new(name: impl AsRef<str>) -> Result<Self, InvalidUsecaseName> {
let name = name.as_ref();
validate(name)?;
Ok(Self(Repr::Dynamic(name.into())))
}
#[track_caller]
pub const fn from_static(name: &'static str) -> Self {
match validate(name) {
Ok(()) => Self(Repr::Static(name)),
Err(InvalidUsecaseName::InvalidLength) => panic!("{}", INVALID_LENGTH),
Err(InvalidUsecaseName::InvalidChar(_)) => panic!("{}", INVALID_CHAR),
}
}
pub fn as_str(&self) -> &str {
match &self.0 {
Repr::Static(name) => name,
Repr::Dynamic(name) => name,
}
}
}
impl fmt::Debug for Usecase {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Usecase").field(&self.as_str()).finish()
}
}
impl PartialEq for Usecase {
fn eq(&self, other: &Self) -> bool {
self.as_str() == other.as_str()
}
}
impl Eq for Usecase {}
impl PartialOrd for Usecase {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for Usecase {
fn cmp(&self, other: &Self) -> Ordering {
self.as_str().cmp(other.as_str())
}
}
impl Hash for Usecase {
fn hash<H: Hasher>(&self, state: &mut H) {
self.as_str().hash(state);
}
}
impl AsRef<str> for Usecase {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl Borrow<str> for Usecase {
fn borrow(&self) -> &str {
self.as_str()
}
}
impl fmt::Display for Usecase {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl FromStr for Usecase {
type Err = InvalidUsecaseName;
fn from_str(name: &str) -> Result<Self, Self::Err> {
Self::new(name)
}
}
impl TryFrom<&str> for Usecase {
type Error = InvalidUsecaseName;
fn try_from(name: &str) -> Result<Self, Self::Error> {
Self::new(name)
}
}
impl TryFrom<String> for Usecase {
type Error = InvalidUsecaseName;
fn try_from(name: String) -> Result<Self, Self::Error> {
Self::new(name)
}
}
impl From<Usecase> for String {
fn from(name: Usecase) -> Self {
name.as_str().to_owned()
}
}
impl Serialize for Usecase {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(self.as_str())
}
}
impl<'de> Deserialize<'de> for Usecase {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_str(UsecaseVisitor)
}
}
#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
pub enum InvalidUsecaseName {
#[error("{message}", message = INVALID_LENGTH)]
InvalidLength,
#[error("{message}, at position {0}", message = INVALID_CHAR)]
InvalidChar(usize),
}
const fn validate(name: &str) -> Result<(), InvalidUsecaseName> {
let bytes = name.as_bytes();
if bytes.len() < MIN_USECASE_NAME_LENGTH || bytes.len() > MAX_USECASE_NAME_LENGTH {
return Err(InvalidUsecaseName::InvalidLength);
}
let mut i = 0;
while i < bytes.len() {
let b = bytes[i];
if !b.is_ascii_alphanumeric() && b != b'_' && b != b'-' {
return Err(InvalidUsecaseName::InvalidChar(i));
}
i += 1;
}
Ok(())
}
struct UsecaseVisitor;
impl serde::de::Visitor<'_> for UsecaseVisitor {
type Value = Usecase;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("a usecase name")
}
fn visit_str<E>(self, name: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Usecase::new(name).map_err(E::custom)
}
fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
let name = std::str::from_utf8(bytes)
.map_err(|_| E::invalid_value(serde::de::Unexpected::Bytes(bytes), &self))?;
self.visit_str(name)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn validates_names() {
for name in [
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-",
"___",
] {
assert_eq!(Usecase::new(name).unwrap().as_str(), name);
}
for name in ["", "_", "ab", &"a".repeat(65)] {
assert_eq!(Usecase::new(name), Err(InvalidUsecaseName::InvalidLength));
}
for (name, position) in [
("testing/org=999/injected", 7),
("test.name", 4),
("test name", 4),
("café", 3),
("ab€cd", 2),
("ab🦀cd", 2),
] {
assert_eq!(
Usecase::new(name),
Err(InvalidUsecaseName::InvalidChar(position))
);
}
assert_eq!(
InvalidUsecaseName::InvalidChar(7).to_string(),
"invalid usecase name: expected ASCII letters, digits, '_' or '-', at position 7"
);
}
#[test]
fn from_static_validates_in_const_context() {
const NAME: Usecase = Usecase::from_static("debug-files");
assert_eq!(NAME.as_str(), "debug-files");
}
#[test]
#[should_panic(expected = "invalid usecase name")]
fn from_static_panics_on_invalid_name() {
Usecase::from_static("testing/org=999/injected");
}
#[test]
fn static_and_dynamic_names_are_equal() {
use std::collections::HashSet;
let dynamic = Usecase::new("debug-files").unwrap();
let static_ = Usecase::from_static("debug-files");
assert_eq!(dynamic, static_);
assert_eq!(dynamic.cmp(&static_), Ordering::Equal);
assert_eq!(format!("{dynamic:?}"), r#"Usecase("debug-files")"#);
assert_eq!(format!("{static_:?}"), r#"Usecase("debug-files")"#);
let set = HashSet::from([dynamic]);
assert!(set.contains(&static_));
assert!(set.contains("debug-files"));
}
#[test]
fn serde_validates_and_uses_strings() {
let name = Usecase::new("Debug_Files-123").unwrap();
let serialized = serde_json::to_string(&name).unwrap();
assert_eq!(serialized, r#""Debug_Files-123""#);
assert_eq!(serde_json::from_str::<Usecase>(&serialized).unwrap(), name);
let escaped = r#""Debug\u005fFiles-123""#;
assert_eq!(serde_json::from_str::<Usecase>(escaped).unwrap(), name);
assert!(serde_json::from_str::<Usecase>(r#""_""#).is_err());
}
#[test]
fn string_conversions_preserve_names() {
let input = "Debug_Files-123";
let name: Usecase = input.parse().unwrap();
assert_eq!(name.as_ref(), input);
assert_eq!(name.to_string(), input);
let owned = String::from(name);
assert_eq!(Usecase::try_from(owned).unwrap().as_str(), input);
}
}