nokolexbor 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5eb708d3b21135112c1e1f373b89f94b83c4926043da9743aff108f4d4eed72
-  data.tar.gz: 5ba497f52ea19c49816e1ec9c2b5e12449ae4f812cb011f2953ba7cf1a0b971b
+  metadata.gz: 7e93c293e8d506960077c772b822d4f75103d6583b8864e56f343a8ad6229c7a
+  data.tar.gz: 1baaaed733eae123b895e21021709fed7a7e185a10e8c27cf0d43105e7e4a272
 SHA512:
-  metadata.gz: ff508a1599f36608c4c7ae0b360d4f2eb6f4740c059a945215dcdbc27a457a74293a2de6ba4043b5db5601dacccd4befac396b85a824e615163ab36f2a603bcb
-  data.tar.gz: 1699d675b60d76a12da000e6bc0844842a31f910b80350a5e87bedaf4474e8078099623eeaeb1e1169c16ec23a51a4d0112aebf76c9ef25ac358a347992f32da
+  metadata.gz: 665232217ba5f1b0a53ad67dfcbb38244685fab9242bf718b1364b59c3b623e5150bdd471284c3424fb2c319761c30f1022d7792e1edf848e3c4c0a41de89806
+  data.tar.gz: 81cc64f435de161807ce0a6d3a0c8b0875a51f0f49307a763be8be4c70b3eefd0a5ea36fb364d2fec2e37b6b3307d549fc0f0bbd3afe35f47b6b797ea5998b96

data/ext/nokolexbor/nl_document.c

@@ -5,7 +5,7 @@ extern VALUE cNokolexborNode;
 VALUE cNokolexborDocument;
 
 static void
-free_nl_document(lxb_dom_document_t *document)
+free_nl_document(lxb_html_document_t *document)
 {
   lxb_html_document_destroy(document);
 }
@@ -25,7 +25,7 @@ static VALUE
 nl_document_parse(VALUE self, VALUE rb_html)
 {
   const char *html_c = StringValuePtr(rb_html);
-  int html_len = RSTRING_LEN(rb_html);
+  size_t html_len = RSTRING_LEN(rb_html);
 
   lxb_html_document_t *document;
 
@@ -35,13 +35,13 @@ nl_document_parse(VALUE self, VALUE rb_html)
     rb_raise(rb_eRuntimeError, "Error creating document");
   }
 
-  lxb_status_t status = lxb_html_document_parse(document, 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);
   }
 
-  return TypedData_Wrap_Struct(cNokolexborDocument, &nl_document_type, &document->dom_document);
+  return TypedData_Wrap_Struct(cNokolexborDocument, &nl_document_type, document);
 }
 
 static VALUE
@@ -50,6 +50,14 @@ nl_document_new(VALUE self)
   return nl_document_parse(self, rb_str_new("", 0));
 }
 
+lxb_dom_document_t *
+nl_rb_document_unwrap(VALUE rb_doc)
+{
+  lxb_dom_document_t *doc;
+  TypedData_Get_Struct(rb_doc, lxb_dom_document_t, &nl_document_type, doc);
+  return doc;
+}
+
 void Init_nl_document(void)
 {
   cNokolexborDocument = rb_define_class_under(mNokolexbor, "Document", cNokolexborNode);

data/ext/nokolexbor/nl_node.c

@@ -43,7 +43,7 @@ nl_rb_node_unwrap(VALUE rb_node)
   lxb_dom_node_t *node;
   if (rb_obj_class(rb_node) == cNokolexborDocument)
   {
-    TypedData_Get_Struct(rb_node, lxb_dom_document_t, &nl_document_type, node);
+    TypedData_Get_Struct(rb_node, lxb_dom_node_t, &nl_document_type, node);
   }
   else
   {
@@ -56,7 +56,6 @@ static VALUE
 nl_node_new(int argc, VALUE *argv, VALUE klass)
 {
   lxb_dom_document_t *document;
-  lxb_dom_node_t *node;
   VALUE rb_name;
   VALUE rb_document;
   VALUE rest;
@@ -68,9 +67,9 @@ nl_node_new(int argc, VALUE *argv, VALUE klass)
     rb_raise(rb_eArgError, "Document must be a Nokolexbor::Document");
   }
 
-  TypedData_Get_Struct(rb_document, lxb_dom_document_t, &nl_document_type, document);
+  document = nl_rb_document_unwrap(rb_document);
 
-  lxb_dom_element_t *element = lxb_dom_document_create_element(document, StringValueCStr(rb_name), RSTRING_LEN(rb_name), NULL);
+  lxb_dom_element_t *element = lxb_dom_document_create_element(document, (const lxb_char_t *)StringValueCStr(rb_name), RSTRING_LEN(rb_name), NULL);
   if (element == NULL)
   {
     rb_raise(rb_eRuntimeError, "Error creating element");
@@ -97,7 +96,7 @@ nl_node_content(VALUE self)
   {
     return rb_str_new("", 0);
   }
-  VALUE rb_str = rb_utf8_str_new(text, str_len);
+  VALUE rb_str = rb_utf8_str_new((char *)text, str_len);
   lxb_dom_document_destroy_text(node->owner_document, text);
 
   return rb_str;
@@ -115,19 +114,19 @@ nl_node_get_attr(VALUE self, VALUE rb_attr)
 
   VALUE rb_attr_s = rb_String(rb_attr);
   const char *attr_c = RSTRING_PTR(rb_attr_s);
-  int attr_len = RSTRING_LEN(rb_attr_s);
+  size_t attr_len = RSTRING_LEN(rb_attr_s);
 
-  lxb_dom_element_t *element = lxb_html_interface_element(node);
+  lxb_dom_element_t *element = lxb_dom_interface_element(node);
 
-  if (!lxb_dom_element_has_attribute(element, attr_c, attr_len))
+  if (!lxb_dom_element_has_attribute(element, (const lxb_char_t *)attr_c, attr_len))
   {
     return Qnil;
   }
 
   size_t attr_value_len;
-  char *attr_value = lxb_dom_element_get_attribute(element, attr_c, attr_len, &attr_value_len);
+  const lxb_char_t *attr_value = lxb_dom_element_get_attribute(element, (const lxb_char_t *)attr_c, attr_len, &attr_value_len);
 
-  return rb_utf8_str_new(attr_value, attr_value_len);
+  return rb_utf8_str_new((const char *)attr_value, attr_value_len);
 }
 
 static VALUE
@@ -144,13 +143,13 @@ nl_node_set_attr(VALUE self, VALUE rb_attr, VALUE rb_value)
   VALUE rb_value_s = rb_String(rb_value);
 
   const char *attr_c = RSTRING_PTR(rb_attr_s);
-  int attr_len = RSTRING_LEN(rb_attr_s);
+  size_t attr_len = RSTRING_LEN(rb_attr_s);
   const char *value_c = RSTRING_PTR(rb_value_s);
-  int value_len = RSTRING_LEN(rb_value_s);
+  size_t value_len = RSTRING_LEN(rb_value_s);
 
-  lxb_dom_element_t *element = lxb_html_interface_element(node);
+  lxb_dom_element_t *element = lxb_dom_interface_element(node);
 
-  lxb_dom_element_set_attribute(element, attr_c, attr_len, value_c, value_len);
+  lxb_dom_element_set_attribute(element, (const lxb_char_t *)attr_c, attr_len, (const lxb_char_t *)value_c, value_len);
 
   return rb_value;
 }
@@ -168,14 +167,14 @@ nl_node_remove_attr(VALUE self, VALUE rb_attr)
   VALUE rb_attr_s = rb_String(rb_attr);
 
   const char *attr_c = RSTRING_PTR(rb_attr_s);
-  int attr_len = RSTRING_LEN(rb_attr_s);
+  size_t attr_len = RSTRING_LEN(rb_attr_s);
 
-  lxb_dom_element_t *element = lxb_html_interface_element(node);
+  lxb_dom_element_t *element = lxb_dom_interface_element(node);
 
-  return lxb_dom_element_remove_attribute(element, attr_c, attr_len) == LXB_STATUS_OK ? Qtrue : Qfalse;
+  return lxb_dom_element_remove_attribute(element, (const lxb_char_t *)attr_c, attr_len) == LXB_STATUS_OK ? Qtrue : Qfalse;
 }
 
-static lxb_status_t
+lxb_status_t
 nl_node_at_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx)
 {
   lexbor_array_t *array = (lexbor_array_t *)ctx;
@@ -188,7 +187,7 @@ nl_node_at_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *sp
   return LXB_STATUS_STOP;
 }
 
-static lxb_status_t
+lxb_status_t
 nl_node_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx)
 {
   lexbor_array_t *array = (lexbor_array_t *)ctx;
@@ -200,11 +199,11 @@ nl_node_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec,
   return LXB_STATUS_OK;
 }
 
-static void
+void
 nl_node_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void *ctx)
 {
   const char *selector_c = StringValuePtr(selector);
-  int selector_len = RSTRING_LEN(selector);
+  size_t selector_len = RSTRING_LEN(selector);
 
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
 
@@ -226,7 +225,7 @@ nl_node_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void *ctx)
 
   /* Parse and get the log. */
   // TODO: Cache the list for reuse, improves performance
-  lxb_css_selector_list_t *list = lxb_css_selectors_parse_relative_list(parser, selector_c, selector_len);
+  lxb_css_selector_list_t *list = lxb_css_selectors_parse_relative_list(parser, (const lxb_char_t *)selector_c, selector_len);
   if (parser->status != LXB_STATUS_OK)
   {
     nl_raise_lexbor_error(parser->status);
@@ -252,15 +251,15 @@ nl_node_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void *ctx)
 static void
 mark_node_orders(lxb_dom_node_t *root)
 {
-  int count = 1;
-  root->user = count;
+  size_t count = 1;
+  root->user = (void *)count;
   lxb_dom_node_t *node = root;
   do
   {
     if (node->first_child != NULL)
     {
       node = node->first_child;
-      node->user = ++count;
+      node->user = (void *)++count;
     }
     else
     {
@@ -275,7 +274,7 @@ mark_node_orders(lxb_dom_node_t *root)
       }
 
       node = node->next;
-      node->user = ++count;
+      node->user = (void *)++count;
     }
 
   } while (true);
@@ -290,7 +289,7 @@ void sort_nodes_if_necessary(VALUE selector, lxb_dom_document_t *doc, lexbor_arr
     int need_order = 0;
     // Check if we have already markded orders, note that
     // we need to order again if new nodes are added to the document
-    for (int i = 0; i < array->length; i++)
+    for (size_t i = 0; i < array->length; i++)
     {
       if (((lxb_dom_node_t *)array->list[i])->user == 0)
       {
@@ -300,13 +299,13 @@ void sort_nodes_if_necessary(VALUE selector, lxb_dom_document_t *doc, lexbor_arr
     }
     if (need_order)
     {
-      mark_node_orders(doc);
+      mark_node_orders(&doc->node);
     }
-    css_result_tim_sort(&array->list[0], array->length);
+    css_result_tim_sort((lxb_dom_node_t **)&array->list[0], array->length);
   }
 }
 
-VALUE
+static VALUE
 nl_node_at_css(VALUE self, VALUE selector)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
@@ -321,10 +320,14 @@ nl_node_at_css(VALUE self, VALUE selector)
 
   sort_nodes_if_necessary(selector, node->owner_document, array);
 
-  return nl_rb_node_create(array->list[0], nl_rb_document_get(self));
+  VALUE ret = nl_rb_node_create(array->list[0], nl_rb_document_get(self));
+
+  lexbor_array_destroy(array, true);
+
+  return ret;
 }
 
-VALUE
+static VALUE
 nl_node_css(VALUE self, VALUE selector)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
@@ -354,7 +357,7 @@ nl_node_inner_html(VALUE self)
 
   if (str.data != NULL)
   {
-    VALUE ret = rb_utf8_str_new(str.data, str.length);
+    VALUE ret = rb_utf8_str_new((const char *)str.data, str.length);
     lexbor_str_destroy(&str, node->owner_document->text, false);
     return ret;
   }
@@ -379,7 +382,7 @@ nl_node_outer_html(VALUE self)
 
   if (str.data != NULL)
   {
-    VALUE ret = rb_utf8_str_new(str.data, str.length);
+    VALUE ret = rb_utf8_str_new((const char *)str.data, str.length);
     lexbor_str_destroy(&str, node->owner_document->text, false);
     return ret;
   }
@@ -399,11 +402,11 @@ nl_node_has_key(VALUE self, VALUE rb_attr)
 
   VALUE rb_attr_s = rb_String(rb_attr);
   const char *attr_c = RSTRING_PTR(rb_attr_s);
-  int attr_len = RSTRING_LEN(rb_attr_s);
+  size_t attr_len = RSTRING_LEN(rb_attr_s);
 
-  lxb_dom_element_t *element = lxb_html_interface_element(node);
+  lxb_dom_element_t *element = lxb_dom_interface_element(node);
 
-  return lxb_dom_element_has_attribute(element, attr_c, attr_len) ? Qtrue : Qfalse;
+  return lxb_dom_element_has_attribute(element, (const lxb_char_t *)attr_c, attr_len) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -417,13 +420,13 @@ nl_node_keys(VALUE self)
     return ary_keys;
   }
 
-  lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_html_interface_element(node));
+  lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_dom_interface_element(node));
 
   while (attr != NULL)
   {
     size_t tmp_len;
-    lxb_char_t *tmp = lxb_dom_attr_qualified_name(attr, &tmp_len);
-    rb_ary_push(ary_keys, rb_utf8_str_new(tmp, tmp_len));
+    const lxb_char_t *tmp = lxb_dom_attr_qualified_name(attr, &tmp_len);
+    rb_ary_push(ary_keys, rb_utf8_str_new((const char *)tmp, tmp_len));
 
     attr = lxb_dom_element_next_attribute(attr);
   }
@@ -442,15 +445,19 @@ nl_node_values(VALUE self)
     return ary_values;
   }
 
-  lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_html_interface_element(node));
+  lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_dom_interface_element(node));
 
   while (attr != NULL)
   {
     size_t tmp_len;
-    lxb_char_t *tmp = lxb_dom_attr_value(attr, &tmp_len);
+    const lxb_char_t *tmp = lxb_dom_attr_value(attr, &tmp_len);
     if (tmp != NULL)
     {
-      rb_ary_push(ary_values, rb_utf8_str_new(tmp, tmp_len));
+      rb_ary_push(ary_values, rb_utf8_str_new((const char *)tmp, tmp_len));
+    }
+    else
+    {
+      rb_ary_push(ary_values, rb_str_new("", 0));
     }
 
     attr = lxb_dom_element_next_attribute(attr);
@@ -470,16 +477,16 @@ nl_node_attrs(VALUE self)
     return rb_hash;
   }
 
-  lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_html_interface_element(node));
+  lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_dom_interface_element(node));
 
   while (attr != NULL)
   {
     size_t tmp_len;
-    lxb_char_t *tmp = lxb_dom_attr_qualified_name(attr, &tmp_len);
-    VALUE rb_key = rb_utf8_str_new(tmp, tmp_len);
+    const lxb_char_t *tmp = lxb_dom_attr_qualified_name(attr, &tmp_len);
+    VALUE rb_key = rb_utf8_str_new((const char *)tmp, tmp_len);
 
     tmp = lxb_dom_attr_value(attr, &tmp_len);
-    VALUE rb_value = tmp != NULL ? rb_utf8_str_new(tmp, tmp_len) : Qnil;
+    VALUE rb_value = tmp != NULL ? rb_utf8_str_new((const char *)tmp, tmp_len) : rb_str_new("", 0);
 
     rb_hash_aset(rb_hash, rb_key, rb_value);
 
@@ -604,15 +611,16 @@ nl_node_name(VALUE self)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
   size_t len;
-  lxb_char_t *name = lxb_dom_node_name_qualified(node, &len);
-  return rb_utf8_str_new(name, len);
+  const lxb_char_t *name = lxb_dom_node_name_qualified(node, &len);
+  return rb_utf8_str_new((const char *)name, len);
 }
 
 static lxb_dom_node_t *
-nl_node_parse_fragment(lxb_html_document_t *doc, lxb_char_t *html, size_t size)
+nl_node_parse_fragment(lxb_dom_document_t *doc, lxb_char_t *html, size_t size)
 {
   size_t tag_name_len;
-  lxb_char_t *tag_name = lxb_tag_name_by_id(lxb_html_document_tags(doc), LXB_TAG__UNDEF, &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");
@@ -622,7 +630,7 @@ nl_node_parse_fragment(lxb_html_document_t *doc, lxb_char_t *html, size_t size)
   {
     rb_raise(rb_eRuntimeError, "Error creating element");
   }
-  lxb_dom_node_t *frag_root = lxb_html_document_parse_fragment(doc, element, html, size);
+  lxb_dom_node_t *frag_root = lxb_html_document_parse_fragment(html_doc, element, html, size);
   if (frag_root == NULL)
   {
     rb_raise(rb_eArgError, "Error parsing HTML");
@@ -637,7 +645,7 @@ nl_node_fragment(VALUE self, VALUE html)
   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, RSTRING_PTR(html), RSTRING_LEN(html));
+  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));
 }
 
@@ -663,7 +671,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, RSTRING_PTR(new), RSTRING_LEN(new));
+    lxb_dom_node_t *frag_root = nl_node_parse_fragment(doc, (lxb_char_t *)RSTRING_PTR(new), RSTRING_LEN(new));
 
     while (frag_root->first_child != NULL)
     {
@@ -694,7 +702,7 @@ nl_node_add_child(VALUE self, VALUE new)
 
   if (TYPE(new) == T_STRING)
   {
-    lxb_dom_node_t *frag_root = nl_node_parse_fragment(doc, RSTRING_PTR(new), RSTRING_LEN(new));
+    lxb_dom_node_t *frag_root = nl_node_parse_fragment(doc, (lxb_char_t *)RSTRING_PTR(new), RSTRING_LEN(new));
 
     while (frag_root->first_child != NULL)
     {
@@ -832,11 +840,13 @@ void Init_nl_node(void)
 
   rb_define_alias(cNokolexborNode, "attr", "[]");
   rb_define_alias(cNokolexborNode, "set_attr", "[]=");
+  rb_define_alias(cNokolexborNode, "delete", "remove_attr");
   rb_define_alias(cNokolexborNode, "text", "content");
   rb_define_alias(cNokolexborNode, "inner_text", "content");
   rb_define_alias(cNokolexborNode, "to_str", "content");
   rb_define_alias(cNokolexborNode, "to_html", "outer_html");
   rb_define_alias(cNokolexborNode, "to_s", "outer_html");
+  rb_define_alias(cNokolexborNode, "unlink", "remove");
   rb_define_alias(cNokolexborNode, "type", "node_type");
   rb_define_alias(cNokolexborNode, "dup", "clone");
 }

data/ext/nokolexbor/nl_node_set.c

@@ -5,15 +5,15 @@ extern VALUE cNokolexborNode;
 VALUE cNokolexborNodeSet;
 extern rb_data_type_t nl_document_type;
 
-VALUE nl_node_at_css(VALUE self, VALUE selector);
-VALUE nl_node_css(VALUE self, VALUE selector);
-
-typedef VALUE (*nl_node_find_f)(VALUE self, VALUE selector);
+void nl_node_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void *ctx);
+void sort_nodes_if_necessary(VALUE selector, lxb_dom_document_t *doc, lexbor_array_t *array);
+lxb_status_t nl_node_at_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx);
+lxb_status_t nl_node_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec, void *ctx);
 
 lxb_status_t
 lexbor_array_push_unique(lexbor_array_t *array, void *value)
 {
-  for (int i = 0; i < array->length; i++)
+  for (size_t i = 0; i < array->length; i++)
     if (array->list[i] == value)
       return LXB_STATUS_STOPPED;
 
@@ -91,7 +91,7 @@ nl_node_set_delete(VALUE self, VALUE rb_node)
   lexbor_array_t *array = nl_rb_node_set_unwrap(self);
   lxb_dom_node_t *node = nl_rb_node_unwrap(rb_node);
 
-  int i;
+  size_t i;
   for (i = 0; i < array->length; i++)
     if (array->list[i] == node)
     {
@@ -113,7 +113,7 @@ nl_node_set_is_include(VALUE self, VALUE rb_node)
   lexbor_array_t *array = nl_rb_node_set_unwrap(self);
   lxb_dom_node_t *node = nl_rb_node_unwrap(rb_node);
 
-  for (int i = 0; i < array->length; i++)
+  for (size_t i = 0; i < array->length; i++)
     if (array->list[i] == node)
     {
       return Qtrue;
@@ -169,7 +169,7 @@ nl_node_set_subseq(VALUE self, long beg, long len)
     }
   }
 
-  for (int j = beg; j < beg + len; ++j)
+  for (long j = beg; j < beg + len; ++j)
   {
     lxb_status_t status = lexbor_array_push(new_array, old_array->list[j]);
     if (status != LXB_STATUS_OK)
@@ -177,7 +177,7 @@ nl_node_set_subseq(VALUE self, long beg, long len)
       nl_raise_lexbor_error(status);
     }
   }
-  return TypedData_Wrap_Struct(cNokolexborNodeSet, &nl_node_set_type, new_array);
+  return nl_rb_node_set_create_with_data(new_array, nl_rb_document_get(self));
 }
 
 static VALUE
@@ -231,7 +231,7 @@ nl_node_set_to_array(VALUE self)
 
   VALUE list = rb_ary_new2(array->length);
   VALUE doc = nl_rb_document_get(self);
-  for (int i = 0; i < array->length; i++)
+  for (size_t i = 0; i < array->length; i++)
   {
     lxb_dom_node_t *node = (lxb_dom_node_t *)array->list[i];
     VALUE rb_node = nl_rb_node_create(node, doc);
@@ -267,7 +267,7 @@ nl_node_set_union(VALUE self, VALUE other)
   memcpy(new_array->list, self_array->list, sizeof(lxb_dom_node_t *) * self_array->length);
   new_array->length = self_array->length;
 
-  for (int i = 0; i < other_array->length; i++)
+  for (size_t i = 0; i < other_array->length; i++)
   {
     lexbor_array_push_unique(new_array, other_array->list[i]);
   }
@@ -275,16 +275,15 @@ nl_node_set_union(VALUE self, VALUE other)
   return nl_rb_node_set_create_with_data(new_array, nl_rb_document_get(self));
 }
 
-static VALUE
-nl_node_set_find(VALUE self, VALUE selector, nl_node_find_f finder)
+static void
+nl_node_set_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void* ctx)
 {
-  VALUE rb_doc = nl_rb_document_get(self);
-  lxb_dom_document_t *doc;
-  TypedData_Get_Struct(rb_doc, lxb_dom_document_t, &nl_document_type, doc);
+  lxb_dom_document_t *doc = nl_rb_document_unwrap(nl_rb_document_get(self));
   if (doc == NULL)
   {
     rb_raise(rb_eRuntimeError, "Error getting document");
   }
+  // Wrap direct children with a temporary fragment so that they can be searched
   lxb_dom_document_fragment_t *frag = lxb_dom_document_fragment_interface_create(doc);
   if (frag == NULL)
   {
@@ -302,7 +301,7 @@ nl_node_set_find(VALUE self, VALUE selector, nl_node_find_f finder)
     }
   }
   // Backup original node data and re-group them into a fragment
-  for (int i = 0; i < array->length; i++)
+  for (size_t i = 0; i < array->length; i++)
   {
     lxb_dom_node_t *node = (lxb_dom_node_t *)array->list[i];
     lxb_dom_node_t *backup_node = malloc(sizeof(lxb_dom_node_t));
@@ -320,29 +319,51 @@ nl_node_set_find(VALUE self, VALUE selector, nl_node_find_f finder)
   }
   VALUE rb_frag = nl_rb_node_create(&frag->node, nl_rb_document_get(self));
 
-  VALUE ret = finder(rb_frag, selector);
+  nl_node_find(rb_frag, selector, cb, ctx);
 
   lxb_dom_document_fragment_interface_destroy(frag);
   // Restore original node data
-  for (int i = 0; i < array->length; i++)
+  for (size_t i = 0; i < array->length; i++)
   {
     memcpy(array->list[i], backup_array->list[i], sizeof(lxb_dom_node_t));
     free(backup_array->list[i]);
   }
   lexbor_array_destroy(backup_array, true);
-  return ret;
 }
 
 static VALUE
 nl_node_set_at_css(VALUE self, VALUE selector)
 {
-  return nl_node_set_find(self, selector, nl_node_at_css);
+  lexbor_array_t *array = lexbor_array_create();
+  lxb_dom_document_t *doc = nl_rb_document_unwrap(nl_rb_document_get(self));
+
+  nl_node_set_find(self, selector, nl_node_at_css_callback, array);
+
+  if (array->length == 0)
+  {
+    return Qnil;
+  }
+
+  sort_nodes_if_necessary(selector, doc, array);
+
+  VALUE ret = nl_rb_node_create(array->list[0], nl_rb_document_get(self));
+
+  lexbor_array_destroy(array, true);
+
+  return ret;
 }
 
 static VALUE
 nl_node_set_css(VALUE self, VALUE selector)
 {
-  return nl_node_set_find(self, selector, nl_node_css);
+  lexbor_array_t *array = lexbor_array_create();
+  lxb_dom_document_t *doc = nl_rb_document_unwrap(nl_rb_document_get(self));
+
+  nl_node_set_find(self, selector, nl_node_css_callback, array);
+
+  sort_nodes_if_necessary(selector, doc, array);
+
+  return nl_rb_node_set_create_with_data(array, nl_rb_document_get(self));
 }
 
 void Init_nl_node_set(void)

data/ext/nokolexbor/nl_xpath_context.c

@@ -7,9 +7,13 @@
 #include "libxml/xpathInternals.h"
 #include "libxml/parserInternals.h"
 
+#define RBSTR_OR_QNIL(_str) (_str ? rb_utf8_str_new_cstr(_str) : Qnil)
+
 extern VALUE mNokolexbor;
 extern VALUE cNokolexborNodeSet;
-VALUE cNokoLexborXpathContext;
+VALUE cNokolexborXpathContext;
+VALUE mNokolexborXpath;
+VALUE cNokolexborXpathSyntaxError;
 
 static void
 free_xml_xpath_context(xmlXPathContextPtr ctx)
@@ -24,7 +28,7 @@ free_xml_xpath_context(xmlXPathContextPtr ctx)
  * Register the namespace with +prefix+ and +uri+.
  */
 static VALUE
-rb_xml_xpath_context_register_ns(VALUE self, VALUE prefix, VALUE uri)
+nl_xpath_context_register_ns(VALUE self, VALUE prefix, VALUE uri)
 {
   xmlXPathContextPtr ctx;
   Data_Get_Struct(self, xmlXPathContext, ctx);
@@ -42,7 +46,7 @@ rb_xml_xpath_context_register_ns(VALUE self, VALUE prefix, VALUE uri)
  * Register the variable +name+ with +value+.
  */
 static VALUE
-rb_xml_xpath_context_register_variable(VALUE self, VALUE name, VALUE value)
+nl_xpath_context_register_variable(VALUE self, VALUE name, VALUE value)
 {
   xmlXPathContextPtr ctx;
   xmlXPathObjectPtr xmlValue;
@@ -69,7 +73,7 @@ xpath2ruby(xmlXPathObjectPtr c_xpath_object, xmlXPathContextPtr ctx, VALUE rb_do
   switch (c_xpath_object->type)
   {
   case XPATH_STRING:
-    rb_retval = rb_utf8_str_new_cstr(c_xpath_object->stringval);
+    rb_retval = rb_utf8_str_new_cstr((const char *)c_xpath_object->stringval);
     xmlFree(c_xpath_object->stringval);
     return rb_retval;
 
@@ -106,6 +110,60 @@ xpath2ruby(xmlXPathObjectPtr c_xpath_object, xmlXPathContextPtr ctx, VALUE rb_do
   }
 }
 
+static VALUE
+nl_xpath_wrap_syntax_error(xmlErrorPtr error)
+{
+  VALUE msg, e;
+
+  msg = (error && error->message) ? rb_utf8_str_new_cstr(error->message) : Qnil;
+
+  e = rb_class_new_instance(
+      1,
+      &msg,
+      cNokolexborXpathSyntaxError);
+
+  if (error)
+  {
+    rb_iv_set(e, "@domain", INT2NUM(error->domain));
+    rb_iv_set(e, "@code", INT2NUM(error->code));
+    rb_iv_set(e, "@level", INT2NUM((short)error->level));
+    rb_iv_set(e, "@file", RBSTR_OR_QNIL(error->file));
+    rb_iv_set(e, "@line", INT2NUM(error->line));
+    rb_iv_set(e, "@str1", RBSTR_OR_QNIL(error->str1));
+    rb_iv_set(e, "@str2", RBSTR_OR_QNIL(error->str2));
+    rb_iv_set(e, "@str3", RBSTR_OR_QNIL(error->str3));
+    rb_iv_set(e, "@int1", INT2NUM(error->int1));
+    rb_iv_set(e, "@column", INT2NUM(error->int2));
+  }
+
+  return e;
+}
+
+static void nl_xpath_error_array_pusher(void *ctx, xmlErrorPtr error)
+{
+  VALUE list = (VALUE)ctx;
+  Check_Type(list, T_ARRAY);
+  rb_ary_push(list, nl_xpath_wrap_syntax_error(error));
+}
+
+static void
+nl_xpath_generic_exception_pusher(void *ctx, const char *msg, ...)
+{
+  VALUE rb_errors = (VALUE)ctx;
+  VALUE rb_message;
+  VALUE rb_exception;
+
+  Check_Type(rb_errors, T_ARRAY);
+
+  va_list args;
+  va_start(args, msg);
+  rb_message = rb_vsprintf(msg, args);
+  va_end(args);
+
+  rb_exception = rb_exc_new_str(cNokolexborXpathSyntaxError, rb_message);
+  rb_ary_push(rb_errors, rb_exception);
+}
+
 /*
  * call-seq:
  *  evaluate(search_path, handler = nil)
@@ -113,7 +171,7 @@ xpath2ruby(xmlXPathObjectPtr c_xpath_object, xmlXPathContextPtr ctx, VALUE rb_do
  * Evaluate the +search_path+ returning an XML::XPath object.
  */
 static VALUE
-rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE self)
+nl_xpath_context_evaluate(int argc, VALUE *argv, VALUE self)
 {
   VALUE search_path, xpath_handler;
   VALUE retval = Qnil;
@@ -137,13 +195,13 @@ rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE self)
   //   xmlXPathRegisterFuncLookup(ctx, handler_lookup, (void *)xpath_handler);
   // }
 
-  // xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
-  // xmlSetGenericErrorFunc((void *)errors, generic_exception_pusher);
+  xmlSetStructuredErrorFunc((void *)errors, nl_xpath_error_array_pusher);
+  xmlSetGenericErrorFunc((void *)errors, nl_xpath_generic_exception_pusher);
 
   xpath = xmlXPathEvalExpression(query, ctx);
 
-  // xmlSetStructuredErrorFunc(NULL, NULL);
-  // xmlSetGenericErrorFunc(NULL, NULL);
+  xmlSetStructuredErrorFunc(NULL, NULL);
+  xmlSetGenericErrorFunc(NULL, NULL);
 
   if (xpath == NULL)
   {
@@ -156,7 +214,7 @@ rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE self)
     retval = rb_funcall(cNokolexborNodeSet, rb_intern("new"), 1, rb_ary_new());
   }
 
-  // xmlXPathFreeNodeSetList(xpath);
+  xmlXPathFreeNodeSetList(xpath);
 
   return retval;
 }
@@ -168,7 +226,7 @@ rb_xml_xpath_context_evaluate(int argc, VALUE *argv, VALUE self)
  * Create a new XPathContext with +node+ as the reference point.
  */
 static VALUE
-rb_xml_xpath_context_new(VALUE klass, VALUE rb_node)
+nl_xpath_context_new(VALUE klass, VALUE rb_node)
 {
   xmlXPathContextPtr ctx;
   VALUE self;
@@ -188,13 +246,15 @@ void Init_nl_xpath_context(void)
 {
   xmlMemSetup((xmlFreeFunc)ruby_xfree, (xmlMallocFunc)ruby_xmalloc, (xmlReallocFunc)ruby_xrealloc, ruby_strdup);
 
-  cNokoLexborXpathContext = rb_define_class_under(mNokolexbor, "XPathContext", rb_cObject);
+  cNokolexborXpathContext = rb_define_class_under(mNokolexbor, "XPathContext", rb_cObject);
+  mNokolexborXpath = rb_define_module_under(mNokolexbor, "XPath");
+  cNokolexborXpathSyntaxError = rb_define_class_under(mNokolexborXpath, "SyntaxError", rb_eStandardError);
 
-  rb_undef_alloc_func(cNokoLexborXpathContext);
+  rb_undef_alloc_func(cNokolexborXpathContext);
 
-  rb_define_singleton_method(cNokoLexborXpathContext, "new", rb_xml_xpath_context_new, 1);
+  rb_define_singleton_method(cNokolexborXpathContext, "new", nl_xpath_context_new, 1);
 
-  rb_define_method(cNokoLexborXpathContext, "evaluate", rb_xml_xpath_context_evaluate, -1);
-  rb_define_method(cNokoLexborXpathContext, "register_variable", rb_xml_xpath_context_register_variable, 2);
-  rb_define_method(cNokoLexborXpathContext, "register_ns", rb_xml_xpath_context_register_ns, 2);
+  rb_define_method(cNokolexborXpathContext, "evaluate", nl_xpath_context_evaluate, -1);
+  rb_define_method(cNokolexborXpathContext, "register_variable", nl_xpath_context_register_variable, 2);
+  rb_define_method(cNokolexborXpathContext, "register_ns", nl_xpath_context_register_ns, 2);
 }

data/ext/nokolexbor/nokolexbor.h

@@ -28,6 +28,8 @@ lxb_inline VALUE nl_rb_document_get(VALUE rb_node_or_doc)
     return rb_iv_get(rb_node_or_doc, "@document");
 }
 
+lxb_dom_document_t * nl_rb_document_unwrap(VALUE rb_doc);
+
 const lxb_char_t *
 lxb_dom_node_name_qualified(lxb_dom_node_t *node, size_t *len);
 

data/ext/nokolexbor/xml_error.c

@@ -3,12 +3,38 @@
 #include <stdarg.h>
 #include "libxml/xmlerror.h"
 
-void *_xmlGenericErrorContext = NULL;
-
-// void * *
-// __xmlGenericErrorContext(void) {
-// 	return (&_xmlGenericErrorContext);
-// }
+#define XML_GET_VAR_STR(msg, str) {				\
+    int       size, prev_size = -1;				\
+    int       chars;						\
+    char      *larger;						\
+    va_list   ap;						\
+								\
+    str = (char *) xmlMalloc(150);				\
+    if (str != NULL) {						\
+								\
+    size = 150;							\
+								\
+    while (size < 64000) {					\
+	va_start(ap, msg);					\
+	chars = vsnprintf(str, size, msg, ap);			\
+	va_end(ap);						\
+	if ((chars > -1) && (chars < size)) {			\
+	    if (prev_size == chars) {				\
+		break;						\
+	    } else {						\
+		prev_size = chars;				\
+	    }							\
+	}							\
+	if (chars > -1)						\
+	    size += chars + 1;					\
+	else							\
+	    size += 100;					\
+	if ((larger = (char *) xmlRealloc(str, size)) == NULL) {\
+	    break;						\
+	}							\
+	str = larger;						\
+    }}								\
+}
 
 /**
  * xmlGenericErrorDefaultFunc:
@@ -20,22 +46,57 @@ void *_xmlGenericErrorContext = NULL;
  */
 void XMLCDECL
 xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
-    va_list args;
+}
 
-    if (_xmlGenericErrorContext == NULL)
-	_xmlGenericErrorContext = (void *) stderr;
+/**
+ * xmlCopyError:
+ * @from:  a source error
+ * @to:  a target error
+ *
+ * Save the original error to the new place.
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ */
+int
+xmlCopyError(xmlErrorPtr from, xmlErrorPtr to) {
+    char *message, *file, *str1, *str2, *str3;
 
-    va_start(args, msg);
-    vfprintf((FILE *)_xmlGenericErrorContext, msg, args);
-    va_end(args);
-}
+    if ((from == NULL) || (to == NULL))
+        return(-1);
+
+    message = (char *) xmlStrdup((xmlChar *) from->message);
+    file = (char *) xmlStrdup ((xmlChar *) from->file);
+    str1 = (char *) xmlStrdup ((xmlChar *) from->str1);
+    str2 = (char *) xmlStrdup ((xmlChar *) from->str2);
+    str3 = (char *) xmlStrdup ((xmlChar *) from->str3);
 
-// xmlGenericErrorFunc _xmlGenericError = xmlGenericErrorDefaultFunc;
+    if (to->message != NULL)
+        xmlFree(to->message);
+    if (to->file != NULL)
+        xmlFree(to->file);
+    if (to->str1 != NULL)
+        xmlFree(to->str1);
+    if (to->str2 != NULL)
+        xmlFree(to->str2);
+    if (to->str3 != NULL)
+        xmlFree(to->str3);
+    to->domain = from->domain;
+    to->code = from->code;
+    to->level = from->level;
+    to->line = from->line;
+    to->node = from->node;
+    to->int1 = from->int1;
+    to->int2 = from->int2;
+    to->node = from->node;
+    to->ctxt = from->ctxt;
+    to->message = message;
+    to->file = file;
+    to->str1 = str1;
+    to->str2 = str2;
+    to->str3 = str3;
 
-// xmlGenericErrorFunc *
-// __xmlGenericError(void) {
-// 	return (&_xmlGenericError);
-// }
+    return 0;
+}
 
 /**
  * __xmlRaiseError:
@@ -63,16 +124,112 @@ xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
  */
 void XMLCDECL
 __xmlRaiseError(xmlStructuredErrorFunc schannel,
-              xmlGenericErrorFunc channel, void *data, void *ctx,
-              void *nod, int domain, int code, xmlErrorLevel level,
-              const char *file, int line, const char *str1,
-              const char *str2, const char *str3, int int1, int col,
-	      const char *msg, ...)
+                xmlGenericErrorFunc channel, void *data, void *ctx,
+                void *nod, int domain, int code, xmlErrorLevel level,
+                const char *file, int line, const char *str1,
+                const char *str2, const char *str3, int int1, int col,
+                const char *msg, ...)
 {
-    va_list args;
-    va_start(args, msg);
-    vfprintf(stderr, msg, args);
-    va_end(args);
+    xmlParserCtxtPtr ctxt = NULL;
+    lxb_dom_node_t_ptr node = (lxb_dom_node_t_ptr)nod;
+    char *str = NULL;
+    xmlParserInputPtr input = NULL;
+    xmlErrorPtr to = &xmlLastError;
+    lxb_dom_node_t_ptr baseptr = NULL;
+
+    if (code == XML_ERR_OK)
+        return;
+    if ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))
+        return;
+    if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
+        (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
+        (domain == XML_FROM_IO) || (domain == XML_FROM_VALID))
+    {
+        ctxt = (xmlParserCtxtPtr)ctx;
+        if ((schannel == NULL) && (ctxt != NULL) && (ctxt->sax != NULL) &&
+            (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
+            (ctxt->sax->serror != NULL))
+        {
+            schannel = ctxt->sax->serror;
+            data = ctxt->userData;
+        }
+    }
+    /*
+     * Check if structured error handler set
+     */
+    if (schannel == NULL)
+    {
+        schannel = xmlStructuredError;
+        /*
+         * if user has defined handler, change data ptr to user's choice
+         */
+        if (schannel != NULL)
+            data = xmlStructuredErrorContext;
+    }
+    /*
+     * Formatting the message
+     */
+    if (msg == NULL)
+    {
+        str = (char *)xmlStrdup(BAD_CAST "No error message provided");
+    }
+    else
+    {
+        XML_GET_VAR_STR(msg, str);
+    }
+
+    /*
+     * specific processing if a parser context is provided
+     */
+    if (ctxt != NULL)
+    {
+        if (file == NULL)
+        {
+            input = ctxt->input;
+            if ((input != NULL) && (input->filename == NULL) &&
+                (ctxt->inputNr > 1))
+            {
+                input = ctxt->inputTab[ctxt->inputNr - 2];
+            }
+            if (input != NULL)
+            {
+                file = input->filename;
+                line = input->line;
+                col = input->col;
+            }
+        }
+        to = &ctxt->lastError;
+    }
+
+    /*
+     * Save the information about the error
+     */
+    xmlResetError(to);
+    to->domain = domain;
+    to->code = code;
+    to->message = str;
+    to->level = level;
+    if (file != NULL)
+        to->file = (char *)xmlStrdup((const xmlChar *)file);
+    to->line = line;
+    if (str1 != NULL)
+        to->str1 = (char *)xmlStrdup((const xmlChar *)str1);
+    if (str2 != NULL)
+        to->str2 = (char *)xmlStrdup((const xmlChar *)str2);
+    if (str3 != NULL)
+        to->str3 = (char *)xmlStrdup((const xmlChar *)str3);
+    to->int1 = int1;
+    to->int2 = col;
+    to->node = node;
+    to->ctxt = ctx;
+
+    if (to != &xmlLastError)
+        xmlCopyError(to, &xmlLastError);
+
+    if (schannel != NULL)
+    {
+        schannel(data, to);
+    }
 }
 
 /**
@@ -131,4 +288,45 @@ __xmlSimpleError(int domain, int code, lxb_dom_node_t_ptr node,
 			code, XML_ERR_ERROR, NULL, 0, extra,
 			NULL, NULL, 0, 0, msg, extra);
     }
+}
+
+/**
+ * xmlSetGenericErrorFunc:
+ * @ctx:  the new error handling context
+ * @handler:  the new handler function
+ *
+ * Function to reset the handler and the error context for out of
+ * context error messages.
+ * This simply means that @handler will be called for subsequent
+ * error messages while not parsing nor validating. And @ctx will
+ * be passed as first argument to @handler
+ * One can simply force messages to be emitted to another FILE * than
+ * stderr by setting @ctx to this file handle and @handler to NULL.
+ * For multi-threaded applications, this must be set separately for each thread.
+ */
+void
+xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {
+    xmlGenericErrorContext = ctx;
+    if (handler != NULL)
+	xmlGenericError = handler;
+    else
+	xmlGenericError = xmlGenericErrorDefaultFunc;
+}
+
+/**
+ * xmlSetStructuredErrorFunc:
+ * @ctx:  the new error handling context
+ * @handler:  the new handler function
+ *
+ * Function to reset the handler and the error context for out of
+ * context structured error messages.
+ * This simply means that @handler will be called for subsequent
+ * error messages while not parsing nor validating. And @ctx will
+ * be passed as first argument to @handler
+ * For multi-threaded applications, this must be set separately for each thread.
+ */
+void
+xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
+    xmlStructuredErrorContext = ctx;
+    xmlStructuredError = handler;
 }

data/lib/nokolexbor/node.rb

@@ -119,8 +119,8 @@ module Nokolexbor
     end
 
     def each
-      attributes.each do |node|
-        yield [node.name, node.value]
+      attributes.each do |name, node|
+        yield [name, node.value]
       end
     end
 

data/lib/nokolexbor/node_set.rb

@@ -69,9 +69,13 @@ module Nokolexbor
       self.each(&:remove)
     end
 
-    alias_method :destroy, :remove
+    alias_method :unlink, :remove
     alias_method :to_ary, :to_a
 
+    def destroy
+      self.each(&:destroy)
+    end
+
     def pop
       return nil if length == 0
 

data/lib/nokolexbor/version.rb

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

data/lib/nokolexbor/xpath.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Nokolexbor
+  module XPath
+    class SyntaxError < StandardError
+      attr_reader :domain
+      attr_reader :code
+      attr_reader :level
+      attr_reader :file
+      attr_reader :line
+      attr_reader :str1
+      attr_reader :str2
+      attr_reader :str3
+      attr_reader :int1
+      attr_reader :column
+
+      ###
+      # return true if this is a non error
+      def none?
+        level == 0
+      end
+
+      ###
+      # return true if this is a warning
+      def warning?
+        level == 1
+      end
+
+      ###
+      # return true if this is an error
+      def error?
+        level == 2
+      end
+
+      ###
+      # return true if this error is fatal
+      def fatal?
+        level == 3
+      end
+
+      def to_s
+        message = super.chomp
+        [location_to_s, level_to_s, message]
+          .compact.join(": ")
+          .force_encoding(message.encoding)
+      end
+
+      private
+
+      def level_to_s
+        case level
+        when 3 then "FATAL"
+        when 2 then "ERROR"
+        when 1 then "WARNING"
+        end
+      end
+
+      def nil_or_zero?(attribute)
+        attribute.nil? || attribute.zero?
+      end
+
+      def location_to_s
+        return nil if nil_or_zero?(line) && nil_or_zero?(column)
+
+        "#{line}:#{column}"
+      end
+    end
+  end
+end

data/lib/nokolexbor.rb

@@ -6,6 +6,7 @@ require 'nokolexbor/node'
 require 'nokolexbor/document'
 require 'nokolexbor/node_set'
 require 'nokolexbor/attribute'
+require 'nokolexbor/xpath'
 require 'nokolexbor/xpath_context'
 
 module Nokolexbor

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nokolexbor
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Yicheng Zhou
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-16 00:00:00.000000000 Z
+date: 2022-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
 description: Nokolexbor is a high performance HTML5 parser, with support for both
   CSS selectors and XPath. It's API is designed to be compatible with Nokogiri.
 email: zyc9012@gmail.com
@@ -105,6 +119,7 @@ files:
 - lib/nokolexbor/node.rb
 - lib/nokolexbor/node_set.rb
 - lib/nokolexbor/version.rb
+- lib/nokolexbor/xpath.rb
 - lib/nokolexbor/xpath_context.rb
 - patches/0001-lexbor-support-text-pseudo-element.patch
 - patches/0002-lexbor-match-id-class-case-sensitive.patch
@@ -522,7 +537,7 @@ licenses:
 - MIT
 metadata:
   msys2_mingw_dependencies: cmake
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -537,8 +552,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: High performance HTML5 parser, with support for both CSS selectors and XPath.
 test_files: []