nokogiri 1.18.0.rc1-x86_64-linux-musl

data/ext/nokogiri/xml_document_fragment.c

@@ -0,0 +1,29 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlDocumentFragment;
+
+/* :nodoc: */
+static VALUE
+noko_xml_document_fragment_s_native_new(VALUE klass, VALUE rb_doc)
+{
+  xmlDocPtr c_doc;
+  xmlNodePtr c_node;
+  VALUE rb_node;
+
+  c_doc = noko_xml_document_unwrap(rb_doc);
+  c_node = xmlNewDocFragment(c_doc->doc);
+  noko_xml_document_pin_node(c_node);
+  rb_node = noko_xml_node_wrap(klass, c_node);
+
+  return rb_node;
+}
+
+void
+noko_init_xml_document_fragment(void)
+{
+  assert(cNokogiriXmlNode);
+
+  cNokogiriXmlDocumentFragment = rb_define_class_under(mNokogiriXml, "DocumentFragment", cNokogiriXmlNode);
+
+  rb_define_singleton_method(cNokogiriXmlDocumentFragment, "native_new", noko_xml_document_fragment_s_native_new, 1);
+}

data/ext/nokogiri/xml_dtd.c

@@ -0,0 +1,208 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlDtd;
+
+static void
+notation_copier(void *c_notation_ptr, void *rb_hash_ptr, const xmlChar *name)
+{
+  VALUE rb_hash = (VALUE)rb_hash_ptr;
+  xmlNotationPtr c_notation = (xmlNotationPtr)c_notation_ptr;
+  VALUE rb_notation;
+  VALUE cNokogiriXmlNotation;
+  VALUE rb_constructor_args[3];
+
+  rb_constructor_args[0] = (c_notation->name ? NOKOGIRI_STR_NEW2(c_notation->name) : Qnil);
+  rb_constructor_args[1] = (c_notation->PublicID ? NOKOGIRI_STR_NEW2(c_notation->PublicID) : Qnil);
+  rb_constructor_args[2] = (c_notation->SystemID ? NOKOGIRI_STR_NEW2(c_notation->SystemID) : Qnil);
+
+  cNokogiriXmlNotation = rb_const_get_at(mNokogiriXml, rb_intern("Notation"));
+  rb_notation = rb_class_new_instance(3, rb_constructor_args, cNokogiriXmlNotation);
+
+  rb_hash_aset(rb_hash, NOKOGIRI_STR_NEW2(name), rb_notation);
+}
+
+static void
+element_copier(void *c_node_ptr, void *rb_hash_ptr, const xmlChar *c_name)
+{
+  VALUE rb_hash = (VALUE)rb_hash_ptr;
+  xmlNodePtr c_node = (xmlNodePtr)c_node_ptr;
+
+  VALUE rb_node = noko_xml_node_wrap(Qnil, c_node);
+
+  rb_hash_aset(rb_hash, NOKOGIRI_STR_NEW2(c_name), rb_node);
+}
+
+/*
+ * call-seq:
+ *   entities
+ *
+ * Get a hash of the elements for this DTD.
+ */
+static VALUE
+entities(VALUE self)
+{
+  xmlDtdPtr dtd;
+  VALUE hash;
+
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
+
+  if (!dtd->entities) { return Qnil; }
+
+  hash = rb_hash_new();
+
+  xmlHashScan((xmlHashTablePtr)dtd->entities, element_copier, (void *)hash);
+
+  return hash;
+}
+
+/*
+ * call-seq:
+ *   notations() → Hash<name(String)⇒Notation>
+ *
+ * [Returns] All the notations for this DTD in a Hash of Notation +name+ to Notation.
+ */
+static VALUE
+notations(VALUE self)
+{
+  xmlDtdPtr dtd;
+  VALUE hash;
+
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
+
+  if (!dtd->notations) { return Qnil; }
+
+  hash = rb_hash_new();
+
+  xmlHashScan((xmlHashTablePtr)dtd->notations, notation_copier, (void *)hash);
+
+  return hash;
+}
+
+/*
+ * call-seq:
+ *   attributes
+ *
+ * Get a hash of the attributes for this DTD.
+ */
+static VALUE
+attributes(VALUE self)
+{
+  xmlDtdPtr dtd;
+  VALUE hash;
+
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
+
+  hash = rb_hash_new();
+
+  if (!dtd->attributes) { return hash; }
+
+  xmlHashScan((xmlHashTablePtr)dtd->attributes, element_copier, (void *)hash);
+
+  return hash;
+}
+
+/*
+ * call-seq:
+ *   elements
+ *
+ * Get a hash of the elements for this DTD.
+ */
+static VALUE
+elements(VALUE self)
+{
+  xmlDtdPtr dtd;
+  VALUE hash;
+
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
+
+  if (!dtd->elements) { return Qnil; }
+
+  hash = rb_hash_new();
+
+  xmlHashScan((xmlHashTablePtr)dtd->elements, element_copier, (void *)hash);
+
+  return hash;
+}
+
+/*
+ * call-seq:
+ *   validate(document)
+ *
+ * Validate +document+ returning a list of errors
+ */
+static VALUE
+validate(VALUE self, VALUE document)
+{
+  xmlDocPtr doc;
+  xmlDtdPtr dtd;
+  xmlValidCtxtPtr ctxt;
+  VALUE error_list;
+
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
+  doc = noko_xml_document_unwrap(document);
+  error_list = rb_ary_new();
+
+  ctxt = xmlNewValidCtxt();
+
+  xmlSetStructuredErrorFunc((void *)error_list, noko__error_array_pusher);
+
+  xmlValidateDtd(ctxt, doc, dtd);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
+  xmlFreeValidCtxt(ctxt);
+
+  return error_list;
+}
+
+/*
+ * call-seq:
+ *   system_id
+ *
+ * Get the System ID for this DTD
+ */
+static VALUE
+system_id(VALUE self)
+{
+  xmlDtdPtr dtd;
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
+
+  if (!dtd->SystemID) { return Qnil; }
+
+  return NOKOGIRI_STR_NEW2(dtd->SystemID);
+}
+
+/*
+ * call-seq:
+ *   external_id
+ *
+ * Get the External ID for this DTD
+ */
+static VALUE
+external_id(VALUE self)
+{
+  xmlDtdPtr dtd;
+  Noko_Node_Get_Struct(self, xmlDtd, dtd);
+
+  if (!dtd->ExternalID) { return Qnil; }
+
+  return NOKOGIRI_STR_NEW2(dtd->ExternalID);
+}
+
+void
+noko_init_xml_dtd(void)
+{
+  assert(cNokogiriXmlNode);
+  /*
+   * Nokogiri::XML::DTD wraps DTD nodes in an XML document
+   */
+  cNokogiriXmlDtd = rb_define_class_under(mNokogiriXml, "DTD", cNokogiriXmlNode);
+
+  rb_define_method(cNokogiriXmlDtd, "notations", notations, 0);
+  rb_define_method(cNokogiriXmlDtd, "elements", elements, 0);
+  rb_define_method(cNokogiriXmlDtd, "entities", entities, 0);
+  rb_define_method(cNokogiriXmlDtd, "validate", validate, 1);
+  rb_define_method(cNokogiriXmlDtd, "attributes", attributes, 0);
+  rb_define_method(cNokogiriXmlDtd, "system_id", system_id, 0);
+  rb_define_method(cNokogiriXmlDtd, "external_id", external_id, 0);
+}

data/ext/nokogiri/xml_element_content.c

@@ -0,0 +1,131 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlElementContent;
+
+static const rb_data_type_t xml_element_content_type = {
+  .wrap_struct_name = "xmlElementContent",
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+/*
+ * call-seq:
+ *   name → String
+ *
+ * [Returns] The content element's +name+
+ */
+static VALUE
+get_name(VALUE self)
+{
+  xmlElementContentPtr elem;
+  TypedData_Get_Struct(self, xmlElementContent, &xml_element_content_type, elem);
+
+  if (!elem->name) { return Qnil; }
+  return NOKOGIRI_STR_NEW2(elem->name);
+}
+
+/*
+ * call-seq:
+ *   type → Integer
+ *
+ * [Returns] The content element's +type+. Possible values are +PCDATA+, +ELEMENT+, +SEQ+, or +OR+.
+ */
+static VALUE
+get_type(VALUE self)
+{
+  xmlElementContentPtr elem;
+  TypedData_Get_Struct(self, xmlElementContent, &xml_element_content_type, elem);
+
+  return INT2NUM(elem->type);
+}
+
+/*
+ * Get the first child.
+ */
+static VALUE
+get_c1(VALUE self)
+{
+  xmlElementContentPtr elem;
+  TypedData_Get_Struct(self, xmlElementContent, &xml_element_content_type, elem);
+
+  if (!elem->c1) { return Qnil; }
+  return noko_xml_element_content_wrap(rb_iv_get(self, "@document"), elem->c1);
+}
+
+/*
+ * Get the second child.
+ */
+static VALUE
+get_c2(VALUE self)
+{
+  xmlElementContentPtr elem;
+  TypedData_Get_Struct(self, xmlElementContent, &xml_element_content_type, elem);
+
+  if (!elem->c2) { return Qnil; }
+  return noko_xml_element_content_wrap(rb_iv_get(self, "@document"), elem->c2);
+}
+
+/*
+ * call-seq:
+ *   occur → Integer
+ *
+ * [Returns] The content element's +occur+ flag. Possible values are +ONCE+, +OPT+, +MULT+ or +PLUS+.
+ */
+static VALUE
+get_occur(VALUE self)
+{
+  xmlElementContentPtr elem;
+  TypedData_Get_Struct(self, xmlElementContent, &xml_element_content_type, elem);
+
+  return INT2NUM(elem->ocur);
+}
+
+/*
+ * call-seq:
+ *   prefix → String
+ *
+ * [Returns] The content element's namespace +prefix+.
+ */
+static VALUE
+get_prefix(VALUE self)
+{
+  xmlElementContentPtr elem;
+  TypedData_Get_Struct(self, xmlElementContent, &xml_element_content_type, elem);
+
+  if (!elem->prefix) { return Qnil; }
+
+  return NOKOGIRI_STR_NEW2(elem->prefix);
+}
+
+/*
+ *  create a Nokogiri::XML::ElementContent object around an +element+.
+ */
+VALUE
+noko_xml_element_content_wrap(VALUE rb_document, xmlElementContentPtr c_element_content)
+{
+  VALUE elem = TypedData_Wrap_Struct(
+                 cNokogiriXmlElementContent,
+                 &xml_element_content_type,
+                 c_element_content
+               );
+
+  /* keep a handle on the document for GC marking */
+  rb_iv_set(elem, "@document", rb_document);
+
+  return elem;
+}
+
+void
+noko_init_xml_element_content(void)
+{
+  cNokogiriXmlElementContent = rb_define_class_under(mNokogiriXml, "ElementContent", rb_cObject);
+
+  rb_undef_alloc_func(cNokogiriXmlElementContent);
+
+  rb_define_method(cNokogiriXmlElementContent, "name", get_name, 0);
+  rb_define_method(cNokogiriXmlElementContent, "type", get_type, 0);
+  rb_define_method(cNokogiriXmlElementContent, "occur", get_occur, 0);
+  rb_define_method(cNokogiriXmlElementContent, "prefix", get_prefix, 0);
+
+  rb_define_private_method(cNokogiriXmlElementContent, "c1", get_c1, 0);
+  rb_define_private_method(cNokogiriXmlElementContent, "c2", get_c2, 0);
+}

data/ext/nokogiri/xml_element_decl.c

@@ -0,0 +1,69 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlElementDecl;
+
+static ID id_document;
+
+/*
+ * call-seq:
+ *   element_type → Integer
+ *
+ * The element_type
+ */
+static VALUE
+element_type(VALUE self)
+{
+  xmlElementPtr node;
+  Noko_Node_Get_Struct(self, xmlElement, node);
+  return INT2NUM(node->etype);
+}
+
+/*
+ * call-seq:
+ *   content → Nokogiri::XML::ElementContent
+ *
+ * [Returns] The root of this element declaration's content tree.
+ */
+static VALUE
+content(VALUE self)
+{
+  xmlElementPtr node;
+  Noko_Node_Get_Struct(self, xmlElement, node);
+
+  if (!node->content) { return Qnil; }
+
+  return noko_xml_element_content_wrap(
+           rb_funcall(self, id_document, 0),
+           node->content
+         );
+}
+
+/*
+ * call-seq:
+ *   prefix → String
+ *
+ * [Returns] The namespace +prefix+ for this element declaration.
+ */
+static VALUE
+prefix(VALUE self)
+{
+  xmlElementPtr node;
+  Noko_Node_Get_Struct(self, xmlElement, node);
+
+  if (!node->prefix) { return Qnil; }
+
+  return NOKOGIRI_STR_NEW2(node->prefix);
+}
+
+void
+noko_init_xml_element_decl(void)
+{
+  assert(cNokogiriXmlNode);
+  cNokogiriXmlElementDecl = rb_define_class_under(mNokogiriXml, "ElementDecl", cNokogiriXmlNode);
+
+  rb_define_method(cNokogiriXmlElementDecl, "element_type", element_type, 0);
+  rb_define_method(cNokogiriXmlElementDecl, "content", content, 0);
+  rb_define_method(cNokogiriXmlElementDecl, "prefix", prefix, 0);
+
+  id_document = rb_intern("document");
+}

data/ext/nokogiri/xml_encoding_handler.c

@@ -0,0 +1,112 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriEncodingHandler;
+
+static void
+xml_encoding_handler_dealloc(void *data)
+{
+  /* make sure iconv handlers are cleaned up and freed */
+  xmlCharEncodingHandlerPtr c_handler = data;
+  xmlCharEncCloseFunc(c_handler);
+}
+
+static const rb_data_type_t xml_char_encoding_handler_type = {
+  .wrap_struct_name = "xmlCharEncodingHandler",
+  .function = {
+    .dfree = xml_encoding_handler_dealloc,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+
+/*
+ * call-seq: Nokogiri::EncodingHandler.[](name)
+ *
+ * Get the encoding handler for +name+
+ */
+static VALUE
+rb_xml_encoding_handler_s_get(VALUE klass, VALUE key)
+{
+  xmlCharEncodingHandlerPtr handler;
+
+  handler = xmlFindCharEncodingHandler(StringValueCStr(key));
+  if (handler) {
+    return TypedData_Wrap_Struct(klass, &xml_char_encoding_handler_type, handler);
+  }
+
+  return Qnil;
+}
+
+
+/*
+ * call-seq: Nokogiri::EncodingHandler.delete(name)
+ *
+ * Delete the encoding alias named +name+
+ */
+static VALUE
+rb_xml_encoding_handler_s_delete(VALUE klass, VALUE name)
+{
+  if (xmlDelEncodingAlias(StringValueCStr(name))) { return Qnil; }
+
+  return Qtrue;
+}
+
+
+/*
+ * call-seq: Nokogiri::EncodingHandler.alias(real_name, alias_name)
+ *
+ * Alias encoding handler with name +real_name+ to name +alias_name+
+ */
+static VALUE
+rb_xml_encoding_handler_s_alias(VALUE klass, VALUE from, VALUE to)
+{
+  xmlAddEncodingAlias(StringValueCStr(from), StringValueCStr(to));
+
+  return to;
+}
+
+
+/*
+ * call-seq: Nokogiri::EncodingHandler.clear_aliases!
+ *
+ * Remove all encoding aliases.
+ */
+static VALUE
+rb_xml_encoding_handler_s_clear_aliases(VALUE klass)
+{
+  xmlCleanupEncodingAliases();
+
+  return klass;
+}
+
+
+/*
+ * call-seq: name
+ *
+ * Get the name of this EncodingHandler
+ */
+static VALUE
+rb_xml_encoding_handler_name(VALUE self)
+{
+  xmlCharEncodingHandlerPtr handler;
+
+  TypedData_Get_Struct(self, xmlCharEncodingHandler, &xml_char_encoding_handler_type, handler);
+
+  return NOKOGIRI_STR_NEW2(handler->name);
+}
+
+
+void
+noko_init_xml_encoding_handler(void)
+{
+  cNokogiriEncodingHandler = rb_define_class_under(mNokogiri, "EncodingHandler", rb_cObject);
+
+  rb_undef_alloc_func(cNokogiriEncodingHandler);
+
+  rb_define_singleton_method(cNokogiriEncodingHandler, "[]", rb_xml_encoding_handler_s_get, 1);
+  rb_define_singleton_method(cNokogiriEncodingHandler, "delete", rb_xml_encoding_handler_s_delete, 1);
+  rb_define_singleton_method(cNokogiriEncodingHandler, "alias", rb_xml_encoding_handler_s_alias, 2);
+  rb_define_singleton_method(cNokogiriEncodingHandler, "clear_aliases!", rb_xml_encoding_handler_s_clear_aliases, 0);
+
+  rb_define_method(cNokogiriEncodingHandler, "name", rb_xml_encoding_handler_name, 0);
+}

data/ext/nokogiri/xml_entity_decl.c

@@ -0,0 +1,112 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlEntityDecl;
+
+/*
+ * call-seq:
+ *  original_content
+ *
+ * Get the original_content before ref substitution
+ */
+static VALUE
+original_content(VALUE self)
+{
+  xmlEntityPtr node;
+  Noko_Node_Get_Struct(self, xmlEntity, node);
+
+  if (!node->orig) { return Qnil; }
+
+  return NOKOGIRI_STR_NEW2(node->orig);
+}
+
+/*
+ * call-seq:
+ *  content
+ *
+ * Get the content
+ */
+static VALUE
+get_content(VALUE self)
+{
+  xmlEntityPtr node;
+  Noko_Node_Get_Struct(self, xmlEntity, node);
+
+  if (!node->content) { return Qnil; }
+
+  return NOKOGIRI_STR_NEW(node->content, node->length);
+}
+
+/*
+ * call-seq:
+ *  entity_type
+ *
+ * Get the entity type
+ */
+static VALUE
+entity_type(VALUE self)
+{
+  xmlEntityPtr node;
+  Noko_Node_Get_Struct(self, xmlEntity, node);
+
+  return INT2NUM((int)node->etype);
+}
+
+/*
+ * call-seq:
+ *  external_id
+ *
+ * Get the external identifier for PUBLIC
+ */
+static VALUE
+external_id(VALUE self)
+{
+  xmlEntityPtr node;
+  Noko_Node_Get_Struct(self, xmlEntity, node);
+
+  if (!node->ExternalID) { return Qnil; }
+
+  return NOKOGIRI_STR_NEW2(node->ExternalID);
+}
+
+/*
+ * call-seq:
+ *  system_id
+ *
+ * Get the URI for a SYSTEM or PUBLIC Entity
+ */
+static VALUE
+system_id(VALUE self)
+{
+  xmlEntityPtr node;
+  Noko_Node_Get_Struct(self, xmlEntity, node);
+
+  if (!node->SystemID) { return Qnil; }
+
+  return NOKOGIRI_STR_NEW2(node->SystemID);
+}
+
+void
+noko_init_xml_entity_decl(void)
+{
+  assert(cNokogiriXmlNode);
+  cNokogiriXmlEntityDecl = rb_define_class_under(mNokogiriXml, "EntityDecl", cNokogiriXmlNode);
+
+  rb_define_method(cNokogiriXmlEntityDecl, "original_content", original_content, 0);
+  rb_define_method(cNokogiriXmlEntityDecl, "content", get_content, 0);
+  rb_define_method(cNokogiriXmlEntityDecl, "entity_type", entity_type, 0);
+  rb_define_method(cNokogiriXmlEntityDecl, "external_id", external_id, 0);
+  rb_define_method(cNokogiriXmlEntityDecl, "system_id", system_id, 0);
+
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("INTERNAL_GENERAL"),
+               INT2NUM(XML_INTERNAL_GENERAL_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("EXTERNAL_GENERAL_PARSED"),
+               INT2NUM(XML_EXTERNAL_GENERAL_PARSED_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("EXTERNAL_GENERAL_UNPARSED"),
+               INT2NUM(XML_EXTERNAL_GENERAL_UNPARSED_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("INTERNAL_PARAMETER"),
+               INT2NUM(XML_INTERNAL_PARAMETER_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("EXTERNAL_PARAMETER"),
+               INT2NUM(XML_EXTERNAL_PARAMETER_ENTITY));
+  rb_const_set(cNokogiriXmlEntityDecl, rb_intern("INTERNAL_PREDEFINED"),
+               INT2NUM(XML_INTERNAL_PREDEFINED_ENTITY));
+}

data/ext/nokogiri/xml_entity_reference.c

@@ -0,0 +1,50 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlEntityReference;
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new EntityReference element on the +document+ with +name+
+ */
+static VALUE
+new (int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr xml_doc;
+  xmlNodePtr node;
+  VALUE document;
+  VALUE name;
+  VALUE rest;
+  VALUE rb_node;
+
+  rb_scan_args(argc, argv, "2*", &document, &name, &rest);
+
+  xml_doc = noko_xml_document_unwrap(document);
+
+  node = xmlNewReference(
+           xml_doc,
+           (const xmlChar *)StringValueCStr(name)
+         );
+
+  noko_xml_document_pin_node(node);
+
+  rb_node = noko_xml_node_wrap(klass, node);
+  rb_obj_call_init(rb_node, argc, argv);
+
+  if (rb_block_given_p()) { rb_yield(rb_node); }
+
+  return rb_node;
+}
+
+void
+noko_init_xml_entity_reference(void)
+{
+  assert(cNokogiriXmlNode);
+  /*
+   * EntityReference represents an EntityReference node in an xml document.
+   */
+  cNokogiriXmlEntityReference = rb_define_class_under(mNokogiriXml, "EntityReference", cNokogiriXmlNode);
+
+  rb_define_singleton_method(cNokogiriXmlEntityReference, "new", new, -1);
+}