nokogiri 1.11.2 → 1.12.5

data/ext/nokogiri/xml_node.c

@@ -2,7 +2,7 @@
 
 VALUE cNokogiriXmlNode ;
 
-static ID decorate, decorate_bang;
+static ID id_decorate, id_decorate_bang;
 
 #ifdef DEBUG
 static void
@@ -36,6 +36,7 @@ static void
 relink_namespace(xmlNodePtr reparented)
 {
   xmlNodePtr child;
+  xmlAttrPtr attr;
 
   if (reparented->type != XML_ATTRIBUTE_NODE &&
       reparented->type != XML_ELEMENT_NODE) { return; }
@@ -69,7 +70,9 @@ relink_namespace(xmlNodePtr reparented)
   if (reparented->type != XML_ELEMENT_NODE || !reparented->parent) { return; }
 
   /* Make sure that our reparented node has the correct namespaces */
-  if (!reparented->ns && reparented->doc != (xmlDocPtr)reparented->parent) {
+  if (!reparented->ns &&
+      (reparented->doc != (xmlDocPtr)reparented->parent) &&
+      (rb_iv_get(DOC_RUBY_OBJECT(reparented->doc), "@namespace_inheritance") == Qtrue)) {
     xmlSetNs(reparented, reparented->parent->ns);
   }
 
@@ -132,10 +135,10 @@ relink_namespace(xmlNodePtr reparented)
   }
 
   if (reparented->type == XML_ELEMENT_NODE) {
-    child = (xmlNodePtr)((xmlElementPtr)reparented)->attributes;
-    while (NULL != child) {
-      relink_namespace(child);
-      child = child->next;
+    attr = reparented->properties;
+    while (NULL != attr) {
+      relink_namespace((xmlNodePtr)attr);
+      attr = attr->next;
     }
   }
 }
@@ -170,7 +173,7 @@ static VALUE
 reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_reparentee_func prf)
 {
   VALUE reparented_obj ;
-  xmlNodePtr reparentee, pivot, reparented, next_text, new_next_text, parent ;
+  xmlNodePtr reparentee, original_reparentee, pivot, reparented, next_text, new_next_text, parent ;
   int original_ns_prefix_is_default = 0 ;
 
   if (!rb_obj_is_kind_of(reparentee_obj, cNokogiriXmlNode)) {
@@ -197,66 +200,66 @@ reparent_node_with(VALUE pivot_obj, VALUE reparentee_obj, pivot_reparentee_func
 
   if (parent) {
     switch (parent->type) {
-    case XML_DOCUMENT_NODE:
-    case XML_HTML_DOCUMENT_NODE:
-      switch (reparentee->type) {
-      case XML_ELEMENT_NODE:
-      case XML_PI_NODE:
-      case XML_COMMENT_NODE:
-      case XML_DOCUMENT_TYPE_NODE:
-      /*
-       * The DOM specification says no to adding text-like nodes
-       * directly to a document, but we allow it for compatibility.
-       */
-      case XML_TEXT_NODE:
-      case XML_CDATA_SECTION_NODE:
-      case XML_ENTITY_REF_NODE:
-        goto ok;
-      default:
+      case XML_DOCUMENT_NODE:
+      case XML_HTML_DOCUMENT_NODE:
+        switch (reparentee->type) {
+          case XML_ELEMENT_NODE:
+          case XML_PI_NODE:
+          case XML_COMMENT_NODE:
+          case XML_DOCUMENT_TYPE_NODE:
+          /*
+           * The DOM specification says no to adding text-like nodes
+           * directly to a document, but we allow it for compatibility.
+           */
+          case XML_TEXT_NODE:
+          case XML_CDATA_SECTION_NODE:
+          case XML_ENTITY_REF_NODE:
+            goto ok;
+          default:
+            break;
+        }
         break;
-      }
-      break;
-    case XML_DOCUMENT_FRAG_NODE:
-    case XML_ENTITY_REF_NODE:
-    case XML_ELEMENT_NODE:
-      switch (reparentee->type) {
-      case XML_ELEMENT_NODE:
-      case XML_PI_NODE:
-      case XML_COMMENT_NODE:
-      case XML_TEXT_NODE:
-      case XML_CDATA_SECTION_NODE:
+      case XML_DOCUMENT_FRAG_NODE:
       case XML_ENTITY_REF_NODE:
-        goto ok;
-      default:
+      case XML_ELEMENT_NODE:
+        switch (reparentee->type) {
+          case XML_ELEMENT_NODE:
+          case XML_PI_NODE:
+          case XML_COMMENT_NODE:
+          case XML_TEXT_NODE:
+          case XML_CDATA_SECTION_NODE:
+          case XML_ENTITY_REF_NODE:
+            goto ok;
+          default:
+            break;
+        }
+        break;
+      case XML_ATTRIBUTE_NODE:
+        switch (reparentee->type) {
+          case XML_TEXT_NODE:
+          case XML_ENTITY_REF_NODE:
+            goto ok;
+          default:
+            break;
+        }
         break;
-      }
-      break;
-    case XML_ATTRIBUTE_NODE:
-      switch (reparentee->type) {
       case XML_TEXT_NODE:
-      case XML_ENTITY_REF_NODE:
-        goto ok;
+        /*
+         * xmlAddChild() breaks the DOM specification in that it allows
+         * adding a text node to another, in which case text nodes are
+         * coalesced, but since our JRuby version does not support such
+         * operation, we should inhibit it.
+         */
+        break;
       default:
         break;
-      }
-      break;
-    case XML_TEXT_NODE:
-      /*
-       * xmlAddChild() breaks the DOM specification in that it allows
-       * adding a text node to another, in which case text nodes are
-       * coalesced, but since our JRuby version does not support such
-       * operation, we should inhibit it.
-       */
-      break;
-    default:
-      break;
     }
 
     rb_raise(rb_eArgError, "cannot reparent %s there", rb_obj_classname(reparentee_obj));
   }
 
 ok:
-  xmlUnlinkNode(reparentee);
+  original_reparentee = reparentee;
 
   if (reparentee->doc != pivot->doc || reparentee->type == XML_TEXT_NODE) {
     /*
@@ -308,11 +311,13 @@ ok:
        *  issue #391, where new node's prefix may become the string "default"
        *  see libxml2 tree.c xmlNewReconciliedNs which implements this behavior.
        */
-      xmlFree((xmlChar *)reparentee->ns->prefix);
+      xmlFree(DISCARD_CONST_QUAL_XMLCHAR(reparentee->ns->prefix));
       reparentee->ns->prefix = NULL;
     }
   }
 
+  xmlUnlinkNode(original_reparentee);
+
   if (prf != xmlAddPrevSibling && prf != xmlAddNextSibling
       && reparentee->type == XML_TEXT_NODE && pivot->next && pivot->next->type == XML_TEXT_NODE) {
     /*
@@ -357,7 +362,7 @@ ok:
 
   reparented_obj = noko_xml_node_wrap(Qnil, reparented);
 
-  rb_funcall(reparented_obj, decorate_bang, 0);
+  rb_funcall(reparented_obj, id_decorate_bang, 0);
 
   return reparented_obj ;
 }
@@ -936,7 +941,7 @@ get(VALUE self, VALUE rattribute)
   Data_Get_Struct(self, xmlNode, node);
   attribute = xmlCharStrdup(StringValueCStr(rattribute));
 
-  colon = (xmlChar *)(uintptr_t)xmlStrchr(attribute, (const xmlChar)':');
+  colon = DISCARD_CONST_QUAL_XMLCHAR(xmlStrchr(attribute, (const xmlChar)':'));
   if (colon) {
     /* split the attribute string into separate prefix and name by
      * null-terminating the prefix at the colon */
@@ -1292,17 +1297,25 @@ get_name(VALUE self)
  * Returns the path associated with this Node
  */
 static VALUE
-path(VALUE self)
+noko_xml_node_path(VALUE rb_node)
 {
-  xmlNodePtr node;
-  xmlChar *path ;
+  xmlNodePtr c_node;
+  xmlChar *c_path ;
   VALUE rval;
 
-  Data_Get_Struct(self, xmlNode, node);
+  Data_Get_Struct(rb_node, xmlNode, c_node);
+
+  c_path = xmlGetNodePath(c_node);
+  if (c_path == NULL) {
+    // see https://github.com/sparklemotion/nokogiri/issues/2250
+    // this behavior is clearly undesirable, but is what libxml <= 2.9.10 returned, and so we
+    // do this for now to preserve the behavior across libxml2 versions.
+    rval = NOKOGIRI_STR_NEW2("?");
+  } else {
+    rval = NOKOGIRI_STR_NEW2(c_path);
+    xmlFree(c_path);
+  }
 
-  path = xmlGetNodePath(node);
-  rval = NOKOGIRI_STR_NEW2(path);
-  xmlFree(path);
   return rval ;
 }
 
@@ -1443,6 +1456,7 @@ add_namespace_definition(VALUE rb_node, VALUE rb_prefix, VALUE rb_href)
  *   Create a new node with +name+ sharing GC lifecycle with +document+.
  *   @param name [String]
  *   @param document [Nokogiri::XML::Document]
+ *   @yieldparam node [Nokogiri::XML::Node]
  *   @return [Nokogiri::XML::Node]
  *   @see Nokogiri::XML::Node#initialize
  */
@@ -1632,12 +1646,12 @@ in_context(VALUE self, VALUE _str, VALUE _options)
 
   /* FIXME: This probably needs to handle more constants... */
   switch (error) {
-  case XML_ERR_INTERNAL_ERROR:
-  case XML_ERR_NO_MEMORY:
-    rb_raise(rb_eRuntimeError, "error parsing fragment (%d)", error);
-    break;
-  default:
-    break;
+    case XML_ERR_INTERNAL_ERROR:
+    case XML_ERR_NO_MEMORY:
+      rb_raise(rb_eRuntimeError, "error parsing fragment (%d)", error);
+      break;
+    default:
+      break;
   }
 
   set = xmlXPathNodeSetCreate(NULL);
@@ -1655,85 +1669,83 @@ in_context(VALUE self, VALUE _str, VALUE _options)
 
 
 VALUE
-noko_xml_node_wrap(VALUE klass, xmlNodePtr node)
+noko_xml_node_wrap(VALUE rb_class, xmlNodePtr c_node)
 {
-  VALUE document = Qnil ;
-  VALUE node_cache = Qnil ;
-  VALUE rb_node = Qnil ;
+  VALUE rb_document, rb_node_cache, rb_node;
   nokogiriTuplePtr node_has_a_document;
-  xmlDocPtr doc;
+  xmlDocPtr c_doc;
   void (*mark_method)(xmlNodePtr) = NULL ;
 
-  assert(node);
+  assert(c_node);
 
-  if (node->type == XML_DOCUMENT_NODE || node->type == XML_HTML_DOCUMENT_NODE) {
-    return DOC_RUBY_OBJECT(node->doc);
+  if (c_node->type == XML_DOCUMENT_NODE || c_node->type == XML_HTML_DOCUMENT_NODE) {
+    return DOC_RUBY_OBJECT(c_node->doc);
   }
 
   /* It's OK if the node doesn't have a fully-realized document (as in XML::Reader). */
   /* see https://github.com/sparklemotion/nokogiri/issues/95 */
   /* and https://github.com/sparklemotion/nokogiri/issues/439 */
-  doc = node->doc;
-  if (doc->type == XML_DOCUMENT_FRAG_NODE) { doc = doc->doc; }
-  node_has_a_document = DOC_RUBY_OBJECT_TEST(doc);
+  c_doc = c_node->doc;
+  if (c_doc->type == XML_DOCUMENT_FRAG_NODE) { c_doc = c_doc->doc; }
+  node_has_a_document = DOC_RUBY_OBJECT_TEST(c_doc);
 
-  if (node->_private && node_has_a_document) {
-    return (VALUE)node->_private;
+  if (c_node->_private && node_has_a_document) {
+    return (VALUE)c_node->_private;
   }
 
-  if (!RTEST(klass)) {
-    switch (node->type) {
-    case XML_ELEMENT_NODE:
-      klass = cNokogiriXmlElement;
-      break;
-    case XML_TEXT_NODE:
-      klass = cNokogiriXmlText;
-      break;
-    case XML_ATTRIBUTE_NODE:
-      klass = cNokogiriXmlAttr;
-      break;
-    case XML_ENTITY_REF_NODE:
-      klass = cNokogiriXmlEntityReference;
-      break;
-    case XML_COMMENT_NODE:
-      klass = cNokogiriXmlComment;
-      break;
-    case XML_DOCUMENT_FRAG_NODE:
-      klass = cNokogiriXmlDocumentFragment;
-      break;
-    case XML_PI_NODE:
-      klass = cNokogiriXmlProcessingInstruction;
-      break;
-    case XML_ENTITY_DECL:
-      klass = cNokogiriXmlEntityDecl;
-      break;
-    case XML_CDATA_SECTION_NODE:
-      klass = cNokogiriXmlCData;
-      break;
-    case XML_DTD_NODE:
-      klass = cNokogiriXmlDtd;
-      break;
-    case XML_ATTRIBUTE_DECL:
-      klass = cNokogiriXmlAttributeDecl;
-      break;
-    case XML_ELEMENT_DECL:
-      klass = cNokogiriXmlElementDecl;
-      break;
-    default:
-      klass = cNokogiriXmlNode;
+  if (!RTEST(rb_class)) {
+    switch (c_node->type) {
+      case XML_ELEMENT_NODE:
+        rb_class = cNokogiriXmlElement;
+        break;
+      case XML_TEXT_NODE:
+        rb_class = cNokogiriXmlText;
+        break;
+      case XML_ATTRIBUTE_NODE:
+        rb_class = cNokogiriXmlAttr;
+        break;
+      case XML_ENTITY_REF_NODE:
+        rb_class = cNokogiriXmlEntityReference;
+        break;
+      case XML_COMMENT_NODE:
+        rb_class = cNokogiriXmlComment;
+        break;
+      case XML_DOCUMENT_FRAG_NODE:
+        rb_class = cNokogiriXmlDocumentFragment;
+        break;
+      case XML_PI_NODE:
+        rb_class = cNokogiriXmlProcessingInstruction;
+        break;
+      case XML_ENTITY_DECL:
+        rb_class = cNokogiriXmlEntityDecl;
+        break;
+      case XML_CDATA_SECTION_NODE:
+        rb_class = cNokogiriXmlCData;
+        break;
+      case XML_DTD_NODE:
+        rb_class = cNokogiriXmlDtd;
+        break;
+      case XML_ATTRIBUTE_DECL:
+        rb_class = cNokogiriXmlAttributeDecl;
+        break;
+      case XML_ELEMENT_DECL:
+        rb_class = cNokogiriXmlElementDecl;
+        break;
+      default:
+        rb_class = cNokogiriXmlNode;
     }
   }
 
   mark_method = node_has_a_document ? mark : NULL ;
 
-  rb_node = Data_Wrap_Struct(klass, mark_method, debug_node_dealloc, node) ;
-  node->_private = (void *)rb_node;
+  rb_node = Data_Wrap_Struct(rb_class, mark_method, debug_node_dealloc, c_node) ;
+  c_node->_private = (void *)rb_node;
 
   if (node_has_a_document) {
-    document = DOC_RUBY_OBJECT(doc);
-    node_cache = DOC_NODE_CACHE(doc);
-    rb_ary_push(node_cache, rb_node);
-    rb_funcall(document, decorate, 1, rb_node);
+    rb_document = DOC_RUBY_OBJECT(c_doc);
+    rb_node_cache = DOC_NODE_CACHE(c_doc);
+    rb_ary_push(rb_node_cache, rb_node);
+    rb_funcall(rb_document, id_decorate, 1, rb_node);
   }
 
   return rb_node ;
@@ -1763,6 +1775,8 @@ noko_init_xml_node()
 {
   cNokogiriXmlNode = rb_define_class_under(mNokogiriXml, "Node", rb_cObject);
 
+  rb_undef_alloc_func(cNokogiriXmlNode);
+
   rb_define_singleton_method(cNokogiriXmlNode, "new", rb_xml_node_new, -1);
 
   rb_define_method(cNokogiriXmlNode, "add_namespace_definition", add_namespace_definition, 2);
@@ -1780,7 +1794,7 @@ noko_init_xml_node()
   rb_define_method(cNokogiriXmlNode, "next_element", next_element, 0);
   rb_define_method(cNokogiriXmlNode, "previous_element", previous_element, 0);
   rb_define_method(cNokogiriXmlNode, "node_type", node_type, 0);
-  rb_define_method(cNokogiriXmlNode, "path", path, 0);
+  rb_define_method(cNokogiriXmlNode, "path", noko_xml_node_path, 0);
   rb_define_method(cNokogiriXmlNode, "key?", key_eh, 1);
   rb_define_method(cNokogiriXmlNode, "namespaced_key?", namespaced_key_eh, 2);
   rb_define_method(cNokogiriXmlNode, "blank?", blank_eh, 0);
@@ -1818,8 +1832,8 @@ noko_init_xml_node()
   rb_define_private_method(cNokogiriXmlNode, "set_namespace", set_namespace, 1);
   rb_define_private_method(cNokogiriXmlNode, "compare", compare, 1);
 
-  decorate      = rb_intern("decorate");
-  decorate_bang = rb_intern("decorate!");
+  id_decorate      = rb_intern("decorate");
+  id_decorate_bang = rb_intern("decorate!");
 }
 
 /* vim: set noet sw=4 sws=4 */

data/ext/nokogiri/xml_node_set.c

@@ -20,20 +20,20 @@ ruby_object_get(xmlNodePtr c_node)
 {
   /* see xmlElementType in libxml2 tree.h */
   switch (c_node->type) {
-  case XML_NAMESPACE_DECL:
-    /* _private is later in the namespace struct */
-    return (VALUE)(((xmlNsPtr)c_node)->_private);
-
-  case XML_DOCUMENT_NODE:
-  case XML_HTML_DOCUMENT_NODE:
-    /* in documents we use _private to store a tuple */
-    if (DOC_RUBY_OBJECT_TEST(((xmlDocPtr)c_node))) {
-      return DOC_RUBY_OBJECT((xmlDocPtr)c_node);
-    }
-    return (VALUE)NULL;
-
-  default:
-    return (VALUE)(c_node->_private);
+    case XML_NAMESPACE_DECL:
+      /* _private is later in the namespace struct */
+      return (VALUE)(((xmlNsPtr)c_node)->_private);
+
+    case XML_DOCUMENT_NODE:
+    case XML_HTML_DOCUMENT_NODE:
+      /* in documents we use _private to store a tuple */
+      if (DOC_RUBY_OBJECT_TEST(((xmlDocPtr)c_node))) {
+        return DOC_RUBY_OBJECT((xmlDocPtr)c_node);
+      }
+      return (VALUE)NULL;
+
+    default:
+      return (VALUE)(c_node->_private);
   }
 }
 
@@ -373,12 +373,12 @@ slice(int argc, VALUE *argv, VALUE self)
 
   /* if arg is Range */
   switch (rb_range_beg_len(arg, &beg, &len, (long)node_set->nodeNr, 0)) {
-  case Qfalse:
-    break;
-  case Qnil:
-    return Qnil;
-  default:
-    return subseq(self, beg, len);
+    case Qfalse:
+      break;
+    case Qnil:
+      return Qnil;
+    default:
+      return subseq(self, beg, len);
   }
 
   return index_at(self, NUM2LONG(arg));

data/ext/nokogiri/xml_reader.c

@@ -662,6 +662,8 @@ noko_init_xml_reader()
    */
   cNokogiriXmlReader = rb_define_class_under(mNokogiriXml, "Reader", rb_cObject);
 
+  rb_undef_alloc_func(cNokogiriXmlReader);
+
   rb_define_singleton_method(cNokogiriXmlReader, "from_memory", from_memory, -1);
   rb_define_singleton_method(cNokogiriXmlReader, "from_io", from_io, -1);
 

data/ext/nokogiri/xml_sax_parser.c

@@ -30,12 +30,12 @@ start_document(void *ctx)
       version = ctxt->version ? NOKOGIRI_STR_NEW2(ctxt->version) : Qnil;
 
       switch (ctxt->standalone) {
-      case 0:
-        standalone = NOKOGIRI_STR_NEW2("no");
-        break;
-      case 1:
-        standalone = NOKOGIRI_STR_NEW2("yes");
-        break;
+        case 0:
+          standalone = NOKOGIRI_STR_NEW2("no");
+          break;
+        case 1:
+          standalone = NOKOGIRI_STR_NEW2("yes");
+          break;
       }
 
       rb_funcall(doc, id_xmldecl, 3, version, encoding, standalone);

data/ext/nokogiri/xml_sax_parser_context.c

@@ -265,6 +265,8 @@ noko_init_xml_sax_parser_context()
 {
   cNokogiriXmlSaxParserContext = rb_define_class_under(mNokogiriXmlSax, "ParserContext", rb_cObject);
 
+  rb_undef_alloc_func(cNokogiriXmlSaxParserContext);
+
   rb_define_singleton_method(cNokogiriXmlSaxParserContext, "io", parse_io, 2);
   rb_define_singleton_method(cNokogiriXmlSaxParserContext, "memory", parse_memory, 1);
   rb_define_singleton_method(cNokogiriXmlSaxParserContext, "file", parse_file, 1);

data/ext/nokogiri/xml_schema.c

@@ -274,6 +274,8 @@ noko_init_xml_schema()
 {
   cNokogiriXmlSchema = rb_define_class_under(mNokogiriXml, "Schema", rb_cObject);
 
+  rb_undef_alloc_func(cNokogiriXmlSchema);
+
   rb_define_singleton_method(cNokogiriXmlSchema, "read_memory", read_memory, -1);
   rb_define_singleton_method(cNokogiriXmlSchema, "from_document", from_document, -1);