yass-css 0.2.0

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::direction::T;
+
+#[magnus::wrap(class = "Yass::Declarations::Direction")]
+pub struct YDirection {
+    specified_value: T
+}
+
+impl YDirection {
+    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::Ltr => ruby.intern("ltr"),
+            T::Rtl => ruby.intern("rtl"),
+        }
+    }
+}

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

@@ -0,0 +1,74 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::{computed::Display, specified::box_::{DisplayInside, DisplayOutside}};
+
+#[magnus::wrap(class = "Yass::Declarations::Display")]
+pub struct YDisplay {
+    display: Display
+}
+
+impl YDisplay {
+    pub fn new(display: Display) -> Self {
+        Self { display }
+    }
+
+    pub fn inside(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.display.inside() {
+            DisplayInside::None => ruby.intern("none"),
+            DisplayInside::Contents => ruby.intern("contents"),
+            DisplayInside::Flow => ruby.intern("flow"),
+            DisplayInside::FlowRoot => ruby.intern("flow_root"),
+            DisplayInside::Flex => ruby.intern("flex"),
+            DisplayInside::Grid => ruby.intern("grid"),
+            DisplayInside::Table => ruby.intern("table"),
+            DisplayInside::TableRowGroup => ruby.intern("table_row_group"),
+            DisplayInside::TableColumn => ruby.intern("table_column"),
+            DisplayInside::TableColumnGroup => ruby.intern("table_column_group"),
+            DisplayInside::TableHeaderGroup => ruby.intern("table_header_group"),
+            DisplayInside::TableFooterGroup => ruby.intern("table_footer_group"),
+            DisplayInside::TableRow => ruby.intern("table_row"),
+            DisplayInside::TableCell => ruby.intern("table_cell"),
+        }
+    }
+
+    pub fn outside(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.display.outside() {
+            DisplayOutside::None => ruby.intern("none"),
+            DisplayOutside::Inline => ruby.intern("inline"),
+            DisplayOutside::Block => ruby.intern("block"),
+            DisplayOutside::TableCaption => ruby.intern("table_caption"),
+            DisplayOutside::InternalTable => ruby.intern("internal_table"),
+        }
+    }
+
+    pub fn is_list_item(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.display.is_list_item()
+    }
+
+    pub fn is_contents(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.display.is_contents()
+    }
+
+    pub fn is_none(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.display.is_none()
+    }
+
+    pub fn is_inline_flow(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.display.is_inline_flow()
+    }
+
+    pub fn is_item_container(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.display.is_item_container()
+    }
+
+    pub fn is_line_participant(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.display.is_line_participant()
+    }
+
+    pub fn is_ruby_level_container(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.display.is_ruby_level_container()
+    }
+
+    pub fn is_ruby_type(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.display.is_ruby_type()
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::empty_cells::T;
+
+#[magnus::wrap(class = "Yass::Declarations::EmptyCells")]
+pub struct YEmptyCells {
+    specified_value: T
+}
+
+impl YEmptyCells {
+    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::Show => ruby.intern("show"),
+            T::Hide => ruby.intern("hide"),
+        }
+    }
+}

data/ext/yass/src/declarations/filter/blur.rs

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

data/ext/yass/src/declarations/filter/brightness.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::NonNegative, specified::effects::FilterFactor};
+
+use crate::cached_value::CachedValue;
+
+use super::filter_factor_to_value;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Filter::Brightness", mark)]
+pub struct YFilterBrightness {
+    factor: CachedValue<NonNegative<FilterFactor>>,
+}
+
+impl YFilterBrightness {
+    pub fn new(factor: NonNegative<FilterFactor>) -> Self {
+        Self {
+            factor: CachedValue::new(factor, |factor, ruby| filter_factor_to_value(&factor.0, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.factor.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFilterBrightness {
+    fn mark(&self, marker: &gc::Marker) {
+        self.factor.mark(marker);
+    }
+}

data/ext/yass/src/declarations/filter/contrast.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::NonNegative, specified::effects::FilterFactor};
+
+use crate::cached_value::CachedValue;
+
+use super::filter_factor_to_value;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Filter::Contrast", mark)]
+pub struct YFilterContrast {
+    factor: CachedValue<NonNegative<FilterFactor>>,
+}
+
+impl YFilterContrast {
+    pub fn new(factor: NonNegative<FilterFactor>) -> Self {
+        Self {
+            factor: CachedValue::new(factor, |factor, ruby| filter_factor_to_value(&factor.0, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.factor.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFilterContrast {
+    fn mark(&self, marker: &gc::Marker) {
+        self.factor.mark(marker);
+    }
+}

data/ext/yass/src/declarations/filter/drop_shadow.rs

@@ -0,0 +1,68 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{
+    generics::NonNegative,
+    specified::{Color, Length, effects::SimpleShadow},
+};
+
+use crate::{
+    cached_value::CachedValue,
+    declarations::{color::color::make_color, length::length_to_value},
+};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Filter::DropShadow", mark)]
+pub struct YFilterDropShadow {
+    color: CachedValue<Option<Color>>,
+    horizontal: CachedValue<Length>,
+    vertical: CachedValue<Length>,
+    blur: CachedValue<Option<NonNegative<Length>>>,
+}
+
+impl YFilterDropShadow {
+    pub fn new(shadow: SimpleShadow) -> Self {
+        Self {
+            color: CachedValue::new(shadow.color, |color, ruby| match color {
+                Some(color) => make_color(&color, ruby),
+                None => ruby.qnil().into_value_with(ruby),
+            }),
+
+            horizontal: CachedValue::new(shadow.horizontal, |horizontal, ruby| {
+                length_to_value(horizontal, ruby)
+            }),
+
+            vertical: CachedValue::new(shadow.vertical, |vertical, ruby| {
+                length_to_value(vertical, ruby)
+            }),
+
+            blur: CachedValue::new(shadow.blur, |blur, ruby| match blur {
+                Some(length) => length_to_value(&length.0, ruby),
+                None => ruby.qnil().into_value_with(ruby),
+            }),
+        }
+    }
+
+    pub fn color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color.get(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)
+    }
+
+    pub fn blur(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.blur.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFilterDropShadow {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+        self.horizontal.mark(marker);
+        self.vertical.mark(marker);
+        self.blur.mark(marker);
+    }
+}

data/ext/yass/src/declarations/filter/grayscale.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::ZeroToOne, specified::effects::FilterFactor};
+
+use crate::cached_value::CachedValue;
+
+use super::filter_factor_to_value;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Filter::Grayscale", mark)]
+pub struct YFilterGrayscale {
+    factor: CachedValue<ZeroToOne<FilterFactor>>,
+}
+
+impl YFilterGrayscale {
+    pub fn new(factor: ZeroToOne<FilterFactor>) -> Self {
+        Self {
+            factor: CachedValue::new(factor, |factor, ruby| filter_factor_to_value(&factor.0, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.factor.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFilterGrayscale {
+    fn mark(&self, marker: &gc::Marker) {
+        self.factor.mark(marker);
+    }
+}

data/ext/yass/src/declarations/filter/hue_rotate.rs

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

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

@@ -0,0 +1,43 @@
+use magnus::{Error, Module, RModule, Ruby, method};
+
+use crate::declarations::filter::{YFilter, blur::YFilterBlur, brightness::YFilterBrightness, contrast::YFilterContrast, drop_shadow::YFilterDropShadow, grayscale::YFilterGrayscale, hue_rotate::YFilterHueRotate, invert::YFilterInvert, opacity::YFilterOpacity, saturate::YFilterSaturate, sepia::YFilterSepia};
+
+pub fn init(ruby: &Ruby, _yass_module: &RModule, declarations_module: &RModule) -> Result<(), Error> {
+    let filter_class = declarations_module.define_class("Filter", ruby.class_object())?;
+    filter_class.define_method("values", method!(YFilter::values, 0))?;
+
+    let blur_class = filter_class.define_class("Blur", ruby.class_object())?;
+    blur_class.define_method("value", method!(YFilterBlur::value, 0))?;
+
+    let brightness_class = filter_class.define_class("Brightness", ruby.class_object())?;
+    brightness_class.define_method("value", method!(YFilterBrightness::value, 0))?;
+
+    let contrast_class = filter_class.define_class("Contrast", ruby.class_object())?;
+    contrast_class.define_method("value", method!(YFilterContrast::value, 0))?;
+
+    let drop_shadow_class = filter_class.define_class("DropShadow", ruby.class_object())?;
+    drop_shadow_class.define_method("color", method!(YFilterDropShadow::color, 0))?;
+    drop_shadow_class.define_method("horizontal", method!(YFilterDropShadow::horizontal, 0))?;
+    drop_shadow_class.define_method("vertical", method!(YFilterDropShadow::vertical, 0))?;
+    drop_shadow_class.define_method("blur", method!(YFilterDropShadow::blur, 0))?;
+
+    let grayscale_class = filter_class.define_class("Grayscale", ruby.class_object())?;
+    grayscale_class.define_method("value", method!(YFilterGrayscale::value, 0))?;
+
+    let hue_rotate_class = filter_class.define_class("HueRotate", ruby.class_object())?;
+    hue_rotate_class.define_method("value", method!(YFilterHueRotate::value, 0))?;
+
+    let invert_class = filter_class.define_class("Invert", ruby.class_object())?;
+    invert_class.define_method("value", method!(YFilterInvert::value, 0))?;
+
+    let opacity_class = filter_class.define_class("Opacity", ruby.class_object())?;
+    opacity_class.define_method("value", method!(YFilterOpacity::value, 0))?;
+
+    let saturate_class = filter_class.define_class("Saturate", ruby.class_object())?;
+    saturate_class.define_method("value", method!(YFilterSaturate::value, 0))?;
+
+    let sepia_class = filter_class.define_class("Sepia", ruby.class_object())?;
+    sepia_class.define_method("value", method!(YFilterSepia::value, 0))?;
+
+    Ok(())
+}

data/ext/yass/src/declarations/filter/invert.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::ZeroToOne, specified::effects::FilterFactor};
+
+use crate::cached_value::CachedValue;
+
+use super::filter_factor_to_value;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Filter::Invert", mark)]
+pub struct YFilterInvert {
+    factor: CachedValue<ZeroToOne<FilterFactor>>,
+}
+
+impl YFilterInvert {
+    pub fn new(factor: ZeroToOne<FilterFactor>) -> Self {
+        Self {
+            factor: CachedValue::new(factor, |factor, ruby| filter_factor_to_value(&factor.0, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.factor.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFilterInvert {
+    fn mark(&self, marker: &gc::Marker) {
+        self.factor.mark(marker);
+    }
+}

data/ext/yass/src/declarations/filter/mod.rs

@@ -0,0 +1,80 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data};
+use style::{
+    properties::longhands::filter::SpecifiedValue,
+    values::specified::effects::{Filter as SpecifiedFilter, FilterFactor},
+};
+use style_traits::ToCss;
+
+use crate::{
+    cached_value_list::CachedValueList, declarations::{filter::{blur::YFilterBlur, brightness::YFilterBrightness, contrast::YFilterContrast, drop_shadow::YFilterDropShadow, grayscale::YFilterGrayscale, hue_rotate::YFilterHueRotate, invert::YFilterInvert, opacity::YFilterOpacity, saturate::YFilterSaturate, sepia::YFilterSepia}, number::YNumber, percentage::YPercentage},
+};
+
+pub mod blur;
+pub mod brightness;
+pub mod contrast;
+pub mod drop_shadow;
+pub mod grayscale;
+pub mod hue_rotate;
+pub mod init;
+pub mod invert;
+pub mod opacity;
+pub mod saturate;
+pub mod sepia;
+
+fn filter_factor_css_to_value(css: &str, ruby: &Ruby) -> Value {
+    if let Some(percentage) = css.strip_suffix('%').and_then(|raw| raw.parse::<f32>().ok()) {
+        return YPercentage::new(percentage / 100.0).into_value_with(ruby);
+    }
+
+    if let Ok(number) = css.parse::<f32>() {
+        return YNumber::new(number).into_value_with(ruby);
+    }
+
+    ruby.str_new(css).into_value_with(ruby)
+}
+
+pub fn filter_factor_to_value(factor: &FilterFactor, ruby: &Ruby) -> Value {
+    filter_factor_css_to_value(&factor.to_css_string(), ruby)
+}
+
+pub fn filter_to_value(value: &SpecifiedFilter, ruby: &Ruby) -> Value {
+    match value {
+        SpecifiedFilter::Blur(length) => YFilterBlur::new(length.clone()).into_value_with(ruby),
+        SpecifiedFilter::Brightness(factor) => YFilterBrightness::new(factor.clone()).into_value_with(ruby),
+        SpecifiedFilter::Contrast(factor) => YFilterContrast::new(factor.clone()).into_value_with(ruby),
+        SpecifiedFilter::Grayscale(factor) => YFilterGrayscale::new(factor.clone()).into_value_with(ruby),
+        SpecifiedFilter::HueRotate(angle) => YFilterHueRotate::new(angle.clone()).into_value_with(ruby),
+        SpecifiedFilter::Invert(factor) => YFilterInvert::new(factor.clone()).into_value_with(ruby),
+        SpecifiedFilter::Opacity(factor) => YFilterOpacity::new(factor.clone()).into_value_with(ruby),
+        SpecifiedFilter::Saturate(factor) => YFilterSaturate::new(factor.clone()).into_value_with(ruby),
+        SpecifiedFilter::Sepia(factor) => YFilterSepia::new(factor.clone()).into_value_with(ruby),
+        SpecifiedFilter::DropShadow(shadow) => YFilterDropShadow::new(shadow.clone()).into_value_with(ruby),
+        SpecifiedFilter::Url(_) => unreachable!("servo specified filter URLs are impossible"),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Filter", mark)]
+pub struct YFilter {
+    values: CachedValueList<SpecifiedFilter>,
+}
+
+impl YFilter {
+    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 YFilter {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::ZeroToOne, specified::effects::FilterFactor};
+
+use crate::cached_value::CachedValue;
+
+use super::filter_factor_to_value;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Filter::Opacity", mark)]
+pub struct YFilterOpacity {
+    factor: CachedValue<ZeroToOne<FilterFactor>>,
+}
+
+impl YFilterOpacity {
+    pub fn new(factor: ZeroToOne<FilterFactor>) -> Self {
+        Self {
+            factor: CachedValue::new(factor, |factor, ruby| filter_factor_to_value(&factor.0, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.factor.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFilterOpacity {
+    fn mark(&self, marker: &gc::Marker) {
+        self.factor.mark(marker);
+    }
+}

data/ext/yass/src/declarations/filter/saturate.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::NonNegative, specified::effects::FilterFactor};
+
+use crate::cached_value::CachedValue;
+
+use super::filter_factor_to_value;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Filter::Saturate", mark)]
+pub struct YFilterSaturate {
+    factor: CachedValue<NonNegative<FilterFactor>>,
+}
+
+impl YFilterSaturate {
+    pub fn new(factor: NonNegative<FilterFactor>) -> Self {
+        Self {
+            factor: CachedValue::new(factor, |factor, ruby| filter_factor_to_value(&factor.0, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.factor.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFilterSaturate {
+    fn mark(&self, marker: &gc::Marker) {
+        self.factor.mark(marker);
+    }
+}

data/ext/yass/src/declarations/filter/sepia.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::ZeroToOne, specified::effects::FilterFactor};
+
+use crate::cached_value::CachedValue;
+
+use super::filter_factor_to_value;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Filter::Sepia", mark)]
+pub struct YFilterSepia {
+    factor: CachedValue<ZeroToOne<FilterFactor>>,
+}
+
+impl YFilterSepia {
+    pub fn new(factor: ZeroToOne<FilterFactor>) -> Self {
+        Self {
+            factor: CachedValue::new(factor, |factor, ruby| filter_factor_to_value(&factor.0, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.factor.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFilterSepia {
+    fn mark(&self, marker: &gc::Marker) {
+        self.factor.mark(marker);
+    }
+}

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

@@ -0,0 +1,71 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::{NonNegative, flex::FlexBasis, length::Size}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::size::make_size};
+
+fn make_flex_basis_value(
+    value: &FlexBasis<Size<NonNegative<LengthPercentage>>>,
+    ruby: &Ruby,
+) -> Value {
+    match value {
+        FlexBasis::Content => YFlexBasisContent::new().into_value_with(ruby),
+        FlexBasis::Size(size) => YFlexBasisSize::new(size.clone()).into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FlexBasis", mark)]
+pub struct YFlexBasis {
+    value: CachedValue<FlexBasis<Size<NonNegative<LengthPercentage>>>>,
+}
+
+impl YFlexBasis {
+    pub fn new(specified_value: Box<FlexBasis<Size<NonNegative<LengthPercentage>>>>) -> Self {
+        Self {
+            value: CachedValue::new(*specified_value, make_flex_basis_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFlexBasis {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FlexBasis::Content")]
+pub struct YFlexBasisContent {}
+
+impl YFlexBasisContent {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FlexBasis::Size", mark)]
+pub struct YFlexBasisSize {
+    size: CachedValue<Size<NonNegative<LengthPercentage>>>,
+}
+
+impl YFlexBasisSize {
+    pub fn new(size: Size<NonNegative<LengthPercentage>>) -> Self {
+        Self {
+            size: CachedValue::new(size, |size, ruby| make_size(size, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.size.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFlexBasisSize {
+    fn mark(&self, marker: &gc::Marker) {
+        self.size.mark(marker);
+    }
+}

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

@@ -0,0 +1,22 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::flex_direction::T;
+
+#[magnus::wrap(class = "Yass::Declarations::FlexDirection")]
+pub struct YFlexDirection {
+    specified_value: T
+}
+
+impl YFlexDirection {
+    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::Row => ruby.intern("row"),
+            T::RowReverse => ruby.intern("row_reverse"),
+            T::Column => ruby.intern("column"),
+            T::ColumnReverse => ruby.intern("column_reverse"),
+        }
+    }
+}