yass-css 0.2.0

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

@@ -0,0 +1,113 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data};
+use style::{
+    properties::longhands::box_shadow::{SingleSpecifiedValue, SpecifiedValue},
+    values::specified::{Color, Length, NonNegativeLength},
+};
+
+use crate::{
+    cached_value::CachedValue,
+    cached_value_list::CachedValueList,
+    declarations::{color::color::make_color, length::length_to_value},
+};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BoxShadow", mark)]
+pub struct YBoxShadow {
+    values: CachedValueList<SingleSpecifiedValue>,
+}
+
+impl YBoxShadow {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                YBoxShadowShadow::new(value.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 YBoxShadow {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::BoxShadow::Shadow", mark)]
+pub struct YBoxShadowShadow {
+    color: CachedValue<Option<Color>>,
+    horizontal: CachedValue<Length>,
+    vertical: CachedValue<Length>,
+    blur: CachedValue<Option<NonNegativeLength>>,
+    spread: CachedValue<Option<Length>>,
+    inset: bool,
+}
+
+impl YBoxShadowShadow {
+    pub fn new(value: SingleSpecifiedValue) -> Self {
+        Self {
+            color: CachedValue::new(value.base.color, |color, ruby| match color {
+                Some(color) => make_color(color, ruby),
+                None => ruby.qnil().into_value_with(ruby),
+            }),
+
+            horizontal: CachedValue::new(value.base.horizontal, |length, ruby| {
+                length_to_value(length, ruby)
+            }),
+
+            vertical: CachedValue::new(value.base.vertical, |length, ruby| {
+                length_to_value(length, ruby)
+            }),
+
+            blur: CachedValue::new(value.base.blur, |blur, ruby| match blur {
+                Some(blur) => length_to_value(&blur.0, ruby),
+                None => ruby.qnil().into_value_with(ruby),
+            }),
+
+            spread: CachedValue::new(value.spread, |spread, ruby| match spread {
+                Some(spread) => length_to_value(spread, ruby),
+                None => ruby.qnil().into_value_with(ruby),
+            }),
+
+            inset: value.inset,
+        }
+    }
+
+    pub fn color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color.get(ruby)
+    }
+
+    pub fn horizontal(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.horizontal.get(ruby)
+    }
+
+    pub fn vertical(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.vertical.get(ruby)
+    }
+
+    pub fn blur(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.blur.get(ruby)
+    }
+
+    pub fn spread(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.spread.get(ruby)
+    }
+
+    pub fn is_inset(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.inset
+    }
+}
+
+impl DataTypeFunctions for YBoxShadowShadow {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+        self.horizontal.mark(marker);
+        self.vertical.mark(marker);
+        self.blur.mark(marker);
+        self.spread.mark(marker);
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::properties::longhands::box_sizing::SpecifiedValue;
+
+#[magnus::wrap(class = "Yass::Declarations::BoxSizing")]
+pub struct YBoxSizing {
+    specified_value: SpecifiedValue
+}
+
+impl YBoxSizing {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.specified_value {
+            SpecifiedValue::ContentBox => ruby.intern("content_box"),
+            SpecifiedValue::BorderBox => ruby.intern("border_box"),
+        }
+    }
+}

data/ext/yass/src/declarations/calc/abs.rs

@@ -0,0 +1,32 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc, typed_data};
+use style::values::specified::calc::CalcNode;
+
+use crate::{cached_value::CachedValue, declarations::calc::YCalc};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc::Abs", mark)]
+pub struct YAbs {
+    child: CachedValue<CalcNode>
+}
+
+impl YAbs {
+    pub fn new(child: CalcNode) -> Self {
+        Self {
+            child: CachedValue::new(child, |calc_node, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            })
+        }
+    }
+
+    pub fn children(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(1);
+        result.push(rb_self.child.get(ruby))?;
+        Ok(result)
+    }
+}
+
+impl DataTypeFunctions for YAbs {
+    fn mark(&self, marker: &gc::Marker) {
+        self.child.mark(marker);
+    }
+}

data/ext/yass/src/declarations/calc/anchor_function.rs

@@ -0,0 +1,96 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{generics::{Optional, position::{AnchorSideKeyword, GenericAnchorFunction, GenericAnchorSide}}, specified::calc::CalcNode};
+
+use crate::{cached_value::CachedValue, declarations::calc::YCalc};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc::AnchorFunction", mark)]
+pub struct YAnchorFunction {
+    target_element: CachedValue<String>,
+    side: CachedValue<GenericAnchorSide<Box<CalcNode>>>,
+    fallback: CachedValue<Optional<Box<CalcNode>>>
+}
+
+impl YAnchorFunction {
+    pub fn new(anchor_function: GenericAnchorFunction<Box<CalcNode>, Box<CalcNode>>) -> Self {
+        Self {
+            target_element: CachedValue::new(anchor_function.target_element.value.0.to_string(), |el, ruby| {
+                ruby.str_new(el).into_value_with(ruby)
+            }),
+
+            side: CachedValue::new(anchor_function.side, |side, ruby| {
+                match side {
+                    GenericAnchorSide::Percentage(p) => {
+                        YCalc::make_node(p, ruby)
+                    },
+
+                    GenericAnchorSide::Keyword(k) => {
+                        YAnchorSideKeyword::new(k.clone()).into_value_with(ruby)
+                    }
+                }
+            }),
+
+            fallback: CachedValue::new(anchor_function.fallback, |fallback, ruby| {
+                match fallback {
+                    Optional::Some(fb) => YCalc::make_node(fb, ruby),
+                    Optional::None => ruby.qnil().into_value_with(ruby)
+                }
+            })
+        }
+    }
+
+    pub fn target_element(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.target_element.get(ruby)
+    }
+
+    pub fn side(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.side.get(ruby)
+    }
+
+    pub fn fallback(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.fallback.get(ruby)
+    }
+
+    pub fn children(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(3);
+        result.push(rb_self.target_element.get(ruby))?;
+        result.push(rb_self.side.get(ruby))?;
+        result.push(rb_self.fallback.get(ruby))?;
+        Ok(result)
+    }
+}
+
+impl DataTypeFunctions for YAnchorFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.target_element.mark(marker);
+        self.side.mark(marker);
+        self.fallback.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Calc::AnchorSideKeyword")]
+pub struct YAnchorSideKeyword {
+    anchor_side_keyword: AnchorSideKeyword
+}
+
+impl YAnchorSideKeyword {
+    pub fn new(anchor_side_keyword: AnchorSideKeyword) -> Self {
+        Self { anchor_side_keyword }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.anchor_side_keyword {
+            AnchorSideKeyword::Inside => ruby.intern("inside"),
+            AnchorSideKeyword::Outside => ruby.intern("outside"),
+            AnchorSideKeyword::Top => ruby.intern("top"),
+            AnchorSideKeyword::Left => ruby.intern("left"),
+            AnchorSideKeyword::Right => ruby.intern("right"),
+            AnchorSideKeyword::Bottom => ruby.intern("bottom"),
+            AnchorSideKeyword::Start => ruby.intern("start"),
+            AnchorSideKeyword::End => ruby.intern("end"),
+            AnchorSideKeyword::SelfStart => ruby.intern("self_start"),
+            AnchorSideKeyword::SelfEnd => ruby.intern("self_end"),
+            AnchorSideKeyword::Center => ruby.intern("center"),
+        }
+    }
+}

data/ext/yass/src/declarations/calc/anchor_size_function.rs

@@ -0,0 +1,84 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{generics::{Optional, length::{AnchorSizeKeyword, GenericAnchorSizeFunction}}, specified::calc::CalcNode};
+
+use crate::{cached_value::CachedValue, declarations::calc::YCalc};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc::AnchorSizeFunction", mark)]
+pub struct YAnchorSizeFunction {
+    target_element: CachedValue<String>,
+    size: CachedValue<AnchorSizeKeyword>,
+    fallback: CachedValue<Optional<Box<CalcNode>>>
+}
+
+impl YAnchorSizeFunction {
+    pub fn new(anchor_size: GenericAnchorSizeFunction<Box<CalcNode>>) -> Self {
+        Self {
+            target_element: CachedValue::new(anchor_size.target_element.value.0.to_string(), |el, ruby| {
+                ruby.str_new(el).into_value_with(ruby)
+            }),
+
+            size: CachedValue::new(anchor_size.size, |size, ruby| {
+                YAnchorSizeKeyword::new(*size).into_value_with(ruby)
+            }),
+
+            fallback: CachedValue::new(anchor_size.fallback, |fallback, ruby| {
+                match fallback {
+                    Optional::Some(fb) => YCalc::make_node(fb, ruby),
+                    Optional::None => ruby.qnil().into_value_with(ruby)
+                }
+            })
+        }
+    }
+
+    pub fn target_element(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.target_element.get(ruby)
+    }
+
+    pub fn size(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.size.get(ruby)
+    }
+
+    pub fn fallback(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.fallback.get(ruby)
+    }
+
+    pub fn children(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(3);
+        result.push(rb_self.target_element.get(ruby))?;
+        result.push(rb_self.size.get(ruby))?;
+        result.push(rb_self.fallback.get(ruby))?;
+        Ok(result)
+    }
+}
+
+impl DataTypeFunctions for YAnchorSizeFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.target_element.mark(marker);
+        self.size.mark(marker);
+        self.fallback.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Calc::AnchorSizeKeyword")]
+pub struct YAnchorSizeKeyword {
+    anchor_size_keyword: AnchorSizeKeyword
+}
+
+impl YAnchorSizeKeyword {
+    pub fn new(anchor_size_keyword: AnchorSizeKeyword) -> Self {
+        Self { anchor_size_keyword }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.anchor_size_keyword {
+            AnchorSizeKeyword::None => unreachable!(),
+            AnchorSizeKeyword::Width => ruby.intern("width"),
+            AnchorSizeKeyword::Height => ruby.intern("height"),
+            AnchorSizeKeyword::Block => ruby.intern("block"),
+            AnchorSizeKeyword::Inline => ruby.intern("inline"),
+            AnchorSizeKeyword::SelfBlock => ruby.intern("self_block"),
+            AnchorSizeKeyword::SelfInline => ruby.intern("self_inline"),
+        }
+    }
+}

data/ext/yass/src/declarations/calc/clamp.rs

@@ -0,0 +1,58 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::calc::CalcNode;
+
+use crate::{cached_value::CachedValue, declarations::calc::YCalc};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc::Clamp", mark)]
+pub struct YClamp {
+    min: CachedValue<CalcNode>,
+    center: CachedValue<CalcNode>,
+    max: CachedValue<CalcNode>
+}
+
+impl YClamp {
+    pub fn new(min: CalcNode, center: CalcNode, max: CalcNode) -> Self {
+        Self {
+            min: CachedValue::new(min, |calc_node, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            }),
+
+            center: CachedValue::new(center, |calc_node, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            }),
+
+            max: CachedValue::new(max, |calc_node, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            })
+        }
+    }
+
+    pub fn children(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(3);
+        result.push(rb_self.min.get(ruby))?;
+        result.push(rb_self.center.get(ruby))?;
+        result.push(rb_self.max.get(ruby))?;
+        Ok(result)
+    }
+
+    pub fn min(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.min.get(ruby)
+    }
+
+    pub fn center(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.center.get(ruby)
+    }
+
+    pub fn max(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.max.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YClamp {
+    fn mark(&self, marker: &gc::Marker) {
+        self.min.mark(marker);
+        self.center.mark(marker);
+        self.max.mark(marker);
+    }
+}

data/ext/yass/src/declarations/calc/hypot.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc, typed_data};
+use style::{OwnedSlice, values::specified::calc::CalcNode};
+
+use crate::{declarations::calc::YCalc, cached_value_list::CachedValueList};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc::Hypot", mark)]
+pub struct YHypot {
+    children: CachedValueList<CalcNode>
+}
+
+impl YHypot {
+    pub fn new(children: &OwnedSlice<CalcNode>) -> Self {
+        Self {
+            children: CachedValueList::new(children.to_vec(), |calc_node, _ctx, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            })
+        }
+    }
+
+    pub fn children(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.children.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YHypot {
+    fn mark(&self, marker: &gc::Marker) {
+        self.children.mark(marker);
+    }
+}

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

@@ -0,0 +1,72 @@
+use magnus::{Error, Module, RModule, Ruby, method};
+
+use crate::declarations::calc::{YCalc, abs::YAbs, anchor_function::{YAnchorFunction, YAnchorSideKeyword}, anchor_size_function::{YAnchorSizeFunction, YAnchorSizeKeyword}, clamp::YClamp, hypot::YHypot, invert::YInvert, min_max::YMinMax, mod_rem::YModRem, negate::YNegate, product::YProduct, round::YRound, sign::YSign, sum::YSum};
+
+pub fn init(ruby: &Ruby, _yass_module: &RModule, declarations_module: &RModule) -> Result<(), Error> {
+    let calc_class = declarations_module.define_class("Calc", ruby.class_object())?;
+    calc_class.define_method("clamping_mode", method!(YCalc::clamping_mode, 0))?;
+    calc_class.define_method("root", method!(YCalc::root, 0))?;
+
+    let abs_class = calc_class.define_class("Abs", ruby.class_object())?;
+    abs_class.define_method("children", method!(YAbs::children, 0))?;
+
+    let anchor_function_class = calc_class.define_class("AnchorFunction", ruby.class_object())?;
+    anchor_function_class.define_method("children", method!(YAnchorFunction::children, 0))?;
+    anchor_function_class.define_method("target_element", method!(YAnchorFunction::target_element, 0))?;
+    anchor_function_class.define_method("side", method!(YAnchorFunction::side, 0))?;
+    anchor_function_class.define_method("fallback", method!(YAnchorFunction::fallback, 0))?;
+
+    let anchor_side_keyword_class = calc_class.define_class("AnchorSideKeyword", ruby.class_object())?;
+    anchor_side_keyword_class.define_method("value", method!(YAnchorSideKeyword::value, 0))?;
+
+    let anchor_size_function_class = calc_class.define_class("AnchorSizeFunction", ruby.class_object())?;
+    anchor_size_function_class.define_method("children", method!(YAnchorSizeFunction::children, 0))?;
+    anchor_size_function_class.define_method("target_element", method!(YAnchorSizeFunction::target_element, 0))?;
+    anchor_size_function_class.define_method("size", method!(YAnchorSizeFunction::size, 0))?;
+    anchor_size_function_class.define_method("fallback", method!(YAnchorSizeFunction::fallback, 0))?;
+
+    let anchor_size_keyword_class = calc_class.define_class("AnchorSizeKeyword", ruby.class_object())?;
+    anchor_size_keyword_class.define_method("value", method!(YAnchorSizeKeyword::value, 0))?;
+
+    let clamp_class = calc_class.define_class("Clamp", ruby.class_object())?;
+    clamp_class.define_method("children", method!(YClamp::children, 0))?;
+    clamp_class.define_method("min", method!(YClamp::min, 0))?;
+    clamp_class.define_method("center", method!(YClamp::center, 0))?;
+    clamp_class.define_method("max", method!(YClamp::max, 0))?;
+
+    let hypot_class = calc_class.define_class("Hypot", ruby.class_object())?;
+    hypot_class.define_method("children", method!(YHypot::children, 0))?;
+
+    let invert_class = calc_class.define_class("Invert", ruby.class_object())?;
+    invert_class.define_method("children", method!(YInvert::children, 0))?;
+
+    let min_max_class = calc_class.define_class("MinMax", ruby.class_object())?;
+    min_max_class.define_method("children", method!(YMinMax::children, 0))?;
+    min_max_class.define_method("op", method!(YMinMax::op, 0))?;
+
+    let mod_rem_class = calc_class.define_class("ModRem", ruby.class_object())?;
+    mod_rem_class.define_method("children", method!(YModRem::children, 0))?;
+    mod_rem_class.define_method("dividend", method!(YModRem::dividend, 0))?;
+    mod_rem_class.define_method("divisor", method!(YModRem::divisor, 0))?;
+    mod_rem_class.define_method("op", method!(YModRem::op, 0))?;
+
+    let negate_class = calc_class.define_class("Negate", ruby.class_object())?;
+    negate_class.define_method("children", method!(YNegate::children, 0))?;
+
+    let product_class = calc_class.define_class("Product", ruby.class_object())?;
+    product_class.define_method("children", method!(YProduct::children, 0))?;
+
+    let round_class = calc_class.define_class("Round", ruby.class_object())?;
+    round_class.define_method("children", method!(YRound::children, 0))?;
+    round_class.define_method("value", method!(YRound::value, 0))?;
+    round_class.define_method("step", method!(YRound::step, 0))?;
+    round_class.define_method("rounding_strategy", method!(YRound::rounding_strategy, 0))?;
+
+    let sign_class = calc_class.define_class("Sign", ruby.class_object())?;
+    sign_class.define_method("children", method!(YSign::children, 0))?;
+
+    let sum_class = calc_class.define_class("Sum", ruby.class_object())?;
+    sum_class.define_method("children", method!(YSum::children, 0))?;
+
+    Ok(())
+}

data/ext/yass/src/declarations/calc/invert.rs

@@ -0,0 +1,32 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc, typed_data};
+use style::values::specified::calc::CalcNode;
+
+use crate::{cached_value::CachedValue, declarations::calc::YCalc};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc::Invert", mark)]
+pub struct YInvert {
+    child: CachedValue<CalcNode>
+}
+
+impl YInvert {
+    pub fn new(child: CalcNode) -> Self {
+        Self {
+            child: CachedValue::new(child, |calc_node, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            })
+        }
+    }
+
+    pub fn children(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(1);
+        result.push(rb_self.child.get(ruby))?;
+        Ok(result)
+    }
+}
+
+impl DataTypeFunctions for YInvert {
+    fn mark(&self, marker: &gc::Marker) {
+        self.child.mark(marker);
+    }
+}

data/ext/yass/src/declarations/calc/leaf.rs

@@ -0,0 +1,36 @@
+use magnus::{IntoValue, Ruby, Value};
+use style::values::specified::calc::Leaf;
+
+use crate::declarations::{angle::YAngle, channel_keyword::YChannelKeyword, length::no_calc_length_to_value, number::YNumber, percentage::YPercentage, resolution::YResolution, time::YTime};
+
+pub fn make_leaf(leaf: &Leaf, ruby: &Ruby) -> Value {
+    match leaf {
+        Leaf::Length(no_calc_length) => {
+            no_calc_length_to_value(&no_calc_length, ruby)
+        },
+
+        Leaf::Angle(angle) => {
+            YAngle::new(angle.clone()).into_value_with(ruby)
+        },
+
+        Leaf::Time(time) => {
+            YTime::new(time.clone()).into_value_with(ruby)
+        },
+
+        Leaf::Resolution(resolution) => {
+            YResolution::new(resolution.clone()).into_value_with(ruby)
+        },
+
+        Leaf::ColorComponent(channel_keyword) => {
+            YChannelKeyword::new(channel_keyword.clone()).into_value_with(ruby)
+        },
+
+        Leaf::Percentage(percentage) => {
+            YPercentage::new(percentage.clone()).into_value_with(ruby)
+        },
+
+        Leaf::Number(number) => {
+            YNumber::new(number.clone()).into_value_with(ruby)
+        },
+    }
+}

data/ext/yass/src/declarations/calc/min_max.rs

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc, typed_data, value::Id};
+use style::{OwnedSlice, values::{generics::calc::MinMaxOp, specified::calc::CalcNode}};
+
+use crate::{declarations::calc::YCalc, cached_value_list::CachedValueList};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc::MinMax", mark)]
+pub struct YMinMax {
+    op: MinMaxOp,
+    children: CachedValueList<CalcNode>
+}
+
+impl YMinMax {
+    pub fn new(children: &OwnedSlice<CalcNode>, op: MinMaxOp) -> Self {
+        Self {
+            children: CachedValueList::new(children.to_vec(), |calc_node, _ctx, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            }),
+
+            op
+        }
+    }
+
+    pub fn children(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.children.to_a(ruby)
+    }
+
+    pub fn op(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.op {
+            MinMaxOp::Min => ruby.intern("min"),
+            MinMaxOp::Max => ruby.intern("max"),
+        }
+    }
+}
+
+impl DataTypeFunctions for YMinMax {
+    fn mark(&self, marker: &gc::Marker) {
+        self.children.mark(marker);
+    }
+}