lint 0.1.3

A versatile linting tool with CLI, MCP, and library interfaces
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
121
122

use crate::language_rules::LanguageRule;
use crate::output::{LintMessage, Severity};
use std::path::Path;

#[derive(Debug, Clone)]
pub struct JavaStyleRule;

impl LanguageRule for JavaStyleRule {
    fn name(&self) -> &str {
        "java-style"
    }

    fn description(&self) -> &str {
        "Enforces Java naming conventions and style guidelines."
    }

    fn default_severity(&self) -> Severity {
        Severity::Error
    }

    fn check(&self, content: &str, _file_path: &Path) -> Vec<LintMessage> {
        let mut messages = Vec::new();

        for (line_num, line) in content.lines().enumerate() {
            if line.trim().starts_with("class ")
                && line
                    .chars()
                    .next()
                    .map(|c| c.is_lowercase())
                    .unwrap_or(false)
            {
                messages.push(LintMessage::new(
                    line_num + 1,
                    line.find("class").unwrap_or(0),
                    self.default_severity(),
                    "Class name should use PascalCase".to_string(),
                    self.name().to_string(),
                    Some("Rename class to start with uppercase letter (e.g., MyClass)".to_string()),
                ));
            }

            if line.contains("System.out.print") && !line.trim_start().starts_with("//") {
                messages.push(LintMessage::new(
                    line_num + 1,
                    line.find("System.out.print").unwrap_or(0),
                    self.default_severity(),
                    "System.out.print statement found".to_string(),
                    self.name().to_string(),
                    Some("Use SLF4J: 'private static final Logger log = LoggerFactory.getLogger(MyClass.class); log.info(\"message\");'".to_string()),
                ));
            }
        }

        messages
    }

    fn supports_extension(&self, extension: &str) -> bool {
        extension == "java"
    }
}

#[derive(Debug, Clone)]
pub struct SemicolonRule;

impl LanguageRule for SemicolonRule {
    fn name(&self) -> &str {
        "missing-semicolon"
    }

    fn category(&self) -> &str {
        "style"
    }

    fn description(&self) -> &str {
        "Detects missing semicolons in JS/TS/Java/C-style code."
    }

    fn check(&self, content: &str, _file_path: &Path) -> Vec<LintMessage> {
        let mut messages = Vec::new();

        for (line_num, line) in content.lines().enumerate() {
            let trimmed = line.trim();
            if !trimmed.is_empty()
                && !trimmed.starts_with("//")
                && !trimmed.starts_with("/*")
                && !trimmed.starts_with("*")
                && !trimmed.ends_with(';')
                && !trimmed.ends_with('{')
                && !trimmed.ends_with('}')
                && !trimmed.ends_with(',')
                && !trimmed.ends_with('(')
                && !trimmed.ends_with(':')
                && !trimmed.contains("return")
                && !trimmed.contains("if ")
                && !trimmed.contains("for ")
                && !trimmed.contains("while ")
                && !trimmed.contains("function")
                && !trimmed.contains("=>")
                && !trimmed.contains("import")
                && !trimmed.contains("export")
                && (trimmed.contains("=")
                    || trimmed.contains("print")
                    || trimmed.contains("println"))
            {
                messages.push(LintMessage::new(
                    line_num + 1,
                    line.len(),
                    self.default_severity(),
                    "Missing semicolon".to_string(),
                    self.name().to_string(),
                    Some("Add semicolon at the end of the statement".to_string()),
                ));
            }
        }

        messages
    }

    fn supports_extension(&self, extension: &str) -> bool {
        matches!(extension, "js" | "ts" | "java" | "c" | "cpp" | "rs")
    }
}