checkpoint, syn in - but missing

Author: elasticdotventures

Cargo.lock

@@ -47,6 +47,8 @@ rand = "0.8"
 clap = { version = "4.4", features = ["derive"] }
 html2md = "0.2.14"
 regex = "1"
+syn = { version = "2.0.104", features = ["full"] }
+flate2 = "1.1.2"
 
 [dev-dependencies]
 # Testing utilities

Cargo.toml

@@ -1,4 +1,11 @@
 use anyhow::Result;
+use reqwest;
+use std::fs;
+use std::path::Path;
+use tar::Archive;
+use flate2::read::GzDecoder;
+use syn::{File, Item};
+use tokio::fs as tokio_fs;
 
 /// Represents filters for item listing.
 #[derive(Debug)]
@@ -8,70 +15,55 @@ pub struct ItemListFilters {
     pub module: Option<String>,
 }
 
+/// Utility function to download and cache crate source.
+async fn download_and_cache_crate(crate_name: &str, version: &str) -> Result<String> {
+    let cache_dir = Path::new("./cache");
+    let crate_dir = cache_dir.join(format!("{}-{}", crate_name, version));
+
+    if crate_dir.exists() {
+        return Ok(crate_dir.to_string_lossy().to_string());
+    }
+
+    let url = format!("https://crates.io/api/v1/crates/{}/{}/download", crate_name, version);
+    let response = reqwest::get(&url).await?;
+    let tarball = response.bytes().await?;
+
+    fs::create_dir_all(&cache_dir)?;
+    let tar_gz = GzDecoder::new(&*tarball);
+    let mut archive = Archive::new(tar_gz);
+    archive.unpack(&cache_dir)?;
+
+    Ok(crate_dir.to_string_lossy().to_string())
+}
+
 /// Stub for the crate item enumeration tool.
 /// This will use rust-analyzer to enumerate items in a crate.
 pub async fn list_crate_items(
     crate_name: &str,
     version: &str,
     filters: Option<ItemListFilters>,
 ) -> Result<String> {
-    // 🦨 skunky: Implementation pending. Will use rust-analyzer APIs.
-    Ok(format!(
-        "Stub: list_crate_items for crate: {}, version: {}, filters: {:?}",
-        crate_name, version, filters
-    ))
-}
+    let crate_path = download_and_cache_crate(crate_name, version).await?;
+    let mut items = Vec::new();
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use tokio;
+    for entry in fs::read_dir(crate_path)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.extension().and_then(|ext| ext.to_str()) == Some("rs") {
+            let content = fs::read_to_string(&path)?;
+            let parsed_file: File = syn::parse_file(&content)?;
 
-    #[tokio::test]
-    async fn test_basic_call_returns_stub() {
-        let result = list_crate_items("serde", "1.0.0", None).await.unwrap();
-        assert!(result.contains("Stub: list_crate_items for crate: serde, version: 1.0.0"), "Stub output missing expected text");
+            for item in parsed_file.items {
+                match item {
+                    Item::Struct(_) if filters.as_ref().map_or(true, |f| f.item_type.as_deref() == Some("struct")) => items.push(format!("{:?}", item)),
+                    Item::Enum(_) if filters.as_ref().map_or(true, |f| f.item_type.as_deref() == Some("enum")) => items.push(format!("{:?}", item)),
+                    Item::Trait(_) if filters.as_ref().map_or(true, |f| f.item_type.as_deref() == Some("trait")) => items.push(format!("{:?}", item)),
+                    Item::Fn(_) if filters.as_ref().map_or(true, |f| f.item_type.as_deref() == Some("fn")) => items.push(format!("{:?}", item)),
+                    _ => {}
+                }
+            }
+        }
     }
 
-    #[tokio::test]
-    async fn test_with_item_type_filter() {
-        let filters = ItemListFilters {
-            item_type: Some("struct".to_string()),
-            visibility: None,
-            module: None,
-        };
-        let result = list_crate_items("serde", "1.0.0", Some(filters)).await.unwrap();
-        assert!(result.contains("filters: Some"), "Stub output missing filters");
-        assert!(result.contains("struct"), "Stub output missing item_type");
-    }
-
-    #[tokio::test]
-    async fn test_with_visibility_filter() {
-        let filters = ItemListFilters {
-            item_type: None,
-            visibility: Some("pub".to_string()),
-            module: None,
-        };
-        let result = list_crate_items("serde", "1.0.0", Some(filters)).await.unwrap();
-        assert!(result.contains("filters: Some"), "Stub output missing filters");
-        assert!(result.contains("pub"), "Stub output missing visibility");
-    }
-
-    #[tokio::test]
-    async fn test_with_module_filter() {
-        let filters = ItemListFilters {
-            item_type: None,
-            visibility: None,
-            module: Some("serde::de".to_string()),
-        };
-        let result = list_crate_items("serde", "1.0.0", Some(filters)).await.unwrap();
-        assert!(result.contains("filters: Some"), "Stub output missing filters");
-        assert!(result.contains("serde::de"), "Stub output missing module filter");
-    }
-
-    #[tokio::test]
-    async fn test_invalid_crate_name() {
-        let result = list_crate_items("not_a_real_crate", "0.0.1", None).await.unwrap();
-        assert!(result.contains("not_a_real_crate"), "Stub output missing invalid crate name");
-    }
+    Ok(items.join("\n"))
 }