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

//! Dependency tracking for incremental builds

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

/// Tracks dependencies between files
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DependencyTracker {
    /// Map from file to its dependencies
    pub forward_deps: HashMap<PathBuf, HashSet<PathBuf>>,
    /// Map from file to files that depend on it
    pub reverse_deps: HashMap<PathBuf, HashSet<PathBuf>>,
}

impl DependencyTracker {
    pub fn new() -> Self {
        Self {
            forward_deps: HashMap::new(),
            reverse_deps: HashMap::new(),
        }
    }

    /// Add a dependency relationship
    pub fn add_dependency(&mut self, from: PathBuf, to: PathBuf) {
        self.forward_deps
            .entry(from.clone())
            .or_default()
            .insert(to.clone());
        self.reverse_deps
            .entry(to)
            .or_default()
            .insert(from);
    }

    /// Get all files that transitively depend on a file
    pub fn get_dependents(&self, file: &PathBuf) -> HashSet<PathBuf> {
        let mut dependents = HashSet::new();
        let mut queue = Vec::new();

        if let Some(direct) = self.reverse_deps.get(file) {
            queue.extend(direct.clone());
        }

        while let Some(current) = queue.pop() {
            if dependents.contains(&current) {
                continue;
            }
            dependents.insert(current.clone());

            if let Some(direct) = self.reverse_deps.get(&current) {
                queue.extend(direct.clone());
            }
        }

        dependents
    }

    /// Get all transitive dependencies of a file
    pub fn get_dependencies(&self, file: &PathBuf) -> HashSet<PathBuf> {
        let mut dependencies = HashSet::new();
        let mut queue = Vec::new();

        if let Some(direct) = self.forward_deps.get(file) {
            queue.extend(direct.clone());
        }

        while let Some(current) = queue.pop() {
            if dependencies.contains(&current) {
                continue;
            }
            dependencies.insert(current.clone());

            if let Some(direct) = self.forward_deps.get(&current) {
                queue.extend(direct.clone());
            }
        }

        dependencies
    }

    /// Remove a file and update dependencies
    pub fn remove_file(&mut self, file: &PathBuf) {
        if let Some(deps) = self.forward_deps.remove(file) {
            for dep in deps {
                if let Some(reverse) = self.reverse_deps.get_mut(&dep) {
                    reverse.remove(file);
                }
            }
        }

        if let Some(reverse) = self.reverse_deps.remove(file) {
            for rev in reverse {
                if let Some(forward) = self.forward_deps.get_mut(&rev) {
                    forward.remove(file);
                }
            }
        }
    }

    /// Clear all dependencies
    pub fn clear(&mut self) {
        self.forward_deps.clear();
        self.reverse_deps.clear();
    }
}

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

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

    #[test]
    fn test_dependency_tracker() {
        let mut tracker = DependencyTracker::new();

        let a = PathBuf::from("A.java");
        let b = PathBuf::from("B.java");
        let c = PathBuf::from("C.java");

        tracker.add_dependency(a.clone(), b.clone());
        tracker.add_dependency(b.clone(), c.clone());

        let deps = tracker.get_dependencies(&a);
        assert!(deps.contains(&b));
        assert!(deps.contains(&c));
    }
}