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

use std::collections::HashSet;

use crate::artifact::{Artifact, LocalRepository};
use crate::model::Dependency;
use crate::resolver::repository::RemoteRepository;
use crate::resolver::downloader::ArtifactDownloader;

/// Dependency resolver
pub struct DependencyResolver {
    local_repository: Box<dyn LocalRepository>,
    remote_repositories: Vec<RemoteRepository>,
    downloader: ArtifactDownloader,
}

impl DependencyResolver {
    pub fn new(local_repository: Box<dyn LocalRepository>) -> Self {
        Self {
            local_repository,
            remote_repositories: vec![RemoteRepository::new(
                "central",
                url::Url::parse("https://repo1.maven.org/maven2/").unwrap(),
            )],
            downloader: ArtifactDownloader::new(),
        }
    }

    pub fn with_remote_repositories(
        mut self,
        repositories: Vec<RemoteRepository>,
    ) -> Self {
        self.remote_repositories = repositories;
        self
    }

    /// Get remote repositories
    pub fn remote_repositories(&self) -> &[RemoteRepository] {
        &self.remote_repositories
    }

    /// Resolve a dependency to an artifact
    pub fn resolve_dependency(
        &self,
        dependency: &Dependency,
    ) -> anyhow::Result<Option<Artifact>> {
        let version = dependency.version.as_ref().ok_or_else(|| {
            anyhow::anyhow!("Dependency {}:{} has no version", dependency.group_id, dependency.artifact_id)
        })?;

        let artifact = Artifact::new(
            &dependency.group_id,
            &dependency.artifact_id,
            version,
        );

        self.resolve_artifact(&artifact)
    }

    /// Resolve an artifact
    pub fn resolve_artifact(
        &self,
        artifact: &Artifact,
    ) -> anyhow::Result<Option<Artifact>> {
        // Check local repository first
        if self.local_repository.artifact_exists(artifact) {
            let mut resolved = artifact.clone();
            resolved.file = Some(self.local_repository.artifact_path(artifact));
            return Ok(Some(resolved));
        }

        // Download from remote repositories
        let local_path = self.local_repository.artifact_path(artifact);
        
        match self.downloader.download_from_repositories(
            artifact,
            &self.remote_repositories,
            &local_path,
        ) {
            Ok(_) => {
                let mut resolved = artifact.clone();
                resolved.file = Some(local_path);
                Ok(Some(resolved))
            }
            Err(e) => {
                tracing::warn!("Failed to resolve artifact {}: {}", artifact, e);
                Ok(None)
            }
        }
    }

    /// Resolve and parse a POM for an artifact
    pub fn resolve_pom(
        &self,
        artifact: &Artifact,
    ) -> anyhow::Result<Option<crate::model::Model>> {
        let mut pom_artifact = artifact.clone();
        pom_artifact.coordinates.packaging = Some("pom".to_string());
        
        if let Some(resolved) = self.resolve_artifact(&pom_artifact)? {
            if let Some(path) = resolved.file {
                let content = std::fs::read_to_string(path)?;
                let model = crate::model::parser::parse_pom(&content)?;
                return Ok(Some(model));
            }
        }
        
        Ok(None)
    }

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

        for dependency in dependencies {
            let key = format!("{}:{}", dependency.group_id, dependency.artifact_id);
            if seen.contains(&key) {
                continue;
            }
            seen.insert(key);

            if let Some(artifact) = self.resolve_dependency(dependency)? {
                resolved.push(artifact);
            }
        }

        Ok(resolved)
    }
}