yass-css 0.2.0

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

@@ -0,0 +1,22 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::computed_values::white_space_collapse::T;
+
+#[magnus::wrap(class = "Yass::Declarations::WhiteSpaceCollapse")]
+pub struct YWhiteSpaceCollapse {
+    specified_value: T
+}
+
+impl YWhiteSpaceCollapse {
+    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::Collapse => ruby.intern("collapse"),
+            T::Preserve => ruby.intern("preserve"),
+            T::PreserveBreaks => ruby.intern("preserve_breaks"),
+            T::BreakSpaces => ruby.intern("break_spaces"),
+        }
+    }
+}

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

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

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

@@ -0,0 +1,83 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::values::computed::WillChange;
+use style::values::specified::WillChangeBits;
+use style_traits::ToCss;
+
+#[magnus::wrap(class = "Yass::Declarations::WillChange")]
+pub struct YWillChange {
+    will_change: WillChange,
+}
+
+impl YWillChange {
+    pub fn new(will_change: WillChange) -> Self {
+        Self { will_change }
+    }
+
+    pub fn is_auto(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.to_css_string() == "auto"
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        if Self::is_auto(ruby, rb_self) {
+            return Ok(ruby.ary_new());
+        }
+
+        let css = rb_self.will_change.to_css_string();
+        let values = css
+            .split(',')
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .collect::<Vec<_>>();
+        let result = ruby.ary_new_capa(values.len());
+
+        for value in values {
+            result.push(ruby.str_new(value))?;
+        }
+
+        Ok(result)
+    }
+
+    pub fn is_stacking_context_unconditional(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::STACKING_CONTEXT_UNCONDITIONAL)
+    }
+
+    pub fn is_transform(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::TRANSFORM)
+    }
+
+    pub fn is_scroll(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::SCROLL)
+    }
+
+    pub fn is_contain(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::CONTAIN)
+    }
+
+    pub fn is_opacity(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::OPACITY)
+    }
+
+    pub fn is_perspective(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::PERSPECTIVE)
+    }
+
+    pub fn is_z_index(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::Z_INDEX)
+    }
+
+    pub fn is_fixpos_cb_non_svg(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::FIXPOS_CB_NON_SVG)
+    }
+
+    pub fn is_position(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::POSITION)
+    }
+
+    pub fn is_view_transition_name(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::VIEW_TRANSITION_NAME)
+    }
+
+    pub fn is_backdrop_root(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.will_change.bits.contains(WillChangeBits::BACKDROP_ROOT)
+    }
+}

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

@@ -0,0 +1,35 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::properties::VariableDeclaration;
+use style_traits::ToCss;
+
+use crate::cached_value::CachedValue;
+
+fn variable_declaration_to_value(variable_declaration: &VariableDeclaration, ruby: &Ruby) -> Value {
+    ruby
+        .str_new(&variable_declaration.to_css_string())
+        .into_value_with(ruby)
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::WithVariables", mark)]
+pub struct YWithVariables {
+    value: CachedValue<VariableDeclaration>,
+}
+
+impl YWithVariables {
+    pub fn new(variable_declaration: VariableDeclaration) -> Self {
+        Self {
+            value: CachedValue::new(variable_declaration, variable_declaration_to_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YWithVariables {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}

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

@@ -0,0 +1,21 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::WordBreak;
+
+#[magnus::wrap(class = "Yass::Declarations::WordBreak")]
+pub struct YWordBreak {
+    word_break: WordBreak
+}
+
+impl YWordBreak {
+    pub fn new(word_break: WordBreak) -> Self {
+        Self { word_break }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.word_break {
+            WordBreak::Normal => ruby.intern("normal"),
+            WordBreak::BreakAll => ruby.intern("break_all"),
+            WordBreak::KeepAll => ruby.intern("keep_all"),
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc::Marker, typed_data};
+use style::values::specified::WordSpacing;
+use style::values::specified::text::Spacing;
+
+use crate::{cached_value::CachedValue, declarations::size::length_percentage_to_value};
+
+fn word_spacing_to_value(word_spacing: &WordSpacing, ruby: &Ruby) -> Value {
+    match &word_spacing.0 {
+        Spacing::Normal => YWordSpacingNormal::new().into_value_with(ruby),
+        Spacing::Value(length_percentage) => {
+            length_percentage_to_value(length_percentage, ruby)
+        }
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::WordSpacing", mark)]
+pub struct YWordSpacing {
+    value: CachedValue<WordSpacing>,
+}
+
+impl YWordSpacing {
+    pub fn new(word_spacing: WordSpacing) -> Self {
+        Self {
+            value: CachedValue::new(word_spacing, word_spacing_to_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YWordSpacing {
+    fn mark(&self, marker: &Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::WordSpacing::Normal")]
+pub struct YWordSpacingNormal {}
+
+impl YWordSpacingNormal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}

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

@@ -0,0 +1,21 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::computed::WritingModeProperty;
+
+#[magnus::wrap(class = "Yass::Declarations::WritingMode")]
+pub struct YWritingMode {
+    writing_mode_property: WritingModeProperty
+}
+
+impl YWritingMode {
+    pub fn new(writing_mode_property: WritingModeProperty) -> Self {
+        Self { writing_mode_property }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.writing_mode_property {
+            WritingModeProperty::HorizontalTb => ruby.intern("horizontal_tb"),
+            WritingModeProperty::VerticalRl => ruby.intern("vertical_rl"),
+            WritingModeProperty::VerticalLr => ruby.intern("vertical_lr"),
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+use magnus::{IntoValue, Ruby, Value, typed_data};
+use style::values::computed::XLang;
+
+#[magnus::wrap(class = "Yass::Declarations::XLang")]
+pub struct YXLang {
+    xlang: XLang
+}
+
+impl YXLang {
+    pub fn new(xlang: XLang) -> Self {
+        Self { xlang }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        ruby.str_from_slice(rb_self.xlang.0.as_bytes()).into_value_with(ruby)
+    }
+
+    pub fn is_empty(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> bool {
+        rb_self.xlang.0.as_bytes().is_empty()
+    }
+}

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

@@ -0,0 +1,61 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::{Integer, ZIndex};
+
+use crate::cached_value::CachedValue;
+
+fn make_zindex_value(zindex: &ZIndex, ruby: &Ruby) -> Value {
+    match zindex {
+        ZIndex::Integer(integer) => YZIndexInteger::new(integer.clone()).into_value_with(ruby),
+        ZIndex::Auto => YZIndexAuto::new().into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::ZIndex", mark)]
+pub struct YZIndex {
+    value: CachedValue<ZIndex>,
+}
+
+impl YZIndex {
+    pub fn new(zindex: ZIndex) -> Self {
+        Self {
+            value: CachedValue::new(zindex, make_zindex_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YZIndex {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ZIndex::Auto")]
+pub struct YZIndexAuto {}
+
+impl YZIndexAuto {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::ZIndex::Integer")]
+pub struct YZIndexInteger {
+    value: i32,
+}
+
+impl YZIndexInteger {
+    pub fn new(integer: Integer) -> Self {
+        Self {
+            value: integer.value(),
+        }
+    }
+
+    pub fn value(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> i32 {
+        rb_self.value
+    }
+}

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

@@ -0,0 +1,87 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{generics::NonNegative, specified::{NumberOrPercentage, Zoom}};
+
+use crate::{cached_value::CachedValue, declarations::{number::YNumber, percentage::YPercentage}};
+
+fn make_zoom_value(value: &NonNegative<NumberOrPercentage>, ruby: &Ruby) -> Value {
+    match value.0 {
+        NumberOrPercentage::Number(number) => YNumber::new(number.get()).into_value_with(ruby),
+        NumberOrPercentage::Percentage(percentage) => {
+            YPercentage::new(percentage.get()).into_value_with(ruby)
+        }
+    }
+}
+
+fn make_zoom(zoom: &Zoom, ruby: &Ruby) -> Value {
+    match zoom {
+        Zoom::Normal => YZoomNormal::new().into_value_with(ruby),
+        Zoom::Document => YZoomDocument::new().into_value_with(ruby),
+        Zoom::Value(value) => YZoomValue::new(*value).into_value_with(ruby),
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Zoom", mark)]
+pub struct YZoom {
+    zoom: CachedValue<Zoom>,
+}
+
+impl YZoom {
+    pub fn new(zoom: Zoom) -> Self {
+        Self {
+            zoom: CachedValue::new(zoom, make_zoom),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.zoom.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YZoom {
+    fn mark(&self, marker: &gc::Marker) {
+        self.zoom.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Zoom::Normal")]
+pub struct YZoomNormal {}
+
+impl YZoomNormal {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Zoom::Document")]
+pub struct YZoomDocument {}
+
+impl YZoomDocument {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Zoom::Value", mark)]
+pub struct YZoomValue {
+    value: CachedValue<NonNegative<NumberOrPercentage>>,
+}
+
+impl YZoomValue {
+    pub fn new(value: NonNegative<NumberOrPercentage>) -> Self {
+        Self {
+            value: CachedValue::new(value, make_zoom_value),
+        }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.value.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YZoomValue {
+    fn mark(&self, marker: &gc::Marker) {
+        self.value.mark(marker);
+    }
+}

data/ext/yass/src/general/init.rs

@@ -0,0 +1,15 @@
+use magnus::{Error, Module, RModule, Ruby, method};
+
+use crate::general::{YSourceLocation, YUnicodeRange};
+
+pub fn init(ruby: &Ruby, yass_module: &RModule) -> Result<(), Error> {
+    let unicode_range_class = yass_module.define_class("UnicodeRange", ruby.class_object())?;
+    unicode_range_class.define_method("start", method!(YUnicodeRange::start, 0))?;
+    unicode_range_class.define_method("end", method!(YUnicodeRange::end, 0))?;
+
+    let source_location_class = yass_module.define_class("SourceLocation", ruby.class_object())?;
+    source_location_class.define_method("line", method!(YSourceLocation::line, 0))?;
+    source_location_class.define_method("column", method!(YSourceLocation::column, 0))?;
+
+    Ok(())
+}

data/ext/yass/src/general/mod.rs

@@ -0,0 +1,43 @@
+use magnus::{Ruby, typed_data};
+
+pub mod init;
+
+#[magnus::wrap(class = "Yass::UnicodeRange")]
+pub struct YUnicodeRange {
+    start: u32,
+    end: u32,
+}
+
+impl YUnicodeRange {
+    pub fn new(start: u32, end: u32) -> Self {
+        Self { start, end }
+    }
+
+    pub fn start(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> u32 {
+        rb_self.start
+    }
+
+    pub fn end(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> u32 {
+        rb_self.end
+    }
+}
+
+#[magnus::wrap(class = "Yass::SourceLocation")]
+pub struct YSourceLocation {
+    line: u32,
+    column: u32,
+}
+
+impl YSourceLocation {
+    pub fn new(line: u32, column: u32) -> Self {
+        Self { line, column }
+    }
+
+    pub fn line(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> u32 {
+        rb_self.line
+    }
+
+    pub fn column(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> u32 {
+        rb_self.column
+    }
+}

data/ext/yass/src/lib.rs

@@ -0,0 +1,72 @@
+mod cached_value;
+mod declarations;
+mod general;
+mod rules;
+mod selectors;
+mod sheet;
+mod utils;
+mod cached_value_list;
+mod optional_cached_value;
+
+use magnus::{Error, Ruby, function, method, prelude::*};
+use style::context::QuirksMode;
+use style::media_queries::MediaList;
+use style::shared_lock::SharedRwLock;
+use style::servo_arc::Arc;
+use style::stylesheets::{AllowImportRules, Origin, Stylesheet, UrlExtraData};
+use url::Url;
+
+use crate::sheet::YSheet;
+
+fn parse(css: String) -> YSheet {
+    let lock = SharedRwLock::new();
+    let base_url = Url::parse("https://example.com/style.css").expect("invalid URL");
+    let url_data = UrlExtraData::from(base_url);
+
+    // `MediaList::empty()` means "applies to all media".
+    let media = Arc::new(lock.wrap(MediaList::empty()));
+
+    let stylesheet = Stylesheet::from_str(
+        &css,
+        url_data,
+        Origin::Author,             // stylesheet origin: Author / User / UserAgent
+        media,
+        lock.clone(),
+        None,     // no external @import loader
+        None,        // no error reporter
+        QuirksMode::NoQuirks,
+        AllowImportRules::Yes,
+    );
+
+    YSheet::new(stylesheet)
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    <bool as stylo_static_prefs::Preference>::set("layout.unimplemented", true);
+    <bool as stylo_static_prefs::Preference>::set(
+        "layout.css.backdrop-filter.enabled",
+        true,
+    );
+    <bool as stylo_static_prefs::Preference>::set("layout.variable_fonts.enabled", true);
+    <bool as stylo_static_prefs::Preference>::set("layout.css.font-variations.enabled", true);
+    <bool as stylo_static_prefs::Preference>::set("layout.container-queries.enabled", true);
+    <bool as stylo_static_prefs::Preference>::set("layout.columns.enabled", true);
+    <bool as stylo_static_prefs::Preference>::set("layout.grid.enabled", true);
+    <bool as stylo_static_prefs::Preference>::set("layout.writing-mode.enabled", true);
+
+    let yass_module = ruby.define_module("Yass")?;
+
+    let parser_module = yass_module.define_module("Parser")?;
+    parser_module.define_singleton_method("parse", function!(parse, 1))?;
+
+    let stylesheet_class = yass_module.define_class("Stylesheet", ruby.class_object())?;
+    stylesheet_class.define_method("rules", method!(YSheet::rules, 0))?;
+
+    general::init::init(ruby, &yass_module)?;
+    declarations::init::init(ruby, &yass_module)?;
+    rules::init::init(ruby, &yass_module)?;
+    selectors::init::init(ruby, &yass_module)?;
+
+    Ok(())
+}

data/ext/yass/src/optional_cached_value.rs

@@ -0,0 +1,33 @@
+use magnus::{IntoValue, Ruby, Value, gc};
+
+use crate::cached_value::CachedValue;
+
+type OptionalTransform<T> = fn(&(Option<T>, fn(&T, &Ruby) -> Value), &Ruby) -> Value;
+
+pub struct OptionalCachedValue<T> {
+    cached_value: CachedValue<(Option<T>, fn(&T, &Ruby) -> Value), OptionalTransform<T>>
+}
+
+impl<T> OptionalCachedValue<T> {
+    pub fn new(value: Option<T>, cb: fn(&T, &Ruby) -> Value) -> Self {
+        let transform: OptionalTransform<T> = |(value, cb), ruby| {
+            if let Some(v) = value {
+                cb(v, ruby)
+            } else {
+                ruby.qnil().into_value_with(ruby)
+            }
+        };
+
+        Self {
+            cached_value: CachedValue::new((value, cb), transform)
+        }
+    }
+
+    pub fn get(&self, ruby: &Ruby) -> Value {
+        self.cached_value.get(ruby)
+    }
+
+    pub fn mark(&self, marker: &gc::Marker) {
+        self.cached_value.mark(marker);
+    }
+}