nokogiri 1.18.0.rc1-aarch64-linux-musl

data/ext/nokogiri/xml_schema.c

@@ -0,0 +1,226 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlSchema;
+
+static void
+xml_schema_deallocate(void *data)
+{
+  xmlSchemaPtr schema = data;
+  xmlSchemaFree(schema);
+}
+
+static const rb_data_type_t xml_schema_type = {
+  .wrap_struct_name = "xmlSchema",
+  .function = {
+    .dfree = xml_schema_deallocate,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static VALUE
+noko_xml_schema__validate_document(VALUE self, VALUE document)
+{
+  xmlDocPtr doc;
+  xmlSchemaPtr schema;
+  xmlSchemaValidCtxtPtr valid_ctxt;
+  VALUE errors;
+
+  TypedData_Get_Struct(self, xmlSchema, &xml_schema_type, schema);
+  doc = noko_xml_document_unwrap(document);
+
+  errors = rb_ary_new();
+
+  valid_ctxt = xmlSchemaNewValidCtxt(schema);
+
+  if (NULL == valid_ctxt) {
+    /* we have a problem */
+    rb_raise(rb_eRuntimeError, "Could not create a validation context");
+  }
+
+  xmlSchemaSetValidStructuredErrors(
+    valid_ctxt,
+    noko__error_array_pusher,
+    (void *)errors
+  );
+
+  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;
+}
+
+static VALUE
+noko_xml_schema__validate_file(VALUE self, VALUE rb_filename)
+{
+  xmlSchemaPtr schema;
+  xmlSchemaValidCtxtPtr valid_ctxt;
+  const char *filename ;
+  VALUE errors;
+
+  TypedData_Get_Struct(self, xmlSchema, &xml_schema_type, schema);
+  filename = (const char *)StringValueCStr(rb_filename) ;
+
+  errors = rb_ary_new();
+
+  valid_ctxt = xmlSchemaNewValidCtxt(schema);
+
+  if (NULL == valid_ctxt) {
+    /* we have a problem */
+    rb_raise(rb_eRuntimeError, "Could not create a validation context");
+  }
+
+  xmlSchemaSetValidStructuredErrors(
+    valid_ctxt,
+    noko__error_array_pusher,
+    (void *)errors
+  );
+
+  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 rb_class,
+  xmlSchemaParserCtxtPtr c_parser_context,
+  VALUE rb_parse_options
+)
+{
+  xmlExternalEntityLoader saved_loader = 0;
+  libxmlStructuredErrorHandlerState handler_state;
+
+  if (NIL_P(rb_parse_options)) {
+    rb_parse_options = rb_const_get_at(
+                         rb_const_get_at(mNokogiriXml, rb_intern("ParseOptions")),
+                         rb_intern("DEFAULT_SCHEMA")
+                       );
+  }
+  int c_parse_options = (int)NUM2INT(rb_funcall(rb_parse_options, rb_intern("to_i"), 0));
+
+  VALUE rb_errors = rb_ary_new();
+  noko__structured_error_func_save_and_set(&handler_state, (void *)rb_errors, noko__error_array_pusher);
+
+  xmlSchemaSetParserStructuredErrors(
+    c_parser_context,
+    noko__error_array_pusher,
+    (void *)rb_errors
+  );
+
+  if (c_parse_options & XML_PARSE_NONET) {
+    saved_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
+  }
+
+  xmlSchemaPtr c_schema = xmlSchemaParse(c_parser_context);
+
+  if (saved_loader) {
+    xmlSetExternalEntityLoader(saved_loader);
+  }
+
+  xmlSchemaFreeParserCtxt(c_parser_context);
+  noko__structured_error_func_restore(&handler_state);
+
+  if (NULL == c_schema) {
+    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");
+    }
+  }
+
+  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);
+
+  return rb_schema;
+}
+
+/*
+ * :call-seq:
+ *   from_document(input) → Nokogiri::XML::Schema
+ *   from_document(input, parse_options) → Nokogiri::XML::Schema
+ *
+ * Parse an \XSD schema definition from a Document to create a new Nokogiri::XML::Schema
+ *
+ * [Parameters]
+ * - +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
+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;
+  xmlDocPtr c_document;
+  xmlSchemaParserCtxtPtr c_parser_context;
+  int defensive_copy_p = 0;
+
+  rb_scan_args(argc, argv, "11", &rb_document, &rb_parse_options);
+
+  if (!rb_obj_is_kind_of(rb_document, cNokogiriXmlNode)) {
+    rb_raise(rb_eTypeError,
+             "expected parameter to be a Nokogiri::XML::Document, received %"PRIsVALUE,
+             rb_obj_class(rb_document));
+  }
+
+  if (!rb_obj_is_kind_of(rb_document, cNokogiriXmlDocument)) {
+    xmlNodePtr deprecated_node_type_arg;
+    NOKO_WARN_DEPRECATION("Passing a Node as the first parameter to Schema.from_document is deprecated. Please pass a Document instead. This will become an error in Nokogiri v1.17.0."); // TODO: deprecated in v1.15.3, remove in v1.17.0
+    Noko_Node_Get_Struct(rb_document, xmlNode, deprecated_node_type_arg);
+    c_document = deprecated_node_type_arg->doc;
+  } else {
+    c_document = noko_xml_document_unwrap(rb_document);
+  }
+
+  if (noko_xml_document_has_wrapped_blank_nodes_p(c_document)) {
+    // see https://github.com/sparklemotion/nokogiri/pull/2001
+    c_document = xmlCopyDoc(c_document, 1);
+    defensive_copy_p = 1;
+  }
+
+  c_parser_context = xmlSchemaNewDocParserCtxt(c_document);
+  rb_schema = xml_schema_parse_schema(rb_class, c_parser_context, rb_parse_options);
+
+  if (defensive_copy_p) {
+    xmlFreeDoc(c_document);
+    c_document = NULL;
+  }
+
+  return rb_schema;
+}
+
+void
+noko_init_xml_schema(void)
+{
+  cNokogiriXmlSchema = rb_define_class_under(mNokogiriXml, "Schema", rb_cObject);
+
+  rb_undef_alloc_func(cNokogiriXmlSchema);
+
+  rb_define_singleton_method(cNokogiriXmlSchema, "from_document", noko_xml_schema_s_from_document, -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

@@ -0,0 +1,93 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlSyntaxError;
+
+void
+noko__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
+noko__structured_error_func_save_and_set(
+  libxmlStructuredErrorHandlerState *handler_state,
+  void *user_data,
+  xmlStructuredErrorFunc handler
+)
+{
+  noko__structured_error_func_save(handler_state);
+  xmlSetStructuredErrorFunc(user_data, handler);
+}
+
+void
+noko__structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state)
+{
+  xmlSetStructuredErrorFunc(handler_state->user_data, handler_state->handler);
+}
+
+void
+noko__error_array_pusher(void *ctx, xmlErrorConstPtr error)
+{
+  VALUE list = (VALUE)ctx;
+  Check_Type(list, T_ARRAY);
+  rb_ary_push(list,  noko_xml_syntax_error__wrap(error));
+}
+
+void
+noko__error_raise(void *ctx, xmlErrorConstPtr error)
+{
+  rb_exc_raise(noko_xml_syntax_error__wrap(error));
+}
+
+VALUE
+noko_xml_syntax_error__wrap(xmlErrorConstPtr error)
+{
+  xmlChar *c_path ;
+  VALUE msg, e, klass;
+
+  klass = cNokogiriXmlSyntaxError;
+
+  if (error && error->domain == XML_FROM_XPATH) {
+    klass = cNokogiriXmlXpathSyntaxError;
+  }
+
+  msg = (error && error->message) ? NOKOGIRI_STR_NEW2(error->message) : Qnil;
+
+  e = rb_class_new_instance(
+        1,
+        &msg,
+        klass
+      );
+
+  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;
+}
+
+void
+noko_init_xml_syntax_error(void)
+{
+  assert(cNokogiriSyntaxError);
+  /*
+   * The XML::SyntaxError is raised on parse errors
+   */
+  cNokogiriXmlSyntaxError = rb_define_class_under(mNokogiriXml, "SyntaxError", cNokogiriSyntaxError);
+}

data/ext/nokogiri/xml_text.c

@@ -0,0 +1,59 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlText ;
+
+/*
+ * call-seq:
+ *  new(content, document)
+ *
+ * Create a new Text element on the +document+ with +content+
+ */
+static VALUE
+rb_xml_text_s_new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr c_document;
+  xmlNodePtr c_node;
+  VALUE rb_string;
+  VALUE rb_document;
+  VALUE rb_rest;
+  VALUE rb_node;
+
+  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,
+             rb_obj_class(rb_document));
+  }
+
+  if (!rb_obj_is_kind_of(rb_document, cNokogiriXmlDocument)) {
+    xmlNodePtr deprecated_node_type_arg;
+    NOKO_WARN_DEPRECATION("Passing a Node as the second parameter to Text.new is deprecated. Please pass a Document instead. This will become an error in Nokogiri v1.17.0."); // TODO: deprecated in v1.15.3, remove in v1.17.0
+    Noko_Node_Get_Struct(rb_document, xmlNode, deprecated_node_type_arg);
+    c_document = deprecated_node_type_arg->doc;
+  } else {
+    c_document = noko_xml_document_unwrap(rb_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);
+
+  if (rb_block_given_p()) { rb_yield(rb_node); }
+
+  return rb_node;
+}
+
+void
+noko_init_xml_text(void)
+{
+  assert(cNokogiriXmlCharacterData);
+  /*
+   * Wraps Text nodes.
+   */
+  cNokogiriXmlText = rb_define_class_under(mNokogiriXml, "Text", cNokogiriXmlCharacterData);
+
+  rb_define_singleton_method(cNokogiriXmlText, "new", rb_xml_text_s_new, -1);
+}