refactor: comment on convoluted Filesystem::from_str code (#1315)

* refactor: use a less convoluted match for filesystem type conversion

* revert, just use comment

* just use if statements instead

* test

* inline

src/app/data_harvester/disks/unix/file_systems.rs

@@ -1,6 +1,7 @@
 use std::str::FromStr;
 
-/// Known filesystems. From [heim](https://github.com/heim-rs/heim/blob/master/heim-disk/src/filesystem.rs).
+/// Known filesystems. Original list from
+/// [heim](https://github.com/heim-rs/heim/blob/master/heim-disk/src/filesystem.rs).
 ///
 /// All physical filesystems should have their own enum element and all virtual filesystems will go into
 /// the [`FileSystem::Other`] element.
@@ -82,7 +83,8 @@ impl FileSystem {
     }
 
     #[allow(dead_code)]
-    /// Returns a string identifying this filesystem.
+    #[inline]
+    /// Returns a string literal identifying this filesystem.
     pub fn as_str(&self) -> &str {
         match self {
             FileSystem::Ext2 => "ext2",
@@ -112,30 +114,70 @@ impl FileSystem {
 impl FromStr for FileSystem {
     type Err = anyhow::Error;
 
+    #[inline]
+
     fn from_str(s: &str) -> anyhow::Result<Self> {
-        match () {
-            _ if s.eq_ignore_ascii_case("ext2") => Ok(FileSystem::Ext2),
-            _ if s.eq_ignore_ascii_case("ext3") => Ok(FileSystem::Ext3),
-            _ if s.eq_ignore_ascii_case("ext4") => Ok(FileSystem::Ext4),
-            _ if s.eq_ignore_ascii_case("msdos") || s.eq_ignore_ascii_case("vfat") => {
-                Ok(FileSystem::VFat)
-            }
-            _ if s == "ntfs3" || s.eq_ignore_ascii_case("ntfs") => Ok(FileSystem::Ntfs),
-            _ if s.eq_ignore_ascii_case("zfs") => Ok(FileSystem::Zfs),
-            _ if s.eq_ignore_ascii_case("hfs") => Ok(FileSystem::Hfs),
-            _ if s.eq_ignore_ascii_case("reiserfs") => Ok(FileSystem::Reiser3),
-            _ if s.eq_ignore_ascii_case("reiser4") => Ok(FileSystem::Reiser4),
-            _ if s.eq_ignore_ascii_case("exfat") => Ok(FileSystem::ExFat),
-            _ if s.eq_ignore_ascii_case("f2fs") => Ok(FileSystem::F2fs),
-            _ if s.eq_ignore_ascii_case("hfsplus") => Ok(FileSystem::HfsPlus),
-            _ if s.eq_ignore_ascii_case("jfs") => Ok(FileSystem::Jfs),
-            _ if s.eq_ignore_ascii_case("btrfs") => Ok(FileSystem::Btrfs),
-            _ if s.eq_ignore_ascii_case("minix") => Ok(FileSystem::Minix),
-            _ if s.eq_ignore_ascii_case("nilfs") => Ok(FileSystem::Nilfs),
-            _ if s.eq_ignore_ascii_case("xfs") => Ok(FileSystem::Xfs),
-            _ if s.eq_ignore_ascii_case("apfs") => Ok(FileSystem::Apfs),
-            _ if s.eq_ignore_ascii_case("fuseblk") => Ok(FileSystem::FuseBlk),
-            _ => Ok(FileSystem::Other(s.to_string())),
-        }
+        // Done like this as `eq_ignore_ascii_case` avoids a string allocation.
+        Ok(if s.eq_ignore_ascii_case("ext2") {
+            FileSystem::Ext2
+        } else if s.eq_ignore_ascii_case("ext3") {
+            FileSystem::Ext3
+        } else if s.eq_ignore_ascii_case("ext4") {
+            FileSystem::Ext4
+        } else if s.eq_ignore_ascii_case("msdos") || s.eq_ignore_ascii_case("vfat") {
+            FileSystem::VFat
+        } else if s.eq_ignore_ascii_case("ntfs3") || s.eq_ignore_ascii_case("ntfs") {
+            FileSystem::Ntfs
+        } else if s.eq_ignore_ascii_case("zfs") {
+            FileSystem::Zfs
+        } else if s.eq_ignore_ascii_case("hfs") {
+            FileSystem::Hfs
+        } else if s.eq_ignore_ascii_case("reiserfs") {
+            FileSystem::Reiser3
+        } else if s.eq_ignore_ascii_case("reiser4") {
+            FileSystem::Reiser4
+        } else if s.eq_ignore_ascii_case("exfat") {
+            FileSystem::ExFat
+        } else if s.eq_ignore_ascii_case("f2fs") {
+            FileSystem::F2fs
+        } else if s.eq_ignore_ascii_case("hfsplus") {
+            FileSystem::HfsPlus
+        } else if s.eq_ignore_ascii_case("jfs") {
+            FileSystem::Jfs
+        } else if s.eq_ignore_ascii_case("btrfs") {
+            FileSystem::Btrfs
+        } else if s.eq_ignore_ascii_case("minix") {
+            FileSystem::Minix
+        } else if s.eq_ignore_ascii_case("nilfs") {
+            FileSystem::Nilfs
+        } else if s.eq_ignore_ascii_case("xfs") {
+            FileSystem::Xfs
+        } else if s.eq_ignore_ascii_case("apfs") {
+            FileSystem::Apfs
+        } else if s.eq_ignore_ascii_case("fuseblk") {
+            FileSystem::FuseBlk
+        } else {
+            FileSystem::Other(s.to_string())
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::FileSystem;
+    use std::str::FromStr;
+
+    #[test]
+    fn file_system_from_str() {
+        // Something supported
+        assert_eq!(FileSystem::from_str("ext4").unwrap(), FileSystem::Ext4);
+        assert_eq!(FileSystem::from_str("msdos").unwrap(), FileSystem::VFat);
+        assert_eq!(FileSystem::from_str("vfat").unwrap(), FileSystem::VFat);
+
+        // Something unsupported
+        assert_eq!(
+            FileSystem::from_str("this does not exist").unwrap(),
+            FileSystem::Other("this does not exist".to_owned())
+        );
     }
 }

src/app/data_harvester/disks/unix/linux/partition.rs

@@ -129,13 +129,6 @@ impl FromStr for Partition {
             }
         };
 
-        // let options = match parts.next() {
-        //     Some(opts) => opts.to_string(),
-        //     None => {
-        //         bail!("missing options");
-        //     }
-        // };
-
         Ok(Partition {
             device,
             mount_point,