wowlab_tidy/languages/rust/rules/style/

aligned.rs

#[cfg(test)]
use googletest::prelude::*;
use winnow::token::take_until;
use wowlab_types::sim::FastMap;

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

const MARKER: &str = "// #t:aligned";
const MIN_ALIGNED_ROWS: usize = 2;
const MAJORITY_DIVISOR: usize = 2;

#[rustfmt::skip]
const EXAMPLES: &[Example] = &[
    Example {
        label: "arrow aligned",
        code: "// #t:aligned\nSpells    => \"a\";\nTraits    => \"b\";\nItems     => \"c\";",
        pass: true,
    },
    Example {
        label: "arrow misaligned",
        code: "// #t:aligned\nSpells    => \"a\";\nTraits => \"b\";\nItems     => \"c\";",
        pass: false,
    },
    Example {
        label: "comma aligned",
        code: "// #t:aligned\ncall(a,  \"x\",  TypeA);\ncall(b,  \"y\",  TypeB);",
        pass: true,
    },
    Example {
        label: "no marker",
        code: "Spells    => \"a\";\nTraits => \"b\";",
        pass: true,
    },
    Example {
        label: "comma misaligned",
        code: "// #t:aligned\ncall(a,  \"x\",  TypeA);\ncall(long_name, \"y\", TypeB);",
        pass: false,
    },
    Example {
        label: "trailing comments aligned",
        code: "// #t:aligned\n(A, 1), // first\n(B, 2), // second",
        pass: true,
    },
    Example {
        label: "trailing comments misaligned",
        code: "// #t:aligned\n(A, 1),      // first\n(B, 2), // second",
        pass: false,
    },
];

crate::line_rule!(
    aligned,
    "Enforce column alignment in regions marked with `// #t:aligned`.",
    "Consistent column alignment in marked regions makes tabular data and match arms easier to scan.",
    Low,
    fix_aligned,
);

fn check_aligned(ctx: &FileCtx<'_>) -> Vec<Violation> {
    let mut out = Vec::new();
    let mut i = 0;

    while i < ctx.lines.len() {
        if ctx.lines.get(i).is_some_and(|line| line.contains(MARKER)) {
            let marker_line = i + 1;
            let block = collect_block(ctx.lines, i + 1);

            if block.len() >= MIN_ALIGNED_ROWS {
                let texts: Vec<&str> = block.iter().map(|&(_, s)| s).collect();

                match detect_separator(&texts) {
                    Some(Sep::Arrow) => {
                        check_arrow(ctx.rel, &block, marker_line, &mut out);
                    }
                    Some(Sep::Comma) => {
                        check_comma(ctx.rel, &block, marker_line, &mut out);
                    }
                    None => {}
                }

                check_comments(ctx.rel, &block, marker_line, &mut out);
            }

            i = block.last().map_or(i + 1, |&(idx, _)| idx + 1);
        } else {
            i += 1;
        }
    }

    out
}

fn collect_block<'a>(lines: &[&'a str], start: usize) -> Vec<(usize, &'a str)> {
    let mut block = Vec::new();

    for (i, &line) in lines.iter().enumerate().skip(start) {
        let trimmed = line.trim();

        if trimmed.is_empty()
            || matches!(
                trimmed,
                ")" | ");" | "]" | "];" | "]," | "])" | "]);" | "}" | "};" | "},"
            )
            || trimmed.contains(MARKER)
        {
            break;
        }

        if parse::is_comment(trimmed) {
            continue;
        }

        block.push((i, line));
    }

    block
}

enum Sep {
    Arrow,
    Comma,
}

fn detect_separator(block: &[&str]) -> Option<Sep> {
    let arrows = block.iter().filter(|l| l.contains("=>")).count();

    if arrows > block.len() / MAJORITY_DIVISOR {
        return Some(Sep::Arrow);
    }

    let commas = block.iter().filter(|l| l.contains(',')).count();

    if commas > block.len() / MAJORITY_DIVISOR {
        return Some(Sep::Comma);
    }

    None
}

fn check_arrow(rel: &str, block: &[(usize, &str)], marker_line: usize, out: &mut Vec<Violation>) {
    let positions: Vec<(usize, usize)> = block
        .iter()
        .filter_map(|&(idx, line)| {
            let mut input = line;
            let before: &str = parse::try_parse(&mut input, take_until(0.., "=>"))?;

            Some((idx, before.len()))
        })
        .collect();

    if positions.len() < MIN_ALIGNED_ROWS {
        return;
    }

    let expected = majority(positions.iter().map(|&(_, p)| p));

    for &(idx, pos) in &positions {
        if pos != expected {
            out.push(violation(
                rel,
                idx + 1,
                format!(
                    "`=>` at column {pos}, expected {expected} \
                     (aligned block at line {marker_line})"
                ),
            ));
        }
    }
}

fn check_comma(rel: &str, block: &[(usize, &str)], marker_line: usize, out: &mut Vec<Violation>) {
    let mut all: Vec<(usize, Vec<usize>)> = Vec::new();

    for &(idx, line) in block {
        let positions = comma_positions(line);

        if !positions.is_empty() {
            all.push((idx, positions));
        }
    }

    if all.len() < MIN_ALIGNED_ROWS {
        return;
    }

    let expected_count = majority(all.iter().map(|(_, p)| p.len()));

    for &(idx, ref positions) in &all {
        if positions.len() != expected_count {
            out.push(violation(
                rel,
                idx + 1,
                format!(
                    "{} commas, expected {expected_count} \
                     (aligned block at line {marker_line})",
                    positions.len()
                ),
            ));
        }
    }

    let matching: Vec<&(usize, Vec<usize>)> = all
        .iter()
        .filter(|(_, p)| p.len() == expected_count)
        .collect();

    if matching.len() < MIN_ALIGNED_ROWS {
        return;
    }

    for col in 0..expected_count {
        let expected_pos = majority(
            matching
                .iter()
                .filter_map(|(_, positions)| positions.get(col).copied()),
        );

        for &&(idx, ref positions) in &matching {
            let Some(actual) = positions.get(col).copied() else {
                continue;
            };

            if actual != expected_pos {
                out.push(violation(
                    rel,
                    idx + 1,
                    format!(
                        "comma {} at column {}, expected {expected_pos} \
                         (aligned block at line {marker_line})",
                        col + 1,
                        actual
                    ),
                ));
                break;
            }
        }
    }
}

fn comma_positions(line: &str) -> Vec<usize> {
    crate::infra::scanner::char_positions(line, ',')
}

fn comment_position(line: &str) -> Option<usize> {
    crate::infra::scanner::line_comment_starts(line)
        .into_iter()
        .next()
        .flatten()
}

fn check_comments(
    rel: &str,
    block: &[(usize, &str)],
    marker_line: usize,
    out: &mut Vec<Violation>,
) {
    let positions: Vec<(usize, usize)> = block
        .iter()
        .filter_map(|&(index, line)| comment_position(line).map(|position| (index, position)))
        .collect();

    if positions.len() < MIN_ALIGNED_ROWS {
        return;
    }

    let expected = majority(positions.iter().map(|&(_, position)| position));

    if let Some(&(index, actual)) = positions
        .iter()
        .find(|&&(_, position)| position != expected)
    {
        out.push(violation(
            rel,
            index + 1,
            format!(
                "trailing comment at column {actual}, expected {expected} \
                 (aligned block at line {marker_line})"
            ),
        ));
    }
}

fn majority<T>(iter: impl Iterator<Item = T>) -> T
where
    T: Eq + std::hash::Hash + Copy,
{
    let mut counts: FastMap<T, usize> = FastMap::default();

    for v in iter {
        *counts.entry(v).or_default() += 1;
    }

    counts
        .into_iter()
        .max_by_key(|&(_, c)| c)
        .expect("majority called on empty iterator")
        .0
}

fn fix_aligned(ctx: &FileCtx<'_>, violation: &Violation) -> Option<Fix> {
    let (start, block) = containing_block(ctx, violation.line)?;
    let texts: Vec<&str> = block.iter().map(|(_, line)| *line).collect();
    let end = block.last()?.0;
    let mut replacement: Vec<String> = ctx
        .lines
        .get(start..=end)?
        .iter()
        .map(|line| (*line).to_owned())
        .collect();

    match detect_separator(&texts)? {
        Sep::Arrow => align_arrows(&block, start, &mut replacement),
        Sep::Comma => align_commas(&block, start, &mut replacement)?,
    }

    align_comments(&block, start, &mut replacement);

    Some(Fix::replace_lines(
        start + 1,
        block.last()?.0 + 1,
        replacement.join("\n"),
    ))
}

fn containing_block<'a>(
    ctx: &'a FileCtx<'_>,
    violation_line: usize,
) -> Option<(usize, Vec<(usize, &'a str)>)> {
    ctx.lines.iter().enumerate().find_map(|(index, line)| {
        if !line.contains(MARKER) {
            return None;
        }

        let block = collect_block(ctx.lines, index + 1);

        block
            .iter()
            .any(|(line_index, _)| *line_index + 1 == violation_line)
            .then_some((index + 1, block))
    })
}

// #t(fn: rust_unchecked_indexing) block indices originate from the same bounded replacement range
fn align_arrows(block: &[(usize, &str)], start: usize, replacement: &mut [String]) {
    let target = block
        .iter()
        .filter_map(|(_, line)| line.find("=>"))
        .max()
        .unwrap_or_default();

    for (index, line) in block {
        let Some(position) = line.find("=>") else {
            continue;
        };

        replacement[*index - start].insert_str(position, &" ".repeat(target - position));
    }
}

// #t(fn: rust_alloc_in_loop, rust_collection_new_in_loop) each row needs an independently rebuilt aligned representation
// #t(fn: rust_unchecked_indexing) row and column indices are derived from validated equal-width segment tables
fn align_commas(block: &[(usize, &str)], start: usize, replacement: &mut [String]) -> Option<()> {
    let segments: Vec<Vec<&str>> = block
        .iter()
        .map(|(_, line)| split_at_commas(line))
        .collect();
    let count = segments.first()?.len();

    if count < MIN_ALIGNED_ROWS || segments.iter().any(|row| row.len() != count) {
        return None;
    }

    let widths: Vec<usize> = (0..count - 1)
        .map(|column| {
            segments
                .iter()
                .map(|row| row[column].trim_end().len())
                .max()
                .unwrap_or_default()
        })
        .collect();

    for ((index, _), row) in block.iter().zip(&segments) {
        let mut line = String::new();

        for (column, segment) in row.iter().enumerate() {
            if column == row.len() - 1 {
                line.push_str(segment);
            } else {
                let segment = segment.trim_end();

                line.push_str(segment);
                line.push_str(&" ".repeat(widths[column] - segment.len()));
                line.push(',');
            }
        }

        replacement[*index - start] = line;
    }

    Some(())
}

// #t(fn: rust_alloc_in_loop) each commented row needs an independently rebuilt aligned representation
fn align_comments(block: &[(usize, &str)], start: usize, replacement: &mut [String]) {
    let commented: Vec<(usize, usize)> = block
        .iter()
        .filter_map(|(index, _)| {
            let row = replacement.get(*index - start)?;

            comment_position(row).map(|position| (*index, position))
        })
        .collect();

    if commented.len() < MIN_ALIGNED_ROWS {
        return;
    }

    let target = commented
        .iter()
        .filter_map(|(index, position)| {
            replacement
                .get(*index - start)
                .and_then(|row| row.get(..*position))
                .map(str::trim_end)
                .map(str::len)
        })
        .max()
        .unwrap_or_default()
        + 1;

    for (index, position) in commented {
        let Some(row) = replacement.get_mut(index - start) else {
            continue;
        };
        let Some(comment) = row.get(position..).map(str::to_owned) else {
            continue;
        };

        row.truncate(position);
        let code_len = row.trim_end().len();

        row.truncate(code_len);
        row.push_str(&" ".repeat(target - code_len));
        row.push_str(&comment);
    }
}

// #t(fn: rust_unchecked_indexing) scanner positions are valid UTF-8 byte boundaries within the source line
fn split_at_commas(line: &str) -> Vec<&str> {
    let mut segments = Vec::new();
    let mut start = 0;

    for position in comma_positions(line) {
        segments.push(&line[start..position]);
        start = position + 1;
    }

    segments.push(&line[start..]);

    segments
}

crate::tidy_test!(check_aligned, {
    crate::example_tests!(EXAMPLES, check_aligned);
    crate::fix_tests!(line, check_aligned, fix_aligned);

    #[gtest]
    fn arrow_aligned_passes() -> Result<()> {
        let v = run("// #t:aligned\n\
             Spells    => \"cleanup_spells.sql\";\n\
             Traits    => \"cleanup_traits.sql\";\n\
             Items     => \"cleanup_items.sql\";");
        verify_true!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn arrow_misaligned_fails() -> Result<()> {
        let v = run("// #t:aligned\n\
             Spells    => \"cleanup_spells.sql\";\n\
             Traits => \"cleanup_traits.sql\";\n\
             Items     => \"cleanup_items.sql\";");
        verify_eq!(v.len(), 1)?;
        verify_eq!(v[0].line, 3)?;
        verify_true!(v[0].message.contains("=>"))?;

        Ok(())
    }

    #[gtest]
    fn comma_aligned_passes() -> Result<()> {
        let v = run("// #t:aligned\n\
             register!(A,  \"a\",  TypeA);\n\
             register!(B,  \"b\",  TypeB);\n\
             register!(C,  \"c\",  TypeC);");
        verify_true!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn comma_misaligned_fails() -> Result<()> {
        let v = run("// #t:aligned\n\
             register!(A,  \"a\",  TypeA);\n\
             register!(B, \"b\", TypeB);\n\
             register!(C,  \"c\",  TypeC);");
        verify_false!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn trailing_commas_are_aligned() -> Result<()> {
        let source = "// #t:aligned\n\
             \"id\": Int,\n\
             \"patch_version\": Text,\n\
             \"cloth_modifier\": Float,";
        let fixed = crate::apply_line_fixes(source, check_aligned, fix_aligned);

        verify_true!(run(&fixed).is_empty())?;

        Ok(())
    }

    #[gtest]
    fn skips_comments_in_block() -> Result<()> {
        let v = run("// #t:aligned\n\
             Spells => \"a\";\n\
             // comment\n\
             Traits => \"b\";");
        verify_true!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn block_ends_at_blank_line() -> Result<()> {
        let v = run("// #t:aligned\n\
             Spells => \"a\";\n\
             Traits => \"b\";\n\
             \n\
             Misaligned => \"c\";");
        verify_true!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn block_ends_at_closing_delim() -> Result<()> {
        let v = run("// #t:aligned\n\
             Spells => \"a\";\n\
             Traits => \"b\";\n\
             );");
        verify_true!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn block_ends_at_array_closing_delim() -> Result<()> {
        let v = run("// #t:aligned\n\
             (1, 2),\n\
             (3, 4),\n\
             ];\n\
             call(a, b, c);");
        verify_true!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn block_ends_at_macro_array_closing_delim() -> Result<()> {
        let v = run("// #t:aligned\n\
             \"id\": Int,\n\
             \"x\": Text,\n\
             ]);");
        verify_true!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn no_marker_no_violations() -> Result<()> {
        let v = run("Spells    => \"a\";\n\
             Traits => \"b\";");
        verify_true!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn comma_inside_string_ignored() -> Result<()> {
        let v = run("// #t:aligned\n\
             call(a, \"hello, world\", b);\n\
             call(c, \"hello, world\", d);");
        verify_true!(v.is_empty())?;

        Ok(())
    }

    #[gtest]
    fn mismatched_comma_count() -> Result<()> {
        let v = run("// #t:aligned\n\
             call(a, b, c);\n\
             call(a, b, c);\n\
             call(a, b);");
        verify_eq!(v.len(), 1)?;
        verify_true!(v[0].message.contains("commas"))?;

        Ok(())
    }
});