libxml-ruby 3.0.0-x64-mingw32 → 3.2.2-x64-mingw32

data/ext/libxml/ruby_xml_io.c

@@ -1,13 +1,10 @@
 /* Please see the LICENSE file for copyright and distribution information */
 
 #include "ruby_libxml.h"
+#include <ruby/io.h>
 
 static ID READ_METHOD;
-#ifdef HAVE_RB_IO_BUFWRITE
-#include <ruby/io.h>
-#else
 static ID WRITE_METHOD;
-#endif /* !HAVE_RB_IO_BUFWRITE */
 
 /* This method is called by libxml when it wants to read
  more data from a stream. We go with the duck typing
@@ -27,25 +24,24 @@ int rxml_read_callback(void *context, char *buffer, int len)
   return (int)size;
 }
 
-int rxml_write_callback(void *context, const char *buffer, int len)
+int rxml_write_callback(VALUE io, const char *buffer, int len)
 {
-#ifndef HAVE_RB_IO_BUFWRITE
-  VALUE io, written, string;
-
-  io = (VALUE) context;
-  string = rb_str_new(buffer, len);
-  written = rb_funcall(io, WRITE_METHOD, 1, string);
-
-  return NUM2INT(written);
-#else
-  return (int)rb_io_bufwrite((VALUE) context, buffer, (size_t)len);
-#endif /* !HAVE_RB_IO_BUFWRITE */
+    if (rb_io_check_io(io) == Qnil)
+    {
+        // Could be StringIO
+        VALUE written, string;
+        string = rb_external_str_new_with_enc(buffer, strlen(buffer), rb_enc_get(io));
+        written = rb_funcall(io, WRITE_METHOD, 1, string);
+        return NUM2INT(written);
+    }
+    else
+    {
+        return (int)rb_io_bufwrite(io, buffer, (size_t)len);
+    }
 }
 
 void rxml_init_io(void)
 {
   READ_METHOD = rb_intern("read");
-#ifndef HAVE_RB_IO_BUFWRITE
   WRITE_METHOD = rb_intern("write");
-#endif /* !HAVE_RB_IO_BUFWRITE */
 }

data/ext/libxml/ruby_xml_io.h

@@ -4,7 +4,7 @@
 #define __RXML_IO__
 
 int rxml_read_callback(void *context, char *buffer, int len);
-int rxml_write_callback(void *context, const char *buffer, int len);
+int rxml_write_callback(VALUE io, const char *buffer, int len);
 void rxml_init_io(void);
 
 #endif

data/ext/libxml/ruby_xml_node.c

@@ -57,7 +57,7 @@ static void rxml_node_free(xmlNodePtr xnode)
 
 void rxml_node_manage(xmlNodePtr xnode, VALUE node)
 {
-  RDATA(node)->dfree = rxml_node_free;
+  RDATA(node)->dfree = (RUBY_DATA_FUNC)rxml_node_free;
   xnode->_private = (void*)node;
 }
 
@@ -83,8 +83,11 @@ void rxml_node_mark(xmlNodePtr xnode)
 {
    if (xnode->doc)
    {
-     VALUE doc = (VALUE)xnode->doc->_private;
-     rb_gc_mark(doc);
+     if (xnode->doc->_private)
+	 {
+	   VALUE doc = (VALUE)xnode->doc->_private;
+	   rb_gc_mark(doc);
+	 }
    }
    else if (xnode->parent)
    {
@@ -120,8 +123,7 @@ VALUE rxml_node_wrap(xmlNodePtr xnode)
 
 static VALUE rxml_node_alloc(VALUE klass)
 {
-  /* Ruby is responsible for freeing this node not libxml but don't set
-     up mark and free yet until we assign the node. */
+  // This node was created from Ruby so we are responsible for freeing it not libxml
   return Data_Wrap_Struct(klass, rxml_node_mark, rxml_node_free, NULL);
 }
 
@@ -308,25 +310,22 @@ static VALUE rxml_node_modify_dom(VALUE self, VALUE target,
   xtarget = rxml_get_xnode(target);
 
   if (xtarget->doc != NULL && xtarget->doc != xnode->doc)
-    rb_raise(eXMLError, "Nodes belong to different documents.  You must first import the node by calling XML::Document.import");
+    rb_raise(eXMLError, "Nodes belong to different documents.  You must first import the node by calling LibXML::XML::Document.import");
 
   xmlUnlinkNode(xtarget);
 
-  /* This target node could be freed here. */  
+  // Target is about to have a parent, so stop having ruby manage it.
+  rxml_node_unmanage(xtarget, target);
+
+  // This target node could be freed here and be replaced by a different node 
   xresult = xmlFunc(xnode, xtarget);
 
   if (!xresult)
-    rxml_raise(&xmlLastError);
-
-  /* Was the target freed? If yes, then wrap the new node */
-  if (xresult != xtarget)
-  {
-    RDATA(target)->data = xresult;
-  }
+	  rxml_raise(&xmlLastError);
 
-  // Target now has a parent so ruby should no longer manage its memory
-  rxml_node_unmanage(xresult, target);
-  xtarget->_private = NULL;
+  /* Assume the target was freed, we need to fix up the ruby object to point to the
+     newly returned node. */
+  RDATA(target)->data = xresult;
 
   return target;
 }

data/ext/libxml/ruby_xml_parser_context.c

@@ -47,7 +47,7 @@ static VALUE rxml_parser_context_document(VALUE klass, VALUE document)
   int length;
 
   if (rb_obj_is_kind_of(document, cXMLDocument) == Qfalse)
-    rb_raise(rb_eTypeError, "Must pass an XML::Document object");
+    rb_raise(rb_eTypeError, "Must pass an LibXML::XML::Document object");
 
   Data_Get_Struct(document, xmlDoc, xdoc);
   xmlDocDumpFormatMemoryEnc(xdoc, &buffer, &length, (const char*)xdoc->encoding, 0);

data/ext/libxml/ruby_xml_reader.c

@@ -23,7 +23,7 @@
  *  reader = XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
  *  reader.read
  *  assert_equal('foo', reader.name)
- *  assert_equal(nil, reader.value)
+ *  assert_nil(reader.value)
  *
  *  3.times do |i|
  *    reader.read
@@ -995,7 +995,12 @@ static VALUE rxml_reader_expand(VALUE self)
   }
   else
   {
-    return rxml_node_wrap(xnode);
+	  /* We cannot call rxml_node_wrap here because its sets up a mark function
+	   for the node. But according to the libxml docs (http://xmlsoft.org/html/libxml-xmlreader.html#xmlTextReaderExpand)
+	   this is only valid until the next xmlTextReaderRead call.  At that point the node is freed (from reading
+	   the libxml2 source code.  So don't set a mark or free function, because they will get called in the next
+	   garbage collection run and cause a segfault.*/
+	return Data_Wrap_Struct(cXMLNode, NULL, NULL, xnode);
   }
 }
 

data/ext/libxml/ruby_xml_schema.c

@@ -8,7 +8,6 @@
 #include "ruby_xml_schema_attribute.h"
 #include "ruby_xml_schema_facet.h"
 
-
 /*
  * Document-class: LibXML::XML::Schema
  *
@@ -152,7 +151,6 @@ static VALUE rxml_schema_id(VALUE self)
   QNIL_OR_STRING(xschema->id)
 }
 
-
 static VALUE rxml_schema_document(VALUE self)
 {
   xmlSchemaPtr xschema;
@@ -162,21 +160,20 @@ static VALUE rxml_schema_document(VALUE self)
   return rxml_node_wrap(xmlDocGetRootElement(xschema->doc));
 }
 
-static void storeNs(xmlSchemaImportPtr import, VALUE self, xmlChar *nsname)
+static void scan_namespaces(xmlSchemaImportPtr ximport, VALUE array, xmlChar *nsname)
 {
-  VALUE schemas;
   xmlNodePtr xnode;
   xmlNsPtr xns;
 
-  schemas = rb_iv_get(self, "@namespaces");
-  if (import->doc) {
-    xnode = xmlDocGetRootElement(import->doc);
-
+  if (ximport->doc)
+  {
+    xnode = xmlDocGetRootElement(ximport->doc);
     xns = xnode->nsDef;
 
-    while (xns) {
-      VALUE anamespace = rxml_namespace_wrap(xns);
-      rb_ary_push(schemas, anamespace);
+    while (xns)
+	{
+      VALUE namespace = rxml_namespace_wrap(xns);
+      rb_ary_push(array, namespace);
       xns = xns->next;
     }
   }
@@ -184,95 +181,76 @@ static void storeNs(xmlSchemaImportPtr import, VALUE self, xmlChar *nsname)
 
 static VALUE rxml_schema_namespaces(VALUE self)
 {
-  VALUE schemas;
+  VALUE result;
   xmlSchemaPtr xschema;
 
   Data_Get_Struct(self, xmlSchema, xschema);
 
-  if (rb_iv_get(self, "@namespaces") == Qnil) {
-    schemas = rb_ary_new();
-    rb_iv_set(self, "@namespaces", schemas);
-    xmlHashScan(xschema->schemasImports, (xmlHashScanner) storeNs, (void *)self);
-  }
+  result = rb_ary_new();
+  xmlHashScan(xschema->schemasImports, (xmlHashScanner)scan_namespaces, (void *)result);
 
-  return rb_iv_get(self, "@namespaces");
+  return result;
 }
 
-static void storeType(xmlSchemaTypePtr type, VALUE self, xmlChar *name)
+static void scan_element(xmlSchemaElementPtr xelement, VALUE hash, xmlChar *name)
 {
-  VALUE types;
-  VALUE rtype;
-
-  types = rb_iv_get(self, "@types");
-  rtype = rxml_wrap_schema_type(type);
-
-  rb_hash_aset(types, rb_str_new2((const char*)name), rtype);
+  VALUE element = rxml_wrap_schema_element(xelement);
+  rb_hash_aset(hash, rb_str_new2((const char*)name), element);
 }
 
-static VALUE rxml_schema_collect_types(VALUE self);
-
-static VALUE rxml_schema_types(VALUE self)
+static VALUE rxml_schema_elements(VALUE self)
 {
-  VALUE types;
+  VALUE result = rb_hash_new();
   xmlSchemaPtr xschema;
 
   Data_Get_Struct(self, xmlSchema, xschema);
+  xmlHashScan(xschema->elemDecl, (xmlHashScanner)scan_element, (void *)result);
 
-  if (rb_iv_get(self, "@types") == Qnil) {
-    types = rb_hash_new();
-    rb_iv_set(self, "@types", types);
-    rxml_schema_collect_types(self);
-    if(xschema != NULL && xschema->typeDecl != NULL)
-      xmlHashScan(xschema->typeDecl, (xmlHashScanner) storeType, (void *)self);
-  }
-
-  return rb_iv_get(self, "@types");
+  return result;
 }
 
-static void storeElement(xmlSchemaElementPtr element, VALUE self, xmlChar *name)
+static void scan_type(xmlSchemaTypePtr xtype, VALUE hash, xmlChar *name)
 {
-  VALUE elements;
-  VALUE relement;
-
-  elements = rb_iv_get(self, "@elements");
-  relement = rxml_wrap_schema_element(element);
-  rb_hash_aset(elements, rb_str_new2((const char*)name), relement);
+	VALUE type = rxml_wrap_schema_type(xtype);
+	rb_hash_aset(hash, rb_str_new2((const char*)name), type);
 }
 
-static VALUE rxml_schema_elements(VALUE self)
+static VALUE rxml_schema_types(VALUE self)
 {
-  VALUE elements;
-  xmlSchemaPtr xschema;
+	VALUE result = rb_hash_new();
+	xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+	Data_Get_Struct(self, xmlSchema, xschema);
 
-  if (rb_iv_get(self, "@elements") == Qnil) {
-    elements = rb_hash_new();
-    rb_iv_set(self, "@elements", elements);
-    xmlHashScan(xschema->elemDecl, (xmlHashScanner) storeElement, (void *)self);
-  }
+	if (xschema != NULL && xschema->typeDecl != NULL)
+	{
+		xmlHashScan(xschema->typeDecl, (xmlHashScanner)scan_type, (void *)result);
+	}
 
-  return rb_iv_get(self, "@elements");
+	return result;
 }
 
-static void collectSchemaTypes(xmlSchemaImportPtr import, VALUE self)
+static void collect_imported_types(xmlSchemaImportPtr import, VALUE result)
 {
-  if (import->imported && import->schema) {
-    xmlHashScan(import->schema->typeDecl, (xmlHashScanner) storeType, (void *)self);
+  if (import->imported && import->schema)
+  {
+    xmlHashScan(import->schema->typeDecl, (xmlHashScanner)scan_type, (void *)result);
   }
 }
 
-static VALUE rxml_schema_collect_types(VALUE self)
+static VALUE rxml_schema_imported_types(VALUE self)
 {
   xmlSchemaPtr xschema;
+  VALUE result = rb_hash_new();
 
   Data_Get_Struct(self, xmlSchema, xschema);
 
-  if(xschema){
-    xmlHashScan(xschema->schemasImports, (xmlHashScanner) collectSchemaTypes, (void *)self);
+  if (xschema)
+  {
+	  xmlHashScan(xschema->schemasImports, (xmlHashScanner)collect_imported_types, (void *)result);
   }
 
-  return Qnil;
+  return result;
 }
 
 void rxml_init_schema(void)
@@ -288,10 +266,10 @@ void rxml_init_schema(void)
   rb_define_method(cXMLSchema, "version", rxml_schema_version, 0);
   rb_define_method(cXMLSchema, "document", rxml_schema_document, 0);
 
-  rb_define_method(cXMLSchema, "_namespaces", rxml_schema_namespaces, 0);
-  rb_define_method(cXMLSchema, "_collect_types", rxml_schema_collect_types, 0);
-  rb_define_method(cXMLSchema, "types", rxml_schema_types, 0);
   rb_define_method(cXMLSchema, "elements", rxml_schema_elements, 0);
+  rb_define_method(cXMLSchema, "imported_types", rxml_schema_imported_types, 0);
+  rb_define_method(cXMLSchema, "namespaces", rxml_schema_namespaces, 0);
+  rb_define_method(cXMLSchema, "types", rxml_schema_types, 0);
 
   rxml_init_schema_facet();
   rxml_init_schema_element();

data/ext/libxml/ruby_xml_schema_element.c

@@ -64,22 +64,25 @@ static VALUE rxml_schema_element_value(VALUE self)
   QNIL_OR_STRING(xelem->value)
 }
 
-static VALUE rxml_schema_element_min_occurs(VALUE self)
-{
-  return rb_iv_get(self, "@min");
-}
-
-static VALUE rxml_schema_element_max_occurs(VALUE self)
-{
-  return rb_iv_get(self, "@max");
-}
-
 static VALUE rxml_schema_element_annot(VALUE self)
 {
-  return rb_iv_get(self, "@annotation");
+	VALUE result = Qnil;
+	xmlSchemaElementPtr xelem;
+
+	Data_Get_Struct(self, xmlSchemaElement, xelem);
+
+	if (xelem != NULL && xelem->annot != NULL && xelem->annot->content != NULL)
+	{
+		xmlChar *content = xmlNodeGetContent(xelem->annot->content);
+		if (content)
+		{
+			result = rxml_new_cstr(content, NULL);
+			xmlFree(content);
+		}
+	}
+	return result;
 }
 
-
 void rxml_init_schema_element(void)
 {
   cXMLSchemaElement = rb_define_class_under(cXMLSchema, "Element", rb_cObject);
@@ -88,7 +91,5 @@ void rxml_init_schema_element(void)
   rb_define_method(cXMLSchemaElement, "type", rxml_schema_element_type, 0);
   rb_define_method(cXMLSchemaElement, "node", rxml_schema_element_node, 0);
   rb_define_method(cXMLSchemaElement, "value", rxml_schema_element_value, 0);
-  rb_define_method(cXMLSchemaElement, "min_occurs", rxml_schema_element_min_occurs, 0);
-  rb_define_method(cXMLSchemaElement, "max_occurs", rxml_schema_element_max_occurs, 0);
   rb_define_method(cXMLSchemaElement, "annotation", rxml_schema_element_annot, 0);
 }

data/ext/libxml/ruby_xml_schema_type.c

@@ -50,28 +50,22 @@ static VALUE rxml_schema_type_base(VALUE self)
 static VALUE rxml_schema_type_facets(VALUE self)
 {
   xmlSchemaTypePtr xtype;
-  xmlSchemaFacetPtr facet;
-  VALUE facets;
-  VALUE rfacet;
+  xmlSchemaFacetPtr xfacet;
+  VALUE result = rb_ary_new();
+  VALUE facet;
 
-  facets = rb_iv_get(self, "@facets");
-
-  if (facets == Qnil) {
-    facets = rb_ary_new();
-    Data_Get_Struct(self, xmlSchemaType, xtype);
-
-    facet = xtype->facets;
+  Data_Get_Struct(self, xmlSchemaType, xtype);
 
-    while (facet != NULL) {
-      rfacet = rxml_wrap_schema_facet((xmlSchemaFacetPtr) facet);
-      rb_ary_push(facets, rfacet);
-      facet = facet->next;
-    }
+  xfacet = xtype->facets;
 
-    rb_iv_set(self, "@facets", facets);
+  while (xfacet != NULL)
+  {
+    facet = rxml_wrap_schema_facet((xmlSchemaFacetPtr)xfacet);
+    rb_ary_push(result, facet);
+    xfacet = xfacet->next;
   }
 
-  return facets;
+  return result;
 }
 
 static VALUE rxml_schema_type_node(VALUE self)
@@ -95,67 +89,60 @@ static VALUE rxml_schema_type_kind(VALUE self)
   return INT2NUM(xtype->type);
 }
 
-static VALUE get_annotation(xmlSchemaAnnotPtr annot)
-{
-  if(annot != NULL && annot->content != NULL && annot->content->content != NULL)
-    return rb_str_new2((const char *) annot->content->content);
-  else
-    return Qnil;
-}
-
 static VALUE rxml_schema_type_annot(VALUE self)
 {
+  VALUE result = Qnil;
   xmlSchemaTypePtr xtype;
 
   Data_Get_Struct(self, xmlSchemaType, xtype);
 
-  if(xtype != NULL && xtype->annot != NULL)
-    return get_annotation(xtype->annot);
-  else
-    return Qnil;
+  if(xtype != NULL && xtype->annot != NULL && xtype->annot->content != NULL)
+  {
+    xmlChar *content = xmlNodeGetContent(xtype->annot->content);
+	if (content)
+	{
+	  result = rxml_new_cstr(content, NULL);
+	  xmlFree(content);
+    }
+  }
+  return result;
 }
 
-static void rxmlSchemaCollectElements(xmlSchemaParticlePtr particle, VALUE self)
+static void rxmlSchemaCollectElements(xmlSchemaParticlePtr xparticle, VALUE hash)
 {
-  VALUE elements;
-  VALUE relement;
-  xmlSchemaTreeItemPtr term;
+  VALUE element;
+  xmlSchemaTreeItemPtr xterm;
 
-  if (particle == NULL)
+  if (xparticle == NULL)
     return;
 
-  term = particle->children;
-
-  if (term != NULL) {
-    elements = rb_iv_get(self, "@elements");
+  xterm = xparticle->children;
 
-    switch (term->type) {
+  if (xterm != NULL)
+  {
+    switch (xterm->type)
+	{
       case XML_SCHEMA_TYPE_ELEMENT:
-        relement = rxml_wrap_schema_element((xmlSchemaElementPtr) term);
+        element = rxml_wrap_schema_element((xmlSchemaElementPtr)xterm);
+        rb_iv_set(element, "@min", INT2NUM(xparticle->minOccurs));
 
-
-        rb_iv_set(relement, "@min", INT2NUM(particle->minOccurs));
-
-        if (particle->maxOccurs >= UNBOUNDED)
-          rb_iv_set(relement, "@max", rb_const_get(rb_path2class("Float"), rb_intern("INFINITY")));
+        if (xparticle->maxOccurs >= UNBOUNDED)
+          rb_iv_set(element, "@max", rb_const_get(rb_path2class("Float"), rb_intern("INFINITY")));
         else
-          rb_iv_set(relement, "@max", INT2NUM(particle->maxOccurs));
+          rb_iv_set(element, "@max", INT2NUM(xparticle->maxOccurs));
 
-        if (particle->annot != NULL)
+        if (xparticle->annot != NULL)
         {
-          xmlChar *content;
-
-          content = xmlNodeGetContent(particle->annot->content);
+          xmlChar *content = xmlNodeGetContent(xparticle->annot->content);
 
           if (content != NULL)
           {
-            rb_iv_set(relement, "@annotation", rb_str_new2((const char *) content));
+            rb_iv_set(element, "@annotation", rb_str_new2((const char *) content));
             xmlFree(content);
           }
         }
 
-        rb_hash_aset(elements, rb_str_new2((const char *) ((xmlSchemaElementPtr) term)->name), relement);
-
+        rb_hash_aset(hash, rb_str_new2((const char *) ((xmlSchemaElementPtr)xterm)->name), element);
         break;
 
       case XML_SCHEMA_TYPE_SEQUENCE:
@@ -171,71 +158,57 @@ static void rxmlSchemaCollectElements(xmlSchemaParticlePtr particle, VALUE self)
         break;
 
       default:
-
         return;
     }
   }
 
-  if (term &&
-      ((term->type == XML_SCHEMA_TYPE_SEQUENCE) ||
-          (term->type == XML_SCHEMA_TYPE_CHOICE) ||
-          (term->type == XML_SCHEMA_TYPE_ALL)) &&
-      (term->children != NULL)) {
-
-    rxmlSchemaCollectElements((xmlSchemaParticlePtr) term->children, self);
+  if (xterm &&
+      ((xterm->type == XML_SCHEMA_TYPE_SEQUENCE) || (xterm->type == XML_SCHEMA_TYPE_CHOICE) || (xterm->type == XML_SCHEMA_TYPE_ALL)) &&
+      (xterm->children != NULL))
+  {
+    rxmlSchemaCollectElements((xmlSchemaParticlePtr)xterm->children, hash);
   }
 
-  if (particle->next != NULL)
-    rxmlSchemaCollectElements((xmlSchemaParticlePtr) particle->next, self);
+  if (xparticle->next != NULL)
+  {
+	rxmlSchemaCollectElements((xmlSchemaParticlePtr)xparticle->next, hash);
+  }
 }
 
-static VALUE
-rxml_schema_type_elements(VALUE self)
+static VALUE rxml_schema_type_elements(VALUE self)
 {
-  VALUE elements;
+  VALUE result = rb_hash_new();
   xmlSchemaTypePtr xtype;
 
   Data_Get_Struct(self, xmlSchemaType, xtype);
+  rxmlSchemaCollectElements((xmlSchemaParticlePtr) xtype->subtypes, result);
 
-  if (rb_iv_get(self, "@elements") == Qnil) {
-    elements = rb_hash_new();
-    rb_iv_set(self, "@elements", elements);
-    rxmlSchemaCollectElements((xmlSchemaParticlePtr) xtype->subtypes, self);
-  }
-
-  return rb_iv_get(self, "@elements");
+  return result;
 }
 
-static VALUE
-rxml_schema_type_attributes(VALUE self)
+static VALUE rxml_schema_type_attributes(VALUE self)
 {
-  VALUE attributes;
+  VALUE result = rb_ary_new();
   xmlSchemaTypePtr xtype;
-  xmlSchemaAttributeUsePtr use;
-  xmlSchemaItemListPtr uses;
+  xmlSchemaAttributeUsePtr xuse;
+  xmlSchemaItemListPtr xuses;
   int i;
 
   Data_Get_Struct(self, xmlSchemaType, xtype);
-
-  if (rb_iv_get(self, "@attributes") == Qnil) {
-    attributes = rb_ary_new();
-    rb_iv_set(self, "@attributes", attributes);
-
-    uses = xtype->attrUses;
-
-    if ((uses == NULL) || (uses->nbItems == 0))
-      return rb_iv_get(self, "@attributes");
-
-    for (i = 0; i < uses->nbItems; i++) {
-      use = (xmlSchemaAttributeUsePtr) uses->items[i];
-      rb_ary_push(attributes, rxml_wrap_schema_attribute(use));
+  xuses = xtype->attrUses;
+
+  if (xuses != NULL)
+  {
+    for (i = 0; i < xuses->nbItems; i++)
+	{
+      xuse = (xmlSchemaAttributeUsePtr)xuses->items[i];
+      rb_ary_push(result, rxml_wrap_schema_attribute(xuse));
     }
   }
 
-  return rb_iv_get(self, "@attributes");
+  return result;
 }
 
-
 void rxml_init_schema_type(void)
 {
   /* Add in infinity support for ruby 1.8.7 */

data/ext/libxml/ruby_xml_version.h

@@ -1,9 +1,9 @@
 /* Don't nuke this block!  It is used for automatically updating the
  * versions below. VERSION = string formatting, VERNUM = numbered
  * version for inline testing: increment both or none at all.*/
-#define RUBY_LIBXML_VERSION  "3.0.0"
-#define RUBY_LIBXML_VERNUM   300
+#define RUBY_LIBXML_VERSION  "3.2.2"
+#define RUBY_LIBXML_VERNUM   321
 #define RUBY_LIBXML_VER_MAJ   3
-#define RUBY_LIBXML_VER_MIN   0
-#define RUBY_LIBXML_VER_MIC   0
+#define RUBY_LIBXML_VER_MIN   2
+#define RUBY_LIBXML_VER_MIC   2
 #define RUBY_LIBXML_VER_PATCH 0