erubis 1.1.0 → 2.0.0

data/ChangeLog

@@ -1,25 +1,52 @@
-# $Rev$
-# $Release: 1.1.0 $
+# $Rev: 21 $
+# $Release: 2.0.0 $
 # copyright(c) 2006 kuwata-lab all rights reserved.
 
-- release:   1.1
-  date:      205-03-05
-  desc:
-    - tag:   enhance
-      text:  '<%# ... %>' is supported
-    - tag:   enhance
-      text:  PrintEnhancer, PrintEruby, and PrintXmlEruby added
+- release:   2.0.0
+  date:      2006-05-20
+  changes:
+    - module 'PrintEnhancer' is renamed to 'PrintEnabledEnahncer'
+    - module 'FastEnhancer' and class 'FastEruby' is obsolete because they are integrated into Eruby class
+    - Eruby#evaluate() calls instance_eval() instead of eval()
+    - XmlEruby.escape_xml() is moved to XmlHelper.escape_xml()
+  enhances:
+    - multi programming language support (Ruby/PHP/C/Java/Scheme/Perl/Javascript)
+    - class Eruby runs very fast because FastEnhancer module is integrated into Eruby by default
+    - TinyEruby class (tiny.rb) is added
+    - module ArrayBufferEnhancer added
+    - module ArrayEnhancer added
+    - module BiPatternEnhancer added
+    - module EscapeEnhancer added
+    - module HeaderFooterEnhancer added
+    - module NoTextEnhancer added
+    - module PercentLineEnhancer added
+    - module PrintEnabledEnhancer added
+    - module PrintOutEnhancer added
+    - module SimplifyEnhancer added
+    - module StringBufferEnhancer added
+    - module StringIOEnhancer added
+    - command-line option '-b' (body only) added
+    - command-line option '-e' (escape) added
+    - command-line option '-l' (lang) added
+    - command-line option '-E' (enhancer) added
+    - command-line option '-I' (require path) added
+    - command-line option '-K' (kanji code) added
+    - command-line option '-S' (string to symbol) added
+    - command-line option '-B' (call result(binding())) added
+
+- release:   1.1.0
+  date:      2006-03-05
+  enhances:
+    - '<%# ... %>' is supported
+    - PrintEnhancer, PrintEruby, and PrintXmlEruby added
 
 - release:   1.0.1
-  date:      2005-02-01
-  desc:
-    - tag:   bugfix
-      text:  bin/erubis is available with RubyGems
+  date:      2006-02-01
+  bugfixes:
+    - bin/erubis is available with RubyGems
 
 - release:   1.0.0
-  date:      2005-02-01
-  desc:
-    - tag:   note
-      text:  first release
-
+  date:      2006-02-01
+  bugfixes:
+    - first release
 

data/README.txt

@@ -0,0 +1,80 @@
+= README
+
+release::	$Release: 2.0.0 $
+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
+* Multi-language support (Ruby/PHP/C/Java/Scheme/Perl/Javascript)
+
+Erubis is implemented in pure Ruby.  It requires Ruby 1.8 or higher.
+
+See doc/users-guide.html for details.
+
+
+
+== Installation
+
+* If you have installed RubyGems, just type <tt>gem install --remote erubis</tt>.
+
+    $ sudo gem install --remote erubis
+
+* Else install abstract[http://rubyforge.org/projects/abstract/] at first,
+  and download erubis_X.X.X.tar.bz2 and install it by setup.rb.
+
+    $ tar xjf abstract_X.X.X.tar.bz2
+    $ cd abstract_X.X.X/
+    $ sudo ruby setup.rb
+    $ cd ..
+    $ tar xjf erubis_X.X.X.tar.bz2
+    $ cd erubis_X.X.X/
+    $ sudo ruby setup.rb
+
+* (Optional) It is able to merge 'lib/**/*.rb' into 'bin/erubis' by
+  'contrib/inline-require' script.
+
+    $ tar xjf erubis_X.X.X.tar.bz2
+    $ cd erubis_X.X.X/
+    $ cp /tmp/abstract_X.X.X/lib/abstract.rb lib
+    $ unset RUBYLIB
+    $ contrib/inline-require -I lib bin/erubis > contrib/erubis
+
+
+
+== Exploring Guide
+
+If you are exploring Eruby, see the following class at first.
+* Erubis::TinyEruby (erubis/tiny.rb) --
+  the most simple eRuby implementation.
+* Erubis::Engine (erubis/engine.rb) --
+  base class of Eruby, Ephp, Ejava, and so on.
+* Erubis::Eruby (erubis/engine/eruby.rb) --
+  engine class for eRuby.
+
+
+
+== Benchmark
+
+'benchmark/erubybenchmark.rb' is a benchmark script of Erubis.
+Try 'ruby erubybenchmark.rb' in benchmark directory.
+
+
+
+== License
+
+GPL ver.2
+
+
+
+== Author
+
+makoto kuwata <kwa(at)kuwata-lab.com>

data/benchmark/erubybench-lib.rb

@@ -0,0 +1,189 @@
+
+module Erubis
+
+  class Eruby2 < Eruby
+    def finalize_src(src)
+      #src << "\nprint _buf.join; nil\n"
+      src << "\n_buf.join; ''\n"
+    end
+  end
+
+  class ExprStrippedEruby < Eruby
+    def add_expr(src, code, indicator)
+      super(src, code.strip! || code, indicator)
+    end
+  end
+
+
+  ##
+  ## use $stdout
+  ##
+  class TinyStdoutEruby
+
+    def initialize(input)
+      @src = compile(input)
+    end
+    attr_reader :src
+
+    def result(binding=TOPLEVEL_BINDING)
+      eval @src, binding
+    end
+
+    EMBEDDED_PATTERN = /(.*?)<%(=+|\#)?(.*?)-?%>/m
+
+    def compile(input)
+      src = "_buf = $stdout;"           # preamble
+      input.scan(EMBEDDED_PATTERN) do |text, indicator, code|
+        src << " _buf << '" << escape_text(text) << "';"
+        if !indicator              # <% %>
+          src << code << ";"
+        elsif indicator[0] == ?\#  # <%# %>
+          n = code.count("\n")
+          add_stmt(src, "\n" * n)
+        else                       # <%= %>
+          src << " _buf << (" << code << ").to_s;"
+        end
+      end
+      rest = $' || input
+      src << " _buf << '" << escape_text(rest) << "';"
+      src << "\nnil\n"       # postamble
+      return src
+    end
+
+    def escape_text(text)
+      return text.gsub!(/['\\]/, '\\\\\&') || text
+    end
+
+  end
+
+
+  ##
+  ## use print statement
+  ##
+  class TinyPrintEruby
+
+    def initialize(input)
+      @src = compile(input)
+    end
+    attr_reader :src
+
+    def result(binding=TOPLEVEL_BINDING)
+      eval @src, binding
+    end
+
+    EMBEDDED_PATTERN = /(.*?)<%(=+|\#)?(.*?)-?%>/m
+
+    def compile(input)
+      src = ""
+      input.scan(EMBEDDED_PATTERN) do |text, indicator, code|
+        src << " print '" << escape_text(text) << "';"
+        if !indicator              # <% %>
+          src << code << ";"
+        elsif indicator[0] == ?\#  # <%# %>
+          n = code.count("\n")
+          add_stmt(src, "\n" * n)
+        else                       # <%= %>
+          src << " print((" << code << ").to_s);"
+        end
+      end
+      rest = $' || input
+      src << " print '" << escape_text(rest) << "';"
+      src << "\nnil\n"
+      return src
+    end
+
+    def escape_text(text)
+      return text.gsub!(/['\\]/, '\\\\\&') || text
+    end
+
+  end
+
+
+  ##
+  ## for test
+  ##
+  class Optimized2Eruby < Eruby   # :nodoc:
+
+    def self.supported_properties()  # :nodoc:
+      return super
+    end
+
+    def initialize(input, properties={})
+      @initialized = false
+      #@prev_is_expr = false
+      super
+    end
+
+    protected
+
+    def escape_text(text)
+      text.gsub(/['\\]/, '\\\\\&')   # "'" => "\\'",  '\\' => '\\\\'
+    end
+
+    def escaped_expr(code)
+      return "Erubis::XmlHelper.escape_xml(#{code})"
+    end
+
+    #def switch_to_expr(src)
+    #  return if @prev_is_expr
+    #  @prev_is_expr = true
+    #  src << ' _buf'
+    #end
+
+    #def switch_to_stmt(src)
+    #  return unless @prev_is_expr
+    #  @prev_is_expr = false
+    #  src << ';'
+    #end
+
+    def add_preamble(src)
+      @initialized = false
+      #@prev_is_expr = false
+    end
+
+    def add_text(src, text)
+      return if text.empty?
+      if @initialized
+        #switch_to_expr(src)
+        #src << " << '" << escape_text(text) << "'"
+        src << "_buf << '" << escape_text(text) << "';"
+      else
+        src << "_buf = '" << escape_text(text) << "';"
+        @initialized = true
+      end
+    end
+
+    def add_stmt(src, code)
+      #switch_to_stmt(src) if @initialized
+      #super
+      src << code << ';'
+    end
+
+    def add_expr_literal(src, code)
+      unless @initialized; src << "_buf = ''"; @initialized = true; end
+      #switch_to_expr(src)
+      #src << " << (" << code << ").to_s"
+      src << " _buf << (" << code << ").to_s;"
+    end
+
+    def add_expr_escaped(src, code)
+      unless @initialized; src << "_buf = ''"; @initialized = true; end
+      #switch_to_expr(src)
+      #src << " << " << escaped_expr(code)
+      src << " _buf << " << escaped_expr(code) << ';'
+    end
+
+    def add_expr_debug(src, code)
+      code.strip!
+      s = (code.dump =~ /\A"(.*)"\z/) && $1
+      src << ' $stderr.puts("*** debug: ' << s << '=#{(' << code << ').inspect}");'
+    end
+
+    def add_postamble(src)
+      #super if @initialized
+      src << "\n_buf\n" if @initialized
+    end
+
+  end
+
+end

data/benchmark/erubybench.rb

@@ -0,0 +1,364 @@
+##
+## $Rev: 21 $
+## $Release: 2.0.0 $
+## copyright(c) 2006 kuwata-lab all rights reserved.
+##
+
+require 'eruby'
+require 'erb'
+require 'stringio'
+
+require 'erubis'
+require 'erubis/engine/enhanced'
+require 'erubis/engine/optimized'
+require 'erubis/tiny'
+require 'erubybench-lib'
+
+
+
+## default values
+filename = 'erubybench.rhtml'
+datafile = 'erubybench.yaml'
+n = 10000
+
+
+## usage
+def usage(n, filename, datafile)
+  s =  "Usage: ruby #{$0} [-h] [-n N] [-f file] [-d file] [testname ...]\n"
+  s << "  -h      :  help\n"
+  s << "  -n N    :  number of times to loop (default #{n})\n"
+  s << "  -f file :  eruby filename (default '#{filename}')\n"
+  s << "  -d file :  data filename (default '#{datafile}')\n"
+  return s
+end
+
+
+## parse command-line options
+flag_help = false
+flag_all = false
+targets = nil
+test_type = nil
+compiler_name = 'ErubisOptimized'
+while !ARGV.empty? && ARGV[0][0] == ?-
+  opt = ARGV.shift
+  case opt
+  when '-n'  ;  n = ARGV.shift.to_i
+  when '-f'  ;  filename = ARGV.shift
+  when '-d'  ;  datafile = ARGV.shift
+  when '-h', '--help'  ;  flag_help = true
+  when '-A'  ;  test_all = true
+  when '-C'  ;  compiler_name = ARGV.shift
+  when '-t'  ;  test_type = ARGV.shift
+  else       ;  raise "#{opt}: invalid option."
+  end
+end
+puts "** n=#{n.inspect}, filename=#{filename.inspect}, datafile=#{datafile.inspect}"
+
+
+## help
+if flag_help
+  puts usage(n, filename, datafile)
+  exit()
+end
+
+
+## load data file
+require 'yaml'
+ydoc = YAML.load_file(datafile)
+data = []
+ydoc['data'].each do |hash|
+  data << hash.inject({}) { |h, t| h[t[0].intern] = t[1]; h }
+  #h = {}; hash.each { |k, v| h[k.intern] = v } ; data << h
+end
+data = data.sort_by { |h| h[:code] }
+#require 'pp'; pp data
+
+
+## open /dev/null
+$devnull = File.open("/dev/null", 'w')
+
+
+## test definitions
+testdefs_str = <<END
+- name:   ERuby
+  class:  ERuby
+  code: |
+    ERuby.import(filename)
+  compile: |
+    ERuby::Compiler.new.compile_string(str)
+  return: null
+
+- name:   ERB
+  class:  ERB
+  code: |
+    print ERB.new(File.read(filename)).result(binding())
+#    eruby = ERB.new(File.read(filename))
+#    print eruby.result(binding())
+  compile: |
+    ERB.new(str).src
+  return: str
+
+- name:   ErubisEruby
+  class:  Erubis::Eruby
+  return: str
+
+- name:   ErubisEruby2
+  desc:   print _buf    #, no binding()
+  class:  Erubis::Eruby2
+  code: |
+    #Erubis::Eruby2.new(File.read(filename)).result()
+    Erubis::Eruby2.new(File.read(filename)).result(binding())
+  return: null
+  skip:   yes
+
+- name:   ErubisExprStripped
+  desc:   strip expr code
+  class:  Erubis::ExprStrippedEruby
+  return: str
+  skip:   yes
+
+- name:   ErubisOptimized
+  class:  Erubis::OptimizedEruby
+  return: str
+  skip:   yes
+
+- name:   ErubisOptimized2
+  class:  Erubis::Optimized2Eruby
+  return: str
+  skip:   yes
+
+#- name:   ErubisArrayBuffer
+#  class:  Erubis::ArrayBufferEruby
+#  code: |
+#    Erubis::ArrayBufferEruby.new(File.read(filename)).result(binding())
+#  compile: |
+#    Erubis::ArrayBufferEruby.new(str).src
+#  return: str
+#  skip:   no
+
+- name:   ErubisStringBuffer
+  class:  Erubis::StringBufferEruby
+  return: str
+  skip:   no
+
+- name:   ErubisStringIO
+  class:  Erubis::StringIOEruby
+  return: str
+  skip:   yes
+
+- name:   ErubisSimplified
+  class:  Erubis::SimplifiedEruby
+  return: str
+  skip:   no
+
+- name:   ErubisStdout
+  class:  Erubis::StdoutEruby
+  return: null
+  skip:   no
+
+- name:   ErubisStdoutSimplified
+  class:  Erubis::StdoutSimplifiedEruby
+  return: str
+  skip:   no
+
+- name:   ErubisPrintOut
+  class:  Erubis::PrintOutEruby
+  return: str
+  skip:   no
+
+- name:   ErubisPrintOutSimplified
+  class:  Erubis::PrintOutSimplifiedEruby
+  return: str
+  skip:   no
+
+- name:   ErubisTiny
+  class:  Erubis::TinyEruby
+  return: yes
+  skip:   no
+
+- name:   ErubisTinyStdout
+  class:  Erubis::TinyStdoutEruby
+  return: null
+  skip:   no
+
+- name:   ErubisTinyPrint
+  class:  Erubis::TinyPrintEruby
+  return: null
+  skip:   no
+
+#- name:    load
+#  class:   load
+#  code: |
+#    load($load_filename)
+#  compile: null
+#  return: null
+#  skip:    yes
+
+END
+testdefs = YAML.load(testdefs_str)
+
+## manipulate
+testdefs.each do |testdef|
+  c = testdef['class']
+  testdef['code']    ||= "print #{c}.new(File.read(filename)).result(binding())\n"
+  testdef['compile'] ||= "#{c}.new(str).src\n"
+  require 'pp'
+  #pp testdef
+end
+
+
+### create file for load
+#if testdefs.find { |h| h['name'] == 'load' }
+#  $load_filename = filename + ".tmp"   # for load
+#  $data = data
+#  str = File.read(filename)
+#  str.gsub!(/\bdata\b/, '$data')
+#  hash = testdefs.find { |h| h['name'] == compiler_name }
+#  code = eval hash['compile']
+#  code.sub!(/_buf\s*\z/, 'print \&')
+#  File.open($load_filename, 'w') { |f| f.write(code) }
+#  at_exit do
+#    File.unlink $load_filename if test(?f, $load_filename)
+#  end
+#end
+
+
+## select test target
+if test_all
+  #testdefs.each { |h| h['skip'] = false }
+elsif !ARGV.empty?
+  #testdefs.each { |h| h['skip'] = ARGV.include?(h['name']) }
+  testdefs.delete_if { |h| !ARGV.include?(h['name']) }
+else
+  testdefs.delete_if { |h| h['skip'] }
+end
+#require 'pp'
+#pp testdefs
+
+
+## define test functions for each classes
+testdefs.each do |h|
+  s = ''
+  s << "def test_#{h['name']}(filename, data)\n"
+  s << "  $stdout = $devnull\n"
+  n.times do
+    s << '  ' << h['code']  #<< "\n"
+  end
+  s << "  $stdout = STDOUT\n"
+  s << "end\n"
+  #puts s
+  eval s
+end
+
+
+## define view functions for each classes
+str = File.read(filename)
+testdefs.each do |h|
+  next unless h['compile']
+  code = eval h['compile']
+  s = <<-END
+    def view_#{h['name']}(data)
+      #{code}
+    end
+  END
+  #puts s
+  eval s
+end
+
+
+## define tests for view functions
+testdefs.each do |h|
+  pr = h['return'] ? 'print ' : ''
+  s = ''
+  s << "def test_view_#{h['name']}(data)\n"
+  s << "  $stdout = $devnull\n"
+  n.times do
+    s << "  #{pr}view_#{h['name']}(data)\n"
+  end
+  s << "  $stdout = STDOUT\n"
+  s << "end\n"
+  #puts s
+  eval s
+end
+
+
+## define tests for caching
+str = File.read(filename)
+testdefs.each do |h|
+  next unless h['compile']
+  # create file to read
+  code = eval h['compile']
+  fname = "#{filename}.#{h['name']}"
+  File.open(fname, 'w') { |f| f.write(code) }
+  #at_exit do File.unlink fname if test(?f, fname) end
+  # define function
+  pr = h['return'] ? 'print ' : ''
+  s = ''
+  s << "def test_cache_#{h['name']}(filename, data)\n"
+  s << "  $stdout = $devnull\n"
+  n.times do
+    s << "  #{pr}eval(File.read(\"\#{filename}.#{h['name']}\"))\n"
+  end
+  s << "  $stdout = STDOUT\n"
+  s << "end\n"
+  #puts s
+  eval s
+end
+
+
+## rehearsal
+$stdout = $devnull
+testdefs.each do |h|
+  ## execute test code
+  eval h['code']
+  ## execute view function
+  next unless h['compile']
+  v = __send__("view_#{h['name']}", data)
+  print v if h['return']
+  ## execute caching function
+  v = eval(File.read("#{filename}.#{h['name']}"))
+  print v if h['return']
+end
+$stdout = STDOUT
+
+
+## do benchmark
+require 'benchmark'
+begin
+  Benchmark.bmbm(25) do |job|
+    ## basic test
+    testdefs.each do |h|
+      title = h['class']
+      func = 'test_' + h['name']
+      GC.start
+      job.report(title) do
+        __send__(func, filename, data)
+      end
+    end if !test_type || test_type == 'basic'
+
+    ## caching function
+    testdefs.each do |h|
+      next unless h['compile']
+      title = 'cache_' + h['name']
+      func = 'test_cache_' + h['name']
+      GC.start
+      job.report(title) do
+        __send__(func, filename, data)
+      end
+    end if !test_type || test_type == 'eval'
+
+    ## view-function test
+    testdefs.each do |h|
+      next unless h['compile']
+      title = 'func_' + h['name']
+      func = 'test_view_' + h['name']
+      GC.start
+      job.report(title) do
+        __send__(func, data)
+      end
+    end if !test_type || test_type == 'func'
+
+  end
+ensure
+  $devnull.close()
+end