use std::fmt;
use std::hash::{Hash, Hasher};
#[derive(Clone)]
pub struct Secret<T>(T);
impl<T> Secret<T> {
pub const fn new(value: T) -> Self {
Self(value)
}
pub const fn expose(&self) -> &T {
&self.0
}
pub fn into_inner(self) -> T {
self.0
}
pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Secret<U> {
Secret(f(self.0))
}
pub const fn as_ref(&self) -> &T {
&self.0
}
}
impl<T: Default> Default for Secret<T> {
fn default() -> Self {
Self(T::default())
}
}
impl<T> From<T> for Secret<T> {
fn from(value: T) -> Self {
Self(value)
}
}
impl<T> AsRef<T> for Secret<T> {
fn as_ref(&self) -> &T {
&self.0
}
}
impl<T> fmt::Debug for Secret<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Secret([REDACTED])")
}
}
impl<T> fmt::Display for Secret<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("[REDACTED]")
}
}
impl<T: PartialEq> PartialEq for Secret<T> {
fn eq(&self, other: &Self) -> bool {
self.0 == other.0
}
}
impl<T: Eq> Eq for Secret<T> {}
impl<T: Hash> Hash for Secret<T> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.0.hash(state);
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::hash_map::DefaultHasher;
#[test]
fn debug_is_redacted() {
let s = Secret::new("password123".to_owned());
assert_eq!(format!("{s:?}"), "Secret([REDACTED])");
}
#[test]
fn display_is_redacted() {
let s = Secret::new("password123".to_owned());
assert_eq!(format!("{s}"), "[REDACTED]");
}
#[test]
fn expose_returns_inner() {
let s = Secret::new(42u32);
assert_eq!(*s.expose(), 42);
}
#[test]
fn into_inner_consumes() {
let s = Secret::new("token".to_owned());
let inner: String = s.into_inner();
assert_eq!(inner, "token");
}
#[test]
fn map_transforms() {
let s = Secret::new("abc".to_owned());
let len = s.map(|s| s.len());
assert_eq!(*len.expose(), 3);
assert_eq!(format!("{len:?}"), "Secret([REDACTED])");
}
#[test]
fn clone_works() {
let s = Secret::new("x".to_owned());
let s2 = s.clone();
assert_eq!(s, s2);
}
#[test]
fn partial_eq_compares_inner() {
assert_eq!(Secret::new(1), Secret::new(1));
assert_ne!(Secret::new(1), Secret::new(2));
}
#[test]
fn from_conversion() {
let s: Secret<String> = "hello".to_owned().into();
assert_eq!(s.expose(), "hello");
}
#[test]
fn as_ref_works() {
let s = Secret::new(vec![1, 2, 3]);
let v: &Vec<i32> = s.as_ref();
assert_eq!(v.len(), 3);
}
#[test]
fn default_works() {
let s: Secret<String> = Secret::default();
assert_eq!(s.expose(), "");
}
#[test]
fn hash_delegates_to_inner() {
let mut h1 = DefaultHasher::new();
let mut h2 = DefaultHasher::new();
Secret::new("same").hash(&mut h1);
"same".hash(&mut h2);
assert_eq!(h1.finish(), h2.finish());
}
#[test]
fn secret_is_send_sync_when_t_is() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<Secret<String>>();
assert_send_sync::<Secret<u64>>();
}
#[test]
fn nested_secret_still_redacted() {
let s = Secret::new(Secret::new("deep".to_owned()));
assert_eq!(format!("{s:?}"), "Secret([REDACTED])");
assert_eq!(s.expose().expose(), "deep");
}
#[test]
fn as_ref_borrows_without_consuming() {
let s = Secret::new("test".to_owned());
assert_eq!(s.as_ref().len(), 4);
assert_eq!(s.expose(), "test");
}
#[test]
fn as_ref_returns_inner_reference() {
let s = Secret::new(vec![1, 2, 3]);
let slice: &[i32] = s.as_ref();
assert_eq!(slice, &[1, 2, 3]);
}
}