refact(rustup): Use match statements and bail

Use match statements for Option types and use bail! macro to utilize
recoverable errors.

Signed-off-by: innocentzero <isfarulhaque@proton.me>

crates/pacdef_core/src/backend/actual/rustup.rs

@@ -1,8 +1,7 @@
 use crate::backend::backend_trait::{Backend, Switches, Text};
 use crate::backend::macros::impl_backend_constants;
 use crate::{Group, Package};
-use anyhow::{Context, Result};
+use anyhow::{bail, Context, Result};
-use core::panic;
 use std::collections::HashSet;
 use std::os::unix::process::ExitStatusExt;
 use std::process::{Command, ExitStatus};
@@ -58,15 +57,14 @@ impl Backend for Rustup {
     }
 
     fn make_dependency(&self, _: &[Package]) -> Result<ExitStatus> {
-        anyhow::bail!("Not supported by {}", self.get_binary())
+        bail!("Not supported by {}", self.get_binary())
     }
 
     fn install_packages(&self, packages: &[Package], _: bool) -> Result<ExitStatus> {
         for p in packages {
-            let repo = if p.repo.is_some() {
+            let repo = match p.repo.as_ref() {
-                p.repo.as_ref().expect("This should never be reached")
+                Some(name) => name,
-            } else {
+                None => bail!("Not specified whether it is a toolchain or a component"),
-                anyhow::bail!("Not specified whether it is a toolchain or a component")
             };
 
             let mut cmd = Command::new(self.get_binary());
@@ -77,12 +75,22 @@ impl Backend for Rustup {
                 }
                 "component" => {
                     cmd.args(get_install_switches(Repotype::Component));
+
                     let mut iter = p.name.split('/');
-                    let toolchain = iter.next().expect("Toolchain not specified!");
+
-                    let component = iter.next().expect("Component not specified!");
+                    let toolchain = match iter.next() {
-                    cmd.arg(toolchain).arg(component);
+                        Some(name) => name,
+                        None => bail!("Toolchain not specified!"),
+                    };
+                    cmd.arg(toolchain);
+
+                    let component = match iter.next() {
+                        Some(name) => name,
+                        None => bail!("Component not specified!"),
+                    };
+                    cmd.arg(component);
                 }
-                _ => anyhow::bail!("No such type is managed by rustup!"),
+                _ => bail!("No such type is managed by rustup!"),
             }
 
             let result = cmd.status().context("Installing toolchain {p}");
@@ -97,10 +105,9 @@ impl Backend for Rustup {
         let mut toolchains_rem = Vec::new();
 
         for p in packages {
-            let repo = if p.repo.is_some() {
+            let repo = match p.repo.as_ref() {
-                p.repo.as_ref().expect("This will never be printed!")
+                Some(reponame) => reponame,
-            } else {
+                None => bail!("Not specified whether it is a toolchain or a component"),
-                anyhow::bail!("Not specified whether it is a toolchain or a component")
             };
 
             if repo == "toolchain" {
@@ -117,29 +124,29 @@ impl Backend for Rustup {
         }
 
         for p in packages {
-            let repo = if p.repo.is_some() {
+            let repo = match p.repo.as_ref() {
-                p.repo.as_ref().expect("This will never be printed!")
+                Some(reponame) => reponame,
-            } else {
+                None => bail!("Not specified whether it is a toolchain or a component"),
-                anyhow::bail!("Not specified whether it is a toolchain or a component")
             };
 
             let mut iter = p.name.split('/').peekable();
-            let toolchain = if iter.peek().is_some() {
+            let toolchain = match iter.peek() {
-                iter.next().expect("This should never be printed")
+                Some(name) => name,
-            } else {
+                None => bail!("No toolchain name provided for the given component!"),
-                anyhow::bail!("No toolchain name provided for the given component!")
             };
 
-            if repo == "component" && !toolchains_rem.contains(&toolchain) {
+            if repo == "component" && !toolchains_rem.contains(toolchain) {
                 let mut cmd = Command::new(self.get_binary());
 
                 cmd.args(get_remove_switches(Repotype::Component))
-                    .arg(toolchain)
+                    .arg(toolchain);
-                    .arg(
+
-                        iter.next().unwrap_or_else(|| {
+                let component = match iter.next() {
-                            panic!("Component name not provided for {}", p.name)
+                    Some(name) => name,
-                        }),
+                    None => bail!("No component name provided for {}", p.name),
-                    );
+                };
+
+                cmd.arg(component);
 
                 let result = cmd.status().context("Removing toolchain {p}");
                 if !result.as_ref().is_ok_and(|exit| exit.success()) {
@@ -179,9 +186,12 @@ impl Rustup {
         cmd.args(args);
         let output = String::from_utf8(cmd.output()?.stdout)?;
         let mut val = Vec::new();
-        for i in output.lines() {
+        for line in output.lines() {
-            let mut it = i.splitn(2, '-');
+            let toolchain = line.split('-').next();
-            val.push(it.next().expect("Toolchain name is empty.").to_string());
+            match toolchain {
+                Some(name) => val.push(name.to_string()),
+                None => bail!("Toolchain name not provided!"),
+            }
         }
         Ok(val)
     }