nokogumbo 1.3.0 → 1.5.0

data/gumbo-parser/src/tokenizer.h

@@ -64,8 +64,8 @@ typedef struct GumboInternalToken {
     GumboTokenDocType doc_type;
     GumboTokenStartTag start_tag;
     GumboTag end_tag;
-    const char* text;    // For comments.
-    int character;      // For character, whitespace, null, and EOF tokens.
+    const char* text;  // For comments.
+    int character;     // For character, whitespace, null, and EOF tokens.
   } v;
 } GumboToken;
 

data/gumbo-parser/src/utf8.c

@@ -19,7 +19,7 @@
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
-#include <strings.h>    // For strncasecmp.
+#include <strings.h>  // For strncasecmp.
 
 #include "error.h"
 #include "gumbo.h"
@@ -47,9 +47,11 @@ const int kUtf8ReplacementChar = 0xFFFD;
 
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights to
+// in the Software without restriction, including without limitation the rights
+// to
 // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-// of the Software, and to permit persons to whom the Software is furnished to do
+// of the Software, and to permit persons to whom the Software is furnished to
+// do
 // so, subject to the following conditions:
 
 // The above copyright notice and this permission notice shall be included in
@@ -59,32 +61,35 @@ const int kUtf8ReplacementChar = 0xFFFD;
 #define UTF8_REJECT 12
 
 static const uint8_t utf8d[] = {
-  // The first part of the table maps bytes to character classes that
-  // to reduce the size of the transition table and create bitmasks.
-   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
-   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-   8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-  10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
-
-  // The second part is a transition table that maps a combination
-  // of a state of the automaton and a character class to a state.
-   0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12,
-  12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12,
-  12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12,
-  12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12,
-  12,36,12,12,12,12,12,12,12,12,12,12, 
+    // The first part of the table maps bytes to character classes that
+    // to reduce the size of the transition table and create bitmasks.
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9,
+    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 10,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 11, 6, 6, 6, 5, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 8, 8,
+
+    // The second part is a transition table that maps a combination
+    // of a state of the automaton and a character class to a state.
+    0, 12, 24, 36, 60, 96, 84, 12, 12, 12, 48, 72, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 0, 12, 12, 12, 12, 12, 0, 12, 0, 12, 12, 12, 24, 12,
+    12, 12, 12, 12, 24, 12, 24, 12, 12, 12, 12, 12, 12, 12, 12, 12, 24, 12, 12,
+    12, 12, 12, 24, 12, 12, 12, 12, 12, 12, 12, 24, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 36, 12, 36, 12, 12, 12, 36, 12, 12, 12, 12, 12, 36, 12, 36, 12, 12,
+    12, 36, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
 };
 
 uint32_t static inline decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
   uint32_t type = utf8d[byte];
 
-  *codep = (*state != UTF8_ACCEPT) ?
-    (byte & 0x3fu) | (*codep << 6) :
-    (0xff >> type) & (byte);
+  *codep = (*state != UTF8_ACCEPT) ? (byte & 0x3fu) | (*codep << 6)
+                                   : (0xff >> type) & (byte);
 
   *state = utf8d[256 + *state + type];
   return *state;
@@ -130,13 +135,13 @@ static void read_char(Utf8Iterator* iter) {
   uint32_t code_point = 0;
   uint32_t state = UTF8_ACCEPT;
   for (const char* c = iter->_start; c < iter->_end; ++c) {
-    decode(&state, &code_point, (uint32_t) (unsigned char) (*c));
+    decode(&state, &code_point, (uint32_t)(unsigned char) (*c));
     if (state == UTF8_ACCEPT) {
       iter->_width = c - iter->_start + 1;
-      // This is the special handling for carriage returns that is mandated by the
-      // HTML5 spec.  Since we're looking for particular 7-bit literal characters,
-      // we operate in terms of chars and only need a check for iter overrun,
-      // instead of having to read in a full next code point.
+      // This is the special handling for carriage returns that is mandated by
+      // the HTML5 spec.  Since we're looking for particular 7-bit literal
+      // characters, we operate in terms of chars and only need a check for iter
+      // overrun, instead of having to read in a full next code point.
       // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream
       if (code_point == '\r') {
         assert(iter->_width == 1);
@@ -165,10 +170,11 @@ static void read_char(Utf8Iterator* iter) {
       return;
     }
   }
-  // If we got here without exiting early, then we've reached the end of the iterator.
-  // Add an error for truncated input, set the width to consume the rest of the
-  // iterator, and emit a replacement character.  The next time we enter this method,
-  // it will detect that there's no input to consume and 
+  // If we got here without exiting early, then we've reached the end of the
+  // iterator.  Add an error for truncated input, set the width to consume the
+  // rest of the iterator, and emit a replacement character.  The next time we
+  // enter this method, it will detect that there's no input to consume and
+  // output an EOF.
   iter->_current = kUtf8ReplacementChar;
   iter->_width = iter->_end - iter->_start;
   add_error(iter, GUMBO_ERR_UTF8_TRUNCATED);
@@ -179,10 +185,10 @@ static void update_position(Utf8Iterator* iter) {
   if (iter->_current == '\n') {
     ++iter->_pos.line;
     iter->_pos.column = 1;
-  } else if(iter->_current == '\t') {
+  } else if (iter->_current == '\t') {
     int tab_stop = iter->_parser->_options->tab_stop;
     iter->_pos.column = ((iter->_pos.column / tab_stop) + 1) * tab_stop;
-  } else if(iter->_current != -1) {
+  } else if (iter->_current != -1) {
     ++iter->_pos.column;
   }
 }
@@ -191,13 +197,12 @@ static void update_position(Utf8Iterator* iter) {
 // forbidden by the HTML5 spec, such as undefined control chars.
 bool utf8_is_invalid_code_point(int c) {
   return (c >= 0x1 && c <= 0x8) || c == 0xB || (c >= 0xE && c <= 0x1F) ||
-      (c >= 0x7F && c <= 0x9F) || (c >= 0xFDD0 && c <= 0xFDEF) ||
-      ((c & 0xFFFF) == 0xFFFE) || ((c & 0xFFFF) == 0xFFFF);
+         (c >= 0x7F && c <= 0x9F) || (c >= 0xFDD0 && c <= 0xFDEF) ||
+         ((c & 0xFFFF) == 0xFFFE) || ((c & 0xFFFF) == 0xFFFF);
 }
 
-void utf8iterator_init(
-    GumboParser* parser, const char* source, size_t source_length,
-    Utf8Iterator* iter) {
+void utf8iterator_init(GumboParser* parser, const char* source,
+    size_t source_length, Utf8Iterator* iter) {
   iter->_start = source;
   iter->_end = source + source_length;
   iter->_pos.line = 1;
@@ -215,9 +220,7 @@ void utf8iterator_next(Utf8Iterator* iter) {
   read_char(iter);
 }
 
-int utf8iterator_current(const Utf8Iterator* iter) {
-  return iter->_current;
-}
+int utf8iterator_current(const Utf8Iterator* iter) { return iter->_current; }
 
 void utf8iterator_get_position(
     const Utf8Iterator* iter, GumboSourcePosition* output) {
@@ -232,14 +235,13 @@ const char* utf8iterator_get_end_pointer(const Utf8Iterator* iter) {
   return iter->_end;
 }
 
-bool utf8iterator_maybe_consume_match(
-    Utf8Iterator* iter, const char* prefix, size_t length,
-    bool case_sensitive) {
-  bool matched = (iter->_start + length <= iter->_end) && (case_sensitive ?
-      !strncmp(iter->_start, prefix, length) :
-      !strncasecmp(iter->_start, prefix, length));
+bool utf8iterator_maybe_consume_match(Utf8Iterator* iter, const char* prefix,
+    size_t length, bool case_sensitive) {
+  bool matched = (iter->_start + length <= iter->_end) &&
+                 (case_sensitive ? !strncmp(iter->_start, prefix, length)
+                                 : !strncasecmp(iter->_start, prefix, length));
   if (matched) {
-    for (int i = 0; i < length; ++i) {
+    for (unsigned int i = 0; i < length; ++i) {
       utf8iterator_next(iter);
     }
     return true;
@@ -262,8 +264,7 @@ void utf8iterator_reset(Utf8Iterator* iter) {
 
 // Sets the position and original text fields of an error to the value at the
 // mark.
-void utf8iterator_fill_error_at_mark(
-    Utf8Iterator* iter, GumboError* error) {
+void utf8iterator_fill_error_at_mark(Utf8Iterator* iter, GumboError* error) {
   error->position = iter->_mark_pos;
   error->original_text = iter->_mark;
 }

data/gumbo-parser/src/utf8.h

@@ -81,8 +81,7 @@ bool utf8_is_invalid_code_point(int c);
 
 // Initializes a new Utf8Iterator from the given byte buffer.  The source does
 // not have to be NUL-terminated, but the length must be passed in explicitly.
-void utf8iterator_init(
-    struct GumboInternalParser* parser, const char* source,
+void utf8iterator_init(struct GumboInternalParser* parser, const char* source,
     size_t source_length, Utf8Iterator* iter);
 
 // Advances the current position by one code point.

data/gumbo-parser/src/util.c

@@ -29,7 +29,7 @@
 // TODO(jdtang): This should be elsewhere, but there's no .c file for
 // SourcePositions and yet the constant needs some linkage, so this is as good
 // as any.
-const GumboSourcePosition kGumboEmptySourcePosition = { 0, 0, 0 };
+const GumboSourcePosition kGumboEmptySourcePosition = {0, 0, 0};
 
 void* gumbo_parser_allocate(GumboParser* parser, size_t num_bytes) {
   return parser->_options->allocator(parser->_options->userdata, num_bytes);

data/gumbo-parser/src/util.h

@@ -25,8 +25,6 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-
-
 #ifdef __cplusplus
 extern "C" {
 #endif

data/gumbo-parser/src/vector.c

@@ -25,21 +25,22 @@
 
 struct GumboInternalParser;
 
-const GumboVector kGumboEmptyVector = { NULL, 0, 0 };
+const GumboVector kGumboEmptyVector = {NULL, 0, 0};
 
-void gumbo_vector_init(
-    struct GumboInternalParser* parser, size_t initial_capacity, GumboVector* vector) {
+void gumbo_vector_init(struct GumboInternalParser* parser,
+    size_t initial_capacity, GumboVector* vector) {
   vector->length = 0;
   vector->capacity = initial_capacity;
   if (initial_capacity > 0) {
-    vector->data = gumbo_parser_allocate(
-        parser, sizeof(void*) * initial_capacity);
+    vector->data =
+        gumbo_parser_allocate(parser, sizeof(void*) * initial_capacity);
   } else {
     vector->data = NULL;
   }
 }
 
-void gumbo_vector_destroy(struct GumboInternalParser* parser, GumboVector* vector) {
+void gumbo_vector_destroy(
+    struct GumboInternalParser* parser, GumboVector* vector) {
   if (vector->capacity > 0) {
     gumbo_parser_deallocate(parser, vector->data);
   }
@@ -59,8 +60,8 @@ static void enlarge_vector_if_full(
     } else {
       // 0-capacity vector; no previous array to deallocate.
       vector->capacity = 2;
-      vector->data = gumbo_parser_allocate(
-          parser, sizeof(void*) * vector->capacity);
+      vector->data =
+          gumbo_parser_allocate(parser, sizeof(void*) * vector->capacity);
     }
   }
 }
@@ -81,8 +82,8 @@ void* gumbo_vector_pop(
   return vector->data[--vector->length];
 }
 
-int gumbo_vector_index_of(GumboVector* vector, void* element) {
-  for (int i = 0; i < vector->length; ++i) {
+int gumbo_vector_index_of(GumboVector* vector, const void* element) {
+  for (unsigned int i = 0; i < vector->length; ++i) {
     if (vector->data[i] == element) {
       return i;
     }
@@ -90,15 +91,14 @@ int gumbo_vector_index_of(GumboVector* vector, void* element) {
   return -1;
 }
 
-void gumbo_vector_insert_at(
-    struct GumboInternalParser* parser, void* element, int index,
-    GumboVector* vector) {
+void gumbo_vector_insert_at(struct GumboInternalParser* parser, void* element,
+    unsigned int index, GumboVector* vector) {
   assert(index >= 0);
   assert(index <= vector->length);
   enlarge_vector_if_full(parser, vector);
   ++vector->length;
   memmove(&vector->data[index + 1], &vector->data[index],
-          sizeof(void*) * (vector->length - index - 1));
+      sizeof(void*) * (vector->length - index - 1));
   vector->data[index] = element;
 }
 
@@ -111,13 +111,13 @@ void gumbo_vector_remove(
   gumbo_vector_remove_at(parser, index, vector);
 }
 
-void* gumbo_vector_remove_at(
-    struct GumboInternalParser* parser, int index, GumboVector* vector) {
+void* gumbo_vector_remove_at(struct GumboInternalParser* parser,
+    unsigned int index, GumboVector* vector) {
   assert(index >= 0);
   assert(index < vector->length);
   void* result = vector->data[index];
   memmove(&vector->data[index], &vector->data[index + 1],
-          sizeof(void*) * (vector->length - index - 1));
+      sizeof(void*) * (vector->length - index - 1));
   --vector->length;
   return result;
 }

data/gumbo-parser/src/vector.h

@@ -28,9 +28,8 @@ extern "C" {
 struct GumboInternalParser;
 
 // Initializes a new GumboVector with the specified initial capacity.
-void gumbo_vector_init(
-    struct GumboInternalParser* parser, size_t initial_capacity,
-    GumboVector* vector);
+void gumbo_vector_init(struct GumboInternalParser* parser,
+    size_t initial_capacity, GumboVector* vector);
 
 // Frees the memory used by an GumboVector.  Does not free the contained
 // pointers.
@@ -48,9 +47,8 @@ void* gumbo_vector_pop(struct GumboInternalParser* parser, GumboVector* vector);
 
 // Inserts an element at a specific index.  This is potentially O(N) time, but
 // is necessary for some of the spec's behavior.
-void gumbo_vector_insert_at(
-    struct GumboInternalParser* parser, void* element, int index,
-    GumboVector* vector);
+void gumbo_vector_insert_at(struct GumboInternalParser* parser, void* element,
+    unsigned int index, GumboVector* vector);
 
 // Removes an element from the vector, or does nothing if the element is not in
 // the vector.
@@ -59,8 +57,8 @@ void gumbo_vector_remove(
 
 // Removes and returns an element at a specific index.  Note that this is
 // potentially O(N) time and should be used sparingly.
-void* gumbo_vector_remove_at(
-    struct GumboInternalParser* parser, int index, GumboVector* vector);
+void* gumbo_vector_remove_at(struct GumboInternalParser* parser,
+    unsigned int index, GumboVector* vector);
 
 #ifdef __cplusplus
 }

data/gumbo-parser/visualc/include/strings.h

@@ -1,3 +1,4 @@
 /*Dummy file to satisfy source file dependencies on Windows platform*/
 #define strcasecmp _stricmp
-#define  strncasecmp _strnicmp
+#define strncasecmp _strnicmp
+#define inline __inline

data/lib/nokogumbo.rb

@@ -4,14 +4,14 @@ require 'nokogumboc'
 module Nokogiri
   # Parse an HTML document.  +string+ contains the document.  +string+
   # may also be an IO-like object.  Returns a +Nokogiri::HTML::Document+.
-  def self.HTML5(string)
-    Nokogiri::HTML5.parse(string)
+  def self.HTML5(*args)
+    Nokogiri::HTML5.parse(*args)
   end
 
   module HTML5
     # Parse an HTML document.  +string+ contains the document.  +string+
     # may also be an IO-like object.  Returns a +Nokogiri::HTML::Document+.
-    def self.parse(string)
+    def self.parse(string, options={})
       if string.respond_to? :read
         string = string.read
       end
@@ -21,7 +21,7 @@ module Nokogiri
         string = reencode(string)
       end
 
-      Nokogumbo.parse(string.to_s)
+      Nokogumbo.parse(string.to_s, options[:max_parse_errors] || 0)
     end
 
     # Fetch and parse a HTML document from the web, following redirects,
@@ -67,7 +67,7 @@ module Nokogiri
 
       case response
       when Net::HTTPSuccess
-        doc = parse(reencode(response.body, response['content-type']))
+        doc = parse(reencode(response.body, response['content-type']), options)
         doc.instance_variable_set('@response', response)
         doc.class.send(:attr_reader, :response)
         doc
@@ -83,8 +83,8 @@ module Nokogiri
     # while fragment is on the Gumbo TODO list, simulate it by doing
     # a full document parse and ignoring the parent <html>, <head>, and <body>
     # tags, and collecting up the children of each.
-    def self.fragment(string)
-      doc = parse(string)
+    def self.fragment(*args)
+      doc = parse(*args)
       fragment = Nokogiri::HTML::DocumentFragment.new(doc)
 
       if doc.children.length != 1 or doc.children.first.name != 'html'
@@ -151,7 +151,7 @@ module Nokogiri
 
         # look for a charset in a content-encoding header
         if content_type
-          encoding ||= content_type[/charset=(.*?)($|\s|;)/i, 1]
+          encoding ||= content_type[/charset=["']?(.*?)($|["';\s])/i, 1]
         end
 
         # look for a charset in a meta tag in the first 1024 bytes

data/test-nokogumbo.rb

@@ -0,0 +1,190 @@
+$:.unshift('lib')
+$:.unshift('ext/nokogumboc')
+
+gem 'minitest'
+
+require 'nokogumbo'
+require 'minitest/autorun'
+
+class TestNokogumbo < Minitest::Test
+  def test_element_text
+    doc = Nokogiri::HTML5(buffer)
+    assert_equal "content", doc.at('span').text
+  end
+
+  def test_element_cdata_textarea
+    doc = Nokogiri::HTML5(buffer)
+    assert_equal "foo<x>bar", doc.at('textarea').text.strip
+  end
+
+  def test_element_cdata_script
+    doc = Nokogiri::HTML5.fragment(buffer)
+    assert_equal true, doc.document.html?
+    assert_equal "<script> if (a < b) alert(1) </script>", doc.at('script').to_s
+  end
+
+  def test_attr_value
+    doc = Nokogiri::HTML5(buffer)
+    assert_equal "utf-8", doc.at('meta')['charset']
+  end
+
+  def test_comment
+    doc = Nokogiri::HTML5(buffer)
+    assert_equal " test comment ", doc.xpath('//comment()').text
+  end
+
+  def test_unknown_element
+    doc = Nokogiri::HTML5(buffer)
+    assert_equal "main", doc.at('main').name
+  end
+
+  def test_IO
+    require 'stringio'
+    doc = Nokogiri::HTML5(StringIO.new(buffer))
+    assert_equal 'textarea', doc.at('form').element_children.first.name
+  end
+
+  def test_nil
+    doc = Nokogiri::HTML5(nil)
+    assert_equal 1, doc.search('body').count
+  end
+
+  if ''.respond_to? 'encoding'
+    def test_macroman_encoding
+      mac="<span>\xCA</span>".force_encoding('macroman')
+      doc = Nokogiri::HTML5(mac)
+      assert_equal '<span>&#xA0;</span>', doc.at('span').to_xml
+    end
+
+    def test_iso8859_encoding
+      iso8859="<span>Se\xF1or</span>".force_encoding(Encoding::ASCII_8BIT)
+      doc = Nokogiri::HTML5(iso8859)
+      assert_equal '<span>Se&#xF1;or</span>', doc.at('span').to_xml
+    end
+
+    def test_charset_encoding
+      utf8="<meta charset='utf-8'><span>Se\xC3\xB1or</span>".
+        force_encoding(Encoding::ASCII_8BIT)
+      doc = Nokogiri::HTML5(utf8)
+      assert_equal '<span>Se&#xF1;or</span>', doc.at('span').to_xml
+    end
+
+    def test_bogus_encoding
+      bogus="<meta charset='bogus'><span>Se\xF1or</span>".
+        force_encoding(Encoding::ASCII_8BIT)
+      doc = Nokogiri::HTML5(bogus)
+      assert_equal '<span>Se&#xF1;or</span>', doc.at('span').to_xml
+    end
+  end
+
+  def test_html5_doctype
+    doc = Nokogiri::HTML5.parse("<!DOCTYPE html><html></html>")
+    assert_match /<!DOCTYPE html>/, doc.to_html
+  end
+
+  def test_fragment_head
+    doc = Nokogiri::HTML5.fragment(buffer[/<head>(.*?)<\/head>/m, 1])
+    assert_equal "hello world", doc.xpath('title').text
+    assert_equal "utf-8", doc.xpath('meta').first['charset']
+  end
+
+  def test_fragment_body
+    doc = Nokogiri::HTML5.fragment(buffer[/<body>(.*?)<\/body>/m, 1])
+    assert_equal '<span>content</span>', doc.xpath('main/span').to_xml
+    assert_equal " test comment ", doc.xpath('comment()').text
+  end
+
+  def test_xlink_attribute
+    source = <<-EOF.gsub(/^ {6}/, '')
+      <svg xmlns="http://www.w3.org/2000/svg">
+        <a xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="#s1"/>
+      </svg>
+    EOF
+    doc = Nokogiri::HTML5.fragment(source)
+    a = doc.at('a')
+    assert_equal ["xlink:href", "xmlns:xlink"], a.attributes.keys.sort
+  end
+
+  def test_template
+    source = <<-EOF.gsub(/^ {6}/, '')
+      <template id="productrow">
+        <tr>
+          <td class="record"></td>
+          <td></td>
+        </tr>
+      </template>
+    EOF
+    doc = Nokogiri::HTML5.fragment(source)
+    template = doc.at('template')
+    assert_equal "productrow", template['id']
+    assert_equal "record", template.at('td')['class']
+  end
+
+  def test_root_comments
+    doc = Nokogiri::HTML5("<!DOCTYPE html><!-- start --><html></html><!-- -->")
+    assert_equal ["html", "comment", "html", "comment"], doc.children.map(&:name)
+  end
+
+  def test_parse_errors
+    doc = Nokogiri::HTML5("<!DOCTYPE html><html><!-- -- --></a>", max_parse_errors: 10)
+    assert_equal doc.errors.length, 2
+    doc = Nokogiri::HTML5("<!DOCTYPE html><html>", max_parse_errors: 10)
+    assert_empty doc.errors
+  end
+
+  def test_max_parse_errors
+    # This document contains 2 parse errors, but we force limit to 1.
+    doc = Nokogiri::HTML5("<!DOCTYPE html><html><!-- -- --></a>", max_parse_errors: 1)
+    assert_equal 1, doc.errors.length
+    doc = Nokogiri::HTML5("<!DOCTYPE html><html>", max_parse_errors: 1)
+    assert_empty doc.errors
+  end
+
+  def test_default_max_parse_errors
+    # This document contains 200 parse errors, but default limit is 0.
+    doc = Nokogiri::HTML5("<!DOCTYPE html><html>" + "</p>" * 200)
+    assert_equal 0, doc.errors.length
+  end
+
+  def test_parse_fragment_errors
+    doc = Nokogiri::HTML5.fragment("<\r\n", max_parse_errors: 10)
+    refute_empty doc.errors
+  end
+
+  def test_fragment_max_parse_errors
+    # This fragment contains 3 parse errors, but we force limit to 1.
+    doc = Nokogiri::HTML5.fragment("<!-- -- --></a>", max_parse_errors: 1)
+    assert_equal 1, doc.errors.length
+  end
+
+  def test_fragment_default_max_parse_errors
+    # This fragment contains 201 parse errors, but default limit is 0.
+    doc = Nokogiri::HTML5.fragment("</p>" * 200)
+    assert_equal 0, doc.errors.length
+  end
+
+private
+
+  def buffer
+    <<-EOF.gsub(/^      /, '')
+      <html>
+        <head>
+          <meta charset="utf-8"/>
+          <title>hello world</title>
+          <script> if (a < b) alert(1) </script>
+        </head>
+        <body>
+          <h1>hello world</h1>
+          <main>
+            <span>content</span>
+          </main>
+          <!-- test comment -->
+          <form>
+            <textarea>foo<x>bar</textarea>
+          </form>
+        </body>
+      </html>
+    EOF
+  end
+
+end