nokogiri 1.16.8-java → 1.17.0-java

data/ext/nokogiri/html4_sax_push_parser.c

@@ -3,13 +3,10 @@
 VALUE cNokogiriHtml4SaxPushParser;
 
 /*
- * call-seq:
- *  native_write(chunk, last_chunk)
- *
  * Write +chunk+ to PushParser. +last_chunk+ triggers the end_document handle
  */
 static VALUE
-native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
+noko_html4_sax_push_parser__native_write(VALUE self, VALUE rb_chunk, VALUE rb_last_chunk)
 {
   xmlParserCtxtPtr ctx;
   const char *chunk = NULL;
@@ -19,44 +16,45 @@ native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
 
   ctx = noko_xml_sax_push_parser_unwrap(self);
 
-  if (Qnil != _chunk) {
-    chunk = StringValuePtr(_chunk);
-    size = (int)RSTRING_LEN(_chunk);
+  if (Qnil != rb_chunk) {
+    chunk = StringValuePtr(rb_chunk);
+    size = (int)RSTRING_LEN(rb_chunk);
   }
 
-  Nokogiri_structured_error_func_save_and_set(&handler_state, NULL, NULL);
+  noko__structured_error_func_save_and_set(&handler_state, NULL, NULL);
 
-  status = htmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0);
+  status = htmlParseChunk(ctx, chunk, size, Qtrue == rb_last_chunk ? 1 : 0);
 
-  Nokogiri_structured_error_func_restore(&handler_state);
+  noko__structured_error_func_restore(&handler_state);
 
-  if ((status != 0) && !(ctx->options & XML_PARSE_RECOVER)) {
+  if ((status != 0) && !(xmlCtxtGetOptions(ctx) & XML_PARSE_RECOVER)) {
     // TODO: there appear to be no tests for this block
     xmlErrorConstPtr e = xmlCtxtGetLastError(ctx);
-    Nokogiri_error_raise(NULL, e);
+    noko__error_raise(NULL, e);
   }
 
   return self;
 }
 
 /*
- * call-seq:
- *  initialize_native(xml_sax, filename)
- *
  * Initialize the push parser with +xml_sax+ using +filename+
  */
 static VALUE
-initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
-                  VALUE encoding)
+noko_html4_sax_push_parser__initialize_native(
+  VALUE self,
+  VALUE rb_xml_sax,
+  VALUE rb_filename,
+  VALUE encoding
+)
 {
   htmlSAXHandlerPtr sax;
   const char *filename = NULL;
   htmlParserCtxtPtr ctx;
   xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
 
-  sax = noko_sax_handler_unwrap(_xml_sax);
+  sax = noko_xml_sax_parser_unwrap(rb_xml_sax);
 
-  if (_filename != Qnil) { filename = StringValueCStr(_filename); }
+  if (rb_filename != Qnil) { filename = StringValueCStr(rb_filename); }
 
   if (!NIL_P(encoding)) {
     enc = xmlParseCharEncoding(StringValueCStr(encoding));
@@ -77,9 +75,9 @@ initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename,
     rb_raise(rb_eRuntimeError, "Could not create a parser context");
   }
 
-  ctx->userData = NOKOGIRI_SAX_TUPLE_NEW(ctx, self);
+  ctx->userData = ctx;
+  ctx->_private = (void *)rb_xml_sax;
 
-  ctx->sax2 = 1;
   DATA_PTR(self) = ctx;
   return self;
 }
@@ -88,8 +86,11 @@ void
 noko_init_html_sax_push_parser(void)
 {
   assert(cNokogiriXmlSaxPushParser);
-  cNokogiriHtml4SaxPushParser = rb_define_class_under(mNokogiriHtml4Sax, "PushParser", cNokogiriXmlSaxPushParser);
+  cNokogiriHtml4SaxPushParser =
+    rb_define_class_under(mNokogiriHtml4Sax, "PushParser", cNokogiriXmlSaxPushParser);
 
-  rb_define_private_method(cNokogiriHtml4SaxPushParser, "initialize_native", initialize_native, 3);
-  rb_define_private_method(cNokogiriHtml4SaxPushParser, "native_write", native_write, 2);
+  rb_define_private_method(cNokogiriHtml4SaxPushParser, "initialize_native",
+                           noko_html4_sax_push_parser__initialize_native, 3);
+  rb_define_private_method(cNokogiriHtml4SaxPushParser, "native_write",
+                           noko_html4_sax_push_parser__native_write, 2);
 }

data/ext/nokogiri/libxml2_polyfill.c

@@ -0,0 +1,114 @@
+#include <nokogiri.h>
+
+#ifndef HAVE_XMLCTXTSETOPTIONS
+/* based on libxml2-2.14.0-dev (1d8bd126) parser.c xmlCtxtSetInternalOptions */
+int
+xmlCtxtSetOptions(xmlParserCtxtPtr ctxt, int options)
+{
+  int keepMask = 0;
+  int allMask;
+
+  if (ctxt == NULL) {
+    return (-1);
+  }
+
+  /*
+   * XInclude options aren't handled by the parser.
+   *
+   * XML_PARSE_XINCLUDE
+   * XML_PARSE_NOXINCNODE
+   * XML_PARSE_NOBASEFIX
+   */
+  allMask = XML_PARSE_RECOVER |
+            XML_PARSE_NOENT |
+            XML_PARSE_DTDLOAD |
+            XML_PARSE_DTDATTR |
+            XML_PARSE_DTDVALID |
+            XML_PARSE_NOERROR |
+            XML_PARSE_NOWARNING |
+            XML_PARSE_PEDANTIC |
+            XML_PARSE_NOBLANKS |
+#ifdef LIBXML_SAX1_ENABLED
+            XML_PARSE_SAX1 |
+#endif
+            XML_PARSE_NONET |
+            XML_PARSE_NODICT |
+            XML_PARSE_NSCLEAN |
+            XML_PARSE_NOCDATA |
+            XML_PARSE_COMPACT |
+            XML_PARSE_OLD10 |
+            XML_PARSE_HUGE |
+            XML_PARSE_OLDSAX |
+            XML_PARSE_IGNORE_ENC |
+            XML_PARSE_BIG_LINES;
+
+  ctxt->options = (ctxt->options & keepMask) | (options & allMask);
+
+  /*
+   * For some options, struct members are historically the source
+   * of truth. The values are initalized from global variables and
+   * old code could also modify them directly. Several older API
+   * functions that don't take an options argument rely on these
+   * deprecated mechanisms.
+   *
+   * Once public access to struct members and the globals are
+   * disabled, we can use the options bitmask as source of
+   * truth, making all these struct members obsolete.
+   *
+   * The XML_DETECT_IDS flags is misnamed. It simply enables
+   * loading of the external subset.
+   */
+  ctxt->recovery = (options & XML_PARSE_RECOVER) ? 1 : 0;
+  ctxt->replaceEntities = (options & XML_PARSE_NOENT) ? 1 : 0;
+  ctxt->loadsubset = (options & XML_PARSE_DTDLOAD) ? XML_DETECT_IDS : 0;
+  ctxt->loadsubset |= (options & XML_PARSE_DTDATTR) ? XML_COMPLETE_ATTRS : 0;
+  ctxt->validate = (options & XML_PARSE_DTDVALID) ? 1 : 0;
+  ctxt->pedantic = (options & XML_PARSE_PEDANTIC) ? 1 : 0;
+  ctxt->keepBlanks = (options & XML_PARSE_NOBLANKS) ? 0 : 1;
+  ctxt->dictNames = (options & XML_PARSE_NODICT) ? 0 : 1;
+
+  /*
+   * Changing SAX callbacks is a bad idea. This should be fixed.
+   */
+  if (options & XML_PARSE_NOBLANKS) {
+    ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+  }
+  if (options & XML_PARSE_NOCDATA) {
+    ctxt->sax->cdataBlock = NULL;
+  }
+  if (options & XML_PARSE_HUGE) {
+    if (ctxt->dict != NULL) {
+      xmlDictSetLimit(ctxt->dict, 0);
+    }
+  }
+
+  ctxt->linenumbers = 1;
+
+  return (options & ~allMask);
+}
+#endif
+
+#ifndef HAVE_XMLCTXTGETOPTIONS
+int
+xmlCtxtGetOptions(xmlParserCtxtPtr ctxt)
+{
+  return (ctxt->options);
+}
+#endif
+
+#ifndef HAVE_XMLSWITCHENCODINGNAME
+int
+xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding)
+{
+  if (ctxt == NULL) {
+    return (-1);
+  }
+
+  xmlCharEncodingHandlerPtr handler = xmlFindCharEncodingHandler(encoding);
+  if (handler == NULL) {
+    return (-1);
+  }
+
+  return (xmlSwitchToEncoding(ctxt, handler));
+}
+#endif

data/ext/nokogiri/nokogiri.c

@@ -46,6 +46,7 @@ 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_html4_sax_parser(void);
 void noko_init_gumbo(void);
 void noko_init_test_global_handlers(void);
 
@@ -184,8 +185,8 @@ Init_nokogiri(void)
 {
   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");
+  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");
   mNokogiriXmlSax   = rb_define_module_under(mNokogiriXml, "SAX");
@@ -202,6 +203,9 @@ Init_nokogiri(void)
   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));
 
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ZLIB_ENABLED"),
+               xmlHasFeature(XML_WITH_ZLIB) == 1 ? Qtrue : Qfalse);
+
 #ifdef NOKOGIRI_PACKAGED_LIBRARIES
   rb_const_set(mNokogiri, rb_intern("PACKAGED_LIBRARIES"), Qtrue);
 #  ifdef NOKOGIRI_PRECOMPILED_LIBRARIES
@@ -244,7 +248,10 @@ Init_nokogiri(void)
   noko_init_xml_namespace();
   noko_init_xml_node_set();
   noko_init_xml_reader();
+
   noko_init_xml_sax_parser();
+  noko_init_html4_sax_parser();
+
   noko_init_xml_xpath_context();
   noko_init_xslt_stylesheet();
   noko_init_html_element_description();

data/ext/nokogiri/xml_attr.c

@@ -6,7 +6,7 @@ VALUE cNokogiriXmlAttr;
  * call-seq:
  *  value=(content)
  *
- * Set the value for this Attr to +content+. Use `nil` to remove the value
+ * Set the value for this Attr to +content+. Use +nil+ to remove the value
  * (e.g., a HTML boolean attribute).
  */
 static VALUE

data/ext/nokogiri/xml_cdata.c

@@ -20,11 +20,10 @@ rb_xml_cdata_s_new(int argc, VALUE *argv, VALUE klass)
   VALUE rb_content;
   VALUE rb_rest;
   VALUE rb_node;
-  xmlChar *c_content = NULL;
-  int c_content_len = 0;
 
   rb_scan_args(argc, argv, "2*", &rb_document, &rb_content, &rb_rest);
 
+  Check_Type(rb_content, T_STRING);
   if (!rb_obj_is_kind_of(rb_document, cNokogiriXmlNode)) {
     rb_raise(rb_eTypeError,
              "expected first parameter to be a Nokogiri::XML::Document, received %"PRIsVALUE,
@@ -40,15 +39,8 @@ rb_xml_cdata_s_new(int argc, VALUE *argv, VALUE klass)
     c_document = noko_xml_document_unwrap(rb_document);
   }
 
-  if (!NIL_P(rb_content)) {
-    c_content = (xmlChar *)StringValuePtr(rb_content);
-    c_content_len = RSTRING_LENINT(rb_content);
-  }
-
-  c_node = xmlNewCDataBlock(c_document, c_content, c_content_len);
-
+  c_node = xmlNewCDataBlock(c_document, (xmlChar *)StringValueCStr(rb_content), RSTRING_LENINT(rb_content));
   noko_xml_document_pin_node(c_node);
-
   rb_node = noko_xml_node_wrap(klass, c_node);
   rb_obj_call_init(rb_node, argc, argv);
 

data/ext/nokogiri/xml_comment.c

@@ -23,25 +23,20 @@ new (int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &document, &content, &rest);
 
+  Check_Type(content, T_STRING);
   if (rb_obj_is_kind_of(document, cNokogiriXmlNode)) {
     document = rb_funcall(document, document_id, 0);
   } else if (!rb_obj_is_kind_of(document, cNokogiriXmlDocument)
              && !rb_obj_is_kind_of(document, cNokogiriXmlDocumentFragment)) {
     rb_raise(rb_eArgError, "first argument must be a XML::Document or XML::Node");
   }
-
   xml_doc = noko_xml_document_unwrap(document);
 
-  node = xmlNewDocComment(
-           xml_doc,
-           (const xmlChar *)StringValueCStr(content)
-         );
-
+  node = xmlNewDocComment(xml_doc, (const xmlChar *)StringValueCStr(content));
+  noko_xml_document_pin_node(node);
   rb_node = noko_xml_node_wrap(klass, node);
   rb_obj_call_init(rb_node, argc, argv);
 
-  noko_xml_document_pin_node(node);
-
   if (rb_block_given_p()) { rb_yield(rb_node); }
 
   return rb_node;