yass-css 0.2.0

data/ext/yass/src/declarations/images/line_direction.rs

@@ -0,0 +1,100 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data, value::Id};
+use style::values::specified::{Angle, image::LineDirection, position::{HorizontalPositionKeyword, VerticalPositionKeyword}};
+
+use crate::{cached_value::CachedValue, declarations::{angle::YAngle, images::{horizontal_keyword_to_id, vertical_keyword_to_id}}};
+
+pub fn make_line_direction(direction: &LineDirection, ruby: &Ruby) -> Value {
+    match direction {
+        LineDirection::Angle(angle) => {
+            YAngleLineDirection::new(angle.clone()).into_value_with(ruby)
+        },
+
+        LineDirection::Horizontal(keyword) => {
+            YHorizontalLineDirection::new(keyword.clone()).into_value_with(ruby)
+        },
+
+        LineDirection::Vertical(keyword) => {
+            YVerticalLineDirection::new(keyword.clone()).into_value_with(ruby)
+        },
+
+        LineDirection::Corner(h_keyword, v_keyword) => {
+            YCornerLineDirection::new(h_keyword.clone(), v_keyword.clone()).into_value_with(ruby)
+        },
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Image::AngleLineDirection", mark)]
+pub struct YAngleLineDirection {
+    angle: CachedValue<Angle>,
+}
+
+impl YAngleLineDirection {
+    pub fn new(angle: Angle) -> Self {
+        Self {
+            angle: CachedValue::new(angle, |angle, ruby| {
+                YAngle::new(angle.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn angle(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.angle.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAngleLineDirection {
+    fn mark(&self, marker: &gc::Marker) {
+        self.angle.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Image::HorizontalLineDirection")]
+pub struct YHorizontalLineDirection {
+    keyword: HorizontalPositionKeyword,
+}
+
+impl YHorizontalLineDirection {
+    pub fn new(keyword: HorizontalPositionKeyword) -> Self {
+        Self { keyword }
+    }
+
+    pub fn direction(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        horizontal_keyword_to_id(rb_self.keyword, ruby)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Image::VerticalLineDirection")]
+pub struct YVerticalLineDirection {
+    keyword: VerticalPositionKeyword,
+}
+
+impl YVerticalLineDirection {
+    pub fn new(keyword: VerticalPositionKeyword) -> Self {
+        Self { keyword }
+    }
+
+    pub fn direction(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        vertical_keyword_to_id(rb_self.keyword, ruby)
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Image::CornerLineDirection")]
+pub struct YCornerLineDirection {
+    horizontal: HorizontalPositionKeyword,
+    vertical: VerticalPositionKeyword,
+}
+
+impl YCornerLineDirection {
+    pub fn new(horizontal: HorizontalPositionKeyword, vertical: VerticalPositionKeyword) -> Self {
+        Self { horizontal, vertical }
+    }
+
+    pub fn horizontal_direction(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        horizontal_keyword_to_id(rb_self.horizontal, ruby)
+    }
+
+    pub fn vertical_direction(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        vertical_keyword_to_id(rb_self.vertical, ruby)
+    }
+}

data/ext/yass/src/declarations/images/linear_gradient.rs

@@ -0,0 +1,75 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, Value, gc::Marker, typed_data, value::Id};
+use style::{color::mix::ColorInterpolationMethod, values::{generics::image::{GradientCompatMode, GradientFlags, GradientItem}, specified::{Color, LengthPercentage, image::{Gradient, LineDirection}}}};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList, declarations::{color::color_interpolation_method::YColorInterpolationMethod, images::{compat_mode_to_id, gradient_length_percentage_item::make_gradient_length_percentage_item, line_direction::make_line_direction}}};
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::LinearGradient", mark)]
+pub struct YLinearGradient {
+    direction: CachedValue<LineDirection>,
+    color_interpolation_method: CachedValue<ColorInterpolationMethod>,
+    items: CachedValueList<GradientItem<Color, LengthPercentage>>,
+    repeating: bool,
+    compat_mode: GradientCompatMode,
+}
+
+impl YLinearGradient {
+    pub fn new(gradient: Gradient) -> Self {
+        match gradient {
+            Gradient::Linear {
+                direction,
+                color_interpolation_method,
+                items,
+                flags,
+                compat_mode,
+            } => Self {
+                direction: CachedValue::new(direction, |direction, ruby| {
+                    make_line_direction(direction, ruby)
+                }),
+
+                color_interpolation_method: CachedValue::new(
+                    color_interpolation_method,
+                    |method, ruby| {
+                        YColorInterpolationMethod::new(*method).into_value_with(ruby)
+                    },
+                ),
+
+                items: CachedValueList::new(items.to_vec(), |item, _ctx, ruby| {
+                    make_gradient_length_percentage_item(item, ruby)
+                }),
+
+                repeating: flags.contains(GradientFlags::REPEATING),
+                compat_mode,
+            },
+            _ => unreachable!("expected linear gradient"),
+        }
+    }
+
+    pub fn repeating(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.repeating
+    }
+
+    pub fn compat_mode(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        compat_mode_to_id(rb_self.compat_mode, ruby)
+    }
+
+    pub fn direction(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.direction.get(ruby)
+    }
+
+    pub fn color_interpolation_method(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color_interpolation_method.get(ruby)
+    }
+
+    pub fn items(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.items.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YLinearGradient {
+    fn mark(&self, marker: &Marker) {
+        self.direction.mark(marker);
+        self.color_interpolation_method.mark(marker);
+        self.items.mark(marker);
+    }
+}

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

@@ -0,0 +1,93 @@
+use magnus::{IntoValue, Ruby, Value, value::Id};
+use style::{
+    values::{
+        generics::image::{GradientCompatMode, ShapeExtent},
+        specified::{
+            image::{Gradient, Image as SpecifiedImage},
+            position::{HorizontalPositionKeyword, VerticalPositionKeyword},
+        },
+    },
+};
+use style_traits::ToCss;
+
+use crate::declarations::{images::{conic_gradient::YConicGradient, cross_fade::YCrossFade, image_set::YImageSet, light_dark::YImageLightDark, linear_gradient::YLinearGradient, none::YImageNone, radial_gradient::YImageRadialGradient, url::YImageUrl}};
+
+pub mod angle_or_percentage;
+pub mod circle;
+pub mod conic_gradient;
+pub mod cross_fade;
+pub mod cross_fade_element;
+pub mod cross_fade_image;
+pub mod ellipse;
+pub mod ending_shape;
+pub mod gradient_angle_or_percentage_item;
+pub mod gradient_length_percentage_item;
+pub mod init;
+pub mod image_set;
+pub mod image_set_item;
+pub mod light_dark;
+pub mod line_direction;
+pub mod linear_gradient;
+pub mod none;
+pub mod position;
+pub mod radial_gradient;
+pub mod url;
+
+pub fn image_to_value(image: &SpecifiedImage, ruby: &Ruby) -> Value {
+    match image {
+        SpecifiedImage::None => YImageNone::new().into_value_with(ruby),
+        SpecifiedImage::Url(url) => YImageUrl::new(url.clone()).into_value_with(ruby),
+        SpecifiedImage::Gradient(gradient) => gradient_to_value(gradient, ruby),
+        SpecifiedImage::CrossFade(cross_fade) => {
+            YCrossFade::new((**cross_fade).clone()).into_value_with(ruby)
+        },
+        SpecifiedImage::ImageSet(image_set) => {
+            YImageSet::new((**image_set).clone()).into_value_with(ruby)
+        },
+        SpecifiedImage::LightDark(light_dark) => {
+            YImageLightDark::new((**light_dark).clone()).into_value_with(ruby)
+        },
+        _ => ruby.str_new(&image.to_css_string()).into_value_with(ruby),
+    }
+}
+
+fn gradient_to_value(gradient: &Gradient, ruby: &Ruby) -> Value {
+    match gradient {
+        Gradient::Linear { .. } => YLinearGradient::new(gradient.clone()).into_value_with(ruby),
+        Gradient::Radial { .. } => YImageRadialGradient::new(gradient.clone()).into_value_with(ruby),
+        Gradient::Conic { .. } => YConicGradient::new(gradient.clone()).into_value_with(ruby),
+    }
+}
+
+pub fn horizontal_keyword_to_id(keyword: HorizontalPositionKeyword, ruby: &Ruby) -> Id {
+    match keyword {
+        HorizontalPositionKeyword::Left => ruby.intern("left"),
+        HorizontalPositionKeyword::Right => ruby.intern("right"),
+    }
+}
+
+pub fn vertical_keyword_to_id(keyword: VerticalPositionKeyword, ruby: &Ruby) -> Id {
+    match keyword {
+        VerticalPositionKeyword::Top => ruby.intern("top"),
+        VerticalPositionKeyword::Bottom => ruby.intern("bottom"),
+    }
+}
+
+pub fn shape_extent_to_id(extent: ShapeExtent, ruby: &Ruby) -> Id {
+    match extent {
+        ShapeExtent::ClosestSide => ruby.intern("closest_side"),
+        ShapeExtent::FarthestSide => ruby.intern("farthest_side"),
+        ShapeExtent::ClosestCorner => ruby.intern("closest_corner"),
+        ShapeExtent::FarthestCorner => ruby.intern("farthest_corner"),
+        ShapeExtent::Contain => ruby.intern("contain"),
+        ShapeExtent::Cover => ruby.intern("cover"),
+    }
+}
+
+pub fn compat_mode_to_id(mode: GradientCompatMode, ruby: &Ruby) -> Id {
+    match mode {
+        GradientCompatMode::Modern => ruby.intern("modern"),
+        GradientCompatMode::WebKit => ruby.intern("webkit"),
+        GradientCompatMode::Moz => ruby.intern("moz"),
+    }
+}

data/ext/yass/src/declarations/images/none.rs

@@ -0,0 +1,8 @@
+#[magnus::wrap(class = "Yass::Declarations::Image::None")]
+pub struct YImageNone {}
+
+impl YImageNone {
+    pub fn new() -> Self {
+        Self { }
+    }
+}

data/ext/yass/src/declarations/images/position.rs

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, Ruby, Value, gc::Marker, typed_data};
+use style::values::specified::position::{HorizontalPositionKeyword, Position, PositionComponent, VerticalPositionKeyword};
+
+use crate::{cached_value::CachedValue, declarations::{horizontal_position_component::make_horizontal_position_component, vertical_position_component::make_vertical_position_component}};
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::Position", mark)]
+pub struct YImagePosition {
+    horizontal: CachedValue<PositionComponent<HorizontalPositionKeyword>>,
+    vertical: CachedValue<PositionComponent<VerticalPositionKeyword>>,
+}
+
+impl YImagePosition {
+    pub fn new(position: Position) -> Self {
+        Self {
+            horizontal: CachedValue::new(position.horizontal, |component, ruby| {
+                make_horizontal_position_component(component, ruby)
+            }),
+
+            vertical: CachedValue::new(position.vertical, |component, ruby| {
+                make_vertical_position_component(component, ruby)
+            }),
+        }
+    }
+
+    pub fn horizontal_position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.horizontal.get(ruby)
+    }
+
+    pub fn vertical_position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.vertical.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YImagePosition {
+    fn mark(&self, marker: &Marker) {
+        self.horizontal.mark(marker);
+        self.vertical.mark(marker);
+    }
+}

data/ext/yass/src/declarations/images/radial_gradient.rs

@@ -0,0 +1,86 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, Value, gc::Marker, typed_data, value::Id};
+use style::{color::mix::ColorInterpolationMethod, values::{generics::image::{GradientCompatMode, GradientFlags, GradientItem}, specified::{Color, LengthPercentage, image::{EndingShape, Gradient}, position::Position}}};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList, declarations::{color::color_interpolation_method::YColorInterpolationMethod, images::{compat_mode_to_id, ending_shape::YEndingShape, gradient_length_percentage_item::make_gradient_length_percentage_item, position::YImagePosition}}};
+
+#[derive(magnus::TypedData)]
+#[magnus(class = "Yass::Declarations::Image::RadialGradient", mark)]
+pub struct YImageRadialGradient {
+    shape: CachedValue<EndingShape>,
+    position: CachedValue<Position>,
+    color_interpolation_method: CachedValue<ColorInterpolationMethod>,
+    items: CachedValueList<GradientItem<Color, LengthPercentage>>,
+    repeating: bool,
+    compat_mode: GradientCompatMode,
+}
+
+impl YImageRadialGradient {
+    pub fn new(gradient: Gradient) -> Self {
+        match gradient {
+            Gradient::Radial {
+                shape,
+                position,
+                color_interpolation_method,
+                items,
+                flags,
+                compat_mode,
+            } => Self {
+                shape: CachedValue::new(shape, |shape, ruby| {
+                    YEndingShape::new(shape.clone()).into_value_with(ruby)
+                }),
+
+                position: CachedValue::new(position, |position, ruby| {
+                    YImagePosition::new(position.clone()).into_value_with(ruby)
+                }),
+
+                color_interpolation_method: CachedValue::new(
+                    color_interpolation_method,
+                    |method, ruby| {
+                        YColorInterpolationMethod::new(*method).into_value_with(ruby)
+                    },
+                ),
+
+                items: CachedValueList::new(items.to_vec(), |item, _ctx, ruby| {
+                    make_gradient_length_percentage_item(item, ruby)
+                }),
+
+                repeating: flags.contains(GradientFlags::REPEATING),
+                compat_mode,
+            },
+            _ => unreachable!("expected radial gradient"),
+        }
+    }
+
+    pub fn repeating(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.repeating
+    }
+
+    pub fn compat_mode(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        compat_mode_to_id(rb_self.compat_mode, ruby)
+    }
+
+    pub fn shape(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.shape.get(ruby)
+    }
+
+    pub fn position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.position.get(ruby)
+    }
+
+    pub fn color_interpolation_method(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.color_interpolation_method.get(ruby)
+    }
+
+    pub fn items(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.items.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YImageRadialGradient {
+    fn mark(&self, marker: &Marker) {
+        self.shape.mark(marker);
+        self.position.mark(marker);
+        self.color_interpolation_method.mark(marker);
+        self.items.mark(marker);
+    }
+}

data/ext/yass/src/declarations/images/url.rs

@@ -0,0 +1,28 @@
+use magnus::{IntoValue, Ruby, Value, typed_data};
+use style::values::specified::url::SpecifiedUrl;
+
+#[magnus::wrap(class = "Yass::Declarations::Image::Url")]
+pub struct YImageUrl {
+    url: SpecifiedUrl,
+}
+
+impl YImageUrl {
+    pub fn new(url: SpecifiedUrl) -> Self {
+        Self { url }
+    }
+
+    pub fn resolved(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        match rb_self.url.url() {
+            Some(url) => ruby.str_new(url.as_str()).into_value_with(ruby),
+            None => ruby.qnil().into_value_with(ruby),
+        }
+    }
+
+    pub fn original(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        ruby.str_new(rb_self.url.as_str()).into_value_with(ruby)
+    }
+
+    pub fn invalid(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.url.is_invalid()
+    }
+}