rusteerio 1.0.0 → 1.1.0

package/native/src/extraction.rs

@@ -64,7 +64,7 @@ fn extract(
                             .unwrap_or(Value::Null));
                     }
                     document.ensure_arena()?;
-                    let mut arena = document.arena.borrow_mut();
+                    let mut arena = document.arena_for_write();
                     let arena = arena
                         .as_mut()
                         .ok_or_else(|| invalid("Missing native document arena"))?;
@@ -73,7 +73,7 @@ fn extract(
                             Some(node) if name == "name" => {
                                 node.name.clone().map(Value::String).unwrap_or(Value::Null)
                             }
-                            Some(node) if name == "type" => Value::String(node.kind.clone()),
+                            Some(node) if name == "type" => Value::String(node.kind.to_string()),
                             Some(_) => json!(1),
                             None => Value::Null,
                         });
@@ -115,6 +115,18 @@ pub(crate) fn execute(document: &NativeDocument, plan: &Value) -> Result<Value>
     extract(document, entries(plan)?, None, 0)
 }
 
+/// Extracts relative to `contexts`, reading the parse tree while it is unchanged.
+pub(crate) fn execute_in(
+    document: &NativeDocument,
+    plan: &Value,
+    contexts: &[u32],
+) -> Result<Value> {
+    if plan.get("version").and_then(Value::as_u64) != Some(1) {
+        return Err(invalid("Unsupported extraction plan version"));
+    }
+    extract(document, entries(plan)?, Some(contexts), 0)
+}
+
 fn extract_arena(
     arena: &mut crate::arena::DomArena,
     plan: &[Value],
@@ -152,7 +164,7 @@ fn extract_arena(
                             Some(node) if name == "name" => {
                                 node.name.clone().map(Value::String).unwrap_or(Value::Null)
                             }
-                            Some(node) if name == "type" => Value::String(node.kind.clone()),
+                            Some(node) if name == "type" => Value::String(node.kind.to_string()),
                             Some(_) => json!(1),
                             None => Value::Null,
                         });

package/native/src/gc.rs

@@ -14,16 +14,20 @@ pub(crate) struct GcStats {
 
 #[cfg(test)]
 pub(crate) fn collect(arena: &mut DomArena, pins: &HashMap<u32, usize>) -> GcStats {
-    collect_managed(arena, pins, true)
+    collect_managed(arena, pins, true, 0)
 }
 
+/// Reclaims nodes connected to neither a pin, the root (with `keep_root`)
+/// nor a slot below `keep_below`.
 pub(crate) fn collect_managed(
     arena: &mut DomArena,
     pins: &HashMap<u32, usize>,
     keep_root: bool,
+    keep_below: u32,
 ) -> GcStats {
     let mut marked = vec![false; arena.nodes.len()];
-    let mut stack = if keep_root { vec![0] } else { Vec::new() };
+    let mut stack: Vec<u32> = if keep_root { vec![0] } else { Vec::new() };
+    stack.extend(0..keep_below.min(arena.nodes.len() as u32));
     stack.extend(
         pins.iter()
             .filter_map(|(id, count)| (*count > 0).then_some(*id)),
@@ -59,6 +63,9 @@ pub(crate) fn collect_managed(
         node.attribs = Default::default();
         node.children = Vec::new();
         node.extras = Default::default();
+        node.namespace = None;
+        node.attribs_namespace = None;
+        node.attribs_prefix = None;
         node.parent = None;
         node.prev = None;
         node.next = None;
@@ -79,6 +86,8 @@ pub(crate) fn collect_managed(
         .filter(|node| node.kind == "released")
         .map(|node| node.id)
         .collect::<Vec<_>>();
+    arena.detached_since_collection = 0;
+    arena.collected_live = arena.nodes.len() as u32 - free.len() as u32;
     GcStats {
         live: arena.nodes.len() as u32 - free.len() as u32,
         slots: arena.nodes.len() as u32,
@@ -155,7 +164,7 @@ mod tests {
     #[test]
     fn managed_detached_handle_does_not_retain_the_original_document() {
         let mut arena = fixture();
-        let stats = collect_managed(&mut arena, &HashMap::from([(3, 1)]), false);
+        let stats = collect_managed(&mut arena, &HashMap::from([(3, 1)]), false, 0);
         assert_eq!((stats.live, stats.retained, stats.reclaimed), (3, 1, 3));
         assert_eq!(arena.nodes[0].kind, "released");
         assert_eq!(arena.nodes[1].kind, "released");

package/native/src/hook_sink.rs

@@ -1,7 +1,7 @@
 //! An active user-supplied tree adapter. Rust runs the HTML5 algorithm; the
 //! adapter supplies every construction, mutation and tree-inspection decision.
 use std::borrow::Cow;
-use std::cell::{Ref, RefCell};
+use std::cell::{Cell, Ref, RefCell};
 use std::collections::HashMap;
 use std::rc::Rc;
 
@@ -196,6 +196,26 @@ struct HookSink {
     context: Option<Rc<crate::diagnostics::DiagnosticContext>>,
     diagnostics: RefCell<Vec<Value>>,
     locations: Option<crate::tracker::Locations<u32>>,
+    pending_escape: Cell<Option<TextTarget>>,
+}
+
+/// Where a text chunk is inserted: appended to `parent`, or before `sibling`.
+#[derive(Clone, Copy, PartialEq, Eq)]
+struct TextTarget {
+    parent: u32,
+    sibling: Option<u32>,
+}
+
+/// Whether the final character is a codec escape whose character has not
+/// arrived yet. Escapes pair with the following character.
+fn ends_with_unpaired_escape(text: &str) -> bool {
+    let mut chars = text.chars();
+    while let Some(ch) = chars.next() {
+        if ch == crate::codec::ESCAPE && chars.next().is_none() {
+            return true;
+        }
+    }
+    false
 }
 
 impl HookSink {
@@ -203,6 +223,17 @@ impl HookSink {
         if self.error.borrow().is_some() {
             return Value::Null;
         }
+        if matches!(
+            method,
+            "appendChild"
+                | "insertBefore"
+                | "detachNode"
+                | "setDocumentType"
+                | "setTemplateContent"
+                | "__snapshot"
+        ) {
+            self.flush_escape();
+        }
         let result = self.bridge.call(method, args);
         match result {
             Ok(value) => value,
@@ -215,6 +246,38 @@ impl HookSink {
     fn node(&self, method: &str, args: Value) -> u32 {
         self.call(method, args).as_u64().unwrap_or(0) as u32
     }
+    /// The tokenizer may split a codec escape from its character across text
+    /// chunks. Adapters decode each chunk separately, so a trailing escape is
+    /// held until the next chunk for the same target.
+    fn insert_text(&self, target: TextTarget, text: &str) {
+        let mut data = String::with_capacity(text.len() + crate::codec::ESCAPE.len_utf8());
+        if let Some(pending) = self.pending_escape.take() {
+            if pending == target {
+                data.push(crate::codec::ESCAPE);
+            } else {
+                self.send_text(pending, &crate::codec::ESCAPE.to_string());
+            }
+        }
+        data.push_str(text);
+        if ends_with_unpaired_escape(&data) {
+            data.pop();
+            self.pending_escape.set(Some(target));
+        }
+        if !data.is_empty() {
+            self.send_text(target, &data);
+        }
+    }
+    fn send_text(&self, target: TextTarget, data: &str) {
+        match target.sibling {
+            None => self.call("insertText", json!([target.parent, data])),
+            Some(sibling) => self.call("insertTextBefore", json!([target.parent, data, sibling])),
+        };
+    }
+    fn flush_escape(&self) {
+        if let Some(pending) = self.pending_escape.take() {
+            self.send_text(pending, &crate::codec::ESCAPE.to_string());
+        }
+    }
     fn attrs(attrs: Vec<Attribute>) -> Value {
         Value::Array(
             attrs
@@ -463,7 +526,11 @@ impl TreeSink for HookSink {
                 }
             }
             NodeOrText::AppendText(text) => {
-                self.call("insertText", json!([parent, text.as_ref()]));
+                let target = TextTarget {
+                    parent: *parent,
+                    sibling: None,
+                };
+                self.insert_text(target, text.as_ref());
                 self.mark_text(*parent, None, text.as_ref());
             }
         }
@@ -530,7 +597,11 @@ impl TreeSink for HookSink {
                 self.call("insertBefore", json!([parent, node, sibling]));
             }
             NodeOrText::AppendText(text) => {
-                self.call("insertTextBefore", json!([parent, text.as_ref(), sibling]));
+                let target = TextTarget {
+                    parent,
+                    sibling: Some(*sibling),
+                };
+                self.insert_text(target, text.as_ref());
                 self.mark_text(parent, Some(*sibling), text.as_ref());
             }
         }
@@ -589,6 +660,7 @@ fn parser(
         context: None,
         diagnostics: RefCell::new(Vec::new()),
         locations: None,
+        pending_escape: Cell::new(None),
     };
     sink.call(
         if is_document {
@@ -659,6 +731,7 @@ pub(crate) fn parse(
             diagnostics: RefCell::new(Vec::new()),
             locations: (options.get("sourceCodeLocationInfo") == Some(&Value::Bool(true)))
                 .then(|| crate::tracker::Locations::new(context.clone())),
+            pending_escape: Cell::new(None),
         };
         sink.call(
             if is_document {
@@ -706,6 +779,7 @@ where
         diagnostics: RefCell::new(Vec::new()),
         locations: (options.get("sourceCodeLocationInfo") == Some(&Value::Bool(true)))
             .then(|| crate::tracker::Locations::new(context.clone())),
+        pending_escape: Cell::new(None),
     };
     sink.call(
         if is_document {

package/native/src/id_hash.rs

@@ -0,0 +1,42 @@
+//! A fast hasher for maps keyed by node ids. The default SipHash resists
+//! adversarial keys, which tree-assigned ids cannot be, at several times the cost.
+use std::collections::{HashMap, HashSet};
+use std::hash::{BuildHasherDefault, Hasher};
+
+const SEED: u64 = 0x51_7c_c1_b7_27_22_0a_95;
+
+#[derive(Default, Clone, Copy)]
+pub(crate) struct IdHasher(u64);
+
+impl IdHasher {
+    fn add(&mut self, value: u64) {
+        self.0 = (self.0.rotate_left(5) ^ value).wrapping_mul(SEED);
+    }
+}
+
+impl Hasher for IdHasher {
+    fn finish(&self) -> u64 {
+        self.0
+    }
+    fn write(&mut self, bytes: &[u8]) {
+        let (chunks, remainder) = bytes.as_chunks::<8>();
+        for chunk in chunks {
+            self.add(u64::from_le_bytes(*chunk));
+        }
+        for byte in remainder {
+            self.add(u64::from(*byte));
+        }
+    }
+    fn write_u32(&mut self, value: u32) {
+        self.add(u64::from(value));
+    }
+    fn write_u64(&mut self, value: u64) {
+        self.add(value);
+    }
+    fn write_usize(&mut self, value: usize) {
+        self.add(value as u64);
+    }
+}
+
+pub(crate) type IdMap<K, V> = HashMap<K, V, BuildHasherDefault<IdHasher>>;
+pub(crate) type IdSet<K> = HashSet<K, BuildHasherDefault<IdHasher>>;

package/native/src/immutable.rs

@@ -0,0 +1,256 @@
+//! Read-only selection over a parsed document. Queries, matching and ordering
+//! run on the parse tree, so a document is copied into the mutable arena only
+//! when it is first changed.
+use ego_tree::iter::Edge;
+use ego_tree::NodeId;
+use scraper::{Html, Node};
+use serde_json::Value;
+
+use crate::selector::SelectDom;
+
+const NONE: u32 = u32::MAX;
+
+/// Parent and child links by local id. Local ids are preorder positions, so
+/// ascending order is document order.
+pub(crate) struct TreeIndex {
+    parent: Vec<u32>,
+    child_start: Vec<u32>,
+    child_end: Vec<u32>,
+    children: Vec<u32>,
+}
+
+impl TreeIndex {
+    pub(crate) fn build(html: &Html, count: usize) -> Self {
+        let mut parent = vec![NONE; count];
+        let mut stack: Vec<u32> = Vec::new();
+        let mut next = 0u32;
+        for edge in html.tree.root().traverse() {
+            match edge {
+                Edge::Open(_) => {
+                    if (next as usize) < count {
+                        parent[next as usize] = stack.last().copied().unwrap_or(NONE);
+                    }
+                    stack.push(next);
+                    next += 1;
+                }
+                Edge::Close(_) => {
+                    stack.pop();
+                }
+            }
+        }
+        let mut counts = vec![0u32; count];
+        for parent in &parent {
+            if let Some(slot) = counts.get_mut(*parent as usize) {
+                *slot += 1;
+            }
+        }
+        let mut total = 0u32;
+        let child_start: Vec<u32> = counts
+            .iter()
+            .map(|count| {
+                let start = total;
+                total += count;
+                start
+            })
+            .collect();
+        let mut child_end = child_start.clone();
+        let mut children = vec![0u32; total as usize];
+        for (local, parent) in parent.iter().enumerate() {
+            if let Some(end) = child_end.get_mut(*parent as usize) {
+                children[*end as usize] = local as u32;
+                *end += 1;
+            }
+        }
+        Self {
+            parent,
+            child_start,
+            child_end,
+            children,
+        }
+    }
+
+    /// The index of a tree some of whose nodes were detached after parsing,
+    /// when traversal order no longer matches local ids.
+    pub(crate) fn build_mapped(
+        html: &Html,
+        ids: &[NodeId],
+        reverse: &crate::id_hash::IdMap<NodeId, u32>,
+    ) -> Self {
+        let local = |node: Option<ego_tree::NodeRef<'_, Node>>| {
+            node.and_then(|node| reverse.get(&node.id()).copied())
+        };
+        let mut parent = vec![NONE; ids.len()];
+        let mut child_start = vec![0u32; ids.len()];
+        let mut child_end = vec![0u32; ids.len()];
+        let mut children = Vec::with_capacity(ids.len());
+        for (index, id) in ids.iter().enumerate() {
+            let Some(node) = html.tree.get(*id) else {
+                continue;
+            };
+            parent[index] = local(node.parent()).unwrap_or(NONE);
+            child_start[index] = children.len() as u32;
+            children.extend(node.children().filter_map(|child| local(Some(child))));
+            child_end[index] = children.len() as u32;
+        }
+        Self {
+            parent,
+            child_start,
+            child_end,
+            children,
+        }
+    }
+
+    pub(crate) fn parent(&self, id: u32) -> Option<u32> {
+        self.parent
+            .get(id as usize)
+            .copied()
+            .filter(|parent| *parent != NONE)
+    }
+
+    pub(crate) fn children(&self, id: u32) -> &[u32] {
+        match (
+            self.child_start.get(id as usize),
+            self.child_end.get(id as usize),
+        ) {
+            (Some(start), Some(end)) => &self.children[*start as usize..*end as usize],
+            _ => &[],
+        }
+    }
+
+    /// Whether `ancestor` is a proper ancestor of `id`.
+    pub(crate) fn contains(&self, ancestor: u32, id: u32) -> bool {
+        let mut current = self.parent(id);
+        while let Some(node) = current {
+            if node == ancestor {
+                return true;
+            }
+            current = self.parent(node);
+        }
+        false
+    }
+}
+
+/// The parse tree seen through the same interface as the mutable arena.
+pub(crate) struct TreeDom<'a> {
+    pub html: &'a Html,
+    pub ids: &'a [NodeId],
+    pub index: &'a TreeIndex,
+    pub options: &'a Value,
+}
+
+impl TreeDom<'_> {
+    fn node(&self, id: u32) -> Option<ego_tree::NodeRef<'_, Node>> {
+        self.html.tree.get(*self.ids.get(id as usize)?)
+    }
+
+    /// The value the arena would hold: attributes are keyed by local name and
+    /// a repeated local name keeps its last value.
+    pub(crate) fn element_attr(&self, id: u32, name: &str) -> Option<&str> {
+        match self.node(id)?.value() {
+            Node::Element(element) => element
+                .attrs
+                .iter()
+                .rev()
+                .find(|(key, _)| key.local.as_ref() == name)
+                .map(|(_, value)| value.as_ref()),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn is_element(&self, id: u32) -> bool {
+        matches!(
+            self.node(id).map(|node| node.value()),
+            Some(Node::Element(_))
+        )
+    }
+}
+
+impl SelectDom for TreeDom<'_> {
+    fn kind(&self, id: u32) -> &str {
+        match self.node(id).map(|node| node.value()) {
+            Some(Node::Element(element)) => match element.name() {
+                "script" => "script",
+                "style" => "style",
+                _ => "tag",
+            },
+            Some(Node::Text(_)) => "text",
+            Some(Node::Comment(_)) => "comment",
+            Some(Node::Doctype(_) | Node::ProcessingInstruction(_)) => "directive",
+            Some(Node::Document | Node::Fragment) => "root",
+            None => "",
+        }
+    }
+    fn name(&self, id: u32) -> Option<&str> {
+        match self.node(id)?.value() {
+            Node::Element(element) => Some(element.name()),
+            Node::Doctype(_) => Some("!doctype"),
+            Node::ProcessingInstruction(instruction) => Some(&instruction.target),
+            _ => None,
+        }
+    }
+    fn attr(&self, id: u32, name: &str) -> Option<&str> {
+        self.element_attr(id, name)
+    }
+    fn parent(&self, id: u32) -> Option<u32> {
+        self.index.parent(id)
+    }
+    fn children(&self, id: u32) -> &[u32] {
+        self.index.children(id)
+    }
+    fn text(&self, id: u32) -> String {
+        let mut output = String::new();
+        let mut stack = vec![id];
+        while let Some(id) = stack.pop() {
+            match self.node(id).map(|node| node.value()) {
+                Some(Node::Text(text)) => output.push_str(text),
+                Some(_) => stack.extend(self.index.children(id).iter().rev().copied()),
+                None => {}
+            }
+        }
+        output
+    }
+    fn xml_mode(&self) -> bool {
+        crate::arena::xml_mode(self.options)
+    }
+    fn lower_case_tags(&self) -> bool {
+        self.options
+            .get("lowerCaseTags")
+            .and_then(Value::as_bool)
+            .unwrap_or(!self.xml_mode())
+    }
+    fn lower_case_attribute_names(&self) -> bool {
+        self.options
+            .get("lowerCaseAttributeNames")
+            .and_then(Value::as_bool)
+            .unwrap_or(!self.xml_mode())
+    }
+    fn custom_pseudo(&self, id: u32, name: &str, arg: Option<&str>) -> Option<bool> {
+        let key = format!("{}({})", name, arg.unwrap_or(""));
+        self.options
+            .get("__pseudoMatches")?
+            .get(&key)?
+            .as_array()
+            .map(|ids| ids.iter().any(|value| value.as_u64() == Some(id as u64)))
+    }
+    fn pseudo_alias(&self, name: &str) -> Option<&str> {
+        self.options.get("pseudos")?.get(name)?.as_str()
+    }
+}
+
+/// Whether a class attribute contains `needle` as a whitespace-separated token,
+/// exactly as the arena's `hasClass` reads it.
+pub(crate) fn has_class_token(classes: &str, needle: &str) -> bool {
+    !needle.is_empty()
+        && classes.match_indices(needle).any(|(index, _)| {
+            (index == 0
+                || classes[..index]
+                    .chars()
+                    .next_back()
+                    .is_some_and(char::is_whitespace))
+                && (index + needle.len() == classes.len()
+                    || classes[index + needle.len()..]
+                        .chars()
+                        .next()
+                        .is_some_and(char::is_whitespace))
+        })
+}