cataract 0.1.1 → 0.1.2

data/ext/cataract/shorthand_expander.c

@@ -498,6 +498,8 @@ VALUE cataract_expand_list_style(VALUE self, VALUE value) {
  * This is complex - background has many sub-properties and / separator for size
  */
 VALUE cataract_expand_background(VALUE self, VALUE value) {
+    DEBUG_PRINTF("[cataract_expand_background] input value: '%s'\n", RSTRING_PTR(value));
+
     // First, check if there's a / separator for background-size
     const char *str = StringValueCStr(value);
     const char *slash = strchr(str, '/');
@@ -529,16 +531,25 @@ VALUE cataract_expand_background(VALUE self, VALUE value) {
     const char *attachment_keywords[] = {"scroll", "fixed", NULL};
     const char *position_keywords[] = {"left", "right", "top", "bottom", "center", NULL};
 
-    VALUE color = Qnil, image = Qnil, repeat = Qnil, attachment = Qnil, size = size_part;
+    VALUE color = Qnil, repeat = Qnil, attachment = Qnil, size = size_part;
     VALUE position_parts = rb_ary_new(); // Collect all position keywords
+    VALUE image_parts = rb_ary_new();    // Collect all image functions (for layered backgrounds)
 
     for (long i = 0; i < len; i++) {
         VALUE part = rb_ary_entry(parts, i);
         const char *str = StringValueCStr(part);
 
-        // Check for image
-        if (image == Qnil && (strncmp(str, "url(", 4) == 0 || strcmp(str, "none") == 0)) {
-            image = part;
+        // Check for image (url, gradient functions, or none) - collect ALL image tokens
+        if (strncmp(str, "url(", 4) == 0 ||
+            strncmp(str, "linear-gradient(", 16) == 0 ||
+            strncmp(str, "radial-gradient(", 16) == 0 ||
+            strncmp(str, "repeating-linear-gradient(", 26) == 0 ||
+            strncmp(str, "repeating-radial-gradient(", 26) == 0 ||
+            strncmp(str, "conic-gradient(", 15) == 0 ||
+            strcmp(str, "none") == 0) {
+            DEBUG_PRINTF("  -> Recognized as IMAGE: '%s'\n", str);
+            rb_ary_push(image_parts, part);
+            goto next_part;
         }
         // Check for repeat
         else if (repeat == Qnil) {
@@ -570,10 +581,12 @@ VALUE cataract_expand_background(VALUE self, VALUE value) {
         // Check for color (hex, rgb, or keyword)
         if (color == Qnil) {
             if (str[0] == '#' || strncmp(str, "rgb", 3) == 0 || strncmp(str, "hsl", 3) == 0) {
+                DEBUG_PRINTF("  -> Recognized as COLOR (function/hex): '%s'\n", str);
                 color = part;
             } else {
                 for (int j = 0; color_keywords[j]; j++) {
                     if (strcmp(str, color_keywords[j]) == 0) {
+                        DEBUG_PRINTF("  -> Recognized as COLOR (keyword): '%s'\n", str);
                         color = part;
                         break;
                     }
@@ -590,12 +603,32 @@ VALUE cataract_expand_background(VALUE self, VALUE value) {
         position = rb_ary_join(position_parts, STR_NEW_CSTR(" "));
     }
 
-    if (color != Qnil) rb_hash_aset(result, STR_NEW_CSTR("background-color"), color);
-    if (image != Qnil) rb_hash_aset(result, STR_NEW_CSTR("background-image"), image);
-    if (repeat != Qnil) rb_hash_aset(result, STR_NEW_CSTR("background-repeat"), repeat);
-    if (attachment != Qnil) rb_hash_aset(result, STR_NEW_CSTR("background-attachment"), attachment);
-    if (position != Qnil) rb_hash_aset(result, STR_NEW_CSTR("background-position"), position);
-    if (size != Qnil) rb_hash_aset(result, STR_NEW_CSTR("background-size"), size);
+    // Join all image parts into a single string if any were found (for layered backgrounds)
+    VALUE image = Qnil;
+    if (RARRAY_LEN(image_parts) > 0) {
+        image = rb_ary_join(image_parts, STR_NEW_CSTR(" "));
+        DEBUG_PRINTF("  -> Joined %ld image parts into: '%s'\n", RARRAY_LEN(image_parts), RSTRING_PTR(image));
+    }
+
+    DEBUG_PRINTF("[cataract_expand_background] Final values:\n");
+    DEBUG_PRINTF("  color: %s\n", color != Qnil ? RSTRING_PTR(color) : "(nil -> transparent)");
+    DEBUG_PRINTF("  image: %s\n", image != Qnil ? RSTRING_PTR(image) : "(nil -> none)");
+
+    // Background shorthand sets ALL longhand properties
+    // Unspecified values get CSS initial values (defaults)
+    rb_hash_aset(result, STR_NEW_CSTR("background-color"),
+                 color != Qnil ? color : STR_NEW_CSTR("transparent"));
+    rb_hash_aset(result, STR_NEW_CSTR("background-image"),
+                 image != Qnil ? image : STR_NEW_CSTR("none"));
+    rb_hash_aset(result, STR_NEW_CSTR("background-repeat"),
+                 repeat != Qnil ? repeat : STR_NEW_CSTR("repeat"));
+    rb_hash_aset(result, STR_NEW_CSTR("background-attachment"),
+                 attachment != Qnil ? attachment : STR_NEW_CSTR("scroll"));
+    rb_hash_aset(result, STR_NEW_CSTR("background-position"),
+                 position != Qnil ? position : STR_NEW_CSTR("0% 0%"));
+    if (size != Qnil) {
+        rb_hash_aset(result, STR_NEW_CSTR("background-size"), size);
+    }
 
     return result;
 }
@@ -783,48 +816,100 @@ VALUE cataract_create_background_shorthand(VALUE self, VALUE properties) {
     VALUE image = rb_hash_aref(properties, STR_NEW_CSTR("background-image"));
     VALUE repeat = rb_hash_aref(properties, STR_NEW_CSTR("background-repeat"));
     VALUE position = rb_hash_aref(properties, STR_NEW_CSTR("background-position"));
+    VALUE attachment = rb_hash_aref(properties, STR_NEW_CSTR("background-attachment"));
     VALUE size = rb_hash_aref(properties, STR_NEW_CSTR("background-size"));
 
     // Need at least one property
-    if (NIL_P(color) && NIL_P(image) && NIL_P(repeat) && NIL_P(position) && NIL_P(size)) {
+    if (NIL_P(color) && NIL_P(image) && NIL_P(repeat) && NIL_P(position) && NIL_P(attachment) && NIL_P(size)) {
         return Qnil;
     }
 
+    // Check if all 5 core properties are present (from shorthand expansion)
+    // If so, omit defaults to optimize output
+    int all_present = !NIL_P(color) && !NIL_P(image) && !NIL_P(repeat) &&
+                      !NIL_P(position) && !NIL_P(attachment);
+
+    DEBUG_PRINTF("[create_background_shorthand] all_present=%d (color=%d image=%d repeat=%d pos=%d attach=%d)\n",
+                 all_present, !NIL_P(color), !NIL_P(image), !NIL_P(repeat),
+                 !NIL_P(position), !NIL_P(attachment));
+    if (!NIL_P(color)) DEBUG_PRINTF("  color='%s'\n", RSTRING_PTR(color));
+    if (!NIL_P(image)) DEBUG_PRINTF("  image='%s'\n", RSTRING_PTR(image));
+    if (!NIL_P(repeat)) DEBUG_PRINTF("  repeat='%s'\n", RSTRING_PTR(repeat));
+    if (!NIL_P(position)) DEBUG_PRINTF("  position='%s'\n", RSTRING_PTR(position));
+    if (!NIL_P(attachment)) DEBUG_PRINTF("  attachment='%s'\n", RSTRING_PTR(attachment));
+
     VALUE result = STR_NEW_WITH_CAPACITY(128);
     int first = 1;
 
     if (!NIL_P(color)) {
-        rb_str_append(result, color);
-        first = 0;
+        // Omit default 'transparent' if all properties present
+        if (!all_present || !STR_EQ(color, "transparent")) {
+            DEBUG_PRINTF("  -> Adding color: '%s'\n", RSTRING_PTR(color));
+            rb_str_append(result, color);
+            first = 0;
+        } else {
+            DEBUG_PRINTF("  -> Omitting default color 'transparent'\n");
+        }
     }
     if (!NIL_P(image)) {
-        if (!first) rb_str_cat2(result, " ");
-        rb_str_append(result, image);
-        first = 0;
+        // Omit default 'none' if all properties present
+        if (!all_present || !STR_EQ(image, "none")) {
+            DEBUG_PRINTF("  -> Adding image: '%s'\n", RSTRING_PTR(image));
+            if (!first) rb_str_cat2(result, " ");
+            rb_str_append(result, image);
+            first = 0;
+        } else {
+            DEBUG_PRINTF("  -> Omitting default image 'none'\n");
+        }
     }
     if (!NIL_P(repeat)) {
-        if (!first) rb_str_cat2(result, " ");
-        rb_str_append(result, repeat);
-        first = 0;
+        // Omit default 'repeat' if all properties present
+        if (!all_present || !STR_EQ(repeat, "repeat")) {
+            DEBUG_PRINTF("  -> Adding repeat: '%s'\n", RSTRING_PTR(repeat));
+            if (!first) rb_str_cat2(result, " ");
+            rb_str_append(result, repeat);
+            first = 0;
+        } else {
+            DEBUG_PRINTF("  -> Omitting default repeat 'repeat'\n");
+        }
     }
     if (!NIL_P(position)) {
-        if (!first) rb_str_cat2(result, " ");
-        rb_str_append(result, position);
-        first = 0;
+        // Omit default '0% 0%' if all properties present
+        if (!all_present || !STR_EQ(position, "0% 0%")) {
+            DEBUG_PRINTF("  -> Adding position: '%s'\n", RSTRING_PTR(position));
+            if (!first) rb_str_cat2(result, " ");
+            rb_str_append(result, position);
+            first = 0;
+        } else {
+            DEBUG_PRINTF("  -> Omitting default position '0%% 0%%'\n");
+        }
+    }
+    if (!NIL_P(attachment)) {
+        // Omit default 'scroll' if all properties present
+        if (!all_present || !STR_EQ(attachment, "scroll")) {
+            DEBUG_PRINTF("  -> Adding attachment: '%s'\n", RSTRING_PTR(attachment));
+            if (!first) rb_str_cat2(result, " ");
+            rb_str_append(result, attachment);
+            first = 0;
+        } else {
+            DEBUG_PRINTF("  -> Omitting default attachment 'scroll'\n");
+        }
     }
     if (!NIL_P(size)) {
         // size needs to be prefixed with /
+        DEBUG_PRINTF("  -> Adding size: '/%s'\n", RSTRING_PTR(size));
         if (!first) rb_str_cat2(result, " ");
-        rb_str_cat2(result, "/ ");
+        rb_str_cat2(result, "/");
         rb_str_append(result, size);
     }
 
+    DEBUG_PRINTF("[create_background_shorthand] result='%s'\n", RSTRING_PTR(result));
     return result;
 }
 
 // Create font shorthand from longhand properties
 // Requires: font-size and font-family
-// Optional: font-style, font-weight, line-height
+// Optional: font-style, font-variant, font-weight, line-height
 VALUE cataract_create_font_shorthand(VALUE self, VALUE properties) {
     VALUE size = rb_hash_aref(properties, STR_NEW_CSTR("font-size"));
     VALUE family = rb_hash_aref(properties, STR_NEW_CSTR("font-family"));
@@ -835,32 +920,60 @@ VALUE cataract_create_font_shorthand(VALUE self, VALUE properties) {
     }
 
     VALUE style = rb_hash_aref(properties, STR_NEW_CSTR("font-style"));
+    VALUE variant = rb_hash_aref(properties, STR_NEW_CSTR("font-variant"));
     VALUE weight = rb_hash_aref(properties, STR_NEW_CSTR("font-weight"));
     VALUE line_height = rb_hash_aref(properties, STR_NEW_CSTR("line-height"));
 
+    // Check if all optional properties are present (from shorthand expansion)
+    // If so, omit defaults to optimize output
+    int all_present = !NIL_P(style) && !NIL_P(variant) && !NIL_P(weight) && !NIL_P(line_height);
+
     VALUE result = STR_NEW_WITH_CAPACITY(128);
     int has_content = 0;
 
-    // Order: style weight size/line-height family
-    // Skip "normal" for style (it's the default)
-    if (!NIL_P(style) && strcmp(RSTRING_PTR(style), "normal") != 0) {
-        rb_str_append(result, style);
-        has_content = 1;
+    // Order: style variant weight size/line-height family
+    if (!NIL_P(style)) {
+        // Omit default 'normal' only if all properties present
+        if (!all_present || !STR_EQ(style, "normal")) {
+            rb_str_append(result, style);
+            has_content = 1;
+        }
     }
-    if (!NIL_P(weight) && strcmp(RSTRING_PTR(weight), "normal") != 0) {
-        if (has_content) rb_str_cat2(result, " ");
-        rb_str_append(result, weight);
-        has_content = 1;
+    if (!NIL_P(variant)) {
+        // Omit default 'normal' only if all properties present
+        if (!all_present || !STR_EQ(variant, "normal")) {
+            if (has_content) rb_str_cat2(result, " ");
+            rb_str_append(result, variant);
+            has_content = 1;
+        }
+    }
+    if (!NIL_P(weight)) {
+        // Omit default 'normal' only if all properties present
+        if (!all_present || !STR_EQ(weight, "normal")) {
+            if (has_content) rb_str_cat2(result, " ");
+            rb_str_append(result, weight);
+            has_content = 1;
+        }
     }
 
     // size is required
     if (has_content) rb_str_cat2(result, " ");
-    rb_str_append(result, size);
-
-    // line-height goes with size using / (skip "normal")
-    if (!NIL_P(line_height) && strcmp(RSTRING_PTR(line_height), "normal") != 0) {
-        rb_str_cat2(result, "/");
-        rb_str_append(result, line_height);
+    if (all_present && !NIL_P(line_height)) {
+        // Omit line-height if default 'normal' and all properties present
+        if (!STR_EQ(line_height, "normal")) {
+            rb_str_append(result, size);
+            rb_str_cat2(result, "/");
+            rb_str_append(result, line_height);
+        } else {
+            rb_str_append(result, size);
+        }
+    } else {
+        rb_str_append(result, size);
+        // Include line-height if present (partial set)
+        if (!NIL_P(line_height)) {
+            rb_str_cat2(result, "/");
+            rb_str_append(result, line_height);
+        }
     }
 
     // family is required

data/ext/cataract_color/color_conversion.c

@@ -1363,6 +1363,14 @@ static color_parser_fn detect_color_format(VALUE value) {
         return parse_lab;
     }
 
+    // Skip function calls (url, gradient functions, etc.) - they can't be colors
+    // Check if there's a '(' in the string, indicating it's a function
+    const char *paren = strchr(p, '(');
+    if (paren != NULL && (paren - p) < remaining) {
+        // It's a function call like url(...) or linear-gradient(...), not a color
+        return NULL;
+    }
+
     // Check for named colors (fallback - alphabetic characters)
     // Named colors must start with a letter
     if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')) {
@@ -1473,26 +1481,47 @@ struct expand_convert_context {
     VALUE important;
 };
 
+// Properties that can contain color values
+static int is_color_property(const char *prop_name) {
+    // Only these properties can contain actual color values
+    return (strcmp(prop_name, "color") == 0 ||
+            strcmp(prop_name, "background-color") == 0 ||
+            strcmp(prop_name, "border-color") == 0 ||
+            strcmp(prop_name, "border-top-color") == 0 ||
+            strcmp(prop_name, "border-right-color") == 0 ||
+            strcmp(prop_name, "border-bottom-color") == 0 ||
+            strcmp(prop_name, "border-left-color") == 0 ||
+            strcmp(prop_name, "outline-color") == 0 ||
+            strcmp(prop_name, "text-decoration-color") == 0 ||
+            strcmp(prop_name, "column-rule-color") == 0 ||
+            strcmp(prop_name, "caret-color") == 0);
+}
+
 // Callback for iterating expanded properties, converting colors, and creating declaration structs
 static int convert_expanded_property_callback(VALUE prop_name, VALUE prop_value, VALUE arg) {
     struct expand_convert_context *ctx = (struct expand_convert_context *)arg;
 
     if (!NIL_P(prop_value) && TYPE(prop_value) == T_STRING) {
-        color_parser_fn parser;
+        const char *prop_name_str = RSTRING_PTR(prop_name);
 
-        // Auto-detect or use specified format
-        if (ctx->parser == NULL) {
-            parser = detect_color_format(prop_value);
-        } else if (matches_color_format(prop_value, ctx->from_format)) {
-            parser = ctx->parser;
-        } else {
-            parser = NULL;
-        }
+        // Only try to convert colors in properties that can contain colors
+        if (is_color_property(prop_name_str)) {
+            color_parser_fn parser;
 
-        if (parser != NULL) {
-            // Parse → IR → Format
-            struct color_ir color = parser(prop_value);
-            prop_value = ctx->formatter(color, ctx->use_modern_syntax);
+            // Auto-detect or use specified format
+            if (ctx->parser == NULL) {
+                parser = detect_color_format(prop_value);
+            } else if (matches_color_format(prop_value, ctx->from_format)) {
+                parser = ctx->parser;
+            } else {
+                parser = NULL;
+            }
+
+            if (parser != NULL) {
+                // Parse → IR → Format
+                struct color_ir color = parser(prop_value);
+                prop_value = ctx->formatter(color, ctx->use_modern_syntax);
+            }
         }
 
         VALUE new_decl = rb_struct_new(cDeclaration, prop_name, prop_value, ctx->important, NULL);
@@ -1617,7 +1646,23 @@ VALUE rb_stylesheet_convert_colors(int argc, VALUE *argv, VALUE self) {
                 continue;
             }
 
-            // Check if this property needs expansion (e.g., background shorthand)
+            // First, try to convert as a value with potentially multiple colors WITHOUT expanding
+            // (e.g., "border-color: #fff #000 #ccc" or "box-shadow: 0 0 10px #ff0000")
+            // This preserves shorthands like "background: linear-gradient(...)" which have no colors
+            VALUE converted_multi = convert_value_with_colors(value, parser, formatter, use_modern_syntax);
+
+            if (!NIL_P(converted_multi)) {
+                DEBUG_PRINTF("Creating new decl with property='%s' value='%s'\n",
+                        StringValueCStr(property), StringValueCStr(converted_multi));
+                // Successfully converted multi-value property - keep as shorthand
+                VALUE new_decl = rb_struct_new(cDeclaration, property, converted_multi, important, NULL);
+                rb_ary_push(new_declarations, new_decl);
+                DEBUG_PRINTF("Pushed new_decl to new_declarations\n");
+                continue;
+            }
+
+            // No colors found in shorthand value - check if this property needs expansion
+            // (e.g., background shorthand that couldn't be converted as-is)
             VALUE expanded = expand_property_if_needed(property, value);
 
             if (!NIL_P(expanded) && TYPE(expanded) == T_HASH && RHASH_SIZE(expanded) > 0) {
@@ -1635,20 +1680,6 @@ VALUE rb_stylesheet_convert_colors(int argc, VALUE *argv, VALUE self) {
             }
             // If expansion returned empty hash, keep original declaration (e.g., gradients)
 
-            // Try to convert as a value with potentially multiple colors
-            // (e.g., "border-color: #fff #000 #ccc" or "box-shadow: 0 0 10px #ff0000")
-            VALUE converted_multi = convert_value_with_colors(value, parser, formatter, use_modern_syntax);
-
-            if (!NIL_P(converted_multi)) {
-                DEBUG_PRINTF("Creating new decl with property='%s' value='%s'\n",
-                        StringValueCStr(property), StringValueCStr(converted_multi));
-                // Successfully converted multi-value property
-                VALUE new_decl = rb_struct_new(cDeclaration, property, converted_multi, important, NULL);
-                rb_ary_push(new_declarations, new_decl);
-                DEBUG_PRINTF("Pushed new_decl to new_declarations\n");
-                continue;
-            }
-
             // Try single-value color conversion
             color_parser_fn single_parser;
 

data/ext/cataract_color/color_conversion_named.c

@@ -241,6 +241,15 @@ struct color_ir parse_named(VALUE named_value) {
         name_len--;
     }
 
+    // Special case: "transparent" is rgba(0,0,0,0) per CSS spec
+    if (name_len == 11 && strncasecmp(name, "transparent", 11) == 0) {
+        color.red = 0;
+        color.green = 0;
+        color.blue = 0;
+        color.alpha = 0.0;  // Fully transparent
+        return color;
+    }
+
     // Look up the color
     int hex = lookup_named_color(name, name_len);
 
@@ -254,6 +263,7 @@ struct color_ir parse_named(VALUE named_value) {
     color.red = (hex >> 16) & 0xFF;
     color.green = (hex >> 8) & 0xFF;
     color.blue = hex & 0xFF;
+    // alpha stays at -1.0 (no alpha / opaque)
 
     return color;
 }

data/lib/cataract/declarations.rb

@@ -198,8 +198,7 @@ module Cataract
 
     # Convert declarations to CSS string.
     #
-    # Implemented in C for performance (see ext/cataract/cataract.c).
-    # The C implementation is defined via rb_define_method and overrides this stub.
+    # Implemented in C for performance.
     #
     # @return [String] CSS declaration block string
     #

data/lib/cataract/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cataract
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/cataract.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require_relative 'cataract/version'
-require_relative 'cataract/cataract' # Load C extension (defines Rule, Declaration, AtRule structs)
-require_relative 'cataract/rule' # Add Ruby methods to Rule
-require_relative 'cataract/at_rule' # Add Ruby methods to AtRule
+require_relative 'cataract/native_extension'
+require_relative 'cataract/rule'
+require_relative 'cataract/at_rule'
 require_relative 'cataract/stylesheet_scope'
 require_relative 'cataract/stylesheet'
 require_relative 'cataract/declarations'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cataract
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - James Cook
@@ -22,6 +22,7 @@ files:
 - ".clang-tidy"
 - ".github/workflows/ci-macos.yml"
 - ".github/workflows/ci.yml"
+- ".github/workflows/docs.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".overcommit.yml"
@@ -56,6 +57,7 @@ files:
 - benchmarks/yjit_tests.rb
 - cataract.gemspec
 - cliff.toml
+- docs/files/EXAMPLE.md
 - examples/color_conversion_visual_test/color_conversion_test.html
 - examples/color_conversion_visual_test/generate.rb
 - examples/color_conversion_visual_test/template.html.erb