use std::collections::BTreeSet;
use std::path::{Path, PathBuf};
use serde::Serialize;
use crate::extract::{extract_structure, language_for_extension};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ChangedPaths {
Diffed(Vec<PathBuf>),
NoRepo,
UnresolvedRef(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct EntityChange {
pub file: String,
pub name: String,
pub kind: &'static str,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct UnreadFile {
pub file: String,
pub why: String,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
pub struct ChangeSet {
pub base: String,
pub to: String,
pub entities: Vec<EntityChange>,
pub unread: Vec<UnreadFile>,
}
impl ChangeSet {
#[must_use]
pub fn fully_read(&self) -> bool {
self.unread.is_empty()
}
#[must_use]
pub fn unread_summary(&self) -> Option<String> {
if self.unread.is_empty() {
return None;
}
let names: Vec<&str> = self.unread.iter().map(|u| u.file.as_str()).collect();
Some(format!(
"{} of the changed file(s) produced NO entities and were NOT judged: {}",
self.unread.len(),
names.join(", ")
))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ChangeError {
NoRepo,
UnresolvedRef(String),
}
impl std::fmt::Display for ChangeError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::NoRepo => write!(
f,
"not a git work tree (or `git` is unavailable), so there is no \
base to diff against — the change was NOT evaluated"
),
Self::UnresolvedRef(r) => write!(
f,
"`{r}` does not resolve to a commit, so there is no base to diff \
against — the change was NOT evaluated"
),
}
}
}
#[must_use]
pub fn changed_paths_checked(root: &Path, from: &str, to: &str) -> ChangedPaths {
if !crate::git::is_repo(root) {
return ChangedPaths::NoRepo;
}
for reference in [from, to] {
if crate::git::resolve_commit(root, reference).is_none() {
return ChangedPaths::UnresolvedRef(reference.to_string());
}
}
ChangedPaths::Diffed(crate::git::changed_paths(root, from, to))
}
pub fn changed_entities(
root: &Path,
base: &str,
to: Option<&str>,
) -> Result<ChangeSet, ChangeError> {
if !crate::git::is_repo(root) {
return Err(ChangeError::NoRepo);
}
let base_commit = crate::git::resolve_commit(root, base)
.ok_or_else(|| ChangeError::UnresolvedRef(base.to_string()))?;
let to_label = match to {
Some(reference) => crate::git::resolve_commit(root, reference)
.ok_or_else(|| ChangeError::UnresolvedRef(reference.to_string()))?,
None => "(working tree)".to_string(),
};
let paths = match to {
Some(reference) => crate::git::changed_paths(root, &base_commit, reference),
None => working_tree_changes(root, &base_commit),
};
let mut set = ChangeSet {
base: base_commit.clone(),
to: to_label,
..ChangeSet::default()
};
for path in paths {
let rel = path.display().to_string();
let Some(language) = path
.extension()
.and_then(std::ffi::OsStr::to_str)
.and_then(language_for_extension)
else {
set.unread.push(UnreadFile {
file: rel,
why: "this build has no grammar for it, so its entities are UNKNOWN".to_string(),
});
continue;
};
let before = symbols_at(root, &base_commit, &path, language);
let after = match to {
Some(reference) => symbols_at(root, reference, &path, language),
None => symbols_in_working_tree(root, &path, language),
};
match (&before, &after) {
(None, None) => set.unread.push(UnreadFile {
file: rel,
why: "could not be read or parsed on EITHER side of the diff".to_string(),
}),
_ => {
let before = before.unwrap_or_default();
let after = after.unwrap_or_default();
for name in after.difference(&before) {
set.entities.push(EntityChange {
file: rel.clone(),
name: name.clone(),
kind: "added",
});
}
for name in before.difference(&after) {
set.entities.push(EntityChange {
file: rel.clone(),
name: name.clone(),
kind: "removed",
});
}
for name in before.intersection(&after) {
set.entities.push(EntityChange {
file: rel.clone(),
name: name.clone(),
kind: "modified",
});
}
}
}
}
set.entities.sort_by(|a, b| {
(a.file.as_str(), a.name.as_str(), a.kind).cmp(&(b.file.as_str(), b.name.as_str(), b.kind))
});
Ok(set)
}
fn working_tree_changes(root: &Path, base: &str) -> Vec<PathBuf> {
let mut paths: BTreeSet<PathBuf> = crate::git::changed_paths(root, base, "HEAD")
.into_iter()
.collect();
for args in [
vec!["diff", "--name-only", "HEAD"],
vec!["ls-files", "--others", "--exclude-standard"],
] {
if let Some(out) = crate::git::run(root, &args) {
paths.extend(out.lines().filter(|l| !l.is_empty()).map(PathBuf::from));
}
}
paths.into_iter().collect()
}
fn symbols_at(
root: &Path,
reference: &str,
path: &Path,
language: &str,
) -> Option<BTreeSet<String>> {
let source = crate::git::read_blob_at(root, reference, path)?;
let structure = extract_structure(&source, language).ok()?;
Some(structure.symbols.into_iter().map(|s| s.name).collect())
}
fn symbols_in_working_tree(root: &Path, path: &Path, language: &str) -> Option<BTreeSet<String>> {
let source = std::fs::read_to_string(root.join(path)).ok()?;
let structure = extract_structure(&source, language).ok()?;
Some(structure.symbols.into_iter().map(|s| s.name).collect())
}
#[cfg(test)]
mod tests {
use super::*;
fn repo_with(files: &[(&str, &str)]) -> (tempfile::TempDir, String) {
let dir = tempfile::tempdir().unwrap();
let run = |args: &[&str]| {
std::process::Command::new("git")
.arg("-C")
.arg(dir.path())
.args(args)
.output()
.unwrap();
};
run(&["init", "-q", "-b", "main"]);
run(&["config", "user.email", "t@t"]);
run(&["config", "user.name", "t"]);
for (name, body) in files {
std::fs::write(dir.path().join(name), body).unwrap();
}
run(&["add", "-A"]);
run(&["commit", "-qm", "base"]);
let base = crate::git::head_commit(dir.path()).unwrap();
(dir, base)
}
#[test]
fn an_added_symbol_in_the_working_tree_is_reported() {
let (dir, base) = repo_with(&[("leaf.rs", "fn leaf() {}\n")]);
std::fs::write(dir.path().join("leaf.rs"), "fn leaf() {}\nfn sprout() {}\n").unwrap();
let set = changed_entities(dir.path(), &base, None).unwrap();
assert!(set.fully_read(), "unread: {:?}", set.unread);
assert!(set
.entities
.iter()
.any(|e| e.name == "sprout" && e.kind == "added"));
assert_eq!(set.to, "(working tree)");
}
#[test]
fn a_removed_symbol_is_reported() {
let (dir, base) = repo_with(&[("leaf.rs", "fn leaf() {}\nfn gone() {}\n")]);
std::fs::write(dir.path().join("leaf.rs"), "fn leaf() {}\n").unwrap();
let set = changed_entities(dir.path(), &base, None).unwrap();
assert!(set
.entities
.iter()
.any(|e| e.name == "gone" && e.kind == "removed"));
}
#[test]
fn an_untracked_file_counts_as_part_of_the_proposal() {
let (dir, base) = repo_with(&[("leaf.rs", "fn leaf() {}\n")]);
std::fs::write(dir.path().join("new.rs"), "fn fresh() {}\n").unwrap();
let set = changed_entities(dir.path(), &base, None).unwrap();
assert!(set
.entities
.iter()
.any(|e| e.name == "fresh" && e.file == "new.rs"));
}
#[test]
fn a_change_that_touches_nothing_is_an_empty_measurement_not_a_failure() {
let (dir, base) = repo_with(&[("leaf.rs", "fn leaf() {}\n")]);
let set = changed_entities(dir.path(), &base, None).unwrap();
assert!(set.entities.is_empty());
assert!(set.fully_read(), "an empty change must still be fully read");
assert!(set.unread_summary().is_none());
}
#[test]
fn outside_a_repo_is_an_error_not_an_empty_change() {
let dir = tempfile::tempdir().unwrap();
assert_eq!(
changed_entities(dir.path(), "main", None).unwrap_err(),
ChangeError::NoRepo
);
assert_eq!(
changed_paths_checked(dir.path(), "a", "b"),
ChangedPaths::NoRepo
);
}
#[test]
fn an_unresolved_ref_is_an_error_not_an_empty_change() {
let (dir, _base) = repo_with(&[("leaf.rs", "fn leaf() {}\n")]);
let err = changed_entities(dir.path(), "no-such-ref", None).unwrap_err();
assert_eq!(err, ChangeError::UnresolvedRef("no-such-ref".to_string()));
assert!(err.to_string().contains("NOT evaluated"));
}
#[test]
fn an_unparseable_file_is_reported_unread_not_omitted() {
let (dir, base) = repo_with(&[("leaf.rs", "fn leaf() {}\n")]);
std::fs::write(dir.path().join("notes.md"), "# hi\n").unwrap();
let set = changed_entities(dir.path(), &base, None).unwrap();
assert!(!set.fully_read());
assert_eq!(set.unread.len(), 1);
assert_eq!(set.unread[0].file, "notes.md");
assert!(set.unread[0].why.contains("no grammar"));
assert!(set.unread_summary().unwrap().contains("NOT judged"));
}
#[cfg(feature = "langs-extra")]
#[test]
fn a_python_change_is_read_like_a_rust_one() {
let (dir, base) = repo_with(&[("leaf.py", "def leaf():\n return 1\n")]);
std::fs::write(
dir.path().join("leaf.py"),
"def leaf():\n return 1\n\n\ndef sprout():\n return 2\n",
)
.unwrap();
let set = changed_entities(dir.path(), &base, None).unwrap();
assert!(set.fully_read(), "unread: {:?}", set.unread);
assert!(
set.entities
.iter()
.any(|e| e.name == "sprout" && e.kind == "added"),
"{:?}",
set.entities
);
}
#[test]
fn two_commits_can_be_diffed_directly() {
let (dir, base) = repo_with(&[("leaf.rs", "fn leaf() {}\n")]);
std::fs::write(dir.path().join("leaf.rs"), "fn leaf() {}\nfn second() {}\n").unwrap();
let run = |args: &[&str]| {
std::process::Command::new("git")
.arg("-C")
.arg(dir.path())
.args(args)
.output()
.unwrap();
};
run(&["add", "-A"]);
run(&["commit", "-qm", "second"]);
let head = crate::git::head_commit(dir.path()).unwrap();
let set = changed_entities(dir.path(), &base, Some(&head)).unwrap();
assert_eq!(set.to, head);
assert!(set
.entities
.iter()
.any(|e| e.name == "second" && e.kind == "added"));
}
}