1.75.1

Author: billy1624

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.75.1 - Pending
+
+### Enhancements
+
+- parser: parse `required-features` from Cargo Metadata
+- command: compile Rust target with `required-features`
+- command: selectively list binary, example, integration test and unit test targets
+
 ## 1.75.0 - 2023-12-28
 
 ### New Features

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "firedbg-cli"
-version = "1.75.0"
+version = "1.75.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 authors = [

command/Cargo.toml

@@ -17,7 +17,7 @@ use std::{
     process::exit,
     time::SystemTime,
 };
-use structopt::StructOpt;
+use structopt::{clap::arg_enum, StructOpt};
 use tokio::fs::{create_dir_all, remove_dir_all, remove_file};
 
 const TEMPLATE: &str = concat!(
@@ -111,6 +111,14 @@ enum SubCommand {
     ListTarget {
         #[structopt(long)]
         json_format: bool,
+        #[structopt(
+            long,
+            case_insensitive = true,
+            possible_values = &ListTarget::variants(),
+            default_value = "Bin Example Test UnitTest",
+            value_delimiter = " ",
+        )]
+        targets: Vec<ListTarget>,
     },
     /// Open debugger view in VS Code
     Open {
@@ -129,6 +137,16 @@ enum SubCommand {
     },
 }
 
+arg_enum! {
+    #[derive(Debug, PartialEq)]
+    enum ListTarget {
+        Bin,
+        Example,
+        Test,
+        UnitTest,
+    }
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
     env_logger::init();
@@ -347,7 +365,10 @@ async fn main() -> Result<()> {
                 println!("{}", serde_json::json!(arr));
             }
         }
-        SubCommand::ListTarget { json_format } => list_target(workspace, json_format)
+        SubCommand::ListTarget {
+            json_format,
+            targets,
+        } => list_target(workspace, json_format, targets)
             .await
             .context("Fail to list target")?,
         SubCommand::Open { idx } => {
@@ -858,7 +879,11 @@ fn list_firedbg_runs(firedbg_runs: Vec<PathBuf>) {
     }
 }
 
-async fn list_target(workspace: &Workspace, json_format: bool) -> Result<()> {
+async fn list_target(
+    workspace: &Workspace,
+    json_format: bool,
+    targets: Vec<ListTarget>,
+) -> Result<()> {
     #[derive(Debug, Serialize)]
     struct Target<'a> {
         binaries: Vec<&'a Binary>,
@@ -880,17 +905,37 @@ async fn list_target(workspace: &Workspace, json_format: bool) -> Result<()> {
         test_cases: Vec<String>,
     }
 
-    let binaries: Vec<_> = workspace
-        .packages
-        .iter()
-        .flat_map(|package| &package.binaries)
-        .collect();
+    let list_all = targets.contains(&ListTarget::Bin)
+        && targets.contains(&ListTarget::Example)
+        && targets.contains(&ListTarget::Test)
+        && targets.contains(&ListTarget::UnitTest);
+    let list_partial = !list_all
+        && targets.iter().any(|t| {
+            matches!(
+                t,
+                ListTarget::Bin | ListTarget::Example | ListTarget::Test | ListTarget::UnitTest
+            )
+        });
 
-    let examples: Vec<_> = workspace
-        .packages
-        .iter()
-        .flat_map(|package| &package.examples)
-        .collect();
+    let binaries: Vec<_> = if list_all || (list_partial && targets.contains(&ListTarget::Bin)) {
+        workspace
+            .packages
+            .iter()
+            .flat_map(|package| &package.binaries)
+            .collect()
+    } else {
+        Vec::new()
+    };
+
+    let examples: Vec<_> = if list_all || (list_partial && targets.contains(&ListTarget::Example)) {
+        workspace
+            .packages
+            .iter()
+            .flat_map(|package| &package.examples)
+            .collect()
+    } else {
+        Vec::new()
+    };
 
     fn handle_tests<'a>((package, test): &'a (&'a Package, Option<&'a Test>)) -> TestType {
         if let Some(test) = test {
@@ -926,13 +971,15 @@ async fn list_target(workspace: &Workspace, json_format: bool) -> Result<()> {
             package
                 .tests
                 .iter()
+                .filter(|_| list_all || (list_partial && targets.contains(&ListTarget::Test)))
                 .map(|test| (package, Some(test)))
                 .collect::<Vec<_>>()
         })
         .chain(
             workspace
                 .packages
                 .iter()
+                .filter(|_| list_all || (list_partial && targets.contains(&ListTarget::UnitTest)))
                 .filter(|package| package.has_lib)
                 .map(|package| (package, None)),
         )
@@ -999,8 +1046,12 @@ async fn list_target(workspace: &Workspace, json_format: bool) -> Result<()> {
     create_dir_all(firedbg_dir)
         .await
         .with_context(|| format!("Fail to create directory: `{firedbg_dir}`"))?;
-    let path = &format!("{firedbg_dir}/target.json");
-    to_json_file(path, &target)
+    let path = if !list_all && list_partial && targets.contains(&ListTarget::UnitTest) {
+        format!("{firedbg_dir}/target-unit-test.json")
+    } else {
+        format!("{firedbg_dir}/target.json")
+    };
+    to_json_file(&path, &target)
         .await
         .with_context(|| format!("Fail to create JSON file: `{path}`"))?;
     Ok(())

command/src/main.rs

@@ -1,6 +1,6 @@
 [package]
 name = "firedbg-rust-debugger"
-version = "1.75.0"
+version = "1.75.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 build = "build.rs"

debugger/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "firedbg-stream-indexer"
-version = "1.75.0"
+version = "1.75.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 authors = [
@@ -28,7 +28,7 @@ tokio = { version = "1", optional = true }
 pretty_assertions = { version = "1", optional = true }
 async-trait = { version = "0.1", optional = true }
 # workspace
-firedbg-rust-debugger = { path = "../debugger", version = "1.75.0", default-features = false }
+firedbg-rust-debugger = { path = "../debugger", version = "1.75.1", default-features = false }
 
 [features]
 # The base feature only exports the sea-orm entities

indexer/Cargo.toml

@@ -35,18 +35,21 @@ pub struct Dependency {
 pub struct Binary {
     pub name: String,
     pub src_path: String,
+    pub required_features: Vec<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Test {
     pub name: String,
     pub src_path: String,
+    pub required_features: Vec<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Example {
     pub name: String,
     pub src_path: String,
+    pub required_features: Vec<String>,
 }
 
 impl Workspace {
@@ -255,6 +258,9 @@ impl Binary {
             .arg(format!("{root_dir}/Cargo.toml"))
             .arg("--bin")
             .arg(binary_name);
+        if !self.required_features.is_empty() {
+            cmd.arg("--features").arg(self.required_features.join(","));
+        }
         cmd
     }
 
@@ -318,6 +324,9 @@ impl Test {
             .arg(format!("{root_dir}/Cargo.toml"))
             .arg("--test")
             .arg(test_name);
+        if !self.required_features.is_empty() {
+            cmd.arg("--features").arg(self.required_features.join(","));
+        }
         cmd
     }
 
@@ -356,6 +365,9 @@ impl Example {
             .arg(format!("{root_dir}/Cargo.toml"))
             .arg("--example")
             .arg(example_name);
+        if !self.required_features.is_empty() {
+            cmd.arg("--features").arg(self.required_features.join(","));
+        }
         cmd
     }
 

parser/src/def/workspace.rs

@@ -29,4 +29,6 @@ pub struct Target {
     pub kind: Vec<String>,
     pub name: String,
     pub src_path: String,
+    #[serde(default, rename(deserialize = "required-features"))]
+    pub required_features: Vec<String>,
 }

parser/src/def/workspace/raw.rs

@@ -71,6 +71,7 @@ fn parse_binaries(raw_target: Vec<raw::Target>) -> Vec<Binary> {
         .map(|raw_target| Binary {
             name: raw_target.name,
             src_path: raw_target.src_path,
+            required_features: raw_target.required_features,
         })
         .collect()
 }
@@ -82,6 +83,7 @@ fn parse_tests(raw_target: Vec<raw::Target>) -> Vec<Test> {
         .map(|raw_target| Test {
             name: raw_target.name,
             src_path: raw_target.src_path,
+            required_features: raw_target.required_features,
         })
         .collect()
 }
@@ -93,6 +95,7 @@ fn parse_examples(raw_target: Vec<raw::Target>) -> Vec<Example> {
         .map(|raw_target| Example {
             name: raw_target.name,
             src_path: raw_target.src_path,
+            required_features: raw_target.required_features,
         })
         .collect()
 }