rusteerio 1.0.1 → 1.1.0

package/native/src/selector.rs

@@ -1,7 +1,7 @@
 //! Cheerio-compatible CSS and jQuery selection over the native mutable DOM.
 
+use crate::id_hash::{IdMap, IdSet};
 use napi::{Error, Result, Status};
-use std::collections::HashSet;
 
 pub(crate) trait SelectDom {
     fn kind(&self, id: u32) -> &str;
@@ -23,8 +23,68 @@ pub(crate) trait SelectDom {
     fn pseudo_alias(&self, _name: &str) -> Option<&str> {
         None
     }
+    /// Every element whose ASCII-lowercased name is `lowercase_name`, in
+    /// document order, when the tree keeps such an index.
+    fn elements_named(&self, _lowercase_name: &str) -> Option<&[u32]> {
+        None
+    }
+    /// Whether ascending ids are document order for every node.
+    fn is_id_order_document_order(&self) -> bool {
+        false
+    }
 }
 
+/// Attributes whose values css-select compares case-insensitively in HTML
+/// documents when a selector has no `i` or `s` flag.
+pub(crate) const CASE_INSENSITIVE_ATTRIBUTES: &[&str] = &[
+    "accept",
+    "accept-charset",
+    "align",
+    "alink",
+    "axis",
+    "bgcolor",
+    "charset",
+    "checked",
+    "clear",
+    "codetype",
+    "color",
+    "compact",
+    "declare",
+    "defer",
+    "dir",
+    "direction",
+    "disabled",
+    "enctype",
+    "face",
+    "frame",
+    "hreflang",
+    "http-equiv",
+    "lang",
+    "language",
+    "link",
+    "media",
+    "method",
+    "multiple",
+    "nohref",
+    "noresize",
+    "noshade",
+    "nowrap",
+    "readonly",
+    "rel",
+    "rev",
+    "rules",
+    "scope",
+    "scrolling",
+    "selected",
+    "shape",
+    "target",
+    "text",
+    "type",
+    "valign",
+    "valuetype",
+    "vlink",
+];
+
 const KNOWN: &[&str] = &[
     "not",
     "is",
@@ -119,8 +179,8 @@ fn validate<D: SelectDom>(dom: &D, complex: &Complex) -> Result<()> {
                     return Err(invalid(format!("Unknown pseudo-class :{name}")));
                 }
                 if matches!(name.as_str(), "not" | "is" | "where" | "matches" | "has") {
-                    for nested in parse(argument)? {
-                        validate(dom, &nested)?;
+                    for nested in parse(argument)?.iter() {
+                        validate(dom, nested)?;
                     }
                 }
             }
@@ -204,7 +264,8 @@ fn unescape(value: &str) -> String {
 
 fn equal_strings(left: &str, right: &str) -> bool {
     left == right
-        || (crate::codec::has_encoding(left) || crate::codec::has_encoding(right))
+        || !(left.is_ascii() && right.is_ascii())
+            && (crate::codec::has_encoding(left) || crate::codec::has_encoding(right))
             && crate::codec::to_units(left) == crate::codec::to_units(right)
 }
 
@@ -489,7 +550,29 @@ fn parse_compound(source: &str) -> Result<Vec<Test>> {
     Ok(tests)
 }
 
-fn parse(source: &str) -> Result<Vec<Complex>> {
+thread_local! {
+    /// Parsed selectors by source; queries reuse a handful of selectors many times.
+    static PARSED: std::cell::RefCell<std::collections::HashMap<String, std::rc::Rc<Vec<Complex>>>> =
+        std::cell::RefCell::new(std::collections::HashMap::new());
+}
+const PARSED_LIMIT: usize = 512;
+
+fn parse(source: &str) -> Result<std::rc::Rc<Vec<Complex>>> {
+    if let Some(parsed) = PARSED.with(|cache| cache.borrow().get(source).cloned()) {
+        return Ok(parsed);
+    }
+    let parsed = std::rc::Rc::new(parse_uncached(source)?);
+    PARSED.with(|cache| {
+        let mut cache = cache.borrow_mut();
+        if cache.len() >= PARSED_LIMIT {
+            cache.clear();
+        }
+        cache.insert(source.to_owned(), parsed.clone());
+    });
+    Ok(parsed)
+}
+
+fn parse_uncached(source: &str) -> Result<Vec<Complex>> {
     split_groups(source)?
         .iter()
         .map(|group| {
@@ -568,7 +651,7 @@ fn parse(source: &str) -> Result<Vec<Complex>> {
 }
 
 fn unique(ids: impl IntoIterator<Item = u32>) -> Vec<u32> {
-    let mut seen = HashSet::new();
+    let mut seen = IdSet::default();
     ids.into_iter().filter(|id| seen.insert(*id)).collect()
 }
 
@@ -587,7 +670,29 @@ fn descendants<D: SelectDom>(dom: &D, roots: &[u32]) -> Vec<u32> {
             stack.extend(dom.children(id).iter().rev().copied());
         }
     }
-    unique(output)
+    // One root's descendants are distinct; only overlapping roots repeat.
+    if roots.len() > 1 {
+        unique(output)
+    } else {
+        output
+    }
+}
+
+/// Visits the elements below `root` in document order, as `descendants` lists
+/// them for one root, until `visit` returns false.
+fn for_each_descendant<D: SelectDom>(dom: &D, root: u32, mut visit: impl FnMut(u32) -> bool) {
+    let scope_barrier = tag(dom, root);
+    let mut stack: Vec<u32> = dom.children(root).iter().rev().copied().collect();
+    while let Some(id) = stack.pop() {
+        let kind = dom.kind(id);
+        if scope_barrier && kind == "root" {
+            continue;
+        }
+        if matches!(kind, "tag" | "script" | "style") && !visit(id) {
+            return;
+        }
+        stack.extend(dom.children(id).iter().rev().copied());
+    }
 }
 
 fn siblings<D: SelectDom>(dom: &D, id: u32) -> Vec<u32> {
@@ -637,13 +742,13 @@ fn position(name: &str) -> bool {
 }
 
 fn has_position(source: &str) -> Result<bool> {
-    for complex in parse(source)? {
-        for part in complex.parts {
+    for complex in parse(source)?.iter() {
+        for part in &complex.parts {
             for test in part {
                 if let Test::Pseudo(name, argument) = test {
-                    if position(&name)
+                    if position(name)
                         || (matches!(name.as_str(), "not" | "is" | "where" | "matches")
-                            && has_position(&argument)?)
+                            && has_position(argument)?)
                     {
                         return Ok(true);
                     }
@@ -775,22 +880,7 @@ fn attr_matches<D: SelectDom>(
     let insensitive = flag == Some('i')
         || (flag != Some('s')
             && !dom.xml_mode()
-            && matches!(
-                name.as_str(),
-                "type"
-                    | "lang"
-                    | "dir"
-                    | "rel"
-                    | "target"
-                    | "method"
-                    | "enctype"
-                    | "align"
-                    | "valign"
-                    | "charset"
-                    | "hreflang"
-                    | "media"
-                    | "http-equiv"
-            ));
+            && CASE_INSENSITIVE_ATTRIBUTES.contains(&name.as_str()));
     let (attribute, value) = if insensitive {
         (attribute.to_lowercase(), value.to_lowercase())
     } else {
@@ -819,6 +909,49 @@ fn matches_backwards<D: SelectDom>(
     complex: &Complex,
     index: usize,
     scope: &[u32],
+    memo: &mut BackwardMemo,
+) -> Result<bool> {
+    matches_backwards_within(dom, id, complex, index, scope, None, memo)
+}
+
+/// Results of matching an element against the compounds up to an index, for
+/// one complex selector, scope and allowed set. Without it, chains of
+/// descendant combinators retry the same ancestors for every candidate,
+/// which grows exponentially with nesting depth.
+#[derive(Default)]
+struct BackwardMemo(IdMap<u64, bool>);
+
+/// Matches right to left. With `allowed`, every element matched for an
+/// earlier compound must be in that set.
+fn matches_backwards_within<D: SelectDom>(
+    dom: &D,
+    id: u32,
+    complex: &Complex,
+    index: usize,
+    scope: &[u32],
+    allowed: Option<&IdSet<u32>>,
+    memo: &mut BackwardMemo,
+) -> Result<bool> {
+    // One combinator cannot repeat work; the memo would only cost lookups.
+    let key = (complex.parts.len() > 2).then(|| (index as u64) << 32 | u64::from(id));
+    if let Some(known) = key.and_then(|key| memo.0.get(&key)) {
+        return Ok(*known);
+    }
+    let matched = matches_backwards_uncached(dom, id, complex, index, scope, allowed, memo)?;
+    if let Some(key) = key {
+        memo.0.insert(key, matched);
+    }
+    Ok(matched)
+}
+
+fn matches_backwards_uncached<D: SelectDom>(
+    dom: &D,
+    id: u32,
+    complex: &Complex,
+    index: usize,
+    scope: &[u32],
+    allowed: Option<&IdSet<u32>>,
+    memo: &mut BackwardMemo,
 ) -> Result<bool> {
     if !matches_compound(dom, id, &complex.parts[index], scope)? {
         return Ok(false);
@@ -857,16 +990,43 @@ fn matches_backwards<D: SelectDom>(
         }
     };
     for candidate in candidates {
-        if matches_backwards(dom, candidate, complex, index - 1, scope)? {
+        if allowed.is_some_and(|allowed| !allowed.contains(&candidate)) {
+            continue;
+        }
+        if matches_backwards_within(dom, candidate, complex, index - 1, scope, allowed, memo)? {
             return Ok(true);
         }
     }
     Ok(false)
 }
 
+/// Whether evaluating `complex` right to left gives the same result as
+/// expanding it left to right: no leading combinator, no `:scope`, and no
+/// positional pseudo-class, which filters each intermediate selection.
+fn is_backward_safe(complex: &Complex) -> Result<bool> {
+    if complex.leading.is_some() || complex.parts.len() < 2 {
+        return Ok(false);
+    }
+    for part in &complex.parts {
+        for test in part {
+            if let Test::Pseudo(name, argument) = test {
+                if name == "scope"
+                    || position(name)
+                    || (matches!(name.as_str(), "not" | "is" | "where" | "matches")
+                        && has_position(argument)?)
+                {
+                    return Ok(false);
+                }
+            }
+        }
+    }
+    Ok(true)
+}
+
 fn matches_expression<D: SelectDom>(dom: &D, id: u32, source: &str, scope: &[u32]) -> Result<bool> {
-    for complex in parse(source)? {
-        if matches_backwards(dom, id, &complex, complex.parts.len() - 1, scope)? {
+    for complex in parse(source)?.iter() {
+        let mut memo = BackwardMemo::default();
+        if matches_backwards(dom, id, complex, complex.parts.len() - 1, scope, &mut memo)? {
             return Ok(true);
         }
     }
@@ -890,7 +1050,7 @@ fn pseudo<D: SelectDom>(
     Ok(match name {
         "not" => !matches_expression(dom, id, argument, scope)?,
         "is" | "where" | "matches" => matches_expression(dom, id, argument, scope)?,
-        "has" => !select(dom, argument, Some(&[id]))?.is_empty(),
+        "has" => !select_in(dom, argument, Some(&[id]))?.is_empty(),
         "contains" | "icontains" => {
             let value = unescape(argument.trim_matches(['\'', '"']));
             let text = dom.text(id);
@@ -923,7 +1083,7 @@ fn pseudo<D: SelectDom>(
             let mut argument = argument;
             if let Some((formula, of)) = argument.split_once(" of ") {
                 argument = formula;
-                children = filter(dom, of, &children)?;
+                children = filter_in(dom, of, &children)?;
             }
             let Some(index) = children.iter().position(|child| *child == id) else {
                 return Ok(false);
@@ -1004,6 +1164,15 @@ fn pseudo<D: SelectDom>(
     })
 }
 
+/// The candidates of a compound that names an element type, from the tree's
+/// name index; `matches_compound` still tests each one.
+fn elements_named_by<'a, D: SelectDom>(dom: &'a D, tests: &[Test]) -> Option<&'a [u32]> {
+    tests.iter().find_map(|test| match test {
+        Test::Tag(name) => dom.elements_named(&name.to_ascii_lowercase()),
+        _ => None,
+    })
+}
+
 fn matches_compound<D: SelectDom>(dom: &D, id: u32, tests: &[Test], scope: &[u32]) -> Result<bool> {
     if !tag(dom, id) {
         return Ok(false);
@@ -1088,7 +1257,7 @@ fn apply<D: SelectDom>(dom: &D, ids: Vec<u32>, tests: &[Test], scope: &[u32]) ->
             } else if matches!(name.as_str(), "not" | "is" | "where" | "matches")
                 && has_position(argument)?
             {
-                let wanted: HashSet<_> = filter(dom, argument, &result)?.into_iter().collect();
+                let wanted: IdSet<_> = filter_in(dom, argument, &result)?.into_iter().collect();
                 result.retain(|id| wanted.contains(id) != (name == "not"));
             }
         }
@@ -1097,11 +1266,81 @@ fn apply<D: SelectDom>(dom: &D, ids: Vec<u32>, tests: &[Test], scope: &[u32]) ->
 }
 
 /// Query descendants of contexts (the root document when omitted).
+/// Option-derived flags, read once per query rather than for every node tested.
+struct Flagged<'a, D> {
+    dom: &'a D,
+    xml: bool,
+    lower_tags: bool,
+    lower_attributes: bool,
+}
+
+impl<'a, D: SelectDom> Flagged<'a, D> {
+    fn new(dom: &'a D) -> Self {
+        Self {
+            dom,
+            xml: dom.xml_mode(),
+            lower_tags: dom.lower_case_tags(),
+            lower_attributes: dom.lower_case_attribute_names(),
+        }
+    }
+}
+
+impl<D: SelectDom> SelectDom for Flagged<'_, D> {
+    fn kind(&self, id: u32) -> &str {
+        self.dom.kind(id)
+    }
+    fn name(&self, id: u32) -> Option<&str> {
+        self.dom.name(id)
+    }
+    fn attr(&self, id: u32, name: &str) -> Option<&str> {
+        self.dom.attr(id, name)
+    }
+    fn parent(&self, id: u32) -> Option<u32> {
+        self.dom.parent(id)
+    }
+    fn children(&self, id: u32) -> &[u32] {
+        self.dom.children(id)
+    }
+    fn text(&self, id: u32) -> String {
+        self.dom.text(id)
+    }
+    fn xml_mode(&self) -> bool {
+        self.xml
+    }
+    fn lower_case_tags(&self) -> bool {
+        self.lower_tags
+    }
+    fn lower_case_attribute_names(&self) -> bool {
+        self.lower_attributes
+    }
+    fn custom_pseudo(&self, id: u32, name: &str, argument: Option<&str>) -> Option<bool> {
+        self.dom.custom_pseudo(id, name, argument)
+    }
+    fn pseudo_alias(&self, name: &str) -> Option<&str> {
+        self.dom.pseudo_alias(name)
+    }
+    fn elements_named(&self, lowercase_name: &str) -> Option<&[u32]> {
+        self.dom.elements_named(lowercase_name)
+    }
+    fn is_id_order_document_order(&self) -> bool {
+        self.dom.is_id_order_document_order()
+    }
+}
+
 pub(crate) fn select<D: SelectDom>(
     dom: &D,
     source: &str,
     contexts: Option<&[u32]>,
 ) -> Result<Vec<u32>> {
+    select_in(&Flagged::new(dom), source, contexts)
+}
+
+/// Filter a supplied selection, applying positional pseudos to that selection.
+pub(crate) fn filter<D: SelectDom>(dom: &D, source: &str, ids: &[u32]) -> Result<Vec<u32>> {
+    filter_in(&Flagged::new(dom), source, ids)
+}
+
+fn select_in<D: SelectDom>(dom: &D, source: &str, contexts: Option<&[u32]>) -> Result<Vec<u32>> {
     let scope = contexts.unwrap_or(&[0]);
     let complexes = parse(source)?;
     // A compound over one subtree already follows DOM order. Avoid walking
@@ -1111,10 +1350,68 @@ pub(crate) fn select<D: SelectDom>(
         && complexes[0].leading.is_none()
         && scope.len() == 1;
     let mut result = Vec::new();
-    for complex in complexes {
-        validate(dom, &complex)?;
+    let mut is_ordered = complexes.len() == 1 && scope.len() == 1;
+    for complex in complexes.iter() {
+        validate(dom, complex)?;
+        if is_backward_safe(complex)? {
+            // As in Cheerio, results lie within the scope, and elements matched
+            // by earlier compounds may be the scope itself but not above it.
+            // Candidates are in document order, and each is tested once.
+            let last = complex.parts.len() - 1;
+            let mut memo = BackwardMemo::default();
+            if let Some(named) = (scope == [0] && !tag(dom, 0))
+                .then(|| elements_named_by(dom, &complex.parts[last]))
+                .flatten()
+            {
+                for id in named {
+                    if matches_backwards_within(dom, *id, complex, last, scope, None, &mut memo)? {
+                        result.push(*id);
+                    }
+                }
+                continue;
+            }
+            if scope == [0] && !tag(dom, 0) {
+                // Test each node while the walk has it in cache, without a candidate list.
+                let mut failure = None;
+                for_each_descendant(dom, 0, |id| {
+                    match matches_backwards_within(dom, id, complex, last, scope, None, &mut memo) {
+                        Ok(true) => result.push(id),
+                        Ok(false) => {}
+                        Err(error) => failure = Some(error),
+                    }
+                    failure.is_none()
+                });
+                if let Some(error) = failure {
+                    return Err(error);
+                }
+                continue;
+            }
+            let candidates = descendants(dom, scope);
+            let allowed: Option<IdSet<u32>> = (scope != [0] || tag(dom, 0))
+                .then(|| scope.iter().chain(&candidates).copied().collect());
+            for id in candidates {
+                if matches_backwards_within(
+                    dom,
+                    id,
+                    complex,
+                    last,
+                    scope,
+                    allowed.as_ref(),
+                    &mut memo,
+                )? {
+                    result.push(id);
+                }
+            }
+            continue;
+        }
+        is_ordered &= ordered_compound;
+        let named = (scope == [0] && complex.parts.len() == 1 && !tag(dom, 0))
+            .then(|| elements_named_by(dom, &complex.parts[0]))
+            .flatten();
         let mut candidates = if let Some(leading) = complex.leading {
             expand(dom, scope, leading)
+        } else if let Some(named) = named {
+            named.to_vec()
         } else {
             descendants(dom, scope)
         };
@@ -1135,17 +1432,22 @@ pub(crate) fn select<D: SelectDom>(
         }
         result.extend(current);
     }
-    if ordered_compound {
+    if is_ordered {
+        return Ok(result);
+    }
+    if dom.is_id_order_document_order() {
+        result.sort_unstable();
+        result.dedup();
         return Ok(result);
     }
-    let wanted: HashSet<u32> = result.iter().copied().collect();
+    let wanted: IdSet<u32> = result.iter().copied().collect();
     // Stable IDs are allocation IDs after mutations; obtain actual DOM order.
     let ordered = descendants(dom, &[0]);
     let mut sorted: Vec<u32> = ordered
         .into_iter()
         .filter(|id| wanted.contains(id))
         .collect();
-    let attached: HashSet<u32> = sorted.iter().copied().collect();
+    let attached: IdSet<u32> = sorted.iter().copied().collect();
     sorted.extend(
         unique(result)
             .into_iter()
@@ -1154,17 +1456,17 @@ pub(crate) fn select<D: SelectDom>(
     Ok(sorted)
 }
 
-/// Filter a supplied selection, applying positional pseudos to that selection.
-pub(crate) fn filter<D: SelectDom>(dom: &D, source: &str, ids: &[u32]) -> Result<Vec<u32>> {
-    let mut wanted = HashSet::new();
-    for complex in parse(source)? {
-        validate(dom, &complex)?;
+fn filter_in<D: SelectDom>(dom: &D, source: &str, ids: &[u32]) -> Result<Vec<u32>> {
+    let mut wanted = IdSet::default();
+    for complex in parse(source)?.iter() {
+        validate(dom, complex)?;
         let candidates = if complex.parts.len() == 1 {
             apply(dom, ids.to_vec(), &complex.parts[0], ids)?
         } else {
             let mut result = Vec::new();
+            let mut memo = BackwardMemo::default();
             for id in ids {
-                if matches_backwards(dom, *id, &complex, complex.parts.len() - 1, ids)? {
+                if matches_backwards(dom, *id, complex, complex.parts.len() - 1, ids, &mut memo)? {
                     result.push(*id);
                 }
             }

package/native/src/sink.rs

@@ -241,7 +241,20 @@ impl TreeSink for CompatibleSink {
     }
 
     fn reparent_children(&self, node: &NodeId, new_parent: &NodeId) {
-        self.0.reparent_children(node, new_parent);
+        // scraper reparents with ego_tree's `reparent_from_id_append`, which
+        // only points the first and last moved child at their new parent;
+        // the adoption agency algorithm then loses nodes moved later.
+        let mut html = self.0 .0.borrow_mut();
+        let children: Vec<NodeId> = html
+            .tree
+            .get(*node)
+            .map(|parent| parent.children().map(|child| child.id()).collect())
+            .unwrap_or_default();
+        if let Some(mut parent) = html.tree.get_mut(*new_parent) {
+            for child in children {
+                parent.append_id(child);
+            }
+        }
     }
 
     fn is_mathml_annotation_xml_integration_point(&self, handle: &NodeId) -> bool {