p_css 0.2.0.beta1-x86_64-linux

data/ext/css_native/src/lib.rs

@@ -0,0 +1,117 @@
+mod matcher;
+mod selectors;
+mod snapshot;
+mod state;
+mod tokenizer;
+
+use magnus::{
+    function, kwargs, prelude::*, value::ReprValue, Error, RArray, RClass, Ruby, Value,
+};
+use tokenizer::{HashFlag, Kind, NumberFlag, Token, TokenValue, Tokenizer};
+
+fn hello() -> &'static str {
+    "hello from rust"
+}
+
+fn tokenize(ruby: &Ruby, input: String, preserve_comments: bool) -> Result<RArray, Error> {
+    let tokens = Tokenizer::new(&input, preserve_comments).tokenize();
+    let array  = ruby.ary_new_capa(tokens.len());
+    let klass  = token_class(ruby)?;
+
+    for t in tokens {
+        array.push(build_token(ruby, klass, t)?)?;
+    }
+
+    Ok(array)
+}
+
+fn token_class(ruby: &Ruby) -> Result<RClass, Error> {
+    let css: Value = ruby.class_object().funcall("const_get", ("CSS",))?;
+    css.funcall("const_get", ("Token",))
+}
+
+fn build_token(ruby: &Ruby, klass: RClass, token: Token) -> Result<Value, Error> {
+    let kind_sym = kind_to_symbol(ruby, token.kind);
+    let value    = value_to_ruby(ruby, &token.value);
+    let flag_sym = flag_to_symbol(ruby, token.number_flag, token.hash_flag);
+    let unit_val = unit_to_ruby(ruby, token.unit.as_deref());
+
+    klass.funcall(
+        "new",
+        (kind_sym, value, kwargs!("flag" => flag_sym, "unit" => unit_val))
+    )
+}
+
+fn kind_to_symbol(ruby: &Ruby, kind: Kind) -> magnus::value::StaticSymbol {
+    let name = match kind {
+        Kind::Ident      => "ident",
+        Kind::Function   => "function",
+        Kind::AtKeyword  => "at_keyword",
+        Kind::Hash       => "hash",
+        Kind::String_    => "string",
+        Kind::BadString  => "bad_string",
+        Kind::Url        => "url",
+        Kind::BadUrl     => "bad_url",
+        Kind::Delim      => "delim",
+        Kind::Number     => "number",
+        Kind::Percentage => "percentage",
+        Kind::Dimension  => "dimension",
+        Kind::Whitespace => "whitespace",
+        Kind::Cdo        => "cdo",
+        Kind::Cdc        => "cdc",
+        Kind::Comment    => "comment",
+        Kind::Colon      => "colon",
+        Kind::Semicolon  => "semicolon",
+        Kind::Comma      => "comma",
+        Kind::LBracket   => "lbracket",
+        Kind::RBracket   => "rbracket",
+        Kind::LParen     => "lparen",
+        Kind::RParen     => "rparen",
+        Kind::LBrace     => "lbrace",
+        Kind::RBrace     => "rbrace",
+    };
+
+    ruby.sym_new(name)
+}
+
+fn value_to_ruby(ruby: &Ruby, v: &TokenValue) -> Value {
+    match v {
+        TokenValue::None     => ruby.qnil().as_value(),
+        TokenValue::Str(s)   => ruby.str_new(s).as_value(),
+        TokenValue::Delim(c) => ruby.str_new(&c.to_string()).as_value(),
+        TokenValue::Int(i)   => ruby.integer_from_i64(*i).as_value(),
+        TokenValue::Float(f) => ruby.float_from_f64(*f).as_value(),
+    }
+}
+
+fn flag_to_symbol(ruby: &Ruby, num: Option<NumberFlag>, hash: Option<HashFlag>) -> Value {
+    match (num, hash) {
+        (Some(NumberFlag::Integer), _) => ruby.sym_new("integer").as_value(),
+        (Some(NumberFlag::Number),  _) => ruby.sym_new("number").as_value(),
+        (_, Some(HashFlag::Id))        => ruby.sym_new("id").as_value(),
+        (_, Some(HashFlag::Unrestricted)) => ruby.sym_new("unrestricted").as_value(),
+        _                              => ruby.qnil().as_value(),
+    }
+}
+
+fn unit_to_ruby(ruby: &Ruby, unit: Option<&str>) -> Value {
+    match unit {
+        Some(s) => ruby.str_new(s).as_value(),
+        None    => ruby.qnil().as_value(),
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let css    = ruby.define_module("CSS")?;
+    let native = css.define_module("Native")?;
+
+    native.define_singleton_method("hello",    function!(hello, 0))?;
+    native.define_singleton_method("tokenize", function!(tokenize, 2))?;
+
+    selectors::init(ruby)?;
+    state::init(ruby)?;
+    snapshot::init(ruby)?;
+
+    Ok(())
+}

data/ext/css_native/src/matcher.rs

@@ -0,0 +1,356 @@
+use crate::selectors::{AnB, AttrMatcher, CaseFlag, Combinator, Complex, Compound, Pseudo, Selector, Simple};
+use crate::snapshot::{ElementData, Snapshot};
+use crate::state::{State, StatefulKind};
+
+// Entry point. Returns true if any of the SelectorList alternatives match.
+// Runs entirely against owned data — safe to call without the GVL.
+pub fn matches(snap: &Snapshot, slot: u32, selector: &Selector, state: Option<&State>) -> bool {
+    selector.list().iter().any(|c| match_complex(snap, slot, c, state))
+}
+
+fn match_complex(snap: &Snapshot, slot: u32, complex: &Complex, state: Option<&State>) -> bool {
+    let last = complex.compounds.len().saturating_sub(1);
+    match_at(snap, Some(slot), complex, last, state)
+}
+
+fn match_at(snap: &Snapshot, slot: Option<u32>, complex: &Complex, index: usize, state: Option<&State>) -> bool {
+    let Some(slot) = slot else { return false };
+
+    if !match_compound(snap, slot, &complex.compounds[index], state) {
+        return false;
+    }
+
+    if index == 0 {
+        return true;
+    }
+
+    let prev = index - 1;
+    let element = snap.element(slot);
+
+    match complex.combinators[prev] {
+        Combinator::Descendant         => walk_until_match(snap, element.parent,       complex, prev, Step::Parent,      state),
+        Combinator::Child              => match_at(snap, element.parent,               complex, prev,                    state),
+        Combinator::NextSibling        => match_at(snap, element.prev_sibling,         complex, prev,                    state),
+        Combinator::SubsequentSibling  => walk_until_match(snap, element.prev_sibling, complex, prev, Step::PrevSibling, state),
+    }
+}
+
+#[derive(Clone, Copy)]
+enum Step {
+    Parent,
+    PrevSibling,
+}
+
+fn walk_until_match(
+    snap:    &Snapshot,
+    start:   Option<u32>,
+    complex: &Complex,
+    index:   usize,
+    step:    Step,
+    state:   Option<&State>,
+) -> bool {
+    let mut current = start;
+
+    while let Some(slot) = current {
+        if match_at(snap, Some(slot), complex, index, state) {
+            return true;
+        }
+
+        let e = snap.element(slot);
+        current = match step {
+            Step::Parent      => e.parent,
+            Step::PrevSibling => e.prev_sibling,
+        };
+    }
+
+    false
+}
+
+fn match_compound(snap: &Snapshot, slot: u32, compound: &Compound, state: Option<&State>) -> bool {
+    let element = snap.element(slot);
+    compound.components.iter().all(|s| match_simple(snap, slot, element, s, state))
+}
+
+fn match_simple(snap: &Snapshot, slot: u32, element: &ElementData, simple: &Simple, state: Option<&State>) -> bool {
+    match simple {
+        Simple::Type(name)      => &element.tag == name,
+        Simple::Universal       => true,
+        Simple::Id(name)        => element.id.as_deref() == Some(name.as_str()),
+        Simple::Class(name)     => element.classes.iter().any(|c| c == name),
+        Simple::Attribute(attr) => match_attribute(element, attr),
+        Simple::PseudoClass(p)  => match_pseudo(snap, slot, element, p, state),
+    }
+}
+
+fn match_pseudo(snap: &Snapshot, slot: u32, element: &ElementData, pseudo: &Pseudo, state: Option<&State>) -> bool {
+    match pseudo {
+        Pseudo::Root        => element.parent.is_none(),
+        Pseudo::FirstChild  => element.prev_sibling.is_none(),
+        Pseudo::LastChild   => element.next_sibling.is_none(),
+        Pseudo::OnlyChild   => element.prev_sibling.is_none() && element.next_sibling.is_none(),
+        Pseudo::Empty       => element.is_empty,
+        Pseudo::Defined     => true,
+        Pseudo::FirstOfType => element.index_of_type == 1,
+        Pseudo::LastOfType  => element.last_index_of_type == 1,
+        Pseudo::OnlyOfType  => element.index_of_type == 1 && element.last_index_of_type == 1,
+
+        // Pure-Ruby parity: nth-* require a parent. Root elements never
+        // satisfy them, even when the index would be 1.
+        Pseudo::NthChild(anb)       => element.parent.is_some() && match_anb(anb, element.index),
+        Pseudo::NthLastChild(anb)   => element.parent.is_some() && match_anb(anb, element.last_index),
+        Pseudo::NthOfType(anb)      => element.parent.is_some() && match_anb(anb, element.index_of_type),
+        Pseudo::NthLastOfType(anb)  => element.parent.is_some() && match_anb(anb, element.last_index_of_type),
+
+        Pseudo::Is(list)  =>  list.iter().any(|c| match_complex(snap, slot, c, state)),
+        Pseudo::Not(list) => !list.iter().any(|c| match_complex(snap, slot, c, state)),
+
+        Pseudo::Link             => is_link(element),
+        Pseudo::Enabled          => is_disableable(element) && !is_disabled(snap, slot),
+        Pseudo::Disabled         => is_disableable(element) &&  is_disabled(snap, slot),
+        Pseudo::Checked          => is_checked(element),
+        Pseudo::Required         => is_input_like(element) && element.attrs.contains_key("required"),
+        Pseudo::Optional         => is_input_like(element) && !element.attrs.contains_key("required"),
+        Pseudo::ReadOnly         => is_read_only(snap, slot, element),
+        Pseudo::ReadWrite        => is_read_write(snap, slot, element),
+        Pseudo::PlaceholderShown => is_placeholder_shown(element),
+
+        Pseudo::Hover        => stateful(state, snap, slot, StatefulKind::Hover),
+        Pseudo::Focus        => stateful(state, snap, slot, StatefulKind::Focus),
+        Pseudo::FocusWithin  => stateful(state, snap, slot, StatefulKind::FocusWithin),
+        Pseudo::FocusVisible => stateful(state, snap, slot, StatefulKind::FocusVisible),
+        Pseudo::Active       => stateful(state, snap, slot, StatefulKind::Active),
+        Pseudo::Visited      => stateful(state, snap, slot, StatefulKind::Visited),
+        Pseudo::Target       => stateful(state, snap, slot, StatefulKind::Target),
+
+        Pseudo::Has          => false,
+        Pseudo::Lang(target) => match_lang(snap, slot, target.as_deref()),
+        Pseudo::Dir(target)  => match_dir(snap, slot, target.as_deref()),
+    }
+}
+
+fn match_lang(snap: &Snapshot, slot: u32, target: Option<&str>) -> bool {
+    let Some(target) = target else { return false };
+
+    let mut cur = Some(slot);
+    while let Some(s) = cur {
+        let el = snap.element(s);
+
+        let actual = el.attrs.get("lang").or_else(|| el.attrs.get("xml:lang"));
+
+        if let Some(actual) = actual {
+            let actual = actual.to_ascii_lowercase();
+            return actual == target
+                || actual.starts_with(target) && actual.as_bytes().get(target.len()) == Some(&b'-');
+        }
+
+        cur = el.parent;
+    }
+
+    false
+}
+
+fn match_dir(snap: &Snapshot, slot: u32, target: Option<&str>) -> bool {
+    let Some(target) = target else { return false };
+
+    let mut cur = Some(slot);
+    while let Some(s) = cur {
+        let el = snap.element(s);
+
+        if let Some(actual) = el.attrs.get("dir") {
+            return actual.eq_ignore_ascii_case(target);
+        }
+
+        cur = el.parent;
+    }
+
+    target == "ltr"
+}
+
+fn stateful(state: Option<&State>, snap: &Snapshot, slot: u32, kind: StatefulKind) -> bool {
+    state.is_some_and(|s| s.matches(snap, slot, kind))
+}
+
+const LINK_TAGS:        &[&str] = &["a", "area", "link"];
+const DISABLEABLE_TAGS: &[&str] = &["button", "input", "select", "textarea", "optgroup", "option", "fieldset"];
+const INPUT_TAGS:       &[&str] = &["input", "textarea", "select"];
+const RO_INPUT_TYPES:   &[&str] = &["hidden", "range", "color", "checkbox", "radio", "file", "submit", "image", "reset", "button"];
+
+fn is_link(element: &ElementData) -> bool {
+    LINK_TAGS.contains(&element.tag.as_str()) && element.attrs.contains_key("href")
+}
+
+fn is_disableable(element: &ElementData) -> bool {
+    DISABLEABLE_TAGS.contains(&element.tag.as_str())
+}
+
+fn is_input_like(element: &ElementData) -> bool {
+    INPUT_TAGS.contains(&element.tag.as_str())
+}
+
+fn is_checked(element: &ElementData) -> bool {
+    match element.tag.as_str() {
+        "input" => {
+            let ty = element.attrs.get("type").map(String::as_str).unwrap_or("");
+            (ty.eq_ignore_ascii_case("checkbox") || ty.eq_ignore_ascii_case("radio"))
+                && element.attrs.contains_key("checked")
+        }
+        "option" => element.attrs.contains_key("selected"),
+        _ => false,
+    }
+}
+
+// `:disabled` walks the ancestor chain. A fieldset[disabled] disables every
+// descendant unless that descendant sits inside the fieldset's first <legend>.
+fn is_disabled(snap: &Snapshot, slot: u32) -> bool {
+    let element = snap.element(slot);
+    if element.attrs.contains_key("disabled") {
+        return true;
+    }
+
+    let mut ancestor = element.parent;
+    while let Some(a_slot) = ancestor {
+        let a = snap.element(a_slot);
+        if a.tag == "fieldset" && a.attrs.contains_key("disabled") {
+            if !is_inside_first_legend(snap, slot, a_slot) {
+                return true;
+            }
+        }
+        ancestor = a.parent;
+    }
+
+    false
+}
+
+fn is_inside_first_legend(snap: &Snapshot, element_slot: u32, fieldset_slot: u32) -> bool {
+    let Some(first_legend) = first_legend_child(snap, fieldset_slot) else {
+        return false;
+    };
+
+    let mut cur = Some(element_slot);
+    while let Some(s) = cur {
+        if s == first_legend  { return true; }
+        if s == fieldset_slot { return false; }
+        cur = snap.element(s).parent;
+    }
+    false
+}
+
+fn first_legend_child(snap: &Snapshot, parent_slot: u32) -> Option<u32> {
+    let mut cur = snap.element(parent_slot).first_child;
+    while let Some(s) = cur {
+        if snap.element(s).tag == "legend" {
+            return Some(s);
+        }
+        cur = snap.element(s).next_sibling;
+    }
+    None
+}
+
+fn is_read_only(snap: &Snapshot, slot: u32, element: &ElementData) -> bool {
+    match element.tag.as_str() {
+        "input" => {
+            let ty = element.attrs.get("type").map(String::as_str).unwrap_or("");
+            if RO_INPUT_TYPES.iter().any(|t| ty.eq_ignore_ascii_case(t)) {
+                return true;
+            }
+            element.attrs.contains_key("readonly") || is_disabled(snap, slot)
+        }
+        "textarea" => element.attrs.contains_key("readonly") || is_disabled(snap, slot),
+        _ => {
+            let ce = element.attrs.get("contenteditable")
+                .map(|s| s.to_ascii_lowercase())
+                .unwrap_or_default();
+            ce.is_empty() || (ce != "true" && ce != "plaintext-only")
+        }
+    }
+}
+
+fn is_read_write(snap: &Snapshot, slot: u32, element: &ElementData) -> bool {
+    match element.tag.as_str() {
+        "input" | "textarea" => !is_read_only(snap, slot, element),
+        _ => {
+            let ce = element.attrs.get("contenteditable")
+                .map(|s| s.to_ascii_lowercase())
+                .unwrap_or_default();
+            ce == "true" || ce == "plaintext-only"
+        }
+    }
+}
+
+fn is_placeholder_shown(element: &ElementData) -> bool {
+    if element.tag != "input" && element.tag != "textarea" {
+        return false;
+    }
+    if !element.attrs.contains_key("placeholder") {
+        return false;
+    }
+    let value = element.attrs.get("value").map(String::as_str).unwrap_or("");
+    value.is_empty()
+}
+
+// CSS Selectors §6.6.5.1: matches when there exists a non-negative integer
+// `k` such that `index == step * k + offset`. When step is zero, that
+// collapses to `index == offset`.
+fn match_anb(anb: &AnB, index: u32) -> bool {
+    let index = index as i64;
+
+    if anb.step == 0 {
+        return index == anb.offset;
+    }
+
+    let diff = index - anb.offset;
+    diff % anb.step == 0 && (diff / anb.step) >= 0
+}
+
+fn match_attribute(element: &ElementData, attr: &crate::selectors::AttrSel) -> bool {
+    let actual = match attr.name.as_str() {
+        "id"    => element.id.as_deref(),
+        "class" => element.attrs.get("class").map(String::as_str),
+        _       => element.attrs.get(&attr.name).map(String::as_str),
+    };
+
+    let Some(actual) = actual else { return false };
+    let Some(matcher) = attr.matcher else { return true };
+
+    let needle = attr.value.as_deref().unwrap_or("");
+    let case_insensitive = attr.case_flag == Some(CaseFlag::I);
+
+    let cmp_eq = |h: &str, n: &str| {
+        if case_insensitive { h.eq_ignore_ascii_case(n) } else { h == n }
+    };
+
+    let starts = |h: &str, n: &str| {
+        if case_insensitive {
+            h.len() >= n.len() && h[..n.len()].eq_ignore_ascii_case(n)
+        } else {
+            h.starts_with(n)
+        }
+    };
+
+    let ends = |h: &str, n: &str| {
+        if case_insensitive {
+            h.len() >= n.len() && h[h.len() - n.len()..].eq_ignore_ascii_case(n)
+        } else {
+            h.ends_with(n)
+        }
+    };
+
+    let contains = |h: &str, n: &str| {
+        if case_insensitive {
+            h.to_ascii_lowercase().contains(&n.to_ascii_lowercase())
+        } else {
+            h.contains(n)
+        }
+    };
+
+    match matcher {
+        AttrMatcher::Exact     => cmp_eq(actual, needle),
+        AttrMatcher::Includes  => !needle.is_empty()
+            && actual.split_whitespace().any(|w| cmp_eq(w, needle)),
+        AttrMatcher::Dash      => cmp_eq(actual, needle)
+            || starts(actual, &format!("{}-", needle)),
+        AttrMatcher::Prefix    => !needle.is_empty() && starts(actual, needle),
+        AttrMatcher::Suffix    => !needle.is_empty() && ends(actual, needle),
+        AttrMatcher::Substring => !needle.is_empty() && contains(actual, needle),
+    }
+}