swt 5.0.0-rc.8

🍬 Sweet: A blazing-fast code health and architecture analyzer.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Diagnostic generation logic for Sweet LSP.

use serde_json::to_value;
use swt::{Config, FileReport, Severity};
use tower_lsp::lsp_types::{
    Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, Location, Position, Range, Url,
};

/// Generates a list of diagnostics from a file report.
pub fn generate(report: &FileReport, config: &Config) -> Vec<Diagnostic> {
    let mut diagnostics = Vec::new();

    for issue in &report.issues {
        let rule = match_rule(&issue.message);
        let severity = to_lsp_severity(config.thresholds.severities.get(rule));

        diagnostics.push(create_diagnostic(
            Range::new(Position::new(0, 0), Position::new(0, 80)),
            severity,
            format!("🍬 Sweet: {}", issue.message),
            rule,
            None,
        ));
    }

    for (line, depth) in &report.deep_lines {
        #[allow(clippy::cast_possible_truncation)]
        let l = (*line as u32).saturating_sub(1);
        let severity = to_lsp_severity(config.thresholds.severities.get("max-depth"));

        diagnostics.push(create_diagnostic(
            Range::new(Position::new(l, 0), Position::new(l, 80)),
            severity,
            format!("🍬 Sweet: Excessive nesting depth: {depth}"),
            "max-depth",
            None,
        ));
    }

    report_duplicates(report, config, &mut diagnostics);
    diagnostics
}

fn match_rule(message: &str) -> &'static str {
    if message.contains("File too long") {
        "max-lines"
    } else if message.contains("Too many imports") {
        "max-imports"
    } else if message.contains("Excessive nesting") {
        "max-depth"
    } else if message.contains("repetition") {
        "max-repetition"
    } else {
        "unknown"
    }
}

const fn to_lsp_severity(severity: Severity) -> DiagnosticSeverity {
    match severity {
        Severity::Error => DiagnosticSeverity::ERROR,
        Severity::Warning => DiagnosticSeverity::WARNING,
    }
}

fn create_diagnostic(
    range: Range,
    severity: DiagnosticSeverity,
    message: String,
    rule: &str,
    related: Option<Vec<DiagnosticRelatedInformation>>,
) -> Diagnostic {
    Diagnostic {
        range,
        severity: Some(severity),
        message,
        source: Some("sweet".to_string()),
        related_information: related,
        data: Some(to_value(rule).unwrap_or_default()),
        ..Default::default()
    }
}

/// Append duplication diagnostics to the list.
fn report_duplicates(report: &FileReport, config: &Config, diagnostics: &mut Vec<Diagnostic>) {
    for duplicate in &report.duplicates {
        #[allow(clippy::cast_possible_truncation)]
        let start_line = (duplicate.line as u32).saturating_sub(1);
        #[allow(clippy::cast_possible_truncation)]
        let line_count = duplicate.content.lines().count() as u32;
        let end_line = start_line + line_count.saturating_sub(1);

        let mut related_information = Vec::new();
        for (other_path, other_line) in &duplicate.occurrences {
            if let Ok(other_uri) = Url::from_file_path(other_path) {
                #[allow(clippy::cast_possible_truncation)]
                let l = (*other_line as u32).saturating_sub(1);
                related_information.push(DiagnosticRelatedInformation {
                    location: Location::new(
                        other_uri,
                        Range::new(Position::new(l, 0), Position::new(l, 80)),
                    ),
                    message: format!("Duplicate found here (line {other_line})"),
                });
            }
        }

        let severity = to_lsp_severity(config.thresholds.severities.get("max-repetition"));

        diagnostics.push(create_diagnostic(
            Range::new(Position::new(start_line, 0), Position::new(end_line, 80)),
            severity,
            format!(
                "🍬 Sweet: Code duplication detected! (repeated in {} other places)",
                duplicate.occurrences.len()
            ),
            "max-repetition",
            Some(related_information),
        ));
    }
}