nokolexbor 0.3.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bfa3062e8718581cd8aabef75f0084a6626bd90301c9db4957ee975215edec1
-  data.tar.gz: 243f5c217c85750f63bfc0dcb8af575c019d3f2fd920f41769c0affc8a219802
+  metadata.gz: 042127a2ed4027c52d3718c148921604cae07c274dddb7f3702c7caf0708863f
+  data.tar.gz: 60230b55b773ef41abdca313adc3ffdba38a0b8462c9d23c3365e57c68b63bd5
 SHA512:
-  metadata.gz: e66b390ef696ed5cafa480065e8ac8fc66ce98d86a7cb15f2f59d8acb7df21381942e5fe6f0244e3b9c7bf54787131c5241a49faeaba328eb49e65af0ac3216c
-  data.tar.gz: d266e2a7c49a202aec4112667807158b54878cc014b42fc32492fc0977c06db76b1a5ded827d9810f2e7966ba3e5068fe54ab89915a4c56e499181ddc190b6d7
+  metadata.gz: f06063b84e62e23ba093a397ba6ffdbd802480e711ca24966d5b78be8bc8a7299754ab8bb4cd5d77d6dfe39efa7c21c705b105fe9d626d62eddc5e2e5a6ec9fb
+  data.tar.gz: 86ddfdb650b78827071385cfca708ddbffcd35204a71f439315f800e8e60ee73c2d49ce46e28192ac454df8bab7ef8cbc937b97830e0b488290dbadccd8e51d6

data/ext/nokolexbor/libxml/xpathInternals.h

@@ -477,11 +477,10 @@ XMLPUBFUN xmlXPathParserContextPtr XMLCALL
 XMLPUBFUN void XMLCALL
 		nl_xmlXPathFreeParserContext	(xmlXPathParserContextPtr ctxt);
 
-/* TODO: remap to xmlXPathValuePop and Push. */
-static xmlXPathObjectPtr XMLCALL
-		valuePop			(xmlXPathParserContextPtr ctxt);
-static int XMLCALL
-		valuePush			(xmlXPathParserContextPtr ctxt,
+XMLPUBFUN xmlXPathObjectPtr XMLCALL
+		nl_xmlXPathValuePop		(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN int XMLCALL
+		nl_xmlXPathValuePush		(xmlXPathParserContextPtr ctxt,
 						 xmlXPathObjectPtr value);
 
 XMLPUBFUN xmlXPathObjectPtr XMLCALL

data/ext/nokolexbor/nl_cdata.c

@@ -20,7 +20,7 @@ nl_cdata_new(int argc, VALUE *argv, VALUE klass)
 
   document = nl_rb_document_unwrap(rb_document);
 
-  const char* c_content = StringValuePtr(rb_content);
+  const char *c_content = StringValuePtr(rb_content);
   size_t content_len = RSTRING_LEN(rb_content);
   lxb_dom_cdata_section_t *element = lxb_dom_document_create_cdata_section(document, (const lxb_char_t *)c_content, content_len);
   if (element == NULL) {

data/ext/nokolexbor/nl_comment.c

@@ -20,7 +20,7 @@ nl_comment_new(int argc, VALUE *argv, VALUE klass)
 
   document = nl_rb_document_unwrap(rb_document);
 
-  const char* c_content = StringValuePtr(rb_content);
+  const char *c_content = StringValuePtr(rb_content);
   size_t content_len = RSTRING_LEN(rb_content);
   lxb_dom_comment_t *element = lxb_dom_document_create_comment(document, (const lxb_char_t *)c_content, content_len);
   if (element == NULL) {

data/ext/nokolexbor/nl_document.c

@@ -41,6 +41,8 @@ nl_document_parse(VALUE self, VALUE rb_string_or_io)
     rb_raise(rb_eRuntimeError, "Error creating document");
   }
 
+  lxb_dom_document_scripting_set(lxb_dom_interface_document(document), true);
+
   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);

data/ext/nokolexbor/nl_document_fragment.c

@@ -0,0 +1,39 @@
+#include "nokolexbor.h"
+
+VALUE cNokolexborDocumentFragment;
+extern VALUE cNokolexborNode;
+extern VALUE mNokolexbor;
+
+static VALUE
+nl_document_fragment_new(int argc, VALUE *argv, VALUE klass)
+{
+  lxb_dom_document_t *document;
+  VALUE rb_document;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "1*", &rb_document, &rest);
+
+  if (!rb_obj_is_kind_of(rb_document, cNokolexborDocument)) {
+    rb_raise(rb_eArgError, "Document must be a Nokolexbor::Document");
+  }
+
+  document = nl_rb_document_unwrap(rb_document);
+
+  lxb_dom_document_fragment_t *node = lxb_dom_document_create_document_fragment(document);
+  if (node == NULL) {
+    rb_raise(rb_eRuntimeError, "Error creating document fragment");
+  }
+
+  VALUE rb_node = nl_rb_node_create(&node->node, rb_document);
+
+  rb_obj_call_init(rb_node, argc, argv);
+
+  return rb_node;
+}
+
+void Init_nl_document_fragment(void)
+{
+  cNokolexborDocumentFragment = rb_define_class_under(mNokolexbor, "DocumentFragment", cNokolexborNode);
+
+  rb_define_singleton_method(cNokolexborDocumentFragment, "new", nl_document_fragment_new, -1);
+}

data/ext/nokolexbor/nl_error.c

@@ -0,0 +1,93 @@
+#include "nokolexbor.h"
+
+VALUE eLexborError;
+VALUE eLexborMemoryAllocationError;
+VALUE eLexborSmallBufferError;
+VALUE eLexborObjectIsNullError;
+VALUE eLexborIncompleteObjectError;
+VALUE eLexborNoFreeSlotError;
+VALUE eLexborTooSmallSizeError;
+VALUE eLexborNotExistsError;
+VALUE eLexborWrongArgsError;
+VALUE eLexborWrongStageError;
+VALUE eLexborUnexpectedResultError;
+VALUE eLexborUnexpectedDataError;
+VALUE eLexborOverflowError;
+VALUE eLexborContinueStatus;
+VALUE eLexborSmallBufferStatus;
+VALUE eLexborAbortedStatus;
+VALUE eLexborStoppedStatus;
+VALUE eLexborNextStatus;
+VALUE eLexborStopStatus;
+extern VALUE mNokolexbor;
+
+void nl_raise_lexbor_error(lxb_status_t error)
+{
+  switch (error) {
+  case LXB_STATUS_ERROR:
+    rb_exc_raise(eLexborError);
+  case LXB_STATUS_ERROR_MEMORY_ALLOCATION:
+    rb_exc_raise(eLexborMemoryAllocationError);
+  case LXB_STATUS_ERROR_OBJECT_IS_NULL:
+    rb_exc_raise(eLexborObjectIsNullError);
+  case LXB_STATUS_ERROR_SMALL_BUFFER:
+    rb_exc_raise(eLexborSmallBufferError);
+  case LXB_STATUS_ERROR_INCOMPLETE_OBJECT:
+    rb_exc_raise(eLexborIncompleteObjectError);
+  case LXB_STATUS_ERROR_NO_FREE_SLOT:
+    rb_exc_raise(eLexborNoFreeSlotError);
+  case LXB_STATUS_ERROR_TOO_SMALL_SIZE:
+    rb_exc_raise(eLexborTooSmallSizeError);
+  case LXB_STATUS_ERROR_NOT_EXISTS:
+    rb_exc_raise(eLexborNotExistsError);
+  case LXB_STATUS_ERROR_WRONG_ARGS:
+    rb_exc_raise(eLexborWrongArgsError);
+  case LXB_STATUS_ERROR_WRONG_STAGE:
+    rb_exc_raise(eLexborWrongStageError);
+  case LXB_STATUS_ERROR_UNEXPECTED_RESULT:
+    rb_exc_raise(eLexborUnexpectedResultError);
+  case LXB_STATUS_ERROR_UNEXPECTED_DATA:
+    rb_raise(eLexborUnexpectedDataError, "Invalid syntax");
+  case LXB_STATUS_ERROR_OVERFLOW:
+    rb_exc_raise(eLexborOverflowError);
+  case LXB_STATUS_CONTINUE:
+    rb_exc_raise(eLexborContinueStatus);
+  case LXB_STATUS_SMALL_BUFFER:
+    rb_exc_raise(eLexborSmallBufferStatus);
+  case LXB_STATUS_ABORTED:
+    rb_exc_raise(eLexborAbortedStatus);
+  case LXB_STATUS_STOPPED:
+    rb_exc_raise(eLexborStoppedStatus);
+  case LXB_STATUS_NEXT:
+    rb_exc_raise(eLexborNextStatus);
+  case LXB_STATUS_STOP:
+    rb_exc_raise(eLexborStopStatus);
+  case LXB_STATUS_OK:
+    return;
+  default:
+    rb_raise(eLexborError, "Unknown error (%d)", error);
+  }
+}
+
+void Init_nl_error(void)
+{
+  eLexborError = rb_define_class_under(mNokolexbor, "LexborError", rb_eStandardError);
+  eLexborMemoryAllocationError = rb_define_class_under(mNokolexbor, "LexborMemoryAllocationError", eLexborError);
+  eLexborSmallBufferError = rb_define_class_under(mNokolexbor, "LexborSmallBufferError", eLexborError);
+  eLexborObjectIsNullError = rb_define_class_under(mNokolexbor, "LexborObjectIsNullError", eLexborError);
+  eLexborIncompleteObjectError = rb_define_class_under(mNokolexbor, "LexborIncompleteObjectError", eLexborError);
+  eLexborNoFreeSlotError = rb_define_class_under(mNokolexbor, "LexborNoFreeSlotError", eLexborError);
+  eLexborTooSmallSizeError = rb_define_class_under(mNokolexbor, "LexborTooSmallSizeError", eLexborError);
+  eLexborNotExistsError = rb_define_class_under(mNokolexbor, "LexborNotExistsError", eLexborError);
+  eLexborWrongArgsError = rb_define_class_under(mNokolexbor, "LexborWrongArgsError", eLexborError);
+  eLexborWrongStageError = rb_define_class_under(mNokolexbor, "LexborWrongStageError", eLexborError);
+  eLexborUnexpectedResultError = rb_define_class_under(mNokolexbor, "LexborUnexpectedResultError", eLexborError);
+  eLexborUnexpectedDataError = rb_define_class_under(mNokolexbor, "LexborUnexpectedDataError", eLexborError);
+  eLexborOverflowError = rb_define_class_under(mNokolexbor, "LexborOverflowError", eLexborError);
+  eLexborContinueStatus = rb_define_class_under(mNokolexbor, "LexborContinueStatus", eLexborError);
+  eLexborSmallBufferStatus = rb_define_class_under(mNokolexbor, "LexborSmallBufferStatus", eLexborError);
+  eLexborAbortedStatus = rb_define_class_under(mNokolexbor, "LexborAbortedStatus", eLexborError);
+  eLexborStoppedStatus = rb_define_class_under(mNokolexbor, "LexborStoppedStatus", eLexborError);
+  eLexborNextStatus = rb_define_class_under(mNokolexbor, "LexborNextStatus", eLexborError);
+  eLexborStopStatus = rb_define_class_under(mNokolexbor, "LexborStopStatus", eLexborError);
+}

data/ext/nokolexbor/nl_node.c

@@ -9,7 +9,9 @@ extern VALUE mNokolexbor;
 extern VALUE cNokolexborDocument;
 extern VALUE cNokolexborText;
 extern VALUE cNokolexborComment;
+extern VALUE cNokolexborProcessingInstruction;
 extern VALUE cNokolexborNodeSet;
+extern VALUE cNokolexborDocumentFragment;
 extern VALUE eLexborError;
 VALUE cNokolexborNode;
 VALUE cNokolexborElement;
@@ -41,8 +43,9 @@ nl_rb_node_create(lxb_dom_node_t *node, VALUE rb_document)
   //   break;
   // case LXB_DOM_NODE_TYPE_ENTITY:
   //   break;
-  // case LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION:
-  //   break;
+  case LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION:
+    rb_class = cNokolexborProcessingInstruction;
+    break;
   case LXB_DOM_NODE_TYPE_COMMENT:
     rb_class = cNokolexborComment;
     break;
@@ -50,8 +53,9 @@ nl_rb_node_create(lxb_dom_node_t *node, VALUE rb_document)
   //   break;
   // case LXB_DOM_NODE_TYPE_DOCUMENT_TYPE:
   //   break;
-  // case LXB_DOM_NODE_TYPE_DOCUMENT_FRAGMENT:
-  //   break;
+  case LXB_DOM_NODE_TYPE_DOCUMENT_FRAGMENT:
+    rb_class = cNokolexborDocumentFragment;
+    break;
   // case LXB_DOM_NODE_TYPE_NOTATION:
   //   break;
   default:
@@ -91,7 +95,7 @@ nl_node_new(int argc, VALUE *argv, VALUE klass)
 
   document = nl_rb_document_unwrap(rb_document);
 
-  const char* c_name = StringValuePtr(rb_name);
+  const char *c_name = StringValuePtr(rb_name);
   size_t name_len = RSTRING_LEN(rb_name);
   lxb_dom_element_t *element = lxb_dom_document_create_element(document, (const lxb_char_t *)c_name, name_len, NULL);
   if (element == NULL) {
@@ -657,17 +661,19 @@ nl_node_name(VALUE self)
 }
 
 static lxb_dom_node_t *
-nl_node_parse_fragment(lxb_dom_document_t *doc, lxb_char_t *html, size_t size)
+nl_node_parse_fragment(lxb_dom_document_t *doc, lxb_dom_element_t *element, lxb_char_t *html, size_t size)
 {
   size_t tag_name_len;
   lxb_html_document_t *html_doc = lxb_html_interface_document(doc);
-  const lxb_char_t *tag_name = lxb_tag_name_by_id(lxb_html_document_tags(html_doc), LXB_TAG__UNDEF, &tag_name_len);
-  if (tag_name == NULL) {
-    rb_raise(rb_eRuntimeError, "Error getting tag name");
-  }
-  lxb_dom_element_t *element = lxb_dom_document_create_element(doc, tag_name, tag_name_len, NULL);
   if (element == NULL) {
-    rb_raise(rb_eRuntimeError, "Error creating element");
+    const lxb_char_t *tag_name = lxb_tag_name_by_id(lxb_html_document_tags(html_doc), LXB_TAG__UNDEF, &tag_name_len);
+    if (tag_name == NULL) {
+      rb_raise(rb_eRuntimeError, "Error getting tag name");
+    }
+    element = lxb_dom_document_create_element(doc, tag_name, tag_name_len, NULL);
+    if (element == NULL) {
+      rb_raise(rb_eRuntimeError, "Error creating element");
+    }
   }
   lxb_dom_node_t *frag_root = lxb_html_document_parse_fragment(html_doc, element, html, size);
   if (frag_root == NULL) {
@@ -677,14 +683,22 @@ nl_node_parse_fragment(lxb_dom_document_t *doc, lxb_char_t *html, size_t size)
 }
 
 static VALUE
-nl_node_fragment(VALUE self, VALUE html)
+nl_node_parse(VALUE self, VALUE html)
 {
   Check_Type(html, T_STRING);
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
   lxb_dom_document_t *doc = node->owner_document;
 
-  lxb_dom_node_t *frag_root = nl_node_parse_fragment(doc, (lxb_char_t *)RSTRING_PTR(html), RSTRING_LEN(html));
-  return nl_rb_node_create(frag_root, nl_rb_document_get(self));
+  lxb_dom_node_t *frag_root = nl_node_parse_fragment(doc, lxb_dom_interface_element(node), (lxb_char_t *)RSTRING_PTR(html), RSTRING_LEN(html));
+  lexbor_array_t *array = lexbor_array_create();
+
+  while (frag_root->first_child != NULL) {
+    lxb_dom_node_t *child = frag_root->first_child;
+    lxb_dom_node_remove(child);
+    lexbor_array_push(array, child);
+  }
+  lxb_dom_node_destroy(frag_root);
+  return nl_rb_node_set_create_with_data(array, nl_rb_document_get(self));
 }
 
 static VALUE
@@ -703,7 +717,7 @@ nl_node_add_sibling(VALUE self, VALUE next_or_previous, VALUE new)
   }
 
   if (TYPE(new) == T_STRING) {
-    lxb_dom_node_t *frag_root = nl_node_parse_fragment(doc, (lxb_char_t *)RSTRING_PTR(new), RSTRING_LEN(new));
+    lxb_dom_node_t *frag_root = nl_node_parse_fragment(doc, NULL, (lxb_char_t *)RSTRING_PTR(new), RSTRING_LEN(new));
     lexbor_array_t *array = lexbor_array_create();
 
     while (frag_root->first_child != NULL) {
@@ -734,7 +748,7 @@ nl_node_add_child(VALUE self, VALUE new)
   lxb_dom_document_t *doc = node->owner_document;
 
   if (TYPE(new) == T_STRING) {
-    lxb_dom_node_t *frag_root = nl_node_parse_fragment(doc, (lxb_char_t *)RSTRING_PTR(new), RSTRING_LEN(new));
+    lxb_dom_node_t *frag_root = nl_node_parse_fragment(doc, NULL, (lxb_char_t *)RSTRING_PTR(new), RSTRING_LEN(new));
     lexbor_array_t *array = lexbor_array_create();
 
     while (frag_root->first_child != NULL) {
@@ -859,7 +873,7 @@ void Init_nl_node(void)
   rb_define_method(cNokolexborNode, "destroy", nl_node_destroy, 0);
   rb_define_method(cNokolexborNode, "attrs", nl_node_attrs, 0);
   rb_define_method(cNokolexborNode, "name", nl_node_name, 0);
-  rb_define_method(cNokolexborNode, "fragment", nl_node_fragment, 1);
+  rb_define_method(cNokolexborNode, "parse", nl_node_parse, 1);
   rb_define_method(cNokolexborNode, "add_sibling", nl_node_add_sibling, 2);
   rb_define_method(cNokolexborNode, "add_child", nl_node_add_child, 1);
   rb_define_method(cNokolexborNode, "node_type", nl_node_get_type, 0);

data/ext/nokolexbor/nl_processing_instruction.c

@@ -0,0 +1,47 @@
+#include "nokolexbor.h"
+
+VALUE cNokolexborProcessingInstruction;
+extern VALUE cNokolexborNode;
+extern VALUE mNokolexbor;
+
+static VALUE
+nl_processing_instruction_new(int argc, VALUE *argv, VALUE klass)
+{
+  lxb_dom_document_t *document;
+  VALUE rb_name;
+  VALUE rb_content;
+  VALUE rb_document;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "3*", &rb_name, &rb_content, &rb_document, &rest);
+
+  if (!rb_obj_is_kind_of(rb_document, cNokolexborDocument)) {
+    rb_raise(rb_eArgError, "Document must be a Nokolexbor::Document");
+  }
+
+  document = nl_rb_document_unwrap(rb_document);
+
+  const char *c_name = StringValuePtr(rb_name);
+  size_t name_len = RSTRING_LEN(rb_name);
+  const char *c_content = StringValuePtr(rb_content);
+  size_t content_len = RSTRING_LEN(rb_content);
+  lxb_dom_processing_instruction_t *node = lxb_dom_document_create_processing_instruction(document, (const lxb_char_t *)c_name, name_len, (const lxb_char_t *)c_content, content_len);
+  if (node == NULL) {
+    rb_raise(rb_eRuntimeError, "Error creating processing instruction");
+  }
+
+  VALUE rb_node = nl_rb_node_create(&node->char_data.node, rb_document);
+
+  if (rb_block_given_p()) {
+    rb_yield(rb_node);
+  }
+
+  return rb_node;
+}
+
+void Init_nl_processing_instruction(void)
+{
+  cNokolexborProcessingInstruction = rb_define_class_under(mNokolexbor, "ProcessingInstruction", cNokolexborNode);
+
+  rb_define_singleton_method(cNokolexborProcessingInstruction, "new", nl_processing_instruction_new, -1);
+}

data/ext/nokolexbor/nl_text.c

@@ -20,7 +20,7 @@ nl_text_new(int argc, VALUE *argv, VALUE klass)
 
   document = nl_rb_document_unwrap(rb_document);
 
-  const char* c_text = StringValuePtr(rb_text);
+  const char *c_text = StringValuePtr(rb_text);
   size_t text_len = RSTRING_LEN(rb_text);
   lxb_dom_text_t *element = lxb_dom_document_create_text_node(document, (const lxb_char_t *)c_text, text_len);
   if (element == NULL) {

data/ext/nokolexbor/nl_xpath_context.c

@@ -15,12 +15,110 @@ VALUE cNokolexborXpathContext;
 VALUE mNokolexborXpath;
 VALUE cNokolexborXpathSyntaxError;
 
+static const xmlChar *NOKOGIRI_PREFIX = (const xmlChar *)"nokogiri";
+static const xmlChar *NOKOGIRI_URI = (const xmlChar *)"http://www.nokogiri.org/default_ns/ruby/extensions_functions";
+static const xmlChar *NOKOGIRI_BUILTIN_PREFIX = (const xmlChar *)"nokogiri-builtin";
+static const xmlChar *NOKOGIRI_BUILTIN_URI = (const xmlChar *)"https://www.nokogiri.org/default_ns/ruby/builtins";
+
 static void
 free_xml_xpath_context(xmlXPathContextPtr ctx)
 {
   nl_xmlXPathFreeContext(ctx);
 }
 
+/* find a CSS class in an HTML element's `class` attribute */
+static const xmlChar *
+builtin_css_class(const xmlChar *str, const xmlChar *val)
+{
+  int val_len;
+
+  if (str == NULL) {
+    return (NULL);
+  }
+  if (val == NULL) {
+    return (NULL);
+  }
+
+  val_len = nl_xmlStrlen(val);
+  if (val_len == 0) {
+    return (str);
+  }
+
+  while (*str != 0) {
+    if ((*str == *val) && !nl_xmlStrncmp(str, val, val_len)) {
+      const xmlChar *next_byte = str + val_len;
+
+      /* only match if the next byte is whitespace or end of string */
+      if ((*next_byte == 0) || (IS_BLANK_CH(*next_byte))) {
+        return ((const xmlChar *)str);
+      }
+    }
+
+    /* advance str to whitespace */
+    while ((*str != 0) && !IS_BLANK_CH(*str)) {
+      str++;
+    }
+
+    /* advance str to start of next word or end of string */
+    while ((*str != 0) && IS_BLANK_CH(*str)) {
+      str++;
+    }
+  }
+
+  return (NULL);
+}
+
+/* xmlXPathFunction to wrap builtin_css_class() */
+static void
+xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlXPathObjectPtr hay, needle;
+
+  CHECK_ARITY(2);
+
+  CAST_TO_STRING;
+  needle = nl_xmlXPathValuePop(ctxt);
+  if ((needle == NULL) || (needle->type != XPATH_STRING)) {
+    nl_xmlXPathFreeObject(needle);
+    XP_ERROR(XPATH_INVALID_TYPE);
+  }
+
+  CAST_TO_STRING;
+  hay = nl_xmlXPathValuePop(ctxt);
+  if ((hay == NULL) || (hay->type != XPATH_STRING)) {
+    nl_xmlXPathFreeObject(hay);
+    nl_xmlXPathFreeObject(needle);
+    XP_ERROR(XPATH_INVALID_TYPE);
+  }
+
+  if (builtin_css_class(hay->stringval, needle->stringval)) {
+    nl_xmlXPathValuePush(ctxt, nl_xmlXPathNewBoolean(1));
+  } else {
+    nl_xmlXPathValuePush(ctxt, nl_xmlXPathNewBoolean(0));
+  }
+
+  nl_xmlXPathFreeObject(hay);
+  nl_xmlXPathFreeObject(needle);
+}
+
+/* xmlXPathFunction to select nodes whose local name matches, for HTML5 CSS queries that should ignore namespaces */
+static void
+xpath_builtin_local_name_is(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlXPathObjectPtr element_name;
+  size_t tmp_len;
+
+  CHECK_ARITY(1);
+  CAST_TO_STRING;
+  CHECK_TYPE(XPATH_STRING);
+  element_name = nl_xmlXPathValuePop(ctxt);
+
+  const lxb_char_t *node_name = lxb_dom_node_name_qualified(ctxt->context->node, &tmp_len);
+  nl_xmlXPathValuePush(ctxt, nl_xmlXPathNewBoolean(nl_xmlStrEqual((xmlChar *)node_name, element_name->stringval)));
+
+  nl_xmlXPathFreeObject(element_name);
+}
+
 /*
  * call-seq:
  *  register_ns(prefix, uri)
@@ -228,6 +326,13 @@ nl_xpath_context_new(VALUE klass, VALUE rb_node)
   ctx = nl_xmlXPathNewContext(node->owner_document);
   ctx->node = node;
 
+  nl_xmlXPathRegisterNs(ctx, NOKOGIRI_PREFIX, NOKOGIRI_URI);
+  nl_xmlXPathRegisterNs(ctx, NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
+  nl_xmlXPathRegisterFuncNS(ctx, (const xmlChar *)"css-class", NOKOGIRI_BUILTIN_URI,
+                            xpath_builtin_css_class);
+  nl_xmlXPathRegisterFuncNS(ctx, (const xmlChar *)"local-name-is", NOKOGIRI_BUILTIN_URI,
+                            xpath_builtin_local_name_is);
+
   self = Data_Wrap_Struct(klass, 0, free_xml_xpath_context, ctx);
   rb_iv_set(self, "@document", nl_rb_document_get(rb_node));
 

data/ext/nokolexbor/nokolexbor.c

@@ -1,67 +1,21 @@
 #include "nokolexbor.h"
 
 VALUE mNokolexbor;
-VALUE eLexborError;
-VALUE eLexborSyntaxError;
-
-void nl_raise_lexbor_error(lxb_status_t error)
-{
-  switch (error) {
-  case LXB_STATUS_ERROR:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR");
-  case LXB_STATUS_ERROR_MEMORY_ALLOCATION:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_MEMORY_ALLOCATION");
-  case LXB_STATUS_ERROR_OBJECT_IS_NULL:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_OBJECT_IS_NULL");
-  case LXB_STATUS_ERROR_SMALL_BUFFER:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_SMALL_BUFFER");
-  case LXB_STATUS_ERROR_INCOMPLETE_OBJECT:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_INCOMPLETE_OBJECT");
-  case LXB_STATUS_ERROR_NO_FREE_SLOT:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_NO_FREE_SLOT");
-  case LXB_STATUS_ERROR_TOO_SMALL_SIZE:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_TOO_SMALL_SIZE");
-  case LXB_STATUS_ERROR_NOT_EXISTS:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_NOT_EXISTS");
-  case LXB_STATUS_ERROR_WRONG_ARGS:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_WRONG_ARGS");
-  case LXB_STATUS_ERROR_WRONG_STAGE:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_WRONG_STAGE");
-  case LXB_STATUS_ERROR_UNEXPECTED_RESULT:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_UNEXPECTED_RESULT");
-  case LXB_STATUS_ERROR_UNEXPECTED_DATA:
-    rb_raise(eLexborSyntaxError, "LXB_STATUS_ERROR_UNEXPECTED_DATA");
-  case LXB_STATUS_ERROR_OVERFLOW:
-    rb_raise(eLexborError, "LXB_STATUS_ERROR_OVERFLOW");
-  case LXB_STATUS_CONTINUE:
-    rb_raise(eLexborError, "LXB_STATUS_CONTINUE");
-  case LXB_STATUS_SMALL_BUFFER:
-    rb_raise(eLexborError, "LXB_STATUS_SMALL_BUFFER");
-  case LXB_STATUS_ABORTED:
-    rb_raise(eLexborError, "LXB_STATUS_ABORTED");
-  case LXB_STATUS_STOPPED:
-    rb_raise(eLexborError, "LXB_STATUS_STOPPED");
-  case LXB_STATUS_NEXT:
-    rb_raise(eLexborError, "LXB_STATUS_NEXT");
-  case LXB_STATUS_STOP:
-    rb_raise(eLexborError, "LXB_STATUS_STOP");
-  case LXB_STATUS_OK:
-    return;
-  default:
-    rb_raise(eLexborError, "LXB_ERROR_UKNOWN(%d)", error);
-  }
-}
 
 void Init_nokolexbor(void)
 {
+#ifndef NOKOLEXBOR_ASAN
+  lexbor_memory_setup(ruby_xmalloc, ruby_xrealloc, ruby_xcalloc, ruby_xfree);
+#endif
   mNokolexbor = rb_define_module("Nokolexbor");
-  eLexborError = rb_define_class_under(mNokolexbor, "LexborError", rb_eStandardError);
-  eLexborSyntaxError = rb_define_class_under(mNokolexbor, "LexborSyntaxError", eLexborError);
+  Init_nl_error();
   Init_nl_node();
   Init_nl_document();
   Init_nl_text();
   Init_nl_comment();
   Init_nl_cdata();
+  Init_nl_processing_instruction();
   Init_nl_node_set();
+  Init_nl_document_fragment();
   Init_nl_xpath_context();
 }

data/ext/nokolexbor/nokolexbor.h

@@ -9,12 +9,15 @@
 
 extern VALUE cNokolexborDocument;
 
+void Init_nl_error(void);
 void Init_nl_document(void);
 void Init_nl_node(void);
-void Init_nl_node_set(void);
 void Init_nl_text(void);
 void Init_nl_comment(void);
 void Init_nl_cdata(void);
+void Init_nl_processing_instruction(void);
+void Init_nl_node_set(void);
+void Init_nl_document_fragment(void);
 void Init_nl_xpath_context(void);
 
 void nl_raise_lexbor_error(lxb_status_t error);

data/ext/nokolexbor/xml_xpath.c

@@ -2897,6 +2897,10 @@ valuePop(xmlXPathParserContextPtr ctxt)
     ctxt->valueTab[ctxt->valueNr] = NULL;
     return (ret);
 }
+
+xmlXPathObjectPtr
+nl_xmlXPathValuePop(xmlXPathParserContextPtr ctxt) { return valuePop(ctxt); }
+
 /**
  * valuePush:
  * @ctxt:  an XPath evaluation context
@@ -2941,6 +2945,9 @@ valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
     return (ctxt->valueNr++);
 }
 
+int
+nl_xmlXPathValuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value) { return valuePush(ctxt, value); }
+
 /**
  * nl_xmlXPathPopBoolean:
  * @ctxt:  an XPath parser context

data/lib/nokolexbor/document.rb

@@ -93,5 +93,9 @@ module Nokolexbor
         head.prepend_child(element)
       end
     end
+
+    private
+
+    IMPLIED_XPATH_CONTEXTS = ["//"].freeze # :nodoc:
   end
 end

data/lib/nokolexbor/document_fragment.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Nokolexbor
+  class DocumentFragment < Nokolexbor::Node
+    def self.parse(tags)
+      new(Nokolexbor::Document.new, tags, nil)
+    end
+
+    def initialize(document, tags = nil, ctx = nil)
+      return self unless tags
+
+      ctx ||= document
+      node_set = ctx.parse(tags)
+      node_set.each { |child| child.parent = self } unless node_set.empty?
+      nil
+    end
+
+    def name
+      "#document-fragment"
+    end
+
+    alias_method :outer_html, :inner_html
+    alias_method :to_html, :outer_html
+    alias_method :to_s, :outer_html
+    alias_method :serialize, :outer_html
+
+    def fragment(data)
+      document.fragment(data)
+    end
+  end
+end

data/lib/nokolexbor/node.rb

@@ -182,6 +182,10 @@ module Nokolexbor
       end
     end
 
+    def fragment(tags)
+      Nokolexbor::DocumentFragment.new(document, tags, self)
+    end
+
     alias_method :inner_html=, :children=
 
     def css(*args)
@@ -192,6 +196,16 @@ module Nokolexbor
       at_css_impl(args.join(', '))
     end
 
+    def nokogiri_css(*args)
+      rules, handler, ns, _ = extract_params(args)
+
+      nokogiri_css_internal(self, rules, handler, ns)
+    end
+
+    def nokogiri_at_css(*args)
+      nokogiri_css(*args).first
+    end
+
     def xpath(*args)
       paths, handler, ns, binds = extract_params(args)
 
@@ -299,6 +313,10 @@ module Nokolexbor
 
     private
 
+    def nokogiri_css_internal(node, rules, handler, ns)
+      xpath_internal(node, css_rules_to_xpath(rules, ns), handler, ns, nil)
+    end
+
     def xpath_internal(node, paths, handler, ns, binds)
       # document = node.document
       # return NodeSet.new(document) unless document
@@ -326,6 +344,34 @@ module Nokolexbor
       ctx.evaluate(path, handler)
     end
 
+    def css_rules_to_xpath(rules, ns)
+      rules.map { |rule| xpath_query_from_css_rule(rule, ns) }
+    end
+
+    def ensure_nokogiri
+      unless defined?(Nokogiri) && defined?(Nokogiri::CSS)
+        require 'nokogiri'
+      end
+    rescue LoadError
+      fail('nokogiri_css and nokogiri_at_css require Nokogiri to be installed')
+    end
+
+    def xpath_query_from_css_rule(rule, ns)
+      ensure_nokogiri
+      if defined? Nokogiri::CSS::XPathVisitor::BuiltinsConfig
+        visitor = Nokogiri::CSS::XPathVisitor.new(
+          builtins: Nokogiri::CSS::XPathVisitor::BuiltinsConfig::OPTIMAL,
+          doctype: :html4,
+        )
+      else
+        visitor = Nokogiri::CSS::XPathVisitorOptimallyUseBuiltins.new
+      end
+      self.class::IMPLIED_XPATH_CONTEXTS.map do |implied_xpath_context|
+        Nokogiri::CSS.xpath_for(rule.to_s, { prefix: implied_xpath_context, ns: ns,
+                                   visitor: visitor, })
+      end.join(" | ")
+    end
+
     def extract_params(params)
       handler = params.find do |param|
         ![Hash, String, Symbol].include?(param.class)
@@ -344,5 +390,7 @@ module Nokolexbor
 
       [params, handler, ns, binds]
     end
+
+    IMPLIED_XPATH_CONTEXTS = [".//"].freeze
   end
-end
+end

data/lib/nokolexbor/node_set.rb

@@ -126,6 +126,23 @@ module Nokolexbor
         end
       end
     end
+
+    def nokogiri_css(*args)
+      rules, handler, ns, _ = extract_params(args)
+      paths = css_rules_to_xpath(rules, ns)
+
+      NodeSet.new(@document) do |set|
+        each do |node|
+          node.send(:xpath_internal, node, paths, handler, ns, nil).each do |inner_node|
+            set << inner_node
+          end
+        end
+      end
+    end
+
+    private
+
+    IMPLIED_XPATH_CONTEXTS = [".//", "self::"].freeze # :nodoc:
       
   end
 end

data/lib/nokolexbor/version.rb

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

data/lib/nokolexbor.rb

@@ -25,6 +25,7 @@ require 'nokolexbor/version'
 require 'nokolexbor/node'
 require 'nokolexbor/document'
 require 'nokolexbor/node_set'
+require 'nokolexbor/document_fragment'
 require 'nokolexbor/attribute'
 require 'nokolexbor/xpath'
 require 'nokolexbor/xpath_context'

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

@@ -13,7 +13,7 @@ index 2b19f18..5e56181 100644
  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
+index 398d1bb..ddd5f3e 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
@@ -36,7 +36,7 @@ index 398d1bb..b35bfab 100644
      {"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
+index fef05d3..1ceaa19 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
@@ -91,16 +91,7 @@ index c2d18ea..84b5b14 100644
  
          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
+@@ -289,6 +313,12 @@ lxb_selectors_following(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry
          {
              return node;
          }
@@ -113,7 +104,7 @@ index c2d18ea..84b5b14 100644
  
          node = node->next;
      }
-@@ -1429,6 +1461,8 @@ lxb_selectors_pseudo_element(lxb_selectors_t *selectors,
+@@ -1428,6 +1458,8 @@ lxb_selectors_pseudo_element(lxb_selectors_t *selectors,
      lxb_css_selector_pseudo_t *pseudo = &selector->u.pseudo;
  
      switch (pseudo->type) {

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

@@ -2,7 +2,7 @@ diff --git i/source/lexbor/selectors/selectors.c w/source/lexbor/selectors/selec
 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,
+@@ -750,7 +780,7 @@ lxb_selectors_match(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry,
              src = &selector->name;
  
              if (trg->length == src->length
@@ -11,7 +11,7 @@ index c2d18ea..84b5b14 100644
              {
                  return true;
              }
-@@ -766,7 +798,7 @@ lxb_selectors_match(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry,
+@@ -765,7 +795,7 @@ lxb_selectors_match(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry,
              }
  
              return lxb_selectors_match_class(element->attr_class->value,

data/vendor/lexbor/source/lexbor/core/lexbor.h

@@ -13,6 +13,10 @@ extern "C" {
 
 #include "lexbor/core/def.h"
 
+typedef void *(*lexbor_memory_malloc_f)(size_t size);
+typedef void *(*lexbor_memory_realloc_f)(void *dst, size_t size);
+typedef void *(*lexbor_memory_calloc_f)(size_t num, size_t size);
+typedef void (*lexbor_memory_free_f)(void *dst);
 
 LXB_API void *
 lexbor_malloc(size_t size);
@@ -26,6 +30,10 @@ lexbor_calloc(size_t num, size_t size);
 LXB_API void *
 lexbor_free(void *dst);
 
+LXB_API lxb_status_t
+lexbor_memory_setup(lexbor_memory_malloc_f new_malloc, lexbor_memory_realloc_f new_realloc,
+                    lexbor_memory_calloc_f new_calloc, lexbor_memory_free_f new_free);
+
 
 #ifdef __cplusplus
 } /* extern "C" */

data/vendor/lexbor/source/lexbor/ports/posix/lexbor/core/memory.c

@@ -6,28 +6,48 @@
 
 #include "lexbor/core/base.h"
 
+static lexbor_memory_malloc_f lexbor_memory_malloc = malloc;
+static lexbor_memory_realloc_f lexbor_memory_realloc = realloc;
+static lexbor_memory_calloc_f lexbor_memory_calloc = calloc;
+static lexbor_memory_free_f lexbor_memory_free = free;
 
 void *
 lexbor_malloc(size_t size)
 {
-    return malloc(size);
+    return lexbor_memory_malloc(size);
 }
 
 void *
 lexbor_realloc(void *dst, size_t size)
 {
-    return realloc(dst, size);
+    return lexbor_memory_realloc(dst, size);
 }
 
 void *
 lexbor_calloc(size_t num, size_t size)
 {
-    return calloc(num, size);
+    return lexbor_memory_calloc(num, size);
 }
 
 void *
 lexbor_free(void *dst)
 {
-    free(dst);
+    lexbor_memory_free(dst);
     return NULL;
 }
+
+lxb_status_t
+lexbor_memory_setup(lexbor_memory_malloc_f new_malloc, lexbor_memory_realloc_f new_realloc,
+                    lexbor_memory_calloc_f new_calloc, lexbor_memory_free_f new_free)
+{
+    if (new_malloc == NULL || new_realloc == NULL || new_calloc == NULL || new_free == NULL) {
+        return LXB_STATUS_ERROR_OBJECT_IS_NULL;
+    }
+
+    lexbor_memory_malloc = new_malloc;
+    lexbor_memory_realloc = new_realloc;
+    lexbor_memory_calloc = new_calloc;
+    lexbor_memory_free = new_free;
+
+    return LXB_STATUS_OK;
+}

data/vendor/lexbor/source/lexbor/ports/windows_nt/lexbor/core/memory.c

@@ -6,28 +6,48 @@
 
 #include "lexbor/core/base.h"
 
+static lexbor_memory_malloc_f lexbor_memory_malloc = malloc;
+static lexbor_memory_realloc_f lexbor_memory_realloc = realloc;
+static lexbor_memory_calloc_f lexbor_memory_calloc = calloc;
+static lexbor_memory_free_f lexbor_memory_free = free;
 
 void *
 lexbor_malloc(size_t size)
 {
-    return malloc(size);
+    return lexbor_memory_malloc(size);
 }
 
 void *
 lexbor_realloc(void *dst, size_t size)
 {
-    return realloc(dst, size);
+    return lexbor_memory_realloc(dst, size);
 }
 
 void *
 lexbor_calloc(size_t num, size_t size)
 {
-    return calloc(num, size);
+    return lexbor_memory_calloc(num, size);
 }
 
 void *
 lexbor_free(void *dst)
 {
-    free(dst);
+    lexbor_memory_free(dst);
     return NULL;
 }
+
+lxb_status_t
+lexbor_memory_setup(lexbor_memory_malloc_f new_malloc, lexbor_memory_realloc_f new_realloc,
+                    lexbor_memory_calloc_f new_calloc, lexbor_memory_free_f new_free)
+{
+    if (new_malloc == NULL || new_realloc == NULL || new_calloc == NULL || new_free == NULL) {
+        return LXB_STATUS_ERROR_OBJECT_IS_NULL;
+    }
+
+    lexbor_memory_malloc = new_malloc;
+    lexbor_memory_realloc = new_realloc;
+    lexbor_memory_calloc = new_calloc;
+    lexbor_memory_free = new_free;
+
+    return LXB_STATUS_OK;
+}

data/vendor/lexbor/source/lexbor/selectors/selectors.c

@@ -262,7 +262,7 @@ lxb_selectors_sibling(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry,
 {
     node = node->next;
 
-    do {
+    while (node != NULL) {
         if (node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
             if (lxb_selectors_match(selectors, entry, selector, node)) {
                 return node;
@@ -273,7 +273,6 @@ lxb_selectors_sibling(lxb_selectors_t *selectors, lxb_selectors_entry_t *entry,
 
         node = node->next;
     }
-    while (node != NULL);
 
     return NULL;
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nokolexbor
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Yicheng Zhou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-31 00:00:00.000000000 Z
+date: 2023-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -78,12 +78,14 @@ files:
 - ext/nokolexbor/libxml/xpath.h
 - ext/nokolexbor/libxml/xpathInternals.h
 - ext/nokolexbor/libxml/xpointer.h
-- ext/nokolexbor/memory.c
 - ext/nokolexbor/nl_cdata.c
 - ext/nokolexbor/nl_comment.c
 - ext/nokolexbor/nl_document.c
+- ext/nokolexbor/nl_document_fragment.c
+- ext/nokolexbor/nl_error.c
 - ext/nokolexbor/nl_node.c
 - ext/nokolexbor/nl_node_set.c
+- ext/nokolexbor/nl_processing_instruction.c
 - ext/nokolexbor/nl_text.c
 - ext/nokolexbor/nl_xpath_context.c
 - ext/nokolexbor/nokolexbor.c
@@ -119,6 +121,7 @@ files:
 - lib/nokolexbor.rb
 - lib/nokolexbor/attribute.rb
 - lib/nokolexbor/document.rb
+- lib/nokolexbor/document_fragment.rb
 - lib/nokolexbor/node.rb
 - lib/nokolexbor/node_set.rb
 - lib/nokolexbor/version.rb

data/ext/nokolexbor/memory.c

@@ -1,46 +0,0 @@
-/*
- * This file overrides the default `lexbor_malloc` and other
- * related functions to reduce memory bloat and allow Ruby to
- * GC more often.
- * By calling `ruby_xmalloc` instead of `malloc`, Ruby can
- * count the memory usage of the C extension and run GC
- * whenever `malloc_increase_byte` exceeds the limit. Similar
- * to Nokogiri's solution by calling `xmlMemSetup`.
- * The downside will be the downgrade of performance because
- * of more frequent GC.
- */
-
-#include "lexbor/core/base.h"
-#include <ruby.h>
-
-// Disable using ruby memory functions when ASAN is enabled,
-// otherwise memory leak info will be all about ruby which
-// is useless.
-#ifndef NOKOLEXBOR_ASAN
-
-void *
-lexbor_malloc(size_t size)
-{
-  return ruby_xmalloc(size);
-}
-
-void *
-lexbor_realloc(void *dst, size_t size)
-{
-  return ruby_xrealloc(dst, size);
-}
-
-void *
-lexbor_calloc(size_t num, size_t size)
-{
-  return ruby_xcalloc(num, size);
-}
-
-void *
-lexbor_free(void *dst)
-{
-  ruby_xfree(dst);
-  return NULL;
-}
-
-#endif