yass-css 0.2.0

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

@@ -0,0 +1,309 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, RString, Ruby, TypedData, Value, gc, typed_data};
+use style::counter_style::{CounterStyle, Symbol, Symbols, SymbolsType};
+use style::values::generics::counters::GenericContentItem;
+use style::values::specified::Content;
+use style::values::specified::image::Image as SpecifiedImage;
+
+use crate::{
+    cached_value::CachedValue,
+    cached_value_list::CachedValueList,
+    declarations::images::image_to_value,
+};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Content", mark)]
+pub struct YContent {
+    value: CachedValue<Content>,
+}
+
+impl YContent {
+    pub fn new(content: Content) -> Self {
+        Self {
+            value: CachedValue::new(content, |content, ruby| {
+                make_content(content, ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YContent {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Content::Normal")]
+pub struct YContentNormal {}
+
+impl YContentNormal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Content::None")]
+pub struct YContentNone {}
+
+impl YContentNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+fn make_content(content: &Content, ruby: &Ruby) -> Value {
+    match content {
+        Content::Normal => YContentNormal::new().into_value_with(ruby),
+        Content::None => YContentNone::new().into_value_with(ruby),
+        Content::Items(items) => {
+            YContentItems::new(items.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Content::Items", mark)]
+pub struct YContentItems {
+    items: CachedValueList<GenericContentItem<SpecifiedImage>>,
+    alt_start: usize,
+}
+
+impl YContentItems {
+    pub fn new(content_items: style::values::generics::counters::GenericContentItems<SpecifiedImage>) -> Self {
+        Self {
+            items: CachedValueList::new(content_items.items.to_vec(), |item, _ctx, ruby| {
+                make_content_item_value(item, ruby)
+            }),
+
+            alt_start: content_items.alt_start,
+        }
+    }
+
+    pub fn items(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.items.to_a(ruby)
+    }
+
+    pub fn alt_start(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> usize {
+        rb_self.alt_start
+    }
+}
+
+impl DataTypeFunctions for YContentItems {
+    fn mark(&self, marker: &gc::Marker) {
+        self.items.mark(marker);
+    }
+}
+
+fn make_content_item_value(item: &GenericContentItem<SpecifiedImage>, ruby: &Ruby) -> Value {
+    match item {
+        GenericContentItem::String(s) => {
+            YContentItemString::new((&**s).to_owned()).into_value_with(ruby)
+        }
+
+        GenericContentItem::Counter(name, style) => {
+            YContentItemCounter::new((&*name.0).to_owned(), style.clone())
+                .into_value_with(ruby)
+        }
+
+        GenericContentItem::Counters(name, separator, style) => {
+            YContentItemCounters::new(
+                (&*name.0).to_owned(),
+                (&**separator).to_owned(),
+                style.clone(),
+            )
+            .into_value_with(ruby)
+        }
+
+        GenericContentItem::OpenQuote => ruby.to_symbol("open_quote").into_value_with(ruby),
+        GenericContentItem::CloseQuote => ruby.to_symbol("close_quote").into_value_with(ruby),
+        GenericContentItem::NoOpenQuote => ruby.to_symbol("no_open_quote").into_value_with(ruby),
+        GenericContentItem::NoCloseQuote => ruby.to_symbol("no_close_quote").into_value_with(ruby),
+        GenericContentItem::Attr(attr) => {
+            YContentItemAttr::new(
+                (&**attr.namespace_prefix).to_owned(),
+                (&**attr.namespace_url).to_owned(),
+                (&*attr.attribute).to_owned(),
+                (&**attr.fallback).to_owned(),
+            ).into_value_with(ruby)
+        }
+
+        GenericContentItem::Image(image) => {
+            YContentItemImage::new(image.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Content::Item::String")]
+pub struct YContentItemString {
+    value: String,
+}
+
+impl YContentItemString {
+    pub fn new(value: String) -> Self {
+        Self { value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.value)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Content::Item::Counter")]
+pub struct YContentItemCounter {
+    name: String,
+    style: CounterStyle,
+}
+
+impl YContentItemCounter {
+    pub fn new(name: String, style: CounterStyle) -> Self {
+        Self { name, style }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.name)
+    }
+
+    pub fn style(ruby: &Ruby, rb_self: &Self) -> Value {
+        make_counter_style_value(&rb_self.style, ruby)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Content::Item::Counters")]
+pub struct YContentItemCounters {
+    name: String,
+    separator: String,
+    style: CounterStyle,
+}
+
+impl YContentItemCounters {
+    pub fn new(name: String, separator: String, style: CounterStyle) -> Self {
+        Self { name, separator, style }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.name)
+    }
+
+    pub fn separator(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.separator)
+    }
+
+    pub fn style(ruby: &Ruby, rb_self: &Self) -> Value {
+        make_counter_style_value(&rb_self.style, ruby)
+    }
+}
+
+fn make_counter_style_value(style: &CounterStyle, ruby: &Ruby) -> Value {
+    match style {
+        CounterStyle::None => ruby.intern("none").into_value_with(ruby),
+        CounterStyle::Name(name) => ruby.intern(&name.0.to_string()).into_value_with(ruby),
+        CounterStyle::String(value) => ruby.str_new(value).into_value_with(ruby),
+        CounterStyle::Symbols { ty, symbols } => {
+            YContentCounterStyleSymbols::new(*ty, symbols.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Content::CounterStyle::Symbols")]
+pub struct YContentCounterStyleSymbols {
+    kind: SymbolsType,
+    symbols: Vec<String>,
+}
+
+impl YContentCounterStyleSymbols {
+    pub fn new(kind: SymbolsType, symbols: Symbols) -> Self {
+        Self {
+            kind,
+            symbols: symbols
+                .0
+                .iter()
+                .map(|symbol| match symbol {
+                    Symbol::String(value) => (&**value).to_owned(),
+                    Symbol::Ident(ident) => ident.0.to_string(),
+                })
+                .collect(),
+        }
+    }
+
+    pub fn kind(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.intern(symbols_type_name(rb_self.kind)).into_value_with(ruby)
+    }
+
+    pub fn symbols(ruby: &Ruby, rb_self: &Self) -> Result<RArray, Error> {
+        let array = ruby.ary_new_capa(rb_self.symbols.len());
+
+        for symbol in rb_self.symbols.iter() {
+            array.push(ruby.str_new(symbol))?;
+        }
+
+        Ok(array)
+    }
+}
+
+fn symbols_type_name(symbols_type: SymbolsType) -> &'static str {
+    match symbols_type {
+        SymbolsType::Cyclic => "cyclic",
+        SymbolsType::Numeric => "numeric",
+        SymbolsType::Alphabetic => "alphabetic",
+        SymbolsType::Symbolic => "symbolic",
+        SymbolsType::Fixed => "fixed",
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Content::Item::Attr")]
+pub struct YContentItemAttr {
+    namespace_prefix: String,
+    namespace_url: String,
+    attribute: String,
+    fallback: String,
+}
+
+impl YContentItemAttr {
+    pub fn new(namespace_prefix: String, namespace_url: String, attribute: String, fallback: String) -> Self {
+        Self { namespace_prefix, namespace_url, attribute, fallback }
+    }
+
+    pub fn namespace_prefix(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.namespace_prefix)
+    }
+
+    pub fn namespace_url(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.namespace_url)
+    }
+
+    pub fn attribute(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.attribute)
+    }
+
+    pub fn fallback(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.fallback)
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Content::Item::Image", mark)]
+pub struct YContentItemImage {
+    image: CachedValue<SpecifiedImage>,
+}
+
+impl YContentItemImage {
+    pub fn new(image: SpecifiedImage) -> Self {
+        Self {
+            image: CachedValue::new(image, |img, ruby| image_to_value(img, ruby)),
+        }
+    }
+
+    pub fn image(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.image.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YContentItemImage {
+    fn mark(&self, marker: &gc::Marker) {
+        self.image.mark(marker);
+    }
+}
+

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

@@ -0,0 +1,60 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, RString, Ruby, TypedData, gc, typed_data};
+use style::values::generics::counters::CounterPair;
+use style::values::specified::{CounterIncrement, Integer};
+
+use crate::cached_value_list::CachedValueList;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::CounterIncrement", mark)]
+pub struct YCounterIncrement {
+    values: CachedValueList<CounterPair<Integer>>,
+}
+
+impl YCounterIncrement {
+    pub fn new(counter_increment: CounterIncrement) -> Self {
+        Self {
+            values: CachedValueList::new(counter_increment.to_vec(), |counter, _ctx, ruby| {
+                YCounterIncrementCounter::new(counter.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 YCounterIncrement {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::CounterIncrement::Counter")]
+pub struct YCounterIncrementCounter {
+    name: String,
+    value: i32,
+    is_reversed: bool,
+}
+
+impl YCounterIncrementCounter {
+    pub fn new(counter: CounterPair<Integer>) -> Self {
+        Self {
+            name: counter.name.0.to_string(),
+            value: counter.value.value(),
+            is_reversed: counter.is_reversed,
+        }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.name)
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: &Self) -> i32 {
+        rb_self.value
+    }
+
+    pub fn reversed(_ruby: &Ruby, rb_self: &Self) -> bool {
+        rb_self.is_reversed
+    }
+}

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

@@ -0,0 +1,60 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, RString, Ruby, TypedData, gc, typed_data};
+use style::values::generics::counters::CounterPair;
+use style::values::specified::{CounterReset, Integer};
+
+use crate::cached_value_list::CachedValueList;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::CounterReset", mark)]
+pub struct YCounterReset {
+    values: CachedValueList<CounterPair<Integer>>,
+}
+
+impl YCounterReset {
+    pub fn new(counter_reset: CounterReset) -> Self {
+        Self {
+            values: CachedValueList::new(counter_reset.to_vec(), |counter, _ctx, ruby| {
+                YCounterResetCounter::new(counter.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 YCounterReset {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::CounterReset::Counter")]
+pub struct YCounterResetCounter {
+    name: String,
+    value: i32,
+    is_reversed: bool,
+}
+
+impl YCounterResetCounter {
+    pub fn new(counter: CounterPair<Integer>) -> Self {
+        Self {
+            name: counter.name.0.to_string(),
+            value: counter.value.value(),
+            is_reversed: counter.is_reversed,
+        }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.name)
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: &Self) -> i32 {
+        rb_self.value
+    }
+
+    pub fn reversed(_ruby: &Ruby, rb_self: &Self) -> bool {
+        rb_self.is_reversed
+    }
+}

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

@@ -0,0 +1,28 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::properties::{CSSWideKeyword, WideKeywordDeclaration};
+
+pub fn css_wide_keyword_to_id(ruby: &Ruby, keyword: CSSWideKeyword) -> Id {
+    match keyword {
+        CSSWideKeyword::Initial => ruby.intern("initial"),
+        CSSWideKeyword::Inherit => ruby.intern("inherit"),
+        CSSWideKeyword::Unset => ruby.intern("unset"),
+        CSSWideKeyword::Revert => ruby.intern("revert"),
+        CSSWideKeyword::RevertLayer => ruby.intern("revert_layer"),
+        CSSWideKeyword::RevertRule => ruby.intern("revert_rule"),
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::CSSWideKeyword")]
+pub struct YCSSWideKeyword {
+    wide_keyword_declaration: WideKeywordDeclaration
+}
+
+impl YCSSWideKeyword {
+    pub fn new(wide_keyword_declaration: WideKeywordDeclaration) -> Self {
+        Self { wide_keyword_declaration }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        css_wide_keyword_to_id(ruby, rb_self.wide_keyword_declaration.keyword)
+    }
+}

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

@@ -0,0 +1,125 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::specified::{Cursor, ui::{CursorImage, CursorKind}};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList, declarations::{images::image_to_value, number::YNumber}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Cursor", mark)]
+pub struct YCursor {
+    images: CachedValueList<CursorImage>,
+    keyword: CursorKind,
+}
+
+impl YCursor {
+    pub fn new(cursor: Cursor) -> Self {
+        Self {
+            images: CachedValueList::new(cursor.images.to_vec(), |image, _ctx, ruby| {
+                YCursorImage::new(image.clone()).into_value_with(ruby)
+            }),
+            keyword: cursor.keyword,
+        }
+    }
+
+    pub fn images(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.images.to_a(ruby)
+    }
+
+    pub fn keyword(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        cursor_kind_to_id(rb_self.keyword, ruby)
+    }
+}
+
+impl DataTypeFunctions for YCursor {
+    fn mark(&self, marker: &gc::Marker) {
+        self.images.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Cursor::Image", mark)]
+pub struct YCursorImage {
+    image: CachedValue<style::values::specified::image::Image>,
+    has_hotspot: bool,
+    hotspot_x: CachedValue<style::values::specified::Number>,
+    hotspot_y: CachedValue<style::values::specified::Number>,
+}
+
+impl YCursorImage {
+    pub fn new(cursor_image: CursorImage) -> Self {
+        Self {
+            image: CachedValue::new(cursor_image.image, |image, ruby| image_to_value(image, ruby)),
+            has_hotspot: cursor_image.has_hotspot,
+            hotspot_x: CachedValue::new(cursor_image.hotspot_x, |hotspot_x, ruby| {
+                YNumber::new(hotspot_x.get()).into_value_with(ruby)
+            }),
+            hotspot_y: CachedValue::new(cursor_image.hotspot_y, |hotspot_y, ruby| {
+                YNumber::new(hotspot_y.get()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn image(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.image.get(ruby)
+    }
+
+    pub fn has_hotspot(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.has_hotspot
+    }
+
+    pub fn hotspot_x(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.hotspot_x.get(ruby)
+    }
+
+    pub fn hotspot_y(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.hotspot_y.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YCursorImage {
+    fn mark(&self, marker: &gc::Marker) {
+        self.image.mark(marker);
+        self.hotspot_x.mark(marker);
+        self.hotspot_y.mark(marker);
+    }
+}
+
+fn cursor_kind_to_id(cursor_kind: CursorKind, ruby: &Ruby) -> Id {
+    match cursor_kind {
+        CursorKind::None => ruby.intern("none"),
+        CursorKind::Default => ruby.intern("default"),
+        CursorKind::Pointer => ruby.intern("pointer"),
+        CursorKind::ContextMenu => ruby.intern("context_menu"),
+        CursorKind::Help => ruby.intern("help"),
+        CursorKind::Progress => ruby.intern("progress"),
+        CursorKind::Wait => ruby.intern("wait"),
+        CursorKind::Cell => ruby.intern("cell"),
+        CursorKind::Crosshair => ruby.intern("crosshair"),
+        CursorKind::Text => ruby.intern("text"),
+        CursorKind::VerticalText => ruby.intern("vertical_text"),
+        CursorKind::Alias => ruby.intern("alias"),
+        CursorKind::Copy => ruby.intern("copy"),
+        CursorKind::Move => ruby.intern("move"),
+        CursorKind::NoDrop => ruby.intern("no_drop"),
+        CursorKind::NotAllowed => ruby.intern("not_allowed"),
+        CursorKind::Grab => ruby.intern("grab"),
+        CursorKind::Grabbing => ruby.intern("grabbing"),
+        CursorKind::EResize => ruby.intern("e_resize"),
+        CursorKind::NResize => ruby.intern("n_resize"),
+        CursorKind::NeResize => ruby.intern("ne_resize"),
+        CursorKind::NwResize => ruby.intern("nw_resize"),
+        CursorKind::SResize => ruby.intern("s_resize"),
+        CursorKind::SeResize => ruby.intern("se_resize"),
+        CursorKind::SwResize => ruby.intern("sw_resize"),
+        CursorKind::WResize => ruby.intern("w_resize"),
+        CursorKind::EwResize => ruby.intern("ew_resize"),
+        CursorKind::NsResize => ruby.intern("ns_resize"),
+        CursorKind::NeswResize => ruby.intern("nesw_resize"),
+        CursorKind::NwseResize => ruby.intern("nwse_resize"),
+        CursorKind::ColResize => ruby.intern("col_resize"),
+        CursorKind::RowResize => ruby.intern("row_resize"),
+        CursorKind::AllScroll => ruby.intern("all_scroll"),
+        CursorKind::ZoomIn => ruby.intern("zoom_in"),
+        CursorKind::ZoomOut => ruby.intern("zoom_out"),
+        CursorKind::Auto => ruby.intern("auto"),
+    }
+}

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

@@ -0,0 +1,108 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::{
+    custom_properties::SpecifiedValue as CustomSpecifiedValue,
+    properties::{CSSWideKeyword, CustomDeclaration, CustomDeclarationValue},
+    properties_and_values::value::SpecifiedValue as RegisteredCustomSpecifiedValue,
+};
+use style_traits::ToCss;
+
+use crate::{cached_value::CachedValue, declarations::csswide_keyword::css_wide_keyword_to_id};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Custom", mark)]
+pub struct YCustom {
+    name: CachedValue<String>,
+    value: CachedValue<CustomDeclarationValue>,
+}
+
+impl YCustom {
+    pub fn new(custom_declaration: CustomDeclaration) -> Self {
+        Self {
+            name: CachedValue::new(custom_declaration.name.to_string(), |name, ruby| {
+                ruby.str_new(name).into_value_with(ruby)
+            }),
+
+            value: CachedValue::new(custom_declaration.value, |value, ruby| {
+                make_custom_value(value, ruby)
+            }),
+        }
+    }
+
+    pub fn name(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.name.get(ruby)
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YCustom {
+    fn mark(&self, marker: &gc::Marker) {
+        self.name.mark(marker);
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Custom::Unparsed")]
+pub struct YCustomValueUnparsed {
+    value: CustomSpecifiedValue,
+}
+
+impl YCustomValueUnparsed {
+    pub fn new(value: CustomSpecifiedValue) -> Self {
+        Self { value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby.str_new(&rb_self.value.css).into_value_with(ruby)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Custom::Parsed")]
+pub struct YCustomValueParsed {
+    value: RegisteredCustomSpecifiedValue,
+}
+
+impl YCustomValueParsed {
+    pub fn new(value: RegisteredCustomSpecifiedValue) -> Self {
+        Self { value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: &Self) -> Value {
+        ruby
+            .str_new(&rb_self.value.to_css_string())
+            .into_value_with(ruby)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Custom::CSSWideKeyword")]
+pub struct YCustomValueCSSWideKeyword {
+    value: CSSWideKeyword,
+}
+
+impl YCustomValueCSSWideKeyword {
+    pub fn new(value: CSSWideKeyword) -> Self {
+        Self { value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: &Self) -> Id {
+        css_wide_keyword_to_id(ruby, rb_self.value)
+    }
+}
+
+pub fn make_custom_value(value: &CustomDeclarationValue, ruby: &Ruby) -> Value {
+    match value {
+        CustomDeclarationValue::Unparsed(value) => {
+            YCustomValueUnparsed::new((**value).clone()).into_value_with(ruby)
+        },
+
+        CustomDeclarationValue::Parsed(value) => {
+            YCustomValueParsed::new((**value).clone()).into_value_with(ruby)
+        },
+
+        CustomDeclarationValue::CSSWideKeyword(value) => {
+            YCustomValueCSSWideKeyword::new(*value).into_value_with(ruby)
+        },
+    }
+}