nokogiri 1.10.9 → 1.18.3

data/ext/nokogiri/xml_sax_push_parser.c

@@ -1,44 +1,64 @@
-#include <xml_sax_push_parser.h>
+#include <nokogiri.h>
 
-static void deallocate(xmlParserCtxtPtr ctx)
+VALUE cNokogiriXmlSaxPushParser ;
+
+static void
+xml_sax_push_parser_free(void *data)
 {
-  NOKOGIRI_DEBUG_START(ctx);
-  if (ctx != NULL) {
-    NOKOGIRI_SAX_TUPLE_DESTROY(ctx->userData);
+  xmlParserCtxtPtr ctx = data;
+  if (ctx->myDoc) {
+    xmlFreeDoc(ctx->myDoc);
+  }
+  if (ctx) {
     xmlFreeParserCtxt(ctx);
   }
-  NOKOGIRI_DEBUG_END(ctx);
 }
 
-static VALUE allocate(VALUE klass)
+static const rb_data_type_t xml_sax_push_parser_type = {
+  .wrap_struct_name = "xmlParserCtxt",
+  .function = {
+    .dfree = xml_sax_push_parser_free,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static VALUE
+xml_sax_push_parser_allocate(VALUE klass)
+{
+  return TypedData_Wrap_Struct(klass, &xml_sax_push_parser_type, NULL);
+}
+
+xmlParserCtxtPtr
+noko_xml_sax_push_parser_unwrap(VALUE rb_parser)
 {
-  return Data_Wrap_Struct(klass, NULL, deallocate, NULL);
+  xmlParserCtxtPtr c_parser;
+  TypedData_Get_Struct(rb_parser, xmlParserCtxt, &xml_sax_push_parser_type, c_parser);
+  return c_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)
+static VALUE
+noko_xml_sax_push_parser__native_write(VALUE self, VALUE _chunk, VALUE _last_chunk)
 {
   xmlParserCtxtPtr ctx;
-  const char * chunk  = NULL;
+  const char *chunk  = NULL;
   int size            = 0;
 
-
-  Data_Get_Struct(self, xmlParserCtxt, ctx);
+  ctx = noko_xml_sax_push_parser_unwrap(self);
 
   if (Qnil != _chunk) {
     chunk = StringValuePtr(_chunk);
     size = (int)RSTRING_LEN(_chunk);
   }
 
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
   if (xmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0)) {
-    if (!(ctx->options & XML_PARSE_RECOVER)) {
-      xmlErrorPtr e = xmlCtxtGetLastError(ctx);
-      Nokogiri_error_raise(NULL, e);
+    if (!(xmlCtxtGetOptions(ctx) & XML_PARSE_RECOVER)) {
+      xmlErrorConstPtr e = xmlCtxtGetLastError(ctx);
+      noko__error_raise(NULL, e);
     }
   }
 
@@ -51,13 +71,14 @@ static VALUE 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)
+static VALUE
+noko_xml_sax_push_parser__initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename)
 {
   xmlSAXHandlerPtr sax;
-  const char * filename = NULL;
+  const char *filename = NULL;
   xmlParserCtxtPtr ctx;
 
-  Data_Get_Struct(_xml_sax, xmlSAXHandler, sax);
+  sax = noko_xml_sax_parser_unwrap(_xml_sax);
 
   if (_filename != Qnil) { filename = StringValueCStr(_filename); }
 
@@ -72,28 +93,34 @@ static VALUE 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)
+static VALUE
+noko_xml_sax_push_parser__options_get(VALUE self)
 {
   xmlParserCtxtPtr ctx;
-  Data_Get_Struct(self, xmlParserCtxt, ctx);
 
-  return INT2NUM(ctx->options);
+  ctx = noko_xml_sax_push_parser_unwrap(self);
+
+  return INT2NUM(xmlCtxtGetOptions(ctx));
 }
 
-static VALUE set_options(VALUE self, VALUE options)
+static VALUE
+noko_xml_sax_push_parser__options_set(VALUE self, VALUE options)
 {
+  int error;
   xmlParserCtxtPtr ctx;
-  Data_Get_Struct(self, xmlParserCtxt, ctx);
 
-  if (xmlCtxtUseOptions(ctx, (int)NUM2INT(options)) != 0) {
-    rb_raise(rb_eRuntimeError, "Cannot set XML parser context options");
+  ctx = noko_xml_sax_push_parser_unwrap(self);
+
+  error = xmlCtxtSetOptions(ctx, (int)NUM2INT(options));
+  if (error) {
+    rb_raise(rb_eRuntimeError, "Cannot set XML parser context options (%x)", error);
   }
 
   return Qnil;
@@ -101,59 +128,79 @@ static VALUE 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.
  *
- * Should this parser replace entities?  &amp; will get converted to '&' if
- * set to true
+ * [Returns] (Boolean) Value of the parse option. (Default +false+)
+ *
+ * This option is perhaps misnamed by the libxml2 author, since it controls resolution and not
+ * replacement.
  */
-static VALUE get_replace_entities(VALUE self)
+static VALUE
+noko_xml_sax_push_parser__replace_entities_get(VALUE self)
 {
-  xmlParserCtxtPtr ctx;
-  Data_Get_Struct(self, xmlParserCtxt, ctx);
+  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.
  *
- * Should this parser replace entities?  &amp; will get converted to '&' if
- * set to true
+ * [Parameters]
+ * - +value+ (Boolean) Whether external parsed entities will be resolved.
+ *
+ * ⚠ <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)
+static VALUE
+noko_xml_sax_push_parser__replace_entities_set(VALUE self, VALUE value)
 {
-  xmlParserCtxtPtr ctx;
-  Data_Get_Struct(self, xmlParserCtxt, ctx);
+  int error;
+  xmlParserCtxtPtr ctxt = 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;
 }
 
-VALUE cNokogiriXmlSaxPushParser ;
-void init_xml_sax_push_parser()
+void
+noko_init_xml_sax_push_parser(void)
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-  VALUE sax = rb_define_module_under(xml, "SAX");
-  VALUE klass = rb_define_class_under(sax, "PushParser", rb_cObject);
-
-  cNokogiriXmlSaxPushParser = klass;
-
-  rb_define_alloc_func(klass, allocate);
-  rb_define_private_method(klass, "initialize_native", initialize_native, 2);
-  rb_define_private_method(klass, "native_write", native_write, 2);
-  rb_define_method(klass, "options", get_options, 0);
-  rb_define_method(klass, "options=", set_options, 1);
-  rb_define_method(klass, "replace_entities", get_replace_entities, 0);
-  rb_define_method(klass, "replace_entities=", set_replace_entities, 1);
+  cNokogiriXmlSaxPushParser = rb_define_class_under(mNokogiriXmlSax, "PushParser", rb_cObject);
+
+  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

@@ -1,234 +1,226 @@
-#include <xml_schema.h>
+#include <nokogiri.h>
 
-static void dealloc(xmlSchemaPtr schema)
+VALUE cNokogiriXmlSchema;
+
+static void
+xml_schema_deallocate(void *data)
 {
-  NOKOGIRI_DEBUG_START(schema);
+  xmlSchemaPtr schema = data;
   xmlSchemaFree(schema);
-  NOKOGIRI_DEBUG_END(schema);
 }
 
-/*
- * call-seq:
- *  validate_document(document)
- *
- * Validate a Nokogiri::XML::Document against this Schema.
- */
-static VALUE validate_document(VALUE self, VALUE document)
+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;
 
-  Data_Get_Struct(self, xmlSchema, schema);
-  Data_Get_Struct(document, xmlDoc, doc);
+  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) {
+  if (NULL == valid_ctxt) {
     /* we have a problem */
     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)
+static VALUE
+noko_xml_schema__validate_file(VALUE self, VALUE rb_filename)
 {
   xmlSchemaPtr schema;
   xmlSchemaValidCtxtPtr valid_ctxt;
   const char *filename ;
   VALUE errors;
 
-  Data_Get_Struct(self, xmlSchema, schema);
-  filename = (const char*)StringValueCStr(rb_filename) ;
+  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) {
+  if (NULL == valid_ctxt) {
     /* we have a problem */
     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;
 }
 
-/*
- * call-seq:
- *  read_memory(string)
- *
- * Create a new Schema from the contents of +string+
- */
-static VALUE read_memory(VALUE klass, VALUE content)
+static VALUE
+xml_schema_parse_schema(
+  VALUE rb_class,
+  xmlSchemaParserCtxtPtr c_parser_context,
+  VALUE rb_parse_options
+)
 {
-  xmlSchemaPtr schema;
-  xmlSchemaParserCtxtPtr ctx = xmlSchemaNewMemParserCtxt(
-      (const char *)StringValuePtr(content),
-      (int)RSTRING_LEN(content)
-  );
-  VALUE rb_schema;
-  VALUE errors = rb_ary_new();
-  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+  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);
 
-#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
   xmlSchemaSetParserStructuredErrors(
-    ctx,
-    Nokogiri_error_array_pusher,
-    (void *)errors
+    c_parser_context,
+    noko__error_array_pusher,
+    (void *)rb_errors
   );
-#endif
-
-   schema = xmlSchemaParse(ctx);
-
-  xmlSetStructuredErrorFunc(NULL, NULL);
-  xmlSchemaFreeParserCtxt(ctx);
-
-  if(NULL == schema) {
-    xmlErrorPtr error = xmlGetLastError();
-    if(error)
-      Nokogiri_error_raise(NULL, error);
-    else
-      rb_raise(rb_eRuntimeError, "Could not parse document");
 
-    return Qnil;
+  if (c_parse_options & XML_PARSE_NONET) {
+    saved_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
   }
 
-  rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
-  rb_iv_set(rb_schema, "@errors", errors);
+  xmlSchemaPtr c_schema = xmlSchemaParse(c_parser_context);
 
-  return rb_schema;
-}
+  if (saved_loader) {
+    xmlSetExternalEntityLoader(saved_loader);
+  }
 
-/* Schema creation will remove and deallocate "blank" nodes.
- * If those blank nodes have been exposed to Ruby, they could get freed
- * out from under the VALUE pointer.  This function checks to see if any of
- * those nodes have been exposed to Ruby, and if so we should raise an exception.
- */
-static int has_blank_nodes_p(VALUE cache)
-{
-    long i;
+  xmlSchemaFreeParserCtxt(c_parser_context);
+  noko__structured_error_func_restore(&handler_state);
 
-    if (NIL_P(cache)) {
-        return 0;
+  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");
     }
+  }
 
-    for (i = 0; i < RARRAY_LEN(cache); i++) {
-        xmlNodePtr node;
-        VALUE element = rb_ary_entry(cache, i);
-        Data_Get_Struct(element, xmlNode, node);
-        if (xmlIsBlankNode(node)) {
-            return 1;
-        }
-    }
+  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 0;
+  return rb_schema;
 }
 
 /*
- * call-seq:
- *  from_document(doc)
+ * :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
  *
- * Create a new Schema from the Nokogiri::XML::Document +doc+
+ * [Returns] Nokogiri::XML::Schema
  */
-static VALUE from_document(VALUE klass, VALUE document)
+static VALUE
+noko_xml_schema_s_from_document(int argc, VALUE *argv, VALUE rb_class)
 {
-  xmlDocPtr doc;
-  xmlSchemaParserCtxtPtr ctx;
-  xmlSchemaPtr schema;
-  VALUE errors;
+  /* 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;
 
-  Data_Get_Struct(document, xmlDoc, doc);
+  rb_scan_args(argc, argv, "11", &rb_document, &rb_parse_options);
 
-  /* In case someone passes us a node. ugh. */
-  doc = doc->doc;
-
-  if (has_blank_nodes_p(DOC_NODE_CACHE(doc))) {
-    rb_raise(rb_eArgError, "Creating a schema from a document that has blank nodes exposed to Ruby is dangerous");
+  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));
   }
 
-  ctx = xmlSchemaNewDocParserCtxt(doc);
-
-  errors = rb_ary_new();
-  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
-
-#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
-  xmlSchemaSetParserStructuredErrors(
-    ctx,
-    Nokogiri_error_array_pusher,
-    (void *)errors
-  );
-#endif
-
-  schema = xmlSchemaParse(ctx);
+  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);
+  }
 
-  xmlSetStructuredErrorFunc(NULL, NULL);
-  xmlSchemaFreeParserCtxt(ctx);
+  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;
+  }
 
-  if(NULL == schema) {
-    xmlErrorPtr error = xmlGetLastError();
-    if(error)
-      Nokogiri_error_raise(NULL, error);
-    else
-      rb_raise(rb_eRuntimeError, "Could not parse document");
+  c_parser_context = xmlSchemaNewDocParserCtxt(c_document);
+  rb_schema = xml_schema_parse_schema(rb_class, c_parser_context, rb_parse_options);
 
-    return Qnil;
+  if (defensive_copy_p) {
+    xmlFreeDoc(c_document);
+    c_document = NULL;
   }
 
-  rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
-  rb_iv_set(rb_schema, "@errors", errors);
-
   return rb_schema;
-
-  return Qnil;
 }
 
-VALUE cNokogiriXmlSchema;
-void init_xml_schema()
+void
+noko_init_xml_schema(void)
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-  VALUE klass = rb_define_class_under(xml, "Schema", rb_cObject);
+  cNokogiriXmlSchema = rb_define_class_under(mNokogiriXml, "Schema", rb_cObject);
 
-  cNokogiriXmlSchema = klass;
+  rb_undef_alloc_func(cNokogiriXmlSchema);
 
-  rb_define_singleton_method(klass, "read_memory", read_memory, 1);
-  rb_define_singleton_method(klass, "from_document", from_document, 1);
+  rb_define_singleton_method(cNokogiriXmlSchema, "from_document", noko_xml_schema_s_from_document, -1);
 
-  rb_define_private_method(klass, "validate_document", validate_document, 1);
-  rb_define_private_method(klass, "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);
 }