ud 0.1.0

UpDate! — A fast, universal dependency updater.
Documentation
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; // Stop probing for THIS handler
                    }
                }
            }
        }

        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)
}