bloat-show-cli 0.1.0

The `bloat-show` command line tool: render `cargo bloat` JSON output as an interactive HTML treemap
//! `bloat-show` -- render `cargo bloat` JSON as an HTML treemap.

mod output;
mod style;

use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::process::ExitCode;

use anyhow::Result;
use bloat_show::{RenderOptions, render};
use clap::Parser;

use crate::output::RenderArgs;
use crate::style::ColorWhen;

/// Render `cargo bloat` JSON output as an interactive HTML treemap.
#[derive(Debug, Parser)]
#[command(name = "bloat-show", version, about, long_about = None)]
#[command(styles = style::clap_styles())]
#[command(after_help = concat!(
    "EXAMPLES:\n",
    "    cargo bloat --release --message-format=json -n 0 > bloat.json\n",
    "    bloat-show bloat.json --open\n\n",
    "    cargo bloat --release --message-format=json -n 0 | bloat-show - --open",
))]
struct Args {
    /// `cargo bloat` JSON file to visualize, or `-` to read standard input
    #[arg(value_name = "INPUT")]
    input: PathBuf,

    #[command(flatten)]
    render: RenderArgs,

    /// Coloring
    #[arg(long, value_name = "WHEN")]
    color: Option<ColorWhen>,
}

fn main() -> ExitCode {
    // Before parsing: clap colours its own help and errors with this choice.
    let argv: Vec<OsString> = std::env::args_os().collect();
    style::init(style::peek(&argv));

    match run(Args::parse_from(argv)) {
        Ok(()) => ExitCode::SUCCESS,
        Err(err) => {
            style::report(&err);
            ExitCode::FAILURE
        }
    }
}

fn run(args: Args) -> Result<()> {
    let from_stdin = args.input == Path::new("-");
    let (data, _raw) = output::read_input(&args.input)?;

    let options = RenderOptions {
        // The JSON says nothing about which package it describes.
        title: match args.input.file_stem().filter(|_| !from_stdin) {
            Some(stem) => format!("Bloat: {}", stem.to_string_lossy()),
            None => "Cargo Bloat Treemap".to_owned(),
        },
        meta: match from_stdin {
            true => "from stdin".to_owned(),
            false => format!("from {}", args.input.display()),
        },
    };

    output::deliver(&args.render, &render(&data, &options), &data)
}

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

    #[test]
    fn cli_definition_is_valid() {
        use clap::CommandFactory as _;
        Args::command().debug_assert();
    }
}