libxslt-ruby 0.6.0 → 0.7.0

data/ext/libxslt/libxslt.h

@@ -16,11 +16,6 @@
 #include <libxslt/xsltutils.h>
 #include <libexslt/exslt.h>
 
-// Includes from libxml-ruby
-#include <libxml/ruby_libxml.h>
-#include <libxml/ruby_xml_document.h>
-
-
 #include "ruby_xslt_stylesheet.h"
 #include "ruby_xslt_transform_context.h"
 
@@ -29,21 +24,9 @@
 #define RUBY_LIBXSLT_SRC_TYPE_NULL    0
 #define RUBY_LIBXSLT_SRC_TYPE_FILE    1
 
-extern VALUE mXML;
-//extern VALUE cXMLDocument;
-
 extern VALUE cXSLT;
 extern VALUE eXMLXSLTStylesheetRequireParsedDoc;
 
-typedef struct ruby_xslt {
-  int data_type;
-  void *data;
-  VALUE str;
-  VALUE xml_doc_obj;
-  VALUE ctxt;
-  xsltStylesheetPtr xsp;
-} ruby_xslt;
-
 #if ((RUBY_LIBXML_VER_MAJ != RUBY_LIBXSLT_VER_MAJ) || (RUBY_LIBXML_VER_MIN != RUBY_LIBXSLT_VER_MIN))
 #error "Incompatible LibXML-Ruby headers - please install same major/micro version"
 #endif

data/ext/libxslt/ruby_xslt_stylesheet.c

@@ -5,79 +5,144 @@
 #include "libxslt.h"
 #include "ruby_xslt_stylesheet.h"
 
-VALUE cXSLTStylesheet;
+/*
+ * Document-class: XSLT::Stylesheet
+ * 
+ * The XSLT::Stylesheet represents a XSL stylesheet that
+ * can be used to transform an XML document.  For usage information
+ * refer to XSLT::Stylesheet#apply
+ *
+*/
 
-/* call-seq: 
- *   sheet.apply => (true|false)
- * 
- * Apply this stylesheet transformation to the source
- * document.
- */
-VALUE
-ruby_xslt_stylesheet_apply(int argc, VALUE *argv, VALUE self) {
-  ruby_xslt_stylesheet *xss;
-  ruby_xml_document_t *rxd;
-  const char **params;
-  VALUE parameter, tmp;
-  int i, len;
 
-  Data_Get_Struct(self, ruby_xslt_stylesheet, xss);
-
-  if (NIL_P(xss->xml_doc_obj))
-    rb_raise(rb_eArgError, "Need a document object");
+VALUE cXSLTStylesheet;
 
-  Data_Get_Struct(xss->xml_doc_obj, ruby_xml_document_t, rxd);
+VALUE
+ruby_xslt_stylesheet_document_klass() {
+  VALUE mXML = rb_const_get(rb_cObject, rb_intern("XML"));
+  return rb_const_get(mXML, rb_intern("Document"));
+}
 
-  params = NULL;
 
-  switch(argc) {
-  case 0:
-    break;
-  case 1:
-    parameter = argv[0];
-#if RUBY_VERSION_CODE >= 180
-    if (TYPE(parameter) == T_HASH) {
-      /* Convert parameter to an array */
-      parameter = rb_hash_to_a(parameter);
-    }
-#endif
-
-    if (TYPE(parameter) == T_ARRAY) {
-      /* A hash is better than an array, but we can live with an array of arrays */
-      len = RARRAY(parameter)->len;
-      params = (void *)ALLOC_N(char *, (len * 2) + 2);
-      for (i=0; i < RARRAY(parameter)->len; i++) {
-	tmp = RARRAY(parameter)->ptr[i];
+void
+ruby_xslt_stylesheet_free(xsltStylesheetPtr xstylesheet) {
+  xsltFreeStylesheet(xstylesheet);
+}
 
-	Check_Type(tmp, T_ARRAY);
-	Check_Type(RARRAY(tmp)->ptr[0], T_STRING);
-	Check_Type(RARRAY(tmp)->ptr[1], T_STRING);
+VALUE
+ruby_xslt_stylesheet_alloc(VALUE klass) {
+  return Data_Wrap_Struct(cXSLTStylesheet,
+                          NULL, ruby_xslt_stylesheet_free,
+                          NULL);
+}
+                          
 
-	params[2*i] = RSTRING(RARRAY(tmp)->ptr[0])->ptr;
-	params[2*i+1] = RSTRING(RARRAY(tmp)->ptr[1])->ptr;
-      }
-      params[2*i] = params[2*i+1] = 0;
-    } else {
-      /* I should test to see if the object responds to to_a and to_h before calling this, but oh well */
-      rb_raise(rb_eTypeError, "xslt_stylesheet_appy: expecting a hash or an array of arrays as a parameter");
-    }
+/* call-seq:
+ *    XSLT::Stylesheet.new(document) -> XSLT::Stylesheet
+ * 
+ * Creates a new XSLT stylesheet based on the provided document.
+ *
+ *  stylesheet_doc = XML::Document.file('stylesheet_file')
+ *  stylesheet = XSLT::Stylesheet.new(stylesheet_doc)
+ *
+ */
+VALUE
+ruby_xslt_stylesheet_initialize(VALUE self, VALUE document) {
+  ruby_xml_document_t *rdocument;
+
+  if (!rb_obj_is_kind_of(document, ruby_xslt_stylesheet_document_klass()))
+    rb_raise(rb_eTypeError, "Must pass in an XML::Document instance.");
+    
+  Data_Get_Struct(document, ruby_xml_document_t, rdocument);
+  DATA_PTR(self) = xsltParseStylesheetDoc(rdocument->doc);
+  return self;
+}
 
-    break;
-  default:
-    rb_raise(rb_eArgError, "wrong number of arguments (0 or 1)");
+/* Helper method to convert Ruby params to C params */
+char **
+ruby_xslt_coerce_params(VALUE params) {
+  char** result;
+  size_t length;
+  size_t i;
+
+  length = RARRAY(params)->len;
+  result = ALLOC_N(char *, length + 2);
+
+  for (i=0; i<length; i++) {
+    VALUE str = rb_String(RARRAY(params)->ptr[i]);
+    int strLen = RSTRING(str)->len;
+    result[i] = ALLOC_N(char, strLen + 1);
+    memset(result[i], 0, strLen + 1);
+    strncpy(result[i], RSTRING(str)->ptr, strLen);
   }
+  
+  /* Null terminate the array - need to empty elements */
+  result[i] = NULL;
+  result[i+1] = NULL;
+  
+  return result;
+}  
+   
 
-  xss->parsed = ruby_xml_document_wrap(xsltApplyStylesheet(xss->xsp,
-							   rxd->doc, params));
-
-  if (params) {
-    ruby_xfree(params);
+/* call-seq: 
+ *   stylesheet.apply(document, {params}) -> XML::Document
+ * 
+ * Apply this stylesheet transformation to the provided document.
+ * This method may be invoked multiple times.
+ *
+ * Params:
+ * 
+ * document = An instance of an XML::Document
+ * params = An optional hash table that specifies the values
+ *          for xsl:param values embedded in the stylesheet.
+ *
+ * Example:
+ * 
+ *  stylesheet_doc = XML::Document.file('stylesheet_file')
+ *  stylesheet = XSLT::Stylesheet.new(stylesheet_doc)
+ *
+ *  xml_doc = XML::Document.file('xml_file')
+ *  result = stylesheet.apply(xml_doc)
+ *  result = stylesheet.apply(xml_doc, {:foo => 'bar'})
+ */
+VALUE
+ruby_xslt_stylesheet_apply(int argc, VALUE *argv, VALUE self) {
+  ruby_xml_document_t *rdocument;
+  xsltStylesheetPtr xstylesheet;
+  xmlDocPtr result;
+  VALUE document;
+  VALUE params;
+  int i;
+  
+  char** pParams;
+
+  if (argc > 2 || argc < 1)
+    rb_raise(rb_eArgError, "wrong number of arguments (need 1 or 2)");
+    
+  document = argv[0];
+  
+  if (!rb_obj_is_kind_of(document, ruby_xslt_stylesheet_document_klass()))
+    rb_raise(rb_eTypeError, "Must pass in an XML::Document instance.");
+
+  /* Make sure params is a flat array */
+  params = (argc == 2 ? argv[1]: Qnil);
+  params = rb_Array(params);
+  rb_funcall(params, rb_intern("flatten!"), 0);
+  pParams = ruby_xslt_coerce_params(params);
+  
+  Data_Get_Struct(document, ruby_xml_document_t, rdocument);
+  Data_Get_Struct(self, xsltStylesheet, xstylesheet);
+  
+  result = xsltApplyStylesheet(xstylesheet, rdocument->doc, pParams);
+  
+  /* Free allocated array of *chars.  Note we don't have to
+     free the last array item since its set to NULL. */
+  for (i=0; i<(RARRAY(params)->len); i++) {
+    ruby_xfree(pParams[i]);
   }
-
-  if (xss->parsed == Qnil)
-    return(Qfalse);
-  else
-    return(Qtrue);
+  ruby_xfree(pParams);
+    
+  return ruby_xml_document_wrap(result);
 }
 
 
@@ -90,7 +155,7 @@ ruby_xslt_stylesheet_apply(int argc, VALUE *argv, VALUE self) {
  * is not the case, a warning is triggered and the method returns
  * false.
  */
-VALUE
+/*VALUE
 ruby_xslt_stylesheet_debug(int argc, VALUE *argv, VALUE self) {
 #ifdef LIBXML_DEBUG_ENABLED
   OpenFile *fptr;
@@ -130,48 +195,7 @@ ruby_xslt_stylesheet_debug(int argc, VALUE *argv, VALUE self) {
   return(Qfalse);
 #endif
 }
-
-
-void
-ruby_xslt_stylesheet_free(ruby_xslt_stylesheet *xss) {
-  if (xss->xsp != NULL) {
-    xsltFreeStylesheet(xss->xsp);
-    xss->xsp = NULL;
-  }
-
-  ruby_xfree(xss);
-}
-
-
-void
-ruby_xslt_stylesheet_mark(ruby_xslt_stylesheet *xss) {
-  if (!NIL_P(xss->parsed))      rb_gc_mark(xss->parsed);
-  if (!NIL_P(xss->xml_doc_obj)) rb_gc_mark(xss->xml_doc_obj);
-
-  switch (xss->data_type) {
-  case RUBY_LIBXSLT_SRC_TYPE_FILE:
-    if (xss->data != NULL)
-      rb_gc_mark((VALUE)xss->data);
-    break;
-  }
-}
-
-
-VALUE
-ruby_xslt_stylesheet_new(VALUE class, xsltStylesheetPtr xsp) {
-  ruby_xslt_stylesheet *xss;
-  VALUE rval;
-
-  rval=Data_Make_Struct(cXSLTStylesheet,ruby_xslt_stylesheet,ruby_xslt_stylesheet_mark,
-			ruby_xslt_stylesheet_free,xss);
-  xss->xsp = xsp;
-  xss->xml_doc_obj = Qnil;
-  xss->parsed = Qnil;
-  xss->data_type = RUBY_LIBXSLT_SRC_TYPE_NULL;
-  xss->data = NULL;
-
-  return rval;
-}
+*/
 
 // TODO should this automatically apply the sheet if not already,
 //      given that we're unlikely to do much else with it?
@@ -183,7 +207,7 @@ ruby_xslt_stylesheet_new(VALUE class, xsltStylesheetPtr xsp) {
  * stream (an IO instance, defaults to $stdout). You *must* call
  * +apply+ before this method or an exception will be raised.
  */
-VALUE
+/*VALUE
 ruby_xslt_stylesheet_print(int argc, VALUE *argv, VALUE self) {
   OpenFile *fptr;
   VALUE io;
@@ -219,80 +243,18 @@ ruby_xslt_stylesheet_print(int argc, VALUE *argv, VALUE self) {
   bytes = xsltSaveResultToFile(out, parsed->doc, xss->xsp);
 
   return(INT2NUM(bytes));
-}
-
-// TODO this, too. Either way, to_s probably should have prereqs
-//      like this, for one thing it makes IRB use tricky...
-
-/* call-seq: 
- *   sheet.to_s => "result"
- * 
- * Obtain the result of the transform as a string. You *must* call
- * +apply+ before this method or an exception will be raised.
- */
-VALUE
-ruby_xslt_stylesheet_to_s(VALUE self) {
-  ruby_xml_document_t *parsed;
-  ruby_xslt_stylesheet *xss;
-  xmlChar *str;
-  int len;
-
-  Data_Get_Struct(self, ruby_xslt_stylesheet, xss);
-  if (NIL_P(xss->parsed))
-    rb_raise(eXMLXSLTStylesheetRequireParsedDoc, "must have a parsed XML result");
-  Data_Get_Struct(xss->parsed, ruby_xml_document_t, parsed);
-  if (parsed->doc == NULL)
-    return(Qnil);
-
-  xsltSaveResultToString(&str, &len, parsed->doc, xss->xsp);
-  if (str == NULL)
-    return(Qnil);
-  else
-    return(rb_str_new((const char*)str,len));
-}
+}*/
 
 
-
-/* call-seq: 
- *   sheet.save(io) => true
- * 
- * Save the result of the transform to the supplied open
- * file (an IO instance). You *must* call +apply+ before 
- * this method or an exception will be raised.
- */
-VALUE
-ruby_xslt_stylesheet_save(VALUE self, VALUE io) {
-  ruby_xml_document_t *parsed;
-  ruby_xslt_stylesheet *xss;
-  OpenFile *fptr;
-
-  if (rb_obj_is_kind_of(io, rb_cIO) == Qfalse)
-    rb_raise(rb_eArgError, "Only accept IO objects for saving");
-
-  GetOpenFile(io, fptr);
-
-  Data_Get_Struct(self, ruby_xslt_stylesheet, xss);
-  Data_Get_Struct(xss->parsed, ruby_xml_document_t, parsed);
-
-  xsltSaveResultToFile(fptr->f, parsed->doc, xss->xsp);
-
-  return(Qtrue);
-}
-
 #ifdef RDOC_NEVER_DEFINED
-  mXML = rb_define_module("XML");
-  cXSLT = rb_define_class_under(mXML, "XSLT", rb_cObject);
+  cXSLT = rb_define_module("XSLT");
+  cXSLTStylesheet = rb_define_class_under(cXSLT, "Stylesheet", rb_cObject);
 #endif
 
 void
 ruby_init_xslt_stylesheet(void) {
   cXSLTStylesheet = rb_define_class_under(cXSLT, "Stylesheet", rb_cObject);
-  eXMLXSLTStylesheetRequireParsedDoc =
-    rb_define_class_under(cXSLTStylesheet, "RequireParsedDoc", rb_eException);
-
+  rb_define_alloc_func(cXSLTStylesheet, ruby_xslt_stylesheet_alloc);
+  rb_define_method(cXSLTStylesheet, "initialize", ruby_xslt_stylesheet_initialize, 1);
   rb_define_method(cXSLTStylesheet, "apply", ruby_xslt_stylesheet_apply, -1);
-  rb_define_method(cXSLTStylesheet, "debug", ruby_xslt_stylesheet_debug, -1);
-  rb_define_method(cXSLTStylesheet, "print", ruby_xslt_stylesheet_print, -1);
-  rb_define_method(cXSLTStylesheet, "to_s", ruby_xslt_stylesheet_to_s, 0);
-  rb_define_method(cXSLTStylesheet, "save", ruby_xslt_stylesheet_save, 1);
 }

data/ext/libxslt/ruby_xslt_stylesheet.h

@@ -5,17 +5,12 @@
 #ifndef __RUBY_LIBXSLT_STYLESHEET__
 #define __RUBY_LIBXSLT_STYLESHEET__
 
-extern VALUE cXSLTStylesheet;
+// Includes from libxml-ruby
+#include <libxml/ruby_libxml.h>
+#include <libxml/ruby_xml_document.h>
 
-typedef struct ruby_xslt_stylesheet {
-  int data_type;
-  void *data;
-  VALUE parsed;      /* XML::Document # parsed xml document after xsl apply */
-  VALUE xml_doc_obj; /* XML::Document */
-  xsltStylesheetPtr xsp;
-} ruby_xslt_stylesheet;
+extern VALUE cXSLTStylesheet;
 
 void ruby_init_xslt_stylesheet(void);
-VALUE ruby_xslt_stylesheet_new(VALUE class, xsltStylesheetPtr xsp);
 
-#endif /* __RUBY_LIBXSLT_STYLESHEET__ */
+#endif

data/ext/libxslt/ruby_xslt_transform_context.c

@@ -5,6 +5,9 @@
 #include "libxslt.h"
 #include "ruby_xslt_transform_context.h"
 
+
+/* :nodoc: */
+
 VALUE cXSLTTransformContext;
 
 void
@@ -50,8 +53,8 @@ ruby_xslt_transform_context_new3(VALUE xslt) {
 }
 
 #ifdef RDOC_NEVER_DEFINED
-  mXML = rb_define_module("XML");
-  cXSLT = rb_define_class_under(mXML, "XSLT", rb_cObject);
+  cXSLT = rb_define_module("XSLT");
+  cXSLTTransformContext = rb_define_class_under(cXSLT, "TransformContext", rb_cObject);
 #endif
 
 void

data/ext/libxslt/version.h

@@ -1,5 +1,5 @@
-#define RUBY_LIBXSLT_VERSION  "0.6.0"
+#define RUBY_LIBXSLT_VERSION  "0.7.0"
 #define RUBY_LIBXSLT_VERNUM   0
 #define RUBY_LIBXSLT_VER_MAJ  0
-#define RUBY_LIBXSLT_VER_MIN  6
+#define RUBY_LIBXSLT_VER_MIN  7
 #define RUBY_LIBXSLT_VER_MIC  0

data/lib/deprecated.rb

@@ -0,0 +1,66 @@
+# :enddoc:
+# These classes provide provide backwards compatibility with 
+# versions of libxslt-ruby prior to version 0.7.0
+
+module XML
+  module XSLT
+    MAX_DEPTH = ::XSLT::MAX_DEPTH
+    MAX_SORT = ::XSLT::MAX_SORT
+    ENGINE_VERSION = ::XSLT::ENGINE_VERSION
+    LIBXSLT_VERSION = ::XSLT::LIBXSLT_VERSION
+    LIBXML_VERSION = ::XSLT::LIBXML_VERSION
+    XSLT_NAMESPACE = ::XSLT::XSLT_NAMESPACE
+    DEFAULT_VENDOR = ::XSLT::DEFAULT_VENDOR
+    DEFAULT_VERSION = ::XSLT::DEFAULT_VERSION
+    DEFAULT_URL = ::XSLT::DEFAULT_URL
+    NAMESPACE_LIBXSLT = ::XSLT::NAMESPACE_LIBXSLT
+    NAMESPACE_NORM_SAXON = ::XSLT::NAMESPACE_NORM_SAXON
+    NAMESPACE_SAXON = ::XSLT::NAMESPACE_SAXON
+    NAMESPACE_XT = ::XSLT::NAMESPACE_XT
+    NAMESPACE_XALAN = ::XSLT::NAMESPACE_XALAN
+    
+    def self.new
+      Stylesheet.new(nil)
+    end
+    
+    def self.file(filename)
+      doc = Document.file(filename)
+      stylesheet = ::XSLT::Stylesheet.new(doc)
+      
+      result = Stylesheet.new(stylesheet)
+      result.filename = filename
+      result
+    end
+    
+    class Stylesheet
+      attr_accessor :doc, :filename
+      
+      def initialize(stylesheet)
+        @stylesheet = stylesheet
+      end
+      
+      def filename=(value)
+        @doc = Document.file(value)
+        @filename = value
+      end
+      
+      def parse
+        self
+      end
+      
+      def apply
+        @result = @stylesheet.apply(@doc)
+      end
+      
+      def save(filename)
+        raise(ArgumentError) unless @result
+        @result.save(filename)
+      end
+      
+      def print(filename)
+        raise(ArgumentError) unless @result
+      end
+    end
+  end
+end
+