erubis 2.0.1 → 2.1.0

data/lib/erubis/generator.rb

@@ -0,0 +1,83 @@
+##
+## $Rev: 32 $
+## $Release: 2.1.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+require 'abstract'
+
+module Erubis
+
+
+  module Generator
+
+    def self.supported_properties()  # :nodoc:
+      return [
+              [:escapefunc,    nil,    "escape function name"],
+            ]
+    end
+
+    attr_accessor :escapefunc
+
+    def init_generator(properties={})
+      @escapefunc = properties[:escapefunc]
+    end
+
+
+    ## (abstract) escape text string
+    ##
+    ## ex.
+    ##   def escape_text(text)
+    ##     return text.dump
+    ##     # or return "'" + text.gsub(/['\\]/, '\\\\\&') + "'"
+    ##   end
+    def escape_text(text)
+      not_implemented
+    end
+
+    ## return escaped expression code (ex. 'h(...)' or 'htmlspecialchars(...)')
+    def escaped_expr(code)
+      code.strip!
+      return "#{@escapefunc}(#{code})"
+    end
+
+    ## (abstract) add @preamble to src
+    def add_preamble(src)
+      not_implemented
+    end
+
+    ## (abstract) add text string to src
+    def add_text(src, text)
+      not_implemented
+    end
+
+    ## (abstract) add statement code to src
+    def add_stmt(src, code)
+      not_implemented
+    end
+
+    ## (abstract) add expression literal code to src. this is called by add_expr().
+    def add_expr_literal(src, code)
+      not_implemented
+    end
+
+    ## (abstract) add escaped expression code to src. this is called by add_expr().
+    def add_expr_escaped(src, code)
+      not_implemented
+    end
+
+    ## (abstract) add expression code to src for debug. this is called by add_expr().
+    def add_expr_debug(src, code)
+      not_implemented
+    end
+
+    ## (abstract) add @postamble to src
+    def add_postamble(src)
+      not_implemented
+    end
+
+
+  end
+
+
+end

data/lib/erubis/helper.rb

@@ -1,6 +1,6 @@
 ##
 ## $Rev: 21 $
-## $Release: 2.0.1 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 

data/lib/erubis/helper/rails.rb

@@ -0,0 +1,159 @@
+###
+### $Rev: 38 $
+### $Release: 2.1.0 $
+### copyright(c) 2006 kuwata-lab all rights reserved.
+###
+### = How to use Erubis in Rails
+###
+### 1. add the folliwng code in your 'app/controllers/application.rb'.
+###      --------------------
+###      require 'erubis/helper/rails'
+###      suffix = 'erubis'
+###      ActionView::Base.register_template_handler(suffix, Erubis::Helper::RailsTemplate)
+###      #Erubis::Helper::RailsTemplate.engine_class = Erubis::EscapedEruby ## if you want
+###      #Erubis::Helper::RailsTemplate.default_class = { :escape=>true, :escapefunc='h' }
+###      --------------------
+### 2. restart web server.
+### 3. change view template filename from 'file.rhtml' to 'file.erubis'.
+###    (suffix '.rhtml' is not recommended because error page of Rails is
+###     assumed to use ERB.)
+###
+
+
+require 'erubis'
+
+
+module Erubis
+
+  module Helper
+
+    class RailsTemplate
+
+
+      @@engine_class = Erubis::Eruby
+
+      def self.engine_class
+        @@engine_class
+      end
+
+      def self.engine_class=(klass)
+        @@engine_class = klass
+        @@engine_instance = klass.new
+      end
+
+      #cattr_accessor :engine_class
+
+
+      @@default_properties = { }
+
+      def self.default_properties
+        return @@default_properties
+      end
+
+      def self.default_properties=(properties)
+        @@default_properties = properties
+      end
+
+      #cattr_accessor :default_properties
+
+
+      def initialize(view)
+        @view = view
+        #@@engine_instance ||= @@engine_class.new(nil, @@default_properties)
+      end
+
+
+      def convert(template)
+        #code = @@engine_instance.convert(template)
+        #return code
+        engine = @@engine_class.new(nil, @@default_properties)
+        code = engine.convert(template)
+        return code
+      end
+
+
+      def render(template, assigns)
+        ## get ruby code
+        code = convert(template)
+
+        ## use @view as context object
+        @view.__send__(:evaluate_assigns)  #or @view.instance_eval("evaluate_assigns()")
+        context = @view
+
+        ## evaluate ruby code with context object
+        if assigns && !assigns.empty?
+          return _evaluate_string(code, context, assigns)
+        else
+          return context.instance_eval(code)
+        end
+      end
+
+
+      protected
+
+
+      def _localvar_code(_localvars)
+        list = _localvars.collect { |_name| "#{_name} = _localvars[#{_name.inspect}]\n" }
+        code = list.join()
+        return code
+      end
+
+
+      def _evaluate_string(_code, _context, _localvars)
+        eval(_localvar_code(_localvars))
+        _context.instance_eval(_code)
+      end
+
+
+    end #class
+
+
+
+    class CachedRailsTemplate < RailsTemplate
+
+
+      @@cache_table = {}
+
+
+      def render(template, assigns)
+        ## template path without suffix
+        ## (how to get template path name with suffix? I can't find...)
+        c = @view.controller
+        template_basename = c.template_root + "/" + c.controller_name + "/" + c.action_name
+
+        ## cache template
+        proc_obj = @@cache_table[template_basename]
+        unless proc_obj
+          code = convert(template)
+          proc_obj = eval("proc do #{code} end")
+          @@cache_table[template_basename] = proc_obj
+        end
+
+        ## use @view as context object
+        @view.__send__(:evaluate_assigns)
+        #or @view.instance_eval("evaluate_assigns()")
+        context = @view
+
+        ## evaluate ruby code with context object
+        if assigns && !assigns.empty?
+          return _evaluate_proc(proc_obj, context, assigns)
+        else
+          return context.instance_eval(&proc_obj)
+        end
+      end
+
+
+      protected
+
+
+      def _evaluate_proc(_proc_obj, _context, _localvars)
+        eval(_localvar_code(_localvars))
+        _context.instance_eval(&_proc_obj)
+      end
+
+
+    end #class
+
+  end #module
+
+end #module

data/lib/erubis/local-setting.rb

@@ -1,6 +1,6 @@
 ##
 ## $Rev: 13 $
-## $Release: 2.0.1 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 

data/lib/erubis/main.rb

@@ -1,6 +1,6 @@
 ###
-### $Rev: 21 $
-### $Release: 2.0.1 $
+### $Rev: 41 $
+### $Release: 2.1.0 $
 ### copyright(c) 2006 kuwata-lab all rights reserved.
 ###
 
@@ -112,15 +112,15 @@ module Erubis
 
       ## action
       action = opts.action
-      action ||= 'compile' if opts.source
+      action ||= 'convert' if opts.source
 
       ## lang
       lang = opts.lang || 'ruby'
-      action ||= 'compile' if opts.lang
+      action ||= 'convert' if opts.lang
 
       ## class name of Eruby
       classname = opts.class
-      klass = get_classobj(classname, lang)
+      klass = get_classobj(classname, lang, properties[:pi])
 
       ## kanji code
       $KCODE = opts.kanji if opts.kanji
@@ -130,31 +130,33 @@ module Erubis
       context = load_yamlfiles(yamlfiles, opts)
 
       ## properties for engine
+      properties[:escape]   = true         if opts.escape && !properties.key?(:escape)
       properties[:pattern]  = opts.pattern if opts.pattern
       properties[:trim]     = false        if opts.notrim
       properties[:preamble] = properties[:postamble] = false if opts.bodyonly
+      properties[:pi]       = nil          if properties[:pi] == true
 
       ## create engine and extend enhancers
       engine = klass.new(nil, properties)
       enhancers = get_enhancers(opts.enhancers)
-      enhancers.push(Erubis::EscapeEnhancer) if opts.escape
+      #enhancers.push(Erubis::EscapeEnhancer) if opts.escape
       enhancers.each do |enhancer|
         engine.extend(enhancer)
         engine.bipattern = properties[:bipattern] if enhancer == Erubis::BiPatternEnhancer
       end
 
-      ## compile and execute
+      ## convert and execute
       val = nil
       if filenames && !filenames.empty?
         filenames.each do |filename|
           test(?f, filename)  or raise CommandOptionError.new("#{filename}: file not found.")
           engine.filename = filename
-          engine.compile!(File.read(filename))
+          engine.convert!(File.read(filename))
           print val if val = do_action(action, engine, context, opts)
         end
       else
         engine.filename = '(stdin)'
-        engine.compile!($stdin.read())
+        engine.convert!($stdin.read())
         print val if val = do_action(action, engine, context, opts)
       end
 
@@ -164,7 +166,7 @@ module Erubis
 
     def do_action(action, engine, context, opts)
       case action
-      when 'compile'
+      when 'convert'
         s = engine.src
       when nil, 'exec', 'execute'
         s = opts.binding ? engine.result(context) : engine.evaluate(context)
@@ -176,42 +178,61 @@ module Erubis
 
     def usage
       command = File.basename($0)
-      s = <<'END'
-erubis - embedded program compiler for multi-language
+      s = <<END
+erubis - embedded program converter for multi-language
 Usage: #{command} [..options..] [file ...]
   -h, --help    : help
   -v            : version
-  -x            : compiled code
+  -x            : converted code
   -T            : don't trim spaces around '<% %>'
   -b            : body only (no preamble nor postamble)
   -e            : escape (equal to '--E Escape')
   -p pattern    : embedded pattern (default '<% %>')
-  -l lang       : compile but no execute (ruby/php/c/java/scheme/perl/js)
-  -E enhancer,... : enhancer name (Escape, PercentLine, BiPattern, ...)
+  -l lang       : convert but no execute (ruby/php/c/java/scheme/perl/js)
+  -E e1,e2,...  : enhancer names (Escape, PercentLine, BiPattern, ...)
   -I path       : library include path
   -K kanji      : kanji code (euc/sjis/utf8) (default none)
   -f file.yaml  : YAML file for context values (read stdin if filename is '-')
   -t            : expand tab character in YAML file
   -S            : convert mapping key from string to symbol in YAML file
   -B            : invoke 'result(binding)' instead of 'evaluate(context)'
+  --pi=name     : parse '<?name ... ?>' instead of '<% ... %>'
 
 END
+      #'
       #  -c class      : class name (XmlEruby/PercentLineEruby/...) (default Eruby)
       #  -r library    : require library
-      #  -a            : action (compile/execute)
+      #  -a            : action (convert/execute)
       return s
     end
 
+
+    def collect_supported_properties(erubis_klass)
+      list = []
+      erubis_klass.ancestors.each do |klass|
+        if klass.respond_to?(:supported_properties)
+          list.concat(klass.supported_properties)
+        end
+      end
+      return list
+    end
+
     def show_properties
       s = "supported properties:\n"
-      %w[(common) ruby php c java scheme perl javascript].each do |lang|
-        list = Erubis::Engine.supported_properties
-        if lang != '(common)'
-          klass = Erubis.const_get("E#{lang}")
-          list = klass.supported_properties - list
-        end
+      basic_props = collect_supported_properties(Erubis::Basic::Engine)
+      pi_props    = collect_supported_properties(Erubis::PI::Engine)
+      list = []
+      common_props = basic_props & pi_props
+      list << ['(common)', common_props]
+      list << ['(basic)',  basic_props - common_props]
+      list << ['(pi)',     pi_props    - common_props]
+      %w[ruby php c java scheme perl javascript].each do |lang|
+        klass = Erubis.const_get("E#{lang}")
+        list << [lang, collect_supported_properties(klass) - basic_props]
+      end
+      list.each do |lang, props|
         s << "  * #{lang}\n"
-        list.each do |name, default_val, desc|
+        props.each do |name, default_val, desc|
           s << ("     --%-23s : %s\n" % ["#{name}=#{default_val.inspect}", desc])
         end
       end
@@ -233,7 +254,7 @@ END
     end
 
     def version
-      release = ('$Release: 2.0.1 $' =~ /([.\d]+)/) && $1
+      release = ('$Release: 2.1.0 $' =~ /([.\d]+)/) && $1
       return release
     end
 
@@ -283,27 +304,42 @@ END
       return options, context
     end
 
-    def untabify(text, width=8)
+
+    def untabify(str, width=8)
+      list = str.split(/\t/)
+      last = list.pop
       sb = ''
-      text.scan(/(.*?)\t/m) do |s, |
-        len = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
-        sb << s << (" " * (width - len % width))
+      list.each do |s|
+        column = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
+        n = width - (column % width)
+        sb << s << (' ' * n)
       end
-      return $' ? (sb << $') : text
+      sb << last
+      return sb
     end
-
-    def get_classobj(classname, lang)
-      unless classname
-        classname = lang =~ /\Axml(.*)/ ? "EscapedE#{$1}" : "E#{lang}"
-      end
+    #--
+    #def untabify(str, width=8)
+    #  sb = ''
+    #  str.scan(/(.*?)\t/m) do |s, |
+    #    len = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
+    #    sb << s << (" " * (width - len % width))
+    #  end
+    #  return $' ? (sb << $') : str
+    #end
+    #++
+
+
+    def get_classobj(classname, lang, pi)
+      classname ||= "E#{lang}"
+      base_module = pi ? Erubis::PI : Erubis
       begin
-        klass = Erubis.const_get(classname)
+        klass = base_module.const_get(classname)
       rescue NameError
         klass = nil
       end
       unless klass
         if lang
-          msg = "-l #{lang}: invalid language name (class Erubis::#{classname} not found)."
+          msg = "-l #{lang}: invalid language name (class #{base_module.name}::#{classname} not found)."
         else
           msg = "-c #{classname}: invalid class name."
         end
@@ -342,25 +378,30 @@ END
         unless ydoc.is_a?(Hash)
           raise CommandOptionError.new("#{yamlfile}: root object is not a mapping.")
         end
-        convert_mapping_key_from_string_to_symbol(ydoc) if opts.intern
+        intern_hash_keys(ydoc) if opts.intern
         hash.update(ydoc)
       end
       context = hash
       return context
     end
 
-    def convert_mapping_key_from_string_to_symbol(ydoc)
-      if ydoc.is_a?(Hash)
-        ydoc.each do |key, val|
-          ydoc[key.intern] = ydoc.delete(key) if key.is_a?(String)
-          convert_mapping_key_from_string_to_symbol(val)
+    def intern_hash_keys(obj, done={})
+      return if done.key?(obj.__id__)
+      case obj
+      when Hash
+        done[obj.__id__] = obj
+        obj.keys.each do |key|
+          obj[key.intern] = obj.delete(key) if key.is_a?(String)
+        end
+        obj.values.each do |val|
+          intern_hash_keys(val, done) if val.is_a?(Hash) || val.is_a?(Array)
         end
-      elsif ydoc.is_a?(Array)
-        ydoc.each do |val|
-          convert_mapping_key_from_string_to_symbol(val)
+      when Array
+        done[obj.__id__] = obj
+        obj.each do |val|
+          intern_hash_keys(val, done) if val.is_a?(Hash) || val.is_a?(Array)
         end
       end
-      return ydoc
     end
 
   end