differential-engine 0.13.0

Core engine: git io, diff parsing, byte-exact apply, shape classes, invariants
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

//! Tree snapshots of uncommitted state (ADR 0017): the index and the worktree
//! as plain tree oids, so the rest of the pipeline — diff-tree enumeration,
//! the invariants, blob reads — runs on them unchanged.
//!
//! Plumbing only, and never the user's index: a temporary `GIT_INDEX_FILE` is
//! seeded from `ls-files -s -z` piped into `update-index -z --index-info`.
//! Snapshot blobs land in the odb (unreferenced, gc-able), which pins the
//! content so later `cat-file` reads by `<tree>:<path>` always resolve.

use crate::EngineError;
use crate::ports::{IndexSession, TreeBuilder, WorkingCopy};

/// Tree oid of the current index (the staged state). The user's index file is
/// never written to.
pub fn index_tree<G: TreeBuilder>(git: &G) -> Result<String, EngineError> {
    git.begin_from_current_index()?.write_tree()
}

/// Tree oid of the worktree: every tracked file's current content plus
/// untracked-but-not-ignored files, with worktree deletions honoured.
pub fn worktree_tree<G>(git: &G) -> Result<String, EngineError>
where
    G: TreeBuilder + WorkingCopy,
{
    let mut session = git.begin_from_current_index()?;
    // Union of tracked + untracked-unignored paths, NUL-delimited: `--add`
    // admits new files, `--remove` drops ones deleted from the worktree.
    let mut paths = git.tracked_paths()?;
    paths.extend_from_slice(&git.untracked_paths()?);
    session.stage_from_worktree(&paths)?;
    session.write_tree()
}

/// Whether a worktree snapshot would differ from `HEAD` at all.
///
/// The question a reviewer surface actually has: "is offering to include
/// uncommitted work going to change anything?" Answered with two cheap
/// plumbing calls rather than by building the snapshot and comparing trees —
/// the snapshot re-hashes every tracked file, which is precisely the work a
/// clean answer lets the caller skip.
pub fn is_clean<G: WorkingCopy>(git: &G) -> Result<bool, EngineError> {
    Ok(!git.has_tracked_changes()? && git.untracked_paths()?.is_empty())
}