[WIP] switch to cargo_metadata instead of rewriting it

Cargo.toml

@@ -24,6 +24,7 @@ regex = "1"
 structopt = "0.3"
 crates-index = { version = "0.15.1", optional = true }
 crates-index-diff = "7.1.1"
+cargo_metadata = "0.12"
 reqwest = { version = "0.11", features = ["blocking", "json"] } # TODO: Remove blocking when async is ready
 semver = { version = "0.9", features = ["serde"] }
 slug = "=0.1.1"

src/db/add_package.rs

@@ -10,7 +10,7 @@ use crate::{
     error::Result,
     index::api::{CrateData, CrateOwner, ReleaseData},
     storage::CompressionAlgorithm,
-    utils::MetadataPackage,
+    utils::{MetadataPackage, PackageExt},
 };
 use log::{debug, info};
 use postgres::Client;
@@ -89,7 +89,7 @@ pub(crate) fn add_package_into_database(
          RETURNING id",
         &[
             &crate_id,
-            &metadata_pkg.version,
+            &metadata_pkg.version.to_string(),
             &registry_data.release_time,
             &serde_json::to_value(&dependencies)?,
             &metadata_pkg.package_name(),
@@ -202,11 +202,8 @@ fn convert_dependencies(pkg: &MetadataPackage) -> Vec<(String, String, String)>
         .iter()
         .map(|dependency| {
             let name = dependency.name.clone();
-            let version = dependency.req.clone();
-            let kind = dependency
-                .kind
-                .clone()
-                .unwrap_or_else(|| "normal".to_string());
+            let version = dependency.req.to_string();
+            let kind = dbg!(serde_json::to_string(&dependency.kind).unwrap());
 
             (name, version, kind)
         })
@@ -246,7 +243,7 @@ fn get_optional_dependencies(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"));
+    let readme_path = source_dir.join(pkg.readme.as_deref().unwrap_or(Path::new("README.md")));
 
     if !readme_path.exists() {
         return Ok(None);
@@ -267,16 +264,11 @@ 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[0].src_path {
-        let src_path = Path::new(src_path);
-        if src_path.is_absolute() {
-            read_rust_doc(src_path)
-        } else {
-            read_rust_doc(&source_dir.join(src_path))
-        }
+    let src_path = &pkg.targets[0].src_path;
+    if src_path.is_absolute() {
+        read_rust_doc(src_path)
     } else {
-        // FIXME: should we care about metabuild targets?
-        Ok(None)
+        read_rust_doc(&source_dir.join(src_path))
     }
 }
 

src/docbuilder/rustwide_builder.rs

@@ -7,7 +7,7 @@ use crate::docbuilder::{crates::crates_from_path, Limits};
 use crate::error::Result;
 use crate::index::api::ReleaseData;
 use crate::storage::CompressionAlgorithms;
-use crate::utils::{copy_dir_all, parse_rustc_version, CargoMetadata, GithubUpdater};
+use crate::utils::{copy_dir_all, parse_rustc_version, CargoMetadata, GithubUpdater, PackageExt};
 use crate::{db::blacklist::is_blacklisted, utils::MetadataPackage};
 use crate::{Config, Context, Index, Metrics, Storage};
 use docsrs_metadata::{Metadata, DEFAULT_TARGETS, HOST_TARGET};
@@ -236,7 +236,11 @@ impl RustwideBuilder {
                 err.context(format!("failed to load local package {}", path.display()))
             })?;
         let package = metadata.root();
-        self.build_package(&package.name, &package.version, PackageKind::Local(path))
+        self.build_package(
+            &package.name,
+            &package.version.to_string(),
+            PackageKind::Local(path),
+        )
     }
 
     pub fn build_package(

src/test/fakes.rs

@@ -2,7 +2,8 @@ use super::TestDatabase;
 use crate::docbuilder::{BuildResult, DocCoverage};
 use crate::index::api::{CrateData, CrateOwner, ReleaseData};
 use crate::storage::Storage;
-use crate::utils::{Dependency, MetadataPackage, Target};
+use crate::utils::{MetadataPackage, PackageExt};
+use cargo_metadata::PackageId;
 use chrono::{DateTime, Utc};
 use failure::Error;
 use postgres::Client;
@@ -45,35 +46,35 @@ impl<'a> FakeRelease<'a> {
         FakeRelease {
             db,
             storage,
-            package: MetadataPackage {
-                id: "fake-package-id".into(),
-                name: "fake-package".into(),
-                version: "1.0.0".into(),
-                license: Some("MIT".into()),
-                repository: Some("https://git.example.com".into()),
-                homepage: Some("https://www.example.com".into()),
-                description: Some("Fake package".into()),
-                documentation: Some("https://docs.example.com".into()),
-                dependencies: vec![Dependency {
-                    name: "fake-dependency".into(),
-                    req: "^1.0.0".into(),
-                    kind: None,
-                    rename: None,
-                    optional: false,
+            package: serde_json::from_value(serde_json::json!({
+                "id": "fake-package-id",
+                "name": "fake-package",
+                "version": "1.0.0",
+                "license": "MIT",
+                "repository": "https://git.example.com",
+                "homepage": "https://www.example.com",
+                "description": "Fake package",
+                "documentation": "https://docs.example.com",
+                "dependencies": [{
+                    "name": "fake-dependency",
+                    "req": "^1.0.0",
+                    "kind": null,
+                    "rename": null,
+                    "optional": false
                 }],
-                targets: vec![Target::dummy_lib("fake_package".into(), None)],
-                readme: None,
-                keywords: vec!["fake".into(), "package".into()],
-                features: [
-                    ("default".into(), vec!["feature1".into(), "feature3".into()]),
-                    ("feature1".into(), Vec::new()),
-                    ("feature2".into(), vec!["feature1".into()]),
-                    ("feature3".into(), Vec::new()),
-                ]
-                .iter()
-                .cloned()
-                .collect::<HashMap<String, Vec<String>>>(),
-            },
+                "targets": [{
+                    "name": "fake_package"
+                }],
+                "readme": null,
+                "keywords": ["fake", "package"],
+                "features": {
+                    "default": ["feature1", "feature3"],
+                    "feature1": [],
+                    "feature2": ["feature1"],
+                    "feature3": []
+                }
+            }))
+            .unwrap(),
             builds: vec![],
             source_files: Vec::new(),
             rustdoc_files: Vec::new(),
@@ -110,13 +111,15 @@ impl<'a> FakeRelease<'a> {
 
     pub(crate) fn name(mut self, new: &str) -> Self {
         self.package.name = new.into();
-        self.package.id = format!("{}-id", new);
+        self.package.id = PackageId {
+            repr: format!("{}-id", new),
+        };
         self.package.targets[0].name = new.into();
         self
     }
 
     pub(crate) fn version(mut self, new: &str) -> Self {
-        self.package.version = new.into();
+        self.package.version = cargo_metadata::Version::parse(new).expect("invalid semver");
         self
     }
 
@@ -191,7 +194,11 @@ impl<'a> FakeRelease<'a> {
     pub(crate) fn add_platform<S: Into<String>>(mut self, platform: S) -> Self {
         let platform = platform.into();
         let name = self.package.targets[0].name.clone();
-        let target = Target::dummy_lib(name, Some(platform.clone()));
+        let target = serde_json::from_value(serde_json::json!({
+            "name": name,
+            "src_path": platform.clone()
+        }))
+        .unwrap();
         self.package.targets.push(target);
         self.doc_targets.push(platform);
         self
@@ -256,10 +263,10 @@ impl<'a> FakeRelease<'a> {
             }
         }
 
-        let upload_files = |prefix: &str, files: &[(&str, &[u8])], target: Option<&str>| {
+        let upload_files = |prefix: &str, files: &[(&str, &[u8])], target: Option<&Path>| {
             let mut path_prefix = tempdir.path().join(prefix);
             if let Some(target) = target {
-                path_prefix.push(target);
+                path_prefix.push(target.to_owned());
             }
             fs::create_dir(&path_prefix)?;
 
@@ -278,7 +285,7 @@ impl<'a> FakeRelease<'a> {
                 prefix,
                 package.name,
                 package.version,
-                target.unwrap_or("")
+                target.unwrap_or(Path::new("")).display()
             );
             log::debug!("adding directory {} from {}", prefix, path_prefix.display());
             crate::db::add_path_into_database(&storage, &prefix, path_prefix)
@@ -304,9 +311,9 @@ impl<'a> FakeRelease<'a> {
             log::debug!("added rustdoc files {}", rustdoc_meta);
 
             for target in &package.targets[1..] {
-                let platform = target.src_path.as_ref().unwrap();
+                let platform = &target.src_path;
                 upload_files("rustdoc", &rustdoc_files, Some(platform))?;
-                log::debug!("added platform files for {}", platform);
+                log::debug!("added platform files for {}", platform.display());
             }
         }