yass-css 0.2.0

data/ext/yass/src/declarations/images/ellipse.rs

@@ -0,0 +1,67 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data, value::Id};
+use style::values::{generics::{NonNegative, image::{Ellipse, ShapeExtent}}, specified::{LengthPercentage, NonNegativeLengthPercentage}};
+
+use crate::{cached_value::CachedValue, declarations::{images::shape_extent_to_id, size::YLengthPercentage}};
+
+pub fn make_ellipse(ellipse: &Ellipse<NonNegativeLengthPercentage>, ruby: &Ruby) -> Value {
+    match ellipse {
+        Ellipse::Radii(x, y) => {
+            YRadiiEllipse::new(x.clone(), y.clone()).into_value_with(ruby)
+        },
+
+        Ellipse::Extent(shape) => {
+            YExtentEllipse::new(shape.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::RadiiEllipse", mark)]
+pub struct YRadiiEllipse {
+    x: CachedValue<NonNegative<LengthPercentage>>,
+    y: CachedValue<NonNegative<LengthPercentage>>
+}
+
+impl YRadiiEllipse {
+    pub fn new(x: NonNegative<LengthPercentage>, y: NonNegative<LengthPercentage>) -> Self {
+        Self {
+            x: CachedValue::new(x, |x, ruby| {
+                YLengthPercentage::new(x.0.clone()).into_value_with(ruby)
+            }),
+
+            y: CachedValue::new(y, |y, ruby| {
+                YLengthPercentage::new(y.0.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn x(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.x.get(ruby)
+    }
+
+    pub fn y(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.y.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YRadiiEllipse {
+    fn mark(&self, marker: &Marker) {
+        self.x.mark(marker);
+        self.y.mark(marker)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Image::ExtentEllipse")]
+pub struct YExtentEllipse {
+    extent: ShapeExtent
+}
+
+impl YExtentEllipse {
+    pub fn new(extent: ShapeExtent) -> Self {
+        Self { extent }
+    }
+
+    pub fn extent(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        shape_extent_to_id(rb_self.extent, ruby)
+    }
+}

data/ext/yass/src/declarations/images/ending_shape.rs

@@ -0,0 +1,38 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, Value, gc::Marker, typed_data};
+use style::values::specified::image::EndingShape;
+
+use crate::{cached_value::CachedValue, declarations::images::{circle::make_circle, ellipse::make_ellipse}};
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::EndingShape", mark)]
+pub struct YEndingShape {
+    shape: CachedValue<EndingShape>
+}
+
+impl YEndingShape {
+    pub fn new(shape: EndingShape) -> Self {
+        Self {
+            shape: CachedValue::new(shape, |shape, ruby| {
+                match shape {
+                    EndingShape::Circle(circle) => {
+                        make_circle(circle, ruby).into_value_with(ruby)
+                    },
+
+                    EndingShape::Ellipse(ellipse) => {
+                        make_ellipse(ellipse, ruby).into_value_with(ruby)
+                    },
+                }
+            })
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.shape.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YEndingShape {
+    fn mark(&self, marker: &Marker) {
+        self.shape.mark(marker);
+    }
+}

data/ext/yass/src/declarations/images/gradient_angle_or_percentage_item.rs

@@ -0,0 +1,103 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::image::GradientItem, specified::{AngleOrPercentage, Color}};
+
+use crate::{cached_value::CachedValue, declarations::{color::color::make_color, images::angle_or_percentage::YAngleOrPercentage}};
+
+pub fn make_gradient_angle_or_percentage_item(item: &GradientItem<Color, AngleOrPercentage>, ruby: &Ruby) -> Value {
+    match item {
+        GradientItem::SimpleColorStop(color) => {
+            YSimpleColorStopAngle::new(color.clone()).into_value_with(ruby)
+        },
+        GradientItem::ComplexColorStop { color, position } => {
+            YComplexColorStopAngle::new(color.clone(), position.clone()).into_value_with(ruby)
+        },
+        GradientItem::InterpolationHint(position) => {
+            YInterpolationHintAngle::new(position.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::Gradient::SimpleColorStopAngle", mark)]
+pub struct YSimpleColorStopAngle {
+    color: CachedValue<Color>,
+}
+
+impl YSimpleColorStopAngle {
+    pub fn new(color: Color) -> Self {
+        Self {
+            color: CachedValue::new(color, |color, ruby| {
+                make_color(color, ruby)
+            }),
+        }
+    }
+
+    pub fn color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color.get(ruby)
+    }
+
+    pub fn position(ruby: &Ruby, _rb_self: typed_data::Obj<Self>) -> Value {
+        ruby.qnil().into_value_with(ruby)
+    }
+}
+
+impl DataTypeFunctions for YSimpleColorStopAngle {
+    fn mark(&self, marker: &Marker) {
+        self.color.mark(marker);
+    }
+}
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::Gradient::ComplexColorStopAngle", mark)]
+pub struct YComplexColorStopAngle {
+    color: CachedValue<Color>,
+    position: CachedValue<AngleOrPercentage>,
+}
+
+impl YComplexColorStopAngle {
+    pub fn new(color: Color, position: AngleOrPercentage) -> Self {
+        Self {
+            color: CachedValue::new(color, |color, ruby| {
+                make_color(color, ruby)
+            }),
+
+            position: CachedValue::new(position, |position, ruby| {
+                YAngleOrPercentage::new(*position).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color.get(ruby)
+    }
+
+    pub fn position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.position.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YComplexColorStopAngle {
+    fn mark(&self, marker: &Marker) {
+        self.color.mark(marker);
+        self.position.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Image::Gradient::InterpolationHintAngle")]
+pub struct YInterpolationHintAngle {
+    position: AngleOrPercentage,
+}
+
+impl YInterpolationHintAngle {
+    pub fn new(position: AngleOrPercentage) -> Self {
+        Self { position }
+    }
+
+    pub fn color(ruby: &Ruby, _rb_self: typed_data::Obj<Self>) -> Value {
+        ruby.qnil().into_value_with(ruby)
+    }
+
+    pub fn position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        YAngleOrPercentage::new(rb_self.position).into_value_with(ruby)
+    }
+}

data/ext/yass/src/declarations/images/gradient_length_percentage_item.rs

@@ -0,0 +1,106 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::image::GradientItem, specified::{Color, LengthPercentage}};
+
+use crate::{cached_value::CachedValue, declarations::{color::color::make_color, size::YLengthPercentage}};
+
+pub fn make_gradient_length_percentage_item(item: &GradientItem<Color, LengthPercentage>, ruby: &Ruby) -> Value {
+    match item {
+        GradientItem::SimpleColorStop(color) => {
+            YSimpleColorStopLength::new(color.clone()).into_value_with(ruby)
+        },
+        GradientItem::ComplexColorStop { color, position } => {
+            YComplexColorStopLength::new(color.clone(), position.clone()).into_value_with(ruby)
+        },
+        GradientItem::InterpolationHint(position) => {
+            YInterpolationHintLength::new(position.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::Gradient::SimpleColorStopLength", mark)]
+pub struct YSimpleColorStopLength {
+    color: CachedValue<Color>,
+}
+
+impl YSimpleColorStopLength {
+    pub fn new(color: Color) -> Self {
+        Self {
+            color: CachedValue::new(color, |color, ruby| {
+                make_color(color, ruby)
+            }),
+        }
+    }
+
+    pub fn color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YSimpleColorStopLength {
+    fn mark(&self, marker: &Marker) {
+        self.color.mark(marker);
+    }
+}
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::Gradient::ComplexColorStopLength", mark)]
+pub struct YComplexColorStopLength {
+    color: CachedValue<Color>,
+    position: CachedValue<LengthPercentage>,
+}
+
+impl YComplexColorStopLength {
+    pub fn new(color: Color, position: LengthPercentage) -> Self {
+        Self {
+            color: CachedValue::new(color, |color, ruby| {
+                make_color(color, ruby)
+            }),
+
+            position: CachedValue::new(position, |position, ruby| {
+                YLengthPercentage::new(position.clone()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color.get(ruby)
+    }
+
+    pub fn position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.position.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YComplexColorStopLength {
+    fn mark(&self, marker: &Marker) {
+        self.color.mark(marker);
+        self.position.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::Gradient::InterpolationHintLength", mark)]
+pub struct YInterpolationHintLength {
+    position: CachedValue<LengthPercentage>,
+}
+
+impl YInterpolationHintLength {
+    pub fn new(position: LengthPercentage) -> Self {
+        Self {
+            position: CachedValue::new(position, |position, ruby| {
+                YLengthPercentage::new(position.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.position.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YInterpolationHintLength {
+    fn mark(&self, marker: &magnus::gc::Marker) {
+        self.position.mark(marker);
+    }
+}

data/ext/yass/src/declarations/images/image_set.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, gc::Marker, typed_data};
+use style::values::specified::image::{ImageSet, ImageSetItem};
+
+use crate::{cached_value_list::CachedValueList, declarations::images::image_set_item::YImageSetItem};
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::ImageSet", mark)]
+pub struct YImageSet {
+    items: CachedValueList<ImageSetItem>,
+}
+
+impl YImageSet {
+    pub fn new(image_set: ImageSet) -> Self {
+        Self {
+            items: CachedValueList::new(image_set.items.to_vec(), |item, _ctx, ruby| {
+                YImageSetItem::new(item.clone()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn items(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.items.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YImageSet {
+    fn mark(&self, marker: &Marker) {
+        self.items.mark(marker);
+    }
+}

data/ext/yass/src/declarations/images/image_set_item.rs

@@ -0,0 +1,53 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, Value, gc::Marker, typed_data};
+use style::values::specified::{Resolution, image::{Image, ImageSetItem}};
+
+use crate::{cached_value::CachedValue, declarations::{images::image_to_value, resolution::YResolution}};
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::ImageSetItem", mark)]
+pub struct YImageSetItem {
+    image: CachedValue<Image>,
+    resolution: CachedValue<Resolution>,
+    mime_type: String,
+    has_mime_type: bool,
+}
+
+impl YImageSetItem {
+    pub fn new(item: ImageSetItem) -> Self {
+        Self {
+            image: CachedValue::new(item.image, |image, ruby| {
+                image_to_value(image, ruby)
+            }),
+
+            resolution: CachedValue::new(item.resolution, |resolution, ruby| {
+                YResolution::new(resolution.clone()).into_value_with(ruby)
+            }),
+
+            mime_type: item.mime_type.to_string(),
+            has_mime_type: item.has_mime_type,
+        }
+    }
+
+    pub fn image(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.image.get(ruby)
+    }
+
+    pub fn resolution(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.resolution.get(ruby)
+    }
+
+    pub fn has_mime_type(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.has_mime_type
+    }
+
+    pub fn mime_type(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        ruby.str_new(&rb_self.mime_type).into_value_with(ruby)
+    }
+}
+
+impl DataTypeFunctions for YImageSetItem {
+    fn mark(&self, marker: &Marker) {
+        self.image.mark(marker);
+        self.resolution.mark(marker);
+    }
+}

data/ext/yass/src/declarations/images/init.rs

@@ -0,0 +1,145 @@
+use magnus::{Error, Module, RModule, Ruby, method};
+
+use crate::declarations::{horizontal_position_component::{YLengthHorizontalPositionComponent, YSideHorizontalPositionComponent}, vertical_position_component::{YLengthVerticalPositionComponent, YSideVerticalPositionComponent}};
+use crate::declarations::images::{
+    angle_or_percentage::YAngleOrPercentage, circle::{YExtentCircle, YRadiusCircle}, conic_gradient::YConicGradient, cross_fade::YCrossFade, cross_fade_element::YCrossFadeElement, cross_fade_image::{YCrossFadeColor, YCrossFadeImage}, ellipse::{YExtentEllipse, YRadiiEllipse}, ending_shape::YEndingShape, gradient_angle_or_percentage_item::{YComplexColorStopAngle, YInterpolationHintAngle, YSimpleColorStopAngle}, gradient_length_percentage_item::{YComplexColorStopLength, YInterpolationHintLength, YSimpleColorStopLength}, image_set::YImageSet, image_set_item::YImageSetItem, light_dark::YImageLightDark, line_direction::{YAngleLineDirection, YCornerLineDirection, YHorizontalLineDirection, YVerticalLineDirection}, linear_gradient::YLinearGradient, position::YImagePosition, radial_gradient::YImageRadialGradient, url::YImageUrl
+};
+
+pub fn init(ruby: &Ruby, declarations_module: &RModule) -> Result<(), Error> {
+    let image_module = declarations_module.define_module("Image")?;
+
+    let radius_circle_class = image_module.define_class("RadiusCircle", ruby.class_object())?;
+    radius_circle_class.define_method("length", method!(YRadiusCircle::length, 0))?;
+
+    let extent_circle_class = image_module.define_class("ExtentCircle", ruby.class_object())?;
+    extent_circle_class.define_method("extent", method!(YExtentCircle::extent, 0))?;
+
+    let _none_class = image_module.define_class("None", ruby.class_object())?;
+
+    let url_class = image_module.define_class("Url", ruby.class_object())?;
+    url_class.define_method("resolved", method!(YImageUrl::resolved, 0))?;
+    url_class.define_method("original", method!(YImageUrl::original, 0))?;
+    url_class.define_method("invalid?", method!(YImageUrl::invalid, 0))?;
+
+    let light_dark_class = image_module.define_class("LightDark", ruby.class_object())?;
+    light_dark_class.define_method("light", method!(YImageLightDark::light, 0))?;
+    light_dark_class.define_method("dark", method!(YImageLightDark::dark, 0))?;
+
+    let cross_fade_class = image_module.define_class("CrossFade", ruby.class_object())?;
+    cross_fade_class.define_method("elements", method!(YCrossFade::elements, 0))?;
+
+    let cross_fade_image_class = image_module.define_class("CrossFadeImage", ruby.class_object())?;
+    cross_fade_image_class.define_method("image", method!(YCrossFadeImage::image, 0))?;
+
+    let cross_fade_color_class = image_module.define_class("CrossFadeColor", ruby.class_object())?;
+    cross_fade_color_class.define_method("image", method!(YCrossFadeColor::color, 0))?;
+
+    let cross_fade_element_class = image_module.define_class("CrossFadeElement", ruby.class_object())?;
+    cross_fade_element_class.define_method("percent", method!(YCrossFadeElement::percent, 0))?;
+    cross_fade_element_class.define_method("image", method!(YCrossFadeElement::image, 0))?;
+
+    let image_set_class = image_module.define_class("ImageSet", ruby.class_object())?;
+    image_set_class.define_method("items", method!(YImageSet::items, 0))?;
+
+    let image_set_item_class = image_module.define_class("ImageSetItem", ruby.class_object())?;
+    image_set_item_class.define_method("image", method!(YImageSetItem::image, 0))?;
+    image_set_item_class.define_method("resolution", method!(YImageSetItem::resolution, 0))?;
+    image_set_item_class.define_method("has_mime_type?", method!(YImageSetItem::has_mime_type, 0))?;
+    image_set_item_class.define_method("mime_type", method!(YImageSetItem::mime_type, 0))?;
+
+    let angle_line_direction_class = image_module.define_class("AngleLineDirection", ruby.class_object())?;
+    angle_line_direction_class.define_method("angle", method!(YAngleLineDirection::angle, 0))?;
+
+    let horizontal_line_direction_class = image_module.define_class("HorizontalLineDirection", ruby.class_object())?;
+    horizontal_line_direction_class.define_method("direction", method!(YHorizontalLineDirection::direction, 0))?;
+
+    let vertical_line_direction_class = image_module.define_class("VerticalLineDirection", ruby.class_object())?;
+    vertical_line_direction_class.define_method("direction", method!(YVerticalLineDirection::direction, 0))?;
+
+    let corner_line_direction_class = image_module.define_class("CornerLineDirection", ruby.class_object())?;
+    corner_line_direction_class.define_method("horizontal_direction", method!(YCornerLineDirection::horizontal_direction, 0))?;
+    corner_line_direction_class.define_method("vertical_direction", method!(YCornerLineDirection::vertical_direction, 0))?;
+
+    let position_class = image_module.define_class("Position", ruby.class_object())?;
+    position_class.define_method("horizontal_position", method!(YImagePosition::horizontal_position, 0))?;
+    position_class.define_method("vertical_position", method!(YImagePosition::vertical_position, 0))?;
+
+    let _center_horizontal_position_component_class = image_module.define_class("CenterHorizontalPositionComponent", ruby.class_object())?;
+
+    let length_horizontal_position_component_class = image_module.define_class("LengthHorizontalPositionComponent", ruby.class_object())?;
+    length_horizontal_position_component_class.define_method("length", method!(YLengthHorizontalPositionComponent::length, 0))?;
+
+    let side_horizontal_position_component_class = image_module.define_class("SideHorizontalPositionComponent", ruby.class_object())?;
+    side_horizontal_position_component_class.define_method("side", method!(YSideHorizontalPositionComponent::side, 0))?;
+    side_horizontal_position_component_class.define_method("offset", method!(YSideHorizontalPositionComponent::offset, 0))?;
+
+    let _center_vertical_position_component_class = image_module.define_class("CenterVerticalPositionComponent", ruby.class_object())?;
+
+    let length_vertical_position_component_class = image_module.define_class("LengthVerticalPositionComponent", ruby.class_object())?;
+    length_vertical_position_component_class.define_method("length", method!(YLengthVerticalPositionComponent::length, 0))?;
+
+    let side_vertical_position_component_class = image_module.define_class("SideVerticalPositionComponent", ruby.class_object())?;
+    side_vertical_position_component_class.define_method("position", method!(YSideVerticalPositionComponent::position, 0))?;
+    side_vertical_position_component_class.define_method("offset", method!(YSideVerticalPositionComponent::offset, 0))?;
+
+    let ending_shape_class = image_module.define_class("EndingShape", ruby.class_object())?;
+    ending_shape_class.define_method("value", method!(YEndingShape::value, 0))?;
+
+    let radii_ellipse_class = image_module.define_class("RadiiEllipse", ruby.class_object())?;
+    radii_ellipse_class.define_method("x", method!(YRadiiEllipse::x, 0))?;
+    radii_ellipse_class.define_method("y", method!(YRadiiEllipse::y, 0))?;
+
+    let extent_ellipse_class = image_module.define_class("ExtentEllipse", ruby.class_object())?;
+    extent_ellipse_class.define_method("extent", method!(YExtentEllipse::extent, 0))?;
+
+    let angle_or_percentage_class = image_module.define_class("AngleOrPercentage", ruby.class_object())?;
+    angle_or_percentage_class.define_method("value", method!(YAngleOrPercentage::value, 0))?;
+
+    let gradient_module = image_module.define_module("Gradient")?;
+
+    let simple_color_stop_angle_class = gradient_module.define_class("SimpleColorStopAngle", ruby.class_object())?;
+    simple_color_stop_angle_class.define_method("color", method!(YSimpleColorStopAngle::color, 0))?;
+    simple_color_stop_angle_class.define_method("position", method!(YSimpleColorStopAngle::position, 0))?;
+
+    let complex_color_stop_angle_class = gradient_module.define_class("ComplexColorStopAngle", ruby.class_object())?;
+    complex_color_stop_angle_class.define_method("color", method!(YComplexColorStopAngle::color, 0))?;
+    complex_color_stop_angle_class.define_method("position", method!(YComplexColorStopAngle::position, 0))?;
+
+    let interpolation_hint_angle_class = gradient_module.define_class("InterpolationHintAngle", ruby.class_object())?;
+    interpolation_hint_angle_class.define_method("color", method!(YInterpolationHintAngle::color, 0))?;
+    interpolation_hint_angle_class.define_method("position", method!(YInterpolationHintAngle::position, 0))?;
+
+    let simple_color_stop_length_class = gradient_module.define_class("SimpleColorStopLength", ruby.class_object())?;
+    simple_color_stop_length_class.define_method("color", method!(YSimpleColorStopLength::color, 0))?;
+
+    let complex_color_stop_length_class = gradient_module.define_class("ComplexColorStopLength", ruby.class_object())?;
+    complex_color_stop_length_class.define_method("color", method!(YComplexColorStopLength::color, 0))?;
+    complex_color_stop_length_class.define_method("position", method!(YComplexColorStopLength::position, 0))?;
+
+    let interpolation_hint_length_class = gradient_module.define_class("InterpolationHintLength", ruby.class_object())?;
+    interpolation_hint_length_class.define_method("position", method!(YInterpolationHintLength::position, 0))?;
+
+    let linear_gradient_class = image_module.define_class("LinearGradient", ruby.class_object())?;
+    linear_gradient_class.define_method("repeating?", method!(YLinearGradient::repeating, 0))?;
+    linear_gradient_class.define_method("compat_mode", method!(YLinearGradient::compat_mode, 0))?;
+    linear_gradient_class.define_method("direction", method!(YLinearGradient::direction, 0))?;
+    linear_gradient_class.define_method("color_interpolation_method", method!(YLinearGradient::color_interpolation_method, 0))?;
+    linear_gradient_class.define_method("items", method!(YLinearGradient::items, 0))?;
+
+    let radial_gradient_class = image_module.define_class("RadialGradient", ruby.class_object())?;
+    radial_gradient_class.define_method("repeating?", method!(YImageRadialGradient::repeating, 0))?;
+    radial_gradient_class.define_method("compat_mode", method!(YImageRadialGradient::compat_mode, 0))?;
+    radial_gradient_class.define_method("shape", method!(YImageRadialGradient::shape, 0))?;
+    radial_gradient_class.define_method("position", method!(YImageRadialGradient::position, 0))?;
+    radial_gradient_class.define_method("color_interpolation_method", method!(YImageRadialGradient::color_interpolation_method, 0))?;
+    radial_gradient_class.define_method("items", method!(YImageRadialGradient::items, 0))?;
+
+    let conic_gradient_class = image_module.define_class("ConicGradient", ruby.class_object())?;
+    conic_gradient_class.define_method("repeating?", method!(YConicGradient::repeating, 0))?;
+    conic_gradient_class.define_method("angle", method!(YConicGradient::angle, 0))?;
+    conic_gradient_class.define_method("position", method!(YConicGradient::position, 0))?;
+    conic_gradient_class.define_method("color_interpolation_method", method!(YConicGradient::color_interpolation_method, 0))?;
+    conic_gradient_class.define_method("items", method!(YConicGradient::items, 0))?;
+
+    Ok(())
+}

data/ext/yass/src/declarations/images/light_dark.rs

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, Ruby, Value, gc::Marker, typed_data};
+use style::values::{generics::color::GenericLightDark, specified::image::Image};
+
+use crate::{cached_value::CachedValue, declarations::images::image_to_value};
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::LightDark", mark)]
+pub struct YImageLightDark {
+    light: CachedValue<Image>,
+    dark: CachedValue<Image>,
+}
+
+impl YImageLightDark {
+    pub fn new(light_dark: GenericLightDark<Image>) -> Self {
+        Self {
+            light: CachedValue::new(light_dark.light, |image, ruby| {
+                image_to_value(image, ruby)
+            }),
+
+            dark: CachedValue::new(light_dark.dark, |image, ruby| {
+                image_to_value(image, ruby)
+            }),
+        }
+    }
+
+    pub fn light(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.light.get(ruby)
+    }
+
+    pub fn dark(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.dark.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YImageLightDark {
+    fn mark(&self, marker: &Marker) {
+        self.light.mark(marker);
+        self.dark.mark(marker);
+    }
+}