nokolexbor 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb6fea4008f68e39df01fbc3920634bd747f6c6e58605876b4600b6037745d4a
-  data.tar.gz: 38f67c6e320e95d35a82db68f34b08e7103fa8d56e52fe6e59ebdeb266701c16
+  metadata.gz: f479dae3741e343ff292ef23b69fb31697f149b1e799b5eed26c2626ff5b9909
+  data.tar.gz: 35e0a468a1c9c94283271e66abd98663ce4ad9699613c4dea70df82f4d91e99b
 SHA512:
-  metadata.gz: a44ba9da124b17e58ae2abc8c6e99cfab22edbdcdff5b07e9636838f28098a4716aa6f50cf7282c1f15fcbb0630b7bd5ef814b54cb7886dd75b16a864e496405
-  data.tar.gz: 40fcdc69521d2f985be5fa62addf3f4fd03ac577eeb66878f496dbc684fc3925ceddb9fa2f74a870188431c672b16394ccc6c58303caae6c6718af8e978bc967
+  metadata.gz: 1b7c6cb9015d9b4540fb79e3fb04afb484a072f914f2480caa65f81fb66a077c099b8cbc81026aa9c8f1b4fc960ce57d9d2c17e1b1982de0f85a70c35e77cff9
+  data.tar.gz: 6bc107899aae62a756a84944579442fe482cece4375b49bd59a1061525d5e9a590e74308a08758b0effb6190c0f6f9920db5f6bceef43bf1caa4e8c413e68aca

data/ext/nokolexbor/nl_node.c

@@ -237,9 +237,23 @@ nl_node_content_set(VALUE self, VALUE content)
 
   const char *c_content = StringValuePtr(content);
   size_t content_len = RSTRING_LEN(content);
-  lxb_status_t status = lxb_dom_node_text_content_set(node, (const lxb_char_t *)c_content, content_len);
-  if (status != LXB_STATUS_OK) {
-    nl_raise_lexbor_error(status);
+
+  if (node->type == LXB_DOM_NODE_TYPE_DOCUMENT_FRAGMENT || node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
+    lxb_dom_text_t *text = lxb_dom_document_create_text_node(node->owner_document, (const lxb_char_t *)c_content, content_len);
+    if (text == NULL) {
+      nl_raise_lexbor_error(LXB_STATUS_ERROR_MEMORY_ALLOCATION);
+    }
+
+    // Ruby wrappers may still reference replaced nodes, so detach rather than destroy them.
+    while (node->first_child != NULL) {
+      lxb_dom_node_remove(node->first_child);
+    }
+    lxb_dom_node_insert_child(node, lxb_dom_interface_node(text));
+  } else {
+    lxb_status_t status = lxb_dom_node_text_content_set(node, (const lxb_char_t *)c_content, content_len);
+    if (status != LXB_STATUS_OK) {
+      nl_raise_lexbor_error(status);
+    }
   }
   return content;
 }
@@ -561,12 +575,19 @@ static VALUE
 nl_node_inner_html(int argc, VALUE *argv, VALUE self)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  lxb_dom_node_t *serialization_root = node;
   lexbor_str_t str = {0};
   VALUE options;
   lxb_status_t status;
   size_t indent = 0;
   rb_scan_args(argc, argv, "01", &options);
 
+  if (node->type == LXB_DOM_NODE_TYPE_ELEMENT
+      && node->local_name == LXB_TAG_TEMPLATE
+      && node->ns == LXB_NS_HTML) {
+    serialization_root = &lxb_html_interface_template(node)->content->node;
+  }
+
   if (TYPE(options) == T_HASH) {
     VALUE rb_indent = rb_hash_aref(options, ID2SYM(rb_intern("indent")));
     if (!NIL_P(rb_indent)) {
@@ -574,9 +595,9 @@ nl_node_inner_html(int argc, VALUE *argv, VALUE self)
     }
   }
   if (indent > 0) {
-    status = lxb_html_serialize_pretty_deep_str(node, 0, 0, &str);
+    status = lxb_html_serialize_pretty_deep_str(serialization_root, 0, 0, &str);
   } else {
-    status = lxb_html_serialize_deep_str(node, &str);
+    status = lxb_html_serialize_deep_str(serialization_root, &str);
   }
   if (status != LXB_STATUS_OK) {
     if (str.data != NULL) {
@@ -921,6 +942,13 @@ nl_node_equals(VALUE self, VALUE other)
   return node1 == node2 ? Qtrue : Qfalse;
 }
 
+static VALUE
+nl_node_pointer_id(VALUE self)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  return ULL2NUM((unsigned long long)(uintptr_t)node);
+}
+
 const lxb_char_t *
 lxb_dom_node_name_qualified(lxb_dom_node_t *node, size_t *len)
 {
@@ -951,7 +979,7 @@ nl_node_parse_fragment(lxb_dom_document_t *doc, lxb_dom_element_t *element, lxb_
   size_t tag_name_len;
   lxb_html_document_t *html_doc = lxb_html_interface_document(doc);
   if (element == NULL) {
-    const lxb_char_t *tag_name = lxb_tag_name_by_id(lxb_html_document_tags(html_doc), LXB_TAG__UNDEF, &tag_name_len);
+    const lxb_char_t *tag_name = lxb_tag_name_by_id(lxb_html_document_tags(html_doc), LXB_TAG_TEMPLATE, &tag_name_len);
     if (tag_name == NULL) {
       rb_raise(rb_eRuntimeError, "Error getting tag name");
     }
@@ -1241,6 +1269,7 @@ void Init_nl_node(void)
   rb_define_method(cNokolexborNode, "[]=", nl_node_set_attr, 2);
   rb_define_method(cNokolexborNode, "remove_attr", nl_node_remove_attr, 1);
   rb_define_method(cNokolexborNode, "==", nl_node_equals, 1);
+  rb_define_method(cNokolexborNode, "pointer_id", nl_node_pointer_id, 0);
   rb_define_method(cNokolexborNode, "css_impl", nl_node_css, 1);
   rb_define_method(cNokolexborNode, "at_css_impl", nl_node_at_css, 1);
   rb_define_method(cNokolexborNode, "inner_html", nl_node_inner_html, -1);
@@ -1289,4 +1318,6 @@ void Init_nl_node(void)
   rb_define_alias(cNokolexborNode, "unlink", "remove");
   rb_define_alias(cNokolexborNode, "type", "node_type");
   rb_define_alias(cNokolexborNode, "dup", "clone");
+  rb_define_alias(cNokolexborNode, "eql?", "==");
+  rb_define_alias(cNokolexborNode, "hash", "pointer_id");
 }

data/ext/nokolexbor/xml_xpath.c

@@ -7998,7 +7998,7 @@ nl_xmlXPathNextParent(xmlXPathParserContextPtr ctxt, lxb_dom_node_t_ptr cur) {
             case LXB_DOM_NODE_TYPE_ATTRIBUTE: {
 		lxb_dom_attr_t_ptr att = (lxb_dom_attr_t_ptr) ctxt->context->node;
 
-		return(att->node.parent);
+		return((lxb_dom_node_t_ptr) att->owner);
 	    }
             case LXB_DOM_NODE_TYPE_DOCUMENT:
             case LXB_DOM_NODE_TYPE_DOCUMENT_TYPE:
@@ -8068,7 +8068,7 @@ nl_xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, lxb_dom_node_t_ptr cur) {
             case LXB_DOM_NODE_TYPE_ATTRIBUTE: {
 		lxb_dom_attr_t_ptr tmp = (lxb_dom_attr_t_ptr) ctxt->context->node;
 
-		return(tmp->node.parent);
+		return((lxb_dom_node_t_ptr) tmp->owner);
 	    }
             case LXB_DOM_NODE_TYPE_DOCUMENT:
             case LXB_DOM_NODE_TYPE_DOCUMENT_TYPE:
@@ -8235,7 +8235,7 @@ nl_xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, lxb_dom_node_t_ptr cur)
     if (cur == NULL) {
         cur = ctxt->context->node;
         if (cur->type == LXB_DOM_NODE_TYPE_ATTRIBUTE) {
-            cur = cur->parent;
+            cur = (lxb_dom_node_t_ptr)((lxb_dom_attr_t *)cur)->owner;
         } else if (cur->type == XML_NAMESPACE_DECL) {
             xmlNsPtr ns = (xmlNsPtr) cur;
 
@@ -8305,7 +8305,7 @@ nl_xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, lxb_dom_node_t_ptr cur)
     if (cur == NULL) {
         cur = ctxt->context->node;
         if (cur->type == LXB_DOM_NODE_TYPE_ATTRIBUTE) {
-            cur = cur->parent;
+            cur = (lxb_dom_node_t_ptr)((lxb_dom_attr_t *)cur)->owner;
         } else if (cur->type == XML_NAMESPACE_DECL) {
             xmlNsPtr ns = (xmlNsPtr) cur;
 
@@ -8359,7 +8359,7 @@ xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
         if (cur == NULL)
             return (NULL);
         if (cur->type == LXB_DOM_NODE_TYPE_ATTRIBUTE) {
-            cur = cur->parent;
+            cur = (lxb_dom_node_t_ptr)((lxb_dom_attr_t *)cur)->owner;
         } else if (cur->type == XML_NAMESPACE_DECL) {
             xmlNsPtr ns = (xmlNsPtr) cur;
 
@@ -8452,9 +8452,22 @@ nl_xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, lxb_dom_node_t_ptr cur)
     if (cur == NULL) {
         if (ctxt->context->node == (lxb_dom_node_t_ptr) ctxt->context->doc)
 	    return(NULL);
-        return (lxb_dom_node_t_ptr)lxb_dom_element_first_attribute((lxb_dom_element_t *)ctxt->context->node);
+        cur = (lxb_dom_node_t_ptr)lxb_dom_element_first_attribute((lxb_dom_element_t *)ctxt->context->node);
+    } else {
+        cur = (lxb_dom_node_t_ptr)(((lxb_dom_attr_t *)cur)->next);
+    }
+    /*
+     * In Lexbor, attr->owner is not set during tree construction.
+     * Set it here so axis traversal functions that need to find the
+     * owning element (preceding::, following::, ancestor::, parent::)
+     * can use attr->owner when attributes are context nodes.
+     */
+    if (cur != NULL) {
+        lxb_dom_attr_t *attr = (lxb_dom_attr_t *)cur;
+        if (attr->owner == NULL)
+            attr->owner = (lxb_dom_element_t *)ctxt->context->node;
     }
-    return (lxb_dom_node_t_ptr)(((lxb_dom_attr_t *)cur)->next);
+    return cur;
 }
 
 /************************************************************************

data/lib/nokolexbor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nokolexbor
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/patches/0006-lexbor-fix-sibling-combinator-in-pseudo-class-functions.patch

@@ -0,0 +1,174 @@
+diff --git a/source/lexbor/selectors/selectors.c b/source/lexbor/selectors/selectors.c
+index 37b825e..3fec327 100644
+--- a/source/lexbor/selectors/selectors.c
++++ b/source/lexbor/selectors/selectors.c
+@@ -87,6 +87,16 @@ static lxb_status_t
+ lxb_selectors_first_match(lxb_dom_node_t *node,
+                           lxb_css_selector_specificity_t *spec, void *ctx);
+ 
++static bool
++lxb_selectors_match_chain_rtl(lxb_selectors_t *selectors,
++                              lxb_css_selector_t *selector,
++                              lxb_dom_node_t *node);
++
++static bool
++lxb_selectors_match_node_rtl(lxb_selectors_t *selectors,
++                             lxb_dom_node_t *node,
++                             lxb_css_selector_list_t *list);
++
+ 
+ lxb_selectors_t *
+ lxb_selectors_create(void)
+@@ -1254,6 +1264,106 @@ lxb_selectors_pseudo_class(lxb_css_selector_t *selector, lxb_dom_node_t *node)
+     return false;
+ }
+ 
++/*
++ * Recursively match a selector chain (right-to-left) anchored at `node`,
++ * with backtracking: when a combinator has multiple candidate elements
++ * (descendant, following sibling), each candidate is tried until the rest
++ * of the chain matches.
++ */
++static bool
++lxb_selectors_match_chain_rtl(lxb_selectors_t *selectors,
++                              lxb_css_selector_t *selector,
++                              lxb_dom_node_t *node)
++{
++    lxb_css_selector_t *prev;
++    lxb_dom_node_t *cur;
++    lxb_selectors_entry_t tmp_entry;
++
++    memset(&tmp_entry, 0, sizeof(tmp_entry));
++    tmp_entry.selector = selector;
++
++    if (!lxb_selectors_match(selectors, &tmp_entry, selector, node)) {
++        return false;
++    }
++
++    prev = selector->prev;
++    if (prev == NULL) {
++        return true;
++    }
++
++    switch (selector->combinator) {
++        case LXB_CSS_SELECTOR_COMBINATOR_CLOSE:
++            /* Same node - check prev selector on same element. */
++            return lxb_selectors_match_chain_rtl(selectors, prev, node);
++
++        case LXB_CSS_SELECTOR_COMBINATOR_DESCENDANT:
++            /* node is a descendant of prev - try each ancestor. */
++            for (cur = node->parent; cur != NULL; cur = cur->parent) {
++                if (cur->type == LXB_DOM_NODE_TYPE_ELEMENT
++                    && lxb_selectors_match_chain_rtl(selectors, prev, cur))
++                {
++                    return true;
++                }
++            }
++            return false;
++
++        case LXB_CSS_SELECTOR_COMBINATOR_CHILD:
++            /* node is a child of prev - check parent. */
++            cur = node->parent;
++            return cur != NULL
++                   && cur->type == LXB_DOM_NODE_TYPE_ELEMENT
++                   && lxb_selectors_match_chain_rtl(selectors, prev, cur);
++
++        case LXB_CSS_SELECTOR_COMBINATOR_SIBLING:
++            /* node is adjacent to prev (+) - preceding element. */
++            cur = node->prev;
++            while (cur != NULL && cur->type != LXB_DOM_NODE_TYPE_ELEMENT) {
++                cur = cur->prev;
++            }
++            return cur != NULL
++                   && lxb_selectors_match_chain_rtl(selectors, prev, cur);
++
++        case LXB_CSS_SELECTOR_COMBINATOR_FOLLOWING:
++            /* node follows prev (~) - try each preceding sibling. */
++            for (cur = node->prev; cur != NULL; cur = cur->prev) {
++                if (cur->type == LXB_DOM_NODE_TYPE_ELEMENT
++                    && lxb_selectors_match_chain_rtl(selectors, prev, cur))
++                {
++                    return true;
++                }
++            }
++            return false;
++
++        default:
++            return false;
++    }
++}
++
++/*
++ * Match a node against a selector list using right-to-left evaluation.
++ * This is needed for :not(), :is(), :where() etc. where we test a specific
++ * node against a selector that may contain sibling/following combinators.
++ *
++ * The left-to-right algorithm (lxb_selectors_next) can't correctly test
++ * whether a node matches "A ~ B" because it searches forward from the node
++ * for A, but A should be BEFORE the node.
++ */
++static bool
++lxb_selectors_match_node_rtl(lxb_selectors_t *selectors,
++                             lxb_dom_node_t *node,
++                             lxb_css_selector_list_t *list)
++{
++    while (list != NULL) {
++        if (lxb_selectors_match_chain_rtl(selectors, list->last, node)) {
++            return true;
++        }
++
++        list = list->next;
++    }
++
++    return false;
++}
++
+ static bool
+ lxb_selectors_pseudo_class_function(lxb_selectors_t *selectors,
+                                     lxb_css_selector_t *selector,
+@@ -1268,14 +1378,7 @@ lxb_selectors_pseudo_class_function(lxb_selectors_t *selectors,
+ 
+     switch (pseudo->type) {
+         case LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_CURRENT:
+-            entry->child = lxb_selectors_next(selectors, node, entry->child,
+-                                              pseudo->data,
+-                                              lxb_selectors_first_match, &found);
+-            if (entry->child == NULL) {
+-                return false;
+-            }
+-
+-            return found;
++            return lxb_selectors_match_node_rtl(selectors, node, pseudo->data);
+ 
+         case LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_DIR:
+             break;
+@@ -1291,27 +1394,13 @@ lxb_selectors_pseudo_class_function(lxb_selectors_t *selectors,
+             return found;
+ 
+         case LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_IS:
+-            entry->child = lxb_selectors_next(selectors, node, entry->child,
+-                                              pseudo->data,
+-                                              lxb_selectors_first_match, &found);
+-            if (entry->child == NULL) {
+-                return false;
+-            }
+-
+-            return found;
++            return lxb_selectors_match_node_rtl(selectors, node, pseudo->data);
+ 
+         case LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_LANG:
+             break;
+ 
+         case LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NOT:
+-            entry->child = lxb_selectors_next(selectors, node, entry->child,
+-                                              pseudo->data,
+-                                              lxb_selectors_first_match, &found);
+-            if (entry->child == NULL) {
+-                return false;
+-            }
+-
+-            return !found;
++            return !lxb_selectors_match_node_rtl(selectors, node, pseudo->data);
+ 
+         case LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_CHILD:
+             index = 0;

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: nokolexbor
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Yicheng Zhou
 bindir: bin
 cert_chain: []
-date: 2026-03-25 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -132,6 +132,7 @@ files:
 - patches/0003-lexbor-attach-template-content-to-self.patch
 - patches/0004-lexbor-fix-template-clone.patch
 - patches/0005-lexbor-add-source-location-to-node.patch
+- patches/0006-lexbor-fix-sibling-combinator-in-pseudo-class-functions.patch
 - vendor/lexbor/CMakeLists.txt
 - vendor/lexbor/config.cmake
 - vendor/lexbor/feature.cmake
@@ -537,7 +538,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
 summary: High-performance HTML5 parser, with support for both CSS selectors and XPath.
 test_files: []