nokolexbor 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0055757bc7b9a92e9a2d37235722ca6a6945fb438855880ce10055dfa10d0fcb
-  data.tar.gz: b42cb00bc57ac3db09e928ff0b4ae3b3f7fb950312ab64f2606436184785dcc0
+  metadata.gz: 48a8709af6c858df3d9fc1e3de0254f1d44ab308722eabe05a376ecd047eb7ec
+  data.tar.gz: 5bc0dea72106ead6c1382ef37a730f4b5e7d8ddf273380ef31e37d4d22394106
 SHA512:
-  metadata.gz: 5527c86fea7d9efbbea6bcc1a2fcaaad506057ccf2d22d689f0de143b6c142f9bd1e8b33686ed2be1d01c37c1b02879c35e392a0ca81489f7f9cb125e569bf33
-  data.tar.gz: 4af797ac972b1ddfaafceec1ded5de2541daa92a366568f768f63f978bf3215e9a03295f598f4e05eea253aa2af8098ff8de33431119e7aeecad8a223de0c6f4
+  metadata.gz: a025216fbd78c4b399b0938b4750d1eba72b3ed7e78d511222497a94ae904e8ed04a607641ab7d3dc4002d15763b47f4b8a4631575f82be022e6a719e08d0a7d
+  data.tar.gz: 61a219e89f430b2d726b8a676674fc9c5dfa924c8e75e878ba4637a135b04c25dc3cb3cc8e9a437cc6c8fc8099ede8fb14d506766c40df1bba5261e5fbabeb56

data/ext/nokolexbor/libxml/tree.h

@@ -22,6 +22,11 @@
 extern "C" {
 #endif
 
+static size_t tmp_len;
+#define NODE_NAME(node) lxb_dom_node_name_qualified((node), &tmp_len)
+#define NODE_NS_HREF(node) ((node)->prefix ? lxb_ns_by_id((node)->owner_document->ns, (node)->ns, &tmp_len) : NULL)
+#define NODE_NS_PREFIX(node) lxb_ns_by_id((node)->owner_document->prefix, (node)->prefix, &tmp_len)
+
 /*
  * Some of the basic types pointer to structures:
  */
@@ -918,7 +923,7 @@ XMLPUBFUN long XMLCALL
 		xmlGetLineNo		(const xmlNode *node);
 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
 XMLPUBFUN xmlChar * XMLCALL
-		xmlGetNodePath		(const xmlNode *node);
+		nl_xmlGetNodePath		(const lxb_dom_node_t *node);
 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
 XMLPUBFUN lxb_dom_node_t_ptr XMLCALL
 		nl_xmlDocGetRootElement	(const lxb_dom_document_t *doc);

data/ext/nokolexbor/nl_node.c

@@ -1,4 +1,5 @@
 #include "nokolexbor.h"
+#include "libxml/tree.h"
 
 #define SORT_NAME nl_css_result
 #define SORT_TYPE lxb_dom_node_t *
@@ -871,6 +872,9 @@ nl_node_destroy(VALUE self)
 static VALUE
 nl_node_equals(VALUE self, VALUE other)
 {
+  if (!rb_obj_is_kind_of(other, cNokolexborNode)) {
+    return false;
+  }
   lxb_dom_node_t *node1 = nl_rb_node_unwrap(self);
   lxb_dom_node_t *node2 = nl_rb_node_unwrap(other);
   return node1 == node2 ? Qtrue : Qfalse;
@@ -1141,6 +1145,22 @@ nl_node_source_location(VALUE self)
   return ULONG2NUM(node->source_location);
 }
 
+/**
+ * @return [String] The path associated with this Node.
+ */
+static VALUE
+nl_node_path(VALUE self)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  char* path = nl_xmlGetNodePath(node);
+  if (path == NULL) {
+    return Qnil;
+  }
+  VALUE ret = rb_utf8_str_new_cstr(path);
+  nl_xmlFree(path);
+  return ret;
+}
+
 void Init_nl_node(void)
 {
   cNokolexborNode = rb_define_class_under(mNokolexbor, "Node", rb_cObject);
@@ -1186,6 +1206,7 @@ void Init_nl_node(void)
   rb_define_method(cNokolexborNode, "clone", nl_node_clone, 0);
   rb_define_method(cNokolexborNode, "inspect", nl_node_inspect, -1);
   rb_define_method(cNokolexborNode, "source_location", nl_node_source_location, 0);
+  rb_define_method(cNokolexborNode, "path", nl_node_path, 0);
 
   rb_define_alias(cNokolexborNode, "attr", "[]");
   rb_define_alias(cNokolexborNode, "get_attribute", "[]");
@@ -1195,6 +1216,7 @@ void Init_nl_node(void)
   rb_define_alias(cNokolexborNode, "delete", "remove_attr");
   rb_define_alias(cNokolexborNode, "elements", "element_children");
   rb_define_alias(cNokolexborNode, "remove_attribute", "remove_attr");
+  rb_define_alias(cNokolexborNode, "node_name", "name");
   rb_define_alias(cNokolexborNode, "text", "content");
   rb_define_alias(cNokolexborNode, "inner_text", "content");
   rb_define_alias(cNokolexborNode, "to_str", "content");

data/ext/nokolexbor/xml_tree.c

@@ -157,4 +157,228 @@ nl_xmlDocGetRootElement(const lxb_dom_document_t *doc) {
 void
 nl_xmlFreeNodeList(lxb_dom_node_t_ptr cur) {
     // Should never be called
+}
+
+/**
+ * xmlGetNodePath:
+ * @node: a node
+ *
+ * Build a structure based Path for the given node
+ *
+ * Returns the new path or NULL in case of error. The caller must free
+ *     the returned string
+ */
+xmlChar *
+nl_xmlGetNodePath(const lxb_dom_node_t *node)
+{
+    const lxb_dom_node_t *cur, *tmp, *next;
+    xmlChar *buffer = NULL, *temp;
+    size_t buf_len;
+    xmlChar *buf;
+    const char *sep;
+    const char *name;
+    char nametemp[100];
+    int occur = 0, generic;
+
+    if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
+        return (NULL);
+
+    buf_len = 500;
+    buffer = (xmlChar *) nl_xmlMallocAtomic(buf_len);
+    if (buffer == NULL) {
+	xmlTreeErrMemory("getting node path");
+        return (NULL);
+    }
+    buf = (xmlChar *) nl_xmlMallocAtomic(buf_len);
+    if (buf == NULL) {
+	xmlTreeErrMemory("getting node path");
+        nl_xmlFree(buffer);
+        return (NULL);
+    }
+
+    buffer[0] = 0;
+    cur = node;
+    do {
+        name = "";
+        sep = "?";
+        occur = 0;
+        const lxb_char_t* cur_name = NODE_NAME(cur);
+        const lxb_char_t* cur_ns_prefix = NODE_NS_PREFIX(cur);
+        if ((cur->type == LXB_DOM_NODE_TYPE_DOCUMENT) ||
+            (cur->type == XML_HTML_DOCUMENT_NODE)) {
+            if (buffer[0] == '/')
+                break;
+            sep = "/";
+            next = NULL;
+        } else if (cur->type == LXB_DOM_NODE_TYPE_ELEMENT) {
+	    generic = 0;
+            sep = "/";
+            name = (const char *) cur_name;
+            next = cur->parent;
+
+            /*
+             * Thumbler index computation
+	     * TODO: the occurrence test seems bogus for namespaced names
+             */
+            tmp = cur->prev;
+            while (tmp != NULL) {
+                if ((tmp->type == LXB_DOM_NODE_TYPE_ELEMENT) &&
+		    (generic ||
+		     (nl_xmlStrEqual(cur_name, NODE_NAME(tmp)) &&
+		     ((tmp->ns == cur->ns) ||
+		      ((tmp->ns != NULL) && (cur->ns != NULL) &&
+		       (nl_xmlStrEqual(cur_ns_prefix, NODE_NS_PREFIX(tmp))))))))
+                    occur++;
+                tmp = tmp->prev;
+            }
+            if (occur == 0) {
+                tmp = cur->next;
+                while (tmp != NULL && occur == 0) {
+                    if ((tmp->type == LXB_DOM_NODE_TYPE_ELEMENT) &&
+			(generic ||
+			 (nl_xmlStrEqual(cur_name, NODE_NAME(tmp)) &&
+			 ((tmp->ns == cur->ns) ||
+			  ((tmp->ns != NULL) && (cur->ns != NULL) &&
+			   (nl_xmlStrEqual(cur_ns_prefix, NODE_NS_PREFIX(tmp))))))))
+                        occur++;
+                    tmp = tmp->next;
+                }
+                if (occur != 0)
+                    occur = 1;
+            } else
+                occur++;
+        } else if (cur->type == LXB_DOM_NODE_TYPE_COMMENT) {
+            sep = "/";
+	    name = "comment()";
+            next = cur->parent;
+
+            /*
+             * Thumbler index computation
+             */
+            tmp = cur->prev;
+            while (tmp != NULL) {
+                if (tmp->type == LXB_DOM_NODE_TYPE_COMMENT)
+		    occur++;
+                tmp = tmp->prev;
+            }
+            if (occur == 0) {
+                tmp = cur->next;
+                while (tmp != NULL && occur == 0) {
+		    if (tmp->type == LXB_DOM_NODE_TYPE_COMMENT)
+		        occur++;
+                    tmp = tmp->next;
+                }
+                if (occur != 0)
+                    occur = 1;
+            } else
+                occur++;
+        } else if ((cur->type == LXB_DOM_NODE_TYPE_TEXT) ||
+                   (cur->type == LXB_DOM_NODE_TYPE_CDATA_SECTION)) {
+            sep = "/";
+	    name = "text()";
+            next = cur->parent;
+
+            /*
+             * Thumbler index computation
+             */
+            tmp = cur->prev;
+            while (tmp != NULL) {
+                if ((tmp->type == LXB_DOM_NODE_TYPE_TEXT) ||
+		    (tmp->type == LXB_DOM_NODE_TYPE_CDATA_SECTION))
+		    occur++;
+                tmp = tmp->prev;
+            }
+	    /*
+	    * Evaluate if this is the only text- or CDATA-section-node;
+	    * if yes, then we'll get "text()", otherwise "text()[1]".
+	    */
+            if (occur == 0) {
+                tmp = cur->next;
+                while (tmp != NULL) {
+		    if ((tmp->type == LXB_DOM_NODE_TYPE_TEXT) ||
+			(tmp->type == LXB_DOM_NODE_TYPE_CDATA_SECTION))
+		    {
+			occur = 1;
+			break;
+		    }
+		    tmp = tmp->next;
+		}
+            } else
+                occur++;
+        } else if (cur->type == LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION) {
+            sep = "/";
+	    snprintf(nametemp, sizeof(nametemp) - 1,
+		     "processing-instruction('%s')", (char *)cur_name);
+            nametemp[sizeof(nametemp) - 1] = 0;
+            name = nametemp;
+
+	    next = cur->parent;
+
+            /*
+             * Thumbler index computation
+             */
+            tmp = cur->prev;
+            while (tmp != NULL) {
+                if ((tmp->type == LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION) &&
+		    (nl_xmlStrEqual(cur_name, NODE_NAME(tmp))))
+                    occur++;
+                tmp = tmp->prev;
+            }
+            if (occur == 0) {
+                tmp = cur->next;
+                while (tmp != NULL && occur == 0) {
+                    if ((tmp->type == LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION) &&
+			(nl_xmlStrEqual(cur_name, NODE_NAME(tmp))))
+                        occur++;
+                    tmp = tmp->next;
+                }
+                if (occur != 0)
+                    occur = 1;
+            } else
+                occur++;
+
+        } else if (cur->type == LXB_DOM_NODE_TYPE_ATTRIBUTE) {
+            sep = "/@";
+            name = (const char *) lxb_dom_attr_qualified_name(cur, &tmp_len);
+            next = ((lxb_dom_attr_t_ptr)cur)->owner;
+        } else {
+            nl_xmlFree(buf);
+            nl_xmlFree(buffer);
+            return (NULL);
+        }
+
+        /*
+         * Make sure there is enough room
+         */
+        if (nl_xmlStrlen(buffer) + sizeof(nametemp) + 20 > buf_len) {
+            buf_len =
+                2 * buf_len + nl_xmlStrlen(buffer) + sizeof(nametemp) + 20;
+            temp = (xmlChar *) nl_xmlRealloc(buffer, buf_len);
+            if (temp == NULL) {
+		xmlTreeErrMemory("getting node path");
+                nl_xmlFree(buf);
+                nl_xmlFree(buffer);
+                return (NULL);
+            }
+            buffer = temp;
+            temp = (xmlChar *) nl_xmlRealloc(buf, buf_len);
+            if (temp == NULL) {
+		xmlTreeErrMemory("getting node path");
+                nl_xmlFree(buf);
+                nl_xmlFree(buffer);
+                return (NULL);
+            }
+            buf = temp;
+        }
+        if (occur == 0)
+            snprintf((char *) buf, buf_len, "%s%s%s",
+                     sep, name, (char *) buffer);
+        else
+            snprintf((char *) buf, buf_len, "%s%s[%d]%s",
+                     sep, name, occur, (char *) buffer);
+        snprintf((char *) buffer, buf_len, "%s", (char *)buf);
+        cur = next;
+    } while (cur != NULL);
+    nl_xmlFree(buf);
+    return (buffer);
 }

data/ext/nokolexbor/xml_xpath.c

@@ -139,12 +139,6 @@
 #define XPATH_MAX_RECURSION_DEPTH 5000
 #endif
 
-static size_t tmp_len;
-
-#define NODE_NAME(node) lxb_dom_node_name_qualified((node), &tmp_len)
-#define NODE_NS_HREF(node) ((node)->prefix ? lxb_ns_by_id((node)->owner_document->ns, (node)->ns, &tmp_len) : NULL)
-#define NODE_NS_PREFIX(node) lxb_ns_by_id((node)->owner_document->prefix, (node)->prefix, &tmp_len)
-
 /*
  * TODO:
  * There are a few spots where some tests are done which depend upon ascii

data/lib/nokolexbor/node.rb

@@ -51,12 +51,20 @@ module Nokolexbor
     def element?
       type == ELEMENT_NODE
     end
+    alias_method :elem?, :element?
 
     # @return true if this is a {Document}
     def document?
       is_a?(Nokolexbor::Document)
     end
 
+    # Get the path to this node as a CSS expression
+    def css_path
+      path.split(%r{/}).filter_map do |part|
+        part.empty? ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
+      end.join(" > ")
+    end
+
     # Get a list of ancestor Node of this Node
     #
     # @param [String, nil] selector The selector to match ancestors
@@ -285,6 +293,11 @@ module Nokolexbor
       parent_node.add_child(self)
     end
 
+    # @return true if this Node's attributes include <value>
+    def value?(value)
+      values.include?(value)
+    end
+
     # Iterate over each attribute name and value pair of this Node.
     #
     # @yield [String,String] The name and value of the current attribute.

data/lib/nokolexbor/version.rb

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

data/patches/0005-lexbor-add-source-location-to-node.patch

@@ -1,3 +1,15 @@
+diff --git a/source/lexbor/dom/interfaces/node.c b/source/lexbor/dom/interfaces/node.c
+index cf6475d..9f1cf75 100755
+--- a/source/lexbor/dom/interfaces/node.c
++++ b/source/lexbor/dom/interfaces/node.c
+@@ -85,6 +85,7 @@ lxb_dom_node_interface_copy(lxb_dom_node_t *dst,
+ 
+     dst->type = src->type;
+     dst->user = src->user;
++    dst->source_location = src->source_location;
+ 
+     if (dst->owner_document == src->owner_document) {
+         dst->local_name = src->local_name;
 diff --git a/source/lexbor/dom/interfaces/node.h b/source/lexbor/dom/interfaces/node.h
 index acd0c1c..f436257 100755
 --- a/source/lexbor/dom/interfaces/node.h

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nokolexbor
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Yicheng Zhou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-04 00:00:00.000000000 Z
+date: 2023-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler