erubis 2.0.1 → 2.1.0

data/README.txt

@@ -1,6 +1,6 @@
 = README
 
-release::	$Release: 2.0.1 $
+release::	$Release: 2.1.0 $
 copyright::	copyright(c) 2006 kuwata-lab all rights reserved.
 
 
@@ -8,13 +8,16 @@ copyright::	copyright(c) 2006 kuwata-lab all rights reserved.
 == About Erubis
 
 Erubis is an implementation of eRuby. It has the following features.
-* Very fast (about three times faster than ERB and almost as fast as eruby)
-* Auto trimming spaces around '<% %>'
-* Auto escape (sanitizing)
-* Changeable embedded pattern (default '<% %>')
-* Context object available
-* Easy to expand and customize in subclass
+* Very fast, almost three times faster than ERB and even faster than eruby
 * Multi-language support (Ruby/PHP/C/Java/Scheme/Perl/Javascript)
+* Auto escaping support
+* Auto trimming spaces around '<% %>'
+* Embedded pattern changeable (default '<% %>')
+* Enable to handle Processing Instructions (PI) as embedded pattern (ex. '<?rb ... ?>')
+* Context object available and easy to combine eRuby template with YAML datafile
+* Print statement available
+* Easy to extend and customize in subclass
+* Ruby on Rails support
 
 Erubis is implemented in pure Ruby.  It requires Ruby 1.8 or higher.
 
@@ -59,6 +62,8 @@ If you are exploring Eruby, see the following class at first.
   base class of Eruby, Ephp, Ejava, and so on.
 * Erubis::Eruby (erubis/engine/eruby.rb) --
   engine class for eRuby.
+* Erubis::Converter (erubis/converter.rb) --
+  convert eRuby script into Ruby code.
 
 
 
@@ -71,8 +76,9 @@ Try 'ruby erubybenchmark.rb' in benchmark directory.
 
 == License
 
-GPL ver.2
+LGPL version 2.1
 
+If you need looser license, please suggest me.
 
 
 == Author

data/benchmark/erubybench.rb

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

data/benchmark/erubybench.rhtml

@@ -40,17 +40,17 @@ thead {
     </tr>
    </thead>
    <tbody>
-<% data.each_with_index do |h, i| %>
+<% data.each_with_index do |hash, i| %>
 <%  n = i + 1 %>
     <tr class="<%= n % 2 == 0 ? 'even' : 'odd' %>">
      <td style="text-align: center">
       <span><%= n %></span>
      </td>
      <td>
-      <a href="/stock/<%= h[:code] %>"><%= h[:code] %></a>
+      <a href="/stock/<%= hash[:code] %>"><%= hash[:code] %></a>
      </td>
      <td>
-      <a href="<%= h[:url] %>"><%= h[:name] %></a>
+      <a href="<%= hash[:url] %>"><%= hash[:name] %></a>
      </td>
     </tr>
 <% end %>

data/bin/erubis

@@ -2,7 +2,7 @@
 
 ###
 ### $Rev: 10 $
-### $Release: 2.0.1 $
+### $Release: 2.1.0 $
 ### copyright(c) 2006 kuwata-lab all rights reserved.
 ###
 

data/bin/notext

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+
+###
+### notext  -  retrieve embedded code from eRuby, PHP, and so on
+###
+### $Rev$
+### $Release: 2.1.0 $
+### copyright(c) 2006 kuwata-lab all rights reserved.
+###
+
+require 'erubis'
+require 'erubis/engine/eruby'
+require 'erubis/engine/ephp'
+require 'erubis/engine/ec'
+require 'erubis/engine/ejava'
+require 'erubis/engine/escheme'
+require 'erubis/engine/eperl'
+require 'erubis/engine/ejavascript'
+
+
+def help()
+  command = File.basename($0)
+  s = <<END
+#{command} - retrieve embedded code from eRuby, PHP, and so on.
+Usage:  #{command} [-hvncu] [-l lang] [-p pattern] file.php ...
+  -h         : help
+  -v         : version
+  -n         : show line number
+  -c         : compact mode (delete empty lines)
+  -u         : uniq mode (compress repeated empty lines to a line)
+  -l lang    : ruby/php/perl/c/java/scheme/javascript
+  -p pattern : embedded pattern (default '<% %>' or '<\\?(?:php|=|\\s) \\?>')
+END
+  return s
+end
+
+
+## Engine classes which include NoTextEnhancer
+klass_table = {}
+lang_list = %w[ruby php c java scheme perl javascript]
+lang_list.each do |lang|
+  eval <<-END
+    class NoTextE#{lang} < Erubis::E#{lang}
+      include Erubis::NoTextEnhancer
+    end
+  END
+  klass_table[lang] = Object.const_get("NoTextE#{lang}")
+end
+
+
+## parse command-line options
+options = {}
+properties = {}
+while !ARGV.empty? && ARGV[0][0] == ?-
+  optstr = ARGV.shift
+  optstr = optstr.sub(/^-/, '')
+  while !optstr.empty?
+    optch = optstr[0]
+    optstr = optstr[1, optstr.length-1]
+    case optch
+    when ?h, ?v, ?n, ?c, ?u   # help, version, linenum, compact, uniq
+      options[optch] = true
+    when ?l, ?p               # lang, pattern
+      arg = !optstr.empty? ? optstr : ARGV.shift
+      unless arg
+        argnames = { ?l => 'lang name', ?p => 'pattern' }
+        $stderr.puts "-#{optch.chr}: #{argnames[optch]} required."
+        exit(1)
+      end
+      options[optch] = arg
+    else
+      $stderr.puts "-#{optch.chr}: unknown option."
+      exit(1)
+    end
+  end
+end
+
+opt_help    = options[?h]
+opt_version = options[?v]
+opt_linenum = options[?n]
+opt_compact = options[?c]
+opt_unique  = options[?u]
+opt_pattern = options[?p]
+opt_lang    = options[?l]
+
+if opt_lang
+  unless lang_list.include?(opt_lang)
+    $stderr.puts "-l #{opt_lang}: not supported."
+    exit(1)
+  end
+end
+
+
+## help message
+if opt_help || opt_version
+  version = ('$Release: 2.1.0 $' =~ /[\.\d]+/) && $&
+  puts version if opt_version
+  puts help()  if opt_help
+  exit(0)
+end
+
+
+## determine pattern
+lang = opt_lang
+unless lang
+  filename = ARGV[0]
+  if filename && filename =~ /\.(\w+)$/
+    case suffix = $1
+    when 'php', 'php5', 'inc' ;  lang = 'php'
+    when 'ec'                 ;  lang = 'c'
+    when 'ejava'              ;  lang = 'java'
+    when 'escheme', 'escm'    ;  lang = 'scheme'
+    when 'eperl'              ;  lang = 'perl'
+    when 'js', 'javascript'   ;  lang = 'javascript'
+    else                      ;  lang = 'ruby'
+    end
+  else
+    lang = 'ruby'
+  end
+end
+
+
+## determine pattern
+if opt_pattern
+  pattern = opt_pattern
+else
+  case lang
+  when 'php'   ;  pattern = '<\?(?:php\b|(?==)|(?=\s)) \?>'
+  when 'perl'  ;  pattern = '<\?(?=\s|=) !>'
+  else         ;  pattern = '<% %>'
+  end
+end
+
+
+## read input and create engine
+klass = klass_table[lang]
+input = ARGF.read()
+engine = klass.new(input, :pattern=>pattern, :trim=>false)
+
+
+## print embedded code
+n = 0
+prev_empty = false
+engine.src.each_line do |line|
+  n += 1
+  if line =~ /^\s*$/
+    next if opt_compact || (opt_unique && prev_empty)
+    print opt_linenum && !opt_unique ? ("%3d: \n" % n) : "\n"
+    prev_empty = true
+  else
+    print opt_linenum ? ("%3d: %s" % [n, line]) : line
+    prev_empty = false
+  end
+end

data/contrib/erubis

@@ -2,22 +2,22 @@
 
 ###
 ### $Rev: 10 $
-### $Release: 2.0.1 $
+### $Release: 2.1.0 $
 ### copyright(c) 2006 kuwata-lab all rights reserved.
 ###
 
 #--begin of require 'erubis/main'
 ###
-### $Rev: 21 $
-### $Release: 2.0.1 $
+### $Rev: 41 $
+### $Release: 2.1.0 $
 ### copyright(c) 2006 kuwata-lab all rights reserved.
 ###
 
 require 'yaml'
 #--begin of require 'erubis'
 ##
-## $Rev: 21 $
-## $Release: 2.0.1 $
+## $Rev: 36 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -41,12 +41,15 @@ require 'yaml'
 ##    </ul>
 ##   END
 ##   list = ['<aaa>', 'b&b', '"ccc"']
-##   eruby = Erubis::Eruby.new(input)
-##   puts "--- source ---"
-##   puts eruby.src
+##   eruby = Erubis::Eruby.new()
+##   code = eruby.convert(input)
+##   puts "--- code ---"
+##   puts code
 ##   puts "--- result ---"
-##   puts eruby.evaluate(:list=>list)
-##   # or puts eruby.result(binding())
+##   context = Object.new
+##   context.instance_variable_set("@list", list)
+##   puts context.instance_eval(code)
+##   # or @list = list; puts eval(code, binding())
 ##
 ## result:
 ##   --- source ---
@@ -71,16 +74,24 @@ require 'yaml'
 
 #--begin of require 'erubis/engine'
 ##
-## $Rev: 24 $
-## $Release: 2.0.1 $
+## $Rev: 32 $
+## $Release: 2.1.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+
+#--begin of require 'erubis/generator'
+##
+## $Rev: 32 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
 #--begin of require 'abstract'
 ##
 ## $Rev: 1 $
-## $Release$
-## $Copyright$
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
 ##
 ##
 ## helper to define abstract method in Ruby.
@@ -154,116 +165,163 @@ module Kernel
 end
 #--end of require 'abstract'
 
-
 module Erubis
 
 
-  ##
-  ## base error class
-  ##
-  class ErubisError < StandardError
-  end
+  module Generator
 
+    def self.supported_properties()  # :nodoc:
+      return [
+              [:escapefunc,    nil,    "escape function name"],
+            ]
+    end
 
-  ##
-  ## .[abstract] context object for Engine#evaluate
-  ##
-  ## ex.
-  ##   template = <<'END'
-  ##   Hello <%= @user %>!
-  ##   <% for item in @list %>
-  ##    - <%= item %>
-  ##   <% end %>
-  ##   END
-  ##
-  ##   context = Erubis::Context.new(:user=>'World', :list=>['a','b','c'])
-  ##   # or
-  ##   # context = Erubis::Context.new
-  ##   # context[:user] = 'World'
-  ##   # context[:list] = ['a', 'b', 'c']
-  ##
-  ##   eruby = Erubis::Eruby.new(template)
-  ##   print eruby.evaluate(context)
-  ##
-  class Context
+    attr_accessor :escapefunc
 
-    def initialize(hash=nil)
-      hash.each do |name, value|
-        self[name] = value
-      end if hash
+    def init_generator(properties={})
+      @escapefunc = properties[:escapefunc]
     end
 
-    def [](key)
-      return instance_variable_get("@#{key}")
+
+    ## (abstract) escape text string
+    ##
+    ## ex.
+    ##   def escape_text(text)
+    ##     return text.dump
+    ##     # or return "'" + text.gsub(/['\\]/, '\\\\\&') + "'"
+    ##   end
+    def escape_text(text)
+      not_implemented
     end
 
-    def []=(key, value)
-      return instance_variable_set("@#{key}", value)
+    ## return escaped expression code (ex. 'h(...)' or 'htmlspecialchars(...)')
+    def escaped_expr(code)
+      code.strip!
+      return "#{@escapefunc}(#{code})"
     end
 
-    def keys
-      return instance_variables.collect { |name| name[1,name.length-1] }
+    ## (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
+#--end of require 'erubis/generator'
+#--begin of require 'erubis/converter'
+##
+## $Rev: 37 $
+## $Release: 2.1.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+#--already included require 'abstract'
+
+module Erubis
+
+
   ##
-  ## .[abstract] base engine class
+  ## convert
   ##
-  class Engine
+  module Converter
+
+    attr_accessor :preamble, :postamble, :escape
 
     def self.supported_properties    # :nodoc:
       return [
-              [:pattern,  '<% %>', "embed pattern"],
-              #[:filename,  nil,    "filename"],
-              [:trim,      true,   "trim spaces around <% ... %>"],
               [:preamble,  nil,    "preamble (no preamble when false)"],
               [:postamble, nil,    "postamble (no postamble when false)"],
-              [:escape,    nil,     "escape function name"],
+              [:escape,    nil,    "escape expression or not in default"],
              ]
     end
 
-    def initialize(input, properties={})
-      #@input    = input
-      @pattern   = properties[:pattern]
-      @filename  = properties[:filename]
-      @trim      = properties[:trim] != false
+    def init_converter(properties={})
       @preamble  = properties[:preamble]
       @postamble = properties[:postamble]
       @escape    = properties[:escape]
-      @src       = compile(input) if input
     end
-    attr_reader :src
-    attr_accessor :filename
 
-    ## load file and create engine object
-    def self.load_file(filename, properties={})
-      input = File.open(filename, 'rb') { |f| f.read }
-      input.untaint   # is it ok?
-      properties[:filename] = filename
-      engine = self.new(input, properties)
-      return engine
+    ## convert input string into target language
+    def convert(input)
+      codebuf = ""    # or []
+      @preamble.nil? ? add_preamble(codebuf) : (@preamble && (codebuf << @preamble))
+      convert_input(codebuf, input)
+      @postamble.nil? ? add_postamble(codebuf) : (@postamble && (codebuf << @postamble))
+      return codebuf  # or codebuf.join()
     end
 
-    ## eval(@src) with binding object
-    def result(_binding_or_hash=TOPLEVEL_BINDING)
-      _arg = _binding_or_hash
-      if _arg.is_a?(Hash)
-        ## load _context data as local variables by eval
-        eval _arg.keys.inject("") { |s, k| s << "#{k.to_s} = _arg[#{k.inspect}];" }
-        _arg = binding()
-      end
-      return eval(@src, _arg, (@filename || '(erubis)'))
+    protected
+
+    ##
+    ## (abstract) convert input to code
+    ##
+    def convert_input(codebuf, input)
+      not_implemented
     end
 
-    ## invoke context.instance_eval(@src)
-    def evaluate(context=Context.new)
-      context = Context.new(context) if context.is_a?(Hash)
-      return context.instance_eval(@src, (@filename || '(erubis)'))
+  end
+
+
+  module Basic
+  end
+
+
+  ##
+  ## basic converter which supports '<% ... %>' notation.
+  ##
+  module Basic::Converter
+    include Erubis::Converter
+
+    def self.supported_properties    # :nodoc:
+      return [
+              [:pattern,  '<% %>', "embed pattern"],
+              [:trim,      true,   "trim spaces around <% ... %>"],
+             ]
+    end
+
+    attr_accessor :pattern, :trim
+
+    def init_converter(properties={})
+      super(properties)
+      @pattern   = properties[:pattern]
+      @trim      = properties[:trim] != false
     end
 
-    DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    #DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    DEFAULT_REGEXP = /(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
 
     ## return regexp of pattern to parse eRuby script
     def pattern_regexp(pattern=@pattern)
@@ -271,17 +329,20 @@ module Erubis
         return DEFAULT_REGEXP
       else
         prefix, postfix = pattern.split()
-        return /(.*?)(^[ \t]*)?#{prefix}(=+|\#)?(.*?)-?#{postfix}([ \t]*\r?\n)?/m
+        #return /(.*?)(^[ \t]*)?#{prefix}(=+|\#)?(.*?)-?#{postfix}([ \t]*\r?\n)?/m
+        return /(^[ \t]*)?#{prefix}(=+|\#)?(.*?)-?#{postfix}([ \t]*\r?\n)?/m
       end
     end
     protected :pattern_regexp
 
-    ## compile input string into target language
-    def compile(input)
-      src = ""
-      @preamble.nil? ? add_preamble(src) : (@preamble && (src << @preamble))
+    def convert_input(src, input)
       regexp = pattern_regexp(@pattern)
-      input.scan(regexp) do |text, lspace, indicator, code, rspace|
+      pos = 0
+      input.scan(regexp) do |lspace, indicator, code, rspace|
+        match = Regexp.last_match()
+        index = match.begin(0)
+        text  = input[pos, index - pos]
+        pos   = match.end(0)
         add_text(src, text)
         ## * when '<%= %>', do nothing
         ## * when '<% %>' or '<%# %>', delete spaces iff only spaces are around '<% %>'
@@ -302,126 +363,447 @@ module Erubis
             add_stmt(src, "\n" * n)
             add_text(src, rspace) if rspace
           end
-          #flag_trim = @trim && lspace && rspace
-          #add_text(src, lspace) if !flag_trim && lspace
-          #n = code.count("\n") + (rspace ? 1 : 0)
-          #add_stmt(src, "\n" * n)
-          #add_text(src, rspace) if !flag_trim && rspace
         else                        # <%= %>
           add_text(src, lspace) if lspace
           add_expr(src, code, indicator)
           add_text(src, rspace) if rspace
         end
-        #if indicator && indicator[0] == ?=
-        #  flag_trim = false
-        #else
-        #  flag_trim = @trim && lspace && rspace
-        #end
-        ##flag_trim = @trim && !(indicator && indicator[0]==?=) && lspace && rspace
-        #add_text(src, text)
-        #add_text(src, lspace) if !flag_trim && lspace
-        #if !indicator             # <% %>
-        #  code = "#{lspace}#{code}#{rspace}" if flag_trim
-        #  add_stmt(src, code)
-        #elsif indicator[0] == ?\# # <%# %>
-        #  n = code.count("\n") + (rspace ? 1 : 0)
-        #  add_stmt(src, "\n" * n)
-        #else                      # <%= %>
-        #  add_expr(src, code, indicator)
-        #end
-        #add_text(src, rspace) if !flag_trim && rspace
       end
       rest = $' || input     # add input when no matched
       add_text(src, rest)
-      @postamble.nil? ? add_postamble(src) : (@postamble && (src << @postamble))
-      return src
     end
 
-    ## compile input string and set it to @src
-    def compile!(input)
-      @src = compile(input)
+    ## add expression code to src
+    def add_expr(src, code, indicator)
+      case indicator
+      when '='
+        @escape ? add_expr_escaped(src, code) : add_expr_literal(src, code)
+      when '=='
+        @escape ? add_expr_literal(src, code) : add_expr_escaped(src, code)
+      when '==='
+        add_expr_debug(src, code)
+      end
     end
 
-    protected
+  end
 
-    ## .[abstract] escape text string
-    ##
-    ## ex.
-    ##   def escape_text(text)
-    ##     return text.dump
-    ##     # or return "'" + text.gsub(/['\\]/, '\\\\\&') + "'"
-    ##   end
-    def escape_text(text)
-      not_implemented
+
+  module PI
+  end
+
+  ##
+  ## Processing Instructions (PI) converter for XML.
+  ## this class converts '<?rb ... ?>' and '${...}' notation.
+  ##
+  module PI::Converter
+    include Erubis::Converter
+
+    def self.desc   # :nodoc:
+      "use processing instructions (PI) instead of '<% %>'"
     end
 
-    ## .[abstract] return escaped expression code
-    ##
-    ## ex.
-    ##   def escaped_expr(code)
-    ##     @escape ||= 'escape'
-    ##     return "#{@escape}(#{code.strip})"
-    ##   end
-    def escaped_expr(code)
-      not_implemented
+    def self.supported_properties    # :nodoc:
+      return [
+              [:trim,      true,   "trim spaces around <% ... %>"],
+              [:pi,        'rb',   "PI (Processing Instrunctions) name"],
+              [:embchar,   '@',    "char for embedded expression pattern('@{...}@')"],
+              [:pattern,  '<% %>', "embed pattern"],
+             ]
     end
 
-    ## .[abstract] add @preamble to src
-    def add_preamble(src)
-      not_implemented
+    attr_accessor :pi, :prefix
+
+    def init_converter(properties={})
+      super(properties)
+      @trim    = !(properties[:trim] == false)
+      @pi      = properties[:pi] if properties[:pi]
+      @embchar = properties[:embchar]  || '@'
+      @pattern = properties[:pattern]
+      @pattern = '<% %>' if @pattern.nil?  #|| @pattern == true
     end
 
-    ## .[abstract] add text string to src
-    def add_text(src, text)
-      not_implemented
+    def convert(input)
+      code = super(input)
+      return @header || @footer ? "#{@header}#{code}#{@footer}" : code
     end
 
-    ## .[abstract] add statement code to src
-    def add_stmt(src, code)
-      not_implemented
+    protected
+
+    def convert_input(codebuf, input)
+      parse_stmts(codebuf, input)
+      #parse_stmts2(codebuf, input)
     end
 
-    ## add expression code to src
-    def add_expr(src, code, indicator)
+    def parse_stmts(codebuf, input)
+      #regexp = pattern_regexp(@pattern)
+      @pi ||= 'e'
+      @stmt_pattern ||= /(^[ \t]*)?<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?/m
+      pos = 0
+      input.scan(@stmt_pattern) do |lspace, pi_arg, code, rspace|
+        match = Regexp.last_match
+        index = match.begin(0)
+        text = input[pos, index - pos]
+        pos = match.end(0)
+        parse_exprs(codebuf, text) # unless text.empty?
+        if @trim && lspace && rspace
+          add_pi_stmt(codebuf, "#{lspace}#{code}#{rspace}", pi_arg)
+        else
+          add_text(codebuf, lspace)
+          add_pi_stmt(codebuf, code, pi_arg)
+          add_text(codebuf, rspace)
+        end
+      end
+      rest = $' || input
+      parse_exprs(codebuf, rest)
+    end
+
+    def parse_exprs(codebuf, input)
+      unless @expr_pattern
+        ch = Regexp.escape(@embchar)
+        if @pattern
+          left, right = @pattern.split(' ')
+          @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/
+        else
+          @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}/
+        end
+      end
+      pos = 0
+      input.scan(@expr_pattern) do |indicator1, code1, indicator2, code2|
+        indicator = indicator1 || indicator2
+        code = code1 || code2
+        match = Regexp.last_match
+        index = match.begin(0)
+        text = input[pos, index - pos]
+        pos = match.end(0)
+        add_text(codebuf, text) # unless text.empty?
+        add_pi_expr(codebuf, code, indicator)
+      end
+      rest = $' || input
+      add_text(codebuf, rest)
+    end
+
+    def add_pi_stmt(codebuf, code, pi_arg)  # :nodoc:
+      case pi_arg
+      when 'header' ;  @header = code
+      when 'footer' ;  @footer = code
+      when 'comment';  add_stmt(codebuf, "\n" * code.count("\n"))
+      when 'value'  ;  add_expr_literal(codebuf, code)
+      else          ;  add_stmt(codebuf, code)
+      end
+    end
+
+    def add_pi_expr(codebuf, code, indicator)  # :nodoc:
       case indicator
-      when '='
-        add_expr_literal(src, code)
-      when '=='
-        add_expr_escaped(src, code)
-      when '==='
-        add_expr_debug(src, code)
+      when  nil, '', '=='    # @{...}@ or <%== ... %>
+        @escape == false ? add_expr_literal(codebuf, code) : add_expr_escaped(codebuf, code)
+      when  '!', '='         # @!{...}@ or <%= ... %>
+        @escape == false ? add_expr_escaped(codebuf, code) : add_expr_literal(codebuf, code)
+      when  '!!', '==='      # @!!{...}@ or <%=== ... %>
+        add_expr_debug(codebuf, code)
+      else
+        # ignore
       end
     end
 
-    ## .[abstract] add expression literal code to src. this is called by add_expr().
-    def add_expr_literal(src, code)
-      not_implemented
+    ## (obsolete) equivarent to parse_stmts(), but a little slower than it.
+    def parse_stmts2(codebuf, input)   # :nodoc:
+      #regexp = pattern_regexp(@pattern)
+      @pi ||= 'e'
+      unless @embedded_pattern
+        ch = Regexp.escape(@embchar)
+        if @pattern
+          left, right = @pattern.split(' ')
+          @embedded_pattern = /(^[ \t]*)?<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/m
+        else
+          @embedded_pattern = /(^[ \t]*)?<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}/m
+        end
+      end
+      pos = 0
+      input.scan(@embedded_pattern) do |lspace, pi_arg, stmt, rspace,
+                                    indicator1, expr1, indicator2, expr2|
+        match = Regexp.last_match
+        index = match.begin(0)
+        text = input[pos, index - pos]
+        pos = match.end(0)
+        add_text(codebuf, text)  # unless text.empty?
+        if stmt
+          code = stmt
+          if @trim && lspace && rspace
+            add_pi_stmt(codebuf, "#{lspace}#{code}#{rspace}", pi_arg)
+          else
+            add_text(codebuf, lspace)
+            add_pi_stmt(codebuf, code, pi_arg)
+            add_text(codebuf, rspace)
+          end
+        else
+          code = expr1 || expr2
+          indicator = indicator1 || indicator2
+          add_pi_expr(codebuf, code, indicator)
+        end
+      end
+      rest = $' || input
+      add_text(codebuf, rest)
     end
 
-    ## .[abstract] add escaped expression code to src. this is called by add_expr().
-    def add_expr_escaped(src, code)
-      not_implemented
+  end
+
+
+end
+#--end of require 'erubis/converter'
+#--begin of require 'erubis/evaluator'
+##
+## $Rev: 32 $
+## $Release: 2.1.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+#--begin of require 'erubis/error'
+##
+## $Rev: 32 $
+## $Release: 2.1.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+module Erubis
+
+
+  ##
+  ## base error class
+  ##
+  class ErubisError < StandardError
+  end
+
+
+  ##
+  ## raised when method or function is not supported
+  ##
+  class NotSupportedError < ErubisError
+  end
+
+
+end
+#--end of require 'erubis/error'
+#--begin of require 'erubis/context'
+##
+## $Rev: 32 $
+## $Release: 2.1.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+
+module Erubis
+
+
+  ##
+  ## context object for Engine#evaluate
+  ##
+  ## ex.
+  ##   template = <<'END'
+  ##   Hello <%= @user %>!
+  ##   <% for item in @list %>
+  ##    - <%= item %>
+  ##   <% end %>
+  ##   END
+  ##
+  ##   context = Erubis::Context.new(:user=>'World', :list=>['a','b','c'])
+  ##   # or
+  ##   # context = Erubis::Context.new
+  ##   # context[:user] = 'World'
+  ##   # context[:list] = ['a', 'b', 'c']
+  ##
+  ##   eruby = Erubis::Eruby.new(template)
+  ##   print eruby.evaluate(context)
+  ##
+  class Context
+
+    def initialize(hash=nil)
+      hash.each do |name, value|
+        self[name] = value
+      end if hash
     end
 
-    ## .[abstract] add expression code to src for debug. this is called by add_expr().
-    def add_expr_debug(src, code)
-      not_implemented
+    def [](key)
+      return instance_variable_get("@#{key}")
     end
 
-    ## .[abstract] add @postamble to src
-    def add_postamble(src)
-      not_implemented
+    def []=(key, value)
+      return instance_variable_set("@#{key}", value)
+    end
+
+    def keys
+      return instance_variables.collect { |name| name[1,name.length-1] }
+    end
+
+  end
+
+
+end
+#--end of require 'erubis/context'
+
+
+module Erubis
+
+
+  ##
+  ## evaluate code
+  ##
+  module Evaluator
+
+    def self.supported_properties    # :nodoc:
+      return []
+    end
+
+    attr_accessor :src, :filename
+
+    def init_evaluator(properties)
+      @filename = properties[:filename]
+    end
+
+    def result(*args)
+      raise NotSupportedError.new("evaluation of code except Ruby is not supported.")
     end
 
+    def evaluate(*args)
+      raise NotSupportedError.new("evaluation of code except Ruby is not supported.")
+    end
+
+  end
+
+
+  ##
+  ## evaluator for Ruby
+  ##
+  module RubyEvaluator
+    include Evaluator
+
+    def self.supported_properties    # :nodoc:
+      list = Evaluator.supported_properties
+      return list
+    end
+
+    ## eval(@src) with binding object
+    def result(_binding_or_hash=TOPLEVEL_BINDING)
+      _arg = _binding_or_hash
+      if _arg.is_a?(Hash)
+        ## load _context data as local variables by eval
+        eval _arg.keys.inject("") { |s, k| s << "#{k.to_s} = _arg[#{k.inspect}];" }
+        _arg = binding()
+      end
+      return eval(@src, _arg, (@filename || '(erubis)'))
+    end
+
+    ## invoke context.instance_eval(@src)
+    def evaluate(context=Context.new)
+      context = Context.new(context) if context.is_a?(Hash)
+      return context.instance_eval(@src, (@filename || '(erubis)'))
+    end
+
+  end
+
+
+end
+#--end of require 'erubis/evaluator'
+#--already included require 'erubis/context'
+
+
+module Erubis
+
+
+  ##
+  ## (abstract) abstract engine class.
+  ## subclass must include evaluator and converter module.
+  ##
+  class Engine
+    #include Evaluator
+    #include Converter
+    #include Generator
+
+    # convert input string and set it to @src
+    def convert!(input)
+      @src = convert(input)
+    end
+
+    def initialize(input=nil, properties={})
+      #@input = input
+      init_generator(properties)
+      init_converter(properties)
+      init_evaluator(properties)
+      @src    = convert(input) if input
+    end
+
+    ## load file and create engine object
+    def self.load_file(filename, properties={})
+      input = File.open(filename, 'rb') { |f| f.read }
+      input.untaint   # is it ok?
+      properties[:filename] = filename
+      engine = self.new(input, properties)
+      return engine
+    end
+
+
+    ##
+    ## helper method to convert and evaluate input text with context object.
+    ## context may be Binding, Hash, or Object.
+    ##
+    def process(input, context=nil, filename=nil)
+      code = convert(input)
+      filename ||= '(erubis)'
+      if context.is_a?(Binding)
+        return eval(code, context, filename)
+      else
+        context = Context.new(context) if context.is_a?(Hash)
+        return context.instance_eval(code, filename)
+      end
+    end
+
+
+    ##
+    ## helper method evaluate Proc object iwth contect object.
+    ## context may be Binding, Hash, or Object.
+    ##
+    def process_proc(proc_obj, context=nil, filename=nil)
+      if context.is_a?(Binding)
+        filename ||= '(erubis)'
+        return eval(proc_obj, context, filename)
+      else
+        context = Context.new(context) if context.is_a?(Hash)
+        return context.instance_eval(&proc_obj)
+      end
+    end
+
+
   end  # end of class Engine
 
 
+  ##
+  ## (abstract) base engine class for Eruby, Eperl, Ejava, and so on.
+  ## subclass must include generator.
+  ##
+  class Basic::Engine < Engine
+    include Evaluator
+    include Basic::Converter
+    include Generator
+  end
+
+
+  class PI::Engine < Engine
+    include Evaluator
+    include PI::Converter
+    include Generator
+  end
+
+
 end
 #--end of require 'erubis/engine'
+#require 'erubis/generator'
+#require 'erubis/converter'
+#require 'erubis/evaluator'
+#require 'erubis/error'
+#require 'erubis/context'
 #--begin of require 'erubis/helper'
 ##
 ## $Rev: 21 $
-## $Release: 2.0.1 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -475,15 +857,12 @@ end
 #--end of require 'erubis/helper'
 #--begin of require 'erubis/enhancer'
 ##
-## $Rev: 21 $
-## $Release: 2.0.1 $
+## $Rev: 32 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
 
-#--already included require 'erubis/engine'
-
-
 module Erubis
 
 
@@ -517,11 +896,9 @@ module Erubis
     def add_expr(src, code, indicator)
       case indicator
       when '='
-        add_expr_escaped(src, code)
-        #add_expr_literal(src, code)
+        @escape ? add_expr_literal(src, code) : add_expr_escaped(src, code)
       when '=='
-        add_expr_literal(src, code)
-        #add_expr_escaped(src, code)
+        @escape ? add_expr_escaped(src, code) : add_expr_literal(src, code)
       when '==='
         add_expr_debug(src, code)
       end
@@ -617,11 +994,11 @@ module Erubis
       end
     end
 
-    def evaluate(context=Context.new)
+    def evaluate(context=nil)
       _src = @src
       if context.is_a?(Hash)
         context.each do |key, val| instance_variable_set("@#{key}", val) end
-      else
+      elsif context
         context.instance_variables.each do |name|
           instance_variable_set(name, context.instance_variable_get(name))
         end
@@ -728,46 +1105,85 @@ module Erubis
   ## remove text and leave code, especially useful when debugging.
   ##
   ## ex.
-  ##   $ erubis -s -e NoText file.eruby | more
+  ##   $ erubis -s -E NoText file.eruby | more
+  ##
+  ## this is language independent.
+  ##
+  module NoTextEnhancer
+
+    def self.desc   # :nodoc:
+      "remove text and leave code (useful when debugging)"
+    end
+
+    def add_text(src, text)
+      src << ("\n" * text.count("\n"))
+      if text[-1] != ?\n
+        text =~ /^(.*?)\z/
+        src << (' ' * $1.length)
+      end
+    end
+
+  end
+
+
+  ##
+  ## remove code and leave text, especially useful when validating HTML tags.
+  ##
+  ## ex.
+  ##   $ erubis -s -E NoCode file.eruby | tidy -errors
   ##
   ## this is language independent.
   ##
-  module NoTextEnhancer
+  module NoCodeEnhancer
 
     def self.desc   # :nodoc:
-      "remove text and leave code (useful when debugging)"
+      "remove code and leave text (useful when validating HTML)"
+    end
+
+    def add_preamble(src)
+    end
+
+    def add_postamble(src)
     end
 
     def add_text(src, text)
-      src << ("\n" * text.count("\n"))
-      if text[-1] != ?\n
-        text =~ /^(.*?)\z/
-        src << (' ' * $1.length)
-      end
+      src << text
+    end
+
+    def add_expr(src, code, indicator)
+      src << "\n" * code.count("\n")
+    end
+
+    def add_stmt(src, code)
+      src << "\n" * code.count("\n")
     end
 
   end
 
 
   ##
-  ## get compile faster, but spaces around '<%...%>' are not trimmed.
+  ## get convert faster, but spaces around '<%...%>' are not trimmed.
   ##
   ## this is language-independent.
   ##
   module SimplifyEnhancer
 
     def self.desc   # :nodoc:
-      "get compile faster but leave spaces around '<% %>'"
+      "get convert faster but leave spaces around '<% %>'"
     end
 
-    #DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
-    SIMPLE_REGEXP = /(.*?)<%(=+|\#)?(.*?)-?%>/m
+    #DEFAULT_REGEXP = /(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
+    SIMPLE_REGEXP = /<%(=+|\#)?(.*?)-?%>/m
 
-    def compile(input)
+    def convert(input)
       src = ""
       add_preamble(src)
       #regexp = pattern_regexp(@pattern)
-      input.scan(SIMPLE_REGEXP) do |text, indicator, code|
+      pos = 0
+      input.scan(SIMPLE_REGEXP) do |indicator, code|
+        index = Regexp.last_match.begin(0)
+        text = input[pos, index - pos]
+        pos = index + $&.length()
         add_text(src, text)
         if !indicator              # <% %>
           add_stmt(src, code)
@@ -952,7 +1368,7 @@ module Erubis
 
     attr_accessor :header, :footer
 
-    def compile(input)
+    def convert(input)
       source = super
       return @src = "#{@header}#{source}#{@footer}"
     end
@@ -965,27 +1381,34 @@ end
 #require 'erubis/tiny'
 #--begin of require 'erubis/engine/eruby'
 ##
-## $Rev: 21 $
-## $Release: 2.0.1 $
+## $Rev: 33 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
 #--already included require 'erubis/engine'
 #--already included require 'erubis/enhancer'
+#--already included require 'abstract'
 
 
 module Erubis
 
 
   ##
-  ## engine for Ruby
+  ## code generator for Ruby
   ##
-  class Eruby < Engine
+  module RubyGenerator
+    include Generator
     #include StringBufferEnhancer
     include ArrayBufferEnhancer
 
+    def init_generator(properties={})
+      super
+      @escapefunc ||= "Erubis::XmlHelper.escape_xml"
+    end
+
     def self.supported_properties()  # :nodoc:
-      return super
+      return []
     end
 
     def escape_text(text)
@@ -993,8 +1416,7 @@ module Erubis
     end
 
     def escaped_expr(code)
-      @escape ||= "Erubis::XmlHelper.escape_xml"
-      return "#{@escape}(#{code})"
+      return "#{@escapefunc}(#{code})"
     end
 
     #--
@@ -1036,6 +1458,15 @@ module Erubis
   end
 
 
+  ##
+  ## engine for Ruby
+  ##
+  class Eruby < Basic::Engine
+    include RubyEvaluator
+    include RubyGenerator
+  end
+
+
   ##
   ## swtich '<%= %>' to escaped and '<%== %>' to not escaped
   ##
@@ -1054,6 +1485,18 @@ module Erubis
   end
 
 
+  class PI::Eruby < PI::Engine
+    include RubyEvaluator
+    include RubyGenerator
+
+    def init_converter(properties={})
+      @pi = 'rb'
+      super(properties)
+    end
+
+  end
+
+
 end
 #--end of require 'erubis/engine/eruby'
 #require 'erubis/engine/enhanced'    # enhanced eruby engines
@@ -1065,11 +1508,10 @@ end
 #require 'erubis/engine/eperl'
 #require 'erubis/engine/ejavascript'
 
-
 #--begin of require 'erubis/local-setting'
 ##
 ## $Rev: 13 $
-## $Release: 2.0.1 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1081,8 +1523,8 @@ end
 #--end of require 'erubis'
 #--begin of require 'erubis/tiny'
 ##
-## $Rev: 21 $
-## $Release: 2.0.1 $
+## $Rev: 35 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1099,16 +1541,21 @@ module Erubis
   ##
   class TinyEruby
 
-    def initialize(input)
-      @src = compile(input)
+    def initialize(input=nil)
+      @src = convert(input) if input
     end
     attr_reader :src
 
-    EMBEDDED_PATTERN = /(.*?)<%(=+|\#)?(.*?)-?%>/m
+    EMBEDDED_PATTERN = /<%(=+|\#)?(.*?)-?%>/m
 
-    def compile(input)
+    def convert(input)
       src = "_buf = [];"           # preamble
-      input.scan(EMBEDDED_PATTERN) do |text, indicator, code|
+      pos = 0
+      input.scan(EMBEDDED_PATTERN) do |indicator, code|
+        match = Regexp.last_match
+        index = match.begin(0)
+        text  = input[pos, index - pos]
+        pos   = match.end(0)
         src << " _buf << '" << escape_text(text) << "';"
         if !indicator              # <% %>
           src << code << ";"
@@ -1144,12 +1591,81 @@ module Erubis
 
   end
 
+
+
+  module PI
+  end
+
+  class PI::TinyEruby
+
+    def initialize(input=nil, options={})
+      @escape  = options[:escape] || 'Erubis::XmlHelper.escape_xml'
+      @src = convert(input) if input
+    end
+
+    attr_reader :src
+
+    EMBEDDED_PATTERN = /(^[ \t]*)?<\?rb(\s.*?)\?>([ \t]*\r?\n)?|\$(!*)?\{(.*?)\}/
+
+    def convert(input)
+      src = "_buf = [];"           # preamble
+      pos = 0
+      input.scan(EMBEDDED_PATTERN) do |lspace, stmtcode, rspace, indicator, exprcode|
+        match = Regexp.last_match
+        index = match.begin(0)
+        text  = input[pos, index - pos]
+        pos   = match.end(0)
+        if stmtcode                # <?rb ... ?>
+          code = stmtcode
+          src << " _buf << '" << escape_text(text) << "';"
+          if lspace && rspace
+            src << "#{lspace}#{code}#{rspace}"
+          else
+            src << " _buf << '#{lspace}';" if lspace
+            src << code << ";"
+            src << " _buf << '#{rspace}';" if rspace
+          end
+        else                       # ${...}, $!{...}
+          code = exprcode
+          if indicator.nil? || indicator.empty?
+            src << " _buf << #{@escape}(" << code << ");"
+          elsif indicator == '!'
+            src << " _buf << (" << code << ").to_s;"
+          end
+        end
+      end
+      rest = $' || input
+      src << " _buf << '" << escape_text(rest) << "';"
+      src << "\n_buf.join\n"       # postamble
+      return src
+    end
+
+    def escape_text(text)
+      return text.gsub!(/['\\]/, '\\\\\&') || text
+    end
+
+    def result(binding=TOPLEVEL_BINDING)
+      eval @src, binding
+    end
+
+    def evaluate(context=Object.new)
+      if context.is_a?(Hash)
+        obj = Object.new
+        context.each do |k, v| obj.instance_variable_set("@#{k}", v) end
+        context = obj
+      end
+      context.instance_eval @src
+    end
+
+  end
+
+
 end
 #--end of require 'erubis/tiny'
 #--begin of require 'erubis/engine/enhanced'
 ##
-## $Rev: 19 $
-## $Release: 2.0.1 $
+## $Rev: 27 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1216,6 +1732,11 @@ module Erubis
   end
 
 
+  class NoCodeEruby < Eruby
+    include NoCodeEnhancer
+  end
+
+
   class SimplifiedEruby < Eruby
     include SimplifyEnhancer
   end
@@ -1252,8 +1773,8 @@ end
 #--end of require 'erubis/engine/enhanced'
 #--begin of require 'erubis/engine/optimized'
 ##
-## $Rev: 21 $
-## $Release: 2.0.1 $
+## $Rev: 31 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1264,19 +1785,18 @@ end
 module Erubis
 
 
-  ##
-  ## Eruby class which generates optimized ruby code
-  ##
-  class OptimizedEruby < Engine    # Eruby
+  module OptimizedGenerator
+    include Generator
 
     def self.supported_properties()  # :nodoc:
-      return super
+      return []
     end
 
-    def initialize(input, properties={})
+    def init_generator(properties={})
+      super
+      @escapefunc ||= "Erubis::XmlHelper.escape_xml"
       @initialized = false
       @prev_is_expr = false
-      super
     end
 
     protected
@@ -1286,8 +1806,8 @@ module Erubis
     end
 
     def escaped_expr(code)
-      @escape ||= 'Erubis::XmlHelper.escape_xml'
-      return "#{@escape}(#{code})"
+      @escapefunc ||= 'Erubis::XmlHelper.escape_xml'
+      return "#{@escapefunc}(#{code})"
     end
 
     def switch_to_expr(src)
@@ -1351,6 +1871,21 @@ module Erubis
   end  # end of class OptimizedEruby
 
 
+  ##
+  ## Eruby class which generates optimized ruby code
+  ##
+  class OptimizedEruby < Basic::Engine    # Eruby
+    include RubyEvaluator
+    include OptimizedGenerator
+
+    def init_converter(properties={})
+      @pi = 'rb'
+      super(properties)
+    end
+
+  end
+
+
   ##
   ## XmlEruby class which generates optimized ruby code
   ##
@@ -1369,8 +1904,8 @@ end
 #--already included require 'erubis/engine/eruby'
 #--begin of require 'erubis/engine/ephp'
 ##
-## $Rev: 24 $
-## $Release: 2.0.1 $
+## $Rev: 31 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1381,13 +1916,16 @@ end
 module Erubis
 
 
-  ##
-  ## engine for PHP
-  ##
-  class Ephp < Engine
+  module PhpGenerator
+    include Generator
 
     def self.supported_properties()  # :nodoc:
-      return super
+      return []
+    end
+
+    def init_generator(properties={})
+      super
+      @escapefunc ||= 'htmlspecialchars'
     end
 
     def add_preamble(src)
@@ -1402,17 +1940,13 @@ module Erubis
       src << escape_text(text)
     end
 
-    def escaped_expr(code)
-      @escape ||= 'htmlspecialchars'
-      return "#{@escape}(#{code.strip})"
-    end
-
     def add_expr_literal(src, code)
-      src << "<?php echo #{code.strip}; ?>"
+      code.strip!
+      src << "<?php echo #{code}; ?>"
     end
 
     def add_expr_escaped(src, code)
-      src << "<?php echo #{escaped_expr(code)}; ?>"
+      add_expr_literal(src, escaped_expr(code))
     end
 
     def add_expr_debug(src, code)
@@ -1439,6 +1973,14 @@ module Erubis
   end
 
 
+  ##
+  ## engine for PHP
+  ##
+  class Ephp < Basic::Engine
+    include PhpGenerator
+  end
+
+
   class EscapedEphp < Ephp
     include EscapeEnhancer
   end
@@ -1449,12 +1991,23 @@ module Erubis
   #end
 
 
+  class PI::Ephp < PI::Engine
+    include PhpGenerator
+
+    def init_converter(properties={})
+      @pi = 'php'
+      super(properties)
+    end
+
+  end
+
+
 end
 #--end of require 'erubis/engine/ephp'
 #--begin of require 'erubis/engine/ec'
 ##
-## $Rev: 24 $
-## $Release: 2.0.1 $
+## $Rev: 33 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1465,22 +2018,21 @@ end
 module Erubis
 
 
-  ##
-  ## engine for C
-  ##
-  class Ec < Engine
+  module CGenerator
+    include Generator
 
     def self.supported_properties()  # :nodoc:
-      list = super
-      list << [:indent, '',       "indent spaces (ex. '  ')"]
-      list << [:out,    'stdout', "output file pointer name"]
-      return list
+      return [
+              [:indent, '',       "indent spaces (ex. '  ')"],
+              [:out,    'stdout', "output file pointer name"],
+            ]
     end
 
-    def initialize(input, properties={})
+    def init_generator(properties={})
+      super
+      @escapefunc ||= "escape"
       @indent = properties[:indent] || ''
       @out = properties[:out] || 'stdout'
-      super
     end
 
     def add_preamble(src)
@@ -1494,13 +2046,7 @@ module Erubis
     end
 
     def escaped_expr(code)
-      @escape ||= "escape"
-      code.strip!
-      if code =~ /\A(\".*?\")\s*,\s*(.*)/
-        return "#{$1}, #{@escape}(#{$2})"
-      else
-        return "#{@escape}(#{code})"
-      end
+      return "#{@escapefunc}(#{code.strip}, #{@out})"
     end
 
     def add_text(src, text)
@@ -1528,7 +2074,7 @@ module Erubis
 
     def add_expr_escaped(src, code)
       src << @indent if src.empty? || src[-1] == ?\n
-      src << " fprintf(#{@out}, " << escaped_expr(code) << ');'
+      src << ' ' << escaped_expr(code) << ';'
     end
 
     def add_expr_debug(src, code)
@@ -1548,6 +2094,14 @@ module Erubis
   end
 
 
+  ##
+  ## engine for C
+  ##
+  class Ec < Basic::Engine
+    include CGenerator
+  end
+
+
   class EscapedEc < Ec
     include EscapeEnhancer
   end
@@ -1557,13 +2111,23 @@ module Erubis
   #  include EscapeEnhancer
   #end
 
+  class PI::Ec < PI::Engine
+    include CGenerator
+
+    def init_converter(properties={})
+      @pi = 'c'
+      super(properties)
+    end
+
+  end
+
 
 end
 #--end of require 'erubis/engine/ec'
 #--begin of require 'erubis/engine/ejava'
 ##
-## $Rev: 24 $
-## $Release: 2.0.1 $
+## $Rev: 31 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1574,24 +2138,23 @@ end
 module Erubis
 
 
-  ##
-  ## engine for Java
-  ##
-  class Ejava < Engine
+  module JavaGenerator
+    include Generator
 
     def self.supported_properties()   # :nodoc:
-      list = super
-      list << [:indent,   '',       "indent spaces (ex. '  ')"]
-      list << [:buf,      '_buf',   "output buffer name"]
-      list << [:bufclass, 'StringBuffer', "output buffer class (ex. 'StringBuilder')"]
-      return list
+      return [
+              [:indent,   '',       "indent spaces (ex. '  ')"],
+              [:buf,      '_buf',   "output buffer name"],
+              [:bufclass, 'StringBuffer', "output buffer class (ex. 'StringBuilder')"],
+            ]
     end
 
-    def initialize(input, properties={})
+    def init_generator(properties={})
+      super
+      @escapefunc ||= 'escape'
       @indent = properties[:indent] || ''
       @buf = properties[:buf] || '_buf'
       @bufclass = properties[:bufclass] || 'StringBuffer'
-      super
     end
 
     def add_preamble(src)
@@ -1603,11 +2166,6 @@ module Erubis
       return text.gsub!(/[\r\n\t"\\]/) { |m| @@table_[m] } || text
     end
 
-    def escaped_expr(code)
-      @escape ||= 'escape'
-      return "#{@escape}(#{code.strip})"
-    end
-
     def add_text(src, text)
       return if text.empty?
       src << (src.empty? || src[-1] == ?\n ? @indent : ' ')
@@ -1627,12 +2185,12 @@ module Erubis
 
     def add_expr_literal(src, code)
       src << @indent if src.empty? || src[-1] == ?\n
-      src << ' ' << @buf << '.append(' << code.strip << ');'
+      code.strip!
+      src << " #{@buf}.append(#{code});"
     end
 
     def add_expr_escaped(src, code)
-      src << @indent if src.empty? || src[-1] == ?\n
-      src << ' ' << @buf << '.append(' << escaped_expr(code) << ');'
+      add_expr_literal(src, escaped_expr(code))
     end
 
     def add_expr_debug(src, code)
@@ -1644,11 +2202,20 @@ module Erubis
     def add_postamble(src)
       src << "\n" if src[-1] == ?;
       src << @indent << "return " << @buf << ".toString();\n"
+      #src << @indent << "System.out.print(" << @buf << ".toString());\n"
     end
 
   end
 
 
+  ##
+  ## engine for Java
+  ##
+  class Ejava < Basic::Engine
+    include JavaGenerator
+  end
+
+
   class EscapedEjava < Ejava
     include EscapeEnhancer
   end
@@ -1658,13 +2225,22 @@ module Erubis
   #  include EscapeEnhancer
   #end
 
+  class PI::Ejava < PI::Engine
+    include JavaGenerator
+
+    def init_converter(properties={})
+      @pi = 'java'
+      super(properties)
+    end
+
+  end
 
 end
 #--end of require 'erubis/engine/ejava'
 #--begin of require 'erubis/engine/escheme'
 ##
-## $Rev: 21 $
-## $Release: 2.0.1 $
+## $Rev: 33 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1675,20 +2251,19 @@ end
 module Erubis
 
 
-  ##
-  ## engine for Scheme
-  ##
-  class Escheme < Engine
+  module SchemeGenerator
+    include Generator
 
     def self.supported_properties()  # :nodoc:
-      list = super
-      list << [:func,  '_add',   "function name (ex. 'display')"]
-      return list
+      return [
+              [:func,  '_add',   "function name (ex. 'display')"],
+              ]
     end
 
-    def initialize(input, properties={})
-      @func = properties[:func] || '_add'   # or 'display'
+    def init_generator(properties={})
       super
+      @escapefunc ||= 'escape'
+      @func = properties[:func] || '_add'   # or 'display'
     end
 
     def add_preamble(src)
@@ -1706,8 +2281,8 @@ module Erubis
     end
 
     def escaped_expr(code)
-      @escape ||= 'escape'
-      return "(#{@escape} #{code.strip})"
+      code.strip!
+      return "(#{@escapefunc} #{code})"
     end
 
     def add_text(src, text)
@@ -1726,11 +2301,12 @@ module Erubis
     end
 
     def add_expr_literal(src, code)
-      src << "(#{@func} " << code.strip << ')'
+      code.strip!
+      src << "(#{@func} #{code})"
     end
 
     def add_expr_escaped(src, code)
-      src << "(#{@func} " << escaped_expr(code) << ')'
+      add_expr_literal(src, escaped_expr(code))
     end
 
     def add_expr_debug(src, code)
@@ -1747,6 +2323,14 @@ module Erubis
   end
 
 
+  ##
+  ## engine for Scheme
+  ##
+  class Escheme < Basic::Engine
+    include SchemeGenerator
+  end
+
+
   class EscapedEscheme < Escheme
     include EscapeEnhancer
   end
@@ -1757,12 +2341,23 @@ module Erubis
   #end
 
 
+  class PI::Escheme < PI::Engine
+    include SchemeGenerator
+
+    def init_converter(properties={})
+      @pi = 'scheme'
+      super(properties)
+    end
+
+  end
+
+
 end
 #--end of require 'erubis/engine/escheme'
 #--begin of require 'erubis/engine/eperl'
 ##
-## $Rev: 24 $
-## $Release: 2.0.1 $
+## $Rev: 40 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1773,24 +2368,23 @@ end
 module Erubis
 
 
-  ##
-  ## engine for Perl
-  ##
-  class Eperl < Engine
+  module PerlGenerator
+    include Generator
 
     def self.supported_properties()  # :nodoc:
-      list = super
-      list << [:func, 'print', "function name"]
-      return list
+      return [
+              [:func, 'print', "function name"],
+              ]
     end
 
-    def initialize(input, properties={})
-      @func = properties[:func] || 'print'
+    def init_generator(properties={})
       super
+      @escapefunc ||= 'encode_entities'
+      @func = properties[:func] || 'print'
     end
 
     def add_preamble(src)
-      # empty
+      src << "use HTML::Entities; ";
     end
 
     def escape_text(text)
@@ -1801,17 +2395,13 @@ module Erubis
       src << @func << "('" << escape_text(text) << "'); " unless text.empty?
     end
 
-    def escaped_expr(code)
-      @escape ||= 'escape'
-      return "escape(#{code.strip})"
-    end
-
     def add_expr_literal(src, code)
-      src << @func << "(" << code.strip << "); "
+      code.strip!
+      src << @func << "(" << code << "); "
     end
 
     def add_expr_escaped(src, code)
-      src << @func << "(" << escaped_expr(code) << "); "
+      add_expr_literal(src, escaped_expr(code))
     end
 
     def add_expr_debug(src, code)
@@ -1831,6 +2421,14 @@ module Erubis
   end
 
 
+  ##
+  ## engine for Perl
+  ##
+  class Eperl < Basic::Engine
+    include PerlGenerator
+  end
+
+
   class EscapedEperl < Eperl
     include EscapeEnhancer
   end
@@ -1841,12 +2439,23 @@ module Erubis
   #end
 
 
+  class PI::Eperl < PI::Engine
+    include PerlGenerator
+
+    def init_converter(properties={})
+      @pi = 'perl'
+      super(properties)
+    end
+
+  end
+
+
 end
 #--end of require 'erubis/engine/eperl'
 #--begin of require 'erubis/engine/ejavascript'
 ##
-## $Rev: 24 $
-## $Release: 2.0.1 $
+## $Rev: 31 $
+## $Release: 2.1.0 $
 ## copyright(c) 2006 kuwata-lab all rights reserved.
 ##
 
@@ -1857,23 +2466,21 @@ end
 module Erubis
 
 
-  ##
-  ## engine for JavaScript
-  ##
-  class Ejavascript < Engine
+  module JavascriptGenerator
+    include Generator
 
     def self.supported_properties()   # :nodoc:
-      list = super
+      list = []
       #list << [:indent,   '',       "indent spaces (ex. '  ')"]
       #list << [:buf,      '_buf',   "output buffer name"]
       return list
     end
 
-    def initialize(input, properties={})
+    def init_generator(properties={})
+      super
+      @escapefunc ||= 'escape'
       @indent = properties[:indent] || ''
       @buf = properties[:out] || '_buf'
-      #@bufclass = properties[:outclass] || 'StringBuffer'
-      super
     end
 
     def add_preamble(src)
@@ -1885,11 +2492,6 @@ module Erubis
       return text.gsub!(/[\r\n\t"\\]/) { |m| @@table_[m] } || text
     end
 
-    def escaped_expr(code)
-      @escape ||= 'escape'
-      return "#{@escape}(#{code.strip})"
-    end
-
     def add_indent(src, indent)
       src << (src.empty? || src[-1] == ?\n ? indent : ' ')
     end
@@ -1913,12 +2515,12 @@ module Erubis
 
     def add_expr_literal(src, code)
       add_indent(src, @indent)
-      src << @buf << '.push(' << code.strip << ');'
+      code.strip!
+      src << "#{@buf}.push(#{code});"
     end
 
     def add_expr_escaped(src, code)
-      add_indent(src, @indent)
-      src << @buf << '.push(' << escaped_expr(code) << ');'
+      add_expr_literal(src, escaped_expr(code))
     end
 
     def add_expr_debug(src, code)
@@ -1935,6 +2537,14 @@ module Erubis
   end
 
 
+  ##
+  ## engine for JavaScript
+  ##
+  class Ejavascript < Basic::Engine
+    include JavascriptGenerator
+  end
+
+
   class EscapedEjavascript < Ejavascript
     include EscapeEnhancer
   end
@@ -1945,6 +2555,17 @@ module Erubis
   #end
 
 
+  class PI::Ejavascript < PI::Engine
+    include JavascriptGenerator
+
+    def init_converter(properties={})
+      @pi = 'js'
+      super(properties)
+    end
+
+  end
+
+
 end
 #--end of require 'erubis/engine/ejavascript'
 
@@ -2043,15 +2664,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
@@ -2061,31 +2682,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
 
@@ -2095,7 +2718,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)
@@ -2107,42 +2730,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
@@ -2164,7 +2806,7 @@ END
     end
 
     def version
-      release = ('$Release: 2.0.1 $' =~ /([.\d]+)/) && $1
+      release = ('$Release: 2.1.0 $' =~ /([.\d]+)/) && $1
       return release
     end
 
@@ -2214,27 +2856,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 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)
-      unless classname
-        classname = lang =~ /\Axml(.*)/ ? "EscapedE#{$1}" : "E#{lang}"
-      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
@@ -2273,25 +2930,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