Use serde to encode/decode config

Author: djc

src/dist/config.rs

@@ -2,81 +2,34 @@ use std::fmt;
 use std::str::FromStr;
 
 use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
 
 use super::manifest::Component;
 use crate::errors::*;
-use crate::utils::toml_utils::*;
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct Config {
     pub config_version: ConfigVersion,
     pub components: Vec<Component>,
 }
 
 impl Config {
-    pub(crate) fn from_toml(mut table: toml::value::Table, path: &str) -> Result<Self> {
-        let config_version = get_string(&mut table, "config_version", path)?;
-        let config_version = ConfigVersion::from_str(&config_version)?;
-
-        let components = get_array(&mut table, "components", path)?;
-        let components =
-            Self::toml_to_components(components, &format!("{}{}.", path, "components"))?;
-
-        Ok(Self {
-            config_version,
-            components,
-        })
-    }
-    pub(crate) fn into_toml(self) -> toml::value::Table {
-        let mut result = toml::value::Table::new();
-        result.insert(
-            "config_version".to_owned(),
-            toml::Value::String(self.config_version.as_str().to_owned()),
-        );
-        let components = Self::components_to_toml(self.components);
-        if !components.is_empty() {
-            result.insert("components".to_owned(), toml::Value::Array(components));
-        }
-        result
-    }
-
     pub(crate) fn parse(data: &str) -> Result<Self> {
-        let value = toml::from_str(data).context("error parsing config")?;
-        Self::from_toml(value, "")
-    }
-
-    pub(crate) fn stringify(self) -> String {
-        self.into_toml().to_string()
+        toml::from_str(data).context("error parsing config")
     }
 
-    fn toml_to_components(arr: toml::value::Array, path: &str) -> Result<Vec<Component>> {
-        let mut result = Vec::new();
-
-        for (i, v) in arr.into_iter().enumerate() {
-            if let toml::Value::Table(t) = v {
-                let path = format!("{path}[{i}]");
-                result.push(Component::from_toml(t, &path, false)?);
-            }
-        }
-
-        Ok(result)
-    }
-
-    fn components_to_toml(components: Vec<Component>) -> toml::value::Array {
-        let mut result = toml::value::Array::new();
-        for v in components {
-            result.push(toml::Value::Table(v.into_toml()));
-        }
-        result
+    pub(crate) fn stringify(&self) -> Result<String> {
+        Ok(toml::to_string(&self)?)
     }
 
     pub(crate) fn new() -> Self {
         Default::default()
     }
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
 pub(crate) enum ConfigVersion {
+    #[serde(rename = "1")]
     #[default]
     V1,
 }

src/dist/manifest.rs

@@ -21,12 +21,10 @@ use std::str::FromStr;
 use anyhow::{anyhow, bail, Context, Result};
 use serde::{Deserialize, Serialize};
 
+use super::{config::Config, dist::ToolchainDesc};
 use crate::dist::dist::{Profile, TargetTriple};
 use crate::errors::*;
 use crate::toolchain::distributable::DistributableToolchain;
-use crate::utils::toml_utils::*;
-
-use super::{config::Config, dist::ToolchainDesc};
 
 /// Used by the `installed_components` function
 pub(crate) struct ComponentStatus {
@@ -529,36 +527,7 @@ impl Component {
             is_extension: false,
         }
     }
-    pub(crate) fn from_toml(
-        mut table: toml::value::Table,
-        path: &str,
-        is_extension: bool,
-    ) -> Result<Self> {
-        Ok(Self {
-            pkg: get_string(&mut table, "pkg", path)?,
-            target: get_string(&mut table, "target", path).map(|s| {
-                if s == "*" {
-                    None
-                } else {
-                    Some(TargetTriple::new(s))
-                }
-            })?,
-            is_extension,
-        })
-    }
-    pub(crate) fn into_toml(self) -> toml::value::Table {
-        let mut result = toml::value::Table::new();
-        result.insert(
-            "target".to_owned(),
-            toml::Value::String(
-                self.target
-                    .map(|t| t.to_string())
-                    .unwrap_or_else(|| "*".to_owned()),
-            ),
-        );
-        result.insert("pkg".to_owned(), toml::Value::String(self.pkg));
-        result
-    }
+
     pub(crate) fn name(&self, manifest: &Manifest) -> String {
         let pkg = self.short_name(manifest);
         if let Some(ref t) = self.target {

src/dist/manifestation.rs

@@ -287,7 +287,7 @@ impl Manifestation {
         // name/target. Needs to be fixed in rust-installer.
         let mut new_config = Config::new();
         new_config.components = update.final_component_list;
-        let config_str = new_config.stringify();
+        let config_str = new_config.stringify()?;
         let rel_config_path = prefix.rel_manifest_file(CONFIG_FILE);
         let config_path = prefix.path().join(&rel_config_path);
         tx.modify_file(rel_config_path)?;

src/utils/mod.rs

@@ -1,7 +1,6 @@
 //!  Utility functions for Rustup
 pub(crate) mod notifications;
 pub mod raw;
-pub(crate) mod toml_utils;
 pub(crate) mod units;
 #[allow(clippy::module_inception)]
 pub mod utils;