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

use crate::core::MavenExecutionRequest;
use std::path::PathBuf;
use std::collections::HashMap;

/// Builder for MavenExecutionRequest
/// Provides a fluent API for constructing execution requests
#[derive(Debug, Clone)]
pub struct ExecutionRequestBuilder {
    base_directory: PathBuf,
    goals: Vec<String>,
    pom_file: Option<PathBuf>,
    system_properties: HashMap<String, String>,
    active_profiles: Vec<String>,
    reactor_active: bool,
}

impl ExecutionRequestBuilder {
    /// Create a new builder with base directory
    pub fn new(base_directory: PathBuf) -> Self {
        Self {
            base_directory,
            goals: vec![],
            pom_file: None,
            system_properties: HashMap::new(),
            active_profiles: vec![],
            reactor_active: true,
        }
    }

    /// Set goals
    pub fn with_goals(mut self, goals: Vec<String>) -> Self {
        self.goals = goals;
        self
    }

    /// Add a single goal
    pub fn add_goal(mut self, goal: String) -> Self {
        self.goals.push(goal);
        self
    }

    /// Set POM file
    pub fn with_pom_file(mut self, pom_file: PathBuf) -> Self {
        self.pom_file = Some(pom_file);
        self
    }

    /// Add system property
    pub fn with_property(mut self, key: String, value: String) -> Self {
        self.system_properties.insert(key, value);
        self
    }

    /// Add multiple system properties
    pub fn with_properties(mut self, properties: HashMap<String, String>) -> Self {
        self.system_properties.extend(properties);
        self
    }

    /// Activate profile
    pub fn with_profile(mut self, profile: String) -> Self {
        self.active_profiles.push(profile);
        self
    }

    /// Set reactor active
    pub fn reactor_active(mut self, active: bool) -> Self {
        self.reactor_active = active;
        self
    }

    /// Build the execution request
    pub fn build(self) -> MavenExecutionRequest {
        let mut request = MavenExecutionRequest::new(self.base_directory);
        request.goals = self.goals;
        request.pom_file = self.pom_file;
        request.system_properties = self.system_properties;
        request.active_profiles = self.active_profiles;
        request.reactor_active = self.reactor_active;
        request
    }
}

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

    #[test]
    fn test_execution_request_builder_basic() {
        let base_dir = PathBuf::from("/project");
        let request = ExecutionRequestBuilder::new(base_dir.clone())
            .with_goals(vec!["compile".to_string()])
            .build();

        assert_eq!(request.base_directory, base_dir);
        assert_eq!(request.goals, vec!["compile".to_string()]);
    }

    #[test]
    fn test_execution_request_builder_with_properties() {
        let base_dir = PathBuf::from("/project");
        let request = ExecutionRequestBuilder::new(base_dir)
            .with_property("maven.compiler.source".to_string(), "11".to_string())
            .with_property("maven.compiler.target".to_string(), "11".to_string())
            .build();

        assert_eq!(request.system_properties.len(), 2);
        assert_eq!(
            request.system_properties.get("maven.compiler.source"),
            Some(&"11".to_string())
        );
    }

    #[test]
    fn test_execution_request_builder_fluent() {
        let base_dir = PathBuf::from("/project");
        let request = ExecutionRequestBuilder::new(base_dir)
            .add_goal("clean".to_string())
            .add_goal("compile".to_string())
            .add_goal("test".to_string())
            .reactor_active(false)
            .with_profile("dev".to_string())
            .build();

        assert_eq!(request.goals.len(), 3);
        assert!(!request.reactor_active);
        assert_eq!(request.active_profiles.len(), 1);
    }
}