[WIP] Implement config v0 -> v1 migration.

cargo-dist/src/config/mod.rs

@@ -12,6 +12,7 @@ use cargo_dist_schema::{
 use serde::{Deserialize, Serialize};
 
 use crate::announce::TagSettings;
+use crate::config::v1::{DistWorkspaceConfig, TomlLayer};
 use crate::SortedMap;
 use crate::{
     errors::{DistError, DistResult},
@@ -22,7 +23,7 @@ pub mod v0;
 pub mod v0_to_v1;
 pub mod v1;
 
-pub use v0::{DistMetadata, GenericConfig};
+pub use v0::{DistMetadata, GenericConfig, V0WorkspaceConfig};
 
 /// values of the form `permission-name: read`
 pub type GithubPermissionMap = SortedMap<String, GithubPermission>;
@@ -678,6 +679,12 @@ impl ChecksumStyle {
     }
 }
 
+impl std::fmt::Display for ChecksumStyle {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.ext())
+    }
+}
+
 /// Which style(s) of configuration to generate
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub enum GenerateMode {
@@ -929,25 +936,79 @@ impl std::fmt::Display for ProductionMode {
     }
 }
 
+pub(crate) fn try_load_config(
+    dist_manifest_path: Option<&Utf8PathBuf>,
+) -> DistResult<DistWorkspaceConfig> {
+    let path = dist_manifest_path.ok_or(DistError::NoDistManifest {})?;
+    load_config(path)
+}
+
+pub(crate) fn try_load_package_config(
+    dist_manifest_path: Option<&Utf8PathBuf>,
+) -> DistResult<TomlLayer> {
+    if let Some(dist_manifest_path) = dist_manifest_path {
+        let src = SourceFile::load_local(dist_manifest_path)?;
+        Ok(parse_config(src)?.dist)
+    } else {
+        Ok(Default::default())
+    }
+}
+
+pub(crate) fn load_config(dist_manifest_path: &Utf8PathBuf) -> DistResult<DistWorkspaceConfig> {
+    let src = SourceFile::load_local(dist_manifest_path.as_path())?;
+    parse_config(src)
+}
+
+pub(crate) fn parse_config(src: SourceFile) -> DistResult<DistWorkspaceConfig> {
+    let config: DistWorkspaceConfig = src.deserialize_toml()?;
+    Ok(config)
+}
+
 pub(crate) fn parse_metadata_table_or_manifest(
     manifest_path: &Utf8Path,
     dist_manifest_path: Option<&Utf8Path>,
     metadata_table: Option<&serde_json::Value>,
-) -> DistResult<DistMetadata> {
+) -> DistResult<TomlLayer> {
     if let Some(dist_manifest_path) = dist_manifest_path {
         reject_metadata_table(manifest_path, dist_manifest_path, metadata_table)?;
         // Generic dist.toml
         let src = SourceFile::load_local(dist_manifest_path)?;
-        parse_generic_config(src)
+        Ok(parse_config(src)?.dist)
     } else {
         // Pre-parsed Rust metadata table
         parse_metadata_table(manifest_path, metadata_table)
     }
 }
 
-pub(crate) fn parse_generic_config(src: SourceFile) -> DistResult<DistMetadata> {
-    let config: GenericConfig = src.deserialize_toml()?;
-    Ok(config.dist.unwrap_or_default())
+// Extremely minimal struct designed to catch the most visible difference
+// between V0 and V1 config.
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case")]
+struct FauxV0 {
+    #[allow(dead_code)]
+    cargo_dist_version: String,
+}
+
+#[derive(Deserialize)]
+struct FauxConfigV0 {
+    #[allow(dead_code)]
+    dist: FauxV0,
+}
+
+pub(crate) fn looks_like_v0_config(dist_manifest_path: &Utf8Path) -> bool {
+    let Ok(src) = SourceFile::load_local(dist_manifest_path) else {
+        return false;
+    };
+    src.deserialize_toml::<FauxConfigV0>().is_ok()
+}
+
+pub(crate) fn load_v0_config(dist_manifest_path: &Utf8Path) -> DistResult<V0WorkspaceConfig> {
+    let src = SourceFile::load_local(dist_manifest_path)?;
+    parse_v0_config(src)
+}
+
+pub(crate) fn parse_v0_config(src: SourceFile) -> DistResult<V0WorkspaceConfig> {
+    Ok(src.deserialize_toml()?)
 }
 
 pub(crate) fn reject_metadata_table(
@@ -969,10 +1030,14 @@ pub(crate) fn reject_metadata_table(
 pub(crate) fn parse_metadata_table(
     manifest_path: &Utf8Path,
     metadata_table: Option<&serde_json::Value>,
-) -> DistResult<DistMetadata> {
+) -> DistResult<TomlLayer> {
+    if looks_like_v0_config(manifest_path) {
+        return Err(DistError::OldConfigFormat {});
+    }
+
     Ok(metadata_table
         .and_then(|t| t.get(METADATA_DIST))
-        .map(DistMetadata::deserialize)
+        .map(TomlLayer::deserialize)
         .transpose()
         .map_err(|cause| DistError::CargoTomlParse {
             manifest_path: manifest_path.to_owned(),

cargo-dist/src/config/v0.rs

@@ -12,6 +12,19 @@ use super::*;
 use crate::platform::MinGlibcVersion;
 use crate::SortedMap;
 
+use crate::config::v1::{PackageTable, WorkspaceTable};
+
+/// A container to assist deserializing the entirety of `dist-workspace.toml`.
+#[derive(Debug, Deserialize)]
+pub struct V0WorkspaceConfig {
+    /// the `[workspace]` table.
+    pub workspace: Option<WorkspaceTable>,
+    /// the `[package]` table.
+    pub package: Option<PackageTable>,
+    /// the `[dist]` table.
+    pub dist: Option<DistMetadata>,
+}
+
 /// A container to assist deserializing metadata from dist(-workspace).tomls
 #[derive(Debug, Deserialize)]
 pub struct GenericConfig {

cargo-dist/src/config/v1/artifacts/mod.rs

@@ -23,7 +23,7 @@ pub struct WorkspaceArtifactConfig {
     pub checksum: ChecksumStyle,
 }
 /// artifact config (raw from file)
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct ArtifactLayer {
     /// archive config

cargo-dist/src/config/v1/installers/mod.rs

@@ -65,7 +65,7 @@ pub struct InstallerConfigInheritable {
 }
 
 /// installer config (raw from file)
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct InstallerLayer {
     /// inheritable fields

cargo-dist/src/config/v1/layer.rs

@@ -171,3 +171,44 @@ pub enum BoolOr<T> {
     /// They gave a more interesting value
     Val(T),
 }
+
+impl<T> BoolOr<T> {
+    /// Returns true if it is `BoolOr::Bool(true)`, or if it contains a value.
+    pub fn not_false(&self) -> bool {
+        match self {
+            BoolOr::Bool(b) => *b,
+            BoolOr::Val(_v) => true,
+        }
+    }
+}
+
+/// Extension trait to provide Option<BoolOr<T>>::none_or_false()
+pub trait BoolOrOptExt
+where
+    Self: Sized,
+{
+    /// Given an Option<BoolOr<T>>, returns `true` if the value is
+    /// `None` or `Some(BoolOr::Bool(false))`.
+    fn none_or_false(&self) -> bool;
+
+    /// Given an Option<BoolOr<T>>, returns `true` if the value is
+    /// a `Some(BoolOr::Val(...))` or `Some(BoolOr::Bool(true))`.
+    fn is_some_and_not_false(&self) -> bool;
+}
+impl<T> BoolOrOptExt for Option<BoolOr<T>> {
+    fn none_or_false(&self) -> bool {
+        if let Some(item) = self {
+            !item.not_false()
+        } else {
+            true
+        }
+    }
+
+    fn is_some_and_not_false(&self) -> bool {
+        if let Some(item) = self {
+            item.not_false()
+        } else {
+            false
+        }
+    }
+}