nokogiri 1.16.7-x86_64-linux → 1.17.0-x86_64-linux

data/ext/nokogiri/xml_node.c

@@ -38,8 +38,8 @@ _xml_node_update_references(void *ptr)
   }
 }
 
-static const rb_data_type_t nokogiri_node_type = {
-  .wrap_struct_name = "Nokogiri::XML::Node",
+static const rb_data_type_t xml_node_type = {
+  .wrap_struct_name = "xmlNode",
   .function = {
     .dmark = _xml_node_mark,
     .dcompact = _xml_node_update_references,
@@ -47,6 +47,24 @@ static const rb_data_type_t nokogiri_node_type = {
   .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
+static VALUE
+_xml_node_alloc(VALUE klass)
+{
+  return TypedData_Wrap_Struct(klass, &xml_node_type, NULL);
+}
+
+static void
+_xml_node_data_ptr_set(VALUE rb_node, xmlNodePtr c_node)
+{
+  assert(DATA_PTR(rb_node) == NULL);
+  assert(c_node->_private == NULL);
+
+  DATA_PTR(rb_node) = c_node;
+  c_node->_private = (void *)rb_node;
+
+  return;
+}
+
 static void
 relink_namespace(xmlNodePtr reparented)
 {
@@ -141,7 +159,7 @@ relink_namespace(xmlNodePtr reparented)
   /* reparent. */
   if (NULL == reparented->ns) { return; }
 
-  /* When a node gets reparented, walk it's children to make sure that */
+  /* When a node gets reparented, walk its children to make sure that */
   /* their namespaces are reparented as well. */
   child = reparented->children;
   while (NULL != child) {
@@ -944,51 +962,25 @@ internal_subset(VALUE self)
   return noko_xml_node_wrap(Qnil, (xmlNodePtr)dtd);
 }
 
-/*
- * :call-seq:
- *   dup → Nokogiri::XML::Node
- *   dup(depth) → Nokogiri::XML::Node
- *   dup(depth, new_parent_doc) → Nokogiri::XML::Node
- *
- * Copy this node.
- *
- * [Parameters]
- * - +depth+ 0 is a shallow copy, 1 (the default) is a deep copy.
- * - +new_parent_doc+
- *   The new node's parent Document. Defaults to the this node's document.
- *
- * [Returns] The new Nokogiri::XML::Node
- */
+/* :nodoc: */
 static VALUE
-duplicate_node(int argc, VALUE *argv, VALUE self)
+rb_xml_node_initialize_copy_with_args(VALUE rb_self, VALUE rb_other, VALUE rb_level, VALUE rb_new_parent_doc)
 {
-  VALUE r_level, r_new_parent_doc;
-  int level;
-  int n_args;
-  xmlDocPtr new_parent_doc;
-  xmlNodePtr node, dup;
+  xmlNodePtr c_self, c_other;
+  int c_level;
+  xmlDocPtr c_new_parent_doc;
 
-  Noko_Node_Get_Struct(self, xmlNode, node);
-
-  n_args = rb_scan_args(argc, argv, "02", &r_level, &r_new_parent_doc);
-
-  if (n_args < 1) {
-    r_level = INT2NUM((long)1);
-  }
-  level = (int)NUM2INT(r_level);
-
-  if (n_args < 2) {
-    new_parent_doc = node->doc;
-  } else {
-    new_parent_doc = noko_xml_document_unwrap(r_new_parent_doc);
-  }
+  Noko_Node_Get_Struct(rb_other, xmlNode, c_other);
+  c_level = (int)NUM2INT(rb_level);
+  c_new_parent_doc = noko_xml_document_unwrap(rb_new_parent_doc);
 
-  dup = xmlDocCopyNode(node, new_parent_doc, level);
-  if (dup == NULL) { return Qnil; }
+  c_self = xmlDocCopyNode(c_other, c_new_parent_doc, c_level);
+  if (c_self == NULL) { return Qnil; }
 
-  noko_xml_document_pin_node(dup);
+  _xml_node_data_ptr_set(rb_self, c_self);
+  noko_xml_document_pin_node(c_self);
 
-  return noko_xml_node_wrap(rb_obj_class(self), dup);
+  return rb_self;
 }
 
 /*
@@ -1074,17 +1066,10 @@ previous_element(VALUE self)
   xmlNodePtr node, sibling;
   Noko_Node_Get_Struct(self, xmlNode, node);
 
-  /*
-   *  note that we don't use xmlPreviousElementSibling here because it's buggy pre-2.7.7.
-   */
-  sibling = node->prev;
+  sibling = xmlPreviousElementSibling(node);
   if (!sibling) { return Qnil; }
 
-  while (sibling && sibling->type != XML_ELEMENT_NODE) {
-    sibling = sibling->prev;
-  }
-
-  return sibling ? noko_xml_node_wrap(Qnil, sibling) : Qnil ;
+  return noko_xml_node_wrap(Qnil, sibling);
 }
 
 /* :nodoc: */
@@ -1500,9 +1485,44 @@ node_type(VALUE self)
 
 /*
  * call-seq:
- *  content=
+ *   native_content=(input)
+ *
+ * Set the content of this node to +input+.
+ *
+ * [Parameters]
+ * - +input+ (String) The new content for this node.
+ *
+ * ⚠ This method behaves differently depending on the node type. For Text, CDATA, Comment, and
+ * ProcessingInstruction nodes, it treats the input as raw content, which means that the final DOM
+ * will contain the entity-escaped version of the input (see example below). For Element and Attr
+ * nodes, it treats the input as parsed content and expects it to be valid markup that is already
+ * entity-escaped.
+ *
+ * 💡 Use Node#content= for a more consistent API across node types.
+ *
+ * [Example]
+ * Note the behavior differences of this method between Text and Element nodes:
  *
- * Set the content for this Node
+ *   doc = Nokogiri::HTML::Document.parse(<<~HTML)
+ *     <html>
+ *       <body>
+ *         <div id="first">asdf</div>
+ *         <div id="second">asdf</div>
+ *   HTML
+ *
+ *   text_node = doc.at_css("div#first").children.first
+ *   div_node = doc.at_css("div#second")
+ *
+ *   value = "You &amp; Me"
+ *
+ *   text_node.native_content = value
+ *   div_node.native_content = value
+ *
+ *   doc.css("div").to_html
+ *   # => "<div id=\"first\">You &amp;amp; Me</div>
+ *   #     <div id=\"second\">You &amp; Me</div>"
+ *
+ * See also: #content=
  */
 static VALUE
 set_native_content(VALUE self, VALUE content)
@@ -1813,12 +1833,12 @@ output_escaped_string(VALUE out, xmlChar const *start, bool attr)
       ++next;
       continue;
     }
-    output_partial_string(out, (char const *)start, next - start);
+    output_partial_string(out, (char const *)start, (size_t)(next - start));
     output_string(out, replacement);
     next += replaced_bytes;
     start = next;
   }
-  output_partial_string(out, (char const *)start, next - start);
+  output_partial_string(out, (char const *)start, (size_t)(next - start));
 }
 
 static bool
@@ -1849,13 +1869,19 @@ is_one_of(xmlNodePtr node, char const *const *tagnames, size_t num_tagnames)
   if (name == NULL) { // fragments don't have a name
     return false;
   }
+
+  if (node->ns != NULL) {
+    // if the node has a namespace, it's in a foreign context and is not one of the HTML tags we're
+    // matching against.
+    return false;
+  }
+
   for (size_t idx = 0; idx < num_tagnames; ++idx) {
     if (!strcmp(name, tagnames[idx])) {
       return true;
     }
   }
   return false;
-
 }
 
 static void
@@ -1883,17 +1909,7 @@ output_node(
       // Add attributes.
       for (xmlAttrPtr attr = node->properties; attr; attr = attr->next) {
         output_char(out, ' ');
-        output_attr_name(out, attr);
-        if (attr->children) {
-          output_string(out, "=\"");
-          xmlChar *value = xmlNodeListGetString(attr->doc, attr->children, 1);
-          output_escaped_string(out, value, true);
-          xmlFree(value);
-          output_char(out, '"');
-        } else {
-          // Output name=""
-          output_string(out, "=\"\"");
-        }
+        output_node(out, (xmlNodePtr)attr, preserve_newline);
       }
       output_char(out, '>');
 
@@ -1911,6 +1927,22 @@ output_node(
       }
       break;
 
+    case XML_ATTRIBUTE_NODE: {
+      xmlAttrPtr attr = (xmlAttrPtr)node;
+      output_attr_name(out, attr);
+      if (attr->children) {
+        output_string(out, "=\"");
+        xmlChar *value = xmlNodeListGetString(attr->doc, attr->children, 1);
+        output_escaped_string(out, value, true);
+        xmlFree(value);
+        output_char(out, '"');
+      } else {
+        // Output name=""
+        output_string(out, "=\"\"");
+      }
+    }
+    break;
+
     case XML_TEXT_NODE:
       if (node->parent
           && is_one_of(node->parent, UNESCAPED_TEXT_ELEMENTS,
@@ -2026,11 +2058,11 @@ rb_xml_node_line_set(VALUE rb_node, VALUE rb_line_number)
   // libxml2 optionally uses xmlNode.psvi to store longer line numbers, but only for text nodes.
   // search for "psvi" in SAX2.c and tree.c to learn more.
   if (line_number < 65535) {
-    c_node->line = (short) line_number;
+    c_node->line = (short unsigned)line_number;
   } else {
     c_node->line = 65535;
     if (c_node->type == XML_TEXT_NODE) {
-      c_node->psvi = (void *)(ptrdiff_t) line_number;
+      c_node->psvi = (void *)(ptrdiff_t)line_number;
     }
   }
 
@@ -2090,7 +2122,7 @@ dump_html(VALUE self)
 
   buf = xmlBufferCreate() ;
   htmlNodeDump(buf, node->doc, node);
-  html = NOKOGIRI_STR_NEW2(buf->content);
+  html = NOKOGIRI_STR_NEW2(xmlBufferContent(buf));
   xmlBufferFree(buf);
   return html ;
 }
@@ -2114,36 +2146,38 @@ compare(VALUE self, VALUE _other)
 
 /*
  * call-seq:
- *   process_xincludes(options)
+ *   process_xincludes(flags)
  *
  * Loads and substitutes all xinclude elements below the node. The
- * parser context will be initialized with +options+.
+ * parser context will be initialized with +flags+.
  */
 static VALUE
-process_xincludes(VALUE self, VALUE options)
+noko_xml_node__process_xincludes(VALUE rb_node, VALUE rb_flags)
 {
-  int rcode ;
-  xmlNodePtr node;
-  VALUE error_list = rb_ary_new();
+  int status ;
+  xmlNodePtr c_node;
+  VALUE rb_errors = rb_ary_new();
+  libxmlStructuredErrorHandlerState handler_state;
 
-  Noko_Node_Get_Struct(self, xmlNode, node);
+  Noko_Node_Get_Struct(rb_node, xmlNode, c_node);
 
-  xmlSetStructuredErrorFunc((void *)error_list, Nokogiri_error_array_pusher);
-  rcode = xmlXIncludeProcessTreeFlags(node, (int)NUM2INT(options));
-  xmlSetStructuredErrorFunc(NULL, NULL);
+  noko__structured_error_func_save_and_set(&handler_state, (void *)rb_errors, noko__error_array_pusher);
+
+  status = xmlXIncludeProcessTreeFlags(c_node, (int)NUM2INT(rb_flags));
 
-  if (rcode < 0) {
-    xmlErrorConstPtr error;
+  noko__structured_error_func_restore(&handler_state);
 
-    error = xmlGetLastError();
-    if (error) {
-      rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
+  if (status < 0) {
+    VALUE exception = rb_funcall(cNokogiriXmlSyntaxError, rb_intern("aggregate"), 1, rb_errors);
+
+    if (RB_TEST(exception)) {
+      rb_exc_raise(exception);
     } else {
       rb_raise(rb_eRuntimeError, "Could not perform xinclude substitution");
     }
   }
 
-  return self;
+  return rb_node;
 }
 
 
@@ -2165,16 +2199,7 @@ in_context(VALUE self, VALUE _str, VALUE _options)
   node_children = node->children;
   doc_children  = node->doc->children;
 
-  xmlSetStructuredErrorFunc((void *)err, Nokogiri_error_array_pusher);
-
-  /* Twiddle global variable because of a bug in libxml2.
-   * http://git.gnome.org/browse/libxml2/commit/?id=e20fb5a72c83cbfc8e4a8aa3943c6be8febadab7
-   *
-   * TODO: this is fixed, and HTML_PARSE_NOIMPLIED is defined, in libxml2 2.7.7
-   */
-#ifndef HTML_PARSE_NOIMPLIED
-  htmlHandleOmittedElem(0);
-#endif
+  xmlSetStructuredErrorFunc((void *)err, noko__error_array_pusher);
 
   /* This function adds a fake node to the child of +node+.  If the parser
    * does not exit cleanly with XML_ERR_OK, the list is freed.  This can
@@ -2204,10 +2229,6 @@ in_context(VALUE self, VALUE _str, VALUE _options)
     child_iter = child_iter->next;
   }
 
-#ifndef HTML_PARSE_NOIMPLIED
-  htmlHandleOmittedElem(1);
-#endif
-
   xmlSetStructuredErrorFunc(NULL, NULL);
 
   /*
@@ -2256,6 +2277,15 @@ in_context(VALUE self, VALUE _str, VALUE _options)
   return noko_xml_node_set_wrap(set, doc);
 }
 
+/* :nodoc: */
+VALUE
+rb_xml_node_data_ptr_eh(VALUE self)
+{
+  xmlNodePtr c_node;
+  Noko_Node_Get_Struct(self, xmlNode, c_node);
+  return c_node ? Qtrue : Qfalse;
+}
+
 VALUE
 noko_xml_node_wrap(VALUE rb_class, xmlNodePtr c_node)
 {
@@ -2321,8 +2351,8 @@ noko_xml_node_wrap(VALUE rb_class, xmlNodePtr c_node)
     }
   }
 
-  rb_node = TypedData_Wrap_Struct(rb_class, &nokogiri_node_type, c_node) ;
-  c_node->_private = (void *)rb_node;
+  rb_node = _xml_node_alloc(rb_class);
+  _xml_node_data_ptr_set(rb_node, c_node);
 
   if (node_has_a_document) {
     rb_document = DOC_RUBY_OBJECT(c_doc);
@@ -2358,7 +2388,7 @@ noko_init_xml_node(void)
 {
   cNokogiriXmlNode = rb_define_class_under(mNokogiriXml, "Node", rb_cObject);
 
-  rb_undef_alloc_func(cNokogiriXmlNode);
+  rb_define_alloc_func(cNokogiriXmlNode, _xml_node_alloc);
 
   rb_define_singleton_method(cNokogiriXmlNode, "new", rb_xml_node_new, -1);
 
@@ -2372,8 +2402,8 @@ noko_init_xml_node(void)
   rb_define_method(cNokogiriXmlNode, "content", rb_xml_node_content, 0);
   rb_define_method(cNokogiriXmlNode, "create_external_subset", create_external_subset, 3);
   rb_define_method(cNokogiriXmlNode, "create_internal_subset", create_internal_subset, 3);
+  rb_define_method(cNokogiriXmlNode, "data_ptr?", rb_xml_node_data_ptr_eh, 0);
   rb_define_method(cNokogiriXmlNode, "document", rb_xml_node_document, 0);
-  rb_define_method(cNokogiriXmlNode, "dup", duplicate_node, -1);
   rb_define_method(cNokogiriXmlNode, "element_children", rb_xml_node_element_children, 0);
   rb_define_method(cNokogiriXmlNode, "encode_special_chars", encode_special_chars, 1);
   rb_define_method(cNokogiriXmlNode, "external_subset", external_subset, 0);
@@ -2402,6 +2432,8 @@ noko_init_xml_node(void)
   rb_define_method(cNokogiriXmlNode, "previous_sibling", previous_sibling, 0);
   rb_define_method(cNokogiriXmlNode, "unlink", unlink_node, 0);
 
+  rb_define_protected_method(cNokogiriXmlNode, "initialize_copy_with_args", rb_xml_node_initialize_copy_with_args, 3);
+
   rb_define_private_method(cNokogiriXmlNode, "add_child_node", add_child, 1);
   rb_define_private_method(cNokogiriXmlNode, "add_next_sibling_node", add_next_sibling, 1);
   rb_define_private_method(cNokogiriXmlNode, "add_previous_sibling_node", add_previous_sibling, 1);
@@ -2412,7 +2444,7 @@ noko_init_xml_node(void)
   rb_define_private_method(cNokogiriXmlNode, "native_write_to", native_write_to, 4);
   rb_define_private_method(cNokogiriXmlNode, "prepend_newline?", rb_prepend_newline, 0);
   rb_define_private_method(cNokogiriXmlNode, "html_standard_serialize", html_standard_serialize, 1);
-  rb_define_private_method(cNokogiriXmlNode, "process_xincludes", process_xincludes, 1);
+  rb_define_private_method(cNokogiriXmlNode, "process_xincludes", noko_xml_node__process_xincludes, 1);
   rb_define_private_method(cNokogiriXmlNode, "replace_node", replace, 1);
   rb_define_private_method(cNokogiriXmlNode, "set", set, 2);
   rb_define_private_method(cNokogiriXmlNode, "set_namespace", set_namespace, 1);

data/ext/nokogiri/xml_node_set.c

@@ -68,15 +68,8 @@ xml_node_set_deallocate(void *data)
   xmlFree(node_set);
 }
 
-
-static VALUE
-xml_node_set_allocate(VALUE klass)
-{
-  return noko_xml_node_set_wrap(xmlXPathNodeSetCreate(NULL), Qnil);
-}
-
 static const rb_data_type_t xml_node_set_type = {
-  .wrap_struct_name = "Nokogiri::XML::NodeSet",
+  .wrap_struct_name = "xmlNodeSet",
   .function = {
     .dmark = xml_node_set_mark,
     .dfree = xml_node_set_deallocate,
@@ -84,6 +77,33 @@ static const rb_data_type_t xml_node_set_type = {
   .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
+static VALUE
+xml_node_set_allocate(VALUE klass)
+{
+  return TypedData_Wrap_Struct(klass, &xml_node_set_type, xmlXPathNodeSetCreate(NULL));
+}
+
+/* :nodoc: */
+static VALUE
+rb_xml_node_set_initialize_copy(VALUE rb_self, VALUE rb_other)
+{
+  xmlNodeSetPtr c_self, c_other;
+  VALUE rb_document;
+
+  TypedData_Get_Struct(rb_self, xmlNodeSet, &xml_node_set_type, c_self);
+  TypedData_Get_Struct(rb_other, xmlNodeSet, &xml_node_set_type, c_other);
+
+  xmlXPathNodeSetMerge(c_self, c_other);
+
+  rb_document = rb_iv_get(rb_other, "@document");
+  if (!NIL_P(rb_document)) {
+    rb_iv_set(rb_self, "@document", rb_document);
+    rb_funcall(rb_document, decorate, 1, rb_self);
+  }
+
+  return rb_self;
+}
+
 static void
 xpath_node_set_del(xmlNodeSetPtr cur, xmlNodePtr val)
 {
@@ -112,27 +132,6 @@ xpath_node_set_del(xmlNodeSetPtr cur, xmlNodePtr val)
   cur->nodeTab[cur->nodeNr] = NULL;
 }
 
-
-/*
- * call-seq:
- *  dup
- *
- * Duplicate this NodeSet. Note that the Nodes contained in the NodeSet are not
- * duplicated (similar to how Array and other Enumerable classes work).
- */
-static VALUE
-duplicate(VALUE rb_self)
-{
-  xmlNodeSetPtr c_self;
-  xmlNodeSetPtr dupl;
-
-  TypedData_Get_Struct(rb_self, xmlNodeSet, &xml_node_set_type, c_self);
-
-  dupl = xmlXPathNodeSetMerge(NULL, c_self);
-
-  return noko_xml_node_set_wrap(dupl, rb_iv_get(rb_self, "@document"));
-}
-
 /*
  * call-seq:
  *  length
@@ -453,19 +452,21 @@ noko_xml_node_set_wrap(xmlNodeSetPtr c_node_set, VALUE document)
   VALUE rb_node_set ;
 
   if (c_node_set == NULL) {
-    c_node_set = xmlXPathNodeSetCreate(NULL);
+    rb_node_set = xml_node_set_allocate(cNokogiriXmlNodeSet);
+  } else {
+    rb_node_set = TypedData_Wrap_Struct(cNokogiriXmlNodeSet, &xml_node_set_type, c_node_set);
   }
 
-  rb_node_set = TypedData_Wrap_Struct(cNokogiriXmlNodeSet, &xml_node_set_type, c_node_set);
-
   if (!NIL_P(document)) {
     rb_iv_set(rb_node_set, "@document", document);
     rb_funcall(document, decorate, 1, rb_node_set);
   }
 
-  /* make sure we create ruby objects for all the results, so they'll be marked during the GC mark phase */
-  for (j = 0 ; j < c_node_set->nodeNr ; j++) {
-    noko_xml_node_wrap_node_set_result(c_node_set->nodeTab[j], rb_node_set);
+  if (c_node_set) {
+    /* create ruby objects for all the results, so they'll be marked during the GC mark phase */
+    for (j = 0 ; j < c_node_set->nodeNr ; j++) {
+      noko_xml_node_wrap_node_set_result(c_node_set->nodeTab[j], rb_node_set);
+    }
   }
 
   return rb_node_set ;
@@ -499,18 +500,19 @@ noko_init_xml_node_set(void)
 
   rb_define_alloc_func(cNokogiriXmlNodeSet, xml_node_set_allocate);
 
-  rb_define_method(cNokogiriXmlNodeSet, "length", length, 0);
-  rb_define_method(cNokogiriXmlNodeSet, "[]", slice, -1);
-  rb_define_method(cNokogiriXmlNodeSet, "slice", slice, -1);
-  rb_define_method(cNokogiriXmlNodeSet, "push", push, 1);
-  rb_define_method(cNokogiriXmlNodeSet, "|", rb_xml_node_set_union, 1);
+  rb_define_method(cNokogiriXmlNodeSet, "&", intersection, 1);
   rb_define_method(cNokogiriXmlNodeSet, "-", minus, 1);
-  rb_define_method(cNokogiriXmlNodeSet, "unlink", unlink_nodeset, 0);
-  rb_define_method(cNokogiriXmlNodeSet, "to_a", to_array, 0);
-  rb_define_method(cNokogiriXmlNodeSet, "dup", duplicate, 0);
+  rb_define_method(cNokogiriXmlNodeSet, "[]", slice, -1);
   rb_define_method(cNokogiriXmlNodeSet, "delete", delete, 1);
-  rb_define_method(cNokogiriXmlNodeSet, "&", intersection, 1);
   rb_define_method(cNokogiriXmlNodeSet, "include?", include_eh, 1);
+  rb_define_method(cNokogiriXmlNodeSet, "length", length, 0);
+  rb_define_method(cNokogiriXmlNodeSet, "push", push, 1);
+  rb_define_method(cNokogiriXmlNodeSet, "slice", slice, -1);
+  rb_define_method(cNokogiriXmlNodeSet, "to_a", to_array, 0);
+  rb_define_method(cNokogiriXmlNodeSet, "unlink", unlink_nodeset, 0);
+  rb_define_method(cNokogiriXmlNodeSet, "|", rb_xml_node_set_union, 1);
+
+  rb_define_private_method(cNokogiriXmlNodeSet, "initialize_copy", rb_xml_node_set_initialize_copy, 1);
 
   decorate = rb_intern("decorate");
 }