yass-css 0.2.0

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

@@ -0,0 +1,23 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::LineBreak;
+
+#[magnus::wrap(class = "Yass::Declarations::LineBreak")]
+pub struct YLineBreak {
+    line_break: LineBreak
+}
+
+impl YLineBreak {
+    pub fn new(line_break: LineBreak) -> Self {
+        Self { line_break }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.line_break {
+            LineBreak::Auto => ruby.intern("auto"),
+            LineBreak::Loose => ruby.intern("loose"),
+            LineBreak::Normal => ruby.intern("normal"),
+            LineBreak::Strict => ruby.intern("strict"),
+            LineBreak::Anywhere => ruby.intern("anywhere"),
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::generics::font::GenericLineHeight;
+use style::values::specified::{LineHeight};
+
+use crate::declarations::size::length_percentage_to_value;
+use crate::{cached_value::CachedValue, declarations::{number::YNumber}};
+
+fn make_line_height(line_height: &LineHeight, ruby: &Ruby) -> Value {
+    match line_height {
+        GenericLineHeight::Normal => YLineHeightNormal::new().into_value_with(ruby),
+        GenericLineHeight::Number(non_negative_number) => {
+            YNumber::new(non_negative_number.get()).into_value_with(ruby).into_value_with(ruby)
+        },
+        GenericLineHeight::Length(non_negative_lp) => {
+            length_percentage_to_value(&non_negative_lp.0, ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::LineHeight", mark)]
+pub struct YLineHeight {
+    value: CachedValue<LineHeight>,
+}
+
+impl YLineHeight {
+    pub fn new(line_height: LineHeight) -> Self {
+        Self {
+            value: CachedValue::new(line_height, make_line_height),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YLineHeight {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::LineHeight::Normal")]
+pub struct YLineHeightNormal {}
+
+impl YLineHeightNormal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}

data/ext/yass/src/declarations/list_style_image.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::ListStyleImage", mark)]
+pub struct YListStyleImage {
+    image: CachedValue<Image>,
+}
+
+impl YListStyleImage {
+    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 YListStyleImage {
+    fn mark(&self, marker: &gc::Marker) {
+        self.image.mark(marker);
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::list_style_position::T;
+
+#[magnus::wrap(class = "Yass::Declarations::ListStylePosition")]
+pub struct YListStylePosition {
+    specified_value: T
+}
+
+impl YListStylePosition {
+    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::Inside => ruby.intern("inside"),
+            T::Outside => ruby.intern("outside"),
+        }
+    }
+}

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

@@ -0,0 +1,132 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, RString, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::{counter_style::{CounterStyle, Symbol, Symbols, SymbolsType}, values::computed::ListStyleType};
+
+use crate::cached_value::CachedValue;
+
+fn make_list_style_type_value(list_style_type: &ListStyleType, ruby: &Ruby) -> Value {
+    match &list_style_type.0 {
+        CounterStyle::None => YListStyleTypeNone::new().into_value_with(ruby),
+        CounterStyle::Name(name) => YListStyleTypeName::new(name.0.to_string()).into_value_with(ruby),
+        CounterStyle::String(value) => YListStyleTypeString::new(value.to_string()).into_value_with(ruby),
+        CounterStyle::Symbols { ty, symbols } => {
+            YListStyleTypeSymbols::new(*ty, symbols.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+fn symbols_type_name(symbols_type: SymbolsType) -> &'static str {
+    match symbols_type {
+        SymbolsType::Cyclic => "cyclic",
+        SymbolsType::Numeric => "numeric",
+        SymbolsType::Alphabetic => "alphabetic",
+        SymbolsType::Symbolic => "symbolic",
+        SymbolsType::Fixed => "fixed",
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::ListStyleType", mark)]
+pub struct YListStyleType {
+    list_style_type: CachedValue<ListStyleType>,
+}
+
+impl YListStyleType {
+    pub fn new(list_style_type: ListStyleType) -> Self {
+        Self {
+            list_style_type: CachedValue::new(list_style_type, make_list_style_type_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.list_style_type.get(ruby)
+    }
+
+    pub fn bullet(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        if let Some(value) = &rb_self.list_style_type.value {
+            value.is_bullet()
+        } else {
+            false
+        }
+    }
+}
+
+impl DataTypeFunctions for YListStyleType {
+    fn mark(&self, marker: &gc::Marker) {
+        self.list_style_type.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ListStyleType::None")]
+pub struct YListStyleTypeNone {}
+
+impl YListStyleTypeNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ListStyleType::Name")]
+pub struct YListStyleTypeName {
+    name: String,
+}
+
+impl YListStyleTypeName {
+    pub fn new(name: String) -> Self {
+        Self { name }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: &Self) -> Id {
+        ruby.intern(&rb_self.name)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ListStyleType::String")]
+pub struct YListStyleTypeString {
+    value: String,
+}
+
+impl YListStyleTypeString {
+    pub fn new(value: String) -> Self {
+        Self { value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.value)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ListStyleType::Symbols")]
+pub struct YListStyleTypeSymbols {
+    kind: SymbolsType,
+    symbols: Vec<String>,
+}
+
+impl YListStyleTypeSymbols {
+    pub fn new(kind: SymbolsType, symbols: Symbols) -> Self {
+        Self {
+            kind,
+            symbols: symbols
+                .0
+                .iter()
+                .map(|symbol| match symbol {
+                    Symbol::String(value) => (&**value).to_owned(),
+                    Symbol::Ident(ident) => ident.0.to_string(),
+                })
+                .collect(),
+        }
+    }
+
+    pub fn ty(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.intern(symbols_type_name(rb_self.kind)).into_value_with(ruby)
+    }
+
+    pub fn symbols(ruby: &Ruby, rb_self: &Self) -> Result<RArray, Error> {
+        let array = ruby.ary_new_capa(rb_self.symbols.len());
+
+        for symbol in rb_self.symbols.iter() {
+            array.push(ruby.str_new(symbol))?;
+        }
+
+        Ok(array)
+    }
+}

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

@@ -0,0 +1,103 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::{Optional, length::{AnchorSizeKeyword, GenericAnchorSizeFunction, GenericMargin}}, specified::{LengthPercentage, Margin}};
+
+use crate::{cached_value::CachedValue, declarations::size::{YLengthPercentage, anchor_size_keyword::YAnchorSizeKeyword, length_percentage_to_value}};
+
+pub fn make_margin(margin: &Margin, ruby: &Ruby) -> Value {
+    match margin {
+        Margin::Auto => YMarginAuto::new().into_value_with(ruby),
+        Margin::LengthPercentage(length_percentage) => {
+            YLengthPercentage::new(length_percentage.clone()).into_value_with(ruby)
+        }
+        Margin::AnchorSizeFunction(anchor_size_function) => {
+            YMarginAnchorSizeFunction::new(*anchor_size_function.clone()).into_value_with(ruby)
+        }
+        Margin::AnchorContainingCalcFunction(length_percentage) => {
+            YMarginAnchorContainingCalcFunction::new(length_percentage.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Margin::Auto")]
+pub struct YMarginAuto {}
+
+impl YMarginAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Margin::AnchorContainingCalcFunction", mark)]
+pub struct YMarginAnchorContainingCalcFunction {
+    length_percentage: CachedValue<LengthPercentage>,
+}
+
+impl YMarginAnchorContainingCalcFunction {
+    pub fn new(length_percentage: LengthPercentage) -> Self {
+        Self {
+            length_percentage: CachedValue::new(length_percentage, |value, ruby| {
+                length_percentage_to_value(value, ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length_percentage.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YMarginAnchorContainingCalcFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length_percentage.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Margin::AnchorSizeFunction", mark)]
+pub struct YMarginAnchorSizeFunction {
+    target_element: CachedValue<String>,
+    size: CachedValue<AnchorSizeKeyword>,
+    fallback: CachedValue<Optional<GenericMargin<LengthPercentage>>>
+}
+
+impl YMarginAnchorSizeFunction {
+    pub fn new(anchor_size: GenericAnchorSizeFunction<GenericMargin<LengthPercentage>>) -> Self {
+        Self {
+            target_element: CachedValue::new(anchor_size.target_element.value.0.to_string(), |el, ruby| {
+                ruby.str_new(el).into_value_with(ruby)
+            }),
+
+            size: CachedValue::new(anchor_size.size, |size, ruby| {
+                YAnchorSizeKeyword::new(*size).into_value_with(ruby)
+            }),
+
+            fallback: CachedValue::new(anchor_size.fallback, |fallback, ruby| {
+                match fallback {
+                    Optional::Some(fb) => make_margin(fb, ruby),
+                    Optional::None => ruby.qnil().into_value_with(ruby)
+                }
+            })
+        }
+    }
+
+    pub fn target_element(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.target_element.get(ruby)
+    }
+
+    pub fn size(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.size.get(ruby)
+    }
+
+    pub fn fallback(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.fallback.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YMarginAnchorSizeFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.target_element.mark(marker);
+        self.size.mark(marker);
+        self.fallback.mark(marker);
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc, typed_data};
+use style::properties::longhands::mask_image::{SingleSpecifiedValue, SpecifiedValue};
+
+use crate::{cached_value_list::CachedValueList, declarations::images::image_to_value};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::MaskImage", mark)]
+pub struct YMaskImage {
+  values: CachedValueList<SingleSpecifiedValue>,
+}
+
+impl YMaskImage {
+  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 YMaskImage {
+  fn mark(&self, marker: &gc::Marker) {
+    self.values.mark(marker);
+  }
+}

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

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

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

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