yass-css 0.2.0

data/ext/yass/src/rules/rule.rs

@@ -0,0 +1,33 @@
+use magnus::{IntoValue, Ruby, Value};
+use style::{shared_lock::SharedRwLock, stylesheets::CssRule};
+
+use crate::rules::{font_face_rule::YFontFaceRule, media_rule::YMediaRule, style_rule::YStyleRule};
+
+pub fn make_rule(rule: &CssRule, lock: &SharedRwLock, ruby: &Ruby) -> Value {
+    match rule {
+        CssRule::Style(locked_rule) => {
+            YStyleRule::new(locked_rule.clone(), lock.clone()).into_value_with(ruby)
+        }
+
+        CssRule::Media(media_rule) => {
+            YMediaRule::new(media_rule.clone(), lock.clone()).into_value_with(ruby)
+        }
+
+        CssRule::FontFace(font_face_rule) => {
+            YFontFaceRule::new(font_face_rule.clone(), lock.clone()).into_value_with(ruby)
+        }
+
+        _ => {
+            YUnimplementedRule::new().into_value_with(ruby)
+        }
+    }
+}
+
+#[magnus::wrap(class = "Yass::UnimplementedRule")]
+pub struct YUnimplementedRule { }
+
+impl YUnimplementedRule {
+    pub fn new() -> Self {
+        Self {}
+    }
+}

data/ext/yass/src/rules/style_rule.rs

@@ -0,0 +1,82 @@
+use cssparser::SourceLocation;
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data};
+use selectors::parser::Selector;
+use style::{properties::PropertyDeclaration, selector_parser::SelectorImpl, servo_arc::Arc, shared_lock::{Locked, SharedRwLock}, stylesheets::StyleRule};
+
+use crate::{cached_value::CachedValue, cached_value_list::CachedValueList, declarations::declaration::YDeclaration, general::YSourceLocation, selectors::YSelector};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::StyleRule", mark)]
+pub struct YStyleRule {
+    rule: Arc<Locked<StyleRule>>,
+    lock: SharedRwLock,
+    selectors: CachedValueList<Selector<SelectorImpl>>,
+    declarations: CachedValueList<PropertyDeclaration>,
+    source_location: CachedValue<SourceLocation>
+}
+
+impl YStyleRule {
+    pub fn new(rule: Arc<Locked<StyleRule>>, lock: SharedRwLock) -> Self {
+        YStyleRule {
+            rule,
+            lock,
+
+            selectors: CachedValueList::empty(None, |selector, _ctx, ruby| {
+                YSelector::new(selector.clone()).into_value_with(ruby)
+            }),
+
+            declarations: CachedValueList::empty(None, |declaration, _ctx, ruby| {
+                YDeclaration::from(declaration, ruby).unwrap().into_value_with(ruby)
+            }),
+
+            source_location: CachedValue::empty(|source_location, ruby| {
+                YSourceLocation::new(source_location.line, source_location.column).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn selectors(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        if rb_self.selectors.is_empty() {
+            let guard = rb_self.lock.read();
+            let style_rule = rb_self.rule.read_with(&guard);
+
+            for selector in style_rule.selectors.slice() {
+                rb_self.selectors.add(selector.clone(), ruby)?;
+            }
+        }
+
+        rb_self.selectors.to_a(ruby)
+    }
+
+    pub fn declarations(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        if rb_self.declarations.is_empty() {
+            let guard = rb_self.lock.read();
+            let style_rule = rb_self.rule.read_with(&guard);
+            let block = style_rule.block.read_with(&guard);
+
+            for declaration in block.declarations() {
+                rb_self.declarations.add(declaration.clone(), ruby)?;
+            }
+        }
+
+        rb_self.declarations.to_a(ruby)
+    }
+
+    pub fn source_location(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        if rb_self.source_location.is_empty() {
+            let guard = rb_self.lock.read();
+            let style_rule = rb_self.rule.read_with(&guard);
+            rb_self.source_location.set(style_rule.source_location, ruby);
+        }
+
+        rb_self.source_location.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YStyleRule {
+    fn mark(&self, marker: &gc::Marker) {
+        self.selectors.mark(marker);
+        self.declarations.mark(marker);
+        self.source_location.mark(marker);
+    }
+}

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

@@ -0,0 +1,21 @@
+use magnus::{Integer, Ruby, typed_data};
+
+#[magnus::wrap(class = "Yass::Selector::AnPlusB")]
+pub struct YAnPlusB {
+    a: i32,
+    b: i32
+}
+
+impl YAnPlusB {
+    pub fn new(a: i32, b: i32) -> Self {
+        Self { a, b }
+    }
+
+    pub fn a(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Integer {
+        ruby.integer_from_i128(rb_self.a as i128)
+    }
+
+    pub fn b(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Integer {
+        ruby.integer_from_i128(rb_self.b as i128)
+    }
+}

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

@@ -0,0 +1,34 @@
+use magnus::{RString, Ruby, value::Id};
+use selectors::attr::{AttrSelectorOperator, ParsedCaseSensitivity};
+
+use crate::selectors::YSelector;
+
+#[magnus::wrap(class = "Yass::Selector::AttributeInNoNamespace")]
+pub struct YAttributeInNoNamespace {
+    local_name: String,
+    operator: AttrSelectorOperator,
+    value: String,
+    case_sensitivity: ParsedCaseSensitivity
+}
+
+impl YAttributeInNoNamespace {
+    pub fn new(local_name: String, operator: AttrSelectorOperator, value: String, case_sensitivity: ParsedCaseSensitivity) -> Self {
+        Self { local_name, operator, value, case_sensitivity }
+    }
+
+    pub fn name(&self, ruby: &Ruby) -> RString {
+        return ruby.str_new(&self.local_name)
+    }
+
+    pub fn operator(&self, ruby: &Ruby) -> Id {
+        YSelector::intern_operator(&self.operator, ruby)
+    }
+
+    pub fn value(&self, ruby: &Ruby) -> RString {
+        ruby.str_new(&self.value)
+    }
+
+    pub fn case_sensitivity(&self, ruby: &Ruby) -> Id {
+        return YSelector::intern_case_sensitivity(&self.case_sensitivity, ruby)
+    }
+}

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

@@ -0,0 +1,16 @@
+use magnus::{RString, Ruby};
+
+#[magnus::wrap(class = "Yass::Selector::AttributeInNoNamespaceExists")]
+pub struct YAttributeInNoNamespaceExists {
+    local_name: String
+}
+
+impl YAttributeInNoNamespaceExists {
+    pub fn new(local_name: String) -> Self {
+        Self { local_name }
+    }
+
+    pub fn value(&self, ruby: &Ruby) -> RString {
+        ruby.str_new(&self.local_name.to_string())
+    }
+}

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

@@ -0,0 +1,41 @@
+use magnus::{Error, Ruby, Value};
+use selectors::attr::{AttrSelectorWithOptionalNamespace, NamespaceConstraint};
+use style::selector_parser::SelectorImpl;
+
+use crate::{selectors::YSpecificNamespaceConstraint, utils::singleton_instance};
+
+#[magnus::wrap(class = "Yass::Selector::AttributeOther")]
+pub struct YAttributeOther {
+    attr_selector_with_optional_namespace: Box<AttrSelectorWithOptionalNamespace<SelectorImpl>>
+}
+
+impl YAttributeOther {
+    pub fn new(attr_selector_with_optional_namespace: Box<AttrSelectorWithOptionalNamespace<SelectorImpl>>) -> Self {
+        Self { attr_selector_with_optional_namespace }
+    }
+
+    pub fn namespace(&self, ruby: &Ruby) -> Result<Option<Value>, Error> {
+        Ok(
+            if let Some(constraint) = &self.attr_selector_with_optional_namespace.namespace {
+                match constraint {
+                    NamespaceConstraint::Any => {
+                        Some(singleton_instance("Yass::Selector::AnyNamespace", ruby)?)
+                    },
+
+                    NamespaceConstraint::Specific(constraint) => {
+                        Some(
+                            ruby.into_value(
+                                YSpecificNamespaceConstraint::new(
+                                    constraint.0.to_string(),
+                                    constraint.1.to_string()
+                                )
+                            )
+                        )
+                    }
+                }
+            } else {
+                None
+            }
+        )
+    }
+}

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

@@ -0,0 +1,16 @@
+use magnus::{RString, Ruby};
+
+#[magnus::wrap(class = "Yass::Selector::Klass")]
+pub struct YClass {
+    pub class: String
+}
+
+impl YClass {
+    pub fn new(class: String) -> Self {
+        Self { class }
+    }
+
+    pub fn value(&self, ruby: &Ruby) -> RString {
+        ruby.str_new(self.class.as_str())
+    }
+}

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

@@ -0,0 +1,49 @@
+use magnus::{Ruby, Value, value::{Id, ReprValue}};
+use selectors::parser::Combinator;
+
+#[magnus::wrap(class = "Yass::Selector::Combinator")]
+pub struct YCombinator {  // lol
+    pub combinator: Combinator
+}
+
+impl YCombinator {
+    pub fn new(combinator: Combinator) -> Self {
+        YCombinator { combinator }
+    }
+
+    pub fn is_ancestor(&self, ruby: &Ruby) -> Value {
+        if self.combinator.is_ancestor() {
+            ruby.qtrue().as_value()
+        } else {
+            ruby.qfalse().as_value()
+        }
+    }
+
+    pub fn is_pseudo_element(&self, ruby: &Ruby) -> Value {
+        if self.combinator.is_pseudo_element() {
+            ruby.qtrue().as_value()
+        } else {
+            ruby.qfalse().as_value()
+        }
+    }
+
+    pub fn is_sibling(&self, ruby: &Ruby) -> Value {
+        if self.combinator.is_sibling() {
+            ruby.qtrue().as_value()
+        } else {
+            ruby.qfalse().as_value()
+        }
+    }
+
+    pub fn kind(&self, ruby: &Ruby) -> Id {
+        match self.combinator {
+            Combinator::Child => ruby.intern("child"),
+            Combinator::Descendant => ruby.intern("descendant"),
+            Combinator::NextSibling => ruby.intern("next_sibling"),
+            Combinator::LaterSibling => ruby.intern("later_sibling"),
+            Combinator::PseudoElement => ruby.intern("pseudo_element"),
+            Combinator::SlotAssignment => ruby.intern("slot_assignment"),
+            Combinator::Part => ruby.intern("part"),
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+use magnus::{RString, Ruby};
+
+#[magnus::wrap(class = "Yass::Selector::DefaultNamespace")]
+pub struct YDefaultNamespace {
+    url: String
+}
+
+impl YDefaultNamespace {
+    pub fn new(url: String) -> Self {
+        Self { url }
+    }
+
+    pub fn url(&self, ruby: &Ruby) -> RString {
+        ruby.str_new(&self.url)
+    }
+}

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

@@ -0,0 +1,31 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc};
+use selectors::parser::RelativeSelector;
+use style::selector_parser::SelectorImpl;
+
+use crate::{cached_value_list::CachedValueList, selectors::{YRelativeSelector}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Selector::Has", mark)]
+pub struct YHas {
+    relative_selectors: CachedValueList<RelativeSelector<SelectorImpl>>
+}
+
+impl YHas {
+    pub fn new(relative_selectors: Box<[RelativeSelector<SelectorImpl>]>) -> Self {
+        Self {
+            relative_selectors: CachedValueList::new(relative_selectors.to_vec(), |relative_selector, _ctx, ruby| {
+                YRelativeSelector::new(relative_selector.clone(), ruby).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn relative_selectors(&self, ruby: &Ruby) -> Result<RArray, Error> {
+        self.relative_selectors.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YHas {
+    fn mark(&self, marker: &gc::Marker) {
+        self.relative_selectors.mark(marker);
+    }
+}

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

@@ -0,0 +1,35 @@
+use magnus::{DataTypeFunctions, Ruby, TypedData, Value, gc, typed_data, value::{Opaque, ReprValue}};
+use selectors::parser::Selector;
+use style::selector_parser::SelectorImpl;
+
+use crate::selectors::YSelector;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Selector::Host", mark)]
+pub struct YHost {
+    selector: Option<Opaque<typed_data::Obj<YSelector>>>
+}
+
+impl YHost {
+    pub fn new(selector: Option<Selector<SelectorImpl>>, ruby: &Ruby) -> Self {
+        Self {
+            selector: selector.and_then(|f|
+                Some(Opaque::from(ruby.obj_wrap(YSelector::new(f))))
+            )
+        }
+    }
+
+    pub fn selector(&self, ruby: &Ruby) -> Option<Value> {
+        self.selector.and_then(|f|
+            Some(ruby.get_inner(f).as_value())
+        )
+    }
+}
+
+impl DataTypeFunctions for YHost {
+    fn mark(&self, marker: &gc::Marker) {
+        if let Some(selector) = self.selector {
+            marker.mark(selector);
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+use magnus::{RString, Ruby};
+
+#[magnus::wrap(class = "Yass::Selector::Id")]
+pub struct YID {
+    id: String
+}
+
+impl YID {
+    pub fn new(id: String) -> Self {
+        Self { id }
+    }
+
+    pub fn value(&self, ruby: &Ruby) -> RString {
+        ruby.str_new(self.id.as_str())
+    }
+}

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

@@ -0,0 +1,146 @@
+use magnus::{Error, Module, RModule, Ruby, method};
+
+use crate::selectors::{YAnPlusB, YRelativeSelector, YSelector, YSelectorChild, YSpecificNamespaceConstraint};
+
+pub fn init(ruby: &Ruby, yass_module: &RModule) -> Result<(), Error> {
+    let selector_class = yass_module.define_class("Selector", ruby.class_object())?;
+    selector_class.define_method("children", method!(YSelector::children, 0))?;
+
+    let relative_selector_class = yass_module.define_class("RelativeSelector", ruby.class_object())?;
+    relative_selector_class.define_method("selector", method!(YRelativeSelector::selector, 0))?;
+    relative_selector_class.define_method("match_hint", method!(YRelativeSelector::match_hint, 0))?;
+
+    let selector_child_class = yass_module.define_class("SelectorChild", ruby.class_object())?;
+
+    let combinator_class = selector_class.define_class("Combinator", selector_child_class)?;
+    selector_child_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    combinator_class.define_method("ancestor?", method!(YSelectorChild::is_ancestor, 0))?;
+    combinator_class.define_method("pseudo_element?", method!(YSelectorChild::is_pseudo_element, 0))?;
+    combinator_class.define_method("sibling?", method!(YSelectorChild::is_sibling, 0))?;
+
+    let local_name_class = selector_class.define_class("LocalName", selector_child_class)?;
+    local_name_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    local_name_class.define_method("value", method!(YSelectorChild::value, 0))?;
+
+    let id_class = selector_class.define_class("Id", selector_child_class)?;
+    id_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    id_class.define_method("value", method!(YSelectorChild::value, 0))?;
+
+    let class_class = selector_class.define_class("Klass", selector_child_class)?;
+    class_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    class_class.define_method("value", method!(YSelectorChild::value, 0))?;
+
+    let negation_class = selector_class.define_class("Negation", selector_child_class)?;
+    negation_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    negation_class.define_method("selectors", method!(YSelectorChild::selectors, 0))?;
+
+    let attribute_in_no_namespace_exists_class = selector_class.define_class("AttributeInNoNamespaceExists", selector_child_class)?;
+    attribute_in_no_namespace_exists_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let attribute_in_no_namespace_class = selector_class.define_class("AttributeInNoNamespace", selector_child_class)?;
+    attribute_in_no_namespace_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    attribute_in_no_namespace_class.define_method("name", method!(YSelectorChild::name, 0))?;
+    attribute_in_no_namespace_class.define_method("value", method!(YSelectorChild::value, 0))?;
+    attribute_in_no_namespace_class.define_method("operator", method!(YSelectorChild::operator, 0))?;
+    attribute_in_no_namespace_class.define_method("case_sensitivity", method!(YSelectorChild::case_sensitivity, 0))?;
+
+    let attribute_other_class = selector_class.define_class("AttributeOther", selector_child_class)?;
+    attribute_other_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    attribute_other_class.define_method("namespace", method!(YSelectorChild::namespace, 0))?;
+
+    let any_namespace_class = selector_class.define_class("AnyNamespace", ruby.class_object())?;
+    let _ = ruby.require("singleton");
+    any_namespace_class.include_module(ruby.class_object().const_get("Singleton")?)?;
+
+    let specific_namespace_constraint_class = selector_class.define_class("SpecificNamespaceConstraint", ruby.class_object())?;
+    specific_namespace_constraint_class.define_method("prefix", method!(YSpecificNamespaceConstraint::prefix, 0))?;
+    specific_namespace_constraint_class.define_method("url", method!(YSpecificNamespaceConstraint::url, 0))?;
+
+    let explicit_universal_type_class = selector_class.define_class("ExplicitUniversalType", selector_child_class)?;
+    explicit_universal_type_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let explicit_any_namespace_class = selector_class.define_class("ExplicitAnyNamespace", selector_child_class)?;
+    explicit_any_namespace_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let explicit_no_namespace_class = selector_class.define_class("ExplicitNoNamespace", selector_child_class)?;
+    explicit_no_namespace_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let default_namespace_class = selector_class.define_class("DefaultNamespace", selector_child_class)?;
+    default_namespace_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    default_namespace_class.define_method("url", method!(YSelectorChild::url, 0))?;
+
+    let namespace_class = selector_class.define_class("Namespace", selector_child_class)?;
+    namespace_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    namespace_class.define_method("prefix", method!(YSelectorChild::prefix, 0))?;
+    namespace_class.define_method("url", method!(YSelectorChild::url, 0))?;
+
+    let root_class = selector_class.define_class("Root", selector_child_class)?;
+    root_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let empty_class = selector_class.define_class("Empty", selector_child_class)?;
+    empty_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let scope_class = selector_class.define_class("Scope", selector_child_class)?;
+    scope_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let implicit_scope_class = selector_class.define_class("ImplicitScope", selector_child_class)?;
+    implicit_scope_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let parent_selector_class = selector_class.define_class("ParentSelector", selector_child_class)?;
+    parent_selector_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let nth_class = selector_class.define_class("Nth", selector_child_class)?;
+    nth_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    nth_class.define_method("type", method!(YSelectorChild::ty, 0))?;
+    nth_class.define_method("function?", method!(YSelectorChild::is_method, 0))?;
+    nth_class.define_method("an_plus_b", method!(YSelectorChild::an_plus_b, 0))?;
+
+    let an_plus_b_class = selector_class.define_class("AnPlusB", ruby.class_object())?;
+    an_plus_b_class.define_method("a", method!(YAnPlusB::a, 0))?;
+    an_plus_b_class.define_method("b", method!(YAnPlusB::b, 0))?;
+
+    let nth_of_class = selector_class.define_class("NthOf", selector_child_class)?;
+    nth_of_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    nth_of_class.define_method("nth", method!(YSelectorChild::nth, 0))?;
+    nth_of_class.define_method("selectors", method!(YSelectorChild::selectors, 0))?;
+
+    let non_ts_pseudo_class = selector_class.define_class("NonTsPseudoClass", selector_child_class)?;
+    non_ts_pseudo_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    non_ts_pseudo_class.define_method("type", method!(YSelectorChild::ty, 0))?;
+    non_ts_pseudo_class.define_method("value", method!(YSelectorChild::value, 0))?;
+
+    let slotted_class = selector_class.define_class("Slotted", selector_child_class)?;
+    slotted_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    slotted_class.define_method("selector", method!(YSelectorChild::selector, 0))?;
+
+    let where_class = selector_class.define_class("Where", selector_child_class)?;
+    where_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    where_class.define_method("selectors", method!(YSelectorChild::selectors, 0))?;
+
+    let is_class = selector_class.define_class("Is", selector_child_class)?;
+    is_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    is_class.define_method("selectors", method!(YSelectorChild::selectors, 0))?;
+
+    let part_class = selector_class.define_class("Part", selector_child_class)?;
+    part_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    part_class.define_method("items", method!(YSelectorChild::items, 0))?;
+
+    let has_class = selector_class.define_class("Has", selector_child_class)?;
+    has_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    has_class.define_method("relative_selectors", method!(YSelectorChild::relative_selectors, 0))?;
+
+    let host_class = selector_class.define_class("Host", selector_child_class)?;
+    host_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+    host_class.define_method("selector", method!(YSelectorChild::selector, 0))?;
+
+    let invalid_class = selector_class.define_class("Invalid", selector_child_class)?;
+    invalid_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let pseudo_element_class = selector_class.define_class("PseudoElement", selector_child_class)?;
+    pseudo_element_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    let relative_selector_anchor_class = selector_class.define_class("RelativeSelectorAnchor", selector_child_class)?;
+    relative_selector_anchor_class.define_method("kind", method!(YSelectorChild::kind, 0))?;
+
+    Ok(())
+}

data/ext/yass/src/selectors/is.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::Is", mark)]
+pub struct YIs {
+    selectors: YSelectorList
+}
+
+impl YIs {
+    pub fn new(selectors: SelectorList<SelectorImpl>) -> Self {
+        Self { selectors: YSelectorList::new(selectors.slice()) }
+    }
+
+    pub fn selectors(&self, ruby: &Ruby) -> Result<RArray, Error> {
+        self.selectors.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YIs {
+    fn mark(&self, marker: &gc::Marker) {
+        self.selectors.mark(marker);
+    }
+}

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

@@ -0,0 +1,18 @@
+use magnus::{RString, Ruby};
+use selectors::parser::LocalName;
+use style::selector_parser::SelectorImpl;
+
+#[magnus::wrap(class = "Yass::Selector::LocalName")]
+pub struct YLocalName {
+    local_name: LocalName<SelectorImpl>
+}
+
+impl YLocalName {
+    pub fn new(local_name: LocalName<SelectorImpl>) -> Self {
+        Self { local_name }
+    }
+
+    pub fn value(&self, ruby: &Ruby) -> RString {
+        ruby.str_new(&self.local_name.name.to_string())
+    }
+}

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

@@ -0,0 +1,54 @@
+pub mod selector_child;
+pub mod selector;
+pub mod relative_selector;
+pub mod local_name;
+pub mod id;
+pub mod init;
+pub mod class;
+pub mod selector_list;
+pub mod negation;
+pub mod attribute_in_no_namespace_exists;
+pub mod attribute_in_no_namespace;
+pub mod attribute_other;
+pub mod specific_namespace_constraint;
+pub mod default_namespace;
+pub mod namespace;
+pub mod nth;
+pub mod nth_of;
+pub mod an_plus_b;
+pub mod non_ts_pseudo_class;
+pub mod slotted;
+pub mod r#where;
+pub mod is;
+pub mod host;
+pub mod part;
+pub mod has;
+pub mod combinator;
+pub mod unit_selectors;
+
+pub use selector_child::*;
+pub use selector::*;
+pub use relative_selector::*;
+pub use local_name::*;
+pub use id::*;
+pub use class::*;
+pub use selector_list::*;
+pub use negation::*;
+pub use attribute_in_no_namespace_exists::*;
+pub use attribute_in_no_namespace::*;
+pub use attribute_other::*;
+pub use specific_namespace_constraint::*;
+pub use default_namespace::*;
+pub use namespace::*;
+pub use nth::*;
+pub use nth_of::*;
+pub use an_plus_b::*;
+pub use non_ts_pseudo_class::*;
+pub use slotted::*;
+pub use r#where::*;
+pub use is::*;
+pub use host::*;
+pub use part::*;
+pub use has::*;
+pub use combinator::*;
+pub use unit_selectors::*;

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

@@ -0,0 +1,21 @@
+use magnus::{RString, Ruby};
+
+#[magnus::wrap(class = "Yass::Selector::Namespace")]
+pub struct YNamespace {
+    prefix: String,
+    url: String
+}
+
+impl YNamespace {
+    pub fn new(prefix: String, url: String) -> Self {
+        Self { prefix, url }
+    }
+
+    pub fn prefix(&self, ruby: &Ruby) -> RString {
+        ruby.str_new(&self.prefix)
+    }
+
+    pub fn url(&self, ruby: &Ruby) -> RString {
+        ruby.str_new(&self.url)
+    }
+}