nokogiri 1.11.0.rc1-x64-mingw32 → 1.11.1-x64-mingw32

data/ext/nokogiri/xml_sax_parser.c

@@ -1,8 +1,5 @@
 #include <xml_sax_parser.h>
 
-int vasprintf (char **strp, const char *fmt, va_list ap);
-void vasprintf_free (void *p);
-
 static ID id_start_document, id_end_document, id_start_element, id_end_element;
 static ID id_start_element_namespace, id_end_element_namespace;
 static ID id_comment, id_characters, id_xmldecl, id_error, id_warning;
@@ -206,7 +203,7 @@ static void warning_func(void * ctx, const char *msg, ...)
   va_end(args);
 
   ruby_message = NOKOGIRI_STR_NEW2(message);
-  vasprintf_free(message);
+  free(message);
   rb_funcall(doc, id_warning, 1, ruby_message);
 }
 
@@ -223,7 +220,7 @@ static void error_func(void * ctx, const char *msg, ...)
   va_end(args);
 
   ruby_message = NOKOGIRI_STR_NEW2(message);
-  vasprintf_free(message);
+  free(message);
   rb_funcall(doc, id_error, 1, ruby_message);
 }
 
@@ -262,8 +259,6 @@ static VALUE allocate(VALUE klass)
 {
   xmlSAXHandlerPtr handler = calloc((size_t)1, sizeof(xmlSAXHandler));
 
-  xmlSetStructuredErrorFunc(NULL, NULL);
-
   handler->startDocument = start_document;
   handler->endDocument = end_document;
   handler->startElement = start_element;

data/ext/nokogiri/xml_sax_parser_context.c

@@ -4,13 +4,13 @@ VALUE cNokogiriXmlSaxParserContext ;
 
 static void deallocate(xmlParserCtxtPtr ctxt)
 {
-  NOKOGIRI_DEBUG_START(handler);
+  NOKOGIRI_DEBUG_START(ctxt);
 
   ctxt->sax = NULL;
 
   xmlFreeParserCtxt(ctxt);
 
-  NOKOGIRI_DEBUG_END(handler);
+  NOKOGIRI_DEBUG_END(ctxt);
 }
 
 /*
@@ -120,6 +120,8 @@ parse_with(VALUE self, VALUE sax_handler)
     ctxt->sax = sax;
     ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
 
+    xmlSetStructuredErrorFunc(NULL, NULL);
+
     rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);
 
     return Qnil;

data/ext/nokogiri/xml_sax_push_parser.c

@@ -35,6 +35,8 @@ static VALUE native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
     size = (int)RSTRING_LEN(_chunk);
   }
 
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
   if (xmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0)) {
     if (!(ctx->options & XML_PARSE_RECOVER)) {
       xmlErrorPtr e = xmlCtxtGetLastError(ctx);

data/ext/nokogiri/xml_schema.c

@@ -93,15 +93,27 @@ static VALUE validate_file(VALUE self, VALUE rb_filename)
  *
  * Create a new Schema from the contents of +string+
  */
-static VALUE read_memory(VALUE klass, VALUE content)
+static VALUE read_memory(int argc, VALUE *argv, VALUE klass)
 {
+  VALUE content;
+  VALUE parse_options;
+  int parse_options_int;
+  xmlSchemaParserCtxtPtr ctx;
   xmlSchemaPtr schema;
-  xmlSchemaParserCtxtPtr ctx = xmlSchemaNewMemParserCtxt(
-      (const char *)StringValuePtr(content),
-      (int)RSTRING_LEN(content)
-  );
+  VALUE errors;
   VALUE rb_schema;
-  VALUE errors = rb_ary_new();
+  int scanned_args = 0;
+  xmlExternalEntityLoader old_loader = 0;
+
+  scanned_args = rb_scan_args(argc, argv, "11", &content, &parse_options);
+  if (scanned_args == 1) {
+    parse_options = rb_const_get(rb_const_get(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
+  }
+  parse_options_int = (int)NUM2INT(rb_funcall(parse_options, rb_intern("to_i"), 0));
+
+  ctx = xmlSchemaNewMemParserCtxt((const char *)StringValuePtr(content), (int)RSTRING_LEN(content));
+
+  errors = rb_ary_new();
   xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
 
 #ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
@@ -109,10 +121,19 @@ static VALUE read_memory(VALUE klass, VALUE content)
     ctx,
     Nokogiri_error_array_pusher,
     (void *)errors
-  );
+    );
 #endif
 
-   schema = xmlSchemaParse(ctx);
+  if (parse_options_int & XML_PARSE_NONET) {
+    old_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
+  }
+
+  schema = xmlSchemaParse(ctx);
+
+  if (old_loader) {
+    xmlSetExternalEntityLoader(old_loader);
+  }
 
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSchemaFreeParserCtxt(ctx);
@@ -129,28 +150,68 @@ static VALUE read_memory(VALUE klass, VALUE content)
 
   rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
   rb_iv_set(rb_schema, "@errors", errors);
+  rb_iv_set(rb_schema, "@parse_options", parse_options);
 
   return rb_schema;
 }
 
+/* Schema creation will remove and deallocate "blank" nodes.
+ * If those blank nodes have been exposed to Ruby, they could get freed
+ * out from under the VALUE pointer.  This function checks to see if any of
+ * those nodes have been exposed to Ruby, and if so we should raise an exception.
+ */
+static int has_blank_nodes_p(VALUE cache)
+{
+    long i;
+
+    if (NIL_P(cache)) {
+        return 0;
+    }
+
+    for (i = 0; i < RARRAY_LEN(cache); i++) {
+        xmlNodePtr node;
+        VALUE element = rb_ary_entry(cache, i);
+        Data_Get_Struct(element, xmlNode, node);
+        if (xmlIsBlankNode(node)) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
 /*
  * call-seq:
  *  from_document(doc)
  *
  * Create a new Schema from the Nokogiri::XML::Document +doc+
  */
-static VALUE from_document(VALUE klass, VALUE document)
+static VALUE from_document(int argc, VALUE *argv, VALUE klass)
 {
+  VALUE document;
+  VALUE parse_options;
+  int parse_options_int;
   xmlDocPtr doc;
   xmlSchemaParserCtxtPtr ctx;
   xmlSchemaPtr schema;
   VALUE errors;
   VALUE rb_schema;
+  int scanned_args = 0;
+  xmlExternalEntityLoader old_loader = 0;
+
+  scanned_args = rb_scan_args(argc, argv, "11", &document, &parse_options);
 
   Data_Get_Struct(document, xmlDoc, doc);
+  doc = doc->doc; /* In case someone passes us a node. ugh. */
 
-  /* In case someone passes us a node. ugh. */
-  doc = doc->doc;
+  if (scanned_args == 1) {
+    parse_options = rb_const_get(rb_const_get(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
+  }
+  parse_options_int = (int)NUM2INT(rb_funcall(parse_options, rb_intern("to_i"), 0));
+
+  if (has_blank_nodes_p(DOC_NODE_CACHE(doc))) {
+    rb_raise(rb_eArgError, "Creating a schema from a document that has blank nodes exposed to Ruby is dangerous");
+  }
 
   ctx = xmlSchemaNewDocParserCtxt(doc);
 
@@ -165,8 +226,17 @@ static VALUE from_document(VALUE klass, VALUE document)
   );
 #endif
 
+  if (parse_options_int & XML_PARSE_NONET) {
+    old_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
+  }
+
   schema = xmlSchemaParse(ctx);
 
+  if (old_loader) {
+    xmlSetExternalEntityLoader(old_loader);
+  }
+
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSchemaFreeParserCtxt(ctx);
 
@@ -182,6 +252,7 @@ static VALUE from_document(VALUE klass, VALUE document)
 
   rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
   rb_iv_set(rb_schema, "@errors", errors);
+  rb_iv_set(rb_schema, "@parse_options", parse_options);
 
   return rb_schema;
 
@@ -197,8 +268,8 @@ void init_xml_schema()
 
   cNokogiriXmlSchema = klass;
 
-  rb_define_singleton_method(klass, "read_memory", read_memory, 1);
-  rb_define_singleton_method(klass, "from_document", from_document, 1);
+  rb_define_singleton_method(klass, "read_memory", read_memory, -1);
+  rb_define_singleton_method(klass, "from_document", from_document, -1);
 
   rb_define_private_method(klass, "validate_document", validate_document, 1);
   rb_define_private_method(klass, "validate_file",     validate_file, 1);

data/ext/nokogiri/xml_syntax_error.c

@@ -1,5 +1,28 @@
 #include <xml_syntax_error.h>
 
+void
+Nokogiri_structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state)
+{
+  /* this method is tightly coupled to the implementation of xmlSetStructuredErrorFunc */
+  handler_state->user_data = xmlStructuredErrorContext;
+  handler_state->handler = xmlStructuredError;
+}
+
+void
+Nokogiri_structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state,
+                                            void *user_data,
+                                            xmlStructuredErrorFunc handler)
+{
+  Nokogiri_structured_error_func_save(handler_state);
+  xmlSetStructuredErrorFunc(user_data, handler);
+}
+
+void
+Nokogiri_structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state)
+{
+  xmlSetStructuredErrorFunc(handler_state->user_data, handler_state->handler);
+}
+
 void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error)
 {
   VALUE list = (VALUE)ctx;

data/ext/nokogiri/xml_syntax_error.h

@@ -3,11 +3,23 @@
 
 #include <nokogiri.h>
 
+typedef struct _libxmlStructuredErrorHandlerState {
+  void *user_data;
+  xmlStructuredErrorFunc handler;
+} libxmlStructuredErrorHandlerState ;
+
 void init_xml_syntax_error();
+
+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_error_array_pusher(void *ctx, xmlErrorPtr error);
+NORETURN(void Nokogiri_error_raise(void *ctx, xmlErrorPtr error));
 
 extern VALUE cNokogiriXmlSyntaxError;
-#endif
 
+#endif /* NOKOGIRI_XML_SYNTAX_ERROR */

data/ext/nokogiri/xml_xpath_context.c

@@ -1,6 +1,11 @@
 #include <xml_xpath_context.h>
 
-int vasprintf (char **strp, const char *fmt, va_list ap);
+/*
+ * these constants have matching declarations in
+ * ext/java/nokogiri/internals/NokogiriNamespaceContext.java
+ */
+static const xmlChar *NOKOGIRI_BUILTIN_PREFIX = (const xmlChar *)"nokogiri-builtin";
+static const xmlChar *NOKOGIRI_BUILTIN_URI = (const xmlChar *)"https://www.nokogiri.org/default_ns/ruby/builtins";
 
 static void deallocate(xmlXPathContextPtr ctx)
 {
@@ -9,6 +14,73 @@ static void deallocate(xmlXPathContextPtr ctx)
   NOKOGIRI_DEBUG_END(ctx);
 }
 
+/* find a CSS class in an HTML element's `class` attribute */
+const xmlChar* builtin_css_class(const xmlChar* str, const xmlChar *val)
+{
+  int val_len;
+
+  if (str == NULL) { return(NULL); }
+  if (val == NULL) { return(NULL); }
+
+  val_len = xmlStrlen(val);
+  if (val_len == 0) { return(str); }
+
+  while (*str != 0) {
+    if ((*str == *val) && !xmlStrncmp(str, val, val_len)) {
+      const xmlChar* next_byte = str + val_len;
+
+      /* only match if the next byte is whitespace or end of string */
+      if ((*next_byte == 0) || (IS_BLANK_CH(*next_byte))) {
+        return((const xmlChar*)str);
+      }
+    }
+
+    /* advance str to whitespace */
+    while ((*str != 0) && !IS_BLANK_CH(*str)) {
+      str++;
+    }
+
+    /* advance str to start of next word or end of string */
+    while ((*str != 0) && IS_BLANK_CH(*str)) {
+      str++;
+    }
+  }
+
+  return(NULL);
+}
+
+/* xmlXPathFunction to wrap builtin_css_class() */
+static void xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlXPathObjectPtr hay, needle;
+
+  CHECK_ARITY(2);
+
+  CAST_TO_STRING;
+  needle = valuePop(ctxt);
+  if ((needle == NULL) || (needle->type != XPATH_STRING)) {
+    xmlXPathFreeObject(needle);
+    XP_ERROR(XPATH_INVALID_TYPE);
+  }
+
+  CAST_TO_STRING;
+  hay = valuePop(ctxt);
+  if ((hay == NULL) || (hay->type != XPATH_STRING)) {
+    xmlXPathFreeObject(hay);
+    xmlXPathFreeObject(needle);
+    XP_ERROR(XPATH_INVALID_TYPE);
+  }
+
+  if (builtin_css_class(hay->stringval, needle->stringval)) {
+    valuePush(ctxt, xmlXPathNewBoolean(1));
+  } else {
+    valuePush(ctxt, xmlXPathNewBoolean(0));
+  }
+
+  xmlXPathFreeObject(hay);
+  xmlXPathFreeObject(needle);
+}
+
 /*
  * call-seq:
  *  register_ns(prefix, uri)
@@ -263,14 +335,18 @@ static VALUE new(VALUE klass, VALUE nodeobj)
   xmlXPathContextPtr ctx;
   VALUE self;
 
-  xmlXPathInit();
-
   Data_Get_Struct(nodeobj, xmlNode, node);
 
+  xmlXPathInit();
+
   ctx = xmlXPathNewContext(node->doc);
   ctx->node = node;
+
+  xmlXPathRegisterNs(ctx, NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
+  xmlXPathRegisterFuncNS(ctx, (const xmlChar *)"css-class", NOKOGIRI_BUILTIN_URI,
+                         xpath_builtin_css_class);
+
   self = Data_Wrap_Struct(klass, 0, deallocate, ctx);
-  /*rb_iv_set(self, "@xpath_handler", Qnil); */
   return self;
 }
 

data/ext/nokogiri/xslt_stylesheet.c

@@ -7,9 +7,6 @@
 
 VALUE xslt;
 
-int vasprintf (char **strp, const char *fmt, va_list ap);
-void vasprintf_free (void *p);
-
 static void mark(nokogiriXsltStylesheetTuple *wrapper)
 {
   rb_gc_mark(wrapper->func_instances);
@@ -37,7 +34,7 @@ static void xslt_generic_error_handler(void * ctx, const char *msg, ...)
 
   rb_str_cat2((VALUE)ctx, message);
 
-  vasprintf_free(message);
+  free(message);
 }
 
 VALUE Nokogiri_wrap_xslt_stylesheet(xsltStylesheetPtr ss)

data/lib/nokogiri.rb

@@ -11,7 +11,24 @@ end
 begin
   RUBY_VERSION =~ /(\d+\.\d+)/
   require "nokogiri/#{$1}/nokogiri"
-rescue LoadError
+rescue LoadError => e
+  if e.message =~ /GLIBC/
+    warn <<~EOM
+
+      ERROR: It looks like you're trying to use Nokogiri as a precompiled native gem on a system with glibc < 2.17:
+
+        #{e.message}
+
+        If that's the case, then please install Nokogiri via the `ruby` platform gem:
+            gem install nokogiri --platform=ruby
+        or:
+            bundle config set force_ruby_platform true
+
+        Please visit https://nokogiri.org/tutorials/installing_nokogiri.html for more help.
+
+    EOM
+    raise e
+  end
   require 'nokogiri/nokogiri'
 end
 require 'nokogiri/version'
@@ -37,7 +54,7 @@ require 'nokogiri/html/builder'
 #
 #   # Get a Nokogiri::HTML:Document for the page we’re interested in...
 #
-#   doc = Nokogiri::HTML(open('http://www.google.com/search?q=tenderlove'))
+#   doc = Nokogiri::HTML(URI.open('http://www.google.com/search?q=tenderlove'))
 #
 #   # Do funky things with it using Nokogiri::XML::Node methods...
 #
@@ -113,7 +130,7 @@ module Nokogiri
 end
 
 ###
-# Parser a document contained in +args+.  Nokogiri will try to guess what
+# Parse a document contained in +args+.  Nokogiri will try to guess what
 # type of document you are attempting to parse.  For more information, see
 # Nokogiri.parse
 #