Fix HAML extraction with embedded Ruby (#17846)

This PR fixes and improves the HAML extractor by ensuring that whenever
we detect lines or blocks of Ruby code (`-`, `=` and `~`) characters at
the beginning of the line, we treat them as Ruby code.

Fixes: #17813

## Test Plan

1. Existing tests pass
2. Changed 1 existing test which embedded Ruby syntax
3. Added a dedicated test to ensure the HAML file in the linked issue is
parsed correctly

Running this in the internal extractor tool you can see that the
`w-[12px]`, `w-[16px]`, `h-[12px]`, and `h-[16px]` are properly
extracted.

Note: the `mr-12px` is also extracted, but not highlighted because this
is not a valid Tailwind CSS class.

<img width="1816" alt="image"
src="https://github.com/user-attachments/assets/fc5929ca-bc71-47d2-b21b-7abeec86f54d"
/>

Author: RobinMalfait

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - Ensure negative arbitrary `scale` values generate negative values ([#17831](https://github.com/tailwindlabs/tailwindcss/pull/17831))
+- Fix HAML extraction with embedded Ruby ([#17846](https://github.com/tailwindlabs/tailwindcss/pull/17846))
 
 ## [4.1.5] - 2025-04-30
 

Cargo.lock

@@ -23,3 +23,4 @@ regex = "1.11.1"
 [dev-dependencies]
 tempfile = "3.13.0"
 pretty_assertions = "1.4.1"
+unicode-width = "0.2.0"

crates/oxide/Cargo.toml

@@ -3,6 +3,8 @@ use crate::extractor::bracket_stack::BracketStack;
 use crate::extractor::machine::{Machine, MachineState};
 use crate::extractor::pre_processors::pre_processor::PreProcessor;
 use crate::extractor::variant_machine::VariantMachine;
+use crate::scanner::pre_process_input;
+use bstr::ByteVec;
 
 #[derive(Debug, Default)]
 pub struct Haml;
@@ -14,8 +16,153 @@ impl PreProcessor for Haml {
         let mut cursor = cursor::Cursor::new(content);
         let mut bracket_stack = BracketStack::default();
 
+        // Haml Comments: -#
+        // https://haml.info/docs/yardoc/file.REFERENCE.html#ruby-evaluation
+        //
+        // > The hyphen followed immediately by the pound sign signifies a silent comment. Any text
+        // > following this isn’t rendered in the resulting document at all.
+        //
+        // ```haml
+        // %p foo
+        // -# This is a comment
+        // %p bar
+        // ```
+        //
+        // > You can also nest text beneath a silent comment. None of this text will be rendered.
+        //
+        // ```haml
+        // %p foo
+        // -#
+        //   This won't be displayed
+        //     Nor will this
+        //                    Nor will this.
+        // %p bar
+        // ```
+        //
+        // Ruby Evaluation
+        // https://haml.info/docs/yardoc/file.REFERENCE.html#ruby-evaluation
+        //
+        // When any of the following characters are the first non-whitespace character on the line,
+        // then the line is treated as Ruby code:
+        //
+        // - Inserting Ruby: =
+        //   https://haml.info/docs/yardoc/file.REFERENCE.html#inserting_ruby
+        //
+        //   ```haml
+        //   %p
+        //     = ['hi', 'there', 'reader!'].join " "
+        //     = "yo"
+        //   ```
+        //
+        // - Running Ruby: -
+        //   https://haml.info/docs/yardoc/file.REFERENCE.html#running-ruby--
+        //
+        //   ```haml
+        //   - foo = "hello"
+        //   - foo << " there"
+        //   - foo << " you!"
+        //   %p= foo
+        //   ```
+        //
+        // - Whitespace Preservation: ~
+        //   https://haml.info/docs/yardoc/file.REFERENCE.html#tilde
+        //
+        //   > ~ works just like =, except that it runs Haml::Helpers.preserve on its input.
+        //
+        //   ```haml
+        //   ~ "Foo\n<pre>Bar\nBaz</pre>"
+        //   ```
+        //
+        // Important note:
+        //
+        // > A line of Ruby code can be stretched over multiple lines as long as each line but the
+        // > last ends with a comma.
+        //
+        // ```haml
+        // - links = {:home => "/",
+        //   :docs => "/docs",
+        //   :about => "/about"}
+        // ```
+        //
+        // Ruby Blocks:
+        // https://haml.info/docs/yardoc/file.REFERENCE.html#ruby-blocks
+        //
+        // > Ruby blocks, like XHTML tags, don’t need to be explicitly closed in Haml. Rather,
+        // > they’re automatically closed, based on indentation. A block begins whenever the
+        // > indentation is increased after a Ruby evaluation command. It ends when the indentation
+        // > decreases (as long as it’s not an else clause or something similar).
+        //
+        // ```haml
+        // - (42...47).each do |i|
+        //   %p= i
+        // %p See, I can count!
+        // ```
+        //
+        let mut last_newline_position = 0;
+
         while cursor.pos < len {
             match cursor.curr {
+                // Escape the next character
+                b'\\' => {
+                    cursor.advance_twice();
+                    continue;
+                }
+
+                // Track the last newline position
+                b'\n' => {
+                    last_newline_position = cursor.pos;
+                    cursor.advance();
+                    continue;
+                }
+
+                // Skip HAML comments. `-#`
+                b'-' if cursor.input[last_newline_position..cursor.pos]
+                    .iter()
+                    .all(u8::is_ascii_whitespace)
+                    && matches!(cursor.next, b'#') =>
+                {
+                    // Just consume the comment
+                    let updated_last_newline_position =
+                        self.skip_indented_block(&mut cursor, last_newline_position);
+
+                    // Override the last known newline position
+                    last_newline_position = updated_last_newline_position;
+                }
+
+                // Skip HTML comments. `/`
+                b'/' if cursor.input[last_newline_position..cursor.pos]
+                    .iter()
+                    .all(u8::is_ascii_whitespace) =>
+                {
+                    // Just consume the comment
+                    let updated_last_newline_position =
+                        self.skip_indented_block(&mut cursor, last_newline_position);
+
+                    // Override the last known newline position
+                    last_newline_position = updated_last_newline_position;
+                }
+
+                // Ruby evaluation
+                b'-' | b'=' | b'~'
+                    if cursor.input[last_newline_position..cursor.pos]
+                        .iter()
+                        .all(u8::is_ascii_whitespace) =>
+                {
+                    let mut start = cursor.pos;
+                    let end = self.skip_indented_block(&mut cursor, last_newline_position);
+
+                    // Increment start with 1 character to skip the `=` or `-` character
+                    start += 1;
+
+                    let ruby_code = &cursor.input[start..end];
+
+                    // Override the last known newline position
+                    last_newline_position = end;
+
+                    let replaced = pre_process_input(ruby_code, "rb");
+                    result.replace_range(start..end, replaced);
+                }
+
                 // Only replace `.` with a space if it's not surrounded by numbers. E.g.:
                 //
                 // ```diff
@@ -89,6 +236,107 @@ impl PreProcessor for Haml {
     }
 }
 
+impl Haml {
+    fn skip_indented_block(
+        &self,
+        cursor: &mut cursor::Cursor,
+        last_known_newline_position: usize,
+    ) -> usize {
+        let len = cursor.input.len();
+
+        // Special case: if the first character of the block is `=`, then newlines are only allowed
+        // _if_ the last character of the previous line is a comma `,`.
+        //
+        // https://haml.info/docs/yardoc/file.REFERENCE.html#inserting_ruby
+        //
+        // > A line of Ruby code can be stretched over multiple lines as long as each line but the
+        // > last ends with a comma. For example:
+        //
+        // ```haml
+        // = link_to_remote "Add to cart",
+        //     :url => { :action => "add", :id => product.id },
+        //     :update => { :success => "cart", :failure => "error" }
+        // ```
+        let evaluation_type = cursor.curr;
+
+        let block_indentation_level = cursor
+            .pos
+            .saturating_sub(last_known_newline_position)
+            .saturating_sub(1); /* The newline itself */
+
+        let mut last_newline_position = last_known_newline_position;
+
+        // Consume until the end of the line first
+        while cursor.pos < len && cursor.curr != b'\n' {
+            cursor.advance();
+        }
+
+        // Block is already done, aka just a line
+        if evaluation_type == b'=' && cursor.prev != b',' {
+            return cursor.pos;
+        }
+
+        'outer: while cursor.pos < len {
+            match cursor.curr {
+                // Escape the next character
+                b'\\' => {
+                    cursor.advance_twice();
+                    continue;
+                }
+
+                // Track the last newline position
+                b'\n' => {
+                    last_newline_position = cursor.pos;
+
+                    // We are done with this block
+                    if evaluation_type == b'=' && cursor.prev != b',' {
+                        break;
+                    }
+
+                    cursor.advance();
+                    continue;
+                }
+
+                // Skip whitespace and compute the indentation level
+                x if x.is_ascii_whitespace() => {
+                    // Find first non-whitespace character
+                    while cursor.pos < len && cursor.curr.is_ascii_whitespace() {
+                        if cursor.curr == b'\n' {
+                            last_newline_position = cursor.pos;
+
+                            if evaluation_type == b'=' && cursor.prev != b',' {
+                                // We are done with this block
+                                break 'outer;
+                            }
+                        }
+
+                        cursor.advance();
+                    }
+
+                    let indentation = cursor
+                        .pos
+                        .saturating_sub(last_newline_position)
+                        .saturating_sub(1); /* The newline itself */
+                    if indentation < block_indentation_level {
+                        // We are done with this block
+                        break;
+                    }
+                }
+
+                // Not whitespace, end of block
+                _ => break,
+            };
+
+            cursor.advance();
+        }
+
+        // Move the cursor to the last newline position
+        cursor.move_to(last_newline_position);
+
+        last_newline_position
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::Haml;
@@ -173,10 +421,18 @@ mod tests {
 
     // https://github.com/tailwindlabs/tailwindcss/pull/17051#issuecomment-2711181352
     #[test]
-    fn test_haml_full_file() {
-        let processed = Haml.process(include_bytes!("./test-fixtures/haml/src-1.haml"));
-        let actual = std::str::from_utf8(&processed).unwrap();
-        let expected = include_str!("./test-fixtures/haml/dst-1.haml");
+    fn test_haml_full_file_17051() {
+        let actual = Haml::extract_annotated(include_bytes!("./test-fixtures/haml/src-17051.haml"));
+        let expected = include_str!("./test-fixtures/haml/dst-17051.haml");
+
+        assert_eq!(actual, expected);
+    }
+
+    // https://github.com/tailwindlabs/tailwindcss/issues/17813
+    #[test]
+    fn test_haml_full_file_17813() {
+        let actual = Haml::extract_annotated(include_bytes!("./test-fixtures/haml/src-17813.haml"));
+        let expected = include_str!("./test-fixtures/haml/dst-17813.haml");
 
         assert_eq!(actual, expected);
     }