nokolexbor 0.6.4 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3615acd25f6233c5701c91d25ef6c94a73adf2de8433e2e1b6b3aa215f0581ab
-  data.tar.gz: ad3e9f8134a7f26924b2283a2ac10a8dfae2f5684dd650be5903faf069f595ef
+  metadata.gz: f479dae3741e343ff292ef23b69fb31697f149b1e799b5eed26c2626ff5b9909
+  data.tar.gz: 35e0a468a1c9c94283271e66abd98663ce4ad9699613c4dea70df82f4d91e99b
 SHA512:
-  metadata.gz: 2d84f341a6b3e1c4dcc8501ab9772e4376bc8c9acf2441753253c331ca381ff161c95cbb93f32568aada6ac03e3bedb01343bbc507d5201c468884f286008228
-  data.tar.gz: f8a85acb4fdd063714316490289bae356a731931aa8c4202a80f677b70d2f02258f69991e0d996cfaadf80dbcad8c505c61b4a6a91456514bbc972e0d7861148
+  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/builder.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Nokolexbor
+  # A DSL for programmatically building HTML documents.
+  #
+  # == No-arg block (instance_eval style) – tag names are called bare:
+  #
+  #   Nokolexbor do
+  #     body do
+  #       h1 'Hello world'
+  #       p 'This little p'
+  #       ul do
+  #         li 'Go to market'
+  #         li 'Go to bed'
+  #       end
+  #     end
+  #   end
+  #
+  # == Block-parameter style – tag names are called on the builder argument:
+  #
+  #   Nokolexbor::Builder.new do |b|
+  #     b.body do
+  #       b.h1 'Hello world'
+  #     end
+  #   end
+  #
+  # == Building into an existing node:
+  #
+  #   Nokolexbor::Builder.with(existing_node) do
+  #     span 'injected'
+  #   end
+  #
+  class Builder
+    # The Document used to create new nodes
+    attr_accessor :doc
+
+    # The node that currently receives new children
+    attr_accessor :parent
+
+    # Arity of the outermost block (drives instance_eval vs yield dispatch)
+    attr_accessor :arity
+
+    # A context object for use when the block has no arguments
+    attr_accessor :context
+
+    # Build into an existing +root+ node.
+    def self.with(root, &block)
+      new(root, &block)
+    end
+
+    # @param root [Node, nil]
+    #   When given, new nodes are appended under +root+ and +root.document+
+    #   is used as the owning document.  When omitted a fresh {Document} and
+    #   a {DocumentFragment} container are created.
+    def initialize(root = nil, &block)
+      if root
+        @doc    = root.document
+        @parent = root
+      else
+        @doc    = Document.new
+        @parent = DocumentFragment.new(@doc)
+      end
+
+      @context = nil
+      @arity   = nil
+
+      return unless block
+
+      @arity = block.arity
+      if @arity <= 0
+        # Capture outer self so that outer methods / ivars remain accessible
+        # via method_missing delegation while the builder acts as self.
+        @context = eval("self", block.binding)
+        instance_eval(&block)
+      else
+        yield self
+      end
+    end
+
+    # Insert a Text node containing +string+.
+    def text(string)
+      insert(@doc.create_text_node(string))
+    end
+
+    # Insert a CDATA node containing +string+.
+    def cdata(string)
+      insert(@doc.create_cdata(string))
+    end
+
+    # Insert a Comment node containing +string+.
+    def comment(string)
+      insert(@doc.create_comment(string))
+    end
+
+    # Append raw HTML (parsed into nodes) under the current parent.
+    def <<(string)
+      @doc.fragment(string).children.each { |x| insert(x) }
+    end
+
+    # Serialize the built content to an HTML string.
+    def to_html
+      @parent.to_html
+    end
+    alias_method :to_s, :to_html
+
+    # Ruby's Kernel#p, Kernel#pp, etc. are defined on Object and therefore on
+    # Builder itself.  They must be overridden so they fall through to
+    # method_missing and create the corresponding HTML element instead of
+    # printing values to stdout.
+    def p(*args, &block) # :nodoc:
+      method_missing(:p, *args, &block)
+    end
+
+    def method_missing(method, *args, &block) # :nodoc:
+      # Only delegate to the outer context for methods the user defined there.
+      # Standard Object / Kernel methods (like :p, :pp, :puts …) must not be
+      # forwarded to @context because all objects respond to them, which would
+      # bypass element creation entirely.
+      if @context && !OBJECT_INSTANCE_METHODS.include?(method) && @context.respond_to?(method)
+        @context.send(method, *args, &block)
+      else
+        node = @doc.create_element(method.to_s.sub(/[_!]$/, ""), *args)
+        insert(node, &block)
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false) # :nodoc:
+      (@context && !OBJECT_INSTANCE_METHODS.include?(method) && @context.respond_to?(method)) || super
+    end
+
+    # Methods defined on plain Object that should never be forwarded to @context
+    # as HTML element creation fallbacks.
+    OBJECT_INSTANCE_METHODS = Object.instance_methods.to_set.freeze
+
+    private
+
+    # Add +node+ as a child of @parent; if a block is given, push @parent
+    # to +node+ for the duration of that block, then restore it.
+    # Returns a {NodeBuilder} for the inserted node so attributes / classes
+    # can be chained: <tt>div.container.hero!</tt>
+    def insert(node, &block)
+      node = @parent.add_child(node)
+      if block
+        old_parent = @parent
+        @parent    = node
+        @arity   ||= block.arity
+        begin
+          if @arity <= 0
+            instance_eval(&block)
+          else
+            yield(self)
+          end
+        ensure
+          @parent = old_parent
+        end
+      end
+      NodeBuilder.new(node, self)
+    end
+
+    # Wraps a built node and exposes a fluent API for setting classes and ids:
+    #
+    #   div.container        # => <div class="container">
+    #   div.box.highlight    # => <div class="box highlight">
+    #   div.thing!           # => <div id="thing">
+    #   div.container.hero!  # => <div class="container" id="hero">
+    #
+    class NodeBuilder # :nodoc:
+      def initialize(node, doc_builder)
+        @node        = node
+        @doc_builder = doc_builder
+      end
+
+      def []=(k, v)
+        @node[k] = v
+      end
+
+      def [](k)
+        @node[k]
+      end
+
+      def method_missing(method, *args, &block)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+
+        case method.to_s
+        when /^(.*)!$/
+          @node["id"]  = Regexp.last_match(1)
+          @node.content = args.first if args.first
+        when /^(.*)=$/
+          @node[Regexp.last_match(1)] = args.first
+        else
+          @node["class"] =
+            ((@node["class"] || "").split(/\s/) + [method.to_s]).join(" ")
+          @node.content = args.first if args.first
+        end
+
+        opts.each do |k, v|
+          @node[k.to_s] = ((@node[k.to_s] || "").split(/\s/) + [v.to_s]).join(" ")
+        end
+
+        if block
+          old_parent           = @doc_builder.parent
+          @doc_builder.parent  = @node
+          arity = @doc_builder.arity || block.arity
+          value = if arity <= 0
+            @doc_builder.instance_eval(&block)
+          else
+            yield(@doc_builder)
+          end
+          @doc_builder.parent = old_parent
+          return value
+        end
+
+        self
+      end
+
+      def respond_to_missing?(_method, _include_private = false) # :nodoc:
+        true
+      end
+    end
+  end
+end

data/lib/nokolexbor/version.rb

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

data/lib/nokolexbor.rb

@@ -28,11 +28,23 @@ require 'nokolexbor/node_set'
 require 'nokolexbor/document_fragment'
 require 'nokolexbor/xpath'
 require 'nokolexbor/xpath_context'
+require 'nokolexbor/builder'
 
 module Nokolexbor
   class << self
-    def HTML(*args)
+    def parse(*args)
       Document.parse(*args)
     end
+
+    alias_method :HTML, :parse
+  end
+end
+
+# Parse an HTML document, or build one with the DSL when a block is given.
+def Nokolexbor(string_or_io = nil, &block)
+  if block
+    Nokolexbor::Builder.new(&block).parent
+  else
+    Nokolexbor.parse(string_or_io)
   end
 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,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: nokolexbor
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.8.0
 platform: ruby
 authors:
 - Yicheng Zhou
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -120,6 +119,7 @@ files:
 - ext/nokolexbor/xml_tree.c
 - ext/nokolexbor/xml_xpath.c
 - lib/nokolexbor.rb
+- lib/nokolexbor/builder.rb
 - lib/nokolexbor/document.rb
 - lib/nokolexbor/document_fragment.rb
 - lib/nokolexbor/node.rb
@@ -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
@@ -523,7 +524,6 @@ licenses:
 - MIT
 metadata:
   msys2_mingw_dependencies: cmake
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -538,8 +538,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: High-performance HTML5 parser, with support for both CSS selectors and XPath.
 test_files: []