jbuild 0.1.8

High-performance Java build tool supporting Maven and Gradle
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

//! Base check implementations

use crate::checkstyle::api::ast::DetailAst;
use crate::checkstyle::api::check::Check;
use crate::checkstyle::api::config::{Configurable, Configuration, Context, Contextualizable};
use crate::checkstyle::api::error::CheckstyleResult;
use crate::checkstyle::api::violation::Violation;
use std::collections::BTreeSet;
use std::sync::Mutex;

/// Base implementation for AST-based checks
pub struct AbstractCheck {
    /// Module ID
    pub module_id: String,
    /// Context
    pub context: Context,
    /// Violations collected by this check
    violations: Mutex<BTreeSet<Violation>>,
}

impl AbstractCheck {
    /// Create a new abstract check
    pub fn new(module_id: String) -> Self {
        Self {
            module_id,
            context: Context::new(),
            violations: Mutex::new(BTreeSet::new()),
        }
    }

    /// Log a violation at a specific line
    pub fn log(&self, line: usize, key: String, args: Vec<String>) {
        let violation = Violation::new(
            line,
            0,
            0,
            0,
            self.context.severity,
            self.module_id.clone(),
            key,
            args,
            "checkstyle".to_string(),
            self.module_id.clone(),
            None,
        );
        let mut violations = self.violations.lock().unwrap();
        violations.insert(violation);
    }

    /// Log a violation at a specific line and column
    pub fn log_with_column(&self, line: usize, column: usize, key: String, args: Vec<String>) {
        let violation = Violation::new(
            line,
            column,
            0,
            0,
            self.context.severity,
            self.module_id.clone(),
            key,
            args,
            "checkstyle".to_string(),
            self.module_id.clone(),
            None,
        );
        let mut violations = self.violations.lock().unwrap();
        violations.insert(violation);
    }

    /// Log a violation from an AST node
    pub fn log_ast(&self, ast: &dyn DetailAst, key: String, args: Vec<String>) {
        let violation = Violation::new(
            ast.get_line_no(),
            ast.get_column_no(),
            ast.get_column_no(),
            ast.get_type(),
            self.context.severity,
            self.module_id.clone(),
            key,
            args,
            "checkstyle".to_string(),
            self.module_id.clone(),
            None,
        );
        let mut violations = self.violations.lock().unwrap();
        violations.insert(violation);
    }
}

impl Configurable for AbstractCheck {
    fn configure(&mut self, _config: &Configuration) -> CheckstyleResult<()> {
        Ok(())
    }
}

impl Contextualizable for AbstractCheck {
    fn contextualize(&mut self, context: &Context) -> CheckstyleResult<()> {
        self.context = context.clone();
        Ok(())
    }
}

impl Check for AbstractCheck {
    fn get_default_tokens(&self) -> Vec<i32> {
        Vec::new()
    }

    fn get_acceptable_tokens(&self) -> Vec<i32> {
        Vec::new()
    }

    fn get_required_tokens(&self) -> Vec<i32> {
        Vec::new()
    }

    fn get_violations(&self) -> BTreeSet<Violation> {
        self.violations.lock().unwrap().clone()
    }

    fn clear_violations(&mut self) {
        self.violations.lock().unwrap().clear();
    }
}