feat: do not use system package managers by default

resolves #364

Actually, the default depends on the state of a CI env var.

- if CI env var is present and its value is one of "true", "on", or "1", then system package managers are used by default.
- if CI is not present (or its value is not "true", "on", or "1"), then the new `--mod-sys` switch can allow explicit opt-in to use system package managers.

Author: 2bndy5

clang-tools-manager/Cargo.toml

@@ -21,7 +21,7 @@ required-features = ["bin"]
 [dependencies]
 anyhow = { workspace = true, optional = true }
 blake2 = "0.10.6"
-clap = { workspace = true, features = ["derive"], optional = true }
+clap = { workspace = true, features = ["derive", "env"], optional = true }
 colored = { workspace = true, optional = true }
 directories = "6.0.0"
 log = { workspace = true }

clang-tools-manager/src/main.rs

@@ -138,6 +138,19 @@ pub struct CliOptions {
     /// This will only overwrite an existing symlink.
     #[arg(short, long)]
     pub force: bool,
+
+    /// Whether to use the system's available package managers.
+    /// 
+    /// This matches the value of a CI environment variable.
+    /// For non-CI contexts, this allows users to opt-in to using
+    /// system package managers as a fallback in case PyPI offerings
+    /// are unsatisfactory.
+    /// 
+    /// If system package managers are not allowed or fail, then
+    /// static binaries built by cpp-linter are sought (for
+    /// compatible platforms).
+    #[arg(long, action = clap::ArgAction::SetTrue, env = "CI")]
+    pub mod_sys: bool,
 }
 
 #[tokio::main]
@@ -161,7 +174,7 @@ async fn main() -> Result<()> {
             let mut map_tools = HashMap::new();
             for t in tool {
                 if let Some(version) = req_ver
-                    .eval_tool(&t, options.force, options.directory.as_ref())
+                    .eval_tool(&t, options.force, options.directory.as_ref(), options.mod_sys)
                     .await?
                 {
                     map_tools.entry(t).or_insert(version);

clang-tools-manager/src/version.rs

@@ -78,6 +78,7 @@ impl RequestedVersion {
         tool: &ClangTool,
         overwrite_symlink: bool,
         directory: Option<&PathBuf>,
+        allow_system_package_manager: bool,
     ) -> Result<Option<ClangVersion>, GetToolError> {
         match self {
             RequestedVersion::Path(_) => {
@@ -139,8 +140,9 @@ impl RequestedVersion {
                     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).await?
+                        if allow_system_package_manager
+                            && let Some(result) =
+                                try_install_package(tool, version_req, &min_ver).await?
                         {
                             return Ok(Some(result));
                         }
@@ -245,7 +247,7 @@ impl FromStr for RequestedVersion {
 
 #[cfg(test)]
 mod tests {
-    use std::{path::PathBuf, str::FromStr};
+    use std::{env, path::PathBuf, str::FromStr};
 
     use semver::VersionReq;
     use tempfile::TempDir;
@@ -281,7 +283,7 @@ mod tests {
     #[tokio::test]
     async fn eval_no_value() {
         let result = RequestedVersion::NoValue
-            .eval_tool(&ClangTool::ClangFormat, false, None)
+            .eval_tool(&ClangTool::ClangFormat, false, None, false)
             .await
             .unwrap();
         assert!(result.is_none());
@@ -301,14 +303,19 @@ mod tests {
         let version_req =
             VersionReq::parse(option_env!("MIN_CLANG_TOOLS_VERSION").unwrap_or("16")).unwrap();
         let downloaded_clang = RequestedVersion::Requirement(version_req.clone())
-            .eval_tool(&tool, false, Some(&PathBuf::from(tmp_cache_dir.path())))
+            .eval_tool(
+                &tool,
+                false,
+                Some(&PathBuf::from(tmp_cache_dir.path())),
+                false,
+            )
             .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, None)
+            .eval_tool(&tool, false, None, false)
             .await
             .unwrap()
             .unwrap();
@@ -331,7 +338,13 @@ mod tests {
             let version_req = VersionReq::parse(clang_version).unwrap();
             println!("Installing {tool} with version requirement: {version_req}");
             let clang_path = RequestedVersion::Requirement(version_req.clone())
-                .eval_tool(&tool, false, None)
+                .eval_tool(
+                    &tool,
+                    false,
+                    None,
+                    env::var("CI")
+                        .is_ok_and(|v| ["true", "on", "1"].contains(&v.to_lowercase().as_str())),
+                )
                 .await
                 .unwrap()
                 .unwrap();

cpp-linter/src/clang_tools/mod.rs

@@ -2,7 +2,7 @@
 //! clang-tidy.
 
 use std::{
-    fs,
+    env, fs,
     path::PathBuf,
     sync::{Arc, Mutex},
 };
@@ -105,10 +105,12 @@ pub async fn capture_clang_tools_output(
     let mut clang_versions = ClangVersions::default();
     // find the executable paths for clang-tidy and/or clang-format and show version
     // info as debugging output.
+    let in_ci =
+        env::var("CI").is_ok_and(|v| ["true", "on", "1"].contains(&v.to_lowercase().as_str()));
     if clang_params.tidy_checks != "-*" {
         let tool = ClangTool::ClangTidy;
         let tool_info = version
-            .eval_tool(&tool, false, None)
+            .eval_tool(&tool, false, None, in_ci)
             .await?
             .ok_or(ClangTaskError::FindToolError(tool.as_str()))?;
         log::info!(
@@ -123,7 +125,7 @@ pub async fn capture_clang_tools_output(
     if !clang_params.style.is_empty() {
         let tool = ClangTool::ClangFormat;
         let tool_info = version
-            .eval_tool(&tool, false, None)
+            .eval_tool(&tool, false, None, in_ci)
             .await?
             .ok_or(ClangTaskError::FindToolError(tool.as_str()))?;
         log::info!(