Cargo workspace support

Author: LebedevRI

Cargo.lock

@@ -17,7 +17,6 @@ anyhow = "1.0.66"
 current_platform = "0.2.0"
 clap = { version = "4.4.0", features = ["derive", "deprecated"] }
 tempfile = "3.4.0"
-toml = "0.5.9"
 rustc_version = "0.4.0"
 cargo_metadata = "0.18.1"
 rayon = "1.11"

Cargo.toml

@@ -16,7 +16,7 @@ pub use self::{
 
 use anyhow::{bail, Error, Result};
 use clap::{Parser, ValueEnum};
-use std::{fmt as stdfmt, path::PathBuf, str::FromStr};
+use std::{fmt as stdfmt, ops::Deref, path::PathBuf, str::FromStr};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, ValueEnum)]
 pub enum Sanitizer {
@@ -51,6 +51,17 @@ pub enum BuildMode {
 
 #[derive(Clone, Debug, Eq, PartialEq, Parser)]
 pub struct BuildOptions {
+    #[command(flatten)]
+    pub fuzz_dir_wrapper: FuzzDirWrapper,
+
+    /// Build all packages in the workspace
+    #[arg(long)]
+    pub workspace: bool,
+
+    /// Package to build (see `cargo help pkgid`)
+    #[arg(short = 'p', long = "package")]
+    pub packages: Vec<String>,
+
     /// Build artifacts in development mode, without optimizations
     #[arg(short = 'D', long, conflicts_with = "release")]
     pub dev: bool,
@@ -209,6 +220,16 @@ pub struct BuildOptions {
 
 impl stdfmt::Display for BuildOptions {
     fn fmt(&self, f: &mut stdfmt::Formatter) -> stdfmt::Result {
+        self.fuzz_dir_wrapper.fmt(f)?;
+
+        if self.workspace {
+            write!(f, " --workspace")?;
+        }
+
+        for pkg in &self.packages {
+            write!(f, " --package {}", pkg)?;
+        }
+
         if self.dev {
             write!(f, " -D")?;
         }
@@ -270,10 +291,36 @@ pub struct FuzzDirWrapper {
     pub fuzz_dir: Option<PathBuf>,
 }
 
+#[derive(Debug, Clone)]
+pub struct ManifestPath(PathBuf);
+
+impl ManifestPath {
+    pub fn new(path_buf: PathBuf) -> Self {
+        Self(path_buf)
+    }
+}
+
+impl Deref for ManifestPath {
+    type Target = PathBuf;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl FuzzDirWrapper {
+    pub fn get_manifest_path(&self) -> Option<ManifestPath> {
+        if let Some(ref fuzz_dir) = self.fuzz_dir {
+            return Some(ManifestPath(fuzz_dir.join("Cargo.toml")));
+        }
+        None
+    }
+}
+
 impl stdfmt::Display for FuzzDirWrapper {
     fn fmt(&self, f: &mut stdfmt::Formatter) -> stdfmt::Result {
         if let Some(ref elem) = self.fuzz_dir {
-            write!(f, " --fuzz-dir={}", elem.display())?;
+            write!(f, " --fuzz-dir {}", elem.display())?;
         }
 
         Ok(())
@@ -305,6 +352,9 @@ mod test {
     #[test]
     fn display_build_options() {
         let default_opts = BuildOptions {
+            fuzz_dir_wrapper: FuzzDirWrapper { fuzz_dir: None },
+            workspace: false,
+            packages: Vec::new(),
             dev: false,
             release: false,
             debug_assertions: false,
@@ -377,7 +427,29 @@ mod test {
             },
             BuildOptions {
                 coverage: false,
-                ..default_opts
+                ..default_opts.clone()
+            },
+            BuildOptions {
+                workspace: false,
+                ..default_opts.clone()
+            },
+            BuildOptions {
+                packages: vec![String::from("pkg1")],
+                ..default_opts.clone()
+            },
+            BuildOptions {
+                packages: vec![String::from("pkg1"), String::from("pkg2")],
+                ..default_opts.clone()
+            },
+            BuildOptions {
+                workspace: true,
+                packages: vec![String::from("pkg1")],
+                ..default_opts.clone()
+            },
+            BuildOptions {
+                workspace: true,
+                packages: vec![String::from("pkg1"), String::from("pkg2")],
+                ..default_opts.clone()
             },
         ];
 

src/options.rs

@@ -14,7 +14,7 @@ pub struct Add {
 
 impl RunCommand for Add {
     fn run_command(&mut self) -> Result<()> {
-        let project = FuzzProject::new(self.fuzz_dir_wrapper.fuzz_dir.to_owned())?;
+        let project = FuzzProject::new(self.fuzz_dir_wrapper.get_manifest_path())?;
         let manifest = Manifest::parse()?;
         project.add_target(self, &manifest)
     }

src/options/add.rs

@@ -1,5 +1,5 @@
 use crate::{
-    options::{BuildMode, BuildOptions, FuzzDirWrapper},
+    options::{BuildMode, BuildOptions},
     project::FuzzProject,
     RunCommand,
 };
@@ -11,16 +11,13 @@ pub struct Build {
     #[command(flatten)]
     pub build: BuildOptions,
 
-    #[command(flatten)]
-    pub fuzz_dir_wrapper: FuzzDirWrapper,
-
     /// Name of the fuzz target to build, or build all targets if not supplied
     pub target: Option<String>,
 }
 
 impl RunCommand for Build {
     fn run_command(&mut self) -> Result<()> {
-        let project = FuzzProject::new(self.fuzz_dir_wrapper.fuzz_dir.to_owned())?;
+        let project = FuzzProject::new(self.build.fuzz_dir_wrapper.get_manifest_path())?;
         project.exec_build(BuildMode::Build, &self.build, self.target.as_deref())
     }
 }

src/options/build.rs

@@ -1,5 +1,5 @@
 use crate::{
-    options::{BuildMode, BuildOptions, FuzzDirWrapper},
+    options::{BuildMode, BuildOptions},
     project::FuzzProject,
     RunCommand,
 };
@@ -11,16 +11,13 @@ pub struct Check {
     #[command(flatten)]
     pub build: BuildOptions,
 
-    #[command(flatten)]
-    pub fuzz_dir_wrapper: FuzzDirWrapper,
-
     /// Name of the fuzz target to check, or check all targets if not supplied
     pub target: Option<String>,
 }
 
 impl RunCommand for Check {
     fn run_command(&mut self) -> Result<()> {
-        let project = FuzzProject::new(self.fuzz_dir_wrapper.fuzz_dir.to_owned())?;
+        let project = FuzzProject::new(self.build.fuzz_dir_wrapper.get_manifest_path())?;
         project.exec_build(BuildMode::Check, &self.build, self.target.as_deref())
     }
 }

src/options/check.rs

@@ -1,8 +1,4 @@
-use crate::{
-    options::{BuildOptions, FuzzDirWrapper},
-    project::FuzzProject,
-    RunCommand,
-};
+use crate::{options::BuildOptions, project::FuzzProject, RunCommand};
 use anyhow::Result;
 use clap::Parser;
 use std::path::PathBuf;
@@ -12,9 +8,6 @@ pub struct Cmin {
     #[command(flatten)]
     pub build: BuildOptions,
 
-    #[command(flatten)]
-    pub fuzz_dir_wrapper: FuzzDirWrapper,
-
     /// Name of the fuzz target
     pub target: String,
 
@@ -29,7 +22,7 @@ pub struct Cmin {
 
 impl RunCommand for Cmin {
     fn run_command(&mut self) -> Result<()> {
-        let project = FuzzProject::new(self.fuzz_dir_wrapper.fuzz_dir.to_owned())?;
+        let project = FuzzProject::new(self.build.fuzz_dir_wrapper.get_manifest_path())?;
         project.exec_cmin(self)
     }
 }

src/options/cmin.rs

@@ -1,10 +1,6 @@
 use std::path::PathBuf;
 
-use crate::{
-    options::{BuildOptions, FuzzDirWrapper},
-    project::FuzzProject,
-    RunCommand,
-};
+use crate::{options::BuildOptions, project::FuzzProject, RunCommand};
 use anyhow::{bail, Result};
 use clap::Parser;
 
@@ -13,9 +9,6 @@ pub struct Coverage {
     #[command(flatten)]
     pub build: BuildOptions,
 
-    #[command(flatten)]
-    pub fuzz_dir_wrapper: FuzzDirWrapper,
-
     /// Sets the path to the LLVM bin directory. By default, it will use the one installed with rustc
     #[arg(long)]
     pub llvm_path: Option<PathBuf>,
@@ -48,7 +41,7 @@ impl RunCommand for Coverage {
                 see https://github.com/rust-lang/wg-cargo-std-aware/issues/63"
             );
         }
-        let project = FuzzProject::new(self.fuzz_dir_wrapper.fuzz_dir.to_owned())?;
+        let project = FuzzProject::new(self.build.fuzz_dir_wrapper.get_manifest_path())?;
         self.build.coverage = true;
         project.exec_coverage(self)
     }

src/options/coverage.rs

@@ -1,8 +1,4 @@
-use crate::{
-    options::{BuildOptions, FuzzDirWrapper},
-    project::FuzzProject,
-    RunCommand,
-};
+use crate::{options::BuildOptions, project::FuzzProject, RunCommand};
 use anyhow::Result;
 use clap::Parser;
 use std::path::PathBuf;
@@ -12,9 +8,6 @@ pub struct Fmt {
     #[command(flatten)]
     pub build: BuildOptions,
 
-    #[command(flatten)]
-    pub fuzz_dir_wrapper: FuzzDirWrapper,
-
     /// Name of fuzz target
     pub target: String,
 
@@ -24,7 +17,7 @@ pub struct Fmt {
 
 impl RunCommand for Fmt {
     fn run_command(&mut self) -> Result<()> {
-        let project = FuzzProject::new(self.fuzz_dir_wrapper.fuzz_dir.to_owned())?;
+        let project = FuzzProject::new(self.build.fuzz_dir_wrapper.get_manifest_path())?;
         project.debug_fmt_input(self)
     }
 }

src/options/fmt.rs

@@ -1,5 +1,5 @@
 use crate::{
-    options::{FuzzDirWrapper, FuzzEngine},
+    options::{FuzzDirWrapper, FuzzEngine, ManifestPath},
     project::FuzzProject,
     RunCommand,
 };
@@ -28,7 +28,20 @@ pub struct Init {
 
 impl RunCommand for Init {
     fn run_command(&mut self) -> Result<()> {
-        FuzzProject::init(self, self.fuzz_dir_wrapper.fuzz_dir.to_owned())?;
+        let manifest_path = if let Some(manifest_path) = self.fuzz_dir_wrapper.get_manifest_path() {
+            manifest_path
+        } else {
+            let metadata = cargo_metadata::MetadataCommand::new().no_deps().exec()?;
+            ManifestPath(
+                metadata
+                    .workspace_root
+                    .to_path_buf()
+                    .join("fuzz")
+                    .join("Cargo.toml")
+                    .into(),
+            )
+        };
+        FuzzProject::init(manifest_path, self)?;
         Ok(())
     }
 }