Simplify some code

src/bin/cargo-ziggy/add_seeds.rs

@@ -3,7 +3,7 @@ use anyhow::bail;
 use std::{env, process};
 
 impl AddSeeds {
-    pub fn add_seeds(&mut self) -> Result<(), anyhow::Error> {
+    pub fn add_seeds(&self) -> Result<(), anyhow::Error> {
         eprintln!("Adding seeds to AFL");
 
         let req = semver::VersionReq::parse(">=0.14.5").unwrap();
@@ -25,29 +25,19 @@ impl AddSeeds {
             bail!("Outdated version of cargo-afl, ziggy needs >=0.14.5, please run `cargo install cargo-afl`");
         }
 
-        self.target = find_target(&self.target)?;
-
-        let input = self
-            .input
-            .display()
-            .to_string()
-            .replace("{ziggy_output}", &self.ziggy_output.display().to_string())
-            .replace("{target_name}", &self.target);
+        let target = find_target(&self.target)?;
+        let input = self.input.display().to_string();
 
         let cargo = env::var("CARGO").unwrap_or_else(|_| String::from("cargo"));
         process::Command::new(&cargo)
-            .args(
-                [
-                    "afl",
-                    "addseeds",
-                    "-o",
-                    &format!("{}/{}/afl", self.ziggy_output.display(), self.target),
-                    "-i",
-                    &input,
-                ]
-                .iter()
-                .filter(|a| !a.is_empty()),
-            )
+            .args([
+                "afl",
+                "addseeds",
+                "-o",
+                &format!("{}/{target}/afl", self.ziggy_output.display()),
+                "-i",
+                &input,
+            ])
             .spawn()?
             .wait()?;
         Ok(())

src/bin/cargo-ziggy/fuzz.rs

@@ -370,11 +370,8 @@ impl Fuzz {
             } else {
                 // we assign roughly 2/3 to AFL++, 1/3 to honggfuzz, however do
                 // not apply more than 4 jobs to honggfuzz
-                match self.jobs {
-                    1 => (1, 0),
-                    2..=12 => (self.jobs - self.jobs.div_ceil(3), self.jobs.div_ceil(3)),
-                    _ => (self.jobs - 4, 4),
-                }
+                let hfuzz = ((self.jobs + 1) / 3).min(4);
+                (self.jobs - hfuzz, hfuzz)
             }
         };
 

src/bin/cargo-ziggy/main.rs

@@ -383,11 +383,9 @@ fn main() -> Result<(), anyhow::Error> {
             .generate_coverage()
             .context("Failure generating coverage"),
         Ziggy::Plot(mut args) => args.generate_plot().context("Failure generating plot"),
-        Ziggy::AddSeeds(mut args) => args.add_seeds().context("Failure addings seeds to AFL"),
-        Ziggy::Triage(mut args) => args
-            .triage()
-            .context("Triaging with casr failed, try \"cargo install casr\""),
-        Ziggy::Clean(args) => args.clean(),
+        Ziggy::AddSeeds(args) => args.add_seeds().context("Failure adding seeds to AFL"),
+        Ziggy::Triage(args) => args.triage().context("Failure triaging with casr"),
+        Ziggy::Clean(args) => args.clean().context("Failure cleaning build artifacts"),
     }
 }
 

src/bin/cargo-ziggy/triage.rs

@@ -1,52 +1,47 @@
 use crate::*;
+use anyhow::bail;
 use std::process;
 
 impl Triage {
-    pub fn triage(&mut self) -> Result<(), anyhow::Error> {
+    pub fn triage(&self) -> Result<(), anyhow::Error> {
         eprintln!("Running CASR triage on crashes");
 
-        self.target = find_target(&self.target)?;
-        let input_dir = format!("{}/{}/afl", self.ziggy_output.display(), self.target);
+        let target = find_target(&self.target)?;
+        let input_dir = format!("{}/{target}/afl", self.ziggy_output.display());
 
         let triage_dir = self
             .output
             .display()
             .to_string()
             .replace("{ziggy_output}", &self.ziggy_output.display().to_string())
-            .replace("{target_name}", &self.target);
-        fs::remove_dir_all(&triage_dir).unwrap_or_default();
+            .replace("{target_name}", &target);
+        fs::remove_dir_all(&triage_dir).ok();
 
         if !fs::metadata(&input_dir)
             .map(|meta| meta.is_dir())
             .unwrap_or(false)
         {
-            eprintln!("This option requires that at least one AFL++ instance was run!");
-            return Ok(());
+            bail!("This option requires that at least one AFL++ instance was run!");
         }
 
         if fs::metadata(&triage_dir)
             .map(|meta| meta.is_dir())
             .unwrap_or(false)
         {
-            eprintln!("Please remove {triage_dir:?} first");
-            return Ok(());
+            bail!("Please remove {triage_dir:?} first");
         }
 
-        let tool = String::from("casr-afl");
-        process::Command::new(tool)
-            .args(
-                [
-                    "-i",
-                    &input_dir,
-                    "-o",
-                    &triage_dir,
-                    &format!("-j{}", self.jobs),
-                    &format!("-t{}", self.timeout.unwrap_or(0)), // future: add option for crashes directory and use runner
-                ]
-                .iter()
-                .filter(|a| !a.is_empty()),
-            )
-            .spawn()?
+        process::Command::new("casr-afl")
+            .args([
+                "-i",
+                &input_dir,
+                "-o",
+                &triage_dir,
+                &format!("-j{}", self.jobs),
+                &format!("-t{}", self.timeout.unwrap_or(0)), // future: add option for crashes directory and use runner
+            ])
+            .spawn()
+            .context("Running casr failed, try `cargo install casr`")?
             .wait()?;
 
         Ok(())