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
123
124
125
126
127
128
129

//! Default logger implementation for Checkstyle-rs

use crate::checkstyle::api::error::{CheckstyleError, CheckstyleResult};
use crate::checkstyle::api::event::AuditEvent;
use crate::checkstyle::api::listener::AuditListener;
use std::io::{self, Write};
use std::sync::Mutex;

/// Default logger that writes violations to stdout/stderr
pub struct DefaultLogger {
    /// Output stream (stdout) - wrapped in Mutex for Sync
    output: Mutex<Box<dyn Write + Send>>,
}

impl DefaultLogger {
    /// Create a new default logger writing to stdout
    pub fn new() -> Self {
        Self {
            output: Mutex::new(Box::new(io::stdout())),
        }
    }

    /// Create a logger writing to a custom writer
    pub fn with_writer(writer: Box<dyn Write + Send>) -> Self {
        Self {
            output: Mutex::new(writer),
        }
    }
}

impl Default for DefaultLogger {
    fn default() -> Self {
        Self::new()
    }
}

impl AuditListener for DefaultLogger {
    fn audit_started(&mut self, _event: &AuditEvent) -> CheckstyleResult<()> {
        // DefaultLogger in Checkstyle doesn't print audit started message
        Ok(())
    }

    fn audit_finished(&mut self, _event: &AuditEvent) -> CheckstyleResult<()> {
        // DefaultLogger in Checkstyle doesn't print audit finished message
        Ok(())
    }

    fn file_started(&mut self, _event: &AuditEvent) -> CheckstyleResult<()> {
        // DefaultLogger in Checkstyle doesn't print file started message
        Ok(())
    }

    fn file_finished(&mut self, _event: &AuditEvent) -> CheckstyleResult<()> {
        Ok(())
    }

    fn add_error(&mut self, event: &AuditEvent) -> CheckstyleResult<()> {
        if let Some(violation) = &event.violation {
            // Skip IGNORE severity violations
            if violation.severity_level == crate::checkstyle::api::event::SeverityLevel::Ignore {
                return Ok(());
            }

            let file_name = event
                .file
                .as_ref()
                .map(|f| f.display().to_string())
                .unwrap_or_else(|| "unknown".to_string());

            // Format severity level - WARNING becomes WARN, others are uppercase
            let severity_str = match violation.severity_level {
                crate::checkstyle::api::event::SeverityLevel::Warning => "WARN",
                crate::checkstyle::api::event::SeverityLevel::Error => "ERROR",
                crate::checkstyle::api::event::SeverityLevel::Info => "INFO",
                crate::checkstyle::api::event::SeverityLevel::Ignore => "IGNORE", // Shouldn't reach here
            };

            let mut output = self.output.lock().unwrap();

            // Format: [SEVERITY] filePath:lineNo:columnNo: message [ModuleId]
            // Column is only shown if > 0
            if violation.column_no > 0 {
                writeln!(
                    output,
                    "[{}] {}:{}:{}: {} [{}]",
                    severity_str,
                    file_name,
                    violation.line_no,
                    violation.column_no,
                    violation.get_message(),
                    violation.module_id
                )
                .map_err(CheckstyleError::Io)?;
            } else {
                writeln!(
                    output,
                    "[{}] {}:{}: {} [{}]",
                    severity_str,
                    file_name,
                    violation.line_no,
                    violation.get_message(),
                    violation.module_id
                )
                .map_err(CheckstyleError::Io)?;
            }
        }
        Ok(())
    }

    fn add_exception(
        &mut self,
        event: &AuditEvent,
        error: &dyn std::error::Error,
    ) -> CheckstyleResult<()> {
        let file_name = event
            .file
            .as_ref()
            .map(|f| f.display().to_string())
            .unwrap_or_else(|| "unknown".to_string());

        let mut output = self.output.lock().unwrap();
        writeln!(
            output,
            "[ERROR] {file_name}: Exception occurred: {error}"
        )
        .map_err(CheckstyleError::Io)?;
        Ok(())
    }
}