libxml-ruby 0.3.6

data/ext/xml/cbg.c

@@ -0,0 +1,76 @@
+#include <string.h>
+#include <libxml/xmlIO.h>
+#include "ruby.h"
+
+/*
+int         xmlRegisterInputCallbacks       (xmlInputMatchCallback matchFunc,
+                                             xmlInputOpenCallback openFunc,
+                                             xmlInputReadCallback readFunc,
+                                             xmlInputCloseCallback closeFunc);
+
+
+int         (*xmlInputMatchCallback)        (char const *filename);
+void*       (*xmlInputOpenCallback)         (char const *filename);
+int         (*xmlInputReadCallback)         (void *context,
+                                             char *buffer,
+                                             int len);
+int         (*xmlInputCloseCallback)        (void *context);
+*/
+
+typedef struct deb_doc_context {
+    char *buffer;
+    char *bpos;
+    int remaining;
+} deb_doc_context;
+
+int deb_Match (char const *filename) {
+    fprintf( stderr, "deb_Match: %s\n", filename );
+    if (!xmlStrncasecmp(BAD_CAST filename, BAD_CAST "deb://", 6)) {
+        return(1);
+    }
+    return(0);
+}
+
+void* deb_Open (char const *filename) {
+    deb_doc_context *deb_doc;
+    VALUE res;
+
+    deb_doc = (deb_doc_context*)malloc( sizeof(deb_doc_context) );
+
+    res = rb_funcall( rb_funcall( rb_mKernel, rb_intern("const_get"), 1, rb_str_new2("DEBSystem") ),
+                      rb_intern("document_query"), 1, rb_str_new2(filename));
+    deb_doc->buffer = strdup( StringValuePtr(res) );
+    //deb_doc->buffer = strdup("<serepes>serepes</serepes>");
+
+    deb_doc->bpos = deb_doc->buffer;
+    deb_doc->remaining = strlen(deb_doc->buffer);
+    return deb_doc;
+}
+
+int deb_Read (void *context, char *buffer, int len) {
+    deb_doc_context *deb_doc;
+    int ret_len;
+    deb_doc = (deb_doc_context*)context;
+
+    if (len >= deb_doc->remaining) {
+        ret_len =  deb_doc->remaining;
+    } else {
+        ret_len = len;
+    }
+    deb_doc->remaining -= ret_len;
+    strncpy( buffer, deb_doc->bpos, ret_len );
+    deb_doc->bpos += ret_len;
+
+    return ret_len;
+}
+
+int deb_Close (void *context) {
+    free( ((deb_doc_context*)context)->buffer );
+    free( context );
+    return 1;
+}
+
+
+void deb_register_cbg() {
+    xmlRegisterInputCallbacks( deb_Match, deb_Open, deb_Read, deb_Close );
+}

data/ext/xml/extconf.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require 'mkmf'
+
+if defined?(CFLAGS)
+  if CFLAGS.index(CONFIG['CCDLFLAGS'])
+    $CFLAGS = CFLAGS
+  else
+    $CFLAGS = CFLAGS + ' ' + CONFIG['CCDLFLAGS']
+  end
+else
+  $CFLAGS = CONFIG['CFLAGS']
+end
+$LDFLAGS = CONFIG['LDFLAGS']
+$LIBPATH.push(Config::CONFIG['libdir'])
+
+def crash(str)
+  printf(" extconf failure: %s\n", str)
+  exit 1
+end
+
+dir_config('iconv')
+dir_config('xml2')
+dir_config('zlib')
+
+have_library('socket','socket')
+have_library('nsl','gethostbyname')
+
+unless have_library('m', 'atan')
+  # try again for gcc 4.0
+  saveflags = $CFLAGS
+  $CFLAGS += ' -fno-builtin'
+  unless have_library('m', 'atan')
+    crash('need libm')
+  end
+  $CFLAGS = saveflags
+end
+
+unless have_library('z', 'inflate')
+  crash('need zlib')
+else
+  $defs.push('-DHAVE_ZLIB_H')
+end
+
+unless have_library('iconv','iconv_open') or have_library('c','iconv_open') or
+  have_library('recode','iconv_open')
+  crash(<<EOL)
+need libiconv.
+
+	Install the libiconv or try passing one of the following options
+	to extconf.rb:
+
+	--with-iconv-dir=/path/to/iconv
+	--with-iconv-lib=/path/to/iconv/lib
+	--with-iconv-include=/path/to/iconv/include
+EOL
+end
+
+unless have_library('xml2', 'xmlParseDoc')
+  crash(<<EOL)
+need libxml2.
+
+        Install the library or try one of the following options to extconf.rb:
+
+        --with-xml2-dir=/path/to/libxml2
+        --with-xml2-lib=/path/to/libxml2/lib
+        --with-xml2-include=/path/to/libxml2/include
+EOL
+end
+
+unless have_library('xml2', 'xmlDocFormatDump')
+  crash('Your version of libxml2 is too old.  Please upgrade.')
+end
+
+unless have_func('docbCreateFileParserCtxt')
+  crash('Need docbCreateFileParserCtxt')
+end
+
+$LDFLAGS << ' ' + `xslt-config --libs`.chomp
+$LDFLAGS << ' ' + `xml2-config --libs`.chomp
+
+$CFLAGS << ' ' + `xslt-config --cflags`.chomp
+$CFLAGS << ' ' + `xml2-config --cflags`.chomp
+$CFLAGS = '-g -Wall ' + $CFLAGS
+
+create_header()
+create_makefile('xml/libxml')
+
+# Quick hack around a problem building on OSX
+if RUBY_PLATFORM =~ /darwin/
+   mf = File.read('Makefile')
+   File.open('Makefile','w+') do |f|
+     f << mf.gsub(/^CFLAGS\s+=\s+(.*)/) { "CFLAGS = #{$1.gsub('-fno-common','')}" }
+   end
+end

data/ext/xml/libxml.c

@@ -0,0 +1,86 @@
+/* $Id: libxml.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"
+
+/* Ruby's util.h has ruby_strdup */
+#include "util.h"
+
+#ifdef xmlMalloc
+#undef xmlMalloc
+#endif
+#ifdef xmlRealloc
+#undef xmlRealloc
+#endif
+#ifdef xmlMemStrdup
+#undef xmlMemStrdup
+#endif
+#ifdef xmlMemFree
+#undef xmlMemFree
+#endif
+
+#ifdef RubyMemMalloc
+#undef RubyMemMalloc
+#endif
+#ifdef RubyMemRealloc
+#undef RubyMemRealloc
+#endif
+#ifdef RubyMemStrdup
+#undef RubyMemStrdup
+#endif
+#ifdef RubyMemFree
+#undef RubyMemFree
+#endif
+
+#define RubyMemFree     ruby_xfree
+#define RubyMemRealloc  ruby_xrealloc
+#define RubyMemMalloc   ruby_xmalloc
+#define RubyMemStrdup   ruby_strdup
+
+VALUE mXML;
+
+static xmlFreeFunc freeFunc = NULL;
+static xmlMallocFunc mallocFunc = NULL;
+static xmlReallocFunc reallocFunc = NULL;
+static xmlStrdupFunc strdupFunc = NULL;
+
+void
+Init_libxml(void) {
+  /* Some libxml memory goo that should be done before anything else */
+  xmlMemGet((xmlFreeFunc *) & freeFunc,
+            (xmlMallocFunc *) & mallocFunc,
+            (xmlReallocFunc *) & reallocFunc,
+            (xmlStrdupFunc *) & strdupFunc);
+
+  if (xmlMemSetup((xmlFreeFunc)RubyMemFree, (xmlMallocFunc)RubyMemMalloc,
+                  (xmlReallocFunc)RubyMemRealloc, (xmlStrdupFunc)RubyMemStrdup) != 0)
+    rb_fatal("could not install the memory handlers for libxml");
+  xmlInitParser();
+
+  mXML = rb_define_module("XML");
+
+  rb_define_const(mXML, "XML_NAMESPACE", rb_str_new2((const char*)XML_XML_NAMESPACE));
+
+  ruby_init_parser();
+  ruby_init_xml_parser_context();
+  ruby_init_xml_attr();
+  ruby_init_xml_attribute();
+  ruby_init_xml_document();
+  ruby_init_xml_node();
+  ruby_init_xml_node_set();
+  ruby_init_xml_ns();
+  ruby_init_xml_sax_parser();
+  ruby_init_xml_tree();
+  ruby_init_xml_xinclude();
+  ruby_init_xml_xpath();
+  ruby_init_xml_xpath_context();
+  ruby_init_xml_xpointer();
+  ruby_init_xml_xpointer_context();
+  ruby_init_input_callbacks(); /* MUFF */
+  ruby_init_xml_dtd();         /* MUFF */
+  ruby_init_xml_schema();      /* MUFF */
+
+  ruby_xml_parser_default_substitute_entities_set(cXMLParser, Qtrue);
+  ruby_xml_parser_default_load_external_dtd_set(cXMLParser, Qtrue);
+}

data/ext/xml/libxml.h

@@ -0,0 +1,79 @@
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_LIBXML_H__
+#define __RUBY_LIBXML_H__
+
+/* 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  "0.3.6"
+#define RUBY_LIBXML_VERNUM   036
+
+#include <ruby.h>
+#include <rubyio.h>
+#include <util.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/debugXML.h>
+#include <libxml/xmlversion.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/xpath.h>
+#include <libxml/valid.h>
+#include <libxml/catalog.h>
+#ifdef LIBXML_DEBUG_ENABLED
+#include <libxml/xpathInternals.h>
+#endif
+#ifdef LIBXML_XINCLUDE_ENABLED
+#include <libxml/xinclude.h>
+#endif
+#ifdef LIBXML_XPTR_ENABLED
+#include <libxml/xpointer.h>
+#endif
+
+#define RUBY_LIBXML_SRC_TYPE_NULL    0
+#define RUBY_LIBXML_SRC_TYPE_FILE    1
+#define RUBY_LIBXML_SRC_TYPE_STRING  2
+#define RUBY_LIBXML_SRC_TYPE_IO      3
+#define RUBY_LIBXML_SRC_TYPE_XPATH   4
+
+typedef struct rx_file_data {
+  VALUE filename; /* Filename/path to self */
+} rx_file_data;
+
+typedef struct rx_io_data {
+  VALUE io;
+} rx_io_data;
+
+typedef struct rx_string_data {
+  VALUE str;
+} rx_string_data;
+
+typedef struct rx_xpath_data {
+  VALUE ctxt;
+} rx_xpath_data;
+
+#include "ruby_xml_attr.h"
+#include "ruby_xml_attribute.h"
+#include "ruby_xml_document.h"
+#include "ruby_xml_node.h"
+#include "ruby_xml_node_set.h"
+#include "ruby_xml_ns.h"
+#include "ruby_xml_parser.h"
+#include "ruby_xml_parser_context.h"
+#include "ruby_xml_sax_parser.h"
+#include "ruby_xml_tree.h"
+#include "ruby_xml_xinclude.h"
+#include "ruby_xml_xpath.h"
+#include "ruby_xml_xpath_context.h"
+#include "ruby_xml_xpointer.h"
+#include "ruby_xml_xpointer_context.h"
+#include "ruby_xml_input_cbg.h"
+#include "ruby_xml_dtd.h"
+#include "ruby_xml_schema.h"
+
+extern VALUE mXML;
+
+void ruby_init_parser(void);
+void ruby_xml_parser_free(ruby_xml_parser *rxp);
+
+#endif

data/ext/xml/ruby_xml_attr.c

@@ -0,0 +1,372 @@
+/* $Id: ruby_xml_attr.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_attr.h"
+
+VALUE cXMLAttr;
+
+void
+ruby_xml_attr_free(ruby_xml_attr *rxa) {
+  if (rxa->attr != NULL && !rxa->is_ptr) {
+    xmlUnlinkNode((xmlNodePtr)rxa->attr);
+    xmlFreeNode((xmlNodePtr)rxa->attr);
+    rxa->attr = NULL;
+  }
+
+  free(rxa);
+}
+
+
+/*
+ * call-seq:
+ *    attr.child => node
+ * 
+ * Obtain this attribute's child attribute(s).
+ */
+VALUE
+ruby_xml_attr_child_get(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->children == NULL)
+    return(Qnil);
+  else
+    return(ruby_xml_node_new2(cXMLNode, rxa->xd, rxa->attr->children));
+}
+
+
+/*
+ * call-seq:
+ *    attr.child? => (true|false)
+ * 
+ * Determine whether this attribute has child attributes.
+ */
+VALUE
+ruby_xml_attr_child_q(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->children == NULL)
+    return(Qfalse);
+  else
+    return(Qtrue);
+}
+
+
+/*
+ * call-seq:
+ *    attr.doc => document
+ * 
+ * Obtain the XML::Document this attribute is associated with,
+ * if any.
+ */
+VALUE
+ruby_xml_attr_doc_get(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->doc == NULL)
+    return(Qnil);
+  else
+    return(ruby_xml_document_new(cXMLDocument, rxa->attr->doc));
+}
+
+
+/*
+ * call-seq:
+ *    attr.doc? => (true|false)
+ * 
+ * Determine whether this attribute is associated with an
+ * XML::Document.
+ */
+VALUE
+ruby_xml_attr_doc_q(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->doc == NULL)
+    return(Qfalse);
+  else
+    return(Qtrue);
+}
+
+
+/*
+ * call-seq:
+ *    attr.last => node
+ * 
+ * Obtain the last attribute.
+ */
+VALUE
+ruby_xml_attr_last_get(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->last == NULL)
+    return(Qnil);
+  else
+    return(ruby_xml_node_new2(cXMLNode, rxa->xd, rxa->attr->last));
+}
+
+
+/*
+ * call-seq:
+ *    attr.last? => (true|false)
+ * 
+ * Determine whether this is the last attribute.
+ */
+VALUE
+ruby_xml_attr_last_q(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->last == NULL)
+    return(Qfalse);
+  else
+    return(Qtrue);
+}
+
+
+static void
+ruby_xml_attr_mark(ruby_xml_attr *rxa) {
+  if (rxa == NULL) return;
+  if (!NIL_P(rxa->xd)) rb_gc_mark(rxa->xd);
+}
+
+
+/*
+ * call-seq:
+ *    attr.name => "name"
+ * 
+ * Obtain this attribute's name.
+ */
+VALUE
+ruby_xml_attr_name_get(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+
+  if (rxa->attr->name == NULL)
+    return(Qnil);
+  else
+    return(rb_str_new2((const char*)rxa->attr->name));
+}
+
+
+VALUE
+ruby_xml_attr_new(VALUE class, VALUE xd, xmlAttrPtr attr) {
+  ruby_xml_attr *rxa;
+
+  rxa = ALLOC(ruby_xml_attr);
+  rxa->attr = attr;
+  rxa->xd = xd;
+  rxa->is_ptr = 0;
+  return(Data_Wrap_Struct(class, ruby_xml_attr_mark,
+			  ruby_xml_attr_free, rxa));
+}
+
+
+VALUE
+ruby_xml_attr_new2(VALUE class, VALUE xd, xmlAttrPtr attr) {
+  ruby_xml_attr *rxa;
+
+  rxa = ALLOC(ruby_xml_attr);
+  rxa->attr = xmlCopyProp(attr->parent, attr);
+  rxa->xd = xd;
+  rxa->is_ptr = 0;
+  return(Data_Wrap_Struct(class, ruby_xml_attr_mark,
+			  ruby_xml_attr_free, rxa));
+}
+
+
+/*
+ * call-seq:
+ *    attr.next => node
+ * 
+ * Obtain the next attribute.
+ */
+VALUE
+ruby_xml_attr_next_get(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->next == NULL)
+    return(Qnil);
+  else
+    return(ruby_xml_attr_new(cXMLAttr, rxa->xd, rxa->attr->next));
+}
+
+
+/*
+ * call-seq:
+ *    attr.next? => (true|false)
+ * 
+ * Determine whether there is a next attribute.
+ */
+VALUE
+ruby_xml_attr_next_q(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->next == NULL)
+    return(Qfalse);
+  else
+    return(Qtrue);
+}
+
+
+/*
+ * call-seq:
+ *    attr.type_name => "attribute"
+ * 
+ * Obtain this attribute node's type name.
+ */
+VALUE
+ruby_xml_attr_node_type_name(VALUE self) {
+  /* I think libxml2's naming convention blows monkey ass */
+  return(rb_str_new2("attribute"));
+}
+
+
+/*
+ * call-seq:
+ *    attr.ns => namespace
+ * 
+ * Obtain this attribute's associated XML::NS, if any.
+ */
+VALUE
+ruby_xml_attr_ns_get(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->ns == NULL)
+    return(Qnil);
+  else
+    return(ruby_xml_ns_new2(cXMLNS, rxa->xd, rxa->attr->ns));
+}
+
+
+/*
+ * call-seq:
+ *    attr.ns? => (true|false)
+ * 
+ * Determine whether this attribute has an associated 
+ * namespace.
+ */
+VALUE
+ruby_xml_attr_ns_q(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->ns == NULL)
+    return(Qfalse);
+  else
+    return(Qtrue);
+}
+
+
+/*
+ * call-seq:
+ *    attr.parent => node
+ * 
+ * Obtain this attribute node's parent.
+ */
+VALUE
+ruby_xml_attr_parent_get(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->parent == NULL)
+    return(Qnil);
+  else
+    return(ruby_xml_node_new2(cXMLNode, rxa->xd, rxa->attr->parent));
+}
+
+
+/*
+ * call-seq:
+ *    attr.parent? => (true|false)
+ * 
+ * Determine whether this attribute has a parent.
+ */
+VALUE
+ruby_xml_attr_parent_q(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->parent == NULL)
+    return(Qfalse);
+  else
+    return(Qtrue);
+}
+
+
+/*
+ * call-seq:
+ *    attr.prev => node
+ * 
+ * Obtain the previous attribute.
+ */
+VALUE
+ruby_xml_attr_prev_get(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->prev == NULL)
+    return(Qnil);
+  else
+    return(ruby_xml_attr_new(cXMLAttr, rxa->xd, rxa->attr->prev));
+}
+
+
+/*
+ * call-seq:
+ *    attr.prev? => (true|false)
+ * 
+ * Determine whether there is a previous attribute.
+ */
+VALUE
+ruby_xml_attr_prev_q(VALUE self) {
+  ruby_xml_attr *rxa;
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (rxa->attr->prev == NULL)
+    return(Qfalse);
+  else
+    return(Qtrue);
+}
+
+
+/*
+ * call-seq:
+ *    attr.value => "value"
+ * 
+ * Obtain the value of this attribute.
+ */
+VALUE
+ruby_xml_attr_value(VALUE self) {
+  ruby_xml_attr *rxa;
+  xmlChar *value;
+
+  Data_Get_Struct(self, ruby_xml_attr, rxa);
+  if (ruby_xml_attr_parent_q(self) == Qtrue) {
+    value = xmlGetProp(rxa->attr->parent, rxa->attr->name);
+    if (value != NULL)
+      return(rb_str_new2((const char*)value));
+  }
+  return(Qnil);
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+
+void
+ruby_init_xml_attr(void) {
+  cXMLAttr = rb_define_class_under(mXML, "Attr", rb_cObject);
+  rb_define_method(cXMLAttr, "child", ruby_xml_attr_child_get, 0);
+  rb_define_method(cXMLAttr, "child?", ruby_xml_attr_child_q, 0);
+  rb_define_method(cXMLAttr, "doc", ruby_xml_attr_doc_get, 0);
+  rb_define_method(cXMLAttr, "doc?", ruby_xml_attr_doc_q, 0);
+  rb_define_method(cXMLAttr, "last", ruby_xml_attr_last_get, 0);
+  rb_define_method(cXMLAttr, "last?", ruby_xml_attr_last_q, 0);
+  rb_define_method(cXMLAttr, "name", ruby_xml_attr_name_get, 0);
+  rb_define_method(cXMLAttr, "next", ruby_xml_attr_next_get, 0);
+  rb_define_method(cXMLAttr, "next?", ruby_xml_attr_next_q, 0);
+  rb_define_method(cXMLAttr, "node_type_name", ruby_xml_attr_node_type_name, 0);
+  rb_define_method(cXMLAttr, "ns", ruby_xml_attr_ns_get, 0);
+  rb_define_method(cXMLAttr, "ns?", ruby_xml_attr_ns_q, 0);
+  rb_define_method(cXMLAttr, "parent", ruby_xml_attr_parent_get, 0);
+  rb_define_method(cXMLAttr, "parent?", ruby_xml_attr_parent_q, 0);
+  rb_define_method(cXMLAttr, "prev", ruby_xml_attr_prev_get, 0);
+  rb_define_method(cXMLAttr, "prev?", ruby_xml_attr_prev_q, 0);
+  rb_define_method(cXMLAttr, "value", ruby_xml_attr_value, 0);
+}