migrate to cargo_metadata crate & and its structs

Author: syphar

Cargo.lock

@@ -76,6 +76,7 @@ aws-sdk-cloudfront = "1.3.0"
 aws-smithy-types-convert = { version = "0.60.0", features = ["convert-chrono"] }
 http = "1.0.0"
 uuid = { version = "1.1.2", features = ["v4"]}
+cargo_metadata = { version = "0.23.0", features = ["builder"] }
 
 # Data serialization and deserialization
 serde = { version = "1.0", features = ["derive"] }

Cargo.toml

@@ -7,7 +7,7 @@ use crate::{
     error::Result,
     registry_api::{CrateData, CrateOwner, ReleaseData},
     storage::CompressionAlgorithm,
-    utils::{MetadataPackage, rustc_version::parse_rustc_date},
+    utils::{cargo_metadata::PackageExt, rustc_version::parse_rustc_date},
     web::crate_details::{latest_release, releases_for_crate},
 };
 use anyhow::{Context, anyhow};
@@ -34,7 +34,7 @@ pub(crate) async fn finish_release(
     conn: &mut sqlx::PgConnection,
     crate_id: CrateId,
     release_id: ReleaseId,
-    metadata_pkg: &MetadataPackage,
+    metadata_pkg: &cargo_metadata::Package,
     source_dir: &Path,
     default_target: &str,
     source_files: Value,
@@ -388,7 +388,7 @@ pub(crate) async fn initialize_build(
 }
 
 /// Reads features and converts them to Vec<Feature> with default being first
-fn get_features(pkg: &MetadataPackage) -> Vec<Feature> {
+fn get_features(pkg: &cargo_metadata::Package) -> Vec<Feature> {
     let mut features = Vec::with_capacity(pkg.features.len());
     if let Some(subfeatures) = pkg.features.get("default") {
         features.push(Feature::new("default".into(), subfeatures.clone()));
@@ -403,8 +403,8 @@ fn get_features(pkg: &MetadataPackage) -> Vec<Feature> {
 }
 
 /// Reads readme if there is any read defined in Cargo.toml of a Package
-fn get_readme(pkg: &MetadataPackage, source_dir: &Path) -> Result<Option<String>> {
-    let readme_path = source_dir.join(pkg.readme.as_deref().unwrap_or("README.md"));
+fn get_readme(pkg: &cargo_metadata::Package, source_dir: &Path) -> Result<Option<String>> {
+    let readme_path = source_dir.join(pkg.readme.as_deref().unwrap_or("README.md".into()));
 
     if !readme_path.exists() {
         return Ok(None);
@@ -424,8 +424,8 @@ fn get_readme(pkg: &MetadataPackage, source_dir: &Path) -> Result<Option<String>
     }
 }
 
-fn get_rustdoc(pkg: &MetadataPackage, source_dir: &Path) -> Result<Option<String>> {
-    if let Some(src_path) = &pkg.targets.first().and_then(|t| t.src_path.as_ref()) {
+fn get_rustdoc(pkg: &cargo_metadata::Package, source_dir: &Path) -> Result<Option<String>> {
+    if let Some(src_path) = &pkg.targets.first().map(|t| &t.src_path) {
         let src_path = Path::new(src_path);
         if src_path.is_absolute() {
             read_rust_doc(src_path)
@@ -473,7 +473,7 @@ fn read_rust_doc(file_path: &Path) -> Result<Option<String>> {
 /// Adds keywords into database
 async fn add_keywords_into_database(
     conn: &mut sqlx::PgConnection,
-    pkg: &MetadataPackage,
+    pkg: &cargo_metadata::Package,
     release_id: ReleaseId,
 ) -> Result<()> {
     let wanted_keywords: HashMap<String, String> = pkg
@@ -625,7 +625,7 @@ mod test {
     use super::*;
     use crate::registry_api::OwnerKind;
     use crate::test::*;
-    use crate::utils::CargoMetadata;
+    use crate::utils::cargo_metadata::{MetadataExt as _, load_cargo_metadata_from_host_path};
     use chrono::NaiveDate;
     use std::slice;
     use test_case::test_case;
@@ -1171,7 +1171,7 @@ mod test {
         "#;
 
         std::fs::write(dir.path().join("Cargo.toml"), [base, extra].concat())?;
-        let metadata = CargoMetadata::load_from_host_path(dir.path())?;
+        let metadata = load_cargo_metadata_from_host_path(dir.path())?;
         let features = super::get_features(metadata.root());
         assert_eq!(features, expected.as_ref());
 

src/db/add_package.rs

@@ -1,13 +1,16 @@
-use crate::utils::Dependency;
-use derive_more::Deref;
+use cargo_metadata::{Dependency, DependencyKind};
 use semver::VersionReq;
 use serde::{Deserialize, Serialize};
 
-const DEFAULT_KIND: &str = "normal";
-
-/// A crate dependency in our internal representation for releases.dependencies json.
-#[derive(Debug, Clone, PartialEq, Deref)]
-pub(crate) struct ReleaseDependency(Dependency);
+/// A subset of `cargo_metadata::Dependency`.
+/// Only the data we store in our `releases.dependencies` column.
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct ReleaseDependency {
+    pub(crate) name: String,
+    pub(crate) req: VersionReq,
+    pub(crate) kind: DependencyKind,
+    pub(crate) optional: bool,
+}
 
 impl<'de> Deserialize<'de> for ReleaseDependency {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -22,25 +25,24 @@ impl<'de> Deserialize<'de> for ReleaseDependency {
             /// just [name, version]``
             Basic((String, VersionReq)),
             /// [name, version, kind]
-            WithKind((String, VersionReq, String)),
+            WithKind((String, VersionReq, DependencyKind)),
             /// [name, version, kind, optional]
-            Full((String, VersionReq, String, bool)),
+            Full((String, VersionReq, DependencyKind, bool)),
         }
 
         let src = Repr::deserialize(deserializer)?;
         let (name, req, kind, optional) = match src {
-            Repr::Basic((name, req)) => (name, req, DEFAULT_KIND.into(), false),
+            Repr::Basic((name, req)) => (name, req, DependencyKind::default(), false),
             Repr::WithKind((name, req, kind)) => (name, req, kind, false),
             Repr::Full((name, req, kind, optional)) => (name, req, kind, optional),
         };
 
-        Ok(ReleaseDependency(Dependency {
+        Ok(ReleaseDependency {
             name,
             req,
-            kind: Some(kind),
+            kind,
             optional,
-            rename: None,
-        }))
+        })
     }
 }
 
@@ -49,21 +51,18 @@ impl Serialize for ReleaseDependency {
     where
         S: serde::Serializer,
     {
-        let dep = &self.0;
-        let kind = dep.kind.as_deref().unwrap_or(DEFAULT_KIND);
-        (dep.name.as_str(), &dep.req, kind, dep.optional).serialize(serializer)
+        (self.name.as_str(), &self.req, &self.kind, self.optional).serialize(serializer)
     }
 }
 
 impl From<Dependency> for ReleaseDependency {
     fn from(dep: Dependency) -> Self {
-        ReleaseDependency(dep)
-    }
-}
-
-impl From<ReleaseDependency> for Dependency {
-    fn from(dep: ReleaseDependency) -> Self {
-        dep.0
+        ReleaseDependency {
+            name: dep.name,
+            req: dep.req,
+            kind: dep.kind,
+            optional: dep.optional,
+        }
     }
 }
 
@@ -103,12 +102,20 @@ mod tests {
         Ok(())
     }
 
-    #[test_case(r#"[["vec_map", "^0.0.1"]]"#, "normal", false)]
-    #[test_case(r#"[["vec_map", "^0.0.1", "dev" ]]"#, "dev", false)]
-    #[test_case(r#"[["vec_map", "^0.0.1", "dev", true ]]"#, "dev", true)]
+    #[test_case(r#"[["vec_map", "^0.0.1"]]"#, DependencyKind::Normal, false)]
+    #[test_case(
+        r#"[["vec_map", "^0.0.1", "dev" ]]"#,
+        DependencyKind::Development,
+        false
+    )]
+    #[test_case(
+        r#"[["vec_map", "^0.0.1", "dev", true ]]"#,
+        DependencyKind::Development,
+        true
+    )]
     fn test_parse_dependency(
         input: &str,
-        expected_kind: &str,
+        expected_kind: DependencyKind,
         expected_optional: bool,
     ) -> Result<()> {
         let deps: ReleaseDependencyList = serde_json::from_str(input)?;
@@ -118,7 +125,7 @@ mod tests {
 
         assert_eq!(dep.name, "vec_map");
         assert_eq!(dep.req, VersionReq::parse("^0.0.1")?);
-        assert_eq!(dep.kind.as_deref(), Some(expected_kind));
+        assert_eq!(dep.kind, expected_kind);
         assert_eq!(dep.optional, expected_optional);
 
         Ok(())

src/db/types/dependencies.rs

@@ -17,8 +17,9 @@ use crate::{
         rustdoc_archive_path, rustdoc_json_path, source_archive_path,
     },
     utils::{
-        CargoMetadata, ConfigName, MetadataPackage, copy_dir_all, get_config, parse_rustc_version,
-        report_error, set_config,
+        ConfigName,
+        cargo_metadata::{MetadataExt as _, PackageExt as _, load_cargo_metadata_from_rustwide},
+        copy_dir_all, get_config, parse_rustc_version, report_error, set_config,
     },
 };
 use anyhow::{Context as _, Error, anyhow, bail};
@@ -379,14 +380,14 @@ impl RustwideBuilder {
     }
 
     pub fn build_local_package(&mut self, path: &Path) -> Result<BuildPackageSummary> {
-        let metadata = CargoMetadata::load_from_rustwide(&self.workspace, &self.toolchain, path)
+        let metadata = load_cargo_metadata_from_rustwide(&self.workspace, &self.toolchain, path)
             .map_err(|err| {
                 err.context(format!("failed to load local package {}", path.display()))
             })?;
         let package = metadata.root();
         self.build_package(
             &package.name,
-            &package.version,
+            &package.version(),
             PackageKind::Local(path),
             false,
         )
@@ -1001,7 +1002,7 @@ impl RustwideBuilder {
         create_essential_files: bool,
         collect_metrics: bool,
     ) -> Result<FullBuildResult> {
-        let cargo_metadata = CargoMetadata::load_from_rustwide(
+        let cargo_metadata = load_cargo_metadata_from_rustwide(
             &self.workspace,
             &self.toolchain,
             &build.host_source_dir(),
@@ -1232,7 +1233,7 @@ impl RustwideBuilder {
         copy_dir_all(source, dest).map_err(Into::into)
     }
 
-    fn get_repo(&self, metadata: &MetadataPackage) -> Result<Option<i32>> {
+    fn get_repo(&self, metadata: &cargo_metadata::Package) -> Result<Option<i32>> {
         self.runtime
             .block_on(self.repository_stats_updater.load_repository(metadata))
     }
@@ -1241,7 +1242,7 @@ impl RustwideBuilder {
 struct FullBuildResult {
     result: BuildResult,
     target: String,
-    cargo_metadata: CargoMetadata,
+    cargo_metadata: cargo_metadata::Metadata,
     doc_coverage: Option<DocCoverage>,
     build_log: String,
 }
@@ -1286,10 +1287,12 @@ impl Default for BuildPackageSummary {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::db::types::Feature;
-    use crate::registry_api::ReleaseData;
-    use crate::storage::{CompressionAlgorithm, compression};
-    use crate::test::{AxumRouterTestExt, TestEnvironment};
+    use crate::{
+        db::types::Feature,
+        registry_api::ReleaseData,
+        storage::{CompressionAlgorithm, compression},
+        test::{AxumRouterTestExt, TestEnvironment, dummy_metadata_package},
+    };
     use pretty_assertions::assert_eq;
     use std::{io, iter};
     use test_case::test_case;
@@ -1658,21 +1661,7 @@ mod tests {
                 &mut conn,
                 crate_id,
                 release_id,
-                &MetadataPackage {
-                    name: crate_.into(),
-                    version: version.clone(),
-                    id: "".into(),
-                    license: None,
-                    repository: None,
-                    homepage: None,
-                    description: None,
-                    documentation: None,
-                    dependencies: vec![],
-                    targets: vec![],
-                    readme: None,
-                    keywords: vec![],
-                    features: HashMap::new(),
-                },
+                &dummy_metadata_package().build().unwrap(),
                 Path::new("/unknown/"),
                 "x86_64-unknown-linux-gnu",
                 serde_json::Value::Array(vec![]),

src/docbuilder/rustwide_builder.rs

@@ -1,6 +1,5 @@
 use crate::error::Result;
 use crate::repositories::{GitHub, GitLab, RateLimitReached};
-use crate::utils::MetadataPackage;
 use crate::{Config, db::Pool};
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
@@ -81,7 +80,10 @@ impl RepositoryStatsUpdater {
         Self { updaters, pool }
     }
 
-    pub(crate) async fn load_repository(&self, metadata: &MetadataPackage) -> Result<Option<i32>> {
+    pub(crate) async fn load_repository(
+        &self,
+        metadata: &cargo_metadata::Package,
+    ) -> Result<Option<i32>> {
         let url = match &metadata.repository {
             Some(url) => url,
             None => {