yass-css 0.2.0

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

@@ -0,0 +1,275 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{
+    generics::{
+        motion::RaySize,
+        position::GenericPositionOrAuto,
+    },
+    specified::{
+        Angle,
+        PositionComponent,
+        motion::{CoordBox, OffsetPath, OffsetPathFunction, RayFunction},
+        position::{HorizontalPositionKeyword, VerticalPositionKeyword},
+    },
+};
+use style_traits::ToCss;
+
+use crate::{
+    cached_value::CachedValue,
+    declarations::{
+        angle::YAngle,
+        clip_path::{make_basic_shape, ClipPathBasicShape},
+        horizontal_position_component::make_horizontal_position_component,
+        vertical_position_component::make_vertical_position_component,
+    },
+};
+
+type OffsetPathPositionOrAuto = GenericPositionOrAuto<
+    style::values::generics::position::GenericPosition<
+        PositionComponent<HorizontalPositionKeyword>,
+        PositionComponent<VerticalPositionKeyword>,
+    >
+>;
+
+fn coord_box_to_id(coord_box: CoordBox, ruby: &Ruby) -> Id {
+    match coord_box {
+        CoordBox::ContentBox => ruby.intern("content_box"),
+        CoordBox::PaddingBox => ruby.intern("padding_box"),
+        CoordBox::BorderBox => ruby.intern("border_box"),
+        CoordBox::FillBox => ruby.intern("fill_box"),
+        CoordBox::StrokeBox => ruby.intern("stroke_box"),
+        CoordBox::ViewBox => ruby.intern("view_box"),
+    }
+}
+
+fn ray_size_to_id(ray_size: RaySize, ruby: &Ruby) -> Id {
+    match ray_size {
+        RaySize::ClosestSide => ruby.intern("closest_side"),
+        RaySize::ClosestCorner => ruby.intern("closest_corner"),
+        RaySize::FarthestSide => ruby.intern("farthest_side"),
+        RaySize::FarthestCorner => ruby.intern("farthest_corner"),
+        RaySize::Sides => ruby.intern("sides"),
+    }
+}
+
+fn make_offset_path_position_or_auto(position: &OffsetPathPositionOrAuto, ruby: &Ruby) -> Value {
+    match position {
+        GenericPositionOrAuto::Auto => YOffsetPathPositionAuto::new().into_value_with(ruby),
+        GenericPositionOrAuto::Position(pos) => {
+            YOffsetPathPosition::new(pos.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+fn make_offset_path_function(path: &OffsetPathFunction, ruby: &Ruby) -> Value {
+    match path {
+        OffsetPathFunction::Ray(ray) => {
+            YOffsetPathRay::new(ray.clone()).into_value_with(ruby)
+        }
+        OffsetPathFunction::Url(url) => {
+            YOffsetPathUrl::new(url.to_css_string()).into_value_with(ruby)
+        }
+        OffsetPathFunction::Shape(basic_shape) => {
+            make_basic_shape(basic_shape as &ClipPathBasicShape, ruby)
+        }
+    }
+}
+
+fn make_offset_path(offset_path: &OffsetPath, ruby: &Ruby) -> Value {
+    match offset_path {
+        OffsetPath::None => YOffsetPathNone::new().into_value_with(ruby),
+        OffsetPath::CoordBox(coord_box) => {
+            YOffsetPathCoordBox::new(*coord_box).into_value_with(ruby)
+        }
+        OffsetPath::OffsetPath { path, coord_box } => {
+            YOffsetPathFunction::new((**path).clone(), *coord_box).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::OffsetPath", mark)]
+pub struct YOffsetPath {
+    value: CachedValue<OffsetPath>,
+}
+
+impl YOffsetPath {
+    pub fn new(offset_path: OffsetPath) -> Self {
+        Self {
+            value: CachedValue::new(offset_path, make_offset_path),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YOffsetPath {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::OffsetPath::None")]
+pub struct YOffsetPathNone {}
+
+impl YOffsetPathNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::OffsetPath::CoordBox")]
+pub struct YOffsetPathCoordBox {
+    coord_box: CoordBox,
+}
+
+impl YOffsetPathCoordBox {
+    pub fn new(coord_box: CoordBox) -> Self {
+        Self { coord_box }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        coord_box_to_id(rb_self.coord_box, ruby)
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::OffsetPath::Function", mark)]
+pub struct YOffsetPathFunction {
+    path: CachedValue<OffsetPathFunction>,
+    coord_box: CoordBox,
+}
+
+impl YOffsetPathFunction {
+    pub fn new(path: OffsetPathFunction, coord_box: CoordBox) -> Self {
+        Self {
+            path: CachedValue::new(path, make_offset_path_function),
+            coord_box,
+        }
+    }
+
+    pub fn path(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.path.get(ruby)
+    }
+
+    pub fn coord_box(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        coord_box_to_id(rb_self.coord_box, ruby)
+    }
+}
+
+impl DataTypeFunctions for YOffsetPathFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.path.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::OffsetPath::Ray", mark)]
+pub struct YOffsetPathRay {
+    angle: CachedValue<Angle>,
+    size: RaySize,
+    contain: bool,
+    position: CachedValue<OffsetPathPositionOrAuto>,
+}
+
+impl YOffsetPathRay {
+    pub fn new(ray: RayFunction) -> Self {
+        Self {
+            angle: CachedValue::new(ray.angle, |angle, ruby| {
+                YAngle::new(*angle).into_value_with(ruby)
+            }),
+
+            size: ray.size,
+            contain: ray.contain,
+            position: CachedValue::new(ray.position, make_offset_path_position_or_auto),
+        }
+    }
+
+    pub fn angle(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.angle.get(ruby)
+    }
+
+    pub fn size(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        ray_size_to_id(rb_self.size, ruby)
+    }
+
+    pub fn contain(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain
+    }
+
+    pub fn position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.position.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YOffsetPathRay {
+    fn mark(&self, marker: &gc::Marker) {
+        self.angle.mark(marker);
+        self.position.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::OffsetPath::Url")]
+pub struct YOffsetPathUrl {
+    css: String,
+}
+
+impl YOffsetPathUrl {
+    pub fn new(css: String) -> Self {
+        Self { css }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        ruby.str_new(&rb_self.css).into_value_with(ruby)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::OffsetPath::PositionAuto")]
+pub struct YOffsetPathPositionAuto {}
+
+impl YOffsetPathPositionAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::OffsetPath::Position", mark)]
+pub struct YOffsetPathPosition {
+    horizontal: CachedValue<PositionComponent<HorizontalPositionKeyword>>,
+    vertical: CachedValue<PositionComponent<VerticalPositionKeyword>>,
+}
+
+impl YOffsetPathPosition {
+    pub fn new(
+        position: style::values::generics::position::GenericPosition<
+            PositionComponent<HorizontalPositionKeyword>,
+            PositionComponent<VerticalPositionKeyword>,
+        >,
+    ) -> Self {
+        Self {
+            horizontal: CachedValue::new(position.horizontal, |component, ruby| {
+                make_horizontal_position_component(component, ruby)
+            }),
+            vertical: CachedValue::new(position.vertical, |component, ruby| {
+                make_vertical_position_component(component, ruby)
+            }),
+        }
+    }
+
+    pub fn horizontal(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.horizontal.get(ruby)
+    }
+
+    pub fn vertical(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.vertical.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YOffsetPathPosition {
+    fn mark(&self, marker: &gc::Marker) {
+        self.horizontal.mark(marker);
+        self.vertical.mark(marker);
+    }
+}

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

@@ -0,0 +1,39 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::Opacity;
+use style_traits::ToCss;
+
+use crate::{cached_value::CachedValue, declarations::number::YNumber};
+
+fn opacity_to_value(opacity: &Opacity, ruby: &Ruby) -> Value {
+    let css = opacity.to_css_string();
+
+    if let Ok(number) = css.parse::<f32>() {
+        return YNumber::new(number).into_value_with(ruby);
+    }
+
+    ruby.str_new(&css).into_value_with(ruby)
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Opacity", mark)]
+pub struct YOpacity {
+    value: CachedValue<Opacity>,
+}
+
+impl YOpacity {
+    pub fn new(opacity: Opacity) -> Self {
+        Self {
+            value: CachedValue::new(opacity, opacity_to_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YOpacity {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}

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

@@ -0,0 +1,17 @@
+use magnus::{Ruby, typed_data};
+use style::values::specified::Integer;
+
+#[magnus::wrap(class = "Yass::Declarations::Order")]
+pub struct YOrder {
+    integer: Integer
+}
+
+impl YOrder {
+    pub fn new(integer: Integer) -> Self {
+        Self { integer }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> i32 {
+        rb_self.integer.value()
+    }
+}

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

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

@@ -0,0 +1,22 @@
+use magnus::{IntoValue, Ruby, Value, typed_data};
+use style::values::specified::BorderSideOffset;
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::OutlineOffset")]
+pub struct YOutlineOffset {
+    border_side_offset: BorderSideOffset
+}
+
+impl YOutlineOffset {
+    pub fn new(border_side_offset: BorderSideOffset) -> Self {
+        Self { border_side_offset }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        // BorderSideOffset wraps Length with a private field, so we have to use
+        // to_css_string instead
+        ruby
+            .str_new(&rb_self.border_side_offset.to_css_string())
+            .into_value_with(ruby)
+    }
+}

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

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

data/ext/yass/src/declarations/outline_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::OutlineWidth")]
+pub struct YOutlineWidth {
+    border_side_width: BorderSideWidth
+}
+
+impl YOutlineWidth {
+    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/overflow.rs

@@ -0,0 +1,12 @@
+use magnus::{Ruby, value::Id};
+use style::values::computed::Overflow;
+
+pub fn overflow_to_id(overflow: &Overflow, ruby: &Ruby) -> Id {
+    match overflow {
+        Overflow::Visible => ruby.intern("visible"),
+        Overflow::Hidden => ruby.intern("hidden"),
+        Overflow::Scroll => ruby.intern("scroll"),
+        Overflow::Auto => ruby.intern("auto"),
+        Overflow::Clip => ruby.intern("clip"),
+    }
+}

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

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

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

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{generics::box_::OverflowClipMarginBox, specified::OverflowClipMargin};
+
+use crate::{cached_value::CachedValue, declarations::length::length_to_value};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::OverflowClipMargin", mark)]
+pub struct YOverflowClipMargin {
+    offset: CachedValue<OverflowClipMargin>,
+    visual_box: OverflowClipMarginBox,
+}
+
+impl YOverflowClipMargin {
+    pub fn new(overflow_clip_margin: OverflowClipMargin) -> Self {
+        Self {
+            visual_box: overflow_clip_margin.visual_box,
+            offset: CachedValue::new(overflow_clip_margin, |overflow_clip_margin, ruby| {
+                length_to_value(&overflow_clip_margin.offset.0, ruby)
+            }),
+        }
+    }
+
+    pub fn offset(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.offset.get(ruby)
+    }
+
+    pub fn visual_box(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.visual_box {
+            OverflowClipMarginBox::ContentBox => ruby.intern("content_box"),
+            OverflowClipMarginBox::PaddingBox => ruby.intern("padding_box"),
+            OverflowClipMarginBox::BorderBox => ruby.intern("border_box"),
+        }
+    }
+}
+
+impl DataTypeFunctions for YOverflowClipMargin {
+    fn mark(&self, marker: &gc::Marker) {
+        self.offset.mark(marker);
+    }
+}

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

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

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

@@ -0,0 +1,21 @@
+use style::values::computed::OverflowWrap;
+use magnus::{Ruby, typed_data, value::Id};
+
+#[magnus::wrap(class = "Yass::Declarations::OverflowWrap")]
+pub struct YOverflowWrap {
+    overflow_wrap: OverflowWrap
+}
+
+impl YOverflowWrap {
+    pub fn new(overflow_wrap: OverflowWrap) -> Self {
+        Self { overflow_wrap }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.overflow_wrap {
+            OverflowWrap::Normal => ruby.intern("normal"),
+            OverflowWrap::BreakWord => ruby.intern("break_word"),
+            OverflowWrap::Anywhere => ruby.intern("anywhere"),
+        }
+    }
+}

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

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

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

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

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

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

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

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

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

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