yass-css 0.2.0

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

@@ -0,0 +1,98 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data};
+use style::{
+    properties::longhands::text_shadow::{SingleSpecifiedValue, SpecifiedValue},
+    values::{
+        generics::NonNegative,
+        specified::{Color, Length},
+    },
+};
+
+use crate::{
+    cached_value::CachedValue,
+    cached_value_list::CachedValueList,
+    declarations::{color::color::make_color, length::length_to_value},
+};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TextShadow", mark)]
+pub struct YTextShadow {
+    values: CachedValueList<SingleSpecifiedValue>,
+}
+
+impl YTextShadow {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                YTextShadowShadow::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 YTextShadow {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TextShadow::Shadow", mark)]
+pub struct YTextShadowShadow {
+    color: CachedValue<Option<Color>>,
+    horizontal: CachedValue<Length>,
+    vertical: CachedValue<Length>,
+    blur: CachedValue<Option<NonNegative<Length>>>,
+}
+
+impl YTextShadowShadow {
+    pub fn new(value: SingleSpecifiedValue) -> Self {
+        Self {
+            color: CachedValue::new(value.color, |color, ruby| match color {
+                Some(color) => make_color(color, ruby),
+                None => ruby.qnil().into_value_with(ruby),
+            }),
+
+            horizontal: CachedValue::new(value.horizontal, |length, ruby| {
+                length_to_value(length, ruby)
+            }),
+
+            vertical: CachedValue::new(value.vertical, |length, ruby| {
+                length_to_value(length, ruby)
+            }),
+
+            blur: CachedValue::new(value.blur, |blur, ruby| match blur {
+                Some(blur) => length_to_value(&blur.0, 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 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)
+    }
+}
+
+impl DataTypeFunctions for YTextShadowShadow {
+    fn mark(&self, marker: &gc::Marker) {
+        self.color.mark(marker);
+        self.horizontal.mark(marker);
+        self.vertical.mark(marker);
+        self.blur.mark(marker);
+    }
+}

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

@@ -0,0 +1,50 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::values::computed::TextTransform;
+use style::values::specified::text::TextTransformCase;
+
+#[magnus::wrap(class = "Yass::Declarations::TextTransform")]
+pub struct YTextTransform {
+    text_transform: TextTransform
+}
+
+impl YTextTransform {
+    pub fn new(text_transform: TextTransform) -> Self {
+        Self { text_transform }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let text_transform = rb_self.text_transform;
+        let result = ruby.ary_new();
+
+        if text_transform.is_none() {
+            result.push(ruby.intern("none"))?;
+            return Ok(result);
+        }
+
+        match text_transform.case() {
+            TextTransformCase::Uppercase => {
+                result.push(ruby.intern("uppercase"))?;
+            },
+            TextTransformCase::Lowercase => {
+                result.push(ruby.intern("lowercase"))?;
+            },
+            TextTransformCase::Capitalize => {
+                result.push(ruby.intern("capitalize"))?;
+            },
+            TextTransformCase::None => {
+                // No case transform, continue
+            },
+        }
+
+        if text_transform.contains(TextTransform::FULL_WIDTH) {
+            result.push(ruby.intern("full_width"))?;
+        }
+
+        if text_transform.contains(TextTransform::FULL_SIZE_KANA) {
+            result.push(ruby.intern("full_size_kana"))?;
+        }
+
+        Ok(result)
+    }
+}
+

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

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

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

@@ -0,0 +1,21 @@
+use magnus::{Ruby, typed_data};
+use style::values::specified::Time;
+
+#[magnus::wrap(class = "Yass::Declarations::Time")]
+pub struct YTime {
+    time: Time
+}
+
+impl YTime {
+    pub fn new(time: Time) -> Self {
+        Self { time }
+    }
+
+    pub fn seconds(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.time.seconds()
+    }
+
+    pub fn unit(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> &'static str {
+        rb_self.time.unit()
+    }
+}

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

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

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

@@ -0,0 +1,88 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::{LengthPercentage, TrackBreadth};
+
+use crate::{
+    cached_value::CachedValue,
+    declarations::size::length_percentage_to_value,
+};
+
+pub fn make_track_breadth_value(track_breadth: &TrackBreadth, ruby: &Ruby) -> Value {
+    match track_breadth {
+        TrackBreadth::Breadth(length_percentage) => {
+            YTrackBreadthLengthPercentage::new(length_percentage.clone())
+                .into_value_with(ruby)
+        }
+        TrackBreadth::Fr(fr) => YTrackBreadthFr::new(*fr).into_value_with(ruby),
+        TrackBreadth::Auto => YTrackBreadthAuto::new().into_value_with(ruby),
+        TrackBreadth::MinContent => YTrackBreadthMinContent::new().into_value_with(ruby),
+        TrackBreadth::MaxContent => YTrackBreadthMaxContent::new().into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TrackBreadth::LengthPercentage", mark)]
+pub struct YTrackBreadthLengthPercentage {
+    value: CachedValue<LengthPercentage>,
+}
+
+impl YTrackBreadthLengthPercentage {
+    pub fn new(length_percentage: LengthPercentage) -> Self {
+        Self {
+            value: CachedValue::new(length_percentage, |value, ruby| {
+                length_percentage_to_value(value, ruby)
+            }),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YTrackBreadthLengthPercentage {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TrackBreadth::Fr")]
+pub struct YTrackBreadthFr {
+    value: f32,
+}
+
+impl YTrackBreadthFr {
+    pub fn new(value: f32) -> Self {
+        Self { value }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: &Self) -> f32 {
+        rb_self.value
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TrackBreadth::Auto")]
+pub struct YTrackBreadthAuto {}
+
+impl YTrackBreadthAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TrackBreadth::MinContent")]
+pub struct YTrackBreadthMinContent {}
+
+impl YTrackBreadthMinContent {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::TrackBreadth::MaxContent")]
+pub struct YTrackBreadthMaxContent {}
+
+impl YTrackBreadthMaxContent {
+    pub fn new() -> Self {
+        Self {}
+    }
+}

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

@@ -0,0 +1,71 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{specified::TrackSize, specified::TrackBreadth};
+
+use crate::{cached_value::CachedValue, declarations::track_breadth::make_track_breadth_value};
+
+pub fn make_track_size_value(track_size: &TrackSize, ruby: &Ruby) -> Value {
+    match track_size {
+        TrackSize::Breadth(breadth) => make_track_breadth_value(breadth, ruby),
+        TrackSize::Minmax(min, max) => {
+            YTrackSizeMinmax::new(min.clone(), max.clone()).into_value_with(ruby)
+        }
+        TrackSize::FitContent(breadth) => {
+            YTrackSizeFitContent::new(breadth.clone()).into_value_with(ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TrackSize::Minmax", mark)]
+pub struct YTrackSizeMinmax {
+    min: CachedValue<TrackBreadth>,
+    max: CachedValue<TrackBreadth>,
+}
+
+impl YTrackSizeMinmax {
+    pub fn new(min: TrackBreadth, max: TrackBreadth) -> Self {
+        Self {
+            min: CachedValue::new(min, make_track_breadth_value),
+            max: CachedValue::new(max, make_track_breadth_value),
+        }
+    }
+
+    pub fn min(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.min.get(ruby)
+    }
+
+    pub fn max(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.max.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YTrackSizeMinmax {
+    fn mark(&self, marker: &gc::Marker) {
+        self.min.mark(marker);
+        self.max.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::TrackSize::FitContent", mark)]
+pub struct YTrackSizeFitContent {
+    value: CachedValue<TrackBreadth>,
+}
+
+impl YTrackSizeFitContent {
+    pub fn new(track_breadth: TrackBreadth) -> Self {
+        Self {
+            value: CachedValue::new(track_breadth, make_track_breadth_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YTrackSizeFitContent {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}