use crate::core::contract::Ecosystem;
use crate::core::model::{Dependency, Edit, ManifestReport, Report, UdError, Verdict};
use crate::core::resolve::{self, ResolveOptions};
use std::path::{Path, PathBuf};
use std::sync::Arc;
pub struct Job {
pub path: PathBuf,
pub ecosystem_idx: usize,
pub manifest: Arc<dyn crate::core::contract::Manifest>,
}
#[derive(Debug, Clone)]
pub struct RunOptions {
pub include_prerelease: bool,
}
#[derive(Debug, Clone)]
pub struct UpdateOptions {
pub allow_breaking: bool,
pub include_prerelease: bool,
}
pub fn discover(target: &Path, ecosystems: &[Ecosystem]) -> Result<Vec<Job>, UdError> {
if target.is_file() {
for (eco_idx, eco) in ecosystems.iter().enumerate() {
for manifest in &eco.manifests {
if manifest.detect(target) {
return Ok(vec![Job {
path: target.to_path_buf(),
ecosystem_idx: eco_idx,
manifest: Arc::clone(manifest),
}]);
}
}
}
return Err(UdError::UnsupportedManifest(target.to_path_buf()));
} else if target.is_dir() {
let mut jobs = Vec::new();
let mut probed_names = Vec::new();
for (eco_idx, eco) in ecosystems.iter().enumerate() {
for manifest in &eco.manifests {
for name in manifest.file_names() {
probed_names.push(*name);
let file_path = target.join(name);
if file_path.exists() && file_path.is_file() {
jobs.push(Job {
path: file_path,
ecosystem_idx: eco_idx,
manifest: Arc::clone(manifest),
});
break; }
}
}
}
if jobs.is_empty() {
return Err(UdError::NoManifestFound(target.to_path_buf()));
}
Ok(jobs)
} else {
Err(UdError::UnsupportedManifest(target.to_path_buf()))
}
}
pub async fn run(
target: &Path,
ecosystems: &[Ecosystem],
opts: &RunOptions,
) -> Result<Report, UdError> {
let jobs = discover(target, ecosystems)?;
run_jobs(&jobs, ecosystems, opts).await
}
async fn run_jobs(
jobs: &[Job],
ecosystems: &[Ecosystem],
opts: &RunOptions,
) -> Result<Report, UdError> {
let mut job_deps = Vec::new();
let mut reports = Vec::new();
for (job_idx, job) in jobs.iter().enumerate() {
let content_res = std::fs::read_to_string(&job.path);
match content_res {
Ok(content) => match job.manifest.read(&content) {
Ok(deps) => {
job_deps.push(Some(deps));
}
Err(e) => {
job_deps.push(None);
reports.push((
job_idx,
ManifestReport {
path: job.path.clone(),
ecosystem: ecosystems[job.ecosystem_idx].name.to_string(),
verdicts: vec![(
Dependency {
coordinate: crate::core::model::Coordinate::from(""),
constraint: crate::core::model::Constraint::from(""),
section: "".to_string(),
source: None,
span: None,
},
Verdict::Errored(e.to_string()),
)],
},
));
}
},
Err(e) => {
job_deps.push(None);
reports.push((
job_idx,
ManifestReport {
path: job.path.clone(),
ecosystem: ecosystems[job.ecosystem_idx].name.to_string(),
verdicts: vec![(
Dependency {
coordinate: crate::core::model::Coordinate::from(""),
constraint: crate::core::model::Constraint::from(""),
section: "".to_string(),
source: None,
span: None,
},
Verdict::Errored(e.to_string()),
)],
},
));
}
}
}
let mut flat_deps = Vec::new();
for (job_idx, deps_opt) in job_deps.iter().enumerate() {
if let Some(deps) = deps_opt {
for (dep_idx, dep) in deps.iter().enumerate() {
flat_deps.push((job_idx, dep_idx, dep.clone()));
}
}
}
let mut resolved_verdicts = Vec::new();
if !flat_deps.is_empty() {
let mut futures = Vec::new();
for (job_idx, dep_idx, dep) in flat_deps {
let eco = &ecosystems[jobs[job_idx].ecosystem_idx];
let scheme = Arc::clone(&eco.scheme);
let opts_clone = opts.clone();
futures.push(async move {
let avail_res = eco.availability(&dep).await;
let verdict = match avail_res {
Ok(avail) => {
let resolve_opts = ResolveOptions {
include_prerelease: opts_clone.include_prerelease,
};
resolve::verdict(&*scheme, &dep, avail, &resolve_opts)
}
Err(e) => Verdict::Errored(e.to_string()),
};
(job_idx, dep_idx, dep, verdict)
});
}
use futures::StreamExt;
resolved_verdicts = futures::stream::iter(futures)
.buffer_unordered(crate::core::runtime::MAX_CONCURRENT_REQUESTS)
.collect::<Vec<_>>()
.await;
}
for (job_idx, deps_opt) in job_deps.iter().enumerate() {
if let Some(deps) = deps_opt {
let mut verdicts_map = vec![None; deps.len()];
for (j_idx, d_idx, dep, verdict) in &resolved_verdicts {
if *j_idx == job_idx {
verdicts_map[*d_idx] = Some((dep.clone(), verdict.clone()));
}
}
let verdicts = verdicts_map.into_iter().map(|x| x.unwrap()).collect();
reports.push((
job_idx,
ManifestReport {
path: jobs[job_idx].path.clone(),
ecosystem: ecosystems[jobs[job_idx].ecosystem_idx].name.to_string(),
verdicts,
},
));
}
}
reports.sort_by_key(|(job_idx, _)| *job_idx);
let mut report = Report::new();
for (_, r) in reports {
report.push(r);
}
Ok(report)
}
pub async fn update(
target: &Path,
ecosystems: &[Ecosystem],
opts: &UpdateOptions,
) -> Result<Report, UdError> {
let jobs = discover(target, ecosystems)?;
let run_opts = RunOptions {
include_prerelease: opts.include_prerelease,
};
let report = run_jobs(&jobs, ecosystems, &run_opts).await?;
for (job, manifest_report) in jobs.iter().zip(&report.manifests) {
if job.path != manifest_report.path {
return Err(UdError::Message(format!(
"Internal invariant violation: Manifest path mismatch during update (job: {}, report: {})",
job.path.display(),
manifest_report.path.display()
)));
}
let raw = std::fs::read_to_string(&job.path)?;
let mut edits = Vec::new();
let eco = &ecosystems[job.ecosystem_idx];
let scheme = &eco.scheme;
for (dep, verdict) in &manifest_report.verdicts {
if let Verdict::Outdated {
compatible, latest, ..
} = verdict
{
let target_ver = if opts.allow_breaking {
Some(latest)
} else {
compatible.as_ref()
};
if let Some(target) = target_ver {
if scheme.is_upgrade(&dep.constraint, target) {
if let Some(replacement) = scheme.rewrite(&dep.constraint, target) {
edits.push(Edit { dep, replacement });
}
}
}
}
}
if !edits.is_empty() {
let new_content = job.manifest.write_batch(&raw, &edits)?;
if new_content != raw {
std::fs::write(&job.path, new_content)?;
}
}
}
Ok(report)
}