nokolexbor 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e83f343175997fd437b89893ae63b7cc6eaffa86711800a42e8ce64371c03c85
-  data.tar.gz: ea272e36f2a37cd5bc3e8e13b3fa8993098503abdaa85299bcf99f59ae484918
+  metadata.gz: 042127a2ed4027c52d3718c148921604cae07c274dddb7f3702c7caf0708863f
+  data.tar.gz: 60230b55b773ef41abdca313adc3ffdba38a0b8462c9d23c3365e57c68b63bd5
 SHA512:
-  metadata.gz: be0f026e8f2571705f1ae6225ddc4a3b7e78d7108e441a63d8b0988d4d0c91afa7af57ce8c6c318c1f2a5c38ebf00d9190ce29ec27de8e17505250273209d834
-  data.tar.gz: 0000f9c78d7743e789c8edc11aaeaf4bf8a75503d0b6631a0a25a9d3c571a56fb424fc69d3e4c2a737d38c4a84c23424cd79a87f4b6f967b749522b217bd1abd
+  metadata.gz: f06063b84e62e23ba093a397ba6ffdbd802480e711ca24966d5b78be8bc8a7299754ab8bb4cd5d77d6dfe39efa7c21c705b105fe9d626d62eddc5e2e5a6ec9fb
+  data.tar.gz: 86ddfdb650b78827071385cfca708ddbffcd35204a71f439315f800e8e60ee73c2d49ce46e28192ac454df8bab7ef8cbc937b97830e0b488290dbadccd8e51d6

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

@@ -329,9 +329,9 @@ nl_xpath_context_new(VALUE klass, VALUE rb_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);
+                            xpath_builtin_css_class);
   nl_xmlXPathRegisterFuncNS(ctx, (const xmlChar *)"local-name-is", NOKOGIRI_BUILTIN_URI,
-                         xpath_builtin_local_name_is);
+                            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,56 +1,6 @@
 #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)
 {
@@ -58,13 +8,14 @@ void Init_nokolexbor(void)
   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/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)

data/lib/nokolexbor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nokolexbor
-  VERSION = '0.3.2'
+  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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nokolexbor
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Yicheng Zhou
@@ -81,8 +81,11 @@ files:
 - 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
@@ -118,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