History and blame of a loaded state: log_of, log_for_path_of with a limit, and blame_of find the path in the tree alone and render nothing else; the *_in forms load once instead of twice bc489b6c7f69

            &snap.base_snapshot.tree,

        self.blame_of(&state, &state.tree().view(), path)

    }

    /// Blame `path` in a loaded state whose tree view the caller holds; no

    /// file other than `path` is rendered.

    pub fn blame_of(

        &self,

        state: &crate::state::State,

        tree: &crate::tree::TreeView,

        path: &str,

    ) -> Result<Vec<BlameLine>> {

        self.blame_state(path, state, tree, "that state")

        tree: &crate::tree::TreeView,

        let Some(f) = tree.entries.get(path) else {

        if f.kind != crate::objects::NodeKind::File || f.mode.opaque {

        Ok(self.log_of(&self.load_state(heads)?))

    }

    /// The log of a state already loaded, newest first.

    pub fn log_of(&self, state: &crate::state::State) -> Vec<LogEntry> {

        entries

        self.log_for_path_of(&self.load_state(heads)?, path, None)

    }

    /// The changes of a loaded state touching `path`, newest first, at most

    /// `limit` of them. The path is found in the state's tree alone, so no

    /// file is rendered, and the walk stops once `limit` are found.

    pub fn log_for_path_of(

        &self,

        state: &State,

        path: &str,

        limit: Option<usize>,

    ) -> Result<Vec<LogEntry>> {

        let Some(node) = state.tree().view().entries.get(path).map(|e| e.node) else {

        Ok(self.entries_touching_up_to(self.log_of(state), node, limit))

        self.entries_touching_up_to(entries, node, None)

    }

    fn entries_touching_up_to(

        &self,

        entries: Vec<LogEntry>,

        node: NodeId,

        limit: Option<usize>,

    ) -> Vec<LogEntry> {

            if limit.is_some_and(|n| out.len() >= n) {

                break;

            }

#[test]

fn history_and_blame_of_a_loaded_state_match_the_full_walk() {

    hermetic();

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

    let repo = Repo::init(dir.path()).unwrap();

    write(dir.path(), "a.txt", b"one\n");

    write(dir.path(), "other.txt", b"x\n");

    write(dir.path(), "bin.dat", &[0u8, 1, 2, 0, 255]);

    repo.snapshot("t").unwrap();

    let c1 = repo.commit("first", &[]).unwrap();

    write(dir.path(), "other.txt", b"y\n");

    repo.snapshot("t").unwrap();

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

    write(dir.path(), "a.txt", b"one\ntwo\n");

    repo.snapshot("t").unwrap();

    let c3 = repo.commit("second line", &[]).unwrap();

    write(dir.path(), "other.txt", b"z\n");

    repo.snapshot("t").unwrap();

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

    let heads = repo.bookmark_heads().unwrap();

    let state = repo.load_state(&heads).unwrap();

    let full: Vec<ChangeHash> = repo

        .log_for_path_in("a.txt", &heads)

        .unwrap()

        .iter()

        .map(|e| e.hash)

        .collect();

    assert_eq!(

        full,

        vec![c3, c1],

        "newest first, only changes touching the path"

    );

    let newest: Vec<ChangeHash> = repo

        .log_for_path_of(&state, "a.txt", Some(1))

        .unwrap()

        .iter()

        .map(|e| e.hash)

        .collect();

    assert_eq!(newest, vec![c3], "stops at the first");

    assert_eq!(

        repo.log_for_path_of(&state, "a.txt", None).unwrap().len(),

        2

    );

    assert!(repo

        .log_for_path_of(&state, "missing.txt", Some(1))

        .is_err());

    assert_eq!(

        repo.log_state(&heads).unwrap().len(),

        repo.log_of(&state).len()

    );

    let tree = state.tree().view();

    let via_state = repo.blame_of(&state, &tree, "a.txt").unwrap();

    let via_heads = repo.blame_in("a.txt", &heads).unwrap();

    assert_eq!(

        via_state

            .iter()

            .map(|l| (l.hash, l.text.clone()))

            .collect::<Vec<_>>(),

        via_heads

            .iter()

            .map(|l| (l.hash, l.text.clone()))

            .collect::<Vec<_>>()

    );

    assert_eq!(

        via_state.iter().map(|l| l.hash).collect::<Vec<_>>(),

        vec![c1, c3]

    );

    assert!(repo.blame_of(&state, &tree, "missing.txt").is_err());

}