nokogiri 1.11.2 → 1.12.5

data/ext/nokogiri/{html_entity_lookup.c → html4_entity_lookup.c}

@@ -1,17 +1,17 @@
 #include <nokogiri.h>
 
-static VALUE cNokogiriHtmlEntityLookup;
+static VALUE cNokogiriHtml4EntityLookup;
 
 /*
  * call-seq:
  *  get(key)
  *
- * Get the HTML::EntityDescription for +key+
+ * Get the HTML4::EntityDescription for +key+
  */
 static VALUE
 get(VALUE _, VALUE rb_entity_name)
 {
-  VALUE cNokogiriHtmlEntityDescription;
+  VALUE cNokogiriHtml4EntityDescription;
   const htmlEntityDesc *c_entity_desc;
   VALUE rb_constructor_args[3];
 
@@ -24,14 +24,14 @@ get(VALUE _, VALUE rb_entity_name)
   rb_constructor_args[1] = NOKOGIRI_STR_NEW2(c_entity_desc->name);
   rb_constructor_args[2] = NOKOGIRI_STR_NEW2(c_entity_desc->desc);
 
-  cNokogiriHtmlEntityDescription = rb_const_get_at(mNokogiriHtml, rb_intern("EntityDescription"));
-  return rb_class_new_instance(3, rb_constructor_args, cNokogiriHtmlEntityDescription);
+  cNokogiriHtml4EntityDescription = rb_const_get_at(mNokogiriHtml4, rb_intern("EntityDescription"));
+  return rb_class_new_instance(3, rb_constructor_args, cNokogiriHtml4EntityDescription);
 }
 
 void
 noko_init_html_entity_lookup()
 {
-  cNokogiriHtmlEntityLookup = rb_define_class_under(mNokogiriHtml, "EntityLookup", rb_cObject);
+  cNokogiriHtml4EntityLookup = rb_define_class_under(mNokogiriHtml4, "EntityLookup", rb_cObject);
 
-  rb_define_method(cNokogiriHtmlEntityLookup, "get", get, 1);
+  rb_define_method(cNokogiriHtml4EntityLookup, "get", get, 1);
 }

data/ext/nokogiri/{html_sax_parser_context.c → html4_sax_parser_context.c}

@@ -1,6 +1,6 @@
 #include <nokogiri.h>
 
-VALUE cNokogiriHtmlSaxParserContext ;
+VALUE cNokogiriHtml4SaxParserContext ;
 
 static void
 deallocate(xmlParserCtxtPtr ctxt)
@@ -110,10 +110,11 @@ void
 noko_init_html_sax_parser_context()
 {
   assert(cNokogiriXmlSaxParserContext);
-  cNokogiriHtmlSaxParserContext = rb_define_class_under(mNokogiriHtmlSax, "ParserContext", cNokogiriXmlSaxParserContext);
+  cNokogiriHtml4SaxParserContext = rb_define_class_under(mNokogiriHtml4Sax, "ParserContext",
+                                   cNokogiriXmlSaxParserContext);
 
-  rb_define_singleton_method(cNokogiriHtmlSaxParserContext, "memory", parse_memory, 2);
-  rb_define_singleton_method(cNokogiriHtmlSaxParserContext, "file", parse_file, 2);
+  rb_define_singleton_method(cNokogiriHtml4SaxParserContext, "memory", parse_memory, 2);
+  rb_define_singleton_method(cNokogiriHtml4SaxParserContext, "file", parse_file, 2);
 
-  rb_define_method(cNokogiriHtmlSaxParserContext, "parse_with", parse_with, 1);
+  rb_define_method(cNokogiriHtml4SaxParserContext, "parse_with", parse_with, 1);
 }

data/ext/nokogiri/{html_sax_push_parser.c → html4_sax_push_parser.c}

@@ -1,6 +1,6 @@
 #include <nokogiri.h>
 
-VALUE cNokogiriHtmlSaxPushParser;
+VALUE cNokogiriHtml4SaxPushParser;
 
 /*
  * call-seq:
@@ -88,8 +88,8 @@ void
 noko_init_html_sax_push_parser()
 {
   assert(cNokogiriXmlSaxPushParser);
-  cNokogiriHtmlSaxPushParser = rb_define_class_under(mNokogiriHtmlSax, "PushParser", cNokogiriXmlSaxPushParser);
+  cNokogiriHtml4SaxPushParser = rb_define_class_under(mNokogiriHtml4Sax, "PushParser", cNokogiriXmlSaxPushParser);
 
-  rb_define_private_method(cNokogiriHtmlSaxPushParser, "initialize_native", initialize_native, 3);
-  rb_define_private_method(cNokogiriHtmlSaxPushParser, "native_write", native_write, 2);
+  rb_define_private_method(cNokogiriHtml4SaxPushParser, "initialize_native", initialize_native, 3);
+  rb_define_private_method(cNokogiriHtml4SaxPushParser, "native_write", native_write, 2);
 }

data/ext/nokogiri/libxml2_backwards_compat.c

@@ -20,14 +20,14 @@ xmlFirstElementChild(xmlNodePtr parent)
     return (NULL);
   }
   switch (parent->type) {
-  case XML_ELEMENT_NODE:
-  case XML_ENTITY_NODE:
-  case XML_DOCUMENT_NODE:
-  case XML_HTML_DOCUMENT_NODE:
-    cur = parent->children;
-    break;
-  default:
-    return (NULL);
+    case XML_ELEMENT_NODE:
+    case XML_ENTITY_NODE:
+    case XML_DOCUMENT_NODE:
+    case XML_HTML_DOCUMENT_NODE:
+      cur = parent->children;
+      break;
+    default:
+      return (NULL);
   }
   while (cur != NULL) {
     if (cur->type == XML_ELEMENT_NODE) {
@@ -57,20 +57,20 @@ xmlNextElementSibling(xmlNodePtr node)
     return (NULL);
   }
   switch (node->type) {
-  case XML_ELEMENT_NODE:
-  case XML_TEXT_NODE:
-  case XML_CDATA_SECTION_NODE:
-  case XML_ENTITY_REF_NODE:
-  case XML_ENTITY_NODE:
-  case XML_PI_NODE:
-  case XML_COMMENT_NODE:
-  case XML_DTD_NODE:
-  case XML_XINCLUDE_START:
-  case XML_XINCLUDE_END:
-    node = node->next;
-    break;
-  default:
-    return (NULL);
+    case XML_ELEMENT_NODE:
+    case XML_TEXT_NODE:
+    case XML_CDATA_SECTION_NODE:
+    case XML_ENTITY_REF_NODE:
+    case XML_ENTITY_NODE:
+    case XML_PI_NODE:
+    case XML_COMMENT_NODE:
+    case XML_DTD_NODE:
+    case XML_XINCLUDE_START:
+    case XML_XINCLUDE_END:
+      node = node->next;
+      break;
+    default:
+      return (NULL);
   }
   while (node != NULL) {
     if (node->type == XML_ELEMENT_NODE) {
@@ -101,14 +101,14 @@ xmlLastElementChild(xmlNodePtr parent)
     return (NULL);
   }
   switch (parent->type) {
-  case XML_ELEMENT_NODE:
-  case XML_ENTITY_NODE:
-  case XML_DOCUMENT_NODE:
-  case XML_HTML_DOCUMENT_NODE:
-    cur = parent->last;
-    break;
-  default:
-    return (NULL);
+    case XML_ELEMENT_NODE:
+    case XML_ENTITY_NODE:
+    case XML_DOCUMENT_NODE:
+    case XML_HTML_DOCUMENT_NODE:
+      cur = parent->last;
+      break;
+    default:
+      return (NULL);
   }
   while (cur != NULL) {
     if (cur->type == XML_ELEMENT_NODE) {

data/ext/nokogiri/nokogiri.c

@@ -1,8 +1,10 @@
 #include <nokogiri.h>
 
 VALUE mNokogiri ;
-VALUE mNokogiriHtml ;
-VALUE mNokogiriHtmlSax ;
+VALUE mNokogiriGumbo ;
+VALUE mNokogiriHtml4 ;
+VALUE mNokogiriHtml4Sax ;
+VALUE mNokogiriHtml5 ;
 VALUE mNokogiriXml ;
 VALUE mNokogiriXmlSax ;
 VALUE mNokogiriXmlXpath ;
@@ -13,38 +15,39 @@ VALUE cNokogiriXmlCharacterData;
 VALUE cNokogiriXmlElement;
 VALUE cNokogiriXmlXpathSyntaxError;
 
-void noko_init_xml_attr();
-void noko_init_xml_attribute_decl();
-void noko_init_xml_cdata();
-void noko_init_xml_comment();
-void noko_init_xml_document();
-void noko_init_xml_document_fragment();
-void noko_init_xml_dtd();
-void noko_init_xml_element_content();
-void noko_init_xml_element_decl();
-void noko_init_xml_encoding_handler();
-void noko_init_xml_entity_decl();
-void noko_init_xml_entity_reference();
-void noko_init_xml_namespace();
-void noko_init_xml_node();
-void noko_init_xml_node_set();
-void noko_init_xml_processing_instruction();
-void noko_init_xml_reader();
-void noko_init_xml_relax_ng();
-void noko_init_xml_sax_parser();
-void noko_init_xml_sax_parser_context();
-void noko_init_xml_sax_push_parser();
-void noko_init_xml_schema();
-void noko_init_xml_syntax_error();
-void noko_init_xml_text();
-void noko_init_xml_xpath_context();
-void noko_init_xslt_stylesheet();
-void noko_init_html_document();
-void noko_init_html_element_description();
-void noko_init_html_entity_lookup();
-void noko_init_html_sax_parser_context();
-void noko_init_html_sax_push_parser();
-void noko_init_test_global_handlers();
+void noko_init_xml_attr(void);
+void noko_init_xml_attribute_decl(void);
+void noko_init_xml_cdata(void);
+void noko_init_xml_comment(void);
+void noko_init_xml_document(void);
+void noko_init_xml_document_fragment(void);
+void noko_init_xml_dtd(void);
+void noko_init_xml_element_content(void);
+void noko_init_xml_element_decl(void);
+void noko_init_xml_encoding_handler(void);
+void noko_init_xml_entity_decl(void);
+void noko_init_xml_entity_reference(void);
+void noko_init_xml_namespace(void);
+void noko_init_xml_node(void);
+void noko_init_xml_node_set(void);
+void noko_init_xml_processing_instruction(void);
+void noko_init_xml_reader(void);
+void noko_init_xml_relax_ng(void);
+void noko_init_xml_sax_parser(void);
+void noko_init_xml_sax_parser_context(void);
+void noko_init_xml_sax_push_parser(void);
+void noko_init_xml_schema(void);
+void noko_init_xml_syntax_error(void);
+void noko_init_xml_text(void);
+void noko_init_xml_xpath_context(void);
+void noko_init_xslt_stylesheet(void);
+void noko_init_html_document(void);
+void noko_init_html_element_description(void);
+void noko_init_html_entity_lookup(void);
+void noko_init_html_sax_parser_context(void);
+void noko_init_html_sax_push_parser(void);
+void noko_init_gumbo(void);
+void noko_init_test_global_handlers(void);
 
 static ID id_read, id_write;
 
@@ -152,12 +155,14 @@ void
 Init_nokogiri()
 {
   mNokogiri         = rb_define_module("Nokogiri");
+  mNokogiriGumbo    = rb_define_module_under(mNokogiri, "Gumbo");
+  mNokogiriHtml4     = rb_define_module_under(mNokogiri, "HTML4");
+  mNokogiriHtml4Sax  = rb_define_module_under(mNokogiriHtml4, "SAX");
+  mNokogiriHtml5    = rb_define_module_under(mNokogiri, "HTML5");
   mNokogiriXml      = rb_define_module_under(mNokogiri, "XML");
-  mNokogiriHtml     = rb_define_module_under(mNokogiri, "HTML");
-  mNokogiriXslt     = rb_define_module_under(mNokogiri, "XSLT");
-  mNokogiriXmlXpath = rb_define_module_under(mNokogiriXml, "XPath");
   mNokogiriXmlSax   = rb_define_module_under(mNokogiriXml, "SAX");
-  mNokogiriHtmlSax  = rb_define_module_under(mNokogiriHtml, "SAX");
+  mNokogiriXmlXpath = rb_define_module_under(mNokogiriXml, "XPath");
+  mNokogiriXslt     = rb_define_module_under(mNokogiri, "XSLT");
 
   rb_const_set(mNokogiri, rb_intern("LIBXML_COMPILED_VERSION"), NOKOGIRI_STR_NEW2(LIBXML_DOTTED_VERSION));
   rb_const_set(mNokogiri, rb_intern("LIBXML_LOADED_VERSION"), NOKOGIRI_STR_NEW2(xmlParserVersion));
@@ -191,9 +196,35 @@ Init_nokogiri()
   rb_const_set(mNokogiri, rb_intern("OTHER_LIBRARY_VERSIONS"), NOKOGIRI_STR_NEW2(NOKOGIRI_OTHER_LIBRARY_VERSIONS));
 #endif
 
+#if defined(_WIN32) && !defined(NOKOGIRI_PACKAGED_LIBRARIES)
+  /*
+   *  We choose *not* to do use Ruby's memory management functions with windows DLLs because of this
+   *  issue in libxml 2.9.12:
+   *
+   *    https://github.com/sparklemotion/nokogiri/issues/2241
+   *
+   *  If the atexit() issue gets fixed in a future version of libxml2, then we may be able to skip
+   *  this config only for the specific libxml2 versions 2.9.12.
+   *
+   *  Alternatively, now that Ruby has a generational GC, it might be OK to let libxml2 use its
+   *  default memory management functions (recall that this config was introduced to reduce memory
+   *  bloat and allow Ruby to GC more often); but we should *really* test with production workloads
+   *  before making that kind of a potentially-invasive change.
+   */
+  rb_const_set(mNokogiri, rb_intern("LIBXML_MEMORY_MANAGEMENT"), NOKOGIRI_STR_NEW2("default"));
+#else
+  rb_const_set(mNokogiri, rb_intern("LIBXML_MEMORY_MANAGEMENT"), NOKOGIRI_STR_NEW2("ruby"));
   xmlMemSetup((xmlFreeFunc)ruby_xfree, (xmlMallocFunc)ruby_xmalloc, (xmlReallocFunc)ruby_xrealloc, ruby_strdup);
+#endif
 
   xmlInitParser();
+  exsltRegisterAll();
+
+  if (xsltExtModuleFunctionLookup((const xmlChar *)"date-time", EXSLT_DATE_NAMESPACE)) {
+    rb_const_set(mNokogiri, rb_intern("LIBXSLT_DATETIME_ENABLED"), Qtrue);
+  } else {
+    rb_const_set(mNokogiri, rb_intern("LIBXSLT_DATETIME_ENABLED"), Qfalse);
+  }
 
   cNokogiriSyntaxError = rb_define_class_under(mNokogiri, "SyntaxError", rb_eStandardError);
   noko_init_xml_syntax_error();
@@ -238,6 +269,7 @@ Init_nokogiri()
   noko_init_xml_document_fragment();
   noko_init_xml_document();
   noko_init_html_document();
+  noko_init_gumbo();
 
   noko_init_test_global_handlers();
 

data/ext/nokogiri/nokogiri.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_NATIVE
 #define NOKOGIRI_NATIVE
 
-#if _MSC_VER
+#ifdef _MSC_VER
 #  ifndef WIN32_LEAN_AND_MEAN
 #    define WIN32_LEAN_AND_MEAN
 #  endif /* WIN32_LEAN_AND_MEAN */
@@ -15,7 +15,7 @@
 #  include <windows.h>
 #endif
 
-#if _WIN32
+#ifdef _WIN32
 #  define NOKOPUBFUN __declspec(dllexport)
 #  define NOKOPUBVAR __declspec(dllexport) extern
 #else
@@ -69,6 +69,7 @@ xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
 #include <ruby/st.h>
 #include <ruby/encoding.h>
 #include <ruby/util.h>
+#include <ruby/version.h>
 
 #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())
@@ -92,12 +93,16 @@ xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
 
 
 NOKOPUBVAR VALUE mNokogiri ;
-NOKOPUBVAR VALUE mNokogiriHtml ;
-NOKOPUBVAR VALUE mNokogiriHtmlSax ;
+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;
@@ -128,10 +133,11 @@ NOKOPUBVAR VALUE cNokogiriXmlXpathContext;
 NOKOPUBVAR VALUE cNokogiriXmlXpathSyntaxError;
 NOKOPUBVAR VALUE cNokogiriXsltStylesheet ;
 
-NOKOPUBVAR VALUE cNokogiriHtmlDocument ;
-NOKOPUBVAR VALUE cNokogiriHtmlSaxPushParser ;
-NOKOPUBVAR VALUE cNokogiriHtmlElementDescription ;
-NOKOPUBVAR VALUE cNokogiriHtmlSaxParserContext;
+NOKOPUBVAR VALUE cNokogiriHtml4Document ;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxPushParser ;
+NOKOPUBVAR VALUE cNokogiriHtml4ElementDescription ;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxParserContext;
+NOKOPUBVAR VALUE cNokogiriHtml5Document ;
 
 typedef struct _nokogiriTuple {
   VALUE         doc;
@@ -177,7 +183,8 @@ 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. */
+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)
@@ -190,6 +197,9 @@ NOKOPUBFUN VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc); /* depr
 #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)
+
 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);

data/ext/nokogiri/xml_document.c

@@ -6,19 +6,19 @@ static int
 dealloc_node_i2(xmlNodePtr key, xmlNodePtr node, xmlDocPtr doc)
 {
   switch (node->type) {
-  case XML_ATTRIBUTE_NODE:
-    xmlFreePropList((xmlAttrPtr)node);
-    break;
-  case XML_NAMESPACE_DECL:
-    xmlFreeNs((xmlNsPtr)node);
-    break;
-  case XML_DTD_NODE:
-    xmlFreeDtd((xmlDtdPtr)node);
-    break;
-  default:
-    if (node->parent == NULL) {
-      xmlAddChild((xmlNodePtr)doc, node);
-    }
+    case XML_ATTRIBUTE_NODE:
+      xmlFreePropList((xmlAttrPtr)node);
+      break;
+    case XML_NAMESPACE_DECL:
+      xmlFreeNs((xmlNsPtr)node);
+      break;
+    case XML_DTD_NODE:
+      xmlFreeDtd((xmlDtdPtr)node);
+      break;
+    default:
+      if (node->parent == NULL) {
+        xmlAddChild((xmlNodePtr)doc, node);
+      }
   }
   return ST_CONTINUE;
 }
@@ -141,42 +141,41 @@ url(VALUE self)
  * Set the root element on this document
  */
 static VALUE
-set_root(VALUE self, VALUE root)
+rb_xml_document_root_set(VALUE self, VALUE rb_new_root)
 {
-  xmlDocPtr doc;
-  xmlNodePtr new_root;
-  xmlNodePtr old_root;
-
-  Data_Get_Struct(self, xmlDoc, doc);
+  xmlDocPtr c_document;
+  xmlNodePtr c_new_root = NULL, c_current_root;
 
-  old_root = NULL;
-
-  if (NIL_P(root)) {
-    old_root = xmlDocGetRootElement(doc);
-
-    if (old_root) {
-      xmlUnlinkNode(old_root);
-      noko_xml_document_pin_node(old_root);
-    }
+  Data_Get_Struct(self, xmlDoc, c_document);
 
-    return root;
+  c_current_root = xmlDocGetRootElement(c_document);
+  if (c_current_root) {
+    xmlUnlinkNode(c_current_root);
+    noko_xml_document_pin_node(c_current_root);
   }
 
-  Data_Get_Struct(root, xmlNode, new_root);
+  if (!NIL_P(rb_new_root)) {
+    if (!rb_obj_is_kind_of(rb_new_root, cNokogiriXmlNode)) {
+      rb_raise(rb_eArgError,
+               "expected Nokogiri::XML::Node but received %"PRIsVALUE,
+               rb_obj_class(rb_new_root));
+    }
 
+    Data_Get_Struct(rb_new_root, xmlNode, c_new_root);
 
-  /* If the new root's document is not the same as the current document,
-   * then we need to dup the node in to this document. */
-  if (new_root->doc != doc) {
-    old_root = xmlDocGetRootElement(doc);
-    if (!(new_root = xmlDocCopyNode(new_root, doc, 1))) {
-      rb_raise(rb_eRuntimeError, "Could not reparent node (xmlDocCopyNode)");
+    /* If the new root's document is not the same as the current document,
+     * then we need to dup the node in to this document. */
+    if (c_new_root->doc != c_document) {
+      c_new_root = xmlDocCopyNode(c_new_root, c_document, 1);
+      if (!c_new_root) {
+        rb_raise(rb_eRuntimeError, "Could not reparent node (xmlDocCopyNode)");
+      }
     }
   }
 
-  xmlDocSetRootElement(doc, new_root);
-  if (old_root) { noko_xml_document_pin_node(old_root); }
-  return root;
+  xmlDocSetRootElement(c_document, c_new_root);
+
+  return rb_new_root;
 }
 
 /*
@@ -186,17 +185,19 @@ set_root(VALUE self, VALUE root)
  * Get the root node for this document.
  */
 static VALUE
-root(VALUE self)
+rb_xml_document_root(VALUE self)
 {
-  xmlDocPtr doc;
-  xmlNodePtr root;
+  xmlDocPtr c_document;
+  xmlNodePtr c_root;
 
-  Data_Get_Struct(self, xmlDoc, doc);
+  Data_Get_Struct(self, xmlDoc, c_document);
 
-  root = xmlDocGetRootElement(doc);
+  c_root = xmlDocGetRootElement(c_document);
+  if (!c_root) {
+    return Qnil;
+  }
 
-  if (!root) { return Qnil; }
-  return noko_xml_node_wrap(Qnil, root) ;
+  return noko_xml_node_wrap(Qnil, c_root) ;
 }
 
 /*
@@ -212,7 +213,7 @@ set_encoding(VALUE self, VALUE encoding)
   Data_Get_Struct(self, xmlDoc, doc);
 
   if (doc->encoding) {
-    free((char *)(uintptr_t) doc->encoding);  /* avoid gcc cast warning */
+    xmlFree(DISCARD_CONST_QUAL_XMLCHAR(doc->encoding));
   }
 
   doc->encoding = xmlStrdup((xmlChar *)StringValueCStr(encoding));
@@ -666,8 +667,8 @@ noko_init_xml_document()
   rb_define_singleton_method(cNokogiriXmlDocument, "read_io", read_io, 4);
   rb_define_singleton_method(cNokogiriXmlDocument, "new", new, -1);
 
-  rb_define_method(cNokogiriXmlDocument, "root", root, 0);
-  rb_define_method(cNokogiriXmlDocument, "root=", set_root, 1);
+  rb_define_method(cNokogiriXmlDocument, "root", rb_xml_document_root, 0);
+  rb_define_method(cNokogiriXmlDocument, "root=", rb_xml_document_root_set, 1);
   rb_define_method(cNokogiriXmlDocument, "encoding", encoding, 0);
   rb_define_method(cNokogiriXmlDocument, "encoding=", set_encoding, 1);
   rb_define_method(cNokogiriXmlDocument, "version", version, 0);

data/ext/nokogiri/xml_element_content.c

@@ -116,6 +116,8 @@ noko_init_xml_element_content()
 {
   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);

data/ext/nokogiri/xml_encoding_handler.c

@@ -1,5 +1,8 @@
 #include <nokogiri.h>
 
+VALUE cNokogiriEncodingHandler;
+
+
 /*
  * call-seq: Nokogiri::EncodingHandler.[](name)
  *
@@ -75,11 +78,13 @@ name(VALUE self)
 void
 noko_init_xml_encoding_handler()
 {
-  VALUE klass = rb_define_class_under(mNokogiri, "EncodingHandler", rb_cObject);
+  cNokogiriEncodingHandler = rb_define_class_under(mNokogiri, "EncodingHandler", rb_cObject);
+
+  rb_undef_alloc_func(cNokogiriEncodingHandler);
 
-  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);
+  rb_define_singleton_method(cNokogiriEncodingHandler, "[]", get, 1);
+  rb_define_singleton_method(cNokogiriEncodingHandler, "delete", delete, 1);
+  rb_define_singleton_method(cNokogiriEncodingHandler, "alias", alias, 2);
+  rb_define_singleton_method(cNokogiriEncodingHandler, "clear_aliases!", clear_aliases, 0);
+  rb_define_method(cNokogiriEncodingHandler, "name", name, 0);
 }

data/ext/nokogiri/xml_namespace.c

@@ -33,10 +33,10 @@ dealloc_namespace(xmlNsPtr ns)
    */
   NOKOGIRI_DEBUG_START(ns) ;
   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) ;
@@ -113,6 +113,8 @@ noko_init_xml_namespace()
 {
   cNokogiriXmlNamespace = rb_define_class_under(mNokogiriXml, "Namespace", rb_cObject);
 
+  rb_undef_alloc_func(cNokogiriXmlNamespace);
+
   rb_define_method(cNokogiriXmlNamespace, "prefix", prefix, 0);
   rb_define_method(cNokogiriXmlNamespace, "href", href, 0);
 }