nokolexbor 0.2.5 → 0.3.1

data/ext/nokolexbor/nl_node.c

@@ -1,38 +1,64 @@
 #include "nokolexbor.h"
 
-#define SORT_NAME css_result
+#define SORT_NAME nl_css_result
 #define SORT_TYPE lxb_dom_node_t *
 #define SORT_CMP(x, y) (x->user >= y->user ? (x->user == y->user ? 0 : 1) : -1)
 #include "timsort.h"
 
 extern VALUE mNokolexbor;
 extern VALUE cNokolexborDocument;
+extern VALUE cNokolexborText;
+extern VALUE cNokolexborComment;
 extern VALUE cNokolexborNodeSet;
 extern VALUE eLexborError;
 VALUE cNokolexborNode;
+VALUE cNokolexborElement;
+VALUE cNokolexborCharacterData;
 
 extern rb_data_type_t nl_document_type;
 
-static const rb_data_type_t nl_node_type = {
-    "Nokolexbor::Node",
-    {
-        0,
-        0,
-    },
-    0,
-    0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
 VALUE
 nl_rb_node_create(lxb_dom_node_t *node, VALUE rb_document)
 {
-  if (node == NULL)
-  {
+  if (node == NULL) {
     rb_raise(rb_eArgError, "Cannot create Nokolexbor::Node with null pointer");
   }
 
-  VALUE ret = TypedData_Wrap_Struct(cNokolexborNode, &nl_node_type, node);
+  VALUE rb_class;
+  switch (node->type) {
+  case LXB_DOM_NODE_TYPE_ELEMENT:
+    rb_class = cNokolexborElement;
+    break;
+  // case LXB_DOM_NODE_TYPE_ATTRIBUTE:
+  //   break;
+  case LXB_DOM_NODE_TYPE_TEXT:
+    rb_class = cNokolexborText;
+    break;
+  case LXB_DOM_NODE_TYPE_CDATA_SECTION:
+    rb_class = cNokolexborCharacterData;
+    break;
+  // case LXB_DOM_NODE_TYPE_ENTITY_REFERENCE:
+  //   break;
+  // case LXB_DOM_NODE_TYPE_ENTITY:
+  //   break;
+  // case LXB_DOM_NODE_TYPE_PROCESSING_INSTRUCTION:
+  //   break;
+  case LXB_DOM_NODE_TYPE_COMMENT:
+    rb_class = cNokolexborComment;
+    break;
+  // case LXB_DOM_NODE_TYPE_DOCUMENT:
+  //   break;
+  // case LXB_DOM_NODE_TYPE_DOCUMENT_TYPE:
+  //   break;
+  // case LXB_DOM_NODE_TYPE_DOCUMENT_FRAGMENT:
+  //   break;
+  // case LXB_DOM_NODE_TYPE_NOTATION:
+  //   break;
+  default:
+    rb_class = cNokolexborNode;
+  }
+
+  VALUE ret = Data_Wrap_Struct(rb_class, NULL, NULL, node);
   rb_iv_set(ret, "@document", rb_document);
   return ret;
 }
@@ -41,13 +67,10 @@ inline lxb_dom_node_t *
 nl_rb_node_unwrap(VALUE rb_node)
 {
   lxb_dom_node_t *node;
-  if (rb_obj_class(rb_node) == cNokolexborDocument)
-  {
+  if (rb_obj_is_kind_of(rb_node, cNokolexborDocument)) {
     TypedData_Get_Struct(rb_node, lxb_dom_node_t, &nl_document_type, node);
-  }
-  else
-  {
-    TypedData_Get_Struct(rb_node, lxb_dom_node_t, &nl_node_type, node);
+  } else {
+    Data_Get_Struct(rb_node, lxb_dom_node_t, node);
   }
   return node;
 }
@@ -62,23 +85,22 @@ nl_node_new(int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &rb_name, &rb_document, &rest);
 
-  if (!rb_obj_is_kind_of(rb_document, cNokolexborDocument))
-  {
+  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_element_t *element = lxb_dom_document_create_element(document, (const lxb_char_t *)StringValueCStr(rb_name), RSTRING_LEN(rb_name), NULL);
-  if (element == NULL)
-  {
+  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) {
     rb_raise(rb_eRuntimeError, "Error creating element");
   }
 
   VALUE rb_node = nl_rb_node_create(&element->node, rb_document);
 
-  if (rb_block_given_p())
-  {
+  if (rb_block_given_p()) {
     rb_yield(rb_node);
   }
 
@@ -92,8 +114,7 @@ nl_node_content(VALUE self)
 
   size_t str_len = 0;
   lxb_char_t *text = lxb_dom_node_text_content(node, &str_len);
-  if (text == NULL)
-  {
+  if (text == NULL) {
     return rb_str_new("", 0);
   }
   VALUE rb_str = rb_utf8_str_new((char *)text, str_len);
@@ -102,13 +123,26 @@ nl_node_content(VALUE self)
   return rb_str;
 }
 
+static VALUE
+nl_node_content_set(VALUE self, VALUE content)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+
+  const char *c_content = StringValuePtr(content);
+  size_t content_len = RSTRING_LEN(content);
+  lxb_status_t status = lxb_dom_node_text_content_set(node, (const lxb_char_t *)c_content, content_len);
+  if (status != LXB_STATUS_OK) {
+    nl_raise_lexbor_error(status);
+  }
+  return content;
+}
+
 static VALUE
 nl_node_get_attr(VALUE self, VALUE rb_attr)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
 
-  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT)
-  {
+  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
     return Qnil;
   }
 
@@ -118,8 +152,7 @@ nl_node_get_attr(VALUE self, VALUE rb_attr)
 
   lxb_dom_element_t *element = lxb_dom_interface_element(node);
 
-  if (!lxb_dom_element_has_attribute(element, (const lxb_char_t *)attr_c, attr_len))
-  {
+  if (!lxb_dom_element_has_attribute(element, (const lxb_char_t *)attr_c, attr_len)) {
     return Qnil;
   }
 
@@ -134,8 +167,7 @@ nl_node_set_attr(VALUE self, VALUE rb_attr, VALUE rb_value)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
 
-  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT)
-  {
+  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
     return Qnil;
   }
 
@@ -159,8 +191,7 @@ nl_node_remove_attr(VALUE self, VALUE rb_attr)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
 
-  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT)
-  {
+  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
     return Qnil;
   }
 
@@ -179,8 +210,7 @@ nl_node_at_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *sp
 {
   lexbor_array_t *array = (lexbor_array_t *)ctx;
   lxb_status_t status = lexbor_array_push_unique(array, node);
-  if (status != LXB_STATUS_OK && status != LXB_STATUS_STOPPED)
-  {
+  if (status != LXB_STATUS_OK && status != LXB_STATUS_STOPPED) {
     nl_raise_lexbor_error(status);
   }
   // Stop at first result
@@ -192,8 +222,7 @@ nl_node_css_callback(lxb_dom_node_t *node, lxb_css_selector_specificity_t *spec,
 {
   lexbor_array_t *array = (lexbor_array_t *)ctx;
   lxb_status_t status = lexbor_array_push_unique(array, node);
-  if (status != LXB_STATUS_OK && status != LXB_STATUS_STOPPED)
-  {
+  if (status != LXB_STATUS_OK && status != LXB_STATUS_STOPPED) {
     nl_raise_lexbor_error(status);
   }
   return LXB_STATUS_OK;
@@ -215,32 +244,28 @@ nl_node_find(VALUE self, VALUE selector, lxb_selectors_cb_f cb, void *ctx)
   /* Create CSS parser. */
   parser = lxb_css_parser_create();
   status = lxb_css_parser_init(parser, NULL, NULL);
-  if (status != LXB_STATUS_OK)
-  {
+  if (status != LXB_STATUS_OK) {
     goto cleanup;
   }
 
   /* Selectors. */
   selectors = lxb_selectors_create();
   status = lxb_selectors_init(selectors);
-  if (status != LXB_STATUS_OK)
-  {
+  if (status != LXB_STATUS_OK) {
     goto cleanup;
   }
 
   /* Parse and get the log. */
   // TODO: Cache the list for reuse, improves performance
   list = lxb_css_selectors_parse_relative_list(parser, (const lxb_char_t *)selector_c, selector_len);
-  if (parser->status != LXB_STATUS_OK)
-  {
+  if (parser->status != LXB_STATUS_OK) {
     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)
-  {
+  if (status != LXB_STATUS_OK) {
     goto cleanup;
   }
 
@@ -263,22 +288,16 @@ mark_node_orders(lxb_dom_node_t *root)
   size_t count = 1;
   root->user = (void *)count;
   lxb_dom_node_t *node = root;
-  do
-  {
-    if (node->first_child != NULL)
-    {
+  do {
+    if (node->first_child != NULL) {
       node = node->first_child;
       node->user = (void *)++count;
-    }
-    else
-    {
-      while (node != root && node->next == NULL)
-      {
+    } else {
+      while (node != root && node->next == NULL) {
         node = node->parent;
       }
 
-      if (node == root)
-      {
+      if (node == root) {
         break;
       }
 
@@ -290,27 +309,23 @@ mark_node_orders(lxb_dom_node_t *root)
 }
 
 // Sort nodes in document traversal order (the same as Nokorigi)
-void sort_nodes_if_necessary(VALUE selector, lxb_dom_document_t *doc, lexbor_array_t *array)
+void nl_sort_nodes_if_necessary(VALUE selector, lxb_dom_document_t *doc, lexbor_array_t *array)
 {
   // No need to sort if there's only one selector, the results are natually in document traversal order
-  if (strchr(RSTRING_PTR(selector), ',') != NULL)
-  {
+  if (strchr(RSTRING_PTR(selector), ',') != NULL) {
     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 (size_t i = 0; i < array->length; i++)
-    {
-      if (((lxb_dom_node_t *)array->list[i])->user == 0)
-      {
+    for (size_t i = 0; i < array->length; i++) {
+      if (((lxb_dom_node_t *)array->list[i])->user == 0) {
         need_order = 1;
         break;
       }
     }
-    if (need_order)
-    {
+    if (need_order) {
       mark_node_orders(&doc->node);
     }
-    css_result_tim_sort((lxb_dom_node_t **)&array->list[0], array->length);
+    nl_css_result_tim_sort((lxb_dom_node_t **)&array->list[0], array->length);
   }
 }
 
@@ -322,19 +337,17 @@ nl_node_at_css(VALUE self, VALUE selector)
 
   lxb_status_t status = nl_node_find(self, selector, nl_node_at_css_callback, array);
 
-  if (status != LXB_STATUS_OK)
-  {
+  if (status != LXB_STATUS_OK) {
     lexbor_array_destroy(array, true);
     nl_raise_lexbor_error(status);
   }
 
-  if (array->length == 0)
-  {
+  if (array->length == 0) {
     lexbor_array_destroy(array, true);
     return Qnil;
   }
 
-  sort_nodes_if_necessary(selector, node->owner_document, array);
+  nl_sort_nodes_if_necessary(selector, node->owner_document, array);
 
   VALUE ret = nl_rb_node_create(array->list[0], nl_rb_document_get(self));
 
@@ -350,34 +363,45 @@ nl_node_css(VALUE self, VALUE selector)
   lexbor_array_t *array = lexbor_array_create();
 
   lxb_status_t status = nl_node_find(self, selector, nl_node_css_callback, array);
-  if (status != LXB_STATUS_OK)
-  {
+  if (status != LXB_STATUS_OK) {
     lexbor_array_destroy(array, true);
     nl_raise_lexbor_error(status);
   }
 
-  sort_nodes_if_necessary(selector, node->owner_document, array);
+  nl_sort_nodes_if_necessary(selector, node->owner_document, array);
 
   return nl_rb_node_set_create_with_data(array, nl_rb_document_get(self));
 }
 
 static VALUE
-nl_node_inner_html(VALUE self)
+nl_node_inner_html(int argc, VALUE *argv, VALUE self)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
   lexbor_str_t str = {0};
-  lxb_status_t status = lxb_html_serialize_deep_str(node, &str);
-  if (status != LXB_STATUS_OK)
-  {
-    if (str.data != NULL)
-    {
+  VALUE options;
+  lxb_status_t status;
+  size_t indent = 0;
+  rb_scan_args(argc, argv, "01", &options);
+
+  if (TYPE(options) == T_HASH) {
+    VALUE rb_indent = rb_hash_aref(options, ID2SYM(rb_intern("indent")));
+    if (!NIL_P(rb_indent)) {
+      indent = NUM2INT(rb_indent);
+    }
+  }
+  if (indent > 0) {
+    status = lxb_html_serialize_pretty_deep_str(node, 0, 0, &str);
+  } else {
+    status = lxb_html_serialize_deep_str(node, &str);
+  }
+  if (status != LXB_STATUS_OK) {
+    if (str.data != NULL) {
       lexbor_str_destroy(&str, node->owner_document->text, false);
     }
     nl_raise_lexbor_error(status);
   }
 
-  if (str.data != NULL)
-  {
+  if (str.data != NULL) {
     VALUE ret = rb_utf8_str_new((const char *)str.data, str.length);
     lexbor_str_destroy(&str, node->owner_document->text, false);
     return ret;
@@ -387,22 +411,34 @@ nl_node_inner_html(VALUE self)
 }
 
 static VALUE
-nl_node_outer_html(VALUE self)
+nl_node_outer_html(int argc, VALUE *argv, VALUE self)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
   lexbor_str_t str = {0};
-  lxb_status_t status = lxb_html_serialize_tree_str(node, &str);
-  if (status != LXB_STATUS_OK)
-  {
-    if (str.data != NULL)
-    {
+  VALUE options;
+  lxb_status_t status;
+  size_t indent = 0;
+  rb_scan_args(argc, argv, "01", &options);
+
+  if (TYPE(options) == T_HASH) {
+    VALUE rb_indent = rb_hash_aref(options, ID2SYM(rb_intern("indent")));
+    if (!NIL_P(rb_indent)) {
+      indent = NUM2INT(rb_indent);
+    }
+  }
+  if (indent > 0) {
+    status = lxb_html_serialize_pretty_tree_str(node, 0, 0, &str);
+  } else {
+    status = lxb_html_serialize_tree_str(node, &str);
+  }
+  if (status != LXB_STATUS_OK) {
+    if (str.data != NULL) {
       lexbor_str_destroy(&str, node->owner_document->text, false);
     }
     nl_raise_lexbor_error(status);
   }
 
-  if (str.data != NULL)
-  {
+  if (str.data != NULL) {
     VALUE ret = rb_utf8_str_new((const char *)str.data, str.length);
     lexbor_str_destroy(&str, node->owner_document->text, false);
     return ret;
@@ -416,8 +452,7 @@ nl_node_has_key(VALUE self, VALUE rb_attr)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
 
-  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT)
-  {
+  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
     return Qfalse;
   }
 
@@ -436,15 +471,13 @@ nl_node_keys(VALUE self)
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
   VALUE ary_keys = rb_ary_new();
 
-  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT)
-  {
+  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
     return ary_keys;
   }
 
   lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_dom_interface_element(node));
 
-  while (attr != NULL)
-  {
+  while (attr != NULL) {
     size_t 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));
@@ -461,23 +494,18 @@ nl_node_values(VALUE self)
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
   VALUE ary_values = rb_ary_new();
 
-  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT)
-  {
+  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
     return ary_values;
   }
 
   lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_dom_interface_element(node));
 
-  while (attr != NULL)
-  {
+  while (attr != NULL) {
     size_t tmp_len;
     const lxb_char_t *tmp = lxb_dom_attr_value(attr, &tmp_len);
-    if (tmp != NULL)
-    {
+    if (tmp != NULL) {
       rb_ary_push(ary_values, rb_utf8_str_new((const char *)tmp, tmp_len));
-    }
-    else
-    {
+    } else {
       rb_ary_push(ary_values, rb_str_new("", 0));
     }
 
@@ -493,15 +521,13 @@ nl_node_attrs(VALUE self)
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
   VALUE rb_hash = rb_hash_new();
 
-  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT)
-  {
+  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
     return rb_hash;
   }
 
   lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_dom_interface_element(node));
 
-  while (attr != NULL)
-  {
+  while (attr != NULL) {
     size_t 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);
@@ -535,11 +561,9 @@ static VALUE
 nl_node_previous_element(VALUE self)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
-  while (node->prev != NULL)
-  {
+  while (node->prev != NULL) {
     node = node->prev;
-    if (node->type == LXB_DOM_NODE_TYPE_ELEMENT)
-    {
+    if (node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
       return nl_rb_node_create(node, nl_rb_document_get(self));
     }
   }
@@ -557,11 +581,9 @@ static VALUE
 nl_node_next_element(VALUE self)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
-  while (node->next != NULL)
-  {
+  while (node->next != NULL) {
     node = node->next;
-    if (node->type == LXB_DOM_NODE_TYPE_ELEMENT)
-    {
+    if (node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
       return nl_rb_node_create(node, nl_rb_document_get(self));
     }
   }
@@ -575,8 +597,7 @@ nl_node_children(VALUE self)
   lxb_dom_node_t *child = node->first_child;
   lexbor_array_t *array = lexbor_array_create();
 
-  while (child != NULL)
-  {
+  while (child != NULL) {
     lexbor_array_push(array, child);
     child = child->next;
   }
@@ -619,8 +640,7 @@ nl_node_equals(VALUE self, VALUE other)
 const lxb_char_t *
 lxb_dom_node_name_qualified(lxb_dom_node_t *node, size_t *len)
 {
-  if (node->type == LXB_DOM_NODE_TYPE_ELEMENT)
-  {
+  if (node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
     return lxb_dom_element_qualified_name(lxb_dom_interface_element(node),
                                           len);
   }
@@ -642,18 +662,15 @@ nl_node_parse_fragment(lxb_dom_document_t *doc, 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)
-  {
+  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)
-  {
+  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)
-  {
+  if (frag_root == NULL) {
     rb_raise(rb_eArgError, "Error parsing HTML");
   }
   return frag_root;
@@ -677,39 +694,34 @@ nl_node_add_sibling(VALUE self, VALUE next_or_previous, VALUE new)
   lxb_dom_document_t *doc = node->owner_document;
 
   int insert_after;
-  if (rb_eql(rb_String(next_or_previous), rb_str_new_literal("next")))
-  {
+  if (rb_eql(rb_String(next_or_previous), rb_str_new_literal("next"))) {
     insert_after = 1;
-  }
-  else if (rb_eql(rb_String(next_or_previous), rb_str_new_literal("previous")))
-  {
+  } else if (rb_eql(rb_String(next_or_previous), rb_str_new_literal("previous"))) {
     insert_after = 0;
-  }
-  else
-  {
+  } else {
     rb_raise(rb_eArgError, "Unsupported inserting position");
   }
 
-  if (TYPE(new) == T_STRING)
-  {
+  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));
+    lexbor_array_t *array = lexbor_array_create();
 
-    while (frag_root->first_child != NULL)
-    {
+    while (frag_root->first_child != NULL) {
       lxb_dom_node_t *child = frag_root->first_child;
       lxb_dom_node_remove(child);
       insert_after ? lxb_dom_node_insert_after(node, child) : lxb_dom_node_insert_before(node, child);
+      lexbor_array_push(array, child);
     }
     lxb_dom_node_destroy(frag_root);
-  }
-  else if (rb_obj_class(new) == cNokolexborNode)
-  {
+    return nl_rb_node_set_create_with_data(array, nl_rb_document_get(self));
+
+  } else if (rb_obj_is_kind_of(new, cNokolexborNode)) {
     lxb_dom_node_t *node_new = nl_rb_node_unwrap(new);
     lxb_dom_node_remove(node_new);
     insert_after ? lxb_dom_node_insert_after(node, node_new) : lxb_dom_node_insert_before(node, node_new);
-  }
-  else
-  {
+    return new;
+
+  } else {
     rb_raise(rb_eArgError, "Unsupported node type");
   }
   return Qnil;
@@ -721,26 +733,26 @@ nl_node_add_child(VALUE self, VALUE new)
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
   lxb_dom_document_t *doc = node->owner_document;
 
-  if (TYPE(new) == T_STRING)
-  {
+  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));
+    lexbor_array_t *array = lexbor_array_create();
 
-    while (frag_root->first_child != NULL)
-    {
+    while (frag_root->first_child != NULL) {
       lxb_dom_node_t *child = frag_root->first_child;
       lxb_dom_node_remove(child);
       lxb_dom_node_insert_child(node, child);
+      lexbor_array_push(array, child);
     }
     lxb_dom_node_destroy(frag_root);
-  }
-  else if (rb_obj_class(new) == cNokolexborNode)
-  {
+    return nl_rb_node_set_create_with_data(array, nl_rb_document_get(self));
+
+  } else if (rb_obj_is_kind_of(new, cNokolexborNode)) {
     lxb_dom_node_t *node_new = nl_rb_node_unwrap(new);
     lxb_dom_node_remove(node_new);
     lxb_dom_node_insert_child(node, node_new);
-  }
-  else
-  {
+    return new;
+
+  } else {
     rb_raise(rb_eArgError, "Unsupported node type");
   }
   return Qnil;
@@ -758,12 +770,10 @@ nl_node_first_element_child(VALUE self)
   lxb_dom_node_t *parent = nl_rb_node_unwrap(self);
   lxb_dom_node_t *cur;
 
-  if (parent == NULL)
-  {
+  if (parent == NULL) {
     return Qnil;
   }
-  switch (parent->type)
-  {
+  switch (parent->type) {
   case LXB_DOM_NODE_TYPE_ELEMENT:
   case LXB_DOM_NODE_TYPE_ENTITY:
   case LXB_DOM_NODE_TYPE_DOCUMENT:
@@ -772,10 +782,8 @@ nl_node_first_element_child(VALUE self)
   default:
     return Qnil;
   }
-  while (cur != NULL)
-  {
-    if (cur->type == LXB_DOM_NODE_TYPE_ELEMENT)
-    {
+  while (cur != NULL) {
+    if (cur->type == LXB_DOM_NODE_TYPE_ELEMENT) {
       return nl_rb_node_create(cur, nl_rb_document_get(self));
     }
     cur = cur->next;
@@ -789,12 +797,10 @@ nl_node_last_element_child(VALUE self)
   lxb_dom_node_t *parent = nl_rb_node_unwrap(self);
   lxb_dom_node_t *cur;
 
-  if (parent == NULL)
-  {
+  if (parent == NULL) {
     return Qnil;
   }
-  switch (parent->type)
-  {
+  switch (parent->type) {
   case LXB_DOM_NODE_TYPE_ELEMENT:
   case LXB_DOM_NODE_TYPE_ENTITY:
   case LXB_DOM_NODE_TYPE_DOCUMENT:
@@ -803,10 +809,8 @@ nl_node_last_element_child(VALUE self)
   default:
     return Qnil;
   }
-  while (cur != NULL)
-  {
-    if (cur->type == LXB_DOM_NODE_TYPE_ELEMENT)
-    {
+  while (cur != NULL) {
+    if (cur->type == LXB_DOM_NODE_TYPE_ELEMENT) {
       return nl_rb_node_create(cur, nl_rb_document_get(self));
     }
     cur = cur->prev;
@@ -827,16 +831,20 @@ void Init_nl_node(void)
   cNokolexborNode = rb_define_class_under(mNokolexbor, "Node", rb_cObject);
   rb_undef_alloc_func(cNokolexborNode);
 
+  cNokolexborElement = rb_define_class_under(mNokolexbor, "Element", cNokolexborNode);
+  cNokolexborCharacterData = rb_define_class_under(mNokolexbor, "CharacterData", cNokolexborNode);
+
   rb_define_singleton_method(cNokolexborNode, "new", nl_node_new, -1);
   rb_define_method(cNokolexborNode, "content", nl_node_content, 0);
+  rb_define_method(cNokolexborNode, "content=", nl_node_content_set, 1);
   rb_define_method(cNokolexborNode, "[]", nl_node_get_attr, 1);
   rb_define_method(cNokolexborNode, "[]=", nl_node_set_attr, 2);
   rb_define_method(cNokolexborNode, "remove_attr", nl_node_remove_attr, 1);
   rb_define_method(cNokolexborNode, "==", nl_node_equals, 1);
   rb_define_method(cNokolexborNode, "css_impl", nl_node_css, 1);
   rb_define_method(cNokolexborNode, "at_css_impl", nl_node_at_css, 1);
-  rb_define_method(cNokolexborNode, "inner_html", nl_node_inner_html, 0);
-  rb_define_method(cNokolexborNode, "outer_html", nl_node_outer_html, 0);
+  rb_define_method(cNokolexborNode, "inner_html", nl_node_inner_html, -1);
+  rb_define_method(cNokolexborNode, "outer_html", nl_node_outer_html, -1);
   rb_define_method(cNokolexborNode, "key?", nl_node_has_key, 1);
   rb_define_method(cNokolexborNode, "keys", nl_node_keys, 0);
   rb_define_method(cNokolexborNode, "values", nl_node_values, 0);
@@ -860,12 +868,17 @@ void Init_nl_node(void)
   rb_define_method(cNokolexborNode, "clone", nl_node_clone, 0);
 
   rb_define_alias(cNokolexborNode, "attr", "[]");
+  rb_define_alias(cNokolexborNode, "get_attribute", "[]");
   rb_define_alias(cNokolexborNode, "set_attr", "[]=");
+  rb_define_alias(cNokolexborNode, "set_attribute", "[]=");
+  rb_define_alias(cNokolexborNode, "has_attribute?", "key?");
   rb_define_alias(cNokolexborNode, "delete", "remove_attr");
+  rb_define_alias(cNokolexborNode, "remove_attribute", "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, "serialize", "outer_html");
   rb_define_alias(cNokolexborNode, "to_s", "outer_html");
   rb_define_alias(cNokolexborNode, "unlink", "remove");
   rb_define_alias(cNokolexborNode, "type", "node_type");