nokolexbor 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d9b715c95c44d85153796fbb2bd0760cde7c83d4a58d0df026a5bd5cddbd7dc
-  data.tar.gz: '01958cbe391c1dd9b57419ee84bc7db14c961428ec3c91c916d8a34cc36afddb'
+  metadata.gz: 48a8709af6c858df3d9fc1e3de0254f1d44ab308722eabe05a376ecd047eb7ec
+  data.tar.gz: 5bc0dea72106ead6c1382ef37a730f4b5e7d8ddf273380ef31e37d4d22394106
 SHA512:
-  metadata.gz: 8bbb957b15cac859b5565c57ccd0830b0ce184db5e63bf5b609b788ac4854e9620ba60e5477de1f85492357b216c4d39cded91ea2297142cef7ee529a0aa1692
-  data.tar.gz: 9dc2200b3506a5ff3eb14ea4438b09798f6845715238193e09d76468943d08e125992ce758bd3a946ad5b5efcb6443a58fa3aae68d2d7b381410883a974d98da
+  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.2'
+  VERSION = '0.5.0'
 end

metadata

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