nokogiri 1.11.3-x86-linux → 1.12.0.rc1-x86-linux

data/ext/nokogiri/xml_node.c

@@ -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; }
@@ -68,11 +69,6 @@ relink_namespace(xmlNodePtr reparented)
   /* Avoid segv when relinking against unlinked nodes. */
   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) {
-    xmlSetNs(reparented, reparented->parent->ns);
-  }
-
   /* Search our parents for an existing definition */
   if (reparented->nsDef) {
     xmlNsPtr curr = reparented->nsDef;
@@ -132,10 +128,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 +166,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 +193,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) {
     /*
@@ -313,6 +309,8 @@ ok:
     }
   }
 
+  xmlUnlinkNode(original_reparentee);
+
   if (prf != xmlAddPrevSibling && prf != xmlAddNextSibling
       && reparentee->type == XML_TEXT_NODE && pivot->next && pivot->next->type == XML_TEXT_NODE) {
     /*
@@ -1292,17 +1290,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 ;
 }
 
@@ -1633,12 +1639,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);
@@ -1682,44 +1688,44 @@ noko_xml_node_wrap(VALUE rb_class, xmlNodePtr c_node)
 
   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;
+      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;
     }
   }
 
@@ -1762,6 +1768,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);
@@ -1779,7 +1787,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);

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);
 

data/ext/nokogiri/xml_xpath_context.c

@@ -154,20 +154,20 @@ Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, i
     do {
       obj = valuePop(ctx);
       switch (obj->type) {
-      case XPATH_STRING:
-        argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
-        break;
-      case XPATH_BOOLEAN:
-        argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
-        break;
-      case XPATH_NUMBER:
-        argv[i] = rb_float_new(obj->floatval);
-        break;
-      case XPATH_NODESET:
-        argv[i] = noko_xml_node_set_wrap(obj->nodesetval, doc);
-        break;
-      default:
-        argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
+        case XPATH_STRING:
+          argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
+          break;
+        case XPATH_BOOLEAN:
+          argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
+          break;
+        case XPATH_NUMBER:
+          argv[i] = rb_float_new(obj->floatval);
+          break;
+        case XPATH_NODESET:
+          argv[i] = noko_xml_node_set_wrap(obj->nodesetval, doc);
+          break;
+        default:
+          argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
       }
       xmlXPathFreeNodeSetList(obj);
     } while (i-- > 0);
@@ -181,43 +181,43 @@ Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, i
   free(argv);
 
   switch (TYPE(result)) {
-  case T_FLOAT:
-  case T_BIGNUM:
-  case T_FIXNUM:
-    xmlXPathReturnNumber(ctx, NUM2DBL(result));
-    break;
-  case T_STRING:
-    xmlXPathReturnString(
-      ctx,
-      xmlCharStrdup(StringValueCStr(result))
-    );
-    break;
-  case T_TRUE:
-    xmlXPathReturnTrue(ctx);
-    break;
-  case T_FALSE:
-    xmlXPathReturnFalse(ctx);
-    break;
-  case T_NIL:
-    break;
-  case T_ARRAY: {
-    VALUE args[2];
-    args[0] = doc;
-    args[1] = result;
-    node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet);
-    Data_Get_Struct(node_set, xmlNodeSet, xml_node_set);
-    xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
-  }
-  break;
-  case T_DATA:
-    if (rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) {
-      Data_Get_Struct(result, xmlNodeSet, xml_node_set);
-      /* Copy the node set, otherwise it will get GC'd. */
-      xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+    case T_FLOAT:
+    case T_BIGNUM:
+    case T_FIXNUM:
+      xmlXPathReturnNumber(ctx, NUM2DBL(result));
+      break;
+    case T_STRING:
+      xmlXPathReturnString(
+        ctx,
+        xmlCharStrdup(StringValueCStr(result))
+      );
+      break;
+    case T_TRUE:
+      xmlXPathReturnTrue(ctx);
+      break;
+    case T_FALSE:
+      xmlXPathReturnFalse(ctx);
       break;
+    case T_NIL:
+      break;
+    case T_ARRAY: {
+      VALUE args[2];
+      args[0] = doc;
+      args[1] = result;
+      node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet);
+      Data_Get_Struct(node_set, xmlNodeSet, xml_node_set);
+      xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
     }
-  default:
-    rb_raise(rb_eRuntimeError, "Invalid return type");
+    break;
+    case T_DATA:
+      if (rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) {
+        Data_Get_Struct(result, xmlNodeSet, xml_node_set);
+        /* Copy the node set, otherwise it will get GC'd. */
+        xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set));
+        break;
+      }
+    default:
+      rb_raise(rb_eRuntimeError, "Invalid return type");
   }
 }
 
@@ -314,22 +314,22 @@ evaluate(int argc, VALUE *argv, VALUE self)
   assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
 
   switch (xpath->type) {
-  case XPATH_STRING:
-    thing = NOKOGIRI_STR_NEW2(xpath->stringval);
-    xmlFree(xpath->stringval);
-    break;
-  case XPATH_NODESET:
-    thing = noko_xml_node_set_wrap(xpath->nodesetval,
-                                   DOC_RUBY_OBJECT(ctx->doc));
-    break;
-  case XPATH_NUMBER:
-    thing = rb_float_new(xpath->floatval);
-    break;
-  case XPATH_BOOLEAN:
-    thing = xpath->boolval == 1 ? Qtrue : Qfalse;
-    break;
-  default:
-    thing = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(ctx->doc));
+    case XPATH_STRING:
+      thing = NOKOGIRI_STR_NEW2(xpath->stringval);
+      xmlFree(xpath->stringval);
+      break;
+    case XPATH_NODESET:
+      thing = noko_xml_node_set_wrap(xpath->nodesetval,
+                                     DOC_RUBY_OBJECT(ctx->doc));
+      break;
+    case XPATH_NUMBER:
+      thing = rb_float_new(xpath->floatval);
+      break;
+    case XPATH_BOOLEAN:
+      thing = xpath->boolval == 1 ? Qtrue : Qfalse;
+      break;
+    default:
+      thing = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(ctx->doc));
   }
 
   xmlXPathFreeNodeSetList(xpath);
@@ -373,6 +373,8 @@ noko_init_xml_xpath_context(void)
    */
   cNokogiriXmlXpathContext = rb_define_class_under(mNokogiriXml, "XPathContext", rb_cObject);
 
+  rb_undef_alloc_func(cNokogiriXmlXpathContext);
+
   rb_define_singleton_method(cNokogiriXmlXpathContext, "new", new, 1);
 
   rb_define_method(cNokogiriXmlXpathContext, "evaluate", evaluate, -1);