nokolexbor 0.4.2 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d9b715c95c44d85153796fbb2bd0760cde7c83d4a58d0df026a5bd5cddbd7dc
-  data.tar.gz: '01958cbe391c1dd9b57419ee84bc7db14c961428ec3c91c916d8a34cc36afddb'
+  metadata.gz: f8686e83a70fe40537a072997e55f11ae40839ccf0b66125e18a251d9ba2c265
+  data.tar.gz: edfedec732ab50ee7a68a56c92b0d71166fdcf091c29105b0995e64096c5ebac
 SHA512:
-  metadata.gz: 8bbb957b15cac859b5565c57ccd0830b0ce184db5e63bf5b609b788ac4854e9620ba60e5477de1f85492357b216c4d39cded91ea2297142cef7ee529a0aa1692
-  data.tar.gz: 9dc2200b3506a5ff3eb14ea4438b09798f6845715238193e09d76468943d08e125992ce758bd3a946ad5b5efcb6443a58fa3aae68d2d7b381410883a974d98da
+  metadata.gz: be9df7bc7747b0d155764069f6782e27127127c1c2ec74394b1d9ae01c56b3428811ee4aec1bf4e89fbc8bd6be61508d6dd26b93bd9929c2fdd70cb4e1b28a7d
+  data.tar.gz: 91d16cbe5143e480bd52f5fdbcfe7aa57ca8127cb8f4ea9f249280f027264297426c00f5c5525cf365969668d4240e80352738b86385e2a489e5f8e5d89a6e11

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_document.c

@@ -1,9 +1,15 @@
 #include "nokolexbor.h"
+#include "config.h"
 
 extern VALUE mNokolexbor;
 extern VALUE cNokolexborNode;
 VALUE cNokolexborDocument;
 
+#ifdef HAVE_PTHREAD_H
+#include <pthread.h>
+pthread_key_t p_key_parser;
+#endif
+
 static void
 free_nl_document(lxb_html_document_t *document)
 {
@@ -44,18 +50,27 @@ nl_document_parse(VALUE self, VALUE rb_string_or_io)
   const char *html_c = StringValuePtr(rb_html);
   size_t html_len = RSTRING_LEN(rb_html);
 
-  lxb_html_document_t *document;
-
-  document = lxb_html_document_create();
-  if (document == NULL) {
-    rb_raise(rb_eRuntimeError, "Error creating document");
+#ifdef HAVE_PTHREAD_H
+  lxb_html_parser_t *g_parser = (lxb_html_parser_t *)pthread_getspecific(p_key_parser);
+#else
+  lxb_html_parser_t *g_parser = NULL;
+#endif
+  if (g_parser == NULL) {
+    g_parser = lxb_html_parser_create();
+    lxb_status_t status = lxb_html_parser_init(g_parser);
+    if (status != LXB_STATUS_OK) {
+      nl_raise_lexbor_error(status);
+    }
+    g_parser->tree->scripting = true;
+#ifdef HAVE_PTHREAD_H
+    pthread_setspecific(p_key_parser, g_parser);
+#endif
   }
 
-  lxb_dom_document_scripting_set(lxb_dom_interface_document(document), true);
+  lxb_html_document_t *document = lxb_html_parse(g_parser, (const lxb_char_t *)html_c, html_len);
 
-  lxb_status_t status = lxb_html_document_parse(document, (const lxb_char_t *)html_c, html_len);
-  if (status != LXB_STATUS_OK) {
-    nl_raise_lexbor_error(status);
+  if (document == NULL) {
+    rb_raise(rb_eRuntimeError, "Error parsing document");
   }
 
   return TypedData_Wrap_Struct(cNokolexborDocument, &nl_document_type, document);
@@ -127,8 +142,21 @@ nl_document_root(VALUE self)
   return nl_rb_node_create(lxb_dom_document_root(doc), self);
 }
 
+static void
+free_parser(void *data)
+{
+  lxb_html_parser_t *g_parser = (lxb_html_parser_t *)data;
+  if (g_parser != NULL) {
+    g_parser = lxb_html_parser_destroy(g_parser);
+  }
+}
+
 void Init_nl_document(void)
 {
+#ifdef HAVE_PTHREAD_H
+  pthread_key_create(&p_key_parser, free_parser);
+#endif
+
   cNokolexborDocument = rb_define_class_under(mNokolexbor, "Document", cNokolexborNode);
   rb_define_singleton_method(cNokolexborDocument, "new", nl_document_new, 0);
   rb_define_singleton_method(cNokolexborDocument, "parse", nl_document_parse, 1);

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 Qfalse;
+  }
   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.2'
 end

metadata

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