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

//! Main class detection from Java source files

use std::path::Path;
use anyhow::{Result, Context};
use walkdir::WalkDir;

/// Detect main class from Java source files
pub fn detect_main_class(base_dir: &Path) -> Result<Option<String>> {
    // Try Maven structure first
    let maven_src = base_dir.join("src/main/java");
    if maven_src.exists() {
        if let Some(main_class) = find_main_class_in_dir(&maven_src)? {
            return Ok(Some(main_class));
        }
    }

    // Try Gradle structure
    let gradle_src = base_dir.join("src/main/java");
    if gradle_src.exists() {
        if let Some(main_class) = find_main_class_in_dir(&gradle_src)? {
            return Ok(Some(main_class));
        }
    }

    Ok(None)
}

/// Find main class in a directory by scanning Java files
fn find_main_class_in_dir(src_dir: &Path) -> Result<Option<String>> {
    for entry in WalkDir::new(src_dir)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| {
            e.path().extension()
                .map(|ext| ext == "java")
                .unwrap_or(false)
        })
    {
        let path = entry.path();
        if let Ok(content) = std::fs::read_to_string(path) {
            // Check for main method
            if content.contains("public static void main") {
                // Extract package name
                let package = extract_package_name(&content);
                
                // Extract class name from file path
                let relative = path.strip_prefix(src_dir)
                    .context("Failed to get relative path")?;
                let class_name = relative
                    .to_string_lossy()
                    .replace(['/', '\\'], ".")
                    .trim_end_matches(".java")
                    .to_string();

                // Combine package and class name
                let full_class_name = if let Some(pkg) = package {
                    format!("{pkg}.{class_name}")
                } else {
                    class_name
                };

                return Ok(Some(full_class_name));
            }
        }
    }

    Ok(None)
}

/// Extract package name from Java source content
fn extract_package_name(content: &str) -> Option<String> {
    for line in content.lines() {
        let trimmed = line.trim();
        if trimmed.starts_with("package ") && trimmed.ends_with(';') {
            let pkg = trimmed
                .strip_prefix("package ")?
                .strip_suffix(';')?
                .trim();
            return Some(pkg.to_string());
        }
    }
    None
}

/// Extract main class from POM or build.gradle configuration
pub fn extract_main_class_from_config(base_dir: &Path) -> Result<Option<String>> {
    // Try Maven POM first
    let pom_path = base_dir.join("pom.xml");
    if pom_path.exists() {
        if let Ok(content) = std::fs::read_to_string(&pom_path) {
            // Look for mainClass in configuration
            if let Some(start) = content.find("<mainClass>") {
                if let Some(end) = content[start..].find("</mainClass>") {
                    let main_class = content[start + 11..start + end].trim();
                    if !main_class.is_empty() {
                        return Ok(Some(main_class.to_string()));
                    }
                }
            }
        }
    }

    // Try Gradle build.gradle
    let gradle_path = base_dir.join("build.gradle");
    if gradle_path.exists() {
        if let Ok(content) = std::fs::read_to_string(&gradle_path) {
            // Look for mainClass in application block
            if let Some(start) = content.find("mainClass") {
                // Try to extract from mainClass = '...' or mainClass = "..."
                let remaining = &content[start..];
                if let Some(quote_start) = remaining.find('=') {
                    let after_eq = &remaining[quote_start + 1..].trim();
                    if let Some(quote_char) = after_eq.chars().next() {
                        if quote_char == '\'' || quote_char == '"' {
                            if let Some(quote_end) = after_eq[1..].find(quote_char) {
                                let main_class = after_eq[1..quote_end + 1].trim();
                                if !main_class.is_empty() {
                                    return Ok(Some(main_class.to_string()));
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    Ok(None)
}