churnloom 0.1.0

Fast codebase health reports woven from churn, LOC, structure, and Cargo ownership
Documentation
use std::{
    collections::HashMap,
    path::{Path, PathBuf},
};

use anyhow::{Context, Result};
use cargo_metadata::{MetadataCommand, PackageId, Target, TargetKind};

use crate::model::SourceKind;

#[derive(Clone, Debug)]
struct PackageInfo {
    name: String,
    root: PathBuf,
    target_kinds: HashMap<PathBuf, SourceKind>,
}

#[derive(Clone, Debug, Default)]
pub struct CargoContext {
    packages: Vec<PackageInfo>,
}

impl CargoContext {
    pub fn discover(root: &Path) -> Result<Self> {
        let manifest = root.join("Cargo.toml");
        if !manifest.is_file() {
            return Ok(Self::default());
        }

        let metadata = MetadataCommand::new()
            .current_dir(root)
            .manifest_path("Cargo.toml")
            .no_deps()
            .exec()
            .with_context(|| format!("cargo metadata failed for {}", manifest.display()))?;
        let members = metadata
            .workspace_members
            .iter()
            .collect::<std::collections::HashSet<&PackageId>>();
        let metadata_root = PathBuf::from(metadata.workspace_root.as_str());

        let mut packages = metadata
            .packages
            .iter()
            .filter(|package| members.contains(&package.id))
            .map(|package| {
                let manifest_path = rebase_metadata_path(
                    Path::new(package.manifest_path.as_str()),
                    &metadata_root,
                    root,
                );
                let package_root = manifest_path
                    .parent()
                    .context("Cargo package manifest has no parent")?
                    .to_path_buf();
                let target_kinds = package
                    .targets
                    .iter()
                    .map(|target| {
                        (
                            rebase_metadata_path(
                                Path::new(target.src_path.as_str()),
                                &metadata_root,
                                root,
                            ),
                            classify_target(target),
                        )
                    })
                    .collect();
                Ok(PackageInfo {
                    name: package.name.to_string(),
                    root: package_root,
                    target_kinds,
                })
            })
            .collect::<Result<Vec<_>>>()?;

        // Nested workspace packages must win over their parents.
        packages.sort_by(|left, right| {
            right
                .root
                .components()
                .count()
                .cmp(&left.root.components().count())
        });
        Ok(Self { packages })
    }

    pub fn package_names(&self) -> impl Iterator<Item = &str> {
        self.packages.iter().map(|package| package.name.as_str())
    }

    pub fn classify(&self, path: &Path) -> (Option<String>, SourceKind) {
        let Some(package) = self
            .packages
            .iter()
            .find(|package| path.starts_with(&package.root))
        else {
            return (None, SourceKind::Other);
        };
        let kind = package
            .target_kinds
            .get(path)
            .copied()
            .unwrap_or_else(|| classify_package_path(path, &package.root));
        (Some(package.name.clone()), kind)
    }
}

fn rebase_metadata_path(path: &Path, metadata_root: &Path, analysis_root: &Path) -> PathBuf {
    path.strip_prefix(metadata_root).map_or_else(
        |_| path.to_path_buf(),
        |relative| analysis_root.join(relative),
    )
}

fn classify_target(target: &Target) -> SourceKind {
    if target.is_custom_build() {
        SourceKind::Build
    } else if target.is_test() {
        SourceKind::IntegrationTest
    } else if target.is_bench() {
        SourceKind::Bench
    } else if target.is_example() {
        SourceKind::Example
    } else if target.kind.iter().any(is_production_target) {
        SourceKind::Production
    } else {
        SourceKind::Other
    }
}

fn is_production_target(kind: &TargetKind) -> bool {
    matches!(
        kind,
        TargetKind::Bin
            | TargetKind::Lib
            | TargetKind::RLib
            | TargetKind::DyLib
            | TargetKind::CDyLib
            | TargetKind::StaticLib
            | TargetKind::ProcMacro
    )
}

fn classify_package_path(path: &Path, package_root: &Path) -> SourceKind {
    let Ok(relative) = path.strip_prefix(package_root) else {
        return SourceKind::Other;
    };
    if relative == Path::new("build.rs") {
        return SourceKind::Build;
    }
    match relative
        .components()
        .next()
        .and_then(|component| component.as_os_str().to_str())
    {
        Some("src") => SourceKind::Production,
        Some("tests") => SourceKind::IntegrationTest,
        Some("benches") => SourceKind::Bench,
        Some("examples") => SourceKind::Example,
        _ => SourceKind::Other,
    }
}

#[cfg(test)]
mod tests {
    use std::path::Path;

    use super::classify_package_path;
    use crate::model::SourceKind;

    #[test]
    fn classifies_standard_cargo_directories() {
        let root = Path::new("/repo/crate");
        assert_eq!(
            classify_package_path(Path::new("/repo/crate/src/lib.rs"), root),
            SourceKind::Production
        );
        assert_eq!(
            classify_package_path(Path::new("/repo/crate/tests/api.rs"), root),
            SourceKind::IntegrationTest
        );
        assert_eq!(
            classify_package_path(Path::new("/repo/crate/benches/load.rs"), root),
            SourceKind::Bench
        );
        assert_eq!(
            classify_package_path(Path::new("/repo/crate/examples/demo.rs"), root),
            SourceKind::Example
        );
    }
}