let each binary have their own config

Author: Bogdan Mircea

tools/rust_analyzer/bin/discover_rust_project.rs

@@ -5,26 +5,20 @@
 use std::convert::TryFrom;
 use std::env;
 use std::fs;
+use std::process::Command;
 
 use anyhow::bail;
-use camino::Utf8Path;
-use camino::Utf8PathBuf;
-use clap::Args;
+use camino::{Utf8Path, Utf8PathBuf};
+use clap::Parser;
 use env_logger::Target;
 use env_logger::WriteStyle;
 use gen_rust_project_lib::DiscoverProject;
 use gen_rust_project_lib::NormalizedProjectString;
 use gen_rust_project_lib::WORKSPACE_ROOT_FILE_NAMES;
-use gen_rust_project_lib::{generate_crate_info, generate_rust_project, Config, RustAnalyzerArg};
+use gen_rust_project_lib::{generate_crate_info, generate_rust_project, RustAnalyzerArg};
 use log::LevelFilter;
 use std::io::Write;
 
-#[derive(Debug, Args)]
-struct DiscoverProjectArgs {
-    /// The argument that `rust-analyzer` can pass to the binary.
-    rust_analyzer_argument: Option<RustAnalyzerArg>,
-}
-
 fn discover_rust_project(
     bazel: &Utf8Path,
     output_base: &Utf8Path,
@@ -111,13 +105,9 @@ fn project_discovery() -> anyhow::Result<()> {
         output_base,
         bazel,
         config_group,
-        specific,
+        rust_analyzer_argument,
     } = Config::parse()?;
 
-    let DiscoverProjectArgs {
-        rust_analyzer_argument,
-    } = specific;
-    
     log::info!("got rust-analyzer argument: {rust_analyzer_argument:?}");
 
     let ra_arg = match rust_analyzer_argument {
@@ -174,3 +164,126 @@ fn main() {
         discovery_failure(e);
     }
 }
+
+#[derive(Debug)]
+pub struct Config {
+    /// The path to the Bazel workspace directory. If not specified, uses the result of `bazel info workspace`.
+    pub workspace: Utf8PathBuf,
+
+    /// The path to the Bazel execution root. If not specified, uses the result of `bazel info execution_root`.
+    pub execution_root: Utf8PathBuf,
+
+    /// The path to the Bazel output user root. If not specified, uses the result of `bazel info output_base`.
+    pub output_base: Utf8PathBuf,
+
+    /// The path to a Bazel binary
+    pub bazel: Utf8PathBuf,
+
+    /// A `--config` directive that gets passed to Bazel to be able to pass custom configurations.
+    pub config_group: Option<String>,
+
+    /// The argument that `rust-analyzer` can pass to the binary.
+    rust_analyzer_argument: Option<RustAnalyzerArg>,
+}
+
+impl Config {
+    // Parse the configuration flags and supplement with bazel info as needed.
+    pub fn parse() -> anyhow::Result<Self> {
+        let ConfigParser {
+            mut workspace,
+            mut execution_root,
+            mut output_base,
+            bazel,
+            config_group,
+            rust_analyzer_argument,
+        } = ConfigParser::parse();
+
+        if workspace.is_some() && execution_root.is_some() && output_base.is_some() {
+            return Ok(Config {
+                workspace: workspace.unwrap(),
+                execution_root: execution_root.unwrap(),
+                output_base: output_base.unwrap(),
+                bazel,
+                config_group,
+                rust_analyzer_argument,
+            });
+        }
+
+        // We need some info from `bazel info`. Fetch it now.
+        let mut bazel_info_command = Command::new(&bazel);
+
+        // Execute bazel info.
+        let output = bazel_info_command
+            // Switch to the workspace directory if one was provided.
+            .current_dir(workspace.as_deref().unwrap_or(Utf8Path::new(".")))
+            .env_remove("BAZELISK_SKIP_WRAPPER")
+            .env_remove("BUILD_WORKING_DIRECTORY")
+            .env_remove("BUILD_WORKSPACE_DIRECTORY")
+            // Set the output_base if one was provided.
+            .args(output_base.as_ref().map(|s| format!("--output_base={s}")))
+            .arg("info")
+            .args(config_group.as_ref().map(|s| format!("--config={s}")))
+            .output()?;
+
+        if !output.status.success() {
+            let status = output.status;
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            bail!("Failed to run `bazel info` ({status:?}): {stderr}");
+        }
+
+        // Extract the output.
+        let output = String::from_utf8(output.stdout)?;
+
+        let iter = output
+            .trim()
+            .split('\n')
+            .filter_map(|line| line.split_once(':'))
+            .map(|(k, v)| (k, v.trim()));
+
+        for (k, v) in iter {
+            match k {
+                "workspace" => workspace = Some(v.into()),
+                "execution_root" => execution_root = Some(v.into()),
+                "output_base" => output_base = Some(v.into()),
+                _ => continue,
+            }
+        }
+
+        let config = Config {
+            workspace: workspace.expect("'workspace' must exist in bazel info"),
+            execution_root: execution_root.expect("'execution_root' must exist in bazel info"),
+            output_base: output_base.expect("'output_base' must exist in bazel info"),
+            bazel,
+            config_group,
+            rust_analyzer_argument,
+        };
+
+        Ok(config)
+    }
+}
+
+#[derive(Debug, Parser)]
+struct ConfigParser {
+    /// The path to the Bazel workspace directory. If not specified, uses the result of `bazel info workspace`.
+    #[clap(long, env = "BUILD_WORKSPACE_DIRECTORY")]
+    workspace: Option<Utf8PathBuf>,
+
+    /// The path to the Bazel execution root. If not specified, uses the result of `bazel info execution_root`.
+    #[clap(long)]
+    execution_root: Option<Utf8PathBuf>,
+
+    /// The path to the Bazel output user root. If not specified, uses the result of `bazel info output_base`.
+    #[clap(long, env = "OUTPUT_BASE")]
+    output_base: Option<Utf8PathBuf>,
+
+    /// The path to a Bazel binary
+    #[clap(long, default_value = "bazel")]
+    bazel: Utf8PathBuf,
+
+    /// A `--config` directive that gets passed to Bazel to be able to pass custom configurations.
+    #[clap(long)]
+    config_group: Option<String>,
+
+    /// The argument that `rust-analyzer` can pass to the binary.
+    rust_analyzer_argument: Option<RustAnalyzerArg>,
+}

tools/rust_analyzer/bin/gen_rust_project.rs

@@ -1,18 +1,10 @@
+use std::process::Command;
 use std::{env, io::ErrorKind};
 
 use anyhow::bail;
-use camino::Utf8Path;
-use clap::Args;
-use gen_rust_project_lib::{
-    generate_crate_info, generate_rust_project, Config, NormalizedProjectString,
-};
-
-#[derive(Debug, Args)]
-struct GenerateProjectArgs {
-    /// Space separated list of target patterns that comes after all other args.
-    #[clap(default_value = "@//...")]
-    targets: Vec<String>,
-}
+use camino::{Utf8Path, Utf8PathBuf};
+use clap::Parser;
+use gen_rust_project_lib::{generate_crate_info, generate_rust_project, NormalizedProjectString};
 
 fn write_rust_project(
     bazel: &Utf8Path,
@@ -63,20 +55,17 @@ fn main() -> anyhow::Result<()> {
         execution_root,
         output_base,
         bazel,
-        config_group,
-        specific,
+        targets,
     } = Config::parse()?;
 
-    let GenerateProjectArgs { targets } = specific;
-
     let rules_rust_name = env!("ASPECT_REPOSITORY");
 
     // Generate the crate specs.
     generate_crate_info(
         &bazel,
         &output_base,
         &workspace,
-        config_group.as_deref(),
+        None,
         rules_rust_name,
         &targets,
     )?;
@@ -87,11 +76,124 @@ fn main() -> anyhow::Result<()> {
         &output_base,
         &workspace,
         &execution_root,
-        config_group.as_deref(),
+        None,
         rules_rust_name,
         &targets,
         &workspace.join("rust-project.json"),
     )?;
 
     Ok(())
 }
+
+#[derive(Debug)]
+pub struct Config {
+    /// The path to the Bazel workspace directory. If not specified, uses the result of `bazel info workspace`.
+    pub workspace: Utf8PathBuf,
+
+    /// The path to the Bazel execution root. If not specified, uses the result of `bazel info execution_root`.
+    pub execution_root: Utf8PathBuf,
+
+    /// The path to the Bazel output user root. If not specified, uses the result of `bazel info output_base`.
+    pub output_base: Utf8PathBuf,
+
+    /// The path to a Bazel binary
+    pub bazel: Utf8PathBuf,
+
+    /// Space separated list of target patterns that comes after all other args.
+    targets: Vec<String>,
+}
+
+impl Config {
+    // Parse the configuration flags and supplement with bazel info as needed.
+    pub fn parse() -> anyhow::Result<Self> {
+        let ConfigParser {
+            mut workspace,
+            mut execution_root,
+            mut output_base,
+            bazel,
+            targets,
+        } = ConfigParser::parse();
+
+        if workspace.is_some() && execution_root.is_some() && output_base.is_some() {
+            return Ok(Config {
+                workspace: workspace.unwrap(),
+                execution_root: execution_root.unwrap(),
+                output_base: output_base.unwrap(),
+                bazel,
+                targets,
+            });
+        }
+
+        // We need some info from `bazel info`. Fetch it now.
+        let mut bazel_info_command = Command::new(&bazel);
+
+        // Execute bazel info.
+        let output = bazel_info_command
+            // Switch to the workspace directory if one was provided.
+            .current_dir(workspace.as_deref().unwrap_or(Utf8Path::new(".")))
+            .env_remove("BAZELISK_SKIP_WRAPPER")
+            .env_remove("BUILD_WORKING_DIRECTORY")
+            .env_remove("BUILD_WORKSPACE_DIRECTORY")
+            // Set the output_base if one was provided.
+            .args(output_base.as_ref().map(|s| format!("--output_base={s}")))
+            .arg("info")
+            .output()?;
+
+        if !output.status.success() {
+            let status = output.status;
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            bail!("Failed to run `bazel info` ({status:?}): {stderr}");
+        }
+
+        // Extract the output.
+        let output = String::from_utf8(output.stdout)?;
+
+        let iter = output
+            .trim()
+            .split('\n')
+            .filter_map(|line| line.split_once(':'))
+            .map(|(k, v)| (k, v.trim()));
+
+        for (k, v) in iter {
+            match k {
+                "workspace" => workspace = Some(v.into()),
+                "execution_root" => execution_root = Some(v.into()),
+                "output_base" => output_base = Some(v.into()),
+                _ => continue,
+            }
+        }
+
+        let config = Config {
+            workspace: workspace.expect("'workspace' must exist in bazel info"),
+            execution_root: execution_root.expect("'execution_root' must exist in bazel info"),
+            output_base: output_base.expect("'output_base' must exist in bazel info"),
+            bazel,
+            targets,
+        };
+
+        Ok(config)
+    }
+}
+
+#[derive(Debug, Parser)]
+struct ConfigParser {
+    /// The path to the Bazel workspace directory. If not specified, uses the result of `bazel info workspace`.
+    #[clap(long, env = "BUILD_WORKSPACE_DIRECTORY")]
+    workspace: Option<Utf8PathBuf>,
+
+    /// The path to the Bazel execution root. If not specified, uses the result of `bazel info execution_root`.
+    #[clap(long)]
+    execution_root: Option<Utf8PathBuf>,
+
+    /// The path to the Bazel output user root. If not specified, uses the result of `bazel info output_base`.
+    #[clap(long, env = "OUTPUT_BASE")]
+    output_base: Option<Utf8PathBuf>,
+
+    /// The path to a Bazel binary
+    #[clap(long, default_value = "bazel")]
+    bazel: Utf8PathBuf,
+
+    /// Space separated list of target patterns that comes after all other args.
+    #[clap(default_value = "@//...")]
+    targets: Vec<String>,
+}