ud 0.0.1

UpDate your dependencies!
Documentation
use crate::core::contract::{Ecosystem, Scheme};
use crate::core::model::{
    Availability, Constraint, Coordinate, Dependency, Span, Version, VersionMetadata,
};
use crate::core::resolve::SemverScheme;
use async_trait::async_trait;
use std::path::Path;
use toml_edit::DocumentMut;

use serde::Deserialize;

#[derive(Deserialize)]
struct CratesIoResponse {
    versions: Vec<CratesIoVersion>,
}

#[derive(Deserialize)]
struct CratesIoVersion {
    num: String,
    yanked: bool,
}

pub struct CargoEcosystem {
    client: reqwest::Client,
}

impl CargoEcosystem {
    pub fn new() -> Self {
        Self {
            client: reqwest::Client::builder()
                .user_agent("ud (https://github.com/filllabs/ud)")
                .build()
                .unwrap(),
        }
    }
}

#[async_trait]
impl Ecosystem for CargoEcosystem {
    fn name(&self) -> &'static str {
        "cargo"
    }

    async fn detect(&self, path: &Path, _content: Option<&str>) -> bool {
        path.file_name().map_or(false, |name| name == "Cargo.toml")
    }

    async fn read(&self, content: &str) -> miette::Result<Vec<Dependency>> {
        let doc: DocumentMut = content
            .parse()
            .map_err(|e| miette::miette!("Failed to parse Cargo.toml: {}", e))?;

        let mut deps = Vec::new();

        for section in &["dependencies", "dev-dependencies", "build-dependencies"] {
            if let Some(table) = doc.get(section).and_then(|v| v.as_table_like()) {
                for (name, value) in table.iter() {
                    let coordinate = Coordinate(name.to_string());

                    let constraint = if let Some(v) = value.as_str() {
                        Constraint(v.to_string())
                    } else if let Some(v) = value.get("version").and_then(|v| v.as_str()) {
                        Constraint(v.to_string())
                    } else {
                        continue;
                    };

                    let span = value
                        .span()
                        .map(|s| Span {
                            start: s.start,
                            end: s.end,
                        })
                        .unwrap_or(Span { start: 0, end: 0 });

                    deps.push(Dependency {
                        coordinate,
                        constraint,
                        span,
                        source_hint: None,
                    });
                }
            }
        }

        Ok(deps)
    }

    async fn source(&self, coordinate: &Coordinate) -> miette::Result<Availability> {
        let url = format!("https://crates.io/api/v1/crates/{}", coordinate.0);
        let res = self
            .client
            .get(&url)
            .send()
            .await
            .map_err(|e| miette::miette!("Network error for {}: {}", coordinate.0, e))?;

        if res.status() == 404 {
            return Ok(Availability::default());
        }

        let json: CratesIoResponse = res
            .json()
            .await
            .map_err(|e| miette::miette!("Failed to parse JSON for {}: {}", coordinate.0, e))?;

        let versions = json
            .versions
            .into_iter()
            .map(|v| {
                let is_prerelease = match semver::Version::parse(&v.num) {
                    Ok(parsed) => !parsed.pre.is_empty(),
                    Err(_) => false,
                };
                VersionMetadata {
                    version: Version(v.num),
                    yanked: v.yanked,
                    prerelease: is_prerelease,
                }
            })
            .collect();

        Ok(Availability { versions })
    }

    fn scheme(&self) -> &dyn Scheme {
        &SemverScheme
    }

    async fn write(
        &self,
        content: &str,
        dependency: &Dependency,
        new_version: &Version,
    ) -> miette::Result<String> {
        let mut doc: DocumentMut = content
            .parse()
            .map_err(|e| miette::miette!("Failed to parse Cargo.toml: {}", e))?;

        for section in &["dependencies", "dev-dependencies", "build-dependencies"] {
            if let Some(table) = doc.get_mut(section).and_then(|v| v.as_table_like_mut()) {
                if let Some(item) = table.get_mut(&dependency.coordinate.0) {
                    if let Some(inline) = item.as_inline_table_mut() {
                        if let Some(v) = inline.get_mut("version") {
                            let decor = v.decor().clone();
                            *v = toml_edit::Value::from(new_version.0.clone());
                            *v.decor_mut() = decor;
                        }
                    } else if let Some(v) = item.as_value_mut() {
                        let decor = v.decor().clone();
                        *v = toml_edit::Value::from(new_version.0.clone());
                        *v.decor_mut() = decor;
                    } else if let Some(table) = item.as_table_like_mut() {
                        if let Some(v) = table.get_mut("version") {
                            if let Some(val) = v.as_value_mut() {
                                let decor = val.decor().clone();
                                *val = toml_edit::Value::from(new_version.0.clone());
                                *val.decor_mut() = decor;
                            } else {
                                *v = toml_edit::value(new_version.0.clone());
                            }
                        }
                    }
                }
            }
        }

        Ok(doc.to_string())
    }
}

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

    #[tokio::test]
    async fn test_cargo_read() {
        let content = r#"
[package]
name = "test"
version = "0.1.0"

[dependencies]
serde = "1.0.0"
tokio = { version = "1.0", features = ["full"] }
"#;
        let eco = CargoEcosystem::new();
        let deps = eco.read(content).await.unwrap();
        assert_eq!(deps.len(), 2);
        assert_eq!(deps[0].coordinate.0, "serde");
        assert_eq!(deps[0].constraint.0, "1.0.0");
        assert_eq!(deps[1].coordinate.0, "tokio");
        assert_eq!(deps[1].constraint.0, "1.0");
    }

    #[tokio::test]
    async fn test_cargo_write() {
        let content = r#"
[dependencies]
serde = "1.0.0" # some comment
"#;
        let eco = CargoEcosystem::new();
        let dep = Dependency {
            coordinate: Coordinate("serde".to_string()),
            constraint: Constraint("1.0.0".to_string()),
            span: Span { start: 0, end: 0 },
            source_hint: None,
        };
        let new_version = Version("1.0.219".to_string());
        let new_content = eco.write(content, &dep, &new_version).await.unwrap();
        assert!(new_content.contains("serde = \"1.0.219\""));
        assert!(new_content.contains("# some comment"));
    }
}