tasks: add package filter so can run on a subset of crates

Match cargo's package filtering interface.

Author: nyonson

tasks/src/bench.rs

@@ -6,10 +6,10 @@ use crate::toolchain::{check_toolchain, Toolchain};
 use xshell::Shell;
 
 /// Run benchmark tests for all crates in the workspace.
-pub fn run(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+pub fn run(sh: &Shell, packages: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     check_toolchain(sh, Toolchain::Nightly)?;
 
-    let crate_dirs = get_crate_dirs(sh)?;
+    let crate_dirs = get_crate_dirs(sh, packages)?;
 
     quiet_println(&format!(
         "Running bench tests for {} crates",

tasks/src/docs.rs

@@ -8,12 +8,17 @@ use xshell::Shell;
 ///
 /// This verifies that `cargo doc` works correctly for users with stable Rust.
 /// Uses basic rustdoc warnings to catch common documentation issues.
-pub fn run(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+pub fn run(sh: &Shell, packages: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     check_toolchain(sh, Toolchain::Stable)?;
 
-    quiet_cmd!(sh, "cargo doc --all-features")
-        .env("RUSTDOCFLAGS", "-D warnings")
-        .run()?;
+    let mut cmd = quiet_cmd!(sh, "cargo doc --all-features");
+
+    // Add package filters if specified.
+    for package in packages {
+        cmd = cmd.args(&["-p", package]);
+    }
+
+    cmd.env("RUSTDOCFLAGS", "-D warnings").run()?;
 
     Ok(())
 }
@@ -22,15 +27,21 @@ pub fn run(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
 ///
 /// This emulates the docs.rs build environment by using the nightly toolchain
 /// with `--cfg docsrs` enabled. This catches docs.rs-specific issues.
-pub fn run_docsrs(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+pub fn run_docsrs(sh: &Shell, packages: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     check_toolchain(sh, Toolchain::Nightly)?;
 
-    quiet_cmd!(sh, "cargo doc --all-features")
-        .env(
-            "RUSTDOCFLAGS",
-            "--cfg docsrs -D warnings -D rustdoc::broken-intra-doc-links",
-        )
-        .run()?;
+    let mut cmd = quiet_cmd!(sh, "cargo doc --all-features");
+
+    // Add package filters if specified.
+    for package in packages {
+        cmd = cmd.args(&["-p", package]);
+    }
+
+    cmd.env(
+        "RUSTDOCFLAGS",
+        "--cfg docsrs -D warnings -D rustdoc::broken-intra-doc-links",
+    )
+    .run()?;
 
     Ok(())
 }

tasks/src/environment.rs

@@ -59,7 +59,11 @@ pub fn change_to_repo_root(sh: &Shell) {
 
 /// Get list of crate directories in the workspace using cargo metadata.
 /// Returns fully qualified paths to support various workspace layouts including nested crates.
-pub fn get_crate_dirs(sh: &Shell) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+///
+/// # Arguments
+///
+/// * `packages` - Optional filter for specific package names. If empty, returns all packages.
+pub fn get_crate_dirs(sh: &Shell, packages: &[String]) -> Result<Vec<String>, Box<dyn std::error::Error>> {
     let metadata = cmd!(sh, "cargo metadata --no-deps --format-version 1").read()?;
     let json: serde_json::Value = serde_json::from_str(&metadata)?;
 
@@ -72,6 +76,15 @@ pub fn get_crate_dirs(sh: &Shell) -> Result<Vec<String>, Box<dyn std::error::Err
             // Extract directory path from the manifest path,
             // e.g., "/path/to/repo/releases/Cargo.toml" -> "/path/to/repo/releases".
             let dir_path = manifest_path.trim_end_matches("/Cargo.toml");
+            
+            // Filter by package name if specified.
+            if !packages.is_empty() {
+                let package_name = package["name"].as_str()?;
+                if !packages.contains(&package_name.to_string()) {
+                    return None;
+                }
+            }
+            
             Some(dir_path.to_string())
         })
         .collect();

tasks/src/lint.rs

@@ -37,12 +37,12 @@ impl LintConfig {
 }
 
 /// Run the lint task.
-pub fn run(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+pub fn run(sh: &Shell, packages: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     check_toolchain(sh, Toolchain::Nightly)?;
     quiet_println("Running lint task...");
 
     lint_workspace(sh)?;
-    lint_crates(sh)?;
+    lint_crates(sh, packages)?;
     check_duplicate_deps(sh)?;
 
     quiet_println("Lint task completed successfully");
@@ -78,10 +78,10 @@ fn lint_workspace(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
 /// even when a crate's own default features are disabled. Running clippy on each crate
 /// individually ensures that each crate truly compiles and passes lints with only its
 /// explicitly enabled features.
-fn lint_crates(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+fn lint_crates(sh: &Shell, packages: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     quiet_println("Running crate-specific lints...");
 
-    let crate_dirs = get_crate_dirs(sh)?;
+    let crate_dirs = get_crate_dirs(sh, packages)?;
     quiet_println(&format!("Found crates: {}", crate_dirs.join(", ")));
 
     for crate_dir in crate_dirs {

tasks/src/main.rs

@@ -21,7 +21,11 @@ struct Cli {
     /// Lock file to use for dependencies (defaults to recent).
     #[arg(long, global = true, value_enum)]
     lock_file: Option<LockFile>,
-    
+
+    /// Filter to specific package (can be specified multiple times).
+    #[arg(short = 'p', long = "package", global = true)]
+    packages: Vec<String>,
+
     #[command(subcommand)]
     command: Commands,
 }
@@ -64,31 +68,31 @@ fn main() {
 
     match cli.command {
         Commands::Lint => {
-            if let Err(e) = lint::run(&sh) {
+            if let Err(e) = lint::run(&sh, &cli.packages) {
                 eprintln!("Error running lint task: {}", e);
                 process::exit(1);
             }
         }
         Commands::Docs => {
-            if let Err(e) = docs::run(&sh) {
+            if let Err(e) = docs::run(&sh, &cli.packages) {
                 eprintln!("Error building docs: {}", e);
                 process::exit(1);
             }
         }
         Commands::Docsrs => {
-            if let Err(e) = docs::run_docsrs(&sh) {
+            if let Err(e) = docs::run_docsrs(&sh, &cli.packages) {
                 eprintln!("Error building docs.rs docs: {}", e);
                 process::exit(1);
             }
         }
         Commands::Bench => {
-            if let Err(e) = bench::run(&sh) {
+            if let Err(e) = bench::run(&sh, &cli.packages) {
                 eprintln!("Error running bench tests: {}", e);
                 process::exit(1);
             }
         }
         Commands::Test { toolchain } => {
-            if let Err(e) = test::run(&sh, toolchain) {
+            if let Err(e) = test::run(&sh, toolchain, &cli.packages) {
                 eprintln!("Error running tests: {}", e);
                 process::exit(1);
             }

tasks/src/test.rs

@@ -83,10 +83,10 @@ impl TestConfig {
 }
 
 /// Run build and test for all crates with the specified toolchain.
-pub fn run(sh: &Shell, toolchain: Toolchain) -> Result<(), Box<dyn std::error::Error>> {
+pub fn run(sh: &Shell, toolchain: Toolchain, packages: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     check_toolchain(sh, toolchain)?;
 
-    let crate_dirs = get_crate_dirs(sh)?;
+    let crate_dirs = get_crate_dirs(sh, packages)?;
     quiet_println(&format!("Testing {} crates", crate_dirs.len()));
 
     for crate_dir in &crate_dirs {