mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 23:24:24 +00:00
80 lines
4.1 KiB
Rust
80 lines
4.1 KiB
Rust
use serde::Deserialize;
|
|
use serde::de::DeserializeOwned;
|
|
use serde_json::Value;
|
|
|
|
use crate::{COMPOSITE, Error, FULL_COMPOSITE, Limits, Manifest, Step, THUMB, migrate, parse_manifest};
|
|
|
|
/// Reads manifest JSON into a [`Manifest`] whose document is `D`.
|
|
///
|
|
/// 1. [`parse_manifest`] checks `json` against `limits` and parses it.
|
|
/// 2. [`migrate`] refuses a `format_version` newer than `target` with [`Error::TooNew`], which
|
|
/// holds the manifest's `generator`, and upgrades an older one with `steps`.
|
|
/// 3. The members are read in the order the parsed JSON object holds them, the document as `D`.
|
|
///
|
|
/// A missing `thumbnail` or `composite` reads as `None`, and members the envelope does not name
|
|
/// are skipped. A missing or invalid `format_version` is [`Error::Corrupt`], from [`migrate`].
|
|
/// Any other member of the wrong type is [`Error::Json`], and so is a missing `generator` or
|
|
/// `document`, which is reported after the members that are present, in the order serde's derived
|
|
/// `Deserialize` reports them. A `thumbnail` other than [`THUMB`] or a `composite` other than
|
|
/// [`COMPOSITE`] is [`Error::Corrupt`], checked after the members are read.
|
|
/// A missing or null `full_composite` reads as `None`; any path other than [`FULL_COMPOSITE`]
|
|
/// is [`Error::Corrupt`], and a value of the wrong type is [`Error::Json`].
|
|
pub fn read_manifest<D: DeserializeOwned, E: From<Error>>(json: &[u8], limits: &Limits, steps: &[Step<E>], target: u32) -> Result<Manifest<D>, E> {
|
|
read_manifest_with(json, limits, steps, target, |document| serde_json::from_value(document).map_err(|e| E::from(Error::Json(e))))
|
|
}
|
|
|
|
/// [`read_manifest`], with the document read by `document` from its JSON value instead of by
|
|
/// `D`'s `Deserialize`, for example to decode a deep tree a level at a time.
|
|
pub fn read_manifest_with<D, E: From<Error>>(
|
|
json: &[u8],
|
|
limits: &Limits,
|
|
steps: &[Step<E>],
|
|
target: u32,
|
|
document: impl FnOnce(Value) -> Result<D, E>,
|
|
) -> Result<Manifest<D>, E> {
|
|
let mut read_document = Some(document);
|
|
let mut value = parse_manifest(json, limits)?;
|
|
migrate(&mut value, steps, target)?;
|
|
let Value::Object(members) = value else {
|
|
return Err(Error::Corrupt("the manifest is not a JSON object".to_owned()).into());
|
|
};
|
|
let (mut format_version, mut generator, mut doc, mut thumbnail, mut composite) = (None, None, None, None, None);
|
|
let mut full_composite = None;
|
|
for (name, member) in members {
|
|
match name.as_str() {
|
|
"format_version" => format_version = Some(u32::deserialize(member).map_err(Error::Json)?),
|
|
"generator" => generator = Some(String::deserialize(member).map_err(Error::Json)?),
|
|
"document" => {
|
|
if let Some(read) = read_document.take() {
|
|
doc = Some(read(member)?);
|
|
}
|
|
}
|
|
"thumbnail" => thumbnail = Option::<String>::deserialize(member).map_err(Error::Json)?,
|
|
"composite" => composite = Option::<String>::deserialize(member).map_err(Error::Json)?,
|
|
"full_composite" => full_composite = Option::<String>::deserialize(member).map_err(Error::Json)?,
|
|
_ => {}
|
|
}
|
|
}
|
|
let missing = |name| Error::Json(serde::de::Error::missing_field(name));
|
|
let manifest = Manifest {
|
|
format_version: format_version.ok_or_else(|| missing("format_version"))?,
|
|
generator: generator.ok_or_else(|| missing("generator"))?,
|
|
document: doc.ok_or_else(|| missing("document"))?,
|
|
thumbnail,
|
|
composite,
|
|
full_composite,
|
|
};
|
|
check_preview("thumbnail", manifest.thumbnail.as_deref(), THUMB)?;
|
|
check_preview("composite", manifest.composite.as_deref(), COMPOSITE)?;
|
|
check_preview("full_composite", manifest.full_composite.as_deref(), FULL_COMPOSITE)?;
|
|
Ok(manifest)
|
|
}
|
|
|
|
/// Refuses a preview member that names an entry other than `expected`.
|
|
fn check_preview(member: &str, entry: Option<&str>, expected: &str) -> Result<(), Error> {
|
|
match entry {
|
|
Some(entry) if entry != expected => Err(Error::Corrupt(format!("`{member}` names {entry:?}, not {expected:?}"))),
|
|
_ => Ok(()),
|
|
}
|
|
}
|