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

use std::path::{Path, PathBuf};
use anyhow::{Context, Result};
use walkdir::WalkDir;
use glob::Pattern as GlobPattern;

/// Resource file filter
#[derive(Debug, Clone)]
pub struct ResourceFilter {
    includes: Vec<GlobPattern>,
    excludes: Vec<GlobPattern>,
}

impl ResourceFilter {
    pub fn new() -> Self {
        Self {
            includes: vec![GlobPattern::new("**/*").expect("Default include pattern")],
            excludes: Vec::new(),
        }
    }

    pub fn with_includes(mut self, includes: Vec<String>) -> Result<Self> {
        self.includes = includes
            .into_iter()
            .map(|p| GlobPattern::new(&p))
            .collect::<Result<Vec<_>, _>>()
            .context("Invalid include pattern")?;
        Ok(self)
    }

    pub fn with_excludes(mut self, excludes: Vec<String>) -> Result<Self> {
        self.excludes = excludes
            .into_iter()
            .map(|p| GlobPattern::new(&p))
            .collect::<Result<Vec<_>, _>>()
            .context("Invalid exclude pattern")?;
        Ok(self)
    }

    /// Check if a path matches the filter
    pub fn matches(&self, path: &Path) -> bool {
        let path_str = path.to_string_lossy();
        
        // Check excludes first
        for exclude in &self.excludes {
            if exclude.matches(&path_str) {
                return false;
            }
        }

        // Check includes
        for include in &self.includes {
            if include.matches(&path_str) {
                return true;
            }
        }

        false
    }
}

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

/// Resource collector
pub struct ResourceCollector;

impl ResourceCollector {
    /// Collect resources from a directory with filtering
    pub fn collect_resources(
        source_dir: &Path,
        target_path: Option<&str>,
        filter: &ResourceFilter,
    ) -> Result<Vec<(PathBuf, PathBuf)>> {
        let mut resources = Vec::new();

        if !source_dir.exists() {
            return Ok(resources);
        }

        for entry in WalkDir::new(source_dir)
            .into_iter()
            .filter_map(|e| e.ok())
        {
            let source_path = entry.path();
            
            if source_path.is_file() && filter.matches(source_path) {
                let relative_path = source_path.strip_prefix(source_dir)
                    .context("Failed to get relative path")?;
                
                let target = if let Some(target_prefix) = target_path {
                    PathBuf::from(target_prefix).join(relative_path)
                } else {
                    relative_path.to_path_buf()
                };

                resources.push((source_path.to_path_buf(), target));
            }
        }

        Ok(resources)
    }

    /// Collect resources from multiple directories
    pub fn collect_from_directories(
        directories: &[(PathBuf, Option<String>, ResourceFilter)],
    ) -> Result<Vec<(PathBuf, PathBuf)>> {
        let mut all_resources = Vec::new();

        for (source_dir, target_path, filter) in directories {
            let resources = Self::collect_resources(
                source_dir,
                target_path.as_deref(),
                filter,
            )?;
            all_resources.extend(resources);
        }

        Ok(all_resources)
    }
}