nokogiri 1.5.10 → 1.12.5

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,94 +1,190 @@
 #include <nokogiri.h>
 
 VALUE mNokogiri ;
+VALUE mNokogiriGumbo ;
+VALUE mNokogiriHtml4 ;
+VALUE mNokogiriHtml4Sax ;
+VALUE mNokogiriHtml5 ;
 VALUE mNokogiriXml ;
-VALUE mNokogiriHtml ;
-VALUE mNokogiriXslt ;
 VALUE mNokogiriXmlSax ;
-VALUE mNokogiriHtmlSax ;
+VALUE mNokogiriXmlXpath ;
+VALUE mNokogiriXslt ;
+
+VALUE cNokogiriSyntaxError;
+VALUE cNokogiriXmlCharacterData;
+VALUE cNokogiriXmlElement;
+VALUE cNokogiriXmlXpathSyntaxError;
+
+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);
 
-#ifdef USE_INCLUDED_VASPRINTF
+static ID id_read, id_write;
+
+
+#ifndef HAVE_VASPRINTF
 /*
- * I srsly hate windows.  it doesn't 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)
 {
-  int len = vsnprintf (NULL, 0, fmt, ap) + 1;
+  /* 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;
   char *res = (char *)malloc((unsigned int)len);
-  if (res == NULL)
-      return -1;
+  if (res == NULL) {
+    return -1;
+  }
   *strp = res;
   return vsnprintf(res, (unsigned int)len, fmt, ap);
 }
 #endif
 
-#ifdef USING_SYSTEM_ALLOCATOR_LIBRARY /* Ruby Enterprise Edition with tcmalloc */
-void vasprintf_free (void *p)
+
+static VALUE
+read_check(VALUE val)
 {
-  system_free(p);
+  VALUE *args = (VALUE *)val;
+  return rb_funcall(args[0], id_read, 1, args[1]);
 }
-#else
-void vasprintf_free (void *p)
+
+
+static VALUE
+read_failed(VALUE arg, VALUE exc)
 {
-  free(p);
+  return Qundef;
 }
-#endif
 
-#ifdef HAVE_RUBY_UTIL_H
-#include "ruby/util.h"
-#else
-#ifndef __MACRUBY__
-#include "util.h"
-#endif
-#endif
 
-void nokogiri_root_node(xmlNodePtr node)
+int
+noko_io_read(void *ctx, char *buffer, int len)
 {
-  xmlDocPtr doc;
-  nokogiriTuplePtr tuple;
+  VALUE string, args[2];
+  size_t str_len, safe_len;
 
-  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);
+  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;
 }
 
-void nokogiri_root_nsdef(xmlNsPtr ns, xmlDocPtr doc)
+
+static VALUE
+write_check(VALUE val)
 {
-  nokogiriTuplePtr tuple;
+  VALUE *args = (VALUE *)val;
+  return rb_funcall(args[0], id_write, 1, args[1]);
+}
+
 
-  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);
+static VALUE
+write_failed(VALUE arg, VALUE exc)
+{
+  return Qundef;
 }
 
-void Init_nokogiri()
+
+int
+noko_io_write(void *ctx, char *buffer, int len)
 {
-#ifndef __MACRUBY__
-  xmlMemSetup(
-      (xmlFreeFunc)ruby_xfree,
-      (xmlMallocFunc)ruby_xmalloc,
-      (xmlReallocFunc)ruby_xrealloc,
-      ruby_strdup
-  );
-#endif
+  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 (size == Qundef) { return -1; }
+
+  return NUM2INT(size);
+}
+
+
+int
+noko_io_close(void *ctx)
+{
+  return 0;
+}
+
+
+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");
   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_VERSION"),
-                NOKOGIRI_STR_NEW2(LIBXML_DOTTED_VERSION)
-              );
-  rb_const_set( mNokogiri,
-                rb_intern("LIBXML_PARSER_VERSION"),
-                NOKOGIRI_STR_NEW2(xmlParserVersion)
-              );
+  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));
+
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_COMPILED_VERSION"), NOKOGIRI_STR_NEW2(LIBXSLT_DOTTED_VERSION));
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_LOADED_VERSION"), NOKOGIRI_STR_NEW2(xsltEngineVersion));
+
+#ifdef NOKOGIRI_PACKAGED_LIBRARIES
+  rb_const_set(mNokogiri, rb_intern("PACKAGED_LIBRARIES"), Qtrue);
+#  ifdef NOKOGIRI_PRECOMPILED_LIBRARIES
+  rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qtrue);
+#  else
+  rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qfalse);
+#  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
+  rb_const_set(mNokogiri, rb_intern("PACKAGED_LIBRARIES"), Qfalse);
+  rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qfalse);
+  rb_const_set(mNokogiri, rb_intern("LIBXML2_PATCHES"), Qnil);
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_PATCHES"), Qnil);
+#endif
 
 #ifdef LIBXML_ICONV_ENABLED
   rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qtrue);
@@ -96,38 +192,87 @@ void Init_nokogiri()
   rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qfalse);
 #endif
 
+#ifdef NOKOGIRI_OTHER_LIBRARY_VERSIONS
+  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();
+  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_gumbo();
+
+  noko_init_test_global_handlers();
 
-  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();
+  id_read = rb_intern("read");
+  id_write = rb_intern("write");
 }