yass-css 0.2.0

data/ext/yass/src/declarations/clip_path/shape_box.rs

@@ -0,0 +1,71 @@
+#[magnus::wrap(class = "Yass::Declarations::ClipPath::ElementDependent")]
+pub struct YClipPathElementDependent {}
+
+impl YClipPathElementDependent {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ClipPath::FillBox")]
+pub struct YClipPathFillBox {}
+
+impl YClipPathFillBox {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ClipPath::StrokeBox")]
+pub struct YClipPathStrokeBox {}
+
+impl YClipPathStrokeBox {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ClipPath::ViewBox")]
+pub struct YClipPathViewBox {}
+
+impl YClipPathViewBox {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ClipPath::MarginBox")]
+pub struct YClipPathMarginBox {}
+
+impl YClipPathMarginBox {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ClipPath::BorderBox")]
+pub struct YClipPathBorderBox {}
+
+impl YClipPathBorderBox {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ClipPath::PaddingBox")]
+pub struct YClipPathPaddingBox {}
+
+impl YClipPathPaddingBox {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ClipPath::ContentBox")]
+pub struct YClipPathContentBox {}
+
+impl YClipPathContentBox {
+    pub fn new() -> Self {
+        Self {}
+    }
+}

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

@@ -0,0 +1,46 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::{
+    color::AbsoluteColor,
+    values::specified::color::Absolute as SpecifiedAbsolute,
+};
+
+use crate::{cached_value::CachedValue, declarations::color::absolute_color::YAbsoluteColor};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Color::Absolute", mark)]
+pub struct YAbsolute {
+    color: CachedValue<AbsoluteColor>,
+    authored: CachedValue<Option<String>>,
+}
+
+impl YAbsolute {
+    pub fn new(absolute: SpecifiedAbsolute) -> Self {
+        Self {
+            color: CachedValue::new(absolute.color, |absolute_color, ruby| {
+                YAbsoluteColor::new(*absolute_color).into_value_with(ruby)
+            }),
+
+            authored: CachedValue::new(absolute.authored.map(|authored| authored.to_string()), |authored, ruby| {
+                match authored {
+                    Some(authored) => ruby.str_new(authored).into_value_with(ruby),
+                    None => ruby.qnil().into_value_with(ruby),
+                }
+            }),
+        }
+    }
+
+    pub fn color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color.get(ruby)
+    }
+
+    pub fn authored(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.authored.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAbsolute {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+        self.authored.mark(marker);
+    }
+}

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

@@ -0,0 +1,53 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::color::{AbsoluteColor, ColorComponents};
+
+use crate::{cached_value::CachedValue, declarations::{color::color_components::YColorComponents}};
+
+use super::{color_space_to_id};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Color::AbsoluteColor", mark)]
+pub struct YAbsoluteColor {
+    absolute_color: AbsoluteColor,
+    components: CachedValue<ColorComponents>,
+    alpha: Option<f32>,
+}
+
+impl YAbsoluteColor {
+    pub fn new(absolute_color: AbsoluteColor) -> Self {
+        Self {
+            components: CachedValue::new(absolute_color.components, |components, ruby| {
+                YColorComponents::new(*components).into_value_with(ruby)
+            }),
+
+            alpha: absolute_color.alpha(),
+            absolute_color,
+        }
+    }
+
+    pub fn components(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.components.get(ruby)
+    }
+
+    pub fn alpha(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Option<f32> {
+        rb_self.alpha
+    }
+
+    pub fn color_space(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        color_space_to_id(rb_self.absolute_color.color_space, ruby)
+    }
+
+    pub fn legacy_syntax(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.absolute_color.is_legacy_syntax()
+    }
+
+    pub fn transparent(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.absolute_color.is_transparent()
+    }
+}
+
+impl DataTypeFunctions for YAbsoluteColor {
+    fn mark(&self, marker: &gc::Marker) {
+        self.components.mark(marker);
+    }
+}

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

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

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

@@ -0,0 +1,38 @@
+use magnus::{IntoValue, Ruby, Value};
+use style::values::{generics::color::ColorOrAuto, specified::Color};
+
+use crate::declarations::color::{absolute::YAbsolute, auto::YAutoColor, color_function::YColorFunction, color_mix::YColorMix, current_color::YCurrentColor, light_dark::YLightDark, system_color::YSystemColor};
+
+pub fn make_color(color: &Color, ruby: &Ruby) -> Value {
+    match &color {
+        Color::Absolute(absolute) => {
+            YAbsolute::new((**absolute).clone()).into_value_with(ruby)
+        },
+        Color::ColorFunction(color_function) => {
+            YColorFunction::new((**color_function).clone()).into_value_with(ruby)
+        },
+        Color::ColorMix(color_mix) => {
+            YColorMix::new((**color_mix).clone()).into_value_with(ruby)
+        },
+        Color::LightDark(light_dark) => {
+            YLightDark::new((**light_dark).clone()).into_value_with(ruby)
+        },
+        Color::ContrastColor(contrast_color) => {
+            make_color(contrast_color, ruby)
+        },
+        Color::CurrentColor => {
+            YCurrentColor::new().into_value_with(ruby)
+        },
+        Color::System(system_color) => {
+            YSystemColor::new(*system_color).into_value_with(ruby)
+        },
+        Color::InheritFromBodyQuirk => todo!(),
+    }
+}
+
+pub fn make_color_or_auto(color_or_auto: &ColorOrAuto<Color>, ruby: &Ruby) -> Value {
+    match color_or_auto {
+        ColorOrAuto::Color(c) => make_color(c, ruby),
+        ColorOrAuto::Auto => YAutoColor::new().into_value_with(ruby),
+    }
+}

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

@@ -0,0 +1,25 @@
+use magnus::{Ruby, typed_data};
+use style::color::ColorComponents;
+
+#[magnus::wrap(class = "Yass::Declarations::Color::ColorComponents")]
+pub struct YColorComponents {
+    color_components: ColorComponents,
+}
+
+impl YColorComponents {
+    pub fn new(color_components: ColorComponents) -> Self {
+        Self { color_components }
+    }
+
+    pub fn c0(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.color_components.0
+    }
+
+    pub fn c1(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.color_components.1
+    }
+
+    pub fn c2(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.color_components.2
+    }
+}

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

@@ -0,0 +1,151 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data};
+use style::{
+    color::ColorFunction,
+    values::specified::Color as SpecifiedColor,
+};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList, declarations::color::{color::make_color, color_function_component::YColorFunctionComponent, stored_color_function_component::StoredColorFunctionComponent}};
+
+use super::{color_space_to_id};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Color::ColorFunction", mark)]
+pub struct YColorFunction {
+    color_function: ColorFunction<SpecifiedColor>,
+    origin_color: CachedValue<Option<SpecifiedColor>>,
+    components: CachedValueList<StoredColorFunctionComponent>,
+    alpha: CachedValue<StoredColorFunctionComponent>,
+}
+
+impl YColorFunction {
+    pub fn new(color_function: ColorFunction<SpecifiedColor>) -> Self {
+        let origin_color = color_function_origin(&color_function);
+        let components = color_function_components(&color_function);
+        let alpha = color_function_alpha(&color_function);
+
+        Self {
+            origin_color: CachedValue::new(origin_color, |color, ruby| {
+                maybe_specified_color_to_value(color.clone(), ruby)
+            }),
+
+            components: CachedValueList::new(components, |component, _ctx, ruby| {
+                YColorFunctionComponent::new(component.clone()).into_value_with(ruby)
+            }),
+
+            alpha: CachedValue::new(alpha, |component, ruby| {
+                YColorFunctionComponent::new(component.clone()).into_value_with(ruby)
+            }),
+
+            color_function,
+        }
+    }
+
+    pub fn has_origin_color(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.color_function.has_origin_color()
+    }
+
+    pub fn origin_color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.origin_color.get(ruby)
+    }
+
+    pub fn components(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.components.to_a(ruby)
+    }
+
+    pub fn alpha(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.alpha.get(ruby)
+    }
+
+    pub fn color_space(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        match rb_self.color_function {
+            ColorFunction::Color(.., color_space) => color_space_to_id(color_space, ruby).into_value_with(ruby),
+            _ => ruby.qnil().into_value_with(ruby),
+        }
+    }
+}
+
+impl DataTypeFunctions for YColorFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.origin_color.mark(marker);
+        self.components.mark(marker);
+        self.alpha.mark(marker);
+    }
+}
+
+fn maybe_specified_color_to_value(color: Option<SpecifiedColor>, ruby: &Ruby) -> Value {
+    match color {
+        Some(color) => make_color(&color, ruby),
+        None => ruby.qnil().into_value_with(ruby),
+    }
+}
+
+fn color_function_origin(color_function: &ColorFunction<SpecifiedColor>) -> Option<SpecifiedColor> {
+    match color_function {
+        ColorFunction::Rgb(origin_color, ..)
+        | ColorFunction::Hsl(origin_color, ..)
+        | ColorFunction::Hwb(origin_color, ..)
+        | ColorFunction::Lab(origin_color, ..)
+        | ColorFunction::Lch(origin_color, ..)
+        | ColorFunction::Oklab(origin_color, ..)
+        | ColorFunction::Oklch(origin_color, ..)
+        | ColorFunction::Color(origin_color, ..) => origin_color.as_ref().cloned(),
+    }
+}
+
+fn color_function_components(color_function: &ColorFunction<SpecifiedColor>) -> Vec<StoredColorFunctionComponent> {
+    match color_function {
+        ColorFunction::Rgb(_, c0, c1, c2, _) => vec![
+            StoredColorFunctionComponent::NumberOrPercentage(c0.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c1.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c2.clone()),
+        ],
+        ColorFunction::Lab(_, c0, c1, c2, _) => vec![
+            StoredColorFunctionComponent::NumberOrPercentage(c0.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c1.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c2.clone()),
+        ],
+        ColorFunction::Oklab(_, c0, c1, c2, _) => vec![
+            StoredColorFunctionComponent::NumberOrPercentage(c0.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c1.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c2.clone()),
+        ],
+        ColorFunction::Color(_, c0, c1, c2, _, _) => vec![
+            StoredColorFunctionComponent::NumberOrPercentage(c0.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c1.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c2.clone()),
+        ],
+        ColorFunction::Hsl(_, c0, c1, c2, _) => vec![
+            StoredColorFunctionComponent::NumberOrAngle(c0.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c1.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c2.clone()),
+        ],
+        ColorFunction::Hwb(_, c0, c1, c2, _) => vec![
+            StoredColorFunctionComponent::NumberOrAngle(c0.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c1.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c2.clone()),
+        ],
+        ColorFunction::Lch(_, c0, c1, c2, _) => vec![
+            StoredColorFunctionComponent::NumberOrPercentage(c0.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c1.clone()),
+            StoredColorFunctionComponent::NumberOrAngle(c2.clone()),
+        ],
+        ColorFunction::Oklch(_, c0, c1, c2, _) => vec![
+            StoredColorFunctionComponent::NumberOrPercentage(c0.clone()),
+            StoredColorFunctionComponent::NumberOrPercentage(c1.clone()),
+            StoredColorFunctionComponent::NumberOrAngle(c2.clone()),
+        ],
+    }
+}
+
+fn color_function_alpha(color_function: &ColorFunction<SpecifiedColor>) -> StoredColorFunctionComponent {
+    match color_function {
+        ColorFunction::Rgb(_, _, _, _, alpha)
+        | ColorFunction::Hsl(_, _, _, _, alpha)
+        | ColorFunction::Hwb(_, _, _, _, alpha)
+        | ColorFunction::Lab(_, _, _, _, alpha)
+        | ColorFunction::Lch(_, _, _, _, alpha)
+        | ColorFunction::Oklab(_, _, _, _, alpha)
+        | ColorFunction::Oklch(_, _, _, _, alpha)
+        | ColorFunction::Color(_, _, _, _, alpha, _) => StoredColorFunctionComponent::NumberOrPercentage(alpha.clone()),
+    }
+}

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

@@ -0,0 +1,61 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::{
+    color::{parsing::{ChannelKeyword}},
+    values::specified::{calc::CalcNode},
+};
+
+use crate::{
+    cached_value::CachedValue,
+    declarations::{calc::YCalc, channel_keyword::YChannelKeyword, color::stored_color_function_component::{StoredColorComponentValue, StoredColorFunctionComponent}},
+};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Color::ColorFunctionComponent", mark)]
+pub struct YColorFunctionComponent {
+    value: CachedValue<Option<StoredColorComponentValue>>,
+    channel_keyword: CachedValue<Option<ChannelKeyword>>,
+    calc: CachedValue<Option<CalcNode>>,
+}
+
+impl YColorFunctionComponent {
+    pub fn new(component: StoredColorFunctionComponent) -> Self {
+        Self {
+            value: CachedValue::new(component.value(), |value, ruby| match value {
+                Some(value) => value.to_value(ruby),
+                None => ruby.qnil().into_value_with(ruby),
+            }),
+
+            channel_keyword: CachedValue::new(component.channel_keyword(), |channel_keyword, ruby| {
+                match channel_keyword {
+                    Some(channel_keyword) => YChannelKeyword::new(*channel_keyword).into_value_with(ruby),
+                    None => ruby.qnil().into_value_with(ruby),
+                }
+            }),
+
+            calc: CachedValue::new(component.calc_node(), |calc_node, ruby| match calc_node {
+                Some(calc_node) => YCalc::make_node(calc_node, ruby),
+                None => ruby.qnil().into_value_with(ruby),
+            })
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+
+    pub fn channel_keyword(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.channel_keyword.get(ruby)
+    }
+
+    pub fn calc(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.calc.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YColorFunctionComponent {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+        self.channel_keyword.mark(marker);
+        self.calc.mark(marker);
+    }
+}

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

@@ -0,0 +1,29 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::color::mix::{ColorInterpolationMethod, HueInterpolationMethod};
+
+use super::color_space_to_id;
+
+#[magnus::wrap(class = "Yass::Declarations::Color::ColorInterpolationMethod")]
+pub struct YColorInterpolationMethod {
+    interpolation: ColorInterpolationMethod,
+}
+
+impl YColorInterpolationMethod {
+    pub fn new(interpolation: ColorInterpolationMethod) -> Self {
+        Self { interpolation }
+    }
+
+    pub fn space(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        color_space_to_id(rb_self.interpolation.space, ruby)
+    }
+
+    pub fn hue(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.interpolation.hue {
+            HueInterpolationMethod::Shorter => ruby.intern("shorter"),
+            HueInterpolationMethod::Longer => ruby.intern("longer"),
+            HueInterpolationMethod::Increasing => ruby.intern("increasing"),
+            HueInterpolationMethod::Decreasing => ruby.intern("decreasing"),
+            HueInterpolationMethod::Specified => ruby.intern("specified"),
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data};
+use style::values::generics::color::GenericColorMixItem;
+use style::values::specified::Color;
+use style::values::specified::percentage::Percentage;
+use style::values::{
+    generics::color::ColorMixFlags,
+    specified::color::ColorMix as SpecifiedColorMix,
+};
+use style::color::mix::ColorInterpolationMethod;
+
+use crate::declarations::color::color_interpolation_method::YColorInterpolationMethod;
+use crate::declarations::color::color_mix_item::YColorMixItem;
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Color::ColorMix", mark)]
+pub struct YColorMix {
+    flags: ColorMixFlags,
+    interpolation: CachedValue<ColorInterpolationMethod>,
+    items: CachedValueList<GenericColorMixItem<Color, Percentage>>,
+}
+
+impl YColorMix {
+    pub fn new(color_mix: SpecifiedColorMix) -> Self {
+        Self {
+            flags: color_mix.flags,
+
+            interpolation: CachedValue::new(color_mix.interpolation, |interpolation, ruby| {
+                YColorInterpolationMethod::new(*interpolation).into_value_with(ruby)
+            }),
+
+            items: CachedValueList::new(color_mix.items.to_vec(), |item, _ctx, ruby| {
+                YColorMixItem::new(item.clone()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn interpolation(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.interpolation.get(ruby)
+    }
+
+    pub fn items(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.items.to_a(ruby)
+    }
+
+    pub fn normalize_weights(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.flags.contains(ColorMixFlags::NORMALIZE_WEIGHTS)
+    }
+
+    pub fn result_in_modern_syntax(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.flags.contains(ColorMixFlags::RESULT_IN_MODERN_SYNTAX)
+    }
+}
+
+impl DataTypeFunctions for YColorMix {
+    fn mark(&self, marker: &gc::Marker) {
+        self.interpolation.mark(marker);
+        self.items.mark(marker);
+    }
+}

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

@@ -0,0 +1,43 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{
+    generics::color::GenericColorMixItem,
+    specified::{Color as SpecifiedColor, percentage::{Percentage, ToPercentage}},
+};
+
+use crate::{cached_value::CachedValue, declarations::{color::color::make_color, percentage::YPercentage}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Color::ColorMixItem", mark)]
+pub struct YColorMixItem {
+    color: CachedValue<SpecifiedColor>,
+    percentage: CachedValue<Percentage>,
+}
+
+impl YColorMixItem {
+    pub fn new(item: GenericColorMixItem<SpecifiedColor, Percentage>) -> Self {
+        Self {
+            color: CachedValue::new(item.color, |color, ruby| {
+                make_color(&color, ruby)
+            }),
+
+            percentage: CachedValue::new(item.percentage, |percentage, ruby| {
+                YPercentage::new(percentage.to_percentage()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color.get(ruby)
+    }
+
+    pub fn percentage(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.percentage.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YColorMixItem {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+        self.percentage.mark(marker);
+    }
+}

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

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

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

@@ -0,0 +1,60 @@
+use magnus::{Error, Module, RClass, Ruby, method};
+
+use crate::declarations::color::{absolute::YAbsolute, absolute_color::YAbsoluteColor, color_components::YColorComponents, color_function::YColorFunction, color_function_component::YColorFunctionComponent, color_interpolation_method::YColorInterpolationMethod, color_mix::YColorMix, color_mix_item::YColorMixItem, light_dark::YLightDark, system_color::YSystemColor};
+
+pub fn init(ruby: &Ruby, color_class: &RClass) -> Result<(), Error> {
+    let absolute_class = color_class.define_class("Absolute", ruby.class_object())?;
+    absolute_class.define_method("color", method!(YAbsolute::color, 0))?;
+    absolute_class.define_method("authored", method!(YAbsolute::authored, 0))?;
+
+    let _auto_class = color_class.define_class("Auto", ruby.class_object())?;
+
+    let absolute_color_class = color_class.define_class("AbsoluteColor", ruby.class_object())?;
+    absolute_color_class.define_method("components", method!(YAbsoluteColor::components, 0))?;
+    absolute_color_class.define_method("alpha", method!(YAbsoluteColor::alpha, 0))?;
+    absolute_color_class.define_method("color_space", method!(YAbsoluteColor::color_space, 0))?;
+    absolute_color_class.define_method("legacy_syntax?", method!(YAbsoluteColor::legacy_syntax, 0))?;
+    absolute_color_class.define_method("transparent?", method!(YAbsoluteColor::transparent, 0))?;
+
+    let color_components_class = color_class.define_class("ColorComponents", ruby.class_object())?;
+    color_components_class.define_method("c0", method!(YColorComponents::c0, 0))?;
+    color_components_class.define_method("c1", method!(YColorComponents::c1, 0))?;
+    color_components_class.define_method("c2", method!(YColorComponents::c2, 0))?;
+
+    let color_function_class = color_class.define_class("ColorFunction", ruby.class_object())?;
+    color_function_class.define_method("has_origin_color?", method!(YColorFunction::has_origin_color, 0))?;
+    color_function_class.define_method("origin_color", method!(YColorFunction::origin_color, 0))?;
+    color_function_class.define_method("components", method!(YColorFunction::components, 0))?;
+    color_function_class.define_method("alpha", method!(YColorFunction::alpha, 0))?;
+    color_function_class.define_method("color_space", method!(YColorFunction::color_space, 0))?;
+
+    let color_function_component_class = color_class.define_class("ColorFunctionComponent", ruby.class_object())?;
+    color_function_component_class.define_method("value", method!(YColorFunctionComponent::value, 0))?;
+    color_function_component_class.define_method("channel_keyword", method!(YColorFunctionComponent::channel_keyword, 0))?;
+    color_function_component_class.define_method("calc", method!(YColorFunctionComponent::calc, 0))?;
+
+    let color_mix_class = color_class.define_class("ColorMix", ruby.class_object())?;
+    color_mix_class.define_method("interpolation", method!(YColorMix::interpolation, 0))?;
+    color_mix_class.define_method("items", method!(YColorMix::items, 0))?;
+    color_mix_class.define_method("normalize_weights?", method!(YColorMix::normalize_weights, 0))?;
+    color_mix_class.define_method("result_in_modern_syntax?", method!(YColorMix::result_in_modern_syntax, 0))?;
+
+    let color_mix_item_class = color_class.define_class("ColorMixItem", ruby.class_object())?;
+    color_mix_item_class.define_method("color", method!(YColorMixItem::color, 0))?;
+    color_mix_item_class.define_method("percentage", method!(YColorMixItem::percentage, 0))?;
+
+    let light_dark_class = color_class.define_class("LightDark", ruby.class_object())?;
+    light_dark_class.define_method("light", method!(YLightDark::light, 0))?;
+    light_dark_class.define_method("dark", method!(YLightDark::dark, 0))?;
+
+    let color_interpolation_method_class = color_class.define_class("ColorInterpolationMethod", ruby.class_object())?;
+    color_interpolation_method_class.define_method("space", method!(YColorInterpolationMethod::space, 0))?;
+    color_interpolation_method_class.define_method("hue", method!(YColorInterpolationMethod::hue, 0))?;
+
+    let system_color_class = color_class.define_class("SystemColor", ruby.class_object())?;
+    system_color_class.define_method("value", method!(YSystemColor::value, 0))?;
+
+    let _current_color_class = color_class.define_class("CurrentColor", ruby.class_object())?;
+
+    Ok(())
+}