refactor(component)!: extract ComponentPartKind

Author: rami3l

src/dist/component/components.rs

@@ -3,8 +3,11 @@
 //! installation / uninstallation process.
 
 use std::borrow::Cow;
+use std::convert::Infallible;
+use std::fmt;
 use std::io::BufWriter;
 use std::path::{Path, PathBuf};
+use std::str::FromStr;
 
 use anyhow::{bail, Result};
 
@@ -103,28 +106,28 @@ pub(crate) struct ComponentBuilder<'a> {
 impl<'a> ComponentBuilder<'a> {
     pub(crate) fn copy_file(&mut self, path: PathBuf, src: &Path) -> Result<()> {
         self.parts.push(ComponentPart {
-            kind: "file".to_owned(),
+            kind: ComponentPartKind::File,
             path: path.clone(),
         });
         self.tx.copy_file(&self.name, path, src)
     }
     pub(crate) fn copy_dir(&mut self, path: PathBuf, src: &Path) -> Result<()> {
         self.parts.push(ComponentPart {
-            kind: "dir".to_owned(),
+            kind: ComponentPartKind::Dir,
             path: path.clone(),
         });
         self.tx.copy_dir(&self.name, path, src)
     }
     pub(crate) fn move_file(&mut self, path: PathBuf, src: &Path) -> Result<()> {
         self.parts.push(ComponentPart {
-            kind: "file".to_owned(),
+            kind: ComponentPartKind::File,
             path: path.clone(),
         });
         self.tx.move_file(&self.name, path, src)
     }
     pub(crate) fn move_dir(&mut self, path: PathBuf, src: &Path) -> Result<()> {
         self.parts.push(ComponentPart {
-            kind: "dir".to_owned(),
+            kind: ComponentPartKind::Dir,
             path: path.clone(),
         });
         self.tx.move_dir(&self.name, path, src)
@@ -156,12 +159,40 @@ impl<'a> ComponentBuilder<'a> {
 #[derive(Debug)]
 pub struct ComponentPart {
     /// Kind of the [`ComponentPart`], such as `"file"` or `"dir"`.
-    pub kind: String,
+    pub kind: ComponentPartKind,
     /// Relative path of the [`ComponentPart`],
     /// with components separated by the system's main path separator.
     pub path: PathBuf,
 }
 
+#[derive(Debug, PartialEq)]
+pub enum ComponentPartKind {
+    File,
+    Dir,
+    Unknown(String),
+}
+
+impl fmt::Display for ComponentPartKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::File => write!(f, "file"),
+            Self::Dir => write!(f, "dir"),
+            Self::Unknown(s) => write!(f, "{s}"),
+        }
+    }
+}
+
+impl FromStr for ComponentPartKind {
+    type Err = Infallible;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "file" => Ok(Self::File),
+            "dir" => Ok(Self::Dir),
+            s => Ok(Self::Unknown(s.to_owned())),
+        }
+    }
+}
+
 impl ComponentPart {
     const PATH_SEP_MANIFEST: &str = "/";
     const PATH_SEP_MAIN: &str = std::path::MAIN_SEPARATOR_STR;
@@ -183,7 +214,8 @@ impl ComponentPart {
             path_str = Cow::Owned(path_str.replace(Self::PATH_SEP_MANIFEST, Self::PATH_SEP_MAIN));
         };
         Some(Self {
-            kind: line[0..pos].to_owned(),
+            // FIXME: Use `.into_ok()` when it's available.
+            kind: line[0..pos].parse().unwrap(),
             path: PathBuf::from(path_str.as_ref()),
         })
     }
@@ -337,9 +369,9 @@ impl Component {
             prefix: self.components.prefix.abs_path(""),
         };
         for part in self.parts()?.into_iter().rev() {
-            match &*part.kind {
-                "file" => tx.remove_file(&self.name, part.path.clone())?,
-                "dir" => tx.remove_dir(&self.name, part.path.clone())?,
+            match part.kind {
+                ComponentPartKind::File => tx.remove_file(&self.name, part.path.clone())?,
+                ComponentPartKind::Dir => tx.remove_dir(&self.name, part.path.clone())?,
                 _ => return Err(RustupError::CorruptComponent(self.name.clone()).into()),
             }
             pset.seen(part.path);
@@ -362,7 +394,7 @@ mod tests {
     #[test]
     fn decode_component_part() {
         let part = ComponentPart::decode("dir:share/doc/rust/html").unwrap();
-        assert_eq!(part.kind, "dir");
+        assert_eq!(part.kind, ComponentPartKind::Dir);
         assert_eq!(
             part.path,
             Path::new(&"share/doc/rust/html".replace("/", ComponentPart::PATH_SEP_MAIN))
@@ -372,7 +404,7 @@ mod tests {
     #[test]
     fn encode_component_part() {
         let part = ComponentPart {
-            kind: "dir".to_owned(),
+            kind: ComponentPartKind::Dir,
             path: ["share", "doc", "rust", "html"].into_iter().collect(),
         };
         assert_eq!(part.encode(), "dir:share/doc/rust/html");

src/dist/component/package.rs

@@ -106,15 +106,15 @@ impl Package for DirectoryPackage {
             let path = part.path;
             let src_path = root.join(&path);
 
-            match &*part.kind {
-                "file" => {
+            match part.kind {
+                ComponentPartKind::File => {
                     if self.copy {
                         builder.copy_file(path.clone(), &src_path)?
                     } else {
                         builder.move_file(path.clone(), &src_path)?
                     }
                 }
-                "dir" => {
+                ComponentPartKind::Dir => {
                     if self.copy {
                         builder.copy_dir(path.clone(), &src_path)?
                     } else {