use crate::ServiceError;
#[cfg(feature = "parse")]
use crate::Value;
#[cfg(feature = "parse")]
use ron::value::Value as RonValue;
#[derive(Clone, Debug)]
pub struct RegistryEntry {
pub filename: String,
pub data: Vec<u8>,
}
#[cfg(feature = "parse")]
pub fn parse_registry_data(bytes: &[u8]) -> Result<Value, ServiceError> {
let s = std::str::from_utf8(bytes).map_err(|e| {
ServiceError::ParseError(format!("registry data is not valid UTF-8: {e}"))
})?;
let ron_value: RonValue = ron::from_str(s).map_err(|e| {
ServiceError::ParseError(format!("failed to parse registry data: {e}"))
})?;
Ok(convert_ron_value(ron_value))
}
#[cfg(feature = "parse")]
pub fn parse_registry_list(bytes: &[u8]) -> Result<Vec<Value>, ServiceError> {
let root = parse_registry_data(bytes)?;
match root {
Value::Array(arr) => Ok(arr),
other => Err(ServiceError::TypeMismatch {
expected: "array".into(),
found: format!("{other:?}"),
}),
}
}
#[cfg(feature = "parse")]
fn convert_ron_value(v: RonValue) -> Value {
match v {
RonValue::Unit => Value::Null,
RonValue::Bool(b) => Value::Bool(b),
RonValue::Number(n) => {
match n {
ron::value::Number::I32(i) => Value::I32(i),
ron::value::Number::I64(i) => {
if let Ok(n) = i32::try_from(i) {
Value::I32(n)
} else {
Value::F64(i as f64)
}
}
ron::value::Number::F32(f) => Value::F64(f64::from(f.0)),
ron::value::Number::F64(f) => Value::F64(f.0),
ron::value::Number::U32(u) => Value::U32(u),
ron::value::Number::U64(u) => {
if let Ok(n) = u32::try_from(u) {
Value::U32(n)
} else {
Value::F64(u as f64)
}
}
ron::value::Number::I8(i) => Value::I32(i32::from(i)),
ron::value::Number::I16(i) => Value::I32(i32::from(i)),
ron::value::Number::U8(u) => Value::U32(u32::from(u)),
ron::value::Number::U16(u) => Value::U32(u32::from(u)),
#[allow(unreachable_patterns)]
_ => Value::Null,
}
}
RonValue::Char(c) => Value::String(c.to_string()),
RonValue::String(s) => Value::String(s),
RonValue::Bytes(b) => Value::Bytes(b),
RonValue::Seq(arr) => {
Value::Array(arr.into_iter().map(convert_ron_value).collect())
}
RonValue::Map(map) => {
Value::Map(
map.into_iter()
.map(|(k, v)| (convert_ron_key(k), convert_ron_value(v)))
.collect(),
)
}
RonValue::Option(Some(v)) => convert_ron_value(*v),
RonValue::Option(None) => Value::Null,
}
}
#[cfg(feature = "parse")]
fn convert_ron_key(k: RonValue) -> String {
match k {
RonValue::String(s) => s,
RonValue::Char(c) => c.to_string(),
other => format!("{other:?}"),
}
}
#[cfg(test)]
#[cfg(feature = "parse")]
mod tests {
use super::*;
#[test]
fn test_parse_registry_data_object() {
let ron = br#"ItemDef(id: 1, name: "Wood")"#;
let value = parse_registry_data(ron).unwrap();
assert_eq!(value.get("id").unwrap().as_u32().unwrap(), 1);
assert_eq!(value.get("name").unwrap().as_str().unwrap(), "Wood");
}
#[test]
fn test_parse_registry_data_array() {
let ron = br#"[1, 2, 3]"#;
let value = parse_registry_data(ron).unwrap();
assert_eq!(value.as_array().unwrap().len(), 3);
}
#[test]
fn test_parse_registry_list_ok() {
let ron = br#"[ItemDef(id: 1), ItemDef(id: 2)]"#;
let items = parse_registry_list(ron).unwrap();
assert_eq!(items.len(), 2);
assert_eq!(items[0].get("id").unwrap().as_u32().unwrap(), 1);
}
#[test]
fn test_parse_registry_list_not_array() {
let ron = br#"ItemDef(id: 1)"#;
let err = parse_registry_list(ron).unwrap_err();
assert!(matches!(err, ServiceError::TypeMismatch { .. }));
}
#[test]
fn test_parse_invalid_ron() {
let ron = b"not valid ron {{{";
assert!(parse_registry_data(ron).is_err());
}
}