nokogiri 1.11.0.rc2-x86-linux → 1.11.2-x86-linux

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,107 +1,184 @@
 #include <nokogiri.h>
 
 VALUE mNokogiri ;
-VALUE mNokogiriXml ;
 VALUE mNokogiriHtml ;
-VALUE mNokogiriXslt ;
-VALUE mNokogiriXmlSax ;
 VALUE mNokogiriHtmlSax ;
+VALUE mNokogiriXml ;
+VALUE mNokogiriXmlSax ;
+VALUE mNokogiriXmlXpath ;
+VALUE mNokogiriXslt ;
 
-#ifdef USE_INCLUDED_VASPRINTF
+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
 /*
- * 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)
 {
   /* 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;
+  if (res == NULL) {
+    return -1;
+  }
   *strp = res;
   return vsnprintf(res, (unsigned int)len, fmt, ap);
 }
 #endif
 
-void vasprintf_free (void *p)
+
+static VALUE
+read_check(VALUE val)
 {
-  free(p);
+  VALUE *args = (VALUE *)val;
+  return rb_funcall(args[0], id_read, 1, args[1]);
 }
 
-#ifdef HAVE_RUBY_UTIL_H
-#include "ruby/util.h"
-#else
-#include "util.h"
-#endif
 
-void nokogiri_root_node(xmlNodePtr node)
+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);
 
-  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);
+  size = rb_rescue(write_check, (VALUE)args, write_failed, 0);
+
+  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");
 
-  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_USE_PACKAGED_LIBRARIES
-  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_USE_PACKAGED_LIBRARIES"), Qtrue);
-  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXML2_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXML2_PATCHES), " "));
-  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXSLT_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXSLT_PATCHES), " "));
+  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("NOKOGIRI_USE_PACKAGED_LIBRARIES"), Qfalse);
-  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXML2_PATCHES"), Qnil);
-  rb_const_set(mNokogiri, rb_intern("NOKOGIRI_LIBXSLT_PATCHES"), Qnil);
+  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
@@ -110,38 +187,60 @@ 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
+
+  xmlMemSetup((xmlFreeFunc)ruby_xfree, (xmlMallocFunc)ruby_xmalloc, (xmlReallocFunc)ruby_xrealloc, ruby_strdup);
+
   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");
 }