yass-css 0.2.0

data/ext/yass/src/selectors/negation.rs

@@ -0,0 +1,27 @@
+use magnus::{DataTypeFunctions, Error, RArray, Ruby, TypedData, gc};
+use selectors::SelectorList;
+use style::selector_parser::SelectorImpl;
+
+use crate::selectors::YSelectorList;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Selector::Negation", mark)]
+pub struct YNegation {
+    selectors: YSelectorList
+}
+
+impl DataTypeFunctions for YNegation {
+    fn mark(&self, marker: &gc::Marker) {
+        self.selectors.mark(marker);
+    }
+}
+
+impl YNegation {
+    pub fn new(selector_list: SelectorList<SelectorImpl>) -> Self {
+        Self { selectors: YSelectorList::new(selector_list.slice()) }
+    }
+
+    pub fn selectors(&self, ruby: &Ruby) -> Result<RArray, Error> {
+        self.selectors.to_a(ruby)
+    }
+}

data/ext/yass/src/selectors/non_ts_pseudo_class.rs

@@ -0,0 +1,63 @@
+use magnus::{Ruby, Value, value::{Id, ReprValue}};
+use style::selector_parser::NonTSPseudoClass;
+
+#[magnus::wrap(class = "Yass::Selector::NonTsPseudoClass")]
+pub struct YNonTSPseudoClass {
+    non_ts_pseudo_class: NonTSPseudoClass
+}
+
+impl YNonTSPseudoClass {
+    pub fn new(non_ts_pseudo_class: NonTSPseudoClass) -> Self {
+        Self { non_ts_pseudo_class }
+    }
+
+    pub fn ty(&self, ruby: &Ruby) -> Id {
+        match self.non_ts_pseudo_class {
+            NonTSPseudoClass::Active => ruby.intern("active"),
+            NonTSPseudoClass::AnyLink => ruby.intern("any_link"),
+            NonTSPseudoClass::Autofill => ruby.intern("autofill"),
+            NonTSPseudoClass::Checked => ruby.intern("checked"),
+            NonTSPseudoClass::CustomState(_) => ruby.intern("custom_state"),
+            NonTSPseudoClass::Default => ruby.intern("default"),
+            NonTSPseudoClass::Defined => ruby.intern("defined"),
+            NonTSPseudoClass::Disabled => ruby.intern("disabled"),
+            NonTSPseudoClass::Enabled => ruby.intern("enabled"),
+            NonTSPseudoClass::Focus => ruby.intern("focus"),
+            NonTSPseudoClass::FocusWithin => ruby.intern("focus_within"),
+            NonTSPseudoClass::FocusVisible => ruby.intern("focus_visible"),
+            NonTSPseudoClass::Fullscreen => ruby.intern("fullscreen"),
+            NonTSPseudoClass::Hover => ruby.intern("hover"),
+            NonTSPseudoClass::InRange => ruby.intern("in_range"),
+            NonTSPseudoClass::Indeterminate => ruby.intern("indeterminate"),
+            NonTSPseudoClass::Invalid => ruby.intern("invalid"),
+            NonTSPseudoClass::Lang(_) => ruby.intern("lang"),
+            NonTSPseudoClass::Link => ruby.intern("link"),
+            NonTSPseudoClass::Modal => ruby.intern("modal"),
+            NonTSPseudoClass::MozMeterOptimum => ruby.intern("moz_meter_optimum"),
+            NonTSPseudoClass::MozMeterSubOptimum => ruby.intern("moz_meter_sub_optimum"),
+            NonTSPseudoClass::MozMeterSubSubOptimum => ruby.intern("moz_meter_sub_sub_optimum"),
+            NonTSPseudoClass::Open => ruby.intern("open"),
+            NonTSPseudoClass::Optional => ruby.intern("optional"),
+            NonTSPseudoClass::OutOfRange => ruby.intern("out_of_range"),
+            NonTSPseudoClass::PlaceholderShown => ruby.intern("placeholder_shown"),
+            NonTSPseudoClass::PopoverOpen => ruby.intern("popover_open"),
+            NonTSPseudoClass::ReadOnly => ruby.intern("read_only"),
+            NonTSPseudoClass::ReadWrite => ruby.intern("read_write"),
+            NonTSPseudoClass::Required => ruby.intern("required"),
+            NonTSPseudoClass::ServoNonZeroBorder => ruby.intern("servo_non_zero_border"),
+            NonTSPseudoClass::Target => ruby.intern("target"),
+            NonTSPseudoClass::UserInvalid => ruby.intern("user_invalid"),
+            NonTSPseudoClass::UserValid => ruby.intern("user_valid"),
+            NonTSPseudoClass::Valid => ruby.intern("valid"),
+            NonTSPseudoClass::Visited => ruby.intern("visited"),
+        }
+    }
+
+    pub fn value(&self, ruby: &Ruby) -> Value {
+        match &self.non_ts_pseudo_class {
+            NonTSPseudoClass::CustomState(state) => ruby.str_new(&state.0.to_string()).as_value(),
+            NonTSPseudoClass::Lang(lang) => ruby.str_new(&lang.to_string()).as_value(),
+            _ => ruby.qnil().as_value()
+        }
+    }
+}

data/ext/yass/src/selectors/nth.rs

@@ -0,0 +1,51 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, value::{Id, ReprValue}};
+use selectors::parser::{NthSelectorData, NthType};
+
+use crate::{cached_value::CachedValue, selectors::YAnPlusB};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Selector::Nth", mark)]
+pub struct YNth {
+    nth_selector_data: NthSelectorData,
+    an_plus_b: CachedValue<(i32, i32)>
+}
+
+impl YNth {
+    pub fn new(nth_selector_data: NthSelectorData) -> Self {
+        Self {
+            nth_selector_data,
+            an_plus_b: CachedValue::new((nth_selector_data.an_plus_b.0, nth_selector_data.an_plus_b.1), |values, ruby| {
+                YAnPlusB::new(values.0, values.1).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn ty(&self, ruby: &Ruby) -> Id {
+        match self.nth_selector_data.ty {
+            NthType::Child => ruby.intern("child"),
+            NthType::LastChild => ruby.intern("last_child"),
+            NthType::OnlyChild => ruby.intern("only_child"),
+            NthType::OfType => ruby.intern("of_type"),
+            NthType::LastOfType => ruby.intern("last_of_type"),
+            NthType::OnlyOfType => ruby.intern("only_of_type"),
+        }
+    }
+
+    pub fn is_function(&self, ruby: &Ruby) -> Value {
+        if self.nth_selector_data.is_function {
+            ruby.qtrue().as_value()
+        } else {
+            ruby.qfalse().as_value()
+        }
+    }
+
+    pub fn an_plus_b(&self, ruby: &Ruby) -> Value {
+        self.an_plus_b.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YNth {
+    fn mark(&self, marker: &gc::Marker) {
+        self.an_plus_b.mark(marker);
+    }
+}

data/ext/yass/src/selectors/nth_of.rs

@@ -0,0 +1,43 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc};
+use selectors::parser::{NthOfSelectorData, NthSelectorData, Selector};
+use style::selector_parser::SelectorImpl;
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList, selectors::{YNth, YSelector}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Selector::NthOf", mark)]
+pub struct YNthOf {
+    // nth_of_selector_data: NthOfSelectorData<SelectorImpl>,
+    nth: CachedValue<NthSelectorData>,
+    selectors: CachedValueList<Selector<SelectorImpl>>
+}
+
+impl YNthOf {
+    pub fn new(nth_of_selector_data: NthOfSelectorData<SelectorImpl>) -> Self {
+        YNthOf {
+            // nth_of_selector_data,
+            nth: CachedValue::new(nth_of_selector_data.nth_data().clone(), |nth_data, ruby| {
+                YNth::new(*nth_data).into_value_with(ruby)
+            }),
+
+            selectors: CachedValueList::new(nth_of_selector_data.selectors().to_vec(), |selector, _ctx, ruby| {
+                YSelector::new(selector.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn nth(&self, ruby: &Ruby) -> Value {
+        self.nth.get(ruby)
+    }
+
+    pub fn selectors(&self, ruby: &Ruby) -> Result<RArray, Error> {
+        self.selectors.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YNthOf {
+    fn mark(&self, marker: &gc::Marker) {
+        self.nth.mark(marker);
+        self.selectors.mark(marker);
+    }
+}

data/ext/yass/src/selectors/part.rs

@@ -0,0 +1,22 @@
+use magnus::{Error, RArray, Ruby};
+
+#[magnus::wrap(class = "Yass::Selector::Part")]
+pub struct YPart {
+    items: Vec<String>
+}
+
+impl YPart {
+    pub fn new(items: Vec<String>) -> Self {
+        Self { items }
+    }
+
+    pub fn items(&self, ruby: &Ruby) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(self.items.len());
+
+        for item in &self.items {
+            result.push(ruby.str_new(item))?;
+        }
+
+        Ok(result)
+    }
+}

data/ext/yass/src/selectors/relative_selector.rs

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data, value::{Id, Opaque, ReprValue}};
+use selectors::parser::{RelativeSelector, RelativeSelectorMatchHint};
+use style::selector_parser::SelectorImpl;
+
+use crate::selectors::YSelector;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::RelativeSelector", mark)]
+pub struct YRelativeSelector {
+    selector: Opaque<typed_data::Obj<YSelector>>,
+    match_hint: RelativeSelectorMatchHint
+}
+
+impl YRelativeSelector {
+    pub fn new(relative_selector: RelativeSelector<SelectorImpl>, ruby: &Ruby) -> Self {
+        let selector = Opaque::from(ruby.obj_wrap(YSelector::new(relative_selector.selector)));
+        Self { selector, match_hint: relative_selector.match_hint }
+    }
+
+    pub fn selector(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        ruby.get_inner(rb_self.selector).as_value()
+    }
+
+    pub fn match_hint(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.match_hint {
+            RelativeSelectorMatchHint::InSubtree => ruby.intern("in_subtree"),
+            RelativeSelectorMatchHint::InChild => ruby.intern("in_child"),
+            RelativeSelectorMatchHint::InNextSibling => ruby.intern("in_next_sibling"),
+            RelativeSelectorMatchHint::InNextSiblingSubtree => ruby.intern("in_next_sibling_subtree"),
+            RelativeSelectorMatchHint::InSibling => ruby.intern("in_sibling"),
+            RelativeSelectorMatchHint::InSiblingSubtree => ruby.intern("in_sibling_subtree")
+        }
+    }
+}
+
+impl DataTypeFunctions for YRelativeSelector {
+    fn mark(&self, marker: &gc::Marker) {
+        marker.mark(self.selector);
+    }
+}

data/ext/yass/src/selectors/selector.rs

@@ -0,0 +1,230 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data, value::Id};
+use selectors::{attr::{AttrSelectorOperator, ParsedCaseSensitivity}, parser::{Component, Selector}};
+use style::selector_parser::SelectorImpl;
+
+use crate::{selectors::{
+    YAttributeInNoNamespace,
+    YAttributeInNoNamespaceExists,
+    YAttributeOther,
+    YClass,
+    YCombinator,
+    YDefaultNamespace,
+    YEmpty,
+    YExplicitAnyNamespace,
+    YExplicitNoNamespace,
+    YExplicitUniversalType,
+    YHas,
+    YHost,
+    YID,
+    YImplicitScope,
+    YInvalid,
+    YIs,
+    YLocalName,
+    YNamespace,
+    YNegation,
+    YNonTSPseudoClass,
+    YNth,
+    YNthOf,
+    YParentSelector,
+    YPart,
+    YPseudoElement,
+    YRelativeSelectorAnchor,
+    YRoot,
+    YScope,
+    YSelectorChild,
+    YSlotted,
+    YWhere
+}, cached_value_list::CachedValueList};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Selector", mark)]
+pub struct YSelector {
+    selector: Selector<SelectorImpl>,
+    children: CachedValueList<Component<SelectorImpl>>
+}
+
+impl DataTypeFunctions for YSelector {
+    fn mark(&self, marker: &gc::Marker) {
+        self.children.mark(marker);
+    }
+}
+
+impl YSelector {
+    pub fn new(selector: Selector<SelectorImpl>) -> Self {
+        Self {
+            selector,
+            children: CachedValueList::new(vec![], |component, _ctx, ruby| {
+                YSelector::wrap_child(component, ruby).into_value_with(ruby)
+            })
+        }
+    }
+
+    fn wrap_child(component: &Component<SelectorImpl>, ruby: &Ruby) -> YSelectorChild {
+        match component {
+            Component::LocalName(local_name) => {
+                YSelectorChild::LocalName(YLocalName::new(local_name.clone()))
+            },
+            Component::ID(id) => {
+                YSelectorChild::ID(YID::new(id.to_string()))
+            },
+            Component::Class(class) => {
+                YSelectorChild::Class(YClass::new(class.to_string()))
+            },
+
+            Component::AttributeInNoNamespaceExists { local_name, local_name_lower: _ } => {
+                YSelectorChild::AttributeInNoNamespaceExists(YAttributeInNoNamespaceExists::new(local_name.to_string()))
+            },
+
+            Component::AttributeInNoNamespace { local_name, operator, value, case_sensitivity } => {
+                YSelectorChild::AttributeInNoNamespace(
+                    YAttributeInNoNamespace::new(
+                        local_name.to_string(),
+                        *operator,
+                        value.to_string(),
+                        *case_sensitivity
+                    )
+                )
+            },
+
+            Component::AttributeOther(attr_selector_with_optional_namespace) => {
+                YSelectorChild::AttributeOther(
+                    YAttributeOther::new(attr_selector_with_optional_namespace.clone())
+                )
+            },
+
+            Component::ExplicitUniversalType => {
+                YSelectorChild::ExplicitUniversalType(YExplicitUniversalType::new())
+            },
+
+            Component::ExplicitAnyNamespace => {
+                YSelectorChild::ExplicitAnyNamespace(YExplicitAnyNamespace::new())
+            },
+
+            Component::ExplicitNoNamespace => {
+                YSelectorChild::ExplicitNoNamespace(YExplicitNoNamespace::new())
+            },
+
+            Component::DefaultNamespace(ns) => {
+                YSelectorChild::DefaultNamespace(YDefaultNamespace::new(ns.to_string()))
+            },
+
+            Component::Namespace(prefix, url) => {
+                YSelectorChild::Namespace(YNamespace::new(prefix.to_string(), url.to_string()))
+            },
+
+            Component::Negation(selector_list) => {
+                YSelectorChild::Negation(YNegation::new(selector_list.clone()))
+            },
+
+            Component::Root => YSelectorChild::Root(YRoot::new()),
+            Component::Empty => YSelectorChild::Empty(YEmpty::new()),
+            Component::Scope => YSelectorChild::Scope(YScope::new()),
+            Component::ImplicitScope => YSelectorChild::ImplicitScope(YImplicitScope::new()),
+            Component::ParentSelector => YSelectorChild::ParentSelector(YParentSelector::new()),
+
+            Component::Nth(nth_selector_data) => {
+                YSelectorChild::Nth(YNth::new(nth_selector_data.clone()))
+            },
+
+            Component::NthOf(nth_of_selector_data) => {
+                YSelectorChild::NthOf(YNthOf::new(nth_of_selector_data.clone()))
+            },
+
+            Component::NonTSPseudoClass(non_ts_pseudo_class) => {
+                YSelectorChild::NonTSPseudoClass(YNonTSPseudoClass::new(non_ts_pseudo_class.clone()))
+            },
+
+            Component::Slotted(selector) => {
+                YSelectorChild::Slotted(YSlotted::new(selector.clone(), ruby))
+            },
+
+            Component::Part(items) => {
+                let mut item_strings: Vec<String> = Vec::with_capacity(items.len());
+
+                for item in items {
+                    item_strings.push(item.to_string());
+                }
+
+                YSelectorChild::Part(YPart::new(item_strings))
+            },
+
+            Component::Host(selector) => {
+                YSelectorChild::Host(YHost::new(selector.clone(), ruby))
+            },
+
+            Component::Where(selector_list) => {
+                YSelectorChild::Where(YWhere::new(selector_list.clone()))
+            },
+
+            Component::Is(selector_list) => {
+                YSelectorChild::Is(YIs::new(selector_list.clone()))
+            },
+
+            Component::Has(relative_selectors) => {
+                YSelectorChild::Has(YHas::new(relative_selectors.clone()))
+            },
+
+            Component::Invalid(_) => {
+                YSelectorChild::Invalid(YInvalid::new())
+            },
+
+            Component::PseudoElement(_) => {
+                YSelectorChild::PseudoElement(YPseudoElement::new())
+            },
+
+            Component::Combinator(combinator) => {
+                YSelectorChild::Combinator(YCombinator::new(combinator.clone()))
+            },
+
+            Component::RelativeSelectorAnchor => {
+                YSelectorChild::RelativeSelectorAnchor(YRelativeSelectorAnchor::new())
+            }
+        }
+    }
+
+    pub fn children(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        if rb_self.children.is_empty() {
+            let mut iter = rb_self.selector.iter();
+
+            loop {
+                for raw_component in iter.by_ref() {
+                    rb_self.children.add(raw_component.clone(), ruby)?;
+                }
+
+                if let Some(combinator) = iter.next_sequence() {
+                    rb_self.children.add(Component::Combinator(combinator), ruby)?;
+                } else {
+                    break;
+                }
+            }
+        }
+
+        rb_self.children.to_a(ruby)
+    }
+
+    pub fn intern_operator(operator: &AttrSelectorOperator, ruby: &Ruby) -> Id {
+        match operator {
+            AttrSelectorOperator::Equal => ruby.intern("equal"),
+            AttrSelectorOperator::Includes => ruby.intern("includes"),
+            AttrSelectorOperator::DashMatch => ruby.intern("dash_match"),
+            AttrSelectorOperator::Prefix => ruby.intern("prefix"),
+            AttrSelectorOperator::Substring => ruby.intern("substring"),
+            AttrSelectorOperator::Suffix => ruby.intern("suffix")
+        }
+    }
+
+    pub fn intern_case_sensitivity(cs: &ParsedCaseSensitivity, ruby: &Ruby) -> Id {
+        match cs {
+            // 's' was specified.
+            ParsedCaseSensitivity::ExplicitCaseSensitive => ruby.intern("explicit_case_sensitive"),
+            // 'i' was specified.
+            ParsedCaseSensitivity::AsciiCaseInsensitive => ruby.intern("ascii_case_insensitive"),
+            // No flags were specified and HTML says this is a case-sensitive attribute.
+            ParsedCaseSensitivity::CaseSensitive => ruby.intern("case_sensitive"),
+            // No flags were specified and HTML says this is a case-insensitive attribute.
+            ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {
+                ruby.intern("ascii_case_insensitive_if_in_html_element_in_html_document")
+            }
+        }
+    }
+}