nokolexbor 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 042127a2ed4027c52d3718c148921604cae07c274dddb7f3702c7caf0708863f
-  data.tar.gz: 60230b55b773ef41abdca313adc3ffdba38a0b8462c9d23c3365e57c68b63bd5
+  metadata.gz: 23409daec8c9cbe801afef6c39e6507fc938eb35cad2458ef80fc99e6bf5bece
+  data.tar.gz: 06e83318711ac6e6c2582d78fcd87f5a0efeaceff7421a1880cd8e698637d803
 SHA512:
-  metadata.gz: f06063b84e62e23ba093a397ba6ffdbd802480e711ca24966d5b78be8bc8a7299754ab8bb4cd5d77d6dfe39efa7c21c705b105fe9d626d62eddc5e2e5a6ec9fb
-  data.tar.gz: 86ddfdb650b78827071385cfca708ddbffcd35204a71f439315f800e8e60ee73c2d49ce46e28192ac454df8bab7ef8cbc937b97830e0b488290dbadccd8e51d6
+  metadata.gz: d77bb45c508edba84043156149ff1dfce0249b7f4d52d871c0552b4f590c01e0879c77b0bf039a46ee019be4e445b072a658fbb9fc3872c8b1d6f48e4801b0dd
+  data.tar.gz: 8ec494323f66188fbd39455c05a63e6be0fa5f8979fcb43310dc80a429a3d77355b8875988fa800041a04f1746254b0d88d9522780c085469efe18308a3d4576

data/ext/nokolexbor/nl_attribute.c

@@ -0,0 +1,201 @@
+#include "nokolexbor.h"
+
+VALUE cNokolexborAttribute;
+extern VALUE mNokolexbor;
+extern VALUE cNokolexborNode;
+
+/**
+ * call-seq:
+ *   new(document, name) -> Attribute
+ *
+ * Create a new Attribute on the +document+ with +name+.
+ *
+ * @param document [Document]
+ * @param name [String]
+ */
+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;
+}
+
+/**
+ * Get the name of the Attribute.
+ *
+ * @return [String]
+ */
+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);
+}
+
+/**
+ * call-seq:
+ *   name=(name) -> String
+ *
+ * Set the name of the Attribute.
+ */
+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;
+}
+
+/**
+ * Get the value of the Attribute.
+ *
+ * @return [String]
+ */
+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);
+}
+
+/**
+ * call-seq:
+ *   value=(value) -> String
+ *
+ * Set the value of the Attribute.
+ */
+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;
+}
+
+/**
+ * Get the owner Node of the Attribute.
+ *
+ * @return [Node]
+ */
+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));
+}
+
+/**
+ * Get the previous Attribute.
+ *
+ * @return [Attribute]
+ */
+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));
+}
+
+/**
+ * Get the next Attribute.
+ *
+ * @return [Attribute]
+ */
+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

@@ -4,6 +4,14 @@ VALUE cNokolexborCData;
 extern VALUE cNokolexborText;
 extern VALUE mNokolexbor;
 
+/**
+ * call-seq:
+ *   new(content, document) { |CDATA| ... } -> CDATA
+ *
+ * Create a new CDATA from +content+.
+ *
+ * @return [CDATA]
+ */
 static VALUE
 nl_cdata_new(int argc, VALUE *argv, VALUE klass)
 {

data/ext/nokolexbor/nl_comment.c

@@ -4,6 +4,12 @@ VALUE cNokolexborComment;
 extern VALUE cNokolexborCharacterData;
 extern VALUE mNokolexbor;
 
+/**
+ * call-seq:
+ *   new(content, document) { |Comment| ... } -> Comment
+ *
+ * Create a new Comment from +content+.
+ */
 static VALUE
 nl_comment_new(int argc, VALUE *argv, VALUE klass)
 {

data/ext/nokolexbor/nl_document.c

@@ -21,6 +21,16 @@ const rb_data_type_t nl_document_type = {
     RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
+/**
+ * call-seq:
+ *   parse(string_or_io) -> Document
+ *
+ * Parse HTML into a {Document}.
+ *
+ * @param string_or_io [String, #read]
+ *   The HTML to be parsed. It may be a String, or any object that
+ *   responds to #read such as an IO, or StringIO.
+ */
 static VALUE
 nl_document_parse(VALUE self, VALUE rb_string_or_io)
 {
@@ -51,6 +61,11 @@ nl_document_parse(VALUE self, VALUE rb_string_or_io)
   return TypedData_Wrap_Struct(cNokolexborDocument, &nl_document_type, document);
 }
 
+/**
+ * Create a new document.
+ *
+ * @return [Document]
+ */
 static VALUE
 nl_document_new(VALUE self)
 {
@@ -65,21 +80,51 @@ nl_rb_document_unwrap(VALUE rb_doc)
   return doc;
 }
 
-VALUE
-nl_document_get_title(VALUE rb_doc)
+/**
+ * Get the title of this document.
+ *
+ * @return [String]
+ */
+static VALUE
+nl_document_get_title(VALUE self)
 {
   size_t len;
-  lxb_char_t *str = lxb_html_document_title(nl_rb_document_unwrap(rb_doc), &len);
+  lxb_char_t *str = lxb_html_document_title(nl_rb_document_unwrap(self), &len);
   return str == NULL ? rb_str_new("", 0) : rb_utf8_str_new(str, len);
 }
 
-VALUE
-nl_document_set_title(VALUE rb_doc, VALUE rb_title)
+/**
+ * call-seq:
+ *   title=(text) -> String
+ *
+ * Set the title of this document.
+ *
+ * If a title element is already present, its content is replaced
+ * with the given text.
+ *
+ * Otherwise, this method tries to create one inside <head>.
+ *
+ * @return [String]
+ */
+static VALUE
+nl_document_set_title(VALUE self, VALUE rb_title)
 {
   const char *c_title = StringValuePtr(rb_title);
   size_t len = RSTRING_LEN(rb_title);
-  lxb_char_t *str = lxb_html_document_title_set(nl_rb_document_unwrap(rb_doc), (const lxb_char_t *)c_title, len);
-  return Qnil;
+  lxb_char_t *str = lxb_html_document_title_set(nl_rb_document_unwrap(self), (const lxb_char_t *)c_title, len);
+  return rb_title;
+}
+
+/**
+ * Get the root node for this document.
+ *
+ * @return [Node]
+ */
+static VALUE
+nl_document_root(VALUE self)
+{
+  lxb_dom_document_t *doc = nl_rb_document_unwrap(self);
+  return nl_rb_node_create(lxb_dom_document_root(doc), self);
 }
 
 void Init_nl_document(void)
@@ -89,4 +134,5 @@ void Init_nl_document(void)
   rb_define_singleton_method(cNokolexborDocument, "parse", nl_document_parse, 1);
   rb_define_method(cNokolexborDocument, "title", nl_document_get_title, 0);
   rb_define_method(cNokolexborDocument, "title=", nl_document_set_title, 1);
+  rb_define_method(cNokolexborDocument, "root", nl_document_root, 0);
 }

data/ext/nokolexbor/nl_document_fragment.c

@@ -4,6 +4,15 @@ VALUE cNokolexborDocumentFragment;
 extern VALUE cNokolexborNode;
 extern VALUE mNokolexbor;
 
+/**
+ * call-seq:
+ *   new(document, tags = nil, ctx = nil) -> DocumentFragment
+ *
+ * Create a {DocumentFragment} from +tags+.
+ *
+ * If +ctx+ is present, it is used as a context node for the
+ * subtree created.
+ */
 static VALUE
 nl_document_fragment_new(int argc, VALUE *argv, VALUE klass)
 {

data/ext/nokolexbor/nl_error.c

@@ -1,5 +1,6 @@
 #include "nokolexbor.h"
 
+VALUE mLexbor;
 VALUE eLexborError;
 VALUE eLexborMemoryAllocationError;
 VALUE eLexborSmallBufferError;
@@ -71,23 +72,24 @@ void nl_raise_lexbor_error(lxb_status_t 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);
+  mLexbor = rb_define_module_under(mNokolexbor, "Lexbor");
+  eLexborError = rb_define_class_under(mLexbor, "Error", rb_eStandardError);
+  eLexborMemoryAllocationError = rb_define_class_under(mLexbor, "MemoryAllocationError", eLexborError);
+  eLexborSmallBufferError = rb_define_class_under(mLexbor, "SmallBufferError", eLexborError);
+  eLexborObjectIsNullError = rb_define_class_under(mLexbor, "ObjectIsNullError", eLexborError);
+  eLexborIncompleteObjectError = rb_define_class_under(mLexbor, "IncompleteObjectError", eLexborError);
+  eLexborNoFreeSlotError = rb_define_class_under(mLexbor, "NoFreeSlotError", eLexborError);
+  eLexborTooSmallSizeError = rb_define_class_under(mLexbor, "TooSmallSizeError", eLexborError);
+  eLexborNotExistsError = rb_define_class_under(mLexbor, "NotExistsError", eLexborError);
+  eLexborWrongArgsError = rb_define_class_under(mLexbor, "WrongArgsError", eLexborError);
+  eLexborWrongStageError = rb_define_class_under(mLexbor, "WrongStageError", eLexborError);
+  eLexborUnexpectedResultError = rb_define_class_under(mLexbor, "UnexpectedResultError", eLexborError);
+  eLexborUnexpectedDataError = rb_define_class_under(mLexbor, "UnexpectedDataError", eLexborError);
+  eLexborOverflowError = rb_define_class_under(mLexbor, "OverflowError", eLexborError);
+  eLexborContinueStatus = rb_define_class_under(mLexbor, "ContinueStatus", eLexborError);
+  eLexborSmallBufferStatus = rb_define_class_under(mLexbor, "SmallBufferStatus", eLexborError);
+  eLexborAbortedStatus = rb_define_class_under(mLexbor, "AbortedStatus", eLexborError);
+  eLexborStoppedStatus = rb_define_class_under(mLexbor, "StoppedStatus", eLexborError);
+  eLexborNextStatus = rb_define_class_under(mLexbor, "NextStatus", eLexborError);
+  eLexborStopStatus = rb_define_class_under(mLexbor, "StopStatus", eLexborError);
 }