slimwasm 0.1.0

A WASM size profiler for wasm32-unknown-unknown and wasm32-wasip2 binaries
Documentation
//! Implementation of the `diff` command

use crate::analysis::{compute_diff, DiffStatus, RetainedSizeAnalyzer};
use crate::parser::parse_wasm;
use anyhow::{Context, Result};
use colored::Colorize;
use humansize::{format_size, BINARY};
use std::path::Path;

/// Run the diff command
pub fn run(old_path: &Path, new_path: &Path, limit: usize, json: bool) -> Result<()> {
    let old_parsed = parse_wasm(old_path).context("Failed to parse old WASM file")?;
    let new_parsed = parse_wasm(new_path).context("Failed to parse new WASM file")?;

    let old_analyzer = RetainedSizeAnalyzer::new(old_parsed);
    let new_analyzer = RetainedSizeAnalyzer::new(new_parsed);

    let old_analysis = old_analyzer.analyze(false);
    let new_analysis = new_analyzer.analyze(false);

    let diff = compute_diff(&old_analysis, &new_analysis);

    if json {
        output_json(&diff, limit)?;
    } else {
        output_human(&diff, limit, old_path, new_path)?;
    }

    Ok(())
}

fn output_json(diff: &crate::analysis::DiffResult, limit: usize) -> Result<()> {
    #[derive(serde::Serialize)]
    struct JsonOutput {
        old_total: u64,
        new_total: u64,
        size_delta: i64,
        items: Vec<crate::analysis::DiffItem>,
    }

    let items: Vec<_> = diff
        .items
        .iter()
        .filter(|item| !matches!(item.status, DiffStatus::Unchanged))
        .take(limit)
        .cloned()
        .collect();

    let output = JsonOutput {
        old_total: diff.old_total,
        new_total: diff.new_total,
        size_delta: diff.size_delta,
        items,
    };

    println!("{}", serde_json::to_string_pretty(&output)?);
    Ok(())
}

fn output_human(
    diff: &crate::analysis::DiffResult,
    limit: usize,
    old_path: &Path,
    new_path: &Path,
) -> Result<()> {
    println!();
    println!("{}", " WASM Size Diff ".bold().white().on_blue());
    println!();

    // File comparison header
    println!(
        "  {} {} ({})",
        "Old:".dimmed(),
        old_path.file_name().unwrap_or_default().to_string_lossy(),
        format_size(diff.old_total, BINARY)
    );
    println!(
        "  {} {} ({})",
        "New:".dimmed(),
        new_path.file_name().unwrap_or_default().to_string_lossy(),
        format_size(diff.new_total, BINARY)
    );
    println!();

    // Overall delta
    let delta_str = format_delta(diff.size_delta);
    let delta_pct = if diff.old_total > 0 {
        (diff.size_delta as f64 / diff.old_total as f64) * 100.0
    } else {
        0.0
    };

    let total_line = format!(
        "Total: {} -> {} ({} / {:+.1}%)",
        format_size(diff.old_total, BINARY),
        format_size(diff.new_total, BINARY),
        delta_str,
        delta_pct
    );

    match diff.size_delta.cmp(&0) {
        std::cmp::Ordering::Greater => println!("  {}", total_line.red()),
        std::cmp::Ordering::Less => println!("  {}", total_line.green()),
        std::cmp::Ordering::Equal => println!("  {}", total_line),
    }
    println!();

    // Changed items
    let changed: Vec<_> = diff
        .items
        .iter()
        .filter(|item| !matches!(item.status, DiffStatus::Unchanged))
        .take(limit)
        .collect();

    if changed.is_empty() {
        println!("  {}", "No changes detected.".dimmed());
        return Ok(());
    }

    println!("{}", "Changes:".bold());

    // Group by status
    let added: Vec<_> = changed
        .iter()
        .filter(|i| matches!(i.status, DiffStatus::Added))
        .collect();
    let removed: Vec<_> = changed
        .iter()
        .filter(|i| matches!(i.status, DiffStatus::Removed))
        .collect();
    let modified: Vec<_> = changed
        .iter()
        .filter(|i| matches!(i.status, DiffStatus::Changed))
        .collect();

    // Show added
    if !added.is_empty() {
        println!("\n  {} ({}):", "Added".green().bold(), added.len());
        for item in added.iter().take(limit / 3 + 1) {
            let name = truncate_name(&item.name, 50);
            println!(
                "    {} {:>10}  [{}]  {}",
                "+".green(),
                format_size(item.new_size, BINARY).green(),
                item.kind,
                name
            );
        }
    }

    // Show removed
    if !removed.is_empty() {
        println!("\n  {} ({}):", "Removed".red().bold(), removed.len());
        for item in removed.iter().take(limit / 3 + 1) {
            let name = truncate_name(&item.name, 50);
            println!(
                "    {} {:>10}  [{}]  {}",
                "-".red(),
                format_size(item.old_size, BINARY).red(),
                item.kind,
                name
            );
        }
    }

    // Show modified (sorted by delta)
    if !modified.is_empty() {
        let mut modified: Vec<_> = modified.into_iter().collect();
        modified.sort_by_key(|b| std::cmp::Reverse(b.delta.abs()));

        println!("\n  {} ({}):", "Changed".yellow().bold(), modified.len());
        for item in modified.iter().take(limit / 3 + 1) {
            let name = truncate_name(&item.name, 50);
            let delta = format_delta(item.delta);
            let arrow = if item.delta > 0 {
                "↑".red()
            } else {
                "↓".green()
            };

            println!("    {} {:>10}  [{}]  {}", arrow, delta, item.kind, name);
        }
    }

    println!();
    Ok(())
}

fn format_delta(delta: i64) -> String {
    if delta >= 0 {
        format!("+{}", format_size(delta as u64, BINARY))
    } else {
        format!("-{}", format_size((-delta) as u64, BINARY))
    }
}

fn truncate_name(name: &str, max_len: usize) -> String {
    if name.len() > max_len {
        format!("{}...", &name[..max_len - 3])
    } else {
        name.to_string()
    }
}