yass-css 0.2.0

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::NonNegativeNumber;
+
+use crate::{cached_value::CachedValue, declarations::number::YNumber};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FlexGrow", mark)]
+pub struct YFlexGrow {
+    non_negative_number: CachedValue<NonNegativeNumber>
+}
+
+impl YFlexGrow {
+    pub fn new(non_negative_number: NonNegativeNumber) -> Self {
+        Self {
+            non_negative_number: CachedValue::new(non_negative_number, |num, ruby| {
+                YNumber::new(num.get()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.non_negative_number.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFlexGrow {
+    fn mark(&self, marker: &gc::Marker) {
+        self.non_negative_number.mark(marker);
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::NonNegativeNumber;
+
+use crate::{cached_value::CachedValue, declarations::number::YNumber};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FlexShrink", mark)]
+pub struct YFlexShrink {
+    non_negative_number: CachedValue<NonNegativeNumber>
+}
+
+impl YFlexShrink {
+    pub fn new(non_negative_number: NonNegativeNumber) -> Self {
+        Self {
+            non_negative_number: CachedValue::new(non_negative_number, |num, ruby| {
+                YNumber::new(num.get()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.non_negative_number.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFlexShrink {
+    fn mark(&self, marker: &gc::Marker) {
+        self.non_negative_number.mark(marker);
+    }
+}

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

@@ -0,0 +1,21 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::flex_wrap::T;
+
+#[magnus::wrap(class = "Yass::Declarations::FlexWrap")]
+pub struct YFlexWrap {
+    specified_value: T
+}
+
+impl YFlexWrap {
+    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::Nowrap => ruby.intern("nowrap"),
+            T::Wrap => ruby.intern("wrap"),
+            T::WrapReverse => ruby.intern("wrap_reverse"),
+        }
+    }
+}

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

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

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

@@ -0,0 +1,28 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::FontFamily;
+
+use crate::{cached_value::CachedValue, rules::fonts::family::make_font_family};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FontFamily", mark)]
+pub struct YFontFamily {
+    font_family: CachedValue<FontFamily>
+}
+
+impl YFontFamily {
+    pub fn new(font_family: FontFamily) -> Self {
+        Self {
+            font_family: CachedValue::new(font_family, make_font_family),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.font_family.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontFamily {
+    fn mark(&self, marker: &gc::Marker) {
+        self.font_family.mark(marker);
+    }
+}

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

@@ -0,0 +1,30 @@
+use magnus::{IntoValue, Ruby, Value, typed_data};
+use style::values::computed::FontLanguageOverride;
+
+#[magnus::wrap(class = "Yass::Declarations::FontLanguageOverride")]
+pub struct YFontLanguageOverride {
+    font_language_override: FontLanguageOverride
+}
+
+impl YFontLanguageOverride {
+    pub fn new(font_language_override: FontLanguageOverride) -> Self {
+        Self { font_language_override }
+    }
+
+    pub fn is_normal(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.font_language_override.0 == 0
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        if rb_self.font_language_override.0 == 0 {
+            return ruby.intern("normal").into_value_with(ruby);
+        }
+
+        let bytes = rb_self.font_language_override.0.to_be_bytes();
+        let value = std::str::from_utf8(&bytes)
+            .unwrap_or_default()
+            .trim_end();
+
+        ruby.str_new(value).into_value_with(ruby)
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::font_optical_sizing::T;
+
+#[magnus::wrap(class = "Yass::Declarations::FontOpticalSizing")]
+pub struct YFontOpticalSizing {
+    specified_value: T
+}
+
+impl YFontOpticalSizing {
+    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::None => ruby.intern("none"),
+        }
+    }
+}

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

@@ -0,0 +1,126 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::specified::{FontSize, LengthPercentage, font::{FontSizeKeyword, KeywordInfo}};
+
+use crate::{cached_value::CachedValue, declarations::size::YLengthPercentage};
+
+fn make_font_size(font_size: &FontSize, ruby: &Ruby) -> Value {
+    match font_size {
+        FontSize::Length(length_percentage) => {
+            YFontSizeLength::new(length_percentage.clone()).into_value_with(ruby)
+        },
+        FontSize::Keyword(keyword_info) => YFontSizeKeyword::new(*keyword_info).into_value_with(ruby),
+        FontSize::Smaller => YFontSizeSmaller::new().into_value_with(ruby),
+        FontSize::Larger => YFontSizeLarger::new().into_value_with(ruby),
+        FontSize::System(_) => YFontSizeSystem::new().into_value_with(ruby),
+    }
+}
+
+fn font_size_keyword_to_id(keyword: FontSizeKeyword, ruby: &Ruby) -> Id {
+    match keyword {
+        FontSizeKeyword::XXSmall => ruby.intern("xx_small"),
+        FontSizeKeyword::XSmall => ruby.intern("x_small"),
+        FontSizeKeyword::Small => ruby.intern("small"),
+        FontSizeKeyword::Medium => ruby.intern("medium"),
+        FontSizeKeyword::Large => ruby.intern("large"),
+        FontSizeKeyword::XLarge => ruby.intern("x_large"),
+        FontSizeKeyword::XXLarge => ruby.intern("xx_large"),
+        FontSizeKeyword::XXXLarge => ruby.intern("xxx_large"),
+        FontSizeKeyword::None => ruby.intern("none"),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FontSize", mark)]
+pub struct YFontSize {
+    font_size: CachedValue<FontSize>
+}
+
+impl YFontSize {
+    pub fn new(font_size: FontSize) -> Self {
+        Self {
+            font_size: CachedValue::new(font_size, make_font_size),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.font_size.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontSize {
+    fn mark(&self, marker: &gc::Marker) {
+        self.font_size.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FontSize::Length", mark)]
+pub struct YFontSizeLength {
+    length_percentage: CachedValue<LengthPercentage>,
+}
+
+impl YFontSizeLength {
+    pub fn new(length_percentage: LengthPercentage) -> Self {
+        Self {
+            length_percentage: CachedValue::new(length_percentage, |value, ruby| {
+                YLengthPercentage::new(value.clone()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.length_percentage.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontSizeLength {
+    fn mark(&self, marker: &gc::Marker) {
+        self.length_percentage.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontSize::Keyword")]
+pub struct YFontSizeKeyword {
+    keyword_info: KeywordInfo
+}
+
+impl YFontSizeKeyword {
+    pub fn new(keyword_info: KeywordInfo) -> Self {
+        Self { keyword_info }
+    }
+
+    pub fn keyword(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        font_size_keyword_to_id(rb_self.keyword_info.kw, ruby)
+    }
+
+    pub fn factor(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.keyword_info.factor
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontSize::Smaller")]
+pub struct YFontSizeSmaller {}
+
+impl YFontSizeSmaller {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontSize::Larger")]
+pub struct YFontSizeLarger {}
+
+impl YFontSizeLarger {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontSize::System")]
+pub struct YFontSizeSystem {}
+
+impl YFontSizeSystem {
+    pub fn new() -> Self {
+        Self {}
+    }
+}

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

@@ -0,0 +1,102 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::specified::{FontStretch, NonNegativePercentage, font::FontStretchKeyword};
+
+use crate::{cached_value::CachedValue, declarations::percentage::YPercentage};
+
+fn font_stretch_keyword_to_id(keyword: FontStretchKeyword, ruby: &Ruby) -> Id {
+    match keyword {
+        FontStretchKeyword::Normal => ruby.intern("normal"),
+        FontStretchKeyword::Condensed => ruby.intern("condensed"),
+        FontStretchKeyword::UltraCondensed => ruby.intern("ultra_condensed"),
+        FontStretchKeyword::ExtraCondensed => ruby.intern("extra_condensed"),
+        FontStretchKeyword::SemiCondensed => ruby.intern("semi_condensed"),
+        FontStretchKeyword::SemiExpanded => ruby.intern("semi_expanded"),
+        FontStretchKeyword::Expanded => ruby.intern("expanded"),
+        FontStretchKeyword::ExtraExpanded => ruby.intern("extra_expanded"),
+        FontStretchKeyword::UltraExpanded => ruby.intern("ultra_expanded"),
+    }
+}
+
+fn make_font_stretch(font_stretch: &FontStretch, ruby: &Ruby) -> Value {
+    match font_stretch {
+        FontStretch::Stretch(percentage) => {
+            YFontStretchValue::new(*percentage).into_value_with(ruby)
+        },
+        FontStretch::Keyword(keyword) => YFontStretchKeyword::new(*keyword).into_value_with(ruby),
+        FontStretch::System(_) => YFontStretchSystem::new().into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FontStretch", mark)]
+pub struct YFontStretch {
+    font_stretch: CachedValue<FontStretch>
+}
+
+impl YFontStretch {
+    pub fn new(font_stretch: FontStretch) -> Self {
+        Self {
+            font_stretch: CachedValue::new(font_stretch, make_font_stretch),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.font_stretch.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontStretch {
+    fn mark(&self, marker: &gc::Marker) {
+        self.font_stretch.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FontStretch::Stretch", mark)]
+pub struct YFontStretchValue {
+    percentage: CachedValue<NonNegativePercentage>,
+}
+
+impl YFontStretchValue {
+    pub fn new(percentage: NonNegativePercentage) -> Self {
+        Self {
+            percentage: CachedValue::new(percentage, |value, ruby| {
+                YPercentage::new(value.0.get()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.percentage.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontStretchValue {
+    fn mark(&self, marker: &gc::Marker) {
+        self.percentage.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontStretch::Keyword")]
+pub struct YFontStretchKeyword {
+    keyword: FontStretchKeyword,
+}
+
+impl YFontStretchKeyword {
+    pub fn new(keyword: FontStretchKeyword) -> Self {
+        Self { keyword }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        font_stretch_keyword_to_id(rb_self.keyword, ruby)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontStretch::System")]
+pub struct YFontStretchSystem {}
+
+impl YFontStretchSystem {
+    pub fn new() -> Self {
+        Self {}
+    }
+}

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

@@ -0,0 +1,101 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::font::FontStyle as GenericFontStyle, specified::{Angle, FontStyle, font::SpecifiedFontStyle}};
+
+use crate::{cached_value::CachedValue, declarations::angle::YAngle};
+
+fn make_font_style(font_style: &FontStyle, ruby: &Ruby) -> Value {
+    match font_style {
+        FontStyle::Specified(specified) => make_specified_font_style(specified, ruby),
+        FontStyle::System(_) => YFontStyleSystem::new().into_value_with(ruby),
+    }
+}
+
+fn make_specified_font_style(font_style: &SpecifiedFontStyle, ruby: &Ruby) -> Value {
+    match font_style {
+        GenericFontStyle::Italic => YFontStyleItalic::new().into_value_with(ruby),
+        GenericFontStyle::Oblique(angle) => {
+            if angle.degrees() == 0.0 && !angle.was_calc() {
+                YFontStyleNormal::new().into_value_with(ruby)
+            } else {
+                YFontStyleOblique::new(*angle).into_value_with(ruby)
+            }
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FontStyle", mark)]
+pub struct YFontStyle {
+    font_style: CachedValue<FontStyle>
+}
+
+impl YFontStyle {
+    pub fn new(font_style: FontStyle) -> Self {
+        Self {
+            font_style: CachedValue::new(font_style, make_font_style),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.font_style.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontStyle {
+    fn mark(&self, marker: &gc::Marker) {
+        self.font_style.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontStyle::Normal")]
+pub struct YFontStyleNormal {}
+
+impl YFontStyleNormal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontStyle::Italic")]
+pub struct YFontStyleItalic {}
+
+impl YFontStyleItalic {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FontStyle::Oblique", mark)]
+pub struct YFontStyleOblique {
+    angle: CachedValue<Angle>,
+}
+
+impl YFontStyleOblique {
+    pub fn new(angle: Angle) -> Self {
+        Self {
+            angle: CachedValue::new(angle, |value, ruby| {
+                YAngle::new(*value).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn angle(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.angle.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YFontStyleOblique {
+    fn mark(&self, marker: &gc::Marker) {
+        self.angle.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontStyle::System")]
+pub struct YFontStyleSystem {}
+
+impl YFontStyleSystem {
+    pub fn new() -> Self {
+        Self {}
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::FontSynthesis;
+
+#[magnus::wrap(class = "Yass::Declarations::FontSynthesisWeight")]
+pub struct YFontSynthesisWeight {
+    font_synthesis: FontSynthesis
+}
+
+impl YFontSynthesisWeight {
+    pub fn new(font_synthesis: FontSynthesis) -> Self {
+        Self { font_synthesis }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.font_synthesis {
+            FontSynthesis::Auto => ruby.intern("auto"),
+            FontSynthesis::None => ruby.intern("none"),
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::font_variant_caps::T;
+
+#[magnus::wrap(class = "Yass::Declarations::FontVariantCaps")]
+pub struct YFontVariantCaps {
+    specified_value: T
+}
+
+impl YFontVariantCaps {
+    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::Normal => ruby.intern("normal"),
+            T::SmallCaps => ruby.intern("small_caps"),
+        }
+    }
+}

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

@@ -0,0 +1,54 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::font::VariationValue, specified::{FontVariationSettings, Number}};
+
+use crate::{cached_value_list::CachedValueList, declarations::number::YNumber};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::FontVariationSettings", mark)]
+pub struct YFontVariationSettings {
+    font_variation_settings: CachedValueList<VariationValue<Number>>,
+}
+
+impl YFontVariationSettings {
+    pub fn new(font_variation_settings: FontVariationSettings) -> Self {
+        Self {
+            font_variation_settings: CachedValueList::new(font_variation_settings.0.into_vec(), |setting, _ctx, ruby| {
+                YFontVariationSetting::new(setting.clone()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.font_variation_settings.to_a(ruby)
+    }
+
+    pub fn is_normal(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.font_variation_settings.is_empty()
+    }
+}
+
+impl DataTypeFunctions for YFontVariationSettings {
+    fn mark(&self, marker: &gc::Marker) {
+        self.font_variation_settings.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::FontVariationSettings::Setting")]
+pub struct YFontVariationSetting {
+    variation_value: VariationValue<Number>,
+}
+
+impl YFontVariationSetting {
+    pub fn new(variation_value: VariationValue<Number>) -> Self {
+        Self { variation_value }
+    }
+
+    pub fn tag(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> String {
+        let bytes = rb_self.variation_value.tag.0.to_be_bytes();
+        String::from_utf8_lossy(&bytes).to_string()
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        YNumber::new(rb_self.variation_value.value.get()).into_value_with(ruby)
+    }
+}