ud 0.1.0

UpDate! — A fast, universal dependency updater.
Documentation
use crate::core::contract::Registry;
use crate::core::model::{Availability, Dependency, RegistryId, UdError, Version, VersionMeta};
use async_trait::async_trait;
use serde::Deserialize;

crate::http_registry! {
    CratesRegistry { id: "crates", base: "https://index.crates.io" },
}

#[derive(Deserialize)]
struct SparseIndexEntry {
    vers: String,
    yanked: bool,
}

fn sparse_index_path(name: &str) -> String {
    let name_lower = name.to_lowercase();
    let chars: Vec<char> = name_lower.chars().collect();
    let len = chars.len();
    if len == 1 {
        format!("1/{}", name_lower)
    } else if len == 2 {
        format!("2/{}", name_lower)
    } else if len == 3 {
        format!("3/{}/{}", chars[0], name_lower)
    } else {
        let first_two: String = chars[0..2].iter().collect();
        let next_two: String = chars[2..4].iter().collect();
        format!("{}/{}/{}", first_two, next_two, name_lower)
    }
}

#[async_trait]
impl Registry for CratesRegistry {
    fn id(&self) -> RegistryId {
        RegistryId::from(Self::REGISTRY_ID)
    }

    async fn versions(&self, dep: &Dependency) -> Result<Availability, UdError> {
        let path = sparse_index_path(&dep.coordinate.0);
        let url = format!("{}/{}", self.base_url, path);

        tracing::debug!(crate_name = %dep.coordinate.0, url = %url, "fetching index");

        let res =
            self.client.get(&url).send().await.map_err(|e| {
                UdError::Http(format!("Network error for {}: {}", dep.coordinate.0, e))
            })?;

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

        if !res.status().is_success() {
            return Err(UdError::Http(format!(
                "HTTP error {} for {}",
                res.status(),
                dep.coordinate.0
            )));
        }

        let body = res.text().await.map_err(|e| {
            UdError::Http(format!(
                "Failed to read response body for {}: {}",
                dep.coordinate.0, e
            ))
        })?;

        let mut versions = Vec::new();
        for line in body.lines() {
            let line = line.trim();
            if line.is_empty() {
                continue;
            }
            let entry: SparseIndexEntry = serde_json::from_str(line).map_err(|e| {
                UdError::Parse(format!(
                    "Failed to parse index JSON for {}: {} (line: {})",
                    dep.coordinate.0, e, line
                ))
            })?;

            versions.push(VersionMeta {
                version: Version(entry.vers),
                yanked: entry.yanked,
            });
        }

        Ok(Availability { versions })
    }
}

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

    #[test]
    fn test_sparse_index_path() {
        assert_eq!(sparse_index_path("a"), "1/a");
        assert_eq!(sparse_index_path("ab"), "2/ab");
        assert_eq!(sparse_index_path("abc"), "3/a/abc");
        assert_eq!(sparse_index_path("abcd"), "ab/cd/abcd");
        assert_eq!(sparse_index_path("serde"), "se/rd/serde");
        assert_eq!(sparse_index_path("SerDe"), "se/rd/serde");
    }

    #[test]
    fn test_sparse_index_parse() {
        let ndjson = r#"
{"name":"serde","vers":"1.0.0","deps":[],"cksum":"123","features":{},"yanked":false}
{"name":"serde","vers":"1.0.1-alpha.1","deps":[],"cksum":"456","features":{},"yanked":true}
"#;
        let mut entries = Vec::new();
        for line in ndjson.lines() {
            let line = line.trim();
            if line.is_empty() {
                continue;
            }
            let entry: SparseIndexEntry = serde_json::from_str(line).unwrap();
            entries.push(entry);
        }
        assert_eq!(entries.len(), 2);
        assert_eq!(entries[0].vers, "1.0.0");
        assert!(!entries[0].yanked);
        assert_eq!(entries[1].vers, "1.0.1-alpha.1");
        assert!(entries[1].yanked);
    }
}