yass-css 0.2.0

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

@@ -0,0 +1,19 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::BorderStyle;
+
+use crate::declarations::border_style::border_style_to_id;
+
+#[magnus::wrap(class = "Yass::Declarations::BorderBlockEndStyle")]
+pub struct YBorderBlockEndStyle {
+    border_style: BorderStyle
+}
+
+impl YBorderBlockEndStyle {
+    pub fn new(border_style: BorderStyle) -> Self {
+        Self { border_style }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        border_style_to_id(rb_self.border_style, ruby)
+    }
+}

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

@@ -0,0 +1,24 @@
+use magnus::{IntoValue, Ruby, Value, typed_data};
+use style::values::specified::BorderSideWidth;
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::BorderBlockEndWidth")]
+pub struct YBorderBlockEndWidth {
+    border_side_width: BorderSideWidth
+}
+
+impl YBorderBlockEndWidth {
+    pub fn new(border_side_width: BorderSideWidth) -> Self {
+        Self { border_side_width }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        // BorderSideWidth wraps LineWidth with a private field, so we have to use
+        // to_css_string instead.
+        let css = rb_self.border_side_width.to_css_string();
+        match css.as_str() {
+            keyword @ ("thin" | "medium" | "thick") => ruby.intern(keyword).into_value_with(ruby),
+            _ => ruby.str_new(&css).into_value_with(ruby),
+        }
+    }
+}

data/ext/yass/src/declarations/border_block_start_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::BorderBlockStartColor", mark)]
+pub struct YBorderBlockStartColor {
+    color: CachedValue<Color>
+}
+
+impl YBorderBlockStartColor {
+    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 YBorderBlockStartColor {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+    }
+}

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

@@ -0,0 +1,19 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::BorderStyle;
+
+use crate::declarations::border_style::border_style_to_id;
+
+#[magnus::wrap(class = "Yass::Declarations::BorderBlockStartStyle")]
+pub struct YBorderBlockStartStyle {
+    border_style: BorderStyle
+}
+
+impl YBorderBlockStartStyle {
+    pub fn new(border_style: BorderStyle) -> Self {
+        Self { border_style }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        border_style_to_id(rb_self.border_style, ruby)
+    }
+}

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

@@ -0,0 +1,24 @@
+use magnus::{IntoValue, Ruby, Value, typed_data};
+use style::values::specified::BorderSideWidth;
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::BorderBlockStartWidth")]
+pub struct YBorderBlockStartWidth {
+    border_side_width: BorderSideWidth
+}
+
+impl YBorderBlockStartWidth {
+    pub fn new(border_side_width: BorderSideWidth) -> Self {
+        Self { border_side_width }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        // BorderSideWidth wraps LineWidth with a private field, so we have to use
+        // to_css_string instead.
+        let css = rb_self.border_side_width.to_css_string();
+        match css.as_str() {
+            keyword @ ("thin" | "medium" | "thick") => ruby.intern(keyword).into_value_with(ruby),
+            _ => ruby.str_new(&css).into_value_with(ruby),
+        }
+    }
+}

data/ext/yass/src/declarations/border_bottom_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::BorderBottomColor", mark)]
+pub struct YBorderBottomColor {
+    color: CachedValue<Color>
+}
+
+impl YBorderBottomColor {
+    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 YBorderBottomColor {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+    }
+}

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

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::{NonNegative, border::BorderCornerRadius}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BorderBottomLeftRadius", mark)]
+pub struct YBorderBottomLeftRadius {
+    width: CachedValue<NonNegative<LengthPercentage>>,
+    height: CachedValue<NonNegative<LengthPercentage>>
+}
+
+impl YBorderBottomLeftRadius {
+    pub fn new(specified_value: Box<BorderCornerRadius<NonNegative<LengthPercentage>>>) -> Self {
+        Self {
+            width: CachedValue::new(specified_value.0.width, |width, ruby| {
+                YLengthPercentage::new(width.0.clone()).into_value_with(ruby)
+            }),
+
+            height: CachedValue::new(specified_value.0.height, |height, ruby| {
+                YLengthPercentage::new(height.0.clone()).into_value_with(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 YBorderBottomLeftRadius {
+    fn mark(&self, marker: &Marker) {
+        self.width.mark(marker);
+        self.height.mark(marker);
+    }
+}

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

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::{NonNegative, border::BorderCornerRadius}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BorderBottomRightRadius", mark)]
+pub struct YBorderBottomRightRadius {
+    width: CachedValue<NonNegative<LengthPercentage>>,
+    height: CachedValue<NonNegative<LengthPercentage>>
+}
+
+impl YBorderBottomRightRadius {
+    pub fn new(specified_value: Box<BorderCornerRadius<NonNegative<LengthPercentage>>>) -> Self {
+        Self {
+            width: CachedValue::new(specified_value.0.width, |width, ruby| {
+                YLengthPercentage::new(width.0.clone()).into_value_with(ruby)
+            }),
+
+            height: CachedValue::new(specified_value.0.height, |height, ruby| {
+                YLengthPercentage::new(height.0.clone()).into_value_with(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 YBorderBottomRightRadius {
+    fn mark(&self, marker: &Marker) {
+        self.width.mark(marker);
+        self.height.mark(marker);
+    }
+}

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

@@ -0,0 +1,19 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::BorderStyle;
+
+use crate::declarations::border_style::border_style_to_id;
+
+#[magnus::wrap(class = "Yass::Declarations::BorderBottomStyle")]
+pub struct YBorderBottomStyle {
+    border_style: BorderStyle
+}
+
+impl YBorderBottomStyle {
+    pub fn new(border_style: BorderStyle) -> Self {
+        Self { border_style }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        border_style_to_id(rb_self.border_style, ruby)
+    }
+}

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

@@ -0,0 +1,24 @@
+use magnus::{IntoValue, Ruby, Value, typed_data};
+use style::values::specified::BorderSideWidth;
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::BorderBottomWidth")]
+pub struct YBorderBottomWidth {
+    border_side_width: BorderSideWidth
+}
+
+impl YBorderBottomWidth {
+    pub fn new(border_side_width: BorderSideWidth) -> Self {
+        Self { border_side_width }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        // BorderSideWidth wraps LineWidth with a private field, so we have to use
+        // to_css_string instead.
+        let css = rb_self.border_side_width.to_css_string();
+        match css.as_str() {
+            keyword @ ("thin" | "medium" | "thick") => ruby.intern(keyword).into_value_with(ruby),
+            _ => ruby.str_new(&css).into_value_with(ruby),
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::properties::longhands::border_collapse::SpecifiedValue;
+
+#[magnus::wrap(class = "Yass::Declarations::BorderCollapse")]
+pub struct YBorderCollapse {
+    specified_value: SpecifiedValue
+}
+
+impl YBorderCollapse {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.specified_value {
+            SpecifiedValue::Separate => ruby.intern("separate"),
+            SpecifiedValue::Collapse => ruby.intern("collapse"),
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::{NonNegative, border::BorderCornerRadius}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BorderEndEndRadius", mark)]
+pub struct YBorderEndEndRadius {
+    width: CachedValue<NonNegative<LengthPercentage>>,
+    height: CachedValue<NonNegative<LengthPercentage>>
+}
+
+impl YBorderEndEndRadius {
+    pub fn new(specified_value: Box<BorderCornerRadius<NonNegative<LengthPercentage>>>) -> Self {
+        Self {
+            width: CachedValue::new(specified_value.0.width, |width, ruby| {
+                YLengthPercentage::new(width.0.clone()).into_value_with(ruby)
+            }),
+
+            height: CachedValue::new(specified_value.0.height, |height, ruby| {
+                YLengthPercentage::new(height.0.clone()).into_value_with(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 YBorderEndEndRadius {
+    fn mark(&self, marker: &Marker) {
+        self.width.mark(marker);
+        self.height.mark(marker);
+    }
+}

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

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::{NonNegative, border::BorderCornerRadius}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BorderEndStartRadius", mark)]
+pub struct YBorderEndStartRadius {
+    width: CachedValue<NonNegative<LengthPercentage>>,
+    height: CachedValue<NonNegative<LengthPercentage>>
+}
+
+impl YBorderEndStartRadius {
+    pub fn new(specified_value: Box<BorderCornerRadius<NonNegative<LengthPercentage>>>) -> Self {
+        Self {
+            width: CachedValue::new(specified_value.0.width, |width, ruby| {
+                YLengthPercentage::new(width.0.clone()).into_value_with(ruby)
+            }),
+
+            height: CachedValue::new(specified_value.0.height, |height, ruby| {
+                YLengthPercentage::new(height.0.clone()).into_value_with(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 YBorderEndStartRadius {
+    fn mark(&self, marker: &Marker) {
+        self.width.mark(marker);
+        self.height.mark(marker);
+    }
+}

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

@@ -0,0 +1,73 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::{NonNegative, length::LengthOrNumber, rect::Rect}, specified::{Length, Number}};
+
+use crate::{cached_value::CachedValue, declarations::{calc::YCalc, length::no_calc_length_to_value, number::YNumber}};
+
+type BorderImageOutsetValue = LengthOrNumber<NonNegative<Length>, NonNegative<Number>>;
+
+fn border_image_outset_value_to_ruby(value: &BorderImageOutsetValue, ruby: &Ruby) -> Value {
+    match value {
+        LengthOrNumber::Number(number) => YNumber::new(number.0.get()).into_value_with(ruby),
+
+        LengthOrNumber::Length(length) => match &length.0 {
+            Length::NoCalc(no_calc_length) => no_calc_length_to_value(no_calc_length, ruby),
+            Length::Calc(calc_length) => YCalc::new(calc_length.clone()).into_value_with(ruby),
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BorderImageOutset", mark)]
+pub struct YBorderImageOutset {
+    top: CachedValue<BorderImageOutsetValue>,
+    right: CachedValue<BorderImageOutsetValue>,
+    bottom: CachedValue<BorderImageOutsetValue>,
+    left: CachedValue<BorderImageOutsetValue>,
+}
+
+impl YBorderImageOutset {
+    pub fn new(specified_value: Box<Rect<BorderImageOutsetValue>>) -> Self {
+        Self {
+            top: CachedValue::new(specified_value.0, |value, ruby| {
+                border_image_outset_value_to_ruby(value, ruby)
+            }),
+
+            right: CachedValue::new(specified_value.1, |value, ruby| {
+                border_image_outset_value_to_ruby(value, ruby)
+            }),
+
+            bottom: CachedValue::new(specified_value.2, |value, ruby| {
+                border_image_outset_value_to_ruby(value, ruby)
+            }),
+
+            left: CachedValue::new(specified_value.3, |value, ruby| {
+                border_image_outset_value_to_ruby(value, ruby)
+            }),
+        }
+    }
+
+    pub fn top(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.top.get(ruby)
+    }
+
+    pub fn right(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.right.get(ruby)
+    }
+
+    pub fn bottom(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.bottom.get(ruby)
+    }
+
+    pub fn left(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.left.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBorderImageOutset {
+    fn mark(&self, marker: &Marker) {
+        self.top.mark(marker);
+        self.right.mark(marker);
+        self.bottom.mark(marker);
+        self.left.mark(marker);
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::specified::border::{BorderImageRepeat, BorderImageRepeatKeyword};
+
+#[magnus::wrap(class = "Yass::Declarations::BorderImageRepeat")]
+pub struct YBorderImageRepeat {
+    border_image_repeat: BorderImageRepeat,
+}
+
+impl YBorderImageRepeat {
+    pub fn new(border_image_repeat: BorderImageRepeat) -> Self {
+        Self { border_image_repeat }
+    }
+
+    pub fn horizontal(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        border_image_repeat_keyword_to_id(rb_self.border_image_repeat.0, ruby)
+    }
+
+    pub fn vertical(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        border_image_repeat_keyword_to_id(rb_self.border_image_repeat.1, ruby)
+    }
+}
+
+fn border_image_repeat_keyword_to_id(keyword: BorderImageRepeatKeyword, ruby: &Ruby) -> Id {
+    match keyword {
+        BorderImageRepeatKeyword::Stretch => ruby.intern("stretch"),
+        BorderImageRepeatKeyword::Repeat => ruby.intern("repeat"),
+        BorderImageRepeatKeyword::Round => ruby.intern("round"),
+        BorderImageRepeatKeyword::Space => ruby.intern("space"),
+    }
+}

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

@@ -0,0 +1,78 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::{NonNegative, border::BorderImageSlice}, specified::NumberOrPercentage};
+
+use crate::{cached_value::CachedValue, declarations::{number::YNumber, percentage::YPercentage}};
+
+type BorderImageSliceValue = NonNegative<NumberOrPercentage>;
+
+fn border_image_slice_value_to_ruby(value: &BorderImageSliceValue, ruby: &Ruby) -> Value {
+    match value.0 {
+        NumberOrPercentage::Number(number) => YNumber::new(number.get()).into_value_with(ruby),
+        NumberOrPercentage::Percentage(percentage) => {
+            YPercentage::new(percentage.get()).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BorderImageSlice", mark)]
+pub struct YBorderImageSlice {
+    top: CachedValue<BorderImageSliceValue>,
+    right: CachedValue<BorderImageSliceValue>,
+    bottom: CachedValue<BorderImageSliceValue>,
+    left: CachedValue<BorderImageSliceValue>,
+    fill: bool,
+}
+
+impl YBorderImageSlice {
+    pub fn new(specified_value: Box<BorderImageSlice<BorderImageSliceValue>>) -> Self {
+        Self {
+            top: CachedValue::new(specified_value.offsets.0, |value, ruby| {
+                border_image_slice_value_to_ruby(value, ruby)
+            }),
+
+            right: CachedValue::new(specified_value.offsets.1, |value, ruby| {
+                border_image_slice_value_to_ruby(value, ruby)
+            }),
+
+            bottom: CachedValue::new(specified_value.offsets.2, |value, ruby| {
+                border_image_slice_value_to_ruby(value, ruby)
+            }),
+
+            left: CachedValue::new(specified_value.offsets.3, |value, ruby| {
+                border_image_slice_value_to_ruby(value, ruby)
+            }),
+
+            fill: specified_value.fill,
+        }
+    }
+
+    pub fn top(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.top.get(ruby)
+    }
+
+    pub fn right(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.right.get(ruby)
+    }
+
+    pub fn bottom(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.bottom.get(ruby)
+    }
+
+    pub fn left(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.left.get(ruby)
+    }
+
+    pub fn fill(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.fill
+    }
+}
+
+impl DataTypeFunctions for YBorderImageSlice {
+    fn mark(&self, marker: &Marker) {
+        self.top.mark(marker);
+        self.right.mark(marker);
+        self.bottom.mark(marker);
+        self.left.mark(marker);
+    }
+}

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

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

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

@@ -0,0 +1,85 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::{NonNegative, border::BorderImageSideWidth, rect::Rect}, specified::{LengthPercentage, Number}};
+
+use crate::{cached_value::CachedValue, declarations::{number::YNumber, size::YLengthPercentage}};
+
+type BorderImageWidthValue = BorderImageSideWidth<NonNegative<LengthPercentage>, NonNegative<Number>>;
+
+fn border_image_width_value_to_ruby(value: &BorderImageWidthValue, ruby: &Ruby) -> Value {
+    match value {
+        BorderImageSideWidth::Number(number) => {
+            YNumber::new(number.get()).into_value_with(ruby)
+        }
+
+        BorderImageSideWidth::LengthPercentage(length_percentage) => {
+            YLengthPercentage::new(length_percentage.0.clone()).into_value_with(ruby)
+        }
+
+        BorderImageSideWidth::Auto => YBorderImageWidthAuto::new().into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BorderImageWidth", mark)]
+pub struct YBorderImageWidth {
+    top: CachedValue<BorderImageWidthValue>,
+    right: CachedValue<BorderImageWidthValue>,
+    bottom: CachedValue<BorderImageWidthValue>,
+    left: CachedValue<BorderImageWidthValue>,
+}
+
+impl YBorderImageWidth {
+    pub fn new(specified_value: Box<Rect<BorderImageWidthValue>>) -> Self {
+        Self {
+            top: CachedValue::new(specified_value.0, |value, ruby| {
+                border_image_width_value_to_ruby(value, ruby)
+            }),
+
+            right: CachedValue::new(specified_value.1, |value, ruby| {
+                border_image_width_value_to_ruby(value, ruby)
+            }),
+
+            bottom: CachedValue::new(specified_value.2, |value, ruby| {
+                border_image_width_value_to_ruby(value, ruby)
+            }),
+
+            left: CachedValue::new(specified_value.3, |value, ruby| {
+                border_image_width_value_to_ruby(value, ruby)
+            }),
+        }
+    }
+
+    pub fn top(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.top.get(ruby)
+    }
+
+    pub fn right(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.right.get(ruby)
+    }
+
+    pub fn bottom(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.bottom.get(ruby)
+    }
+
+    pub fn left(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.left.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YBorderImageWidth {
+    fn mark(&self, marker: &Marker) {
+        self.top.mark(marker);
+        self.right.mark(marker);
+        self.bottom.mark(marker);
+        self.left.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::BorderImageWidth::Auto")]
+pub struct YBorderImageWidthAuto {}
+
+impl YBorderImageWidthAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}