blockworx/

cli.rs

//! The command line: the three container subcommands, their reporting, and
//! the tracing the whole binary logs through. Nothing here names a toolkit.

use clap::Parser;
use std::path::{Path, PathBuf};

#[derive(Parser)]
#[command(name = "blockworx")]
pub(crate) struct Cli {
    #[command(subcommand)]
    pub(crate) command: Command,
}

#[derive(clap::Subcommand)]
pub(crate) enum Command {
    /// Print a container's commit log — rev, time, author, kind, op count,
    /// label — oldest first, the order the file holds. Read-only: it takes
    /// no lock and repairs nothing, so it is safe to run against a
    /// container the editor has open. A log that stops verifying prints
    /// the trail up to the break, then the break.
    Log {
        /// The `.bwx` container to read.
        container: PathBuf,
    },
    /// Verify a container's log end to end: every chain link and every
    /// folded-state stamp. Opening the editor samples the stamps —
    /// recomputing one costs a pass over the whole document — so this is
    /// the fsck that proves a log whole, and the only check that names a
    /// drifted record exactly. Read-only, and exits non-zero on any fault.
    Verify {
        /// The `.bwx` container to check.
        container: PathBuf,
    },
    /// Carry a container written when revs were zstd over to gzip, which
    /// is what every build since writes and what a browser can read. Each
    /// rev lands under its new name before the old one goes, the rows are
    /// re-stamped against the bytes that are now there, and the
    /// projection is refreshed; running it twice is running it once.
    /// Takes the container's lock, so close the editor on it first.
    Migrate {
        /// The `.bwx` container to carry over.
        container: PathBuf,
    },
}

impl Command {
    pub(crate) fn run(&self) -> ! {
        match self {
            Command::Log { container } => print_log(container),
            Command::Verify { container } => print_verification(container),
            Command::Migrate { container } => migrate_container(container),
        }
    }
}

/// Carry a container over to the rev encoding this build writes. Exits
/// non-zero when anything in it did not come over, leaving the container
/// as it was found or part-way, which the next run finishes.
fn migrate_container(container: &Path) -> ! {
    let started = std::time::Instant::now();
    match blockworx_store::migrate::to_gzip(&blockworx_store::storage::Native::at(container)) {
        Ok(migrated) => {
            println!(
                "{}: {migrated}, in {:.1?}",
                container.display(),
                started.elapsed(),
            );
            std::process::exit(0);
        }
        Err(e) => {
            eprintln!("{}: {e}", container.display());
            std::process::exit(1);
        }
    }
}

/// Print a container's trail. Exits non-zero when the log does not verify
/// end to end, so a script can tell an intact trail from a damaged one.
fn print_log(container: &Path) -> ! {
    let dumped = match blockworx_store::dump::dump(&blockworx_store::storage::Native::at(container))
    {
        Ok(dumped) => dumped,
        Err(e) => {
            eprintln!("{}: {e}", container.display());
            std::process::exit(1);
        }
    };
    for line in &dumped.lines {
        println!("{line}");
    }
    match dumped.broken {
        None => std::process::exit(0),
        Some(report) => {
            eprintln!("{report:?}");
            std::process::exit(1);
        }
    }
}

/// Check a container's whole log. Exits non-zero on any fault, so a
/// script — or a bisect over app versions hunting fold drift — can use it
/// as a gate.
fn print_verification(container: &Path) -> ! {
    let started = std::time::Instant::now();
    let checked =
        match blockworx_store::dump::verify(blockworx_store::storage::Native::at(container)) {
            Ok(checked) => checked,
            Err(e) => {
                eprintln!("{}: {e}", container.display());
                std::process::exit(1);
            }
        };
    for line in &checked.lines {
        println!("{line}");
    }
    println!("in {:.1?}", started.elapsed());
    match checked.broken {
        None => std::process::exit(0),
        Some(report) => {
            eprintln!("{report:?}");
            std::process::exit(1);
        }
    }
}

/// Install the console subscriber the whole app logs through, so a failure
/// reported with `tracing::error!`/`warn!` is not swallowed. `RUST_LOG`
/// raises it: `RUST_LOG=blockworx=info` for what the store is doing,
/// `RUST_LOG=edit=debug` to narrate every document mutation (the named
/// `Drawing` setters), `edit=trace` for the per-frame drag writes.
///
/// There is no span-timing switch. `--trace` was one, and every span it
/// could close was on the frame path, which nothing here runs.
pub(crate) fn init_tracing() {
    use tracing_subscriber::EnvFilter;
    let filter =
        EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("blockworx=warn"));
    tracing_subscriber::fmt()
        .with_env_filter(filter)
        .with_target(false)
        .with_writer(std::io::stderr)
        .with_ansi(std::io::IsTerminal::is_terminal(&std::io::stderr()))
        .init();
}

#[cfg(test)]
mod tests {
    use super::{Cli, Command};
    use clap::Parser as _;

    /// Each subcommand takes the container as its one argument. The binary
    /// opens nothing — there is no window to open it in — so a bare path is
    /// not a command and must be refused rather than read as one.
    #[test]
    fn every_subcommand_names_a_container() {
        let dumped = Cli::try_parse_from(["blockworx", "log", "doc.bwx"]).expect("the dump parses");
        let Command::Log { container } = dumped.command else {
            panic!("`log` was not read as the subcommand");
        };
        assert_eq!(container, std::path::Path::new("doc.bwx"));

        let checked =
            Cli::try_parse_from(["blockworx", "verify", "doc.bwx"]).expect("so does the fsck");
        let Command::Verify { container } = checked.command else {
            panic!("`verify` was not read as the subcommand");
        };
        assert_eq!(container, std::path::Path::new("doc.bwx"));

        let carried = Cli::try_parse_from(["blockworx", "migrate", "doc.bwx"])
            .expect("and so does the carry");
        let Command::Migrate { container } = carried.command else {
            panic!("`migrate` was not read as the subcommand");
        };
        assert_eq!(container, std::path::Path::new("doc.bwx"));

        assert!(Cli::try_parse_from(["blockworx", "doc.bwx"]).is_err());
        assert!(Cli::try_parse_from(["blockworx"]).is_err());
    }
}