rusteerio 0.0.0-stage → 0.1.0

package/native/src/extraction.rs

@@ -0,0 +1,226 @@
+//! Evaluate callback-free extraction maps on native worker threads.
+
+use napi::bindgen_prelude::*;
+use serde_json::{json, Map, Value};
+
+use crate::NativeDocument;
+
+fn invalid(message: &str) -> Error {
+    Error::new(Status::InvalidArg, message.to_owned())
+}
+
+fn entries(value: &Value) -> Result<&[Value]> {
+    value
+        .get("entries")
+        .and_then(Value::as_array)
+        .map(Vec::as_slice)
+        .ok_or_else(|| invalid("Extraction plan requires entries"))
+}
+
+fn extract(
+    document: &NativeDocument,
+    plan: &[Value],
+    contexts: Option<&[u32]>,
+    depth: usize,
+) -> Result<Value> {
+    if depth > 64 {
+        return Err(invalid("Extraction plan nesting exceeds 64 levels"));
+    }
+    let mut result = Map::new();
+    for entry in plan {
+        let key = entry
+            .get("key")
+            .and_then(Value::as_str)
+            .ok_or_else(|| invalid("Extraction entry requires a key"))?;
+        let selector = entry
+            .get("selector")
+            .and_then(Value::as_str)
+            .ok_or_else(|| invalid("Extraction entry requires a selector"))?;
+        let all = entry.get("all").and_then(Value::as_bool).unwrap_or(false);
+        let value = entry
+            .get("value")
+            .ok_or_else(|| invalid("Extraction entry requires a value"))?;
+        let ids = document.select_ids(selector, contexts)?;
+        let read = |id: u32| -> Result<Value> {
+            match value.get("kind").and_then(Value::as_str) {
+                Some("map") => extract(document, entries(value)?, Some(&[id]), depth + 1),
+                Some("property") => {
+                    let name = value
+                        .get("name")
+                        .and_then(Value::as_str)
+                        .ok_or_else(|| invalid("Extraction property requires a name"))?;
+                    if name == "textContent" {
+                        return Ok(Value::String(document.text_ids(&[id])));
+                    }
+                    if matches!(name, "id" | "class" | "title" | "alt")
+                        || name.starts_with("data-")
+                        || name.starts_with("aria-")
+                        || matches!(name, "href" | "src")
+                            && document.options.get("baseURI").is_none()
+                    {
+                        return Ok(document
+                            .attribute(id, name)
+                            .map(Value::String)
+                            .unwrap_or(Value::Null));
+                    }
+                    document.ensure_arena()?;
+                    let mut arena = document.arena.borrow_mut();
+                    let arena = arena
+                        .as_mut()
+                        .ok_or_else(|| invalid("Missing native document arena"))?;
+                    if matches!(name, "name" | "type" | "nodeType") {
+                        return Ok(match arena.node(id) {
+                            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(_) => json!(1),
+                            None => Value::Null,
+                        });
+                    }
+                    crate::attributes::execute(
+                        arena,
+                        "prop",
+                        &json!({ "ids": [id], "name": name }),
+                    )?
+                    .ok_or_else(|| invalid("Unsupported extraction property"))
+                }
+                _ => Err(invalid("Unknown extraction value kind")),
+            }
+        };
+        if all {
+            let mut values = Vec::new();
+            for id in ids {
+                match read(id)? {
+                    Value::Null => {}
+                    Value::Array(items) => values.extend(items),
+                    item => values.push(item),
+                }
+            }
+            result.insert(key.into(), Value::Array(values));
+        } else if let Some(id) = ids.first() {
+            let item = read(*id)?;
+            if !item.is_null() {
+                result.insert(key.into(), item);
+            }
+        }
+    }
+    Ok(Value::Object(result))
+}
+
+pub(crate) fn execute(document: &NativeDocument, plan: &Value) -> Result<Value> {
+    if plan.get("version").and_then(Value::as_u64) != Some(1) {
+        return Err(invalid("Unsupported extraction plan version"));
+    }
+    extract(document, entries(plan)?, None, 0)
+}
+
+fn extract_arena(
+    arena: &mut crate::arena::DomArena,
+    plan: &[Value],
+    contexts: &[u32],
+    depth: usize,
+) -> Result<Value> {
+    if depth > 64 {
+        return Err(invalid("Extraction plan nesting exceeds 64 levels"));
+    }
+    let mut result = Map::new();
+    for entry in plan {
+        let key = entry
+            .get("key")
+            .and_then(Value::as_str)
+            .ok_or_else(|| invalid("Extraction entry requires a key"))?;
+        let selector = entry
+            .get("selector")
+            .and_then(Value::as_str)
+            .ok_or_else(|| invalid("Extraction entry requires a selector"))?;
+        let all = entry.get("all").and_then(Value::as_bool).unwrap_or(false);
+        let value = entry
+            .get("value")
+            .ok_or_else(|| invalid("Extraction entry requires a value"))?;
+        let ids = crate::selector::select(arena, selector, Some(contexts))?;
+        let mut read = |id| -> Result<Value> {
+            match value.get("kind").and_then(Value::as_str) {
+                Some("map") => extract_arena(arena, entries(value)?, &[id], depth + 1),
+                Some("property") => {
+                    let name = value
+                        .get("name")
+                        .and_then(Value::as_str)
+                        .ok_or_else(|| invalid("Extraction property requires a name"))?;
+                    if matches!(name, "name" | "type" | "nodeType") {
+                        return Ok(match arena.node(id) {
+                            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(_) => json!(1),
+                            None => Value::Null,
+                        });
+                    }
+                    crate::attributes::execute(arena, "prop", &json!({"ids":[id],"name":name}))?
+                        .ok_or_else(|| invalid("Unsupported extraction property"))
+                }
+                _ => Err(invalid("Unknown extraction value kind")),
+            }
+        };
+        if all {
+            let mut values = Vec::new();
+            for id in ids {
+                match read(id)? {
+                    Value::Null => {}
+                    Value::Array(items) => values.extend(items),
+                    value => values.push(value),
+                }
+            }
+            result.insert(key.into(), Value::Array(values));
+        } else if let Some(id) = ids.first() {
+            let value = read(*id)?;
+            if !value.is_null() {
+                result.insert(key.into(), value);
+            }
+        }
+    }
+    Ok(Value::Object(result))
+}
+
+/** Use the caller's active options and contexts for pure prefixes around callbacks. */
+pub(crate) fn execute_arena(
+    arena: &mut crate::arena::DomArena,
+    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_arena(arena, entries(plan)?, contexts, 0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn nested_maps_preserve_native_property_and_missing_value_semantics() {
+        let document = NativeDocument::parse_options(
+            "<section><a href='/page'>A<b>B</b></a><input checked></section><section><p>C</p></section>",
+            true,
+            json!({ "baseURI": "https://example.test/base/" }),
+            None,
+        );
+        let plan = json!({"version":1,"entries":[
+            {"key":"rows","selector":"section","all":true,"value":{"kind":"map","entries":[
+                {"key":"link","selector":"a","all":false,"value":{"kind":"property","name":"href"}},
+                {"key":"content","selector":"a","all":false,"value":{"kind":"property","name":"innerHTML"}},
+                {"key":"checked","selector":"input","all":true,"value":{"kind":"property","name":"checked"}},
+                {"key":"missing","selector":".absent","all":false,"value":{"kind":"property","name":"textContent"}}
+            ]}}
+        ]});
+        assert_eq!(
+            execute(&document, &plan).unwrap(),
+            json!({"rows":[
+                {"link":"https://example.test/page","content":"A<b>B</b>","checked":[true]},
+                {"checked":[]}
+            ]})
+        );
+    }
+}

package/native/src/gc.rs

@@ -0,0 +1,166 @@
+//! Reclaim detached native components that have no live JavaScript handles.
+use std::collections::HashMap;
+
+use crate::arena::DomArena;
+
+#[derive(Debug)]
+pub(crate) struct GcStats {
+    pub live: u32,
+    pub slots: u32,
+    pub retained: u32,
+    pub reclaimed: u32,
+    pub free: Vec<u32>,
+}
+
+#[cfg(test)]
+pub(crate) fn collect(arena: &mut DomArena, pins: &HashMap<u32, usize>) -> GcStats {
+    collect_managed(arena, pins, true)
+}
+
+pub(crate) fn collect_managed(
+    arena: &mut DomArena,
+    pins: &HashMap<u32, usize>,
+    keep_root: bool,
+) -> GcStats {
+    let mut marked = vec![false; arena.nodes.len()];
+    let mut stack = if keep_root { vec![0] } else { Vec::new() };
+    stack.extend(
+        pins.iter()
+            .filter_map(|(id, count)| (*count > 0).then_some(*id)),
+    );
+    // Following both directions marks the entire parent/child component. A
+    // held descendant keeps its detached parent and siblings navigable. The
+    // visited bitmap also bounds work for cyclic or inconsistent user graphs.
+    while let Some(id) = stack.pop() {
+        let Some(node) = arena.nodes.get(id as usize) else {
+            continue;
+        };
+        if marked[id as usize] || node.kind == "released" {
+            continue;
+        }
+        marked[id as usize] = true;
+        stack.extend(node.parent);
+        stack.extend(node.children.iter().copied());
+    }
+
+    let retained = pins
+        .iter()
+        .filter(|(id, count)| **count > 0 && marked.get(**id as usize) == Some(&true))
+        .count() as u32;
+    let mut reclaimed = 0;
+    for (index, node) in arena.nodes.iter_mut().enumerate() {
+        if marked[index] || node.kind == "released" {
+            continue;
+        }
+        reclaimed += 1;
+        node.kind = "released".into();
+        node.name = None;
+        node.data = None;
+        node.attribs = Default::default();
+        node.children = Vec::new();
+        node.extras = Default::default();
+        node.parent = None;
+        node.prev = None;
+        node.next = None;
+    }
+    while arena
+        .nodes
+        .last()
+        .is_some_and(|node| node.kind == "released")
+    {
+        arena.nodes.pop();
+    }
+    if arena.nodes.capacity() > arena.nodes.len().saturating_mul(2).saturating_add(64) {
+        arena.nodes.shrink_to_fit();
+    }
+    let free = arena
+        .nodes
+        .iter()
+        .filter(|node| node.kind == "released")
+        .map(|node| node.id)
+        .collect::<Vec<_>>();
+    GcStats {
+        live: arena.nodes.len() as u32 - free.len() as u32,
+        slots: arena.nodes.len() as u32,
+        retained,
+        reclaimed,
+        free,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::arena::DomNode;
+    use serde_json::json;
+
+    fn fixture() -> DomArena {
+        let mut nodes = vec![DomNode::new("root")];
+        nodes.extend((0..5).map(|_| DomNode::new("tag")));
+        nodes[0].children = vec![1, 5];
+        nodes[2].children = vec![3, 4];
+        nodes[2].name = Some("detached".into());
+        nodes[3].data = Some("payload".repeat(100));
+        nodes[3].attribs.insert("key".into(), json!("value"));
+        nodes[3].extras.insert("data".into(), json!({"held":true}));
+        DomArena::from_records(nodes, json!({}))
+    }
+
+    #[test]
+    fn held_detached_child_preserves_its_parent_and_sibling() {
+        let mut arena = fixture();
+        let stats = collect(&mut arena, &HashMap::from([(3, 2)]));
+        assert_eq!(
+            (stats.live, stats.slots, stats.retained, stats.reclaimed),
+            (6, 6, 1, 0)
+        );
+        assert!(stats.free.is_empty());
+        assert_eq!(arena.nodes[3].parent, Some(2));
+        assert_eq!(arena.nodes[3].next, Some(4));
+        assert_eq!(arena.nodes[2].children, vec![3, 4]);
+    }
+
+    #[test]
+    fn unpinned_payloads_are_cleared_and_trailing_slots_trimmed() {
+        let mut arena = fixture();
+        let stats = collect(&mut arena, &HashMap::new());
+        assert_eq!((stats.live, stats.slots, stats.reclaimed), (3, 6, 3));
+        assert_eq!(stats.free, vec![2, 3, 4]);
+        let node = &arena.nodes[3];
+        assert_eq!(node.kind, "released");
+        assert!(node.data.is_none() && node.name.is_none());
+        assert!(node.attribs.is_empty() && node.children.is_empty() && node.extras.is_empty());
+        assert!(node.parent.is_none() && node.prev.is_none() && node.next.is_none());
+        arena.detach(5);
+        let stats = collect(&mut arena, &HashMap::from([(5, 0)]));
+        assert_eq!(
+            (stats.live, stats.slots, stats.retained, stats.reclaimed),
+            (2, 2, 0, 1)
+        );
+        assert!(stats.free.is_empty());
+        assert_eq!(collect(&mut arena, &HashMap::new()).reclaimed, 0);
+    }
+
+    #[test]
+    fn cyclic_components_are_marked_once() {
+        let mut arena = fixture();
+        arena.nodes[2].parent = Some(3);
+        arena.nodes[3].children.push(2);
+        let stats = collect(&mut arena, &HashMap::from([(3, 1)]));
+        assert_eq!((stats.live, stats.retained, stats.reclaimed), (6, 1, 0));
+        let stats = collect(&mut arena, &HashMap::new());
+        assert_eq!(stats.reclaimed, 3);
+    }
+
+    #[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);
+        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");
+        assert_eq!(arena.nodes[2].name.as_deref(), Some("detached"));
+        assert_eq!(arena.nodes[3].parent, Some(2));
+        assert_eq!(arena.nodes[3].next, Some(4));
+    }
+}