Use lazy_regex for compile time regex checking (#996)

Author: j178

Cargo.lock

@@ -57,6 +57,7 @@ ignore = { version = "0.4.23" }
 indicatif = { version = "0.18.0" }
 indoc = { version = "2.0.5" }
 itertools = { version = "0.14.0" }
+lazy-regex = { version = "3.4.2" }
 levenshtein = { version = "1.0.5" }
 # Enable static linking for liblzma
 # This is required for the `xz` feature in `async-compression`

Cargo.toml

@@ -5,9 +5,9 @@ use std::process::Stdio;
 use anyhow::{Context, Result};
 use bstr::ByteSlice;
 use constants::MANIFEST_FILE;
-use fancy_regex::Regex;
 use futures::StreamExt;
 use itertools::Itertools;
+use lazy_regex::regex;
 use owo_colors::OwoColorize;
 use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
@@ -350,14 +350,13 @@ async fn write_new_config(path: &Path, revisions: &[Option<Revision>]) -> Result
         .map(ToString::to_string)
         .collect::<Vec<_>>();
 
-    let rev_regex = Regex::new(r#"^(\s+)rev:(\s*)(['"]?)([^\s#]+)(.*)(\r?\n)$"#)
-        .expect("Failed to compile regex");
+    let rev_regex = regex!(r#"^(\s+)rev:(\s*)(['"]?)([^\s#]+)(.*)(\r?\n)$"#);
 
     let rev_lines = lines
         .iter()
         .enumerate()
         .filter_map(|(line_no, line)| {
-            if let Ok(true) = rev_regex.is_match(line) {
+            if rev_regex.is_match(line) {
                 Some(line_no)
             } else {
                 None
@@ -394,8 +393,7 @@ async fn write_new_config(path: &Path, revisions: &[Option<Revision>]) -> Result
 
         let caps = rev_regex
             .captures(&lines[*line_no])
-            .expect("Invalid regex")
-            .expect("Failed to capture revision line");
+            .context("Failed to capture rev line")?;
 
         let comment = if let Some(frozen) = &revision.frozen {
             format!("  # frozen: {frozen}")

src/cli/auto_update.rs

@@ -2,11 +2,11 @@ use std::fmt::Display;
 use std::ops::{Deref, RangeInclusive};
 use std::path::Path;
 use std::str::FromStr;
-use std::sync::OnceLock;
 
 use anyhow::Result;
 use constants::{ALT_CONFIG_FILE, CONFIG_FILE};
-use fancy_regex::{self as regex, Regex};
+use fancy_regex::Regex;
+use lazy_regex::regex;
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_yaml::Value;
@@ -524,8 +524,8 @@ impl<'de> Deserialize<'de> for MetaHook {
                     files: Some(
                         Regex::new(&format!(
                             "^{}|{}$",
-                            regex::escape(CONFIG_FILE),
-                            regex::escape(ALT_CONFIG_FILE)
+                            fancy_regex::escape(CONFIG_FILE),
+                            fancy_regex::escape(ALT_CONFIG_FILE)
                         ))
                         .map(SerdeRegex)
                         .unwrap(),
@@ -542,8 +542,8 @@ impl<'de> Deserialize<'de> for MetaHook {
                     files: Some(
                         Regex::new(&format!(
                             "^{}|{}$",
-                            regex::escape(CONFIG_FILE),
-                            regex::escape(ALT_CONFIG_FILE)
+                            fancy_regex::escape(CONFIG_FILE),
+                            fancy_regex::escape(ALT_CONFIG_FILE)
                         ))
                         .map(SerdeRegex)
                         .unwrap(),
@@ -812,9 +812,7 @@ pub fn read_manifest(path: &Path) -> Result<Manifest, Error> {
 
 /// Check if a string looks like a git SHA
 fn looks_like_sha(s: &str) -> bool {
-    static SHA_RE: OnceLock<Regex> = OnceLock::new();
-    let re = SHA_RE.get_or_init(|| Regex::new(r"^[a-fA-F0-9]+$").unwrap());
-    re.is_match(s).unwrap_or(false)
+    regex!(r"^[a-fA-F0-9]+$").is_match(s)
 }
 
 /// Deserializes a vector of strings and validates that each is a known file type tag.

src/config.rs

@@ -6,7 +6,7 @@ use std::path::Path;
 use std::sync::{Arc, LazyLock};
 
 use anyhow::{Context, Result};
-use fancy_regex::Regex;
+use lazy_regex::regex;
 use tracing::trace;
 
 use crate::cli::reporter::HookInstallReporter;
@@ -121,9 +121,9 @@ impl Docker {
     /// <https://stackoverflow.com/questions/20995351/how-can-i-get-docker-linux-container-information-from-within-the-container-itsel>
     fn current_container_id() -> Result<String> {
         // Adapted from https://github.com/open-telemetry/opentelemetry-java-instrumentation/pull/7167/files
-        let regex = Regex::new(r".*/docker/containers/([0-9a-f]{64})/.*").expect("invalid regex");
+        let regex = regex!(r".*/docker/containers/([0-9a-f]{64})/.*");
         let cgroup_path = fs::read_to_string("/proc/self/cgroup")?;
-        let Some(captures) = regex.captures(&cgroup_path)? else {
+        let Some(captures) = regex.captures(&cgroup_path) else {
             anyhow::bail!("Failed to get container id: no match found");
         };
         let Some(id) = captures.get(1).map(|m| m.as_str().to_string()) else {

src/languages/docker.rs

@@ -0,0 +1,7 @@
+use anyhow::Result;
+
+use crate::hook::Hook;
+
+pub(crate) async fn extract_go_mod_metadata(_hook: &mut Hook) -> Result<()> {
+    Ok(())
+}

src/languages/golang/gomod.rs

@@ -1,7 +1,9 @@
 #[allow(clippy::module_inception)]
 mod golang;
+mod gomod;
 mod installer;
 mod version;
 
 pub(crate) use golang::Golang;
+pub(crate) use gomod::extract_go_mod_metadata;
 pub(crate) use version::GoRequest;

src/languages/golang/mod.rs

@@ -49,7 +49,9 @@ trait LanguageImpl {
         store: &Store,
         reporter: &HookInstallReporter,
     ) -> Result<InstalledHook>;
+
     async fn check_health(&self, info: &InstallInfo) -> Result<()>;
+
     async fn run(
         &self,
         hook: &InstalledHook,
@@ -227,40 +229,35 @@ impl Language {
 }
 
 /// Try to extract metadata from the given hook entry if possible.
-///
-/// Currently, only PEP 723 inline metadata for `python` hooks is supported.
-/// First part of `entry` must be a file path to the Python script.
-/// Effectively, we are implementing a new `python-script` language which works like `script`.
-/// But we don't want to introduce a new language just for this for now.
 pub(crate) async fn extract_metadata_from_entry(hook: &mut Hook) -> Result<()> {
-    // Only support `python` hooks for now.
-    if hook.language == Language::Python {
-        return python::extract_pep723_metadata(hook).await;
+    match hook.language {
+        Language::Python => python::extract_pep723_metadata(hook).await,
+        Language::Golang => golang::extract_go_mod_metadata(hook).await,
+        _ => Ok(()),
     }
-
-    Ok(())
 }
 
-pub(crate) fn resolve_command(mut cmds: Vec<String>, env_path: Option<&OsStr>) -> Vec<String> {
-    let cmd = &cmds[0];
-    let exe_path = match which::which_in(cmd, env_path, &*CWD) {
+/// Resolve the actual process invocation, honoring shebangs and PATH lookups.
+pub(crate) fn resolve_command(mut cmds: Vec<String>, paths: Option<&OsStr>) -> Vec<String> {
+    let candidate = &cmds[0];
+    let resolved_binary = match which::which_in(candidate, paths, &*CWD) {
         Ok(p) => p,
-        Err(_) => PathBuf::from(cmd),
+        Err(_) => PathBuf::from(candidate),
     };
-    trace!("Resolved command: {}", exe_path.display());
+    trace!("Resolved command: {}", resolved_binary.display());
 
-    if let Ok(mut interpreter) = parse_shebang(&exe_path) {
-        trace!("Found shebang: {:?}", interpreter);
+    if let Ok(mut shebang_argv) = parse_shebang(&resolved_binary) {
+        trace!("Found shebang: {:?}", shebang_argv);
         // Resolve the interpreter path, convert "python3" to "python3.exe" on Windows
-        if let Ok(p) = which::which_in(&interpreter[0], env_path, &*CWD) {
-            interpreter[0] = p.to_string_lossy().to_string();
-            trace!("Resolved interpreter: {}", &interpreter[0]);
+        if let Ok(p) = which::which_in(&shebang_argv[0], paths, &*CWD) {
+            shebang_argv[0] = p.to_string_lossy().to_string();
+            trace!("Resolved interpreter: {}", &shebang_argv[0]);
         }
-        interpreter.push(exe_path.to_string_lossy().to_string());
-        interpreter.extend_from_slice(&cmds[1..]);
-        interpreter
+        shebang_argv.push(resolved_binary.to_string_lossy().to_string());
+        shebang_argv.extend_from_slice(&cmds[1..]);
+        shebang_argv
     } else {
-        cmds[0] = exe_path.to_string_lossy().to_string();
+        cmds[0] = resolved_binary.to_string_lossy().to_string();
         cmds
     }
 }

src/languages/mod.rs

@@ -251,6 +251,10 @@ impl ScriptTag {
     }
 }
 
+/// Extract PEP 723 inline metadata for `python` hooks.
+/// First part of `entry` must be a file path to the Python script.
+/// Effectively, we are implementing a new `python-script` language which works like `script`.
+/// But we don't want to introduce a new language just for this for now.
 pub(crate) async fn extract_pep723_metadata(hook: &mut Hook) -> Result<()> {
     if !hook.additional_dependencies.is_empty() {
         trace!(