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