yass-css 0.2.0

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

@@ -0,0 +1,118 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::specified::{CalcLengthPercentage, calc::CalcNode};
+use style_traits::values::specified::AllowedNumericType;
+
+use crate::{cached_value::CachedValue, declarations::calc::{abs::YAbs, anchor_function::YAnchorFunction, anchor_size_function::YAnchorSizeFunction, clamp::YClamp, hypot::YHypot, invert::YInvert, leaf::make_leaf, min_max::YMinMax, mod_rem::YModRem, negate::YNegate, product::YProduct, round::YRound, sign::YSign, sum::YSum}};
+
+pub mod abs;
+pub mod anchor_function;
+pub mod anchor_size_function;
+pub mod clamp;
+pub mod hypot;
+pub mod init;
+pub mod invert;
+pub mod leaf;
+pub mod min_max;
+pub mod mod_rem;
+pub mod negate;
+pub mod product;
+pub mod round;
+pub mod sign;
+pub mod sum;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc", mark)]
+pub struct YCalc {
+    clamping_mode: AllowedNumericType,
+    root: CachedValue<CalcNode>
+}
+
+impl YCalc {
+    pub fn new(calc_length_percentage: Box<CalcLengthPercentage>) -> Self {
+        Self {
+            clamping_mode: calc_length_percentage.clamping_mode,
+            root: CachedValue::new(calc_length_percentage.node, |calc_node, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            })
+        }
+    }
+
+    pub fn make_node(calc_node: &CalcNode, ruby: &Ruby) -> Value {
+        match calc_node {
+            CalcNode::Leaf(leaf) => {
+                make_leaf(leaf, ruby)
+            },
+
+            CalcNode::Negate(generic_calc_node) => {
+                YNegate::new((**generic_calc_node).clone()).into_value_with(ruby)
+            },
+
+            CalcNode::Invert(generic_calc_node) => {
+                YInvert::new((**generic_calc_node).clone()).into_value_with(ruby)
+            },
+
+            CalcNode::Sum(owned_slice) => {
+                YSum::new(owned_slice).into_value_with(ruby)
+            },
+
+            CalcNode::Product(owned_slice) => {
+                YProduct::new(owned_slice).into_value_with(ruby)
+            },
+
+            CalcNode::MinMax(owned_slice, min_max_op) => {
+                YMinMax::new(owned_slice, min_max_op.clone()).into_value_with(ruby)
+            },
+
+            CalcNode::Clamp { min, center, max } => {
+                YClamp::new((**min).clone(), (**center).clone(), (**max).clone()).into_value_with(ruby)
+            },
+
+            CalcNode::Round { strategy, value, step } => {
+                YRound::new(strategy.clone(), (**value).clone(), (**step).clone()).into_value_with(ruby)
+            },
+
+            CalcNode::ModRem { dividend, divisor, op } => {
+                YModRem::new((**dividend).clone(), (**divisor).clone(), op.clone()).into_value_with(ruby)
+            },
+
+            CalcNode::Hypot(owned_slice) => {
+                YHypot::new(owned_slice).into_value_with(ruby)
+            },
+
+            CalcNode::Abs(generic_calc_node) => {
+                YAbs::new((**generic_calc_node).clone()).into_value_with(ruby)
+            },
+
+            CalcNode::Sign(generic_calc_node) => {
+                YSign::new((**generic_calc_node).clone()).into_value_with(ruby)
+            },
+
+            CalcNode::Anchor(generic_anchor_function) => {
+                YAnchorFunction::new((**generic_anchor_function).clone()).into_value_with(ruby)
+            },
+
+            CalcNode::AnchorSize(generic_anchor_size_function) => {
+                YAnchorSizeFunction::new((**generic_anchor_size_function).clone()).into_value_with(ruby)
+            },
+        }
+    }
+
+    pub fn clamping_mode(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.clamping_mode {
+            AllowedNumericType::All => ruby.intern("all"),
+            AllowedNumericType::NonNegative => ruby.intern("non_negative"),
+            AllowedNumericType::AtLeastOne => ruby.intern("at_least_one"),
+            AllowedNumericType::ZeroToOne => ruby.intern("zero_to_one"),
+        }
+    }
+
+    pub fn root(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.root.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YCalc {
+    fn mark(&self, marker: &gc::Marker) {
+        self.root.mark(marker);
+    }
+}

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

@@ -0,0 +1,57 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{generics::calc::ModRemOp, specified::calc::CalcNode};
+
+use crate::{cached_value::CachedValue, declarations::calc::YCalc};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc::ModRem", mark)]
+pub struct YModRem {
+    dividend: CachedValue<CalcNode>,
+    divisor: CachedValue<CalcNode>,
+    op: ModRemOp
+}
+
+impl YModRem {
+    pub fn new(dividend: CalcNode, divisor: CalcNode, op: ModRemOp) -> Self {
+        Self {
+            dividend: CachedValue::new(dividend, |calc_node, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            }),
+
+            divisor: CachedValue::new(divisor, |calc_node, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            }),
+
+            op
+        }
+    }
+
+    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.dividend.get(ruby))?;
+        result.push(rb_self.divisor.get(ruby))?;
+        Ok(result)
+    }
+
+    pub fn dividend(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.dividend.get(ruby)
+    }
+
+    pub fn divisor(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.divisor.get(ruby)
+    }
+
+    pub fn op(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.op {
+            ModRemOp::Mod => ruby.intern("mod"),
+            ModRemOp::Rem => ruby.intern("rem"),
+        }
+    }
+}
+
+impl DataTypeFunctions for YModRem {
+    fn mark(&self, marker: &gc::Marker) {
+        self.dividend.mark(marker);
+        self.divisor.mark(marker);
+    }
+}

data/ext/yass/src/declarations/calc/negate.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::Negate", mark)]
+pub struct YNegate {
+    child: CachedValue<CalcNode>
+}
+
+impl YNegate {
+    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 YNegate {
+    fn mark(&self, marker: &gc::Marker) {
+        self.child.mark(marker);
+    }
+}

data/ext/yass/src/declarations/calc/product.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::Product", mark)]
+pub struct YProduct {
+    children: CachedValueList<CalcNode>
+}
+
+impl YProduct {
+    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 YProduct {
+    fn mark(&self, marker: &gc::Marker) {
+        self.children.mark(marker);
+    }
+}

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

@@ -0,0 +1,59 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::{generics::calc::RoundingStrategy, specified::calc::CalcNode};
+
+use crate::{cached_value::CachedValue, declarations::calc::YCalc};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Calc::Round", mark)]
+pub struct YRound {
+    rounding_strategy: RoundingStrategy,
+    value: CachedValue<CalcNode>,
+    step: CachedValue<CalcNode>
+}
+
+impl YRound {
+    pub fn new(rounding_strategy: RoundingStrategy, value: CalcNode, step: CalcNode) -> Self {
+        Self {
+            rounding_strategy,
+
+            value: CachedValue::new(value, |calc_node, ruby| {
+                YCalc::make_node(calc_node, ruby)
+            }),
+
+            step: CachedValue::new(step, |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(2);
+        result.push(rb_self.value.get(ruby))?;
+        result.push(rb_self.step.get(ruby))?;
+        Ok(result)
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+
+    pub fn step(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.step.get(ruby)
+    }
+
+    pub fn rounding_strategy(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.rounding_strategy {
+            RoundingStrategy::Nearest => ruby.intern("nearest"),
+            RoundingStrategy::Up => ruby.intern("up"),
+            RoundingStrategy::Down => ruby.intern("down"),
+            RoundingStrategy::ToZero => ruby.intern("tozero"),
+        }
+    }
+}
+
+impl DataTypeFunctions for YRound {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+        self.step.mark(marker);
+    }
+}

data/ext/yass/src/declarations/calc/sign.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::Sign", mark)]
+pub struct YSign {
+    child: CachedValue<CalcNode>
+}
+
+impl YSign {
+    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 YSign {
+    fn mark(&self, marker: &gc::Marker) {
+        self.child.mark(marker);
+    }
+}

data/ext/yass/src/declarations/calc/sum.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::Sum", mark)]
+pub struct YSum {
+    children: CachedValueList<CalcNode>
+}
+
+impl YSum {
+    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 YSum {
+    fn mark(&self, marker: &gc::Marker) {
+        self.children.mark(marker);
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::specified::table::CaptionSide;
+
+#[magnus::wrap(class = "Yass::Declarations::CaptionSide")]
+pub struct YCaptionSide {
+    caption_side: CaptionSide
+}
+
+impl YCaptionSide {
+    pub fn new(caption_side: CaptionSide) -> Self {
+        Self { caption_side }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.caption_side {
+            CaptionSide::Top => ruby.intern("top"),
+            CaptionSide::Bottom => ruby.intern("bottom"),
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::generics::color::GenericCaretColor;
+use style::values::specified::color::Color;
+
+use crate::declarations::color::color::make_color_or_auto;
+use crate::{cached_value::CachedValue};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::CaretColor", mark)]
+pub struct YCaretColor {
+    color: CachedValue<GenericCaretColor<Color>>,
+}
+
+impl YCaretColor {
+    pub fn new(caret_color: GenericCaretColor<Color>) -> Self {
+        Self {
+            color: CachedValue::new(caret_color, |caret_color, ruby| {
+                make_color_or_auto(&caret_color.0, ruby)
+            }),
+        }
+    }
+
+    pub fn color(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YCaretColor {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+    }
+}

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

@@ -0,0 +1,31 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::color::parsing::ChannelKeyword;
+
+#[magnus::wrap(class = "Yass::Declarations::ChannelKeyword")]
+pub struct YChannelKeyword {
+    channel_keyword: ChannelKeyword
+}
+
+impl YChannelKeyword {
+    pub fn new(channel_keyword: ChannelKeyword) -> Self {
+        Self { channel_keyword }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.channel_keyword {
+            ChannelKeyword::Alpha => ruby.intern("alpha"),
+            ChannelKeyword::A => ruby.intern("a"),
+            ChannelKeyword::B => ruby.intern("b"),
+            ChannelKeyword::C => ruby.intern("c"),
+            ChannelKeyword::G => ruby.intern("g"),
+            ChannelKeyword::H => ruby.intern("h"),
+            ChannelKeyword::L => ruby.intern("l"),
+            ChannelKeyword::R => ruby.intern("r"),
+            ChannelKeyword::S => ruby.intern("s"),
+            ChannelKeyword::W => ruby.intern("w"),
+            ChannelKeyword::X => ruby.intern("x"),
+            ChannelKeyword::Y => ruby.intern("y"),
+            ChannelKeyword::Z => ruby.intern("z"),
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::Clear;
+
+#[magnus::wrap(class = "Yass::Declarations::Clear")]
+pub struct YClear {
+    clear: Clear
+}
+
+impl YClear {
+    pub fn new(clear: Clear) -> Self {
+        Self { clear }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.clear {
+            Clear::None => ruby.intern("none"),
+            Clear::Left => ruby.intern("left"),
+            Clear::Right => ruby.intern("right"),
+            Clear::Both => ruby.intern("both"),
+            Clear::InlineStart => ruby.intern("inline_start"),
+            Clear::InlineEnd => ruby.intern("inline_end"),
+        }
+    }
+}

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

@@ -0,0 +1,135 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::{ClipRect, ClipRectOrAuto, length::LengthPercentageOrAuto}, specified::Length};
+
+use crate::{cached_value::CachedValue, declarations::length::length_to_value};
+
+type ClipSide = LengthPercentageOrAuto<Length>;
+type ClipRectValue = ClipRect<ClipSide>;
+type ClipValue = ClipRectOrAuto<ClipRectValue>;
+
+fn make_clip_value(value: &ClipValue, ruby: &Ruby) -> Value {
+    match value {
+        ClipRectOrAuto::Auto => YClipAuto::new().into_value_with(ruby),
+        ClipRectOrAuto::Rect(rect) => YClipRect::new(rect.clone()).into_value_with(ruby),
+    }
+}
+
+fn make_clip_side(value: &ClipSide, ruby: &Ruby) -> Value {
+    match value {
+        LengthPercentageOrAuto::Auto => YClipLengthAuto::new().into_value_with(ruby),
+        LengthPercentageOrAuto::LengthPercentage(length) => {
+            YClipLength::new(length.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Clip", mark)]
+pub struct YClip {
+    value: CachedValue<ClipValue>,
+}
+
+impl YClip {
+    pub fn new(specified_value: Box<ClipRectOrAuto<ClipRect<LengthPercentageOrAuto<Length>>>>) -> Self {
+        Self {
+            value: CachedValue::new(*specified_value, make_clip_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YClip {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Clip::Auto")]
+pub struct YClipAuto {}
+
+impl YClipAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Clip::Rect", mark)]
+pub struct YClipRect {
+    top: CachedValue<ClipSide>,
+    right: CachedValue<ClipSide>,
+    bottom: CachedValue<ClipSide>,
+    left: CachedValue<ClipSide>,
+}
+
+impl YClipRect {
+    pub fn new(rect: ClipRectValue) -> Self {
+        Self {
+            top: CachedValue::new(rect.top, make_clip_side),
+            right: CachedValue::new(rect.right, make_clip_side),
+            bottom: CachedValue::new(rect.bottom, make_clip_side),
+            left: CachedValue::new(rect.left, make_clip_side),
+        }
+    }
+
+    pub fn top(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.top.get(ruby)
+    }
+
+    pub fn right(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.right.get(ruby)
+    }
+
+    pub fn bottom(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.bottom.get(ruby)
+    }
+
+    pub fn left(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.left.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YClipRect {
+    fn mark(&self, marker: &gc::Marker) {
+        self.top.mark(marker);
+        self.right.mark(marker);
+        self.bottom.mark(marker);
+        self.left.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Clip::Length", mark)]
+pub struct YClipLength {
+    length: CachedValue<Length>,
+}
+
+impl YClipLength {
+    pub fn new(length: Length) -> Self {
+        Self {
+            length: CachedValue::new(length, |length, ruby| length_to_value(length, ruby)),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YClipLength {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Clip::LengthAuto")]
+pub struct YClipLengthAuto {}
+
+impl YClipLengthAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}