nokogiri 1.16.8-x86_64-linux → 1.17.0-x86_64-linux

data/ext/nokogiri/gumbo.c

@@ -37,30 +37,6 @@ VALUE cNokogiriHtml5Document;
 static ID internal_subset;
 static ID parent;
 
-/* Backwards compatibility to Ruby 2.1.0 */
-#if RUBY_API_VERSION_CODE < 20200
-#define ONIG_ESCAPE_UCHAR_COLLISION 1
-#include <ruby/encoding.h>
-
-static VALUE
-rb_utf8_str_new(const char *str, long length)
-{
-  return rb_enc_str_new(str, length, rb_utf8_encoding());
-}
-
-static VALUE
-rb_utf8_str_new_cstr(const char *str)
-{
-  return rb_enc_str_new_cstr(str, rb_utf8_encoding());
-}
-
-static VALUE
-rb_utf8_str_new_static(const char *str, long length)
-{
-  return rb_enc_str_new(str, length, rb_utf8_encoding());
-}
-#endif
-
 #include <nokogiri.h>
 #include <libxml/tree.h>
 #include <libxml/HTMLtree.h>
@@ -94,7 +70,7 @@ perform_parse(const GumboOptions *options, VALUE input)
   GumboOutput *output = gumbo_parse_with_options(
                           options,
                           RSTRING_PTR(input),
-                          RSTRING_LEN(input)
+                          (size_t)RSTRING_LEN(input)
                         );
 
   const char *status_string = gumbo_status_to_string(output->status);
@@ -260,7 +236,7 @@ static void
 add_errors(const GumboOutput *output, VALUE rdoc, VALUE input, VALUE url)
 {
   const char *input_str = RSTRING_PTR(input);
-  size_t input_len = RSTRING_LEN(input);
+  size_t input_len = (size_t)RSTRING_LEN(input);
 
   // Add parse errors to rdoc.
   if (output->errors.length) {
@@ -272,11 +248,11 @@ add_errors(const GumboOutput *output, VALUE rdoc, VALUE input, VALUE url)
       GumboSourcePosition position = gumbo_error_position(err);
       char *msg;
       size_t size = gumbo_caret_diagnostic_to_string(err, input_str, input_len, &msg);
-      VALUE err_str = rb_utf8_str_new(msg, size);
+      VALUE err_str = rb_utf8_str_new(msg, (int)size);
       free(msg);
       VALUE syntax_error = rb_class_new_instance(1, &err_str, cNokogiriXmlSyntaxError);
       const char *error_code = gumbo_error_code(err);
-      VALUE str1 = error_code ? rb_utf8_str_new_static(error_code, strlen(error_code)) : Qnil;
+      VALUE str1 = error_code ? rb_utf8_str_new_static(error_code, (int)strlen(error_code)) : Qnil;
       rb_iv_set(syntax_error, "@domain", INT2NUM(1)); // XML_FROM_PARSER
       rb_iv_set(syntax_error, "@code", INT2NUM(1));   // XML_ERR_INTERNAL_ERROR
       rb_iv_set(syntax_error, "@level", INT2NUM(2));  // XML_ERR_ERROR
@@ -316,18 +292,58 @@ parse_cleanup(VALUE parse_args)
   return Qnil;
 }
 
+// Scan the keyword arguments for options common to the document and fragment
+// parse.
+static GumboOptions
+common_options(VALUE kwargs)
+{
+  // The order of the keywords determines the order of the values below.
+  // If this order is changed, then setting the options below must change as
+  // well.
+  ID keywords[] = {
+    // Required keywords.
+    rb_intern_const("max_attributes"),
+    rb_intern_const("max_errors"),
+    rb_intern_const("max_tree_depth"),
+
+    // Optional keywords.
+    rb_intern_const("parse_noscript_content_as_text"),
+  };
+  VALUE values[sizeof keywords / sizeof keywords[0]];
+
+  // Extract the values coresponding to the required keywords. Raise an error
+  // if required arguments are missing.
+  rb_get_kwargs(kwargs, keywords, 3, 1, values);
+
+  GumboOptions options = kGumboDefaultOptions;
+  options.max_attributes = NUM2INT(values[0]);
+  options.max_errors = NUM2INT(values[1]);
+
+  // handle negative values
+  int depth = NUM2INT(values[2]);
+  options.max_tree_depth = depth < 0 ? UINT_MAX : (unsigned int)depth;
+
+  options.parse_noscript_content_as_text = values[3] != Qundef && RTEST(values[3]);
+
+  return options;
+}
+
 static VALUE parse_continue(VALUE parse_args);
 
 /*
  *  @!visibility protected
  */
 static VALUE
-parse(VALUE self, VALUE input, VALUE url, VALUE max_attributes, VALUE max_errors, VALUE max_depth, VALUE klass)
+noko_gumbo_s_parse(int argc, VALUE *argv, VALUE _self)
 {
-  GumboOptions options = kGumboDefaultOptions;
-  options.max_attributes = NUM2INT(max_attributes);
-  options.max_errors = NUM2INT(max_errors);
-  options.max_tree_depth = NUM2INT(max_depth);
+  VALUE input, url, klass, kwargs;
+
+  rb_scan_args(argc, argv, "3:", &input, &url, &klass, &kwargs);
+  if (NIL_P(kwargs)) {
+    kwargs = rb_hash_new();
+  }
+
+  GumboOptions options = common_options(kwargs);
 
   GumboOutput *output = perform_parse(&options, input);
   ParseArgs args = {
@@ -383,7 +399,7 @@ lookup_namespace(VALUE node, bool require_known_ns)
   Check_Type(ns, T_STRING);
 
   const char *href_ptr = RSTRING_PTR(ns);
-  size_t href_len = RSTRING_LEN(ns);
+  size_t href_len = (size_t)RSTRING_LEN(ns);
 #define NAMESPACE_P(uri) (href_len == sizeof uri - 1 && !memcmp(href_ptr, uri, href_len))
   if (NAMESPACE_P("http://www.w3.org/1999/xhtml")) {
     return GUMBO_NAMESPACE_HTML;
@@ -415,16 +431,12 @@ static VALUE fragment_continue(VALUE parse_args);
  *  @!visibility protected
  */
 static VALUE
-fragment(
-  VALUE self,
-  VALUE doc_fragment,
-  VALUE tags,
-  VALUE ctx,
-  VALUE max_attributes,
-  VALUE max_errors,
-  VALUE max_depth
-)
+noko_gumbo_s_fragment(int argc, VALUE *argv, VALUE _self)
 {
+  VALUE doc_fragment;
+  VALUE tags;
+  VALUE ctx;
+  VALUE kwargs;
   ID name = rb_intern_const("name");
   const char *ctx_tag;
   GumboNamespaceEnum ctx_ns;
@@ -432,13 +444,20 @@ fragment(
   bool form = false;
   const char *encoding = NULL;
 
+  rb_scan_args(argc, argv, "3:", &doc_fragment, &tags, &ctx, &kwargs);
+  if (NIL_P(kwargs)) {
+    kwargs = rb_hash_new();
+  }
+
+  GumboOptions options = common_options(kwargs);
+
   if (NIL_P(ctx)) {
     ctx_tag = "body";
     ctx_ns = GUMBO_NAMESPACE_HTML;
   } else if (TYPE(ctx) == T_STRING) {
     ctx_tag = StringValueCStr(ctx);
     ctx_ns = GUMBO_NAMESPACE_HTML;
-    size_t len = RSTRING_LEN(ctx);
+    size_t len = (size_t)RSTRING_LEN(ctx);
     const char *colon = memchr(ctx_tag, ':', len);
     if (colon) {
       switch (colon - ctx_tag) {
@@ -519,7 +538,7 @@ error:
   VALUE doc = rb_funcall(doc_fragment, rb_intern_const("document"), 0);
   VALUE dtd = rb_funcall(doc, internal_subset, 0);
   VALUE doc_quirks_mode = rb_iv_get(doc, "@quirks_mode");
-  if (NIL_P(ctx) || NIL_P(doc_quirks_mode)) {
+  if (NIL_P(ctx) || (TYPE(ctx) == T_STRING) || NIL_P(doc_quirks_mode)) {
     quirks_mode = GUMBO_DOCTYPE_NO_QUIRKS;
   } else if (NIL_P(dtd)) {
     quirks_mode = GUMBO_DOCTYPE_QUIRKS;
@@ -535,18 +554,15 @@ error:
   }
 
   // Perform a fragment parse.
-  int depth = NUM2INT(max_depth);
-  GumboOptions options = kGumboDefaultOptions;
-  options.max_attributes = NUM2INT(max_attributes);
-  options.max_errors = NUM2INT(max_errors);
-  // Add one to account for the HTML element.
-  options.max_tree_depth = depth < 0 ? -1 : (depth + 1);
   options.fragment_context = ctx_tag;
   options.fragment_namespace = ctx_ns;
   options.fragment_encoding = encoding;
   options.quirks_mode = quirks_mode;
   options.fragment_context_has_form_ancestor = form;
 
+  // Add one to the max tree depth to account for the HTML element.
+  if (options.max_tree_depth < UINT_MAX) { options.max_tree_depth++; }
+
   GumboOutput *output = perform_parse(&options, tags);
   ParseArgs args = {
     .output = output,
@@ -587,8 +603,8 @@ noko_init_gumbo(void)
   parent = rb_intern_const("parent");
 
   // Define Nokogumbo module with parse and fragment methods.
-  rb_define_singleton_method(mNokogiriGumbo, "parse", parse, 6);
-  rb_define_singleton_method(mNokogiriGumbo, "fragment", fragment, 6);
+  rb_define_singleton_method(mNokogiriGumbo, "parse", noko_gumbo_s_parse, -1);
+  rb_define_singleton_method(mNokogiriGumbo, "fragment", noko_gumbo_s_fragment, -1);
 }
 
 // vim: set shiftwidth=2 softtabstop=2 tabstop=8 expandtab:

data/ext/nokogiri/html4_document.c

@@ -7,9 +7,9 @@ static ID id_to_s;
 
 /*
  * call-seq:
- *  new
+ *  new(uri=nil, external_id=nil) → HTML4::Document
  *
- * Create a new document
+ * Create a new empty document with base URI +uri+ and external ID +external_id+.
  */
 static VALUE
 rb_html_document_s_new(int argc, VALUE *argv, VALUE klass)
@@ -46,7 +46,7 @@ rb_html_document_s_read_io(VALUE klass, VALUE rb_io, VALUE rb_url, VALUE rb_enco
   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);
+  xmlSetStructuredErrorFunc((void *)rb_error_list, noko__error_array_pusher);
 
   c_doc = htmlReadIO(noko_io_read, noko_io_close, (void *)rb_io, c_url, c_encoding, options);
 
@@ -106,7 +106,7 @@ rb_html_document_s_read_memory(VALUE klass, VALUE rb_html, VALUE rb_url, VALUE r
   int html_len = (int)RSTRING_LEN(rb_html);
   int options = NUM2INT(rb_options);
 
-  xmlSetStructuredErrorFunc((void *)rb_error_list, Nokogiri_error_array_pusher);
+  xmlSetStructuredErrorFunc((void *)rb_error_list, noko__error_array_pusher);
 
   c_doc = htmlReadMemory(c_buffer, html_len, c_url, c_encoding, options);
 
@@ -151,6 +151,12 @@ rb_html_document_type(VALUE self)
 void
 noko_init_html_document(void)
 {
+  /* this is here so that rdoc doesn't ignore this file. */
+  /*
+    mNokogiri         = rb_define_module("Nokogiri");
+    mNokogiriHtml4    = rb_define_module_under(mNokogiri, "HTML4");
+  */
+
   assert(cNokogiriXmlDocument);
   cNokogiriHtml4Document = rb_define_class_under(mNokogiriHtml4, "Document", cNokogiriXmlDocument);
 

data/ext/nokogiri/html4_element_description.c

@@ -1,7 +1,7 @@
 #include <nokogiri.h>
 
-static const rb_data_type_t html4_element_description_type = {
-  .wrap_struct_name = "Nokogiri::HTML4::ElementDescription",
+static const rb_data_type_t html_elem_desc_type = {
+  .wrap_struct_name = "htmlElemDesc",
   .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
@@ -20,7 +20,7 @@ required_attributes(VALUE self)
   VALUE list;
   int i;
 
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   list = rb_ary_new();
 
@@ -46,7 +46,7 @@ deprecated_attributes(VALUE self)
   VALUE list;
   int i;
 
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   list = rb_ary_new();
 
@@ -72,7 +72,7 @@ optional_attributes(VALUE self)
   VALUE list;
   int i;
 
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   list = rb_ary_new();
 
@@ -95,7 +95,7 @@ static VALUE
 default_sub_element(VALUE self)
 {
   const htmlElemDesc *description;
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   if (description->defaultsubelt) {
     return NOKOGIRI_STR_NEW2(description->defaultsubelt);
@@ -117,7 +117,7 @@ sub_elements(VALUE self)
   VALUE list;
   int i;
 
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   list = rb_ary_new();
 
@@ -140,7 +140,7 @@ static VALUE
 description(VALUE self)
 {
   const htmlElemDesc *description;
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   return NOKOGIRI_STR_NEW2(description->desc);
 }
@@ -155,7 +155,7 @@ static VALUE
 inline_eh(VALUE self)
 {
   const htmlElemDesc *description;
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   if (description->isinline) { return Qtrue; }
   return Qfalse;
@@ -171,7 +171,7 @@ static VALUE
 deprecated_eh(VALUE self)
 {
   const htmlElemDesc *description;
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   if (description->depr) { return Qtrue; }
   return Qfalse;
@@ -187,7 +187,7 @@ static VALUE
 empty_eh(VALUE self)
 {
   const htmlElemDesc *description;
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   if (description->empty) { return Qtrue; }
   return Qfalse;
@@ -203,7 +203,7 @@ static VALUE
 save_end_tag_eh(VALUE self)
 {
   const htmlElemDesc *description;
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   if (description->saveEndTag) { return Qtrue; }
   return Qfalse;
@@ -219,7 +219,7 @@ static VALUE
 implied_end_tag_eh(VALUE self)
 {
   const htmlElemDesc *description;
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   if (description->endTag) { return Qtrue; }
   return Qfalse;
@@ -235,7 +235,7 @@ static VALUE
 implied_start_tag_eh(VALUE self)
 {
   const htmlElemDesc *description;
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   if (description->startTag) { return Qtrue; }
   return Qfalse;
@@ -245,13 +245,13 @@ implied_start_tag_eh(VALUE self)
  * call-seq:
  *  name
  *
- * Get the tag name for this ElemementDescription
+ * Get the tag name for this ElementDescription
  */
 static VALUE
 name(VALUE self)
 {
   const htmlElemDesc *description;
-  TypedData_Get_Struct(self, htmlElemDesc, &html4_element_description_type, description);
+  TypedData_Get_Struct(self, htmlElemDesc, &html_elem_desc_type, description);
 
   if (NULL == description->name) { return Qnil; }
   return NOKOGIRI_STR_NEW2(description->name);
@@ -261,7 +261,7 @@ name(VALUE self)
  * call-seq:
  *  [](tag_name)
  *
- * Get ElemementDescription for +tag_name+
+ * Get ElementDescription for +tag_name+
  */
 static VALUE
 get_description(VALUE klass, VALUE tag_name)
@@ -271,7 +271,7 @@ get_description(VALUE klass, VALUE tag_name)
                                     );
 
   if (NULL == description) { return Qnil; }
-  return TypedData_Wrap_Struct(klass, &html4_element_description_type, DISCARD_CONST_QUAL(void *, description));
+  return TypedData_Wrap_Struct(klass, &html_elem_desc_type, DISCARD_CONST_QUAL(void *, description));
 }
 
 void

data/ext/nokogiri/html4_sax_parser.c

@@ -0,0 +1,40 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriHtml4SaxParser;
+
+static ID id_start_document;
+
+static void
+noko_html4_sax_parser_start_document(void *ctx)
+{
+  xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
+  VALUE self = (VALUE)ctxt->_private;
+  VALUE doc = rb_iv_get(self, "@document");
+
+  xmlSAX2StartDocument(ctx);
+
+  rb_funcall(doc, id_start_document, 0);
+}
+
+static VALUE
+noko_html4_sax_parser_initialize(VALUE self)
+{
+  xmlSAXHandlerPtr handler = noko_xml_sax_parser_unwrap(self);
+
+  rb_call_super(0, NULL);
+
+  handler->startDocument = noko_html4_sax_parser_start_document;
+
+  return self;
+}
+
+void
+noko_init_html4_sax_parser(void)
+{
+  cNokogiriHtml4SaxParser = rb_define_class_under(mNokogiriHtml4Sax, "Parser", cNokogiriXmlSaxParser);
+
+  rb_define_private_method(cNokogiriHtml4SaxParser, "initialize_native",
+                           noko_html4_sax_parser_initialize, 0);
+
+  id_start_document = rb_intern("start_document");
+}

data/ext/nokogiri/html4_sax_parser_context.c

@@ -2,96 +2,83 @@
 
 VALUE cNokogiriHtml4SaxParserContext ;
 
+/* :nodoc: */
 static VALUE
-parse_memory(VALUE klass, VALUE data, VALUE encoding)
+noko_html4_sax_parser_context_s_native_memory(VALUE rb_class, VALUE rb_input, VALUE rb_encoding)
 {
-  htmlParserCtxtPtr ctxt;
-
-  Check_Type(data, T_STRING);
-
-  if (!(int)RSTRING_LEN(data)) {
-    rb_raise(rb_eRuntimeError, "data cannot be empty");
+  Check_Type(rb_input, T_STRING);
+  if (!(int)RSTRING_LEN(rb_input)) {
+    rb_raise(rb_eRuntimeError, "input string cannot be empty");
   }
 
-  ctxt = htmlCreateMemoryParserCtxt(StringValuePtr(data),
-                                    (int)RSTRING_LEN(data));
-  if (ctxt->sax) {
-    xmlFree(ctxt->sax);
-    ctxt->sax = NULL;
+  if (!NIL_P(rb_encoding) && !rb_obj_is_kind_of(rb_encoding, rb_cEncoding)) {
+    rb_raise(rb_eTypeError, "argument must be an Encoding object");
   }
 
-  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));
-      }
-    }
+  htmlParserCtxtPtr c_context =
+    htmlCreateMemoryParserCtxt(StringValuePtr(rb_input), (int)RSTRING_LEN(rb_input));
+  if (!c_context) {
+    rb_raise(rb_eRuntimeError, "failed to create xml sax parser context");
   }
 
-  return noko_xml_sax_parser_context_wrap(klass, ctxt);
-}
+  noko_xml_sax_parser_context_set_encoding(c_context, rb_encoding);
 
-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;
+  if (c_context->sax) {
+    xmlFree(c_context->sax);
+    c_context->sax = NULL;
   }
 
-  return noko_xml_sax_parser_context_wrap(klass, ctxt);
+  return noko_xml_sax_parser_context_wrap(rb_class, c_context);
 }
 
+/* :nodoc: */
 static VALUE
-parse_doc(VALUE ctxt_val)
+noko_html4_sax_parser_context_s_native_file(VALUE rb_class, VALUE rb_filename, VALUE rb_encoding)
 {
-  htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
-  htmlParseDocument(ctxt);
-  return Qnil;
-}
+  if (!NIL_P(rb_encoding) && !rb_obj_is_kind_of(rb_encoding, rb_cEncoding)) {
+    rb_raise(rb_eTypeError, "argument must be an Encoding object");
+  }
 
-static VALUE
-parse_doc_finalize(VALUE ctxt_val)
-{
-  htmlParserCtxtPtr ctxt = (htmlParserCtxtPtr)ctxt_val;
+  htmlParserCtxtPtr c_context = htmlCreateFileParserCtxt(StringValueCStr(rb_filename), NULL);
+  if (!c_context) {
+    rb_raise(rb_eRuntimeError, "failed to create xml sax parser context");
+  }
 
-  if (ctxt->myDoc) {
-    xmlFreeDoc(ctxt->myDoc);
+  noko_xml_sax_parser_context_set_encoding(c_context, rb_encoding);
+
+  if (c_context->sax) {
+    xmlFree(c_context->sax);
+    c_context->sax = NULL;
   }
 
-  NOKOGIRI_SAX_TUPLE_DESTROY(ctxt->userData);
-  return Qnil;
+  return noko_xml_sax_parser_context_wrap(rb_class, c_context);
 }
 
 static VALUE
-parse_with(VALUE self, VALUE sax_handler)
+noko_html4_sax_parser_context__parse_with(VALUE rb_context, VALUE rb_sax_parser)
 {
   htmlParserCtxtPtr ctxt;
   htmlSAXHandlerPtr sax;
 
-  if (!rb_obj_is_kind_of(sax_handler, cNokogiriXmlSaxParser)) {
+  if (!rb_obj_is_kind_of(rb_sax_parser, 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 = noko_xml_sax_parser_context_unwrap(rb_context);
+  sax = noko_xml_sax_parser_unwrap(rb_sax_parser);
 
   ctxt->sax = sax;
-  ctxt->userData = (void *)NOKOGIRI_SAX_TUPLE_NEW(ctxt, sax_handler);
+  ctxt->userData = ctxt; /* so we can use libxml2/SAX2.c handlers if we want to */
+  ctxt->_private = (void *)rb_sax_parser;
 
   xmlSetStructuredErrorFunc(NULL, NULL);
 
-  rb_ensure(parse_doc, (VALUE)ctxt, parse_doc_finalize, (VALUE)ctxt);
+  /* although we're calling back into Ruby here, we don't need to worry about exceptions, because we
+   * don't have any cleanup to do. The only memory we need to free is handled by
+   * xml_sax_parser_context_type_free */
+  htmlParseDocument(ctxt);
 
-  return self;
+  return Qnil;
 }
 
 void
@@ -101,8 +88,11 @@ noko_init_html_sax_parser_context(void)
   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_singleton_method(cNokogiriHtml4SaxParserContext, "native_memory",
+                             noko_html4_sax_parser_context_s_native_memory, 2);
+  rb_define_singleton_method(cNokogiriHtml4SaxParserContext, "native_file",
+                             noko_html4_sax_parser_context_s_native_file, 2);
 
-  rb_define_method(cNokogiriHtml4SaxParserContext, "parse_with", parse_with, 1);
+  rb_define_method(cNokogiriHtml4SaxParserContext, "parse_with",
+                   noko_html4_sax_parser_context__parse_with, 1);
 }