nokogiri 1.8.5 → 1.15.3

data/ext/nokogiri/xml_encoding_handler.c

@@ -1,79 +1,112 @@
-#include <xml_encoding_handler.h>
+#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_encoding_handler_type = {
+  .wrap_struct_name = "Nokogiri::EncodingHandler",
+  .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 get(VALUE klass, VALUE key)
+static VALUE
+rb_xml_encoding_handler_s_get(VALUE klass, VALUE key)
 {
   xmlCharEncodingHandlerPtr handler;
 
   handler = xmlFindCharEncodingHandler(StringValueCStr(key));
-  if(handler)
-    return Data_Wrap_Struct(klass, NULL, NULL, handler);
+  if (handler) {
+    return TypedData_Wrap_Struct(klass, &xml_encoding_handler_type, handler);
+  }
 
   return Qnil;
 }
 
+
 /*
  * call-seq: Nokogiri::EncodingHandler.delete(name)
  *
  * Delete the encoding alias named +name+
  */
-static VALUE delete(VALUE klass, VALUE name)
+static VALUE
+rb_xml_encoding_handler_s_delete(VALUE klass, VALUE name)
 {
-  if(xmlDelEncodingAlias(StringValueCStr(name))) return Qnil;
+  if (xmlDelEncodingAlias(StringValueCStr(name))) { return Qnil; }
 
   return Qtrue;
 }
 
+
 /*
- * call-seq: Nokogiri::EncodingHandler.alias(from, to)
+ * call-seq: Nokogiri::EncodingHandler.alias(real_name, alias_name)
  *
- * Alias encoding handler with name +from+ to name +to+
+ * Alias encoding handler with name +real_name+ to name +alias_name+
  */
-static VALUE alias(VALUE klass, VALUE from, VALUE to)
+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 clear_aliases(VALUE klass)
+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 name(VALUE self)
+static VALUE
+rb_xml_encoding_handler_name(VALUE self)
 {
   xmlCharEncodingHandlerPtr handler;
 
-  Data_Get_Struct(self, xmlCharEncodingHandler, handler);
+  TypedData_Get_Struct(self, xmlCharEncodingHandler, &xml_encoding_handler_type, handler);
 
   return NOKOGIRI_STR_NEW2(handler->name);
 }
 
-void init_xml_encoding_handler()
+
+void
+noko_init_xml_encoding_handler(void)
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE klass = rb_define_class_under(nokogiri, "EncodingHandler", rb_cObject);
-
-  rb_define_singleton_method(klass, "[]", get, 1);
-  rb_define_singleton_method(klass, "delete", delete, 1);
-  rb_define_singleton_method(klass, "alias", alias, 2);
-  rb_define_singleton_method(klass, "clear_aliases!", clear_aliases, 0);
-  rb_define_method(klass, "name", name, 0);
+  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

@@ -1,4 +1,6 @@
-#include <xml_entity_decl.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlEntityDecl;
 
 /*
  * call-seq:
@@ -6,12 +8,13 @@
  *
  * Get the original_content before ref substitution
  */
-static VALUE original_content(VALUE self)
+static VALUE
+original_content(VALUE self)
 {
   xmlEntityPtr node;
-  Data_Get_Struct(self, xmlEntity, node);
+  Noko_Node_Get_Struct(self, xmlEntity, node);
 
-  if(!node->orig) return Qnil;
+  if (!node->orig) { return Qnil; }
 
   return NOKOGIRI_STR_NEW2(node->orig);
 }
@@ -22,12 +25,13 @@ static VALUE original_content(VALUE self)
  *
  * Get the content
  */
-static VALUE get_content(VALUE self)
+static VALUE
+get_content(VALUE self)
 {
   xmlEntityPtr node;
-  Data_Get_Struct(self, xmlEntity, node);
+  Noko_Node_Get_Struct(self, xmlEntity, node);
 
-  if(!node->content) return Qnil;
+  if (!node->content) { return Qnil; }
 
   return NOKOGIRI_STR_NEW(node->content, node->length);
 }
@@ -38,10 +42,11 @@ static VALUE get_content(VALUE self)
  *
  * Get the entity type
  */
-static VALUE entity_type(VALUE self)
+static VALUE
+entity_type(VALUE self)
 {
   xmlEntityPtr node;
-  Data_Get_Struct(self, xmlEntity, node);
+  Noko_Node_Get_Struct(self, xmlEntity, node);
 
   return INT2NUM((int)node->etype);
 }
@@ -52,12 +57,13 @@ static VALUE entity_type(VALUE self)
  *
  * Get the external identifier for PUBLIC
  */
-static VALUE external_id(VALUE self)
+static VALUE
+external_id(VALUE self)
 {
   xmlEntityPtr node;
-  Data_Get_Struct(self, xmlEntity, node);
+  Noko_Node_Get_Struct(self, xmlEntity, node);
 
-  if(!node->ExternalID) return Qnil;
+  if (!node->ExternalID) { return Qnil; }
 
   return NOKOGIRI_STR_NEW2(node->ExternalID);
 }
@@ -68,43 +74,39 @@ static VALUE external_id(VALUE self)
  *
  * Get the URI for a SYSTEM or PUBLIC Entity
  */
-static VALUE system_id(VALUE self)
+static VALUE
+system_id(VALUE self)
 {
   xmlEntityPtr node;
-  Data_Get_Struct(self, xmlEntity, node);
+  Noko_Node_Get_Struct(self, xmlEntity, node);
 
-  if(!node->SystemID) return Qnil;
+  if (!node->SystemID) { return Qnil; }
 
   return NOKOGIRI_STR_NEW2(node->SystemID);
 }
 
-VALUE cNokogiriXmlEntityDecl;
-
-void init_xml_entity_decl()
+void
+noko_init_xml_entity_decl(void)
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
-  VALUE klass = rb_define_class_under(xml, "EntityDecl", node);
-
-  cNokogiriXmlEntityDecl = klass;
+  assert(cNokogiriXmlNode);
+  cNokogiriXmlEntityDecl = rb_define_class_under(mNokogiriXml, "EntityDecl", cNokogiriXmlNode);
 
-  rb_define_method(klass, "original_content", original_content, 0);
-  rb_define_method(klass, "content", get_content, 0);
-  rb_define_method(klass, "entity_type", entity_type, 0);
-  rb_define_method(klass, "external_id", external_id, 0);
-  rb_define_method(klass, "system_id", system_id, 0);
+  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));
+               INT2NUM(XML_INTERNAL_GENERAL_ENTITY));
   rb_const_set(cNokogiriXmlEntityDecl, rb_intern("EXTERNAL_GENERAL_PARSED"),
-      INT2NUM(XML_EXTERNAL_GENERAL_PARSED_ENTITY));
+               INT2NUM(XML_EXTERNAL_GENERAL_PARSED_ENTITY));
   rb_const_set(cNokogiriXmlEntityDecl, rb_intern("EXTERNAL_GENERAL_UNPARSED"),
-      INT2NUM(XML_EXTERNAL_GENERAL_UNPARSED_ENTITY));
+               INT2NUM(XML_EXTERNAL_GENERAL_UNPARSED_ENTITY));
   rb_const_set(cNokogiriXmlEntityDecl, rb_intern("INTERNAL_PARAMETER"),
-      INT2NUM(XML_INTERNAL_PARAMETER_ENTITY));
+               INT2NUM(XML_INTERNAL_PARAMETER_ENTITY));
   rb_const_set(cNokogiriXmlEntityDecl, rb_intern("EXTERNAL_PARAMETER"),
-      INT2NUM(XML_EXTERNAL_PARAMETER_ENTITY));
+               INT2NUM(XML_EXTERNAL_PARAMETER_ENTITY));
   rb_const_set(cNokogiriXmlEntityDecl, rb_intern("INTERNAL_PREDEFINED"),
-      INT2NUM(XML_INTERNAL_PREDEFINED_ENTITY));
+               INT2NUM(XML_INTERNAL_PREDEFINED_ENTITY));
 }

data/ext/nokogiri/xml_entity_reference.c

@@ -1,4 +1,6 @@
-#include <xml_entity_reference.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlEntityReference;
 
 /*
  * call-seq:
@@ -6,7 +8,8 @@
  *
  * Create a new EntityReference element on the +document+ with +name+
  */
-static VALUE new(int argc, VALUE *argv, VALUE klass)
+static VALUE
+new (int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr xml_doc;
   xmlNodePtr node;
@@ -17,36 +20,31 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &document, &name, &rest);
 
-  Data_Get_Struct(document, xmlDoc, xml_doc);
+  xml_doc = noko_xml_document_unwrap(document);
 
   node = xmlNewReference(
-      xml_doc,
-      (const xmlChar *)StringValueCStr(name)
-  );
+           xml_doc,
+           (const xmlChar *)StringValueCStr(name)
+         );
 
-  nokogiri_root_node(node);
+  noko_xml_document_pin_node(node);
 
-  rb_node = Nokogiri_wrap_xml_node(klass, 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);
+  if (rb_block_given_p()) { rb_yield(rb_node); }
 
   return rb_node;
 }
 
-VALUE cNokogiriXmlEntityReference;
-void init_xml_entity_reference()
+void
+noko_init_xml_entity_reference(void)
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
-
+  assert(cNokogiriXmlNode);
   /*
    * EntityReference represents an EntityReference node in an xml document.
    */
-  VALUE klass = rb_define_class_under(xml, "EntityReference", node);
-
-  cNokogiriXmlEntityReference = klass;
+  cNokogiriXmlEntityReference = rb_define_class_under(mNokogiriXml, "EntityReference", cNokogiriXmlNode);
 
-  rb_define_singleton_method(klass, "new", new, -1);
+  rb_define_singleton_method(cNokogiriXmlEntityReference, "new", new, -1);
 }

data/ext/nokogiri/xml_namespace.c

@@ -1,111 +1,185 @@
-#include <xml_namespace.h>
+#include <nokogiri.h>
+
+/*
+ *  The lifecycle of a Namespace node is more complicated than other Nodes, for two reasons:
+ *
+ *  1. the underlying C structure has a different layout than all the other node structs, with the
+ *     `_private` member where we store a pointer to Ruby object data not being in first position.
+ *  2. xmlNs structures returned in an xmlNodeset from an XPath query are copies of the document's
+ *     namespaces, and so do not share the same memory lifecycle as everything else in a document.
+ *
+ *  As a result of 1, you may see special handling of XML_NAMESPACE_DECL node types throughout the
+ *  Nokogiri C code, though I intend to wrap up that logic in ruby_object_{get,set} functions
+ *  shortly.
+ *
+ *  As a result of 2, you will see we have special handling in this file and in xml_node_set.c to
+ *  carefully manage the memory lifecycle of xmlNs structs to match the Ruby object's GC
+ *  lifecycle. In xml_node_set.c we have local versions of xmlXPathNodeSetDel() and
+ *  xmlXPathFreeNodeSet() that avoid freeing xmlNs structs in the node set. In this file, we decide
+ *  whether or not to call dealloc_namespace() depending on whether the xmlNs struct appears to be
+ *  in an xmlNodeSet (and thus the result of an XPath query) or not.
+ *
+ *  Yes, this is madness.
+ */
 
 VALUE cNokogiriXmlNamespace ;
 
-static void dealloc_namespace(xmlNsPtr ns)
+static void
+_xml_namespace_dealloc(void *ptr)
 {
   /*
-   *
    * this deallocator is only used for namespace nodes that are part of an xpath
-   * node set.
-   *
-   * see Nokogiri_wrap_xml_namespace() for more details.
-   *
+   * node set. see noko_xml_namespace_wrap().
    */
-  NOKOGIRI_DEBUG_START(ns) ;
+  xmlNsPtr ns = ptr;
+
   if (ns->href) {
-    xmlFree((xmlChar *)(uintptr_t)ns->href);
+    xmlFree(DISCARD_CONST_QUAL_XMLCHAR(ns->href));
   }
   if (ns->prefix) {
-    xmlFree((xmlChar *)(uintptr_t)ns->prefix);
+    xmlFree(DISCARD_CONST_QUAL_XMLCHAR(ns->prefix));
   }
   xmlFree(ns);
-  NOKOGIRI_DEBUG_END(ns) ;
 }
 
+#ifdef HAVE_RB_GC_LOCATION
+static void
+_xml_namespace_update_references(void *ptr)
+{
+  xmlNsPtr ns = ptr;
+  if (ns->_private) {
+    ns->_private = (void *)rb_gc_location((VALUE)ns->_private);
+  }
+}
+#else
+#  define _xml_namespace_update_references 0
+#endif
+
+static const rb_data_type_t nokogiri_xml_namespace_type_with_dealloc = {
+  .wrap_struct_name = "Nokogiri::XML::Namespace#with_dealloc",
+  .function = {
+    .dfree = _xml_namespace_dealloc,
+    .dcompact = _xml_namespace_update_references,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static const rb_data_type_t nokogiri_xml_namespace_type_without_dealloc = {
+  .wrap_struct_name = "Nokogiri::XML::Namespace#without_dealloc",
+  .function = {
+    .dcompact = _xml_namespace_update_references,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
 
 /*
- * call-seq:
- *  prefix
+ *  :call-seq:
+ *    prefix() → String or nil
+ *
+ *  Return the prefix for this Namespace, or +nil+ if there is no prefix (e.g., default namespace).
+ *
+ *  *Example*
+ *
+ *    doc = Nokogiri::XML.parse(<<~XML)
+ *      <?xml version="1.0"?>
+ *      <root xmlns="http://nokogiri.org/ns/default" xmlns:noko="http://nokogiri.org/ns/noko">
+ *        <child1 foo="abc" noko:bar="def"/>
+ *        <noko:child2 foo="qwe" noko:bar="rty"/>
+ *      </root>
+ *    XML
+ *
+ *    doc.root.elements.first.namespace.prefix
+ *    # => nil
  *
- * Get the prefix for this namespace.  Returns +nil+ if there is no prefix.
+ *    doc.root.elements.last.namespace.prefix
+ *    # => "noko"
  */
-static VALUE prefix(VALUE self)
+static VALUE
+prefix(VALUE self)
 {
   xmlNsPtr ns;
 
-  Data_Get_Struct(self, xmlNs, ns);
-  if(!ns->prefix) return Qnil;
+  Noko_Namespace_Get_Struct(self, xmlNs, ns);
+  if (!ns->prefix) { return Qnil; }
 
   return NOKOGIRI_STR_NEW2(ns->prefix);
 }
 
 /*
- * call-seq:
- *  href
+ *  :call-seq:
+ *    href() → String
  *
- * Get the href for this namespace
+ *  Returns the URI reference for this Namespace.
+ *
+ *  *Example*
+ *
+ *    doc = Nokogiri::XML.parse(<<~XML)
+ *      <?xml version="1.0"?>
+ *      <root xmlns="http://nokogiri.org/ns/default" xmlns:noko="http://nokogiri.org/ns/noko">
+ *        <child1 foo="abc" noko:bar="def"/>
+ *        <noko:child2 foo="qwe" noko:bar="rty"/>
+ *      </root>
+ *    XML
+ *
+ *    doc.root.elements.first.namespace.href
+ *    # => "http://nokogiri.org/ns/default"
+ *
+ *    doc.root.elements.last.namespace.href
+ *    # => "http://nokogiri.org/ns/noko"
  */
-static VALUE href(VALUE self)
+static VALUE
+href(VALUE self)
 {
   xmlNsPtr ns;
 
-  Data_Get_Struct(self, xmlNs, ns);
-  if(!ns->href) return Qnil;
+  Noko_Namespace_Get_Struct(self, xmlNs, ns);
+  if (!ns->href) { return Qnil; }
 
   return NOKOGIRI_STR_NEW2(ns->href);
 }
 
-static int part_of_an_xpath_node_set_eh(xmlNsPtr node)
+VALUE
+noko_xml_namespace_wrap(xmlNsPtr c_namespace, xmlDocPtr c_document)
 {
-  return (node->next && ! NOKOGIRI_NAMESPACE_EH(node->next));
-}
-
-VALUE Nokogiri_wrap_xml_namespace(xmlDocPtr doc, xmlNsPtr node)
-{
-  VALUE ns, document, node_cache;
-
-  assert(doc->type == XML_DOCUMENT_NODE || doc->type == XML_HTML_DOCUMENT_NODE);
+  VALUE rb_namespace;
 
-  if (node->_private) return (VALUE)node->_private;
-
-  if (doc->type == XML_DOCUMENT_FRAG_NODE) doc = doc->doc;
-
-  ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, 0, node);
+  if (c_namespace->_private) {
+    return (VALUE)c_namespace->_private;
+  }
 
-  if (DOC_RUBY_OBJECT_TEST(doc)) {
-    document = DOC_RUBY_OBJECT(doc);
+  if (c_document) {
+    rb_namespace = TypedData_Wrap_Struct(cNokogiriXmlNamespace,
+                                         &nokogiri_xml_namespace_type_without_dealloc,
+                                         c_namespace);
 
-    if (part_of_an_xpath_node_set_eh(node)) {
-      /*
-       *  this is a duplicate returned as part of an xpath query node set, and so
-       *  we need to make sure we manage this memory.
-       *
-       *  see comments in xml_node_set.c for more details.
-       */
-      ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, dealloc_namespace, node);
-    } else {
-      ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, 0, node);
-      node_cache = rb_iv_get(document, "@node_cache");
-      rb_ary_push(node_cache, ns);
+    if (DOC_RUBY_OBJECT_TEST(c_document)) {
+      rb_iv_set(rb_namespace, "@document", DOC_RUBY_OBJECT(c_document));
+      rb_ary_push(DOC_NODE_CACHE(c_document), rb_namespace);
     }
-
-    rb_iv_set(ns, "@document", document);
+  } else {
+    rb_namespace = TypedData_Wrap_Struct(cNokogiriXmlNamespace,
+                                         &nokogiri_xml_namespace_type_with_dealloc,
+                                         c_namespace);
   }
 
-  node->_private = (void *)ns;
+  c_namespace->_private = (void *)rb_namespace;
 
-  return ns;
+  return rb_namespace;
+}
+
+VALUE
+noko_xml_namespace_wrap_xpath_copy(xmlNsPtr c_namespace)
+{
+  return noko_xml_namespace_wrap(c_namespace, NULL);
 }
 
-void init_xml_namespace()
+void
+noko_init_xml_namespace(void)
 {
-  VALUE nokogiri  = rb_define_module("Nokogiri");
-  VALUE xml       = rb_define_module_under(nokogiri, "XML");
-  VALUE klass     = rb_define_class_under(xml, "Namespace", rb_cObject);
+  cNokogiriXmlNamespace = rb_define_class_under(mNokogiriXml, "Namespace", rb_cObject);
 
-  cNokogiriXmlNamespace = klass;
+  rb_undef_alloc_func(cNokogiriXmlNamespace);
 
-  rb_define_method(klass, "prefix", prefix, 0);
-  rb_define_method(klass, "href", href, 0);
+  rb_define_method(cNokogiriXmlNamespace, "prefix", prefix, 0);
+  rb_define_method(cNokogiriXmlNamespace, "href", href, 0);
 }