yass-css 0.2.0

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

@@ -0,0 +1,99 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{generics::transform::TransformOrigin, specified::{Length, position::{HorizontalPositionKeyword, VerticalPositionKeyword}, transform::OriginComponent}};
+
+use crate::{cached_value::CachedValue, declarations::{images::{horizontal_keyword_to_id, vertical_keyword_to_id}, length::length_to_value, size::YLengthPercentage}};
+
+fn make_horizontal_origin_component(component: &OriginComponent<HorizontalPositionKeyword>, ruby: &Ruby) -> Value {
+    match component {
+        OriginComponent::Center => YOriginCenter::new().into_value_with(ruby),
+        OriginComponent::Length(lp) => YLengthPercentage::new(lp.clone()).into_value_with(ruby),
+        OriginComponent::Side(keyword) => YSideHorizontalOriginComponent::new(*keyword).into_value_with(ruby),
+    }
+}
+
+fn make_vertical_origin_component(component: &OriginComponent<VerticalPositionKeyword>, ruby: &Ruby) -> Value {
+    match component {
+        OriginComponent::Center => YOriginCenter::new().into_value_with(ruby),
+        OriginComponent::Length(lp) => YLengthPercentage::new(lp.clone()).into_value_with(ruby),
+        OriginComponent::Side(keyword) => YSideVerticalOriginComponent::new(*keyword).into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TransformOrigin", mark)]
+pub struct YTransformOrigin {
+    horizontal: CachedValue<OriginComponent<HorizontalPositionKeyword>>,
+    vertical: CachedValue<OriginComponent<VerticalPositionKeyword>>,
+    depth: CachedValue<Length>,
+}
+
+impl YTransformOrigin {
+    pub fn new(specified_value: Box<TransformOrigin<OriginComponent<HorizontalPositionKeyword>, OriginComponent<VerticalPositionKeyword>, Length>>) -> Self {
+        let to = *specified_value;
+
+        Self {
+            horizontal: CachedValue::new(to.horizontal, make_horizontal_origin_component),
+            vertical: CachedValue::new(to.vertical, make_vertical_origin_component),
+            depth: CachedValue::new(to.depth, |length, ruby| length_to_value(length, 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 depth(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.depth.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YTransformOrigin {
+    fn mark(&self, marker: &gc::Marker) {
+        self.horizontal.mark(marker);
+        self.vertical.mark(marker);
+        self.depth.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TransformOrigin::Center")]
+pub struct YOriginCenter {}
+
+impl YOriginCenter {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TransformOrigin::SideHorizontalComponent")]
+pub struct YSideHorizontalOriginComponent {
+    keyword: HorizontalPositionKeyword,
+}
+
+impl YSideHorizontalOriginComponent {
+    pub fn new(keyword: HorizontalPositionKeyword) -> Self {
+        Self { keyword }
+    }
+
+    pub fn side(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        horizontal_keyword_to_id(rb_self.keyword, ruby)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TransformOrigin::SideVerticalComponent")]
+pub struct YSideVerticalOriginComponent {
+    keyword: VerticalPositionKeyword,
+}
+
+impl YSideVerticalOriginComponent {
+    pub fn new(keyword: VerticalPositionKeyword) -> Self {
+        Self { keyword }
+    }
+
+    pub fn side(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        vertical_keyword_to_id(rb_self.keyword, ruby)
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::TransformStyle;
+
+#[magnus::wrap(class = "Yass::Declarations::TransformStyle")]
+pub struct YTransformStyle {
+    transform_style: TransformStyle
+}
+
+impl YTransformStyle {
+    pub fn new(transform_style: TransformStyle) -> Self {
+        Self { transform_style }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.transform_style {
+            TransformStyle::Flat => ruby.intern("flat"),
+            TransformStyle::Preserve3d => ruby.intern("preserve_3d"),
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::{properties::longhands::transition_behavior::SpecifiedValue, values::specified::TransitionBehavior};
+
+#[magnus::wrap(class = "Yass::Declarations::TransitionBehavior")]
+pub struct YTransitionBehavior {
+    specified_value: SpecifiedValue
+}
+
+impl YTransitionBehavior {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for behavior in rb_self.specified_value.0.as_ref() {
+            let id = match behavior {
+                TransitionBehavior::Normal => ruby.intern("normal"),
+                TransitionBehavior::AllowDiscrete => ruby.intern("allow_discrete"),
+            };
+
+            result.push(id)?;
+        }
+
+        Ok(result)
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data};
+use style::{properties::longhands::transition_delay::SpecifiedValue, values::specified::Time};
+
+use crate::{cached_value_list::CachedValueList, declarations::time::YTime};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TransitionDelay", mark)]
+pub struct YTransitionDelay {
+    times: CachedValueList<Time>
+}
+
+impl YTransitionDelay {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            times: CachedValueList::new(specified_value.0.to_vec(), |time, _ctx, ruby| {
+                YTime::new(time.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.times.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YTransitionDelay {
+    fn mark(&self, marker: &gc::Marker) {
+        self.times.mark(marker);
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data};
+use style::{properties::longhands::transition_duration::SpecifiedValue, values::specified::Time};
+
+use crate::{cached_value_list::CachedValueList, declarations::time::YTime};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TransitionDuration", mark)]
+pub struct YTransitionDuration {
+    times: CachedValueList<Time>
+}
+
+impl YTransitionDuration {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            times: CachedValueList::new(specified_value.0.to_vec(), |time, _ctx, ruby| {
+                YTime::new(time.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.times.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YTransitionDuration {
+    fn mark(&self, marker: &gc::Marker) {
+        self.times.mark(marker);
+    }
+}

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

@@ -0,0 +1,122 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, RString, Ruby, TypedData, Value, gc, typed_data};
+use style::{
+    properties::longhands::transition_property::SpecifiedValue,
+    values::specified::TransitionProperty,
+};
+
+use crate::cached_value_list::CachedValueList;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TransitionProperty", mark)]
+pub struct YTransitionProperty {
+    values: CachedValueList<TransitionProperty>,
+}
+
+impl YTransitionProperty {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |transition_property, _ctx, ruby| {
+                make_transition_property(transition_property, ruby)
+            }),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YTransitionProperty {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TransitionProperty::NonCustom")]
+pub struct YTransitionPropertyNonCustom {
+    name: String,
+    is_all: bool,
+}
+
+impl YTransitionPropertyNonCustom {
+    pub fn new(transition_property: &TransitionProperty) -> Self {
+        let TransitionProperty::NonCustom(id) = transition_property else {
+            unreachable!()
+        };
+
+        Self {
+            name: id.name().to_owned(),
+            is_all: transition_property.is_all(),
+        }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.name)
+    }
+
+    pub fn is_all(rb_self: &Self) -> bool {
+        rb_self.is_all
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TransitionProperty::Custom")]
+pub struct YTransitionPropertyCustom {
+    name: String,
+}
+
+impl YTransitionPropertyCustom {
+    pub fn new(transition_property: &TransitionProperty) -> Self {
+        let TransitionProperty::Custom(name) = transition_property else {
+            unreachable!()
+        };
+
+        Self {
+            name: format!("--{}", name),
+        }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.name)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TransitionProperty::Unsupported")]
+pub struct YTransitionPropertyUnsupported {
+    name: String,
+    is_none: bool,
+}
+
+impl YTransitionPropertyUnsupported {
+    pub fn new(transition_property: &TransitionProperty) -> Self {
+        let TransitionProperty::Unsupported(custom_ident) = transition_property else {
+            unreachable!()
+        };
+
+        Self {
+            name: custom_ident.0.to_string(),
+            is_none: transition_property.is_none(),
+        }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.name)
+    }
+
+    pub fn is_none(rb_self: &Self) -> bool {
+        rb_self.is_none
+    }
+}
+
+fn make_transition_property(transition_property: &TransitionProperty, ruby: &Ruby) -> Value {
+    match transition_property {
+        TransitionProperty::NonCustom(_) => {
+            YTransitionPropertyNonCustom::new(transition_property).into_value_with(ruby)
+        }
+        TransitionProperty::Custom(_) => {
+            YTransitionPropertyCustom::new(transition_property).into_value_with(ruby)
+        }
+        TransitionProperty::Unsupported(_) => {
+            YTransitionPropertyUnsupported::new(transition_property).into_value_with(ruby)
+        }
+    }
+}

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

@@ -0,0 +1,46 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data};
+use style::{piecewise_linear::PiecewiseLinearFunction, properties::longhands::transition_timing_function::SpecifiedValue, values::{generics::easing::TimingFunction, specified::{Integer, Number}}};
+
+use crate::{cached_value_list::CachedValueList, declarations::animation::timing_function::{cubic_bezier::YCubicBezier, keyword::YKeyword, piecewise_linear_function::YPiecewiseLinearFunction, steps::YSteps}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TransitionTimingFunction", mark)]
+pub struct YTransitionTimingFunction {
+    values: CachedValueList<TimingFunction<Integer, Number, PiecewiseLinearFunction>>
+}
+
+impl YTransitionTimingFunction {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                match value {
+                    TimingFunction::Keyword(timing_keyword) => {
+                        YKeyword::new(timing_keyword.clone()).into_value_with(ruby)
+                    },
+
+                    TimingFunction::CubicBezier { x1, y1, x2, y2 } => {
+                        YCubicBezier::new(x1.clone(), y1.clone(), x2.clone(), y2.clone()).into_value_with(ruby)
+                    },
+
+                    TimingFunction::Steps(steps, step_position) => {
+                        YSteps::new(steps.value(), *step_position).into_value_with(ruby)
+                    },
+
+                    TimingFunction::LinearFunction(linear_function) => {
+                        YPiecewiseLinearFunction::new(linear_function.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 YTransitionTimingFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}

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

@@ -0,0 +1,84 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::transform::Translate, specified::{Length, LengthPercentage}};
+
+use crate::{cached_value::CachedValue, declarations::{length::length_to_value, size::length_percentage_to_value}};
+
+fn make_translate_value(value: &Translate<LengthPercentage, Length>, ruby: &Ruby) -> Value {
+    match value {
+        Translate::None => YTranslateNone::new().into_value_with(ruby),
+        Translate::Translate(x, y, z) => {
+            YTranslateCoords::new(x.clone(), y.clone(), z.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Translate", mark)]
+pub struct YTranslate {
+    value: CachedValue<Translate<LengthPercentage, Length>>,
+}
+
+impl YTranslate {
+    pub fn new(specified_value: Box<Translate<LengthPercentage, Length>>) -> Self {
+        Self {
+            value: CachedValue::new(*specified_value, make_translate_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YTranslate {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Translate::None")]
+pub struct YTranslateNone {}
+
+impl YTranslateNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Translate::Coords", mark)]
+pub struct YTranslateCoords {
+    x: CachedValue<LengthPercentage>,
+    y: CachedValue<LengthPercentage>,
+    z: CachedValue<Length>,
+}
+
+impl YTranslateCoords {
+    pub fn new(x: LengthPercentage, y: LengthPercentage, z: Length) -> Self {
+        Self {
+            x: CachedValue::new(x, length_percentage_to_value),
+            y: CachedValue::new(y, length_percentage_to_value),
+            z: CachedValue::new(z, length_to_value),
+        }
+    }
+
+    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 YTranslateCoords {
+    fn mark(&self, marker: &gc::Marker) {
+        self.x.mark(marker);
+        self.y.mark(marker);
+        self.z.mark(marker);
+    }
+}

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

@@ -0,0 +1,24 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::unicode_bidi::T;
+
+#[magnus::wrap(class = "Yass::Declarations::UnicodeBidi")]
+pub struct YUnicodeBidi {
+    specified_value: T
+}
+
+impl YUnicodeBidi {
+    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::Normal => ruby.intern("normal"),
+            T::Embed => ruby.intern("embed"),
+            T::Isolate => ruby.intern("isolate"),
+            T::BidiOverride => ruby.intern("bidi_override"),
+            T::IsolateOverride => ruby.intern("isolate_override"),
+            T::Plaintext => ruby.intern("plaintext"),
+        }
+    }
+}

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

@@ -0,0 +1,93 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::specified::{LengthPercentage, position::{PositionComponent, VerticalPositionKeyword}};
+
+use crate::{cached_value::CachedValue, declarations::{images::vertical_keyword_to_id, size::YLengthPercentage}};
+
+pub fn make_vertical_position_component(component: &PositionComponent<VerticalPositionKeyword>, ruby: &Ruby) -> Value {
+    match component {
+        PositionComponent::Center => {
+            YCenterVerticalPositionComponent::new().into_value_with(ruby)
+        },
+
+        PositionComponent::Length(length) => {
+            YLengthVerticalPositionComponent::new(length.clone()).into_value_with(ruby)
+        },
+
+        PositionComponent::Side(keyword, offset) => {
+            YSideVerticalPositionComponent::new(keyword.clone(), offset.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Image::CenterVerticalPositionComponent")]
+pub struct YCenterVerticalPositionComponent {}
+
+impl YCenterVerticalPositionComponent {
+    pub fn new() -> Self {
+        Self { }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::LengthVerticalPositionComponent", mark)]
+pub struct YLengthVerticalPositionComponent {
+    length: CachedValue<LengthPercentage>,
+}
+
+impl YLengthVerticalPositionComponent {
+    pub fn new(length: LengthPercentage) -> Self {
+        Self {
+            length: CachedValue::new(length, |length, ruby| {
+                YLengthPercentage::new(length.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn length(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YLengthVerticalPositionComponent {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::SideVerticalPositionComponent", mark)]
+pub struct YSideVerticalPositionComponent {
+    keyword: VerticalPositionKeyword,
+    offset: CachedValue<Option<LengthPercentage>>,
+}
+
+impl YSideVerticalPositionComponent {
+    pub fn new(keyword: VerticalPositionKeyword, offset: Option<LengthPercentage>) -> Self {
+        Self {
+            keyword,
+            offset: CachedValue::new(offset, |offset, ruby| {
+                match offset {
+                    Some(offset) => {
+                        YLengthPercentage::new(offset.clone()).into_value_with(ruby)
+                    },
+
+                    None => ruby.qnil().into_value_with(ruby),
+                }
+            })
+        }
+    }
+
+    pub fn position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        vertical_keyword_to_id(rb_self.keyword, ruby)
+    }
+
+    pub fn offset(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.offset.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YSideVerticalPositionComponent {
+    fn mark(&self, marker: &gc::Marker) {
+        self.offset.mark(marker);
+    }
+}

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

@@ -0,0 +1,31 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::values::computed::ViewTransitionClass;
+
+#[magnus::wrap(class = "Yass::Declarations::ViewTransitionClass")]
+pub struct YViewTransitionClass {
+    view_transition_class: ViewTransitionClass,
+}
+
+impl YViewTransitionClass {
+    pub fn new(view_transition_class: ViewTransitionClass) -> Self {
+        Self { view_transition_class }
+    }
+
+    pub fn is_none(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.view_transition_class.value.is_none()
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        if rb_self.view_transition_class.value.is_none() {
+            return Ok(ruby.ary_new());
+        }
+
+        let result = ruby.ary_new();
+
+        for value in rb_self.view_transition_class.value.iter() {
+            result.push(ruby.str_new(&value.0.to_string()))?;
+        }
+
+        Ok(result)
+    }
+}

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

@@ -0,0 +1,18 @@
+use magnus::{RString, Ruby, typed_data};
+use style::values::computed::ViewTransitionName;
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::ViewTransitionName")]
+pub struct YViewTransitionName {
+    view_transition_name: ViewTransitionName,
+}
+
+impl YViewTransitionName {
+    pub fn new(view_transition_name: ViewTransitionName) -> Self {
+        Self { view_transition_name }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> RString {
+        ruby.str_new(&rb_self.view_transition_name.value.to_css_string())
+    }
+}

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

@@ -0,0 +1,21 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::visibility::T;
+
+#[magnus::wrap(class = "Yass::Declarations::Visibility")]
+pub struct YVisibility {
+    specified_value: T
+}
+
+impl YVisibility {
+    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::Visible => ruby.intern("visible"),
+            T::Hidden => ruby.intern("hidden"),
+            T::Collapse => ruby.intern("collapse"),
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::_webkit_text_security::T;
+
+#[magnus::wrap(class = "Yass::Declarations::WebkitTextSecurity")]
+pub struct YWebkitTextSecurity {
+    specified_value: T
+}
+
+impl YWebkitTextSecurity {
+    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::Circle => ruby.intern("circle"),
+            T::Disc => ruby.intern("disc"),
+            T::Square => ruby.intern("square"),
+        }
+    }
+}