libxml-ruby 2.8.0 → 3.2.1

data/ext/libxml/ruby_xml_sax2_handler.h

@@ -1,10 +1,10 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RXML_SAX2_HANDLER__
-#define __RXML_SAX2_HANDLER__
-
-extern xmlSAXHandler rxml_sax_handler;
-
-void rxml_init_sax2_handler(void);
-
-#endif
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_SAX2_HANDLER__
+#define __RXML_SAX2_HANDLER__
+
+extern xmlSAXHandler rxml_sax_handler;
+
+void rxml_init_sax2_handler(void);
+
+#endif

data/ext/libxml/ruby_xml_sax_parser.c

@@ -1,120 +1,116 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#include "ruby_libxml.h"
-#include "ruby_xml_sax_parser.h"
-
-/*
- * Document-class: LibXML::XML::SaxParser
- *
- * XML::SaxParser provides a callback based API for parsing documents,
- * in contrast to XML::Parser's tree based API and XML::Reader's stream
- * based API.
- *
- * The XML::SaxParser API is fairly complex, not well standardized,
- * and does not directly support validation making entity, namespace and
- * base processing relatively hard.
- *
- * To use the XML::SaxParser, register a callback class via the
- * XML::SaxParser#callbacks=.  It is easiest to include the
- * XML::SaxParser::Callbacks module in your class and override
- * the methods as needed.
- *
- * Basic example:
- *
- *   class MyCallbacks
- *     include XML::SaxParser::Callbacks
- *     def on_start_element(element, attributes)
- *       puts #Element started: #{element}"
- *     end
- *   end
- *
- *   parser = XML::SaxParser.string(my_string)
- *   parser.callbacks = MyCallbacks.new
- *   parser.parse
- *
- * You can also parse strings (see XML::SaxParser.string) and
- * io objects (see XML::SaxParser.io).
- */
-
-VALUE cXMLSaxParser;
-static ID CALLBACKS_ATTR;
-static ID CONTEXT_ATTR;
-
-
-/* ======  Parser  =========== */
-
-/*
- * call-seq:
- *    parser.initialize(context) -> XML::Parser
- *
- * Creates a new XML::Parser from the specified 
- * XML::Parser::Context.
- */
-static VALUE rxml_sax_parser_initialize(int argc, VALUE *argv, VALUE self)
-{
-  VALUE context = Qnil;
-
-  rb_scan_args(argc, argv, "01", &context);
-
-  if (context == Qnil)
-  {
-    rb_warn("Passing no parameters to XML::SaxParser.new is deprecated.  Pass an instance of XML::Parser::Context instead.");
-    context = rb_class_new_instance(0, NULL, cXMLParserContext);
-  }
-
-  rb_ivar_set(self, CONTEXT_ATTR, context);
-  return self;
-}
-
-/*
- * call-seq:
- *    parser.parse -> (true|false)
- *
- * Parse the input XML, generating callbacks to the object
- * registered via the +callbacks+ attributesibute.
- */
-static VALUE rxml_sax_parser_parse(VALUE self)
-{
-  int status;
-  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
-  xmlParserCtxtPtr ctxt;
-  Data_Get_Struct(context, xmlParserCtxt, ctxt);
-
-  ctxt->sax2 = 1;
-	ctxt->userData = (void*)rb_ivar_get(self, CALLBACKS_ATTR);
-
-  if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
-    xmlFree(ctxt->sax);
-    
-  ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(rxml_sax_handler));
-  if (ctxt->sax == NULL)
-    rb_fatal("Not enough memory.");
-  memcpy(ctxt->sax, &rxml_sax_handler, sizeof(rxml_sax_handler));
-    
-  status = xmlParseDocument(ctxt);
-
-  /* Now check the parsing result*/
-  if (status == -1 || !ctxt->wellFormed)
-  {
-    if (ctxt->myDoc)
-      xmlFreeDoc(ctxt->myDoc);
-
-    rxml_raise(&ctxt->lastError);
-  }
-  return Qtrue;
-}
-
-void rxml_init_sax_parser(void)
-{
-  /* SaxParser */
-  cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
-
-  /* Atributes */
-  CALLBACKS_ATTR = rb_intern("@callbacks");
-  CONTEXT_ATTR = rb_intern("@context");
-  rb_define_attr(cXMLSaxParser, "callbacks", 1, 1);
-
-  /* Instance Methods */
-  rb_define_method(cXMLSaxParser, "initialize", rxml_sax_parser_initialize, -1);
-  rb_define_method(cXMLSaxParser, "parse", rxml_sax_parser_parse, 0);
-}
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "ruby_libxml.h"
+#include "ruby_xml_sax_parser.h"
+
+/*
+ * Document-class: LibXML::XML::SaxParser
+ *
+ * XML::SaxParser provides a callback based API for parsing documents,
+ * in contrast to XML::Parser's tree based API and XML::Reader's stream
+ * based API.
+ *
+ * The XML::SaxParser API is fairly complex, not well standardized,
+ * and does not directly support validation making entity, namespace and
+ * base processing relatively hard.
+ *
+ * To use the XML::SaxParser, register a callback class via the
+ * XML::SaxParser#callbacks=.  It is easiest to include the
+ * XML::SaxParser::Callbacks module in your class and override
+ * the methods as needed.
+ *
+ * Basic example:
+ *
+ *   class MyCallbacks
+ *     include XML::SaxParser::Callbacks
+ *     def on_start_element(element, attributes)
+ *       puts #Element started: #{element}"
+ *     end
+ *   end
+ *
+ *   parser = XML::SaxParser.string(my_string)
+ *   parser.callbacks = MyCallbacks.new
+ *   parser.parse
+ *
+ * You can also parse strings (see XML::SaxParser.string) and
+ * io objects (see XML::SaxParser.io).
+ */
+
+VALUE cXMLSaxParser;
+static ID CALLBACKS_ATTR;
+static ID CONTEXT_ATTR;
+
+
+/* ======  Parser  =========== */
+
+/*
+ * call-seq:
+ *    parser.initialize(context) -> XML::Parser
+ *
+ * Creates a new XML::Parser from the specified 
+ * XML::Parser::Context.
+ */
+static VALUE rxml_sax_parser_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE context = Qnil;
+
+  rb_scan_args(argc, argv, "01", &context);
+
+  if (context == Qnil)
+  {
+    rb_raise(rb_eArgError, "An instance of a XML::Parser::Context must be passed to XML::SaxParser.new");
+  }
+
+  rb_ivar_set(self, CONTEXT_ATTR, context);
+  return self;
+}
+
+/*
+ * call-seq:
+ *    parser.parse -> (true|false)
+ *
+ * Parse the input XML, generating callbacks to the object
+ * registered via the +callbacks+ attributesibute.
+ */
+static VALUE rxml_sax_parser_parse(VALUE self)
+{
+  int status;
+  VALUE context = rb_ivar_get(self, CONTEXT_ATTR);
+  xmlParserCtxtPtr ctxt;
+  Data_Get_Struct(context, xmlParserCtxt, ctxt);
+
+  ctxt->sax2 = 1;
+	ctxt->userData = (void*)rb_ivar_get(self, CALLBACKS_ATTR);
+
+  if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
+    xmlFree(ctxt->sax);
+    
+  ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(rxml_sax_handler));
+  if (ctxt->sax == NULL)
+    rb_fatal("Not enough memory.");
+  memcpy(ctxt->sax, &rxml_sax_handler, sizeof(rxml_sax_handler));
+    
+  status = xmlParseDocument(ctxt);
+
+  /* Now check the parsing result*/
+  if (status == -1 || !ctxt->wellFormed)
+  {
+    rxml_raise(&ctxt->lastError);
+  }
+  return Qtrue;
+}
+
+void rxml_init_sax_parser(void)
+{
+  /* SaxParser */
+  cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
+
+  /* Atributes */
+  CALLBACKS_ATTR = rb_intern("@callbacks");
+  CONTEXT_ATTR = rb_intern("@context");
+  rb_define_attr(cXMLSaxParser, "callbacks", 1, 1);
+
+  /* Instance Methods */
+  rb_define_method(cXMLSaxParser, "initialize", rxml_sax_parser_initialize, -1);
+  rb_define_method(cXMLSaxParser, "parse", rxml_sax_parser_parse, 0);
+}

data/ext/libxml/ruby_xml_sax_parser.h

@@ -1,10 +1,10 @@
-/* Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RXML_SAX_PARSER__
-#define __RXML_SAX_PARSER__
-
-extern VALUE cXMLSaxParser;
-
-void rxml_init_sax_parser(void);
-
-#endif
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RXML_SAX_PARSER__
+#define __RXML_SAX_PARSER__
+
+extern VALUE cXMLSaxParser;
+
+void rxml_init_sax_parser(void);
+
+#endif

data/ext/libxml/ruby_xml_schema.c

@@ -1,301 +1,278 @@
-#include "ruby_libxml.h"
-#define LIBXML_OUTPUT_ENABLED
-#define DUMP_CONTENT_MODEL
-#include "ruby_xml_schema.h"
-
-#include "ruby_xml_schema_type.h"
-#include "ruby_xml_schema_element.h"
-#include "ruby_xml_schema_attribute.h"
-#include "ruby_xml_schema_facet.h"
-
-
-/*
- * Document-class: LibXML::XML::Schema
- *
- * The XML::Schema class is used to prepare XML Schemas for validation of xml
- * documents.
- *
- * Schemas can be created from XML documents, strinings or URIs using the
- * corresponding methods (new for URIs).
- *
- * Once a schema is prepared, an XML document can be validated by the
- * XML::Document#validate_schema method providing the XML::Schema object
- * as parameter. The method return true if the document validates, false
- * otherwise.
- *
- * Basic usage:
- *
- *  # parse schema as xml document
- *  schema_document = XML::Document.file('schema.rng')
- *
- *  # prepare schema for validation
- *  schema = XML::Schema.document(schema_document)
- *
- *  # parse xml document to be validated
- *  instance = XML::Document.file('instance.xml')
- *
- *  # validate
- *  instance.validate_schema(schema)
- */
-
-VALUE cXMLSchema;
-
-static void rxml_schema_free(xmlSchemaPtr xschema)
-{
-  xmlSchemaFree(xschema);
-}
-
-VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
-{
-  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
-}
-
-
-/*
- * call-seq:
- *    XML::Schema.initialize(schema_uri) -> schema
- *
- * Create a new schema from the specified URI.
- */
-static VALUE rxml_schema_init_from_uri(VALUE class, VALUE uri)
-{
-  xmlSchemaParserCtxtPtr xparser;
-  xmlSchemaPtr xschema;
-
-  Check_Type(uri, T_STRING);
-
-  xparser = xmlSchemaNewParserCtxt(StringValuePtr(uri));
-  xschema = xmlSchemaParse(xparser);
-  xmlSchemaFreeParserCtxt(xparser);
-
-  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
-}
-
-/*
- * call-seq:
- *    XML::Schema.document(document) -> schema
- *
- * Create a new schema from the specified document.
- */
-static VALUE rxml_schema_init_from_document(VALUE class, VALUE document)
-{
-  xmlDocPtr xdoc;
-  xmlSchemaPtr xschema;
-  xmlSchemaParserCtxtPtr xparser;
-
-  Data_Get_Struct(document, xmlDoc, xdoc);
-
-  xparser = xmlSchemaNewDocParserCtxt(xdoc);
-  xschema = xmlSchemaParse(xparser);
-  xmlSchemaFreeParserCtxt(xparser);
-
-  if (xschema == NULL)
-    return Qnil;
-
-  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
-}
-
-/*
- * call-seq:
- *    XML::Schema.from_string("schema_data") -> "value"
- *
- * Create a new schema using the specified string.
- */
-static VALUE rxml_schema_init_from_string(VALUE self, VALUE schema_str)
-{
-  xmlSchemaParserCtxtPtr xparser;
-  xmlSchemaPtr xschema;
-
-  Check_Type(schema_str, T_STRING);
-
-  xparser = xmlSchemaNewMemParserCtxt(StringValuePtr(schema_str), 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);
-
-  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)
-}
-
-
-static VALUE rxml_schema_document(VALUE self)
-{
-  xmlSchemaPtr xschema;
-
-  Data_Get_Struct(self, xmlSchema, xschema);
-
-  return rxml_node_wrap(xmlDocGetRootElement(xschema->doc));
-}
-
-static void storeNs(xmlSchemaImportPtr import, VALUE self, xmlChar *nsname)
-{
-  VALUE schemas;
-  xmlNodePtr xnode;
-  xmlNsPtr xns;
-
-  schemas = rb_iv_get(self, "@namespaces");
-  if (import->doc) {
-    xnode = xmlDocGetRootElement(import->doc);
-
-    xns = xnode->nsDef;
-
-    while (xns) {
-      VALUE anamespace = rxml_namespace_wrap(xns);
-      rb_ary_push(schemas, anamespace);
-      xns = xns->next;
-    }
-  }
-}
-
-static VALUE rxml_schema_namespaces(VALUE self)
-{
-  VALUE schemas;
-  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);
-  }
-
-  return rb_iv_get(self, "@namespaces");
-}
-
-static void storeType(xmlSchemaTypePtr type, VALUE self, 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(name), rtype);
-}
-
-static VALUE rxml_schema_collect_types(VALUE self);
-
-static VALUE rxml_schema_types(VALUE self)
-{
-  VALUE types;
-  xmlSchemaPtr xschema;
-
-  Data_Get_Struct(self, xmlSchema, xschema);
-
-  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");
-}
-
-static void storeElement(xmlSchemaElementPtr element, VALUE self, 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(name), relement);
-}
-
-static VALUE rxml_schema_elements(VALUE self)
-{
-  VALUE elements;
-  xmlSchemaPtr 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);
-  }
-
-  return rb_iv_get(self, "@elements");
-}
-
-static void collectSchemaTypes(xmlSchemaImportPtr import, VALUE self)
-{
-  if (import->imported && import->schema) {
-    xmlHashScan(import->schema->typeDecl, (xmlHashScanner) storeType, (void *)self);
-  }
-}
-
-static VALUE rxml_schema_collect_types(VALUE self)
-{
-  xmlSchemaPtr xschema;
-
-  Data_Get_Struct(self, xmlSchema, xschema);
-
-  if(xschema){
-    xmlHashScan(xschema->schemasImports, (xmlHashScanner) collectSchemaTypes, (void *)self);
-  }
-
-  return Qnil;
-}
-
-void rxml_init_schema(void)
-{
-  cXMLSchema = rb_define_class_under(mXML, "Schema", rb_cObject);
-  rb_define_singleton_method(cXMLSchema, "new", rxml_schema_init_from_uri, 1);
-  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);
-
-  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);
-
-  rxml_init_schema_facet();
-  rxml_init_schema_element();
-  rxml_init_schema_attribute();
-  rxml_init_schema_type();
-}
+#include "ruby_libxml.h"
+#define LIBXML_OUTPUT_ENABLED
+#define DUMP_CONTENT_MODEL
+#include "ruby_xml_schema.h"
+
+#include "ruby_xml_schema_type.h"
+#include "ruby_xml_schema_element.h"
+#include "ruby_xml_schema_attribute.h"
+#include "ruby_xml_schema_facet.h"
+
+/*
+ * Document-class: LibXML::XML::Schema
+ *
+ * The XML::Schema class is used to prepare XML Schemas for validation of xml
+ * documents.
+ *
+ * Schemas can be created from XML documents, strinings or URIs using the
+ * corresponding methods (new for URIs).
+ *
+ * Once a schema is prepared, an XML document can be validated by the
+ * XML::Document#validate_schema method providing the XML::Schema object
+ * as parameter. The method return true if the document validates, false
+ * otherwise.
+ *
+ * Basic usage:
+ *
+ *  # parse schema as xml document
+ *  schema_document = XML::Document.file('schema.rng')
+ *
+ *  # prepare schema for validation
+ *  schema = XML::Schema.document(schema_document)
+ *
+ *  # parse xml document to be validated
+ *  instance = XML::Document.file('instance.xml')
+ *
+ *  # validate
+ *  instance.validate_schema(schema)
+ */
+
+VALUE cXMLSchema;
+
+static void rxml_schema_free(xmlSchemaPtr xschema)
+{
+  xmlSchemaFree(xschema);
+}
+
+VALUE rxml_wrap_schema(xmlSchemaPtr xschema)
+{
+  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+}
+
+
+/*
+ * call-seq:
+ *    XML::Schema.initialize(schema_uri) -> schema
+ *
+ * Create a new schema from the specified URI.
+ */
+static VALUE rxml_schema_init_from_uri(VALUE class, VALUE uri)
+{
+  xmlSchemaParserCtxtPtr xparser;
+  xmlSchemaPtr xschema;
+
+  Check_Type(uri, T_STRING);
+
+  xparser = xmlSchemaNewParserCtxt(StringValuePtr(uri));
+  xschema = xmlSchemaParse(xparser);
+  xmlSchemaFreeParserCtxt(xparser);
+
+  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.document(document) -> schema
+ *
+ * Create a new schema from the specified document.
+ */
+static VALUE rxml_schema_init_from_document(VALUE class, VALUE document)
+{
+  xmlDocPtr xdoc;
+  xmlSchemaPtr xschema;
+  xmlSchemaParserCtxtPtr xparser;
+
+  Data_Get_Struct(document, xmlDoc, xdoc);
+
+  xparser = xmlSchemaNewDocParserCtxt(xdoc);
+  xschema = xmlSchemaParse(xparser);
+  xmlSchemaFreeParserCtxt(xparser);
+
+  if (xschema == NULL)
+    return Qnil;
+
+  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.from_string("schema_data") -> "value"
+ *
+ * Create a new schema using the specified string.
+ */
+static VALUE rxml_schema_init_from_string(VALUE self, VALUE schema_str)
+{
+  xmlSchemaParserCtxtPtr xparser;
+  xmlSchemaPtr xschema;
+
+  Check_Type(schema_str, T_STRING);
+
+  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);
+
+  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)
+}
+
+static VALUE rxml_schema_document(VALUE self)
+{
+  xmlSchemaPtr xschema;
+
+  Data_Get_Struct(self, xmlSchema, xschema);
+
+  return rxml_node_wrap(xmlDocGetRootElement(xschema->doc));
+}
+
+static void scan_namespaces(xmlSchemaImportPtr ximport, VALUE array, xmlChar *nsname)
+{
+  xmlNodePtr xnode;
+  xmlNsPtr xns;
+
+  if (ximport->doc)
+  {
+    xnode = xmlDocGetRootElement(ximport->doc);
+    xns = xnode->nsDef;
+
+    while (xns)
+	{
+      VALUE namespace = rxml_namespace_wrap(xns);
+      rb_ary_push(array, namespace);
+      xns = xns->next;
+    }
+  }
+}
+
+static VALUE rxml_schema_namespaces(VALUE self)
+{
+  VALUE result;
+  xmlSchemaPtr xschema;
+
+  Data_Get_Struct(self, xmlSchema, xschema);
+
+  result = rb_ary_new();
+  xmlHashScan(xschema->schemasImports, (xmlHashScanner)scan_namespaces, (void *)result);
+
+  return result;
+}
+
+static void scan_element(xmlSchemaElementPtr xelement, VALUE hash, xmlChar *name)
+{
+  VALUE element = rxml_wrap_schema_element(xelement);
+  rb_hash_aset(hash, rb_str_new2((const char*)name), element);
+}
+
+static VALUE rxml_schema_elements(VALUE self)
+{
+  VALUE result = rb_hash_new();
+  xmlSchemaPtr xschema;
+
+  Data_Get_Struct(self, xmlSchema, xschema);
+  xmlHashScan(xschema->elemDecl, (xmlHashScanner)scan_element, (void *)result);
+
+  return result;
+}
+
+static void scan_type(xmlSchemaTypePtr xtype, VALUE hash, 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;
+
+	Data_Get_Struct(self, xmlSchema, xschema);
+
+	if (xschema != NULL && xschema->typeDecl != NULL)
+	{
+		xmlHashScan(xschema->typeDecl, (xmlHashScanner)scan_type, (void *)result);
+	}
+
+	return result;
+}
+
+static void collect_imported_types(xmlSchemaImportPtr import, VALUE result)
+{
+  if (import->imported && import->schema)
+  {
+    xmlHashScan(import->schema->typeDecl, (xmlHashScanner)scan_type, (void *)result);
+  }
+}
+
+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)collect_imported_types, (void *)result);
+  }
+
+  return result;
+}
+
+void rxml_init_schema(void)
+{
+  cXMLSchema = rb_define_class_under(mXML, "Schema", rb_cObject);
+  rb_define_singleton_method(cXMLSchema, "new", rxml_schema_init_from_uri, 1);
+  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);
+
+  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();
+  rxml_init_schema_attribute();
+  rxml_init_schema_type();
+}