cataract 0.1.0

data/ext/cataract/specificity.c

@@ -0,0 +1,213 @@
+/*
+ * specificity.c - CSS selector specificity calculator
+ *
+ * Calculates CSS selector specificity according to W3C spec:
+ * https://www.w3.org/TR/selectors/#specificity
+ *
+ * Specificity = a*100 + b*10 + c*1 where:
+ *   a = count of ID selectors (#id)
+ *   b = count of class selectors (.class), attributes ([attr]), and pseudo-classes (:hover)
+ *   c = count of type selectors (div) and pseudo-elements (::before)
+ *
+ * Special handling:
+ *   - :not() doesn't count itself, but its content does
+ *   - Legacy pseudo-elements with single colon (:before) count as pseudo-elements
+ *   - Universal selector (*) has zero specificity
+ */
+
+#include "cataract.h"
+#include <string.h>
+
+// Calculate specificity for a CSS selector string
+VALUE calculate_specificity(VALUE self, VALUE selector_string) {
+    Check_Type(selector_string, T_STRING);
+
+    const char *p = RSTRING_PTR(selector_string);
+    const char *pe = p + RSTRING_LEN(selector_string);
+
+    // Counters for specificity components
+    int id_count = 0;
+    int class_count = 0;
+    int attr_count = 0;
+    int pseudo_class_count = 0;
+    int pseudo_element_count = 0;
+    int element_count = 0;
+
+    while (p < pe) {
+        char c = *p;
+
+        // Skip whitespace and combinators
+        if (IS_WHITESPACE(c) || c == '>' || c == '+' || c == '~' || c == ',') {
+            p++;
+            continue;
+        }
+
+        // ID selector: #id
+        if (c == '#') {
+            id_count++;
+            p++;
+            // Skip the identifier
+            while (p < pe && ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') ||
+                              (*p >= '0' && *p <= '9') || *p == '-' || *p == '_')) {
+                p++;
+            }
+            continue;
+        }
+
+        // Class selector: .class
+        if (c == '.') {
+            class_count++;
+            p++;
+            // Skip the identifier
+            while (p < pe && ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') ||
+                              (*p >= '0' && *p <= '9') || *p == '-' || *p == '_')) {
+                p++;
+            }
+            continue;
+        }
+
+        // Attribute selector: [attr] or [attr=value]
+        if (c == '[') {
+            attr_count++;
+            p++;
+            // Skip to closing bracket
+            int bracket_depth = 1;
+            while (p < pe && bracket_depth > 0) {
+                if (*p == '[') bracket_depth++;
+                else if (*p == ']') bracket_depth--;
+                p++;
+            }
+            continue;
+        }
+
+        // Pseudo-element (::) or pseudo-class (:)
+        if (c == ':') {
+            p++;
+            int is_pseudo_element = 0;
+
+            // Check for double colon (::)
+            if (p < pe && *p == ':') {
+                is_pseudo_element = 1;
+                p++;
+            }
+
+            // Extract pseudo name
+            const char *pseudo_start = p;
+            while (p < pe && ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') ||
+                              (*p >= '0' && *p <= '9') || *p == '-')) {
+                p++;
+            }
+            long pseudo_len = p - pseudo_start;
+
+            // Check for legacy pseudo-elements (single colon but should be double)
+            // :before, :after, :first-line, :first-letter, :selection
+            int is_legacy_pseudo_element = 0;
+            if (!is_pseudo_element && pseudo_len > 0) {
+                is_legacy_pseudo_element =
+                    (pseudo_len == 6 && strncmp(pseudo_start, "before", 6) == 0) ||
+                    (pseudo_len == 5 && strncmp(pseudo_start, "after", 5) == 0) ||
+                    (pseudo_len == 10 && strncmp(pseudo_start, "first-line", 10) == 0) ||
+                    (pseudo_len == 12 && strncmp(pseudo_start, "first-letter", 12) == 0) ||
+                    (pseudo_len == 9 && strncmp(pseudo_start, "selection", 9) == 0);
+            }
+
+            // Check for :not() - it doesn't count itself, but its content does
+            int is_not = (pseudo_len == 3 && strncmp(pseudo_start, "not", 3) == 0);
+
+            // Skip function arguments if present
+            if (p < pe && *p == '(') {
+                p++;
+                int paren_depth = 1;
+
+                // If it's :not(), we need to calculate specificity of the content
+                if (is_not) {
+                    const char *not_content_start = p;
+
+                    // Find closing paren
+                    while (p < pe && paren_depth > 0) {
+                        if (*p == '(') paren_depth++;
+                        else if (*p == ')') paren_depth--;
+                        if (paren_depth > 0) p++;
+                    }
+
+                    const char *not_content_end = p;
+                    long not_content_len = not_content_end - not_content_start;
+
+                    // Recursively calculate specificity of :not() content
+                    if (not_content_len > 0) {
+                        VALUE not_content = rb_str_new(not_content_start, not_content_len);
+                        VALUE not_spec = calculate_specificity(self, not_content);
+                        int not_specificity = NUM2INT(not_spec);
+
+                        // Add :not() content's specificity to our counts
+                        int additional_a = not_specificity / 100;
+                        int additional_b = (not_specificity % 100) / 10;
+                        int additional_c = not_specificity % 10;
+
+                        id_count += additional_a;
+                        class_count += additional_b;
+                        element_count += additional_c;
+
+                        RB_GC_GUARD(not_content);
+                        RB_GC_GUARD(not_spec);
+                    }
+
+                    p++;  // Skip closing paren
+                } else {
+                    // Skip other function arguments
+                    while (p < pe && paren_depth > 0) {
+                        if (*p == '(') paren_depth++;
+                        else if (*p == ')') paren_depth--;
+                        p++;
+                    }
+
+                    // Count the pseudo-class/element
+                    if (is_pseudo_element || is_legacy_pseudo_element) {
+                        pseudo_element_count++;
+                    } else {
+                        pseudo_class_count++;
+                    }
+                }
+            } else {
+                // No function arguments - count the pseudo-class/element
+                if (is_not) {
+                    // :not without parens is invalid, but don't count it
+                } else if (is_pseudo_element || is_legacy_pseudo_element) {
+                    pseudo_element_count++;
+                } else {
+                    pseudo_class_count++;
+                }
+            }
+            continue;
+        }
+
+        // Universal selector: *
+        if (c == '*') {
+            // Universal selector has specificity 0, don't count
+            p++;
+            continue;
+        }
+
+        // Type selector (element name): div, span, etc.
+        if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')) {
+            element_count++;
+            // Skip the identifier
+            while (p < pe && ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') ||
+                              (*p >= '0' && *p <= '9') || *p == '-' || *p == '_')) {
+                p++;
+            }
+            continue;
+        }
+
+        // Unknown character, skip it
+        p++;
+    }
+
+    // Calculate specificity using W3C formula:
+    // IDs * 100 + (classes + attributes + pseudo-classes) * 10 + (elements + pseudo-elements) * 1
+    int specificity = (id_count * 100) +
+                      ((class_count + attr_count + pseudo_class_count) * 10) +
+                      ((element_count + pseudo_element_count) * 1);
+
+    return INT2NUM(specificity);
+}

data/ext/cataract/value_splitter.c

@@ -0,0 +1,116 @@
+/*
+ * value_splitter.c - CSS value splitting utility
+ *
+ * Purpose: Split CSS declaration values on whitespace while preserving content
+ *          inside functions and quoted strings.
+ *
+ * Examples:
+ *   "1px 2px 3px 4px"              => ["1px", "2px", "3px", "4px"]
+ *   "10px calc(100% - 20px)"       => ["10px", "calc(100% - 20px)"]
+ *   "rgb(255, 0, 0) blue"          => ["rgb(255, 0, 0)", "blue"]
+ *   "'Helvetica Neue', sans-serif" => ["'Helvetica Neue',", "sans-serif"]
+ */
+
+#include "cataract.h"
+
+/*
+ * Split a CSS declaration value on whitespace while preserving content
+ * inside functions and quoted strings.
+ *
+ * Algorithm:
+ *   - Track parenthesis depth for functions like calc(), rgb()
+ *   - Track quote state for strings like 'Helvetica Neue'
+ *   - Split on whitespace only when depth=0 and not in quotes
+ *
+ * @param value [String] Pre-parsed CSS declaration value (assumed well-formed)
+ * @return [Array<String>] Array of value tokens
+ */
+VALUE cataract_split_value(VALUE self, VALUE value) {
+    Check_Type(value, T_STRING);
+    const char *str = RSTRING_PTR(value);
+    long len = RSTRING_LEN(value);
+
+    // Sanity check: reject unreasonably long values (DoS protection)
+    if (len > 65536) {
+        rb_raise(rb_eArgError, "CSS value too long (max 64KB)");
+    }
+
+    // Result array
+    VALUE result = rb_ary_new();
+
+    // State tracking
+    int paren_depth = 0;
+    int in_quotes = 0;
+    char quote_char = '\0';
+    const char *token_start = NULL;
+    const char *p = str;
+    const char *pe = str + len;
+
+    while (p < pe) {
+        char c = *p;
+
+        // Handle quotes
+        if ((c == '"' || c == '\'') && !in_quotes) {
+            // Opening quote
+            in_quotes = 1;
+            quote_char = c;
+            if (token_start == NULL) token_start = p;
+            p++;
+            continue;
+        }
+
+        if (in_quotes && c == quote_char) {
+            // Closing quote
+            in_quotes = 0;
+            p++;
+            continue;
+        }
+
+        // Handle parentheses (only when not in quotes)
+        if (!in_quotes) {
+            if (c == '(') {
+                paren_depth++;
+                if (token_start == NULL) token_start = p;
+                p++;
+                continue;
+            }
+
+            if (c == ')') {
+                paren_depth--;
+                p++;
+                continue;
+            }
+
+            // Handle whitespace (delimiter when depth=0 and not quoted)
+            if (IS_WHITESPACE(c)) {
+                if (paren_depth == 0 && !in_quotes) {
+                    // Emit token if we have one
+                    if (token_start != NULL) {
+                        size_t token_len = p - token_start;
+                        VALUE token = rb_str_new(token_start, token_len);
+                        rb_ary_push(result, token);
+                        token_start = NULL;
+                    }
+                    p++;
+                    continue;
+                }
+                // else: whitespace inside function/quotes, part of token
+            }
+        }
+
+        // Regular character - mark start if needed
+        if (token_start == NULL) {
+            token_start = p;
+        }
+        p++;
+    }
+
+    // Emit final token if any
+    if (token_start != NULL) {
+        size_t token_len = pe - token_start;
+        VALUE token = rb_str_new(token_start, token_len);
+        rb_ary_push(result, token);
+    }
+
+    return result;
+}

data/ext/cataract_color/cataract_color.c

@@ -0,0 +1,16 @@
+// cataract_color.c - Color conversion extension entry point
+// This is a separate extension loaded on-demand via require 'cataract/color_conversion'
+
+#include <ruby.h>
+
+// Forward declaration from color_conversion.c
+void Init_color_conversion(VALUE mCataract);
+
+// Extension initialization - called when the .so is loaded
+void Init_cataract_color(void) {
+    // Get the Cataract module (must already be loaded by main extension)
+    VALUE mCataract = rb_const_get(rb_cObject, rb_intern("Cataract"));
+
+    // Initialize color conversion methods on Cataract::Stylesheet
+    Init_color_conversion(mCataract);
+}