nokogiri 1.16.8 → 1.18.2

data/ext/nokogiri/xml_sax_parser_context.c

@@ -5,11 +5,16 @@ VALUE cNokogiriXmlSaxParserContext ;
 static ID id_read;
 
 static void
-xml_sax_parser_context_free(void *data)
+xml_sax_parser_context_type_free(void *data)
 {
   xmlParserCtxtPtr ctxt = data;
   ctxt->sax = NULL;
-  xmlFreeParserCtxt(ctxt);
+  if (ctxt->myDoc) {
+    xmlFreeDoc(ctxt->myDoc);
+  }
+  if (ctxt) {
+    xmlFreeParserCtxt(ctxt);
+  }
 }
 
 /*
@@ -17,9 +22,9 @@ xml_sax_parser_context_free(void *data)
  *  so we use this type for both XML::SAX::ParserContext and HTML::SAX::ParserContext
  */
 static const rb_data_type_t xml_sax_parser_context_type = {
-  .wrap_struct_name = "Nokogiri::XML::SAX::ParserContext",
+  .wrap_struct_name = "xmlParserCtxt",
   .function = {
-    .dfree = xml_sax_parser_context_free,
+    .dfree = xml_sax_parser_context_type_free,
   },
   .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
@@ -38,104 +43,124 @@ noko_xml_sax_parser_context_wrap(VALUE klass, xmlParserCtxtPtr c_context)
   return TypedData_Wrap_Struct(klass, &xml_sax_parser_context_type, c_context);
 }
 
+void
+noko_xml_sax_parser_context_set_encoding(xmlParserCtxtPtr c_context, VALUE rb_encoding)
+{
+  if (!NIL_P(rb_encoding)) {
+    VALUE rb_encoding_name = rb_funcall(rb_encoding, rb_intern("name"), 0);
+
+    char *encoding_name = StringValueCStr(rb_encoding_name);
+    if (encoding_name) {
+      libxmlStructuredErrorHandlerState handler_state;
+      VALUE rb_errors = rb_ary_new();
 
-/*
- * call-seq:
- *  parse_io(io, encoding)
- *
- * Parse +io+ object with +encoding+
- */
+      noko__structured_error_func_save_and_set(&handler_state, (void *)rb_errors, noko__error_array_pusher);
+
+      int result = xmlSwitchEncodingName(c_context, encoding_name);
+
+      noko__structured_error_func_restore(&handler_state);
+
+      if (result != 0) {
+        xmlFreeParserCtxt(c_context);
+
+        VALUE exception = rb_funcall(cNokogiriXmlSyntaxError, rb_intern("aggregate"), 1, rb_errors);
+        if (!NIL_P(exception)) {
+          rb_exc_raise(exception);
+        } else {
+          rb_raise(rb_eRuntimeError, "could not set encoding");
+        }
+      }
+    }
+  }
+}
+
+/* :nodoc: */
 static VALUE
-parse_io(VALUE klass, VALUE io, VALUE encoding)
+noko_xml_sax_parser_context_s_native_io(VALUE rb_class, VALUE rb_io, VALUE rb_encoding)
 {
-  xmlParserCtxtPtr ctxt;
-  xmlCharEncoding enc = (xmlCharEncoding)NUM2INT(encoding);
-
-  if (!rb_respond_to(io, id_read)) {
+  if (!rb_respond_to(rb_io, id_read)) {
     rb_raise(rb_eTypeError, "argument expected to respond to :read");
   }
 
-  ctxt = xmlCreateIOParserCtxt(NULL, NULL,
-                               (xmlInputReadCallback)noko_io_read,
-                               (xmlInputCloseCallback)noko_io_close,
-                               (void *)io, enc);
-  if (!ctxt) {
-    rb_raise(rb_eRuntimeError, "failed to create xml sax parser context");
+  if (!NIL_P(rb_encoding) && !rb_obj_is_kind_of(rb_encoding, rb_cEncoding)) {
+    rb_raise(rb_eTypeError, "argument must be an Encoding object");
   }
 
-  if (ctxt->sax) {
-    xmlFree(ctxt->sax);
-    ctxt->sax = NULL;
+  xmlParserCtxtPtr c_context =
+    xmlCreateIOParserCtxt(NULL, NULL,
+                          (xmlInputReadCallback)noko_io_read,
+                          (xmlInputCloseCallback)noko_io_close,
+                          (void *)rb_io, XML_CHAR_ENCODING_NONE);
+  if (!c_context) {
+    rb_raise(rb_eRuntimeError, "failed to create xml sax parser context");
   }
 
-  return noko_xml_sax_parser_context_wrap(klass, ctxt);
-}
-
-/*
- * call-seq:
- *  parse_file(filename)
- *
- * Parse file given +filename+
- */
-static VALUE
-parse_file(VALUE klass, VALUE filename)
-{
-  xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(StringValueCStr(filename));
+  noko_xml_sax_parser_context_set_encoding(c_context, rb_encoding);
 
-  if (ctxt->sax) {
-    xmlFree(ctxt->sax);
-    ctxt->sax = NULL;
+  if (c_context->sax) {
+    xmlFree(c_context->sax);
+    c_context->sax = NULL;
   }
 
-  return noko_xml_sax_parser_context_wrap(klass, ctxt);
+  VALUE rb_context = noko_xml_sax_parser_context_wrap(rb_class, c_context);
+  rb_iv_set(rb_context, "@input", rb_io);
+
+  return rb_context;
 }
 
-/*
- * call-seq:
- *  parse_memory(data)
- *
- * Parse the XML stored in memory in +data+
- */
+/* :nodoc: */
 static VALUE
-parse_memory(VALUE klass, VALUE data)
+noko_xml_sax_parser_context_s_native_file(VALUE rb_class, VALUE rb_path, VALUE rb_encoding)
 {
-  xmlParserCtxtPtr ctxt;
-
-  Check_Type(data, T_STRING);
+  if (!NIL_P(rb_encoding) && !rb_obj_is_kind_of(rb_encoding, rb_cEncoding)) {
+    rb_raise(rb_eTypeError, "argument must be an Encoding object");
+  }
 
-  if (!(int)RSTRING_LEN(data)) {
-    rb_raise(rb_eRuntimeError, "data cannot be empty");
+  xmlParserCtxtPtr c_context = xmlCreateFileParserCtxt(StringValueCStr(rb_path));
+  if (!c_context) {
+    rb_raise(rb_eRuntimeError, "failed to create xml sax parser context");
   }
 
-  ctxt = xmlCreateMemoryParserCtxt(StringValuePtr(data),
-                                   (int)RSTRING_LEN(data));
-  if (ctxt->sax) {
-    xmlFree(ctxt->sax);
-    ctxt->sax = NULL;
+  noko_xml_sax_parser_context_set_encoding(c_context, rb_encoding);
+
+  if (c_context->sax) {
+    xmlFree(c_context->sax);
+    c_context->sax = NULL;
   }
 
-  return noko_xml_sax_parser_context_wrap(klass, ctxt);
+  return noko_xml_sax_parser_context_wrap(rb_class, c_context);
 }
 
+/* :nodoc: */
 static VALUE
-parse_doc(VALUE ctxt_val)
+noko_xml_sax_parser_context_s_native_memory(VALUE rb_class, VALUE rb_input, VALUE rb_encoding)
 {
-  xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctxt_val;
-  xmlParseDocument(ctxt);
-  return Qnil;
-}
+  Check_Type(rb_input, T_STRING);
+  if (!(int)RSTRING_LEN(rb_input)) {
+    rb_raise(rb_eRuntimeError, "input string cannot be empty");
+  }
 
-static VALUE
-parse_doc_finalize(VALUE ctxt_val)
-{
-  xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctxt_val;
+  if (!NIL_P(rb_encoding) && !rb_obj_is_kind_of(rb_encoding, rb_cEncoding)) {
+    rb_raise(rb_eTypeError, "argument must be an Encoding object");
+  }
 
-  if (NULL != ctxt->myDoc) {
-    xmlFreeDoc(ctxt->myDoc);
+  xmlParserCtxtPtr c_context =
+    xmlCreateMemoryParserCtxt(StringValuePtr(rb_input), (int)RSTRING_LEN(rb_input));
+  if (!c_context) {
+    rb_raise(rb_eRuntimeError, "failed to create xml sax parser context");
   }
 
-  NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
-  return Qnil;
+  noko_xml_sax_parser_context_set_encoding(c_context, rb_encoding);
+
+  if (c_context->sax) {
+    xmlFree(c_context->sax);
+    c_context->sax = NULL;
+  }
+
+  VALUE rb_context = noko_xml_sax_parser_context_wrap(rb_class, c_context);
+  rb_iv_set(rb_context, "@input", rb_input);
+
+  return rb_context;
 }
 
 /*
@@ -143,80 +168,113 @@ parse_doc_finalize(VALUE ctxt_val)
  *  parse_with(sax_handler)
  *
  * Use +sax_handler+ and parse the current document
+ *
+ * 💡 Calling this method directly is discouraged. Use Nokogiri::XML::SAX::Parser methods which are
+ * more convenient for most use cases.
  */
 static VALUE
-parse_with(VALUE self, VALUE sax_handler)
+noko_xml_sax_parser_context__parse_with(VALUE rb_context, VALUE rb_sax_parser)
 {
-  xmlParserCtxtPtr ctxt;
+  xmlParserCtxtPtr c_context;
   xmlSAXHandlerPtr sax;
 
-  if (!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser)) {
+  if (!rb_obj_is_kind_of(rb_sax_parser, cNokogiriXmlSaxParser)) {
     rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
   }
 
-  ctxt = noko_xml_sax_parser_context_unwrap(self);
-  sax = noko_sax_handler_unwrap(sax_handler);
+  c_context = noko_xml_sax_parser_context_unwrap(rb_context);
+  sax = noko_xml_sax_parser_unwrap(rb_sax_parser);
 
-  ctxt->sax = sax;
-  ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
+  c_context->sax = sax;
+  c_context->userData = c_context; /* so we can use libxml2/SAX2.c handlers if we want to */
+  c_context->_private = (void *)rb_sax_parser;
 
   xmlSetStructuredErrorFunc(NULL, NULL);
 
-  rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);
+  /* although we're calling back into Ruby here, we don't need to worry about exceptions, because we
+   * don't have any cleanup to do. The only memory we need to free is handled by
+   * xml_sax_parser_context_type_free */
+  xmlParseDocument(c_context);
 
   return Qnil;
 }
 
 /*
  * call-seq:
- *  replace_entities=(boolean)
+ *   replace_entities=(value)
+ *
+ * See Document@Entity+Handling for an explanation of the behavior controlled by this flag.
+ *
+ * [Parameters]
+ * - +value+ (Boolean) Whether external parsed entities will be resolved.
  *
- * Should this parser replace entities?  & will get converted to '&' if
- * set to true
+ * ⚠ <b>It is UNSAFE to set this option to +true+</b> when parsing untrusted documents. The option
+ * defaults to +false+ for this reason.
+ *
+ * This option is perhaps misnamed by the libxml2 author, since it controls resolution and not
+ * replacement.
+ *
+ * [Example]
+ * Because this class is generally not instantiated directly, you would typically set this option
+ * via the block argument to Nokogiri::XML::SAX::Parser.parse et al:
+ *
+ *     parser = Nokogiri::XML::SAX::Parser.new(document_handler)
+ *     parser.parse(xml) do |ctx|
+ *       ctx.replace_entities = true # this is UNSAFE for untrusted documents!
+ *     end
  */
 static VALUE
-set_replace_entities(VALUE self, VALUE value)
+noko_xml_sax_parser_context__replace_entities_set(VALUE rb_context, VALUE rb_value)
 {
-  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
+  int error;
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(rb_context);
 
-  if (Qfalse == value) {
-    ctxt->replaceEntities = 0;
+  if (RB_TEST(rb_value)) {
+    error = xmlCtxtSetOptions(ctxt, xmlCtxtGetOptions(ctxt) | XML_PARSE_NOENT);
   } else {
-    ctxt->replaceEntities = 1;
+    error = xmlCtxtSetOptions(ctxt, xmlCtxtGetOptions(ctxt) & ~XML_PARSE_NOENT);
+  }
+
+  if (error) {
+    rb_raise(rb_eRuntimeError, "failed to set parser context options (%x)", error);
   }
 
-  return value;
+  return rb_value;
 }
 
 /*
  * call-seq:
- *  replace_entities
+ *   replace_entities
+ *
+ * See Document@Entity+Handling for an explanation of the behavior controlled by this flag.
+ *
+ * [Returns] (Boolean) Value of the parse option. (Default +false+)
  *
- * Should this parser replace entities?  &amp; will get converted to '&' if
- * set to true
+ * This option is perhaps misnamed by the libxml2 author, since it controls resolution and not
+ * replacement.
  */
 static VALUE
-get_replace_entities(VALUE self)
+noko_xml_sax_parser_context__replace_entities_get(VALUE rb_context)
 {
-  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(rb_context);
 
-  if (0 == ctxt->replaceEntities) {
-    return Qfalse;
-  } else {
+  if (xmlCtxtGetOptions(ctxt) & XML_PARSE_NOENT) {
     return Qtrue;
+  } else {
+    return Qfalse;
   }
 }
 
 /*
  * call-seq: line
  *
- * Get the current line the parser context is processing.
+ * [Returns] (Integer) the line number of the line being currently parsed.
  */
 static VALUE
-line(VALUE self)
+noko_xml_sax_parser_context__line(VALUE rb_context)
 {
   xmlParserInputPtr io;
-  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(rb_context);
 
   io = ctxt->input;
   if (io) {
@@ -229,12 +287,12 @@ line(VALUE self)
 /*
  * call-seq: column
  *
- * Get the current column the parser context is processing.
+ * [Returns] (Integer) the column number of the column being currently parsed.
  */
 static VALUE
-column(VALUE self)
+noko_xml_sax_parser_context__column(VALUE rb_context)
 {
-  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(rb_context);
   xmlParserInputPtr io;
 
   io = ctxt->input;
@@ -247,41 +305,66 @@ column(VALUE self)
 
 /*
  * call-seq:
- *  recovery=(boolean)
+ *   recovery=(value)
+ *
+ * Controls whether this parser will recover from parsing errors. If set to +true+, the parser will
+ * invoke the SAX::Document#error callback and continue processing the file. If set to +false+, the
+ * parser will stop processing the file on the first parsing error.
+ *
+ * [Parameters]
+ * - +value+ (Boolean) Recover from parsing errors. (Default is +false+ for XML and +true+ for HTML.)
+ *
+ * [Returns] (Boolean) The passed +value+.
  *
- * Should this parser recover from structural errors? It will not stop processing
- * file on structural errors if set to true
+ * [Example]
+ * Because this class is generally not instantiated directly, you would typically set this option
+ * via the block argument to Nokogiri::XML::SAX::Parser.parse et al:
+ *
+ *     parser = Nokogiri::XML::SAX::Parser.new(document_handler)
+ *     parser.parse(xml) do |ctx|
+ *       ctx.recovery = true
+ *     end
  */
 static VALUE
-set_recovery(VALUE self, VALUE value)
+noko_xml_sax_parser_context__recovery_set(VALUE rb_context, VALUE rb_value)
 {
-  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
+  int error;
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(rb_context);
 
-  if (value == Qfalse) {
-    ctxt->recovery = 0;
+  if (RB_TEST(rb_value)) {
+    error = xmlCtxtSetOptions(ctxt, xmlCtxtGetOptions(ctxt) | XML_PARSE_RECOVER);
   } else {
-    ctxt->recovery = 1;
+    error = xmlCtxtSetOptions(ctxt, xmlCtxtGetOptions(ctxt) & ~XML_PARSE_RECOVER);
+  }
+
+  if (error) {
+    rb_raise(rb_eRuntimeError, "failed to set parser context options (%x)", error);
   }
 
-  return value;
+  return rb_value;
 }
 
 /*
  * call-seq:
- *  recovery
+ *   recovery
+ *
+ * Inspect whether this parser will recover from parsing errors. If set to +true+, the parser will
+ * invoke the SAX::Document#error callback and continue processing the file. If set to +false+, the
+ * parser will stop processing the file on the first parsing error.
+ *
+ * [Returns] (Boolean) Whether this parser will recover from parsing errors.
  *
- * Should this parser recover from structural errors? It will not stop processing
- * file on structural errors if set to true
+ * Default is +false+ for XML and +true+ for HTML.
  */
 static VALUE
-get_recovery(VALUE self)
+noko_xml_sax_parser_context__recovery_get(VALUE rb_context)
 {
-  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(self);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_parser_context_unwrap(rb_context);
 
-  if (ctxt->recovery == 0) {
-    return Qfalse;
-  } else {
+  if (xmlCtxtGetOptions(ctxt) & XML_PARSE_RECOVER) {
     return Qtrue;
+  } else {
+    return Qfalse;
   }
 }
 
@@ -292,17 +375,22 @@ noko_init_xml_sax_parser_context(void)
 
   rb_undef_alloc_func(cNokogiriXmlSaxParserContext);
 
-  rb_define_singleton_method(cNokogiriXmlSaxParserContext, "io", parse_io, 2);
-  rb_define_singleton_method(cNokogiriXmlSaxParserContext, "memory", parse_memory, 1);
-  rb_define_singleton_method(cNokogiriXmlSaxParserContext, "file", parse_file, 1);
-
-  rb_define_method(cNokogiriXmlSaxParserContext, "parse_with", parse_with, 1);
-  rb_define_method(cNokogiriXmlSaxParserContext, "replace_entities=", set_replace_entities, 1);
-  rb_define_method(cNokogiriXmlSaxParserContext, "replace_entities", get_replace_entities, 0);
-  rb_define_method(cNokogiriXmlSaxParserContext, "recovery=", set_recovery, 1);
-  rb_define_method(cNokogiriXmlSaxParserContext, "recovery", get_recovery, 0);
-  rb_define_method(cNokogiriXmlSaxParserContext, "line", line, 0);
-  rb_define_method(cNokogiriXmlSaxParserContext, "column", column, 0);
+  rb_define_singleton_method(cNokogiriXmlSaxParserContext, "native_io",
+                             noko_xml_sax_parser_context_s_native_io, 2);
+  rb_define_singleton_method(cNokogiriXmlSaxParserContext, "native_memory",
+                             noko_xml_sax_parser_context_s_native_memory, 2);
+  rb_define_singleton_method(cNokogiriXmlSaxParserContext, "native_file",
+                             noko_xml_sax_parser_context_s_native_file, 2);
+
+  rb_define_method(cNokogiriXmlSaxParserContext, "parse_with", noko_xml_sax_parser_context__parse_with, 1);
+  rb_define_method(cNokogiriXmlSaxParserContext, "replace_entities=",
+                   noko_xml_sax_parser_context__replace_entities_set, 1);
+  rb_define_method(cNokogiriXmlSaxParserContext, "replace_entities",
+                   noko_xml_sax_parser_context__replace_entities_get, 0);
+  rb_define_method(cNokogiriXmlSaxParserContext, "recovery=", noko_xml_sax_parser_context__recovery_set, 1);
+  rb_define_method(cNokogiriXmlSaxParserContext, "recovery", noko_xml_sax_parser_context__recovery_get, 0);
+  rb_define_method(cNokogiriXmlSaxParserContext, "line", noko_xml_sax_parser_context__line, 0);
+  rb_define_method(cNokogiriXmlSaxParserContext, "column", noko_xml_sax_parser_context__column, 0);
 
   id_read = rb_intern("read");
 }