yass-css 0.2.0

data/ext/yass/src/declarations/color/light_dark.rs

@@ -0,0 +1,43 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{
+    generics::color::GenericLightDark,
+    specified::Color,
+};
+
+use crate::{cached_value::CachedValue, declarations::color::color::make_color};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Color::LightDark", mark)]
+pub struct YLightDark {
+    light: CachedValue<Color>,
+    dark: CachedValue<Color>,
+}
+
+impl YLightDark {
+    pub fn new(light_dark: GenericLightDark<Color>) -> Self {
+        Self {
+            light: CachedValue::new(light_dark.light, |color, ruby| {
+                make_color(&color, ruby)
+            }),
+
+            dark: CachedValue::new(light_dark.dark, |color, ruby| {
+                make_color(&color, ruby)
+            }),
+        }
+    }
+
+    pub fn light(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.light.get(ruby)
+    }
+
+    pub fn dark(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.dark.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YLightDark {
+    fn mark(&self, marker: &gc::Marker) {
+        self.light.mark(marker);
+        self.dark.mark(marker);
+    }
+}

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

@@ -0,0 +1,69 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::{
+    color::ColorSpace,
+    values::specified::{Color, ColorPropertyValue},
+};
+
+use crate::{cached_value::CachedValue, declarations::color::color::make_color};
+
+pub mod absolute_color;
+pub mod absolute;
+pub mod auto;
+pub mod color_components;
+pub mod color_function_component;
+pub mod color_function;
+pub mod color_interpolation_method;
+pub mod color_mix_item;
+pub mod color_mix;
+pub mod current_color;
+pub mod init;
+pub mod light_dark;
+pub mod color;
+pub mod stored_color_function_component;
+pub mod system_color;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Color", mark)]
+pub struct YColor {
+    color: CachedValue<Color>,
+}
+
+impl YColor {
+    pub fn new(color_property_value: ColorPropertyValue) -> Self {
+        Self {
+            color: CachedValue::new(color_property_value.0, |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 YColor {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+    }
+}
+
+pub fn color_space_to_id(color_space: ColorSpace, ruby: &Ruby) -> Id {
+    match color_space {
+        ColorSpace::Srgb => ruby.intern("srgb"),
+        ColorSpace::Hsl => ruby.intern("hsl"),
+        ColorSpace::Hwb => ruby.intern("hwb"),
+        ColorSpace::Lab => ruby.intern("lab"),
+        ColorSpace::Lch => ruby.intern("lch"),
+        ColorSpace::Oklab => ruby.intern("oklab"),
+        ColorSpace::Oklch => ruby.intern("oklch"),
+        ColorSpace::SrgbLinear => ruby.intern("srgb_linear"),
+        ColorSpace::DisplayP3 => ruby.intern("display_p3"),
+        ColorSpace::DisplayP3Linear => ruby.intern("display_p3_linear"),
+        ColorSpace::A98Rgb => ruby.intern("a98_rgb"),
+        ColorSpace::ProphotoRgb => ruby.intern("prophoto_rgb"),
+        ColorSpace::Rec2020 => ruby.intern("rec2020"),
+        ColorSpace::XyzD50 => ruby.intern("xyz_d50"),
+        ColorSpace::XyzD65 => ruby.intern("xyz_d65"),
+    }
+}

data/ext/yass/src/declarations/color/stored_color_function_component.rs

@@ -0,0 +1,70 @@
+use magnus::{IntoValue, Ruby, Value};
+use style::{color::{component::ColorComponent, parsing::{ChannelKeyword, NumberOrAngleComponent, NumberOrPercentageComponent}}, values::specified::{Angle, calc::CalcNode}};
+
+use crate::declarations::{angle::YAngle, number::YNumber, percentage::YPercentage};
+
+#[derive(Clone)]
+pub enum StoredColorFunctionComponent {
+    NumberOrPercentage(ColorComponent<NumberOrPercentageComponent>),
+    NumberOrAngle(ColorComponent<NumberOrAngleComponent>),
+}
+
+impl StoredColorFunctionComponent {
+    pub fn value(&self) -> Option<StoredColorComponentValue> {
+        match self {
+            Self::NumberOrPercentage(component) => match component {
+                ColorComponent::Value(NumberOrPercentageComponent::Number(value)) => Some(StoredColorComponentValue::Number(*value)),
+                ColorComponent::Value(NumberOrPercentageComponent::Percentage(value)) => Some(StoredColorComponentValue::Percentage(*value)),
+                _ => None,
+            },
+            Self::NumberOrAngle(component) => match component {
+                ColorComponent::Value(NumberOrAngleComponent::Number(value)) => Some(StoredColorComponentValue::Number(*value)),
+                ColorComponent::Value(NumberOrAngleComponent::Angle(value)) => Some(StoredColorComponentValue::Angle(*value)),
+                _ => None,
+            },
+        }
+    }
+
+    pub fn channel_keyword(&self) -> Option<ChannelKeyword> {
+        match self {
+            Self::NumberOrPercentage(component) => match component {
+                ColorComponent::ChannelKeyword(channel_keyword) => Some(*channel_keyword),
+                _ => None,
+            },
+            Self::NumberOrAngle(component) => match component {
+                ColorComponent::ChannelKeyword(channel_keyword) => Some(*channel_keyword),
+                _ => None,
+            },
+        }
+    }
+
+    pub fn calc_node(&self) -> Option<CalcNode> {
+        match self {
+            Self::NumberOrPercentage(component) => match component {
+                ColorComponent::Calc(calc_node) => Some((**calc_node).clone()),
+                _ => None,
+            },
+            Self::NumberOrAngle(component) => match component {
+                ColorComponent::Calc(calc_node) => Some((**calc_node).clone()),
+                _ => None,
+            },
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum StoredColorComponentValue {
+    Number(f32),
+    Percentage(f32),
+    Angle(f32),
+}
+
+impl StoredColorComponentValue {
+    pub fn to_value(&self, ruby: &Ruby) -> Value {
+        match self {
+            Self::Number(value) => YNumber::new(*value).into_value_with(ruby),
+            Self::Percentage(value) => YPercentage::new(*value).into_value_with(ruby),
+            Self::Angle(value) => YAngle::new(Angle::from_degrees(*value, false)).into_value_with(ruby),
+        }
+    }
+}

data/ext/yass/src/declarations/color/system_color.rs

@@ -0,0 +1,60 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::specified::color::SystemColor;
+
+#[magnus::wrap(class = "Yass::Declarations::Color::SystemColor")]
+pub struct YSystemColor {
+    system_color: SystemColor
+}
+
+impl YSystemColor {
+    pub fn new(system_color: SystemColor) -> Self {
+        Self { system_color }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.system_color {
+            SystemColor::Accentcolor => ruby.intern("accent_color"),
+            SystemColor::Accentcolortext => ruby.intern("accent_color_text"),
+            SystemColor::Activetext => ruby.intern("active_text"),
+            SystemColor::Linktext => ruby.intern("link_text"),
+            SystemColor::Visitedtext => ruby.intern("visited_text"),
+            SystemColor::Buttonborder => ruby.intern("button_border"),
+            SystemColor::Buttonface => ruby.intern("button_face"),
+            SystemColor::Buttontext => ruby.intern("button_text"),
+            SystemColor::Canvas => ruby.intern("canvas"),
+            SystemColor::Canvastext => ruby.intern("canvas_text"),
+            SystemColor::Field => ruby.intern("field"),
+            SystemColor::Fieldtext => ruby.intern("field_text"),
+            SystemColor::Graytext => ruby.intern("gray_text"),
+            SystemColor::Highlight => ruby.intern("highlight"),
+            SystemColor::Highlighttext => ruby.intern("highlight_text"),
+            SystemColor::Mark => ruby.intern("mark"),
+            SystemColor::Marktext => ruby.intern("mark_text"),
+            SystemColor::Selecteditem => ruby.intern("selected_item"),
+            SystemColor::Selecteditemtext => ruby.intern("selected_item_text"),
+            SystemColor::Activeborder => ruby.intern("active_border"),
+            SystemColor::Inactiveborder => ruby.intern("inactive_border"),
+            SystemColor::Threeddarkshadow => ruby.intern("threed_dark_shadow"),
+            SystemColor::Threedhighlight => ruby.intern("threed_highlight"),
+            SystemColor::Threedlightshadow => ruby.intern("threed_light_shadow"),
+            SystemColor::Threedshadow => ruby.intern("threed_shadow"),
+            SystemColor::Windowframe => ruby.intern("window_frame"),
+            SystemColor::Buttonhighlight => ruby.intern("button_highlight"),
+            SystemColor::Buttonshadow => ruby.intern("button_shadow"),
+            SystemColor::Threedface => ruby.intern("threed_face"),
+            SystemColor::Activecaption => ruby.intern("active_caption"),
+            SystemColor::Appworkspace => ruby.intern("app_workspace"),
+            SystemColor::Background => ruby.intern("background"),
+            SystemColor::Inactivecaption => ruby.intern("inactive_caption"),
+            SystemColor::Infobackground => ruby.intern("info_background"),
+            SystemColor::Menu => ruby.intern("menu"),
+            SystemColor::Scrollbar => ruby.intern("scrollbar"),
+            SystemColor::Window => ruby.intern("window"),
+            SystemColor::Captiontext => ruby.intern("caption_text"),
+            SystemColor::Infotext => ruby.intern("info_text"),
+            SystemColor::Menutext => ruby.intern("menu_text"),
+            SystemColor::Windowtext => ruby.intern("window_text"),
+            SystemColor::Inactivecaptiontext => ruby.intern("inactive_caption_text"),
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::values::{computed::ColorScheme};
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::ColorScheme")]
+pub struct YColorScheme {
+    color_scheme: ColorScheme
+}
+
+impl YColorScheme {
+    pub fn new(color_scheme: ColorScheme) -> Self {
+        Self { color_scheme }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let css = rb_self.color_scheme.to_css_string();
+        let idents: Vec<&str> = css.split_whitespace().collect();
+        let result = ruby.ary_new_capa(idents.len());
+
+        for ident in idents {
+            result.push(ruby.str_new(ident))?
+        }
+
+        Ok(result)
+    }
+}

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

@@ -0,0 +1,37 @@
+use magnus::{IntoValue, Ruby, Value, typed_data};
+use style::values::{generics::{GreaterThanOrEqualToOne, column::ColumnCount}, specified::Integer};
+
+pub fn make_column_count(column_count: &ColumnCount<GreaterThanOrEqualToOne<Integer>>, ruby: &Ruby) -> Value {
+    match column_count {
+        ColumnCount::Auto => YColumnCountAuto::new().into_value_with(ruby),
+        ColumnCount::Integer(greater_than_or_equal_to_one) => {
+            YColumnCountInteger::new(greater_than_or_equal_to_one.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ColumnCount::Auto")]
+pub struct YColumnCountAuto {}
+
+impl YColumnCountAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ColumnCount::Integer")]
+pub struct YColumnCountInteger {
+    value: i32,
+}
+
+impl YColumnCountInteger {
+    pub fn new(greater_than_or_equal_to_one: GreaterThanOrEqualToOne<Integer>) -> Self {
+        Self {
+            value: greater_than_or_equal_to_one.0.value(),
+        }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> i32 {
+        rb_self.value
+    }
+}

data/ext/yass/src/declarations/column_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 ColumnGapValue = LengthPercentageOrNormal<NonNegative<LengthPercentage>>;
+
+fn column_gap_value_to_ruby(value: &ColumnGapValue, ruby: &Ruby) -> Value {
+    match value {
+        LengthPercentageOrNormal::Normal => YColumnGapNormal::new().into_value_with(ruby),
+        LengthPercentageOrNormal::LengthPercentage(length_percentage) => {
+            YColumnGapLengthPercentage::new(length_percentage.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::ColumnGap", mark)]
+pub struct YColumnGap {
+    value: CachedValue<ColumnGapValue>,
+}
+
+impl YColumnGap {
+    pub fn new(value: ColumnGapValue) -> Self {
+        Self {
+            value: CachedValue::new(value, column_gap_value_to_ruby),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YColumnGap {
+    fn mark(&self, marker: &Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ColumnGap::Normal")]
+pub struct YColumnGapNormal {}
+
+impl YColumnGapNormal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::ColumnGap::LengthPercentage", mark)]
+pub struct YColumnGapLengthPercentage {
+    length_percentage: CachedValue<NonNegative<LengthPercentage>>,
+}
+
+impl YColumnGapLengthPercentage {
+    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 YColumnGapLengthPercentage {
+    fn mark(&self, marker: &Marker) {
+        self.length_percentage.mark(marker);
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::column_span::T;
+
+#[magnus::wrap(class = "Yass::Declarations::ColumnSpan")]
+pub struct YColumnSpan {
+    specified_value: T
+}
+
+impl YColumnSpan {
+    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::All => ruby.intern("all"),
+        }
+    }
+}

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

@@ -0,0 +1,70 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::{NonNegative, length::LengthPercentageOrAuto}, specified::Length};
+
+use crate::{cached_value::CachedValue, declarations::length::length_to_value};
+
+fn make_column_width_value(value: &LengthPercentageOrAuto<NonNegative<Length>>, ruby: &Ruby) -> Value {
+    match value {
+        LengthPercentageOrAuto::Auto => YColumnWidthAuto::new().into_value_with(ruby),
+        LengthPercentageOrAuto::LengthPercentage(non_negative) => {
+            YColumnWidthLength::new(non_negative.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::ColumnWidth", mark)]
+pub struct YColumnWidth {
+    value: CachedValue<LengthPercentageOrAuto<NonNegative<Length>>>,
+}
+
+impl YColumnWidth {
+    pub fn new(non_negative_length_or_auto: LengthPercentageOrAuto<NonNegative<Length>>) -> Self {
+        Self {
+            value: CachedValue::new(non_negative_length_or_auto, make_column_width_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YColumnWidth {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ColumnWidth::Auto")]
+pub struct YColumnWidthAuto {}
+
+impl YColumnWidthAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::ColumnWidth::Length", mark)]
+pub struct YColumnWidthLength {
+    length: CachedValue<NonNegative<Length>>,
+}
+
+impl YColumnWidthLength {
+    pub fn new(non_negative: NonNegative<Length>) -> Self {
+        Self {
+            length: CachedValue::new(non_negative, |v, ruby| length_to_value(&v.0, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YColumnWidthLength {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length.mark(marker);
+    }
+}

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

@@ -0,0 +1,106 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::values::computed::Contain;
+
+#[magnus::wrap(class = "Yass::Declarations::Contain")]
+pub struct YContain {
+    contain: Contain
+}
+
+impl YContain {
+    pub fn new(contain: Contain) -> Self {
+        Self { contain }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let contain = rb_self.contain;
+        let result = ruby.ary_new();
+
+        if contain.is_empty() {
+            result.push(ruby.intern("none"))?;
+            return Ok(result);
+        }
+
+        if contain.contains(Contain::STRICT) {
+            result.push(ruby.intern("strict"))?;
+            return Ok(result);
+        }
+
+        if contain.contains(Contain::CONTENT) {
+            result.push(ruby.intern("content"))?;
+        }
+
+        if contain.contains(Contain::SIZE) {
+            result.push(ruby.intern("size"))?;
+        } else {
+            if contain.contains(Contain::INLINE_SIZE) {
+                result.push(ruby.intern("inline_size"))?;
+            }
+
+            if contain.contains(Contain::BLOCK_SIZE) {
+                result.push(ruby.intern("block_size"))?;
+            }
+        }
+
+        if !contain.contains(Contain::CONTENT) {
+            if contain.contains(Contain::LAYOUT) {
+                result.push(ruby.intern("layout"))?;
+            }
+
+            if contain.contains(Contain::STYLE) {
+                result.push(ruby.intern("style"))?;
+            }
+
+            if contain.contains(Contain::PAINT) {
+                result.push(ruby.intern("paint"))?;
+            }
+        }
+
+        Ok(result)
+    }
+
+    pub fn is_none(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain.is_empty()
+    }
+
+    pub fn is_inline_size(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain.contains(Contain::STRICT) ||
+            rb_self.contain.contains(Contain::SIZE) ||
+            rb_self.contain.contains(Contain::INLINE_SIZE)
+    }
+
+    pub fn is_block_size(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain.contains(Contain::STRICT) ||
+            rb_self.contain.contains(Contain::SIZE) ||
+            rb_self.contain.contains(Contain::BLOCK_SIZE)
+    }
+
+    pub fn is_layout(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain.contains(Contain::STRICT) ||
+            rb_self.contain.contains(Contain::CONTENT) ||
+            rb_self.contain.contains(Contain::LAYOUT)
+    }
+
+    pub fn is_style(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain.contains(Contain::STRICT) ||
+            rb_self.contain.contains(Contain::CONTENT) ||
+            rb_self.contain.contains(Contain::STYLE)
+    }
+
+    pub fn is_paint(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain.contains(Contain::STRICT) ||
+            rb_self.contain.contains(Contain::CONTENT) ||
+            rb_self.contain.contains(Contain::PAINT)
+    }
+
+    pub fn is_size(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain.contains(Contain::STRICT) || rb_self.contain.contains(Contain::SIZE)
+    }
+
+    pub fn is_content(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain.contains(Contain::STRICT) || rb_self.contain.contains(Contain::CONTENT)
+    }
+
+    pub fn is_strict(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.contain.contains(Contain::STRICT)
+    }
+}

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

@@ -0,0 +1,32 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::values::computed::ContainerName;
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::ContainerName")]
+pub struct YContainerName {
+    container_name: ContainerName
+}
+
+impl YContainerName {
+    pub fn new(container_name: ContainerName) -> Self {
+        Self { container_name }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        // Stylo keeps the underlying list private, so we split the serialized
+        // CSS value to expose each container name.
+        let css = rb_self.container_name.to_css_string();
+        let idents: Vec<&str> = css.split_whitespace().collect();
+        let result = ruby.ary_new_capa(idents.len());
+
+        for ident in idents {
+            result.push(ruby.str_new(ident))?;
+        }
+
+        Ok(result)
+    }
+
+    pub fn is_none(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.container_name.is_none()
+    }
+}

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

@@ -0,0 +1,52 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::values::computed::ContainerType;
+
+#[magnus::wrap(class = "Yass::Declarations::ContainerType")]
+pub struct YContainerType {
+    container_type: ContainerType
+}
+
+impl YContainerType {
+    pub fn new(container_type: ContainerType) -> Self {
+        Self { container_type }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let container_type = rb_self.container_type;
+        let result = ruby.ary_new();
+
+        if container_type.is_normal() {
+            result.push(ruby.intern("normal"))?;
+            return Ok(result);
+        }
+
+        if container_type.contains(ContainerType::SIZE) {
+            result.push(ruby.intern("size"))?;
+        } else if container_type.contains(ContainerType::INLINE_SIZE) {
+            result.push(ruby.intern("inline_size"))?;
+        }
+
+        if container_type.contains(ContainerType::SCROLL_STATE) {
+            result.push(ruby.intern("scroll_state"))?;
+        }
+
+        Ok(result)
+    }
+
+    pub fn is_normal(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.container_type.is_normal()
+    }
+
+    pub fn is_inline_size(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.container_type.contains(ContainerType::SIZE) ||
+            rb_self.container_type.contains(ContainerType::INLINE_SIZE)
+    }
+
+    pub fn is_size(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.container_type.contains(ContainerType::SIZE)
+    }
+
+    pub fn is_scroll_state(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.container_type.contains(ContainerType::SCROLL_STATE)
+    }
+}