yass-css 0.2.0

data/ext/yass/src/declarations/grid_template_areas.rs

@@ -0,0 +1,131 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{computed::GridTemplateAreas, specified::position::{NamedArea, TemplateAreasArc}};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::GridTemplateAreas", mark)]
+pub struct YGridTemplateAreas {
+    areas: CachedValue<GridTemplateAreas>,
+}
+
+impl YGridTemplateAreas {
+    pub fn new(grid_template_areas: GridTemplateAreas) -> Self {
+        Self {
+            areas: CachedValue::new(grid_template_areas, make_grid_template_areas_value),
+        }
+    }
+
+    pub fn areas(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.areas.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YGridTemplateAreas {
+    fn mark(&self, marker: &gc::Marker) {
+        self.areas.mark(marker);
+    }
+}
+
+fn make_grid_template_areas_value(grid_template_areas: &GridTemplateAreas, ruby: &Ruby) -> Value {
+    match grid_template_areas {
+        GridTemplateAreas::None => YGridTemplateAreasNone::new().into_value_with(ruby),
+        GridTemplateAreas::Areas(areas) => YGridTemplateAreaList::new(areas.clone()).into_value_with(ruby),
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::GridTemplateAreas::None")]
+pub struct YGridTemplateAreasNone {}
+
+impl YGridTemplateAreasNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::GridTemplateAreas::AreaList", mark)]
+pub struct YGridTemplateAreaList {
+    width: u32,
+    strings: CachedValueList<String>,
+    areas: CachedValueList<NamedArea>,
+}
+
+impl YGridTemplateAreaList {
+    pub fn new(template_areas: TemplateAreasArc) -> Self {
+        let areas = &template_areas.0;
+
+        Self {
+            width: areas.width,
+
+            strings: CachedValueList::new(
+                areas.strings.iter().map(|s| s.to_string()).collect(),
+                |value, _ctx, ruby| ruby.str_new(value).into_value_with(ruby),
+            ),
+
+            areas: CachedValueList::new(areas.areas.to_vec(), |value, _ctx, ruby| {
+                YGridTemplateArea::new(value.clone()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn width(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> u32 {
+        rb_self.width
+    }
+
+    pub fn strings(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.strings.to_a(ruby)
+    }
+
+    pub fn areas(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.areas.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YGridTemplateAreaList {
+    fn mark(&self, marker: &gc::Marker) {
+        self.strings.mark(marker);
+        self.areas.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::GridTemplateAreas::Area")]
+pub struct YGridTemplateArea {
+    name: String,
+    row_start: u32,
+    row_end: u32,
+    column_start: u32,
+    column_end: u32,
+}
+
+impl YGridTemplateArea {
+    pub fn new(area: NamedArea) -> Self {
+        Self {
+            name: area.name.to_string(),
+            row_start: area.rows.start,
+            row_end: area.rows.end,
+            column_start: area.columns.start,
+            column_end: area.columns.end,
+        }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.str_new(&rb_self.name).into_value_with(ruby)
+    }
+
+    pub fn row_start(_ruby: &Ruby, rb_self: &Self) -> u32 {
+        rb_self.row_start
+    }
+
+    pub fn row_end(_ruby: &Ruby, rb_self: &Self) -> u32 {
+        rb_self.row_end
+    }
+
+    pub fn column_start(_ruby: &Ruby, rb_self: &Self) -> u32 {
+        rb_self.column_start
+    }
+
+    pub fn column_end(_ruby: &Ruby, rb_self: &Self) -> u32 {
+        rb_self.column_end
+    }
+}

data/ext/yass/src/declarations/grid_template_columns.rs

@@ -0,0 +1,31 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::GridTemplateComponent;
+
+use crate::{
+    cached_value::CachedValue,
+    declarations::grid_template::make_grid_template_component_value,
+};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::GridTemplateColumns", mark)]
+pub struct YGridTemplateColumns {
+    value: CachedValue<GridTemplateComponent>,
+}
+
+impl YGridTemplateColumns {
+    pub fn new(grid_template_component: GridTemplateComponent) -> Self {
+        Self {
+            value: CachedValue::new(grid_template_component, make_grid_template_component_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YGridTemplateColumns {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}

data/ext/yass/src/declarations/grid_template_rows.rs

@@ -0,0 +1,31 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::GridTemplateComponent;
+
+use crate::{
+    cached_value::CachedValue,
+    declarations::grid_template::make_grid_template_component_value,
+};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::GridTemplateRows", mark)]
+pub struct YGridTemplateRows {
+    value: CachedValue<GridTemplateComponent>,
+}
+
+impl YGridTemplateRows {
+    pub fn new(grid_template_component: GridTemplateComponent) -> Self {
+        Self {
+            value: CachedValue::new(grid_template_component, make_grid_template_component_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YGridTemplateRows {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}

data/ext/yass/src/declarations/height.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::Size;
+
+use crate::{cached_value::CachedValue, declarations::size::make_size};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Height", mark)]
+pub struct YHeight {
+    size: CachedValue<Size>
+}
+
+impl YHeight {
+    pub fn new(size: Size) -> Self {
+        Self {
+            size: CachedValue::new(size, |s, ruby| {
+                make_size(s, ruby)
+            })
+        }
+    }
+
+    pub fn size(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.size.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YHeight {
+    fn mark(&self, marker: &gc::Marker) {
+        self.size.mark(marker);
+    }
+}

data/ext/yass/src/declarations/horizontal_position_component.rs

@@ -0,0 +1,93 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data, value::Id};
+use style::values::specified::{LengthPercentage, position::{HorizontalPositionKeyword, PositionComponent}};
+
+use crate::{cached_value::CachedValue, declarations::{images::horizontal_keyword_to_id, size::YLengthPercentage}};
+
+pub fn make_horizontal_position_component(component: &PositionComponent<HorizontalPositionKeyword>, ruby: &Ruby) -> Value {
+    match component {
+        PositionComponent::Center => {
+            YCenterHorizontalPositionComponent::new().into_value_with(ruby)
+        },
+
+        PositionComponent::Length(length) => {
+            YLengthHorizontalPositionComponent::new(length.clone()).into_value_with(ruby)
+        },
+
+        PositionComponent::Side(keyword, offset) => {
+            YSideHorizontalPositionComponent::new(keyword.clone(), offset.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Image::CenterHorizontalPositionComponent")]
+pub struct YCenterHorizontalPositionComponent {}
+
+impl YCenterHorizontalPositionComponent {
+    pub fn new() -> Self {
+        Self { }
+    }
+}
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::LengthHorizontalPositionComponent", mark)]
+pub struct YLengthHorizontalPositionComponent {
+    length: CachedValue<LengthPercentage>,
+}
+
+impl YLengthHorizontalPositionComponent {
+    pub fn new(length: LengthPercentage) -> Self {
+        Self {
+            length: CachedValue::new(length, |length, ruby| {
+                YLengthPercentage::new(length.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn length(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YLengthHorizontalPositionComponent {
+    fn mark(&self, marker: &Marker) {
+        self.length.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::SideHorizontalPositionComponent", mark)]
+pub struct YSideHorizontalPositionComponent {
+    keyword: HorizontalPositionKeyword,
+    offset: CachedValue<Option<LengthPercentage>>,
+}
+
+impl YSideHorizontalPositionComponent {
+    pub fn new(keyword: HorizontalPositionKeyword, offset: Option<LengthPercentage>) -> Self {
+        Self {
+            keyword,
+            offset: CachedValue::new(offset, |offset, ruby| {
+                match offset {
+                    Some(offset) => {
+                        YLengthPercentage::new(offset.clone()).into_value_with(ruby)
+                    },
+
+                    None => ruby.qnil().into_value_with(ruby),
+                }
+            })
+        }
+    }
+
+    pub fn side(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        horizontal_keyword_to_id(rb_self.keyword, ruby)
+    }
+
+    pub fn offset(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.offset.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YSideHorizontalPositionComponent {
+    fn mark(&self, marker: &Marker) {
+        self.offset.mark(marker);
+    }
+}

data/ext/yass/src/declarations/image_rendering.rs

@@ -0,0 +1,21 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::ImageRendering;
+
+#[magnus::wrap(class = "Yass::Declarations::ImageRendering")]
+pub struct YImageRendering {
+    image_rendering: ImageRendering
+}
+
+impl YImageRendering {
+    pub fn new(image_rendering: ImageRendering) -> Self {
+        Self { image_rendering }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.image_rendering {
+            ImageRendering::Auto => ruby.intern("auto"),
+            ImageRendering::CrispEdges => ruby.intern("crisp_edges"),
+            ImageRendering::Pixelated => ruby.intern("pixelated"),
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::AngleOrPercentage;
+
+use crate::{cached_value::CachedValue, declarations::{angle::YAngle, percentage::YPercentage}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::AngleOrPercentage", mark)]
+pub struct YAngleOrPercentage {
+    value: CachedValue<AngleOrPercentage>,
+}
+
+impl YAngleOrPercentage {
+    pub fn new(value: AngleOrPercentage) -> Self {
+        Self {
+            value: CachedValue::new(value, |val, ruby| {
+                match val {
+                    AngleOrPercentage::Angle(angle) => YAngle::new(*angle).into_value_with(ruby),
+                    AngleOrPercentage::Percentage(percentage) => {
+                        YPercentage::new(percentage.get()).into_value_with(ruby)
+                    },
+                }
+            })
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAngleOrPercentage {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}

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

@@ -0,0 +1,72 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data, value::Id};
+use style::values::{generics::{NonNegative, image::{Circle, ShapeExtent}}, specified::{Length, NonNegativeLength}};
+
+use crate::{cached_value::CachedValue, declarations::{calc::YCalc, length::no_calc_length_to_value}};
+
+pub fn make_circle(circle: &Circle<NonNegativeLength>, ruby: &Ruby) -> Value {
+    match circle {
+        Circle::Radius(length) => {
+            YRadiusCircle::new(length.clone()).into_value_with(ruby)
+        },
+
+        Circle::Extent(shape_extent) => {
+            YExtentCircle::new(shape_extent.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::RadiusCircle", mark)]
+pub struct YRadiusCircle {
+    length: CachedValue<NonNegative<Length>>
+}
+
+impl YRadiusCircle {
+    pub fn new(length: NonNegative<Length>) -> Self {
+        Self {
+            length: CachedValue::new(length, |length, ruby| {
+                match &length.0 {
+                    Length::NoCalc(no_calc_length) => {
+                        no_calc_length_to_value(no_calc_length, ruby)
+                    },
+
+                    Length::Calc(calc_length_percentage) => {
+                        YCalc::new(calc_length_percentage.clone()).into_value_with(ruby)
+                    },
+                }
+            })
+        }
+    }
+
+    pub fn length(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YRadiusCircle {
+    fn mark(&self, marker: &Marker) {
+        self.length.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Image::ExtentCircle")]
+pub struct YExtentCircle {
+    extent: ShapeExtent
+}
+
+impl YExtentCircle {
+    pub fn new(extent: ShapeExtent) -> Self {
+        Self { extent }
+    }
+
+    pub fn extent(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.extent {
+            ShapeExtent::ClosestSide => ruby.intern("closest_side"),
+            ShapeExtent::FarthestSide => ruby.intern("farthest_side"),
+            ShapeExtent::ClosestCorner => ruby.intern("closest_corner"),
+            ShapeExtent::FarthestCorner => ruby.intern("farthest_corner"),
+            ShapeExtent::Contain => ruby.intern("contain"),
+            ShapeExtent::Cover => ruby.intern("cover"),
+        }
+    }
+}

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

@@ -0,0 +1,80 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, Value, gc::Marker, typed_data};
+use style::{color::mix::ColorInterpolationMethod, values::{generics::image::{GradientFlags, GradientItem}, specified::{Angle, AngleOrPercentage, Color, image::Gradient, position::Position}}};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList, declarations::{angle::YAngle, color::color_interpolation_method::YColorInterpolationMethod, images::{gradient_angle_or_percentage_item, position::YImagePosition}}};
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::ConicGradient", mark)]
+pub struct YConicGradient {
+    angle: CachedValue<Angle>,
+    position: CachedValue<Position>,
+    color_interpolation_method: CachedValue<ColorInterpolationMethod>,
+    items: CachedValueList<GradientItem<Color, AngleOrPercentage>>,
+    repeating: bool,
+}
+
+impl YConicGradient {
+    pub fn new(gradient: Gradient) -> Self {
+        match gradient {
+            Gradient::Conic {
+                angle,
+                position,
+                color_interpolation_method,
+                items,
+                flags,
+            } => Self {
+                angle: CachedValue::new(angle, |angle, ruby| {
+                    YAngle::new(*angle).into_value_with(ruby)
+                }),
+
+                position: CachedValue::new(position, |position, ruby| {
+                    YImagePosition::new(position.clone()).into_value_with(ruby)
+                }),
+
+                color_interpolation_method: CachedValue::new(
+                    color_interpolation_method,
+                    |method, ruby| {
+                        YColorInterpolationMethod::new(*method).into_value_with(ruby)
+                    },
+                ),
+
+                items: CachedValueList::new(items.to_vec(), |item, _ctx, ruby| {
+                    gradient_angle_or_percentage_item::make_gradient_angle_or_percentage_item(item, ruby)
+                }),
+
+                repeating: flags.contains(GradientFlags::REPEATING),
+            },
+
+            _ => unreachable!("expected conic gradient"),
+        }
+    }
+
+    pub fn repeating(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.repeating
+    }
+
+    pub fn angle(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.angle.get(ruby)
+    }
+
+    pub fn position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.position.get(ruby)
+    }
+
+    pub fn color_interpolation_method(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color_interpolation_method.get(ruby)
+    }
+
+    pub fn items(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.items.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YConicGradient {
+    fn mark(&self, marker: &Marker) {
+        self.angle.mark(marker);
+        self.position.mark(marker);
+        self.color_interpolation_method.mark(marker);
+        self.items.mark(marker);
+    }
+}

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

@@ -0,0 +1,33 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc::Marker, typed_data};
+use style::values::specified::image::{CrossFade, CrossFadeElement};
+
+use crate::{cached_value_list::CachedValueList, declarations::images::cross_fade_element::YCrossFadeElement};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::CrossFade", mark)]
+pub struct YCrossFade {
+    elements: CachedValueList<CrossFadeElement>,
+}
+
+impl YCrossFade {
+    pub fn new(cross_fade: CrossFade) -> Self {
+        Self {
+            elements: CachedValueList::new(
+                cross_fade.elements.to_vec(),
+                |element, _ctx, ruby| {
+                    YCrossFadeElement::new(element.clone()).into_value_with(ruby)
+                },
+            ),
+        }
+    }
+
+    pub fn elements(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.elements.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YCrossFade {
+    fn mark(&self, marker: &Marker) {
+        self.elements.mark(marker);
+    }
+}

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

@@ -0,0 +1,44 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, Value, gc::Marker, typed_data};
+use style::values::specified::{Percentage, image::{CrossFadeElement, CrossFadeImage}};
+
+use crate::{cached_value::CachedValue, declarations::{images::cross_fade_image::make_cross_fade_image, percentage::YPercentage}};
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::CrossFadeElement", mark)]
+pub struct YCrossFadeElement {
+    percent: CachedValue<Option<Percentage>>,
+    image: CachedValue<CrossFadeImage>,
+}
+
+impl YCrossFadeElement {
+    pub fn new(element: CrossFadeElement) -> Self {
+        Self {
+            percent: CachedValue::new(element.percent.into_rust(), |percent, ruby| match percent {
+                Some(percent) => {
+                    YPercentage::new(percent.get()).into_value_with(ruby)
+                },
+
+                None => ruby.qnil().into_value_with(ruby),
+            }),
+
+            image: CachedValue::new(element.image, |image, ruby| {
+                make_cross_fade_image(image, ruby).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn percent(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.percent.get(ruby)
+    }
+
+    pub fn image(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.image.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YCrossFadeElement {
+    fn mark(&self, marker: &Marker) {
+        self.percent.mark(marker);
+        self.image.mark(marker);
+    }
+}

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

@@ -0,0 +1,68 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::specified::{Color, Image, image::CrossFadeImage};
+
+use crate::{cached_value::CachedValue, declarations::{color::color::make_color, images::image_to_value}};
+
+pub fn make_cross_fade_image(image: &CrossFadeImage, ruby: &Ruby) -> Value {
+    match image {
+        CrossFadeImage::Image(image) => {
+            YCrossFadeImage::new(image.clone()).into_value_with(ruby)
+        },
+
+        CrossFadeImage::Color(color) => {
+            YCrossFadeColor::new(color.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::CrossFadeImage", mark)]
+pub struct YCrossFadeImage {
+    image: CachedValue<Image>,
+}
+
+impl YCrossFadeImage {
+    pub fn new(image: Image) -> Self {
+        Self {
+            image: CachedValue::new(image, |image, ruby| {
+                image_to_value(image, ruby)
+            })
+        }
+    }
+
+    pub fn image(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.image.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YCrossFadeImage {
+    fn mark(&self, marker: &Marker) {
+        self.image.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::CrossFadeColor", mark)]
+pub struct YCrossFadeColor {
+    color: CachedValue<Color>,
+}
+
+impl YCrossFadeColor {
+    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 YCrossFadeColor {
+    fn mark(&self, marker: &Marker) {
+        self.color.mark(marker);
+    }
+}