ruby-xslt 0.9.2

data/parameters.h

@@ -0,0 +1,20 @@
+/**
+ * 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
+ */
+
+VALUE each_pair( VALUE );
+VALUE process_pair( VALUE, VALUE );

data/parser.c

@@ -0,0 +1,228 @@
+/**
+ * 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 "parser.h"
+
+extern VALUE cXSLT;
+
+xmlDocPtr parse_xml( char* xml, int iXmlType ) {
+  xmlDocPtr tXMLDocument = NULL;
+  
+#ifdef USE_ERROR_HANDLER
+  VALUE error_arr = rb_cvar_get(cXSLT, rb_intern("@@errors"));
+  int iInitialNumberOfErrors = RARRAY(error_arr)->len;
+#endif
+  
+  /** Act: Parse XML */
+  if( iXmlType == RUBY_XSLT_XMLSRC_TYPE_STR ) {
+    tXMLDocument = xmlParseMemory( xml, strlen( xml ) );
+  } else if( iXmlType == RUBY_XSLT_XMLSRC_TYPE_FILE ) {
+    tXMLDocument = xmlParseFile( xml );
+  }
+
+  if( tXMLDocument == NULL ) {
+    rb_raise( eXSLTParsingError, "XML parsing error" );
+    return( NULL );
+  }
+
+#ifdef USE_ERROR_HANDLER
+	if(RARRAY(error_arr)->len > iInitialNumberOfErrors) {
+	  rb_raise( eXSLTTransformationError, "Stylesheet transformation error" );
+	}
+#endif
+  
+  return( tXMLDocument );
+}
+
+xsltStylesheetPtr parse_xsl( char* xsl, int iXslType ) {
+  xsltStylesheetPtr tParsedXslt   = NULL;
+  xmlDocPtr         tXSLDocument  = NULL;
+  
+  /** Rem: For encoding */
+  xmlCharEncodingHandlerPtr encoder = NULL;
+  const xmlChar *encoding = NULL;
+  
+#ifdef USE_ERROR_HANDLER
+  VALUE error_arr = rb_cvar_get(cXSLT, rb_intern("@@errors"));
+  int iInitialNumberOfErrors = RARRAY(error_arr)->len;
+#endif
+  
+  /** Act: Encoding support */
+  xmlInitCharEncodingHandlers( );
+
+  /** Act: Parse XSL */
+  if( iXslType == RUBY_XSLT_XSLSRC_TYPE_STR ) {
+    tXSLDocument = xmlParseMemory( xsl, strlen( xsl ) );
+    if( tXSLDocument == NULL ) {
+      rb_raise( eXSLTParsingError, "XSL parsing error" );
+      return( NULL );
+    }
+
+    tParsedXslt = xsltParseStylesheetDoc( tXSLDocument );
+  } else if( iXslType == RUBY_XSLT_XSLSRC_TYPE_FILE ) {
+    tParsedXslt = xsltParseStylesheetFile( BAD_CAST xsl );
+  }
+
+  if( tParsedXslt == NULL ) {
+    rb_raise( eXSLTParsingError, "XSL Stylesheet parsing error" );
+    return( NULL );
+  }
+    
+  /** Act: Get encoding */
+  XSLT_GET_IMPORT_PTR( encoding, tParsedXslt, encoding )
+  encoder = xmlFindCharEncodingHandler((char *)encoding);
+  
+  if( encoding != NULL ) {
+    encoder = xmlFindCharEncodingHandler((char *)encoding);
+    if( (encoder != NULL) && (xmlStrEqual((const xmlChar *)encoder->name, (const xmlChar *) "UTF-8")) ) {
+      encoder = NULL;
+    }
+  }
+  
+#ifdef USE_ERROR_HANDLER
+	if(RARRAY(error_arr)->len > iInitialNumberOfErrors) {
+	  rb_raise( eXSLTTransformationError, "Stylesheet transformation error" );
+	}
+#endif
+
+  return( tParsedXslt );
+}
+
+/**
+ * xOut = parser( char *xml, int iXmlType, char *xslt, int iXslType, char **pxParams );
+ */
+char* parse( xsltStylesheetPtr tParsedXslt, xmlDocPtr tXMLDocument, char **pxParams ) {
+  xmlDocPtr tXMLDocumentResult  = NULL;
+  int iXMLDocumentResult;
+  xmlChar *tXMLDocumentResultString;
+  int tXMLDocumentResultLenght;
+
+#ifdef USE_ERROR_HANDLER
+  VALUE error_arr = rb_cvar_get(cXSLT, rb_intern("@@errors"));
+  int iInitialNumberOfErrors = RARRAY(error_arr)->len;
+#endif
+
+  tXMLDocumentResult = xsltApplyStylesheet( tParsedXslt, tXMLDocument, (const char**) pxParams );
+  if( tXMLDocumentResult == NULL ) {
+    rb_raise( eXSLTTransformationError, "Stylesheet transformation error" );
+    return( NULL );
+  }
+  
+  iXMLDocumentResult = xsltSaveResultToString( &tXMLDocumentResultString, &tXMLDocumentResultLenght, tXMLDocumentResult, tParsedXslt );
+
+  xmlFreeDoc(tXMLDocumentResult);
+  
+#ifdef USE_ERROR_HANDLER
+	if(RARRAY(error_arr)->len > iInitialNumberOfErrors) {
+	  rb_raise( eXSLTTransformationError, "Stylesheet transformation error" );
+	}
+#endif
+
+  return((char*)tXMLDocumentResultString);
+}
+
+/**
+ * vOut = object_to_string( VALUE object );
+ */
+VALUE object_to_string( VALUE object ) {
+  VALUE vOut = Qnil;
+    
+  switch( TYPE( object ) ) {
+    case T_STRING:
+      {
+        if( isFile( STR2CSTR( object ) ) == 0 ) {
+          vOut = object;
+        } else {
+          long iBufferLength;
+          long iCpt;
+          char *xBuffer;
+
+          FILE* fStream = fopen( STR2CSTR( object ), "r" );
+          if( fStream == NULL ) {
+            return( Qnil );
+          }
+
+          fseek( fStream, 0L, 2 );
+          iBufferLength = ftell( fStream );
+          xBuffer = (char *)malloc( (int)iBufferLength + 1 );
+          if( !xBuffer )
+            rb_raise( rb_eNoMemError, "Memory allocation error" );
+
+          xBuffer[iBufferLength] = 0;
+          fseek( fStream, 0L, 0 );
+          iCpt = fread( xBuffer, 1, (int)iBufferLength, fStream );
+          
+          if( iCpt != iBufferLength ) {
+            free( (char *)xBuffer );
+            rb_raise( rb_eSystemCallError, "Read file error" );
+          }
+
+          vOut = rb_str_new2( xBuffer );
+          free( xBuffer );
+
+          fclose( fStream );
+        }
+      }
+      break;
+    
+    case T_DATA:
+    case T_OBJECT: 
+      {
+        if( strcmp( getRubyObjectName( object ), "XML::Smart::Dom" ) == 0 || 
+            strcmp( getRubyObjectName( object ), "XML::Simple::Dom" ) == 0 ) {
+          vOut = rb_funcall( object, rb_intern( "to_s" ), 0 );
+        } else if ( strcmp( getRubyObjectName( object ), "REXML::Document" ) == 0 ) {  
+          vOut = rb_funcall( object, rb_intern( "to_s" ), 0 );
+        } else {
+          rb_raise( rb_eSystemCallError, "Can't read XML from object %s", getRubyObjectName( object ) );
+        }
+      }
+      break;
+    
+    default:
+      rb_raise( rb_eArgError, "XML object #0x%x not supported", TYPE( object ) );
+  }
+
+  return( vOut );
+}
+
+/**
+ * bOut = objectIsFile( VALUE object );
+ */
+int objectIsFile( VALUE object ) {
+  int bOut = 0;
+    
+  switch( TYPE( object ) ) {
+    case T_STRING:
+      {
+        if( isFile( STR2CSTR( object ) ) == 0 )
+          bOut = 0;
+        else
+          bOut = 1;
+      }
+      break;
+    
+    case T_DATA:
+    case T_OBJECT: 
+    default:
+      bOut = 0;
+  }
+
+  return( bOut );
+}

data/parser.h

@@ -0,0 +1,30 @@
+/**
+ * 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
+ */
+
+#ifndef __RUBY_XSLT_PARSER_H__
+#define __RUBY_XSLT_PARSER_H__
+extern int xmlLoadExtDtdDefaultValue;
+
+xmlDocPtr parse_xml( char* , int );
+xsltStylesheetPtr parse_xsl( char*, int );
+char* parse( xsltStylesheetPtr, xmlDocPtr, char ** );
+
+VALUE object_to_string( VALUE );
+int objectIsFile( VALUE );
+#endif
+

data/rb_utils.c

@@ -0,0 +1,30 @@
+/**
+ * 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 "rb_utils.h"
+
+char * getRubyObjectName( VALUE rb_Object ) {
+  VALUE klass = rb_funcall( rb_Object, rb_intern( "class" ), 0 );
+  return( STR2CSTR( rb_funcall( klass, rb_intern( "to_s" ), 0 ) ) );
+}
+
+int isFile( const char *filename ) {
+  struct stat stbuf;
+
+  if( stat( filename, &stbuf ) ) return 0;
+  return( ( (stbuf.st_mode & S_IFMT) == S_IFREG ) ? 1 : 0 );
+}

data/rb_utils.h

@@ -0,0 +1,34 @@
+/**
+ * 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
+ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_RB_UTILS_H__
+#define __RUBY_RB_UTILS_H__
+
+#include <ruby.h>
+#include <rubyio.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+
+char * getRubyObjectName( VALUE );
+int isFile( const char *filename );
+
+#endif

data/ruby-xslt.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name = %q{ruby-xslt}
+  s.version = "0.9.2"
+  s.date = %q{2005-11-17}
+  s.summary = %q{A Ruby class for processing XSLT}
+  s.email = %q{greg@webtime-project.net}
+  s.homepage = %q{http://raa.ruby-lang.org/project/ruby-xslt/}
+  s.description = %q{Ruby/XSLT is a simple XSLT class based on libxml <http://xmlsoft.org/> and libxslt <http://xmlsoft.org/XSLT/>}
+  s.has_rdoc = true
+  s.authors = ["Gregoire Lejeune"]
+  candidates = Dir.glob("{.,debug,examples,tests}/*")
+  s.files = candidates.delete_if do |item|
+                item.include?("CVS") || item.include?("rdoc")
+            end
+  s.test_files = ["tests/test.rb"]
+  s.rdoc_options = ["--title", "Ruby/XSLT", "--main", "README", "--line-numbers"]
+  s.extra_rdoc_files = ["README", "AUTHORS", "COPYING", "ChangeLog"]
+  s.extensions = ["extconf.rb"]
+end

data/tests/t.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<test>This is a test file</test>

data/tests/t.xsl

@@ -0,0 +1,6 @@
+<?xml version="1.0" ?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+  <xsl:template match="/">
+    <xsl:apply-templates />
+  </xsl:template>
+</xsl:stylesheet> 

data/tests/test.rb

@@ -0,0 +1,125 @@
+#!ruby
+
+require "test/unit"
+require "../xslt"
+
+# Test::Unit suite for flattenx extension
+#
+# $Id: test.rb,v 1.4 2005/11/14 00:22:27 whateley Exp $
+# $Author: whateley $
+
+class XsltTest < Test::Unit::TestCase
+  def setup 
+    if @xslt.nil? == true
+      @xslt = XML::XSLT.new( )
+      @testOut = "<?xml version=\"1.0\"?>\nThis is a test file\n"
+      @xml_simple = true
+      begin
+        require "xml/simple"
+      rescue LoadError => e
+        @xml_simple = false
+      end
+      
+      @xml_smart = true
+      begin
+        require "xml/smart"
+      rescue LoadError => e
+        @xml_smart = false
+      end
+    end
+  end
+  
+  def test_instance
+    assert_instance_of( XML::XSLT, @xslt )
+  end
+  
+  def test_from_file
+    @xslt.xml = "t.xml"
+    @xslt.xsl = "t.xsl"
+    out = @xslt.serve
+    assert_equal( @testOut, out )
+  end
+
+  def test_from_data
+    @xslt.xml = IO::readlines( "t.xml" ).join
+    @xslt.xsl = IO::readlines( "t.xsl" ).join
+    out = @xslt.serve
+    assert_equal( @testOut, out )
+  end
+  
+  def test_from_simple
+    if @xml_simple
+      require 'xml/simple'
+      @xslt.xml = XML::Simple.open( "t.xml" )
+      @xslt.xsl = XML::Simple.open( "t.xsl" )
+      out = @xslt.serve()
+      assert_equal( @testOut, out )
+    else
+      assert( true )
+    end
+  end
+
+  def test_from_smart
+    if @xml_smart
+      require 'xml/smart'
+      @xslt.xml = XML::Smart.open( "t.xml" )
+      @xslt.xsl = XML::Smart.open( "t.xsl" )
+      out = @xslt.serve()
+      assert_equal( @testOut, out )
+    else
+      assert( true ) 
+    end
+  end
+
+  def test_from_rexml
+    require 'rexml/document'
+    @xslt.xml = REXML::Document.new File.open( "t.xml" )
+    @xslt.xsl = REXML::Document.new File.open( "t.xsl" )
+    out = @xslt.serve()
+    assert_equal( @testOut, out )
+  end
+
+  def test_error_1
+    begin
+      @xslt.xsl = "nil"
+    rescue => e
+      assert_instance_of( XML::XSLT::ParsingError, e )
+    end
+  end
+
+  def test_error_2
+    begin
+      @xslt.xml = "nil"
+    rescue => e
+      assert_instance_of( XML::XSLT::ParsingError, e )
+    end
+  end
+
+  def test_error_3
+    begin
+      @xslt.xml = "t.xsl"
+    rescue => e
+      assert_instance_of( XML::XSLT::ParsingError, e )
+    end
+  end
+
+  def test_base_uri_1
+    @xslt.xml = "<test/>"
+    xsl = "subdir/test.xsl"
+
+    # the base URI of a loaded XSL file should be the URI of that file
+    assert_nothing_raised( XML::XSLT::ParsingError ) do
+      @xslt.xsl = xsl
+    end
+  end
+
+  def test_base_uri_2
+    @xslt.xml = "<test/>"
+    xsl = File.read("subdir/test.xsl")
+    
+    # a file loaded from memory has no base URI, so this should fail
+    assert_raises( XML::XSLT::ParsingError ) do
+      @xslt.xsl = xsl
+    end
+  end
+end