libxml-ruby 3.2.2 → 3.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40cfe66ffd84495bc2bd079978d06abd01be932513d0c04160453fe04c33db6c
-  data.tar.gz: 1c45a468970af35413989b9af9f516efb1fc7aae17b401fa83626a762141d04e
+  metadata.gz: 5173bcced46009decd7e7a710aaf20b4005cf8baa5e8ee55148cb28733fd3c97
+  data.tar.gz: 3649de749c1064ec31c3d563a1328abfb43e401372beb6af4b0b5ad891af1ae3
 SHA512:
-  metadata.gz: 6352fc0f0414020fbd48118313e6557e18f6dbccbd1a67270ef04cf693c3abd3a054ff68548e4235266acb41182b0907df079ba99e0b461afc6f320e1b3b923f
-  data.tar.gz: e19986fa3ee2298dd6ed3d00f300e5ce25b956562cf6609b27fb976b9acc5df6e6f3ddcf22926de76cd9d9eb97d6d95d05d8c281dc4df0a53ec27b81a16552dd
+  metadata.gz: 3f5e71808404d9553073ae483c15a55b4d72e7a0e5b40939c7f2c72c8867386e7c7489769f6da2ce7da13cbbbd3329f0851d949f6dc48d7c5b40d9ec5784b630
+  data.tar.gz: 731d9152dca3cf219af862eb67171b9e5cce8df6c8bde4262eae3c53f1a5528e211188a50b472be67e3a294cf4b4f0d2a239317b5c08a3b2886b5e9c5fece14a

data/HISTORY

@@ -1,5 +1,16 @@
 = Release History
 
+== 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/Rakefile

@@ -21,7 +21,7 @@ Rake::ExtensionTask.new do |ext|
   ext.name = SO_NAME
   ext.ext_dir = "ext/libxml"
   ext.lib_dir = "lib/#{RUBY_VERSION.sub(/\.\d$/, '')}"
-  if RUBY_PLATFORM.match(/mswin32|mswin64|mingw32|ucrt/)
+  if RUBY_PLATFORM.match(/mswin|mingw/)
     ext.config_options <<
       if (dir = ENV['WINDOWS_XML2_INCLUDE'])
         "--with-xml2-include=#{dir}"
@@ -49,7 +49,7 @@ Gem::PackageTask.new(spec) do |pkg|
 end
 
 # Setup Windows Gem
-if RUBY_PLATFORM.match(/mswin32|mswin64|mingw32/)
+if RUBY_PLATFORM.match(/mswin|mingw/)
   binaries = (FileList['lib/**/*.so',
                        'lib/**/*dll'])
 

data/ext/libxml/ruby_xml.c

@@ -764,6 +764,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 +791,7 @@ static VALUE rxml_features(VALUE klass)
 
   ruby_xfree(list);
   return (arr);
+#endif /* LIBXML_LEGACY_ENABLED */
 }
 
 /*

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

@@ -983,14 +983,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_schema.c

@@ -46,9 +46,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 +87,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 +107,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 +125,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);
-
-  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);
+  if (!xparser)
+    rxml_raise(&xmlLastError);
 
-  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 +154,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 +165,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 +173,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 +192,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 +204,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 +284,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 +328,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();

data/ext/libxml/ruby_xml_schema.h

@@ -9,11 +9,8 @@ extern VALUE cXMLSchema;
 
 void rxml_init_schema(void);
 
-#define QNIL_OR_STRING(slot)			\
-    if (slot == NULL) \
-      return Qnil; \
-    else \
-	    return rb_str_new2((const char *)slot);
+#define QNIL_OR_STRING(slot) \
+    (slot == NULL) ? Qnil : rb_str_new2((const char *)slot)
 
 #define SUBSET_RESTRICTION  1<<0
 #define SUBSET_EXTENSION    1<<1

data/ext/libxml/ruby_xml_schema_attribute.c

@@ -12,62 +12,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 +48,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_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_facet.c

@@ -9,44 +9,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_type.c

@@ -17,34 +17,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);
 
-  QNIL_OR_STRING(xtype->targetNamespace)
+  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));
+
+  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 +70,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 +201,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.3"
+#define RUBY_LIBXML_VERNUM   323
 #define RUBY_LIBXML_VER_MAJ   3
 #define RUBY_LIBXML_VER_MIN   2
-#define RUBY_LIBXML_VER_MIC   2
+#define RUBY_LIBXML_VER_MIC   3
 #define RUBY_LIBXML_VER_PATCH 0

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* }
 

data/test/model/shiporder.rng

@@ -7,9 +7,9 @@
 -->
 <grammar xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://relaxng.org/ns/structure/1.0">
   <start>
-    <ref name="shiporder"/>
+    <ref name="shiporderType"/>
   </start>
-  <define name="shiporder">
+  <define name="shiporderType">
     <element name="shiporder">
       <attribute name="orderid"/>
       <attribute name="xsi:noNamespaceSchemaLocation"/>

data/test/model/shiporder.xsd

@@ -1,8 +1,12 @@
 <?xml version="1.0" encoding="iso-8859-1" ?>
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-  <xs:element name="shiporder" type="shiporder"/>
 
-  <xs:complexType name="shiporder">
+  <xs:import namespace="http://xml4r.org/ibxml-ruby/test/shiporder"
+             schemaLocation="shiporder_import.xsd"/>
+
+  <xs:element name="shiporder" type="shiporderType"/>
+
+  <xs:complexType name="shiporderType">
     <xs:annotation>
       <xs:documentation>Shiporder type documentation</xs:documentation>
     </xs:annotation>
@@ -37,4 +41,4 @@
     <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
     <xs:attribute name="bar" use="prohibited"/>
   </xs:complexType>
-</xs:schema>
+</xs:schema>

data/test/model/shiporder_bad.xsd

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="iso-8859-1" ?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="shiporder" type="shiporderType"/>
+
+  <xs:complexType name="shiporderType">
+    <xs:anntation>
+      <xs:documentation>Shiporder type documentation</xs:documentation>
+    </xs:anntation>
+    <xs:sequence>
+      <xs:element name="orderperson" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>orderperson element documentation</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="shipto">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="address" type="xs:string"/>
+            <xs:element name="city" type="xs:string"/>
+            <xs:element name="country" type="xs:string"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+      <xs:element name="item" maxOccurs="unbounded">
+        <xs:complexType>
+          <xs:seq>
+            <xs:element name="title" type="xs:string"/>
+            <xs:element name="note" type="xs:string" minOccurs="0"/>
+            <xs:element name="quantity" type="xs:positiveInteger"/>
+            <xs:element name="price" type="xs:decimal"/>
+          </xs:seq>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+    <xs:attribute name="orderid" type="xs:string" use="required"/>
+    <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
+    <xs:attribute name="bar" use="prohibited"/>
+  </xs:complexType>
+</xs:schema>

data/test/model/shiporder_import.xsd

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="iso-8859-1" ?>
+<xs:schema xmlns="http://xml4r.org/libxml-ruby/test/shiporder"
+           xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           targetNamespace="http://xml4r.org/libxml-ruby/test/shiporder">
+
+  <xs:element name="shiporder" type="shiporderFooType"/>
+  <xs:complexType name="shiporderFooType">
+    <xs:annotation>
+      <xs:documentation>Shiporder type documentation for Testing of imported schema</xs:documentation>
+    </xs:annotation>
+    <xs:sequence>
+      <xs:element name="orderperson" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>orderperson element documentation</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="shipto">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="address" type="xs:string"/>
+            <xs:element name="city" type="xs:string"/>
+            <xs:element name="country" type="xs:string"/>
+            <xs:element name="phone" type="xs:string"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+      <xs:element name="item" maxOccurs="unbounded">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="title" type="xs:string"/>
+            <xs:element name="note" type="xs:string" minOccurs="0"/>
+            <xs:element name="quantity" type="xs:positiveInteger"/>
+            <xs:element name="price" type="xs:decimal"/>
+            <xs:element name="discount" type="xs:decimal"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+    <xs:attribute name="orderid" type="xs:string" use="required"/>
+    <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
+    <xs:attribute name="bar" type="xs:string" use="optional"/>
+    <xs:attribute name="xyzzy" type="xs:string" use="prohibited"/>
+  </xs:complexType>
+</xs:schema>

data/test/test_schema.rb

@@ -3,18 +3,19 @@
 require_relative './test_helper'
 
 class TestSchema < Minitest::Test
+  Import_NS = 'http://xml4r.org/libxml-ruby/test/shiporder'.freeze
+
   def setup
     file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
     @doc = LibXML::XML::Document.file(file)
+    schema_file = File.join(File.dirname(__FILE__), 'model/shiporder.xsd')
+    schema_doc = LibXML::XML::Document.file(schema_file)
+    @schema = LibXML::XML::Schema.document(schema_doc)
   end
 
   def teardown
     @doc = nil
-  end
-
-  def schema
-    document = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.xsd'))
-    LibXML::XML::Schema.document(document)
+    @schema = nil
   end
 
   def check_error(error)
@@ -33,11 +34,50 @@ class TestSchema < Minitest::Test
   end
 
   def test_load_from_doc
-    assert_instance_of(LibXML::XML::Schema, schema)
+    assert_instance_of(LibXML::XML::Schema, @schema)
+  end
+
+  def test_schema_load_from_uri
+    xlink_schema = LibXML::XML::Schema.new('http://www.w3.org/1999/xlink.xsd')
+    assert_instance_of(LibXML::XML::Schema, xlink_schema)
+    assert_instance_of(LibXML::XML::Schema::Element, xlink_schema.elements['title'])
+    assert_instance_of(LibXML::XML::Schema::Type, xlink_schema.types['titleEltType'])
+    assert_equal('http://www.w3.org/1999/xlink', xlink_schema.target_namespace)
+  end
+
+  def test_schema_from_string
+    schema_file = File.join(File.dirname(__FILE__), 'model/shiporder.xsd')
+    schema_from_str = LibXML::XML::Schema.from_string(File.read(schema_file))
+    assert_instance_of(LibXML::XML::Schema, schema_from_str)
+  end
+
+  def test_invalid_schema_doc
+    bad_schema_file = File.join(File.dirname(__FILE__), 'model/shiporder_bad.xsd')
+    bad_schema_doc = LibXML::XML::Document.file(bad_schema_file)
+    bad_schema = nil
+    ## Note: this type of error throws
+    begin
+      bad_schema = LibXML::XML::Schema.document(bad_schema_doc)
+    rescue LibXML::XML::Error => error
+      bad_schema = error
+      assert(error.message.match(/Error: Element '.*': The content is not valid. Expected is \(/))
+      assert_kind_of(LibXML::XML::Error, error)
+      assert_equal(LibXML::XML::Error::SCHEMASP, error.domain)
+      assert_equal(LibXML::XML::Error::SCHEMAP_S4S_ELEM_NOT_ALLOWED, error.code)
+      assert_equal(LibXML::XML::Error::ERROR, error.level)
+      assert(error.file.match(/shiporder_bad.xsd/))
+      assert_equal("Element '{http://www.w3.org/2001/XMLSchema}complexType'", error.str1)
+      refute_nil(error.str2)
+      assert_nil(error.str3)
+      assert_equal(0, error.int1)
+      assert_equal(0, error.int2)
+    end
+    ## Last but not least, make sure we threw an error
+    assert_instance_of(LibXML::XML::Error, bad_schema)
   end
 
   def test_doc_valid
-    assert(@doc.validate_schema(schema))
+    assert(@doc.validate_schema(@schema))
   end
 
   def test_doc_invalid
@@ -45,7 +85,7 @@ class TestSchema < Minitest::Test
     @doc.root << new_node
 
     error = assert_raises(LibXML::XML::Error) do
-      @doc.validate_schema(schema)
+      @doc.validate_schema(@schema)
     end
 
     check_error(error)
@@ -56,7 +96,7 @@ class TestSchema < Minitest::Test
 
   def test_reader_valid
     reader = LibXML::XML::Reader.string(@doc.to_s)
-    assert(reader.schema_validate(schema))
+    assert(reader.schema_validate(@schema))
 
     while reader.read
     end
@@ -74,7 +114,7 @@ class TestSchema < Minitest::Test
     reader = LibXML::XML::Reader.string(@doc.to_s)
 
     # Set a schema
-    assert(reader.schema_validate(schema))
+    assert(reader.schema_validate(@schema))
 
     while reader.read
     end
@@ -91,32 +131,55 @@ class TestSchema < Minitest::Test
 
   # Schema meta-data tests
   def test_elements
-    assert_instance_of(Hash, schema.elements)
-    assert_equal(1, schema.elements.length)
-    assert_instance_of(LibXML::XML::Schema::Element, schema.elements['shiporder'])
+    assert_instance_of(Hash, @schema.elements)
+    assert_equal(1, @schema.elements.length)
+    assert_instance_of(LibXML::XML::Schema::Element, @schema.elements['shiporder'])
   end
 
   def test_types
-    assert_instance_of(Hash, schema.types)
-    assert_equal(1, schema.types.length)
-    assert_instance_of(LibXML::XML::Schema::Type, schema.types['shiporder'])
+    assert_instance_of(Hash, @schema.types)
+    assert_equal(1, @schema.types.length)
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.types['shiporderType'])
   end
 
   def test_imported_types
-    assert_instance_of(Hash, schema.imported_types)
-    assert_equal(1, schema.imported_types.length)
-    assert_instance_of(LibXML::XML::Schema::Type, schema.types['shiporder'])
+    assert_instance_of(Hash, @schema.imported_types)
+    assert_equal(2, @schema.imported_types.length)
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.imported_types['shiporderType'])
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.imported_types['shiporderFooType'])
+  end
+
+  def test_imported_ns_types
+    assert_instance_of(Hash, @schema.imported_ns_types)
+    assert_equal(2, @schema.imported_ns_types.length)
+    assert_equal(1, @schema.imported_ns_types[nil].length)
+    assert_equal(1, @schema.imported_ns_types[Import_NS].length)
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.imported_ns_types[nil]['shiporderType'])
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.imported_ns_types[Import_NS]['shiporderFooType'])
+  end
+
+  def test_imported_ns_elements
+    assert_instance_of(Hash, @schema.imported_ns_elements)
+    assert_equal(2, @schema.imported_ns_elements.length)
+    assert_equal(1, @schema.imported_ns_elements[nil].length)
+    assert_equal(1, @schema.imported_ns_elements[Import_NS].length)
+    assert_instance_of(LibXML::XML::Schema::Element, @schema.imported_ns_elements[nil]['shiporder'])
+    assert_instance_of(LibXML::XML::Schema::Element, @schema.imported_ns_elements[Import_NS]['shiporder'])
+    assert_equal('shiporderType', @schema.imported_ns_elements[nil]['shiporder'].type.name)
+    assert_equal('shiporderFooType', @schema.imported_ns_elements[Import_NS]['shiporder'].type.name)
   end
 
   def test_namespaces
-    assert_instance_of(Array, schema.namespaces)
-    assert_equal(1, schema.namespaces.length)
+    assert_instance_of(Array, @schema.namespaces)
+    ## For some reason, when importing another schema we end up with two xs->http://www.w3.org/2001/XMLSchema namespaces.
+    ## So, we expect 3 here (one for Import_NS and then two for the schema namespace.
+    assert_equal(3, @schema.namespaces.length)
   end
 
   def test_schema_type
-    type = schema.types['shiporder']
+    type = @schema.types['shiporderType']
 
-    assert_equal('shiporder', type.name)
+    assert_equal('shiporderType', type.name)
     assert_nil(type.namespace)
     assert_equal("Shiporder type documentation", type.annotation)
     assert_instance_of(LibXML::XML::Node, type.node)
@@ -130,22 +193,22 @@ class TestSchema < Minitest::Test
   end
 
   def test_schema_element
-    element = schema.types['shiporder'].elements['orderperson']
+    element = @schema.types['shiporderType'].elements['orderperson']
 
     assert_equal('orderperson', element.name)
     assert_nil(element.namespace)
     assert_equal("orderperson element documentation", element.annotation)
 
-    element = schema.types['shiporder'].elements['item']
+    element = @schema.types['shiporderType'].elements['item']
     assert_equal('item', element.name)
 
-    element = schema.types['shiporder'].elements['item'].type.elements['note']
+    element = @schema.types['shiporderType'].elements['item'].type.elements['note']
     assert_equal('note', element.name)
     assert_equal('string', element.type.name)
   end
 
   def test_schema_attributes
-    type = schema.types['shiporder']
+    type = @schema.types['shiporderType']
 
     assert_instance_of(Array, type.attributes)
     assert_equal(2, type.attributes.length)
@@ -153,14 +216,14 @@ class TestSchema < Minitest::Test
   end
 
   def test_schema_attribute
-    attribute = schema.types['shiporder'].attributes.first
+    attribute = @schema.types['shiporderType'].attributes.first
 
     assert_equal("orderid", attribute.name)
     assert_nil(attribute.namespace)
     assert_equal(1, attribute.occurs)
     assert_equal('string', attribute.type.name)
 
-    attribute = schema.types['shiporder'].attributes[1]
+    attribute = @schema.types['shiporderType'].attributes[1]
     assert_equal(2, attribute.occurs)
     assert_equal('1', attribute.default)
     assert_equal('integer', attribute.type.name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libxml-ruby
 version: !ruby/object:Gem::Version
-  version: 3.2.2
+  version: 3.2.3
 platform: ruby
 authors:
 - Ross Bamform
@@ -14,7 +14,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-15 00:00:00.000000000 Z
+date: 2022-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -215,6 +215,8 @@ files:
 - test/model/shiporder.rng
 - test/model/shiporder.xml
 - test/model/shiporder.xsd
+- test/model/shiporder_bad.xsd
+- test/model/shiporder_import.xsd
 - test/model/soap.xml
 - test/model/xinclude.xml
 - test/test_attr.rb