feat: set clang version min and max at compile time

This adds a build script that downloads versions.json from `cpp-linter/clang-tools-static-binaries` latest release and injects it into the production code using compile-time-only environment variables.

Includes a similar adjustment to the test CI job in some inline nu shell script that employs gh-cli instead of direct download.

Author: 2bndy5

.github/workflows/run-dev-tests.yml

@@ -99,13 +99,23 @@ jobs:
         uses: hustcer/setup-nu@92c296ba1ba2ba04cc948ab64ddefe192dc13f0c # v3.23
 
       - name: Run test suite
-        env:
-          MIN_CLANG_TOOLS_VERSION: "11"
-          MAX_CLANG_TOOLS_VERSION: "22"
         shell: nu {0}
         run: |-
-          let max_ver = $env.MAX_CLANG_TOOLS_VERSION | into int
-          let min_ver = $env.MIN_CLANG_TOOLS_VERSION | into int
+          let version_info = (
+            (^gh release download -R cpp-linter/clang-tools-static-binaries --pattern versions.json --output -)
+            | from json
+          )
+          mut max_ver = 0
+          mut min_ver = 99
+          for ver in ($version_info.llvm_versions | columns) {
+            let ver = $ver | into int
+            if ($ver < $min_ver) {
+              $min_ver = $ver
+            }
+            if ($ver > $max_ver) {
+              $max_ver = $ver
+            }
+          }
           for $ver in ($min_ver..$max_ver) {
             print $"::group::Testing with clang v($ver)"
             with-env { CLANG_VERSION: $"($ver)" } {

.gitignore

@@ -347,3 +347,4 @@ cpp-linter-py/docs/cli_args.rst
 lcov.info
 coverage.json
 .config/ReleaseNotes.md
+versions.json

Cargo.lock

@@ -47,5 +47,10 @@ tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 [features]
 bin = ["dep:clap", "dep:tokio", "dep:anyhow", "dep:colored"]
 
+[build-dependencies]
+serde = { workspace = true }
+serde_json = { workspace = true }
+reqwest = { workspace = true, features = ["default-tls", "blocking"] }
+
 [package.metadata.binstall]
 pkg-url = "{ repo }/releases/download/clang-installer/v{ version }/{ name }-{ target }{ archive-suffix }"

clang-installer/Cargo.toml

@@ -0,0 +1,48 @@
+use std::{fs, path::PathBuf, time::Duration};
+
+use reqwest::blocking::ClientBuilder;
+
+const URL: &str = "https://github.com/cpp-linter/clang-tools-static-binaries/releases/latest/download/versions.json";
+
+#[derive(Debug, serde::Deserialize)]
+struct VersionInfo {
+    release_tag: String,
+    llvm_versions: std::collections::HashMap<u8, String>,
+}
+fn main() {
+    let pre_seed = PathBuf::from("versions.json");
+    let version_info_str = if pre_seed.exists() {
+        println!("cargo:warning=Using pre-seeded version info from {pre_seed:?}");
+        fs::read_to_string(&pre_seed).unwrap()
+    } else {
+        ClientBuilder::new()
+            .user_agent("cpp-linter-rs/clang-installer")
+            .timeout(Duration::from_secs(30))
+            .build()
+            .unwrap()
+            .get(URL)
+            .send()
+            .unwrap()
+            .text()
+            .unwrap()
+    };
+    let version_info: VersionInfo = serde_json::from_str(&version_info_str).unwrap();
+    let (min_ver, max_ver) = {
+        let (mut min_v, mut max_v) = (None, None);
+        for ver in version_info.llvm_versions.keys() {
+            if min_v.is_none_or(|v| v > ver) {
+                min_v = Some(ver);
+            }
+            if max_v.is_none_or(|v| v < ver) {
+                max_v = Some(ver);
+            }
+        }
+        (min_v.unwrap(), max_v.unwrap())
+    };
+    println!(
+        "cargo:rustc-env=CLANG_TOOLS_TAG={}",
+        version_info.release_tag
+    );
+    println!("cargo:rustc-env=MIN_CLANG_TOOLS_VERSION={min_ver}");
+    println!("cargo:rustc-env=MAX_CLANG_TOOLS_VERSION={max_ver}");
+}

clang-installer/build.rs

@@ -43,10 +43,10 @@ pub enum StaticDistDownloadError {
     #[error("Failed to parse the SHA512 sum file")]
     Sha512Corruption,
 }
-const MIN_CLANG_TOOLS_VERSION: u8 = 11;
-pub(crate) const MAX_CLANG_TOOLS_VERSION: u8 = 22;
+const MIN_CLANG_TOOLS_VERSION: &str = env!("MIN_CLANG_TOOLS_VERSION");
+pub(crate) const MAX_CLANG_TOOLS_VERSION: &str = env!("MAX_CLANG_TOOLS_VERSION");
 const CLANG_TOOLS_REPO: &str = "https://github.com/cpp-linter/clang-tools-static-binaries";
-const CLANG_TOOLS_TAG: &str = "master-6e612956";
+const CLANG_TOOLS_TAG: &str = env!("CLANG_TOOLS_TAG");
 
 /// A downloader that uses statically linked binary distribution files
 /// provided by the cpp-linter team.
@@ -56,25 +56,8 @@ impl Cacher for StaticDistDownloader {}
 
 impl StaticDistDownloader {
     pub fn get_major_version_range() -> RangeInclusive<u8> {
-        let min_clang_tools_version: u8 = option_env!("MIN_CLANG_TOOLS_VERSION")
-            .and_then(|v| match v.parse::<u8>() {
-                Ok(parsed) => Some(parsed),
-                Err(e) => {
-                    log::error!("Invalid MIN_CLANG_TOOLS_VERSION env var value: {v}. Error: {e}");
-                    None
-                }
-            })
-            .unwrap_or(MIN_CLANG_TOOLS_VERSION);
-        let max_clang_tools_version: u8 = option_env!("MAX_CLANG_TOOLS_VERSION")
-            .and_then(|v| match v.parse::<u8>() {
-                Ok(parsed) => Some(parsed),
-                Err(e) => {
-                    log::error!("Invalid MAX_CLANG_TOOLS_VERSION env var value: {v}. Error: {e}");
-                    None
-                }
-            })
-            .unwrap_or(MAX_CLANG_TOOLS_VERSION);
-        min_clang_tools_version..=max_clang_tools_version
+        MIN_CLANG_TOOLS_VERSION.parse().unwrap_or(11)
+            ..=MAX_CLANG_TOOLS_VERSION.parse().unwrap_or(22)
     }
 
     /// Finds a suitable version from `req_ver` within the range of available clang tools versions.
@@ -83,6 +66,7 @@ impl StaticDistDownloader {
     /// `MAX_CLANG_TOOLS_VERSION` environment variables (inclusive) at compile time.
     fn find_suitable_version(req_ver: &VersionReq) -> Option<Version> {
         let clang_tools_versions: RangeInclusive<u8> = Self::get_major_version_range();
+        println!("Available clang tools versions: {clang_tools_versions:?}");
         let outlier = Version::new(12, 0, 1);
         for ver in clang_tools_versions
             .map(|v| Version::new(v as u64, 0, 0))