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
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
162
163
164
165
166
167
168
169

//! Annotation processor implementation

use std::path::PathBuf;
use serde::{Deserialize, Serialize};

/// Java annotation processor
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnnotationProcessor {
    /// Processor name (e.g., "org.mapstruct.ap.MappingProcessor")
    pub name: String,
    /// Supported annotation types
    pub supported_annotations: Vec<String>,
    /// Supported options
    pub supported_options: Vec<String>,
    /// Processor class path
    pub class_path: Vec<PathBuf>,
}

impl AnnotationProcessor {
    pub fn new(name: impl Into<String>) -> Self {
        Self {
            name: name.into(),
            supported_annotations: Vec::new(),
            supported_options: Vec::new(),
            class_path: Vec::new(),
        }
    }

    pub fn with_annotations(mut self, annotations: Vec<String>) -> Self {
        self.supported_annotations = annotations;
        self
    }

    pub fn with_options(mut self, options: Vec<String>) -> Self {
        self.supported_options = options;
        self
    }

    pub fn with_class_path(mut self, class_path: Vec<PathBuf>) -> Self {
        self.class_path = class_path;
        self
    }
}

/// Annotation processing configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnnotationProcessorConfig {
    /// Processors to run
    pub processors: Vec<AnnotationProcessor>,
    /// Processor options
    pub options: Vec<(String, String)>,
    /// Generated sources directory
    pub generated_sources_directory: PathBuf,
    /// Generated classes directory
    pub generated_classes_directory: PathBuf,
}

impl Default for AnnotationProcessorConfig {
    fn default() -> Self {
        Self {
            processors: Vec::new(),
            options: Vec::new(),
            generated_sources_directory: PathBuf::from("target/generated-sources/annotations"),
            generated_classes_directory: PathBuf::from("target/generated-sources/annotations"),
        }
    }
}

impl AnnotationProcessorConfig {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn add_processor(&mut self, processor: AnnotationProcessor) {
        self.processors.push(processor);
    }

    pub fn add_option(&mut self, key: String, value: String) {
        self.options.push((key, value));
    }

    /// Get all class paths for processors
    pub fn get_processor_class_paths(&self) -> Vec<PathBuf> {
        let mut paths = Vec::new();
        for processor in &self.processors {
            paths.extend(processor.class_path.clone());
        }
        paths.sort();
        paths.dedup();
        paths
    }
}

/// Common annotation processors
pub mod common {
    use super::*;

    /// MapStruct processor
    pub fn mapstruct_processor() -> AnnotationProcessor {
        AnnotationProcessor::new("org.mapstruct.ap.MappingProcessor")
            .with_annotations(vec![
                "org.mapstruct.Mapping".to_string(),
                "org.mapstruct.Mappings".to_string(),
                "org.mapstruct.Mapper".to_string(),
            ])
    }

    /// AutoValue processor
    pub fn autovalue_processor() -> AnnotationProcessor {
        AnnotationProcessor::new("com.google.auto.value.processor.AutoValueProcessor")
            .with_annotations(vec![
                "com.google.auto.value.AutoValue".to_string(),
                "com.google.auto.value.AutoValue.Builder".to_string(),
            ])
    }

    /// Lombok processor
    pub fn lombok_processor() -> AnnotationProcessor {
        AnnotationProcessor::new("lombok.launch.AnnotationProcessorHider$AnnotationProcessor")
            .with_annotations(vec![
                "lombok.Data".to_string(),
                "lombok.Value".to_string(),
                "lombok.Builder".to_string(),
                "lombok.AllArgsConstructor".to_string(),
                "lombok.NoArgsConstructor".to_string(),
            ])
    }

    /// Dagger processor
    pub fn dagger_processor() -> AnnotationProcessor {
        AnnotationProcessor::new("dagger.internal.codegen.ComponentProcessor")
            .with_annotations(vec![
                "dagger.Component".to_string(),
                "dagger.Module".to_string(),
                "dagger.Provides".to_string(),
                "dagger.Binds".to_string(),
            ])
    }

    /// Get all common processors
    pub fn common_processors() -> Vec<AnnotationProcessor> {
        vec![
            mapstruct_processor(),
            autovalue_processor(),
            lombok_processor(),
            dagger_processor(),
        ]
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_annotation_processor_creation() {
        let processor = AnnotationProcessor::new("test.Processor")
            .with_annotations(vec!["com.example.Test".to_string()]);

        assert_eq!(processor.name, "test.Processor");
        assert_eq!(processor.supported_annotations.len(), 1);
    }

    #[test]
    fn test_common_processors() {
        let processors = common::common_processors();
        assert!(!processors.is_empty());
    }
}