nokogiri 1.19.3 → 1.19.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29a8cf23bf9b784bf84cf87043a08212ea4e6da9badd61f6991c9d97dbb1da2a
-  data.tar.gz: 8f2237b720384a66ada6857634e63a9f22f49b37498b20d1c9fbe6940229a06c
+  metadata.gz: 9b6ae8d128fac90392dfbe122d0c1e1e8c056fd6dc1c49cfecdef2ac1d09788f
+  data.tar.gz: 315ef5552e29320fe8008f9fceff8316718ce263668bf13d1e2f015715203540
 SHA512:
-  metadata.gz: 3af2de0a353b9d763b4ede60b22bba65de24c700fe8ba49bd11e5317e07e1d5ecc894ad98509735f3123fa7202a6686c00c0f0377ffca8b090bf258781ff58e0
-  data.tar.gz: 7d507866d672767fee8cffea87da06e870815afe29b73c58901ac5cff281b37c0d4163a96f0221c0f166b55e2b04044ff935da4b3b37d9d7cbc2b06e4f95d351
+  metadata.gz: 18e131261027295c823d6e4b4d4d0c739ac8dcfc2a5d570409f3081917f39b4c69f6719f55eb4a9e78c34e390c442abb50267bd9e0cfe8a25bfd3076a4de0bdd
+  data.tar.gz: 9ac2042bf9ce20532e61b2b0e29b9582127c034914ddf370bde9a6b0b8abad067c1e4030551451c2f171bb3b48981f83b69aa2c8b45ddb939ffd3fe88d1453ba

data/LICENSE-DEPENDENCIES.md

@@ -15,6 +15,7 @@ Note that this document is broken into multiple sections, each of which describe
   * [Native WindowsⓇ platform releases ("x64-mingw-ucrt")](#native-windows%E2%93%A1-platform-releases-x64-mingw-ucrt)
   * [JavaⓇ (JRuby) platform release ("java")](#java%E2%93%A1-jruby-platform-release-java)
 - [Appendix: Dependencies' License Texts](#appendix-dependencies-license-texts)
+  * [hashmap.c](#hashmapc)
   * [libgumbo](#libgumbo)
   * [libxml2](#libxml2)
   * [libxslt](#libxslt)
@@ -114,6 +115,34 @@ This section contains a subsection for each potentially-distributed dependency,
 Please see previous sections to understand which of these potential dependencies is actually distributed in the gem file you're downloading and using.
 
 
+### hashmap.c
+
+MIT
+
+https://github.com/tidwall/hashmap.c/blob/master/LICENSE
+
+    The MIT License (MIT)
+
+    Copyright (c) 2020 Joshua J Baker
+
+    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
+    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 so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+    FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+    COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
 ### libgumbo
 
 Apache 2.0

data/ext/nokogiri/extconf.rb

@@ -1125,6 +1125,7 @@ end
 have_func("xmlCtxtSetOptions") # introduced in libxml2 2.13.0
 have_func("xmlCtxtGetOptions") # introduced in libxml2 2.14.0
 have_func("xmlSwitchEncodingName") # introduced in libxml2 2.13.0
+have_func("xmlAddIDSafe") # introduced in libxml2 2.13.0
 have_func("rb_category_warning") # introduced in Ruby 3.0 but had trouble resolving this symbol in truffleruby
 
 other_library_versions_string = OTHER_LIBRARY_VERSIONS.map { |k, v| [k, v].join(":") }.join(",")

data/ext/nokogiri/gumbo.c

@@ -113,6 +113,71 @@ set_line(xmlNodePtr node, size_t line)
   }
 }
 
+// This function is essentially xmlNewNsProp, but we skip the full list traversal to append by
+// providing the last property in the linked list as a parameter.
+static xmlAttrPtr
+append_property(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name, const xmlChar *value, xmlAttrPtr last_prop)
+{
+  xmlAttrPtr cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
+  if (cur == NULL) {
+    return NULL;
+  }
+  memset(cur, 0, sizeof(xmlAttr));
+  cur->type = XML_ATTRIBUTE_NODE;
+  cur->parent = node;
+  xmlDocPtr doc = node->doc;
+  cur->doc = doc;
+  cur->ns = ns;
+
+  if ((doc != NULL) && (doc->dict != NULL)) {
+    cur->name = (xmlChar *) xmlDictLookup(doc->dict, name, -1);
+  } else {
+    cur->name = xmlStrdup(name);
+  }
+  if (cur->name == NULL) {
+    goto error;
+  }
+
+  if (value != NULL) {
+    cur->children = xmlNewDocText(doc, value);
+    if (cur->children == NULL) {
+      goto error;
+    }
+    cur->last = NULL;
+    xmlNodePtr tmp = cur->children;
+    while (tmp != NULL) {
+      tmp->parent = (xmlNodePtr) cur;
+      if (tmp->next == NULL) {
+        cur->last = tmp;
+      }
+      tmp = tmp->next;
+    }
+
+    if (doc != NULL) {
+      int res = xmlIsID(doc, node, cur);
+      if (res < 0) {
+        goto error;
+      }
+      if ((res == 1) && (xmlAddIDSafe(cur, value) < 0)) {
+        goto error;
+      }
+    }
+  }
+
+  if (node->properties == NULL) {
+    node->properties = cur;
+  } else {
+    last_prop->next = cur;
+    cur->prev = last_prop;
+  }
+
+  return cur;
+
+error:
+  xmlFreeProp(cur);
+  return (NULL);
+}
+
 // Construct an XML tree rooted at xml_output_node from the Gumbo tree rooted
 // at gumbo_node.
 static void
@@ -200,6 +265,7 @@ build_tree(
         xmlAddChild(xml_node, xml_child);
 
         // Add the attributes.
+        xmlAttrPtr last_prop = NULL;
         const GumboVector *attrs = &gumbo_child->v.element.attributes;
         for (size_t i = 0; i < attrs->length; i++) {
           const GumboAttribute *attr = attrs->data[i];
@@ -220,7 +286,9 @@ build_tree(
             default:
               ns = NULL;
           }
-          xmlNewNsProp(xml_child, ns, (const xmlChar *)attr->name, (const xmlChar *)attr->value);
+
+          // We micromanage the attribute list for performance reasons.
+          last_prop = append_property(xml_child, ns, (const xmlChar *)attr->name, (const xmlChar *)attr->value, last_prop);
         }
 
         // Add children for this element.
@@ -373,12 +441,20 @@ parse_continue(VALUE parse_args)
   } else {
     doc = new_html_doc(NULL, NULL, NULL);
   }
-  args->doc = doc; // Make sure doc gets cleaned up if an error is thrown.
+
+  // We're about to build the libxml2 tree structure from the Gumbo tree
+  // structure. If an exception is raised during tree building, control passes
+  // to `parse_cleanup()` which needs to free the newly allocated `xmlDoc`,
+  // `doc`. If the tree is successfully constructed, then
+  // `noko_xml_document_wrap()` will create a new Ruby object which will own
+  // `doc`. In that case, `parse_cleanup()` should not free `doc`.
+  args->doc = doc;
   build_tree(doc, (xmlNodePtr)doc, output->document);
+  args->doc = NULL;
   VALUE rdoc = noko_xml_document_wrap(args->klass, doc);
+
   rb_iv_set(rdoc, "@url", args->url_or_frag);
   rb_iv_set(rdoc, "@quirks_mode", INT2NUM(output->document->v.document.doc_type_quirks_mode));
-  args->doc = NULL; // The Ruby runtime now owns doc so don't delete it.
   add_errors(output, rdoc, args->input, args->url_or_frag);
   return rdoc;
 }
@@ -512,6 +588,7 @@ error:
         continue;
       }
       VALUE element_name = rb_funcall(node, name, 0);
+      Check_Type(element_name, T_STRING);
       if (RSTRING_LEN(element_name) == 4
           && !st_strcasecmp(RSTRING_PTR(element_name), "form")
           && lookup_namespace(node, false) == GUMBO_NAMESPACE_HTML) {
@@ -568,7 +645,7 @@ error:
     .output = output,
     .input = tags,
     .url_or_frag = doc_fragment,
-    .doc = (xmlDocPtr)extract_xml_node(doc),
+    .doc = NULL,
   };
   rb_ensure(fragment_continue, (VALUE)(&args), parse_cleanup, (VALUE)(&args));
   return Qnil;
@@ -580,9 +657,9 @@ fragment_continue(VALUE parse_args)
   ParseArgs *args = (ParseArgs *)parse_args;
   GumboOutput *output = args->output;
   VALUE doc_fragment = args->url_or_frag;
-  xmlDocPtr xml_doc = args->doc;
+  VALUE doc = rb_funcall(doc_fragment, rb_intern_const("document"), 0);
+  xmlDocPtr xml_doc = (xmlDocPtr)extract_xml_node(doc);
 
-  args->doc = NULL; // 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);
   rb_iv_set(doc_fragment, "@quirks_mode", INT2NUM(output->document->v.document.doc_type_quirks_mode));

data/ext/nokogiri/html4_document.c

@@ -18,8 +18,8 @@ rb_html_document_s_new(int argc, VALUE *argv, VALUE klass)
   htmlDocPtr doc;
 
   rb_scan_args(argc, argv, "0*", &rest);
-  uri = rb_ary_entry(rest, (long)0);
-  external_id = rb_ary_entry(rest, (long)1);
+  uri = rb_ary_entry(rest, (rb_len_t)0);
+  external_id = rb_ary_entry(rest, (rb_len_t)1);
 
   doc = htmlNewDoc(
           RTEST(uri) ? (const xmlChar *)StringValueCStr(uri) : NULL,
@@ -48,10 +48,17 @@ rb_html_document_s_read_io(VALUE klass, VALUE rb_io, VALUE rb_url, VALUE rb_enco
 
   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);
+  noko_io_read_reset_exception();
+  c_doc = htmlReadIO(noko_io_read_protected, noko_io_close, (void *)rb_io, c_url, c_encoding, options);
+  VALUE rb_io_read_exception = noko_io_read_take_exception();
 
   xmlSetStructuredErrorFunc(NULL, NULL);
 
+  if (!NIL_P(rb_io_read_exception)) {
+    xmlFreeDoc(c_doc);
+    noko_io_read_raise_exception(rb_io_read_exception);
+  }
+
   /*
    * If EncodingFound has occurred in EncodingReader, make sure to do
    * a cleanup and propagate the error.

data/ext/nokogiri/libxml2_polyfill.c

@@ -112,3 +112,15 @@ xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding)
   return (xmlSwitchToEncoding(ctxt, handler));
 }
 #endif
+
+#ifndef HAVE_XMLADDIDSAFE
+int
+xmlAddIDSafe(xmlAttrPtr attr, const xmlChar *value)
+{
+  xmlIDPtr id = xmlAddID(NULL, attr->doc, value, attr);
+  if (id) {
+    return 1;
+  }
+  return 0;
+}
+#endif

data/ext/nokogiri/nokogiri.c

@@ -50,7 +50,7 @@ void noko_init_html4_sax_parser(void);
 void noko_init_gumbo(void);
 void noko_init_test_global_handlers(void);
 
-static ID id_read, id_write, id_external_encoding;
+static ID id_read, id_write, id_external_encoding, id_io_read_exception;
 
 
 static VALUE
@@ -92,6 +92,87 @@ noko_io_read(void *io, char *c_buffer, int c_buffer_len)
 }
 
 
+typedef struct {
+  void *io;
+  char *c_buffer;
+  int c_buffer_len;
+  int n_bytes_read;
+} noko_io_read_args_t;
+
+static VALUE
+noko_io_read_call(VALUE data)
+{
+  noko_io_read_args_t *args = (noko_io_read_args_t *)data;
+  args->n_bytes_read = noko_io_read(args->io, args->c_buffer, args->c_buffer_len);
+  return Qnil;
+}
+
+
+/*
+ * Like noko_io_read, a StandardError raised by IO#read is swallowed, and libxml2 sees a read
+ * error. Any other exception (e.g., Interrupt or Timeout::ExitException) must not unwind through
+ * libxml2's stack frames, because that skips libxml2's cleanup and leaks memory, and skips the
+ * reset of the error handlers. So it is saved in a fiber-local variable, and $! is cleared until
+ * it is re-raised.
+ *
+ * A caller of libxml2 that passes this callback must call noko_io_read_reset_exception before
+ * calling libxml2, and noko_io_read_take_exception after libxml2 returns, and must re-raise a
+ * non-nil result with noko_io_read_raise_exception.
+ */
+int
+noko_io_read_protected(void *io, char *c_buffer, int c_buffer_len)
+{
+  noko_io_read_args_t args = { io, c_buffer, c_buffer_len, -1 };
+  int state = 0;
+
+  rb_protect(noko_io_read_call, (VALUE)&args, &state);
+
+  if (state) {
+    VALUE rb_errinfo_value = rb_errinfo();
+    if (RB_TYPE_P(rb_errinfo_value, T_OBJECT) && rb_obj_is_kind_of(rb_errinfo_value, rb_eException)) {
+      rb_set_errinfo(Qnil);
+    } else {
+      rb_errinfo_value = Qnil;
+    }
+    rb_thread_local_aset(rb_thread_current(), id_io_read_exception,
+                         rb_assoc_new(INT2FIX(state), rb_errinfo_value));
+    return -1;
+  }
+
+  return args.n_bytes_read;
+}
+
+
+void
+noko_io_read_reset_exception(void)
+{
+  rb_thread_local_aset(rb_thread_current(), id_io_read_exception, Qnil);
+}
+
+
+VALUE
+noko_io_read_take_exception(void)
+{
+  VALUE rb_thread = rb_thread_current();
+  VALUE rb_exception = rb_thread_local_aref(rb_thread, id_io_read_exception);
+
+  rb_thread_local_aset(rb_thread, id_io_read_exception, Qnil);
+  return rb_exception;
+}
+
+
+void
+noko_io_read_raise_exception(VALUE rb_exception)
+{
+  VALUE rb_errinfo_value = rb_ary_entry(rb_exception, 1);
+
+  if (!NIL_P(rb_errinfo_value)) {
+    rb_set_errinfo(rb_errinfo_value);
+  }
+  rb_jump_tag(FIX2INT(rb_ary_entry(rb_exception, 0)));
+}
+
+
 static VALUE
 noko_io_write_check(VALUE rb_args)
 {
@@ -122,7 +203,7 @@ noko_io_write(void *io, char *c_buffer, int c_buffer_len)
   io_encoding = RB_NIL_P(rb_enc) ? rb_ascii8bit_encoding() : rb_to_encoding(rb_enc);
 
   rb_args[0] = rb_io;
-  rb_args[1] = rb_enc_str_new(c_buffer, (long)c_buffer_len, io_encoding);
+  rb_args[1] = rb_enc_str_new(c_buffer, (rb_len_t)c_buffer_len, io_encoding);
 
   rb_n_bytes_written = rb_rescue(noko_io_write_check, (VALUE)rb_args, noko_io_write_failed, 0);
   if (rb_n_bytes_written == Qundef) { return -1; }
@@ -203,9 +284,6 @@ Init_nokogiri(void)
   rb_const_set(mNokogiri, rb_intern("LIBXSLT_COMPILED_VERSION"), NOKOGIRI_STR_NEW2(LIBXSLT_DOTTED_VERSION));
   rb_const_set(mNokogiri, rb_intern("LIBXSLT_LOADED_VERSION"), NOKOGIRI_STR_NEW2(xsltEngineVersion));
 
-  rb_const_set(mNokogiri, rb_intern("LIBXML_ZLIB_ENABLED"),
-               xmlHasFeature(XML_WITH_ZLIB) == 1 ? Qtrue : Qfalse);
-
 #ifdef NOKOGIRI_PACKAGED_LIBRARIES
   rb_const_set(mNokogiri, rb_intern("PACKAGED_LIBRARIES"), Qtrue);
 #  ifdef NOKOGIRI_PRECOMPILED_LIBRARIES
@@ -228,6 +306,12 @@ Init_nokogiri(void)
   rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qfalse);
 #endif
 
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ZLIB_ENABLED"),
+               xmlHasFeature(XML_WITH_ZLIB) == 1 ? Qtrue : Qfalse);
+
+  rb_const_set(mNokogiri, rb_intern("LIBXML_HTTP_ENABLED"),
+               xmlHasFeature(XML_WITH_HTTP) == 1 ? Qtrue : Qfalse);
+
 #ifdef NOKOGIRI_OTHER_LIBRARY_VERSIONS
   rb_const_set(mNokogiri, rb_intern("OTHER_LIBRARY_VERSIONS"), NOKOGIRI_STR_NEW2(NOKOGIRI_OTHER_LIBRARY_VERSIONS));
 #endif
@@ -289,6 +373,7 @@ Init_nokogiri(void)
   noko_init_test_global_handlers();
 
   id_read = rb_intern("read");
+  id_io_read_exception = rb_intern("__nokogiri_io_read_exception");
   id_write = rb_intern("write");
   id_external_encoding = rb_intern("external_encoding");
 }

data/ext/nokogiri/nokogiri.h

@@ -66,6 +66,9 @@ int xmlCtxtGetOptions(xmlParserCtxtPtr ctxt);
 #ifndef HAVE_XMLSWITCHENCODINGNAME
 int xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding);
 #endif
+#ifndef HAVE_XMLADDIDSAFE
+int xmlAddIDSafe(xmlAttrPtr attr, const xmlChar *value);
+#endif
 
 #define XMLNS_PREFIX "xmlns"
 #define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
@@ -85,7 +88,7 @@ int xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding);
 #include <ruby/version.h>
 
 #define NOKOGIRI_STR_NEW2(str) NOKOGIRI_STR_NEW(str, strlen((const char *)(str)))
-#define NOKOGIRI_STR_NEW(str, len) rb_external_str_new_with_enc((const char *)(str), (long)(len), rb_utf8_encoding())
+#define NOKOGIRI_STR_NEW(str, len) rb_external_str_new_with_enc((const char *)(str), (rb_len_t)(len), rb_utf8_encoding())
 #define RBSTR_OR_QNIL(_str) (_str ? NOKOGIRI_STR_NEW2(_str) : Qnil)
 
 #ifndef NORETURN_DECL
@@ -178,11 +181,24 @@ void noko_xml_document_pin_namespace(xmlNsPtr, xmlDocPtr);
 int noko_xml_document_has_wrapped_blank_nodes_p(xmlDocPtr c_document);
 
 int noko_io_read(void *ctx, char *buffer, int len);
+int noko_io_read_protected(void *ctx, char *buffer, int len);
+void noko_io_read_reset_exception(void);
+VALUE noko_io_read_take_exception(void);
+NORETURN_DECL void noko_io_read_raise_exception(VALUE rb_exception);
 int noko_io_write(void *ctx, char *buffer, int len);
 int noko_io_close(void *ctx);
 
-#define Noko_Node_Get_Struct(obj,type,sval) ((sval) = (type*)DATA_PTR(obj))
-#define Noko_Namespace_Get_Struct(obj,type,sval) ((sval) = (type*)DATA_PTR(obj))
+static inline void *
+_noko_data_ptr(VALUE rb_object)
+{
+  void *c_data = DATA_PTR(rb_object);
+  if (c_data == NULL) {
+    rb_raise(rb_eRuntimeError, "Uninitialized %" PRIsVALUE " struct (null data pointer)", rb_obj_class(rb_object));
+  }
+  return c_data;
+}
+#define Noko_Node_Get_Struct(obj,type,sval) ((sval) = (type*)_noko_data_ptr(obj))
+#define Noko_Namespace_Get_Struct(obj,type,sval) ((sval) = (type*)_noko_data_ptr(obj))
 
 VALUE noko_xml_node_wrap(VALUE klass, xmlNodePtr node) ;
 VALUE noko_xml_node_wrap_node_set_result(xmlNodePtr node, VALUE node_set) ;
@@ -225,6 +241,17 @@ void noko_xml_sax_parser_context_set_encoding(xmlParserCtxtPtr c_context, VALUE
 #  define NOKO_WARN_DEPRECATION(message...) rb_warning(message)
 #endif
 
+#ifndef HAVE_RB_LEN_T
+typedef long rb_len_t;
+#endif
+#ifndef RB_NUM2LEN
+#define RB_NUM2LEN RB_NUM2LONG
+#endif
+/* Ruby 4.1.0-preview1 defines HAVE_RB_LEN_T but not RB_FIX2LEN, which came later. */
+#ifndef RB_FIX2LEN
+#define RB_FIX2LEN RB_FIX2LONG
+#endif
+
 void noko__structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state);
 void noko__structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state, void *user_data,
     xmlStructuredErrorFunc handler);

data/ext/nokogiri/xml_attr.c

@@ -10,37 +10,42 @@ VALUE cNokogiriXmlAttr;
  * (e.g., a HTML boolean attribute).
  */
 static VALUE
-set_value(VALUE self, VALUE content)
+noko_xml_attr_set_value(VALUE self, VALUE content)
 {
   xmlAttrPtr attr;
-  xmlChar *value;
-  xmlNode *cur;
 
   Noko_Node_Get_Struct(self, xmlAttr, attr);
 
-  if (attr->children) {
-    xmlFreeNodeList(attr->children);
+  {
+    /* Unlink and pin any wrapped children */
+    xmlNode *cur = attr->children;
+    xmlNode *next;
+
+    while (cur) {
+      next = cur->next;
+      if (cur->_private) {
+        xmlUnlinkNode(cur);
+        noko_xml_document_pin_node(cur);
+      }
+      cur = next;
+    }
   }
-  attr->children = attr->last = NULL;
 
   if (content == Qnil) {
-    return content;
-  }
-
-  value = xmlEncodeEntitiesReentrant(attr->doc, (unsigned char *)StringValueCStr(content));
-  if (xmlStrlen(value) == 0) {
-    attr->children = xmlNewDocText(attr->doc, value);
+    xmlNodeSetContent((xmlNodePtr)attr, NULL); /* Clear any remaining unwrapped children. */
   } else {
-    attr->children = xmlStringGetNodeList(attr->doc, value);
-  }
-  xmlFree(value);
+    xmlChar *value = xmlEncodeEntitiesReentrant(attr->doc, (unsigned char *)StringValueCStr(content));
+
+    if (xmlStrlen(value) == 0) {
+      xmlNodeSetContent((xmlNodePtr)attr, NULL); /* Clear any remaining unwrapped children. */
 
-  for (cur = attr->children; cur; cur = cur->next) {
-    cur->parent = (xmlNode *)attr;
-    cur->doc = attr->doc;
-    if (cur->next == NULL) {
-      attr->last = cur;
+      /* Preserve empty-string attributes as `foo=""` and not boolean `foo` */
+      attr->children = attr->last = xmlNewDocText(attr->doc, value);
+      attr->children->parent = (xmlNode *)attr;
+    } else {
+      xmlNodeSetContent((xmlNodePtr)attr, value);
     }
+    xmlFree(value);
   }
 
   return content;
@@ -53,7 +58,7 @@ set_value(VALUE self, VALUE content)
  * Create a new Attr element on the +document+ with +name+
  */
 static VALUE
-new (int argc, VALUE *argv, VALUE klass)
+noko_xml_attr__new(int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr xml_doc;
   VALUE document;
@@ -97,7 +102,7 @@ noko_init_xml_attr(void)
    */
   cNokogiriXmlAttr = rb_define_class_under(mNokogiriXml, "Attr", cNokogiriXmlNode);
 
-  rb_define_singleton_method(cNokogiriXmlAttr, "new", new, -1);
+  rb_define_singleton_method(cNokogiriXmlAttr, "new", noko_xml_attr__new, -1);
 
-  rb_define_method(cNokogiriXmlAttr, "value=", set_value, 1);
+  rb_define_method(cNokogiriXmlAttr, "value=", noko_xml_attr_set_value, 1);
 }