cataract 0.1.0

data/ext/cataract_old/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_old/stylesheet.c

@@ -0,0 +1,290 @@
+#include "cataract.h"
+#include <stdio.h>
+
+/*
+ * C implementation of Stylesheet#to_s with no rb_funcall
+ * Optimized for new hash structure: {query_string => {media_types: [...], rules: [...]}}
+ *
+ * This provides ~36% speedup over the Ruby implementation for serialization,
+ * which is important since to_s is a hot path in the premailer use case.
+ */
+
+// Context for merge callback within a group
+struct merge_selector_ctx {
+    VALUE merged_rules;
+    VALUE self;
+};
+
+// Callback for merging rules with the same selector within a media group
+static int merge_selector_callback(VALUE selector, VALUE selector_rules, VALUE arg) {
+    struct merge_selector_ctx *ctx = (struct merge_selector_ctx *)arg;
+
+    // If only one rule, use it directly
+    if (RARRAY_LEN(selector_rules) == 1) {
+        rb_ary_push(ctx->merged_rules, RARRAY_AREF(selector_rules, 0));
+        return ST_CONTINUE;
+    }
+
+    // Multiple rules with same selector - merge them
+    VALUE first_rule = RARRAY_AREF(selector_rules, 0);
+    VALUE specificity = rb_struct_aref(first_rule, INT2FIX(RULE_SPECIFICITY));
+
+    // Merge declarations for this selector (C function, no rb_funcall)
+    VALUE merged_declarations = cataract_merge(ctx->self, selector_rules);
+
+    // Create new merged Rule struct
+    VALUE merged_rule = rb_struct_new(cRule, selector, merged_declarations, specificity);
+    rb_ary_push(ctx->merged_rules, merged_rule);
+
+    return ST_CONTINUE;
+}
+
+// Context for processing each media group
+struct process_group_ctx {
+    VALUE result;
+    VALUE self;
+};
+
+// Callback for processing each media query group
+static int process_group_callback(VALUE query_string, VALUE group_hash, VALUE arg) {
+    struct process_group_ctx *ctx = (struct process_group_ctx *)arg;
+
+    // Extract rules array from group hash
+    VALUE rules_array = rb_hash_aref(group_hash, ID2SYM(rb_intern("rules")));
+    if (NIL_P(rules_array) || RARRAY_LEN(rules_array) == 0) {
+        return ST_CONTINUE; // Skip empty groups
+    }
+
+    // Group rules by selector for merging
+    VALUE rules_by_selector = rb_hash_new();
+    long rules_len = RARRAY_LEN(rules_array);
+
+    for (long i = 0; i < rules_len; i++) {
+        VALUE rule = RARRAY_AREF(rules_array, i);
+        VALUE selector = rb_struct_aref(rule, INT2FIX(RULE_SELECTOR));
+
+        VALUE selector_group = rb_hash_aref(rules_by_selector, selector);
+        if (NIL_P(selector_group)) {
+            selector_group = rb_ary_new();
+            rb_hash_aset(rules_by_selector, selector, selector_group);
+        }
+        rb_ary_push(selector_group, rule);
+    }
+
+    // Merge rules with same selector
+    VALUE merged_rules = rb_ary_new();
+    struct merge_selector_ctx merge_ctx = { merged_rules, ctx->self };
+    rb_hash_foreach(rules_by_selector, merge_selector_callback, (VALUE)&merge_ctx);
+
+    // Check if this is a media query or not
+    int has_media_query = !NIL_P(query_string);
+
+    if (has_media_query) {
+        // Output @media wrapper
+        rb_str_buf_cat2(ctx->result, "@media ");
+        rb_str_buf_append(ctx->result, query_string);
+        rb_str_buf_cat2(ctx->result, " {\n");
+    }
+
+    // Output each merged rule
+    long merged_len = RARRAY_LEN(merged_rules);
+    for (long j = 0; j < merged_len; j++) {
+        VALUE rule = RARRAY_AREF(merged_rules, j);
+        VALUE selector = rb_struct_aref(rule, INT2FIX(RULE_SELECTOR));
+        VALUE declarations = rb_struct_aref(rule, INT2FIX(RULE_DECLARATIONS));
+
+        if (has_media_query) {
+            rb_str_buf_cat2(ctx->result, "  ");
+        }
+
+        rb_str_buf_append(ctx->result, selector);
+        rb_str_buf_cat2(ctx->result, " { ");
+
+        // C function, no rb_funcall
+        VALUE decls_str = declarations_array_to_s(declarations);
+        rb_str_buf_append(ctx->result, decls_str);
+
+        rb_str_buf_cat2(ctx->result, " }\n");
+    }
+
+    if (has_media_query) {
+        rb_str_buf_cat2(ctx->result, "}\n");
+    }
+
+    RB_GC_GUARD(rules_array);
+    RB_GC_GUARD(rules_by_selector);
+    RB_GC_GUARD(merged_rules);
+
+    return ST_CONTINUE;
+}
+
+// Main function: stylesheet_to_s_c(rule_groups_hash, charset)
+// New signature: takes hash structure {query_string => {media_types: [...], rules: [...]}}
+VALUE stylesheet_to_s_c(VALUE self, VALUE rule_groups, VALUE charset) {
+    Check_Type(rule_groups, T_HASH);
+
+    long num_groups = RHASH_SIZE(rule_groups);
+
+    // Handle empty stylesheet
+    if (num_groups == 0) {
+        if (!NIL_P(charset)) {
+            // Even empty stylesheet should emit @charset if present
+            VALUE result = UTF8_STR("@charset \"");
+            rb_str_buf_append(result, charset);
+            rb_str_buf_cat2(result, "\";\n");
+            return result;
+        }
+        return UTF8_STR("");
+    }
+
+    // Allocate result string with reasonable capacity
+    VALUE result = rb_str_buf_new(num_groups * 100);
+
+    // Emit @charset first if present (must be first per W3C spec)
+    if (!NIL_P(charset)) {
+        rb_str_buf_cat2(result, "@charset \"");
+        rb_str_buf_append(result, charset);
+        rb_str_buf_cat2(result, "\";\n");
+    }
+
+    // Process each media query group
+    struct process_group_ctx ctx = { result, self };
+    rb_hash_foreach(rule_groups, process_group_callback, (VALUE)&ctx);
+
+    RB_GC_GUARD(result);
+
+    return result;
+}
+
+// ============================================================================
+// Formatted output (to_formatted_s)
+// ============================================================================
+
+// Context for formatted processing
+struct format_group_ctx {
+    VALUE result;
+    VALUE self;
+};
+
+// Callback for formatted output with newlines and 2-space indentation
+static int format_group_callback(VALUE query_string, VALUE group_hash, VALUE arg) {
+    struct format_group_ctx *ctx = (struct format_group_ctx *)arg;
+
+    // Extract rules array from group hash
+    VALUE rules_array = rb_hash_aref(group_hash, ID2SYM(rb_intern("rules")));
+    if (NIL_P(rules_array) || RARRAY_LEN(rules_array) == 0) {
+        return ST_CONTINUE; // Skip empty groups
+    }
+
+    // Group rules by selector for merging
+    VALUE rules_by_selector = rb_hash_new();
+    long rules_len = RARRAY_LEN(rules_array);
+
+    for (long i = 0; i < rules_len; i++) {
+        VALUE rule = RARRAY_AREF(rules_array, i);
+        VALUE selector = rb_struct_aref(rule, INT2FIX(RULE_SELECTOR));
+
+        VALUE selector_group = rb_hash_aref(rules_by_selector, selector);
+        if (NIL_P(selector_group)) {
+            selector_group = rb_ary_new();
+            rb_hash_aset(rules_by_selector, selector, selector_group);
+        }
+        rb_ary_push(selector_group, rule);
+    }
+
+    // Merge rules with same selector
+    VALUE merged_rules = rb_ary_new();
+    struct merge_selector_ctx merge_ctx = { merged_rules, ctx->self };
+    rb_hash_foreach(rules_by_selector, merge_selector_callback, (VALUE)&merge_ctx);
+
+    // Check if this is a media query or not
+    int has_media_query = !NIL_P(query_string);
+
+    if (has_media_query) {
+        // Output @media wrapper
+        rb_str_buf_cat2(ctx->result, "@media ");
+        rb_str_buf_append(ctx->result, query_string);
+        rb_str_buf_cat2(ctx->result, " {\n");
+    }
+
+    // Output each merged rule with formatting
+    long merged_len = RARRAY_LEN(merged_rules);
+    for (long j = 0; j < merged_len; j++) {
+        VALUE rule = RARRAY_AREF(merged_rules, j);
+        VALUE selector = rb_struct_aref(rule, INT2FIX(RULE_SELECTOR));
+        VALUE declarations = rb_struct_aref(rule, INT2FIX(RULE_DECLARATIONS));
+
+        // Indent selector if inside media query
+        if (has_media_query) {
+            rb_str_buf_cat2(ctx->result, "  ");
+        }
+
+        // Selector on its own line
+        rb_str_buf_append(ctx->result, selector);
+        rb_str_buf_cat2(ctx->result, " {\n");
+
+        // Declarations indented with 2 spaces (or 4 if inside media query)
+        const char *indent = has_media_query ? "    " : "  ";
+        rb_str_buf_cat2(ctx->result, indent);
+
+        // Get declarations string
+        VALUE decls_str = declarations_array_to_s(declarations);
+        rb_str_buf_append(ctx->result, decls_str);
+
+        rb_str_buf_cat2(ctx->result, "\n");
+
+        // Closing brace
+        if (has_media_query) {
+            rb_str_buf_cat2(ctx->result, "  ");
+        }
+        rb_str_buf_cat2(ctx->result, "}\n");
+    }
+
+    if (has_media_query) {
+        rb_str_buf_cat2(ctx->result, "}\n");
+    }
+
+    RB_GC_GUARD(rules_array);
+    RB_GC_GUARD(rules_by_selector);
+    RB_GC_GUARD(merged_rules);
+
+    return ST_CONTINUE;
+}
+
+// stylesheet_to_formatted_s_c(rule_groups_hash, charset)
+// Returns formatted multi-line output with 2-space indentation
+// Not optimized for performance since it's not in the hot path
+VALUE stylesheet_to_formatted_s_c(VALUE self, VALUE rule_groups, VALUE charset) {
+    Check_Type(rule_groups, T_HASH);
+
+    long num_groups = RHASH_SIZE(rule_groups);
+
+    // Handle empty stylesheet
+    if (num_groups == 0) {
+        if (!NIL_P(charset)) {
+            VALUE result = UTF8_STR("@charset \"");
+            rb_str_buf_append(result, charset);
+            rb_str_buf_cat2(result, "\";\n");
+            return result;
+        }
+        return UTF8_STR("");
+    }
+
+    // Simple allocation - let Ruby resize as needed (not in hot path)
+    VALUE result = UTF8_STR("");
+
+    // Emit @charset first if present
+    if (!NIL_P(charset)) {
+        rb_str_buf_cat2(result, "@charset \"");
+        rb_str_buf_append(result, charset);
+        rb_str_buf_cat2(result, "\";\n");
+    }
+
+    // Process each media query group with formatting
+    struct format_group_ctx ctx = { result, self };
+    rb_hash_foreach(rule_groups, format_group_callback, (VALUE)&ctx);
+
+    RB_GC_GUARD(result);
+
+    return result;
+}

data/ext/cataract_old/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;
+}