Fix Tailwind prettier parity (#145)

* Fix Tailwind comparison parity

Recognize parenthesized ring colors and order typed container-query breakpoints by direction and size. Treat nonconvergent Prettier output separately so it cannot create false ordering mismatches.

* Order arbitrary container queries

Treat arbitrary query lengths as container breakpoints so minimum and maximum variants follow Tailwind's resolved size ordering.

* Parse comparison attributes from syntax

Use the pinned TSX, Svelte, and Astro parsers so corpus ranking and comparison ignore class-like text in comments and strings.

* Parse typed ring custom properties

Keep colons inside balanced parenthesized utility values so typed ring custom properties remain one class segment. Map length hints to ring width properties while preserving Tailwind's color behavior for untyped values.

Author: praveenperera

rustywind-core/src/class_name.rs

@@ -0,0 +1,114 @@
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct ClassSegments<'a> {
+    parts: Vec<&'a str>,
+    utility_start: usize,
+}
+
+impl<'a> ClassSegments<'a> {
+    pub(crate) fn parse(class: &'a str) -> Option<Self> {
+        if class.is_empty() {
+            return None;
+        }
+
+        let mut parts = Vec::new();
+        let mut start = 0;
+        let mut delimiters = Vec::new();
+        let mut quote = None;
+        let mut escaped = false;
+
+        for (index, character) in class.char_indices() {
+            if escaped {
+                escaped = false;
+                continue;
+            }
+
+            if character == '\\' {
+                escaped = true;
+                continue;
+            }
+
+            if let Some(active_quote) = quote {
+                if character == active_quote {
+                    quote = None;
+                }
+                continue;
+            }
+
+            if !delimiters.is_empty() && matches!(character, '\'' | '"' | '`') {
+                quote = Some(character);
+                continue;
+            }
+
+            match character {
+                '[' => delimiters.push(']'),
+                '(' => delimiters.push(')'),
+                ']' | ')' if delimiters.pop() != Some(character) => return None,
+                ':' if delimiters.is_empty() => {
+                    if start == index {
+                        return None;
+                    }
+                    parts.push(&class[start..index]);
+                    start = index + character.len_utf8();
+                }
+                _ => {}
+            }
+        }
+
+        if escaped || quote.is_some() || !delimiters.is_empty() || start == class.len() {
+            return None;
+        }
+
+        let utility_start = start;
+        parts.push(&class[start..]);
+
+        Some(Self {
+            parts,
+            utility_start,
+        })
+    }
+
+    pub(crate) fn variants(&self) -> &[&'a str] {
+        &self.parts[..self.parts.len() - 1]
+    }
+
+    pub(crate) fn utility(&self) -> &'a str {
+        self.parts[self.parts.len() - 1]
+    }
+
+    pub(crate) fn utility_start(&self) -> usize {
+        self.utility_start
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ClassSegments;
+
+    #[test]
+    fn splits_only_top_level_variant_separators() {
+        let segments =
+            ClassSegments::parse("supports-[selector(:has(*))]:hover:ring-(length:--ring-width)")
+                .unwrap();
+
+        assert_eq!(
+            segments.variants(),
+            &["supports-[selector(:has(*))]", "hover"]
+        );
+        assert_eq!(segments.utility(), "ring-(length:--ring-width)");
+    }
+
+    #[test]
+    fn ignores_delimiters_inside_quoted_arbitrary_values() {
+        let segments = ClassSegments::parse("before:content-[':)']").unwrap();
+
+        assert_eq!(segments.variants(), &["before"]);
+        assert_eq!(segments.utility(), "content-[':)']");
+    }
+
+    #[test]
+    fn rejects_unbalanced_or_empty_segments() {
+        assert!(ClassSegments::parse("hover::flex").is_none());
+        assert!(ClassSegments::parse("hover:ring-(length:--width").is_none());
+        assert!(ClassSegments::parse("hover:ring-length:--width)").is_none());
+    }
+}

rustywind-core/src/class_parser.rs

@@ -28,7 +28,7 @@
 //! assert!(parsed.important);
 //! ```
 
-use crate::utility_map::UTILITY_MAP;
+use crate::{class_name::ClassSegments, utility_map::UTILITY_MAP};
 
 /// A parsed Tailwind CSS class name with all its components.
 ///
@@ -174,24 +174,17 @@ pub fn parse_class(class: &str) -> Option<ParsedClass<'_>> {
         working = &working[..working.len() - 1];
     }
 
-    // split by ':' but respect brackets - ':' inside [] should not be a separator
-    // e.g., "[&>*:last-child]:rounded-b-lg" -> ["[&>*:last-child]", "rounded-b-lg"]
-    let parts = split_respecting_brackets(working);
+    let segments = ClassSegments::parse(working)?;
 
-    if parts.is_empty() {
-        return None;
-    }
-
-    if parts.len() > 1
-        && parts[..parts.len() - 1]
-            .iter()
-            .any(|part| part.starts_with('!'))
+    if segments
+        .variants()
+        .iter()
+        .any(|variant| variant.starts_with('!'))
     {
         return None;
     }
 
-    // last part is the utility (with value)
-    let mut utility_part = parts[parts.len() - 1];
+    let mut utility_part = segments.utility();
     if let Some(stripped) = utility_part.strip_prefix('!') {
         important = true;
         utility_part = stripped;
@@ -200,11 +193,7 @@ pub fn parse_class(class: &str) -> Option<ParsedClass<'_>> {
     // everything before is variants
     // Tailwind parses variants RIGHT-TO-LEFT, so we need to reverse them
     // for dark:hover:utility, Tailwind stores [hover, dark], not [dark, hover]
-    let mut variants = if parts.len() > 1 {
-        parts[..parts.len() - 1].to_vec()
-    } else {
-        vec![]
-    };
+    let mut variants = segments.variants().to_vec();
     variants.reverse(); // Match Tailwind's right-to-left parsing order
 
     // parse utility into base + value
@@ -219,38 +208,6 @@ pub fn parse_class(class: &str) -> Option<ParsedClass<'_>> {
     })
 }
 
-/// Split a class string by ':' while respecting bracket nesting.
-/// Colons inside square brackets `[]` are NOT treated as separators.
-///
-/// # Examples
-/// - `"hover:p-4"` -> `["hover", "p-4"]`
-/// - `"[&>*:last-child]:rounded-b-lg"` -> `["[&>*:last-child]", "rounded-b-lg"]`
-/// - `"dark:[&.active]:bg-red-500"` -> `["dark", "[&.active]", "bg-red-500"]`
-fn split_respecting_brackets(s: &str) -> Vec<&str> {
-    let mut parts = Vec::new();
-    let mut start = 0;
-    let mut bracket_depth: u32 = 0;
-
-    for (i, c) in s.char_indices() {
-        match c {
-            '[' => bracket_depth += 1,
-            ']' => bracket_depth = bracket_depth.saturating_sub(1),
-            ':' if bracket_depth == 0 => {
-                parts.push(&s[start..i]);
-                start = i + 1;
-            }
-            _ => {}
-        }
-    }
-
-    // don't forget the last part
-    if start < s.len() {
-        parts.push(&s[start..]);
-    }
-
-    parts
-}
-
 /// Parse a utility string into base and value parts.
 ///
 /// This reuses the logic from utility_map but is adapted for class parsing.
@@ -539,6 +496,15 @@ mod tests {
         assert_eq!(parsed.value, "[100px]");
     }
 
+    #[test]
+    fn test_parse_typed_parenthesized_value() {
+        let parsed = parse_class("hover:ring-(length:--ring-width)").unwrap();
+
+        assert_eq!(parsed.variants, vec!["hover"]);
+        assert_eq!(parsed.utility, "ring");
+        assert_eq!(parsed.value, "(length:--ring-width)");
+    }
+
     #[test]
     fn test_parse_multi_part_utility() {
         let parsed = parse_class("min-w-0").unwrap();

rustywind-core/src/lib.rs

@@ -3,6 +3,7 @@
 //! Use [`RustyWind::sort_document`] with a [`SourceDocument`] so RustyWind can
 //! distinguish static class text from embedded template code
 pub mod app;
+mod class_name;
 pub mod class_wrapping;
 pub mod consts;
 pub mod defaults;

rustywind-core/src/pattern_sorter.rs

@@ -28,6 +28,7 @@
 
 use std::cmp::Ordering;
 
+use crate::class_name::ClassSegments;
 use crate::class_parser::parse_class;
 use crate::property_order::get_property_index;
 use crate::tailwind_prefix::{normalize_tailwind_prefix, normalize_tailwind_prefix_value};
@@ -327,19 +328,7 @@ fn compare_alphanumeric(a: &str, z: &str) -> Ordering {
 }
 
 fn utility_part(class: &str) -> &str {
-    let mut start = 0;
-    let mut bracket_depth: u32 = 0;
-
-    for (index, character) in class.char_indices() {
-        match character {
-            '[' => bracket_depth += 1,
-            ']' => bracket_depth = bracket_depth.saturating_sub(1),
-            ':' if bracket_depth == 0 => start = index + 1,
-            _ => {}
-        }
-    }
-
-    let utility = &class[start..];
+    let utility = ClassSegments::parse(class).map_or(class, |segments| segments.utility());
     let utility = utility.strip_prefix('!').unwrap_or(utility);
     utility.strip_suffix('!').unwrap_or(utility)
 }

rustywind-core/src/tailwind_prefix.rs

@@ -1,5 +1,7 @@
 use std::borrow::Cow;
 
+use crate::class_name::ClassSegments;
+
 /// Normalize a Tailwind-prefixed class into the class name used for sorting.
 ///
 /// Tailwind v3 places the prefix on the utility (`md:tw-text-lg`), while v4
@@ -19,7 +21,10 @@ pub fn normalize_tailwind_prefix<'a>(class: &'a str, prefix: Option<&str>) -> Co
         return Cow::Borrowed(rest);
     }
 
-    let utility_start = utility_start(class);
+    let Some(utility_start) = ClassSegments::parse(class).map(|segments| segments.utility_start())
+    else {
+        return Cow::Borrowed(class);
+    };
     let (variants, utility) = class.split_at(utility_start);
 
     match normalize_v3_utility(utility, prefix) {
@@ -34,22 +39,6 @@ pub(crate) fn normalize_tailwind_prefix_value(prefix: &str) -> Option<&str> {
     (!prefix.is_empty()).then_some(prefix)
 }
 
-fn utility_start(class: &str) -> usize {
-    let mut start = 0;
-    let mut bracket_depth: u32 = 0;
-
-    for (index, character) in class.char_indices() {
-        match character {
-            '[' => bracket_depth += 1,
-            ']' => bracket_depth = bracket_depth.saturating_sub(1),
-            ':' if bracket_depth == 0 => start = index + 1,
-            _ => {}
-        }
-    }
-
-    start
-}
-
 fn normalize_v3_utility<'a>(utility: &'a str, prefix: &str) -> Option<Cow<'a, str>> {
     let (important, utility) = utility
         .strip_prefix('!')
@@ -146,6 +135,14 @@ mod tests {
         );
     }
 
+    #[test]
+    fn ignores_colons_inside_parenthesized_utility_values() {
+        assert_eq!(
+            normalize_tailwind_prefix("hover:tw-ring-(length:--ring-width)", Some("tw")),
+            "hover:ring-(length:--ring-width)"
+        );
+    }
+
     #[test]
     fn leaves_unprefixed_classes_unchanged() {
         assert_eq!(