libxml-ruby 0.3.6

data/ext/xml/ruby_xml_parser_context.h

@@ -0,0 +1,22 @@
+/* $Id: ruby_xml_parser_context.h,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_PARSER_CONTEXT__
+#define __RUBY_XML_PARSER_CONTEXT__
+
+extern VALUE cXMLParserContext;
+
+typedef struct ruby_xml_parser_context {
+  xmlParserCtxtPtr ctxt;
+  int is_ptr;
+} ruby_xml_parser_context;
+
+void ruby_xml_parser_context_free(ruby_xml_parser_context *ctxt);
+void ruby_init_xml_parser_context(void);
+VALUE ruby_xml_parser_context_new(VALUE class, xmlParserCtxtPtr ctxt);
+VALUE ruby_xml_parser_context_new2(VALUE class);
+VALUE ruby_xml_parser_context_new3();
+VALUE ruby_xml_parser_context_each(VALUE self);
+
+#endif

data/ext/xml/ruby_xml_sax_parser.c

@@ -0,0 +1,181 @@
+/* $Id: ruby_xml_sax_parser.c,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "libxml.h"
+#include "ruby_xml_sax_parser.h"
+
+VALUE cXMLSaxParser;
+
+void
+ruby_xml_sax_parser_free(ruby_xml_sax_parser *rxsp) {
+  /* Apparently this isn't needed: time will tell */
+  /* if (rxsp->xsh != NULL) */
+  /* xmlFreeSax_Parser(rxsp->sax_parser); */
+}
+
+/*
+ * call-seq:
+ *    XML::SaxParser.new => sax_parser
+ * 
+ * Create a new XML::SaxParser instance.
+ */
+VALUE
+ruby_xml_sax_parser_new(VALUE class) {
+  ruby_xml_sax_parser *rxsp;
+
+  xmlSAXHandler emptySAXHandlerStruct = {
+    NULL, /* internalSubset */
+    NULL, /* isStandalone */
+    NULL, /* hasInternalSubset */
+    NULL, /* hasExternalSubset */
+    NULL, /* resolveEntity */
+    NULL, /* getEntity */
+    NULL, /* entityDecl */
+    NULL, /* notationDecl */
+    NULL, /* attributeDecl */
+    NULL, /* elementDecl */
+    NULL, /* unparsedEntityDecl */
+    NULL, /* setDocumentLocator */
+    NULL, /* startDocument */
+    NULL, /* endDocument */
+    NULL, /* startElement */
+    NULL, /* endElement */
+    NULL, /* reference */
+    NULL, /* characters */
+    NULL, /* ignorableWhitespace */
+    NULL, /* processingInstruction */
+    NULL, /* comment */
+    NULL, /* xmlParserWarning */
+    NULL, /* xmlParserError */
+    NULL, /* xmlParserError */
+    NULL, /* getParameterEntity */
+    NULL, /* cdataBlock; */
+    NULL, /* externalSubset; */
+    1
+  };
+
+  rxsp = ALLOC(ruby_xml_sax_parser);
+  rxsp->xsh = &emptySAXHandlerStruct;
+
+  rxsp->xpc = NULL;
+  rxsp->filename = Qnil;
+  rxsp->str = Qnil;
+
+  return(Data_Wrap_Struct(class, 0, ruby_xml_sax_parser_free, rxsp));
+}
+
+
+/*
+ * call-seq:
+ *    sax_parser.filename => "filename"
+ * 
+ * Obtain the filename this parser reads from.
+ */
+VALUE
+ruby_xml_sax_parser_filename_get(VALUE self) {
+  ruby_xml_sax_parser *rxsp;
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  return(rxsp->filename);
+}
+
+
+/*
+ * call-seq:
+ *    sax_parser.filename = "filename"
+ * 
+ * Set the filename this parser reads from.
+ */
+VALUE
+ruby_xml_sax_parser_filename_set(VALUE self, VALUE filename) {
+  ruby_xml_sax_parser *rxsp;
+  Check_Type(filename, T_STRING);
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  rxsp->filename = filename;
+  return(rxsp->filename);
+}
+
+
+/*
+ * call-seq:
+ *    parser.parse => document
+ * 
+ * Parse the input XML.
+ */
+VALUE
+ruby_xml_sax_parser_parse(VALUE self) {
+  char *str;
+  int status;
+  ruby_xml_sax_parser *rxsp;
+  VALUE docobj = Qnil;
+
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+
+  if (rxsp->filename != Qnil) {
+    status = xmlSAXUserParseFile(rxsp->xsh, NULL, StringValuePtr(rxsp->filename));
+
+    /* XXX This should return an exception for the various error codes
+     * that can come back in status, but I'm too lazy to do that right
+     * now. */
+    if (status)
+      docobj = Qfalse;
+    else
+      docobj = Qtrue;
+  } else if (rxsp->str != Qnil) {
+    str = StringValuePtr(rxsp->str);
+    docobj = ruby_xml_document_new(cXMLDocument,
+				   xmlSAXParseMemory(rxsp->xsh, str,
+						     strlen(str), 0));
+  }
+  return(docobj);
+}
+
+
+/*
+ * call-seq:
+ *    parser.string => "xml"
+ * 
+ * Obtain the parser's input string.
+ */
+VALUE
+ruby_xml_sax_parser_str_get(VALUE self) {
+  ruby_xml_sax_parser *rxsp;
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  return(rxsp->str);
+}
+
+
+/*
+ * call-seq:
+ *    parser.string = "xml"
+ * 
+ * Set the parser's input string.
+ */
+VALUE
+ruby_xml_sax_parser_str_set(VALUE self, VALUE str) {
+  ruby_xml_sax_parser *rxsp;
+  Check_Type(str, T_STRING);
+  Data_Get_Struct(self, ruby_xml_sax_parser, rxsp);
+  rxsp->str = str;
+  return(rxsp->str);
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_sax_parser(void) {
+  cXMLSaxParser = rb_define_class_under(mXML, "SaxParser", rb_cObject);
+
+  rb_define_singleton_method(cXMLSaxParser, "new", ruby_xml_sax_parser_new, 0);
+
+  rb_define_method(cXMLSaxParser, "filename",
+		   ruby_xml_sax_parser_filename_get, 0);
+  rb_define_method(cXMLSaxParser, "filename=",
+		   ruby_xml_sax_parser_filename_set, 1);
+  rb_define_method(cXMLSaxParser, "parse", ruby_xml_sax_parser_parse, 0);
+  rb_define_method(cXMLSaxParser, "string", ruby_xml_sax_parser_str_get, 0);
+  rb_define_method(cXMLSaxParser, "string=", ruby_xml_sax_parser_str_set, 1);
+}

data/ext/xml/ruby_xml_sax_parser.h

@@ -0,0 +1,21 @@
+/* $Id: ruby_xml_sax_parser.h,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_SAX_PARSER__
+#define __RUBY_XML_SAX_PARSER__
+
+extern VALUE cXMLSaxParser;
+
+typedef struct ruby_xml_sax_parser {
+  xmlParserCtxtPtr xpc;
+  xmlSAXHandlerPtr xsh;
+  VALUE filename;
+  VALUE str;
+} ruby_xml_sax_parser;
+
+void ruby_xml_sax_parser_free(ruby_xml_sax_parser *rxsp);
+void ruby_init_xml_sax_parser(void);
+VALUE ruby_xml_sax_parser_new(VALUE class);
+
+#endif

data/ext/xml/ruby_xml_schema.c

@@ -0,0 +1,142 @@
+#include "libxml.h"
+#include "ruby_xml_schema.h"
+
+VALUE cXMLSchema;
+
+static void
+ruby_xml_schema_mark(ruby_xml_schema *rxschema) {
+  return;
+}
+
+void
+ruby_xml_schema_free(ruby_xml_schema *rxschema) {
+  if (rxschema->schema != NULL) {
+    xmlSchemaFree(rxschema->schema);
+    rxschema->schema = NULL;
+  }
+
+  free(rxschema);
+}
+
+/*
+ * call-seq:
+ *    XML::Scheme.new(schema_uri) => schema
+ * 
+ * Create a new schema from the specified URI.
+ */
+VALUE
+ruby_xml_schema_init_from_uri(int argc, VALUE *argv, VALUE class) {
+  VALUE uri;
+  xmlSchemaParserCtxtPtr parser;
+  xmlSchemaPtr sptr;
+
+  switch (argc) {
+  case 1:
+    rb_scan_args(argc, argv, "10", &uri);
+
+    Check_Type(uri, T_STRING);
+
+ 	parser = xmlSchemaNewParserCtxt(StringValuePtr(uri));
+ 	sptr = xmlSchemaParse(parser);
+ 	xmlSchemaFreeParserCtxt(parser);
+    break;
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (need 1)");
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *    XML::Schema.from_string("schema_data") => "value"
+ * 
+ * Create a new schema using the specified string.
+ */
+VALUE
+ruby_xml_schema_init_from_str(int argc, VALUE *argv, VALUE class) {
+  VALUE schema_str;
+
+  xmlSchemaParserCtxtPtr  parser;
+  //xmlSchemaPtr            sptr;
+  ruby_xml_schema *rxschema;
+
+  switch (argc) {
+  case 1:
+    rb_scan_args(argc, argv, "10", &schema_str);
+
+    Check_Type(schema_str, T_STRING);
+
+    parser = xmlSchemaNewMemParserCtxt(StringValuePtr(schema_str), strlen(StringValuePtr(schema_str)));
+    rxschema = ALLOC(ruby_xml_schema);
+    rxschema->schema = xmlSchemaParse(parser);
+ 	xmlSchemaFreeParserCtxt(parser);
+
+    return( Data_Wrap_Struct(cXMLSchema, ruby_xml_schema_mark, ruby_xml_schema_free, rxschema) );
+  default:
+    rb_raise(rb_eArgError, "wrong number of arguments (need 1)");
+  }
+  return Qnil;
+}
+  
+/* 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_schema_free(ruby_xml_schema *rxs) {
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void  ruby_init_xml_schema(void) {
+  cXMLSchema = rb_define_class_under(mXML, "Schema", rb_cObject);
+  rb_define_singleton_method(cXMLSchema, "new",         ruby_xml_schema_init_from_uri, -1);
+  rb_define_singleton_method(cXMLSchema, "from_string", ruby_xml_schema_init_from_str, -1);
+}
+

data/ext/xml/ruby_xml_schema.h

@@ -0,0 +1,16 @@
+#ifndef __RUBY_XML_SCHEMA__
+#define __RUBY_XML_SCHEMA__
+
+#include <libxml/schemasInternals.h>
+#include <libxml/xmlschemas.h>
+
+extern VALUE cXMLDtd;
+
+typedef struct rxp_schema {
+  xmlSchemaPtr schema;   /* Schema interface */
+} ruby_xml_schema;
+
+void  ruby_init_xml_schema(void);
+void  ruby_schema_free(ruby_xml_schema *rxs);
+#endif
+

data/ext/xml/ruby_xml_tree.c

@@ -0,0 +1,43 @@
+/* $Id: ruby_xml_tree.c,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "libxml.h"
+#include "ruby_xml_tree.h"
+
+VALUE cXMLTree;
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_tree(void) {
+  cXMLTree = rb_define_class_under(mXML, "Tree", rb_cObject);
+
+  rb_define_const(cXMLTree, "ELEMENT_NODE", INT2FIX(XML_ELEMENT_NODE));
+  rb_define_const(cXMLTree, "ATTRIBUTE_NODE", INT2FIX(XML_ATTRIBUTE_NODE));
+  rb_define_const(cXMLTree, "TEXT_NODE", INT2FIX(XML_TEXT_NODE));
+  rb_define_const(cXMLTree, "CDATA_SECTION_NODE", INT2FIX(XML_CDATA_SECTION_NODE));
+  rb_define_const(cXMLTree, "ENTITY_REF_NODE", INT2FIX(XML_ENTITY_REF_NODE));
+  rb_define_const(cXMLTree, "ENTITY_NODE", INT2FIX(XML_ENTITY_NODE));
+  rb_define_const(cXMLTree, "PI_NODE", INT2FIX(XML_PI_NODE));
+  rb_define_const(cXMLTree, "COMMENT_NODE", INT2FIX(XML_COMMENT_NODE));
+  rb_define_const(cXMLTree, "DOCUMENT_NODE", INT2FIX(XML_DOCUMENT_NODE));
+  rb_define_const(cXMLTree, "DOCUMENT_TYPE_NODE", INT2FIX(XML_DOCUMENT_TYPE_NODE));
+  rb_define_const(cXMLTree, "DOCUMENT_FRAG_NODE", INT2FIX(XML_DOCUMENT_FRAG_NODE));
+  rb_define_const(cXMLTree, "NOTATION_NODE", INT2FIX(XML_NOTATION_NODE));
+  rb_define_const(cXMLTree, "HTML_DOCUMENT_NODE", INT2FIX(XML_HTML_DOCUMENT_NODE));
+  rb_define_const(cXMLTree, "DTD_NODE", INT2FIX(XML_DTD_NODE));
+  rb_define_const(cXMLTree, "ELEMENT_DECL", INT2FIX(XML_ELEMENT_DECL));
+  rb_define_const(cXMLTree, "ATTRIBUTE_DECL", INT2FIX(XML_ATTRIBUTE_DECL));
+  rb_define_const(cXMLTree, "ENTITY_DECL", INT2FIX(XML_ENTITY_DECL));
+  rb_define_const(cXMLTree, "NAMESPACE_DECL", INT2FIX(XML_NAMESPACE_DECL));
+  rb_define_const(cXMLTree, "XINCLUDE_START", INT2FIX(XML_XINCLUDE_START));
+  rb_define_const(cXMLTree, "XINCLUDE_END", INT2FIX(XML_XINCLUDE_END));
+
+#ifdef LIBXML_DOCB_ENABLED
+  rb_define_const(cXMLTree, "DOCB_DOCUMENT_NODE", INT2FIX(XML_DOCB_DOCUMENT_NODE));
+#endif
+}

data/ext/xml/ruby_xml_tree.h

@@ -0,0 +1,12 @@
+/* $Id: ruby_xml_tree.h,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_TREE__
+#define __RUBY_XML_TREE__
+
+extern VALUE cXMLTree;
+
+void ruby_init_xml_tree(void);
+
+#endif

data/ext/xml/ruby_xml_xinclude.c

@@ -0,0 +1,20 @@
+/* $Id: ruby_xml_xinclude.c,v 1.1 2006/02/21 20:40:16 roscopeco Exp $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#include "libxml.h"
+#include "ruby_xml_xinclude.h"
+
+VALUE cXMLXInclude;
+VALUE eXMLXIncludeError;
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_xinclude(void) {
+  cXMLXInclude = rb_define_class_under(mXML, "XInclude", rb_cObject);
+  eXMLXIncludeError = rb_define_class_under(cXMLXInclude, "Error", rb_eRuntimeError);
+}