Merge branch 'fix-parse-dependences' intoWIP cargo-metadata

Author: syphar

src/db/types/dependencies.rs

@@ -1,59 +1,57 @@
-use cargo_metadata::{Dependency, DependencyBuilder, DependencyKind};
+use cargo_metadata::{Dependency, DependencyKind};
 use derive_more::Deref;
 use semver::VersionReq;
 use serde::{Deserialize, Serialize};
 
-/// The three possible representations of a dependency in our internal JSON format
-/// in the `releases.dependencies` column.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(untagged)]
-enum Dep {
-    Two((String, VersionReq)),
-    Three((String, VersionReq, DependencyKind)),
-    Four((String, VersionReq, DependencyKind, bool)),
+/// A crate dependency in our internal representation for releases.dependencies json.
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct ReleaseDependency {
+    pub(crate) name: String,
+    pub(crate) req: VersionReq,
+    pub(crate) kind: DependencyKind,
+    pub(crate) optional: bool,
 }
 
-// FIXME: open question: should we use `cargo_metadata::Dependency` here? We would insert
-// many default values like default-features, registry, rename, etc,
-// that we don't have in the database.
-
-/// A crate dependency in our internal representation for releases.dependencies json.
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Deref)]
-#[serde(from = "Dep", into = "Dep")]
-pub(crate) struct ReleaseDependency(Dependency);
+impl<'de> Deserialize<'de> for ReleaseDependency {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        /// The three possible representations of a dependency in our internal JSON format
+        /// in the `releases.dependencies` column.
+        #[derive(Serialize, Deserialize)]
+        #[serde(untagged)]
+        enum Repr {
+            /// just [name, version]``
+            Basic((String, VersionReq)),
+            /// [name, version, kind]
+            WithKind((String, VersionReq, DependencyKind)),
+            /// [name, version, kind, optional]
+            Full((String, VersionReq, DependencyKind, bool)),
+        }
 
-impl From<Dep> for ReleaseDependency {
-    fn from(src: Dep) -> Self {
+        let src = Repr::deserialize(deserializer)?;
         let (name, req, kind, optional) = match src {
-            Dep::Two((name, req)) => (name, req, DependencyKind::default(), false),
-            Dep::Three((name, req, kind)) => (name, req, kind, false),
-            Dep::Four((name, req, kind, optional)) => (name, req, kind, optional),
+            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),
         };
 
-        ReleaseDependency(
-            DependencyBuilder::default()
-                .name(name)
-                .source(None)
-                .req(req)
-                .kind(kind)
-                .optional(optional)
-                .uses_default_features(false)
-                .features(vec![])
-                .target(None)
-                .rename(None)
-                .registry(None)
-                .path(None)
-                .build()
-                .expect("we know the data is correct"),
-        )
+        Ok(ReleaseDependency {
+            name,
+            req,
+            kind,
+            optional,
+        })
     }
 }
 
-impl From<ReleaseDependency> for Dep {
-    // dependency serialization for new releases.
-    fn from(rd: ReleaseDependency) -> Self {
-        let d = rd.0;
-        Dep::Four((d.name, d.req, d.kind, d.optional))
+impl Serialize for ReleaseDependency {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        (self.name.as_str(), &self.req, &self.kind, self.optional).serialize(serializer)
     }
 }
 
@@ -66,15 +64,24 @@ where
     I: IntoIterator<Item = Dependency>,
 {
     fn from(deps: I) -> Self {
-        Self(deps.into_iter().map(ReleaseDependency).collect())
+        Self(
+            deps.into_iter()
+                .map(|dep| ReleaseDependency {
+                    name: dep.name,
+                    req: dep.req,
+                    kind: dep.kind,
+                    optional: dep.optional,
+                })
+                .collect(),
+        )
     }
 }
 
-impl ReleaseDependencyList {
-    pub(crate) fn into_iter_dependencies(self) -> impl Iterator<Item = Dependency> {
-        self.0.into_iter().map(|rd| rd.0)
-    }
-}
+// impl ReleaseDependencyList {
+//     pub(crate) fn into_iter_dependencies(self) -> impl Iterator<Item = Dependency> {
+//         self.0.into_iter().map(|rd| rd.0)
+//     }
+// }
 
 #[cfg(test)]
 mod tests {