yass-css 0.2.0

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

@@ -0,0 +1,227 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::{NonNegative, length::Size}, specified::{LengthPercentage, MaxSize}};
+
+use crate::{cached_value::CachedValue, declarations::{calc::YCalc, length::no_calc_length_to_value, percentage::YPercentage, size::{anchor_max_size_function::YAnchorMaxSizeFunction, anchor_size_function::YAnchorSizeFunction}}};
+
+pub mod anchor_size_function;
+pub mod anchor_max_size_function;
+pub mod anchor_size_keyword;
+pub mod init;
+
+pub fn make_size(size: &Size<NonNegative<LengthPercentage>>, ruby: &Ruby) -> Value {
+    match size {
+        Size::LengthPercentage(percentage) => {
+            YLengthPercentage::new(percentage.0.clone()).into_value_with(ruby)
+        },
+
+        Size::Auto => YAuto::new().into_value_with(ruby),
+        Size::MaxContent => YMaxContent::new().into_value_with(ruby),
+        Size::MinContent => YMinContent::new().into_value_with(ruby),
+        Size::FitContent => YFitContent::new().into_value_with(ruby),
+        Size::WebkitFillAvailable => YWebkitFillAvailable::new().into_value_with(ruby),
+        Size::Stretch => YStretch::new().into_value_with(ruby),
+
+        Size::FitContentFunction(fit_content_function) => {
+            YFitContentFunction::new(fit_content_function.clone()).into_value_with(ruby)
+        },
+
+        Size::AnchorSizeFunction(generic_anchor_size_function) => {
+            YAnchorSizeFunction::new((**generic_anchor_size_function).clone()).into_value_with(ruby)
+        },
+
+        Size::AnchorContainingCalcFunction(anchor_with_calc) => {
+            YAnchorContainingCalcFunction::new(anchor_with_calc.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+pub fn make_max_size(max_size: &MaxSize, ruby: &Ruby) -> Value {
+    match max_size {
+        MaxSize::LengthPercentage(length_percentage) => {
+            YLengthPercentage::new(length_percentage.0.clone()).into_value_with(ruby)
+        }
+
+        MaxSize::None => YNone::new().into_value_with(ruby),
+        MaxSize::MaxContent => YMaxContent::new().into_value_with(ruby),
+        MaxSize::MinContent => YMinContent::new().into_value_with(ruby),
+        MaxSize::FitContent => YFitContent::new().into_value_with(ruby),
+        MaxSize::WebkitFillAvailable => YWebkitFillAvailable::new().into_value_with(ruby),
+        MaxSize::Stretch => YStretch::new().into_value_with(ruby),
+
+        MaxSize::FitContentFunction(fit_content_function) => {
+            YFitContentFunction::new(fit_content_function.clone()).into_value_with(ruby)
+        }
+
+        MaxSize::AnchorSizeFunction(anchor_size_function) => {
+            YAnchorMaxSizeFunction::new((**anchor_size_function).clone()).into_value_with(ruby)
+        }
+
+        MaxSize::AnchorContainingCalcFunction(anchor_containing_calc_function) => {
+            YAnchorContainingCalcFunction::new(anchor_containing_calc_function.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+pub fn length_percentage_to_value(length_percentage: &LengthPercentage, ruby: &Ruby) -> Value {
+    match length_percentage {
+        LengthPercentage::Length(no_calc_length) => {
+            no_calc_length_to_value(&no_calc_length, ruby)
+        },
+
+        LengthPercentage::Percentage(percentage) => {
+            YPercentage::new(percentage.0).into_value_with(ruby)
+        },
+
+        LengthPercentage::Calc(calc_length_percentage) => {
+            YCalc::new(calc_length_percentage.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Size::LengthPercentage", mark)]
+pub struct YLengthPercentage {
+    length_percentage: CachedValue<LengthPercentage>
+}
+
+impl YLengthPercentage {
+    pub fn new(length_percentage: LengthPercentage) -> Self {
+        Self {
+            length_percentage: CachedValue::new(length_percentage, |lp, ruby| {
+                length_percentage_to_value(lp, ruby)
+            })
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length_percentage.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YLengthPercentage {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length_percentage.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Size::None")]
+pub struct YNone {
+}
+
+impl YNone {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Size::Auto")]
+pub struct YAuto {
+}
+
+impl YAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Size::MaxContent")]
+pub struct YMaxContent {
+}
+
+impl YMaxContent {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Size::MinContent")]
+pub struct YMinContent {
+}
+
+impl YMinContent {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Size::FitContent")]
+pub struct YFitContent {
+}
+
+impl YFitContent {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Size::WebkitFillAvailable")]
+pub struct YWebkitFillAvailable {
+}
+
+impl YWebkitFillAvailable {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Size::Stretch")]
+pub struct YStretch {
+}
+
+impl YStretch {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Size::FitContentFunction", mark)]
+pub struct YFitContentFunction {
+    fit_content_function: CachedValue<NonNegative<LengthPercentage>>
+}
+
+impl YFitContentFunction {
+    pub fn new(fit_content_function: NonNegative<LengthPercentage>) -> Self {
+        Self {
+            fit_content_function: CachedValue::new(fit_content_function, |fcf, ruby| {
+                length_percentage_to_value(&fcf.0, ruby)
+            })
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.fit_content_function.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFitContentFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.fit_content_function.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Size::AnchorContainingCalcFunction", mark)]
+pub struct YAnchorContainingCalcFunction {
+    anchor_containing_calc_function: CachedValue<NonNegative<LengthPercentage>>
+}
+
+impl YAnchorContainingCalcFunction {
+    pub fn new(anchor_containing_calc_function: NonNegative<LengthPercentage>) -> Self {
+        Self {
+            anchor_containing_calc_function: CachedValue::new(anchor_containing_calc_function, |accf, ruby| {
+                length_percentage_to_value(&accf.0, ruby)
+            })
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.anchor_containing_calc_function.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAnchorContainingCalcFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.anchor_containing_calc_function.mark(marker);
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::table_layout::T;
+
+#[magnus::wrap(class = "Yass::Declarations::TableLayout")]
+pub struct YTableLayout {
+    specified_value: T,
+}
+
+impl YTableLayout {
+    pub fn new(specified_value: T) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.specified_value {
+            T::Auto => ruby.intern("auto"),
+            T::Fixed => ruby.intern("fixed"),
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::specified::{TextAlign, TextAlignKeyword};
+
+#[magnus::wrap(class = "Yass::Declarations::TextAlign")]
+pub struct YTextAlign {
+    text_align: TextAlign
+}
+
+impl YTextAlign {
+    pub fn new(text_align: TextAlign) -> Self {
+        Self { text_align }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.text_align {
+            TextAlign::Keyword(keyword) => match keyword {
+                TextAlignKeyword::Start => ruby.intern("start"),
+                TextAlignKeyword::Left => ruby.intern("left"),
+                TextAlignKeyword::Right => ruby.intern("right"),
+                TextAlignKeyword::Center => ruby.intern("center"),
+                TextAlignKeyword::Justify => ruby.intern("justify"),
+                TextAlignKeyword::End => ruby.intern("end"),
+                TextAlignKeyword::MozCenter => ruby.intern("moz_center"),
+                TextAlignKeyword::MozLeft => ruby.intern("moz_left"),
+                TextAlignKeyword::MozRight => ruby.intern("moz_right"),
+            },
+
+            TextAlign::MozCenterOrInherit => ruby.intern("moz_center_or_inherit"),
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::TextAlignLast;
+
+#[magnus::wrap(class = "Yass::Declarations::TextAlignLast")]
+pub struct YTextAlignLast {
+    text_align_last: TextAlignLast
+}
+
+impl YTextAlignLast {
+    pub fn new(text_align_last: TextAlignLast) -> Self {
+        Self { text_align_last }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.text_align_last {
+            TextAlignLast::Auto => ruby.intern("auto"),
+            TextAlignLast::Start => ruby.intern("start"),
+            TextAlignLast::End => ruby.intern("end"),
+            TextAlignLast::Left => ruby.intern("left"),
+            TextAlignLast::Right => ruby.intern("right"),
+            TextAlignLast::Center => ruby.intern("center"),
+            TextAlignLast::Justify => ruby.intern("justify"),
+        }
+    }
+}

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

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

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

@@ -0,0 +1,77 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::values::computed::TextDecorationLine;
+
+#[magnus::wrap(class = "Yass::Declarations::TextDecorationLine")]
+pub struct YTextDecorationLine {
+    text_decoration_line: TextDecorationLine
+}
+
+impl YTextDecorationLine {
+    pub fn new(text_decoration_line: TextDecorationLine) -> Self {
+        Self { text_decoration_line }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let text_decoration_line = rb_self.text_decoration_line;
+        let result = ruby.ary_new();
+
+        if text_decoration_line.is_empty() {
+            result.push(ruby.intern("none"))?;
+            return Ok(result);
+        }
+
+        if text_decoration_line.contains(TextDecorationLine::UNDERLINE) {
+            result.push(ruby.intern("underline"))?;
+        }
+
+        if text_decoration_line.contains(TextDecorationLine::OVERLINE) {
+            result.push(ruby.intern("overline"))?;
+        }
+
+        if text_decoration_line.contains(TextDecorationLine::LINE_THROUGH) {
+            result.push(ruby.intern("line_through"))?;
+        }
+
+        if text_decoration_line.contains(TextDecorationLine::BLINK) {
+            result.push(ruby.intern("blink"))?;
+        }
+
+        if text_decoration_line.contains(TextDecorationLine::SPELLING_ERROR) {
+            result.push(ruby.intern("spelling_error"))?;
+        }
+
+        if text_decoration_line.contains(TextDecorationLine::GRAMMAR_ERROR) {
+            result.push(ruby.intern("grammar_error"))?;
+        }
+
+        Ok(result)
+    }
+
+    pub fn is_none(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.text_decoration_line.is_empty()
+    }
+
+    pub fn is_underline(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.text_decoration_line.contains(TextDecorationLine::UNDERLINE)
+    }
+
+    pub fn is_overline(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.text_decoration_line.contains(TextDecorationLine::OVERLINE)
+    }
+
+    pub fn is_line_through(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.text_decoration_line.contains(TextDecorationLine::LINE_THROUGH)
+    }
+
+    pub fn is_blink(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.text_decoration_line.contains(TextDecorationLine::BLINK)
+    }
+
+    pub fn is_spelling_error(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.text_decoration_line.contains(TextDecorationLine::SPELLING_ERROR)
+    }
+
+    pub fn is_grammar_error(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.text_decoration_line.contains(TextDecorationLine::GRAMMAR_ERROR)
+    }
+}

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

@@ -0,0 +1,24 @@
+use style::computed_values::text_decoration_style::T;
+use magnus::{Ruby, typed_data, value::Id};
+
+#[magnus::wrap(class = "Yass::Declarations::TextDecorationStyle")]
+pub struct YTextDecorationStyle {
+    specified_value: T
+}
+
+impl YTextDecorationStyle {
+    pub fn new(specified_value: T) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.specified_value {
+            T::Solid => ruby.intern("solid"),
+            T::Double => ruby.intern("double"),
+            T::Dotted => ruby.intern("dotted"),
+            T::Dashed => ruby.intern("dashed"),
+            T::Wavy => ruby.intern("wavy"),
+            T::MozNone => ruby.intern("moz_none"),
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::text::GenericTextIndent, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::size::length_percentage_to_value};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TextIndent", mark)]
+pub struct YTextIndent {
+    length: CachedValue<LengthPercentage>,
+    hanging: bool,
+    each_line: bool,
+}
+
+impl YTextIndent {
+    pub fn new(text_indent: GenericTextIndent<LengthPercentage>) -> Self {
+        Self {
+            length: CachedValue::new(text_indent.length, length_percentage_to_value),
+            hanging: text_indent.hanging,
+            each_line: text_indent.each_line,
+        }
+    }
+
+    pub fn length(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length.get(ruby)
+    }
+
+    pub fn hanging(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.hanging
+    }
+
+    pub fn each_line(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.each_line
+    }
+}
+
+impl DataTypeFunctions for YTextIndent {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length.mark(marker);
+    }
+}

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

@@ -0,0 +1,22 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::TextJustify;
+
+#[magnus::wrap(class = "Yass::Declarations::TextJustify")]
+pub struct YTextJustify {
+    text_justify: TextJustify
+}
+
+impl YTextJustify {
+    pub fn new(text_justify: TextJustify) -> Self {
+        Self { text_justify }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.text_justify {
+            TextJustify::Auto => ruby.intern("auto"),
+            TextJustify::None => ruby.intern("none"),
+            TextJustify::InterWord => ruby.intern("inter_word"),
+            TextJustify::InterCharacter => ruby.intern("inter_character"),
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+use magnus::{DataTypeFunctions, IntoValue, RString, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{computed::TextOverflow, specified::text::TextOverflowSide};
+
+use crate::cached_value::CachedValue;
+
+fn make_text_overflow_side(side: &TextOverflowSide, ruby: &Ruby) -> Value {
+    match side {
+        TextOverflowSide::Clip => YTextOverflowClip::new().into_value_with(ruby),
+        TextOverflowSide::Ellipsis => YTextOverflowEllipsis::new().into_value_with(ruby),
+        TextOverflowSide::String(value) => {
+            YTextOverflowString::new(value.to_string()).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TextOverflow", mark)]
+pub struct YTextOverflow {
+    first: CachedValue<TextOverflowSide>,
+    second: CachedValue<TextOverflowSide>,
+    sides_are_logical: bool,
+}
+
+impl YTextOverflow {
+    pub fn new(specified_value: Box<TextOverflow>) -> Self {
+        let specified_value_unboxed = *specified_value;
+
+        Self {
+            first: CachedValue::new(specified_value_unboxed.first, make_text_overflow_side),
+            second: CachedValue::new(specified_value_unboxed.second, make_text_overflow_side),
+            sides_are_logical: specified_value_unboxed.sides_are_logical,
+        }
+    }
+
+    pub fn first(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.first.get(ruby)
+    }
+
+    pub fn second(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.second.get(ruby)
+    }
+
+    pub fn sides_are_logical(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.sides_are_logical
+    }
+}
+
+impl DataTypeFunctions for YTextOverflow {
+    fn mark(&self, marker: &gc::Marker) {
+        self.first.mark(marker);
+        self.second.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TextOverflow::Clip")]
+pub struct YTextOverflowClip {}
+
+impl YTextOverflowClip {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TextOverflow::Ellipsis")]
+pub struct YTextOverflowEllipsis {}
+
+impl YTextOverflowEllipsis {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TextOverflow::String")]
+pub struct YTextOverflowString {
+    value: String,
+}
+
+impl YTextOverflowString {
+    pub fn new(value: String) -> Self {
+        Self { value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: &Self) -> RString {
+        ruby.str_new(&rb_self.value)
+    }
+}

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

@@ -0,0 +1,22 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::text_rendering::T;
+
+#[magnus::wrap(class = "Yass::Declarations::TextRendering")]
+pub struct YTextRendering {
+    specified_value: T
+}
+
+impl YTextRendering {
+    pub fn new(specified_value: T) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.specified_value {
+            T::Auto => ruby.intern("auto"),
+            T::Optimizespeed => ruby.intern("optimize_speed"),
+            T::Optimizelegibility => ruby.intern("optimize_legibility"),
+            T::Geometricprecision => ruby.intern("geometric_precision"),
+        }
+    }
+}