RubyGems - nokogumbo - Versions diffs - 2.0.0.pre.alpha → 2.0.4 - Mend

nokogumbo 2.0.0.pre.alpha → 2.0.4

Files changed (29) hide show

checksums.yaml +4 -4
data/README.md +101 -14
data/ext/nokogumbo/extconf.rb +7 -2
data/ext/nokogumbo/nokogumbo.c +630 -235
data/gumbo-parser/src/ascii.c +42 -0
data/gumbo-parser/src/ascii.h +91 -7
data/gumbo-parser/src/char_ref.c +5973 -4601
data/gumbo-parser/src/char_ref.h +13 -28
data/gumbo-parser/src/error.c +391 -126
data/gumbo-parser/src/error.h +63 -125
data/gumbo-parser/src/gumbo.h +74 -4
data/gumbo-parser/src/parser.c +1161 -1025
data/gumbo-parser/src/string_buffer.c +1 -1
data/gumbo-parser/src/string_buffer.h +1 -1
data/gumbo-parser/src/token_buffer.c +79 -0
data/gumbo-parser/src/token_buffer.h +71 -0
data/gumbo-parser/src/tokenizer.c +1440 -1278
data/gumbo-parser/src/tokenizer.h +7 -18
data/gumbo-parser/src/tokenizer_states.h +275 -23
data/gumbo-parser/src/utf8.c +17 -59
data/gumbo-parser/src/utf8.h +52 -16
data/lib/nokogumbo.rb +3 -1
data/lib/nokogumbo/html5.rb +17 -15
data/lib/nokogumbo/html5/document.rb +19 -3
data/lib/nokogumbo/html5/document_fragment.rb +36 -20
data/lib/nokogumbo/{xml → html5}/node.rb +28 -13
data/lib/nokogumbo/version.rb +1 -1
metadata +20 -14
data/CHANGELOG.md +0 -56

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0d434c0749d7922ba8f084c15ed7219ccbf0e07b715368ae846bc38e64aad17
-  data.tar.gz: 2770648e3e9e82d0ffb1877f1c06edc537688cf6a8405bc52dbdf5a6bb69bc1a
+  metadata.gz: 6d5936b6ffffb20ec22609b2be5d2493919c81f7c8279a7c21fd8e95e457d0c5
+  data.tar.gz: 5259acf1b328d1097edcbb162433d72e69b084b66ed8bae28703bca53bd88b76
 SHA512:
-  metadata.gz: e6c3de49495bf55ccaa250e2a3275b6796b0f0565da2a930e3333d2a153f2a16312eb77cb28ca3e03c17720127c2ecc27a1f71cfd6acfd15407295c29973e9fb
-  data.tar.gz: e8ce6c80cb2327d2327f03c7e829156c1f0074ba4d6fce2b0d59305b80112b8fd5edc0932fad1fca13cb5f4bb6f2652fe52a2f090110aa76d06e1afbdebc334f
+  metadata.gz: 6fdc59096ec69684932424b70bed03f05f6ea5324e9d3f70eee8481891a15ae9f3cf063fff7106cc38d2873d072d21169b58ed6f5b381b687aa5b1680eee35e6
+  data.tar.gz: 4d1d88817b4242b060e5a9ac74e36e9f23d38b153547b64d51a59d86daff44853915ba8bd07473902fe4d936cd53851d2594c3ac09541159863117eedf8339ab

data/README.md CHANGED

@@ -1,11 +1,12 @@
 # Nokogumbo - a Nokogiri interface to the Gumbo HTML5 parser.
-Nokogumbo provides the ability for a Ruby program to invoke the
-[Gumbo HTML5 parser](https://github.com/google/gumbo-parser#readme)
+Nokogumbo provides the ability for a Ruby program to invoke
+[our version of the  Gumbo HTML5 parser](https://github.com/rubys/nokogumbo/tree/master/gumbo-parser/src)
 and to access the result as a
 [Nokogiri::HTML::Document](http://rdoc.info/github/sparklemotion/nokogiri/Nokogiri/HTML/Document).
-[![Build Status](https://travis-ci.org/rubys/nokogumbo.svg)](https://travis-ci.org/rubys/nokogumbo)
+[![Travis-CI Build Status](https://travis-ci.org/rubys/nokogumbo.svg)](https://travis-ci.org/rubys/nokogumbo)
+[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/rubys/nokogumbo)](https://ci.appveyor.com/project/rubys/nokogumbo/branch/master)
 ## Usage
@@ -14,8 +15,7 @@ require 'nokogumbo'
 doc = Nokogiri.HTML5(string)
 ```
-An experimental _fragment_ method is also provided.  While not HTML5
-compliant, it may be useful:
+To parse an HTML fragment, a `fragment` method is provided.
 ```ruby
 require 'nokogumbo'
@@ -39,8 +39,8 @@ The document and fragment parsing methods,
 - `Nokogiri::HTML5::DocumentFragment.parse(html, encoding = nil, options = {})`
 support options that are different from Nokogiri's.
-The two currently supported options are `:max_errors` and `:max_tree_depth`,
-described below.
+The three currently supported options are `:max_errors`, `:max_tree_depth` and
+`:max_attributes`, described below.
 ### Error reporting
 Nokogumbo contains an experimental parse error reporting facility. By default,
@@ -49,20 +49,26 @@ no parse errors are reported but this can be configured by passing the
 ```ruby
 require 'nokogumbo'
-doc = Nokogiri::HTML5.parse('Hi there!<body>', max_errors: 10)
+doc = Nokogiri::HTML5.parse('<span/>Hi there!</span foo=bar />', max_errors: 10)
 doc.errors.each do |err|
-  puts err
+  puts(err)
 end
 ```
 This prints the following.
 ```
-1:1: ERROR: @1:1: The doctype must be the first token in the document.
-Hi there!<body>
+1:1: ERROR: Expected a doctype token
+<span/>Hi there!</span foo=bar />
 ^
-1:10: ERROR: @1:10: That tag isn't allowed here  Currently open tags: html, body..
-Hi there!<body>
-         ^
+1:1: ERROR: Start tag of nonvoid HTML element ends with '/>', use '>'.
+<span/>Hi there!</span foo=bar />
+^
+1:17: ERROR: End tag ends with '/>', use '>'.
+<span/>Hi there!</span foo=bar />
+                ^
+1:17: ERROR: End tag contains attributes.
+<span/>Hi there!</span foo=bar />
+                ^
 ```
 Using `max_errors: -1` results in an unlimited number of errors being
@@ -71,6 +77,41 @@ returned.
 The errors returned by `#errors` are instances of
 [`Nokogiri::XML::SyntaxError`](https://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/SyntaxError).
+The [HTML
+standard](https://html.spec.whatwg.org/multipage/parsing.html#parse-errors)
+defines a number of standard parse error codes. These error codes only cover
+the "tokenization" stage of parsing HTML. The parse errors in the
+"tree construction" stage do not have standardized error codes (yet).
+As a convenience to Nokogumbo users, the defined error codes are available
+via the
+[`Nokogiri::XML::SyntaxError#str1`](https://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/SyntaxError#str1-instance_method)
+method.
+```ruby
+require 'nokogumbo'
+doc = Nokogiri::HTML5.parse('<span/>Hi there!</span foo=bar />', max_errors: 10)
+doc.errors.each do |err|
+  puts("#{err.line}:#{err.column}: #{err.str1}")
+end
+```
+This prints the following.
+```
+1:1: generic-parser
+1:1: non-void-html-element-start-tag-with-trailing-solidus
+1:17: end-tag-with-trailing-solidus
+1:17: end-tag-with-attributes
+```
+Note that the first error is `generic-parser` because it's an error from the
+tree construction stage and doesn't have a standardized error code.
+For the purposes of semantic versioning, the error messages, error locations,
+and error codes are not part of Nokogumbo's public API. That is, these are
+subject to change without Nokogumbo's major version number changing. These may
+be stabilized in the future.
 ### Maximum tree depth
 The maximum depth of the DOM tree parsed by the various parsing methods is
 configurable by the `:max_tree_depth` option. If the depth of the tree would
@@ -87,6 +128,22 @@ doc = Nokogiri.HTML5(html)
 doc = Nokogiri.HTML5(html, max_tree_depth: -1)
 ```
+### Attribute limit per element
+The maximum number of attributes per DOM element is configurable by the
+`:max_attributes` option. If a given element would exceed this limit, then an
+[ArgumentError](https://ruby-doc.org/core-2.5.0/ArgumentError.html) is thrown.
+This limit (which defaults to `Nokogumbo::DEFAULT_MAX_ATTRIBUTES = 400`) can
+be removed by giving the option `max_attributes: -1`.
+``` ruby
+html = '<!DOCTYPE html><div ' + (1..1000).map { |x| "attr-#{x}" }.join(' ') + '>'
+# "<!DOCTYPE html><div attr-1 attr-2 attr-3 ... attr-1000>"
+doc = Nokogiri.HTML5(html)
+# raises ArgumentError: Attributes per element limit exceeded
+doc = Nokogiri.HTML5(html, max_attributes: -1)
+```
 ## HTML Serialization
 After parsing HTML, it may be serialized using any of the Nokogiri
@@ -201,6 +258,36 @@ rules defined in the HTML5 specification for doing so.
 * Instead of returning `unknown` as the element name for unknown tags, the
 original tag name is returned verbatim.
+# Flavors of Nokogumbo
+Nokogumbo uses libxml2, the XML library underlying Nokogiri, to speed up
+parsing. If the libxml2 headers are not available, then Nokogumbo resorts to
+using Nokogiri's Ruby API to construct the DOM tree.
+Nokogiri can be configured to either use the system library version of libxml2
+or use a bundled version. By default (as of Nokogiri version 1.8.4), Nokogiri
+will use a bundled version.
+To prevent differences between versions of libxml2, Nokogumbo will only use
+libxml2 if the build process can find the exact same version used by Nokogiri.
+This leads to three possibilities
+1. Nokogiri is compiled with the bundled libxml2. In this case, Nokogumbo will
+   (by default) use the same version of libxml2.
+2. Nokogiri is compiled with the system libxml2. In this case, if the libxml2
+   headers are available, then Nokogumbo will (by default) use the system
+   version and headers.
+3. Nokogiri is compiled with the system libxml2 but its headers aren't
+   available at build time for Nokogumbo. In this case, Nokogumbo will use the
+   slower Ruby API.
+Using libxml2 can be required by passing `-- --with-libxml2` to `bundle exec
+rake` or to `gem install`. Using libxml2 can be prohibited by instead passing
+`-- --without-libxml2`.
+Functionally, the only difference between using libxml2 or not is in the
+behavior of `Nokogiri::XML::Node#line`. If it is used, then `#line` will
+return the line number of the corresponding node. Otherwise, it will return 0.
 # Installation
     git clone https://github.com/rubys/nokogumbo.git

data/ext/nokogumbo/extconf.rb CHANGED

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'fileutils'
 require 'mkmf'
 require 'nokogiri'
@@ -23,7 +24,6 @@ def download_headers
     return nil if dep_index.nil?
     requirement = NG_SPEC.dependencies[dep_index].requirement.to_s
-    require 'rubygems'
     gem 'mini_portile2', requirement
     require 'mini_portile2'
     p = MiniPortile::new('libxml2', version).tap do |r|
@@ -108,9 +108,14 @@ gumbo_src = File.join(ext_dir, 'gumbo_src')
 Dir.chdir(ext_dir) do
   $srcs = Dir['*.c', '../../gumbo-parser/src/*.c']
+  $hdrs = Dir['*.h', '../../gumbo-parser/src/*.h']
 end
 $INCFLAGS << ' -I$(srcdir)/../../gumbo-parser/src'
 $VPATH << '$(srcdir)/../../gumbo-parser/src'
-create_makefile('nokogumbo/nokogumbo')
+create_makefile('nokogumbo/nokogumbo') do |conf|
+  conf.map! do |chunk|
+    chunk.gsub(/^HDRS = .*$/, "HDRS = #{$hdrs.map { |h| File.join('$(srcdir)', h)}.join(' ')}")
+  end
+end
 # vim: set sw=2 sts=2 ts=8 et:

data/ext/nokogumbo/nokogumbo.c CHANGED

@@ -9,7 +9,7 @@
 // document tree is then walked:
 //
 //  * if Nokogiri and libxml2 headers are available at compile time,
-//    (ifdef NGLIB) then a parallel libxml2 tree is constructed, and the
+//    (if NGLIB) then a parallel libxml2 tree is constructed, and the
 //    final document is then wrapped using Nokogiri_wrap_xml_document.
 //    This approach reduces memory and CPU requirements as Ruby objects
 //    are only built when necessary.
@@ -20,74 +20,111 @@
 #include <assert.h>
 #include <ruby.h>
+#include <ruby/version.h>
 #include "gumbo.h"
-#include "error.h"
 // class constants
 static VALUE Document;
-#ifdef NGLIB
+// Interned symbols
+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
+#if NGLIB
 #include <nokogiri.h>
-#include <xml_syntax_error.h>
 #include <libxml/tree.h>
 #include <libxml/HTMLtree.h>
 #define NIL NULL
-#define CONST_CAST (xmlChar const*)
 #else
 #define NIL Qnil
-#define CONST_CAST
-// more class constants
+// These are defined by nokogiri.h
 static VALUE cNokogiriXmlSyntaxError;
+static VALUE cNokogiriXmlElement;
+static VALUE cNokogiriXmlText;
+static VALUE cNokogiriXmlCData;
+static VALUE cNokogiriXmlComment;
+// Interned symbols.
+static ID new;
+static ID node_name_;
+// Map libxml2 types to Ruby VALUE.
+typedef VALUE xmlNodePtr;
+typedef VALUE xmlDocPtr;
+typedef VALUE xmlNsPtr;
+typedef VALUE xmlDtdPtr;
+typedef char xmlChar;
+#define BAD_CAST
+// Redefine libxml2 API as Ruby function calls.
+static xmlNodePtr xmlNewDocNode(xmlDocPtr doc, xmlNsPtr ns, const xmlChar *name, const xmlChar *content) {
+  assert(ns == NIL && content == NULL);
+  return rb_funcall(cNokogiriXmlElement, new, 2, rb_utf8_str_new_cstr(name), doc);
+}
+static xmlNodePtr xmlNewDocText(xmlDocPtr doc, const xmlChar *content) {
+  VALUE str = rb_utf8_str_new_cstr(content);
+  return rb_funcall(cNokogiriXmlText, new, 2, str, doc);
+}
+static xmlNodePtr xmlNewCDataBlock(xmlDocPtr doc, const xmlChar *content, int len) {
+  VALUE str = rb_utf8_str_new(content, len);
+  // CDATA.new takes arguments in the opposite order from Text.new.
+  return rb_funcall(cNokogiriXmlCData, new, 2, doc, str);
+}
+static xmlNodePtr xmlNewDocComment(xmlDocPtr doc, const xmlChar *content) {
+  VALUE str = rb_utf8_str_new_cstr(content);
+  return rb_funcall(cNokogiriXmlComment, new, 2, doc, str);
+}
+static xmlNodePtr xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) {
+  ID add_child;
+  CONST_ID(add_child, "add_child");
+  return rb_funcall(parent, add_child, 1, cur);
+}
+static void xmlSetNs(xmlNodePtr node, xmlNsPtr ns) {
+  ID namespace_;
+  CONST_ID(namespace_, "namespace=");
+  rb_funcall(node, namespace_, 1, ns);
+}
+static void xmlFreeDoc(xmlDocPtr doc) { }
-static VALUE Element;
-static VALUE Text;
-static VALUE CDATA;
-static VALUE Comment;
-// interned symbols
-static VALUE new;
-static VALUE attribute;
-static VALUE set_attribute;
-static VALUE remove_attribute;
-static VALUE add_child;
-static VALUE internal_subset;
-static VALUE remove_;
-static VALUE create_internal_subset;
-static VALUE key_;
-static VALUE node_name_;
-// map libxml2 types to Ruby VALUE
-#define xmlNodePtr VALUE
-#define xmlDocPtr VALUE
-// redefine libxml2 API as Ruby function calls
-#define xmlNewDocNode(doc, ns, name, content) \
-  rb_funcall(Element, new, 2, rb_str_new2(name), doc)
-#define xmlNewDocText(doc, text) \
-  rb_funcall(Text, new, 2, rb_str_new2(text), doc)
-#define xmlNewCDataBlock(doc, content, length) \
-  rb_funcall(CDATA, new, 2, doc, rb_str_new(content, length))
-#define xmlNewDocComment(doc, text) \
-  rb_funcall(Comment, new, 2, doc, rb_str_new2(text))
-#define xmlAddChild(element, node) \
-  rb_funcall(element, add_child, 1, node)
-#define xmlDocSetRootElement(doc, root) \
-  rb_funcall(doc, add_child, 1, root)
-#define xmlCreateIntSubset(doc, name, external, system) \
-  rb_funcall(doc, create_internal_subset, 3, rb_str_new2(name), \
-    (external ? rb_str_new2(external) : Qnil), \
-    (system ? rb_str_new2(system) : Qnil));
-#define Nokogiri_wrap_xml_document(klass, doc) \
-  doc
+static VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc) {
+  return doc;
+}
 static VALUE find_dummy_key(VALUE collection) {
   VALUE r_dummy = Qnil;
   char dummy[5] = "a";
   size_t len = 1;
+  ID key_;
+  CONST_ID(key_, "key?");
   while (len < sizeof dummy) {
-    r_dummy = rb_str_new(dummy, len);
+    r_dummy = rb_utf8_str_new(dummy, len);
     if (rb_funcall(collection, key_, 1, r_dummy) == Qfalse)
       return r_dummy;
     for (size_t i = 0; ; ++i) {
@@ -105,10 +142,42 @@ static VALUE find_dummy_key(VALUE collection) {
     }
   }
   // This collection has 475254 elements?? Give up.
-  return Qnil;
+  rb_raise(rb_eArgError, "Failed to find a dummy key.");
 }
-static xmlNodePtr xmlNewProp(xmlNodePtr node, const char *name, const char *value) {
+// This should return an xmlAttrPtr, but we don't need it and it's easier to
+// not get the result.
+static void xmlNewNsProp (
+  xmlNodePtr node,
+  xmlNsPtr ns,
+  const xmlChar *name,
+  const xmlChar *value
+) {
+  ID set_attribute;
+  CONST_ID(set_attribute, "set_attribute");
+  VALUE rvalue = rb_utf8_str_new_cstr(value);
+  if (RTEST(ns)) {
+    // This is an easy case, we have a namespace so it's enough to do
+    // node["#{ns.prefix}:#{name}"] = value
+    ID prefix;
+    CONST_ID(prefix, "prefix");
+    VALUE ns_prefix = rb_funcall(ns, prefix, 0);
+    VALUE qname = rb_sprintf("%" PRIsVALUE ":%s", ns_prefix, name);
+    rb_funcall(node, set_attribute, 2, qname, rvalue);
+    return;
+  }
+  size_t len = strlen(name);
+  VALUE rname = rb_utf8_str_new(name, len);
+  if (memchr(name, ':', len) == NULL) {
+    // This is the easiest case. There's no colon so we can do
+    // node[name] = value.
+    rb_funcall(node, set_attribute, 2, rname, rvalue);
+    return;
+  }
   // Nokogiri::XML::Node#set_attribute calls xmlSetProp(node, name, value)
   // which behaves roughly as
   // if name is a QName prefix:local
@@ -118,7 +187,7 @@ static xmlNodePtr xmlNewProp(xmlNodePtr node, const char *name, const char *valu
   //
   // If the prefix is "xml", then the namespace lookup will create it.
   //
-  // By contrast, xmlNewProp does not do this parsing and creates an attribute
+  // By contrast, xmlNewNsProp does not do this parsing and creates an attribute
   // with the name and value exactly as given. This is the behavior that we
   // want.
   //
@@ -129,169 +198,90 @@ static xmlNodePtr xmlNewProp(xmlNodePtr node, const char *name, const char *valu
   // Work around this by inserting a dummy attribute and then changing the
   // name, if needed.
-  // Can't use strchr since it's locale-sensitive.
-  size_t len = strlen(name);
-  VALUE r_name = rb_str_new(name, len);
-  if (memchr(name, ':', len) == NULL) {
-    // No colon.
-    return rb_funcall(node, set_attribute, 2, r_name, rb_str_new2(value));
-  }
   // Find a dummy attribute string that doesn't already exist.
   VALUE dummy = find_dummy_key(node);
-  if (dummy == Qnil)
-    return Qnil;
   // Add the dummy attribute.
-  VALUE r_value = rb_funcall(node, set_attribute, 2, dummy, rb_str_new2(value));
-  if (r_value == Qnil)
-    return Qnil;
-  // Remove thet old attribute, if it exists.
-  rb_funcall(node, remove_attribute, 1, r_name);
+  rb_funcall(node, set_attribute, 2, dummy, rvalue);
+  // Remove the old attribute, if it exists.
+  ID remove_attribute;
+  CONST_ID(remove_attribute, "remove_attribute");
+  rb_funcall(node, remove_attribute, 1, rname);
   // Rename the dummy
+  ID attribute;
+  CONST_ID(attribute, "attribute");
   VALUE attr = rb_funcall(node, attribute, 1, dummy);
-  if (attr == Qnil)
-    return Qnil;
-  rb_funcall(attr, node_name_, 1, r_name);
-  return attr;
+  rb_funcall(attr, node_name_, 1, rname);
 }
 #endif
-// Build a xmlNodePtr for a given GumboNode (recursively)
-static xmlNodePtr walk_tree(xmlDocPtr document, GumboNode *node);
-// Build a xmlNodePtr for a given GumboElement (recursively)
-static xmlNodePtr walk_element(xmlDocPtr document, GumboElement *node) {
-  // create the given element
-  xmlNodePtr element = xmlNewDocNode(document, NIL, CONST_CAST node->name, NIL);
-  // add in the attributes
-  GumboVector* attrs = &node->attributes;
-  char *name = NULL;
-  size_t namelen = 0;
-  const char *ns;
-  for (size_t i=0; i < attrs->length; i++) {
-    GumboAttribute *attr = attrs->data[i];
-    switch (attr->attr_namespace) {
-      case GUMBO_ATTR_NAMESPACE_XLINK:
-        ns = "xlink:";
-        break;
-      case GUMBO_ATTR_NAMESPACE_XML:
-        ns = "xml:";
-        break;
-      case GUMBO_ATTR_NAMESPACE_XMLNS:
-        ns = "xmlns:";
-        if (!strcmp(attr->name, "xmlns")) ns = NULL;
-        break;
-      default:
-        ns = NULL;
-    }
-    if (ns) {
-      if (strlen(ns) + strlen(attr->name) + 1 > namelen) {
-        free(name);
-        name = NULL;
-      }
-      if (!name) {
-        namelen = strlen(ns) + strlen(attr->name) + 1;
-        name = malloc(namelen);
-      }
-      strcpy(name, ns);
-      strcat(name, attr->name);
-      xmlNewProp(element, CONST_CAST name, CONST_CAST attr->value);
-    } else {
-      xmlNewProp(element, CONST_CAST attr->name, CONST_CAST attr->value);
-    }
-  }
-  if (name) free(name);
-  // add in the children
-  GumboVector* children = &node->children;
-  for (size_t i=0; i < children->length; i++) {
-    xmlNodePtr node = walk_tree(document, children->data[i]);
-    if (node) xmlAddChild(element, node);
-  }
-  return element;
-}
-static xmlNodePtr walk_tree(xmlDocPtr document, GumboNode *node) {
-  switch (node->type) {
-    case GUMBO_NODE_DOCUMENT:
-      return NIL;
-    case GUMBO_NODE_ELEMENT:
-    case GUMBO_NODE_TEMPLATE:
-      return walk_element(document, &node->v.element);
-    case GUMBO_NODE_TEXT:
-    case GUMBO_NODE_WHITESPACE:
-      return xmlNewDocText(document, CONST_CAST node->v.text.text);
-    case GUMBO_NODE_CDATA:
-      return xmlNewCDataBlock(document,
-        CONST_CAST node->v.text.text,
-        (int) strlen(node->v.text.text));
-    case GUMBO_NODE_COMMENT:
-      return xmlNewDocComment(document, CONST_CAST node->v.text.text);
-  }
-}
 // URI = system id
 // external id = public id
-#if NGLIB
-static htmlDocPtr new_html_doc(const char *dtd_name, const char *system, const char *public)
+static xmlDocPtr new_html_doc(const char *dtd_name, const char *system, const char *public)
 {
+#if NGLIB
   // These two libxml2 functions take the public and system ids in
   // opposite orders.
   htmlDocPtr doc = htmlNewDocNoDtD(/* URI */ NULL, /* ExternalID */NULL);
   assert(doc);
   if (dtd_name)
-    xmlCreateIntSubset(doc, CONST_CAST dtd_name, CONST_CAST public, CONST_CAST system);
+    xmlCreateIntSubset(doc, BAD_CAST dtd_name, BAD_CAST public, BAD_CAST system);
   return doc;
-}
 #else
-// remove internal subset from newly created documents
-static VALUE new_html_doc(const char *dtd_name, const char *system, const char *public) {
+  // remove internal subset from newly created documents
   VALUE doc;
   // If system and public are both NULL, Document#new is going to set default
   // values for them so we're going to have to remove the internal subset
   // which seems to leak memory in Nokogiri, so leak as little as possible.
   if (system == NULL && public == NULL) {
-    doc = rb_funcall(Document, new, 2, /* URI */ Qnil, /* external_id */ rb_str_new("", 0));
-    rb_funcall(rb_funcall(doc, internal_subset, 0), remove_, 0);
+    ID remove;
+    CONST_ID(remove, "remove");
+    doc = rb_funcall(Document, new, 2, /* URI */ Qnil, /* external_id */ rb_utf8_str_new_static("", 0));
+    rb_funcall(rb_funcall(doc, internal_subset, 0), remove, 0);
     if (dtd_name) {
       // We need to create an internal subset now.
-      rb_funcall(doc, create_internal_subset, 3, rb_str_new2(dtd_name), Qnil, Qnil);
+      ID create_internal_subset;
+      CONST_ID(create_internal_subset, "create_internal_subset");
+      rb_funcall(doc, create_internal_subset, 3, rb_utf8_str_new_cstr(dtd_name), Qnil, Qnil);
     }
   } else {
     assert(dtd_name);
     // Rather than removing and creating the internal subset as we did above,
     // just create and then rename one.
-    VALUE r_system = system ? rb_str_new2(system) : Qnil;
-    VALUE r_public = public ? rb_str_new2(public) : Qnil;
+    VALUE r_system = system ? rb_utf8_str_new_cstr(system) : Qnil;
+    VALUE r_public = public ? rb_utf8_str_new_cstr(public) : Qnil;
     doc = rb_funcall(Document, new, 2, r_system, r_public);
-    rb_funcall(rb_funcall(doc, internal_subset, 0), node_name_, 1, rb_str_new2(dtd_name));
+    rb_funcall(rb_funcall(doc, internal_subset, 0), node_name_, 1, rb_utf8_str_new_cstr(dtd_name));
   }
   return doc;
-}
 #endif
+}
-// Parse a string using gumbo_parse into a Nokogiri document
-static VALUE parse(VALUE self, VALUE string, VALUE url, VALUE max_errors, VALUE max_depth) {
-  GumboOptions options = kGumboDefaultOptions;
-  options.max_errors = NUM2INT(max_errors);
-  options.max_tree_depth = NUM2INT(max_depth);
+static xmlNodePtr get_parent(xmlNodePtr node) {
+#if NGLIB
+  return node->parent;
+#else
+  if (!rb_respond_to(node, parent))
+    return Qnil;
+  return rb_funcall(node, parent, 0);
+#endif
+}
-  const char *input = RSTRING_PTR(string);
-  size_t input_len = RSTRING_LEN(string);
-  GumboOutput *output = gumbo_parse_with_options(&options, input, input_len);
+static GumboOutput *perform_parse(const GumboOptions *options, VALUE input) {
+  assert(RTEST(input));
+  Check_Type(input, T_STRING);
+  GumboOutput *output = gumbo_parse_with_options (
+    options,
+    RSTRING_PTR(input),
+    RSTRING_LEN(input)
+  );
   const char *status_string = gumbo_status_to_string(output->status);
   switch (output->status) {
   case GUMBO_STATUS_OK:
     break;
+  case GUMBO_STATUS_TOO_MANY_ATTRIBUTES:
   case GUMBO_STATUS_TREE_TOO_DEEP:
     gumbo_destroy_output(output);
     rb_raise(rb_eArgError, "%s", status_string);
@@ -299,100 +289,505 @@ static VALUE parse(VALUE self, VALUE string, VALUE url, VALUE max_errors, VALUE
     gumbo_destroy_output(output);
     rb_raise(rb_eNoMemError, "%s", status_string);
   }
+  return output;
+}
-  xmlDocPtr doc;
-  if (output->document->v.document.has_doctype) {
-    const char *name   = output->document->v.document.name;
-    const char *public = output->document->v.document.public_identifier;
-    const char *system = output->document->v.document.system_identifier;
-    public = public[0] ? public : NULL;
-    system = system[0] ? system : NULL;
-    doc = new_html_doc(name, system, public);
-  } else {
-    doc = new_html_doc(NULL, NULL, NULL);
-  }
+static xmlNsPtr lookup_or_add_ns (
+  xmlDocPtr doc,
+  xmlNodePtr root,
+  const char *href,
+  const char *prefix
+) {
+#if NGLIB
+  xmlNsPtr ns = xmlSearchNs(doc, root, BAD_CAST prefix);
+  if (ns)
+    return ns;
+  return xmlNewNs(root, BAD_CAST href, BAD_CAST prefix);
+#else
+  ID add_namespace_definition;
+  CONST_ID(add_namespace_definition, "add_namespace_definition");
+  VALUE rprefix = rb_utf8_str_new_cstr(prefix);
+  VALUE rhref = rb_utf8_str_new_cstr(href);
+  return rb_funcall(root, add_namespace_definition, 2, rprefix, rhref);
+#endif
+}
+static void set_line(xmlNodePtr node, size_t line) {
+#if NGLIB
+  // libxml2 uses 65535 to mean look elsewhere for the line number on some
+  // nodes.
+  if (line < 65535)
+    node->line = (unsigned short)line;
+#else
+  // XXX: If Nokogiri gets a `#line=` method, we'll use that.
+#endif
+}
-  GumboVector *children = &output->document->v.document.children;
-  for (size_t i=0; i < children->length; i++) {
-    GumboNode *child = children->data[i];
-    xmlNodePtr node = walk_tree(doc, child);
-    if (node) {
-      if (child == output->root)
-        xmlDocSetRootElement(doc, node);
-      else
-        xmlAddChild((xmlNodePtr)doc, node);
+// Construct an XML tree rooted at xml_output_node from the Gumbo tree rooted
+// at gumbo_node.
+static void build_tree (
+  xmlDocPtr doc,
+  xmlNodePtr xml_output_node,
+  const GumboNode *gumbo_node
+) {
+  xmlNodePtr xml_root = NIL;
+  xmlNodePtr xml_node = xml_output_node;
+  size_t child_index = 0;
+  while (true) {
+    assert(gumbo_node != NULL);
+    const GumboVector *children = gumbo_node->type == GUMBO_NODE_DOCUMENT?
+      &gumbo_node->v.document.children : &gumbo_node->v.element.children;
+    if (child_index >= children->length) {
+      // Move up the tree and to the next child.
+      if (xml_node == xml_output_node) {
+        // We've built as much of the tree as we can.
+        return;
+      }
+      child_index = gumbo_node->index_within_parent + 1;
+      gumbo_node = gumbo_node->parent;
+      xml_node = get_parent(xml_node);
+      // Children of fragments don't share the same root, so reset it and
+      // it'll be set below. In the non-fragment case, this will only happen
+      // after the html element has been finished at which point there are no
+      // further elements.
+      if (xml_node == xml_output_node)
+        xml_root = NIL;
+      continue;
+    }
+    const GumboNode *gumbo_child = children->data[child_index++];
+    xmlNodePtr xml_child;
+    switch (gumbo_child->type) {
+      case GUMBO_NODE_DOCUMENT:
+        abort(); // Bug in Gumbo.
+      case GUMBO_NODE_TEXT:
+      case GUMBO_NODE_WHITESPACE:
+        xml_child = xmlNewDocText(doc, BAD_CAST gumbo_child->v.text.text);
+        set_line(xml_child, gumbo_child->v.text.start_pos.line);
+        xmlAddChild(xml_node, xml_child);
+        break;
+      case GUMBO_NODE_CDATA:
+        xml_child = xmlNewCDataBlock(doc, BAD_CAST gumbo_child->v.text.text,
+                                     (int) strlen(gumbo_child->v.text.text));
+        set_line(xml_child, gumbo_child->v.text.start_pos.line);
+        xmlAddChild(xml_node, xml_child);
+        break;
+      case GUMBO_NODE_COMMENT:
+        xml_child = xmlNewDocComment(doc, BAD_CAST gumbo_child->v.text.text);
+        set_line(xml_child, gumbo_child->v.text.start_pos.line);
+        xmlAddChild(xml_node, xml_child);
+        break;
+      case GUMBO_NODE_TEMPLATE:
+        // XXX: Should create a template element and a new DocumentFragment
+      case GUMBO_NODE_ELEMENT:
+      {
+        xml_child = xmlNewDocNode(doc, NIL, BAD_CAST gumbo_child->v.element.name, NULL);
+        set_line(xml_child, gumbo_child->v.element.start_pos.line);
+        if (xml_root == NIL)
+          xml_root = xml_child;
+        xmlNsPtr ns = NIL;
+        switch (gumbo_child->v.element.tag_namespace) {
+        case GUMBO_NAMESPACE_HTML:
+          break;
+        case GUMBO_NAMESPACE_SVG:
+          ns = lookup_or_add_ns(doc, xml_root, "http://www.w3.org/2000/svg", "svg");
+          break;
+        case GUMBO_NAMESPACE_MATHML:
+          ns = lookup_or_add_ns(doc, xml_root, "http://www.w3.org/1998/Math/MathML", "math");
+          break;
+        }
+        if (ns != NIL)
+          xmlSetNs(xml_child, ns);
+        xmlAddChild(xml_node, xml_child);
+        // Add the attributes.
+        const GumboVector* attrs = &gumbo_child->v.element.attributes;
+        for (size_t i=0; i < attrs->length; i++) {
+          const GumboAttribute *attr = attrs->data[i];
+          switch (attr->attr_namespace) {
+            case GUMBO_ATTR_NAMESPACE_XLINK:
+              ns = lookup_or_add_ns(doc, xml_root, "http://www.w3.org/1999/xlink", "xlink");
+              break;
+            case GUMBO_ATTR_NAMESPACE_XML:
+              ns = lookup_or_add_ns(doc, xml_root, "http://www.w3.org/XML/1998/namespace", "xml");
+              break;
+            case GUMBO_ATTR_NAMESPACE_XMLNS:
+              ns = lookup_or_add_ns(doc, xml_root, "http://www.w3.org/2000/xmlns/", "xmlns");
+              break;
+            default:
+              ns = NIL;
+          }
+          xmlNewNsProp(xml_child, ns, BAD_CAST attr->name, BAD_CAST attr->value);
+        }
+        // Add children for this element.
+        child_index = 0;
+        gumbo_node = gumbo_child;
+        xml_node = xml_child;
+      }
     }
   }
+}
-  VALUE rdoc = Nokogiri_wrap_xml_document(Document, doc);
+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);
   // Add parse errors to rdoc.
   if (output->errors.length) {
-    GumboVector *errors = &output->errors;
-    GumboStringBuffer msg;
+    const GumboVector *errors = &output->errors;
     VALUE rerrors = rb_ary_new2(errors->length);
-    gumbo_string_buffer_init(&msg);
     for (size_t i=0; i < errors->length; i++) {
       GumboError *err = errors->data[i];
-      gumbo_string_buffer_clear(&msg);
-      gumbo_caret_diagnostic_to_string(err, input, input_len, &msg);
-      VALUE err_str = rb_str_new(msg.data, msg.length);
+      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);
+      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;
       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
       rb_iv_set(syntax_error, "@file", url);
-      rb_iv_set(syntax_error, "@line", INT2NUM(err->position.line));
-      rb_iv_set(syntax_error, "@str1", Qnil);
+      rb_iv_set(syntax_error, "@line", INT2NUM(position.line));
+      rb_iv_set(syntax_error, "@str1", str1);
       rb_iv_set(syntax_error, "@str2", Qnil);
       rb_iv_set(syntax_error, "@str3", Qnil);
-      rb_iv_set(syntax_error, "@int1", INT2NUM(err->type));
-      rb_iv_set(syntax_error, "@column", INT2NUM(err->position.column));
+      rb_iv_set(syntax_error, "@int1", INT2NUM(0));
+      rb_iv_set(syntax_error, "@column", INT2NUM(position.column));
       rb_ary_push(rerrors, syntax_error);
     }
     rb_iv_set(rdoc, "@errors", rerrors);
-    gumbo_string_buffer_destroy(&msg);
   }
+}
-  gumbo_destroy_output(output);
+typedef struct {
+  GumboOutput *output;
+  VALUE input;
+  VALUE url_or_frag;
+  xmlDocPtr doc;
+} ParseArgs;
+static void parse_args_mark(void *parse_args) {
+  ParseArgs *args = parse_args;
+  rb_gc_mark_maybe(args->input);
+  rb_gc_mark_maybe(args->url_or_frag);
+}
+// Wrap a ParseArgs pointer. The underlying ParseArgs must outlive the
+// wrapper.
+static VALUE wrap_parse_args(ParseArgs *args) {
+  return Data_Wrap_Struct(rb_cData, parse_args_mark, RUBY_NEVER_FREE, args);
+}
+// Returnsd the underlying ParseArgs wrapped by wrap_parse_args.
+static ParseArgs *unwrap_parse_args(VALUE obj) {
+  ParseArgs *args;
+  Data_Get_Struct(obj, ParseArgs, args);
+  return args;
+}
+static VALUE parse_cleanup(VALUE parse_args) {
+  ParseArgs *args = unwrap_parse_args(parse_args);
+  gumbo_destroy_output(args->output);
+  // Make sure garbage collection doesn't mark the objects as being live based
+  // on references from the ParseArgs. This may be unnecessary.
+  args->input = Qnil;
+  args->url_or_frag = Qnil;
+  if (args->doc != NIL)
+    xmlFreeDoc(args->doc);
+  return Qnil;
+}
+static VALUE parse_continue(VALUE parse_args);
+// Parse a string using gumbo_parse into a Nokogiri document
+static VALUE parse(VALUE self, VALUE input, VALUE url, VALUE max_attributes, VALUE max_errors, VALUE max_depth) {
+  GumboOptions options = kGumboDefaultOptions;
+  options.max_attributes = NUM2INT(max_attributes);
+  options.max_errors = NUM2INT(max_errors);
+  options.max_tree_depth = NUM2INT(max_depth);
+  GumboOutput *output = perform_parse(&options, input);
+  ParseArgs args = {
+    .output = output,
+    .input = input,
+    .url_or_frag = url,
+    .doc = NIL,
+  };
+  VALUE parse_args = wrap_parse_args(&args);
+  return rb_ensure(parse_continue, parse_args, parse_cleanup, parse_args);
+}
+static VALUE parse_continue(VALUE parse_args) {
+  ParseArgs *args = unwrap_parse_args(parse_args);
+  GumboOutput *output = args->output;
+  xmlDocPtr doc;
+  if (output->document->v.document.has_doctype) {
+    const char *name   = output->document->v.document.name;
+    const char *public = output->document->v.document.public_identifier;
+    const char *system = output->document->v.document.system_identifier;
+    public = public[0] ? public : NULL;
+    system = system[0] ? system : NULL;
+    doc = new_html_doc(name, system, public);
+  } else {
+    doc = new_html_doc(NULL, NULL, NULL);
+  }
+  args->doc = doc; // Make sure doc gets cleaned up if an error is thrown.
+  build_tree(doc, (xmlNodePtr)doc, output->document);
+  VALUE rdoc = Nokogiri_wrap_xml_document(Document, doc);
+  args->doc = NIL; // The Ruby runtime now owns doc so don't delete it.
+  add_errors(output, rdoc, args->input, args->url_or_frag);
   return rdoc;
 }
-// Initialize the Nokogumbo class and fetch constants we will use later
+static int lookup_namespace(VALUE node, bool require_known_ns) {
+  ID namespace, href;
+  CONST_ID(namespace, "namespace");
+  CONST_ID(href, "href");
+  VALUE ns = rb_funcall(node, namespace, 0);
+  if (NIL_P(ns))
+    return GUMBO_NAMESPACE_HTML;
+  ns = rb_funcall(ns, href, 0);
+  assert(RTEST(ns));
+  Check_Type(ns, T_STRING);
+  const char *href_ptr = RSTRING_PTR(ns);
+  size_t href_len = 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;
+  if (NAMESPACE_P("http://www.w3.org/1998/Math/MathML"))
+    return GUMBO_NAMESPACE_MATHML;
+  if (NAMESPACE_P("http://www.w3.org/2000/svg"))
+    return GUMBO_NAMESPACE_SVG;
+#undef NAMESPACE_P
+  if (require_known_ns)
+    rb_raise(rb_eArgError, "Unexpected namespace URI \"%*s\"", (int)href_len, href_ptr);
+  return -1;
+}
+static xmlNodePtr extract_xml_node(VALUE node) {
+#if NGLIB
+  xmlNodePtr xml_node;
+  Data_Get_Struct(node, xmlNode, xml_node);
+  return xml_node;
+#else
+  return node;
+#endif
+}
+static VALUE fragment_continue(VALUE parse_args);
+static VALUE fragment (
+  VALUE self,
+  VALUE doc_fragment,
+  VALUE tags,
+  VALUE ctx,
+  VALUE max_attributes,
+  VALUE max_errors,
+  VALUE max_depth
+) {
+  ID name = rb_intern_const("name");
+  const char *ctx_tag;
+  GumboNamespaceEnum ctx_ns;
+  GumboQuirksModeEnum quirks_mode;
+  bool form = false;
+  const char *encoding = NULL;
+  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);
+    const char *colon = memchr(ctx_tag, ':', len);
+    if (colon) {
+      switch (colon - ctx_tag) {
+      case 3:
+        if (st_strncasecmp(ctx_tag, "svg", 3) != 0)
+          goto error;
+        ctx_ns = GUMBO_NAMESPACE_SVG;
+        break;
+      case 4:
+        if (st_strncasecmp(ctx_tag, "html", 4) == 0)
+          ctx_ns = GUMBO_NAMESPACE_HTML;
+        else if (st_strncasecmp(ctx_tag, "math", 4) == 0)
+          ctx_ns = GUMBO_NAMESPACE_MATHML;
+        else
+          goto error;
+        break;
+      default:
+      error:
+        rb_raise(rb_eArgError, "Invalid context namespace '%*s'", (int)(colon - ctx_tag), ctx_tag);
+      }
+      ctx_tag = colon+1;
+    } else {
+      // For convenience, put 'svg' and 'math' in their namespaces.
+      if (len == 3 && st_strncasecmp(ctx_tag, "svg", 3) == 0)
+        ctx_ns = GUMBO_NAMESPACE_SVG;
+      else if (len == 4 && st_strncasecmp(ctx_tag, "math", 4) == 0)
+        ctx_ns = GUMBO_NAMESPACE_MATHML;
+    }
+    // Check if it's a form.
+    form = ctx_ns == GUMBO_NAMESPACE_HTML && st_strcasecmp(ctx_tag, "form") == 0;
+  } else {
+    ID element_ = rb_intern_const("element?");
+    // Context fragment name.
+    VALUE tag_name = rb_funcall(ctx, name, 0);
+    assert(RTEST(tag_name));
+    Check_Type(tag_name, T_STRING);
+    ctx_tag = StringValueCStr(tag_name);
+    // Context fragment namespace.
+    ctx_ns = lookup_namespace(ctx, true);
+    // Check for a form ancestor, including self.
+    for (VALUE node = ctx;
+         !NIL_P(node);
+         node = rb_respond_to(node, parent) ? rb_funcall(node, parent, 0) : Qnil) {
+      if (!RTEST(rb_funcall(node, element_, 0)))
+        continue;
+      VALUE element_name = rb_funcall(node, name, 0);
+      if (RSTRING_LEN(element_name) == 4
+          && !st_strcasecmp(RSTRING_PTR(element_name), "form")
+          && lookup_namespace(node, false) == GUMBO_NAMESPACE_HTML) {
+        form = true;
+        break;
+      }
+    }
+    // Encoding.
+    if (RSTRING_LEN(tag_name) == 14
+        && !st_strcasecmp(ctx_tag, "annotation-xml")) {
+      VALUE enc = rb_funcall(ctx, rb_intern_const("[]"),
+                             rb_utf8_str_new_static("encoding", 8));
+      if (RTEST(enc)) {
+        Check_Type(enc, T_STRING);
+        encoding = StringValueCStr(enc);
+      }
+    }
+  }
+  // Quirks mode.
+  VALUE doc = rb_funcall(doc_fragment, rb_intern_const("document"), 0);
+  VALUE dtd = rb_funcall(doc, internal_subset, 0);
+  if (NIL_P(dtd)) {
+    quirks_mode = GUMBO_DOCTYPE_NO_QUIRKS;
+  } else {
+    VALUE dtd_name = rb_funcall(dtd, name, 0);
+    VALUE pubid = rb_funcall(dtd, rb_intern_const("external_id"), 0);
+    VALUE sysid = rb_funcall(dtd, rb_intern_const("system_id"), 0);
+    quirks_mode = gumbo_compute_quirks_mode (
+      NIL_P(dtd_name)? NULL:StringValueCStr(dtd_name),
+      NIL_P(pubid)? NULL:StringValueCStr(pubid),
+      NIL_P(sysid)? NULL:StringValueCStr(sysid)
+    );
+  }
+  // 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;
+  GumboOutput *output = perform_parse(&options, tags);
+  ParseArgs args = {
+    .output = output,
+    .input = tags,
+    .url_or_frag = doc_fragment,
+    .doc = (xmlDocPtr)extract_xml_node(doc),
+  };
+  VALUE parse_args = wrap_parse_args(&args);
+  rb_ensure(fragment_continue, parse_args, parse_cleanup, parse_args);
+  return Qnil;
+}
+static VALUE fragment_continue(VALUE parse_args) {
+  ParseArgs *args = unwrap_parse_args(parse_args);
+  GumboOutput *output = args->output;
+  VALUE doc_fragment = args->url_or_frag;
+  xmlDocPtr xml_doc = args->doc;
+  args->doc = NIL; // The Ruby runtime owns doc so make sure we don't delete it.
+  xmlNodePtr xml_frag = extract_xml_node(doc_fragment);
+  build_tree(xml_doc, xml_frag, output->root);
+  add_errors(output, doc_fragment, args->input, rb_utf8_str_new_static("#fragment", 9));
+  return Qnil;
+}
+// Initialize the Nokogumbo class and fetch constants we will use later.
 void Init_nokogumbo() {
-  rb_funcall(rb_mKernel, rb_intern("gem"), 1, rb_str_new2("nokogiri"));
+  rb_funcall(rb_mKernel, rb_intern_const("gem"), 1, rb_utf8_str_new_static("nokogiri", 8));
   rb_require("nokogiri");
-  // class constants
-  VALUE Nokogiri = rb_const_get(rb_cObject, rb_intern("Nokogiri"));
-  VALUE HTML5 = rb_const_get(Nokogiri, rb_intern("HTML5"));
-  Document = rb_const_get(HTML5, rb_intern("Document"));
-#ifndef NGLIB
-  // more class constants
-  VALUE XML = rb_const_get(Nokogiri, rb_intern("XML"));
-  cNokogiriXmlSyntaxError = rb_const_get(XML, rb_intern("SyntaxError"));
-  Element = rb_const_get(XML, rb_intern("Element"));
-  Text = rb_const_get(XML, rb_intern("Text"));
-  CDATA = rb_const_get(XML, rb_intern("CDATA"));
-  Comment = rb_const_get(XML, rb_intern("Comment"));
-  // interned symbols
-  new = rb_intern("new");
-  attribute = rb_intern("attribute");
-  set_attribute = rb_intern("set_attribute");
-  remove_attribute = rb_intern("remove_attribute");
-  add_child = rb_intern("add_child_node_and_reparent_attrs");
-  internal_subset = rb_intern("internal_subset");
-  remove_ = rb_intern("remove");
-  create_internal_subset = rb_intern("create_internal_subset");
-  key_ = rb_intern("key?");
-  node_name_ = rb_intern("node_name=");
+  VALUE line_supported = Qtrue;
+#if !NGLIB
+  // Class constants.
+  VALUE mNokogiri = rb_const_get(rb_cObject, rb_intern_const("Nokogiri"));
+  VALUE mNokogiriXml = rb_const_get(mNokogiri, rb_intern_const("XML"));
+  cNokogiriXmlSyntaxError = rb_const_get(mNokogiriXml, rb_intern_const("SyntaxError"));
+  rb_gc_register_mark_object(cNokogiriXmlSyntaxError);
+  cNokogiriXmlElement = rb_const_get(mNokogiriXml, rb_intern_const("Element"));
+  rb_gc_register_mark_object(cNokogiriXmlElement);
+  cNokogiriXmlText = rb_const_get(mNokogiriXml, rb_intern_const("Text"));
+  rb_gc_register_mark_object(cNokogiriXmlText);
+  cNokogiriXmlCData = rb_const_get(mNokogiriXml, rb_intern_const("CDATA"));
+  rb_gc_register_mark_object(cNokogiriXmlCData);
+  cNokogiriXmlComment = rb_const_get(mNokogiriXml, rb_intern_const("Comment"));
+  rb_gc_register_mark_object(cNokogiriXmlComment);
+  // Interned symbols.
+  new = rb_intern_const("new");
+  node_name_ = rb_intern_const("node_name=");
+  // #line is not supported (returns 0)
+  line_supported = Qfalse;
 #endif
-  // define Nokogumbo module with a parse method
+  // Class constants.
+  VALUE HTML5 = rb_const_get(mNokogiri, rb_intern_const("HTML5"));
+  Document = rb_const_get(HTML5, rb_intern_const("Document"));
+  rb_gc_register_mark_object(Document);
+  // Interned symbols.
+  internal_subset = rb_intern_const("internal_subset");
+  parent = rb_intern_const("parent");
+  // Define Nokogumbo module with parse and fragment methods.
   VALUE Gumbo = rb_define_module("Nokogumbo");
-  rb_define_singleton_method(Gumbo, "parse", parse, 4);
+  rb_define_singleton_method(Gumbo, "parse", parse, 5);
+  rb_define_singleton_method(Gumbo, "fragment", fragment, 6);
+  // Add private constant for testing.
+  rb_define_const(Gumbo, "LINE_SUPPORTED", line_supported);
+  rb_funcall(Gumbo, rb_intern_const("private_constant"), 1,
+             rb_utf8_str_new_cstr("LINE_SUPPORTED"));
 }
+// vim: set shiftwidth=2 softtabstop=2 tabstop=8 expandtab: