nokogiri 1.9.1 → 1.15.3

data/ext/nokogiri/xslt_stylesheet.c

@@ -1,52 +1,64 @@
-#include <xslt_stylesheet.h>
+#include <nokogiri.h>
 
-#include <libxslt/xsltInternals.h>
-#include <libxslt/xsltutils.h>
-#include <libxslt/transform.h>
-#include <libexslt/exslt.h>
-
-VALUE xslt;
-
-int vasprintf (char **strp, const char *fmt, va_list ap);
-void vasprintf_free (void *p);
+VALUE cNokogiriXsltStylesheet ;
 
-static void mark(nokogiriXsltStylesheetTuple *wrapper)
+static void
+mark(void *data)
 {
+  nokogiriXsltStylesheetTuple *wrapper = (nokogiriXsltStylesheetTuple *)data;
   rb_gc_mark(wrapper->func_instances);
 }
 
-static void dealloc(nokogiriXsltStylesheetTuple *wrapper)
+static void
+dealloc(void *data)
 {
-    xsltStylesheetPtr doc = wrapper->ss;
-
-    NOKOGIRI_DEBUG_START(doc);
-    xsltFreeStylesheet(doc); /* commented out for now. */
-    NOKOGIRI_DEBUG_END(doc);
-
-    free(wrapper);
+  nokogiriXsltStylesheetTuple *wrapper = (nokogiriXsltStylesheetTuple *)data;
+  xsltStylesheetPtr doc = wrapper->ss;
+  xsltFreeStylesheet(doc);
+  ruby_xfree(wrapper);
 }
 
-static void xslt_generic_error_handler(void * ctx, const char *msg, ...)
+static const rb_data_type_t xslt_stylesheet_type = {
+  .wrap_struct_name = "Nokogiri::XSLT::Stylesheet",
+  .function = {
+    .dmark = mark,
+    .dfree = dealloc,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+PRINTFLIKE_DECL(2, 3)
+static void
+xslt_generic_error_handler(void *ctx, const char *msg, ...)
 {
-  char * message;
+  VALUE message;
 
+#ifdef TRUFFLERUBY_NOKOGIRI_SYSTEM_LIBRARIES
+  /* It is not currently possible to pass var args from native
+     functions to sulong, so we work around the issue here. */
+  message = rb_sprintf("xslt_generic_error_handler: %s", msg);
+#else
   va_list args;
   va_start(args, msg);
-  vasprintf(&message, msg, args);
+  message = rb_vsprintf(msg, args);
   va_end(args);
+#endif
 
-  rb_str_cat2((VALUE)ctx, message);
-
-  vasprintf_free(message);
+  rb_str_concat((VALUE)ctx, message);
 }
 
-VALUE Nokogiri_wrap_xslt_stylesheet(xsltStylesheetPtr ss)
+VALUE
+Nokogiri_wrap_xslt_stylesheet(xsltStylesheetPtr ss)
 {
   VALUE self;
   nokogiriXsltStylesheetTuple *wrapper;
 
-  self = Data_Make_Struct(cNokogiriXsltStylesheet, nokogiriXsltStylesheetTuple,
-                          mark, dealloc, wrapper);
+  self = TypedData_Make_Struct(
+           cNokogiriXsltStylesheet,
+           nokogiriXsltStylesheetTuple,
+           &xslt_stylesheet_type,
+           wrapper
+         );
 
   ss->_private = (void *)self;
   wrapper->ss = ss;
@@ -61,29 +73,30 @@ VALUE Nokogiri_wrap_xslt_stylesheet(xsltStylesheetPtr ss)
  *
  * Parse a stylesheet from +document+.
  */
-static VALUE parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
+static VALUE
+parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
 {
-    xmlDocPtr xml, xml_cpy;
-    VALUE errstr, exception;
-    xsltStylesheetPtr ss ;
-    Data_Get_Struct(xmldocobj, xmlDoc, xml);
-    exsltRegisterAll();
+  xmlDocPtr xml, xml_cpy;
+  VALUE errstr, exception;
+  xsltStylesheetPtr ss ;
 
-    errstr = rb_str_new(0, 0);
-    xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
+  xml = noko_xml_document_unwrap(xmldocobj);
 
-    xml_cpy = xmlCopyDoc(xml, 1); /* 1 => recursive */
-    ss = xsltParseStylesheetDoc(xml_cpy);
+  errstr = rb_str_new(0, 0);
+  xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
 
-    xsltSetGenericErrorFunc(NULL, NULL);
+  xml_cpy = xmlCopyDoc(xml, 1); /* 1 => recursive */
+  ss = xsltParseStylesheetDoc(xml_cpy);
 
-    if (!ss) {
-	xmlFreeDoc(xml_cpy);
-	exception = rb_exc_new3(rb_eRuntimeError, errstr);
-	rb_exc_raise(exception);
-    }
+  xsltSetGenericErrorFunc(NULL, NULL);
 
-    return Nokogiri_wrap_xslt_stylesheet(ss);
+  if (!ss) {
+    xmlFreeDoc(xml_cpy);
+    exception = rb_exc_new3(rb_eRuntimeError, errstr);
+    rb_exc_raise(exception);
+  }
+
+  return Nokogiri_wrap_xslt_stylesheet(ss);
 }
 
 
@@ -93,178 +106,311 @@ static VALUE parse_stylesheet_doc(VALUE klass, VALUE xmldocobj)
  *
  * Serialize +document+ to an xml string.
  */
-static VALUE serialize(VALUE self, VALUE xmlobj)
-{
-    xmlDocPtr xml ;
-    nokogiriXsltStylesheetTuple *wrapper;
-    xmlChar* doc_ptr ;
-    int doc_len ;
-    VALUE rval ;
-
-    Data_Get_Struct(xmlobj, xmlDoc, xml);
-    Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);
-    xsltSaveResultToString(&doc_ptr, &doc_len, xml, wrapper->ss);
-    rval = NOKOGIRI_STR_NEW(doc_ptr, doc_len);
-    xmlFree(doc_ptr);
-    return rval ;
-}
-
-static void swallow_superfluous_xml_errors(void * userdata, xmlErrorPtr error, ...)
+static VALUE
+rb_xslt_stylesheet_serialize(VALUE self, VALUE xmlobj)
 {
+  xmlDocPtr xml ;
+  nokogiriXsltStylesheetTuple *wrapper;
+  xmlChar *doc_ptr ;
+  int doc_len ;
+  VALUE rval ;
+
+  xml = noko_xml_document_unwrap(xmlobj);
+  TypedData_Get_Struct(
+    self,
+    nokogiriXsltStylesheetTuple,
+    &xslt_stylesheet_type,
+    wrapper
+  );
+  xsltSaveResultToString(&doc_ptr, &doc_len, xml, wrapper->ss);
+  rval = NOKOGIRI_STR_NEW(doc_ptr, doc_len);
+  xmlFree(doc_ptr);
+  return rval ;
 }
 
 /*
- *  call-seq:
- *    transform(document, params = [])
+ * call-seq:
+ *   transform(document)
+ *   transform(document, params = {})
+ *
+ * Apply an XSLT stylesheet to an XML::Document.
+ *
+ * [Parameters]
+ * - +document+ (Nokogiri::XML::Document) the document to be transformed.
+ * - +params+ (Hash, Array) strings used as XSLT parameters.
+ *
+ * [Returns] Nokogiri::XML::Document
+ *
+ * *Example* of basic transformation:
+ *
+ *   xslt = <<~XSLT
+ *     <xsl:stylesheet version="1.0"
+ *     xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+ *
+ *     <xsl:param name="title"/>
+ *
+ *     <xsl:template match="/">
+ *       <html>
+ *         <body>
+ *           <h1><xsl:value-of select="$title"/></h1>
+ *           <ol>
+ *             <xsl:for-each select="staff/employee">
+ *               <li><xsl:value-of select="employeeId"></li>
+ *             </xsl:for-each>
+ *           </ol>
+ *         </body>
+ *       </html>
+ *     </xsl:stylesheet>
+ *   XSLT
+ *
+ *   xml = <<~XML
+ *     <?xml version="1.0"?>
+ *     <staff>
+ *       <employee>
+ *         <employeeId>EMP0001</employeeId>
+ *         <position>Accountant</position>
+ *       </employee>
+ *       <employee>
+ *         <employeeId>EMP0002</employeeId>
+ *         <position>Developer</position>
+ *       </employee>
+ *     </staff>
+ *   XML
+ *
+ *   doc = Nokogiri::XML::Document.parse(xml)
+ *   stylesheet = Nokogiri::XSLT.parse(xslt)
  *
- *  Apply an XSLT stylesheet to an XML::Document.
- *  +params+ is an array of strings used as XSLT parameters.
- *  returns Nokogiri::XML::Document
+ * ⚠ Note that the +h1+ element is empty because no param has been provided!
  *
- *  Example:
+ *   stylesheet.transform(doc).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1></h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
  *
- *    doc   = Nokogiri::XML(File.read(ARGV[0]))
- *    xslt  = Nokogiri::XSLT(File.read(ARGV[1]))
- *    puts xslt.transform(doc, ['key', 'value'])
+ * *Example* of using an input parameter hash:
  *
+ * ⚠ The title is populated, but note how we need to quote-escape the value.
+ *
+ *   stylesheet.transform(doc, { "title" => "'Employee List'" }).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1>Employee List</h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
+ *
+ * *Example* using the XSLT.quote_params helper method to safely quote-escape strings:
+ *
+ *   stylesheet.transform(doc, Nokogiri::XSLT.quote_params({ "title" => "Aaron's List" })).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1>Aaron's List</h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
+ *
+ * *Example* using an array of XSLT parameters
+ *
+ * You can also use an array if you want to.
+ *
+ *   stylesheet.transform(doc, ["title", "'Employee List'"]).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1>Employee List</h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
+ *
+ * Or pass an array to XSLT.quote_params:
+ *
+ *   stylesheet.transform(doc, Nokogiri::XSLT.quote_params(["title", "Aaron's List"])).to_xml
+ *   # => "<html><body>\n" +
+ *   #    "<h1>Aaron's List</h1>\n" +
+ *   #    "<ol>\n" +
+ *   #    "<li>EMP0001</li>\n" +
+ *   #    "<li>EMP0002</li>\n" +
+ *   #    "</ol>\n" +
+ *   #    "</body></html>\n"
+ *
+ * See: Nokogiri::XSLT.quote_params
  */
-static VALUE transform(int argc, VALUE* argv, VALUE self)
+static VALUE
+rb_xslt_stylesheet_transform(int argc, VALUE *argv, VALUE self)
 {
-    VALUE xmldoc, paramobj, errstr, exception ;
-    xmlDocPtr xml ;
-    xmlDocPtr result ;
-    nokogiriXsltStylesheetTuple *wrapper;
-    const char** params ;
-    long param_len, j ;
-    int parse_error_occurred ;
-
-    rb_scan_args(argc, argv, "11", &xmldoc, &paramobj);
-    if (NIL_P(paramobj)) { paramobj = rb_ary_new2(0L) ; }
-    if (!rb_obj_is_kind_of(xmldoc, cNokogiriXmlDocument))
-      rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::Document");
-
-    /* handle hashes as arguments. */
-    if(T_HASH == TYPE(paramobj)) {
-      paramobj = rb_funcall(paramobj, rb_intern("to_a"), 0);
-      paramobj = rb_funcall(paramobj, rb_intern("flatten"), 0);
-    }
-
-    Check_Type(paramobj, T_ARRAY);
-
-    Data_Get_Struct(xmldoc, xmlDoc, xml);
-    Data_Get_Struct(self, nokogiriXsltStylesheetTuple, wrapper);
-
-    param_len = RARRAY_LEN(paramobj);
-    params = calloc((size_t)param_len+1, sizeof(char*));
-    for (j = 0 ; j < param_len ; j++) {
-      VALUE entry = rb_ary_entry(paramobj, j);
-      const char * ptr = StringValueCStr(entry);
-      params[j] = ptr;
-    }
-    params[param_len] = 0 ;
-
-    errstr = rb_str_new(0, 0);
-    xsltSetGenericErrorFunc((void *)errstr, xslt_generic_error_handler);
-    xmlSetGenericErrorFunc(NULL, (xmlGenericErrorFunc)&swallow_superfluous_xml_errors);
-
-    result = xsltApplyStylesheet(wrapper->ss, xml, params);
-    free(params);
-
-    xsltSetGenericErrorFunc(NULL, NULL);
-    xmlSetGenericErrorFunc(NULL, NULL);
-
-    parse_error_occurred = (Qfalse == rb_funcall(errstr, rb_intern("empty?"), 0));
-
-    if (parse_error_occurred) {
-      exception = rb_exc_new3(rb_eRuntimeError, errstr);
-      rb_exc_raise(exception);
-    }
-
-    return Nokogiri_wrap_xml_document((VALUE)0, result) ;
+  VALUE rb_document, rb_param, rb_error_str;
+  xmlDocPtr c_document ;
+  xmlDocPtr c_result_document ;
+  nokogiriXsltStylesheetTuple *wrapper;
+  const char **params ;
+  long param_len, j ;
+  int parse_error_occurred ;
+  int defensive_copy_p = 0;
+
+  rb_scan_args(argc, argv, "11", &rb_document, &rb_param);
+  if (NIL_P(rb_param)) { rb_param = rb_ary_new2(0L) ; }
+  if (!rb_obj_is_kind_of(rb_document, cNokogiriXmlDocument)) {
+    rb_raise(rb_eArgError, "argument must be a Nokogiri::XML::Document");
+  }
+
+  /* handle hashes as arguments. */
+  if (T_HASH == TYPE(rb_param)) {
+    rb_param = rb_funcall(rb_param, rb_intern("to_a"), 0);
+    rb_param = rb_funcall(rb_param, rb_intern("flatten"), 0);
+  }
+
+  Check_Type(rb_param, T_ARRAY);
+
+  c_document = noko_xml_document_unwrap(rb_document);
+  TypedData_Get_Struct(self, nokogiriXsltStylesheetTuple, &xslt_stylesheet_type, wrapper);
+
+  param_len = RARRAY_LEN(rb_param);
+  params = ruby_xcalloc((size_t)param_len + 1, sizeof(char *));
+  for (j = 0 ; j < param_len ; j++) {
+    VALUE entry = rb_ary_entry(rb_param, j);
+    const char *ptr = StringValueCStr(entry);
+    params[j] = ptr;
+  }
+  params[param_len] = 0 ;
+
+  xsltTransformContextPtr c_transform_context = xsltNewTransformContext(wrapper->ss, c_document);
+  if (xsltNeedElemSpaceHandling(c_transform_context) &&
+      noko_xml_document_has_wrapped_blank_nodes_p(c_document)) {
+    // see https://github.com/sparklemotion/nokogiri/issues/2800
+    c_document = xmlCopyDoc(c_document, 1);
+    defensive_copy_p = 1;
+  }
+  xsltFreeTransformContext(c_transform_context);
+
+  rb_error_str = rb_str_new(0, 0);
+  xsltSetGenericErrorFunc((void *)rb_error_str, xslt_generic_error_handler);
+  xmlSetGenericErrorFunc((void *)rb_error_str, xslt_generic_error_handler);
+
+  c_result_document = xsltApplyStylesheet(wrapper->ss, c_document, params);
+
+  ruby_xfree(params);
+  if (defensive_copy_p) {
+    xmlFreeDoc(c_document);
+    c_document = NULL;
+  }
+
+  xsltSetGenericErrorFunc(NULL, NULL);
+  xmlSetGenericErrorFunc(NULL, NULL);
+
+  parse_error_occurred = (Qfalse == rb_funcall(rb_error_str, rb_intern("empty?"), 0));
+
+  if (parse_error_occurred) {
+    rb_exc_raise(rb_exc_new3(rb_eRuntimeError, rb_error_str));
+  }
+
+  return noko_xml_document_wrap((VALUE)0, c_result_document) ;
 }
 
-static void method_caller(xmlXPathParserContextPtr ctxt, int nargs)
+static void
+method_caller(xmlXPathParserContextPtr ctxt, int nargs)
 {
-    VALUE handler;
-    const char *function_name;
-    xsltTransformContextPtr transform;
-    const xmlChar *functionURI;
-
-    transform = xsltXPathGetTransformContext(ctxt);
-    functionURI = ctxt->context->functionURI;
-    handler = (VALUE)xsltGetExtData(transform, functionURI);
-    function_name = (const char*)(ctxt->context->function);
-
-    Nokogiri_marshal_xpath_funcall_and_return_values(ctxt, nargs, handler, (const char*)function_name);
+  VALUE handler;
+  const char *function_name;
+  xsltTransformContextPtr transform;
+  const xmlChar *functionURI;
+
+  transform = xsltXPathGetTransformContext(ctxt);
+  functionURI = ctxt->context->functionURI;
+  handler = (VALUE)xsltGetExtData(transform, functionURI);
+  function_name = (const char *)(ctxt->context->function);
+
+  Nokogiri_marshal_xpath_funcall_and_return_values(
+    ctxt,
+    nargs,
+    handler,
+    (const char *)function_name
+  );
 }
 
-static void * initFunc(xsltTransformContextPtr ctxt, const xmlChar *uri)
+static void *
+initFunc(xsltTransformContextPtr ctxt, const xmlChar *uri)
 {
-    VALUE modules = rb_iv_get(xslt, "@modules");
-    VALUE obj = rb_hash_aref(modules, rb_str_new2((const char *)uri));
-    VALUE args = { Qfalse };
-    VALUE methods = rb_funcall(obj, rb_intern("instance_methods"), 1, args);
-    VALUE inst;
-    nokogiriXsltStylesheetTuple *wrapper;
-    int i;
-
-    for(i = 0; i < RARRAY_LEN(methods); i++) {
-	VALUE method_name = rb_obj_as_string(rb_ary_entry(methods, i));
-	xsltRegisterExtFunction(ctxt,
-          (unsigned char *)StringValueCStr(method_name), uri, method_caller);
-    }
-
-    Data_Get_Struct((VALUE)ctxt->style->_private, nokogiriXsltStylesheetTuple,
-                    wrapper);
-    inst = rb_class_new_instance(0, NULL, obj);
-    rb_ary_push(wrapper->func_instances, inst);
-
-    return (void *)inst;
+  VALUE modules = rb_iv_get(mNokogiriXslt, "@modules");
+  VALUE obj = rb_hash_aref(modules, rb_str_new2((const char *)uri));
+  VALUE args = { Qfalse };
+  VALUE methods = rb_funcall(obj, rb_intern("instance_methods"), 1, args);
+  VALUE inst;
+  nokogiriXsltStylesheetTuple *wrapper;
+  int i;
+
+  for (i = 0; i < RARRAY_LEN(methods); i++) {
+    VALUE method_name = rb_obj_as_string(rb_ary_entry(methods, i));
+    xsltRegisterExtFunction(
+      ctxt,
+      (unsigned char *)StringValueCStr(method_name),
+      uri,
+      method_caller
+    );
+  }
+
+  TypedData_Get_Struct(
+    (VALUE)ctxt->style->_private,
+    nokogiriXsltStylesheetTuple,
+    &xslt_stylesheet_type,
+    wrapper
+  );
+  inst = rb_class_new_instance(0, NULL, obj);
+  rb_ary_push(wrapper->func_instances, inst);
+
+  return (void *)inst;
 }
 
-static void shutdownFunc(xsltTransformContextPtr ctxt,
-	const xmlChar *uri, void *data)
+static void
+shutdownFunc(xsltTransformContextPtr ctxt,
+             const xmlChar *uri, void *data)
 {
-    nokogiriXsltStylesheetTuple *wrapper;
+  nokogiriXsltStylesheetTuple *wrapper;
 
-    Data_Get_Struct((VALUE)ctxt->style->_private, nokogiriXsltStylesheetTuple,
-                    wrapper);
+  TypedData_Get_Struct(
+    (VALUE)ctxt->style->_private,
+    nokogiriXsltStylesheetTuple,
+    &xslt_stylesheet_type,
+    wrapper
+  );
 
-    rb_ary_clear(wrapper->func_instances);
+  rb_ary_clear(wrapper->func_instances);
 }
 
-/*
- *  call-seq:
- *    register(uri, custom_handler_class)
- *
- *  Register a class that implements custom XSLT transformation functions.
- */
-static VALUE registr(VALUE self, VALUE uri, VALUE obj)
+/* docstring is in lib/nokogiri/xslt.rb */
+static VALUE
+rb_xslt_s_register(VALUE self, VALUE uri, VALUE obj)
 {
-    VALUE modules = rb_iv_get(self, "@modules");
-    if(NIL_P(modules)) rb_raise(rb_eRuntimeError, "wtf! @modules isn't set");
-
-    rb_hash_aset(modules, uri, obj);
-    xsltRegisterExtModule((unsigned char *)StringValueCStr(uri), initFunc, shutdownFunc);
-    return self;
+  VALUE modules = rb_iv_get(self, "@modules");
+  if (NIL_P(modules)) {
+    rb_raise(rb_eRuntimeError, "internal error: @modules not set");
+  }
+
+  rb_hash_aset(modules, uri, obj);
+  xsltRegisterExtModule(
+    (unsigned char *)StringValueCStr(uri),
+    initFunc,
+    shutdownFunc
+  );
+  return self;
 }
 
-VALUE cNokogiriXsltStylesheet ;
-void init_xslt_stylesheet()
+void
+noko_init_xslt_stylesheet(void)
 {
-  VALUE nokogiri;
-  VALUE klass;
-
-  nokogiri = rb_define_module("Nokogiri");
-  xslt = rb_define_module_under(nokogiri, "XSLT");
-  klass = rb_define_class_under(xslt, "Stylesheet", rb_cObject);
+  rb_define_singleton_method(mNokogiriXslt, "register", rb_xslt_s_register, 2);
+  rb_iv_set(mNokogiriXslt, "@modules", rb_hash_new());
 
-  rb_iv_set(xslt, "@modules", rb_hash_new());
+  cNokogiriXsltStylesheet = rb_define_class_under(mNokogiriXslt, "Stylesheet", rb_cObject);
 
-  cNokogiriXsltStylesheet = klass;
+  rb_undef_alloc_func(cNokogiriXsltStylesheet);
 
-  rb_define_singleton_method(klass, "parse_stylesheet_doc", parse_stylesheet_doc, 1);
-  rb_define_singleton_method(xslt, "register", registr, 2);
-  rb_define_method(klass, "serialize", serialize, 1);
-  rb_define_method(klass, "transform", transform, -1);
+  rb_define_singleton_method(cNokogiriXsltStylesheet, "parse_stylesheet_doc", parse_stylesheet_doc, 1);
+  rb_define_method(cNokogiriXsltStylesheet, "serialize", rb_xslt_stylesheet_serialize, 1);
+  rb_define_method(cNokogiriXsltStylesheet, "transform", rb_xslt_stylesheet_transform, -1);
 }

data/gumbo-parser/CHANGES.md

@@ -0,0 +1,63 @@
+## Gumbo 0.10.1 (2015-04-30)
+
+Same as 0.10.0, but with the version number bumped because the last version-number commit to v0.9.4 makes GitHub think that v0.9.4 is the latest version and so it's not highlighted on the webpage.
+
+## Gumbo 0.10.0 (2015-04-30)
+
+* Full support for `<template>` tag (kevinhendricks, nostrademons).
+* Some fixes for `<rtc>`/`<rt>` handling (kevinhendricks, vmg).
+* All html5lib-trunk tests pass now! (kevinhendricks, vmg, nostrademons)
+* Support for fragment parsing (vmg)
+* A couple additional example programs (kevinhendricks)
+* Performance improvements totaling an estimated 30-40% total improvement (vmg, nostrademons).
+
+## Gumbo 0.9.4 (2015-04-30)
+
+* Additional Visual Studio fixes (lowjoel, nostrademons)
+* Fixed some unused variable warnings.
+* Fix for glibtoolize vs. libtoolize build errors on Mac.
+* Fixed `CDATA` end tag handling.
+
+## Gumbo 0.9.3 (2015-02-17)
+
+* Bugfix for `&AElig;` entities (rgrove)
+* Fix `CDATA` handling; `CDATA` sections now generate a `GUMBO_NODE_CDATA` node rather
+than plain text.
+* Fix `get_title example` to handle whitespace nodes (gsnedders)
+* Visual Studio compilation fixes (fishioon)
+* Take the namespace into account when determining whether a node matches a
+certain tag (aroben)
+* Replace the varargs tag functions with a tagset bytevector, for a 20-30%
+speedup in overall parse time (kevinhendricks, vmg)
+* Add MacOS X support to Travis CI, and fix the deployment/DLL issues this
+uncovered (nostrademons, kevinhendricks, vmg)
+
+## Gumbo 0.9.2 (2014-09-21)
+
+* Performance improvements: Ragel-based char ref decoder and DFA-based UTF8
+decoder, totaling speedups of up to 300%.
+* Added benchmarking program and some sample data.
+* Fixed a compiler error under Visual Studio.
+* Fix an error in the ctypes bindings that could lead to memory corruption in
+the Python bindings.
+* Fix duplicate attributes when parsing `<isindex>` tags.
+* Don't leave semicolons behind when consuming entity references (rgrove)
+* Internally rename some functions in preparation for an amalgamation file
+(jdeng)
+* Add proper cflags for gyp builds (skabbes)
+
+## Gumbo 0.9.1 (2014-08-07)
+
+* First version listed on PyPi.
+* Autotools files excluded from GitHub and generated via autogen.sh. (endgame)
+* Numerous compiler warnings fixed. (bnoordhuis, craigbarnes)
+* Google security audit passed.
+* Gyp support (tfarina)
+* Naming convention for structs changed to avoid C reserved words.
+* Fix several integer and buffer overflows (Maxime2)
+* Some Visual Studio compiler support (bugparty)
+* Python3 compatibility for the ctypes bindings.
+
+## Gumbo 0.9.0 (2013-08-13)
+
+* Initial release open-sourced by Google.