yass-css 0.2.0

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

@@ -0,0 +1,43 @@
+use magnus::{IntoValue, Ruby, Value, typed_data};
+use style::values::{
+    generics::{
+        NonNegative,
+        position::{AspectRatio, PreferredRatio},
+    },
+    specified::Number,
+};
+
+use crate::declarations::number::YNumber;
+
+#[magnus::wrap(class = "Yass::Declarations::AspectRatio")]
+pub struct YAspectRatio {
+    aspect_ratio: AspectRatio<NonNegative<Number>>
+}
+
+impl YAspectRatio {
+    pub fn new(aspect_ratio: AspectRatio<NonNegative<Number>>) -> Self {
+        Self { aspect_ratio }
+    }
+
+    pub fn is_auto(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.aspect_ratio.auto
+    }
+
+    pub fn has_ratio(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        matches!(rb_self.aspect_ratio.ratio, PreferredRatio::Ratio(_))
+    }
+
+    pub fn numerator(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Option<Value> {
+        match rb_self.aspect_ratio.ratio {
+            PreferredRatio::Ratio(ratio) => Some(YNumber::new(ratio.0.0.get()).into_value_with(ruby)),
+            PreferredRatio::None => None,
+        }
+    }
+
+    pub fn denominator(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Option<Value> {
+        match rb_self.aspect_ratio.ratio {
+            PreferredRatio::Ratio(ratio) => Some(YNumber::new(ratio.1.0.get()).into_value_with(ruby)),
+            PreferredRatio::None => None,
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc, typed_data};
+use style::{properties::longhands::backdrop_filter::SpecifiedValue, values::specified::effects::Filter as SpecifiedFilter};
+
+use crate::{cached_value_list::CachedValueList, declarations::filter::filter_to_value};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BackdropFilter", mark)]
+pub struct YBackdropFilter {
+    values: CachedValueList<SpecifiedFilter>,
+}
+
+impl YBackdropFilter {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                filter_to_value(value, ruby)
+            }),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBackdropFilter {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::backface_visibility::T;
+
+#[magnus::wrap(class = "Yass::Declarations::BackfaceVisibility")]
+pub struct YBackfaceVisibility {
+    specified_value: T
+}
+
+impl YBackfaceVisibility {
+    pub fn new(specified_value: T) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.specified_value {
+            T::Visible => ruby.intern("visible"),
+            T::Hidden => ruby.intern("hidden"),
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::properties::longhands::background_attachment::SpecifiedValue;
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::BackgroundAttachment")]
+pub struct YBackgroundAttachment {
+    specified_value: SpecifiedValue
+}
+
+impl YBackgroundAttachment {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for attachment in rb_self.specified_value.0.as_ref() {
+            let css = attachment.to_css_string();
+            result.push(ruby.intern(&css))?;
+        }
+
+        Ok(result)
+    }
+}

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

@@ -0,0 +1,42 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::properties::longhands::background_blend_mode::{SpecifiedValue, single_value::SpecifiedValue as SingleSpecifiedValue};
+
+#[magnus::wrap(class = "Yass::Declarations::BackgroundBlendMode")]
+pub struct YBackgroundBlendMode {
+    specified_value: SpecifiedValue
+}
+
+impl YBackgroundBlendMode {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for blend_mode in rb_self.specified_value.0.as_ref() {
+            let id = match blend_mode {
+                SingleSpecifiedValue::Normal => ruby.intern("normal"),
+                SingleSpecifiedValue::Multiply => ruby.intern("multiply"),
+                SingleSpecifiedValue::Screen => ruby.intern("screen"),
+                SingleSpecifiedValue::Overlay => ruby.intern("overlay"),
+                SingleSpecifiedValue::Darken => ruby.intern("darken"),
+                SingleSpecifiedValue::Lighten => ruby.intern("lighten"),
+                SingleSpecifiedValue::ColorDodge => ruby.intern("color_dodge"),
+                SingleSpecifiedValue::ColorBurn => ruby.intern("color_burn"),
+                SingleSpecifiedValue::HardLight => ruby.intern("hard_light"),
+                SingleSpecifiedValue::SoftLight => ruby.intern("soft_light"),
+                SingleSpecifiedValue::Difference => ruby.intern("difference"),
+                SingleSpecifiedValue::Exclusion => ruby.intern("exclusion"),
+                SingleSpecifiedValue::Hue => ruby.intern("hue"),
+                SingleSpecifiedValue::Saturation => ruby.intern("saturation"),
+                SingleSpecifiedValue::Color => ruby.intern("color"),
+                SingleSpecifiedValue::Luminosity => ruby.intern("luminosity"),
+            };
+
+            result.push(id)?;
+        }
+
+        Ok(result)
+    }
+}

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

@@ -0,0 +1,25 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::{OwnedSlice, computed_values::background_clip::SingleComputedValue};
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::BackgroundClip")]
+pub struct YBackgroundClip {
+    specified_value: OwnedSlice<SingleComputedValue>
+}
+
+impl YBackgroundClip {
+    pub fn new(specified_value: OwnedSlice<SingleComputedValue>) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.len());
+
+        for clip in rb_self.specified_value.as_ref() {
+            let css = clip.to_css_string();
+            result.push(ruby.intern(&css))?;
+        }
+
+        Ok(result)
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::Color;
+
+use crate::{cached_value::CachedValue, declarations::color::color::make_color};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BackgroundColor", mark)]
+pub struct YBackgroundColor {
+    color: CachedValue<Color>
+}
+
+impl YBackgroundColor {
+    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 YBackgroundColor {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc, typed_data};
+use style::properties::longhands::background_image::{SingleSpecifiedValue, SpecifiedValue};
+
+use crate::{cached_value_list::CachedValueList, declarations::images::image_to_value};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BackgroundImage", mark)]
+pub struct YBackgroundImage {
+    values: CachedValueList<SingleSpecifiedValue>,
+}
+
+impl YBackgroundImage {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                image_to_value(value, ruby)
+            }),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBackgroundImage {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}

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

@@ -0,0 +1,29 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::properties::longhands::background_origin::{SpecifiedValue, single_value::SpecifiedValue as SingleSpecifiedValue};
+
+#[magnus::wrap(class = "Yass::Declarations::BackgroundOrigin")]
+pub struct YBackgroundOrigin {
+    specified_value: SpecifiedValue
+}
+
+impl YBackgroundOrigin {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for origin in rb_self.specified_value.0.as_ref() {
+            let id = match origin {
+                SingleSpecifiedValue::PaddingBox => ruby.intern("padding_box"),
+                SingleSpecifiedValue::BorderBox => ruby.intern("border_box"),
+                SingleSpecifiedValue::ContentBox => ruby.intern("content_box"),
+            };
+
+            result.push(id)?;
+        }
+
+        Ok(result)
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc, typed_data};
+use style::properties::longhands::background_position_x::{SingleSpecifiedValue, SpecifiedValue};
+
+use crate::{cached_value_list::CachedValueList, declarations::horizontal_position_component::make_horizontal_position_component};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BackgroundPositionX", mark)]
+pub struct YBackgroundPositionX {
+    values: CachedValueList<SingleSpecifiedValue>,
+}
+
+impl YBackgroundPositionX {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |component, _ctx, ruby| {
+                make_horizontal_position_component(component, ruby)
+            }),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBackgroundPositionX {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc, typed_data};
+use style::properties::longhands::background_position_y::{SingleSpecifiedValue, SpecifiedValue};
+
+use crate::{cached_value_list::CachedValueList, declarations::vertical_position_component::make_vertical_position_component};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BackgroundPositionY", mark)]
+pub struct YBackgroundPositionY {
+    values: CachedValueList<SingleSpecifiedValue>,
+}
+
+impl YBackgroundPositionY {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |component, _ctx, ruby| {
+                make_vertical_position_component(component, ruby)
+            }),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBackgroundPositionY {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}

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

@@ -0,0 +1,58 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data, value::Id};
+use style::{properties::longhands::background_repeat::{SingleSpecifiedValue, SpecifiedValue}, values::specified::background::BackgroundRepeatKeyword};
+
+use crate::cached_value_list::CachedValueList;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BackgroundRepeat", mark)]
+pub struct YBackgroundRepeat {
+    values: CachedValueList<SingleSpecifiedValue>,
+}
+
+impl YBackgroundRepeat {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                YBackgroundRepeatValue::new(value.clone()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBackgroundRepeat {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::BackgroundRepeatValue")]
+pub struct YBackgroundRepeatValue {
+    background_repeat: SingleSpecifiedValue,
+}
+
+impl YBackgroundRepeatValue {
+    pub fn new(background_repeat: SingleSpecifiedValue) -> Self {
+        Self { background_repeat }
+    }
+
+    pub fn horizontal(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        background_repeat_keyword_to_id(&rb_self.background_repeat.0, ruby)
+    }
+
+    pub fn vertical(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        background_repeat_keyword_to_id(&rb_self.background_repeat.1, ruby)
+    }
+}
+
+fn background_repeat_keyword_to_id(keyword: &BackgroundRepeatKeyword, ruby: &Ruby) -> Id {
+    match keyword {
+        BackgroundRepeatKeyword::Repeat => ruby.intern("repeat"),
+        BackgroundRepeatKeyword::Space => ruby.intern("space"),
+        BackgroundRepeatKeyword::Round => ruby.intern("round"),
+        BackgroundRepeatKeyword::NoRepeat => ruby.intern("no_repeat"),
+    }
+}

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

@@ -0,0 +1,120 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data};
+use style::{
+    properties::longhands::background_size::{SingleSpecifiedValue, SpecifiedValue},
+    values::specified::{background::BackgroundSize, length::NonNegativeLengthPercentageOrAuto},
+};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList, declarations::size::length_percentage_to_value};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BackgroundSize", mark)]
+pub struct YBackgroundSize {
+    values: CachedValueList<SingleSpecifiedValue>,
+}
+
+impl YBackgroundSize {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                make_background_size(value, ruby)
+            }),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBackgroundSize {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+pub fn make_background_size(value: &SingleSpecifiedValue, ruby: &Ruby) -> Value {
+    match value {
+        BackgroundSize::ExplicitSize { width, height } => {
+            YBackgroundSizeExplicitSize::new(width.clone(), height.clone()).into_value_with(ruby)
+        }
+        BackgroundSize::Cover => YBackgroundSizeCover::new().into_value_with(ruby),
+        BackgroundSize::Contain => YBackgroundSizeContain::new().into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BackgroundSize::ExplicitSize", mark)]
+pub struct YBackgroundSizeExplicitSize {
+    width: CachedValue<NonNegativeLengthPercentageOrAuto>,
+    height: CachedValue<NonNegativeLengthPercentageOrAuto>,
+}
+
+impl YBackgroundSizeExplicitSize {
+    pub fn new(
+        width: NonNegativeLengthPercentageOrAuto,
+        height: NonNegativeLengthPercentageOrAuto,
+    ) -> Self {
+        Self {
+            width: CachedValue::new(width, |width, ruby| {
+                length_percentage_or_auto_to_value(width, ruby)
+            }),
+            height: CachedValue::new(height, |height, ruby| {
+                length_percentage_or_auto_to_value(height, ruby)
+            }),
+        }
+    }
+
+    pub fn width(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.width.get(ruby)
+    }
+
+    pub fn height(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.height.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBackgroundSizeExplicitSize {
+    fn mark(&self, marker: &gc::Marker) {
+        self.width.mark(marker);
+        self.height.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::BackgroundSize::Cover")]
+pub struct YBackgroundSizeCover {}
+
+impl YBackgroundSizeCover {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::BackgroundSize::Contain")]
+pub struct YBackgroundSizeContain {}
+
+impl YBackgroundSizeContain {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::BackgroundSize::Auto")]
+pub struct YBackgroundSizeAuto {}
+
+impl YBackgroundSizeAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+fn length_percentage_or_auto_to_value(
+    value: &NonNegativeLengthPercentageOrAuto,
+    ruby: &Ruby,
+) -> Value {
+    match value {
+        NonNegativeLengthPercentageOrAuto::Auto => YBackgroundSizeAuto::new().into_value_with(ruby),
+        NonNegativeLengthPercentageOrAuto::LengthPercentage(length_percentage) => {
+            length_percentage_to_value(&length_percentage.0, ruby)
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{generics::box_::BaselineShiftKeyword, specified::{BaselineShift, LengthPercentage}};
+
+use crate::{cached_value::CachedValue, declarations::size::length_percentage_to_value};
+
+pub fn make_baseline_shift(baseline_shift: &BaselineShift, ruby: &Ruby) -> Value {
+    match baseline_shift {
+        BaselineShift::Keyword(keyword) => {
+            YBaselineShiftKeyword::new(keyword.clone()).into_value_with(ruby)
+        },
+
+        BaselineShift::Length(length_percentage) => {
+            YBaselineShiftLength::new(length_percentage.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::BaselineShift::Keyword")]
+pub struct YBaselineShiftKeyword {
+    keyword: BaselineShiftKeyword,
+}
+
+impl YBaselineShiftKeyword {
+    pub fn new(keyword: BaselineShiftKeyword) -> Self {
+        Self { keyword }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match &rb_self.keyword {
+            BaselineShiftKeyword::Sub => ruby.intern("sub"),
+            BaselineShiftKeyword::Super => ruby.intern("super"),
+            BaselineShiftKeyword::Top => ruby.intern("top"),
+            BaselineShiftKeyword::Center => ruby.intern("center"),
+            BaselineShiftKeyword::Bottom => ruby.intern("bottom"),
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BaselineShift::Length", mark)]
+pub struct YBaselineShiftLength {
+    value: CachedValue<LengthPercentage>,
+}
+
+impl YBaselineShiftLength {
+    pub fn new(length_percentage: LengthPercentage) -> Self {
+        Self {
+            value: CachedValue::new(length_percentage, |length_percentage, ruby| {
+                length_percentage_to_value(length_percentage, ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBaselineShiftLength {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}

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

@@ -0,0 +1,21 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::BaselineSource;
+
+#[magnus::wrap(class = "Yass::Declarations::BaselineSource")]
+pub struct YBaselineSource {
+    baseline_source: BaselineSource
+}
+
+impl YBaselineSource {
+    pub fn new(baseline_source: BaselineSource) -> Self {
+        Self { baseline_source }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.baseline_source {
+            BaselineSource::Auto => ruby.intern("auto"),
+            BaselineSource::First => ruby.intern("first"),
+            BaselineSource::Last => ruby.intern("last"),
+        }
+    }
+}

data/ext/yass/src/declarations/block_size.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::BlockSize", mark)]
+pub struct YBlockSize {
+    size: CachedValue<Size>
+}
+
+impl YBlockSize {
+    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 YBlockSize {
+    fn mark(&self, marker: &gc::Marker) {
+        self.size.mark(marker);
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::Color;
+
+use crate::{cached_value::CachedValue, declarations::color::color::make_color};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BorderBlockEndColor", mark)]
+pub struct YBorderBlockEndColor {
+    color: CachedValue<Color>
+}
+
+impl YBorderBlockEndColor {
+    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 YBorderBlockEndColor {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+    }
+}