feat(cargo-util-schemas): Create NormalizedResolve

Author: secona

Cargo.lock

@@ -18,7 +18,7 @@ serde-value.workspace = true
 thiserror.workspace = true
 toml = { workspace = true, features = ["serde"] }
 unicode-xid.workspace = true
-url.workspace = true
+url = { workspace = true, features = ["serde"] }
 
 [lints]
 workspace = true

crates/cargo-util-schemas/Cargo.toml

@@ -0,0 +1,131 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "NormalizedResolve",
+  "type": "object",
+  "properties": {
+    "version": {
+      "type": [
+        "integer",
+        "null"
+      ],
+      "format": "uint32",
+      "minimum": 0
+    },
+    "package": {
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/$defs/NormalizedDependency"
+      }
+    },
+    "root": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/NormalizedDependency"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "metadata": {
+      "type": [
+        "object",
+        "null"
+      ],
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "patch": {
+      "$ref": "#/$defs/Patch"
+    }
+  },
+  "$defs": {
+    "NormalizedDependency": {
+      "type": "object",
+      "properties": {
+        "spec": {
+          "$ref": "#/$defs/PackageIdSpec"
+        },
+        "checksum": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "dependencies": {
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/$defs/NormalizedPackageId"
+          }
+        },
+        "replace": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/NormalizedPackageId"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "required": [
+        "spec"
+      ]
+    },
+    "PackageIdSpec": {
+      "type": "string"
+    },
+    "NormalizedPackageId": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "version": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "source": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/NormalizedSourceId"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "required": [
+        "name"
+      ]
+    },
+    "NormalizedSourceId": {
+      "type": "object"
+    },
+    "Patch": {
+      "type": "object",
+      "properties": {
+        "unused": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/NormalizedDependency"
+          }
+        }
+      },
+      "required": [
+        "unused"
+      ]
+    }
+  }
+}

crates/cargo-util-schemas/resolve.schema.json

@@ -1,7 +1,10 @@
 use std::cmp::Ordering;
 
+use serde::{Deserialize, Serialize};
+
 /// The possible kinds of code source.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "unstable-schema", derive(schemars::JsonSchema))]
 pub enum SourceKind {
     /// A git repository.
     Git(GitReference),
@@ -83,7 +86,8 @@ impl PartialOrd for SourceKind {
 }
 
 /// Information to find a specific commit in a Git repository.
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "unstable-schema", derive(schemars::JsonSchema))]
 pub enum GitReference {
     /// From a tag.
     Tag(String),

crates/cargo-util-schemas/src/core/source_kind.rs

@@ -9,6 +9,7 @@
 //! > ecosystem. This crate follows semver compatibility for its APIs.
 
 pub mod core;
+pub mod resolve;
 pub mod manifest;
 pub mod messages;
 #[cfg(feature = "unstable-schema")]

crates/cargo-util-schemas/src/lib.rs

@@ -0,0 +1,80 @@
+//! `Cargo.lock` / Lock file schema definition
+
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use crate::core::{PackageIdSpec, SourceKind};
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(feature = "unstable-schema", derive(schemars::JsonSchema))]
+pub struct NormalizedResolve {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub version: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub package: Option<Vec<NormalizedDependency>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub root: Option<NormalizedDependency>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<Metadata>,
+    #[serde(default, skip_serializing_if = "NormalizedPatch::is_empty")]
+    pub patch: NormalizedPatch,
+}
+
+pub type Metadata = BTreeMap<String, String>;
+
+#[derive(Serialize, Deserialize, Debug, Default)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(feature = "unstable-schema", derive(schemars::JsonSchema))]
+pub struct NormalizedPatch {
+    pub unused: Vec<NormalizedDependency>,
+}
+
+impl NormalizedPatch {
+    fn is_empty(&self) -> bool {
+        self.unused.is_empty()
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(feature = "unstable-schema", derive(schemars::JsonSchema))]
+pub struct NormalizedDependency {
+    pub id: PackageIdSpec,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub checksum: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dependencies: Option<Vec<NormalizedPackageId>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub replace: Option<NormalizedPackageId>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(feature = "unstable-schema", derive(schemars::JsonSchema))]
+pub struct NormalizedPackageId {
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<NormalizedSourceId>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "kebab-case")]
+#[cfg_attr(feature = "unstable-schema", derive(schemars::JsonSchema))]
+pub struct NormalizedSourceId {
+    #[cfg_attr(feature = "unstable-schema", schemars(with = "String"))]
+    pub url: Url,
+    pub kind: SourceKind,
+}
+
+#[cfg(feature = "unstable-schema")]
+#[test]
+fn dump_resolve_schema() {
+    let schema = schemars::schema_for!(crate::resolve::NormalizedResolve);
+    let dump = serde_json::to_string_pretty(&schema).unwrap();
+    snapbox::assert_data_eq!(dump, snapbox::file!("../resolve.schema.json").raw());
+}

crates/cargo-util-schemas/src/resolve.rs

@@ -117,6 +117,8 @@ use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::{Graph, internal};
 use anyhow::{Context as _, bail};
+use cargo_util_schemas::core::PackageIdSpec;
+use cargo_util_schemas::resolve::{NormalizedDependency, NormalizedPackageId, NormalizedPatch, NormalizedResolve, NormalizedSourceId};
 use serde::de;
 use serde::ser;
 use serde::{Deserialize, Serialize};
@@ -142,6 +144,14 @@ struct Patch {
     unused: Vec<EncodableDependency>,
 }
 
+impl Patch {
+    pub fn into_normalized(self) -> NormalizedPatch {
+        NormalizedPatch {
+            unused: self.unused.into_iter().map(|d| d.into_normalized()).collect()
+        }
+    }
+}
+
 pub type Metadata = BTreeMap<String, String>;
 
 impl EncodableResolve {
@@ -436,6 +446,24 @@ impl EncodableResolve {
             })
         }
     }
+
+    pub fn into_normalized(self) -> NormalizedResolve {
+        let root = self.root.map(|r| r.into_normalized());
+
+        let package = self.package.map(|ps| {
+            ps.into_iter().map(|p| p.into_normalized()).collect()
+        });
+
+        let patch = self.patch.into_normalized();
+
+        NormalizedResolve {
+            root,
+            version: self.version,
+            metadata: self.metadata,
+            package,
+            patch,
+        }
+    }
 }
 
 fn build_path_deps(
@@ -528,6 +556,27 @@ pub struct EncodableDependency {
     replace: Option<EncodablePackageId>,
 }
 
+impl EncodableDependency {
+    pub fn into_normalized(self) -> NormalizedDependency {
+        let mut spec = PackageIdSpec::new(self.name)
+            .with_version(self.version.parse().unwrap());
+
+        if let Some(source) = self.source.clone() {
+            spec.set_url(source.url().clone());
+            spec.set_kind(source.kind().clone());
+        }
+
+        NormalizedDependency {
+            id: spec,
+            replace: self.replace.map(|r| r.into_normalized()),
+            checksum: self.checksum,
+            dependencies: self.dependencies.map(|deps| {
+                deps.into_iter().map(|dep| dep.into_normalized()).collect()
+            }),
+        }
+    }
+}
+
 /// Pretty much equivalent to [`SourceId`] with a different serialization method.
 ///
 /// The serialization for `SourceId` doesn't do URL encode for parameters.
@@ -571,6 +620,13 @@ impl EncodableSourceId {
             self.inner.as_url()
         }
     }
+
+    pub fn into_normalized(self) -> NormalizedSourceId {
+        NormalizedSourceId {
+            url: self.url().clone(),
+            kind: self.kind().clone(),
+        }
+    }
 }
 
 impl std::ops::Deref for EncodableSourceId {
@@ -611,6 +667,16 @@ pub struct EncodablePackageId {
     source: Option<EncodableSourceId>,
 }
 
+impl EncodablePackageId {
+    pub fn into_normalized(self) -> NormalizedPackageId {
+        NormalizedPackageId {
+            name: self.name,
+            version: self.version,
+            source: self.source.map(|s| s.into_normalized()),
+        }
+    }
+}
+
 impl fmt::Display for EncodablePackageId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.name)?;