wire up --directory with static and PyPI downloads

2bndy5 · 2bndy5 · commit d17eab747467 · 2026-03-29T20:00:47.000-07:00
diff --git a/clang-installer/src/downloader/pypi.rs b/clang-installer/src/downloader/pypi.rs
@@ -416,6 +416,7 @@ impl PyPiDownloader {
     pub async fn download_tool(
         clang_tool: &ClangTool,
         version: &VersionReq,
+        directory: Option<&PathBuf>,
     ) -> Result<PathBuf, PyPiDownloadError> {
         let info = Self::get_pypi_release_info(clang_tool).await?;
         let (ver, info) = Self::get_best_pypi_release(clang_tool, &info, version)?;
@@ -435,11 +436,15 @@ impl PyPiDownloader {
             log::info!("Verifying wheel file integrity with digest: {digest:?}");
             digest.verify(&cached_wheel)?;
         }
-        let extracted_bin = cached_dir.join(format!(
-            "bin/{clang_tool}-{}{}",
+        let bin_name = format!(
+            "{clang_tool}-{}{}",
             ver.major,
             if cfg!(windows) { ".exe" } else { "" }
-        ));
+        );
+        let extracted_bin = match directory {
+            None => cached_dir.join(format!("bin/{bin_name}",)),
+            Some(dir) => dir.join(&bin_name),
+        };
         Self::extract_bin(clang_tool, &cached_wheel, &extracted_bin)?;
         Ok(extracted_bin)
     }
diff --git a/clang-installer/src/downloader/static_dist.rs b/clang-installer/src/downloader/static_dist.rs
@@ -42,6 +42,10 @@ pub enum StaticDistDownloadError {
     #[error("Failed to parse the SHA512 sum file")]
     Sha512Corruption,
 }
+const MIN_CLANG_TOOLS_VERSION: &str = "9";
+const MAX_CLANG_TOOLS_VERSION: &str = "21";
+const CLANG_TOOLS_REPO: &str = "https://github.com/cpp-linter/clang-tools-static-binaries";
+const CLANG_TOOLS_TAG: &str = "master-6e612956";
 
 /// A downloader that uses statically linked binary distribution files
 /// provided by the cpp-linter team.
@@ -56,11 +60,11 @@ impl StaticDistDownloader {
     /// `MAX_CLANG_TOOLS_VERSION` environment variables (inclusive) at compile time.
     fn find_suitable_version(req_ver: &VersionReq) -> Option<Version> {
         let min_clang_tools_version: u8 = option_env!("MIN_CLANG_TOOLS_VERSION")
-            .unwrap_or("9")
+            .unwrap_or(MIN_CLANG_TOOLS_VERSION)
             .parse()
             .expect("Invalid MIN_CLANG_TOOLS_VERSION env var value");
         let max_clang_tools_version: u8 = option_env!("MAX_CLANG_TOOLS_VERSION")
-            .unwrap_or("21")
+            .unwrap_or(MAX_CLANG_TOOLS_VERSION)
             .parse()
             .expect("Invalid MAX_CLANG_TOOLS_VERSION env var value");
         let clang_tools_versions: RangeInclusive<u8> =
@@ -101,6 +105,7 @@ impl StaticDistDownloader {
     pub async fn download_tool(
         tool: &ClangTool,
         requested_version: &VersionReq,
+        directory: Option<&PathBuf>,
     ) -> Result<PathBuf, StaticDistDownloadError> {
         if consts::ARCH != "x86_64" {
             return Err(StaticDistDownloadError::UnsupportedArchitecture);
@@ -117,9 +122,8 @@ impl StaticDistDownloader {
         } else {
             ""
         };
-        let clang_tools_repo: &str = option_env!("CLANG_TOOLS_REPO")
-            .unwrap_or("https://github.com/cpp-linter/clang-tools-static-binaries");
-        let clang_tools_tag: &str = option_env!("CLANG_TOOLS_TAG").unwrap_or("master-6e612956");
+        let clang_tools_repo: &str = option_env!("CLANG_TOOLS_REPO").unwrap_or(CLANG_TOOLS_REPO);
+        let clang_tools_tag: &str = option_env!("CLANG_TOOLS_TAG").unwrap_or(CLANG_TOOLS_TAG);
 
         let base_url = format!(
             "{clang_tools_repo}/releases/download/{clang_tools_tag}/{tool}-{ver_str}_{}-amd64",
@@ -133,9 +137,11 @@ impl StaticDistDownloader {
         );
         let url = Url::parse(format!("{base_url}{suffix}").as_str())?;
         let cache_path = Self::get_cache_dir();
-        let download_path = cache_path
-            .join("bin")
-            .join(format!("{tool}-{ver_str}{suffix}").as_str());
+        let bin_name = format!("{tool}-{ver_str}{suffix}");
+        let download_path = match directory {
+            None => cache_path.join("bin").join(&bin_name),
+            Some(dir) => dir.join(&bin_name),
+        };
         if download_path.exists() {
             log::info!(
                 "Using cached static binary for {tool} version {ver_str} from {:?}",
diff --git a/clang-installer/src/main.rs b/clang-installer/src/main.rs
@@ -107,6 +107,7 @@ pub struct CliOptions {
             default_value = "",
     )]
     pub version: Option<RequestedVersion>,
+
     /// The clang tool to install.
     #[arg(
         short,
@@ -115,9 +116,11 @@ pub struct CliOptions {
         default_value = "clang-format clang-tidy"
     )]
     pub tool: Option<Vec<ClangTool>>,
+
     /// The directory where the clang tools should be installed.
     #[arg(short, long)]
     pub directory: Option<PathBuf>,
+
     /// Force overwriting symlink to the installed binary.
     ///
     /// This will only overwrite an existing symlink.
@@ -144,7 +147,10 @@ async fn main() -> Result<()> {
         req_ver => {
             let mut map_tools = HashMap::new();
             for t in tool {
-                if let Some(version) = req_ver.eval_tool(&t, options.force).await? {
+                if let Some(version) = req_ver
+                    .eval_tool(&t, options.force, options.directory.as_ref())
+                    .await?
+                {
                     map_tools.entry(t).or_insert(version);
                 }
             }
diff --git a/clang-installer/src/version.rs b/clang-installer/src/version.rs
@@ -77,6 +77,7 @@ impl RequestedVersion {
         &self,
         tool: &ClangTool,
         overwrite_symlink: bool,
+        directory: Option<&PathBuf>,
     ) -> Result<Option<ClangVersion>, GetToolError> {
         match self {
             RequestedVersion::Path(_) => {
@@ -134,15 +135,17 @@ impl RequestedVersion {
                 }
 
                 // try to download a suitable version
-                let bin = match PyPiDownloader::download_tool(tool, version_req).await {
+                let bin = match PyPiDownloader::download_tool(tool, version_req, directory).await {
                     Ok(bin) => bin,
                     Err(e) => {
                         log::error!("Failed to download {tool} {version_req} from PyPi: {e}");
                         if let Some(result) = try_install_package(tool, version_req, &min_ver)? {
                             return Ok(Some(result));
                         }
                         log::info!("Falling back to downloading {tool} static binaries.");
-                        match StaticDistDownloader::download_tool(tool, version_req).await {
+                        match StaticDistDownloader::download_tool(tool, version_req, directory)
+                            .await
+                        {
                             Ok(bin) => bin,
                             Err(e) => {
                                 log::error!(
@@ -283,7 +286,7 @@ mod tests {
     #[tokio::test]
     async fn eval_no_value() {
         let result = RequestedVersion::NoValue
-            .eval_tool(&ClangTool::ClangFormat, false)
+            .eval_tool(&ClangTool::ClangFormat, false, None)
             .await
             .unwrap();
         assert!(result.is_none());
@@ -303,13 +306,17 @@ mod tests {
         let version_req =
             VersionReq::parse(option_env!("MIN_CLANG_TOOLS_VERSION").unwrap_or("11")).unwrap();
         let downloaded_clang = RequestedVersion::Requirement(version_req.clone())
-            .eval_tool(&tool, false)
+            .eval_tool(&tool, false, Some(&PathBuf::from(tmp_cache_dir.path())))
             .await
             .unwrap()
             .unwrap();
         println!("Downloaded clang-format: {downloaded_clang:?}");
         let req_ver = RequestedVersion::Path(downloaded_clang.path.parent().unwrap().to_owned());
-        let result = req_ver.eval_tool(&tool, false).await.unwrap().unwrap();
+        let result = req_ver
+            .eval_tool(&tool, false, None)
+            .await
+            .unwrap()
+            .unwrap();
         println!("Evaluated clang-format from path: {result:?}");
         assert!(
             version_req.matches(&result.version),
@@ -328,7 +335,7 @@ mod tests {
         for tool in [ClangTool::ClangFormat, ClangTool::ClangTidy] {
             let version_req = VersionReq::parse(clang_version).unwrap();
             let clang_path = RequestedVersion::Requirement(version_req.clone())
-                .eval_tool(&tool, false)
+                .eval_tool(&tool, false, None)
                 .await
                 .unwrap()
                 .unwrap();
diff --git a/cpp-linter/src/clang_tools/mod.rs b/cpp-linter/src/clang_tools/mod.rs
@@ -108,15 +108,15 @@ pub async fn capture_clang_tools_output(
     // info as debugging output.
     if clang_params.tidy_checks != "-*" {
         let tool = ClangTool::ClangTidy;
-        let tool_info = version.eval_tool(&tool, false).await?.ok_or(anyhow!(
+        let tool_info = version.eval_tool(&tool, false, None).await?.ok_or(anyhow!(
             "Failed to find {tool} or install a suitable version"
         ))?;
         clang_versions.tidy_version = Some(tool_info.version);
         clang_params.clang_tidy_command = Some(tool_info.path);
     }
     if !clang_params.style.is_empty() {
         let tool = ClangTool::ClangFormat;
-        let tool_info = version.eval_tool(&tool, false).await?.ok_or(anyhow!(
+        let tool_info = version.eval_tool(&tool, false, None).await?.ok_or(anyhow!(
             "Failed to find {tool} or install a suitable version"
         ))?;
         clang_versions.format_version = Some(tool_info.version);
