nokolexbor 0.2.0

data/lib/nokolexbor/attribute.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Nokolexbor
+  class Attribute
+    attr_accessor :name
+    attr_accessor :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    alias_method :text, :value
+    alias_method :content, :value
+    alias_method :to_s, :value
+    alias_method :to_str, :value
+  end
+end

data/lib/nokolexbor/document.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Nokolexbor
+  class Document < Node
+  end
+end

data/lib/nokolexbor/node.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Nokolexbor
+  class Node
+    include Enumerable
+
+    ELEMENT_NODE = 1
+    ATTRIBUTE_NODE = 2
+    TEXT_NODE = 3
+    CDATA_SECTION_NODE = 4
+    ENTITY_REF_NODE = 5
+    ENTITY_NODE = 6
+    PI_NODE = 7
+    COMMENT_NODE = 8
+    DOCUMENT_NODE = 9
+    DOCUMENT_TYPE_NODE = 10
+    DOCUMENT_FRAG_NODE = 11
+    NOTATION_NODE = 12
+
+    attr_reader :document
+
+    LOOKS_LIKE_XPATH = %r{^(\./|/|\.\.|\.$)}
+
+    def comment?
+      type == COMMENT_NODE
+    end
+
+    def cdata?
+      type == CDATA_SECTION_NODE
+    end
+
+    def processing_instruction?
+      type == PI_NODE
+    end
+
+    def text?
+      type == TEXT_NODE
+    end
+
+    def fragment?
+      type == DOCUMENT_FRAG_NODE
+    end
+
+    def element?
+      type == ELEMENT_NODE
+    end
+
+    def ancestors(selector = nil)
+      return NodeSet.new(@document) unless respond_to?(:parent)
+      return NodeSet.new(@document) unless parent
+
+      parents = [parent]
+
+      while parents.last.respond_to?(:parent)
+        break unless (ctx_parent = parents.last.parent)
+
+        parents << ctx_parent
+      end
+
+      return NodeSet.new(@document, parents) unless selector
+
+      root = parents.last
+      search_results = root.search(selector)
+
+      NodeSet.new(@document, parents.find_all do |parent|
+        search_results.include?(parent)
+      end)
+    end
+
+    def matches?(selector)
+      ancestors.last.css(selector).any? { |node| node == self }
+    end
+
+    def attribute(name)
+      return nil unless key?(name)
+      Attribute.new(name, attr(name))
+    end
+
+    def attributes
+      attrs.map { |k, v| [k, Attribute.new(k, v)] }.to_h
+    end
+
+    def replace(node)
+      if node.is_a?(NodeSet)
+        node.each { |n| add_sibling(:previous, n) }
+      else
+        add_sibling(:previous, node)
+      end
+      remove
+    end
+
+    def children=(node)
+      children.remove
+      if node.is_a?(NodeSet)
+        node.each { |n| add_child(n) }
+      else
+        add_child(node)
+      end
+    end
+
+    def each
+      attributes.each do |node|
+        yield [node.name, node.value]
+      end
+    end
+
+    alias_method :inner_html=, :children=
+
+    def css(*args)
+      css_impl(args.join(', '))
+    end
+
+    def at_css(*args)
+      at_css_impl(args.join(', '))
+    end
+
+    def xpath(*args)
+      paths, handler, ns, binds = extract_params(args)
+
+      xpath_internal(self, paths, handler, ns, binds)
+    end
+
+    def at_xpath(*args)
+      xpath(*args).first
+    end
+
+    def search(*args)
+      paths, handler, ns, binds = extract_params(args)
+
+      if paths.size == 1 && !LOOKS_LIKE_XPATH.match?(paths.first)
+        return css(paths.first)
+      end
+
+      xpath(*(paths + [ns, handler, binds].compact))
+    end
+
+    alias_method :/, :search
+
+    def at(*args)
+      paths, handler, ns, binds = extract_params(args)
+
+      if paths.size == 1 && !LOOKS_LIKE_XPATH.match?(paths.first)
+        return at_css(paths.first)
+      end
+
+      at_xpath(*(paths + [ns, handler, binds].compact))
+    end
+
+    alias_method :%, :at
+
+    def classes
+      kwattr_values("class")
+    end
+
+    def add_class(names)
+      kwattr_add("class", names)
+    end
+
+    def append_class(names)
+      kwattr_append("class", names)
+    end
+
+    def remove_class(names = nil)
+      kwattr_remove("class", names)
+    end
+
+    def kwattr_values(attribute_name)
+      keywordify(attr(attribute_name) || [])
+    end
+
+    def kwattr_add(attribute_name, keywords)
+      keywords = keywordify(keywords)
+      current_kws = kwattr_values(attribute_name)
+      new_kws = (current_kws + (keywords - current_kws)).join(" ")
+      set_attr(attribute_name, new_kws)
+      self
+    end
+
+    def kwattr_append(attribute_name, keywords)
+      keywords = keywordify(keywords)
+      current_kws = kwattr_values(attribute_name)
+      new_kws = (current_kws + keywords).join(" ")
+      set_attr(attribute_name, new_kws)
+      self
+    end
+
+    def kwattr_remove(attribute_name, keywords)
+      if keywords.nil?
+        remove_attr(attribute_name)
+        return self
+      end
+
+      keywords = keywordify(keywords)
+      current_kws = kwattr_values(attribute_name)
+      new_kws = current_kws - keywords
+      if new_kws.empty?
+        remove_attr(attribute_name)
+      else
+        set_attr(attribute_name, new_kws.join(" "))
+      end
+      self
+    end
+
+    def keywordify(keywords)
+      case keywords
+      when Enumerable
+        keywords
+      when String
+        keywords.scan(/\S+/)
+      else
+        raise ArgumentError,
+          "Keyword attributes must be passed as either a String or an Enumerable, but received #{keywords.class}"
+      end
+    end
+
+    private
+
+    def xpath_internal(node, paths, handler, ns, binds)
+      # document = node.document
+      # return NodeSet.new(document) unless document
+
+      if paths.length == 1
+        return xpath_impl(node, paths.first, handler, ns, binds)
+      end
+
+      NodeSet.new(@document) do |combined|
+        paths.each do |path|
+          xpath_impl(node, path, handler, ns, binds).each { |set| combined << set }
+        end
+      end
+    end
+
+    def xpath_impl(node, path, handler, ns, binds)
+      ctx = XPathContext.new(node)
+      ctx.register_namespaces(ns)
+      # path = path.gsub(/xmlns:/, " :") unless Nokogiri.uses_libxml?
+
+      binds&.each do |key, value|
+        ctx.register_variable(key.to_s, value)
+      end
+
+      ctx.evaluate(path, handler)
+    end
+
+    def extract_params(params)
+      handler = params.find do |param|
+        ![Hash, String, Symbol].include?(param.class)
+      end
+      params -= [handler] if handler
+
+      hashes = []
+      while Hash === params.last || params.last.nil?
+        hashes << params.pop
+        break if params.empty?
+      end
+      ns, binds = hashes.reverse
+
+      # ns ||= (document.root&.namespaces || {})
+      ns ||= {}
+
+      [params, handler, ns, binds]
+    end
+  end
+end

data/lib/nokolexbor/node_set.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Nokolexbor
+  class NodeSet < Node
+    include Enumerable
+
+    def initialize(document, list = [])
+      @document = document
+      list.each { |x| self << x }
+      yield self if block_given?
+    end
+
+    def each
+      return to_enum unless block_given?
+
+      0.upto(length - 1) do |x|
+        yield self[x]
+      end
+      self
+    end
+
+    def first(n = nil)
+      return self[0] unless n
+
+      list = []
+      [n, length].min.times { |i| list << self[i] }
+      list
+    end
+
+    def last
+      self[-1]
+    end
+
+    def empty?
+      length == 0
+    end
+
+    def index(node = nil)
+      if node
+        each_with_index { |member, j| return j if member == node }
+      elsif block_given?
+        each_with_index { |member, j| return j if yield(member) }
+      end
+      nil
+    end
+
+    def content
+      self.map(&:content).join
+    end
+
+    alias_method :text, :content
+    alias_method :inner_text, :content
+    alias_method :to_str, :content
+
+    def inner_html
+      self.map(&:inner_html).join
+    end
+
+    def outer_html
+      self.map(&:outer_html).join
+    end
+
+    alias_method :to_s, :outer_html
+    alias_method :to_html, :outer_html
+
+    def remove
+      self.each(&:remove)
+    end
+
+    alias_method :destroy, :remove
+    alias_method :to_ary, :to_a
+
+    def pop
+      return nil if length == 0
+
+      delete(last)
+    end
+
+    def shift
+      return nil if length == 0
+
+      delete(first)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(NodeSet)
+      return false unless length == other.length
+
+      each_with_index do |node, i|
+        return false unless node == other[i]
+      end
+      true
+    end
+
+    def children
+      node_set = NodeSet.new(@document)
+      each do |node|
+        node.children.each { |n| node_set.push(n) }
+      end
+      node_set
+    end
+
+    def reverse
+      node_set = NodeSet.new(@document)
+      (length - 1).downto(0) do |x|
+        node_set.push(self[x])
+      end
+      node_set
+    end
+
+    def xpath(*args)
+      paths, handler, ns, binds = extract_params(args)
+
+      NodeSet.new(@document) do |set|
+        each do |node|
+          node.send(:xpath_internal, node, paths, handler, ns, binds).each do |inner_node|
+            set << inner_node
+          end
+        end
+      end
+    end
+      
+  end
+end

data/lib/nokolexbor/version.rb

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

data/lib/nokolexbor/xpath_context.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Nokolexbor
+  class XPathContext
+    ###
+    # Register namespaces in +namespaces+
+    def register_namespaces(namespaces)
+      namespaces.each do |k, v|
+        k = k.to_s.gsub(/.*:/, "") # strip off 'xmlns:' or 'xml:'
+        register_ns(k, v)
+      end
+    end
+  end
+end

data/lib/nokolexbor.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'nokolexbor/nokolexbor'
+require 'nokolexbor/version'
+require 'nokolexbor/node'
+require 'nokolexbor/document'
+require 'nokolexbor/node_set'
+require 'nokolexbor/attribute'
+require 'nokolexbor/xpath_context'
+
+module Nokolexbor
+  class << self
+    def HTML(*args)
+      Document.parse(*args)
+    end
+  end
+end

data/patches/0001-lexbor-support-text-pseudo-element.patch

@@ -0,0 +1,137 @@
+diff --git i/source/lexbor/css/selectors/pseudo_const.h w/source/lexbor/css/selectors/pseudo_const.h
+index 2b19f18..5e56181 100644
+--- i/source/lexbor/css/selectors/pseudo_const.h
++++ w/source/lexbor/css/selectors/pseudo_const.h
+@@ -95,7 +95,8 @@ typedef enum {
+     LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SELECTION          = 0x000a,
+     LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SPELLING_ERROR     = 0x000b,
+     LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TARGET_TEXT        = 0x000c,
+-    LXB_CSS_SELECTOR_PSEUDO_ELEMENT__LAST_ENTRY        = 0x000d
++    LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TEXT               = 0x000d,
++    LXB_CSS_SELECTOR_PSEUDO_ELEMENT__LAST_ENTRY        = 0x000e
+ }
+ lxb_css_selector_pseudo_element_id_t;
+ 
+diff --git i/source/lexbor/css/selectors/pseudo_res.h w/source/lexbor/css/selectors/pseudo_res.h
+index 398d1bb..b35bfab 100644
+--- i/source/lexbor/css/selectors/pseudo_res.h
++++ w/source/lexbor/css/selectors/pseudo_res.h
+@@ -124,7 +124,8 @@ static const lxb_css_selectors_pseudo_data_t lxb_css_selectors_pseudo_data_pseud
+     {(lxb_char_t *) "placeholder", 11, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_PLACEHOLDER},
+     {(lxb_char_t *) "selection", 9, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SELECTION},
+     {(lxb_char_t *) "spelling-error", 14, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SPELLING_ERROR},
+-    {(lxb_char_t *) "target-text", 11, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TARGET_TEXT}
++    {(lxb_char_t *) "target-text", 11, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TARGET_TEXT},
++    {(lxb_char_t *) "text", 4, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TEXT}
+ };
+ 
+ static const lxb_css_selectors_pseudo_data_func_t lxb_css_selectors_pseudo_data_pseudo_element_function[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FUNCTION__LAST_ENTRY] = 
+@@ -268,7 +269,7 @@ static const lexbor_shs_entry_t lxb_css_selectors_pseudo_element_shs[24] =
+     {"placeholder", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_PLACEHOLDER], 11, 0}, 
+     {"after", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_AFTER], 5, 0}, 
+     {"first-letter", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FIRST_LETTER], 12, 0}, 
+-    {NULL, NULL, 0, 0}, 
++    {"text", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TEXT], 4, 0}, 
+     {NULL, NULL, 0, 0}, 
+     {"grammar-error", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_GRAMMAR_ERROR], 13, 0}, 
+     {"before", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_BEFORE], 6, 0}, 
+diff --git i/source/lexbor/selectors/selectors.c w/source/lexbor/selectors/selectors.c
+index c2d18ea..84b5b14 100644
+--- i/source/lexbor/selectors/selectors.c
++++ w/source/lexbor/selectors/selectors.c
+@@ -156,6 +156,12 @@ lxb_selectors_descendant(lxb_selectors_t *selectors, lxb_selectors_entry_t *entr
+         {
+             return node;
+         }
++        else if (selector->type == LXB_CSS_SELECTOR_TYPE_PSEUDO_ELEMENT &&
++            node->type == LXB_DOM_NODE_TYPE_TEXT &&
++            lxb_selectors_pseudo_element(selectors, selector, node))
++        {
++            return node;
++        }
+ 
+         if (node->first_child != NULL) {
+             node = node->first_child;
+@@ -201,6 +207,12 @@ lxb_selectors_descendant_next(lxb_selectors_t *selectors, lxb_selectors_entry_t
+         {
+             return node;
+         }
++        else if (selector->type == LXB_CSS_SELECTOR_TYPE_PSEUDO_ELEMENT &&
++            node->type == LXB_DOM_NODE_TYPE_TEXT &&
++            lxb_selectors_pseudo_element(selectors, selector, node))
++        {
++            return node;
++        }
+     }
+     while (true);
+ }
+@@ -229,6 +241,12 @@ lxb_selectors_child(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry,
+         {
+             return node;
+         }
++        else if (selector->type == LXB_CSS_SELECTOR_TYPE_PSEUDO_ELEMENT &&
++            node->type == LXB_DOM_NODE_TYPE_TEXT &&
++            lxb_selectors_pseudo_element(selectors, selector, node))
++        {
++            return node;
++        }
+ 
+         node = node->next;
+     }
+@@ -249,6 +267,12 @@ lxb_selectors_child_next(lxb_selectors_t *selectors, lxb_selectors_entry_t *entr
+         {
+             return node;
+         }
++        else if (selector->type == LXB_CSS_SELECTOR_TYPE_PSEUDO_ELEMENT &&
++            node->type == LXB_DOM_NODE_TYPE_TEXT &&
++            lxb_selectors_pseudo_element(selectors, selector, node))
++        {
++            return node;
++        }
+ 
+         node = node->next;
+     }
+@@ -262,6 +286,8 @@ lxb_selectors_sibling(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry,
+ {
+     node = node->next;
+ 
++    if (node == NULL) return NULL;
++
+     do {
+         if (node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
+             if (lxb_selectors_match(selectors, entry, selector, node)) {
+@@ -290,6 +316,12 @@ lxb_selectors_following(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry
+         {
+             return node;
+         }
++        else if (selector->type == LXB_CSS_SELECTOR_TYPE_PSEUDO_ELEMENT &&
++            node->type == LXB_DOM_NODE_TYPE_TEXT &&
++            lxb_selectors_pseudo_element(selectors, selector, node))
++        {
++            return node;
++        }
+ 
+         node = node->next;
+     }
+@@ -1429,6 +1461,8 @@ lxb_selectors_pseudo_element(lxb_selectors_t *selectors,
+     lxb_css_selector_pseudo_t *pseudo = &selector->u.pseudo;
+ 
+     switch (pseudo->type) {
++        case LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TEXT:
++            return node->local_name == LXB_TAG__TEXT;
+         case LXB_CSS_SELECTOR_PSEUDO_ELEMENT_AFTER:
+         case LXB_CSS_SELECTOR_PSEUDO_ELEMENT_BACKDROP:
+         case LXB_CSS_SELECTOR_PSEUDO_ELEMENT_BEFORE:
+diff --git i/utils/lexbor/css/selectors/pseudo.py w/utils/lexbor/css/selectors/pseudo.py
+index 57e2b7b..bf3bc01 100755
+--- i/utils/lexbor/css/selectors/pseudo.py
++++ w/utils/lexbor/css/selectors/pseudo.py
+@@ -49,7 +49,7 @@ pseudo_elements = [
+     # https://drafts.csswg.org/css-pseudo-4/#index
+     "after", "before", "first-letter", "first-line", "grammar-error",
+     "inactive-selection", "marker", "placeholder", "selection",
+-    "spelling-error", "target-text",
++    "spelling-error", "target-text", "text",
+ 
+     # https://fullscreen.spec.whatwg.org/#index
+     "backdrop"

data/patches/0002-lexbor-match-id-class-case-sensitive.patch

@@ -0,0 +1,22 @@
+diff --git i/source/lexbor/selectors/selectors.c w/source/lexbor/selectors/selectors.c
+index c2d18ea..84b5b14 100644
+--- i/source/lexbor/selectors/selectors.c
++++ w/source/lexbor/selectors/selectors.c
+@@ -751,7 +783,7 @@ lxb_selectors_match(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry,
+             src = &selector->name;
+ 
+             if (trg->length == src->length
+-                && lexbor_str_data_ncasecmp(trg->data, src->data, src->length))
++                && lexbor_str_data_ncmp(trg->data, src->data, src->length))
+             {
+                 return true;
+             }
+@@ -766,7 +798,7 @@ lxb_selectors_match(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry,
+             }
+ 
+             return lxb_selectors_match_class(element->attr_class->value,
+-                                             &selector->name, true);
++                                             &selector->name, false);
+ 
+         case LXB_CSS_SELECTOR_TYPE_ATTRIBUTE:
+             element = lxb_dom_interface_element(node);

data/patches/0003-lexbor-attach-template-content-to-self.patch

@@ -0,0 +1,13 @@
+diff --git i/source/lexbor/html/interfaces/template_element.c w/source/lexbor/html/interfaces/template_element.c
+index 884fede..29c1e69 100755
+--- i/source/lexbor/html/interfaces/template_element.c
++++ w/source/lexbor/html/interfaces/template_element.c
+@@ -29,6 +29,8 @@ lxb_html_template_element_interface_create(lxb_html_document_t *document)
+         return lxb_html_template_element_interface_destroy(element);
+     }
+ 
++    lxb_dom_node_insert_child(&element->element.element.node, &element->content->node);
++
+     element->content->node.ns = LXB_NS_HTML;
+     element->content->host = lxb_dom_interface_element(element);
+