yass-css 0.2.0

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

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

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

@@ -0,0 +1,114 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::{Inset, LengthPercentage};
+use style_traits::ToCss;
+
+use crate::{cached_value::CachedValue, declarations::size::length_percentage_to_value};
+
+pub fn make_inset(inset: &Inset, ruby: &Ruby) -> Value {
+    match inset {
+        Inset::Auto => YInsetAuto::new().into_value_with(ruby),
+        Inset::LengthPercentage(length_percentage) => {
+            YInsetLengthPercentage::new(length_percentage.clone()).into_value_with(ruby)
+        }
+        Inset::AnchorContainingCalcFunction(length_percentage) => {
+            YInsetAnchorContainingCalcFunction::new(length_percentage.clone()).into_value_with(ruby)
+        }
+        Inset::AnchorFunction(anchor_function) => {
+            YInsetAnchorFunction::new(anchor_function.to_css_string()).into_value_with(ruby)
+        }
+        Inset::AnchorSizeFunction(anchor_size_function) => {
+            YInsetAnchorSizeFunction::new(anchor_size_function.to_css_string()).into_value_with(ruby)
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Inset::Auto")]
+pub struct YInsetAuto {}
+
+impl YInsetAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Inset::LengthPercentage", mark)]
+pub struct YInsetLengthPercentage {
+    length_percentage: CachedValue<LengthPercentage>,
+}
+
+impl YInsetLengthPercentage {
+    pub fn new(length_percentage: LengthPercentage) -> Self {
+        Self {
+            length_percentage: CachedValue::new(length_percentage, |value, ruby| {
+                length_percentage_to_value(value, ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length_percentage.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YInsetLengthPercentage {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length_percentage.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Inset::AnchorContainingCalcFunction", mark)]
+pub struct YInsetAnchorContainingCalcFunction {
+    length_percentage: CachedValue<LengthPercentage>,
+}
+
+impl YInsetAnchorContainingCalcFunction {
+    pub fn new(length_percentage: LengthPercentage) -> Self {
+        Self {
+            length_percentage: CachedValue::new(length_percentage, |value, ruby| {
+                length_percentage_to_value(value, ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length_percentage.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YInsetAnchorContainingCalcFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length_percentage.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Inset::AnchorFunction")]
+pub struct YInsetAnchorFunction {
+    css: String,
+}
+
+impl YInsetAnchorFunction {
+    pub fn new(css: String) -> Self {
+        Self { css }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        ruby.str_new(&rb_self.css).into_value_with(ruby)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Inset::AnchorSizeFunction")]
+pub struct YInsetAnchorSizeFunction {
+    css: String,
+}
+
+impl YInsetAnchorSizeFunction {
+    pub fn new(css: String) -> Self {
+        Self { css }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        ruby.str_new(&rb_self.css).into_value_with(ruby)
+    }
+}

data/ext/yass/src/declarations/inset_block_end.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::InsetBlockEnd", mark)]
+pub struct YInsetBlockEnd {
+    inset: CachedValue<Inset>,
+}
+
+impl YInsetBlockEnd {
+    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 YInsetBlockEnd {
+    fn mark(&self, marker: &gc::Marker) {
+        self.inset.mark(marker);
+    }
+}

data/ext/yass/src/declarations/inset_block_start.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::InsetBlockStart", mark)]
+pub struct YInsetBlockStart {
+    inset: CachedValue<Inset>,
+}
+
+impl YInsetBlockStart {
+    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 YInsetBlockStart {
+    fn mark(&self, marker: &gc::Marker) {
+        self.inset.mark(marker);
+    }
+}

data/ext/yass/src/declarations/inset_inline_end.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::InsetInlineEnd", mark)]
+pub struct YInsetInlineEnd {
+    inset: CachedValue<Inset>,
+}
+
+impl YInsetInlineEnd {
+    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 YInsetInlineEnd {
+    fn mark(&self, marker: &gc::Marker) {
+        self.inset.mark(marker);
+    }
+}

data/ext/yass/src/declarations/inset_inline_start.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::InsetInlineStart", mark)]
+pub struct YInsetInlineStart {
+    inset: CachedValue<Inset>,
+}
+
+impl YInsetInlineStart {
+    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 YInsetInlineStart {
+    fn mark(&self, marker: &gc::Marker) {
+        self.inset.mark(marker);
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::isolation::T;
+
+#[magnus::wrap(class = "Yass::Declarations::Isolation")]
+pub struct YIsolation {
+    specified_value: T
+}
+
+impl YIsolation {
+    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::Auto => ruby.intern("auto"),
+            T::Isolate => ruby.intern("isolate"),
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::ContentDistribution;
+
+use crate::declarations::align_flags;
+
+#[magnus::wrap(class = "Yass::Declarations::JustifyContent")]
+pub struct YJustifyContent {
+    content_distribution: ContentDistribution
+}
+
+impl YJustifyContent {
+    pub fn new(content_distribution: ContentDistribution) -> Self {
+        Self { content_distribution }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Option<Id> {
+        align_flags::to_id(rb_self.content_distribution.primary().value(), ruby)
+    }
+}

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

@@ -0,0 +1,37 @@
+use magnus::{Error, Ruby, typed_data, value::Id};
+use style::values::{specified::JustifyItems, specified::align::AlignFlags};
+
+#[magnus::wrap(class = "Yass::Declarations::JustifyItems")]
+pub struct YJustifyItems {
+    justify_items: JustifyItems
+}
+
+impl YJustifyItems {
+    pub fn new(justify_items: JustifyItems) -> Self {
+        Self { justify_items }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<Id, Error> {
+        match rb_self.justify_items.0.value() {
+            AlignFlags::AUTO => Ok(ruby.intern("auto")),
+            AlignFlags::NORMAL => Ok(ruby.intern("normal")),
+            AlignFlags::START => Ok(ruby.intern("start")),
+            AlignFlags::END => Ok(ruby.intern("end")),
+            AlignFlags::FLEX_START => Ok(ruby.intern("flex_start")),
+            AlignFlags::FLEX_END => Ok(ruby.intern("flex_end")),
+            AlignFlags::CENTER => Ok(ruby.intern("center")),
+            AlignFlags::LEFT => Ok(ruby.intern("left")),
+            AlignFlags::RIGHT => Ok(ruby.intern("right")),
+            AlignFlags::BASELINE => Ok(ruby.intern("baseline")),
+            AlignFlags::LAST_BASELINE => Ok(ruby.intern("last_baseline")),
+            AlignFlags::STRETCH => Ok(ruby.intern("stretch")),
+            AlignFlags::SELF_START => Ok(ruby.intern("self_start")),
+            AlignFlags::SELF_END => Ok(ruby.intern("self_end")),
+            AlignFlags::SPACE_BETWEEN => Ok(ruby.intern("space_between")),
+            AlignFlags::SPACE_AROUND => Ok(ruby.intern("space_around")),
+            AlignFlags::SPACE_EVENLY => Ok(ruby.intern("space_evenly")),
+            AlignFlags::ANCHOR_CENTER => Ok(ruby.intern("anchor_center")),
+            _ => Err(Error::new(ruby.exception_arg_error(), "unreachable"))
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::SelfAlignment;
+
+use crate::declarations::align_flags;
+
+#[magnus::wrap(class = "Yass::Declarations::JustifySelf")]
+pub struct YJustifySelf {
+    self_alignment: SelfAlignment
+}
+
+impl YJustifySelf {
+    pub fn new(self_alignment: SelfAlignment) -> Self {
+        Self { self_alignment }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Option<Id> {
+        align_flags::to_id(rb_self.self_alignment.0.value(), ruby)
+    }
+}

data/ext/yass/src/declarations/left.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::Left", mark)]
+pub struct YLeft {
+    inset: CachedValue<Inset>,
+}
+
+impl YLeft {
+    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 YLeft {
+    fn mark(&self, marker: &gc::Marker) {
+        self.inset.mark(marker);
+    }
+}

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

@@ -0,0 +1,230 @@
+use magnus::{IntoValue, Ruby, Value, typed_data, value::Id};
+use style::values::specified::{AbsoluteLength, CharacterWidth, FontRelativeLength, Length, NoCalcLength, ViewportPercentageLength, length::ContainerRelativeLength};
+
+use crate::declarations::calc::YCalc;
+
+pub fn length_to_value(length: &Length, ruby: &Ruby) -> Value {
+    match length {
+        Length::NoCalc(no_calc_length) => no_calc_length_to_value(no_calc_length, ruby),
+        Length::Calc(calc_length_percentage) => {
+            YCalc::new(calc_length_percentage.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+pub fn no_calc_length_to_value(length: &NoCalcLength, ruby: &Ruby) -> Value {
+    match length {
+        NoCalcLength::Absolute(absolute_length) => {
+            YAbsoluteLength::new(*absolute_length).into_value_with(ruby)
+        },
+        NoCalcLength::FontRelative(font_relative_length) => {
+            YFontRelativeLength::new(*font_relative_length).into_value_with(ruby)
+        },
+        NoCalcLength::ViewportPercentage(viewport_percentage_length) => {
+            YViewportPercentageLength::new(*viewport_percentage_length).into_value_with(ruby)
+        },
+        NoCalcLength::ContainerRelative(container_relative_length) => {
+            YContainerRelativeLength::new(*container_relative_length).into_value_with(ruby)
+        },
+        NoCalcLength::ServoCharacterWidth(character_width) => {
+            YCharacterWidthLength::new(*character_width).into_value_with(ruby)
+        },
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Length::Absolute")]
+pub struct YAbsoluteLength {
+    absolute_length: AbsoluteLength
+}
+
+impl YAbsoluteLength {
+    pub fn new(absolute_length: AbsoluteLength) -> Self {
+        Self { absolute_length }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        match rb_self.absolute_length {
+            AbsoluteLength::Px(value) => value,
+            AbsoluteLength::In(value) => value,
+            AbsoluteLength::Cm(value) => value,
+            AbsoluteLength::Mm(value) => value,
+            AbsoluteLength::Q(value) => value,
+            AbsoluteLength::Pt(value) => value,
+            AbsoluteLength::Pc(value) => value,
+        }
+    }
+
+    pub fn unit(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.absolute_length {
+            AbsoluteLength::Px(_) => ruby.intern("px"),
+            AbsoluteLength::In(_) => ruby.intern("in"),
+            AbsoluteLength::Cm(_) => ruby.intern("cm"),
+            AbsoluteLength::Mm(_) => ruby.intern("mm"),
+            AbsoluteLength::Q(_) => ruby.intern("q"),
+            AbsoluteLength::Pt(_) => ruby.intern("pt"),
+            AbsoluteLength::Pc(_) => ruby.intern("pc"),
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Length::FontRelative")]
+pub struct YFontRelativeLength {
+    font_relative_length: FontRelativeLength
+}
+
+impl YFontRelativeLength {
+    pub fn new(font_relative_length: FontRelativeLength) -> Self {
+        Self { font_relative_length }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        match rb_self.font_relative_length {
+            FontRelativeLength::Em(value) => value,
+            FontRelativeLength::Ex(value) => value,
+            FontRelativeLength::Rex(value) => value,
+            FontRelativeLength::Ch(value) => value,
+            FontRelativeLength::Rch(value) => value,
+            FontRelativeLength::Cap(value) => value,
+            FontRelativeLength::Rcap(value) => value,
+            FontRelativeLength::Ic(value) => value,
+            FontRelativeLength::Ric(value) => value,
+            FontRelativeLength::Rem(value) => value,
+            FontRelativeLength::Lh(value) => value,
+            FontRelativeLength::Rlh(value) => value,
+        }
+    }
+
+    pub fn unit(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.font_relative_length {
+            FontRelativeLength::Em(_) => ruby.intern("em"),
+            FontRelativeLength::Ex(_) => ruby.intern("ex"),
+            FontRelativeLength::Rex(_) => ruby.intern("rex"),
+            FontRelativeLength::Ch(_) => ruby.intern("ch"),
+            FontRelativeLength::Rch(_) => ruby.intern("rch"),
+            FontRelativeLength::Cap(_) => ruby.intern("cap"),
+            FontRelativeLength::Rcap(_) => ruby.intern("rcap"),
+            FontRelativeLength::Ic(_) => ruby.intern("ic"),
+            FontRelativeLength::Ric(_) => ruby.intern("ric"),
+            FontRelativeLength::Rem(_) => ruby.intern("rem"),
+            FontRelativeLength::Lh(_) => ruby.intern("lh"),
+            FontRelativeLength::Rlh(_) => ruby.intern("rlh"),
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Length::ViewportPercentage")]
+pub struct YViewportPercentageLength {
+    viewport_percentage_length: ViewportPercentageLength
+}
+
+impl YViewportPercentageLength {
+    pub fn new(viewport_percentage_length: ViewportPercentageLength) -> Self {
+        Self { viewport_percentage_length }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        match rb_self.viewport_percentage_length {
+            ViewportPercentageLength::Vw(value) => value,
+            ViewportPercentageLength::Svw(value) => value,
+            ViewportPercentageLength::Lvw(value) => value,
+            ViewportPercentageLength::Dvw(value) => value,
+            ViewportPercentageLength::Vh(value) => value,
+            ViewportPercentageLength::Svh(value) => value,
+            ViewportPercentageLength::Lvh(value) => value,
+            ViewportPercentageLength::Dvh(value) => value,
+            ViewportPercentageLength::Vmin(value) => value,
+            ViewportPercentageLength::Svmin(value) => value,
+            ViewportPercentageLength::Lvmin(value) => value,
+            ViewportPercentageLength::Dvmin(value) => value,
+            ViewportPercentageLength::Vmax(value) => value,
+            ViewportPercentageLength::Svmax(value) => value,
+            ViewportPercentageLength::Lvmax(value) => value,
+            ViewportPercentageLength::Dvmax(value) => value,
+            ViewportPercentageLength::Vb(value) => value,
+            ViewportPercentageLength::Svb(value) => value,
+            ViewportPercentageLength::Lvb(value) => value,
+            ViewportPercentageLength::Dvb(value) => value,
+            ViewportPercentageLength::Vi(value) => value,
+            ViewportPercentageLength::Svi(value) => value,
+            ViewportPercentageLength::Lvi(value) => value,
+            ViewportPercentageLength::Dvi(value) => value,
+        }
+    }
+
+    pub fn unit(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.viewport_percentage_length {
+            ViewportPercentageLength::Vw(_) => ruby.intern("vw"),
+            ViewportPercentageLength::Svw(_) => ruby.intern("svw"),
+            ViewportPercentageLength::Lvw(_) => ruby.intern("lvw"),
+            ViewportPercentageLength::Dvw(_) => ruby.intern("dvw"),
+            ViewportPercentageLength::Vh(_) => ruby.intern("vh"),
+            ViewportPercentageLength::Svh(_) => ruby.intern("svh"),
+            ViewportPercentageLength::Lvh(_) => ruby.intern("lvh"),
+            ViewportPercentageLength::Dvh(_) => ruby.intern("dvh"),
+            ViewportPercentageLength::Vmin(_) => ruby.intern("vmin"),
+            ViewportPercentageLength::Svmin(_) => ruby.intern("svmin"),
+            ViewportPercentageLength::Lvmin(_) => ruby.intern("lvmin"),
+            ViewportPercentageLength::Dvmin(_) => ruby.intern("dvmin"),
+            ViewportPercentageLength::Vmax(_) => ruby.intern("vmax"),
+            ViewportPercentageLength::Svmax(_) => ruby.intern("svmax"),
+            ViewportPercentageLength::Lvmax(_) => ruby.intern("lvmax"),
+            ViewportPercentageLength::Dvmax(_) => ruby.intern("dvmax"),
+            ViewportPercentageLength::Vb(_) => ruby.intern("vb"),
+            ViewportPercentageLength::Svb(_) => ruby.intern("svb"),
+            ViewportPercentageLength::Lvb(_) => ruby.intern("lvb"),
+            ViewportPercentageLength::Dvb(_) => ruby.intern("dvb"),
+            ViewportPercentageLength::Vi(_) => ruby.intern("vi"),
+            ViewportPercentageLength::Svi(_) => ruby.intern("svi"),
+            ViewportPercentageLength::Lvi(_) => ruby.intern("lvi"),
+            ViewportPercentageLength::Dvi(_) => ruby.intern("dvi"),
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Length::ContainerRelative")]
+pub struct YContainerRelativeLength {
+    container_relative_length: ContainerRelativeLength
+}
+
+impl YContainerRelativeLength {
+    pub fn new(container_relative_length: ContainerRelativeLength) -> Self {
+        Self { container_relative_length }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        match rb_self.container_relative_length {
+            ContainerRelativeLength::Cqw(value) => value,
+            ContainerRelativeLength::Cqh(value) => value,
+            ContainerRelativeLength::Cqi(value) => value,
+            ContainerRelativeLength::Cqb(value) => value,
+            ContainerRelativeLength::Cqmin(value) => value,
+            ContainerRelativeLength::Cqmax(value) => value,
+        }
+    }
+
+    pub fn unit(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.container_relative_length {
+            ContainerRelativeLength::Cqw(_) => ruby.intern("cqw"),
+            ContainerRelativeLength::Cqh(_) => ruby.intern("cqh"),
+            ContainerRelativeLength::Cqi(_) => ruby.intern("cqi"),
+            ContainerRelativeLength::Cqb(_) => ruby.intern("cqb"),
+            ContainerRelativeLength::Cqmin(_) => ruby.intern("cqmin"),
+            ContainerRelativeLength::Cqmax(_) => ruby.intern("cqmax"),
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Length::CharacterWidth")]
+pub struct YCharacterWidthLength {
+    character_width_length: CharacterWidth
+}
+
+impl YCharacterWidthLength {
+    pub fn new(character_width_length: CharacterWidth) -> Self {
+        Self { character_width_length }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> i32 {
+        rb_self.character_width_length.0
+    }
+}

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

@@ -0,0 +1,47 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::specified::LetterSpacing;
+use style::values::specified::text::Spacing;
+
+use crate::{cached_value::CachedValue, declarations::size::length_percentage_to_value};
+
+fn letter_spacing_to_value(letter_spacing: &LetterSpacing, ruby: &Ruby) -> Value {
+    match &letter_spacing.0 {
+        Spacing::Normal => YLetterSpacingNormal::new().into_value_with(ruby),
+        Spacing::Value(length_percentage) => {
+            length_percentage_to_value(length_percentage, ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::LetterSpacing", mark)]
+pub struct YLetterSpacing {
+    value: CachedValue<LetterSpacing>,
+}
+
+impl YLetterSpacing {
+    pub fn new(letter_spacing: LetterSpacing) -> Self {
+        Self {
+            value: CachedValue::new(letter_spacing, letter_spacing_to_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YLetterSpacing {
+    fn mark(&self, marker: &Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::LetterSpacing::Normal")]
+pub struct YLetterSpacingNormal {}
+
+impl YLetterSpacingNormal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}