compass-st 1.1.2 → 1.2.0

package/cli/tests/e2e_cross_cwd.rs

@@ -0,0 +1,91 @@
+//! E2E — resolve works across cwd (shell cwd ≠ project root) + zero-effort
+//! v1.1 → v1.2 registry migration. Ported from `tests/integration/e2e_cross_cwd.sh`.
+
+#[path = "e2e_common.rs"]
+mod e2e_common;
+
+use e2e_common::{run_cli_ok, HomeGuard};
+use serde_json::Value;
+use std::fs;
+use std::path::Path;
+use tempfile::TempDir;
+
+fn json(out: &str) -> Value {
+    serde_json::from_str(out).unwrap_or_else(|e| panic!("invalid JSON: {e}\n---\n{out}"))
+}
+
+fn make_project(root: &Path, name: &str, prefix: &str) {
+    let state = root.join(".compass").join(".state");
+    fs::create_dir_all(&state).expect("mkdir .compass/.state");
+    fs::create_dir_all(root.join("prd")).expect("mkdir prd");
+    fs::create_dir_all(root.join("epics")).expect("mkdir epics");
+
+    let cfg = serde_json::json!({
+        "version": "1.2.0",
+        "project": {"name": name, "po": "@t"},
+        "lang": "en", "spec_lang": "en", "mode": "standalone",
+        "prefix": prefix, "domain": "ard",
+        "output_paths": {"prd": "prd", "story": "epics/{EPIC}/user-stories", "epic": "epics"},
+        "naming": {"prd": "{slug}.md"}
+    });
+    fs::write(
+        state.join("config.json"),
+        serde_json::to_vec_pretty(&cfg).expect("serialize config"),
+    )
+    .expect("write config.json");
+}
+
+/// Covers REQ-06, REQ-07, REQ-10 — the whole cross-cwd lifecycle as a single
+/// test since the stages share state (registry mutations accumulate).
+#[test]
+fn resolve_works_across_cwd_and_handles_v11_migration() {
+    let _g = HomeGuard::new();
+
+    let tmp = TempDir::new().expect("tempdir");
+    let dir_a = tmp.path().join("project-a");
+    let dir_b = tmp.path().join("random-dir-b");
+    fs::create_dir_all(&dir_b).expect("mkdir dir_b");
+    make_project(&dir_a, "ProjectA", "PA");
+
+    // --- Stage 1: register + activate ProjectA --------------------------
+    run_cli_ok(&["project", "add", dir_a.to_str().unwrap()]);
+    run_cli_ok(&["project", "use", dir_a.to_str().unwrap()]);
+
+    // --- Stage 2: resolve from dir_b (unrelated sibling) ----------------
+    std::env::set_current_dir(&dir_b).expect("cd dir_b");
+    let r = json(&run_cli_ok(&["project", "resolve"]));
+    assert_eq!(r["status"], "ok", "expected ok from sibling cwd; got {r}");
+    let project_root = r["project_root"].as_str().expect("project_root string");
+    assert!(
+        project_root.contains("project-a"),
+        "project_root should point at project-a, got {project_root}"
+    );
+    assert_eq!(r["name"], "ProjectA");
+
+    // --- Stage 3: resolve from /tmp (even more unrelated cwd) -----------
+    std::env::set_current_dir("/tmp").expect("cd /tmp");
+    let r = json(&run_cli_ok(&["project", "resolve"]));
+    assert_eq!(r["status"], "ok", "expected ok from /tmp; got {r}");
+
+    // --- Stage 4: writes to $PROJECT_ROOT land at dir_a ----------------
+    let prd_path = dir_a.join("prd").join("test-prd.md");
+    fs::write(&prd_path, "# test\n").expect("write PRD");
+    assert!(prd_path.exists(), "PRD should exist at {}", prd_path.display());
+
+    // --- Stage 5: zero-effort v1.1 → registry migration -----------------
+    let home = std::env::var("HOME").expect("HOME set by HomeGuard");
+    let registry = Path::new(&home).join(".compass").join("projects.json");
+    if registry.exists() {
+        fs::remove_file(&registry).expect("rm registry");
+    }
+
+    std::env::set_current_dir(&dir_a).expect("cd dir_a");
+    let r = json(&run_cli_ok(&["project", "resolve"]));
+    assert_eq!(r["status"], "ok", "auto-migrate should succeed; got {r}");
+    assert_eq!(r["migrated_from_v11"], true, "migrated_from_v11 should be true");
+    assert!(
+        registry.exists(),
+        "registry should have been auto-created at {}",
+        registry.display()
+    );
+}

package/cli/tests/e2e_fallback.rs

@@ -0,0 +1,175 @@
+//! E2E fallback — ambiguous fallback after last_active dies.
+//!
+//! Port of `tests/integration/e2e_fallback.sh`. Covers REQ-03, REQ-04, REQ-11.
+//!
+//! Scenarios exercised against `compass-cli project resolve`:
+//!   1. Happy path: last_active alive returns status=ok.
+//!   2. last_active dies → status=ambiguous, dead path pruned from registry.
+//!   3. User picks a survivor → status=ok.
+//!   4. Only one survivor left → smart auto-pick, status=ok.
+//!   5. All registry paths dead → status=none, reason=all_paths_dead.
+//!
+//! All 5 stages share state — the registry mutates progressively across
+//! stages — so they run as a single sequential test function.
+
+#[path = "e2e_common.rs"]
+mod e2e_common;
+
+use e2e_common::{run_cli_ok, HomeGuard};
+use std::fs;
+use std::path::Path;
+use tempfile::TempDir;
+
+/// Seed a minimal valid v1.2.0 project config at `<root>/.compass/.state/config.json`.
+fn make_project(root: &Path, name: &str) {
+    let state = root.join(".compass").join(".state");
+    fs::create_dir_all(&state).expect("mkdir .compass/.state");
+    let cfg = serde_json::json!({
+        "version": "1.2.0",
+        "project": { "name": name, "po": "@t" },
+        "lang": "en",
+        "spec_lang": "en",
+        "mode": "standalone",
+        "prefix": "PX",
+        "domain": "ard",
+        "output_paths": {
+            "prd": "prd",
+            "story": "epics/{EPIC}/user-stories",
+            "epic": "epics"
+        },
+        "naming": { "prd": "{slug}.md" }
+    });
+    fs::write(state.join("config.json"), cfg.to_string()).expect("write config.json");
+}
+
+#[test]
+fn fallback_full_lifecycle() {
+    let _guard = HomeGuard::new();
+
+    // Parent dir holding the 3 fake projects. Kept alive via `tmp`.
+    let tmp = TempDir::new().expect("create TMP_ROOT");
+    let alpha = tmp.path().join("proj_alpha");
+    let beta = tmp.path().join("proj_beta");
+    let gamma = tmp.path().join("proj_gamma");
+
+    // -------------------------------------------------------------------
+    // Setup — three projects, each with a valid v1.2.0 config.json.
+    // Register all three and mark beta as last_active.
+    // -------------------------------------------------------------------
+    make_project(&alpha, "proj_alpha");
+    make_project(&beta, "proj_beta");
+    make_project(&gamma, "proj_gamma");
+
+    run_cli_ok(&["project", "add", alpha.to_str().unwrap()]);
+    run_cli_ok(&["project", "add", beta.to_str().unwrap()]);
+    run_cli_ok(&["project", "add", gamma.to_str().unwrap()]);
+    run_cli_ok(&["project", "use", beta.to_str().unwrap()]);
+
+    // -------------------------------------------------------------------
+    // Test 1 — resolve happy path: last_active alive returns ok/beta.
+    // -------------------------------------------------------------------
+    let out = run_cli_ok(&["project", "resolve"]);
+    let r: serde_json::Value = serde_json::from_str(&out)
+        .unwrap_or_else(|e| panic!("T1 resolve stdout not JSON: {e}\n{out}"));
+    assert_eq!(r["status"], "ok", "T1 expected ok, got {}", r["status"]);
+    let active = r["project_root"]
+        .as_str()
+        .expect("T1 project_root missing");
+    assert!(
+        active.contains("proj_beta"),
+        "T1 expected beta active, got {active}"
+    );
+
+    // -------------------------------------------------------------------
+    // Test 2 — kill last_active, expect ambiguous with 2 survivors + pruning.
+    // -------------------------------------------------------------------
+    fs::remove_dir_all(&beta).expect("rm beta");
+    let out = run_cli_ok(&["project", "resolve"]);
+    let r: serde_json::Value = serde_json::from_str(&out)
+        .unwrap_or_else(|e| panic!("T2 resolve stdout not JSON: {e}\n{out}"));
+    assert_eq!(
+        r["status"], "ambiguous",
+        "T2 expected ambiguous, got {}",
+        r["status"]
+    );
+    let cands = r["candidates"]
+        .as_array()
+        .expect("T2 candidates not array");
+    assert_eq!(cands.len(), 2, "T2 expected 2 candidates, got {}", cands.len());
+
+    // Registry should have pruned the dead beta entry.
+    let home = std::env::var("HOME").expect("HOME set");
+    let registry_path = Path::new(&home).join(".compass").join("projects.json");
+    let registry_raw = fs::read_to_string(&registry_path).expect("read registry");
+    let registry: serde_json::Value =
+        serde_json::from_str(&registry_raw).expect("registry is JSON");
+    let paths: Vec<String> = registry["projects"]
+        .as_array()
+        .expect("projects array")
+        .iter()
+        .map(|p| p["path"].as_str().unwrap_or("").to_string())
+        .collect();
+    let joined = paths.join(",");
+    assert!(
+        !joined.contains("proj_beta"),
+        "T2 beta should have been pruned from registry, paths={joined}"
+    );
+
+    // -------------------------------------------------------------------
+    // Test 3 — user picks alpha; resolve returns ok/alpha.
+    // -------------------------------------------------------------------
+    run_cli_ok(&["project", "use", alpha.to_str().unwrap()]);
+    let out = run_cli_ok(&["project", "resolve"]);
+    let r: serde_json::Value = serde_json::from_str(&out)
+        .unwrap_or_else(|e| panic!("T3 resolve stdout not JSON: {e}\n{out}"));
+    assert_eq!(
+        r["status"], "ok",
+        "T3 expected ok after use alpha, got {}",
+        r["status"]
+    );
+    let active = r["project_root"]
+        .as_str()
+        .expect("T3 project_root missing");
+    assert!(
+        active.contains("proj_alpha"),
+        "T3 expected alpha active, got {active}"
+    );
+
+    // -------------------------------------------------------------------
+    // Test 4 — kill alpha too; only gamma survives → smart auto-pick.
+    // -------------------------------------------------------------------
+    fs::remove_dir_all(&alpha).expect("rm alpha");
+    let out = run_cli_ok(&["project", "resolve"]);
+    let r: serde_json::Value = serde_json::from_str(&out)
+        .unwrap_or_else(|e| panic!("T4 resolve stdout not JSON: {e}\n{out}"));
+    assert_eq!(
+        r["status"], "ok",
+        "T4 expected ok (smart auto-pick single survivor), got {}",
+        r["status"]
+    );
+    let active = r["project_root"]
+        .as_str()
+        .expect("T4 project_root missing");
+    assert!(
+        active.contains("proj_gamma"),
+        "T4 expected gamma active after auto-pick, got {active}"
+    );
+
+    // -------------------------------------------------------------------
+    // Test 5 — kill gamma; no survivors → status=none, reason=all_paths_dead.
+    // -------------------------------------------------------------------
+    fs::remove_dir_all(&gamma).expect("rm gamma");
+    let out = run_cli_ok(&["project", "resolve"]);
+    let r: serde_json::Value = serde_json::from_str(&out)
+        .unwrap_or_else(|e| panic!("T5 resolve stdout not JSON: {e}\n{out}"));
+    assert_eq!(
+        r["status"], "none",
+        "T5 expected none, got {}",
+        r["status"]
+    );
+    assert_eq!(
+        r["reason"], "all_paths_dead",
+        "T5 expected all_paths_dead, got {}",
+        r["reason"]
+    );
+}

package/cli/tests/e2e_migrate_v05.rs

@@ -0,0 +1,299 @@
+//! E2E test for `compass-cli migrate` (v0.5 -> v1.0).
+//!
+//! Port of `tests/integration/e2e_migrate_v05.sh`. Covers REQ-06:
+//!
+//!   1. First migrate rewrites every session's `plan.json` to `plan_version:
+//!      "1.0"`, writes a `plan.v0.json` backup equal to the original plan, and
+//!      creates `.compass/.state/project-memory.json`.
+//!   2. Each migrated plan validates via `compass-cli validate plan`.
+//!   3. A second migrate is a no-op: exit 0, logs "already v1.0, no-op" for
+//!      each session, no `plan.v0.plan.v0.json` double-backup, and backup
+//!      mtimes unchanged.
+//!
+//! Each test stages its OWN copy of the fixture into a fresh tempdir so the
+//! tests are safe under `cargo test` parallelism.
+
+#[path = "e2e_common.rs"]
+mod e2e_common;
+
+use std::path::{Path, PathBuf};
+
+use e2e_common::{fixture_root, run_cli};
+
+/// Recursively copy `src` into `dst`. `dst` is created if it does not exist.
+/// Rust stdlib has no such helper, hence this tiny clone of `cp -R src/. dst/`.
+fn copy_dir_recursive(src: &Path, dst: &Path) -> std::io::Result<()> {
+    std::fs::create_dir_all(dst)?;
+    for entry in std::fs::read_dir(src)? {
+        let entry = entry?;
+        let target = dst.join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_dir_recursive(&entry.path(), &target)?;
+        } else {
+            std::fs::copy(entry.path(), &target)?;
+        }
+    }
+    Ok(())
+}
+
+/// Stage the v0 fixture into a fresh tempdir. Returns `(TempDir guard,
+/// work_dir)`. Keep the guard alive for the duration of the test.
+fn setup() -> (tempfile::TempDir, PathBuf) {
+    let tmp = tempfile::tempdir().expect("create tempdir for migrate e2e");
+    let work_dir = tmp.path().join("compass-migrate-test");
+    let fixture_src = fixture_root().join("v0_project");
+    assert!(
+        fixture_src.is_dir(),
+        "fixture missing: {}",
+        fixture_src.display()
+    );
+    copy_dir_recursive(&fixture_src, &work_dir).expect("copy v0 fixture into tempdir");
+    (tmp, work_dir)
+}
+
+/// List session directories under `<work_dir>/.compass/.state/sessions`, sorted
+/// lexicographically (matching the bash `find ... | sort`).
+fn list_sessions(work_dir: &Path) -> Vec<PathBuf> {
+    let base = work_dir.join(".compass").join(".state").join("sessions");
+    let mut out: Vec<PathBuf> = std::fs::read_dir(&base)
+        .unwrap_or_else(|e| panic!("read_dir {}: {e}", base.display()))
+        .filter_map(|e| e.ok())
+        .filter(|e| e.file_type().map(|t| t.is_dir()).unwrap_or(false))
+        .map(|e| e.path())
+        .collect();
+    out.sort();
+    out
+}
+
+/// Read a top-level string field from a JSON file.
+fn read_json_string_field(path: &Path, field: &str) -> Option<String> {
+    let raw = std::fs::read_to_string(path).ok()?;
+    let v: serde_json::Value = serde_json::from_str(&raw).ok()?;
+    v.get(field).and_then(|x| x.as_str()).map(str::to_string)
+}
+
+#[test]
+fn first_migrate_rewrites_plans_and_creates_memory() {
+    let (_guard, work_dir) = setup();
+
+    let sessions = list_sessions(&work_dir);
+    assert!(
+        sessions.len() >= 2,
+        "fixture should provide >= 2 session dirs, got {}",
+        sessions.len()
+    );
+
+    // Capture originals + assert precondition plan_version == "0.5".
+    let mut originals: Vec<String> = Vec::with_capacity(sessions.len());
+    for sd in &sessions {
+        let plan_path = sd.join("plan.json");
+        let orig = std::fs::read_to_string(&plan_path)
+            .unwrap_or_else(|e| panic!("read {}: {e}", plan_path.display()));
+        let v = read_json_string_field(&plan_path, "plan_version");
+        assert_eq!(
+            v.as_deref(),
+            Some("0.5"),
+            "fixture precondition: {} expected plan_version 0.5, got {:?}",
+            plan_path.display(),
+            v
+        );
+        originals.push(orig);
+    }
+
+    // Run migrate — must exit 0.
+    let out = run_cli(&["migrate", work_dir.to_str().unwrap()]);
+    assert!(
+        out.status.success(),
+        "first migrate expected exit 0, got {:?}\nstdout: {}\nstderr: {}",
+        out.status,
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr),
+    );
+
+    // Per-session assertions: plan.json is v1.0, plan.v0.json matches original.
+    for (i, sd) in sessions.iter().enumerate() {
+        let plan_path = sd.join("plan.json");
+        let backup_path = sd.join("plan.v0.json");
+
+        assert!(
+            plan_path.is_file(),
+            "plan.json missing after migrate: {}",
+            plan_path.display()
+        );
+        assert!(
+            backup_path.is_file(),
+            "plan.v0.json backup missing after migrate: {}",
+            backup_path.display()
+        );
+
+        let v = read_json_string_field(&plan_path, "plan_version");
+        assert_eq!(
+            v.as_deref(),
+            Some("1.0"),
+            "expected plan_version 1.0 in {}, got {:?}",
+            plan_path.display(),
+            v
+        );
+
+        let backup_raw = std::fs::read_to_string(&backup_path)
+            .unwrap_or_else(|e| panic!("read {}: {e}", backup_path.display()));
+        assert_eq!(
+            backup_raw, originals[i],
+            "{} does not match original plan.json",
+            backup_path.display()
+        );
+    }
+
+    // project-memory.json must be created.
+    let memory_path = work_dir
+        .join(".compass")
+        .join(".state")
+        .join("project-memory.json");
+    assert!(
+        memory_path.is_file(),
+        "project-memory.json missing after migrate: {}",
+        memory_path.display()
+    );
+}
+
+#[test]
+fn migrated_plans_validate_v1() {
+    let (_guard, work_dir) = setup();
+
+    // Migrate first — prerequisite for this test.
+    let out = run_cli(&["migrate", work_dir.to_str().unwrap()]);
+    assert!(
+        out.status.success(),
+        "migrate failed: {:?}\nstdout: {}\nstderr: {}",
+        out.status,
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr),
+    );
+
+    let sessions = list_sessions(&work_dir);
+    assert!(sessions.len() >= 2, "need >= 2 sessions");
+
+    for sd in &sessions {
+        let plan_path = sd.join("plan.json");
+        let out = run_cli(&["validate", "plan", plan_path.to_str().unwrap()]);
+        assert!(
+            out.status.success(),
+            "validate plan exited {:?} for {}\nstdout: {}\nstderr: {}",
+            out.status,
+            plan_path.display(),
+            String::from_utf8_lossy(&out.stdout),
+            String::from_utf8_lossy(&out.stderr),
+        );
+    }
+}
+
+#[test]
+fn second_migrate_is_idempotent() {
+    let (_guard, work_dir) = setup();
+
+    // First migrate.
+    let out1 = run_cli(&["migrate", work_dir.to_str().unwrap()]);
+    assert!(
+        out1.status.success(),
+        "first migrate failed: {:?}\nstdout: {}\nstderr: {}",
+        out1.status,
+        String::from_utf8_lossy(&out1.stdout),
+        String::from_utf8_lossy(&out1.stderr),
+    );
+
+    let sessions = list_sessions(&work_dir);
+    assert!(sessions.len() >= 2, "need >= 2 sessions");
+
+    // Snapshot backup mtimes.
+    let mtimes_before: Vec<std::time::SystemTime> = sessions
+        .iter()
+        .map(|sd| {
+            let bp = sd.join("plan.v0.json");
+            std::fs::metadata(&bp)
+                .unwrap_or_else(|e| panic!("stat {}: {e}", bp.display()))
+                .modified()
+                .expect("backup mtime")
+        })
+        .collect();
+
+    // Second migrate — must succeed and log "already v1.0, no-op" per session.
+    let out2 = run_cli(&["migrate", work_dir.to_str().unwrap()]);
+    assert!(
+        out2.status.success(),
+        "second migrate expected exit 0, got {:?}\nstdout: {}\nstderr: {}",
+        out2.status,
+        String::from_utf8_lossy(&out2.stdout),
+        String::from_utf8_lossy(&out2.stderr),
+    );
+
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&out2.stdout),
+        String::from_utf8_lossy(&out2.stderr),
+    );
+
+    for sd in &sessions {
+        let slug = sd
+            .file_name()
+            .and_then(|s| s.to_str())
+            .expect("session dir name");
+        // Bash used: grep -qE "${slug}:[[:space:]]+already v1.0, no-op"
+        // Check that somewhere in the combined output a line contains
+        // "<slug>:" followed by whitespace then "already v1.0, no-op".
+        let needle_ok = combined.lines().any(|line| {
+            if let Some(idx) = line.find(&format!("{slug}:")) {
+                let after = &line[idx + slug.len() + 1..];
+                let trimmed = after.trim_start();
+                after.len() != trimmed.len() && trimmed.contains("already v1.0, no-op")
+            } else {
+                false
+            }
+        });
+        assert!(
+            needle_ok,
+            "expected '{slug}: already v1.0, no-op' on second run\n--- combined ---\n{combined}",
+        );
+    }
+
+    // No double-backup: `plan.v0.plan.v0.json` must not exist anywhere under
+    // `work_dir`.
+    fn assert_no_double_backup(dir: &Path) {
+        for entry in std::fs::read_dir(dir)
+            .unwrap_or_else(|e| panic!("read_dir {}: {e}", dir.display()))
+        {
+            let entry = entry.expect("dir entry");
+            let ft = entry.file_type().expect("file type");
+            if ft.is_dir() {
+                assert_no_double_backup(&entry.path());
+            } else if ft.is_file() {
+                let name = entry.file_name();
+                assert_ne!(
+                    name.to_string_lossy(),
+                    "plan.v0.plan.v0.json",
+                    "found double-backup at {}",
+                    entry.path().display()
+                );
+            }
+        }
+    }
+    assert_no_double_backup(&work_dir);
+
+    // Backups must still exist with unchanged mtimes.
+    for (i, sd) in sessions.iter().enumerate() {
+        let backup_path = sd.join("plan.v0.json");
+        assert!(
+            backup_path.is_file(),
+            "{} vanished after second migrate",
+            backup_path.display()
+        );
+        let m_after = std::fs::metadata(&backup_path)
+            .unwrap_or_else(|e| panic!("stat {}: {e}", backup_path.display()))
+            .modified()
+            .expect("backup mtime after");
+        assert_eq!(
+            m_after, mtimes_before[i],
+            "{} mtime changed across idempotent migrate",
+            backup_path.display()
+        );
+    }
+}

package/cli/tests/e2e_no_shell_remains.rs

@@ -0,0 +1,53 @@
+//! Regression guard — Compass is a Rust + JS-launcher project. No `.sh`
+//! files should ever land in the repo. This test walks the repo from
+//! `cli/`'s parent (the repo root) and fails if any `.sh` file is present
+//! outside `target/` and `.git/`. Catches accidental re-introduction of
+//! bash artifacts in any future change.
+//!
+//! Covers REQ-01, REQ-02, REQ-05, REQ-07.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+fn repo_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .expect("CARGO_MANIFEST_DIR has a parent (the repo root)")
+        .to_path_buf()
+}
+
+fn collect_shell_files(dir: &Path, found: &mut Vec<PathBuf>) {
+    let name = dir.file_name().and_then(|n| n.to_str()).unwrap_or("");
+    if name == "target" || name == ".git" || name == "node_modules" {
+        return;
+    }
+    let entries = match fs::read_dir(dir) {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+            collect_shell_files(&path, found);
+        } else if path.extension().and_then(|e| e.to_str()) == Some("sh") {
+            found.push(path);
+        }
+    }
+}
+
+#[test]
+fn no_shell_files_remain_in_repo() {
+    let root = repo_root();
+    let mut found = Vec::new();
+    collect_shell_files(&root, &mut found);
+    assert!(
+        found.is_empty(),
+        "Found {} unexpected `.sh` file(s) in the repo (excluding target/, .git/, node_modules/):\n{}",
+        found.len(),
+        found
+            .iter()
+            .map(|p| format!("  {}", p.display()))
+            .collect::<Vec<_>>()
+            .join("\n")
+    );
+}