nokogiri 1.13.0-x64-mingw-ucrt

data/ext/nokogiri/xml_sax_parser_context.c

@@ -0,0 +1,281 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlSaxParserContext ;
+
+static void
+deallocate(xmlParserCtxtPtr ctxt)
+{
+  NOKOGIRI_DEBUG_START(ctxt);
+
+  ctxt->sax = NULL;
+
+  xmlFreeParserCtxt(ctxt);
+
+  NOKOGIRI_DEBUG_END(ctxt);
+}
+
+/*
+ * call-seq:
+ *  parse_io(io, encoding)
+ *
+ * Parse +io+ object with +encoding+
+ */
+static VALUE
+parse_io(VALUE klass, VALUE io, VALUE encoding)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlCharEncoding enc = (xmlCharEncoding)NUM2INT(encoding);
+
+  ctxt = xmlCreateIOParserCtxt(NULL, NULL,
+                               (xmlInputReadCallback)noko_io_read,
+                               (xmlInputCloseCallback)noko_io_close,
+                               (void *)io, enc);
+  if (ctxt->sax) {
+    xmlFree(ctxt->sax);
+    ctxt->sax = NULL;
+  }
+
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+/*
+ * call-seq:
+ *  parse_file(filename)
+ *
+ * Parse file given +filename+
+ */
+static VALUE
+parse_file(VALUE klass, VALUE filename)
+{
+  xmlParserCtxtPtr ctxt = xmlCreateFileParserCtxt(StringValueCStr(filename));
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+/*
+ * call-seq:
+ *  parse_memory(data)
+ *
+ * Parse the XML stored in memory in +data+
+ */
+static VALUE
+parse_memory(VALUE klass, VALUE data)
+{
+  xmlParserCtxtPtr ctxt;
+
+  if (NIL_P(data)) {
+    rb_raise(rb_eArgError, "data cannot be nil");
+  }
+  if (!(int)RSTRING_LEN(data)) {
+    rb_raise(rb_eRuntimeError, "data cannot be empty");
+  }
+
+  ctxt = xmlCreateMemoryParserCtxt(StringValuePtr(data),
+                                   (int)RSTRING_LEN(data));
+  if (ctxt->sax) {
+    xmlFree(ctxt->sax);
+    ctxt->sax = NULL;
+  }
+
+  return Data_Wrap_Struct(klass, NULL, deallocate, ctxt);
+}
+
+static VALUE
+parse_doc(VALUE ctxt_val)
+{
+  xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctxt_val;
+  xmlParseDocument(ctxt);
+  return Qnil;
+}
+
+static VALUE
+parse_doc_finalize(VALUE ctxt_val)
+{
+  xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctxt_val;
+
+  if (NULL != ctxt->myDoc) {
+    xmlFreeDoc(ctxt->myDoc);
+  }
+
+  NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  parse_with(sax_handler)
+ *
+ * Use +sax_handler+ and parse the current document
+ */
+static VALUE
+parse_with(VALUE self, VALUE sax_handler)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlSAXHandlerPtr sax;
+
+  if (!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser)) {
+    rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::SAX::Parser");
+  }
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+  Data_Get_Struct(sax_handler, xmlSAXHandler, sax);
+
+  /* Free the sax handler since we'll assign our own */
+  if (ctxt->sax && ctxt->sax != (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) {
+    xmlFree(ctxt->sax);
+  }
+
+  ctxt->sax = sax;
+  ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
+  rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  replace_entities=(boolean)
+ *
+ * Should this parser replace entities?  &amp; will get converted to '&' if
+ * set to true
+ */
+static VALUE
+set_replace_entities(VALUE self, VALUE value)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if (Qfalse == value) {
+    ctxt->replaceEntities = 0;
+  } else {
+    ctxt->replaceEntities = 1;
+  }
+
+  return value;
+}
+
+/*
+ * call-seq:
+ *  replace_entities
+ *
+ * Should this parser replace entities?  &amp; will get converted to '&' if
+ * set to true
+ */
+static VALUE
+get_replace_entities(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if (0 == ctxt->replaceEntities) {
+    return Qfalse;
+  } else {
+    return Qtrue;
+  }
+}
+
+/*
+ * call-seq: line
+ *
+ * Get the current line the parser context is processing.
+ */
+static VALUE
+line(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlParserInputPtr io;
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  io = ctxt->input;
+  if (io) {
+    return INT2NUM(io->line);
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq: column
+ *
+ * Get the current column the parser context is processing.
+ */
+static VALUE
+column(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  xmlParserInputPtr io;
+
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  io = ctxt->input;
+  if (io) {
+    return INT2NUM(io->col);
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  recovery=(boolean)
+ *
+ * Should this parser recover from structural errors? It will not stop processing
+ * file on structural errors if set to true
+ */
+static VALUE
+set_recovery(VALUE self, VALUE value)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if (value == Qfalse) {
+    ctxt->recovery = 0;
+  } else {
+    ctxt->recovery = 1;
+  }
+
+  return value;
+}
+
+/*
+ * call-seq:
+ *  recovery
+ *
+ * Should this parser recover from structural errors? It will not stop processing
+ * file on structural errors if set to true
+ */
+static VALUE
+get_recovery(VALUE self)
+{
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(self, xmlParserCtxt, ctxt);
+
+  if (ctxt->recovery == 0) {
+    return Qfalse;
+  } else {
+    return Qtrue;
+  }
+}
+
+void
+noko_init_xml_sax_parser_context()
+{
+  cNokogiriXmlSaxParserContext = rb_define_class_under(mNokogiriXmlSax, "ParserContext", rb_cObject);
+
+  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);
+}

data/ext/nokogiri/xml_sax_push_parser.c

@@ -0,0 +1,168 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlSaxPushParser ;
+
+static void
+deallocate(xmlParserCtxtPtr ctx)
+{
+  NOKOGIRI_DEBUG_START(ctx);
+  if (ctx != NULL) {
+    NOKOGIRI_SAX_TUPLE_DESTROY(ctx->userData);
+    xmlFreeParserCtxt(ctx);
+  }
+  NOKOGIRI_DEBUG_END(ctx);
+}
+
+static VALUE
+allocate(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, NULL, deallocate, NULL);
+}
+
+/*
+ * 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)
+{
+  xmlParserCtxtPtr ctx;
+  const char *chunk  = NULL;
+  int size            = 0;
+
+
+  Data_Get_Struct(self, xmlParserCtxt, ctx);
+
+  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);
+    }
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *  initialize_native(xml_sax, filename)
+ *
+ * Initialize the push parser with +xml_sax+ using +filename+
+ */
+static VALUE
+initialize_native(VALUE self, VALUE _xml_sax, VALUE _filename)
+{
+  xmlSAXHandlerPtr sax;
+  const char *filename = NULL;
+  xmlParserCtxtPtr ctx;
+
+  Data_Get_Struct(_xml_sax, xmlSAXHandler, sax);
+
+  if (_filename != Qnil) { filename = StringValueCStr(_filename); }
+
+  ctx = xmlCreatePushParserCtxt(
+          sax,
+          NULL,
+          NULL,
+          0,
+          filename
+        );
+  if (ctx == NULL) {
+    rb_raise(rb_eRuntimeError, "Could not create a parser context");
+  }
+
+  ctx->userData = NOKOGIRI_SAX_TUPLE_NEW(ctx, self);
+
+  ctx->sax2 = 1;
+  DATA_PTR(self) = ctx;
+  return self;
+}
+
+static VALUE
+get_options(VALUE self)
+{
+  xmlParserCtxtPtr ctx;
+  Data_Get_Struct(self, xmlParserCtxt, ctx);
+
+  return INT2NUM(ctx->options);
+}
+
+static VALUE
+set_options(VALUE self, VALUE options)
+{
+  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");
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  replace_entities
+ *
+ * Should this parser replace entities?  &amp; will get converted to '&' if
+ * set to true
+ */
+static VALUE
+get_replace_entities(VALUE self)
+{
+  xmlParserCtxtPtr ctx;
+  Data_Get_Struct(self, xmlParserCtxt, ctx);
+
+  if (0 == ctx->replaceEntities) {
+    return Qfalse;
+  } else {
+    return Qtrue;
+  }
+}
+
+/*
+ * call-seq:
+ *  replace_entities=(boolean)
+ *
+ * Should this parser replace entities?  &amp; will get converted to '&' if
+ * set to true
+ */
+static VALUE
+set_replace_entities(VALUE self, VALUE value)
+{
+  xmlParserCtxtPtr ctx;
+  Data_Get_Struct(self, xmlParserCtxt, ctx);
+
+  if (Qfalse == value) {
+    ctx->replaceEntities = 0;
+  } else {
+    ctx->replaceEntities = 1;
+  }
+
+  return value;
+}
+
+void
+noko_init_xml_sax_push_parser()
+{
+  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);
+}

data/ext/nokogiri/xml_schema.c

@@ -0,0 +1,284 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlSchema;
+
+static void
+dealloc(xmlSchemaPtr schema)
+{
+  NOKOGIRI_DEBUG_START(schema);
+  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)
+{
+  xmlDocPtr doc;
+  xmlSchemaPtr schema;
+  xmlSchemaValidCtxtPtr valid_ctxt;
+  VALUE errors;
+
+  Data_Get_Struct(self, xmlSchema, schema);
+  Data_Get_Struct(document, xmlDoc, doc);
+
+  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");
+  }
+
+#ifdef HAVE_XMLSCHEMASETVALIDSTRUCTUREDERRORS
+  xmlSchemaSetValidStructuredErrors(
+    valid_ctxt,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  xmlSchemaValidateDoc(valid_ctxt, doc);
+
+  xmlSchemaFreeValidCtxt(valid_ctxt);
+
+  return errors;
+}
+
+/*
+ * call-seq:
+ *  validate_file(filename)
+ *
+ * Validate a file against this Schema.
+ */
+static VALUE
+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) ;
+
+  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");
+  }
+
+#ifdef HAVE_XMLSCHEMASETVALIDSTRUCTUREDERRORS
+  xmlSchemaSetValidStructuredErrors(
+    valid_ctxt,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  xmlSchemaValidateFile(valid_ctxt, filename, 0);
+
+  xmlSchemaFreeValidCtxt(valid_ctxt);
+
+  return errors;
+}
+
+/*
+ * call-seq:
+ *  read_memory(string)
+ *
+ * Create a new Schema from the contents of +string+
+ */
+static VALUE
+read_memory(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE content;
+  VALUE parse_options;
+  int parse_options_int;
+  xmlSchemaParserCtxtPtr ctx;
+  xmlSchemaPtr schema;
+  VALUE errors;
+  VALUE rb_schema;
+  int scanned_args = 0;
+  xmlExternalEntityLoader old_loader = 0;
+
+  scanned_args = rb_scan_args(argc, argv, "11", &content, &parse_options);
+  if (scanned_args == 1) {
+    parse_options = rb_const_get_at(rb_const_get_at(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
+  }
+  parse_options_int = (int)NUM2INT(rb_funcall(parse_options, rb_intern("to_i"), 0));
+
+  ctx = xmlSchemaNewMemParserCtxt((const char *)StringValuePtr(content), (int)RSTRING_LEN(content));
+
+  errors = rb_ary_new();
+  xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
+
+#ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
+  xmlSchemaSetParserStructuredErrors(
+    ctx,
+    Nokogiri_error_array_pusher,
+    (void *)errors
+  );
+#endif
+
+  if (parse_options_int & XML_PARSE_NONET) {
+    old_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
+  }
+
+  schema = xmlSchemaParse(ctx);
+
+  if (old_loader) {
+    xmlSetExternalEntityLoader(old_loader);
+  }
+
+  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;
+  }
+
+  rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
+  rb_iv_set(rb_schema, "@errors", errors);
+  rb_iv_set(rb_schema, "@parse_options", parse_options);
+
+  return rb_schema;
+}
+
+/* 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;
+
+  if (NIL_P(cache)) {
+    return 0;
+  }
+
+  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;
+    }
+  }
+
+  return 0;
+}
+
+/*
+ * call-seq:
+ *  from_document(doc)
+ *
+ * Create a new Schema from the Nokogiri::XML::Document +doc+
+ */
+static VALUE
+from_document(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE document;
+  VALUE parse_options;
+  int parse_options_int;
+  xmlDocPtr doc;
+  xmlSchemaParserCtxtPtr ctx;
+  xmlSchemaPtr schema;
+  VALUE errors;
+  VALUE rb_schema;
+  int scanned_args = 0;
+  xmlExternalEntityLoader old_loader = 0;
+
+  scanned_args = rb_scan_args(argc, argv, "11", &document, &parse_options);
+
+  Data_Get_Struct(document, xmlDoc, doc);
+  doc = doc->doc; /* In case someone passes us a node. ugh. */
+
+  if (scanned_args == 1) {
+    parse_options = rb_const_get_at(rb_const_get_at(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
+  }
+  parse_options_int = (int)NUM2INT(rb_funcall(parse_options, rb_intern("to_i"), 0));
+
+  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");
+  }
+
+  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
+
+  if (parse_options_int & XML_PARSE_NONET) {
+    old_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
+  }
+
+  schema = xmlSchemaParse(ctx);
+
+  if (old_loader) {
+    xmlSetExternalEntityLoader(old_loader);
+  }
+
+  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;
+  }
+
+  rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
+  rb_iv_set(rb_schema, "@errors", errors);
+  rb_iv_set(rb_schema, "@parse_options", parse_options);
+
+  return rb_schema;
+
+  return Qnil;
+}
+
+void
+noko_init_xml_schema()
+{
+  cNokogiriXmlSchema = rb_define_class_under(mNokogiriXml, "Schema", rb_cObject);
+
+  rb_undef_alloc_func(cNokogiriXmlSchema);
+
+  rb_define_singleton_method(cNokogiriXmlSchema, "read_memory", read_memory, -1);
+  rb_define_singleton_method(cNokogiriXmlSchema, "from_document", from_document, -1);
+
+  rb_define_private_method(cNokogiriXmlSchema, "validate_document", validate_document, 1);
+  rb_define_private_method(cNokogiriXmlSchema, "validate_file",     validate_file, 1);
+}