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

use anyhow::Result;

use crate::core::session::MavenSession;
use crate::core::project::MavenProject;
use crate::core::lifecycle::LifecyclePhase;
use crate::core::mojo_executor::{MojoExecutor, MojoExecution};
use crate::plugin_api::registry::PluginRegistry;

/// Lifecycle executor - executes lifecycle phases with plugin bindings
pub struct LifecycleExecutor {
    mojo_executor: MojoExecutor,
}

impl LifecycleExecutor {
    pub fn new() -> Self {
        Self {
            mojo_executor: MojoExecutor::new(),
        }
    }

    /// Execute a lifecycle phase for a project
    pub fn execute_phase(
        &self,
        session: &MavenSession,
        project: &MavenProject,
        phase: &LifecyclePhase,
    ) -> Result<()> {
        tracing::info!("Executing phase: {} for project {}", phase, project.id());

        // Get plugin bindings for this phase
        let mojo_executions = self.get_phase_mojos(project, phase)?;

        // Execute all mojos for this phase
        self.mojo_executor.execute(session, &mojo_executions)?;

        Ok(())
    }

    /// Get mojo executions for a lifecycle phase
    fn get_phase_mojos(
        &self,
        _project: &MavenProject,
        phase: &LifecyclePhase,
    ) -> Result<Vec<MojoExecution>> {
        let mut executions = Vec::new();

        // Get default plugin bindings for standard lifecycle phases
        match phase {
            LifecyclePhase::Compile => {
                executions.push(MojoExecution {
                    group_id: "org.apache.maven.plugins".to_string(),
                    artifact_id: "maven-compiler-plugin".to_string(),
                    version: None, // Will be resolved by MojoExecutor
                    goal: "compile".to_string(),
                    phase: Some("compile".to_string()),
                    configuration: None,
                });
            }
            LifecyclePhase::TestCompile => {
                executions.push(MojoExecution {
                    group_id: "org.apache.maven.plugins".to_string(),
                    artifact_id: "maven-compiler-plugin".to_string(),
                    version: None,
                    goal: "testCompile".to_string(),
                    phase: Some("test-compile".to_string()),
                    configuration: None,
                });
            }
            LifecyclePhase::Test => {
                executions.push(MojoExecution {
                    group_id: "org.apache.maven.plugins".to_string(),
                    artifact_id: "maven-surefire-plugin".to_string(),
                    version: None,
                    goal: "test".to_string(),
                    phase: Some("test".to_string()),
                    configuration: None,
                });
            }
            LifecyclePhase::Package => {
                executions.push(MojoExecution {
                    group_id: "org.apache.maven.plugins".to_string(),
                    artifact_id: "maven-jar-plugin".to_string(),
                    version: None,
                    goal: "jar".to_string(),
                    phase: Some("package".to_string()),
                    configuration: None,
                });
            }
            LifecyclePhase::Install => {
                executions.push(MojoExecution {
                    group_id: "org.apache.maven.plugins".to_string(),
                    artifact_id: "maven-install-plugin".to_string(),
                    version: None,
                    goal: "install".to_string(),
                    phase: Some("install".to_string()),
                    configuration: None,
                });
            }
            LifecyclePhase::Deploy => {
                executions.push(MojoExecution {
                    group_id: "org.apache.maven.plugins".to_string(),
                    artifact_id: "maven-deploy-plugin".to_string(),
                    version: None,
                    goal: "deploy".to_string(),
                    phase: Some("deploy".to_string()),
                    configuration: None,
                });
            }
            _ => {
                // Other phases may not have default bindings
                // Clean is a separate lifecycle, not part of default lifecycle
            }
        }

        // TODO: Also check project.build.plugins for custom bindings
        // TODO: Check pluginManagement for version resolution

        Ok(executions)
    }

    /// Execute lifecycle up to a given phase
    pub fn execute_to_phase(
        &self,
        session: &MavenSession,
        project: &MavenProject,
        target_phase: &LifecyclePhase,
    ) -> Result<()> {
        let all_phases = LifecyclePhase::all();
        
        for phase in all_phases {
            if phase == *target_phase {
                self.execute_phase(session, project, &phase)?;
                break;
            }
            self.execute_phase(session, project, &phase)?;
        }

        Ok(())
    }

    pub fn with_plugin_registry(self, _registry: PluginRegistry) -> Self {
        // TODO: Store registry and use it for plugin loading
        self
    }
}

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