wowlab_tidy/infra/

walk.rs

// #t(file: rust_default_hasher) dedup set on a cold walk path; fast-hasher dependency not warranted

use std::collections::HashSet;

use gix::bstr::ByteSlice;
#[cfg(test)]
use googletest::prelude::*;
use wowlab_fs::{
    directory::{self, EntryKind},
    path::{Path, PathBuf},
};

#[derive(Debug, thiserror::Error)]
#[error("{context}: {details}")]
pub(crate) struct PathDiscoveryError {
    context: Box<str>,
    details: Box<str>,
}

impl PathDiscoveryError {
    fn new(context: impl Into<Box<str>>, mut failures: Vec<String>) -> Self {
        failures.sort_unstable();
        failures.dedup();

        Self {
            context: context.into(),
            details: failures.join("; ").into_boxed_str(),
        }
    }
}

/// Get uncommitted source files with one of `extensions` via `gix`.
pub(crate) fn git_dirty_paths(
    root: &Path,
    crates_dir: &Path,
    crate_filter: &[String],
    extensions: &[&str],
) -> Result<Vec<PathBuf>, PathDiscoveryError> {
    let repo = gix::open(root).map_err(|error| {
        PathDiscoveryError::new(
            format!("failed to inspect dirty files under {}", root.display()),
            vec![format!("failed to open repository: {error}")],
        )
    })?;
    let platform = repo.status(gix::progress::Discard).map_err(|error| {
        PathDiscoveryError::new(
            format!("failed to inspect dirty files under {}", root.display()),
            vec![format!("failed to prepare git status: {error}")],
        )
    })?;
    let iter = platform
        .into_iter(Vec::<gix::bstr::BString>::new())
        .map_err(|error| {
            PathDiscoveryError::new(
                format!("failed to inspect dirty files under {}", root.display()),
                vec![format!("failed to iterate git status: {error}")],
            )
        })?;

    let mut seen = HashSet::new();
    let mut paths = Vec::new();

    let mut failures = Vec::new();

    for item in iter {
        let item = match item {
            Ok(item) => item,
            Err(error) => {
                // #t(rust_alloc_in_loop) preserve each independent traversal failure for one diagnostic
                failures.push(error.to_string());
                continue;
            }
        };
        let rel_bstr = item.location();
        let abs = root.join(rel_bstr.to_path_lossy());

        if abs
            .extension()
            .is_none_or(|extension| !extensions.iter().any(|expected| extension == *expected))
        {
            continue;
        }

        let is_file = directory::inspect(&abs)
            .ok()
            .flatten()
            .is_some_and(|entry| entry.kind() == EntryKind::File);

        if !is_file || !abs.starts_with(crates_dir) {
            continue;
        }

        if !crate_filter.is_empty() {
            let Ok(rel_to_crates) = abs.strip_prefix(crates_dir) else {
                continue;
            };
            let crate_name = match rel_to_crates.components().next() {
                Some(component) => component.as_os_str().to_string_lossy().into_owned(),
                None => continue,
            };

            if !crate_filter.iter().any(|filter| filter == &crate_name) {
                continue;
            }
        }

        // #t(rust_clone_in_loop) need one copy in seen and one in paths
        if seen.insert(abs.clone()) {
            paths.push(abs);
        }
    }

    if failures.is_empty() {
        paths.sort_unstable();

        Ok(paths)
    } else {
        Err(PathDiscoveryError::new(
            format!("failed to inspect dirty files under {}", root.display()),
            failures,
        ))
    }
}

/// Walk the workspace in parallel for files with one of `extensions`.
pub(crate) fn source_paths(
    root: &Path,
    crate_filter: &[String],
    extensions: &[&str],
) -> Result<Vec<PathBuf>, PathDiscoveryError> {
    if crate_filter.is_empty() {
        walk_dir(root, extensions)
    } else {
        let mut all = Vec::new();

        for name in crate_filter {
            let crate_dir = root.join(name);

            if directory::inspect(&crate_dir)
                .ok()
                .flatten()
                .is_some_and(|entry| entry.kind() == EntryKind::Directory)
            {
                all.extend(walk_dir(&crate_dir, extensions)?);
            }
        }

        all.sort_unstable();
        all.dedup();

        Ok(all)
    }
}

/// Walk the workspace in parallel for `.rs` paths.
pub(crate) fn rs_paths(
    root: &Path,
    crate_filter: &[String],
) -> Result<Vec<PathBuf>, PathDiscoveryError> {
    source_paths(root, crate_filter, &["rs"])
}

fn walk_dir(root: &Path, extensions: &[&str]) -> Result<Vec<PathBuf>, PathDiscoveryError> {
    let report = wowlab_fs::walk::visible_source_files(root, extensions, ".tidyignore");
    let (paths, failures) = report.into_parts();

    if failures.is_empty() {
        Ok(paths)
    } else {
        Err(PathDiscoveryError::new(
            format!("failed to walk source tree {}", root.display()),
            failures
                .into_iter()
                .map(|failure| failure.to_string())
                .collect(),
        ))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[gtest]
    fn finds_rust_files() -> Result<()> {
        let directory = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
        let paths = rs_paths(&directory, &[]).or_fail()?;

        verify_true!(paths.len() >= 2)?;
        verify_true!(
            paths
                .iter()
                .all(|path| path.extension().is_some_and(|extension| extension == "rs"))
        )?;

        Ok(())
    }

    #[gtest]
    fn filters_requested_languages() -> Result<()> {
        let directory = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
        let paths = source_paths(&directory, &[], &["rs", "toml"]).or_fail()?;

        verify_true!(
            paths
                .iter()
                .any(|path| path.extension().is_some_and(|extension| extension == "rs"))
        )?;
        verify_true!(paths.iter().all(|path| matches!(
            path.extension().and_then(|value| value.to_str()),
            Some("rs" | "toml")
        )))?;

        Ok(())
    }

    #[gtest]
    fn missing_source_root_is_a_fatal_walk_error() -> Result<()> {
        let directory = wowlab_fs::temporary::Directory::new().or_fail()?;
        let missing = directory.path().join("missing");
        let error = rs_paths(&missing, &[]).unwrap_err().to_string();

        verify_that!(
            error.as_str(),
            contains_substring("failed to walk source tree")
        )?;

        verify_that!(error.as_str(), contains_substring("missing"))
    }
}