nokogiri 1.16.0 → 1.18.1

data/ext/nokogiri/xml_sax_push_parser.c

@@ -6,14 +6,16 @@ static void
 xml_sax_push_parser_free(void *data)
 {
   xmlParserCtxtPtr ctx = data;
-  if (ctx != NULL) {
-    NOKOGIRI_SAX_TUPLE_DESTROY(ctx->userData);
+  if (ctx->myDoc) {
+    xmlFreeDoc(ctx->myDoc);
+  }
+  if (ctx) {
     xmlFreeParserCtxt(ctx);
   }
 }
 
 static const rb_data_type_t xml_sax_push_parser_type = {
-  .wrap_struct_name = "Nokogiri::XML::SAX::PushParser",
+  .wrap_struct_name = "xmlParserCtxt",
   .function = {
     .dfree = xml_sax_push_parser_free,
   },
@@ -21,7 +23,7 @@ static const rb_data_type_t xml_sax_push_parser_type = {
 };
 
 static VALUE
-allocate(VALUE klass)
+xml_sax_push_parser_allocate(VALUE klass)
 {
   return TypedData_Wrap_Struct(klass, &xml_sax_push_parser_type, NULL);
 }
@@ -35,19 +37,15 @@ noko_xml_sax_push_parser_unwrap(VALUE rb_parser)
 }
 
 /*
- * 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_xml_sax_push_parser__native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
 {
   xmlParserCtxtPtr ctx;
   const char *chunk  = NULL;
   int size            = 0;
 
-
   ctx = noko_xml_sax_push_parser_unwrap(self);
 
   if (Qnil != _chunk) {
@@ -58,9 +56,9 @@ native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
   xmlSetStructuredErrorFunc(NULL, NULL);
 
   if (xmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0)) {
-    if (!(ctx->options & XML_PARSE_RECOVER)) {
+    if (!(xmlCtxtGetOptions(ctx) & XML_PARSE_RECOVER)) {
       xmlErrorConstPtr e = xmlCtxtGetLastError(ctx);
-      Nokogiri_error_raise(NULL, e);
+      noko__error_raise(NULL, e);
     }
   }
 
@@ -74,13 +72,13 @@ native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
  * Initialize the push parser with +xml_sax+ using +filename+
  */
 static VALUE
-initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename)
+noko_xml_sax_push_parser__initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename)
 {
   xmlSAXHandlerPtr sax;
   const char *filename = NULL;
   xmlParserCtxtPtr ctx;
 
-  sax = noko_sax_handler_unwrap(_xml_sax);
+  sax = noko_xml_sax_parser_unwrap(_xml_sax);
 
   if (_filename != Qnil) { filename = StringValueCStr(_filename); }
 
@@ -95,32 +93,34 @@ 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 *)_xml_sax;
 
-  ctx->sax2 = 1;
   DATA_PTR(self) = ctx;
   return self;
 }
 
 static VALUE
-get_options(VALUE self)
+noko_xml_sax_push_parser__options_get(VALUE self)
 {
   xmlParserCtxtPtr ctx;
 
   ctx = noko_xml_sax_push_parser_unwrap(self);
 
-  return INT2NUM(ctx->options);
+  return INT2NUM(xmlCtxtGetOptions(ctx));
 }
 
 static VALUE
-set_options(VALUE self, VALUE options)
+noko_xml_sax_push_parser__options_set(VALUE self, VALUE options)
 {
+  int error;
   xmlParserCtxtPtr ctx;
 
   ctx = noko_xml_sax_push_parser_unwrap(self);
 
-  if (xmlCtxtUseOptions(ctx, (int)NUM2INT(options)) != 0) {
-    rb_raise(rb_eRuntimeError, "Cannot set XML parser context options");
+  error = xmlCtxtSetOptions(ctx, (int)NUM2INT(options));
+  if (error) {
+    rb_raise(rb_eRuntimeError, "Cannot set XML parser context options (%x)", error);
   }
 
   return Qnil;
@@ -128,43 +128,56 @@ set_options(VALUE self, VALUE options)
 
 /*
  * 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?  & 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_push_parser__replace_entities_get(VALUE self)
 {
-  xmlParserCtxtPtr ctx;
-
-  ctx = noko_xml_sax_push_parser_unwrap(self);
+  xmlParserCtxtPtr ctxt = noko_xml_sax_push_parser_unwrap(self);
 
-  if (0 == ctx->replaceEntities) {
-    return Qfalse;
-  } else {
+  if (xmlCtxtGetOptions(ctxt) & XML_PARSE_NOENT) {
     return Qtrue;
+  } else {
+    return Qfalse;
   }
 }
 
 /*
  * 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.
  */
 static VALUE
-set_replace_entities(VALUE self, VALUE value)
+noko_xml_sax_push_parser__replace_entities_set(VALUE self, VALUE value)
 {
-  xmlParserCtxtPtr ctx;
+  int error;
+  xmlParserCtxtPtr ctxt = noko_xml_sax_push_parser_unwrap(self);
 
-  ctx = noko_xml_sax_push_parser_unwrap(self);
-
-  if (Qfalse == value) {
-    ctx->replaceEntities = 0;
+  if (RB_TEST(value)) {
+    error = xmlCtxtSetOptions(ctxt, xmlCtxtGetOptions(ctxt) | XML_PARSE_NOENT);
   } else {
-    ctx->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;
@@ -175,13 +188,19 @@ noko_init_xml_sax_push_parser(void)
 {
   cNokogiriXmlSaxPushParser = rb_define_class_under(mNokogiriXmlSax, "PushParser", rb_cObject);
 
-  rb_define_alloc_func(cNokogiriXmlSaxPushParser, allocate);
-
-  rb_define_method(cNokogiriXmlSaxPushParser, "options", get_options, 0);
-  rb_define_method(cNokogiriXmlSaxPushParser, "options=", set_options, 1);
-  rb_define_method(cNokogiriXmlSaxPushParser, "replace_entities", get_replace_entities, 0);
-  rb_define_method(cNokogiriXmlSaxPushParser, "replace_entities=", set_replace_entities, 1);
-
-  rb_define_private_method(cNokogiriXmlSaxPushParser, "initialize_native", initialize_native, 2);
-  rb_define_private_method(cNokogiriXmlSaxPushParser, "native_write", native_write, 2);
+  rb_define_alloc_func(cNokogiriXmlSaxPushParser, xml_sax_push_parser_allocate);
+
+  rb_define_method(cNokogiriXmlSaxPushParser, "options",
+                   noko_xml_sax_push_parser__options_get, 0);
+  rb_define_method(cNokogiriXmlSaxPushParser, "options=",
+                   noko_xml_sax_push_parser__options_set, 1);
+  rb_define_method(cNokogiriXmlSaxPushParser, "replace_entities",
+                   noko_xml_sax_push_parser__replace_entities_get, 0);
+  rb_define_method(cNokogiriXmlSaxPushParser, "replace_entities=",
+                   noko_xml_sax_push_parser__replace_entities_set, 1);
+
+  rb_define_private_method(cNokogiriXmlSaxPushParser, "initialize_native",
+                           noko_xml_sax_push_parser__initialize_native, 2);
+  rb_define_private_method(cNokogiriXmlSaxPushParser, "native_write",
+                           noko_xml_sax_push_parser__native_write, 2);
 }

data/ext/nokogiri/xml_schema.c

@@ -10,21 +10,15 @@ xml_schema_deallocate(void *data)
 }
 
 static const rb_data_type_t xml_schema_type = {
-  .wrap_struct_name = "Nokogiri::XML::Schema",
+  .wrap_struct_name = "xmlSchema",
   .function = {
     .dfree = xml_schema_deallocate,
   },
   .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
-/*
- * call-seq:
- *  validate_document(document)
- *
- * Validate a Nokogiri::XML::Document against this Schema.
- */
 static VALUE
-validate_document(VALUE self, VALUE document)
+noko_xml_schema__validate_document(VALUE self, VALUE document)
 {
   xmlDocPtr doc;
   xmlSchemaPtr schema;
@@ -43,29 +37,27 @@ validate_document(VALUE self, VALUE document)
     rb_raise(rb_eRuntimeError, "Could not create a validation context");
   }
 
-#ifdef HAVE_XMLSCHEMASETVALIDSTRUCTUREDERRORS
   xmlSchemaSetValidStructuredErrors(
     valid_ctxt,
-    Nokogiri_error_array_pusher,
+    noko__error_array_pusher,
     (void *)errors
   );
-#endif
 
-  xmlSchemaValidateDoc(valid_ctxt, doc);
+  int status = xmlSchemaValidateDoc(valid_ctxt, doc);
 
   xmlSchemaFreeValidCtxt(valid_ctxt);
 
+  if (status != 0) {
+    if (RARRAY_LEN(errors) == 0) {
+      rb_ary_push(errors, rb_str_new2("Could not validate document"));
+    }
+  }
+
   return errors;
 }
 
-/*
- * call-seq:
- *  validate_file(filename)
- *
- * Validate a file against this Schema.
- */
 static VALUE
-validate_file(VALUE self, VALUE rb_filename)
+noko_xml_schema__validate_file(VALUE self, VALUE rb_filename)
 {
   xmlSchemaPtr schema;
   xmlSchemaValidCtxtPtr valid_ctxt;
@@ -84,33 +76,34 @@ validate_file(VALUE self, VALUE rb_filename)
     rb_raise(rb_eRuntimeError, "Could not create a validation context");
   }
 
-#ifdef HAVE_XMLSCHEMASETVALIDSTRUCTUREDERRORS
   xmlSchemaSetValidStructuredErrors(
     valid_ctxt,
-    Nokogiri_error_array_pusher,
+    noko__error_array_pusher,
     (void *)errors
   );
-#endif
 
-  xmlSchemaValidateFile(valid_ctxt, filename, 0);
+  int status = xmlSchemaValidateFile(valid_ctxt, filename, 0);
 
   xmlSchemaFreeValidCtxt(valid_ctxt);
 
+  if (status != 0) {
+    if (RARRAY_LEN(errors) == 0) {
+      rb_ary_push(errors, rb_str_new2("Could not validate file."));
+    }
+  }
+
   return errors;
 }
 
 static VALUE
 xml_schema_parse_schema(
-  VALUE klass,
+  VALUE rb_class,
   xmlSchemaParserCtxtPtr c_parser_context,
   VALUE rb_parse_options
 )
 {
-  VALUE rb_errors;
-  int parse_options_int;
-  xmlSchemaPtr c_schema;
-  xmlExternalEntityLoader old_loader = 0;
-  VALUE rb_schema;
+  xmlExternalEntityLoader saved_loader = 0;
+  libxmlStructuredErrorHandlerState handler_state;
 
   if (NIL_P(rb_parse_options)) {
     rb_parse_options = rb_const_get_at(
@@ -118,45 +111,41 @@ xml_schema_parse_schema(
                          rb_intern("DEFAULT_SCHEMA")
                        );
   }
+  int c_parse_options = (int)NUM2INT(rb_funcall(rb_parse_options, rb_intern("to_i"), 0));
 
-  rb_errors = rb_ary_new();
-  xmlSetStructuredErrorFunc((void *)rb_errors, Nokogiri_error_array_pusher);
+  VALUE rb_errors = rb_ary_new();
+  noko__structured_error_func_save_and_set(&handler_state, (void *)rb_errors, noko__error_array_pusher);
 
-#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
   xmlSchemaSetParserStructuredErrors(
     c_parser_context,
-    Nokogiri_error_array_pusher,
+    noko__error_array_pusher,
     (void *)rb_errors
   );
-#endif
 
-  parse_options_int = (int)NUM2INT(rb_funcall(rb_parse_options, rb_intern("to_i"), 0));
-  if (parse_options_int & XML_PARSE_NONET) {
-    old_loader = xmlGetExternalEntityLoader();
+  if (c_parse_options & XML_PARSE_NONET) {
+    saved_loader = xmlGetExternalEntityLoader();
     xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
   }
 
-  c_schema = xmlSchemaParse(c_parser_context);
+  xmlSchemaPtr c_schema = xmlSchemaParse(c_parser_context);
 
-  if (old_loader) {
-    xmlSetExternalEntityLoader(old_loader);
+  if (saved_loader) {
+    xmlSetExternalEntityLoader(saved_loader);
   }
 
-  xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSchemaFreeParserCtxt(c_parser_context);
+  noko__structured_error_func_restore(&handler_state);
 
   if (NULL == c_schema) {
-    xmlErrorConstPtr error = xmlGetLastError();
-    if (error) {
-      Nokogiri_error_raise(NULL, error);
+    VALUE exception = rb_funcall(cNokogiriXmlSyntaxError, rb_intern("aggregate"), 1, rb_errors);
+    if (RB_TEST(exception)) {
+      rb_exc_raise(exception);
     } else {
       rb_raise(rb_eRuntimeError, "Could not parse document");
     }
-
-    return Qnil;
   }
 
-  rb_schema = TypedData_Wrap_Struct(klass, &xml_schema_type, c_schema);
+  VALUE rb_schema = TypedData_Wrap_Struct(rb_class, &xml_schema_type, c_schema);
   rb_iv_set(rb_schema, "@errors", rb_errors);
   rb_iv_set(rb_schema, "@parse_options", rb_parse_options);
 
@@ -164,47 +153,24 @@ xml_schema_parse_schema(
 }
 
 /*
- * call-seq:
- *   read_memory(string) → Nokogiri::XML::Schema
- *
- * Create a new schema parsed from the contents of +string+
- *
- * [Parameters]
- * - +string+: String containing XML to be parsed as a schema
- *
- * [Returns] Nokogiri::XML::Schema
- */
-static VALUE
-read_memory(int argc, VALUE *argv, VALUE klass)
-{
-  VALUE rb_content;
-  VALUE rb_parse_options;
-  xmlSchemaParserCtxtPtr c_parser_context;
-
-  rb_scan_args(argc, argv, "11", &rb_content, &rb_parse_options);
-
-  c_parser_context = xmlSchemaNewMemParserCtxt(
-                       (const char *)StringValuePtr(rb_content),
-                       (int)RSTRING_LEN(rb_content)
-                     );
-
-  return xml_schema_parse_schema(klass, c_parser_context, rb_parse_options);
-}
-
-/*
- * call-seq:
- *   from_document(document) → Nokogiri::XML::Schema
+ * :call-seq:
+ *   from_document(input) → Nokogiri::XML::Schema
+ *   from_document(input, parse_options) → Nokogiri::XML::Schema
  *
- * Create a new schema parsed from the +document+.
+ * Parse an \XSD schema definition from a Document to create a new Nokogiri::XML::Schema
  *
  * [Parameters]
- * - +document+: Nokogiri::XML::Document to be parsed
+ * - +input+ (XML::Document) A document containing the \XSD schema definition
+ * - +parse_options+ (Nokogiri::XML::ParseOptions)
+ *   Defaults to Nokogiri::XML::ParseOptions::DEFAULT_SCHEMA
  *
  * [Returns] Nokogiri::XML::Schema
  */
 static VALUE
-rb_xml_schema_s_from_document(int argc, VALUE *argv, VALUE klass)
+noko_xml_schema_s_from_document(int argc, VALUE *argv, VALUE rb_class)
 {
+  /* TODO: deprecate this method and put file-or-string logic into .new so that becomes the
+   * preferred entry point, and this can become a private method */
   VALUE rb_document;
   VALUE rb_parse_options;
   VALUE rb_schema;
@@ -236,7 +202,7 @@ rb_xml_schema_s_from_document(int argc, VALUE *argv, VALUE klass)
   }
 
   c_parser_context = xmlSchemaNewDocParserCtxt(c_document);
-  rb_schema = xml_schema_parse_schema(klass, c_parser_context, rb_parse_options);
+  rb_schema = xml_schema_parse_schema(rb_class, c_parser_context, rb_parse_options);
 
   if (defensive_copy_p) {
     xmlFreeDoc(c_document);
@@ -253,9 +219,8 @@ noko_init_xml_schema(void)
 
   rb_undef_alloc_func(cNokogiriXmlSchema);
 
-  rb_define_singleton_method(cNokogiriXmlSchema, "read_memory", read_memory, -1);
-  rb_define_singleton_method(cNokogiriXmlSchema, "from_document", rb_xml_schema_s_from_document, -1);
+  rb_define_singleton_method(cNokogiriXmlSchema, "from_document", noko_xml_schema_s_from_document, -1);
 
-  rb_define_private_method(cNokogiriXmlSchema, "validate_document", validate_document, 1);
-  rb_define_private_method(cNokogiriXmlSchema, "validate_file",     validate_file, 1);
+  rb_define_private_method(cNokogiriXmlSchema, "validate_document", noko_xml_schema__validate_document, 1);
+  rb_define_private_method(cNokogiriXmlSchema, "validate_file",     noko_xml_schema__validate_file, 1);
 }

data/ext/nokogiri/xml_syntax_error.c

@@ -3,7 +3,7 @@
 VALUE cNokogiriXmlSyntaxError;
 
 void
-Nokogiri_structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state)
+noko__structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state)
 {
   /* this method is tightly coupled to the implementation of xmlSetStructuredErrorFunc */
   handler_state->user_data = xmlStructuredErrorContext;
@@ -11,37 +11,40 @@ Nokogiri_structured_error_func_save(libxmlStructuredErrorHandlerState *handler_s
 }
 
 void
-Nokogiri_structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state,
-    void *user_data,
-    xmlStructuredErrorFunc handler)
+noko__structured_error_func_save_and_set(
+  libxmlStructuredErrorHandlerState *handler_state,
+  void *user_data,
+  xmlStructuredErrorFunc handler
+)
 {
-  Nokogiri_structured_error_func_save(handler_state);
+  noko__structured_error_func_save(handler_state);
   xmlSetStructuredErrorFunc(user_data, handler);
 }
 
 void
-Nokogiri_structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state)
+noko__structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state)
 {
   xmlSetStructuredErrorFunc(handler_state->user_data, handler_state->handler);
 }
 
 void
-Nokogiri_error_array_pusher(void *ctx, xmlErrorConstPtr error)
+noko__error_array_pusher(void *ctx, xmlErrorConstPtr error)
 {
   VALUE list = (VALUE)ctx;
   Check_Type(list, T_ARRAY);
-  rb_ary_push(list,  Nokogiri_wrap_xml_syntax_error(error));
+  rb_ary_push(list,  noko_xml_syntax_error__wrap(error));
 }
 
 void
-Nokogiri_error_raise(void *ctx, xmlErrorConstPtr error)
+noko__error_raise(void *ctx, xmlErrorConstPtr error)
 {
-  rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
+  rb_exc_raise(noko_xml_syntax_error__wrap(error));
 }
 
 VALUE
-Nokogiri_wrap_xml_syntax_error(xmlErrorConstPtr error)
+noko_xml_syntax_error__wrap(xmlErrorConstPtr error)
 {
+  xmlChar *c_path ;
   VALUE msg, e, klass;
 
   klass = cNokogiriXmlSyntaxError;
@@ -59,16 +62,21 @@ Nokogiri_wrap_xml_syntax_error(xmlErrorConstPtr error)
       );
 
   if (error) {
+    c_path = xmlGetNodePath(error->node);
+
     rb_iv_set(e, "@domain", INT2NUM(error->domain));
     rb_iv_set(e, "@code", INT2NUM(error->code));
     rb_iv_set(e, "@level", INT2NUM((short)error->level));
     rb_iv_set(e, "@file", RBSTR_OR_QNIL(error->file));
     rb_iv_set(e, "@line", INT2NUM(error->line));
+    rb_iv_set(e, "@path", RBSTR_OR_QNIL(c_path));
     rb_iv_set(e, "@str1", RBSTR_OR_QNIL(error->str1));
     rb_iv_set(e, "@str2", RBSTR_OR_QNIL(error->str2));
     rb_iv_set(e, "@str3", RBSTR_OR_QNIL(error->str3));
     rb_iv_set(e, "@int1", INT2NUM(error->int1));
     rb_iv_set(e, "@column", INT2NUM(error->int2));
+
+    xmlFree(c_path);
   }
 
   return e;

data/ext/nokogiri/xml_text.c

@@ -20,6 +20,7 @@ rb_xml_text_s_new(int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "2*", &rb_string, &rb_document, &rb_rest);
 
+  Check_Type(rb_string, T_STRING);
   if (!rb_obj_is_kind_of(rb_document, cNokogiriXmlNode)) {
     rb_raise(rb_eTypeError,
              "expected second parameter to be a Nokogiri::XML::Document, received %"PRIsVALUE,
@@ -35,11 +36,8 @@ rb_xml_text_s_new(int argc, VALUE *argv, VALUE klass)
     c_document = noko_xml_document_unwrap(rb_document);
   }
 
-  c_node = xmlNewText((xmlChar *)StringValueCStr(rb_string));
-  c_node->doc = c_document;
-
+  c_node = xmlNewDocText(c_document, (xmlChar *)StringValueCStr(rb_string));
   noko_xml_document_pin_node(c_node);
-
   rb_node = noko_xml_node_wrap(klass, c_node) ;
   rb_obj_call_init(rb_node, argc, argv);