wowlab_tidy/languages/rust/rules/style/

alphabetical.rs

#[cfg(test)]
use googletest::prelude::*;

use crate::{Example, FileCtx, Fix, Violation, infra::parse, violation};

const START: &str = "tidy-alphabetical-start";
const END: &str = "tidy-alphabetical-end";
const MIN_SORTABLE_LINES: usize = 2;

#[rustfmt::skip]
const EXAMPLES: &[Example] = &[
    Example {
        label: "sorted region",
        code: "// tidy-alphabetical-start\nuse alpha;\nuse beta;\nuse gamma;\n// tidy-alphabetical-end",
        pass: true,
    },
    Example {
        label: "unsorted region",
        code: "// tidy-alphabetical-start\nuse gamma;\nuse alpha;\n// tidy-alphabetical-end",
        pass: false,
    },
    Example {
        label: "no region",
        code: "use zebra;\nuse alpha;",
        pass: true,
    },
];

crate::line_rule!(
    alphabetical,
    "Enforce sorted ordering in regions marked with `tidy-alphabetical-start`.",
    "Sorted lists in marked regions prevent merge conflicts and make entries easy to locate.",
    Low,
    fix_alphabetical,
);

fn sort_key(line: &str) -> String {
    use winnow::combinator::alt;

    let mut input = line.trim();
    let _ = parse::try_parse(&mut input, alt(("pub(crate) ", "pub(super) ", "pub ")));
    let _ = parse::try_parse(&mut input, alt(("extern crate ", "use ", "mod ")));

    input.to_lowercase()
}

fn check_alphabetical(ctx: &FileCtx<'_>) -> Vec<Violation> {
    let mut out = Vec::new();
    let mut depth: usize = 0;
    let mut prev_key: Option<String> = None;
    let mut region_start: usize = 0;

    for (i, line) in ctx.lines.iter().enumerate() {
        let lineno = i + 1;
        let trimmed = line.trim();

        if trimmed.contains(START) {
            if depth == 0 {
                prev_key = None;
                region_start = lineno;
            }

            depth += 1;
            continue;
        }

        if trimmed.contains(END) {
            depth = depth.saturating_sub(1);

            if depth == 0 {
                prev_key = None;
            }

            continue;
        }

        if depth != 1 {
            continue;
        }

        if trimmed.is_empty() || parse::is_comment(trimmed) {
            continue;
        }

        let key = sort_key(trimmed);

        if let Some(ref prev) = prev_key {
            if key < *prev {
                out.push(violation(
                    ctx.rel,
                    lineno,
                    format!(
                        "line not in alphabetical order (region started at line {region_start})"
                    ),
                ));
            }
        }

        prev_key = Some(key);
    }

    if depth > 0 {
        out.push(violation(
            ctx.rel,
            region_start,
            format!("unmatched `{START}` (missing `{END}`)"),
        ));
    }

    out
}

fn fix_alphabetical(ctx: &FileCtx<'_>, v: &Violation) -> Option<Fix> {
    if v.message.contains("unmatched") {
        return None;
    }

    let (start_idx, end_idx) = alphabetical_region(ctx.lines, v.line)?;
    let content_start = start_idx + 1;
    let result_lines = sorted_region(ctx.lines.get(content_start..end_idx)?)?;

    Some(Fix {
        start_line: content_start + 1,
        end_line: end_idx,
        replacement: result_lines.join("\n"),
    })
}

fn alphabetical_region(lines: &[&str], target_line: usize) -> Option<(usize, usize)> {
    let start = lines
        .iter()
        .enumerate()
        .take(target_line)
        .rev()
        .find_map(|(index, line)| line.trim().contains(START).then_some(index))?;
    let end = lines
        .iter()
        .enumerate()
        .skip(start + 1)
        .find_map(|(index, line)| line.trim().contains(END).then_some(index))
        .unwrap_or(lines.len());

    (start < end).then_some((start, end))
}

fn sorted_region<'a>(lines: &[&'a str]) -> Option<Vec<&'a str>> {
    let mut sorted: Vec<&str> = lines
        .iter()
        .copied()
        .filter(|line| {
            let trimmed = line.trim();

            !trimmed.is_empty() && !parse::is_comment(trimmed)
        })
        .collect();

    if sorted.len() < MIN_SORTABLE_LINES {
        return None;
    }

    sorted.sort_by_key(|line| sort_key(line.trim()));
    let mut sorted = sorted.into_iter();

    lines
        .iter()
        .map(|line| {
            let trimmed = line.trim();

            if trimmed.is_empty() || parse::is_comment(trimmed) {
                Some(*line)
            } else {
                sorted.next()
            }
        })
        .collect()
}

crate::tidy_test!(check_alphabetical, {
    crate::example_tests!(EXAMPLES, check_alphabetical);

    #[gtest]
    fn sorted_region_passes() -> Result<()> {
        verify_true!(
            run("// tidy-alphabetical-start\n\
             use alpha;\n\
             use beta;\n\
             use gamma;\n\
             // tidy-alphabetical-end")
            .is_empty()
        )?;

        Ok(())
    }

    #[gtest]
    fn unsorted_region_fails() -> Result<()> {
        let v = run("// tidy-alphabetical-start\n\
             use gamma;\n\
             use alpha;\n\
             // tidy-alphabetical-end");
        verify_eq!(v.len(), 1)?;
        verify_eq!(v[0].line, 3)?;

        Ok(())
    }

    #[gtest]
    fn ignores_comments_and_blanks() -> Result<()> {
        verify_true!(
            run("// tidy-alphabetical-start\n\
             use alpha;\n\
             \n\
             // a comment\n\
             use beta;\n\
             // tidy-alphabetical-end")
            .is_empty()
        )?;

        Ok(())
    }

    #[gtest]
    fn strips_visibility_prefix() -> Result<()> {
        verify_true!(
            run("// tidy-alphabetical-start\n\
             pub mod alpha;\n\
             pub(crate) mod beta;\n\
             mod gamma;\n\
             // tidy-alphabetical-end")
            .is_empty()
        )?;

        Ok(())
    }

    #[gtest]
    fn unmatched_start() -> Result<()> {
        let v = run("// tidy-alphabetical-start\nuse a;");
        verify_eq!(v.len(), 1)?;
        verify_true!(v[0].message.contains("unmatched"))?;

        Ok(())
    }

    #[gtest]
    fn nested_regions_are_opaque() -> Result<()> {
        verify_true!(
            run("// tidy-alphabetical-start\n\
             use alpha;\n\
             // tidy-alphabetical-start\n\
             use zebra;\n\
             use aardvark;\n\
             // tidy-alphabetical-end\n\
             use beta;\n\
             // tidy-alphabetical-end")
            .is_empty()
        )?;

        Ok(())
    }

    #[gtest]
    fn no_region_no_violations() -> Result<()> {
        verify_true!(run("use zebra;\nuse alpha;").is_empty())?;

        Ok(())
    }

    #[gtest]
    fn fix_sorts_region() -> Result<()> {
        let source = "// tidy-alphabetical-start\n\
             use gamma;\n\
             use alpha;\n\
             use beta;\n\
             // tidy-alphabetical-end";
        let fixed = crate::apply_line_fixes(source, check_alphabetical, fix_alphabetical);
        let remaining = run(&fixed);
        verify_true!(remaining.is_empty())?;
        let lines: Vec<&str> = fixed.lines().collect();
        verify_eq!(lines[1].trim(), "use alpha;")?;
        verify_eq!(lines[2].trim(), "use beta;")?;
        verify_eq!(lines[3].trim(), "use gamma;")?;

        Ok(())
    }

    #[gtest]
    fn fix_preserves_comments() -> Result<()> {
        let source = "// tidy-alphabetical-start\n\
             use gamma;\n\
             // a comment\n\
             use alpha;\n\
             // tidy-alphabetical-end";
        let fixed = crate::apply_line_fixes(source, check_alphabetical, fix_alphabetical);
        let remaining = run(&fixed);
        verify_true!(remaining.is_empty())?;

        Ok(())
    }
});