Diff from the status cache: the working-copy change rendered against its indexed base (refs #41) 77445673174b

        let base = self.load_state_history(&change.deps)?;

        self.render_base_for(change, base)

    }

    /// [`Repo::change_base`] with the base already loaded (the working

    /// copy's comes from the state index).

    pub(crate) fn render_base_for(

        &self,

        change: &Change,

        mut base: State,

    ) -> Result<(State, Snapshot)> {

            None => self.working_copy_with_base()?,

    }

    /// The working-copy change with its base state and the base's

    /// rendering, for showing what the working copy changes. While the

    /// status cache holds (every file as the last snapshot left it), the

    /// stored working-copy change is the answer and no snapshot is taken;

    /// otherwise a snapshot makes it.

    pub fn working_copy_with_base(&self) -> Result<(Change, State, Snapshot)> {

        if self.status_by_manifest()?.is_some() {

            let (_, wc) = self.working_copy()?;

            let base = self.load_state_indexed(&wc.deps)?;

            let (base, snapshot) = self.render_base_for(&wc, base)?;

            return Ok((wc, base, snapshot));

        }

        let snap = self.snapshot_status("oxy diff")?;

        Ok((snap.wc, snap.base, snap.base_snapshot))

/// oxygen#41: while the status cache holds, the working copy's diff is

/// rendered from the stored working-copy change, and says exactly what a

/// snapshot's diff says.

#[test]

fn the_working_copy_diff_from_the_cache_matches_a_snapshot() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let repo = Repo::init(root).unwrap();

    write(root, "a.txt", b"one\ntwo\nthree\n");

    write(root, "gone.txt", b"bye\n");

    repo.commit("base", &[]).unwrap();

    write(root, "a.txt", b"one\n2\nthree\nfour\n");

    write(root, "new.txt", b"hello\n");

    fs::remove_file(root.join("gone.txt")).unwrap();

    let snap = repo.snapshot_status("oxy status").unwrap();

    let slow = render_change(&snap.wc, &snap.base, &snap.base_snapshot);

    assert!(

        repo.status_by_manifest().unwrap().is_some(),

        "the cache holds"

    );

    let (wc, base, snapshot) = repo.working_copy_with_base().unwrap();

    assert_eq!(render_change(&wc, &base, &snapshot), slow);

    assert_eq!(repo.diff_files(None).unwrap().len(), 3);

}

Then diff (same day, load average 4.2, Git 0.10 s throughout): while the

status cache holds, `oxy diff` renders the stored working-copy change

against its base loaded from the state index, rather than snapshotting.

0.34 to 0.35 s and 250 MB (from 0.41 s and 360 MB). Rendering it through

`change_base`, which reads the base's changes rather than the index, was

slower than a snapshot (0.9 s) and was not kept. What remains is the

status check's listing (about 130 ms), the index (60 ms) and rendering.

            let (wc, base, snapshot) = repo.working_copy_with_base()?;

            print!("{}", render_change(&wc, &base, &snapshot));