Fix Ruby files causing the CLI to hang (#17383)

Fixes #17379

The preprocessor we added to detect embedded languages uses a back
reference and given a long enough file with certain byte / character
patterns it'll cause what appears to be an indefinite hang (might just
be catastrophically exponential backtracking but not sure)

This replaces the one regex w/ back references with two, anchored,
multi-line regexes

Now we search for all the starting & ending delimiters in the file. We
then loop over all the starting delimiters, find the paired ending one,
and preprocess the content inside

---------

Co-authored-by: Philipp Spiess <hello@philippspiess.com>

Author: thecrypticace

CHANGELOG.md

@@ -21,6 +21,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - _Experimental_: Add `@source inline(…)` ([#17147](https://github.com/tailwindlabs/tailwindcss/pull/17147))
 - _Experimental_: Add `@source not` ([#17255](https://github.com/tailwindlabs/tailwindcss/pull/17255))
 
+### Fixed
+
+- Fix an issue causing the CLI to hang when processing Ruby files ([#17383](https://github.com/tailwindlabs/tailwindcss/pull/17383))
+
 ## [4.0.16] - 2025-03-25
 
 ### Added

Cargo.lock

@@ -19,8 +19,6 @@ fast-glob = "0.4.3"
 classification-macros = { path = "../classification-macros" }
 ignore = { path = "../ignore" }
 regex = "1.11.1"
-fancy-regex = "0.14.0"
 
 [dev-dependencies]
 tempfile = "3.13.0"
-

crates/oxide/Cargo.toml

@@ -4,12 +4,22 @@ use crate::cursor;
 use crate::extractor::bracket_stack;
 use crate::extractor::pre_processors::pre_processor::PreProcessor;
 use crate::scanner::pre_process_input;
-use bstr::ByteSlice;
-use fancy_regex::Regex;
+use bstr::ByteVec;
+use regex::{Regex, RegexBuilder};
 use std::sync;
 
-static TEMPLATE_REGEX: sync::LazyLock<Regex> = sync::LazyLock::new(|| {
-    Regex::new(r#"\s*(.*?)_template\s*<<[-~]?([A-Z]+?)\n([\s\S]*?)\2"#).unwrap()
+static TEMPLATE_START_REGEX: sync::LazyLock<Regex> = sync::LazyLock::new(|| {
+    RegexBuilder::new(r#"\s*([a-z0-9_-]+)_template\s*<<[-~]?([A-Z]+)$"#)
+      .multi_line(true)
+      .build()
+      .unwrap()
+});
+
+static TEMPLATE_END_REGEX: sync::LazyLock<Regex> = sync::LazyLock::new(|| {
+  RegexBuilder::new(r#"^\s*([A-Z]+)"#)
+    .multi_line(true)
+    .build()
+    .unwrap()
 });
 
 #[derive(Debug, Default)]
@@ -25,14 +35,40 @@ impl PreProcessor for Ruby {
         // Extract embedded template languages
         // https://viewcomponent.org/guide/templates.html#interpolations
         let content_as_str = std::str::from_utf8(content).unwrap();
-        for capture in TEMPLATE_REGEX
-            .captures_iter(content_as_str)
-            .filter_map(Result::ok)
-        {
-            let lang = capture.get(1).unwrap().as_str();
-            let body = capture.get(3).unwrap().as_str();
-            let replaced = pre_process_input(body.as_bytes(), lang);
-            result = result.replace(body, replaced);
+
+        let starts = TEMPLATE_START_REGEX.captures_iter(content_as_str).collect::<Vec<_>>();
+        let ends = TEMPLATE_END_REGEX.captures_iter(content_as_str).collect::<Vec<_>>();
+
+        for start in starts.iter() {
+          // The language for this block
+          let lang = start.get(1).unwrap().as_str();
+
+          // The HEREDOC delimiter
+          let delimiter_start = start.get(2).unwrap().as_str();
+
+          // Where the "body" starts for the HEREDOC block
+          let body_start = start.get(0).unwrap().end();
+
+          // Look through all of the ends to find a matching language
+          for end in ends.iter() {
+            // 1. This must appear after the start
+            let body_end = end.get(0).unwrap().start();
+            if body_end < body_start {
+              continue;
+            }
+
+            // The languages must match otherwise we haven't found the end
+            let delimiter_end = end.get(1).unwrap().as_str();
+            if delimiter_end != delimiter_start {
+              continue;
+            }
+
+            let body = &content_as_str[body_start..body_end];
+            let replaced = pre_process_input(body.as_bytes(), &lang.to_ascii_lowercase());
+
+            result.replace_range(body_start..body_end, replaced);
+            break;
+          }
         }
 
         // Ruby extraction