frdt 0.3.0

Edit and inspect Resonite FrDT (.brson) documents without expanding them to JSON
Documentation
//! A document with one empty root slot, laid out the way Resonite writes one.

use crate::bson::{self, DocBuf, DOUBLE};
use crate::error::{Error, Result};
use crate::ids::new_guid;

/// `VersionNumber` must start with `year.month.day`, each part digits only.
/// Up to four parts are accepted, as Resonite writes them.
pub fn check_version(version: &str) -> Result<()> {
    let parts: Vec<&str> = version.split('.').collect();
    let ok = (3..=4).contains(&parts.len())
        && parts
            .iter()
            .all(|p| !p.is_empty() && p.bytes().all(|b| b.is_ascii_digit()));
    if ok {
        Ok(())
    } else {
        Err(Error::Invalid(format!(
            "VersionNumber {version:?} is not year.month.day[.build]"
        )))
    }
}

pub fn empty_bson<I, K>(root_name: &str, version: &str, flags: I) -> Result<Vec<u8>>
where
    I: IntoIterator<Item = (K, i64)>,
    K: AsRef<str>,
{
    check_version(version)?;
    let mut flags_doc = DocBuf::new();
    for (name, value) in flags {
        flags_doc.int64(name.as_ref(), value);
    }
    // The root has no parent. Resonite writes a fresh id here.
    let slot = new_slot(root_name, &new_guid()?)?;

    let mut root = DocBuf::new();
    root.string("VersionNumber", version);
    root.doc("FeatureFlags", &flags_doc.finish());
    root.array("Types", &bson::array_of_strings(&[]));
    root.doc("TypeVersions", &DocBuf::new().finish());
    root.doc("Object", &slot);
    root.array("Assets", &bson::array_of_docs(&[]));
    Ok(root.finish())
}

/// A slot with no components and no children, in the key order and value
/// types Resonite writes: `{ID, Data}` fields, double arrays, int64.
pub fn new_slot(name: &str, parent_reference: &str) -> Result<Vec<u8>> {
    let field = |data: &dyn Fn(&mut DocBuf)| -> Result<Vec<u8>> {
        let mut d = DocBuf::new();
        d.string("ID", &new_guid()?);
        data(&mut d);
        Ok(d.finish())
    };

    let mut components = DocBuf::new();
    components.string("ID", &new_guid()?);
    components.array("Data", &bson::array_of_docs(&[]));

    let mut slot = DocBuf::new();
    slot.string("ID", &new_guid()?);
    slot.doc("Components", &components.finish());
    slot.doc(
        "Name",
        &field(&|d| {
            d.string("Data", name);
        })?,
    );
    slot.doc(
        "Tag",
        &field(&|d| {
            d.null("Data");
        })?,
    );
    slot.doc(
        "Active",
        &field(&|d| {
            d.bool("Data", true);
        })?,
    );
    slot.string("Persistent-ID", &new_guid()?);
    slot.doc(
        "Position",
        &field(&|d| {
            d.array("Data", &doubles(&[0.0, 0.0, 0.0]));
        })?,
    );
    slot.doc(
        "Rotation",
        &field(&|d| {
            d.array("Data", &doubles(&[0.0, 0.0, 0.0, 1.0]));
        })?,
    );
    slot.doc(
        "Scale",
        &field(&|d| {
            d.array("Data", &doubles(&[1.0, 1.0, 1.0]));
        })?,
    );
    slot.doc(
        "OrderOffset",
        &field(&|d| {
            d.int64("Data", 0);
        })?,
    );
    slot.string("ParentReference", parent_reference);
    slot.array("Children", &bson::array_of_docs(&[]));
    Ok(slot.finish())
}

/// A BSON array of doubles, as Resonite writes `float3` and `floatQ`.
pub fn doubles(values: &[f64]) -> Vec<u8> {
    let mut body = Vec::new();
    for (i, v) in values.iter().enumerate() {
        bson::push_element(&mut body, DOUBLE, &i.to_string(), &bson::f64_value(*v));
    }
    bson::finish_doc(&body).expect("small array")
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn version_must_start_with_a_date() {
        check_version("2026.9.18.82").unwrap();
        check_version("2024.7.20").unwrap();
        assert!(check_version("2026.9").is_err());
        assert!(check_version("v2026.9.18").is_err());
        assert!(check_version("2026.9.18.82.1").is_err());
        assert!(check_version("").is_err());
    }
}