nokogiri 1.11.0 → 1.11.5

data/ext/nokogiri/html_sax_push_parser.c

@@ -1,4 +1,6 @@
-#include <html_sax_push_parser.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriHtmlSaxPushParser;
 
 /*
  * call-seq:
@@ -6,25 +8,32 @@
  *
  * Write +chunk+ to PushParser. +last_chunk+ triggers the end_document handle
  */
-static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
+static VALUE
+native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
 {
   xmlParserCtxtPtr ctx;
-  const char * chunk  = NULL;
-  int size            = 0;
-
+  const char *chunk = NULL;
+  int size = 0;
+  int status = 0;
+  libxmlStructuredErrorHandlerState handler_state;
 
   Data_Get_Struct(self, xmlParserCtxt, ctx);
 
-  if(Qnil != _chunk) {
+  if (Qnil != _chunk) {
     chunk = StringValuePtr(_chunk);
     size = (int)RSTRING_LEN(_chunk);
   }
 
-  if(htmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0)) {
-    if (!(ctx->options & XML_PARSE_RECOVER)) {
-      xmlErrorPtr e = xmlCtxtGetLastError(ctx);
-      Nokogiri_error_raise(NULL, e);
-    }
+  Nokogiri_structured_error_func_save_and_set(&handler_state, NULL, NULL);
+
+  status = htmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0);
+
+  Nokogiri_structured_error_func_restore(&handler_state);
+
+  if ((status != 0) && !(ctx->options & XML_PARSE_RECOVER)) {
+    // TODO: there appear to be no tests for this block
+    xmlErrorPtr e = xmlCtxtGetLastError(ctx);
+    Nokogiri_error_raise(NULL, e);
   }
 
   return self;
@@ -36,34 +45,37 @@ static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
  *
  * Initialize the push parser with +xml_sax+ using +filename+
  */
-static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
-			       VALUE encoding)
+static VALUE
+initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
+                  VALUE encoding)
 {
   htmlSAXHandlerPtr sax;
-  const char * filename = NULL;
+  const char *filename = NULL;
   htmlParserCtxtPtr ctx;
   xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
 
   Data_Get_Struct(_xml_sax, xmlSAXHandler, sax);
 
-  if(_filename != Qnil) filename = StringValueCStr(_filename);
+  if (_filename != Qnil) { filename = StringValueCStr(_filename); }
 
   if (!NIL_P(encoding)) {
     enc = xmlParseCharEncoding(StringValueCStr(encoding));
-    if (enc == XML_CHAR_ENCODING_ERROR)
+    if (enc == XML_CHAR_ENCODING_ERROR) {
       rb_raise(rb_eArgError, "Unsupported Encoding");
+    }
   }
 
   ctx = htmlCreatePushParserCtxt(
-      sax,
-      NULL,
-      NULL,
-      0,
-      filename,
-      enc
-  );
-  if(ctx == NULL)
+          sax,
+          NULL,
+          NULL,
+          0,
+          filename,
+          enc
+        );
+  if (ctx == NULL) {
     rb_raise(rb_eRuntimeError, "Could not create a parser context");
+  }
 
   ctx->userData = NOKOGIRI_SAX_TUPLE_NEW(ctx, self);
 
@@ -72,16 +84,12 @@ static VALUE initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
   return self;
 }
 
-VALUE cNokogiriHtmlSaxPushParser;
-void init_html_sax_push_parser()
+void
+noko_init_html_sax_push_parser()
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE html = rb_define_module_under(nokogiri, "HTML");
-  VALUE sax = rb_define_module_under(html, "SAX");
-  VALUE klass = rb_define_class_under(sax, "PushParser", cNokogiriXmlSaxPushParser);
-
-  cNokogiriHtmlSaxPushParser = klass;
+  assert(cNokogiriXmlSaxPushParser);
+  cNokogiriHtmlSaxPushParser = rb_define_class_under(mNokogiriHtmlSax, "PushParser", cNokogiriXmlSaxPushParser);
 
-  rb_define_private_method(klass, "initialize_native", initialize_native, 3);
-  rb_define_private_method(klass, "native_write", native_write, 2);
+  rb_define_private_method(cNokogiriHtmlSaxPushParser, "initialize_native", initialize_native, 3);
+  rb_define_private_method(cNokogiriHtmlSaxPushParser, "native_write", native_write, 2);
 }

data/ext/nokogiri/libxml2_backwards_compat.c

@@ -0,0 +1,121 @@
+#ifndef HAVE_XMLFIRSTELEMENTCHILD
+#include <nokogiri.h>
+/**
+ * xmlFirstElementChild:
+ * @parent: the parent node
+ *
+ * Finds the first child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the first element child or NULL if not available
+ */
+xmlNodePtr
+xmlFirstElementChild(xmlNodePtr parent)
+{
+  xmlNodePtr cur = NULL;
+
+  if (parent == NULL) {
+    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);
+  }
+  while (cur != NULL) {
+    if (cur->type == XML_ELEMENT_NODE) {
+      return (cur);
+    }
+    cur = cur->next;
+  }
+  return (NULL);
+}
+
+/**
+ * xmlNextElementSibling:
+ * @node: the current node
+ *
+ * Finds the first closest next sibling of the node which is an
+ * element node.
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the next element sibling or NULL if not available
+ */
+xmlNodePtr
+xmlNextElementSibling(xmlNodePtr node)
+{
+  if (node == NULL) {
+    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);
+  }
+  while (node != NULL) {
+    if (node->type == XML_ELEMENT_NODE) {
+      return (node);
+    }
+    node = node->next;
+  }
+  return (NULL);
+}
+
+/**
+ * xmlLastElementChild:
+ * @parent: the parent node
+ *
+ * Finds the last child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the last element child or NULL if not available
+ */
+xmlNodePtr
+xmlLastElementChild(xmlNodePtr parent)
+{
+  xmlNodePtr cur = NULL;
+
+  if (parent == NULL) {
+    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);
+  }
+  while (cur != NULL) {
+    if (cur->type == XML_ELEMENT_NODE) {
+      return (cur);
+    }
+    cur = cur->prev;
+  }
+  return (NULL);
+}
+#endif

data/ext/nokogiri/nokogiri.c

@@ -1,24 +1,67 @@
 #include <nokogiri.h>
 
 VALUE mNokogiri ;
-VALUE mNokogiriXml ;
 VALUE mNokogiriHtml ;
-VALUE mNokogiriXslt ;
-VALUE mNokogiriXmlSax ;
 VALUE mNokogiriHtmlSax ;
+VALUE mNokogiriXml ;
+VALUE mNokogiriXmlSax ;
+VALUE mNokogiriXmlXpath ;
+VALUE mNokogiriXslt ;
+
+VALUE cNokogiriSyntaxError;
+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();
+
+static ID id_read, id_write;
+
 
 #ifndef HAVE_VASPRINTF
 /*
  * Thank you Geoffroy Couprie for this implementation of vasprintf!
  */
-int vasprintf(char **strp, const char *fmt, va_list ap)
+int
+vasprintf(char **strp, const char *fmt, va_list ap)
 {
   /* Mingw32/64 have a broken vsnprintf implementation that fails when
    * using a zero-byte limit in order to retrieve the required size for malloc.
    * So we use a one byte buffer instead.
    */
   char tmp[1];
-  int len = vsnprintf (tmp, 1, fmt, ap) + 1;
+  int len = vsnprintf(tmp, 1, fmt, ap) + 1;
   char *res = (char *)malloc((unsigned int)len);
   if (res == NULL) {
     return -1;
@@ -28,41 +71,91 @@ int vasprintf(char **strp, const char *fmt, va_list ap)
 }
 #endif
 
-#include "ruby/util.h"
 
-void nokogiri_root_node(xmlNodePtr node)
+static VALUE
+read_check(VALUE val)
+{
+  VALUE *args = (VALUE *)val;
+  return rb_funcall(args[0], id_read, 1, args[1]);
+}
+
+
+static VALUE
+read_failed(VALUE arg, VALUE exc)
+{
+  return Qundef;
+}
+
+
+int
+noko_io_read(void *ctx, char *buffer, int len)
+{
+  VALUE string, args[2];
+  size_t str_len, safe_len;
+
+  args[0] = (VALUE)ctx;
+  args[1] = INT2NUM(len);
+
+  string = rb_rescue(read_check, (VALUE)args, read_failed, 0);
+
+  if (NIL_P(string)) { return 0; }
+  if (string == Qundef) { return -1; }
+  if (TYPE(string) != T_STRING) { return -1; }
+
+  str_len = (size_t)RSTRING_LEN(string);
+  safe_len = str_len > (size_t)len ? (size_t)len : str_len;
+  memcpy(buffer, StringValuePtr(string), safe_len);
+
+  return (int)safe_len;
+}
+
+
+static VALUE
+write_check(VALUE val)
 {
-  xmlDocPtr doc;
-  nokogiriTuplePtr tuple;
+  VALUE *args = (VALUE *)val;
+  return rb_funcall(args[0], id_write, 1, args[1]);
+}
 
-  doc = node->doc;
-  if (doc->type == XML_DOCUMENT_FRAG_NODE) { doc = doc->doc; }
-  tuple = (nokogiriTuplePtr)doc->_private;
-  st_insert(tuple->unlinkedNodes, (st_data_t)node, (st_data_t)node);
+
+static VALUE
+write_failed(VALUE arg, VALUE exc)
+{
+  return Qundef;
 }
 
-void nokogiri_root_nsdef(xmlNsPtr ns, xmlDocPtr doc)
+
+int
+noko_io_write(void *ctx, char *buffer, int len)
 {
-  nokogiriTuplePtr tuple;
+  VALUE args[2], size;
+
+  args[0] = (VALUE)ctx;
+  args[1] = rb_str_new(buffer, (long)len);
+
+  size = rb_rescue(write_check, (VALUE)args, write_failed, 0);
 
-  if (doc->type == XML_DOCUMENT_FRAG_NODE) { doc = doc->doc; }
-  tuple = (nokogiriTuplePtr)doc->_private;
-  st_insert(tuple->unlinkedNodes, (st_data_t)ns, (st_data_t)ns);
+  if (size == Qundef) { return -1; }
+
+  return NUM2INT(size);
 }
 
-void Init_nokogiri()
+
+int
+noko_io_close(void *ctx)
 {
-  xmlMemSetup(
-    (xmlFreeFunc)ruby_xfree,
-    (xmlMallocFunc)ruby_xmalloc,
-    (xmlReallocFunc)ruby_xrealloc,
-    ruby_strdup
-  );
+  return 0;
+}
 
+
+void
+Init_nokogiri()
+{
   mNokogiri         = rb_define_module("Nokogiri");
   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");
 
@@ -74,11 +167,11 @@ void Init_nokogiri()
 
 #ifdef NOKOGIRI_PACKAGED_LIBRARIES
   rb_const_set(mNokogiri, rb_intern("PACKAGED_LIBRARIES"), Qtrue);
-#ifdef NOKOGIRI_PRECOMPILED_LIBRARIES
+#  ifdef NOKOGIRI_PRECOMPILED_LIBRARIES
   rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qtrue);
-#else
+#  else
   rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qfalse);
-#endif
+#  endif
   rb_const_set(mNokogiri, rb_intern("LIBXML2_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXML2_PATCHES), " "));
   rb_const_set(mNokogiri, rb_intern("LIBXSLT_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXSLT_PATCHES), " "));
 #else
@@ -98,38 +191,75 @@ void 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();
 
-  init_xml_document();
-  init_html_document();
-  init_xml_node();
-  init_xml_document_fragment();
-  init_xml_text();
-  init_xml_cdata();
-  init_xml_processing_instruction();
-  init_xml_attr();
-  init_xml_entity_reference();
-  init_xml_comment();
-  init_xml_node_set();
-  init_xml_xpath_context();
-  init_xml_sax_parser_context();
-  init_xml_sax_parser();
-  init_xml_sax_push_parser();
-  init_xml_reader();
-  init_xml_dtd();
-  init_xml_element_content();
-  init_xml_attribute_decl();
-  init_xml_element_decl();
-  init_xml_entity_decl();
-  init_xml_namespace();
-  init_html_sax_parser_context();
-  init_html_sax_push_parser();
-  init_xslt_stylesheet();
-  init_xml_syntax_error();
-  init_html_entity_lookup();
-  init_html_element_description();
-  init_xml_schema();
-  init_xml_relax_ng();
-  init_nokogiri_io();
-  init_xml_encoding_handler();
+  cNokogiriSyntaxError = rb_define_class_under(mNokogiri, "SyntaxError", rb_eStandardError);
+  noko_init_xml_syntax_error();
+  assert(cNokogiriXmlSyntaxError);
+  cNokogiriXmlXpathSyntaxError = rb_define_class_under(mNokogiriXmlXpath, "SyntaxError", cNokogiriXmlSyntaxError);
+
+  noko_init_xml_element_content();
+  noko_init_xml_encoding_handler();
+  noko_init_xml_namespace();
+  noko_init_xml_node_set();
+  noko_init_xml_reader();
+  noko_init_xml_sax_parser();
+  noko_init_xml_xpath_context();
+  noko_init_xslt_stylesheet();
+  noko_init_html_element_description();
+  noko_init_html_entity_lookup();
+
+  noko_init_xml_schema();
+  noko_init_xml_relax_ng();
+
+  noko_init_xml_sax_parser_context();
+  noko_init_html_sax_parser_context();
+
+  noko_init_xml_sax_push_parser();
+  noko_init_html_sax_push_parser();
+
+  noko_init_xml_node();
+  noko_init_xml_attr();
+  noko_init_xml_attribute_decl();
+  noko_init_xml_dtd();
+  noko_init_xml_element_decl();
+  noko_init_xml_entity_decl();
+  noko_init_xml_entity_reference();
+  noko_init_xml_processing_instruction();
+  assert(cNokogiriXmlNode);
+  cNokogiriXmlElement = rb_define_class_under(mNokogiriXml, "Element", cNokogiriXmlNode);
+  cNokogiriXmlCharacterData = rb_define_class_under(mNokogiriXml, "CharacterData", cNokogiriXmlNode);
+  noko_init_xml_comment();
+  noko_init_xml_text();
+  noko_init_xml_cdata();
+
+  noko_init_xml_document_fragment();
+  noko_init_xml_document();
+  noko_init_html_document();
+
+  noko_init_test_global_handlers();
+
+  id_read = rb_intern("read");
+  id_write = rb_intern("write");
 }