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

use std::collections::{HashMap, HashSet};

use crate::artifact::Artifact;
use crate::model::Dependency;
use crate::resolver::DependencyResolver;

/// Transitive dependency resolver
pub struct TransitiveDependencyResolver {
    resolver: DependencyResolver,
    resolved_cache: HashMap<String, Vec<Artifact>>,
}

impl TransitiveDependencyResolver {
    pub fn new(resolver: DependencyResolver) -> Self {
        Self {
            resolver,
            resolved_cache: HashMap::new(),
        }
    }

    /// Resolve all transitive dependencies for a dependency
    pub fn resolve_transitive(
        &mut self,
        dependency: &Dependency,
    ) -> anyhow::Result<Vec<Artifact>> {
        let key = format!("{}:{}:{}", 
            dependency.group_id, 
            dependency.artifact_id,
            dependency.version.as_deref().unwrap_or("")
        );

        // Check cache
        if let Some(cached) = self.resolved_cache.get(&key) {
            return Ok(cached.clone());
        }

        let mut resolved = Vec::new();
        let mut visited = HashSet::new();

        self.resolve_recursive(dependency, &mut resolved, &mut visited)?;

        // Cache result
        self.resolved_cache.insert(key, resolved.clone());
        Ok(resolved)
    }

    fn resolve_recursive(
        &mut self,
        dependency: &Dependency,
        resolved: &mut Vec<Artifact>,
        visited: &mut HashSet<String>,
    ) -> anyhow::Result<()> {
        let dep_key = format!("{}:{}", dependency.group_id, dependency.artifact_id);
        
        if visited.contains(&dep_key) {
            return Ok(());
        }
        visited.insert(dep_key.clone());

        // Resolve the dependency itself
        if let Some(artifact) = self.resolver.resolve_dependency(dependency)? {
            resolved.push(artifact.clone());

            // Load POM for this artifact to get its dependencies
            if let Ok(Some(model)) = self.resolver.resolve_pom(&artifact) {
                if let Some(deps) = model.dependencies {
                    for sub_dep in deps.dependencies {
                        // Skip test/provided scope for transitive dependencies
                        if sub_dep.scope.as_deref() == Some("test") || sub_dep.scope.as_deref() == Some("provided") {
                            continue;
                        }
                        
                        // Handle optional dependencies (usually skipped in transitive resolution)
                        if sub_dep.optional == Some(true) {
                            continue;
                        }

                        self.resolve_recursive(&sub_dep, resolved, visited)?;
                    }
                }
            }
        }

        Ok(())
    }

    /// Resolve all transitive dependencies for a list of dependencies
    pub fn resolve_all_transitive(
        &mut self,
        dependencies: &[Dependency],
    ) -> anyhow::Result<Vec<Artifact>> {
        let mut all_resolved = Vec::new();
        let mut seen = HashSet::new();

        for dependency in dependencies {
            let transitive = self.resolve_transitive(dependency)?;
            for artifact in transitive {
                let artifact_key = artifact.coordinates.full_id();
                if !seen.contains(&artifact_key) {
                    seen.insert(artifact_key);
                    all_resolved.push(artifact);
                }
            }
        }

        Ok(all_resolved)
    }
}