yass-css 0.2.0

data/examples/visitor_example.rb

@@ -0,0 +1,41 @@
+require "yass"
+
+sheet = Yass::Parser.parse(<<~CSS)
+  h1 {
+    align-items: center;
+    display: flex;
+    position: absolute;
+  }
+
+  .left {
+    float: left;
+  }
+
+  .right {
+    float: right;
+  }
+
+  #thing {
+    visibility: hidden;
+  }
+CSS
+
+class MyVisitor < Yass::Visitor
+  def visit_selector_local_name(node)
+    # prints "h1"
+    puts node.value
+  end
+
+  def visit_selector_klass(node)
+    # prints "left" and "right"
+    puts node.value
+  end
+
+  def visit_selector_id(node)
+    # prints "thing"
+    puts node.value
+  end
+end
+
+visitor = MyVisitor.new
+visitor.visit(sheet)

data/ext/yass/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "yass"
+version = "0.2.0"
+edition = "2021"
+authors = ["Cameron Dutro <camertron@gmail.com>"]
+license = "MIT"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+cssparser = { version = "0.36.0" }
+magnus = { version = "0.8.2" }
+stylo = { version = "0.16.0" }
+stylo_traits = { version = "0.16.0" }
+selectors = { version = "0.37.0" }
+url = { version = "2.5" }
+stylo_static_prefs = "0.16.0"
+
+[profile.release]
+lto = true         # Enable Link-Time Optimization
+opt-level = 3      # Maximum optimization level
+codegen-units = 1  # Slower to compile, but produces a smaller/faster binary

data/ext/yass/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("yass/yass")

data/ext/yass/src/cached_value.rs

@@ -0,0 +1,48 @@
+use std::cell::RefCell;
+
+use magnus::{IntoValue, Ruby, Value, gc, value::Opaque};
+
+pub struct CachedValue<T, F = fn(&T, &Ruby) -> Value> {
+    pub value: Option<T>,
+    transform: F,
+    cached_value: RefCell<Option<Opaque<Value>>>
+}
+
+impl<T, F> CachedValue<T, F> where F: Fn(&T, &Ruby) -> Value {
+    pub fn new(value: T, cb: F) -> Self {
+        Self { value: Some(value), transform: cb, cached_value: RefCell::new(None) }
+    }
+
+    pub fn empty(cb: F) -> Self {
+        Self { value: None, transform: cb, cached_value: RefCell::new(None) }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.cached_value.borrow().is_none()
+    }
+
+    pub fn get(&self, ruby: &Ruby) -> Value {
+        if self.cached_value.borrow().is_none() {
+            if self.value.is_none() {
+                return ruby.qnil().into_value_with(ruby)
+            }
+
+            let new_value = (self.transform)(&self.value.as_ref().unwrap(), ruby);
+            *self.cached_value.borrow_mut() = Some(Opaque::from(new_value));
+        }
+
+        let opaque= self.cached_value.borrow().unwrap();
+        ruby.get_inner(opaque)
+    }
+
+    pub fn set(&self, value: T, ruby: &Ruby) {
+        let new_value = (self.transform)(&value, ruby);
+        *self.cached_value.borrow_mut() = Some(Opaque::from(new_value));
+    }
+
+    pub fn mark(&self, marker: &gc::Marker) {
+        if let Some(cached_value) = self.cached_value.borrow().as_ref() {
+            marker.mark(*cached_value);
+        }
+    }
+}

data/ext/yass/src/cached_value_list.rs

@@ -0,0 +1,63 @@
+use std::cell::RefCell;
+
+use magnus::{Error, RArray, Ruby, Value, gc, value::Opaque};
+
+pub struct CachedValueList<T, C = (), F = fn(&T, &Option<C>, &Ruby) -> Value> {
+    values: Vec<T>,
+    context: Option<C>,
+    transform: F,
+    cached_values: RefCell<Option<Opaque<RArray>>>
+}
+
+impl<T, C, F> CachedValueList<T, C, F> where F: Fn(&T, &Option<C>, &Ruby) -> Value {
+    pub fn new(values: Vec<T>, cb: F) -> Self {
+        Self { values, context: None, transform: cb, cached_values: RefCell::new(None) }
+    }
+
+    pub fn empty(context: Option<C>, cb: F) -> Self {
+        Self {
+            values: vec![],
+            context,
+            transform: cb,
+            cached_values: RefCell::new(None)
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.cached_values.borrow().is_none()
+    }
+
+    pub fn add(&self, value: T, ruby: &Ruby) -> Result<(), Error> {
+        if self.cached_values.borrow().is_none() {
+            let cached_values = ruby.ary_new_capa(1);
+            *self.cached_values.borrow_mut() = Some(Opaque::from(cached_values));
+        }
+
+        let new_value = (self.transform)(&value, &self.context, ruby);
+        let cached_values = ruby.get_inner(*self.cached_values.borrow().as_ref().unwrap());
+        cached_values.push(new_value)?;
+
+        Ok(())
+    }
+
+    pub fn to_a(&self, ruby: &Ruby) -> Result<RArray, Error> {
+        if self.cached_values.borrow().is_none() {
+            let cached_values = ruby.ary_new_capa(self.values.len());
+
+            for value in &self.values {
+                let new_value = (self.transform)(value, &self.context, ruby);
+                cached_values.push(new_value)?;
+            }
+
+            *self.cached_values.borrow_mut() = Some(Opaque::from(cached_values));
+        }
+
+        Ok(ruby.get_inner(*self.cached_values.borrow().as_ref().unwrap()).dup())
+    }
+
+    pub fn mark(&self, marker: &gc::Marker) {
+        if let Some(cached_values) = self.cached_values.borrow().as_ref() {
+            marker.mark(*cached_values);
+        }
+    }
+}

data/ext/yass/src/declarations/align_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::AlignContent")]
+pub struct YAlignContent {
+    content_distribution: ContentDistribution
+}
+
+impl YAlignContent {
+    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/align_flags.rs

@@ -0,0 +1,26 @@
+use magnus::{Ruby, value::Id};
+use style::values::specified::align::AlignFlags;
+
+pub fn to_id(flags: AlignFlags, ruby: &Ruby) -> Option<Id> {
+    match flags {
+        AlignFlags::AUTO => Some(ruby.intern("auto")),
+        AlignFlags::NORMAL => Some(ruby.intern("normal")),
+        AlignFlags::START => Some(ruby.intern("start")),
+        AlignFlags::END => Some(ruby.intern("end")),
+        AlignFlags::FLEX_START => Some(ruby.intern("flex_start")),
+        AlignFlags::FLEX_END => Some(ruby.intern("flex_end")),
+        AlignFlags::CENTER => Some(ruby.intern("center")),
+        AlignFlags::LEFT => Some(ruby.intern("left")),
+        AlignFlags::RIGHT => Some(ruby.intern("right")),
+        AlignFlags::BASELINE => Some(ruby.intern("baseline")),
+        AlignFlags::LAST_BASELINE => Some(ruby.intern("last_baseline")),
+        AlignFlags::STRETCH => Some(ruby.intern("stretch")),
+        AlignFlags::SELF_START => Some(ruby.intern("self_start")),
+        AlignFlags::SELF_END => Some(ruby.intern("self_end")),
+        AlignFlags::SPACE_BETWEEN => Some(ruby.intern("space_between")),
+        AlignFlags::SPACE_AROUND => Some(ruby.intern("space_around")),
+        AlignFlags::SPACE_EVENLY => Some(ruby.intern("space_evenly")),
+        AlignFlags::ANCHOR_CENTER => Some(ruby.intern("anchor_center")),
+        _ => None
+    }
+}

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

@@ -0,0 +1,37 @@
+use magnus::{Error, Ruby, typed_data, value::Id};
+use style::values::{computed::ItemPlacement, specified::align::AlignFlags};
+
+#[magnus::wrap(class = "Yass::Declarations::AlignItems")]
+pub struct YAlignItems {
+    item_placement: ItemPlacement
+}
+
+impl YAlignItems {
+    pub fn new(item_placement: ItemPlacement) -> Self {
+        Self { item_placement }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<Id, Error> {
+        match rb_self.item_placement.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/align_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::AlignSelf")]
+pub struct YAlignSelf {
+    self_alignment: SelfAlignment
+}
+
+impl YAlignSelf {
+    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/alignment_baseline.rs

@@ -0,0 +1,27 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::AlignmentBaseline;
+
+#[magnus::wrap(class = "Yass::Declarations::AlignmentBaseline")]
+pub struct YAlignmentBaseline {
+    alignment_baseline: AlignmentBaseline
+}
+
+impl YAlignmentBaseline {
+    pub fn new(alignment_baseline: AlignmentBaseline) -> Self {
+        Self { alignment_baseline }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.alignment_baseline {
+            AlignmentBaseline::Baseline => ruby.intern("baseline"),
+            AlignmentBaseline::TextBottom => ruby.intern("text_bottom"),
+            AlignmentBaseline::Middle => ruby.intern("middle"),
+            AlignmentBaseline::TextTop => ruby.intern("text_top"),
+            AlignmentBaseline::Alphabetic => ruby.intern("alphabetic"),
+            AlignmentBaseline::Ideographic => ruby.intern("ideographic"),
+            AlignmentBaseline::Central => ruby.intern("central"),
+            AlignmentBaseline::Mathematical => ruby.intern("mathematical"),
+            AlignmentBaseline::Hanging => ruby.intern("hanging"),
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+use magnus::{Ruby, typed_data};
+use style::values::specified::Angle;
+
+#[magnus::wrap(class = "Yass::Declarations::Angle")]
+pub struct YAngle {
+    angle: Angle
+}
+
+impl YAngle {
+    pub fn new(angle: Angle) -> Self {
+        Self { angle }
+    }
+
+    pub fn was_calc(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.angle.was_calc()
+    }
+
+    pub fn degrees(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.angle.degrees()
+    }
+
+    pub fn unit(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> &'static str {
+        rb_self.angle.unit()
+    }
+}

data/ext/yass/src/declarations/animation/auto.rs

@@ -0,0 +1,8 @@
+#[magnus::wrap(class = "Yass::Declarations::Animation::Auto")]
+pub struct YAuto { }
+
+impl YAuto {
+    pub fn new() -> Self {
+        Self { }
+    }
+}

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

@@ -0,0 +1,40 @@
+use magnus::{Error, Module, RModule, Ruby, method};
+
+use crate::declarations::animation::{inset::YInset, range_value::YRangeValue, scroll_axis::YScrollAxis, scroll_function::YScrollFunction, scroller::YScroller, timeline_name::YTimelineName, timing_function, view_function::YViewFunction};
+
+pub fn init(ruby: &Ruby, yass_module: &RModule, declarations_module: &RModule) -> Result<(), Error> {
+    let animation_module = declarations_module.define_module("Animation")?;
+
+    let _auto_class = animation_module.define_class("Auto", ruby.class_object())?;
+
+    let inset_class = animation_module.define_class("Inset", ruby.class_object())?;
+    inset_class.define_method("start", method!(YInset::start, 0))?;
+    inset_class.define_method("end", method!(YInset::end, 0))?;
+
+    let _length_auto_class = animation_module.define_class("LengthAuto", ruby.class_object())?;
+
+    let range_value_class = animation_module.define_class("RangeValue", ruby.class_object())?;
+    range_value_class.define_method("length_percentage", method!(YRangeValue::length_percentage, 0))?;
+    range_value_class.define_method("name", method!(YRangeValue::name, 0))?;
+
+    let scroll_axis_class = animation_module.define_class("ScrollAxis", ruby.class_object())?;
+    scroll_axis_class.define_method("value", method!(YScrollAxis::value, 0))?;
+
+    let scroll_function_class = animation_module.define_class("ScrollFunction", ruby.class_object())?;
+    scroll_function_class.define_method("scroller", method!(YScrollFunction::scroller, 0))?;
+    scroll_function_class.define_method("scroll_axis", method!(YScrollFunction::scroll_axis, 0))?;
+
+    let scroller_class = animation_module.define_class("Scroller", ruby.class_object())?;
+    scroller_class.define_method("value", method!(YScroller::value, 0))?;
+
+    let timeline_name_class = animation_module.define_class("TimelineName", ruby.class_object())?;
+    timeline_name_class.define_method("value", method!(YTimelineName::value, 0))?;
+
+    let view_function_class = animation_module.define_class("ViewFunction", ruby.class_object())?;
+    view_function_class.define_method("scroll_axis", method!(YViewFunction::scroll_axis, 0))?;
+    view_function_class.define_method("inset", method!(YViewFunction::inset, 0))?;
+
+    timing_function::init::init(ruby, yass_module, declarations_module, &animation_module)?;
+
+    Ok(())
+}

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

@@ -0,0 +1,50 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::{animation::ViewTimelineInset, length::LengthPercentageOrAuto}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::{animation::length_auto::YLengthAuto, size::length_percentage_to_value}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Animation::Inset", mark)]
+pub struct YInset {
+    start: CachedValue<LengthPercentageOrAuto<LengthPercentage>>,
+    end: CachedValue<LengthPercentageOrAuto<LengthPercentage>>
+}
+
+impl YInset {
+    pub fn new(inset: ViewTimelineInset<LengthPercentage>) -> Self {
+        Self {
+            start: CachedValue::new(inset.start, |start, ruby| {
+                match start {
+                    LengthPercentageOrAuto::Auto => YLengthAuto::new().into_value_with(ruby),
+                    LengthPercentageOrAuto::LengthPercentage(length) => {
+                        length_percentage_to_value(length, ruby)
+                    }
+                }
+            }),
+
+            end: CachedValue::new(inset.end, |end, ruby| {
+                match end {
+                    LengthPercentageOrAuto::Auto => YLengthAuto::new().into_value_with(ruby),
+                    LengthPercentageOrAuto::LengthPercentage(length) => {
+                        length_percentage_to_value(length, ruby)
+                    }
+                }
+            })
+        }
+    }
+
+    pub fn start(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.start.get(ruby)
+    }
+
+    pub fn end(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.end.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YInset {
+    fn mark(&self, marker: &gc::Marker) {
+        self.start.mark(marker);
+        self.end.mark(marker);
+    }
+}

data/ext/yass/src/declarations/animation/length_auto.rs

@@ -0,0 +1,8 @@
+#[magnus::wrap(class = "Yass::Declarations::Animation::LengthAuto")]
+pub struct YLengthAuto { }
+
+impl YLengthAuto {
+    pub fn new() -> Self {
+        Self { }
+    }
+}

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

@@ -0,0 +1,11 @@
+pub mod auto;
+pub mod init;
+pub mod inset;
+pub mod length_auto;
+pub mod range_value;
+pub mod scroll_axis;
+pub mod scroll_function;
+pub mod scroller;
+pub mod timeline_name;
+pub mod timing_function;
+pub mod view_function;

data/ext/yass/src/declarations/animation/range_value.rs

@@ -0,0 +1,47 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{generics::{animation::AnimationRangeValue}, specified::{LengthPercentage, animation::TimelineRangeName}};
+
+use crate::{cached_value::CachedValue, declarations::size::length_percentage_to_value};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Animation::RangeValue", mark)]
+pub struct YRangeValue {
+    length_percentage: CachedValue<LengthPercentage>,
+    name: TimelineRangeName
+}
+
+impl YRangeValue {
+    pub fn new(value: AnimationRangeValue<LengthPercentage>) -> Self {
+        Self {
+            length_percentage: CachedValue::new(value.lp, |lp, ruby| {
+                length_percentage_to_value(lp, ruby)
+            }),
+
+            name: value.name
+        }
+    }
+
+    pub fn length_percentage(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length_percentage.get(ruby)
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.name {
+            TimelineRangeName::None => ruby.intern("none"),
+            TimelineRangeName::Cover => ruby.intern("cover"),
+            TimelineRangeName::Contain => ruby.intern("contain"),
+            TimelineRangeName::Entry => ruby.intern("entry"),
+            TimelineRangeName::Exit => ruby.intern("exit"),
+            TimelineRangeName::EntryCrossing => ruby.intern("entry_crossing"),
+            TimelineRangeName::ExitCrossing => ruby.intern("exit_crossing"),
+            TimelineRangeName::Scroll => ruby.intern("scroll"),
+            TimelineRangeName::Normal => ruby.intern("normal"),
+        }
+    }
+}
+
+impl DataTypeFunctions for YRangeValue {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length_percentage.mark(marker);
+    }
+}

data/ext/yass/src/declarations/animation/scroll_axis.rs

@@ -0,0 +1,22 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::ScrollAxis;
+
+#[magnus::wrap(class = "Yass::Declarations::Animation::ScrollAxis")]
+pub struct YScrollAxis {
+    scroll_axis: ScrollAxis
+}
+
+impl YScrollAxis {
+    pub fn new(scroll_axis: ScrollAxis) -> Self {
+        Self { scroll_axis }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.scroll_axis {
+            ScrollAxis::Block => ruby.intern("block"),
+            ScrollAxis::Inline => ruby.intern("inline"),
+            ScrollAxis::X => ruby.intern("x"),
+            ScrollAxis::Y => ruby.intern("y"),
+        }
+    }
+}

data/ext/yass/src/declarations/animation/scroll_function.rs

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{computed::ScrollAxis, specified::animation::{ScrollFunction, Scroller}};
+
+use crate::{cached_value::CachedValue, declarations::animation::{scroll_axis::YScrollAxis, scroller::YScroller}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Animation::ScrollFunction", mark)]
+pub struct YScrollFunction {
+    scroller: CachedValue<Scroller>,
+    scroll_axis: CachedValue<ScrollAxis>
+}
+
+impl YScrollFunction {
+    pub fn new(scroll_function: ScrollFunction) -> Self {
+        YScrollFunction {
+            scroller: CachedValue::new(scroll_function.scroller, |scroller, ruby| {
+                YScroller::new(*scroller).into_value_with(ruby)
+            }),
+
+            scroll_axis: CachedValue::new(scroll_function.axis, |axis, ruby| {
+                YScrollAxis::new(*axis).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn scroller(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.scroller.get(ruby)
+    }
+
+    pub fn scroll_axis(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.scroll_axis.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YScrollFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.scroller.mark(marker);
+        self.scroll_axis.mark(marker);
+    }
+}

data/ext/yass/src/declarations/animation/scroller.rs

@@ -0,0 +1,21 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::specified::animation::Scroller;
+
+#[magnus::wrap(class = "Yass::Declarations::Animation::Scroller")]
+pub struct YScroller {
+    scroller: Scroller
+}
+
+impl YScroller {
+    pub fn new(scroller: Scroller) -> Self {
+        Self { scroller }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.scroller {
+            Scroller::Nearest => ruby.intern("nearest"),
+            Scroller::Root => ruby.intern("root"),
+            Scroller::SelfElement => ruby.intern("self_element"),
+        }
+    }
+}

data/ext/yass/src/declarations/animation/timeline_name.rs

@@ -0,0 +1,16 @@
+use magnus::{RString, Ruby, typed_data};
+
+#[magnus::wrap(class = "Yass::Declarations::Animation::TimelineName")]
+pub struct YTimelineName {
+    timeline_name: String
+}
+
+impl YTimelineName {
+    pub fn new(timeline_name: String) -> Self {
+        Self { timeline_name }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> RString {
+        ruby.str_from_slice(rb_self.timeline_name.as_bytes())
+    }
+}