weave-cli 0.5.0

//! Reading whole trees out of git, for the repo-scope pass.
//!
//! Deliberately shells out instead of reusing weave-core's git module: the
//! repo-scope pass must keep working while weave-core's internals move, and the
//! only thing it needs from git is "give me every supported file at this rev".

use std::collections::BTreeSet;
use std::path::Path;
use std::process::Command;

use crate::repo_scope::{is_supported, Tree};

type R<T> = Result<T, Box<dyn std::error::Error>>;

fn git(dir: &Path, args: &[&str]) -> R<String> {
    let out = Command::new("git").args(args).current_dir(dir).output()?;
    if !out.status.success() {
        return Err(format!(
            "git {} failed: {}",
            args.join(" "),
            String::from_utf8_lossy(&out.stderr).trim()
        )
        .into());
    }
    Ok(String::from_utf8_lossy(&out.stdout).to_string())
}

pub(crate) fn rev_exists(dir: &Path, rev: &str) -> bool {
    Command::new("git")
        .args(["rev-parse", "--verify", "--quiet", rev])
        .current_dir(dir)
        .output()
        .map(|o| o.status.success())
        .unwrap_or(false)
}

/// Resolve the merge triple, defaulting to the merge in progress.
///
/// `ours` defaults to `HEAD`; `theirs` defaults to `MERGE_HEAD` (so a bare
/// `weave check` mid-merge does the obvious thing); `base` defaults to the
/// merge base of the two.
pub(crate) fn resolve_revs(
    dir: &Path,
    base: Option<&str>,
    ours: Option<&str>,
    theirs: Option<&str>,
) -> R<(String, String, String)> {
    if !rev_exists(dir, "HEAD") {
        return Err(
            "not a git repository (or no commits yet) — use the directory mode instead".into(),
        );
    }
    let ours = ours.unwrap_or("HEAD").to_string();
    let theirs = match theirs {
        Some(t) => t.to_string(),
        None if rev_exists(dir, "MERGE_HEAD") => "MERGE_HEAD".to_string(),
        None => {
            return Err("no --theirs given and no merge in progress (MERGE_HEAD absent)".into())
        }
    };
    let base = match base {
        Some(b) => b.to_string(),
        None => git(dir, &["merge-base", &ours, &theirs])?
            .trim()
            .to_string(),
    };
    Ok((base, ours, theirs))
}

pub fn trees(
    dir: &Path,
    base: Option<&str>,
    ours: Option<&str>,
    theirs: Option<&str>,
) -> R<(Tree, Tree, Tree)> {
    let (base, ours, theirs) = resolve_revs(dir, base, ours, theirs)?;
    Ok((
        read_rev_tree(dir, &base)?,
        read_rev_tree(dir, &ours)?,
        read_rev_tree(dir, &theirs)?,
    ))
}

/// Everything the working-tree check needs: the three merge stages, the bytes
/// on disk, the files the merge actually had to decide, and a sentence naming
/// what was compared.
pub struct MergeScope {
    pub base: Tree,
    pub ours: Tree,
    pub theirs: Tree,
    /// The working tree, as it is right now.
    pub work: Tree,
    /// Files BOTH sides changed, plus anything git still has unmerged.
    pub subjects: Vec<String>,
    pub scope: String,
}

/// Find the merge this repository is in — or has just finished — and read it.
///
/// Two shapes, in order, because they are the two moments an agent asks:
///
/// * **mid-merge**: `MERGE_HEAD` exists. Ours is `HEAD`, theirs is
///   `MERGE_HEAD`. This is the state right after `git merge` exits 1, and it
///   survives `git add` — which is exactly why the index's unmerged list alone
///   is not enough to find the subjects.
/// * **just committed**: `HEAD` has two parents. Ours is `HEAD^1`, theirs is
///   `HEAD^2`. An agent that committed and then wants to know what it did.
///
/// Neither shape present is not an error and must not be reported as one — it
/// is the sentence "there is no merge here", which the caller prints.
pub fn merge_scope(dir: &Path) -> R<Option<MergeScope>> {
    if !rev_exists(dir, "HEAD") {
        return Ok(None);
    }
    let (ours_rev, theirs_rev, moment) = if rev_exists(dir, "MERGE_HEAD") {
        ("HEAD".to_string(), "MERGE_HEAD".to_string(), "in progress")
    } else if rev_exists(dir, "HEAD^2") {
        ("HEAD^1".to_string(), "HEAD^2".to_string(), "just committed")
    } else {
        return Ok(None);
    };
    let base_rev = git(dir, &["merge-base", &ours_rev, &theirs_rev])?
        .trim()
        .to_string();
    let base = read_rev_tree(dir, &base_rev)?;
    let ours = read_rev_tree(dir, &ours_rev)?;
    let theirs = read_rev_tree(dir, &theirs_rev)?;
    let work = read_worktree(dir)?;

    // The subjects are every file this merge PRODUCED: whatever either side
    // moved. Restricting it to files both sides moved was the obvious-looking
    // choice and it was wrong — the merge's most dangerous breakage is the
    // cross-file one, where one side renames a definition in `a.py` and the
    // other adds a caller in `b.py`, and neither file is contested. A checker
    // that only looks where git had to choose cannot see it.
    let mut subjects: BTreeSet<String> = base
        .keys()
        .chain(ours.keys())
        .chain(theirs.keys())
        .filter(|p| ours.get(*p) != base.get(*p) || theirs.get(*p) != base.get(*p))
        .cloned()
        .collect();
    // …plus whatever git still calls unmerged, whether or not both sides moved
    // it: git's own verdict about what is unresolved outranks ours.
    if let Ok(list) = git(dir, &["diff", "--name-only", "--diff-filter=U", "-z"]) {
        subjects.extend(
            list.split('\0')
                .filter(|p| !p.is_empty() && is_supported(p))
                .map(str::to_string),
        );
    }
    let subjects: Vec<String> = subjects.into_iter().collect();
    let scope = format!(
        "working tree vs the three merge stages of {ours_rev} × {theirs_rev} \
         (base {}, merge {moment}) — {} file(s) either side changed",
        &base_rev[..base_rev.len().min(8)],
        subjects.len()
    );
    Ok(Some(MergeScope {
        base,
        ours,
        theirs,
        work,
        subjects,
        scope,
    }))
}

/// Every tracked, supported file as it exists on disk right now.
pub(crate) fn read_worktree(dir: &Path) -> R<Tree> {
    let listing = git(dir, &["ls-files", "-z"])?;
    let mut tree = Tree::new();
    for rel in listing.split('\0').filter(|p| !p.is_empty()) {
        if !is_supported(rel) {
            continue;
        }
        if let Ok(content) = std::fs::read_to_string(dir.join(rel)) {
            tree.insert(rel.to_string(), content);
        }
    }
    Ok(tree)
}

/// The three merge stages of ONE path, straight out of the index
/// (`:1:`/`:2:`/`:3:`) while the file is unmerged, falling back to the merge
/// revisions once it has been staged.
///
/// `weave explain` needs the triple for a single file and must keep working
/// after `git add` — the index stages disappear at that moment, and an
/// explanation that stops being available the instant you stage is an
/// explanation nobody can use twice.
pub fn file_stages(dir: &Path, path: &str) -> R<(String, String, String)> {
    let stage = |n: u8| -> Option<String> {
        let out = Command::new("git")
            .args(["show", &format!(":{n}:{path}")])
            .current_dir(dir)
            .output()
            .ok()?;
        out.status
            .success()
            .then(|| String::from_utf8_lossy(&out.stdout).to_string())
    };
    if let (Some(b), Some(o), Some(t)) = (stage(1), stage(2), stage(3)) {
        return Ok((b, o, t));
    }
    let scope = merge_scope(dir)?.ok_or(
        "no merge in progress and HEAD is not a merge commit — there is no three-way \
                context to explain this file against",
    )?;
    let get = |t: &Tree| t.get(path).cloned().unwrap_or_default();
    if !scope.ours.contains_key(path) && !scope.theirs.contains_key(path) {
        return Err(format!("`{path}` is in neither side of this merge").into());
    }
    Ok((get(&scope.base), get(&scope.ours), get(&scope.theirs)))
}

/// The WHOLE tree at `rev`, restricted to files weave has a grammar for.
/// Unsupported / binary / oversize files inherit git's guarantees wholesale
/// and are not scanned.
pub(crate) fn read_rev_tree(dir: &Path, rev: &str) -> R<Tree> {
    let listing = git(dir, &["ls-tree", "-r", "--name-only", "-z", rev])?;
    let mut tree = Tree::new();
    for path in listing.split('\0').filter(|p| !p.is_empty()) {
        if !is_supported(path) {
            continue;
        }
        let out = Command::new("git")
            .args(["show", &format!("{rev}:{path}")])
            .current_dir(dir)
            .output()?;
        if !out.status.success() {
            continue;
        }
        if let Ok(content) = String::from_utf8(out.stdout) {
            tree.insert(path.to_string(), content);
        }
    }
    Ok(tree)
}