nokogiri 1.10.10 → 1.13.9

data/ext/nokogiri/nokogiri.h

@@ -1,26 +1,40 @@
 #ifndef NOKOGIRI_NATIVE
 #define NOKOGIRI_NATIVE
 
+#ifdef _MSC_VER
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif /* WIN32_LEAN_AND_MEAN */
+
+#  ifndef WIN32
+#    define WIN32
+#  endif /* WIN32 */
+
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#  include <windows.h>
+#endif
+
+#ifdef _WIN32
+#  define NOKOPUBFUN __declspec(dllexport)
+#  define NOKOPUBVAR __declspec(dllexport) extern
+#else
+#  define NOKOPUBFUN
+#  define NOKOPUBVAR extern
+#endif
+
+
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <stdarg.h>
+#include <stdio.h>
 
-#ifdef USE_INCLUDED_VASPRINTF
-int vasprintf (char **strp, const char *fmt, va_list ap);
-#else
-
-#define _GNU_SOURCE
-#  include <stdio.h>
-#undef _GNU_SOURCE
-
-#endif
 
 #include <libxml/parser.h>
+#include <libxml/tree.h>
 #include <libxml/entities.h>
-#include <libxml/parserInternals.h>
 #include <libxml/xpath.h>
-#include <libxml/xpathInternals.h>
 #include <libxml/xmlreader.h>
 #include <libxml/xmlsave.h>
 #include <libxml/xmlschemas.h>
@@ -28,94 +42,191 @@ int vasprintf (char **strp, const char *fmt, va_list ap);
 #include <libxml/HTMLtree.h>
 #include <libxml/relaxng.h>
 #include <libxml/xinclude.h>
-#include <libxslt/extensions.h>
 #include <libxml/c14n.h>
-#include <ruby.h>
-#include <ruby/st.h>
-#include <ruby/encoding.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xpathInternals.h>
 
-#ifndef NORETURN
-# if defined(__GNUC__)
-#  define NORETURN(name) __attribute__((noreturn)) name
-# else
-#  define NORETURN(name) name
-# endif
+#include <libxslt/extensions.h>
+#include <libxslt/xsltconfig.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/transform.h>
+#include <libxslt/xsltInternals.h>
+
+#include <libexslt/exslt.h>
+
+/* libxml2_backwards_compat.c */
+#ifndef HAVE_XMLFIRSTELEMENTCHILD
+xmlNodePtr xmlFirstElementChild(xmlNodePtr parent);
+xmlNodePtr xmlNextElementSibling(xmlNodePtr node);
+xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
 #endif
 
-#define NOKOGIRI_STR_NEW2(str) \
-  NOKOGIRI_STR_NEW(str, strlen((const char *)(str)))
-
-#define NOKOGIRI_STR_NEW(str, len) \
-  rb_external_str_new_with_enc((const char *)(str), (long)(len), rb_utf8_encoding())
-
-#define RBSTR_OR_QNIL(_str) \
-  (_str ? NOKOGIRI_STR_NEW2(_str) : Qnil)
-
-#include <xml_libxml2_hacks.h>
-
-#include <xml_io.h>
-#include <xml_document.h>
-#include <html_entity_lookup.h>
-#include <html_document.h>
-#include <xml_node.h>
-#include <xml_text.h>
-#include <xml_cdata.h>
-#include <xml_attr.h>
-#include <xml_processing_instruction.h>
-#include <xml_entity_reference.h>
-#include <xml_document_fragment.h>
-#include <xml_comment.h>
-#include <xml_node_set.h>
-#include <xml_dtd.h>
-#include <xml_attribute_decl.h>
-#include <xml_element_decl.h>
-#include <xml_entity_decl.h>
-#include <xml_xpath_context.h>
-#include <xml_element_content.h>
-#include <xml_sax_parser_context.h>
-#include <xml_sax_parser.h>
-#include <xml_sax_push_parser.h>
-#include <xml_reader.h>
-#include <html_sax_parser_context.h>
-#include <html_sax_push_parser.h>
-#include <xslt_stylesheet.h>
-#include <xml_syntax_error.h>
-#include <xml_schema.h>
-#include <xml_relax_ng.h>
-#include <html_element_description.h>
-#include <xml_namespace.h>
-#include <xml_encoding_handler.h>
-
-extern VALUE mNokogiri ;
-extern VALUE mNokogiriXml ;
-extern VALUE mNokogiriXmlSax ;
-extern VALUE mNokogiriHtml ;
-extern VALUE mNokogiriHtmlSax ;
-extern VALUE mNokogiriXslt ;
-
-void nokogiri_root_node(xmlNodePtr);
-void nokogiri_root_nsdef(xmlNsPtr, xmlDocPtr);
-
-#ifdef DEBUG
+#define XMLNS_PREFIX "xmlns"
+#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
 
-#define NOKOGIRI_DEBUG_START(p) if (getenv("NOKOGIRI_NO_FREE")) return ; if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p start\n", __FILE__, __LINE__, p);
-#define NOKOGIRI_DEBUG_END(p) if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p end\n", __FILE__, __LINE__, p);
 
-#else
+#include <ruby.h>
+#include <ruby/st.h>
+#include <ruby/encoding.h>
+#include <ruby/util.h>
+#include <ruby/version.h>
 
-#define NOKOGIRI_DEBUG_START(p)
-#define NOKOGIRI_DEBUG_END(p)
+#define NOKOGIRI_STR_NEW2(str) NOKOGIRI_STR_NEW(str, strlen((const char *)(str)))
+#define NOKOGIRI_STR_NEW(str, len) rb_external_str_new_with_enc((const char *)(str), (long)(len), rb_utf8_encoding())
+#define RBSTR_OR_QNIL(_str) (_str ? NOKOGIRI_STR_NEW2(_str) : Qnil)
 
+#ifdef DEBUG
+#  define NOKOGIRI_DEBUG_START(p) if (getenv("NOKOGIRI_NO_FREE")) return ; if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p start\n", __FILE__, __LINE__, p);
+#  define NOKOGIRI_DEBUG_END(p) if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p end\n", __FILE__, __LINE__, p);
+#else
+#  define NOKOGIRI_DEBUG_START(p)
+#  define NOKOGIRI_DEBUG_END(p)
 #endif
 
-#ifndef __builtin_expect
-# if defined(__GNUC__)
-#  define __builtin_expect(expr, c) __builtin_expect((long)(expr), (long)(c))
-# endif
+#ifndef NORETURN
+#  if defined(__GNUC__)
+#    define NORETURN(name) __attribute__((noreturn)) name
+#  else
+#    define NORETURN(name) name
+#  endif
 #endif
 
-#define XMLNS_PREFIX "xmlns"
-#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
-#define XMLNS_BUFFER_LEN 128
 
+NOKOPUBVAR VALUE mNokogiri ;
+NOKOPUBVAR VALUE mNokogiriGumbo ;
+NOKOPUBVAR VALUE mNokogiriHtml4 ;
+NOKOPUBVAR VALUE mNokogiriHtml4Sax ;
+NOKOPUBVAR VALUE mNokogiriHtml5 ;
+NOKOPUBVAR VALUE mNokogiriXml ;
+NOKOPUBVAR VALUE mNokogiriXmlSax ;
+NOKOPUBVAR VALUE mNokogiriXmlXpath ;
+NOKOPUBVAR VALUE mNokogiriXslt ;
+
+NOKOPUBVAR VALUE cNokogiriEncodingHandler;
+NOKOPUBVAR VALUE cNokogiriSyntaxError;
+NOKOPUBVAR VALUE cNokogiriXmlAttr;
+NOKOPUBVAR VALUE cNokogiriXmlAttributeDecl;
+NOKOPUBVAR VALUE cNokogiriXmlCData;
+NOKOPUBVAR VALUE cNokogiriXmlCharacterData;
+NOKOPUBVAR VALUE cNokogiriXmlComment;
+NOKOPUBVAR VALUE cNokogiriXmlDocument ;
+NOKOPUBVAR VALUE cNokogiriXmlDocumentFragment;
+NOKOPUBVAR VALUE cNokogiriXmlDtd;
+NOKOPUBVAR VALUE cNokogiriXmlElement ;
+NOKOPUBVAR VALUE cNokogiriXmlElementContent;
+NOKOPUBVAR VALUE cNokogiriXmlElementDecl;
+NOKOPUBVAR VALUE cNokogiriXmlEntityDecl;
+NOKOPUBVAR VALUE cNokogiriXmlEntityReference;
+NOKOPUBVAR VALUE cNokogiriXmlNamespace ;
+NOKOPUBVAR VALUE cNokogiriXmlNode ;
+NOKOPUBVAR VALUE cNokogiriXmlNodeSet ;
+NOKOPUBVAR VALUE cNokogiriXmlProcessingInstruction;
+NOKOPUBVAR VALUE cNokogiriXmlReader;
+NOKOPUBVAR VALUE cNokogiriXmlRelaxNG;
+NOKOPUBVAR VALUE cNokogiriXmlSaxParser ;
+NOKOPUBVAR VALUE cNokogiriXmlSaxParserContext;
+NOKOPUBVAR VALUE cNokogiriXmlSaxPushParser ;
+NOKOPUBVAR VALUE cNokogiriXmlSchema;
+NOKOPUBVAR VALUE cNokogiriXmlSyntaxError;
+NOKOPUBVAR VALUE cNokogiriXmlText ;
+NOKOPUBVAR VALUE cNokogiriXmlXpathContext;
+NOKOPUBVAR VALUE cNokogiriXmlXpathSyntaxError;
+NOKOPUBVAR VALUE cNokogiriXsltStylesheet ;
+
+NOKOPUBVAR VALUE cNokogiriHtml4Document ;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxPushParser ;
+NOKOPUBVAR VALUE cNokogiriHtml4ElementDescription ;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxParserContext;
+NOKOPUBVAR VALUE cNokogiriHtml5Document ;
+
+typedef struct _nokogiriTuple {
+  VALUE         doc;
+  st_table     *unlinkedNodes;
+  VALUE         node_cache;
+} nokogiriTuple;
+typedef nokogiriTuple *nokogiriTuplePtr;
+
+typedef struct _nokogiriSAXTuple {
+  xmlParserCtxtPtr  ctxt;
+  VALUE             self;
+} nokogiriSAXTuple;
+typedef nokogiriSAXTuple *nokogiriSAXTuplePtr;
+
+typedef struct _libxmlStructuredErrorHandlerState {
+  void *user_data;
+  xmlStructuredErrorFunc handler;
+} libxmlStructuredErrorHandlerState ;
+
+typedef struct _nokogiriXsltStylesheetTuple {
+  xsltStylesheetPtr ss;
+  VALUE func_instances;
+} nokogiriXsltStylesheetTuple;
+
+int vasprintf(char **strp, const char *fmt, va_list ap);
+void noko_xml_document_pin_node(xmlNodePtr);
+void noko_xml_document_pin_namespace(xmlNsPtr, xmlDocPtr);
+
+int noko_io_read(void *ctx, char *buffer, int len);
+int noko_io_write(void *ctx, char *buffer, int len);
+int noko_io_close(void *ctx);
+
+#define Noko_Node_Get_Struct(obj,type,sval) ((sval) = (type*)DATA_PTR(obj))
+#define Noko_Namespace_Get_Struct(obj,type,sval) ((sval) = (type*)DATA_PTR(obj))
+
+VALUE noko_xml_node_wrap(VALUE klass, xmlNodePtr node) ;
+VALUE noko_xml_node_wrap_node_set_result(xmlNodePtr node, VALUE node_set) ;
+VALUE noko_xml_node_attrs(xmlNodePtr node) ;
+
+VALUE noko_xml_namespace_wrap(xmlNsPtr node, xmlDocPtr doc);
+VALUE noko_xml_namespace_wrap_xpath_copy(xmlNsPtr node);
+
+VALUE noko_xml_element_content_wrap(VALUE doc, xmlElementContentPtr element);
+
+VALUE noko_xml_node_set_wrap(xmlNodeSetPtr node_set, VALUE document) ;
+
+VALUE noko_xml_document_wrap_with_init_args(VALUE klass, xmlDocPtr doc, int argc, VALUE *argv);
+VALUE noko_xml_document_wrap(VALUE klass, xmlDocPtr doc);
+NOKOPUBFUN VALUE Nokogiri_wrap_xml_document(VALUE klass,
+    xmlDocPtr doc); /* deprecated. use noko_xml_document_wrap() instead. */
+
+#define DOC_RUBY_OBJECT_TEST(x) ((nokogiriTuplePtr)(x->_private))
+#define DOC_RUBY_OBJECT(x) (((nokogiriTuplePtr)(x->_private))->doc)
+#define DOC_UNLINKED_NODE_HASH(x) (((nokogiriTuplePtr)(x->_private))->unlinkedNodes)
+#define DOC_NODE_CACHE(x) (((nokogiriTuplePtr)(x->_private))->node_cache)
+#define NOKOGIRI_NAMESPACE_EH(node) ((node)->type == XML_NAMESPACE_DECL)
+
+#define NOKOGIRI_SAX_SELF(_ctxt) ((nokogiriSAXTuplePtr)(_ctxt))->self
+#define NOKOGIRI_SAX_CTXT(_ctxt) ((nokogiriSAXTuplePtr)(_ctxt))->ctxt
+#define NOKOGIRI_SAX_TUPLE_NEW(_ctxt, _self) nokogiri_sax_tuple_new(_ctxt, _self)
+#define NOKOGIRI_SAX_TUPLE_DESTROY(_tuple) free(_tuple)
+
+#define DISCARD_CONST_QUAL(t, v) ((t)(uintptr_t)(v))
+#define DISCARD_CONST_QUAL_XMLCHAR(v) DISCARD_CONST_QUAL(xmlChar *, v)
+
+#if HAVE_RB_CATEGORY_WARNING
+#  define NOKO_WARN_DEPRECATION(message) rb_category_warning(RB_WARN_CATEGORY_DEPRECATED, message)
+#else
+#  define NOKO_WARN_DEPRECATION(message) rb_warning(message)
 #endif
+
+void Nokogiri_structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state);
+void Nokogiri_structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state, void *user_data,
+    xmlStructuredErrorFunc handler);
+void Nokogiri_structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state);
+VALUE Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error);
+void Nokogiri_error_array_pusher(void *ctx, xmlErrorPtr error);
+NORETURN(void Nokogiri_error_raise(void *ctx, xmlErrorPtr error));
+void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler,
+    const char *function_name) ;
+
+static inline
+nokogiriSAXTuplePtr
+nokogiri_sax_tuple_new(xmlParserCtxtPtr ctxt, VALUE self)
+{
+  nokogiriSAXTuplePtr tuple = malloc(sizeof(nokogiriSAXTuple));
+  tuple->self = self;
+  tuple->ctxt = ctxt;
+  return tuple;
+}
+
+#endif /* NOKOGIRI_NATIVE */

data/ext/nokogiri/test_global_handlers.c

@@ -0,0 +1,40 @@
+#include <nokogiri.h>
+
+static VALUE foreign_error_handler_block = Qnil;
+
+static void
+foreign_error_handler(void *user_data, xmlErrorPtr c_error)
+{
+  rb_funcall(foreign_error_handler_block, rb_intern("call"), 0);
+}
+
+/*
+ * call-seq:
+ *   __foreign_error_handler { ... } -> nil
+ *
+ * Override libxml2's global error handlers to call the block. This method thus has very little
+ * value except to test that Nokogiri is properly setting error handlers elsewhere in the code. See
+ * test/helper.rb for how this is being used.
+ */
+static VALUE
+rb_foreign_error_handler(VALUE klass)
+{
+  rb_need_block();
+  foreign_error_handler_block = rb_block_proc();
+  xmlSetStructuredErrorFunc(NULL, foreign_error_handler);
+  return Qnil;
+}
+
+/*
+ *  Document-module: Nokogiri::Test
+ *
+ *  The Nokogiri::Test module should only be used for testing Nokogiri.
+ *  Do NOT use this outside of the Nokogiri test suite.
+ */
+void
+noko_init_test_global_handlers()
+{
+  VALUE mNokogiriTest = rb_define_module_under(mNokogiri, "Test");
+
+  rb_define_singleton_method(mNokogiriTest, "__foreign_error_handler", rb_foreign_error_handler, 0);
+}

data/ext/nokogiri/xml_attr.c

@@ -1,4 +1,6 @@
-#include <xml_attr.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlAttr;
 
 /*
  * call-seq:
@@ -7,13 +9,14 @@
  * Set the value for this Attr to +content+. Use `nil` to remove the value
  * (e.g., a HTML boolean attribute).
  */
-static VALUE set_value(VALUE self, VALUE content)
+static VALUE
+set_value(VALUE self, VALUE content)
 {
   xmlAttrPtr attr;
   xmlChar *value;
   xmlNode *cur;
 
-  Data_Get_Struct(self, xmlAttr, attr);
+  Noko_Node_Get_Struct(self, xmlAttr, attr);
 
   if (attr->children) {
     xmlFreeNodeList(attr->children);
@@ -49,7 +52,8 @@ static VALUE set_value(VALUE self, VALUE content)
  *
  * Create a new Attr 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;
   VALUE document;
@@ -64,7 +68,7 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
     rb_raise(rb_eArgError, "parameter must be a Nokogiri::XML::Document");
   }
 
-  Data_Get_Struct(document, xmlDoc, xml_doc);
+  Noko_Node_Get_Struct(document, xmlDoc, xml_doc);
 
   node = xmlNewDocProp(
            xml_doc,
@@ -72,9 +76,9 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
            NULL
          );
 
-  nokogiri_root_node((xmlNodePtr)node);
+  noko_xml_document_pin_node((xmlNodePtr)node);
 
-  rb_node = Nokogiri_wrap_xml_node(klass, (xmlNodePtr)node);
+  rb_node = noko_xml_node_wrap(klass, (xmlNodePtr)node);
   rb_obj_call_init(rb_node, argc, argv);
 
   if (rb_block_given_p()) {
@@ -84,20 +88,16 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
   return rb_node;
 }
 
-VALUE cNokogiriXmlAttr;
-void init_xml_attr()
+void
+noko_init_xml_attr()
 {
-  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);
   /*
    * Attr represents a Attr node in an xml document.
    */
-  VALUE klass = rb_define_class_under(xml, "Attr", node);
+  cNokogiriXmlAttr = rb_define_class_under(mNokogiriXml, "Attr", cNokogiriXmlNode);
 
-  cNokogiriXmlAttr = klass;
+  rb_define_singleton_method(cNokogiriXmlAttr, "new", new, -1);
 
-  rb_define_singleton_method(klass, "new", new, -1);
-  rb_define_method(klass, "value=", set_value, 1);
+  rb_define_method(cNokogiriXmlAttr, "value=", set_value, 1);
 }

data/ext/nokogiri/xml_attribute_decl.c

@@ -1,4 +1,6 @@
-#include <xml_attribute_decl.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlAttributeDecl;
 
 /*
  * call-seq:
@@ -6,10 +8,11 @@
  *
  * The attribute_type for this AttributeDecl
  */
-static VALUE attribute_type(VALUE self)
+static VALUE
+attribute_type(VALUE self)
 {
   xmlAttributePtr node;
-  Data_Get_Struct(self, xmlAttribute, node);
+  Noko_Node_Get_Struct(self, xmlAttribute, node);
   return INT2NUM((long)node->atype);
 }
 
@@ -19,12 +22,13 @@ static VALUE attribute_type(VALUE self)
  *
  * The default value
  */
-static VALUE default_value(VALUE self)
+static VALUE
+default_value(VALUE self)
 {
   xmlAttributePtr node;
-  Data_Get_Struct(self, xmlAttribute, node);
+  Noko_Node_Get_Struct(self, xmlAttribute, node);
 
-  if(node->defaultValue) return NOKOGIRI_STR_NEW2(node->defaultValue);
+  if (node->defaultValue) { return NOKOGIRI_STR_NEW2(node->defaultValue); }
   return Qnil;
 }
 
@@ -34,18 +38,19 @@ static VALUE default_value(VALUE self)
  *
  * An enumeration of possible values
  */
-static VALUE enumeration(VALUE self)
+static VALUE
+enumeration(VALUE self)
 {
   xmlAttributePtr node;
   xmlEnumerationPtr enm;
   VALUE list;
 
-  Data_Get_Struct(self, xmlAttribute, node);
+  Noko_Node_Get_Struct(self, xmlAttribute, node);
 
   list = rb_ary_new();
   enm = node->tree;
 
-  while(enm) {
+  while (enm) {
     rb_ary_push(list, NOKOGIRI_STR_NEW2(enm->name));
     enm = enm->next;
   }
@@ -53,18 +58,13 @@ static VALUE enumeration(VALUE self)
   return list;
 }
 
-VALUE cNokogiriXmlAttributeDecl;
-
-void init_xml_attribute_decl()
+void
+noko_init_xml_attribute_decl()
 {
-  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, "AttributeDecl", node);
-
-  cNokogiriXmlAttributeDecl = klass;
+  assert(cNokogiriXmlNode);
+  cNokogiriXmlAttributeDecl = rb_define_class_under(mNokogiriXml, "AttributeDecl", cNokogiriXmlNode);
 
-  rb_define_method(klass, "attribute_type", attribute_type, 0);
-  rb_define_method(klass, "default", default_value, 0);
-  rb_define_method(klass, "enumeration", enumeration, 0);
+  rb_define_method(cNokogiriXmlAttributeDecl, "attribute_type", attribute_type, 0);
+  rb_define_method(cNokogiriXmlAttributeDecl, "default", default_value, 0);
+  rb_define_method(cNokogiriXmlAttributeDecl, "enumeration", enumeration, 0);
 }

data/ext/nokogiri/xml_cdata.c

@@ -1,4 +1,6 @@
-#include <xml_cdata.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlCData;
 
 /*
  * call-seq:
@@ -9,7 +11,8 @@
  * If +content+ cannot be implicitly converted to a string, this method will
  * raise a TypeError exception.
  */
-static VALUE new(int argc, VALUE *argv, VALUE klass)
+static VALUE
+new (int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr xml_doc;
   xmlNodePtr node;
@@ -22,7 +25,7 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &doc, &content, &rest);
 
-  Data_Get_Struct(doc, xmlDoc, xml_doc);
+  Noko_Node_Get_Struct(doc, xmlDoc, xml_doc);
 
   if (!NIL_P(content)) {
     content_str = (xmlChar *)StringValuePtr(content);
@@ -31,32 +34,24 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
 
   node = xmlNewCDataBlock(xml_doc->doc, content_str, content_str_len);
 
-  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 cNokogiriXmlCData;
-void init_xml_cdata()
+void
+noko_init_xml_cdata()
 {
-  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 char_data = rb_define_class_under(xml, "CharacterData", node);
-  VALUE text = rb_define_class_under(xml, "Text", char_data);
-
+  assert(cNokogiriXmlText);
   /*
    * CData represents a CData node in an xml document.
    */
-  VALUE klass = rb_define_class_under(xml, "CDATA", text);
-
-
-  cNokogiriXmlCData = klass;
+  cNokogiriXmlCData = rb_define_class_under(mNokogiriXml, "CDATA", cNokogiriXmlText);
 
-  rb_define_singleton_method(klass, "new", new, -1);
+  rb_define_singleton_method(cNokogiriXmlCData, "new", new, -1);
 }

data/ext/nokogiri/xml_comment.c

@@ -1,4 +1,6 @@
-#include <xml_comment.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlComment;
 
 static ID document_id ;
 
@@ -9,7 +11,8 @@ static ID document_id ;
  * Create a new Comment element on the +document+ with +content+.
  * Alternatively, if a +node+ is passed, the +node+'s document is used.
  */
-static VALUE new(int argc, VALUE *argv, VALUE klass)
+static VALUE
+new (int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr xml_doc;
   xmlNodePtr node;
@@ -20,50 +23,40 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &document, &content, &rest);
 
-  if (rb_obj_is_kind_of(document, cNokogiriXmlNode))
-  {
+  if (rb_obj_is_kind_of(document, cNokogiriXmlNode)) {
     document = rb_funcall(document, document_id, 0);
-  }
-  else if (   !rb_obj_is_kind_of(document, cNokogiriXmlDocument)
-           && !rb_obj_is_kind_of(document, cNokogiriXmlDocumentFragment))
-  {
+  } else if (!rb_obj_is_kind_of(document, cNokogiriXmlDocument)
+             && !rb_obj_is_kind_of(document, cNokogiriXmlDocumentFragment)) {
     rb_raise(rb_eArgError, "first argument must be a XML::Document or XML::Node");
   }
 
   Data_Get_Struct(document, xmlDoc, xml_doc);
 
   node = xmlNewDocComment(
-      xml_doc,
-      (const xmlChar *)StringValueCStr(content)
-  );
+           xml_doc,
+           (const xmlChar *)StringValueCStr(content)
+         );
 
-  rb_node = Nokogiri_wrap_xml_node(klass, node);
+  rb_node = noko_xml_node_wrap(klass, node);
   rb_obj_call_init(rb_node, argc, argv);
 
-  nokogiri_root_node(node);
+  noko_xml_document_pin_node(node);
 
-  if(rb_block_given_p()) rb_yield(rb_node);
+  if (rb_block_given_p()) { rb_yield(rb_node); }
 
   return rb_node;
 }
 
-VALUE cNokogiriXmlComment;
-void init_xml_comment()
+void
+noko_init_xml_comment()
 {
-  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 char_data = rb_define_class_under(xml, "CharacterData", node);
-
+  assert(cNokogiriXmlCharacterData);
   /*
    * Comment represents a comment node in an xml document.
    */
-  VALUE klass = rb_define_class_under(xml, "Comment", char_data);
-
-
-  cNokogiriXmlComment = klass;
+  cNokogiriXmlComment = rb_define_class_under(mNokogiriXml, "Comment", cNokogiriXmlCharacterData);
 
-  rb_define_singleton_method(klass, "new", new, -1);
+  rb_define_singleton_method(cNokogiriXmlComment, "new", new, -1);
 
   document_id = rb_intern("document");
 }