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

//! Module factory for creating module instances from configuration

use crate::checkstyle::api::check::{Check, FileSetCheck};
use crate::checkstyle::api::config::{Configuration, Context};
use crate::checkstyle::api::error::{CheckstyleError, CheckstyleResult};
use crate::checkstyle::checks::empty_catch_block::EmptyCatchBlockCheck;
use crate::checkstyle::checks::empty_statement::EmptyStatementCheck;
use crate::checkstyle::checks::line_length::LineLengthCheck;
use crate::checkstyle::checks::missing_switch_default::MissingSwitchDefaultCheck;
use crate::checkstyle::checks::multiple_variable_declarations::MultipleVariableDeclarationsCheck;
use crate::checkstyle::checks::package_name::PackageNameCheck;
use crate::checkstyle::checks::redundant_import::RedundantImportCheck;
use crate::checkstyle::checks::simplify_boolean_return::SimplifyBooleanReturnCheck;
use crate::checkstyle::checks::type_name::TypeNameCheck;
use crate::checkstyle::runner::tree_walker_file_set_check::TreeWalkerFileSetCheck;
use std::sync::{Arc, Mutex};

/// Factory for creating module instances
pub trait ModuleFactory: Send + Sync {
    /// Create a module instance from a name
    fn create_module(&self, name: &str) -> CheckstyleResult<ModuleInstance>;
}

/// A module instance that can be configured
pub enum ModuleInstance {
    /// A FileSetCheck instance
    FileSetCheck(Box<dyn FileSetCheck>),
    /// A Check instance (for TreeWalker)
    Check(Arc<Mutex<dyn Check>>),
}

/// Default module factory implementation
pub struct DefaultModuleFactory;

impl DefaultModuleFactory {
    /// Create a new default module factory
    pub fn new() -> Self {
        Self
    }
}

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

impl ModuleFactory for DefaultModuleFactory {
    fn create_module(&self, name: &str) -> CheckstyleResult<ModuleInstance> {
        match name {
            "Checker" => {
                // Checker is handled separately, not created here
                Err(CheckstyleError::Configuration("Checker should not be created via factory".to_string()))
            }
            "TreeWalker" => {
                let file_set_check = TreeWalkerFileSetCheck::new();
                Ok(ModuleInstance::FileSetCheck(Box::new(file_set_check)))
            }
            "LineLength" => {
                let check = LineLengthCheck::new();
                Ok(ModuleInstance::FileSetCheck(Box::new(check)))
            }
            "EmptyCatchBlock" => {
                let check = EmptyCatchBlockCheck::new();
                Ok(ModuleInstance::Check(Arc::new(Mutex::new(check))))
            }
            "EmptyStatement" => {
                let check = EmptyStatementCheck::new();
                Ok(ModuleInstance::Check(Arc::new(Mutex::new(check))))
            }
            "MissingSwitchDefault" => {
                let check = MissingSwitchDefaultCheck::new();
                Ok(ModuleInstance::Check(Arc::new(Mutex::new(check))))
            }
            "SimplifyBooleanReturn" => {
                let check = SimplifyBooleanReturnCheck::new();
                Ok(ModuleInstance::Check(Arc::new(Mutex::new(check))))
            }
            "MultipleVariableDeclarations" => {
                let check = MultipleVariableDeclarationsCheck::new();
                Ok(ModuleInstance::Check(Arc::new(Mutex::new(check))))
            }
            "PackageName" => {
                let check = PackageNameCheck::new();
                Ok(ModuleInstance::Check(Arc::new(Mutex::new(check))))
            }
            "RedundantImport" => {
                let check = RedundantImportCheck::new();
                Ok(ModuleInstance::Check(Arc::new(Mutex::new(check))))
            }
            "TypeName" => {
                let check = TypeNameCheck::new();
                Ok(ModuleInstance::Check(Arc::new(Mutex::new(check))))
            }
            _ => Err(CheckstyleError::Configuration(format!(
                "Unknown module: {name}"
            ))),
        }
    }
}

/// Helper to configure a module instance
pub fn configure_module(
    instance: &mut ModuleInstance,
    config: &Configuration,
    context: &Context,
) -> CheckstyleResult<()> {
    match instance {
        ModuleInstance::FileSetCheck(check) => {
            check.contextualize(context)?;
            check.configure(config)?;
        }
        ModuleInstance::Check(check) => {
            let mut check_guard = check.lock().unwrap();
            check_guard.contextualize(context)?;
            check_guard.configure(config)?;
        }
    }
    Ok(())
}