anesis 0.12.3

CLI for scaffolding projects from remote templates and extending them with project addons
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use std::{
  collections::HashMap,
  path::{Path, PathBuf},
  process::Command,
};

use anyhow::{Context, Result, bail};
use colored::Colorize;

use crate::{context::AppContext, utils::fs::copy_dir_respecting_gitignore};

use super::runner::run_addon_command;

/// Runs an addon command against a throwaway copy of a fixture project and prints
/// the resulting diff, leaving the original untouched. Used to preview what an
/// addon does before applying it for real.
pub async fn test_addon(
  ctx: &AppContext,
  addon_id: &str,
  command: &str,
  project: Option<String>,
) -> Result<()> {
  let fixture = resolve_fixture(ctx, addon_id, project)?;

  // Two identical gitignore-respecting copies: run the addon on `work`, diff it
  // against the pristine `baseline`. Copying both the same way means anything the
  // addon didn't touch (node_modules, build output) is identical on both sides and
  // never shows up in the diff — no exclude guessing needed.
  let baseline = tempfile::Builder::new()
    .prefix("anesis-test-base-")
    .tempdir()?;
  let work = tempfile::Builder::new()
    .prefix("anesis-test-work-")
    .tempdir()?;
  copy_dir_respecting_gitignore(&fixture, baseline.path())
    .with_context(|| format!("failed to copy fixture from {}", fixture.display()))?;
  copy_dir_respecting_gitignore(&fixture, work.path())
    .with_context(|| format!("failed to copy fixture from {}", fixture.display()))?;

  println!(
    "Testing {} {} on a copy of {} (original untouched)...\n",
    addon_id.cyan(),
    command.cyan(),
    fixture.display()
  );

  // Non-interactive, default inputs; a temp copy so nothing real is modified.
  run_addon_command(
    ctx,
    addon_id,
    command,
    work.path(),
    &HashMap::new(),
    true,
    false,
  )
  .await?;

  println!("\n{}", "Diff (changes the addon made):".bold());
  show_diff(baseline.path(), work.path());
  Ok(())
}

fn resolve_fixture(ctx: &AppContext, addon_id: &str, project: Option<String>) -> Result<PathBuf> {
  if let Some(p) = project {
    let path = PathBuf::from(&p);
    if !path.is_dir() {
      bail!("--project '{p}' is not a directory");
    }
    return Ok(path);
  }
  // Fall back to a `test-fixture/` dir shipped alongside the cached addon.
  let fixture = ctx.paths.addons.join(addon_id).join("test-fixture");
  if fixture.is_dir() {
    return Ok(fixture);
  }
  bail!(
    "No fixture project. Pass --project <path> or ship a 'test-fixture/' directory with the addon."
  )
}

fn show_diff(baseline: &Path, work: &Path) {
  // Skip anesis.lock: its rollback journal embeds file contents as byte arrays,
  // which would bury the addon's actual code changes under thousands of noise lines.
  match Command::new("diff")
    .arg("-ruN")
    .arg("-x")
    .arg("anesis.lock")
    .arg(baseline)
    .arg(work)
    .output()
  {
    // diff exits 0 when identical, 1 when they differ; both are success for us.
    Ok(out) => {
      let text = String::from_utf8_lossy(&out.stdout);
      if text.trim().is_empty() {
        println!("(the addon made no changes)");
      } else {
        print!("{text}");
      }
    }
    Err(_) => eprintln!("(system 'diff' not available; cannot show changes)"),
  }
}