yass-css 0.2.0

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

@@ -0,0 +1,107 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, RString, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{computed::Quotes, specified::list::{QuoteList, QuotePair}};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList};
+
+fn make_quotes_value(quotes: &Quotes, ruby: &Ruby) -> Value {
+    match quotes {
+        Quotes::Auto => YQuotesAuto::new().into_value_with(ruby),
+        Quotes::QuoteList(quote_list) if quote_list.0.is_empty() => {
+            YQuotesNone::new().into_value_with(ruby)
+        }
+        Quotes::QuoteList(quote_list) => {
+            YQuotesQuoteList::new(quote_list.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Quotes", mark)]
+pub struct YQuotes {
+    quotes: CachedValue<Quotes>,
+}
+
+impl YQuotes {
+    pub fn new(quotes: Quotes) -> Self {
+        Self {
+            quotes: CachedValue::new(quotes, make_quotes_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.quotes.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YQuotes {
+    fn mark(&self, marker: &gc::Marker) {
+        self.quotes.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Quotes::Auto")]
+pub struct YQuotesAuto {}
+
+impl YQuotesAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Quotes::None")]
+pub struct YQuotesNone {}
+
+impl YQuotesNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Quotes::QuoteList", mark)]
+pub struct YQuotesQuoteList {
+    values: CachedValueList<QuotePair>,
+}
+
+impl YQuotesQuoteList {
+    pub fn new(quote_list: QuoteList) -> Self {
+        Self {
+            values: CachedValueList::new(quote_list.0.iter().cloned().collect(), |quote_pair, _ctx, ruby| {
+                YQuotesQuotePair::new(quote_pair.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 YQuotesQuoteList {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Quotes::QuotePair")]
+pub struct YQuotesQuotePair {
+    opening: String,
+    closing: String,
+}
+
+impl YQuotesQuotePair {
+    pub fn new(quote_pair: QuotePair) -> Self {
+        Self {
+            opening: quote_pair.opening.to_string(),
+            closing: quote_pair.closing.to_string(),
+        }
+    }
+
+    pub fn opening(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.opening)
+    }
+
+    pub fn closing(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.closing)
+    }
+}

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

@@ -0,0 +1,17 @@
+use magnus::{Ruby, typed_data};
+use style::values::specified::Resolution;
+
+#[magnus::wrap(class = "Yass::Declarations::Resolution")]
+pub struct YResolution {
+    resolution: Resolution
+}
+
+impl YResolution {
+    pub fn new(resolution: Resolution) -> Self {
+        Self { resolution }
+    }
+
+    pub fn dpi(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.resolution.dpi()
+    }
+}

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

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

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

@@ -0,0 +1,103 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::transform::Rotate, specified::{Angle, Number}};
+
+use crate::{cached_value::CachedValue, declarations::{angle::YAngle, number::YNumber}};
+
+fn make_rotate_value(value: &Rotate<Number, Angle>, ruby: &Ruby) -> Value {
+    match value {
+        Rotate::None => YRotateNone::new().into_value_with(ruby),
+        Rotate::Rotate(angle) => YAngle::new(angle.clone()).into_value_with(ruby),
+        Rotate::Rotate3D(x, y, z, angle) => {
+            YRotate3D::new(*x, *y, *z, *angle).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Rotate", mark)]
+pub struct YRotate {
+    value: CachedValue<Rotate<Number, Angle>>,
+}
+
+impl YRotate {
+    pub fn new(specified_value: Box<Rotate<Number, Angle>>) -> Self {
+        Self {
+            value: CachedValue::new(*specified_value, make_rotate_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YRotate {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Rotate::None")]
+pub struct YRotateNone {}
+
+impl YRotateNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Rotate::Rotate3D", mark)]
+pub struct YRotate3D {
+    x: CachedValue<Number>,
+    y: CachedValue<Number>,
+    z: CachedValue<Number>,
+    angle: CachedValue<Angle>,
+}
+
+impl YRotate3D {
+    pub fn new(x: Number, y: Number, z: Number, angle: Angle) -> Self {
+        Self {
+            x: CachedValue::new(x, |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+
+            y: CachedValue::new(y, |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+
+            z: CachedValue::new(z, |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+
+            angle: CachedValue::new(angle, |angle, ruby| {
+                YAngle::new(*angle).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn x(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.x.get(ruby)
+    }
+
+    pub fn y(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.y.get(ruby)
+    }
+
+    pub fn z(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.z.get(ruby)
+    }
+
+    pub fn angle(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.angle.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YRotate3D {
+    fn mark(&self, marker: &gc::Marker) {
+        self.x.mark(marker);
+        self.y.mark(marker);
+        self.z.mark(marker);
+        self.angle.mark(marker);
+    }
+}

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

@@ -0,0 +1,74 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::{generics::{NonNegative, length::LengthPercentageOrNormal}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::size::length_percentage_to_value};
+
+type RowGapValue = LengthPercentageOrNormal<NonNegative<LengthPercentage>>;
+
+fn row_gap_to_value(value: &RowGapValue, ruby: &Ruby) -> Value {
+    match value {
+        LengthPercentageOrNormal::Normal => YRowGapNormal::new().into_value_with(ruby),
+        LengthPercentageOrNormal::LengthPercentage(length_percentage) => {
+            YRowGapLengthPercentage::new(length_percentage.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::RowGap", mark)]
+pub struct YRowGap {
+    value: CachedValue<RowGapValue>,
+}
+
+impl YRowGap {
+    pub fn new(value: RowGapValue) -> Self {
+        Self {
+            value: CachedValue::new(value, row_gap_to_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YRowGap {
+    fn mark(&self, marker: &Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::RowGap::Normal")]
+pub struct YRowGapNormal {}
+
+impl YRowGapNormal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::RowGap::LengthPercentage", mark)]
+pub struct YRowGapLengthPercentage {
+    length_percentage: CachedValue<NonNegative<LengthPercentage>>,
+}
+
+impl YRowGapLengthPercentage {
+    pub fn new(length_percentage: NonNegative<LengthPercentage>) -> Self {
+        Self {
+            length_percentage: CachedValue::new(length_percentage, |value, ruby| {
+                length_percentage_to_value(&value.0, ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length_percentage.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YRowGapLengthPercentage {
+    fn mark(&self, marker: &Marker) {
+        self.length_percentage.mark(marker);
+    }
+}

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

@@ -0,0 +1,90 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::transform::Scale, specified::Number};
+
+use crate::{cached_value::CachedValue, declarations::number::YNumber};
+
+fn make_scale_value(value: &Scale<Number>, ruby: &Ruby) -> Value {
+    match value {
+        Scale::None => YScaleNone::new().into_value_with(ruby),
+        Scale::Scale(x, y, z) => YScaleCoords::new(*x, *y, *z).into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Scale", mark)]
+pub struct YScale {
+    value: CachedValue<Scale<Number>>,
+}
+
+impl YScale {
+    pub fn new(specified_value: Box<Scale<Number>>) -> Self {
+        Self {
+            value: CachedValue::new(*specified_value, make_scale_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YScale {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Scale::None")]
+pub struct YScaleNone {}
+
+impl YScaleNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Scale::Coords", mark)]
+pub struct YScaleCoords {
+    x: CachedValue<Number>,
+    y: CachedValue<Number>,
+    z: CachedValue<Number>,
+}
+
+impl YScaleCoords {
+    pub fn new(x: Number, y: Number, z: Number) -> Self {
+        Self {
+            x: CachedValue::new(x, |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+
+            y: CachedValue::new(y, |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+
+            z: CachedValue::new(z, |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn x(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.x.get(ruby)
+    }
+
+    pub fn y(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.y.get(ruby)
+    }
+
+    pub fn z(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.z.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YScaleCoords {
+    fn mark(&self, marker: &gc::Marker) {
+        self.x.mark(marker);
+        self.y.mark(marker);
+        self.z.mark(marker);
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::_servo_overflow_clip_box::T;
+
+#[magnus::wrap(class = "Yass::Declarations::ServoOverflowClipBox")]
+pub struct YServoOverflowClipBox {
+    specified_value: T
+}
+
+impl YServoOverflowClipBox {
+    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::PaddingBox => ruby.intern("padding_box"),
+            T::ContentBox => ruby.intern("content_box"),
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::_servo_top_layer::T;
+
+#[magnus::wrap(class = "Yass::Declarations::ServoTopLayer")]
+pub struct YServoTopLayer {
+    specified_value: T
+}
+
+impl YServoTopLayer {
+    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::None => ruby.intern("none"),
+            T::Top => ruby.intern("top"),
+        }
+    }
+}

data/ext/yass/src/declarations/size/anchor_max_size_function.rs

@@ -0,0 +1,53 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::{NonNegative, Optional, length::{AnchorSizeKeyword, GenericAnchorSizeFunction, MaxSize}}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::size::{anchor_size_keyword::YAnchorSizeKeyword, make_max_size}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Size::AnchorMaxSizeFunction", mark)]
+pub struct YAnchorMaxSizeFunction {
+    target_element: CachedValue<String>,
+    size: CachedValue<AnchorSizeKeyword>,
+    fallback: CachedValue<Optional<MaxSize<NonNegative<LengthPercentage>>>>
+}
+
+impl YAnchorMaxSizeFunction {
+    pub fn new(anchor_size: GenericAnchorSizeFunction<MaxSize<NonNegative<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_max_size(fb, ruby).into_value_with(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 YAnchorMaxSizeFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.target_element.mark(marker);
+        self.size.mark(marker);
+        self.fallback.mark(marker);
+    }
+}

data/ext/yass/src/declarations/size/anchor_size_function.rs

@@ -0,0 +1,56 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::{NonNegative, Optional, length::{AnchorSizeKeyword, GenericAnchorSizeFunction, Size}}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::size::{anchor_size_keyword::YAnchorSizeKeyword, make_size}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Size::AnchorSizeFunction", mark)]
+pub struct YAnchorSizeFunction {
+    target_element: CachedValue<String>,
+    size: CachedValue<AnchorSizeKeyword>,
+    fallback: CachedValue<Optional<Size<NonNegative<LengthPercentage>>>>
+}
+
+impl YAnchorSizeFunction {
+    pub fn new(anchor_size: GenericAnchorSizeFunction<Size<NonNegative<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_size(fb, ruby).into_value_with(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 YAnchorSizeFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.target_element.mark(marker);
+        self.size.mark(marker);
+        self.fallback.mark(marker);
+    }
+}

data/ext/yass/src/declarations/size/anchor_size_keyword.rs

@@ -0,0 +1,25 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::generics::length::AnchorSizeKeyword;
+
+#[magnus::wrap(class = "Yass::Declarations::Calc::AnchorSizeKeyword")]
+pub struct YAnchorSizeKeyword {
+    anchor_size_keyword: AnchorSizeKeyword
+}
+
+impl YAnchorSizeKeyword {
+    pub fn new(anchor_size_keyword: AnchorSizeKeyword) -> Self {
+        Self { anchor_size_keyword }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.anchor_size_keyword {
+            AnchorSizeKeyword::None => unreachable!(),
+            AnchorSizeKeyword::Width => ruby.intern("width"),
+            AnchorSizeKeyword::Height => ruby.intern("height"),
+            AnchorSizeKeyword::Block => ruby.intern("block"),
+            AnchorSizeKeyword::Inline => ruby.intern("inline"),
+            AnchorSizeKeyword::SelfBlock => ruby.intern("self_block"),
+            AnchorSizeKeyword::SelfInline => ruby.intern("self_inline"),
+        }
+    }
+}

data/ext/yass/src/declarations/size/init.rs

@@ -0,0 +1,45 @@
+use magnus::{Error, Module, RModule, Ruby, method};
+
+use crate::declarations::size::{YAnchorContainingCalcFunction, YFitContentFunction, YLengthPercentage, anchor_max_size_function::YAnchorMaxSizeFunction, anchor_size_function::YAnchorSizeFunction, anchor_size_keyword::YAnchorSizeKeyword};
+
+pub fn init(ruby: &Ruby, _yass_module: &RModule, declarations_module: &RModule) -> Result<(), Error> {
+    let size_module = declarations_module.define_module("Size")?;
+
+    let length_percentage_class = size_module.define_class("LengthPercentage", ruby.class_object())?;
+    length_percentage_class.define_method("value", method!(YLengthPercentage::value, 0))?;
+
+    let _none_class = size_module.define_class("None", ruby.class_object())?;
+
+    let _auto_class = size_module.define_class("Auto", ruby.class_object())?;
+
+    let _max_content_class = size_module.define_class("MaxContent", ruby.class_object())?;
+
+    let _min_content_class = size_module.define_class("MinContent", ruby.class_object())?;
+
+    let _fit_content_class = size_module.define_class("FitContent", ruby.class_object())?;
+
+    let _webkit_fill_available_class = size_module.define_class("WebkitFillAvailable", ruby.class_object())?;
+
+    let _stretch_class = size_module.define_class("Stretch", ruby.class_object())?;
+
+    let fit_content_function_class = size_module.define_class("FitContentFunction", ruby.class_object())?;
+    fit_content_function_class.define_method("value", method!(YFitContentFunction::value, 0))?;
+
+    let anchor_containing_calc_function_class = size_module.define_class("AnchorContainingCalcFunction", ruby.class_object())?;
+    anchor_containing_calc_function_class.define_method("value", method!(YAnchorContainingCalcFunction::value, 0))?;
+
+    let anchor_size_function_class = size_module.define_class("AnchorSizeFunction", ruby.class_object())?;
+    anchor_size_function_class.define_method("target_element", method!(YAnchorSizeFunction::target_element, 0))?;
+    anchor_size_function_class.define_method("size", method!(YAnchorSizeFunction::size, 0))?;
+    anchor_size_function_class.define_method("fallback", method!(YAnchorSizeFunction::fallback, 0))?;
+
+    let anchor_max_size_function_class = size_module.define_class("AnchorMaxSizeFunction", ruby.class_object())?;
+    anchor_max_size_function_class.define_method("target_element", method!(YAnchorMaxSizeFunction::target_element, 0))?;
+    anchor_max_size_function_class.define_method("size", method!(YAnchorMaxSizeFunction::size, 0))?;
+    anchor_max_size_function_class.define_method("fallback", method!(YAnchorMaxSizeFunction::fallback, 0))?;
+
+    let anchor_size_keyword_class = size_module.define_class("AnchorSizeKeyword", ruby.class_object())?;
+    anchor_size_keyword_class.define_method("value", method!(YAnchorSizeKeyword::value, 0))?;
+
+    Ok(())
+}