nokolexbor 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e83f343175997fd437b89893ae63b7cc6eaffa86711800a42e8ce64371c03c85
-  data.tar.gz: ea272e36f2a37cd5bc3e8e13b3fa8993098503abdaa85299bcf99f59ae484918
+  metadata.gz: 53cb1f54e475a0b10fc7773259866fe675e761d0ca204c5f685f4ed8dd60294a
+  data.tar.gz: 0e697320eae75b41e16ac431c6c679159507013b5e3a9858959377eb969355b2
 SHA512:
-  metadata.gz: be0f026e8f2571705f1ae6225ddc4a3b7e78d7108e441a63d8b0988d4d0c91afa7af57ce8c6c318c1f2a5c38ebf00d9190ce29ec27de8e17505250273209d834
-  data.tar.gz: 0000f9c78d7743e789c8edc11aaeaf4bf8a75503d0b6631a0a25a9d3c571a56fb424fc69d3e4c2a737d38c4a84c23424cd79a87f4b6f967b749522b217bd1abd
+  metadata.gz: 609b453f596331b53ab13b403c274cde9472e119307c0af63da19be28f0475603705ef285332c94f8b39a47b6850dfc138694ccee0ede531acffd67e31e915a9
+  data.tar.gz: 9f6d2c3ceba6d98bc8f87d59c846bd6c41fc2758681b66481c72de1027078d30e62344267cfe63ce58209e23f6749502750fa05f4365112275d79cee11641e9d

data/ext/nokolexbor/nl_attribute.c

@@ -0,0 +1,155 @@
+#include "nokolexbor.h"
+
+VALUE cNokolexborAttribute;
+extern VALUE mNokolexbor;
+extern VALUE cNokolexborNode;
+
+static VALUE
+nl_attribute_new(int argc, VALUE *argv, VALUE klass)
+{
+  lxb_dom_document_t *document;
+  VALUE rb_document;
+  VALUE rb_name;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "2*", &rb_document, &rb_name, &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);
+  lxb_dom_attr_t *attr = lxb_dom_attr_interface_create(document);
+  if (attr == NULL) {
+    rb_raise(rb_eRuntimeError, "Error creating attribute");
+  }
+
+  lxb_dom_attr_set_name(attr, (const lxb_char_t *)c_name, name_len, false);
+
+  VALUE rb_node = nl_rb_node_create(&attr->node, rb_document);
+
+  if (rb_block_given_p()) {
+    rb_yield(rb_node);
+  }
+
+  return rb_node;
+}
+
+static VALUE
+nl_attribute_name(VALUE self)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  lxb_dom_attr_t *attr = lxb_dom_interface_attr(node);
+
+  size_t len;
+  lxb_char_t *name = lxb_dom_attr_qualified_name(attr, &len);
+
+  return rb_utf8_str_new(name, len);
+}
+
+static VALUE
+nl_attribute_set_name(VALUE self, VALUE rb_name)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  lxb_dom_attr_t *attr = lxb_dom_interface_attr(node);
+
+  const char *c_name = StringValuePtr(rb_name);
+  size_t name_len = RSTRING_LEN(rb_name);
+
+  lxb_status_t status = lxb_dom_attr_set_name(attr, (const lxb_char_t *)c_name, name_len, false);
+  if (status != LXB_STATUS_OK) {
+    nl_raise_lexbor_error(status);
+  }
+
+  return rb_name;
+}
+
+static VALUE
+nl_attribute_value(VALUE self)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  lxb_dom_attr_t *attr = lxb_dom_interface_attr(node);
+
+  size_t len;
+  lxb_char_t *value = lxb_dom_attr_value(attr, &len);
+
+  return rb_utf8_str_new(value, len);
+}
+
+static VALUE
+nl_attribute_set_value(VALUE self, VALUE rb_content)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  lxb_dom_attr_t *attr = lxb_dom_interface_attr(node);
+
+  const char *c_content = StringValuePtr(rb_content);
+  size_t content_len = RSTRING_LEN(rb_content);
+
+  lxb_status_t status = lxb_dom_attr_set_value(attr, (const lxb_char_t *)c_content, content_len);
+  if (status != LXB_STATUS_OK) {
+    nl_raise_lexbor_error(status);
+  }
+
+  return rb_content;
+}
+
+static VALUE
+nl_attribute_parent(VALUE self)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  lxb_dom_attr_t *attr = lxb_dom_interface_attr(node);
+
+  if (attr->owner == NULL) {
+    return Qnil;
+  }
+  return nl_rb_node_create(attr->owner, nl_rb_document_get(self));
+}
+
+static VALUE
+nl_attribute_previous(VALUE self)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  lxb_dom_attr_t *attr = lxb_dom_interface_attr(node);
+
+  if (attr->prev == NULL) {
+    return Qnil;
+  }
+  return nl_rb_node_create(attr->prev, nl_rb_document_get(self));
+}
+
+static VALUE
+nl_attribute_next(VALUE self)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  lxb_dom_attr_t *attr = lxb_dom_interface_attr(node);
+
+  if (attr->next == NULL) {
+    return Qnil;
+  }
+  return nl_rb_node_create(attr->next, nl_rb_document_get(self));
+}
+
+void Init_nl_attribute(void)
+{
+  cNokolexborAttribute = rb_define_class_under(mNokolexbor, "Attribute", cNokolexborNode);
+
+  rb_define_singleton_method(cNokolexborAttribute, "new", nl_attribute_new, -1);
+
+  rb_define_method(cNokolexborAttribute, "name", nl_attribute_name, 0);
+  rb_define_method(cNokolexborAttribute, "name=", nl_attribute_set_name, 1);
+  rb_define_method(cNokolexborAttribute, "value", nl_attribute_value, 0);
+  rb_define_method(cNokolexborAttribute, "value=", nl_attribute_set_value, 1);
+  rb_define_method(cNokolexborAttribute, "parent", nl_attribute_parent, 0);
+  rb_define_method(cNokolexborAttribute, "previous", nl_attribute_previous, 0);
+  rb_define_method(cNokolexborAttribute, "next", nl_attribute_next, 0);
+
+  rb_define_alias(cNokolexborAttribute, "node_name", "name");
+  rb_define_alias(cNokolexborAttribute, "node_name=", "name=");
+  rb_define_alias(cNokolexborAttribute, "text", "value");
+  rb_define_alias(cNokolexborAttribute, "content", "value");
+  rb_define_alias(cNokolexborAttribute, "to_s", "value");
+  rb_define_alias(cNokolexborAttribute, "to_str", "value");
+}

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,10 @@ extern VALUE mNokolexbor;
 extern VALUE cNokolexborDocument;
 extern VALUE cNokolexborText;
 extern VALUE cNokolexborComment;
+extern VALUE cNokolexborProcessingInstruction;
 extern VALUE cNokolexborNodeSet;
+extern VALUE cNokolexborDocumentFragment;
+extern VALUE cNokolexborAttribute;
 extern VALUE eLexborError;
 VALUE cNokolexborNode;
 VALUE cNokolexborElement;
@@ -29,8 +32,9 @@ nl_rb_node_create(lxb_dom_node_t *node, VALUE rb_document)
   case LXB_DOM_NODE_TYPE_ELEMENT:
     rb_class = cNokolexborElement;
     break;
-  // case LXB_DOM_NODE_TYPE_ATTRIBUTE:
-  //   break;
+  case LXB_DOM_NODE_TYPE_ATTRIBUTE:
+    rb_class = cNokolexborAttribute;
+    break;
   case LXB_DOM_NODE_TYPE_TEXT:
     rb_class = cNokolexborText;
     break;
@@ -41,8 +45,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 +55,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 +97,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) {
@@ -107,6 +113,55 @@ nl_node_new(int argc, VALUE *argv, VALUE klass)
   return rb_node;
 }
 
+static VALUE
+nl_node_attribute(VALUE self, VALUE rb_name)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+
+  const char *c_name = StringValuePtr(rb_name);
+  size_t name_len = RSTRING_LEN(rb_name);
+
+  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
+    return Qnil;
+  }
+
+  lxb_dom_attr_t *attr = lxb_dom_element_attr_by_name(lxb_dom_interface_element(node), (const lxb_char_t *)c_name, name_len);
+  if (attr == NULL) {
+    return Qnil;
+  }
+  if (attr->owner == NULL) {
+    attr->owner = node;
+  }
+  return nl_rb_node_create(attr, nl_rb_document_get(self));
+}
+
+static VALUE
+nl_node_attribute_nodes(VALUE self)
+{
+  lxb_dom_node_t *node = nl_rb_node_unwrap(self);
+  VALUE ary = rb_ary_new();
+  if (node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
+    return ary;
+  }
+
+  lxb_dom_attr_t *attr = lxb_dom_element_first_attribute(lxb_dom_interface_element(node));
+
+  if (attr == NULL) {
+    return ary;
+  }
+
+  VALUE rb_doc = nl_rb_document_get(self);
+  while (attr != NULL) {
+    if (attr->owner == NULL) {
+      attr->owner = node;
+    }
+    rb_ary_push(ary, nl_rb_node_create(attr, rb_doc));
+    attr = attr->next;
+  }
+
+  return ary;
+}
+
 static VALUE
 nl_node_content(VALUE self)
 {
@@ -657,17 +712,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 +734,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 +768,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 +799,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) {
@@ -822,7 +887,17 @@ static VALUE
 nl_node_clone(VALUE self)
 {
   lxb_dom_node_t *node = nl_rb_node_unwrap(self);
-  lxb_dom_node_t *clone = lxb_dom_node_clone(node, 1);
+  lxb_dom_node_t *clone;
+
+  switch (node->type) {
+  case LXB_DOM_NODE_TYPE_ATTRIBUTE:
+    clone = lxb_dom_attr_interface_clone(node->owner_document, lxb_dom_interface_attr(node));
+  case LXB_DOM_NODE_TYPE_CDATA_SECTION:
+    clone = lxb_dom_cdata_section_interface_clone(node->owner_document, lxb_dom_interface_cdata_section(node));
+  default:
+    clone = lxb_dom_node_clone(node, true);
+    break;
+  }
   return nl_rb_node_create(clone, nl_rb_document_get(self));
 }
 
@@ -835,6 +910,8 @@ void Init_nl_node(void)
   cNokolexborCharacterData = rb_define_class_under(mNokolexbor, "CharacterData", cNokolexborNode);
 
   rb_define_singleton_method(cNokolexborNode, "new", nl_node_new, -1);
+  rb_define_method(cNokolexborNode, "attribute", nl_node_attribute, 1);
+  rb_define_method(cNokolexborNode, "attribute_nodes", nl_node_attribute_nodes, 0);
   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);
@@ -859,7 +936,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,15 @@ 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_attribute();
   Init_nl_xpath_context();
 }

data/ext/nokolexbor/nokolexbor.h

@@ -9,12 +9,16 @@
 
 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_attribute(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

@@ -145,13 +145,10 @@ module Nokolexbor
       ancestors.last.css(selector).any? { |node| node == self }
     end
 
-    def attribute(name)
-      return nil unless key?(name)
-      Attribute.new(name, attr(name))
-    end
-
     def attributes
-      attrs.map { |k, v| [k, Attribute.new(k, v)] }.to_h
+      attribute_nodes.each_with_object({}) do |node, hash|
+        hash[node.name] = node
+      end
     end
 
     def replace(node)
@@ -182,6 +179,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.4'
 end

data/lib/nokolexbor.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nokolexbor
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - Yicheng Zhou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-09 00:00:00.000000000 Z
+date: 2023-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -78,11 +78,15 @@ files:
 - ext/nokolexbor/libxml/xpath.h
 - ext/nokolexbor/libxml/xpathInternals.h
 - ext/nokolexbor/libxml/xpointer.h
+- ext/nokolexbor/nl_attribute.c
 - ext/nokolexbor/nl_cdata.c
 - ext/nokolexbor/nl_comment.c
 - ext/nokolexbor/nl_document.c
+- ext/nokolexbor/nl_document_fragment.c
+- ext/nokolexbor/nl_error.c
 - ext/nokolexbor/nl_node.c
 - ext/nokolexbor/nl_node_set.c
+- ext/nokolexbor/nl_processing_instruction.c
 - ext/nokolexbor/nl_text.c
 - ext/nokolexbor/nl_xpath_context.c
 - ext/nokolexbor/nokolexbor.c
@@ -116,8 +120,8 @@ files:
 - ext/nokolexbor/xml_tree.c
 - ext/nokolexbor/xml_xpath.c
 - lib/nokolexbor.rb
-- lib/nokolexbor/attribute.rb
 - lib/nokolexbor/document.rb
+- lib/nokolexbor/document_fragment.rb
 - lib/nokolexbor/node.rb
 - lib/nokolexbor/node_set.rb
 - lib/nokolexbor/version.rb

data/lib/nokolexbor/attribute.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Nokolexbor
-  class Attribute
-    attr_accessor :name
-    attr_accessor :value
-
-    def initialize(name, value)
-      @name = name
-      @value = value
-    end
-
-    alias_method :text, :value
-    alias_method :content, :value
-    alias_method :to_s, :value
-    alias_method :to_str, :value
-  end
-end