nokogiri 1.10.7 → 1.16.0

data/ext/nokogiri/html4_document.c

@@ -0,0 +1,165 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriHtml4Document ;
+
+static ID id_encoding_found;
+static ID id_to_s;
+
+/*
+ * call-seq:
+ *  new
+ *
+ * Create a new document
+ */
+static VALUE
+rb_html_document_s_new(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE uri, external_id, rest, rb_doc;
+  htmlDocPtr doc;
+
+  rb_scan_args(argc, argv, "0*", &rest);
+  uri = rb_ary_entry(rest, (long)0);
+  external_id = rb_ary_entry(rest, (long)1);
+
+  doc = htmlNewDoc(
+          RTEST(uri) ? (const xmlChar *)StringValueCStr(uri) : NULL,
+          RTEST(external_id) ? (const xmlChar *)StringValueCStr(external_id) : NULL
+        );
+  rb_doc = noko_xml_document_wrap_with_init_args(klass, doc, argc, argv);
+  return rb_doc ;
+}
+
+/*
+ * call-seq:
+ *  read_io(io, url, encoding, options)
+ *
+ * Read the HTML document from +io+ with given +url+, +encoding+,
+ * and +options+.  See Nokogiri::HTML4.parse
+ */
+static VALUE
+rb_html_document_s_read_io(VALUE klass, VALUE rb_io, VALUE rb_url, VALUE rb_encoding, VALUE rb_options)
+{
+  VALUE rb_doc;
+  VALUE rb_error_list = rb_ary_new();
+  htmlDocPtr c_doc;
+  const char *c_url = NIL_P(rb_url) ? NULL : StringValueCStr(rb_url);
+  const char *c_encoding = NIL_P(rb_encoding) ? NULL : StringValueCStr(rb_encoding);
+  int options = NUM2INT(rb_options);
+
+  xmlSetStructuredErrorFunc((void *)rb_error_list, Nokogiri_error_array_pusher);
+
+  c_doc = htmlReadIO(noko_io_read, noko_io_close, (void *)rb_io, c_url, c_encoding, options);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
+  /*
+   * If EncodingFound has occurred in EncodingReader, make sure to do
+   * a cleanup and propagate the error.
+   */
+  if (rb_respond_to(rb_io, id_encoding_found)) {
+    VALUE encoding_found = rb_funcall(rb_io, id_encoding_found, 0);
+    if (!NIL_P(encoding_found)) {
+      xmlFreeDoc(c_doc);
+      rb_exc_raise(encoding_found);
+    }
+  }
+
+  if ((c_doc == NULL) || (!(options & XML_PARSE_RECOVER) && (RARRAY_LEN(rb_error_list) > 0))) {
+    VALUE rb_error ;
+
+    xmlFreeDoc(c_doc);
+
+    rb_error = rb_ary_entry(rb_error_list, 0);
+    if (rb_error == Qnil) {
+      rb_raise(rb_eRuntimeError, "Could not parse document");
+    } else {
+      VALUE exception_message = rb_funcall(rb_error, id_to_s, 0);
+      exception_message = rb_str_concat(rb_str_new2("Parser without recover option encountered error or warning: "),
+                                        exception_message);
+      rb_exc_raise(rb_class_new_instance(1, &exception_message, cNokogiriXmlSyntaxError));
+    }
+
+    return Qnil;
+  }
+
+  rb_doc = noko_xml_document_wrap(klass, c_doc);
+  rb_iv_set(rb_doc, "@errors", rb_error_list);
+  return rb_doc;
+}
+
+/*
+ * call-seq:
+ *  read_memory(string, url, encoding, options)
+ *
+ * Read the HTML document contained in +string+ with given +url+, +encoding+,
+ * and +options+.  See Nokogiri::HTML4.parse
+ */
+static VALUE
+rb_html_document_s_read_memory(VALUE klass, VALUE rb_html, VALUE rb_url, VALUE rb_encoding, VALUE rb_options)
+{
+  VALUE rb_doc;
+  VALUE rb_error_list = rb_ary_new();
+  htmlDocPtr c_doc;
+  const char *c_buffer = StringValuePtr(rb_html);
+  const char *c_url = NIL_P(rb_url) ? NULL : StringValueCStr(rb_url);
+  const char *c_encoding = NIL_P(rb_encoding) ? NULL : StringValueCStr(rb_encoding);
+  int html_len = (int)RSTRING_LEN(rb_html);
+  int options = NUM2INT(rb_options);
+
+  xmlSetStructuredErrorFunc((void *)rb_error_list, Nokogiri_error_array_pusher);
+
+  c_doc = htmlReadMemory(c_buffer, html_len, c_url, c_encoding, options);
+
+  xmlSetStructuredErrorFunc(NULL, NULL);
+
+  if ((c_doc == NULL) || (!(options & XML_PARSE_RECOVER) && (RARRAY_LEN(rb_error_list) > 0))) {
+    VALUE rb_error ;
+
+    xmlFreeDoc(c_doc);
+
+    rb_error = rb_ary_entry(rb_error_list, 0);
+    if (rb_error == Qnil) {
+      rb_raise(rb_eRuntimeError, "Could not parse document");
+    } else {
+      VALUE exception_message = rb_funcall(rb_error, id_to_s, 0);
+      exception_message = rb_str_concat(rb_str_new2("Parser without recover option encountered error or warning: "),
+                                        exception_message);
+      rb_exc_raise(rb_class_new_instance(1, &exception_message, cNokogiriXmlSyntaxError));
+    }
+
+    return Qnil;
+  }
+
+  rb_doc = noko_xml_document_wrap(klass, c_doc);
+  rb_iv_set(rb_doc, "@errors", rb_error_list);
+  return rb_doc;
+}
+
+/*
+ * call-seq:
+ *  type
+ *
+ * The type for this document
+ */
+static VALUE
+rb_html_document_type(VALUE self)
+{
+  htmlDocPtr doc = noko_xml_document_unwrap(self);
+  return INT2NUM(doc->type);
+}
+
+void
+noko_init_html_document(void)
+{
+  assert(cNokogiriXmlDocument);
+  cNokogiriHtml4Document = rb_define_class_under(mNokogiriHtml4, "Document", cNokogiriXmlDocument);
+
+  rb_define_singleton_method(cNokogiriHtml4Document, "read_memory", rb_html_document_s_read_memory, 4);
+  rb_define_singleton_method(cNokogiriHtml4Document, "read_io", rb_html_document_s_read_io, 4);
+  rb_define_singleton_method(cNokogiriHtml4Document, "new", rb_html_document_s_new, -1);
+
+  rb_define_method(cNokogiriHtml4Document, "type", rb_html_document_type, 0);
+
+  id_encoding_found = rb_intern("encoding_found");
+  id_to_s = rb_intern("to_s");
+}

data/ext/nokogiri/html4_element_description.c

@@ -0,0 +1,299 @@
+#include <nokogiri.h>
+
+static const rb_data_type_t html4_element_description_type = {
+  .wrap_struct_name = "Nokogiri::HTML4::ElementDescription",
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+VALUE cNokogiriHtml4ElementDescription ;
+
+/*
+ * call-seq:
+ *  required_attributes
+ *
+ * A list of required attributes for this element
+ */
+static VALUE
+required_attributes(VALUE self)
+{
+  const htmlElemDesc *description;
+  VALUE list;
+  int i;
+
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  list = rb_ary_new();
+
+  if (NULL == description->attrs_req) { return list; }
+
+  for (i = 0; description->attrs_depr[i]; i++) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(description->attrs_req[i]));
+  }
+
+  return list;
+}
+
+/*
+ * call-seq:
+ *  deprecated_attributes
+ *
+ * A list of deprecated attributes for this element
+ */
+static VALUE
+deprecated_attributes(VALUE self)
+{
+  const htmlElemDesc *description;
+  VALUE list;
+  int i;
+
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  list = rb_ary_new();
+
+  if (NULL == description->attrs_depr) { return list; }
+
+  for (i = 0; description->attrs_depr[i]; i++) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(description->attrs_depr[i]));
+  }
+
+  return list;
+}
+
+/*
+ * call-seq:
+ *  optional_attributes
+ *
+ * A list of optional attributes for this element
+ */
+static VALUE
+optional_attributes(VALUE self)
+{
+  const htmlElemDesc *description;
+  VALUE list;
+  int i;
+
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  list = rb_ary_new();
+
+  if (NULL == description->attrs_opt) { return list; }
+
+  for (i = 0; description->attrs_opt[i]; i++) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(description->attrs_opt[i]));
+  }
+
+  return list;
+}
+
+/*
+ * call-seq:
+ *  default_sub_element
+ *
+ * The default sub element for this element
+ */
+static VALUE
+default_sub_element(VALUE self)
+{
+  const htmlElemDesc *description;
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  if (description->defaultsubelt) {
+    return NOKOGIRI_STR_NEW2(description->defaultsubelt);
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  sub_elements
+ *
+ * A list of allowed sub elements for this element.
+ */
+static VALUE
+sub_elements(VALUE self)
+{
+  const htmlElemDesc *description;
+  VALUE list;
+  int i;
+
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  list = rb_ary_new();
+
+  if (NULL == description->subelts) { return list; }
+
+  for (i = 0; description->subelts[i]; i++) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(description->subelts[i]));
+  }
+
+  return list;
+}
+
+/*
+ * call-seq:
+ *  description
+ *
+ * The description for this element
+ */
+static VALUE
+description(VALUE self)
+{
+  const htmlElemDesc *description;
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  return NOKOGIRI_STR_NEW2(description->desc);
+}
+
+/*
+ * call-seq:
+ *  inline?
+ *
+ * Is this element an inline element?
+ */
+static VALUE
+inline_eh(VALUE self)
+{
+  const htmlElemDesc *description;
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  if (description->isinline) { return Qtrue; }
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  deprecated?
+ *
+ * Is this element deprecated?
+ */
+static VALUE
+deprecated_eh(VALUE self)
+{
+  const htmlElemDesc *description;
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  if (description->depr) { return Qtrue; }
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  empty?
+ *
+ * Is this an empty element?
+ */
+static VALUE
+empty_eh(VALUE self)
+{
+  const htmlElemDesc *description;
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  if (description->empty) { return Qtrue; }
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  save_end_tag?
+ *
+ * Should the end tag be saved?
+ */
+static VALUE
+save_end_tag_eh(VALUE self)
+{
+  const htmlElemDesc *description;
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  if (description->saveEndTag) { return Qtrue; }
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  implied_end_tag?
+ *
+ * Can the end tag be implied for this tag?
+ */
+static VALUE
+implied_end_tag_eh(VALUE self)
+{
+  const htmlElemDesc *description;
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  if (description->endTag) { return Qtrue; }
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  implied_start_tag?
+ *
+ * Can the start tag be implied for this tag?
+ */
+static VALUE
+implied_start_tag_eh(VALUE self)
+{
+  const htmlElemDesc *description;
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  if (description->startTag) { return Qtrue; }
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  name
+ *
+ * Get the tag name for this ElemementDescription
+ */
+static VALUE
+name(VALUE self)
+{
+  const htmlElemDesc *description;
+  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+
+  if (NULL == description->name) { return Qnil; }
+  return NOKOGIRI_STR_NEW2(description->name);
+}
+
+/*
+ * call-seq:
+ *  [](tag_name)
+ *
+ * Get ElemementDescription for +tag_name+
+ */
+static VALUE
+get_description(VALUE klass, VALUE tag_name)
+{
+  const htmlElemDesc *description = htmlTagLookup(
+                                      (const xmlChar *)StringValueCStr(tag_name)
+                                    );
+
+  if (NULL == description) { return Qnil; }
+  return TypedData_Wrap_Struct(klass, &html4_element_description_type, DISCARD_CONST_QUAL(void *, description));
+}
+
+void
+noko_init_html_element_description(void)
+{
+  cNokogiriHtml4ElementDescription = rb_define_class_under(mNokogiriHtml4, "ElementDescription", rb_cObject);
+
+  rb_undef_alloc_func(cNokogiriHtml4ElementDescription);
+
+  rb_define_singleton_method(cNokogiriHtml4ElementDescription, "[]", get_description, 1);
+
+  rb_define_method(cNokogiriHtml4ElementDescription, "name", name, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "implied_start_tag?", implied_start_tag_eh, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "implied_end_tag?", implied_end_tag_eh, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "save_end_tag?", save_end_tag_eh, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "empty?", empty_eh, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "deprecated?", deprecated_eh, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "inline?", inline_eh, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "description", description, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "sub_elements", sub_elements, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "default_sub_element", default_sub_element, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "optional_attributes", optional_attributes, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "deprecated_attributes", deprecated_attributes, 0);
+  rb_define_method(cNokogiriHtml4ElementDescription, "required_attributes", required_attributes, 0);
+}

data/ext/nokogiri/html4_entity_lookup.c

@@ -0,0 +1,37 @@
+#include <nokogiri.h>
+
+static VALUE cNokogiriHtml4EntityLookup;
+
+/*
+ * call-seq:
+ *  get(key)
+ *
+ * Get the HTML4::EntityDescription for +key+
+ */
+static VALUE
+get(VALUE _, VALUE rb_entity_name)
+{
+  VALUE cNokogiriHtml4EntityDescription;
+  const htmlEntityDesc *c_entity_desc;
+  VALUE rb_constructor_args[3];
+
+  c_entity_desc = htmlEntityLookup((const xmlChar *)StringValueCStr(rb_entity_name));
+  if (NULL == c_entity_desc) {
+    return Qnil;
+  }
+
+  rb_constructor_args[0] = UINT2NUM(c_entity_desc->value);
+  rb_constructor_args[1] = NOKOGIRI_STR_NEW2(c_entity_desc->name);
+  rb_constructor_args[2] = NOKOGIRI_STR_NEW2(c_entity_desc->desc);
+
+  cNokogiriHtml4EntityDescription = rb_const_get_at(mNokogiriHtml4, rb_intern("EntityDescription"));
+  return rb_class_new_instance(3, rb_constructor_args, cNokogiriHtml4EntityDescription);
+}
+
+void
+noko_init_html_entity_lookup(void)
+{
+  cNokogiriHtml4EntityLookup = rb_define_class_under(mNokogiriHtml4, "EntityLookup", rb_cObject);
+
+  rb_define_method(cNokogiriHtml4EntityLookup, "get", get, 1);
+}

data/ext/nokogiri/html4_sax_parser_context.c

@@ -0,0 +1,108 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriHtml4SaxParserContext ;
+
+static VALUE
+parse_memory(VALUE klass, VALUE data, VALUE encoding)
+{
+  htmlParserCtxtPtr ctxt;
+
+  Check_Type(data, T_STRING);
+
+  if (!(int)RSTRING_LEN(data)) {
+    rb_raise(rb_eRuntimeError, "data cannot be empty");
+  }
+
+  ctxt = htmlCreateMemoryParserCtxt(StringValuePtr(data),
+                                    (int)RSTRING_LEN(data));
+  if (ctxt->sax) {
+    xmlFree(ctxt->sax);
+    ctxt->sax = NULL;
+  }
+
+  if (RTEST(encoding)) {
+    xmlCharEncodingHandlerPtr enc = xmlFindCharEncodingHandler(StringValueCStr(encoding));
+    if (enc != NULL) {
+      xmlSwitchToEncoding(ctxt, enc);
+      if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
+        rb_raise(rb_eRuntimeError, "Unsupported encoding %s",
+                 StringValueCStr(encoding));
+      }
+    }
+  }
+
+  return noko_xml_sax_parser_context_wrap(klass, ctxt);
+}
+
+static VALUE
+parse_file(VALUE klass, VALUE filename, VALUE encoding)
+{
+  htmlParserCtxtPtr ctxt = htmlCreateFileParserCtxt(
+                             StringValueCStr(filename),
+                             StringValueCStr(encoding)
+                           );
+
+  if (ctxt->sax) {
+    xmlFree(ctxt->sax);
+    ctxt->sax = NULL;
+  }
+
+  return noko_xml_sax_parser_context_wrap(klass, ctxt);
+}
+
+static VALUE
+parse_doc(VALUE ctxt_val)
+{
+  htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
+  htmlParseDocument(ctxt);
+  return Qnil;
+}
+
+static VALUE
+parse_doc_finalize(VALUE ctxt_val)
+{
+  htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
+
+  if (ctxt->myDoc) {
+    xmlFreeDoc(ctxt->myDoc);
+  }
+
+  NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
+  return Qnil;
+}
+
+static VALUE
+parse_with(VALUE self, VALUE sax_handler)
+{
+  htmlParserCtxtPtr ctxt;
+  htmlSAXHandlerPtr sax;
+
+  if (!rb_obj_is_kind_of(sax_handler, 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);
+
+  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 self;
+}
+
+void
+noko_init_html_sax_parser_context(void)
+{
+  assert(cNokogiriXmlSaxParserContext);
+  cNokogiriHtml4SaxParserContext = rb_define_class_under(mNokogiriHtml4Sax, "ParserContext",
+                                   cNokogiriXmlSaxParserContext);
+
+  rb_define_singleton_method(cNokogiriHtml4SaxParserContext, "memory", parse_memory, 2);
+  rb_define_singleton_method(cNokogiriHtml4SaxParserContext, "file", parse_file, 2);
+
+  rb_define_method(cNokogiriHtml4SaxParserContext, "parse_with", parse_with, 1);
+}

data/ext/nokogiri/html4_sax_push_parser.c

@@ -0,0 +1,95 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriHtml4SaxPushParser;
+
+/*
+ * 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;
+  int status = 0;
+  libxmlStructuredErrorHandlerState handler_state;
+
+  ctx = noko_xml_sax_push_parser_unwrap(self);
+
+  if (Qnil != _chunk) {
+    chunk = StringValuePtr(_chunk);
+    size = (int)RSTRING_LEN(_chunk);
+  }
+
+  Nokogiri_structured_error_func_save_and_set(&handler_state, NULL, NULL);
+
+  status = htmlParseChunk(ctx, chunk, size, Qtrue == _last_chunk ? 1 : 0);
+
+  Nokogiri_structured_error_func_restore(&handler_state);
+
+  if ((status != 0) && !(ctx->options & XML_PARSE_RECOVER)) {
+    // TODO: there appear to be no tests for this block
+    xmlErrorConstPtr 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,
+                  VALUE encoding)
+{
+  htmlSAXHandlerPtr sax;
+  const char *filename = NULL;
+  htmlParserCtxtPtr ctx;
+  xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
+
+  sax = noko_sax_handler_unwrap(_xml_sax);
+
+  if (_filename != Qnil) { filename = StringValueCStr(_filename); }
+
+  if (!NIL_P(encoding)) {
+    enc = xmlParseCharEncoding(StringValueCStr(encoding));
+    if (enc == XML_CHAR_ENCODING_ERROR) {
+      rb_raise(rb_eArgError, "Unsupported Encoding");
+    }
+  }
+
+  ctx = htmlCreatePushParserCtxt(
+          sax,
+          NULL,
+          NULL,
+          0,
+          filename,
+          enc
+        );
+  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;
+}
+
+void
+noko_init_html_sax_push_parser(void)
+{
+  assert(cNokogiriXmlSaxPushParser);
+  cNokogiriHtml4SaxPushParser = rb_define_class_under(mNokogiriHtml4Sax, "PushParser", cNokogiriXmlSaxPushParser);
+
+  rb_define_private_method(cNokogiriHtml4SaxPushParser, "initialize_native", initialize_native, 3);
+  rb_define_private_method(cNokogiriHtml4SaxPushParser, "native_write", native_write, 2);
+}