nokogiri 1.16.8-arm-linux → 1.17.0-arm-linux

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/nokogiri.h

@@ -56,11 +56,15 @@
 
 #include <libexslt/exslt.h>
 
-/* libxml2_backwards_compat.c */
-#ifndef HAVE_XMLFIRSTELEMENTCHILD
-xmlNodePtr xmlFirstElementChild(xmlNodePtr parent);
-xmlNodePtr xmlNextElementSibling(xmlNodePtr node);
-xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
+/* libxml2_polyfill.c */
+#ifndef HAVE_XMLCTXTSETOPTIONS
+int xmlCtxtSetOptions(xmlParserCtxtPtr ctxt, int options);
+#endif
+#ifndef HAVE_XMLCTXTGETOPTIONS
+int xmlCtxtGetOptions(xmlParserCtxtPtr ctxt);
+#endif
+#ifndef HAVE_XMLSWITCHENCODINGNAME
+int xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding);
 #endif
 
 #define XMLNS_PREFIX "xmlns"
@@ -148,6 +152,7 @@ NOKOPUBVAR VALUE cNokogiriXsltStylesheet ;
 NOKOPUBVAR VALUE cNokogiriHtml4Document ;
 NOKOPUBVAR VALUE cNokogiriHtml4SaxPushParser ;
 NOKOPUBVAR VALUE cNokogiriHtml4ElementDescription ;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxParser;
 NOKOPUBVAR VALUE cNokogiriHtml4SaxParserContext;
 NOKOPUBVAR VALUE cNokogiriHtml5Document ;
 
@@ -158,12 +163,6 @@ typedef struct _nokogiriTuple {
 } nokogiriTuple;
 typedef nokogiriTuple *nokogiriTuplePtr;
 
-typedef struct _nokogiriSAXTuple {
-  xmlParserCtxtPtr  ctxt;
-  VALUE             self;
-} nokogiriSAXTuple;
-typedef nokogiriSAXTuple *nokogiriSAXTuplePtr;
-
 typedef struct _libxmlStructuredErrorHandlerState {
   void *user_data;
   xmlStructuredErrorFunc handler;
@@ -203,12 +202,13 @@ xmlDocPtr noko_xml_document_unwrap(VALUE rb_document);
 NOKOPUBFUN VALUE Nokogiri_wrap_xml_document(VALUE klass,
     xmlDocPtr doc); /* deprecated. use noko_xml_document_wrap() instead. */
 
-xmlSAXHandlerPtr noko_sax_handler_unwrap(VALUE rb_sax_handler);
+xmlSAXHandlerPtr noko_xml_sax_parser_unwrap(VALUE rb_sax_handler);
 
 xmlParserCtxtPtr noko_xml_sax_push_parser_unwrap(VALUE rb_parser);
 
 VALUE noko_xml_sax_parser_context_wrap(VALUE klass, xmlParserCtxtPtr c_context);
 xmlParserCtxtPtr noko_xml_sax_parser_context_unwrap(VALUE rb_context);
+void noko_xml_sax_parser_context_set_encoding(xmlParserCtxtPtr c_context, VALUE rb_encoding);
 
 #define DOC_RUBY_OBJECT_TEST(x) ((nokogiriTuplePtr)(x->_private))
 #define DOC_RUBY_OBJECT(x) (((nokogiriTuplePtr)(x->_private))->doc)
@@ -216,11 +216,6 @@ xmlParserCtxtPtr noko_xml_sax_parser_context_unwrap(VALUE rb_context);
 #define DOC_NODE_CACHE(x) (((nokogiriTuplePtr)(x->_private))->node_cache)
 #define NOKOGIRI_NAMESPACE_EH(node) ((node)->type == XML_NAMESPACE_DECL)
 
-#define NOKOGIRI_SAX_SELF(_ctxt) ((nokogiriSAXTuplePtr)(_ctxt))->self
-#define NOKOGIRI_SAX_CTXT(_ctxt) ((nokogiriSAXTuplePtr)(_ctxt))->ctxt
-#define NOKOGIRI_SAX_TUPLE_NEW(_ctxt, _self) nokogiri_sax_tuple_new(_ctxt, _self)
-#define NOKOGIRI_SAX_TUPLE_DESTROY(_tuple) ruby_xfree(_tuple)
-
 #define DISCARD_CONST_QUAL(t, v) ((t)(uintptr_t)(v))
 #define DISCARD_CONST_QUAL_XMLCHAR(v) DISCARD_CONST_QUAL(xmlChar *, v)
 
@@ -230,24 +225,14 @@ xmlParserCtxtPtr noko_xml_sax_parser_context_unwrap(VALUE rb_context);
 #  define NOKO_WARN_DEPRECATION(message...) rb_warning(message)
 #endif
 
-void Nokogiri_structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state);
-void Nokogiri_structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state, void *user_data,
+void noko__structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state);
+void noko__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(xmlErrorConstPtr error);
-void Nokogiri_error_array_pusher(void *ctx, xmlErrorConstPtr error);
-NORETURN_DECL void Nokogiri_error_raise(void *ctx, xmlErrorConstPtr error);
+void noko__structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state);
+VALUE noko_xml_syntax_error__wrap(xmlErrorConstPtr error);
+void noko__error_array_pusher(void *ctx, xmlErrorConstPtr error);
+NORETURN_DECL void noko__error_raise(void *ctx, xmlErrorConstPtr error);
 void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler,
     const char *function_name) ;
 
-static inline
-nokogiriSAXTuplePtr
-nokogiri_sax_tuple_new(xmlParserCtxtPtr ctxt, VALUE self)
-{
-  nokogiriSAXTuplePtr tuple = ruby_xmalloc(sizeof(nokogiriSAXTuple));
-  tuple->self = self;
-  tuple->ctxt = ctxt;
-  return tuple;
-}
-
 #endif /* NOKOGIRI_NATIVE */

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;