libxml-ruby 0.9.4 → 0.9.5

data/ext/libxml/ruby_xml_relaxng.c

@@ -1,12 +1,12 @@
 #include "ruby_libxml.h"
 #include "ruby_xml_relaxng.h"
 
-/* 
+/*
  * Document-class: LibXML::XML::RelaxNG
  *
- * The XML::RelaxNG class is used to prepare RelaxNG schemas for validation 
+ * The XML::RelaxNG class is used to prepare RelaxNG schemas for validation
  * of xml documents.
- * 
+ *
  * Schemas can be created from XML documents, strings or URIs using the
  * corresponding methods (new for URIs).
  *
@@ -19,7 +19,7 @@
  *
  *  # parse schema as xml document
  *  relaxng_document = XML::Document.file('schema.rng')
- *  
+ *
  *  # prepare schema for validation
  *  relaxng_schema = XML::RelaxNG.document(relaxng_document)
  *
@@ -32,25 +32,25 @@
 
 VALUE cXMLRelaxNG;
 
-// Rdoc needs to know 
+// Rdoc needs to know
 #ifdef RDOC_NEVER_DEFINED
-  mLibXML = rb_define_module("LibXML");
-  mXML = rb_define_module_under(mLibXML, "XML");
+mLibXML = rb_define_module("LibXML");
+mXML = rb_define_module_under(mLibXML, "XML");
 #endif
 
-static void
-rxml_relaxng_free(xmlRelaxNGPtr xrelaxng) {
+static void rxml_relaxng_free(xmlRelaxNGPtr xrelaxng)
+{
   xmlRelaxNGFree(xrelaxng);
 }
 
 /*
  * call-seq:
  *    XML::Relaxng.new(relaxng_uri) -> relaxng
- * 
+ *
  * Create a new relaxng from the specified URI.
  */
-static VALUE
-rxml_relaxng_init_from_uri(VALUE class, VALUE uri) {
+static VALUE rxml_relaxng_init_from_uri(VALUE class, VALUE uri)
+{
   xmlRelaxNGParserCtxtPtr xparser;
   xmlRelaxNGPtr xrelaxng;
 
@@ -66,11 +66,11 @@ rxml_relaxng_init_from_uri(VALUE class, VALUE uri) {
 /*
  * call-seq:
  *    XML::RelaxNG.document(document) -> relaxng
- * 
+ *
  * Create a new relaxng from the specified document.
  */
-static VALUE
-rxml_relaxng_init_from_document(VALUE class, VALUE document) {
+static VALUE rxml_relaxng_init_from_document(VALUE class, VALUE document)
+{
   xmlDocPtr xdoc;
   xmlRelaxNGPtr xrelaxng;
   xmlRelaxNGParserCtxtPtr xparser;
@@ -87,27 +87,31 @@ rxml_relaxng_init_from_document(VALUE class, VALUE document) {
 /*
  * call-seq:
  *    XML::RelaxNG.string("relaxng_data") -> "value"
- * 
+ *
  * Create a new relaxng using the specified string.
  */
-static VALUE
-rxml_relaxng_init_from_string(VALUE self, VALUE relaxng_str) {
-  xmlRelaxNGParserCtxtPtr  xparser;
+static VALUE rxml_relaxng_init_from_string(VALUE self, VALUE relaxng_str)
+{
+  xmlRelaxNGParserCtxtPtr xparser;
   xmlRelaxNGPtr xrelaxng;
 
   Check_Type(relaxng_str, T_STRING);
 
-  xparser = xmlRelaxNGNewMemParserCtxt(StringValuePtr(relaxng_str), strlen(StringValuePtr(relaxng_str)));
+  xparser = xmlRelaxNGNewMemParserCtxt(StringValuePtr(relaxng_str), strlen(
+      StringValuePtr(relaxng_str)));
   xrelaxng = xmlRelaxNGParse(xparser);
   xmlRelaxNGFreeParserCtxt(xparser);
 
   return Data_Wrap_Struct(cXMLRelaxNG, NULL, rxml_relaxng_free, xrelaxng);
 }
-  
-void ruby_init_xml_relaxng(void) {
+
+void ruby_init_xml_relaxng(void)
+{
   cXMLRelaxNG = rb_define_class_under(mXML, "RelaxNG", rb_cObject);
-  rb_define_singleton_method(cXMLRelaxNG, "new",         rxml_relaxng_init_from_uri, 1);
-  rb_define_singleton_method(cXMLRelaxNG, "from_string", rxml_relaxng_init_from_string, 1);
-  rb_define_singleton_method(cXMLRelaxNG, "document",    rxml_relaxng_init_from_document, 1);
+  rb_define_singleton_method(cXMLRelaxNG, "new", rxml_relaxng_init_from_uri, 1);
+  rb_define_singleton_method(cXMLRelaxNG, "from_string",
+      rxml_relaxng_init_from_string, 1);
+  rb_define_singleton_method(cXMLRelaxNG, "document",
+      rxml_relaxng_init_from_document, 1);
 }
 

data/ext/libxml/ruby_xml_sax_parser.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_sax_parser.c 630 2008-11-24 06:53:01Z cfis $ */
+/* $Id: ruby_xml_sax_parser.c 650 2008-11-30 03:40:22Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -10,15 +10,15 @@
  *
  * 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.  
+ * based API.
  *
- * Note that the XML::SaxParser API is fairly complex, not well standardized, 
+ * Note that 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 
+ * XML::SaxParser#callbacks=.  It is easiest to include the
+ * XML::SaxParser::Callbacks module in your class and override
  * the methods as needed.
  *
  * Basic example:
@@ -64,54 +64,55 @@ VALUE cbidOnExternalSubset;
 /*
  * call-seq:
  *    sax_parser.initialize -> sax_parser
- * 
+ *
  * Initiliazes instance of parser.
  */
-static VALUE
-rxml_sax_parser_initialize(VALUE self) {
+static VALUE rxml_sax_parser_initialize(VALUE self)
+{
   VALUE input = rb_class_new_instance(0, NULL, cXMLInput);
   rb_iv_set(self, "@input", input);
   return self;
 }
 
-
 /* Parsing data sources */
-static int
-rxml_sax_parser_parse_file(VALUE self, VALUE input) {
+static int rxml_sax_parser_parse_file(VALUE self, VALUE input)
+{
   VALUE file = rb_ivar_get(input, FILE_ATTR);
-  return xmlSAXUserParseFile((xmlSAXHandlerPtr)&rxml_sax_hander_struct, (void *)self, StringValuePtr(file));
+  return xmlSAXUserParseFile((xmlSAXHandlerPtr) & rxml_sax_hander_struct,
+      (void *) self, StringValuePtr(file));
 }
 
-static int
-rxml_sax_parser_parse_string(VALUE self, VALUE input) {
+static int rxml_sax_parser_parse_string(VALUE self, VALUE input)
+{
   VALUE str = rb_ivar_get(input, STRING_ATTR);
-  return xmlSAXUserParseMemory((xmlSAXHandlerPtr)&rxml_sax_hander_struct, (void *)self, StringValuePtr(str), RSTRING_LEN(str));
+  return xmlSAXUserParseMemory((xmlSAXHandlerPtr) & rxml_sax_hander_struct,
+      (void *) self, StringValuePtr(str), RSTRING_LEN(str));
 }
 
-static int
-rxml_sax_parser_parse_io(VALUE self, VALUE input) {
+static int rxml_sax_parser_parse_io(VALUE self, VALUE input)
+{
   VALUE io = rb_ivar_get(input, IO_ATTR);
   VALUE encoding = rb_ivar_get(input, ENCODING_ATTR);
   xmlCharEncoding xmlEncoding = NUM2INT(encoding);
-  xmlParserCtxtPtr ctxt = xmlCreateIOParserCtxt((xmlSAXHandlerPtr)&rxml_sax_hander_struct, (void *)self,
-	 			                                        (xmlInputReadCallback) rxml_read_callback,
-				                                         NULL, (void *)io, xmlEncoding);
+  xmlParserCtxtPtr ctxt =
+      xmlCreateIOParserCtxt((xmlSAXHandlerPtr) & rxml_sax_hander_struct,
+          (void *) self, (xmlInputReadCallback) rxml_read_callback, NULL,
+          (void *) io, xmlEncoding);
   return xmlParseDocument(ctxt);
 }
 
-
 /*
  * 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) {
+static VALUE rxml_sax_parser_parse(VALUE self)
+{
   int status;
   VALUE input = rb_ivar_get(self, INPUT_ATTR);
-  
+
   if (rb_ivar_get(input, FILE_ATTR) != Qnil)
     status = rxml_sax_parser_parse_file(self, input);
   else if (rb_ivar_get(input, STRING_ATTR) != Qnil)
@@ -120,7 +121,7 @@ rxml_sax_parser_parse(VALUE self) {
     status = rxml_sax_parser_parse_io(self, input);
   else
     rb_raise(rb_eArgError, "You must specify a parser data source");
-  
+
   if (status)
   {
     rxml_raise(&xmlLastError);
@@ -128,18 +129,18 @@ rxml_sax_parser_parse(VALUE self) {
   }
   else
   {
-    return(Qtrue);
+    return (Qtrue);
   }
 }
 
-// Rdoc needs to know 
+// Rdoc needs to know
 #ifdef RDOC_NEVER_DEFINED
-  mLibXML = rb_define_module("LibXML");
-  mXML = rb_define_module_under(mLibXML, "XML");
+mLibXML = rb_define_module("LibXML");
+mXML = rb_define_module_under(mLibXML, "XML");
 #endif
 
-void
-ruby_init_xml_sax_parser(void) {
+void ruby_init_xml_sax_parser(void)
+{
   /* SaxParser */
   cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
 

data/ext/libxml/ruby_xml_schema.c

@@ -1,161 +1,165 @@
-#include "ruby_libxml.h"
-#include "ruby_xml_schema.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, strings 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;
-
-// Rdoc needs to know 
-#ifdef RDOC_NEVER_DEFINED
-  mLibXML = rb_define_module("LibXML");
-  mXML = rb_define_module_under(mLibXML, "XML");
-#endif
-
-static void
-rxml_schema_free(xmlSchemaPtr xschema) {
-  xmlSchemaFree(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);
-
-  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
-}
-
-/*
- * call-seq:
- *    XML::Schema.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);
-}
-  
-/* TODO what is this patch doing here?
- 
- 	xmlSchemaParserCtxtPtr  parser;
- 	xmlSchemaPtr            sptr;
- 	xmlSchemaValidCtxtPtr   vptr;
-+	int                     is_invalid;
- 	
- 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &source) == FAILURE) {
- 		return;
-@@ -598,26 +598,24 @@
- 			convert_to_string_ex(&source);
- 			parser = xmlSchemaNewParserCtxt(Z_STRVAL_P(source));
- 			sptr = xmlSchemaParse(parser);
- 			break;
- 		case SCHEMA_BLOB:
- 			convert_to_string_ex(&source);
- 			parser = xmlSchemaNewMemParserCtxt(Z_STRVAL_P(source), Z_STRLEN_P(source));
- 			sptr = xmlSchemaParse(parser);
- 			break;
- 	}
- 
- 	vptr = xmlSchemaNewValidCtxt(sptr);
-+	is_invalid = xmlSchemaValidateDoc(vptr, (xmlDocPtr) sxe->document->ptr);
- 	xmlSchemaFree(sptr);
- 	xmlSchemaFreeValidCtxt(vptr);
- 	xmlSchemaFreeParserCtxt(parser);
- 
--	if (is_valid) {
--		RETURN_TRUE;
--	} else {
-+	if (is_invalid) {
- 		RETURN_FALSE;
-+	} else {
-+		RETURN_TRUE;
- 	}
- }
-  }}} 
-@@ -695,7 +693,7 @@
- {
- 	if (!strcmp(method, "xsearch")) {
- 		simplexml_ce_xpath_search(INTERNAL_FUNCTION_PARAM_PASSTHRU);
--#ifdef xmlSchemaParserCtxtPtr
-+#ifdef LIBXML_SCHEMAS_ENABLED
- 	} else if (!strcmp(method, "validate_schema_file")) {
- 		simplexml_ce_schema_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, SCHEMA_FILE);	
- 	} else if (!strcmp(method, "validate_schema_buffer")) {
-*/
-
-void  ruby_init_xml_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);
-}
-
+#include "ruby_libxml.h"
+#include "ruby_xml_schema.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, strings 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;
+
+// Rdoc needs to know
+#ifdef RDOC_NEVER_DEFINED
+mLibXML = rb_define_module("LibXML");
+mXML = rb_define_module_under(mLibXML, "XML");
+#endif
+
+static void rxml_schema_free(xmlSchemaPtr xschema)
+{
+  xmlSchemaFree(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);
+
+  return Data_Wrap_Struct(cXMLSchema, NULL, rxml_schema_free, xschema);
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.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);
+}
+
+/* TODO what is this patch doing here?
+
+ xmlSchemaParserCtxtPtr  parser;
+ xmlSchemaPtr            sptr;
+ xmlSchemaValidCtxtPtr   vptr;
+ +	int                     is_invalid;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &source) == FAILURE) {
+ return;
+ @@ -598,26 +598,24 @@
+ convert_to_string_ex(&source);
+ parser = xmlSchemaNewParserCtxt(Z_STRVAL_P(source));
+ sptr = xmlSchemaParse(parser);
+ break;
+ case SCHEMA_BLOB:
+ convert_to_string_ex(&source);
+ parser = xmlSchemaNewMemParserCtxt(Z_STRVAL_P(source), Z_STRLEN_P(source));
+ sptr = xmlSchemaParse(parser);
+ break;
+ }
+
+ vptr = xmlSchemaNewValidCtxt(sptr);
+ +	is_invalid = xmlSchemaValidateDoc(vptr, (xmlDocPtr) sxe->document->ptr);
+ xmlSchemaFree(sptr);
+ xmlSchemaFreeValidCtxt(vptr);
+ xmlSchemaFreeParserCtxt(parser);
+
+ -	if (is_valid) {
+ -		RETURN_TRUE;
+ -	} else {
+ +	if (is_invalid) {
+ RETURN_FALSE;
+ +	} else {
+ +		RETURN_TRUE;
+ }
+ }
+ }}}
+ @@ -695,7 +693,7 @@
+ {
+ if (!strcmp(method, "xsearch")) {
+ simplexml_ce_xpath_search(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+ -#ifdef xmlSchemaParserCtxtPtr
+ +#ifdef LIBXML_SCHEMAS_ENABLED
+ } else if (!strcmp(method, "validate_schema_file")) {
+ simplexml_ce_schema_validate(INTERNAL_FUNCTION_PARAM_PASSTHRU, SCHEMA_FILE);
+ } else if (!strcmp(method, "validate_schema_buffer")) {
+ */
+
+void ruby_init_xml_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);
+}
+