nokolexbor 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5eb708d3b21135112c1e1f373b89f94b83c4926043da9743aff108f4d4eed72
-  data.tar.gz: 5ba497f52ea19c49816e1ec9c2b5e12449ae4f812cb011f2953ba7cf1a0b971b
+  metadata.gz: d4f935c5e81aed7b5d964e7332a9abeaa1f44dec7e2532f01c89dfd17df14ded
+  data.tar.gz: 91c58aca5a9b16a3cfa7e2436dfb86feeb777daa3615b8b3a95b234981cc67d0
 SHA512:
-  metadata.gz: ff508a1599f36608c4c7ae0b360d4f2eb6f4740c059a945215dcdbc27a457a74293a2de6ba4043b5db5601dacccd4befac396b85a824e615163ab36f2a603bcb
-  data.tar.gz: 1699d675b60d76a12da000e6bc0844842a31f910b80350a5e87bedaf4474e8078099623eeaeb1e1169c16ec23a51a4d0112aebf76c9ef25ac358a347992f32da
+  metadata.gz: af6ae7b07bde270ea275a5b21221c7e90923f195a6a62ed7b85174f1d9f31f017661dc50c7d8dd1c3d39096a5c1ecbb3469f4496f2e628a3b7026f82ca3994c5
+  data.tar.gz: eea3a38dcbd81cdb7c54996248d6eaa2d2c51b964d79d3131ba04594dd449a141b32b225bc7a879844c92418f3c04e6b63c77c9c6bef86f8ee619fa6a47b03a3

data/ext/nokolexbor/extconf.rb

@@ -1,16 +1,22 @@
 require 'mkmf'
 require 'timeout'
 
-# For debugging
-# CONFIG["optflags"] = "-O0"
-# CONFIG["debugflags"] = "-ggdb3"
-
 cmake_flags = [ ENV["CMAKE_FLAGS"] ]
 cmake_flags << "-DLEXBOR_BUILD_TESTS_CPP=OFF"
 cmake_flags << "-DLEXBOR_BUILD_SHARED=OFF"
 cmake_flags << "-DLEXBOR_BUILD_STATIC=ON"
-# For debugging
-# cmake_flags << "-DLEXBOR_OPTIMIZATION_LEVEL='-O0 -g'"
+
+if ENV['NOKOLEXBOR_DEBUG'] || ENV['NOKOLEXBOR_ASAN']
+  CONFIG["optflags"] = "-O0"
+  CONFIG["debugflags"] = "-ggdb3"
+  cmake_flags << "-DLEXBOR_OPTIMIZATION_LEVEL='-O0 -g'"
+end
+
+if ENV['NOKOLEXBOR_ASAN']
+  $LDFLAGS << " -fsanitize=address"
+  $CFLAGS << " -fsanitize=address -DNOKOLEXBOR_ASAN"
+  cmake_flags << "-DLEXBOR_BUILD_WITH_ASAN=ON"
+end
 
 append_cflags("-DLEXBOR_STATIC")
 append_cflags("-DLIBXML_STATIC")

data/ext/nokolexbor/memory.c

@@ -13,6 +13,11 @@
 #include <ruby.h>
 #include "lexbor/core/base.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)
 {
@@ -37,3 +42,5 @@ lexbor_free(void *dst)
     ruby_xfree(dst);
     return NULL;
 }
+
+#endif

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);
 }
@@ -22,10 +22,20 @@ const rb_data_type_t nl_document_type = {
 };
 
 static VALUE
-nl_document_parse(VALUE self, VALUE rb_html)
+nl_document_parse(VALUE self, VALUE rb_string_or_io)
 {
+  VALUE id_read = rb_intern("read");
+  VALUE rb_html;
+  if (rb_respond_to(rb_string_or_io, id_read))
+  {
+    rb_html = rb_funcall(rb_string_or_io, id_read, 0);
+  }
+  else
+  {
+    rb_html = rb_string_or_io;
+  }
   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 +45,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 +60,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,45 +199,52 @@ nl_node_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec,
   return LXB_STATUS_OK;
 }
 
-static void
+lxb_status_t
 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);
 
+  lxb_status_t status;
+  lxb_css_parser_t *parser = NULL;
+  lxb_selectors_t *selectors = NULL;
+  lxb_css_selector_list_t *list = NULL;
+
   /* Create CSS parser. */
-  lxb_css_parser_t *parser = lxb_css_parser_create();
-  lxb_status_t status = lxb_css_parser_init(parser, NULL, NULL);
+  parser = lxb_css_parser_create();
+  status = lxb_css_parser_init(parser, NULL, NULL);
   if (status != LXB_STATUS_OK)
   {
-    nl_raise_lexbor_error(status);
+    goto cleanup;
   }
 
   /* Selectors. */
-  lxb_selectors_t *selectors = lxb_selectors_create();
+  selectors = lxb_selectors_create();
   status = lxb_selectors_init(selectors);
   if (status != LXB_STATUS_OK)
   {
-    nl_raise_lexbor_error(status);
+    goto cleanup;
   }
 
   /* 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);
+  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);
+    status = parser->status;
+    goto cleanup;
   }
 
   /* Find HTML nodes by CSS Selectors. */
   status = lxb_selectors_find(selectors, node, list, cb, ctx);
   if (status != LXB_STATUS_OK)
   {
-    nl_raise_lexbor_error(status);
+    goto cleanup;
   }
 
+cleanup:
   /* Destroy Selectors object. */
   (void)lxb_selectors_destroy(selectors, true);
 
@@ -247,20 +253,22 @@ nl_node_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void *ctx)
 
   /* Destroy all object for all CSS Selector List. */
   lxb_css_selector_list_destroy_memory(list);
+
+  return status;
 }
 
 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 +283,7 @@ mark_node_orders(lxb_dom_node_t *root)
       }
 
       node = node->next;
-      node->user = ++count;
+      node->user = (void *)++count;
     }
 
   } while (true);
@@ -290,7 +298,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,37 +308,53 @@ 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);
   lexbor_array_t *array = lexbor_array_create();
 
-  nl_node_find(self, selector, nl_node_at_css_callback, array);
+  lxb_status_t status = nl_node_find(self, selector, nl_node_at_css_callback, array);
+
+  if (status != LXB_STATUS_OK)
+  {
+    lexbor_array_destroy(array, true);
+    nl_raise_lexbor_error(status);
+  }
 
   if (array->length == 0)
   {
+    lexbor_array_destroy(array, true);
     return Qnil;
   }
 
   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);
   lexbor_array_t *array = lexbor_array_create();
 
-  nl_node_find(self, selector, nl_node_css_callback, array);
+  lxb_status_t status = nl_node_find(self, selector, nl_node_css_callback, array);
+  if (status != LXB_STATUS_OK)
+  {
+    lexbor_array_destroy(array, true);
+    nl_raise_lexbor_error(status);
+  }
 
   sort_nodes_if_necessary(selector, node->owner_document, array);
 
@@ -354,7 +378,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 +403,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 +423,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 +441,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 +466,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 +498,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 +632,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 +651,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 +666,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 +692,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 +723,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 +861,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");
 }