libxml-ruby 3.2.2-x64-mingw-ucrt → 3.2.4-x64-mingw-ucrt

data/ext/libxml/ruby_xml_schema_attribute.c

@@ -2,6 +2,52 @@
 #include "ruby_xml_schema_attribute.h"
 #include "ruby_xml_schema_type.h"
 
+/**
+ * xmlSchemaBasicItem:
+ *
+ * The abstract base type for schema components.
+ */
+typedef struct _xmlSchemaBasicItem xmlSchemaBasicItem;
+typedef xmlSchemaBasicItem *xmlSchemaBasicItemPtr;
+struct _xmlSchemaBasicItem {
+    xmlSchemaTypeType type;
+};
+
+/**
+ * xmlSchemaQNameRef:
+ *
+ * A component reference item (not a schema component)
+ * (Extends xmlSchemaBasicItem)
+ */
+typedef struct _xmlSchemaQNameRef xmlSchemaQNameRef;
+typedef xmlSchemaQNameRef *xmlSchemaQNameRefPtr;
+struct _xmlSchemaQNameRef {
+    xmlSchemaTypeType type;
+    xmlSchemaBasicItemPtr item;
+    /* The resolved referenced item. */
+    xmlSchemaTypeType itemType;
+    const xmlChar *name;
+    const xmlChar *targetNamespace;
+    xmlNodePtr node;
+};
+
+/**
+ * xmlSchemaAttributeUseProhibPtr:
+ *
+ * A helper component to reflect attribute prohibitions.
+ * (Extends xmlSchemaBasicItem)
+ */
+typedef struct _xmlSchemaAttributeUseProhib xmlSchemaAttributeUseProhib;
+typedef xmlSchemaAttributeUseProhib *xmlSchemaAttributeUseProhibPtr;
+struct _xmlSchemaAttributeUseProhib {
+    xmlSchemaTypeType type;
+    /* == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB */
+    xmlNodePtr node;
+    const xmlChar *name;
+    const xmlChar *targetNamespace;
+    int isRef;
+};
+
 VALUE cXMLSchemaAttribute;
 
 static void rxml_schema_attribute_free(xmlSchemaAttributeUsePtr attr)
@@ -12,62 +58,31 @@ static void rxml_schema_attribute_free(xmlSchemaAttributeUsePtr attr)
 
 VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr)
 {
-  return Data_Wrap_Struct(cXMLSchemaAttribute, NULL, rxml_schema_attribute_free, attr);
-}
-
-static VALUE rxml_schema_attribute_namespace(VALUE self)
-{
-  xmlSchemaAttributeUsePtr attr;
-  const xmlChar *tns;
+  VALUE result;
+  const xmlChar *tns_str, *name_str;
 
-  Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
+  if (!attr)
+    rb_raise(rb_eArgError, "XML::Schema::Attribute required!");
 
-  if (attr == NULL)
-    return Qnil;
+  result = Data_Wrap_Struct(cXMLSchemaAttribute, NULL, rxml_schema_attribute_free, attr);
 
   if (attr->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
-      tns = ((xmlSchemaAttributeUseProhibPtr) attr)->targetNamespace;
+    tns_str = ((xmlSchemaAttributeUseProhibPtr) attr)->targetNamespace;
+    name_str = ((xmlSchemaAttributeUseProhibPtr) attr)->name;
   } else if (attr->type == XML_SCHEMA_EXTRA_QNAMEREF) {
-      tns = ((xmlSchemaQNameRefPtr) attr)->targetNamespace;
+    tns_str = ((xmlSchemaQNameRefPtr) attr)->targetNamespace;
+    name_str = ((xmlSchemaQNameRefPtr) attr)->name;
   } else {
-      tns = ((xmlSchemaAttributePtr) ((xmlSchemaAttributeUsePtr) (attr))->attrDecl)->targetNamespace;
+    tns_str = ((xmlSchemaAttributePtr) (attr->attrDecl))->targetNamespace;
+    name_str = ((xmlSchemaAttributePtr) (attr->attrDecl))->name;
   }
+  rb_iv_set(result, "@target_namespace", QNIL_OR_STRING(tns_str));
+  rb_iv_set(result, "@name", QNIL_OR_STRING(name_str));
+  rb_iv_set(result, "@type", rxml_wrap_schema_type((xmlSchemaTypePtr)attr->attrDecl->subtypes));
+  rb_iv_set(result, "@value", QNIL_OR_STRING(attr->defValue));
+  rb_iv_set(result, "@occurs", INT2NUM(attr->occurs));
 
-  QNIL_OR_STRING(tns)
-}
-
-static VALUE rxml_schema_attribute_name(VALUE self)
-{
-  xmlSchemaAttributeUsePtr attr;
-  const xmlChar *name;
-
-  Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
-
-  if (attr == NULL)
-    return Qnil;
-
-  if (attr->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
-      name = ((xmlSchemaAttributeUseProhibPtr) attr)->name;
-  } else if (attr->type == XML_SCHEMA_EXTRA_QNAMEREF) {
-      name = ((xmlSchemaQNameRefPtr) attr)->name;
-  } else {
-      xmlSchemaAttributePtr attrDecl = ((xmlSchemaAttributeUsePtr) attr)->attrDecl;
-      name = attrDecl->name;
-  }
-
-  QNIL_OR_STRING(name)
-}
-
-static VALUE rxml_schema_attribute_type(VALUE self)
-{
-  xmlSchemaAttributeUsePtr attr;
-  xmlSchemaTypePtr xtype;
-
-  Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
-
-  xtype = attr->attrDecl->subtypes;
-
-  return rxml_wrap_schema_type((xmlSchemaTypePtr) xtype);
+  return result;
 }
 
 static VALUE rxml_schema_attribute_node(VALUE self)
@@ -79,31 +94,14 @@ static VALUE rxml_schema_attribute_node(VALUE self)
   return rxml_node_wrap(attr->node);
 }
 
-static VALUE rxml_schema_attribute_value(VALUE self)
-{
-  xmlSchemaAttributeUsePtr attr;
-
-  Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
-
-  QNIL_OR_STRING(attr->defValue)
-}
-
-static VALUE rxml_schema_attribute_occurs(VALUE self)
-{
-  xmlSchemaAttributeUsePtr attr;
-
-  Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
-
-  return INT2NUM(attr->occurs);
-}
-
 void rxml_init_schema_attribute(void)
 {
   cXMLSchemaAttribute = rb_define_class_under(cXMLSchema, "Attribute", rb_cObject);
-  rb_define_method(cXMLSchemaAttribute, "namespace", rxml_schema_attribute_namespace, 0);
-  rb_define_method(cXMLSchemaAttribute, "name", rxml_schema_attribute_name, 0);
-  rb_define_method(cXMLSchemaAttribute, "type", rxml_schema_attribute_type, 0);
+  rb_define_attr(cXMLSchemaAttribute, "name", 1, 0);
+  rb_define_attr(cXMLSchemaAttribute, "type", 1, 0);
+  rb_define_attr(cXMLSchemaAttribute, "namespace", 1, 0);
+  rb_define_attr(cXMLSchemaAttribute, "value", 1, 0);
+  rb_define_attr(cXMLSchemaAttribute, "occurs", 1, 0);
+
   rb_define_method(cXMLSchemaAttribute, "node", rxml_schema_attribute_node, 0);
-  rb_define_method(cXMLSchemaAttribute, "value", rxml_schema_attribute_value, 0);
-  rb_define_method(cXMLSchemaAttribute, "occurs", rxml_schema_attribute_occurs, 0);
 }

data/ext/libxml/ruby_xml_schema_attribute.h

@@ -2,12 +2,34 @@
 #define __RXML_SCHEMA_ATTRIBUTE__
 
 #include "ruby_xml_schema.h"
-#include <libxml/schemasInternals.h>
-#include <libxml/xmlschemas.h>
-#include <libxml/xmlschemastypes.h>
 
 extern VALUE cXMLSchemaAttribute;
 
+/**
+ * xmlSchemaAttributeUsePtr:
+ *
+ * The abstract base type for tree-like structured schema components.
+ * (Extends xmlSchemaTreeItem)
+ */
+typedef struct _xmlSchemaAttributeUse xmlSchemaAttributeUse;
+typedef xmlSchemaAttributeUse *xmlSchemaAttributeUsePtr;
+struct _xmlSchemaAttributeUse {
+    xmlSchemaTypeType type;
+    xmlSchemaAnnotPtr annot;
+    xmlSchemaAttributeUsePtr next; /* The next attr. use. */
+    /*
+    * The attr. decl. OR a QName-ref. to an attr. decl. OR
+    * a QName-ref. to an attribute group definition.
+    */
+    xmlSchemaAttributePtr attrDecl;
+
+    int flags;
+    xmlNodePtr node;
+    int occurs;
+    /* required, optional */
+    const xmlChar *defValue;
+    xmlSchemaValPtr defVal;
+};
 
 void rxml_init_schema_attribute(void);
 VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr);

data/ext/libxml/ruby_xml_schema_element.c

@@ -10,40 +10,21 @@ static void rxml_schema_element_free(xmlSchemaElementPtr xschema_element)
   xmlFree(xschema_element);
 }
 
-VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelement)
+VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelem)
 {
-  return Data_Wrap_Struct(cXMLSchemaElement, NULL, rxml_schema_element_free, xelement);
-}
+  VALUE result;
 
-static VALUE rxml_schema_element_namespace(VALUE self)
-{
-  xmlSchemaElementPtr xelem;
+  if (!xelem)
+    rb_raise(rb_eArgError, "XML::Schema::Element is required!");
 
-  Data_Get_Struct(self, xmlSchemaElement, xelem);
+  result = Data_Wrap_Struct(cXMLSchemaElement, NULL, rxml_schema_element_free, xelem);
 
-  QNIL_OR_STRING(xelem->targetNamespace)
-}
+  rb_iv_set(result, "@name", QNIL_OR_STRING(xelem->name));
+  rb_iv_set(result, "@value", QNIL_OR_STRING(xelem->value));
+  rb_iv_set(result, "@namespace", QNIL_OR_STRING(xelem->targetNamespace));
+  rb_iv_set(result, "@type", rxml_wrap_schema_type((xmlSchemaTypePtr) (xelem->subtypes)));
 
-static VALUE rxml_schema_element_name(VALUE self)
-{
-  xmlSchemaElementPtr xelem;
-
-  Data_Get_Struct(self, xmlSchemaElement, xelem);
-
-
-  QNIL_OR_STRING(xelem->name)
-}
-
-static VALUE rxml_schema_element_type(VALUE self)
-{
-  xmlSchemaElementPtr xelem;
-  xmlSchemaTypePtr xtype;
-
-  Data_Get_Struct(self, xmlSchemaElement, xelem);
-
-  xtype = xelem->subtypes;
-
-  return rxml_wrap_schema_type((xmlSchemaTypePtr) xtype);
+  return result;
 }
 
 static VALUE rxml_schema_element_node(VALUE self)
@@ -55,41 +36,34 @@ static VALUE rxml_schema_element_node(VALUE self)
   return rxml_node_wrap(xelem->node);
 }
 
-static VALUE rxml_schema_element_value(VALUE self)
+static VALUE rxml_schema_element_annot(VALUE self)
 {
   xmlSchemaElementPtr xelem;
+  VALUE annotation = Qnil;
 
   Data_Get_Struct(self, xmlSchemaElement, xelem);
 
-  QNIL_OR_STRING(xelem->value)
-}
-
-static VALUE rxml_schema_element_annot(VALUE self)
-{
-	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;
+  if ((xelem->annot != NULL) && (xelem->annot->content != NULL))
+  {
+    xmlChar *content = xmlNodeGetContent(xelem->annot->content);
+    if (content)
+    {
+      annotation = rxml_new_cstr(content, NULL);
+      xmlFree(content);
+    }
+  }
+
+  return annotation;
 }
 
 void rxml_init_schema_element(void)
 {
   cXMLSchemaElement = rb_define_class_under(cXMLSchema, "Element", rb_cObject);
-  rb_define_method(cXMLSchemaElement, "namespace", rxml_schema_element_namespace, 0);
-  rb_define_method(cXMLSchemaElement, "name", rxml_schema_element_name, 0);
-  rb_define_method(cXMLSchemaElement, "type", rxml_schema_element_type, 0);
+  rb_define_attr(cXMLSchemaElement, "name", 1, 0);
+  rb_define_attr(cXMLSchemaElement, "value", 1, 0);
+  rb_define_attr(cXMLSchemaElement, "namespace", 1, 0);
+  rb_define_attr(cXMLSchemaElement, "type", 1, 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, "annotation", rxml_schema_element_annot, 0);
 }

data/ext/libxml/ruby_xml_schema_element.h

@@ -2,9 +2,6 @@
 #define __RXML_SCHEMA_ELEMENT__
 
 #include "ruby_xml_schema.h"
-#include <libxml/schemasInternals.h>
-#include <libxml/xmlschemas.h>
-#include <libxml/xmlschemastypes.h>
 
 extern VALUE cXMLSchemaElement;
 

data/ext/libxml/ruby_xml_schema_facet.c

@@ -1,6 +1,10 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_schema_facet.h"
 
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/xmlschemastypes.h>
+
 VALUE cXMLSchemaFacet;
 
 static void rxml_schema_facet_free(xmlSchemaFacetPtr xschema_type)
@@ -9,44 +13,38 @@ static void rxml_schema_facet_free(xmlSchemaFacetPtr xschema_type)
   xmlFree(xschema_type);
 }
 
-/* START FACET*/
-
-static VALUE rxml_schema_facet_node(VALUE self)
+VALUE rxml_wrap_schema_facet(xmlSchemaFacetPtr facet)
 {
-  xmlSchemaFacetPtr facet;
+  VALUE result;
 
-  Data_Get_Struct(self, xmlSchemaFacet, facet);
+  if (!facet)
+    rb_raise(rb_eArgError, "XML::Schema::Facet required!");
 
-  return rxml_node_wrap(facet->node);
-}
+  result = Data_Wrap_Struct(cXMLSchemaFacet, NULL, rxml_schema_facet_free, facet);
 
-static VALUE rxml_schema_facet_value(VALUE self)
-{
-  xmlSchemaFacetPtr facet;
+  rb_iv_set(result, "@kind", INT2NUM(facet->type));
+  rb_iv_set(result, "@value", QNIL_OR_STRING(facet->value));
 
-  Data_Get_Struct(self, xmlSchemaFacet, facet);
+  return result;
 
-  QNIL_OR_STRING(facet->value)
 }
 
-static VALUE rxml_schema_facet_kind(VALUE self)
+/* START FACET*/
+
+static VALUE rxml_schema_facet_node(VALUE self)
 {
   xmlSchemaFacetPtr facet;
 
   Data_Get_Struct(self, xmlSchemaFacet, facet);
 
-  return INT2NUM(facet->type);
-}
-
-VALUE rxml_wrap_schema_facet(xmlSchemaFacetPtr facet)
-{
-  return Data_Wrap_Struct(cXMLSchemaFacet, NULL, rxml_schema_facet_free, facet);
+  return rxml_node_wrap(facet->node);
 }
 
 void rxml_init_schema_facet(void)
 {
   cXMLSchemaFacet = rb_define_class_under(cXMLSchema, "Facet", rb_cObject);
-  rb_define_method(cXMLSchemaFacet, "value", rxml_schema_facet_value, 0);
+  rb_define_attr(cXMLSchemaFacet, "kind", 1, 0);
+  rb_define_attr(cXMLSchemaFacet, "value", 1, 0);
+
   rb_define_method(cXMLSchemaFacet, "node", rxml_schema_facet_node, 0);
-  rb_define_method(cXMLSchemaFacet, "kind", rxml_schema_facet_kind, 0);
 }

data/ext/libxml/ruby_xml_schema_facet.h

@@ -1,10 +1,6 @@
 #ifndef __RXML_SCHEMA_FACET__
 #define __RXML_SCHEMA_FACET__
 
-#include <libxml/schemasInternals.h>
-#include <libxml/xmlschemas.h>
-#include <libxml/xmlschemastypes.h>
-
 extern VALUE cXMLSchemaFacet;
 
 VALUE rxml_wrap_schema_facet(xmlSchemaFacetPtr facet);

data/ext/libxml/ruby_xml_schema_type.c

@@ -7,6 +7,43 @@
 #define UNBOUNDED 1 << 30
 #define FREE_AND_NULL(str) if ((str) != NULL) { xmlFree((xmlChar *) (str)); str = NULL; }
 
+/**
+ * xmlSchemaTreeItem:
+ *
+ * The abstract base type for tree-like structured schema components.
+ * (Extends xmlSchemaAnnotItem)
+ */
+typedef struct _xmlSchemaTreeItem xmlSchemaTreeItem;
+typedef xmlSchemaTreeItem *xmlSchemaTreeItemPtr;
+struct _xmlSchemaTreeItem {
+    xmlSchemaTypeType type;
+    xmlSchemaAnnotPtr annot;
+    xmlSchemaTreeItemPtr next;
+    xmlSchemaTreeItemPtr children;
+};
+
+ /**
+ * xmlSchemaParticle:
+ *
+ * A particle component.
+ * (Extends xmlSchemaTreeItem)
+ */
+typedef struct _xmlSchemaParticle xmlSchemaParticle;
+typedef xmlSchemaParticle *xmlSchemaParticlePtr;
+struct _xmlSchemaParticle {
+    xmlSchemaTypeType type;
+    xmlSchemaAnnotPtr annot;
+    xmlSchemaTreeItemPtr next;
+    /* next particle */
+    xmlSchemaTreeItemPtr children;
+    /* the "term" (e.g. a model group,
+a group definition, a XML_SCHEMA_EXTRA_QNAMEREF (if a reference),
+   etc.) */
+    int minOccurs;
+    int maxOccurs;
+    xmlNodePtr node;
+};
+
 VALUE cXMLSchemaType;
 
 static void rxml_schema_type_free(xmlSchemaTypePtr xschema_type)
@@ -17,34 +54,36 @@ static void rxml_schema_type_free(xmlSchemaTypePtr xschema_type)
 
 VALUE rxml_wrap_schema_type(xmlSchemaTypePtr xtype)
 {
-  return Data_Wrap_Struct(cXMLSchemaType, NULL, rxml_schema_type_free, xtype);
-}
+  VALUE result;
 
-static VALUE rxml_schema_type_namespace(VALUE self)
-{
-  xmlSchemaTypePtr xtype;
+  if (!xtype)
+    rb_raise(rb_eArgError, "XML::Schema::Type required!");
 
-  Data_Get_Struct(self, xmlSchemaType, xtype);
+  result = Data_Wrap_Struct(cXMLSchemaType, NULL, rxml_schema_type_free, xtype);
+
+  rb_iv_set(result, "@name", QNIL_OR_STRING(xtype->name));
+  rb_iv_set(result, "@namespace", QNIL_OR_STRING(xtype->targetNamespace));
+  rb_iv_set(result, "@kind", INT2NUM(xtype->type));
 
-  QNIL_OR_STRING(xtype->targetNamespace)
+  return result;
 }
 
-static VALUE rxml_schema_type_name(VALUE self)
+static VALUE rxml_schema_type_base(VALUE self)
 {
   xmlSchemaTypePtr xtype;
 
   Data_Get_Struct(self, xmlSchemaType, xtype);
 
-  QNIL_OR_STRING(xtype->name)
+  return (xtype->baseType != xtype) ? rxml_wrap_schema_type(xtype->baseType) : Qnil;
 }
 
-static VALUE rxml_schema_type_base(VALUE self)
+static VALUE rxml_schema_type_node(VALUE self)
 {
   xmlSchemaTypePtr xtype;
 
   Data_Get_Struct(self, xmlSchemaType, xtype);
 
-  return Data_Wrap_Struct(cXMLSchemaType, NULL, rxml_schema_type_free, xtype->baseType);
+  return (xtype->node != NULL) ? rxml_node_wrap(xtype->node) : Qnil;
 }
 
 static VALUE rxml_schema_type_facets(VALUE self)
@@ -68,27 +107,6 @@ static VALUE rxml_schema_type_facets(VALUE self)
   return result;
 }
 
-static VALUE rxml_schema_type_node(VALUE self)
-{
-  xmlSchemaTypePtr xtype;
-
-  Data_Get_Struct(self, xmlSchemaType, xtype);
-
-  if(xtype->node != NULL)
-    return rxml_node_wrap(xtype->node);
-  else
-    return Qnil;
-}
-
-static VALUE rxml_schema_type_kind(VALUE self)
-{
-  xmlSchemaTypePtr xtype;
-
-  Data_Get_Struct(self, xmlSchemaType, xtype);
-
-  return INT2NUM(xtype->type);
-}
-
 static VALUE rxml_schema_type_annot(VALUE self)
 {
   VALUE result = Qnil;
@@ -220,13 +238,14 @@ void rxml_init_schema_type(void)
 
   cXMLSchemaType = rb_define_class_under(cXMLSchema, "Type", rb_cObject);
 
-  rb_define_method(cXMLSchemaType, "namespace", rxml_schema_type_namespace, 0);
-  rb_define_method(cXMLSchemaType, "name", rxml_schema_type_name, 0);
-  rb_define_method(cXMLSchemaType, "elements", rxml_schema_type_elements, 0);
-  rb_define_method(cXMLSchemaType, "attributes", rxml_schema_type_attributes, 0);
+  rb_define_attr(cXMLSchemaType, "namespace", 1, 0);
+  rb_define_attr(cXMLSchemaType, "name", 1, 0);
+  rb_define_attr(cXMLSchemaType, "kind", 1, 0);
+
   rb_define_method(cXMLSchemaType, "base", rxml_schema_type_base, 0);
-  rb_define_method(cXMLSchemaType, "kind", rxml_schema_type_kind, 0);
   rb_define_method(cXMLSchemaType, "node", rxml_schema_type_node, 0);
+  rb_define_method(cXMLSchemaType, "elements", rxml_schema_type_elements, 0);
+  rb_define_method(cXMLSchemaType, "attributes", rxml_schema_type_attributes, 0);
   rb_define_method(cXMLSchemaType, "facets", rxml_schema_type_facets, 0);
   rb_define_method(cXMLSchemaType, "annotation", rxml_schema_type_annot, 0);
 }

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.2.2"
-#define RUBY_LIBXML_VERNUM   321
+#define RUBY_LIBXML_VERSION  "3.2.4"
+#define RUBY_LIBXML_VERNUM   324
 #define RUBY_LIBXML_VER_MAJ   3
 #define RUBY_LIBXML_VER_MIN   2
-#define RUBY_LIBXML_VER_MIC   2
+#define RUBY_LIBXML_VER_MIC   4
 #define RUBY_LIBXML_VER_PATCH 0

data/ext/libxml/ruby_xml_writer.c

@@ -1,6 +1,10 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_writer.h"
 
+#ifdef LIBXML_WRITER_ENABLED
+#include <libxml/xmlwriter.h>
+#endif
+
 VALUE cXMLWriter;
 static VALUE sEncoding, sStandalone;
 

data/ext/libxml/ruby_xml_writer.h

@@ -1,10 +1,6 @@
 #ifndef __RXML_WRITER__
 #define __RXML_WRITER__
 
-#ifdef LIBXML_WRITER_ENABLED
-#include <libxml/xmlwriter.h>
-#endif
-
 extern VALUE cXMLWriter;
 void rxml_init_writer(void);
 #endif

data/ext/libxml/ruby_xml_xinclude.c

@@ -1,6 +1,10 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_xinclude.h"
 
+#ifdef LIBXML_XINCLUDE_ENABLED
+#include <libxml/xinclude.h>
+#endif
+
 VALUE cXMLXInclude;
 
 /*

data/ext/libxml/ruby_xml_xpath.c

@@ -75,6 +75,7 @@
 */
 
 #include "ruby_libxml.h"
+#include <libxml/xpathInternals.h>
 
 VALUE mXPath;
 

data/ext/libxml/ruby_xml_xpath.h

@@ -3,6 +3,8 @@
 #ifndef __RXML_XPATH__
 #define __RXML_XPATH__
 
+#include <libxml/xpath.h>
+
 extern VALUE mXPath;
 
 void rxml_init_xpath(void);

data/ext/libxml/ruby_xml_xpath_context.c

@@ -10,6 +10,8 @@
 #include <st.h>
 #endif
 
+#include <libxml/xpathInternals.h>
+
 /*
  * Document-class: LibXML::XML::XPath::Context
  *

data/ext/libxml/ruby_xml_xpath_object.c

@@ -1,4 +1,5 @@
 #include "ruby_libxml.h"
+#include <libxml/xpathInternals.h>
 
 /*
  * Document-class: LibXML::XML::XPath::Object

data/ext/libxml/ruby_xml_xpointer.c

@@ -3,6 +3,10 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_xpointer.h"
 
+#ifdef LIBXML_XPTR_ENABLED
+#include <libxml/xpointer.h>
+#endif
+
 VALUE cXMLXPointer;
 
 /*
@@ -62,7 +66,7 @@ VALUE rxml_xpointer_point2(VALUE node, VALUE xptr_str)
  */
 static VALUE rxml_xpointer_range(VALUE class, VALUE rstart, VALUE rend)
 {
-#ifdef LIBXML_XPTR_ENABLED
+#if defined LIBXML_XPTR_ENABLED && defined LIBXML_XPTR_LOCS_ENABLED
   xmlNodePtr start, end;
   VALUE rxxp;
   xmlXPathObjectPtr xpath;

data/lib/libxml-ruby.rb

@@ -4,7 +4,7 @@
 begin
   RUBY_VERSION =~ /(\d+.\d+)/
   require "#{$1}/libxml_ruby"
-rescue LoadError
+rescue LoadError => e
   require "libxml_ruby"
 end
 

data/test/model/shiporder.rnc

@@ -5,9 +5,9 @@
 #
 namespace xsi = "http://www.w3.org/2001/XMLSchema-instance"
 
-start = shiporder
+start = shiporderType
 
-shiporder  = element shiporder { attribute orderid { text }, 
+shiporderType  = element shiporder { attribute orderid { text },
                                  attribute xsi:noNamespaceSchemaLocation { text }, 
                                orderperson, shipto, item* }