[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;
 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>;
@@ -929,6 +930,16 @@ impl std::fmt::Display for ProductionMode {
     }
 }
 
+pub(crate) fn load_config(dist_manifest_path: &Utf8Path) -> DistResult<DistWorkspaceConfig> {
+    let src = SourceFile::load_local(dist_manifest_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>,
@@ -945,6 +956,15 @@ pub(crate) fn parse_metadata_table_or_manifest(
     }
 }
 
+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 parse_generic_config(src: SourceFile) -> DistResult<DistMetadata> {
     let config: GenericConfig = src.deserialize_toml()?;
     Ok(config.dist.unwrap_or_default())

cargo-dist/src/config/v0.rs

@@ -12,6 +12,19 @@ use super::*;
 use crate::platform::MinGlibcVersion;
 use crate::SortedMap;
 
+use crate::config::v1::{WorkspaceTable, PackageTable};
+
+/// 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/mod.rs

@@ -373,6 +373,78 @@ impl ApplyLayer for AppConfigInheritable {
     }
 }
 
+/// The internal representation of the [package] table from dist[-workspace].toml.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct PackageTable {
+    /// The name of the package.
+    pub name: String,
+    /// The version of the package. Syntax must be a valid Cargo SemVer Version.
+    pub version: String,
+    /// A brief description of the package.
+    pub description: Option<String>,
+    /// The authors of the package.
+    pub authors: Option<Vec<String>>,
+    /// A URL to the repository hosting this package.
+    pub repository: Option<String>,
+    /// A URL to the homepage of the package.
+    pub homepage: Option<String>,
+    /// A URL to the documentation of the package.
+    pub documentation: Option<String>,
+    /// A relative path to the changelog file for your package.
+    pub changelog: Option<String>,
+    /// A relative path to the readme file for your package.
+    pub readme: Option<String>,
+    /// The license(s) of your package, in SPDX format.
+    pub license: Option<String>,
+    /// Relative paths to the license files for your package.
+    pub license_files: Option<Vec<String>>,
+    /// Names of binaries (without the extension) your package is expected
+    /// to build and distribute.
+    pub binaries: Option<Vec<String>>,
+    /// Names of c-style static libraries (without the extension) your
+    /// package is expected to build and distribute.
+    pub cstaticlibs: Option<Vec<String>>,
+    /// Names of c-style dynamic libraries (without the extension) your
+    /// package is expected to build and distribute.
+    pub cdylibs: Option<Vec<String>>,
+    /// A command to run in your package's root directory to build its
+    /// binaries, cstaticlibs, and cdylibs.
+    pub build_command: Option<Vec<String>>,
+}
+
+/// The internal representation of dist.toml.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct DistConfig {
+    /// The `[package]` table from dist.toml.
+    pub package: Option<PackageTable>,
+    /// The `[dist]` table from dist.toml.
+    pub dist: TomlLayer,
+}
+
+/// The internal representation of the [workspace] table from dist-workspace.toml.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct WorkspaceTable {
+    /// The various projects/workspaces/packages to be managed by dist.
+    pub members: Vec<String>,
+}
+
+/// The internal representation of dist-workspace.toml.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct DistWorkspaceConfig {
+    /// The `[workspace]` table.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub workspace: Option<WorkspaceTable>,
+    /// The `[dist]` table
+    pub dist: TomlLayer,
+    /// The `[package]` table.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub package: Option<PackageTable>,
+}
+
 /// The "raw" input from a toml file containing config
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]

cargo-dist/src/errors.rs

@@ -74,6 +74,10 @@ pub enum DistError {
     #[error(transparent)]
     TripleError(#[from] cargo_dist_schema::target_lexicon::ParseError),
 
+    /// error when using axoasset::toml::to_string() or similar
+    #[error(transparent)]
+    AxoassetTomlSerErr(#[from] axoasset::toml::ser::Error),
+
     /// A problem with a jinja template, which is always a dist bug
     #[error("Failed to render template")]
     #[diagnostic(

cargo-dist/src/init.rs

@@ -1,4 +1,4 @@
-use axoasset::{toml_edit, LocalAsset};
+use axoasset::{toml, toml_edit, LocalAsset};
 use axoproject::{WorkspaceGraph, WorkspaceInfo, WorkspaceKind};
 use camino::Utf8PathBuf;
 use cargo_dist_schema::TripleNameRef;
@@ -9,6 +9,7 @@
     config::{
         self, CiStyle, Config, DistMetadata, HostingStyle, InstallPathStrategy, InstallerStyle,
         MacPkgConfig, PublishStyle,
+        v1::TomlLayer,
     },
     do_generate,
     errors::{DistError, DistResult},
@@ -155,7 +156,7 @@
     }
 
     if root_workspace.kind != WorkspaceKind::Generic
-        && root_workspace.manifest_path.file_name() != Some("dist.toml")
+        || root_workspace.manifest_path.file_name() != Some("dist.toml")
     {
         return Ok(());
     }
@@ -199,11 +200,52 @@
     Ok(())
 }
 
+fn do_migrate_from_v0() -> DistResult<()> {
+    let workspaces = config::get_project()?;
+    let root_workspace = workspaces.root_workspace();
+    let manifest_path = &root_workspace.manifest_path;
+
+    if config::load_config(manifest_path).is_ok() {
+        // We're already on a V1 config, no need to migrate!
+        return Ok(());
+    }
+
+    // Load in the root workspace toml to edit and write back
+    let Ok(old_config) = config::load_v0_config(manifest_path) else {
+        // We don't have a valid v0 _or_ v1 config. No migration can be done.
+        // It feels weird to return Ok(()) here, but I think it's right?
+        return Ok(());
+    };
+
+    let Some(dist_metadata) = &old_config.dist else {
+        // We don't have a valid v0 config. No migration can be done.
+        return Ok(());
+    };
+
+    let dist = dist_metadata.to_toml_layer(true);
+
+    let workspace = old_config.workspace;
+    let package = None;
+
+    let config = config::v1::DistWorkspaceConfig {
+        dist,
+        workspace,
+        package,
+    };
+
+    let workspace_toml_text = toml::to_string(&config)?;
+
+    // Write new config file.
+    axoasset::LocalAsset::write_new(&workspace_toml_text, manifest_path)?;
+
+    Ok(())
+}
+
 /// Run `dist migrate`
 pub fn do_migrate() -> DistResult<()> {
     do_migrate_from_rust_workspace()?;
     do_migrate_from_dist_toml()?;
-    //do_migrate_from_v0()?;
+    do_migrate_from_v0()?;
     Ok(())
 }
 
@@ -301,7 +343,7 @@
         // run (potentially interactive) init logic
         let meta = get_new_dist_metadata(cfg, args, &workspaces)?;
         MultiDistMetadata {
             workspace: Some(meta),
             packages: SortedMap::new(),
         }
     };
@@ -465,87 +507,27 @@
     cfg: &Config,
     args: &InitArgs,
     workspaces: &WorkspaceGraph,
-) -> DistResult<DistMetadata> {
+) -> DistResult<TomlLayer> {
     use dialoguer::{Confirm, Input, MultiSelect};
     let root_workspace = workspaces.root_workspace();
     let has_config = has_metadata_table(root_workspace);
 
     let mut meta = if has_config {
-        config::parse_metadata_table_or_manifest(
-            &root_workspace.manifest_path,
-            root_workspace.dist_manifest_path.as_deref(),
-            root_workspace.cargo_metadata_table.as_ref(),
-        )?
+        config::load_config(&root_workspace.manifest_path)?.dist
     } else {
-        DistMetadata {
+        TomlLayer {
             // If they init with this version we're gonna try to stick to it!
-            cargo_dist_version: Some(std::env!("CARGO_PKG_VERSION").parse().unwrap()),
-            cargo_dist_url_override: None,
-            // deprecated, default to not emitting it
-            rust_toolchain_version: None,
-            ci: None,
-            installers: None,
-            install_success_msg: None,
-            tap: None,
-            formula: None,
-            system_dependencies: None,
-            targets: None,
+            dist_version: Some(std::env!("CARGO_PKG_VERSION").parse().unwrap()),
+            dist_url_override: None,
             dist: None,
-            include: None,
-            auto_includes: None,
-            windows_archive: None,
-            unix_archive: None,
-            npm_scope: None,
-            npm_package: None,
-            checksum: None,
-            precise_builds: None,
-            merge_tasks: None,
-            fail_fast: None,
-            cache_builds: None,
-            build_local_artifacts: None,
-            dispatch_releases: None,
-            release_branch: None,
-            install_path: None,
-            features: None,
-            default_features: None,
-            all_features: None,
-            plan_jobs: None,
-            local_artifacts_jobs: None,
-            global_artifacts_jobs: None,
-            source_tarball: None,
-            host_jobs: None,
-            publish_jobs: None,
-            post_announce_jobs: None,
-            publish_prereleases: None,
-            force_latest: None,
-            create_release: None,
-            github_releases_repo: None,
-            github_releases_submodule_path: None,
-            github_release: None,
-            pr_run_mode: None,
             allow_dirty: None,
-            ssldotcom_windows_sign: None,
-            macos_sign: None,
-            github_attestations: None,
-            msvc_crt_static: None,
-            hosting: None,
-            extra_artifacts: None,
-            github_custom_runners: None,
-            github_custom_job_permissions: None,
-            bin_aliases: None,
-            tag_namespace: None,
-            install_updater: None,
-            always_use_latest_updater: None,
-            display: None,
-            display_name: None,
-            package_libraries: None,
-            install_libraries: None,
-            github_build_setup: None,
-            mac_pkg_config: None,
-            min_glibc_version: None,
-            cargo_auditable: None,
-            cargo_cyclonedx: None,
-            omnibor: None,
+            targets: None,
+            artifacts: None,
+            builds: None,
+            ci: None,
+            hosts: None,
+            installers: None,
+            publishers: None,
         }
     };
 
@@ -561,12 +543,12 @@
     let notice = console::style("⚠️".to_string()).for_stderr().yellow();
 
     if !args.host.is_empty() {
         meta.hosting = Some(args.host.clone());
     }
 
     // Set cargo-dist-version
     let current_version: Version = std::env!("CARGO_PKG_VERSION").parse().unwrap();
-    if let Some(desired_version) = &meta.cargo_dist_version {
+    if let Some(desired_version) = &meta.dist_version {
         if desired_version != &current_version && !desired_version.pre.starts_with("github-") {
             let default = true;
             let prompt = format!(
@@ -586,7 +568,7 @@
             };
 
             if response {
-                meta.cargo_dist_version = Some(current_version);
+                meta.dist_version = Some(current_version);
             } else {
                 Err(DistError::NoUpdateVersion {
                     project_version: desired_version.clone(),
@@ -596,7 +578,7 @@
         }
     } else {
         // Really not allowed, so just force them onto the current version
-        meta.cargo_dist_version = Some(current_version);
+        meta.dist_version = Some(current_version);
     }
 
     {
@@ -661,7 +643,7 @@
     // FIXME: when there is more than one option we maybe shouldn't hide this
     // once the user has any one enabled, right now it's just annoying to always
     // prompt for Github CI support.
     if meta.ci.as_deref().unwrap_or_default().is_empty() {
         // FIXME: when there is more than one option this should be a proper
         // multiselect like the installer selector is! For now we do
         // most of the multi-select logic and then just give a prompt.
@@ -675,7 +657,7 @@
             let mut default = meta
                 .ci
                 .as_ref()
                 .map(|ci| ci.contains(item))
                 .unwrap_or(false)
                 || cfg.ci.contains(item);
 
@@ -717,12 +699,12 @@
 
         // Apply the results
         let ci: Vec<_> = selected.into_iter().map(|i| known[i]).collect();
         meta.ci = if ci.is_empty() { None } else { Some(ci) };
     }
 
     // Enable installer backends (if they have a CI backend that can provide URLs)
     // FIXME: "vendored" installers like msi could be enabled without any CI...
     let has_ci = meta.ci.as_ref().map(|ci| !ci.is_empty()).unwrap_or(false);
     {
         // If they have CI, then they can use fetching installers,
         // otherwise they can only do vendored installers.
@@ -745,7 +727,7 @@
             // If they passed it on the CLI, flip it on
             let config_had_it = meta
                 .installers
                 .as_deref()
                 .unwrap_or_default()
                 .contains(item);
             let cli_had_it = cfg.installers.contains(item);
@@ -788,18 +770,18 @@
         meta.installers = Some(selected.into_iter().map(|i| known[i]).collect());
     }
 
     let mut publish_jobs = orig_meta.publish_jobs.clone().unwrap_or(vec![]);
 
     // Special handling of the Homebrew installer
     if meta
         .installers
         .as_deref()
         .unwrap_or_default()
         .contains(&InstallerStyle::Homebrew)
     {
         let homebrew_is_new = !orig_meta
             .installers
             .as_deref()
             .unwrap_or_default()
             .contains(&InstallerStyle::Homebrew);
 
@@ -822,9 +804,9 @@
             let tap = tap.trim();
             if tap.is_empty() {
                 eprintln!("Homebrew packages will not be automatically published");
                 meta.tap = None;
             } else {
                 meta.tap = Some(tap.to_owned());
                 publish_jobs.push(PublishStyle::Homebrew);
 
                 eprintln!("{check} Homebrew package will be published to {tap}");
@@ -840,11 +822,11 @@
     } else {
         let homebrew_toggled_off = orig_meta
             .installers
             .as_deref()
             .unwrap_or_default()
             .contains(&InstallerStyle::Homebrew);
         if homebrew_toggled_off {
             meta.tap = None;
             publish_jobs.retain(|job| job != &PublishStyle::Homebrew);
         }
     }
@@ -852,14 +834,14 @@
     // Special handling of the npm installer
     if meta
         .installers
         .as_deref()
         .unwrap_or_default()
         .contains(&InstallerStyle::Npm)
     {
         // If npm is being newly enabled here, prompt for a @scope
         let npm_is_new = !orig_meta
             .installers
             .as_deref()
             .unwrap_or_default()
             .contains(&InstallerStyle::Npm);
         if npm_is_new {
@@ -897,9 +879,9 @@
             let scope = scope.trim();
             if scope.is_empty() {
                 eprintln!("{check} npm packages will be published globally");
                 meta.npm_scope = None;
             } else {
                 meta.npm_scope = Some(scope.to_owned());
                 eprintln!("{check} npm packages will be published under {scope}");
             }
             eprintln!();
@@ -907,25 +889,25 @@
     } else {
         let npm_toggled_off = orig_meta
             .installers
             .as_deref()
             .unwrap_or_default()
             .contains(&InstallerStyle::Npm);
         if npm_toggled_off {
             meta.npm_scope = None;
             publish_jobs.retain(|job| job != &PublishStyle::Npm);
         }
     }
 
     meta.publish_jobs = if publish_jobs.is_empty() {
         None
     } else {
         Some(publish_jobs)
     };
 
     if orig_meta.install_updater.is_none()
         && meta
             .installers
             .as_deref()
             .unwrap_or_default()
             .iter()
             .any(|installer| {
@@ -946,7 +928,7 @@
             res
         };
 
         meta.install_updater = Some(install_updater);
     }
 
     Ok(meta)