churnloom 0.1.0

Fast codebase health reports woven from churn, LOC, structure, and Cargo ownership
Documentation
use proc_macro2::Span;
use syn::{
    Attribute, ImplItem, Item, Meta, TraitItem,
    punctuated::Punctuated,
    spanned::Spanned,
    token::Comma,
    visit::{self, Visit},
};
use tokei::{Config, LanguageType};

use crate::model::LineStats;

pub fn inline_test_lines(source: &str) -> LineStats {
    let Ok(file) = syn::parse_file(source) else {
        return LineStats::default();
    };
    let mut visitor = TestSpanVisitor::default();
    visitor.visit_file(&file);
    let ranges = merge_ranges(visitor.ranges);
    let lines = source.lines().collect::<Vec<_>>();
    let mut total = LineStats::default();

    for (start, end) in ranges {
        let snippet = lines
            .get(start.saturating_sub(1)..end.min(lines.len()))
            .unwrap_or_default()
            .join("\n");
        let stats = LanguageType::Rust.parse_from_str(snippet, &Config::default());
        total.add_assign(LineStats {
            code: stats.code,
            comments: stats.comments,
            blanks: stats.blanks,
        });
    }
    total
}

#[derive(Default)]
struct TestSpanVisitor {
    ranges: Vec<(usize, usize)>,
}

impl TestSpanVisitor {
    fn record_if_test_only(&mut self, attrs: &[Attribute], span: Span) -> bool {
        if attrs.iter().any(is_test_only_attribute) {
            let start = span.start().line;
            let end = span.end().line.max(start);
            self.ranges.push((start, end));
            true
        } else {
            false
        }
    }
}

impl<'ast> Visit<'ast> for TestSpanVisitor {
    fn visit_item(&mut self, node: &'ast Item) {
        if !self.record_if_test_only(item_attrs(node), node.span()) {
            visit::visit_item(self, node);
        }
    }

    fn visit_impl_item(&mut self, node: &'ast ImplItem) {
        if !self.record_if_test_only(impl_item_attrs(node), node.span()) {
            visit::visit_impl_item(self, node);
        }
    }

    fn visit_trait_item(&mut self, node: &'ast TraitItem) {
        if !self.record_if_test_only(trait_item_attrs(node), node.span()) {
            visit::visit_trait_item(self, node);
        }
    }
}

fn is_test_only_attribute(attribute: &Attribute) -> bool {
    if attribute.path().is_ident("test") || attribute.path().is_ident("bench") {
        return true;
    }
    if !attribute.path().is_ident("cfg") {
        return false;
    }
    let Meta::List(list) = &attribute.meta else {
        return false;
    };
    list.parse_args_with(Punctuated::<Meta, Comma>::parse_terminated)
        .is_ok_and(|predicates| {
            predicates.len() == 1 && predicates.first().is_some_and(cfg_implies_test)
        })
}

fn cfg_implies_test(meta: &Meta) -> bool {
    match meta {
        Meta::Path(path) => path.is_ident("test"),
        Meta::List(list) if list.path.is_ident("all") => {
            parse_nested(list).is_some_and(|items| items.iter().any(cfg_implies_test))
        }
        Meta::List(list) if list.path.is_ident("any") => parse_nested(list)
            .is_some_and(|items| !items.is_empty() && items.iter().all(cfg_implies_test)),
        Meta::NameValue(_) | Meta::List(_) => false,
    }
}

fn parse_nested(list: &syn::MetaList) -> Option<Punctuated<Meta, Comma>> {
    list.parse_args_with(Punctuated::<Meta, Comma>::parse_terminated)
        .ok()
}

fn merge_ranges(mut ranges: Vec<(usize, usize)>) -> Vec<(usize, usize)> {
    ranges.sort_unstable();
    let mut merged: Vec<(usize, usize)> = Vec::new();
    for (start, end) in ranges {
        if let Some(previous) = merged.last_mut()
            && start <= previous.1.saturating_add(1)
        {
            previous.1 = previous.1.max(end);
        } else {
            merged.push((start, end));
        }
    }
    merged
}

macro_rules! attrs_match {
    ($value:expr, $($variant:path),+ $(,)?) => {
        match $value {
            $($variant(item) => &item.attrs,)+
            _ => &[],
        }
    };
}

fn item_attrs(item: &Item) -> &[Attribute] {
    attrs_match!(
        item,
        Item::Const,
        Item::Enum,
        Item::ExternCrate,
        Item::Fn,
        Item::ForeignMod,
        Item::Impl,
        Item::Macro,
        Item::Mod,
        Item::Static,
        Item::Struct,
        Item::Trait,
        Item::TraitAlias,
        Item::Type,
        Item::Union,
        Item::Use,
    )
}

fn impl_item_attrs(item: &ImplItem) -> &[Attribute] {
    attrs_match!(
        item,
        ImplItem::Const,
        ImplItem::Fn,
        ImplItem::Macro,
        ImplItem::Type,
    )
}

fn trait_item_attrs(item: &TraitItem) -> &[Attribute] {
    attrs_match!(
        item,
        TraitItem::Const,
        TraitItem::Fn,
        TraitItem::Macro,
        TraitItem::Type,
    )
}

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

    #[test]
    fn counts_cfg_test_modules_and_test_functions() {
        let source = r"
fn production() {}

#[cfg(test)]
mod tests {
    fn helper() {}
    #[test]
    fn works() { assert!(true); }
}

#[test]
fn root_test() {}
";
        let stats = inline_test_lines(source);
        assert_eq!(stats.code, 8);
    }

    #[test]
    fn does_not_count_optional_feature_as_test_only() {
        let source = r#"
#[cfg(any(test, feature = "fixture"))]
fn shared_fixture() {}
"#;
        assert_eq!(inline_test_lines(source).code, 0);
    }
}