ruby-xslt 0.9.2

data/examples/test.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>
+<nodes>
+	<node number="1">Hello, </node>
+	<node number="2">World!</node>
+</nodes>

data/examples/test.xsl

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+<xsl:output method="text" encoding="iso-8859-1" indent="no"/>
+<xsl:param name="p1"/>	
+<xsl:param name="p2"/>
+
+<xsl:template match="/">
+	p1:<xsl:value-of select="$p1"/>&#10;
+	p2:<xsl:value-of select="$p2"/>&#10;
+	<xsl:apply-templates/>
+</xsl:template>
+
+<xsl:template match="node">
+	<xsl:value-of select="."/>(<xsl:value-of select="@number"/>)&#10;
+</xsl:template>
+
+</xsl:stylesheet>
+

data/examples/test_functions.rb

@@ -0,0 +1,18 @@
+require "../xslt"
+
+class XML::XSLT
+	def round_trip( arg )
+		arg
+	end
+	def type( arg )
+		arg.class.to_s
+	end
+end
+
+xslt = XML::XSLT.new()
+xslt.xsl = "functions.xsl"
+xslt.xml = "test.xml"
+XML::XSLT.extFunction("round-trip", "http://test.none", xslt)
+XML::XSLT.extFunction("type", "http://test.none", xslt)
+
+puts xslt.serve

data/examples/test_parameters.rb

@@ -0,0 +1,13 @@
+require "../xslt"
+
+xslt = XML::XSLT.new()
+xslt.xsl = "test.xsl"
+xslt.xml = "test.xml"
+xslt.parameters = { "p1" => "the first parameter ...",
+                    "p2" => "'and the second one!'" }
+#xslt.save("test.html")
+puts xslt.serve
+xslt.parameters = { "p1" => "Ruby...",
+                    "p2" => "'...is cool !'" }
+#xslt.save("test.html")
+puts xslt.serve

data/extconf.rb

@@ -0,0 +1,114 @@
+#!/usr/bin/ruby -w
+# See the LICENSE file for copyright and distribution information
+
+require "mkmf"
+
+def help
+  print <<HELP
+"extconf.rb" configures this package to adapt to many kinds of systems.
+
+Usage: ruby extconf.rb [OPTION]...
+
+Configuration:
+  --help                   display this help and exit
+  
+  --with-xslt-lib=PATH
+  --with-xslt-include=PATH
+  --with-xslt-dir=PATH     specify the directory name for the libxslt include 
+                           files and/or library 
+  
+  --enable-error-handler   enables a VERY crude error handler. Error messages 
+                           are appended to the class variable XML::XSLT and can
+                           be accessed with the class method XML::XSLT.errors 
+                           (will change in a future version)
+  --disable-exslt          disables libexslt support <http://exslt.org/>
+  
+  --enable-debug           compile with memwatch 
+                           <http://www.linkdata.se/sourcecode.html>
+
+HELP
+end
+
+if ARGV.include?( "--help" )
+  help()
+  exit 0
+end
+
+if enable_config("debug", false)
+  File.symlink( "debug/memwatch.h", "memwatch.h" ) if( ! File.exist?("memwatch.h") )
+  File.symlink( "debug/memwatch.c", "memwatch.c" ) if( ! File.exist?("memwatch.c") )
+  $CFLAGS += " -DMEMWATCH -D__DEBUG__"
+end
+
+if enable_config("error-handler", false)
+  $CFLAGS += " -DUSE_ERROR_HANDLER"
+end
+
+$LIBPATH.push(Config::CONFIG['libdir'])
+
+def crash(str)
+  printf(" extconf failure: %s\n", str)
+  exit 1
+end
+
+#unless have_library("z", "inflate")
+#  crash("need zlib")
+#else
+#  $defs.push('-DHAVE_ZLIB_H')
+#end
+
+if dir_config( "xslt" ) != [nil, nil]
+   inc, lib = dir_config( 'xslt' ) 
+   $LDFLAGS << " -L#{lib} -lxslt -lxml2 -lz -lpthread -liconv -lm"
+   $CFLAGS << " -I#{inc}"
+elsif ex = find_executable( "xslt-config" )
+   $LDFLAGS << ' ' + `#{ex} --libs`.chomp
+   $CFLAGS << ' ' + `#{ex} --cflags`.chomp
+else
+  crash(<<EOL)
+need libxslt.
+
+        Install the library or try one of the following options to extconf.rb:
+
+        --with-xslt-lib=/path/to/libxslt/lib
+        --with-xslt-include=/path/to/libxslt/include
+EOL
+end
+
+if enable_config("exslt", true)
+  $LDFLAGS << " -lexslt"
+  $CFLAGS += " -DUSE_EXSLT"
+end
+
+$CFLAGS = '-g -Wall ' + $CFLAGS
+
+puts "compile with : "
+puts "  CFLAGS = #{$CFLAGS}"
+puts "  LDFLAGS = #{$LDFLAGS}"
+puts
+
+create_header()
+create_makefile("xml/xslt")
+
+######  Modify Makefile: #######
+File.rename( "Makefile", "Makefile.orig" )
+oldmkfl = File.open( "Makefile.orig" )
+newmkfl = File.open( "Makefile", "w" )
+oldmkfl.each_line{ |line|
+   case(line)
+   when /^all:/
+      newmkfl.puts(line)
+      newmkfl.puts("")        
+      newmkfl.puts("test: all")            # insert the "test" target
+      newmkfl.puts("\t\t@cd tests && ruby test.rb && cd ..")
+      newmkfl.puts("doc: all")            # insert the "doc" target
+      newmkfl.puts("\t\t@rdoc -S -t \"Ruby/XSLT Documentation\" README AUTHORS ChangeLog xslt.c")
+   when /^distclean:/
+      newmkfl.puts(line)
+      newmkfl.puts("\t\t@-$(RM) memwatch.h memwatch.c Makefile.orig")
+      newmkfl.puts("\t\t@-$(RM)r doc")
+   else
+      newmkfl.puts(line)
+   end
+}
+newmkfl.close

data/extfunc.c

@@ -0,0 +1,216 @@
+/**
+ * Copyright (C) 2005 Gregoire Lejeune <gregoire.lejeune@free.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include "xslt.h"
+
+extern VALUE mXML;
+extern VALUE cXSLT;
+
+/**
+ * external function support, patch from :
+ *
+ * Brendan Taylor 
+ * whateley@gmail.com
+ *
+ */
+
+
+/*  converts an xmlXPathObjectPtr to a Ruby VALUE 
+ * number -> float
+ * boolean -> boolean
+ * string -> string
+ * nodeset -> an array of REXML::Elements
+ */
+VALUE xpathObj2value(xmlXPathObjectPtr obj, xmlDocPtr doc)
+{
+  VALUE ret = Qnil;
+
+  if (obj == NULL) {
+    return ret;
+  }
+
+  switch (obj->type) {
+    case XPATH_NODESET:
+      rb_require("rexml/document");
+      ret = rb_ary_new();
+      
+      if ((obj->nodesetval != NULL) && (obj->nodesetval->nodeNr != 0)) {
+        xmlBufferPtr buff = xmlBufferCreate();
+        xmlNodePtr node;
+        int i;
+
+        // this assumes all the nodes are elements, which is a bad idea
+        for (i = 0; i < obj->nodesetval->nodeNr; i++) {
+          node = obj->nodesetval->nodeTab[i];
+
+          if( node->type == XML_ELEMENT_NODE ) {
+            xmlNodeDump(buff, doc, node, 0, 0);
+
+            VALUE cREXML = rb_const_get(rb_cObject, rb_intern("REXML"));
+            VALUE cDocument = rb_const_get(cREXML, rb_intern("Document"));
+            VALUE rDocument = rb_funcall(cDocument, rb_intern("new"), 1,rb_str_new2((char *)buff->content));
+            VALUE rElement = rb_funcall(rDocument, rb_intern("root"), 0);
+
+            rb_ary_push(ret, rElement);
+          
+            // empty the buffer (xmlNodeDump appends rather than replaces)
+            xmlBufferEmpty(buff);
+          } else if ( node->type == XML_TEXT_NODE ) {
+            rb_ary_push(ret, rb_str_new2((char *)node->content));
+          }
+        }
+        xmlBufferFree(buff);
+      }
+      break;
+    case XPATH_BOOLEAN:
+      ret = obj->boolval ? Qtrue : Qfalse;
+      break;
+    case XPATH_NUMBER:
+      ret = rb_float_new(obj->floatval);
+      break;
+    case XPATH_STRING:
+      ret = rb_str_new2((char *) obj->stringval);
+      break;
+    /* these cases were in libxslt's python bindings, but i don't know what they are, so i'll leave them alone */
+    case XPATH_XSLT_TREE:
+    case XPATH_POINT:
+    case XPATH_RANGE:
+    case XPATH_LOCATIONSET:
+    default:    
+      rb_warning("xpathObj2value: can't convert XPath object type %d to Ruby object\n", obj->type );
+  }
+  xmlXPathFreeObject(obj);
+  return ret;
+}
+
+/* 
+ *  converts a Ruby VALUE to an xmlXPathObjectPtr
+ * boolean -> boolean
+ * number -> number
+ * string -> escaped string
+ * array -> array of parsed nodes
+ */
+xmlXPathObjectPtr value2xpathObj (VALUE val) {
+  xmlXPathObjectPtr ret = NULL;
+ 
+  switch (TYPE(val)) {
+    case T_TRUE:
+    case T_FALSE:
+      ret = xmlXPathNewBoolean(RTEST(val));
+      break;
+    case T_FIXNUM:
+    case T_FLOAT:
+      ret = xmlXPathNewFloat(NUM2DBL(val));
+      break;
+    case T_STRING:
+    {
+      xmlChar *str;
+
+    // we need the Strdup (this is the major bugfix for 0.8.1)
+      str = xmlStrdup((const xmlChar *) STR2CSTR(val));
+      ret = xmlXPathWrapString(str);
+    }
+      break;
+    case T_NIL:
+      ret = xmlXPathNewNodeSet(NULL);
+      break;
+    case T_ARRAY: {
+      int i,j;
+      ret = xmlXPathNewNodeSet(NULL);
+
+      for(i = RARRAY(val)->len; i > 0; i--) {
+        xmlXPathObjectPtr obj = value2xpathObj( rb_ary_shift( val ) );
+        if ((obj->nodesetval != NULL) && (obj->nodesetval->nodeNr != 0)) {
+          for(j = 0; j < obj->nodesetval->nodeNr; j++) {
+            xmlXPathNodeSetAdd( ret->nodesetval, obj->nodesetval->nodeTab[j] );
+          }
+        }
+      }
+      break;  }
+    case T_DATA:
+    case T_OBJECT: {
+      if( strcmp( getRubyObjectName( val ), "REXML::Document" ) == 0 || strcmp(getRubyObjectName( val ),  "REXML::Element") == 0 ) {
+
+        VALUE to_s = rb_funcall( val, rb_intern( "to_s" ), 0 );
+        xmlDocPtr doc = xmlParseDoc((xmlChar *) STR2CSTR(to_s));
+
+        ret = xmlXPathNewNodeSet((xmlNode *)doc->children);
+        break;
+      } else if( strcmp( getRubyObjectName( val ), "REXML::Text" ) == 0 ) {
+        VALUE to_s = rb_funcall( val, rb_intern( "to_s" ), 0 );
+
+        xmlChar *str;
+
+        str = xmlStrdup((const xmlChar *) STR2CSTR(to_s));
+        ret = xmlXPathWrapString(str);
+        break;
+      }
+      // this drops through so i can reuse the error message
+    }
+    default:
+      rb_warning( "value2xpathObj: can't convert class %s to XPath object\n", getRubyObjectName(val));
+      return NULL;
+  }
+
+  return ret;
+}
+
+/*
+ *  chooses what registered function to call and calls it
+ */
+void xmlXPathFuncCallback( xmlXPathParserContextPtr ctxt, int nargs) {
+  VALUE result, arguments[nargs];
+  VALUE ns_hash, func_hash, object;
+  const xmlChar *namespace;
+  char *rb_func, *chr;
+  xmlXPathObjectPtr obj;
+  int i;
+
+  if (ctxt == NULL || ctxt->context == NULL)
+    return;
+
+  rb_func = strdup((char *)ctxt->context->function);
+  namespace = ctxt->context->functionURI;
+
+  ns_hash = rb_cvar_get(cXSLT, rb_intern("@@extFunctions"));
+
+  func_hash = rb_hash_aref(ns_hash, rb_str_new2((char *)namespace));
+
+  if(func_hash == Qnil) {
+    rb_warning( "xmlXPathFuncCallback: namespace %s not found!\n", namespace );
+  }
+
+  object = rb_hash_aref(func_hash, rb_str_new2((char *)rb_func));
+
+  for (i = nargs - 1; i >= 0; i--) {
+    obj = valuePop(ctxt);
+    arguments[i] = xpathObj2value(obj, ctxt->context->doc);
+  }
+  
+  /* -s are common in XSLT function names, but illegal for Ruby method names */
+  while( (chr = strchr(rb_func, '-')) != NULL ) {
+    chr[0] = '_'; /* so we pretend the - was a _ all along */
+  }
+
+  result = rb_funcall2( object, rb_intern(rb_func), nargs, arguments);
+  
+  free( rb_func );
+
+  obj = value2xpathObj(result);
+  valuePush(ctxt, obj);
+}

data/extfunc.h

@@ -0,0 +1,26 @@
+/**
+ * Copyright (C) 2005 Gregoire Lejeune <gregoire.lejeune@free.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include "xslt.h"
+
+#include <libxml/xpathInternals.h>
+#include <libxslt/extensions.h>
+
+VALUE xpathObj2value( xmlXPathObjectPtr, xmlDocPtr );
+xmlXPathObjectPtr value2xpathObj( VALUE );
+void xmlXPathFuncCallback( xmlXPathParserContextPtr, int );

data/parameters.c

@@ -0,0 +1,59 @@
+/**
+ * Copyright (C) 2005 Gregoire Lejeune <gregoire.lejeune@free.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include "xslt.h"
+
+/**
+ * parameters support, patch from :
+ * 
+ * Eust�quio "TaQ" Rangel
+ * eustaquiorangel@yahoo.com
+ * http://beam.to/taq
+ * 
+ */
+VALUE each_pair( VALUE obj ) {
+  return rb_funcall( obj, rb_intern("each"), 0, 0 );
+}
+    
+VALUE process_pair( VALUE pair, VALUE rbparams ) {
+  VALUE key, value;
+  // Thx to alex__
+  int count = FIX2INT( rb_funcall( rbparams, rb_intern("size"), 0, 0 ) );
+  // static int count = 0;
+  char *xValue = NULL;
+  
+  Check_Type( pair, T_ARRAY );
+
+  key   = RARRAY(pair)->ptr[0];
+  value = RARRAY(pair)->ptr[1];
+  
+  Check_Type( key, T_STRING );
+  Check_Type( value, T_STRING );
+
+  xValue = STR2CSTR( value );
+  if( xValue[0] != '\'' && xValue[strlen( xValue ) - 1] != '\'' ) {
+    value = rb_str_concat( value, rb_str_new2( "'" ) );
+    value = rb_str_concat( rb_str_new2( "'" ), value );
+  }
+  
+  rb_ary_store( rbparams, count, key );
+  rb_ary_store( rbparams, count + 1, value );
+  
+  count += 2;
+  return Qnil;
+}