libxml-ruby 2.9.0-x64-mingw32

data/ext/libxml/ruby_xml_schema_attribute.c

@@ -0,0 +1,109 @@
+#include "ruby_libxml.h"
+#include "ruby_xml_schema_attribute.h"
+#include "ruby_xml_schema_type.h"
+
+VALUE cXMLSchemaAttribute;
+
+static void rxml_schema_attribute_free(xmlSchemaAttributeUsePtr attr)
+{
+  attr = NULL;
+  xmlFree(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;
+
+  Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
+
+  if (attr == NULL)
+    return Qnil;
+
+  if (attr->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
+      tns = ((xmlSchemaAttributeUseProhibPtr) attr)->targetNamespace;
+  } else if (attr->type == XML_SCHEMA_EXTRA_QNAMEREF) {
+      tns = ((xmlSchemaQNameRefPtr) attr)->targetNamespace;
+  } else {
+      tns = ((xmlSchemaAttributePtr) ((xmlSchemaAttributeUsePtr) (attr))->attrDecl)->targetNamespace;
+  }
+
+  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);
+}
+
+static VALUE rxml_schema_attribute_node(VALUE self)
+{
+  xmlSchemaAttributeUsePtr attr;
+
+  Data_Get_Struct(self, xmlSchemaAttributeUse, attr);
+
+  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_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

@@ -0,0 +1,15 @@
+#ifndef __RXML_SCHEMA_ATTRIBUTE__
+#define __RXML_SCHEMA_ATTRIBUTE__
+
+#include "ruby_xml_schema.h"
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/xmlschemastypes.h>
+
+extern VALUE cXMLSchemaAttribute;
+
+
+void rxml_init_schema_attribute(void);
+VALUE rxml_wrap_schema_attribute(xmlSchemaAttributeUsePtr attr);
+
+#endif

data/ext/libxml/ruby_xml_schema_element.c

@@ -0,0 +1,94 @@
+#include "ruby_libxml.h"
+#include "ruby_xml_schema_element.h"
+#include "ruby_xml_schema_type.h"
+
+VALUE cXMLSchemaElement;
+
+static void rxml_schema_element_free(xmlSchemaElementPtr xschema_element)
+{
+  xschema_element = NULL;
+  xmlFree(xschema_element);
+}
+
+VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelement)
+{
+  return Data_Wrap_Struct(cXMLSchemaElement, NULL, rxml_schema_element_free, xelement);
+}
+
+static VALUE rxml_schema_element_namespace(VALUE self)
+{
+  xmlSchemaElementPtr xelem;
+
+  Data_Get_Struct(self, xmlSchemaElement, xelem);
+
+  QNIL_OR_STRING(xelem->targetNamespace)
+}
+
+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);
+}
+
+static VALUE rxml_schema_element_node(VALUE self)
+{
+  xmlSchemaElementPtr xelem;
+
+  Data_Get_Struct(self, xmlSchemaElement, xelem);
+
+  return rxml_node_wrap(xelem->node);
+}
+
+static VALUE rxml_schema_element_value(VALUE self)
+{
+  xmlSchemaElementPtr xelem;
+
+  Data_Get_Struct(self, xmlSchemaElement, xelem);
+
+  QNIL_OR_STRING(xelem->value)
+}
+
+static VALUE rxml_schema_element_min_occurs(VALUE self)
+{
+  return rb_iv_get(self, "@min");
+}
+
+static VALUE rxml_schema_element_max_occurs(VALUE self)
+{
+  return rb_iv_get(self, "@max");
+}
+
+static VALUE rxml_schema_element_annot(VALUE self)
+{
+  return rb_iv_get(self, "@annotation");
+}
+
+
+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_method(cXMLSchemaElement, "node", rxml_schema_element_node, 0);
+  rb_define_method(cXMLSchemaElement, "value", rxml_schema_element_value, 0);
+  rb_define_method(cXMLSchemaElement, "min_occurs", rxml_schema_element_min_occurs, 0);
+  rb_define_method(cXMLSchemaElement, "max_occurs", rxml_schema_element_max_occurs, 0);
+  rb_define_method(cXMLSchemaElement, "annotation", rxml_schema_element_annot, 0);
+}

data/ext/libxml/ruby_xml_schema_element.h

@@ -0,0 +1,14 @@
+#ifndef __RXML_SCHEMA_ELEMENT__
+#define __RXML_SCHEMA_ELEMENT__
+
+#include "ruby_xml_schema.h"
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/xmlschemastypes.h>
+
+extern VALUE cXMLSchemaElement;
+
+VALUE rxml_wrap_schema_element(xmlSchemaElementPtr xelement);
+void rxml_init_schema_element(void);
+
+#endif

data/ext/libxml/ruby_xml_schema_facet.c

@@ -0,0 +1,52 @@
+#include "ruby_libxml.h"
+#include "ruby_xml_schema_facet.h"
+
+VALUE cXMLSchemaFacet;
+
+static void rxml_schema_facet_free(xmlSchemaFacetPtr xschema_type)
+{
+  xschema_type = NULL;
+  xmlFree(xschema_type);
+}
+
+/* START FACET*/
+
+static VALUE rxml_schema_facet_node(VALUE self)
+{
+  xmlSchemaFacetPtr facet;
+
+  Data_Get_Struct(self, xmlSchemaFacet, facet);
+
+  return rxml_node_wrap(facet->node);
+}
+
+static VALUE rxml_schema_facet_value(VALUE self)
+{
+  xmlSchemaFacetPtr facet;
+
+  Data_Get_Struct(self, xmlSchemaFacet, facet);
+
+  QNIL_OR_STRING(facet->value)
+}
+
+static VALUE rxml_schema_facet_kind(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);
+}
+
+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_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

@@ -0,0 +1,13 @@
+#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);
+void rxml_init_schema_facet(void);
+
+#endif

data/ext/libxml/ruby_xml_schema_type.c

@@ -0,0 +1,259 @@
+#include "ruby_libxml.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"
+
+#define UNBOUNDED 1 << 30
+#define FREE_AND_NULL(str) if ((str) != NULL) { xmlFree((xmlChar *) (str)); str = NULL; }
+
+VALUE cXMLSchemaType;
+
+static void rxml_schema_type_free(xmlSchemaTypePtr xschema_type)
+{
+  xschema_type = NULL;
+  xmlFree(xschema_type);
+}
+
+VALUE rxml_wrap_schema_type(xmlSchemaTypePtr xtype)
+{
+  return Data_Wrap_Struct(cXMLSchemaType, NULL, rxml_schema_type_free, xtype);
+}
+
+static VALUE rxml_schema_type_namespace(VALUE self)
+{
+  xmlSchemaTypePtr xtype;
+
+  Data_Get_Struct(self, xmlSchemaType, xtype);
+
+  QNIL_OR_STRING(xtype->targetNamespace)
+}
+
+static VALUE rxml_schema_type_name(VALUE self)
+{
+  xmlSchemaTypePtr xtype;
+
+  Data_Get_Struct(self, xmlSchemaType, xtype);
+
+  QNIL_OR_STRING(xtype->name)
+}
+
+static VALUE rxml_schema_type_base(VALUE self)
+{
+  xmlSchemaTypePtr xtype;
+
+  Data_Get_Struct(self, xmlSchemaType, xtype);
+
+  return Data_Wrap_Struct(cXMLSchemaType, NULL, rxml_schema_type_free, xtype->baseType);
+}
+
+static VALUE rxml_schema_type_facets(VALUE self)
+{
+  xmlSchemaTypePtr xtype;
+  xmlSchemaFacetPtr facet;
+  VALUE facets;
+  VALUE rfacet;
+
+  facets = rb_iv_get(self, "@facets");
+
+  if (facets == Qnil) {
+    facets = rb_ary_new();
+    Data_Get_Struct(self, xmlSchemaType, xtype);
+
+    facet = xtype->facets;
+
+    while (facet != NULL) {
+      rfacet = rxml_wrap_schema_facet((xmlSchemaFacetPtr) facet);
+      rb_ary_push(facets, rfacet);
+      facet = facet->next;
+    }
+
+    rb_iv_set(self, "@facets", facets);
+  }
+
+  return facets;
+}
+
+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 get_annotation(xmlSchemaAnnotPtr annot)
+{
+  if(annot != NULL && annot->content != NULL && annot->content->content != NULL)
+    return rb_str_new2((const char *) annot->content->content);
+  else
+    return Qnil;
+}
+
+static VALUE rxml_schema_type_annot(VALUE self)
+{
+  xmlSchemaTypePtr xtype;
+
+  Data_Get_Struct(self, xmlSchemaType, xtype);
+
+  if(xtype != NULL && xtype->annot != NULL)
+    return get_annotation(xtype->annot);
+  else
+    return Qnil;
+}
+
+static void rxmlSchemaCollectElements(xmlSchemaParticlePtr particle, VALUE self)
+{
+  VALUE elements;
+  VALUE relement;
+  xmlSchemaTreeItemPtr term;
+
+  if (particle == NULL)
+    return;
+
+  term = particle->children;
+
+  if (term != NULL) {
+    elements = rb_iv_get(self, "@elements");
+
+    switch (term->type) {
+      case XML_SCHEMA_TYPE_ELEMENT:
+        relement = rxml_wrap_schema_element((xmlSchemaElementPtr) term);
+
+
+        rb_iv_set(relement, "@min", INT2NUM(particle->minOccurs));
+
+        if (particle->maxOccurs >= UNBOUNDED)
+          rb_iv_set(relement, "@max", rb_const_get(rb_path2class("Float"), rb_intern("INFINITY")));
+        else
+          rb_iv_set(relement, "@max", INT2NUM(particle->maxOccurs));
+
+        if (particle->annot != NULL)
+        {
+          xmlChar *content;
+
+          content = xmlNodeGetContent(particle->annot->content);
+
+          if (content != NULL)
+          {
+            rb_iv_set(relement, "@annotation", rb_str_new2((const char *) content));
+            xmlFree(content);
+          }
+        }
+
+        rb_hash_aset(elements, rb_str_new2((const char *) ((xmlSchemaElementPtr) term)->name), relement);
+
+        break;
+
+      case XML_SCHEMA_TYPE_SEQUENCE:
+        break;
+
+      case XML_SCHEMA_TYPE_CHOICE:
+        break;
+
+      case XML_SCHEMA_TYPE_ALL:
+        break;
+
+      case XML_SCHEMA_TYPE_ANY:
+        break;
+
+      default:
+
+        return;
+    }
+  }
+
+  if (term &&
+      ((term->type == XML_SCHEMA_TYPE_SEQUENCE) ||
+          (term->type == XML_SCHEMA_TYPE_CHOICE) ||
+          (term->type == XML_SCHEMA_TYPE_ALL)) &&
+      (term->children != NULL)) {
+
+    rxmlSchemaCollectElements((xmlSchemaParticlePtr) term->children, self);
+  }
+
+  if (particle->next != NULL)
+    rxmlSchemaCollectElements((xmlSchemaParticlePtr) particle->next, self);
+}
+
+static VALUE
+rxml_schema_type_elements(VALUE self)
+{
+  VALUE elements;
+  xmlSchemaTypePtr xtype;
+
+  Data_Get_Struct(self, xmlSchemaType, xtype);
+
+  if (rb_iv_get(self, "@elements") == Qnil) {
+    elements = rb_hash_new();
+    rb_iv_set(self, "@elements", elements);
+    rxmlSchemaCollectElements((xmlSchemaParticlePtr) xtype->subtypes, self);
+  }
+
+  return rb_iv_get(self, "@elements");
+}
+
+static VALUE
+rxml_schema_type_attributes(VALUE self)
+{
+  VALUE attributes;
+  xmlSchemaTypePtr xtype;
+  xmlSchemaAttributeUsePtr use;
+  xmlSchemaItemListPtr uses;
+  int i;
+
+  Data_Get_Struct(self, xmlSchemaType, xtype);
+
+  if (rb_iv_get(self, "@attributes") == Qnil) {
+    attributes = rb_ary_new();
+    rb_iv_set(self, "@attributes", attributes);
+
+    uses = xtype->attrUses;
+
+    if ((uses == NULL) || (uses->nbItems == 0))
+      return rb_iv_get(self, "@attributes");
+
+    for (i = 0; i < uses->nbItems; i++) {
+      use = (xmlSchemaAttributeUsePtr) uses->items[i];
+      rb_ary_push(attributes, rxml_wrap_schema_attribute(use));
+    }
+  }
+
+  return rb_iv_get(self, "@attributes");
+}
+
+
+void rxml_init_schema_type(void)
+{
+  /* Add in infinity support for ruby 1.8.7 */
+  #if !defined(RUBY_VM) && defined(INFINITY)
+  ID infinityId = rb_intern("INFINITY");
+  if (rb_const_defined(rb_cFloat, infinityId) == Qfalse)
+    rb_define_const(rb_cFloat, "INFINITY", rb_float_new(INFINITY));
+  #endif
+
+  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_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, "facets", rxml_schema_type_facets, 0);
+  rb_define_method(cXMLSchemaType, "annotation", rxml_schema_type_annot, 0);
+}