linthis 0.19.3

A fast, cross-platform multi-language linter and formatter
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

// Copyright 2024 zhlinh and linthis Project Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found at
//
// https://opensource.org/license/MIT
//
// The above copyright notice and this permission
// notice shall be included in all copies or
// substantial portions of the Software.

//! Java language formatter using clang-format.

use crate::formatters::Formatter;
use crate::utils::types::FormatResult;
use crate::{Language, Result};
use std::fs;
use std::path::Path;
use std::process::Command;

/// Java formatter using clang-format.
pub struct JavaFormatter;

impl JavaFormatter {
    pub fn new() -> Self {
        Self
    }

    /// Find clang-format configuration file
    fn find_clang_format_config(path: &Path) -> Option<std::path::PathBuf> {
        let mut current = if path.is_file() {
            path.parent()?.to_path_buf()
        } else {
            path.to_path_buf()
        };

        let config_names = [
            ".linthis/configs/java/.clang-format", // Plugin config (highest priority)
            ".clang-format",
        ];

        loop {
            for config_name in &config_names {
                let config_path = current.join(config_name);
                if config_path.exists() {
                    return Some(config_path);
                }
            }

            if !current.pop() {
                break;
            }
        }

        None
    }
}

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

impl Formatter for JavaFormatter {
    fn name(&self) -> &str {
        "clang-format"
    }

    fn supported_languages(&self) -> &[Language] {
        &[Language::Java]
    }

    fn format(&self, path: &Path) -> Result<FormatResult> {
        // Read original content for comparison
        let original = fs::read_to_string(path).map_err(|e| {
            crate::LintisError::formatter(
                "clang-format",
                path,
                format!("Failed to read file: {}", e),
            )
        })?;

        // Build clang-format command
        let mut cmd = Command::new("clang-format");
        cmd.arg("-i"); // In-place formatting

        // Try to find clang-format config
        if let Some(config_path) = Self::find_clang_format_config(path) {
            cmd.arg(format!("--style=file:{}", config_path.display()));
        } else {
            // Fall back to Google style if no config found
            cmd.arg("--style=Google");
        }

        let output = cmd.arg(path).output().map_err(|e| {
            crate::LintisError::formatter("clang-format", path, format!("Failed to run: {}", e))
        })?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            return Ok(FormatResult::error(
                path.to_path_buf(),
                format!("clang-format failed: {}", stderr),
            ));
        }

        // Read new content and compare
        let new_content = fs::read_to_string(path).map_err(|e| {
            crate::LintisError::formatter(
                "clang-format",
                path,
                format!("Failed to read formatted file: {}", e),
            )
        })?;

        if original == new_content {
            Ok(FormatResult::unchanged(path.to_path_buf()))
        } else {
            Ok(FormatResult::changed(path.to_path_buf()))
        }
    }

    fn check(&self, path: &Path) -> Result<bool> {
        // Read current content
        let current = fs::read_to_string(path).map_err(|e| {
            crate::LintisError::formatter(
                "clang-format",
                path,
                format!("Failed to read file: {}", e),
            )
        })?;

        // Build clang-format command (without -i to output to stdout)
        let mut cmd = Command::new("clang-format");

        // Try to find clang-format config
        if let Some(config_path) = Self::find_clang_format_config(path) {
            cmd.arg(format!("--style=file:{}", config_path.display()));
        } else {
            // Fall back to Google style if no config found
            cmd.arg("--style=Google");
        }

        let output = cmd.arg(path).output().map_err(|e| {
            crate::LintisError::formatter("clang-format", path, format!("Failed to run: {}", e))
        })?;

        let formatted = String::from_utf8_lossy(&output.stdout);

        // If they differ, file needs formatting
        Ok(current != formatted.as_ref())
    }

    fn is_available(&self) -> bool {
        Command::new("clang-format")
            .arg("--version")
            .output()
            .map(|o| o.status.success())
            .unwrap_or(false)
    }
}