html-template-pro 0.0.1

data/ext/html/template/internal/tagstack.h

@@ -0,0 +1,30 @@
+#ifndef _TAGSTACK_H
+#define _TAGSTACK_H	1
+
+struct tagstack_entry {
+  int tag;		/* code of tag */
+  int value;		/* if (true/false) - used in else */
+  int vcontext;		/* visibility context of the tag (visible/unvisible) */
+  const char* position;	/* start of tag; useful for loops */
+};
+
+static 
+void tagstack_init(struct tagstack* tagstack);
+static 
+void tagstack_free(struct tagstack* tagstack);
+static 
+void tagstack_push(struct tagstack* tagstack, struct tagstack_entry);
+static 
+struct tagstack_entry tagstack_pop(struct tagstack* tagstack);
+static 
+struct tagstack_entry* tagstack_top(struct tagstack* tagstack);
+static 
+int tagstack_notempty(struct tagstack* tagstack);
+
+#endif /* tagstack.h */
+
+/*
+ * Local Variables:
+ * mode: c 
+ * End: 
+ */

data/ext/html/template/internal/tagstack.inc

@@ -0,0 +1,65 @@
+#include <stdlib.h>
+#include <assert.h>
+
+#define INIT_ENV_DEPTH 256
+
+static 
+void tagstack_init(struct tagstack* tagstack) {
+  tagstack->depth=INIT_ENV_DEPTH;
+  tagstack->pos=-1;
+  tagstack->entry=(struct tagstack_entry*) malloc (tagstack->depth * sizeof(struct tagstack_entry));
+}
+
+static 
+void tagstack_free(struct tagstack* tagstack) {
+  tagstack->depth=-1;
+  tagstack->pos=-1;
+  free(tagstack->entry);
+}
+
+static 
+int tagstack_notempty(struct tagstack* tagstack) {
+  return tagstack->pos>=0;
+}
+
+/*
+static 
+void tagstack_entry_debug(struct tagstack_entry item) {
+ tmpl_log(TMPL_LOG_DEBUG,"vcontext = %d value=%d\n",item.vcontext,item.value);
+}
+*/
+
+static 
+struct tagstack_entry* tagstack_top(struct tagstack* tagstack) {
+  return tagstack->entry+tagstack->pos;
+}
+
+static 
+struct tagstack_entry tagstack_pop(struct tagstack* tagstack) {
+  if (tagstack->pos<0) {
+    tmpl_log(TMPL_LOG_ERROR,"stack underflow:tags stack is empty\n");
+    tagstack->pos=0;
+    if (tagstack->depth<0) {
+      tmpl_log(TMPL_LOG_ERROR,"FATAL:stack error:tags stack is uninitialized\n");
+      tagstack_init(tagstack);
+    }
+  }
+  return *(tagstack->entry+ tagstack->pos--);
+}
+
+static 
+void tagstack_push(struct tagstack* tagstack, struct tagstack_entry item) {
+  /* overflow check */
+  if (++(tagstack->pos)>=tagstack->depth) {
+    if (tagstack->depth<INIT_ENV_DEPTH) tagstack->depth=INIT_ENV_DEPTH;
+    tagstack->depth*=2;
+    tagstack->entry=(struct tagstack_entry*) realloc (tagstack->entry, tagstack->depth * sizeof(struct tagstack_entry));
+  }
+  *(tagstack->entry+tagstack->pos)=item;
+}
+
+/* 
+ * Local Variables:
+ * mode: c 
+ * End: 
+ */

data/ext/html/template/internal/tmpllog.c

@@ -0,0 +1,62 @@
+/* -*- c -*- 
+ * File: log.c
+ * Author: Igor Vlasenko <vlasenko@imath.kiev.ua>
+ * Created: Thu Sep  1 17:18:16 2005
+ *
+ * $Id$
+ */
+
+/* based on FFmpeg av_log API */
+
+#include <stdio.h>
+#include <string.h>
+#include "tmpllog.h"
+
+static int tmpl_log_level = TMPL_LOG_ERROR;
+
+static void 
+tmpl_log_default_callback(int level, const char* fmt, va_list vl)
+{
+    if(level>tmpl_log_level) return;
+    vfprintf(stderr, fmt, vl);
+}
+
+static void (*tmpl_log_callback)(int, const char*, va_list) = tmpl_log_default_callback;
+
+TMPLPRO_LOCAL
+void 
+tmpl_log(int level, const char *fmt, ...)
+{
+    va_list vl;
+    va_start(vl, fmt);
+    tmpl_vlog(level, fmt, vl);
+    va_end(vl);
+}
+
+TMPLPRO_LOCAL
+void 
+tmpl_vlog(int level, const char *fmt, va_list vl)
+{
+    tmpl_log_callback(level, fmt, vl);
+}
+
+TMPLPRO_LOCAL
+int 
+tmpl_log_get_level(void)
+{
+    return tmpl_log_level;
+}
+
+TMPLPRO_LOCAL
+void 
+tmpl_log_set_level(int level)
+{
+    tmpl_log_level = level;
+}
+
+TMPLPRO_LOCAL
+void 
+tmpl_log_set_callback(void (*callback)(int, const char*, va_list))
+{
+    tmpl_log_callback = callback;
+}

data/ext/html/template/internal/tmpllog.h

@@ -0,0 +1,27 @@
+/* -*- c -*- 
+ * File: log.h
+ * Author: Igor Vlasenko <vlasenko@imath.kiev.ua>
+ * Created: Thu Sep  1 17:17:37 2005
+ *
+ * $Id$
+ */
+
+/* based on FFmpeg av_log API */
+
+#include "pabidecl.h"
+#include "pmiscdef.h"
+#include <stdarg.h>
+
+#define TMPL_LOG_QUIET -1
+#define TMPL_LOG_ERROR 0
+#define TMPL_LOG_INFO 1
+#define TMPL_LOG_DEBUG 2
+#define TMPL_LOG_DEBUG2 3
+
+extern TMPLPRO_LOCAL void tmpl_log(int level, const char *fmt, ...) FORMAT_PRINTF(2,3);
+
+extern TMPLPRO_LOCAL void tmpl_vlog(int level, const char *fmt, va_list);
+extern TMPLPRO_LOCAL  int tmpl_log_get_level(void);
+extern TMPLPRO_LOCAL void tmpl_log_set_level(int);
+extern TMPLPRO_LOCAL void tmpl_log_set_callback(void (*)(int, const char*, va_list));
+

data/ext/html/template/internal/tmplpro.h

@@ -0,0 +1,218 @@
+/*! \file tmplpro.h
+    \brief libhtmltmplpro API header.
+    
+    An official libhtmltmplpro API header.
+
+    \author Igor Vlasenko <vlasenko@imath.kiev.ua>
+*/
+
+#ifndef _TMPLPRO_H
+#define _TMPLPRO_H	1
+
+#include "pabidecl.h"
+#include "pstring.h"
+#include "exprtype.h"
+#include "pabstract.h"
+#include "proparam.h"
+
+/*
+ * generic load/first use library and unload/last use library hooks.
+ */
+TMPLPRO_API void APICALL tmplpro_procore_init(void);
+TMPLPRO_API void APICALL tmplpro_procore_done(void);
+
+TMPLPRO_API const char* APICALL tmplpro_version(void);
+
+struct tmplpro_param;
+/* 
+ * Constructor and destructor of tmplpro_param. 
+ * Note that struct tmplpro_param is not part of the interface
+ * and is subject to change without notice.
+ */
+TMPLPRO_API struct tmplpro_param* APICALL tmplpro_param_init(void);
+TMPLPRO_API void APICALL tmplpro_param_free(struct tmplpro_param*);
+
+TMPLPRO_API int APICALL tmplpro_exec_tmpl (struct tmplpro_param*);
+TMPLPRO_API MPSTRING APICALL tmplpro_tmpl2pstring (struct tmplpro_param *param, int *exitcode);
+
+
+TMPLPRO_API void APICALL tmplpro_clear_option_param_map(struct tmplpro_param *param);
+TMPLPRO_API int APICALL tmplpro_count_option_param_map(struct tmplpro_param *param);
+TMPLPRO_API int APICALL tmplpro_push_option_param_map(struct tmplpro_param *param, ABSTRACT_MAP* map, EXPR_int64 flags);
+
+struct exprval;
+TMPLPRO_API void APICALL tmplpro_set_expr_as_int64 (ABSTRACT_EXPRVAL*,EXPR_int64);
+TMPLPRO_API void APICALL tmplpro_set_expr_as_double (ABSTRACT_EXPRVAL*,double);
+TMPLPRO_API void APICALL tmplpro_set_expr_as_string (ABSTRACT_EXPRVAL*, const char*);
+TMPLPRO_API void APICALL tmplpro_set_expr_as_pstring (ABSTRACT_EXPRVAL*,PSTRING);
+TMPLPRO_API void APICALL tmplpro_set_expr_as_null (ABSTRACT_EXPRVAL*);
+
+TMPLPRO_API int  APICALL tmplpro_get_expr_type (ABSTRACT_EXPRVAL*);
+TMPLPRO_API EXPR_int64 APICALL tmplpro_get_expr_as_int64 (ABSTRACT_EXPRVAL*);
+TMPLPRO_API double APICALL tmplpro_get_expr_as_double (ABSTRACT_EXPRVAL*);
+TMPLPRO_API PSTRING APICALL tmplpro_get_expr_as_pstring (ABSTRACT_EXPRVAL*);
+
+
+#define ASK_NAME_DEFAULT	0
+#define ASK_NAME_AS_IS		1
+#define ASK_NAME_LOWERCASE	2
+#define ASK_NAME_UPPERCASE	4
+#define ASK_NAME_MASK	(ASK_NAME_AS_IS|ASK_NAME_LOWERCASE|ASK_NAME_UPPERCASE)
+/* future compatibility: not yet implemented */
+#define ASK_NAME_CAPITALIZED	8
+#define ASK_NAME_LCFIRST	16
+#define ASK_NAME_UCFIRST	32
+/* define ASK_NAME_MASK	(ASK_NAME_AS_IS|ASK_NAME_LOWERCASE|ASK_NAME_UPPERCASE|ASK_NAME_CAPITALIZED|ASK_NAME_LCFIRST|ASK_NAME_UCFIRST) */
+
+#endif /* tmplpro.h */
+
+
+
+/*! \fn void tmplpro_procore_init(void);
+    \brief generic load library/first use initializer.
+
+    Initializer of global internal structures.
+    Should be called before first use of the library.
+
+    \warning May not be thread safe. Should be called once.
+*/
+
+/*! \fn void tmplpro_procore_done(void);
+    \brief generic load/first use library and unload/last use library hooks.
+
+    Deinitializer of global internal structures.
+    Should be called before unloading the library.
+
+    \warning May not be thread safe. Should be called once.
+*/
+
+/*! \fn const char* tmplpro_version(void);
+    \brief version of the library
+    \return version string.
+*/
+
+/*! \fn struct tmplpro_param* tmplpro_param_init(void);
+    \brief Constructor of tmplpro_param.
+*/
+
+/*! \fn void tmplpro_param_free(struct tmplpro_param*);
+    \brief Destructor of tmplpro_param.
+*/
+
+/*! \fn int tmplpro_exec_tmpl (struct tmplpro_param*);
+    \brief main method of libhtmltmplpro.
+*/
+
+/*! \fn MPSTRING tmplpro_tmpl2pstring (struct tmplpro_param*, int* exitcode);
+    \brief main method of libhtmltmplpro. Returns processed template as a C string.
+
+    Note that caller's responsibility is to free the returned memory.
+*/
+
+/*! \fn void tmplpro_set_expr_as_int64 (ABSTRACT_EXPRVAL*,EXPR_int64);
+    \brief method to return int64 value from callback of call_expr_userfnc_functype.
+
+    It should only be used in a callback of call_expr_userfnc_functype.
+*/
+
+/*! \fn void tmplpro_set_expr_as_double (ABSTRACT_EXPRVAL*,double);
+    \brief method to return double value from callback of call_expr_userfnc_functype.
+
+    It should only be used in a callback of call_expr_userfnc_functype.
+*/
+
+/*! \fn void tmplpro_set_expr_as_string (ABSTRACT_EXPRVAL*,char*);
+    \brief method to return C string value from callback of call_expr_userfnc_functype.
+
+    It should only be used in a callback of call_expr_userfnc_functype.
+*/
+
+/*! \fn void tmplpro_set_expr_as_pstring (ABSTRACT_EXPRVAL*,PSTRING);
+    \brief method to return PSTRING value from callback of call_expr_userfnc_functype.
+
+    It should only be used in a callback of call_expr_userfnc_functype.
+*/
+
+/*! \fn void tmplpro_set_expr_as_null (ABSTRACT_EXPRVAL*);
+    \brief method to return null from callback of call_expr_userfnc_functype.
+
+    It should only be used in a callback of call_expr_userfnc_functype.
+*/
+
+/*! \fn EXPR_int64 tmplpro_get_expr_as_int64 (ABSTRACT_EXPRVAL*);
+    \brief method for callback of push_expr_arglist_functype to retrieve a value as int64.
+*/
+
+/*! \fn double tmplpro_get_expr_as_double (ABSTRACT_EXPRVAL*);
+    \brief method for callback of push_expr_arglist_functype to retrieve a value as double.
+
+    It should only be used in a callback of push_expr_arglist_functype.
+*/
+
+/*! \fn PSTRING tmplpro_get_expr_as_pstring (ABSTRACT_EXPRVAL*);
+    \brief method for callback of push_expr_arglist_functype to retrieve a value as PSTRING.
+
+    It should only be used in a callback of push_expr_arglist_functype.
+*/
+
+/*! \fn int  tmplpro_get_expr_type (ABSTRACT_EXPRVAL*);
+    \brief method for callback of push_expr_arglist_functype to determine the type of a value.
+
+    It should only be used in a callback of push_expr_arglist_functype.
+*/
+
+/** \struct tmplpro_param
+
+    \brief main htmltmplpro class.
+    
+    Main htmltmplpro class. Passed by reference.
+    Its internal structure is hidden and is not part of the API.
+
+    Constructor is  tmplpro_param_init()
+    
+    Destructor is tmplpro_param_free()
+
+    Main methods are tmplpro_exec_tmpl(), tmplpro_tmpl2pstring()
+
+ */
+
+/** \struct exprval
+
+    \brief EXPR="..." variable class.
+    
+    EXPR="..." expression variable class. Passed by reference.
+    Its internal structure is hidden and is not part of the API.
+    It can contain string, 64-bit integer or double.
+
+    Methods:
+    \li tmplpro_set_expr_as_null(ABSTRACT_EXPRVAL*)
+    \li tmplpro_set_expr_as_int64(ABSTRACT_EXPRVAL*,EXPR_int64)
+    \li tmplpro_set_expr_as_double(ABSTRACT_EXPRVAL*,double)
+    \li tmplpro_set_expr_as_string(ABSTRACT_EXPRVAL*,const char*)
+    \li tmplpro_set_expr_as_pstring(ABSTRACT_EXPRVAL*,PSTRING)
+
+    \li tmplpro_get_expr_type(ABSTRACT_EXPRVAL*)
+    \li tmplpro_get_expr_as_int64(ABSTRACT_EXPRVAL*)
+    \li tmplpro_get_expr_as_double(ABSTRACT_EXPRVAL*)
+    \li tmplpro_get_expr_as_pstring(ABSTRACT_EXPRVAL*)
+ */
+
+
+/*! \mainpage
+ *
+ * \section intro_sec Introduction
+ *
+ * \include README
+ *
+ * \section compile_sec Compilation
+ *
+ * \subsection autoconf
+ *  
+ * \subsection CMake
+ * etc...
+ *  
+ * \section api_sec History of API and ABI changes
+ *
+ * \include API
+ *
+ */

data/ext/html/template/internal/tmplpro_version.c

@@ -0,0 +1,35 @@
+/* -*- c -*- 
+ * File: tmplpro_version.c
+ * Author: Igor Vlasenko <vlasenko@imath.kiev.ua>
+ * Created: Mon Jul 13 21:24:55 2009
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifndef PACKAGE_VERSION
+#define PACKAGE_VERSION "0.0(not defined)"
+#endif
+
+/*************************************************
+*          Return version string                 *
+*************************************************/
+
+/* These macros are the standard way of turning unquoted text into C strings.
+They allow macros like PCRE_MAJOR to be defined without quotes, which is
+convenient for user programs that want to test its value. */
+
+#define STRING(a)  # a
+#define XSTRING(s) STRING(s)
+
+const char* tmplpro_version(void) {
+  //return "" XSTRING(PACKAGE_VERSION) ;
+  return "" PACKAGE_VERSION ;
+}
+
+/*
+ *  Local Variables:
+ *  mode: c
+ *  End:
+ */

data/lib/html/template/pro.rb

@@ -0,0 +1,225 @@
+require 'html_template_internal'
+
+module HTML
+  module Template
+
+    def Internal.register_functions_impl(registory, func_spec, &block)
+      if block && func_spec.kind_of?(Symbol)
+        registory[func_spec] = block
+      elsif func_spec.kind_of? Hash
+        unless func_spec.values.all?{|e| e.kind_of? Proc}
+          raise ArgumentError, "functions must be kind_of Proc"
+        end
+        registory.update(func_spec)
+      else
+        raise ArgumentError, "first argument must be symbol or hash contains functions"
+      end
+    end
+
+    class Pro
+
+      VERSION = "0.0.1"
+
+      include HTML::Template::Internal
+
+      INPUTS = [:filename, :filehandle, :arrayref, :scalarref, :source]
+
+      ASK_NAME_DEFAULT   = 0
+      ASK_NAME_AS_IS     = 1
+      ASK_NAME_LOWERCASE = 2
+      ASK_NAME_UPPERCASE = 4
+      ASK_NAME_MASK = ASK_NAME_AS_IS | ASK_NAME_LOWERCASE | ASK_NAME_UPPERCASE
+
+      @@func = {
+        # note that length,defined,sin,cos,log,tan,... are built-in
+        :sprintf => lambda { |*args| sprintf(*args) },
+        :substr  => lambda { |str, *args| args.size == 2 ? str[*args] : str[args[0]..-1] },
+        :lc      => lambda { |str| str.downcase },
+        :lcfirst => lambda { |str| str[0,1].downcase + str[1..-1] },
+        :uc      => lambda { |str| str.upcase },
+        :ucfirst => lambda { |str| str.capitalize },
+#        :length  => lambda { |str| str.length },
+#        :defined => lambda { |obj| obj.nil? },
+#        :abs     => lambda { |num| num.abs },
+#        :hex     => lambda { |obj| obj.to_s.hex },
+#        :oct     => lambda { |obj| obj.to_s.oct },
+        :rand    => lambda { |num|  rand num },
+        :srand   => lambda { |seed| srand seed },
+      }
+
+      def initialize(args={})
+        @options = default_options.merge(args)
+        if args.keys.count(&INPUTS.method(:include?)) != 1
+          raise ArgumentError, "HTML::Template::Pro.new called with multiple (or no) template sources specified!"
+        end
+        @params = @options[:param_map]
+        [:path, :associate, :filter].each do |opt|
+          unless @options[opt].kind_of? Array
+            @options[opt] = [ @options[opt] ]
+          end
+        end
+        @options[:expr_func] = @@func.merge(@options[:functions] || {})
+        initialize_tmpl_source args
+        if @scalarref and @options[:filter]
+          @scalarref = call_filters @scalarref
+        end
+        @filtered_template = {}
+      end
+
+      def param(args=nil, &block)
+        return @params.keys if args.nil?
+        if !(args.kind_of? Hash)
+          key = @options[:case_sensitive] ? args : args.downcase
+          if block
+            return @params[key] = block
+          else
+            return @params[key] || @params[args]
+          end
+        end
+        merge_params(args)
+      end
+
+      def clear_params
+        @params.clear
+      end
+
+      def output(options={})
+
+        @options[:associate].reverse.each do |assoc|
+          assoc.param.each do |key|
+            param(key => assoc.param(key)) unless @params[key]
+          end
+        end
+
+        if (options.include? :print_to)
+          exec_tmpl(options[:print_to])
+        else
+          output_string = String.new
+          exec_tmpl(output_string)
+          return output_string
+        end
+      end
+
+      def self.new_filehandle(file)
+        self.new(:filehandle => file)
+      end
+
+      def self.register_function(func_spec, &block)
+        HTML::Template::Internal.register_functions_impl(@@func, func_spec, &block)
+      end
+
+      def register_function(func_spec, &block)
+        HTML::Template::Internal.register_functions_impl(@options[:expr_func], func_spec, &block)
+      end
+
+      private
+
+      def default_options
+        return {
+          :param_map => {},
+          :filter => [],
+          :debug => 0,
+          :max_includes => 10,
+          :global_vars => false,
+          :no_includes => false,
+          :search_path_on_include => false,
+          :loop_context_vars => false,
+          :path_like_variable_scope => false,
+          :path => [],
+          :associate => [],
+          :case_sensitive => false,
+          :__strict_compatibility => true,
+          :strict => false,
+          :die_on_bad_params => false,
+        }
+      end
+
+      def initialize_tmpl_source(args)
+        if args.include? :filename
+          @filename = args[:filename]
+          @scalarref = nil
+          return
+        end
+
+        @filename = nil
+        if args.include? :source
+          source = args[:source]
+          @scalarref = case source
+                       when IO     then source.read
+                       when Array  then source.join('')
+                       when String then source
+                       else
+                         if source.respond_to? :to_str 
+                           source.to_str
+                         else
+                           raise "unknown source type"
+                         end
+                       end
+        elsif args.include? :scalarref
+          @scalarref = args[:scalarref]
+        elsif args.include? :arrayref
+          @scalarref = args[:arrayref].join('')
+        elsif args.include? :filehandle
+          @scalarref = args[:filehandle].read
+        end
+      end
+
+      def merge_params(params)
+        unless @options[:case_sensitive]
+          params = lowercase_keys params
+        end
+        @params.update(params)
+      end
+
+      def lowercase_keys(orighash)
+        Hash[
+             orighash.map do |key, val|
+               case val
+               when Array then [key.downcase, val.map(&(method :lowercase_keys))]
+               when Proc  then [key.downcase, val]
+               else [key.downcase, val]
+               end
+             end
+            ]
+      end
+
+      def load_template(filepath)
+        File.open(filepath, 'r') do |file|
+          # filtered template is used in internal. we store it to `self'
+          # to prevent gc.
+          @filtered_template[filepath] = call_filters file.read
+        end
+      end
+
+      def call_filters(template)
+        @options[:filter].each do |filter|
+          format, sub = case filter
+                        when Hash then filter.values_at(:format, :sub)
+                        when Proc then ['scalar', filter]
+                        else raise "bad value set for filter parameter - must be a Proc or a Hash object."
+                        end
+
+          unless format and sub
+            raise "bad value set for filter parameter - hash must contain \"format\" key and \"sub\" key."
+          end
+          unless format == 'array' or format == 'scalar'
+            raise "bad value set for filter parameter - \"format\" must be either 'array' or 'scalar'"
+          end
+          unless sub.kind_of? Proc
+            raise "bad value set for filter parameter - \"sub\" must be a code ref"
+          end
+
+          if format == 'scalar'
+            template = sub.call(template)
+          else
+            template = sub.call(template.split("\n").map {|str| str + "\n"}).join('')
+          end
+        end
+        return template
+      end
+    end
+
+    # alias
+    Expr = Pro
+  end
+end