vize_patina 0.12.0

Patina - The quality checker for Vize code linting
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! musea/no-empty-variant
//!
//! Disallow empty variant blocks that have no template content.

use super::{MuseaLintResult, MuseaRule, MuseaRuleMeta};
use crate::diagnostic::{LintDiagnostic, Severity};

static META: MuseaRuleMeta = MuseaRuleMeta {
    name: "musea/no-empty-variant",
    description: "Disallow empty <variant> blocks",
    default_severity: Severity::Warning,
};

/// Disallow empty variant blocks
pub struct NoEmptyVariant;

impl MuseaRule for NoEmptyVariant {
    fn meta(&self) -> &'static MuseaRuleMeta {
        &META
    }

    fn check(&self, source: &str, result: &mut MuseaLintResult) {
        let mut search_start = 0;

        while let Some(variant_pos) = source[search_start..].find("<variant") {
            let abs_pos = search_start + variant_pos;
            let remaining = &source[abs_pos..];

            // Find the opening tag end
            let Some(tag_end) = remaining.find('>') else {
                break;
            };

            // Check for self-closing tag
            if remaining[..tag_end].ends_with('/') {
                result.add_diagnostic(
                    LintDiagnostic::warn(
                        META.name,
                        "Empty self-closing <variant /> block",
                        abs_pos as u32,
                        (abs_pos + tag_end + 1) as u32,
                    )
                    .with_help("Add template content inside the variant"),
                );
                search_start = abs_pos + tag_end + 1;
                continue;
            }

            // Find the closing tag
            let after_open = &remaining[tag_end + 1..];
            if let Some(close_pos) = after_open.find("</variant>") {
                let content = &after_open[..close_pos];
                let trimmed = content.trim();

                if trimmed.is_empty() {
                    result.add_diagnostic(
                        LintDiagnostic::warn(
                            META.name,
                            "Empty <variant> block with no content",
                            abs_pos as u32,
                            (abs_pos + tag_end + 1 + close_pos + 10) as u32,
                        )
                        .with_help("Add template content inside the variant"),
                    );
                }

                search_start = abs_pos + tag_end + 1 + close_pos + 10;
            } else {
                break;
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::{MuseaLintResult, MuseaRule, NoEmptyVariant};

    #[test]
    fn test_valid_variant() {
        let source = r#"<variant name="default"><Button /></variant>"#;
        let rule = NoEmptyVariant;
        let mut result = MuseaLintResult::default();
        rule.check(source, &mut result);
        assert_eq!(result.warning_count, 0);
    }

    #[test]
    fn test_empty_variant() {
        let source = r#"<variant name="empty"></variant>"#;
        let rule = NoEmptyVariant;
        let mut result = MuseaLintResult::default();
        rule.check(source, &mut result);
        assert_eq!(result.warning_count, 1);
    }

    #[test]
    fn test_self_closing_variant() {
        let source = r#"<variant name="empty" />"#;
        let rule = NoEmptyVariant;
        let mut result = MuseaLintResult::default();
        rule.check(source, &mut result);
        assert_eq!(result.warning_count, 1);
    }
}