Ruby: Move codeql_threads calculation to library

Author: hmac

ruby/extractor/Cargo.lock

@@ -14,7 +14,6 @@ clap = "3.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3.3", features = ["env-filter"] }
 rayon = "1.5.0"
-num_cpus = "1.14.0"
 regex = "1.7.1"
 encoding = "0.2"
 lazy_static = "1.4.0"

ruby/extractor/Cargo.toml

@@ -1,9 +1,8 @@
 #[macro_use]
 extern crate lazy_static;
-extern crate num_cpus;
 
 use clap::arg;
-use encoding::{self};
+use encoding;
 use rayon::prelude::*;
 use std::borrow::Cow;
 use std::fs;
@@ -13,32 +12,6 @@ use tree_sitter::{Language, Parser, Range};
 
 use codeql_extractor::{diagnostics, extractor, file_paths, node_types, trap};
 
-/**
- * Gets the number of threads the extractor should use, by reading the
- * CODEQL_THREADS environment variable and using it as described in the
- * extractor spec:
- *
- * "If the number is positive, it indicates the number of threads that should
- * be used. If the number is negative or zero, it should be added to the number
- * of cores available on the machine to determine how many threads to use
- * (minimum of 1). If unspecified, should be considered as set to -1."
- */
-fn num_codeql_threads() -> Result<usize, String> {
-    let threads_str = std::env::var("CODEQL_THREADS").unwrap_or_else(|_| "-1".to_owned());
-    match threads_str.parse::<i32>() {
-        Ok(num) if num <= 0 => {
-            let reduction = -num as usize;
-            Ok(std::cmp::max(1, num_cpus::get() - reduction))
-        }
-        Ok(num) => Ok(num as usize),
-
-        Err(_) => Err(format!(
-            "Unable to parse CODEQL_THREADS value '{}'",
-            &threads_str
-        )),
-    }
-}
-
 lazy_static! {
     static ref CP_NUMBER: regex::Regex = regex::Regex::new("cp([0-9]+)").unwrap();
 }
@@ -67,7 +40,7 @@ fn main() -> std::io::Result<()> {
         .init();
     let diagnostics = diagnostics::DiagnosticLoggers::new("ruby");
     let mut main_thread_logger = diagnostics.logger();
-    let num_threads = match num_codeql_threads() {
+    let num_threads = match codeql_extractor::options::num_threads() {
         Ok(num) => num,
         Err(e) => {
             main_thread_logger.write(

ruby/extractor/src/bin/extractor.rs

@@ -15,3 +15,4 @@ lazy_static = "1.4.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 chrono = { version = "0.4.19", features = ["serde"] }
+num_cpus = "1.14.0"

shared/extractor/Cargo.toml

@@ -3,4 +3,5 @@ pub mod extractor;
 pub mod file_paths;
 pub mod generator;
 pub mod node_types;
+pub mod options;
 pub mod trap;

shared/extractor/src/lib.rs

@@ -0,0 +1,44 @@
+use num_cpus;
+
+/// Gets the number of threads the extractor should use.
+/// This is controlled by the CODEQL_THREADS environment variable.
+pub fn num_threads() -> Result<usize, String> {
+    let threads_str = std::env::var("CODEQL_THREADS").unwrap_or_else(|_| "-1".into());
+    let num_cpus = num_cpus::get();
+    parse_codeql_threads(&threads_str, num_cpus)
+        .ok_or_else(|| format!("Unable to parse CODEQL_THREADS value '{}'", &threads_str))
+}
+
+/// Parses the given string to determine the number of threads the extractor
+/// should use, as described in the extractor spec:
+///
+/// "If the number is positive, it indicates the number of threads that should
+/// be used. If the number is negative or zero, it should be added to the number
+/// of cores available on the machine to determine how many threads to use
+/// (minimum of 1). If unspecified, should be considered as set to -1."
+///
+/// # Examples
+///
+/// ```
+/// use codeql_extractor::options::parse_codeql_threads;
+///
+/// assert_eq!(parse_codeql_threads("1", 4), Some(1));
+/// assert_eq!(parse_codeql_threads("5", 4), Some(5));
+/// assert_eq!(parse_codeql_threads("0", 4), Some(4));
+/// assert_eq!(parse_codeql_threads("-1", 4), Some(3));
+/// assert_eq!(parse_codeql_threads("-3", 4), Some(1));
+/// assert_eq!(parse_codeql_threads("-4", 4), Some(1));
+/// assert_eq!(parse_codeql_threads("-5", 4), Some(1));
+/// assert_eq!(parse_codeql_threads("nope", 4), None);
+/// ```
+pub fn parse_codeql_threads(threads_str: &str, num_cpus: usize) -> Option<usize> {
+    match threads_str.parse::<i32>() {
+        Ok(num) if num <= 0 => {
+            let reduction = num.abs_diff(0) as usize;
+            Some(std::cmp::max(1, num_cpus.saturating_sub(reduction)))
+        }
+        Ok(num) => Some(num as usize),
+
+        Err(_) => None,
+    }
+}