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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee2d2d06a61fdce25ffd0982325278d4da75372a3f1c4138ab43b72836e2d7bd
-  data.tar.gz: 57d57db50b7765d7aef7fdb3f212d02a55ba336949512afe1a1ec9056f013943
+  metadata.gz: 133d86e0978fad8ee63caac2b000d64528da03c5141e484327dc1bd443f85ad5
+  data.tar.gz: 3d43359e5daed2d0e6ea23481aaf405aa9422419edaefe8a51d18767c463c052
 SHA512:
-  metadata.gz: 3cffc96fbe8bce6629e7bc3759853b80f1f8c142b01e1cbbdaab137248bd8b3fadc85872d7dc474124cdbf6697aac37c8ce62ed372f7977718dda4cfc7ada273
-  data.tar.gz: 2edbb7497cc7c03553db64c6deb2d43c571e021fbec03fc1555650f07fd778bf57b9002f177af69b3a48772367bca21529a726ced1740d1446729b99cf6cf144
+  metadata.gz: 7b91fe3b0daa9a90706a531e552ff16a3e785612e259aa7e379d9e948f72c0d2738c34a33a5e5697cee6ba4cb43c991e657347e40d35a13f749c494a64e54bea
+  data.tar.gz: 68afd10bef5ba4f05bdc275b526c319c0d6f98492ba039bff0ce599b58c5eeb72789669a361175491cca6225934a053054955a36ad4833d3bd5a79eee7e4da3d

data/HISTORY

@@ -1,5 +1,21 @@
 = Release History
 
+== 3.2.4 / 2022-10-29
+
+* Support libxml2 version 2.10.2 (Charlie Savage)
+* Reduce number of globally included C header files (Charlie Savage)
+
+== 3.2.3 / 2022-05-22
+
+* Change some getter methods to instance variables with attr_accessors for easier debuggability (David Hansen)
+* Add a number of tests related to schemas  (David Hansen)
+* Add schema.imported_elements so we can find imported elements (David Hansen)
+* Fix segfault under windows when dereferencing a pre-existing error where the node has already been freed (David Hansen)
+* Update to change name from imported_elements to imported_ns_elements and return a hash of hashes for namespaced elements (David Hansen)
+* Only call xmlGetFeaturesList if LIBXML_LEGACY_ENABLED is defined. Most distros still ship libxml2 with legacy features enabled, but this will change (Nick Wellnhofer)
+* Update GitHub Actions to use ruby/setup-ruby (Greg)
+* Fix memory leak in rxml_node_path, node.path (vovanmozg)
+
 == 3.2.2 / 2022-01-15
 * Switch to Github actions for CI/CD (Greg)
 * Test fixes (Greg, Sergio Durigan Junior)

data/ext/libxml/extconf.h

@@ -0,0 +1,3 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#endif

data/ext/libxml/ruby_libxml.h

@@ -4,29 +4,7 @@
 #define __RUBY_LIBXML_H__
 
 #include <ruby.h>
-#include <libxml/parser.h>
-#include <libxml/parserInternals.h>
-#include <libxml/debugXML.h>
 #include <libxml/xmlversion.h>
-#include <libxml/xmlmemory.h>
-#include <libxml/xpath.h>
-#include <libxml/valid.h>
-#include <libxml/catalog.h>
-#include <libxml/HTMLparser.h>
-#include <libxml/xmlreader.h>
-#include <libxml/c14n.h>
-
-#include <ruby/encoding.h>
-
-#ifdef LIBXML_DEBUG_ENABLED
-#include <libxml/xpathInternals.h>
-#endif
-#ifdef LIBXML_XINCLUDE_ENABLED
-#include <libxml/xinclude.h>
-#endif
-#ifdef LIBXML_XPTR_ENABLED
-#include <libxml/xpointer.h>
-#endif
 
 #include "ruby_xml_version.h"
 #include "ruby_xml.h"

data/ext/libxml/ruby_xml.c

@@ -1,6 +1,8 @@
 #include "ruby_libxml.h"
 #include "ruby_xml.h"
 
+#include <libxml/catalog.h>
+
 VALUE mXML;
 
 /*
@@ -764,6 +766,9 @@ static VALUE rxml_default_save_no_empty_tags_set(VALUE klass, VALUE value)
  */
 static VALUE rxml_features(VALUE klass)
 {
+#ifndef LIBXML_LEGACY_ENABLED
+  return Qnil;
+#else
   VALUE arr, str;
   int i, len = MAX_LIBXML_FEATURES_LEN;
   char **list = NULL;
@@ -788,6 +793,7 @@ static VALUE rxml_features(VALUE klass)
 
   ruby_xfree(list);
   return (arr);
+#endif /* LIBXML_LEGACY_ENABLED */
 }
 
 /*

data/ext/libxml/ruby_xml_document.c

@@ -52,6 +52,12 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_document.h"
 
+#include <libxml/c14n.h>
+#include <libxml/debugXML.h>
+#include <libxml/relaxng.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/xinclude.h>
+
 VALUE cXMLDocument;
 
 void rxml_document_free(xmlDocPtr xdoc)

data/ext/libxml/ruby_xml_encoding.h

@@ -3,6 +3,8 @@
 #ifndef __RXML_ENCODING__
 #define __RXML_ENCODING__
 
+#include <ruby/encoding.h>
+
 extern VALUE mXMLEncoding;
 
 void rxml_init_encoding();

data/ext/libxml/ruby_xml_error.h

@@ -3,6 +3,8 @@
 #ifndef __RXML_ERROR__
 #define __RXML_ERROR__
 
+#include <libxml/xmlerror.h>
+
 extern VALUE eXMLError;
 
 void rxml_init_error();

data/ext/libxml/ruby_xml_html_parser.c

@@ -2,6 +2,8 @@
 
 #include "ruby_libxml.h"
 
+#include <libxml/HTMLparser.h>
+
 /* Document-class: LibXML::XML::HTMLParser
  *
  * The HTML parser implements an HTML 4.0 non-verifying parser with an API

data/ext/libxml/ruby_xml_html_parser_context.c

@@ -3,6 +3,7 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_html_parser_context.h"
 
+#include <libxml/parserInternals.h>
 
 /*
  * Document-class: LibXML::XML::HTMLParser::Context

data/ext/libxml/ruby_xml_html_parser_options.c

@@ -2,6 +2,8 @@
 
 #include "ruby_libxml.h"
 
+#include <libxml/HTMLparser.h>
+
 /* Document-class: LibXML::XML::HTMLParser::Options
  *
  * Options to control the operation of the HTMLParser.  The easiest

data/ext/libxml/ruby_xml_namespace.c

@@ -52,6 +52,7 @@ static VALUE rxml_namespace_initialize(VALUE self, VALUE node, VALUE prefix,
 
   Check_Type(node, T_DATA);
   Data_Get_Struct(node, xmlNode, xnode);
+  xmlResetLastError();
 
   /* Prefix can be null - that means its the default namespace */
   xmlPrefix = NIL_P(prefix) ? NULL : (xmlChar *)StringValuePtr(prefix);

data/ext/libxml/ruby_xml_node.c

@@ -2,6 +2,10 @@
 #include "ruby_xml_node.h"
 #include <assert.h>
 
+#include <libxml/debugXML.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xlink.h>
+
 VALUE cXMLNode;
 
 /* Document-class: LibXML::XML::Node
@@ -983,14 +987,18 @@ static VALUE rxml_node_path(VALUE self)
 {
   xmlNodePtr xnode;
   xmlChar *path;
+  VALUE result = Qnil;
 
   xnode = rxml_get_xnode(self);
   path = xmlGetNodePath(xnode);
 
-  if (path == NULL)
-    return (Qnil);
-  else
-    return (rxml_new_cstr( path, NULL));
+  if (path)
+  {
+    result = rxml_new_cstr( path, NULL);
+    xmlFree(path);
+  }
+
+  return result;
 }
 
 /*

data/ext/libxml/ruby_xml_parser_context.c

@@ -3,6 +3,8 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_parser_context.h"
 
+#include <libxml/parserInternals.h>
+
 VALUE cXMLParserContext;
 static ID IO_ATTR;
 

data/ext/libxml/ruby_xml_reader.c

@@ -4,6 +4,9 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_reader.h"
 
+#include <libxml/xmlreader.h>
+#include <libxml/xmlschemas.h>
+
 /*
  * Document-class: LibXML::XML::Reader
  *

data/ext/libxml/ruby_xml_reader.h

@@ -4,9 +4,6 @@
 #ifndef __RXML_READER__
 #define __RXML_READER__
 
-#include <libxml/xmlreader.h>
-#include <libxml/xmlschemas.h>
-
 extern VALUE cXMLReader;
 
 void rxml_init_reader(void);

data/ext/libxml/ruby_xml_relaxng.c

@@ -1,6 +1,8 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_relaxng.h"
 
+#include <libxml/relaxng.h>
+
 /*
  * Document-class: LibXML::XML::RelaxNG
  *

data/ext/libxml/ruby_xml_relaxng.h

@@ -1,8 +1,6 @@
 #ifndef __RXML_RELAXNG__
 #define __RXML_RELAXNG__
 
-#include <libxml/relaxng.h>
-
 extern VALUE cXMLRelaxNG;
 
 void  rxml_init_relaxng(void);

data/ext/libxml/ruby_xml_schema.c

@@ -1,6 +1,4 @@
 #include "ruby_libxml.h"
-#define LIBXML_OUTPUT_ENABLED
-#define DUMP_CONTENT_MODEL
 #include "ruby_xml_schema.h"
 
 #include "ruby_xml_schema_type.h"
@@ -8,6 +6,78 @@
 #include "ruby_xml_schema_attribute.h"
 #include "ruby_xml_schema_facet.h"
 
+#include <libxml/xmlschemas.h>
+
+typedef struct _xmlSchemaBucket xmlSchemaBucket;
+typedef xmlSchemaBucket *xmlSchemaBucketPtr;
+
+/**
+ * xmlSchemaSchemaRelation:
+ *
+ * Used to create a graph of schema relationships.
+ */
+typedef struct _xmlSchemaSchemaRelation xmlSchemaSchemaRelation;
+typedef xmlSchemaSchemaRelation *xmlSchemaSchemaRelationPtr;
+struct _xmlSchemaSchemaRelation {
+    xmlSchemaSchemaRelationPtr next;
+    int type;
+    /* E.g. XML_SCHEMA_SCHEMA_IMPORT */
+    const xmlChar *importNamespace;
+    xmlSchemaBucketPtr bucket;
+};
+
+struct _xmlSchemaBucket {
+    int type;
+    int flags;
+    const xmlChar *schemaLocation;
+    const xmlChar *origTargetNamespace;
+    const xmlChar *targetNamespace;
+    xmlDocPtr doc;
+    xmlSchemaSchemaRelationPtr relations;
+    int located;
+    int parsed;
+    int imported;
+    int preserveDoc;
+    xmlSchemaItemListPtr globals;
+    /* Global components. */
+    xmlSchemaItemListPtr locals; /* Local components. */
+};
+
+/**
+ * xmlSchemaImport:
+ * (extends xmlSchemaBucket)
+ *
+ * Reflects a schema. Holds some information
+ * about the schema and its toplevel components. Duplicate
+ * toplevel components are not checked at this level.
+ */
+typedef struct _xmlSchemaImport xmlSchemaImport;
+typedef xmlSchemaImport *xmlSchemaImportPtr;
+struct _xmlSchemaImport {
+    int type;
+    /* Main OR import OR include. */
+    int flags;
+    const xmlChar *schemaLocation; /* The URI of the schema document. */
+    /* For chameleon includes, @origTargetNamespace will be NULL */
+    const xmlChar *origTargetNamespace;
+    /*
+    * For chameleon includes, @targetNamespace will be the
+    * targetNamespace of the including schema.
+    */
+    const xmlChar *targetNamespace;
+    xmlDocPtr doc; /* The schema node-tree. */
+    /* @relations will hold any included/imported/redefined schemas. */
+    xmlSchemaSchemaRelationPtr relations;
+    int located;
+    int parsed;
+    int imported;
+    int preserveDoc;
+    xmlSchemaItemListPtr globals;
+    xmlSchemaItemListPtr locals;
+    /* The imported schema. */
+    xmlSchemaPtr schema;
+};
+
 /*
  * Document-class: LibXML::XML::Schema
  *
@@ -46,9 +116,37 @@ static void rxml_schema_free(xmlSchemaPtr xschema)
 
 VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
 {
-  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+  VALUE result;
+
+  if (!xschema)
+    rb_raise(rb_eArgError, "XML::Schema is required!");
+
+  result = Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+
+  /*
+   * Create these as instance variables to provide the output of inspect/to_str some
+   * idea of what schema this class contains.
+   */
+  rb_iv_set(result, "@target_namespace", QNIL_OR_STRING(xschema->targetNamespace));
+  rb_iv_set(result, "@name", QNIL_OR_STRING(xschema->name));
+  rb_iv_set(result, "@id", QNIL_OR_STRING(xschema->id));
+  rb_iv_set(result, "@version", QNIL_OR_STRING(xschema->name));
+
+  return result;
 }
 
+static VALUE rxml_schema_init(VALUE class, xmlSchemaParserCtxtPtr xparser)
+{
+  xmlSchemaPtr xschema;
+
+  xschema = xmlSchemaParse(xparser);
+  xmlSchemaFreeParserCtxt(xparser);
+
+  if (!xschema)
+    rxml_raise(&xmlLastError);
+
+  return rxml_wrap_schema(xschema);
+}
 
 /*
  * call-seq:
@@ -59,15 +157,15 @@ VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
 static VALUE rxml_schema_init_from_uri(VALUE class, VALUE uri)
 {
   xmlSchemaParserCtxtPtr xparser;
-  xmlSchemaPtr xschema;
 
   Check_Type(uri, T_STRING);
 
+  xmlResetLastError();
   xparser = xmlSchemaNewParserCtxt(StringValuePtr(uri));
-  xschema = xmlSchemaParse(xparser);
-  xmlSchemaFreeParserCtxt(xparser);
+  if (!xparser)
+    rxml_raise(&xmlLastError);
 
-  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+  return rxml_schema_init(class, xparser);
 }
 
 /*
@@ -79,19 +177,16 @@ static VALUE rxml_schema_init_from_uri(VALUE class, VALUE uri)
 static VALUE rxml_schema_init_from_document(VALUE class, VALUE document)
 {
   xmlDocPtr xdoc;
-  xmlSchemaPtr xschema;
   xmlSchemaParserCtxtPtr xparser;
 
   Data_Get_Struct(document, xmlDoc, xdoc);
 
+  xmlResetLastError();
   xparser = xmlSchemaNewDocParserCtxt(xdoc);
-  xschema = xmlSchemaParse(xparser);
-  xmlSchemaFreeParserCtxt(xparser);
+  if (!xparser)
+    rxml_raise(&xmlLastError);
 
-  if (xschema == NULL)
-    return Qnil;
-
-  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+  return rxml_schema_init(class, xparser);
 }
 
 /*
@@ -100,57 +195,26 @@ static VALUE rxml_schema_init_from_document(VALUE class, VALUE document)
  *
  * Create a new schema using the specified string.
  */
-static VALUE rxml_schema_init_from_string(VALUE self, VALUE schema_str)
+static VALUE rxml_schema_init_from_string(VALUE class, VALUE schema_str)
 {
   xmlSchemaParserCtxtPtr xparser;
-  xmlSchemaPtr xschema;
 
   Check_Type(schema_str, T_STRING);
 
+  xmlResetLastError();
   xparser = xmlSchemaNewMemParserCtxt(StringValuePtr(schema_str), (int)strlen(StringValuePtr(schema_str)));
-  xschema = xmlSchemaParse(xparser);
-  xmlSchemaFreeParserCtxt(xparser);
+  if (!xparser)
+    rxml_raise(&xmlLastError);
 
-  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
-}
-
-
-static VALUE rxml_schema_target_namespace(VALUE self)
-{
-  xmlSchemaPtr xschema;
-
-  Data_Get_Struct(self, xmlSchema, xschema);
-
-  QNIL_OR_STRING(xschema->targetNamespace)
-}
-
-static VALUE rxml_schema_name(VALUE self)
-{
-  xmlSchemaPtr xschema;
-
-  Data_Get_Struct(self, xmlSchema, xschema);
-
-  QNIL_OR_STRING(xschema->name)
-}
-
-static VALUE rxml_schema_version(VALUE self)
-{
-  xmlSchemaPtr xschema;
-
-  Data_Get_Struct(self, xmlSchema, xschema);
-
-  QNIL_OR_STRING(xschema->version)
-}
-
-static VALUE rxml_schema_id(VALUE self)
-{
-  xmlSchemaPtr xschema;
-
-  Data_Get_Struct(self, xmlSchema, xschema);
-
-  QNIL_OR_STRING(xschema->id)
+  return rxml_schema_init(class, xparser);
 }
 
+/*
+ * call-seq:
+ *    XML::Schema.document -> document
+ *
+ * Return the Schema XML Document
+ */
 static VALUE rxml_schema_document(VALUE self)
 {
   xmlSchemaPtr xschema;
@@ -160,7 +224,7 @@ static VALUE rxml_schema_document(VALUE self)
   return rxml_node_wrap(xmlDocGetRootElement(xschema->doc));
 }
 
-static void scan_namespaces(xmlSchemaImportPtr ximport, VALUE array, xmlChar *nsname)
+static void scan_namespaces(xmlSchemaImportPtr ximport, VALUE array, const xmlChar *nsname)
 {
   xmlNodePtr xnode;
   xmlNsPtr xns;
@@ -171,7 +235,7 @@ static void scan_namespaces(xmlSchemaImportPtr ximport, VALUE array, xmlChar *ns
     xns = xnode->nsDef;
 
     while (xns)
-	{
+    {
       VALUE namespace = rxml_namespace_wrap(xns);
       rb_ary_push(array, namespace);
       xns = xns->next;
@@ -179,6 +243,12 @@ static void scan_namespaces(xmlSchemaImportPtr ximport, VALUE array, xmlChar *ns
   }
 }
 
+/*
+ * call-seq:
+ *    XML::Schema.namespaces -> array
+ *
+ * Returns an array of Namespaces defined by the schema
+ */
 static VALUE rxml_schema_namespaces(VALUE self)
 {
   VALUE result;
@@ -192,7 +262,7 @@ static VALUE rxml_schema_namespaces(VALUE self)
   return result;
 }
 
-static void scan_element(xmlSchemaElementPtr xelement, VALUE hash, xmlChar *name)
+static void scan_schema_element(xmlSchemaElementPtr xelement, VALUE hash, const xmlChar *name)
 {
   VALUE element = rxml_wrap_schema_element(xelement);
   rb_hash_aset(hash, rb_str_new2((const char*)name), element);
@@ -204,40 +274,77 @@ static VALUE rxml_schema_elements(VALUE self)
   xmlSchemaPtr xschema;
 
   Data_Get_Struct(self, xmlSchema, xschema);
-  xmlHashScan(xschema->elemDecl, (xmlHashScanner)scan_element, (void *)result);
+  xmlHashScan(xschema->elemDecl, (xmlHashScanner)scan_schema_element, (void *)result);
 
   return result;
 }
 
-static void scan_type(xmlSchemaTypePtr xtype, VALUE hash, xmlChar *name)
+static void collect_imported_ns_elements(xmlSchemaImportPtr import, VALUE result, const xmlChar *name)
 {
-	VALUE type = rxml_wrap_schema_type(xtype);
-	rb_hash_aset(hash, rb_str_new2((const char*)name), type);
+  if (import->imported && import->schema)
+  {
+    VALUE elements = rb_hash_new();
+    xmlHashScan(import->schema->elemDecl, (xmlHashScanner)scan_schema_element, (void *)elements);
+    rb_hash_aset(result, QNIL_OR_STRING(import->schema->targetNamespace), elements);
+  }
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.imported_ns_elements -> hash
+ *
+ * Returns a hash by namespace of a hash of schema elements within the entire schema including imports
+ */
+static VALUE rxml_schema_imported_ns_elements(VALUE self)
+{
+  xmlSchemaPtr xschema;
+  VALUE result = rb_hash_new();
+
+  Data_Get_Struct(self, xmlSchema, xschema);
+
+  if (xschema)
+  {
+    xmlHashScan(xschema->schemasImports, (xmlHashScanner)collect_imported_ns_elements, (void *)result);
+  }
+
+  return result;
+}
+
+static void scan_schema_type(xmlSchemaTypePtr xtype, VALUE hash, const xmlChar *name)
+{
+  VALUE type = rxml_wrap_schema_type(xtype);
+  rb_hash_aset(hash, rb_str_new2((const char*)name), type);
 }
 
 static VALUE rxml_schema_types(VALUE self)
 {
-	VALUE result = rb_hash_new();
-	xmlSchemaPtr xschema;
+  VALUE result = rb_hash_new();
+  xmlSchemaPtr xschema;
 
-	Data_Get_Struct(self, xmlSchema, xschema);
+  Data_Get_Struct(self, xmlSchema, xschema);
 
-	if (xschema != NULL && xschema->typeDecl != NULL)
-	{
-		xmlHashScan(xschema->typeDecl, (xmlHashScanner)scan_type, (void *)result);
-	}
+  if (xschema != NULL && xschema->typeDecl != NULL)
+  {
+    xmlHashScan(xschema->typeDecl, (xmlHashScanner)scan_schema_type, (void *)result);
+  }
 
-	return result;
+  return result;
 }
 
-static void collect_imported_types(xmlSchemaImportPtr import, VALUE result)
+static void collect_imported_types(xmlSchemaImportPtr import, VALUE result, const xmlChar *name)
 {
   if (import->imported && import->schema)
   {
-    xmlHashScan(import->schema->typeDecl, (xmlHashScanner)scan_type, (void *)result);
+    xmlHashScan(import->schema->typeDecl, (xmlHashScanner)scan_schema_type, (void *)result);
   }
 }
 
+/*
+ * call-seq:
+ *    XML::Schema.imported_types -> hash
+ *
+ * Returns a hash of all types within the entire schema including imports
+ */
 static VALUE rxml_schema_imported_types(VALUE self)
 {
   xmlSchemaPtr xschema;
@@ -247,7 +354,38 @@ static VALUE rxml_schema_imported_types(VALUE self)
 
   if (xschema)
   {
-	  xmlHashScan(xschema->schemasImports, (xmlHashScanner)collect_imported_types, (void *)result);
+    xmlHashScan(xschema->schemasImports, (xmlHashScanner)collect_imported_types, (void *)result);
+  }
+
+  return result;
+}
+
+static void collect_imported_ns_types(xmlSchemaImportPtr import, VALUE result, const xmlChar *name)
+{
+  if (import->imported && import->schema)
+  {
+    VALUE types = rb_hash_new();
+    xmlHashScan(import->schema->typeDecl, (xmlHashScanner)scan_schema_type, (void *)types);
+    rb_hash_aset(result, QNIL_OR_STRING(import->schema->targetNamespace), types);
+  }
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.imported_ns_types -> hash
+ *
+ * Returns a hash by namespace of a hash of schema types within the entire schema including imports
+ */
+static VALUE rxml_schema_imported_ns_types(VALUE self)
+{
+  xmlSchemaPtr xschema;
+  VALUE result = rb_hash_new();
+
+  Data_Get_Struct(self, xmlSchema, xschema);
+
+  if (xschema)
+  {
+    xmlHashScan(xschema->schemasImports, (xmlHashScanner)collect_imported_ns_types, (void *)result);
   }
 
   return result;
@@ -260,16 +398,20 @@ void rxml_init_schema(void)
   rb_define_singleton_method(cXMLSchema, "from_string", rxml_schema_init_from_string, 1);
   rb_define_singleton_method(cXMLSchema, "document", rxml_schema_init_from_document, 1);
 
-  rb_define_method(cXMLSchema, "target_namespace", rxml_schema_target_namespace, 0);
-  rb_define_method(cXMLSchema, "name", rxml_schema_name, 0);
-  rb_define_method(cXMLSchema, "id", rxml_schema_id, 0);
-  rb_define_method(cXMLSchema, "version", rxml_schema_version, 0);
-  rb_define_method(cXMLSchema, "document", rxml_schema_document, 0);
+  /* Create attr_reader methods for the above instance variables */
+  rb_define_attr(cXMLSchema, "target_namespace", 1, 0);
+  rb_define_attr(cXMLSchema, "name", 1, 0);
+  rb_define_attr(cXMLSchema, "id", 1, 0);
+  rb_define_attr(cXMLSchema, "version", 1, 0);
 
-  rb_define_method(cXMLSchema, "elements", rxml_schema_elements, 0);
-  rb_define_method(cXMLSchema, "imported_types", rxml_schema_imported_types, 0);
+  // These are just methods so as to hide their values and not overly clutter the output of inspect/to_str
+  rb_define_method(cXMLSchema, "document", rxml_schema_document, 0);
   rb_define_method(cXMLSchema, "namespaces", rxml_schema_namespaces, 0);
+  rb_define_method(cXMLSchema, "elements", rxml_schema_elements, 0);
+  rb_define_method(cXMLSchema, "imported_ns_elements", rxml_schema_imported_ns_elements, 0);
   rb_define_method(cXMLSchema, "types", rxml_schema_types, 0);
+  rb_define_method(cXMLSchema, "imported_types", rxml_schema_imported_types, 0);
+  rb_define_method(cXMLSchema, "imported_ns_types", rxml_schema_imported_ns_types, 0);
 
   rxml_init_schema_facet();
   rxml_init_schema_element();