xtask/

autogen.rs

//! Generators for synthetic test documents, invoked as `cargo xtask autogen
//! <command>`. Output is JSON (blockworx's document format), or a `.bwx.zip`
//! container the web shell's File ▸ Import takes; the scene is built by
//! [`blockworx_doc::fixtures::scale`], so the file written here and the scene
//! the editor's tests lower in-process cannot drift apart. See
//! `docs/json-format.md` for the format.

use std::fs;
use std::path::{Path, PathBuf};

use anyhow::{Context, Result};
use blockworx_doc::document::Document;
use blockworx_doc::fixtures::scale::build_scale;
use blockworx_store::handle::{Clock, Store};
use blockworx_store::record::Identity;
use blockworx_store::storage::{Memory, Name, ready_now};
use blockworx_store::transfer;
use clap::{Args, Subcommand};

#[derive(Subcommand)]
pub enum AutogenCmd {
    /// Emit a square N×N grid of identical `Add` blocks, fully wired — with
    /// every wire's corners stored, as a saved document has them — to stress
    /// the router and editor.
    Scale(ScaleArgs),
    /// Pack a JSON document into a `.bwx.zip` container the web shell's
    /// File ▸ Import takes.
    Pack(PackArgs),
}

#[derive(Args)]
pub struct PackArgs {
    /// The JSON document to pack.
    input: PathBuf,
    /// Destination `.bwx.zip`.
    output: PathBuf,
}

#[derive(Args)]
pub struct ScaleArgs {
    /// Grid dimension: build an N×N grid of blocks.
    n: usize,
    /// Destination: a `.zip` (e.g. `scale.bwx.zip`) is written as an
    /// importable container, anything else as a JSON document.
    output: PathBuf,
}

/// What a destination is written as, told by its extension.
enum Form {
    Json,
    Archive,
}

impl Form {
    fn of(output: &Path) -> Self {
        let zipped = output
            .extension()
            .is_some_and(|ext| ext.eq_ignore_ascii_case("zip"));
        if zipped { Self::Archive } else { Self::Json }
    }
}

pub fn run(cmd: &AutogenCmd) -> Result<()> {
    match cmd {
        AutogenCmd::Scale(args) => scale(args),
        AutogenCmd::Pack(args) => pack(args),
    }
}

fn pack(args: &PackArgs) -> Result<()> {
    let read =
        fs::read(&args.input).with_context(|| format!("reading {}", args.input.display()))?;
    let document: Document = serde_json::from_slice(&read)
        .with_context(|| format!("{} is not a document", args.input.display()))?;
    let bytes = archive(&document, &container_name(&args.output)?)?;
    write(&args.output, &bytes)?;
    eprintln!(
        "packed {} ({} blocks, {} bytes) into {}",
        args.input.display(),
        document.blocks().count(),
        bytes.len(),
        args.output.display()
    );
    Ok(())
}

fn write(output: &Path, bytes: &[u8]) -> Result<()> {
    if let Some(dir) = output.parent().filter(|dir| !dir.as_os_str().is_empty()) {
        fs::create_dir_all(dir).with_context(|| format!("creating {}", dir.display()))?;
    }
    fs::write(output, bytes).with_context(|| format!("writing {}", output.display()))
}

fn scale(args: &ScaleArgs) -> Result<()> {
    let n = args.n;
    if n == 0 {
        anyhow::bail!("grid dimension N must be at least 1");
    }

    let document = settled(build_scale(n))?;
    let bytes = match Form::of(&args.output) {
        Form::Json => {
            let mut json = serde_json::to_string_pretty(&document)
                .context("serializing the generated document")?;
            json.push('\n');
            json.into_bytes()
        }
        Form::Archive => archive(&document, &container_name(&args.output)?)?,
    };
    write(&args.output, &bytes)?;
    let blocks = n * n;
    eprintln!(
        "wrote autogen scale ({n}×{n} = {blocks} blocks, {} bytes) to {}",
        bytes.len(),
        args.output.display()
    );
    Ok(())
}

/// `document` with its wires' corners stored, as a document the editor saved
/// carries them — without them, opening it routes every wire.
fn settled(document: Document) -> Result<Document> {
    blockworx_editor::widget::drawing::settle_corners(document)
        .map_err(|refusal| anyhow::anyhow!("storing the wires' corners: {refusal}"))
}

/// The container an archive at `output` carries, named as the web shell's
/// import names it: `scale.bwx.zip` carries `scale.bwx`.
fn container_name(output: &Path) -> Result<Name> {
    output
        .file_name()
        .and_then(|file| file.to_str())
        .and_then(Name::of_archive)
        .with_context(|| format!("{} names no diagram", output.display()))
}

/// `document` as a packed container: one seeded rev creating all of it, and
/// its projection beside it.
fn archive(document: &Document, name: &Name) -> Result<Vec<u8>> {
    let label = format!("Generated {name}");
    let commits: Vec<_> = document.creating_commit(&label).into_iter().collect();
    let storage = Memory::new(name.as_str());
    Store::seeded(
        storage.clone(),
        Clock::System,
        &commits,
        &Identity::new("cargo xtask autogen"),
    )
    .context("seeding the container")?;
    ready_now(transfer::pack(&storage)).context("packing the container")
}

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

    #[test]
    fn a_scale_archive_unpacks_into_a_container_holding_the_grid() {
        let n = 3;
        let generated = build_scale(n);
        assert_eq!(
            generated.blocks().count(),
            n * n + 1,
            "precondition: the grid's blocks and the sheet wrapping them",
        );
        let name = container_name(Path::new("target/autogen/scale-3.bwx.zip")).expect("a name");
        assert_eq!(name.as_str(), "scale-3.bwx");

        let packed = archive(&generated, &name).expect("the archive");
        let arrived = Memory::new(name.as_str());
        ready_now(transfer::unpack(&arrived, &packed)).expect("the archive lays down");
        let opened = Store::open(arrived, Clock::System).expect("a container");

        assert!(
            opened.read_only_reason().is_none(),
            "the container verifies"
        );
        assert_eq!(opened.document().blocks().count(), n * n + 1);
        assert_eq!(opened.document(), &generated);
    }

    #[test]
    fn the_destination_extension_picks_the_form() {
        assert!(matches!(
            Form::of(Path::new("scale.bwx.zip")),
            Form::Archive
        ));
        assert!(matches!(Form::of(Path::new("scale.ZIP")), Form::Archive));
        assert!(matches!(Form::of(Path::new("scale.json")), Form::Json));
    }
}