use std::fmt;
#[derive(Clone, PartialEq)]
#[non_exhaustive]
pub enum RedisValue {
Nil,
Int(i64),
Float(f64),
String(String),
Bytes(Vec<u8>),
Array(Vec<RedisValue>),
Bool(bool),
Map(Vec<(RedisValue, RedisValue)>),
Set(Vec<RedisValue>),
VerbatimString {
format: String,
text: String,
},
Push(Vec<RedisValue>),
Attribute {
data: Box<RedisValue>,
attributes: Vec<(RedisValue, RedisValue)>,
},
BigNumber(String),
ServerError(String),
}
impl fmt::Debug for RedisValue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
RedisValue::Nil => f.write_str("Nil"),
RedisValue::Int(value) => write!(f, "Int({value})"),
RedisValue::Float(value) => write!(f, "Float({value})"),
RedisValue::String(value) => write!(f, "String(<redacted {} bytes>)", value.len()),
RedisValue::Bytes(value) => write!(f, "Bytes(<redacted {} bytes>)", value.len()),
RedisValue::Array(values) => f.debug_list().entries(values).finish(),
RedisValue::Bool(value) => write!(f, "Bool({value})"),
RedisValue::Map(entries) => write!(f, "Map(<redacted {} entries>)", entries.len()),
RedisValue::Set(values) => write!(f, "Set(<redacted {} items>)", values.len()),
RedisValue::VerbatimString { format, text } => write!(
f,
"VerbatimString {{ format: {format:?}, text: <redacted {} bytes> }}",
text.len()
),
RedisValue::Push(values) => write!(f, "Push(<redacted {} items>)", values.len()),
RedisValue::Attribute { attributes, .. } => {
write!(f, "Attribute(<redacted {} entries>)", attributes.len())
}
RedisValue::BigNumber(value) => write!(f, "BigNumber({value})"),
RedisValue::ServerError(_) => f.write_str("ServerError(<redacted>)"),
}
}
}
impl RedisValue {
pub fn as_str(&self) -> Option<&str> {
match self {
RedisValue::String(value) => Some(value.as_str()),
RedisValue::VerbatimString { text, .. } => Some(text.as_str()),
RedisValue::BigNumber(value) => Some(value.as_str()),
_ => None,
}
}
pub fn as_string(&self) -> Option<String> {
self.as_str().map(|value| value.to_owned())
}
pub fn as_i64(&self) -> Option<i64> {
match self {
RedisValue::Int(value) => Some(*value),
RedisValue::String(value) | RedisValue::BigNumber(value) => value.parse().ok(),
RedisValue::Bytes(value) => std::str::from_utf8(value).ok()?.parse().ok(),
_ => None,
}
}
pub fn as_f64(&self) -> Option<f64> {
match self {
RedisValue::Float(value) => Some(*value),
RedisValue::String(value) | RedisValue::BigNumber(value) => value.parse().ok(),
RedisValue::Bytes(value) => std::str::from_utf8(value).ok()?.parse().ok(),
_ => None,
}
}
pub fn as_bool(&self) -> Option<bool> {
match self {
RedisValue::Bool(value) => Some(*value),
_ => None,
}
}
pub fn as_bytes(&self) -> Option<&[u8]> {
match self {
RedisValue::Bytes(value) => Some(value.as_slice()),
RedisValue::String(value) => Some(value.as_bytes()),
RedisValue::VerbatimString { text, .. } => Some(text.as_bytes()),
RedisValue::BigNumber(value) => Some(value.as_bytes()),
_ => None,
}
}
pub fn as_bytes_owned(&self) -> Option<Vec<u8>> {
self.as_bytes().map(|value| value.to_vec())
}
pub fn as_array(&self) -> Option<&[RedisValue]> {
match self {
RedisValue::Array(values) => Some(values.as_slice()),
_ => None,
}
}
pub fn is_nil(&self) -> bool {
matches!(self, RedisValue::Nil)
}
}
impl From<String> for RedisValue {
fn from(value: String) -> Self {
RedisValue::String(value)
}
}
impl From<&str> for RedisValue {
fn from(value: &str) -> Self {
RedisValue::String(value.to_string())
}
}
impl From<i64> for RedisValue {
fn from(value: i64) -> Self {
RedisValue::Int(value)
}
}
impl From<i32> for RedisValue {
fn from(value: i32) -> Self {
RedisValue::Int(value as i64)
}
}
impl From<f64> for RedisValue {
fn from(value: f64) -> Self {
RedisValue::Float(value)
}
}
impl From<bool> for RedisValue {
fn from(value: bool) -> Self {
RedisValue::Bool(value)
}
}
impl From<Vec<u8>> for RedisValue {
fn from(value: Vec<u8>) -> Self {
RedisValue::Bytes(value)
}
}
impl From<redis::Value> for RedisValue {
fn from(value: redis::Value) -> Self {
match value {
redis::Value::Nil => RedisValue::Nil,
redis::Value::Int(value) => RedisValue::Int(value),
redis::Value::BulkString(bytes) => match String::from_utf8(bytes) {
Ok(value) => RedisValue::String(value),
Err(error) => RedisValue::Bytes(error.into_bytes()),
},
redis::Value::Array(values) => {
RedisValue::Array(values.into_iter().map(RedisValue::from).collect())
}
redis::Value::SimpleString(value) => RedisValue::String(value),
redis::Value::Okay => RedisValue::Bool(true),
redis::Value::Map(entries) => RedisValue::Map(
entries
.into_iter()
.map(|(key, value)| (RedisValue::from(key), RedisValue::from(value)))
.collect(),
),
redis::Value::Attribute { data, attributes } => RedisValue::Attribute {
data: Box::new(RedisValue::from(*data)),
attributes: attributes
.into_iter()
.map(|(key, value)| (RedisValue::from(key), RedisValue::from(value)))
.collect(),
},
redis::Value::Set(values) => {
RedisValue::Set(values.into_iter().map(RedisValue::from).collect())
}
redis::Value::Double(value) => RedisValue::Float(value),
redis::Value::Boolean(value) => RedisValue::Bool(value),
redis::Value::VerbatimString { format, text } => RedisValue::VerbatimString {
format: format!("{format:?}"),
text,
},
redis::Value::BigNumber(value) => RedisValue::BigNumber(value.to_string()),
redis::Value::Push { data, .. } => {
RedisValue::Push(data.into_iter().map(RedisValue::from).collect())
}
redis::Value::ServerError(error) => RedisValue::ServerError(format!("{error:?}")),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_redis_value_nil() {
let value = RedisValue::Nil;
assert!(value.is_nil());
assert_eq!(value.as_string(), None);
assert_eq!(value.as_i64(), None);
}
#[test]
fn test_redis_value_int() {
let value = RedisValue::Int(42);
assert!(!value.is_nil());
assert_eq!(value.as_i64(), Some(42));
assert_eq!(value.as_string(), None);
}
#[test]
fn test_redis_value_float() {
let value = RedisValue::Float(123.456);
assert_eq!(value.as_f64(), Some(123.456));
assert_eq!(value.as_i64(), None);
}
#[test]
fn test_redis_value_string() {
let value = RedisValue::String("hello".to_string());
assert_eq!(value.as_str(), Some("hello"));
assert_eq!(value.as_string(), Some("hello".to_string()));
assert_eq!(value.as_i64(), None);
}
#[test]
fn test_redis_value_bool() {
let value = RedisValue::Bool(true);
assert_eq!(value.as_bool(), Some(true));
assert_eq!(value.as_string(), None);
}
#[test]
fn test_redis_value_bytes() {
let bytes = vec![1, 2, 3, 4];
let value = RedisValue::Bytes(bytes.clone());
assert_eq!(value.as_bytes(), Some(bytes.as_slice()));
assert_eq!(value.as_string(), None);
}
#[test]
fn test_redis_value_array() {
let arr = vec![
RedisValue::Int(1),
RedisValue::String("test".to_string()),
RedisValue::Nil,
];
let value = RedisValue::Array(arr.clone());
assert_eq!(value.as_array(), Some(arr.as_slice()));
assert_eq!(value.as_string(), None);
}
#[test]
fn test_from_string() {
let value: RedisValue = "hello".into();
assert_eq!(value, RedisValue::String("hello".to_string()));
let value: RedisValue = String::from("world").into();
assert_eq!(value, RedisValue::String("world".to_string()));
}
#[test]
fn test_from_int() {
let value: RedisValue = 42i64.into();
assert_eq!(value, RedisValue::Int(42));
let value: RedisValue = 100i32.into();
assert_eq!(value, RedisValue::Int(100));
}
#[test]
fn test_from_float() {
let value: RedisValue = 123.456f64.into();
assert_eq!(value, RedisValue::Float(123.456));
}
#[test]
fn test_from_bool() {
let value: RedisValue = true.into();
assert_eq!(value, RedisValue::Bool(true));
let value: RedisValue = false.into();
assert_eq!(value, RedisValue::Bool(false));
}
#[test]
fn test_from_bytes() {
let bytes = vec![1, 2, 3];
let value: RedisValue = bytes.clone().into();
assert_eq!(value, RedisValue::Bytes(bytes));
}
#[test]
fn test_from_redis_value_nil() {
let redis_val = redis::Value::Nil;
let value: RedisValue = redis_val.into();
assert_eq!(value, RedisValue::Nil);
}
#[test]
fn test_from_redis_value_int() {
let redis_val = redis::Value::Int(42);
let value: RedisValue = redis_val.into();
assert_eq!(value, RedisValue::Int(42));
}
#[test]
fn test_from_redis_value_data_utf8() {
let redis_val = redis::Value::BulkString(b"hello".to_vec());
let value: RedisValue = redis_val.into();
assert_eq!(value, RedisValue::String("hello".to_string()));
}
#[test]
fn test_from_redis_value_data_binary() {
let bytes = vec![0xFF, 0xFE, 0xFD];
let redis_val = redis::Value::BulkString(bytes.clone());
let value: RedisValue = redis_val.into();
assert_eq!(value, RedisValue::Bytes(bytes));
}
#[test]
fn test_from_redis_value_bulk() {
let redis_val = redis::Value::Array(vec![
redis::Value::Int(1),
redis::Value::BulkString(b"test".to_vec()),
]);
let value: RedisValue = redis_val.into();
if let RedisValue::Array(arr) = value {
assert_eq!(arr.len(), 2);
assert_eq!(arr[0], RedisValue::Int(1));
assert_eq!(arr[1], RedisValue::String("test".to_string()));
} else {
panic!("Expected Array");
}
}
#[test]
fn test_from_redis_value_status() {
let redis_val = redis::Value::SimpleString("OK".to_string());
let value: RedisValue = redis_val.into();
assert_eq!(value, RedisValue::String("OK".to_string()));
}
#[test]
fn test_from_redis_value_okay() {
let redis_val = redis::Value::Okay;
let value: RedisValue = redis_val.into();
assert_eq!(value, RedisValue::Bool(true));
}
#[test]
fn test_clone() {
let value = RedisValue::String("test".to_string());
let cloned = value.clone();
assert_eq!(value, cloned);
}
#[test]
fn test_debug_redacts_payloads() {
assert!(format!("{:?}", RedisValue::Int(42)).contains("42"));
assert!(format!("{:?}", RedisValue::Bool(true)).contains("true"));
let string_debug = format!("{:?}", RedisValue::String("super-secret-token".to_string()));
assert!(!string_debug.contains("super-secret-token"));
assert!(string_debug.contains("redacted"));
let bytes_debug = format!("{:?}", RedisValue::Bytes(b"super-secret".to_vec()));
assert!(!bytes_debug.contains("super-secret"));
assert!(bytes_debug.contains("redacted"));
let map_debug = format!(
"{:?}",
RedisValue::Map(vec![(
RedisValue::String("user".to_string()),
RedisValue::String("secret".to_string())
)])
);
assert!(!map_debug.contains("secret"));
assert!(map_debug.contains("redacted"));
}
#[test]
fn test_as_str() {
let value = RedisValue::String("hello".to_string());
assert_eq!(value.as_str(), Some("hello"));
let value = RedisValue::Bytes(vec![0xFF, 0xFE]);
assert_eq!(value.as_str(), None);
assert_eq!(RedisValue::Nil.as_str(), None);
assert_eq!(RedisValue::Int(1).as_str(), None);
assert_eq!(RedisValue::Float(1.0).as_str(), None);
assert_eq!(RedisValue::Bool(true).as_str(), None);
assert_eq!(RedisValue::Array(vec![]).as_str(), None);
}
#[test]
fn test_as_bytes_includes_utf8_strings() {
let value = RedisValue::String("abc".to_string());
assert_eq!(value.as_bytes(), Some(b"abc".as_slice()));
assert_eq!(
RedisValue::Bytes(vec![0xFF]).as_bytes(),
Some([0xFF].as_slice())
);
}
#[test]
fn test_as_i64_and_f64_accept_numeric_strings() {
assert_eq!(RedisValue::String("42".to_string()).as_i64(), Some(42));
assert_eq!(RedisValue::String("1.5".to_string()).as_f64(), Some(1.5));
assert_eq!(RedisValue::String("nope".to_string()).as_i64(), None);
}
#[test]
fn test_partial_eq() {
assert_eq!(RedisValue::Nil, RedisValue::Nil);
assert_eq!(RedisValue::Int(42), RedisValue::Int(42));
assert_ne!(RedisValue::Int(42), RedisValue::Int(43));
assert_ne!(RedisValue::Int(42), RedisValue::String("42".to_string()));
}
}