erubis 1.1.0 → 2.0.0

data/doc/users-guide.html

@@ -14,7 +14,7 @@
 
     <div align="left"><h1>Erubis Users' Guide</h1></div>
     <div align="left">
-      last update: $Date: 2006-02-01 19:54:24 +0900 (Wed, 01 Feb 2006) $<br>
+      last update: $Date: 2006-05-20 08:57:39 +0900 (Sat, 20 May 2006) $<br>
     </div>
 
 <a name="preface"></a>
@@ -23,17 +23,21 @@
 It has the following features.
 </p>
 <ul type="disc">
-<li>Auto sanitizing support
+<li>Very fast, almost three times faster than ERB and even as fast as eruby (implemented in C)
+</li>
+<li>Auto escaping support
 </li>
 <li>Auto trimming spaces around '&lt;% %&gt;'
 </li>
 <li>Embedded pattern changeable (default '&lt;% %&gt;')
 </li>
-<li>Context object available
+<li>Support multi-language (Ruby/PHP/C/Java/Scheme/Perl/Javascript)
+</li>
+<li>Context object available and easy to combine eRuby template with YAML datafile
 </li>
 <li>Print statement available
 </li>
-<li>Easy to expand in subclass
+<li>Easy to extend in subclass
 </li>
 </ul>
 <p>Erubis is implemented in pure Ruby.  It requires Ruby 1.8 or higher.
@@ -55,17 +59,69 @@ It has the following features.
     </li>
     <li><a href="#tut-trim">Trimming Spaces</a>
     </li>
-    <li><a href="#tut-xml">Auto Sanitizing</a>
+    <li><a href="#tut-escape">Escape</a>
     </li>
     <li><a href="#tut-pattern">Embedded Pattern</a>
     </li>
     <li><a href="#tut-context">Context Object</a>
     </li>
-    <li><a href="#tut-fast">Faster Eruby</a>
+    <li><a href="#tut-datafile">Context Data File</a>
+    </li>
+    <li><a href="#tut-preamble">Preamble and Postamble</a>
+    </li>
+  </ul>
+  </li>
+  <li><a href="#enhancer">Enhancer</a>
+  <ul>
+    <li><a href="#escape-enhancer">EscapeEnhancer</a>
+    </li>
+    <li><a href="#stdout-enhancer">StdoutEnhancer</a>
+    </li>
+    <li><a href="#printout-enhancer">PrintOutEnhancer</a>
+    </li>
+    <li><a href="#printenabled-enhancer">PrintEnabledEnhancer</a>
+    </li>
+    <li><a href="#array-enhancer">ArrayEnhancer</a>
+    </li>
+    <li><a href="#arraybuffer-enhancer">ArrayBufferEnhancer</a>
+    </li>
+    <li><a href="#stringbuffer-enhancer">StringBufferEnhancer</a>
+    </li>
+    <li><a href="#notext-enhancer">NoTextEnhancer</a>
+    </li>
+    <li><a href="#simplify-enhancer">SimplifyEnhancer</a>
     </li>
-    <li><a href="#tut-stdout">Stdout Eruby</a>
+    <li><a href="#bipattern-enhancer">BiPatternEnhancer</a>
     </li>
-    <li><a href="#tut-print">Print Avairable Eruby</a>
+    <li><a href="#percentline-enhancer">PercentLineEnhancer</a>
+    </li>
+    <li><a href="#headerfooter-enhancer">HeaderFooterEnhancer</a>
+    </li>
+  </ul>
+  </li>
+  <li><a href="#lang">Multi-Language</a>
+  <ul>
+    <li><a href="#lang-php">PHP</a>
+    </li>
+    <li><a href="#lang-c">C</a>
+    </li>
+    <li><a href="#lang-java">Java</a>
+    </li>
+    <li><a href="#lang-scheme">Scheme</a>
+    </li>
+    <li><a href="#lang-perl">Perl</a>
+    </li>
+    <li><a href="#lang-javascript">JavaScript</a>
+    </li>
+  </ul>
+  </li>
+  <li><a href="#topics">Other Topics</a>
+  <ul>
+    <li><a href="#topics-tinyeruby">TinyEruby class</a>
+    </li>
+    <li><a href="#topics-php">NoTextEnhancer in PHP</a>
+    </li>
+    <li><a href="#topics-benchmark">Benchmark</a>
     </li>
   </ul>
   </li>
@@ -75,6 +131,8 @@ It has the following features.
     </li>
     <li><a href="#command-options">Options</a>
     </li>
+    <li><a href="#command-props">Properties</a>
+    </li>
   </ul>
   </li>
 </ul>
@@ -93,25 +151,21 @@ It has the following features.
 </li>
 </ul>
 <ul type="disc">
-<li>Or if you can be root user, download erubis-X.X.X.tar.bz2 and install by setup.rb.
-<pre class="terminal">$ tar xjf erubis-X.X.X.tar.bz2
-$ cd erubis_X.X.X/
-$ ruby setup.rb
-</pre>
-</li>
-</ul>
-<ul type="disc">
-<li>Else you should copy 'lib/erubis.rb' and 'bin/erubis' into proper directory manually.
-<pre class="terminal">$ tar xjf erubis-X.X.X.tar.bz2
+<li>Else install <a href="http://rubyforge.org/projects/erubis/">abstract</a> at first,
+   and download erubis_X.X.X.tar.bz2 and install it by setup.rb.
+<pre class="terminal">$ 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/
-$ cp lib/erubis.rb /usr/local/lib/ruby/site_ruby/1.8
-$ cp bin/erubis /usr/local/bin
+$ sudo ruby setup.rb
 </pre>
 </li>
 </ul>
 <ul type="disc">
-<li>(Optional) 'contrib/inline-require' enables you to merge 'lib/erubis.rb' into 'bin/erubis'.
-<pre class="terminal">$ tar xjf erubis-X.X.X.tar.bz2
+<li>(Optional) 'contrib/inline-require' enables you to merge 'lib/**/*.rb' into 'bin/erubis'.
+<pre class="terminal">$ tar xjf erubis_X.X.X.tar.bz2
 $ cd erubis_X.X.X/
 $ unset RUBYLIB
 $ contrib/inline-require -I lib bin/erubis &gt; contrib/erubis
@@ -125,16 +179,14 @@ $ contrib/inline-require -I lib bin/erubis &gt; contrib/erubis
 <h2 class="section1">Tutorial</h2>
 <a name="tut-basic"></a>
 <h3 class="section2">Basic Example</h3>
-<p>Here is a most basic example of Erubis.
+<p>Here is a basic example of Erubis.
 </p>
 <a name="example1.eruby"></a>
 <div class="program_caption">
 example1.eruby</div>
 <pre class="program">&lt;ul&gt;
   <b>&lt;% for item in list %&gt;</b>
-  &lt;li&gt;
-    <b>&lt;%= item %&gt;</b>
-  &lt;/li&gt;
+  &lt;li&gt;<b>&lt;%= item %&gt;</b>&lt;/li&gt;
   <b>&lt;% end %&gt;</b>
   <b>&lt;%# here is ignored because starting with '#' %&gt;</b>
 &lt;/ul&gt;
@@ -142,95 +194,126 @@ example1.eruby</div>
 <a name="example1.rb"></a>
 <div class="program_caption">
 example1.rb</div>
-<pre class="program">## create Eruby object
-require 'erubis'
+<pre class="program">require 'erubis'
 input = File.read('example1.eruby')
-eruby = <b>Erubis::Eruby.new(input)</b>
+eruby = <b>Erubis::Eruby.new(input)</b>    # create Eruby object
 
-## print script source
-puts "--- script source ---"
-puts <b>eruby.src</b>
+puts "---------- script source ---"
+puts <b>eruby.src</b>                      # print script source
 
-## get result
-puts "--- result ---"
+puts "---------- result ----------"
 list = ['aaa', 'bbb', 'ccc']
-puts <b>eruby.result(binding())</b>
+puts <b>eruby.result(binding())</b>        # get result
 </pre>
 <div class="terminal_caption">
 output</div>
 <pre class="terminal">$ ruby example1.rb
---- script source ---
-_out = ''; _out &lt;&lt; "&lt;ul&gt;\n"
-   for item in list 
-_out &lt;&lt; "  &lt;li&gt;\n"
-_out &lt;&lt; "    "; _out &lt;&lt; ( item ).to_s; _out &lt;&lt; "\n"
-_out &lt;&lt; "  &lt;/li&gt;\n"
-   end 
-
-_out &lt;&lt; "&lt;/ul&gt;\n"
-_out
---- result ---
+---------- script source ---
+_buf = []; _buf &lt;&lt; '&lt;ul&gt;
+';   for item in list 
+ _buf &lt;&lt; '  &lt;li&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/li&gt;
+';   end 
+
+ _buf &lt;&lt; '&lt;/ul&gt;
+';
+_buf.join
+---------- result ----------
 &lt;ul&gt;
-  &lt;li&gt;
-    aaa
-  &lt;/li&gt;
-  &lt;li&gt;
-    bbb
-  &lt;/li&gt;
-  &lt;li&gt;
-    ccc
-  &lt;/li&gt;
+  &lt;li&gt;aaa&lt;/li&gt;
+  &lt;li&gt;bbb&lt;/li&gt;
+  &lt;li&gt;ccc&lt;/li&gt;
 &lt;/ul&gt;
 </pre>
+<p>Erubis has command 'erubis'.  Command-line option '-x' shows the compiled source code of eRuby script.
+</p>
+<div class="terminal_caption">
+example of command-line option '-x'</div>
+<pre class="terminal">$ erubis <b>-x</b> example1.eruby
+_buf = []; _buf &lt;&lt; '&lt;ul&gt;
+';   for item in list 
+ _buf &lt;&lt; '  &lt;li&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/li&gt;
+';   end 
+
+ _buf &lt;&lt; '&lt;/ul&gt;
+';
+_buf.join
+</pre>
 <br>
 
 
 <a name="tut-trim"></a>
 <h3 class="section2">Trimming Spaces</h3>
 <p>Erubis deletes spaces around '&lt;% %&gt;' automatically, while it leaves spaces around '&lt;%= %&gt;'.
-If you want leave spaces around '&lt;% %&gt;', add <code>:trim=&gt;false</code> option to Erubis::Eruby.new().
 </p>
 <a name="example2.eruby"></a>
 <div class="program_caption">
 example2.eruby</div>
 <pre class="program">&lt;ul&gt;
-  &lt;% for item in list %&gt;
+  &lt;% for item in list %&gt;      # trimmed
   &lt;li&gt;
-    &lt;%= item %&gt;
+    &lt;%= item %&gt;               # not trimmed
   &lt;/li&gt;
-  &lt;% end %&gt;
+  &lt;% end %&gt;                   # trimmed
 &lt;/ul&gt;
 </pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -x example2.eruby
+_buf = []; _buf &lt;&lt; '&lt;ul&gt;
+';   for item in list 
+ _buf &lt;&lt; '  &lt;li&gt;
+'; _buf &lt;&lt; '    '; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '
+'; _buf &lt;&lt; '  &lt;/li&gt;
+';   end 
+ _buf &lt;&lt; '&lt;/ul&gt;
+';
+_buf.join
+</pre>
+<p>If you want leave spaces around '&lt;% %&gt;', add command-line option '-T'.
+</p>
+<div class="terminal_caption">
+compiled source code with command-line option '-T'</div>
+<pre class="terminal">$ erubis -x <b>-T</b> example2.eruby
+_buf = []; _buf &lt;&lt; '&lt;ul&gt;
+'; _buf &lt;&lt; '  '; for item in list ; _buf &lt;&lt; '
+'; _buf &lt;&lt; '  &lt;li&gt;
+'; _buf &lt;&lt; '    '; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '
+'; _buf &lt;&lt; '  &lt;/li&gt;
+'; _buf &lt;&lt; '  '; end ; _buf &lt;&lt; '
+'; _buf &lt;&lt; '&lt;/ul&gt;
+';
+_buf.join
+</pre>
+<p>Or add option <code>:trim=&gt;false</code> to Erubis::Eruby.new().
+</p>
 <a name="example2.rb"></a>
 <div class="program_caption">
 example2.rb</div>
-<pre class="program">## create Eruby object
-require 'erubis'
+<pre class="program">require 'erubis'
 input = File.read('example2.eruby')
 eruby = Erubis::Eruby.new(input<b>, :trim=&gt;false</b>)
 
-## print script source
-puts "--- script source ---"
-puts eruby.src
+puts "---------- script source ---"
+puts eruby.src                            # print script source
 
-## get result
-puts "--- result ---"
+puts "---------- result ----------"
 list = ['aaa', 'bbb', 'ccc']
-puts eruby.result(binding())
+puts eruby.result(binding())              # get result
 </pre>
 <div class="terminal_caption">
 output</div>
 <pre class="terminal">$ ruby example2.rb
---- script source ---
-_out = ''; _out &lt;&lt; "&lt;ul&gt;\n"
-<b>_out &lt;&lt; "  ";</b>  for item in list <b>; _out &lt;&lt; "\n"</b>
-_out &lt;&lt; "  &lt;li&gt;\n"
-_out &lt;&lt; "    "; _out &lt;&lt; ( item ).to_s; _out &lt;&lt; "\n"
-_out &lt;&lt; "  &lt;/li&gt;\n"
-<b>_out &lt;&lt; "  ";</b>  end <b>; _out &lt;&lt; "\n"</b>
-_out &lt;&lt; "&lt;/ul&gt;\n"
-_out
---- result ---
+---------- script source ---
+_buf = []; _buf &lt;&lt; '&lt;ul&gt;
+'; _buf &lt;&lt; '  '; for item in list ; _buf &lt;&lt; '
+'; _buf &lt;&lt; '  &lt;li&gt;
+'; _buf &lt;&lt; '    '; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '
+'; _buf &lt;&lt; '  &lt;/li&gt;
+'; _buf &lt;&lt; '  '; end ; _buf &lt;&lt; '
+'; _buf &lt;&lt; '&lt;/ul&gt;
+';
+_buf.join
+---------- result ----------
 &lt;ul&gt;
   
   &lt;li&gt;
@@ -250,134 +333,164 @@ _out
 <br>
 
 
-<a name="tut-xml"></a>
-<h3 class="section2">Auto Sanitizing</h3>
-<p>If you use Erubis::XmlEruby instead of Erubis::Eruby, output is sanitized automatically.
-</p>
-<p>Erubis::XmlEruby acts the following:
+<a name="tut-escape"></a>
+<h3 class="section2">Escape</h3>
+<p>Erubis have ability to escape (sanitize) expression.
+Erubis::Eruby class act as the following:
 </p>
 <ul type="disc">
-<li><code>&lt;%= <i>expr</i> %&gt;</code> will be sanitized.
+<li><code>&lt;%= <i>expr</i> %&gt;</code> -  not escaped.
 </li>
-<li><code>&lt;%== <i>expr</i> %&gt;</code> will be out as it is.
+<li><code>&lt;%== <i>expr</i> %&gt;</code> - escaped.
 </li>
-<li><code>&lt;%=== <i>expr</i> %&gt;</code> will be out to $stderr.
+<li><code>&lt;%=== <i>expr</i> %&gt;</code> - out to $stderr.
 </li>
-<li><code>&lt;%==== <i>expr</i> %&gt;</code> will be ignored.
+<li><code>&lt;%==== <i>expr</i> %&gt;</code> - ignored.
 </li>
 </ul>
+<p>Erubis::EscapedEruby<sup>(<a href="#fnref:1" name="fnlink:1">*1</a>)</sup> class handle '&lt;%= %&gt;' as escaped and '&lt;%== %&gt;' as not escaped.
+It means that using Erubis::EscapedEruby you can escape expression by default.
+Also Erubis::XmlEruby class (which is equivalent to Erubis::EscapedEruby) is provided for compatibility with Erubis 1.1.
+</p>
 <a name="example3.eruby"></a>
 <div class="program_caption">
 example3.eruby</div>
-<pre class="program">&lt;ul&gt;
-  &lt;% for item in list %&gt;
-  &lt;li&gt;<b>&lt;%=</b> item <b>%&gt;</b>&lt;/li&gt;
-  &lt;li&gt;<b>&lt;%==</b> item <b>%&gt;</b>&lt;/li&gt;
-  &lt;li&gt;<b>&lt;%===</b> item <b>%&gt;</b>&lt;/li&gt;
+<pre class="program">&lt;% for item in list %&gt;
+  &lt;p&gt;<b>&lt;%=</b> item <b>%&gt;</b>&lt;/p&gt;
+  &lt;p&gt;<b>&lt;%==</b> item <b>%&gt;</b>&lt;/p&gt;
+  &lt;p&gt;<b>&lt;%===</b> item <b>%&gt;</b>&lt;/p&gt;
 
-  &lt;% end %&gt;
-&lt;/ul&gt;
+&lt;% end %&gt;
 </pre>
 <a name="example3.rb"></a>
 <div class="program_caption">
 example3.rb</div>
-<pre class="program">## create Eruby object
-require 'erubis'
+<pre class="program">require 'erubis'
 input = File.read('example3.eruby')
-eruby = Erubis::<b>XmlEruby</b>.new(input)
+eruby = Erubis::<b>EscapedEruby</b>.new(input)    # or Erubis::XmlEruby
 
-## print script source
-puts "--- script source ---"
-puts eruby.src
+puts "---------- script source ---"
+puts eruby.src                             # print script source
 
-## get result
-puts "--- result ---"
+puts "---------- result ----------"
 <b>list = ['&lt;aaa&gt;', 'b&amp;b', '"ccc"']</b>
-puts eruby.result(binding())
+puts eruby.result(binding())               # get result
 </pre>
 <div class="terminal_caption">
 output</div>
 <pre class="terminal">$ ruby example3.rb 2&gt; stderr.log
---- script source ---
-_out = ''; _out &lt;&lt; "&lt;ul&gt;\n"
-   for item in list 
-_out &lt;&lt; "  &lt;li&gt;"; <b>_out &lt;&lt; Erubis::XmlEruby.escape( item )</b>; _out &lt;&lt; "&lt;/li&gt;\n"
-_out &lt;&lt; "  &lt;li&gt;"; _out &lt;&lt; ( item ).to_s; _out &lt;&lt; "&lt;/li&gt;\n"
-_out &lt;&lt; "  &lt;li&gt;"; <b>$stderr.puts("** erubis: item = #{(item).inspect}")</b>; _out &lt;&lt; "&lt;/li&gt;\n"
-_out &lt;&lt; "\n"
-   end 
-_out &lt;&lt; "&lt;/ul&gt;\n"
-_out
---- result ---
-&lt;ul&gt;
-  &lt;li&gt;<b>&amp;lt;aaa&amp;gt;</b>&lt;/li&gt;
-  &lt;li&gt;&lt;aaa&gt;&lt;/li&gt;
-  &lt;li&gt;&lt;/li&gt;
+---------- script source ---
+_buf = []; for item in list 
+ _buf &lt;&lt; '  &lt;p&gt;'; <b>_buf &lt;&lt; Erubis::XmlHelper.escape_xml( item );</b> _buf &lt;&lt; '&lt;/p&gt;
+  &lt;p&gt;'; <b>_buf &lt;&lt; ( item ).to_s;</b> _buf &lt;&lt; '&lt;/p&gt;
+  &lt;p&gt;'; <b>$stderr.puts("*** debug: item=#{(item).inspect}");</b> _buf &lt;&lt; '&lt;/p&gt;
 
-  &lt;li&gt;<b>b&amp;amp;b</b>&lt;/li&gt;
-  &lt;li&gt;b&amp;b&lt;/li&gt;
-  &lt;li&gt;&lt;/li&gt;
+'; end 
+_buf.join
+---------- result ----------
+  &lt;p&gt;&amp;lt;aaa&amp;gt;&lt;/p&gt;
+  &lt;p&gt;&lt;aaa&gt;&lt;/p&gt;
+  &lt;p&gt;&lt;/p&gt;
 
-  &lt;li&gt;<b>&amp;quot;ccc&amp;quot;</b>&lt;/li&gt;
-  &lt;li&gt;"ccc"&lt;/li&gt;
-  &lt;li&gt;&lt;/li&gt;
+  &lt;p&gt;b&amp;amp;b&lt;/p&gt;
+  &lt;p&gt;b&amp;b&lt;/p&gt;
+  &lt;p&gt;&lt;/p&gt;
+
+  &lt;p&gt;&amp;quot;ccc&amp;quot;&lt;/p&gt;
+  &lt;p&gt;"ccc"&lt;/p&gt;
+  &lt;p&gt;&lt;/p&gt;
 
-&lt;/ul&gt;
 $ cat stderr.log
-** erubis: item = "&lt;aaa&gt;"
-** erubis: item = "b&amp;b"
-** erubis: item = "\"ccc\""
+*** debug: item="&lt;aaa&gt;"
+*** debug: item="b&amp;b"
+*** debug: item="\"ccc\""
+</pre>
+<p>The command-line option '-e'<sup>(<a href="#fnref:2" name="fnlink:2">*2</a>)</sup> will do the same action as Erubis::EscapedEruby.
+This option is available for any language.
+</p>
+<pre class="terminal">$ erubis -l ruby <b>-e</b> example3.eruby
+_buf = []; for item in list 
+ _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
+  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
+  &lt;p&gt;'; $stderr.puts("*** debug: item=#{(item).inspect}"); _buf &lt;&lt; '&lt;/p&gt;
+
+'; end 
+_buf.join
 </pre>
+<p>Escaping function (default 'Erubis::XmlHelper.escape_xml()') can be changed by command-line property '--escape=xxx' or by overriding Erubis::Eruby#escaped_expr() in subclass.
+</p>
+<div class="program_caption">
+example to override Erubis::Eruby#escaped_expr()</div>
+<pre class="program">class CGIEruby &lt; Erubis::Eruby
+  def <b>escaped_expr(code)</b>
+    return "CGI.escapeHTML((#{code.strip}).to_s)"
+    #return "h(#{code.strip})"
+  end
+end
+
+class LatexEruby &lt; Erubi::Eruby
+  def <b>escaped_expr(code)</b>
+    return "(#{code}).gsub(/[%\\]/,'\\\\\&amp;')"
+  end
+end
+</pre>
+<div class="footnote">
+ <dl compact>
+  <dt>(<a name="fnref:1" href="#fnlink:1">*1</a>)</dt>
+  <dd>Erubis::EscapedEruby class includes Erubis::EscapeEnhancer which swtches the action of '&lt;%= %&gt;' and '&lt;%== %&gt;'.</dd>
+  <dt>(<a name="fnref:2" href="#fnlink:2">*2</a>)</dt>
+  <dd>Command-line option '-e' is equivarent to '-E Escape'.</dd>
+ </dl>
+</div>
 <br>
 
 
 <a name="tut-pattern"></a>
 <h3 class="section2">Embedded Pattern</h3>
-<p>You can change embedded pattern '<code>&lt;% %&gt;</code>' to another.
+<p>You can change embedded pattern '<code>&lt;% %&gt;</code>' to another with command-line option '-p' or option '<code>:pattern=&gt;...</code>' of Erubis::Eruby.new().
 </p>
 <a name="example4.eruby"></a>
 <div class="program_caption">
 example4.eruby</div>
-<pre class="program">&lt;ul&gt;
- <b>&lt;!--%</b> for item in list <b>%--&gt;</b>
-  &lt;li&gt;<b>&lt;!--%=</b> item <b>%--&gt;</b>&lt;/li&gt;
- <b>&lt;!--%</b> end <b>%--&gt;</b>
-&lt;/ul&gt;
+<pre class="program"><b>&lt;!--%</b> for item in list <b>%--&gt;</b>
+  &lt;p&gt;<b>&lt;!--%=</b> item <b>%--&gt;</b>&lt;/p&gt;
+<b>&lt;!--%</b> end <b>%--&gt;</b>
+</pre>
+<div class="terminal_caption">
+compiled source code with command-line option '-p'</div>
+<pre class="terminal">$ erubis -x <b>-p '&lt;!--% %--&gt;'</b> example4.eruby
+_buf = []; for item in list 
+ _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
+'; end 
+_buf.join
 </pre>
 <a name="example4.rb"></a>
 <div class="program_caption">
 example4.rb</div>
-<pre class="program">## create Eruby object
-require 'erubis'
+<pre class="program">require 'erubis'
 input = File.read('example4.eruby')
 eruby = Erubis::Eruby.new(input<b>, :pattern=&gt;'&lt;!--% %--&gt;'</b>)
                                       # or '&lt;(?:!--)?% %(?:--)?&gt;'
 
-## print script source
-puts "--- script source ---"
-puts eruby.src
+puts "---------- script source ---"
+puts eruby.src                            # print script source
 
-## get result
-puts "--- result ---"
+puts "---------- result ----------"
 list = ['aaa', 'bbb', 'ccc']
-puts eruby.result(binding())
+puts eruby.result(binding())              # get result
 </pre>
 <div class="terminal_caption">
 output</div>
 <pre class="terminal">$ ruby example4.rb
---- script source ---
-_out = ''; _out &lt;&lt; "&lt;ul&gt;\n"
-  for item in list 
-_out &lt;&lt; "  &lt;li&gt;"; _out &lt;&lt; ( item ).to_s; _out &lt;&lt; "&lt;/li&gt;\n"
-  end 
-_out &lt;&lt; "&lt;/ul&gt;\n"
-_out
---- result ---
-&lt;ul&gt;
-  &lt;li&gt;aaa&lt;/li&gt;
-  &lt;li&gt;bbb&lt;/li&gt;
-  &lt;li&gt;ccc&lt;/li&gt;
-&lt;/ul&gt;
+---------- script source ---
+_buf = []; for item in list 
+ _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
+'; end 
+_buf.join
+---------- result ----------
+  &lt;p&gt;aaa&lt;/p&gt;
+  &lt;p&gt;bbb&lt;/p&gt;
+  &lt;p&gt;ccc&lt;/p&gt;
 </pre>
 <p>It is able to specify regular expression with :pattern option.
 Notice that you must use '<code>(?: )</code>' instead of '<code>( )</code>' for grouping.
@@ -390,16 +503,16 @@ For example, '<code>&lt;(!--)?% %(--)?&gt;</code>' will not work while '<code>&l
 <h3 class="section2">Context Object</h3>
 <p>Context object is a set of data which are used in eRuby script.
 Using context object makes clear which data to be used.
+In Erubis, Hash object and Erubis::Context object are available as context object.
 </p>
-<p>In Erubis, Hash object is used as context object.
-Hash key means variable name and it can be string or symbol.
+<p>Context data can be accessible via isntance variables in eRuby script.
 </p>
 <a name="example5.eruby"></a>
 <div class="program_caption">
 example5.eruby</div>
-<pre class="program">&lt;span&gt;&lt;%= val %&gt;&lt;/span&gt;
+<pre class="program">&lt;span&gt;&lt;%= <b>@val</b> %&gt;&lt;/span&gt;
 &lt;ul&gt;
- &lt;% for item in list %&gt;
+ &lt;% for item in <b>@list</b> %&gt;
   &lt;li&gt;&lt;%= item %&gt;&lt;/li&gt;
  &lt;% end %&gt;
 &lt;/ul&gt;
@@ -407,25 +520,26 @@ example5.eruby</div>
 <a name="example5.rb"></a>
 <div class="program_caption">
 example5.rb</div>
-<pre class="program">## create Eruby object
-require 'erubis'
+<pre class="program">require 'erubis'
 input = File.read('example5.eruby')
-eruby = Erubis::Eruby.new(input)
+eruby = Erubis::Eruby.new(input)      # create Eruby object
 
 ## create context object
 ## (key means var name, which may be string or symbol.)
-<b>context = {}</b>
-<b>context[:val]   = 'Erubis Example'</b>
-<b>context['list'] = ['aaa', 'bbb', 'ccc']</b>
+<b>context = {
+  :val   =&gt; 'Erubis Example',
+  'list' =&gt; ['aaa', 'bbb', 'ccc'],
+}</b>
+  # or
+  #   context = Erubis::Context.new()
+  #   context['val'] = 'Erubis Example'
+  #   context[:list] = ['aaa', 'bbb', 'ccc'],
 
-## get result
-puts "--- result ---"
-puts <b>eruby.evaluate(context)</b>
+puts <b>eruby.evaluate(context)</b>         # get result
 </pre>
 <div class="terminal_caption">
 output</div>
 <pre class="terminal">$ ruby example5.rb
---- result ---
 &lt;span&gt;Erubis Example&lt;/span&gt;
 &lt;ul&gt;
   &lt;li&gt;aaa&lt;/li&gt;
@@ -433,13 +547,73 @@ output</div>
   &lt;li&gt;ccc&lt;/li&gt;
 &lt;/ul&gt;
 </pre>
-<p>It is very useful to import YAML document data into context object.
+<p>The difference between Erubis#result(binding) and Erubis#evaluate(context) is that the former invokes 'eval @src, binding' and the latter invokes 'context.instance_eval @src'.
+This means that data is passed into eRuby script via local variable when Eruby::binding() is called, or instance variable when Eruby::evaluate() is called.
+</p>
+<p>Here is the definition of Erubis#result() and Erubis#evaluate().
 </p>
-<a name="example6.yaml"></a>
 <div class="program_caption">
-example6.yaml</div>
-<pre class="program">title: Users List
-users:
+definition of result(binding) and evaluate(context)</div>
+<pre class="program">def result(_binding)
+  if _binding.is_a?(Hash)
+    # load hash data as local variable
+    _h = _binding
+    eval _h.keys.inject("") {|s,k| s &lt;&lt; "#{k} = _h[#{k.inspect}];"}
+    _binding = binding()
+  end
+  return <b>eval(@src, _binding)</b>
+end
+
+def evaluate(context)
+  if context.is_a?(Hash)
+    # convert hash object to Context object
+    hash = context
+    context = Erubis::Context.new
+    hash.each { |key, val| context[key] = val }
+  end
+  return <b>context.instance_eval(@src)</b>
+end
+</pre>
+<p>instance_eval() is defined at Object class so it is able to use any object as a context object as well as Hash or Erubis::Context.
+</p>
+<a name="example6.rb"></a>
+<div class="program_caption">
+example6.rb</div>
+<pre class="program">class MyData
+  attr_accessor :val, :list
+end
+
+## any object can be a context object
+<b>mydata = MyData.new</b>
+<b>mydata.val = 'Erubis Example'</b>
+<b>mydata.list = ['aaa', 'bbb', 'ccc']</b>
+
+require 'erubis'
+eruby = Erubis::Eruby.new(File.read('example5.eruby'))
+puts eruby.evaluate(<b>mydata</b>)
+</pre>
+<div class="terminal_caption">
+output</div>
+<pre class="terminal">$ ruby example6.rb
+&lt;span&gt;Erubis Example&lt;/span&gt;
+&lt;ul&gt;
+  &lt;li&gt;aaa&lt;/li&gt;
+  &lt;li&gt;bbb&lt;/li&gt;
+  &lt;li&gt;ccc&lt;/li&gt;
+&lt;/ul&gt;
+</pre>
+<br>
+
+
+<a name="tut-datafile"></a>
+<h3 class="section2">Context Data File</h3>
+<p>It is very useful to import YAML document data into Hash context object.
+</p>
+<a name="example7.yaml"></a>
+<div class="program_caption">
+example7.yaml</div>
+<pre class="program"><b>title:</b> Users List
+<b>users:</b>
   - name:  foo
     mail:  foo@mail.com
   - name:  bar
@@ -447,36 +621,34 @@ users:
   - name:  baz
     mail:  baz@mail.org
 </pre>
-<a name="example6.eruby"></a>
+<a name="example7.eruby"></a>
 <div class="program_caption">
-example6.eruby</div>
-<pre class="program">&lt;h1&gt;&lt;%= title %&gt;&lt;/h1&gt;
+example7.eruby</div>
+<pre class="program">&lt;h1&gt;&lt;%= <b>@title</b> %&gt;&lt;/h1&gt;
 &lt;ul&gt;
- &lt;% for user in users %&gt;
+ &lt;% for user in <b>@users</b> %&gt;
   &lt;li&gt;
     &lt;a href="mailto:&lt;%= user['mail']%&gt;"&gt;&lt;%= user['name'] %&gt;&lt;/a&gt;
   &lt;/li&gt;
  &lt;% end %&gt;
 &lt;/ul&gt;
 </pre>
-<a name="example6.rb"></a>
+<a name="example7.rb"></a>
 <div class="program_caption">
-example6.rb</div>
-<pre class="program">## create Eruby object
-require 'erubis'
-input = File.read('example6.eruby')
-eruby = Erubis::Eruby.new(input)
+example7.rb</div>
+<pre class="program">require 'erubis'
+input = File.read('example7.eruby')
+eruby = Erubis::Eruby.new(input)      # create Eruby object
 
 ## load YAML document as context object
 <b>require 'yaml'</b>
-<b>context = YAML.load_file('example6.yaml')</b>
+<b>context = YAML.load_file('example7.yaml')</b>
 
-## get result
-puts <b>eruby.evaluate(context)</b>
+puts <b>eruby.evaluate(context)</b>        # get result
 </pre>
 <div class="terminal_caption">
 output</div>
-<pre class="terminal">$ ruby example6.rb
+<pre class="terminal">$ ruby example7.rb
 &lt;h1&gt;Users List&lt;/h1&gt;
 &lt;ul&gt;
   &lt;li&gt;
@@ -490,233 +662,1151 @@ output</div>
   &lt;/li&gt;
 &lt;/ul&gt;
 </pre>
+<p>It is able to specify YAML data file with the command-line option '-f'.
+You don't have to write ruby script such as 'example7.rb'.
+</p>
+<div class="terminal_caption">
+example of command-line option '-f'</div>
+<pre class="terminal">$ erubis <b>-f example7.yaml</b> example7.eruby
+&lt;h1&gt;Users List&lt;/h1&gt;
+&lt;ul&gt;
+  &lt;li&gt;
+    &lt;a href="mailto:foo@mail.com"&gt;foo&lt;/a&gt;
+  &lt;/li&gt;
+  &lt;li&gt;
+    &lt;a href="mailto:bar@mail.net"&gt;bar&lt;/a&gt;
+  &lt;/li&gt;
+  &lt;li&gt;
+    &lt;a href="mailto:baz@mail.org"&gt;baz&lt;/a&gt;
+  &lt;/li&gt;
+&lt;/ul&gt;
+</pre>
+<p>Command-line option '-S' converts keys of mapping in YAML data file from string into symbol.
+Command-line option '-B' invokes 'Erubis::Eruby#result(binding())' instead of 'Erubis::Eruby#evaluate(context)'.
+</p>
 <br>
 
 
-<a name="tut-fast"></a>
-<h3 class="section2">Faster Eruby</h3>
-<p>Erubis::FastEruby and Erubis::FastXmlEruby make faster Erubis::Eruby and Erubis::XmlEruby
-to combine several strings into a string.
+<a name="tut-preamble"></a>
+<h3 class="section2">Preamble and Postamble</h3>
+<p>The first line ('_buf = [];') in the compiled source code is called preamble
+and the last line ('_buf.join') is called postamble.
 </p>
-<a name="example7.eruby"></a>
+<p>Command-line option '-b' skips the output of preamble and postamble.
+</p>
+<a name="example8.eruby"></a>
 <div class="program_caption">
-example7.eruby</div>
-<pre class="program">&lt;table&gt;
-  &lt;tbody&gt;
-   &lt;% for item in list %&gt;
-    &lt;tr&gt;
-      &lt;td&gt;&lt;%= item %&gt;&lt;/td&gt;
-    &lt;/tr&gt;
-   &lt;% end %&gt;
-  &lt;/tbody&gt;
-&lt;/table&gt;
+example8.eruby</div>
+<pre class="program">&lt;% for item in @list %&gt;
+ &lt;b&gt;&lt;%= item %&gt;&lt;/b&gt;
+&lt;% end %&gt;
 </pre>
-<a name="example7.rb"></a>
+<p>compiled source code with and without command-line option '-b'
+</p>
+<pre class="terminal">## without '-b'
+$ erubis -x example8.eruby
+<b>_buf = [];</b> for item in @list 
+ _buf &lt;&lt; ' &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
+'; end 
+<b>_buf.join</b>
+
+## with '-b'
+$ erubis -x <b>-b</b> example8.eruby
+ for item in @list 
+ _buf &lt;&lt; ' &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
+'; end 
+</pre>
+<p>Erubis::Eruby.new option '<code>:preamble=&gt;false</code>' and '<code>:postamble=&gt;false</code>' also suppress output of preamble or postamle.
+</p>
+<a name="example8.rb"></a>
 <div class="program_caption">
-example7.rb</div>
-<pre class="program">## print script source with Eruby
-require 'erubis'
-input = File.read('example7.eruby')
-eruby = Erubis::Eruby.new(input)
-puts "--- script source (Eruby) ---"
-puts eruby.src
+example8.rb</div>
+<pre class="program">require 'erubis'
+input = File.read('example8.eruby')
+eruby1 = Erubis::Eruby.new(input)
+eruby2 = Erubis::Eruby.new(input, <b>:preamble=&gt;false, :postamble=&gt;false</b>)
 
-## print script source with FastEruby
-eruby = Erubis::<b>FastEruby</b>.new(input)
-puts "--- script source (FastEruby) ---"
-puts eruby.src
+puts eruby1.src   # print preamble and postamble
+puts "--------------"
+puts eruby2.src   # don't print preamble and postamble
 </pre>
 <div class="terminal_caption">
 output</div>
-<pre class="terminal">$ ruby example7.rb
---- script source (Eruby) ---
-_out = ''; _out &lt;&lt; "&lt;table&gt;\n"
-_out &lt;&lt; "  &lt;tbody&gt;\n"
-    for item in list 
-_out &lt;&lt; "    &lt;tr&gt;\n"
-_out &lt;&lt; "      &lt;td&gt;"; _out &lt;&lt; ( item ).to_s; _out &lt;&lt; "&lt;/td&gt;\n"
-_out &lt;&lt; "    &lt;/tr&gt;\n"
-    end 
-_out &lt;&lt; "  &lt;/tbody&gt;\n"
-_out &lt;&lt; "&lt;/table&gt;\n"
-_out
---- script source (FastEruby) ---
-_out = ''; _out &lt;&lt; "&lt;table&gt;\n  &lt;tbody&gt;\n"
-
-    for item in list 
-_out &lt;&lt; "    &lt;tr&gt;\n      &lt;td&gt;"
-_out &lt;&lt; ( item ).to_s; _out &lt;&lt; "&lt;/td&gt;\n    &lt;/tr&gt;\n"
-
-    end 
-_out &lt;&lt; "  &lt;/tbody&gt;\n&lt;/table&gt;\n"
-
-_out
-</pre>
-<p>Here is the definition of FastEruby or FastXmlEruby.
-They are subclass of Eruby and XmlEruby respectively and only include FastEnhancer module.
-It shows that Erubis is extensible.
-</p>
-<div class="program_caption">
-definition of FastEruby and FastXmlEruby</div>
-<pre class="program">module Erubis
-  class FastEruby &lt; Eruby
-    <b>include FastEnhancer</b>
-  end
-  class FastXmlEruby &lt; XmlEruby
-    <b>include FastEnhancer</b>
-  end
+<pre class="terminal">$ ruby example8.rb
+_buf = []; for item in @list 
+ _buf &lt;&lt; ' &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
+'; end 
+_buf.join
+--------------
+ for item in @list 
+ _buf &lt;&lt; ' &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
+'; end 
+</pre>
+<br>
+
+
+<br>
+
+
+<a name="enhancer"></a>
+<h2 class="section1">Enhancer</h2>
+<p>Enhancer is a module to add a certain feature into Erubis::Eruby class.
+Enhancer may be language-independent or only for Erubis::Eruby class.
+</p>
+<p>To use enhancers, define subclass and include them.
+The folloing is an example to use <a href="#escape-enhancer">EscapeEnhancer</a>, <a href="#percentline-enhancer">PercentLineEnhancer</a>, and <a href="#bipattern-enhancer">BiPatternEnhancer</a>.
+</p>
+<pre class="program">class MyEruby &lt; Erubis::Eruby
+  include EscapeEnhancer
+  include PercentLineEnhancer
+  include BiPatternEnhancer
 end
 </pre>
+<p>You can specify enhancers in command-line with option '-E'.
+The following is an example to use some enhancers in command-line.
+</p>
+<pre class="terminal">$ erubis -xE Escape,PercentLine,BiPattern example.eruby
+</pre>
+<p>The following is the list of enhancers.
+</p>
+<dl class="dl1">
+<dt class="dt1">
+<a href="#escape-enhancer">EscapeEnhander</a> (language-independent)</dt>
+<dd class="dd1">
+	Switch '&lt;%= %&gt;' to escaped and '&lt;%== %&gt;' to unescaped.
+</dd>
+<dt class="dt1">
+<a href="#stdout-enhancer">StdoutEnhancer</a> (only for Eruby)</dt>
+<dd class="dd1">
+	Use $stdout instead of array buffer.
+</dd>
+<dt class="dt1">
+<a href="#printout-enhancer">PrintOutEnhancer</a> (only for Eruby)</dt>
+<dd class="dd1">
+	Use "print(...)" statement insead of "_buf &lt;&lt; ...".
+</dd>
+<dt class="dt1">
+<a href="#printenabled-enhancer">PrintEnabledEnhancer</a> (only for Eruby)</dt>
+<dd class="dd1">
+	Enable to use print() in '&lt;% ... %&gt;'.
+</dd>
+<dt class="dt1">
+<a href="#array-enhancer">ArrayEnhancer</a> (only for Eruby)</dt>
+<dd class="dd1">
+	Return array of string instead of returning string.
+</dd>
+<dt class="dt1">
+<a href="#arraybuffer-enhancer">ArrayBufferEnhancer</a> (only for Eruby)</dt>
+<dd class="dd1">
+	Use array buffer. This is included in Erubis::Eruby by default.
+</dd>
+<dt class="dt1">
+<a href="#stringbuffer-enhancer">StringBufferEnhancer</a> (only for Eruby)</dt>
+<dd class="dd1">
+	Use string buffer. It is a little slower than ArrayBufferEnhancer.
+</dd>
+<dt class="dt1">
+<a href="#notext-enhancer">NoTextEnhancer</a> (language-independent)</dt>
+<dd class="dd1">
+	Print embedded code only and ignore normal text.
+</dd>
+<dt class="dt1">
+<a href="#simplify-enhancer">SimplifyEnhancer</a> (language-independent)</dt>
+<dd class="dd1">
+	Make compile faster but don't trim spaces around '&lt;% %&gt;'.
+</dd>
+<dt class="dt1">
+<a href="#bipattern-enhancer">BiPatternEnhancer</a> (language-independent)</dt>
+<dd class="dd1">
+	[experimental] Enable to use another embedded pattern with '&lt;% %&gt;'.
+</dd>
+<dt class="dt1">
+<a href="#percentline-enhancer">PercentLineEnhancer</a> (language-independent)</dt>
+<dd class="dd1">
+	Regard lines starting with '%' as Ruby code. This is for compatibility with eruby and ERB.
+</dd>
+<dt class="dt1">
+<a href="#headerfooter-enhancer">HeaderFooterEnhancer</a> (language-independent)</dt>
+<dd class="dd1">
+	[experimental] Enable you to add header and footer in eRuby script.
+</dd>
+</dl>
+<p>If you required 'erubis/engine/enhanced', Eruby subclasses which include each enhancers are defined.
+For example, class BiPatternEruby includes BiPatternEnhancer.
+</p>
+<a name="escape-enhancer"></a>
+<h3 class="section2">EscapeEnhancer</h3>
+<p>EscapeEnhancer switches '&lt;%= ... %&gt;' to escaped and '&lt;%== ... %&gt;' to unescaped.
+</p>
+<a name="example.eruby"></a>
+<div class="program_caption">
+example.eruby</div>
+<pre class="program">&lt;div&gt;
+&lt;% for item in list %&gt;
+  &lt;p&gt;&lt;%= item %&gt;&lt;/p&gt;
+  &lt;p&gt;&lt;%== item %&gt;&lt;/p&gt;
+&lt;% end %&gt;
+&lt;/div&gt;
+</pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -xE Escape example.eruby
+_buf = []; _buf &lt;&lt; '&lt;div&gt;
+'; for item in list 
+ _buf &lt;&lt; '  &lt;p&gt;'; <b>_buf &lt;&lt; Erubis::XmlHelper.escape_xml( item );</b> _buf &lt;&lt; '&lt;/p&gt;
+  &lt;p&gt;'; <b>_buf &lt;&lt; ( item ).to_s;</b> _buf &lt;&lt; '&lt;/p&gt;
+'; end 
+ _buf &lt;&lt; '&lt;/div&gt;
+';
+_buf.join
+</pre>
+<p>EscapeEnhancer is language-independent.
+</p>
 <br>
 
 
-<a name="tut-stdout"></a>
-<h3 class="section2">Stdout Eruby</h3>
-<p>Erubis::StdoutEruby and Erubis::StdoutXmlEruby use $stdout instead of string object.
+<a name="stdout-enhancer"></a>
+<h3 class="section2">StdoutEnhancer</h3>
+<p>StdoutEnhancer use $sdtdout instead of array buffer.
 Therefore, you can use 'print' statement in embedded ruby code.
 </p>
-<a name="example8.eruby"></a>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -xE Stdout example.eruby
+<b>_buf = $stdout;</b> _buf &lt;&lt; '&lt;div&gt;
+'; for item in list 
+ _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
+  &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
+'; end 
+ _buf &lt;&lt; '&lt;/div&gt;
+';
+''
+</pre>
+<p>StdoutEnhancer is only for Eruby.
+</p>
+<br>
+
+
+<a name="printout-enhancer"></a>
+<h3 class="section2">PrintOutEnhancer</h3>
+<p>PrintOutEnhancer makes compiled source code to use 'print(...)' instead of '_buf &lt;&lt; ...'.
+</p>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -xE PrintOut example.eruby
+ <b>print</b> '&lt;div&gt;
+'; for item in list 
+ <b>print</b> '  &lt;p&gt;'; <b>print</b>(( item ).to_s); <b>print</b> '&lt;/p&gt;
+  &lt;p&gt;'; <b>print</b> Erubis::XmlHelper.escape_xml( item ); <b>print</b> '&lt;/p&gt;
+'; end 
+ <b>print</b> '&lt;/div&gt;
+';
+</pre>
+<p>PrintOutEnhancer is only for Eruby.
+</p>
+<br>
+
+
+<a name="printenabled-enhancer"></a>
+<h3 class="section2">PrintEnabledEnhancer</h3>
+<p>PrintEnabledEnhancer enables you to use print() method in '&lt;% ... %&gt;'.
+</p>
+<a name="printenabled-example.eruby"></a>
 <div class="program_caption">
-example8.eruby</div>
-<pre class="program">&lt;ul&gt;
- &lt;% for item in list %&gt;
-  &lt;li&gt;<b>&lt;% print item %&gt;</b>&lt;/li&gt;
- &lt;% end %&gt;
-&lt;/ul&gt;
+printenabled-example.eruby</div>
+<pre class="program">&lt;% for item in @list %&gt;
+  &lt;b&gt;<b>&lt;% print item %&gt;</b>&lt;/b&gt;
+&lt;% end %&gt;
 </pre>
-<a name="example8.rb"></a>
+<a name="printenabled-example.rb"></a>
 <div class="program_caption">
-example8.rb</div>
-<pre class="program">## create Eruby object
-require 'erubis'
-input = File.read('example8.eruby')
-eruby = Erubis::<b>StdoutEruby</b>.new(input)
+printenabled-example.rb</div>
+<pre class="program">require 'erubis'
+class PrintEnabledEruby &lt; Erubis::Eruby
+  include Erubis::PrintEnabledEnhancer
+end
+input = File.read('printenabled-example.eruby')
+eruby = PrintEnabledEruby.new(input)
+list = ['aaa', 'bbb', 'ccc']
+print eruby.evaluate(:list=&gt;list)
+</pre>
+<div class="terminal_caption">
+output result</div>
+<pre class="terminal">$ ruby printenabled-example.rb
+  &lt;b&gt;aaa&lt;/b&gt;
+  &lt;b&gt;bbb&lt;/b&gt;
+  &lt;b&gt;ccc&lt;/b&gt;
+</pre>
+<p>Notice to use Eruby#evaluate() and not to use Eruby#result(),
+because print() method in '&lt;% ... %&gt;' invokes not Kernel#print() but PrintEnabledEnhancer#print().
+</p>
+<p>PrintEnabledEnhancer is only for Eruby.
+</p>
+<br>
 
-## print script source
-puts "--- script source ---"
-puts eruby.src
 
-## get result
-puts "--- result ---"
-list = ['aaa', 'bbb', 'ccc']
-#puts eruby.result(binding())
-<b>eruby.result(binding())</b>  # returns nil
+<a name="array-enhancer"></a>
+<h3 class="section2">ArrayEnhancer</h3>
+<p>ArrayEnhancer makes Eruby to return an array of strings.
+</p>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal"><b>_buf = [];</b> _buf &lt;&lt; '&lt;div&gt;
+'; for item in list 
+ _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
+  &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
+'; end 
+ _buf &lt;&lt; '&lt;/div&gt;
+';
+<b>_buf</b>
+</pre>
+<p>ArrayEnhancer is only for Eruby.
+</p>
+<br>
+
+
+<a name="arraybuffer-enhancer"></a>
+<h3 class="section2">ArrayBufferEnhancer</h3>
+<p>Arraybufferenhancer makes Eruby to use array buffer.
+Array buffer is a litte faster than String buffer.
+Erubis::Eruby includes this enhancer by default.
+</p>
+<p>ArrayBufferEnhancer is only for Eruby.
+</p>
+<br>
+
+
+<a name="stringbuffer-enhancer"></a>
+<h3 class="section2">StringBufferEnhancer</h3>
+<p>StringBufferEnhancer makes Eruby to use string buffer.
+</p>
+<pre class="terminal">$ erubis -xE StringBuffer example.eruby
+<b>_buf = '';</b> _buf &lt;&lt; '&lt;div&gt;
+'; for item in list 
+ _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
+  &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
+'; end 
+ _buf &lt;&lt; '&lt;/div&gt;
+';
+<b>_buf</b>
+</pre>
+<p>StringBufferEnhancer is only for Eruby.
+</p>
+<br>
+
+
+<a name="notext-enhancer"></a>
+<h3 class="section2">NoTextEnhancer</h3>
+<p>NoTextEnhancer suppress output of text and prints only embedded code.
+This is useful especially when debugging a complex eRuby script.
+</p>
+<a name="notext-example.eruby"></a>
+<div class="program_caption">
+notext-example.eruby</div>
+<pre class="program">&lt;h3&gt;List&lt;/h3&gt;
+&lt;% if !@list || @list.empty? %&gt;
+&lt;p&gt;not found.&lt;/p&gt;
+&lt;% else %&gt;
+&lt;table&gt;
+  &lt;tbody&gt;
+    &lt;% @list.each_with_index do |item, i| %&gt;
+    &lt;tr bgcolor="&lt;%= i%2 == 0 ? '#FFCCCC' : '#CCCCFF' %&gt;"&gt;
+      &lt;td&gt;&lt;%= item %&gt;&lt;/td&gt;
+    &lt;/tr&gt;
+    &lt;% end %&gt;
+  &lt;/tbody&gt;
+&lt;/table&gt;
+&lt;% end %&gt;
 </pre>
 <div class="terminal_caption">
-output</div>
-<pre class="terminal">$ ruby example8.rb
---- script source ---
-<b>_out = $stdout</b>; _out &lt;&lt; "&lt;ul&gt;\n"
-  for item in list 
-_out &lt;&lt; "  &lt;li&gt;";  <b>print item</b> ; _out &lt;&lt; "&lt;/li&gt;\n"
-  end 
-_out &lt;&lt; "&lt;/ul&gt;\n"
-<b>nil</b>
---- result ---
-&lt;ul&gt;
-  &lt;li&gt;aaa&lt;/li&gt;
-  &lt;li&gt;bbb&lt;/li&gt;
-  &lt;li&gt;ccc&lt;/li&gt;
-&lt;/ul&gt;
+output example of NoTextEnhancer</div>
+<pre class="terminal">$ erubis -TxE NoText notext-example.eruby
+_buf = [];
+ if !@list || @list.empty? ;
+
+ else ;
+
+
+     @list.each_with_index do |item, i| ;
+                  _buf &lt;&lt; ( i%2 == 0 ? '#FFCCCC' : '#CCCCFF' ).to_s;
+           _buf &lt;&lt; ( item ).to_s;
+
+     end ;
+
+
+ end ;
+_buf.join
 </pre>
-<p>Here is the definition of StdoutEruby or StdoutXmlEruby.
-They are subclass of Eruby and XmlEruby respectively and only include StdoutEnhancer module.
-It shows that Erubis is extensible.
+<p>NoTextEnhancer is language-independent. It is useful even if you are PHP user, see <a href="#topics-php">this section</a>.
 </p>
+<br>
+
+
+<a name="simplify-enhancer"></a>
+<h3 class="section2">SimplifyEnhancer</h3>
+<p>SimplifyEnhancer makes compiling a little faster but don't trim spaces around '&lt;% %&gt;'.
+</p>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -xE Simplify example.euby
+_buf = []; _buf &lt;&lt; '&lt;div&gt;
+'; for item in list ; _buf &lt;&lt; '
+  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
+  &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
+'; end ; _buf &lt;&lt; '
+&lt;/div&gt;
+';
+_buf.join
+</pre>
+<p>SimplifyEnhancer is language-independent.
+</p>
+<br>
+
+
+<a name="bipattern-enhancer"></a>
+<h3 class="section2">BiPatternEnhancer</h3>
+<p>BiPatternEnhancer enables to use another embedded pattern with '&lt;% %&gt;'.
+By Default, '[= ... =]' is available for expression.
+You can specify pattern by :bipattern property.
+</p>
+<a name="bipattern-example.rhtml"></a>
 <div class="program_caption">
-definition of StdoutEruby and StdoutXmlEruby</div>
-<pre class="program">module Erubis
-  class StdoutEruby &lt; Eruby
-    <b>include StdoutEnhancer</b>
-  end
-  class StdoutXmlEruby &lt; XmlEruby
-    <b>include StdoutEnhancer</b>
-  end
-end
+bipattern-example.rhtml</div>
+<pre class="program">&lt;% for item in list %&gt;
+  &lt;b&gt;<b>[= item =]</b>&lt;/b&gt;
+  &lt;b&gt;<b>[== item =]</b>&lt;/b&gt;
+&lt;% end %&gt;
 </pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -xE BiPattern bipattern-example.rhtml
+_buf = []; for item in list 
+ _buf &lt;&lt; '  &lt;b&gt;'; <b>_buf &lt;&lt; ( item ).to_s;</b> _buf &lt;&lt; '&lt;/b&gt;
+  &lt;b&gt;'; <b>_buf &lt;&lt; Erubis::XmlHelper.escape_xml( item );</b> _buf &lt;&lt; '&lt;/b&gt;
+'; end 
+_buf.join
+</pre>
+<p>BiPatternEnhancer is language-independent.
+</p>
+<br>
+
+
+<a name="percentline-enhancer"></a>
+<h3 class="section2">PercentLineEnhancer</h3>
+<p>PercentLineEnhancer regards lines starting with '%' as Ruby code.
+This is for compatibility with eruby and ERB.
+</p>
+<a name="percentline-example.rhtml"></a>
+<div class="program_caption">
+percentline-example.rhtml</div>
+<pre class="program"><b>% for item in list</b>
+  &lt;b&gt;&lt;%= item %&gt;&lt;/b&gt;
+<b>% end</b>
+%% lines with '%%'
+</pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -xE PercentLine percentline-example.rhtml
+_buf = []; <b>for item in list</b>
+ _buf &lt;&lt; '  &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
+'; <b>end</b>
+ _buf &lt;&lt; '% lines with \'%%\'
+';
+_buf.join
+</pre>
+<p>PercentLineEnhancer is language-independent.
+</p>
 <br>
 
 
-<a name="tut-print"></a>
-<h3 class="section2">Print Avairable Eruby</h3>
-<p>Erubis::PrintEruby and Erubis::PrintXmlEruby enables you to use print statement.
-You can get output as String because Erubis::PrintEruby and Erubis::PrintXmlEruby doesn't use $stdout.
+<a name="headerfooter-enhancer"></a>
+<h3 class="section2">HeaderFooterEnhancer</h3>
+<p>[experimental]
 </p>
-<p>Notice:
+<p>HeaderFooterEnhancer enables you to add header and footer in eRuby script.
 </p>
- <ul type="disc">
- <li>Use evaluate() and don't use result().
- </li>
- <li>Only print() is available, put() or p() are not available.
- </li>
- <li>PrintEruby and PrintXmlEruby has instance method 'print()'.
-    It means that print statement invokes PrintEruby#print() or PrintXmlEruby#print(),
-    and Kernel#print() is not invoked.
- </li>
- <li>PrintEruby#print() and PrintXmlEruby#print() can take just an argument.
- </li>
- </ul>
-<a name="example9.eruby"></a>
+<a name="headerfooter-example.eruby"></a>
 <div class="program_caption">
-example9.eruby</div>
-<pre class="program">&lt;ul&gt;
- &lt;% for item in list %&gt;
-  &lt;li&gt;<b>&lt;% print item %&gt;</b>&lt;/li&gt;
- &lt;% end %&gt;
-&lt;/ul&gt;
+headerfooter-example.eruby</div>
+<pre class="program"><b>&lt;!--#header:</b>
+<b>def list_items(items)</b>
+<b>#--&gt;</b>
+&lt;% for item in items %&gt;
+  &lt;b&gt;&lt;%= item %&gt;&lt;/b&gt;
+&lt;% end %&gt;
+<b>&lt;!--#footer:</b>
+<b>end</b>
+<b>#--&gt;</b>
 </pre>
-<a name="example9.rb"></a>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -xE HeaderFooter headerfooter-example.eruby
+
+<b>def list_items(items)</b>
+
+_buf = []; for item in items 
+ _buf &lt;&lt; '  &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
+'; end 
+_buf.join
+
+<b>end</b>
+
+</pre>
+<p>Compare to the following:
+</p>
+<a name="normal-eruby-test.eruby"></a>
 <div class="program_caption">
-example9.rb</div>
-<pre class="program">## create Eruby object
-require 'erubis'
-input = File.read('example9.eruby')
-eruby = Erubis::<b>PrintEruby</b>.new(input)
+normal-eruby-test.eruby</div>
+<pre class="program"><b>&lt;%</b>
+<b>def list_items(items)</b>
+<b>%&gt;</b>
+&lt;% for item in items %&gt;
+&lt;li&gt;&lt;%= item %&gt;&lt;/li&gt;
+&lt;% end %&gt;
+<b>&lt;%</b>
+<b>end</b>
+<b>%&gt;</b>
+</pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -x normal-eruby-test.eruby
+_buf = [];
+<b>def list_items(items)</b>
 
-## print script source
-puts "--- script source ---"
-puts eruby.src
+ for item in items 
+ _buf &lt;&lt; '&lt;li&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/li&gt;
+'; end 
 
-## get result
-puts "--- result ---"
-list = ['aaa', 'bbb', 'ccc']
-puts <b>eruby.evaluate(:list =&gt; list)</b>   # don't use result()!
+<b>end</b>
+
+_buf.join
+</pre>
+<p>Header and footer can be in any position in eRuby script,
+that is, header is no need to be in the head of eRuby script.
+</p>
+<a name="headerfooter-example2.rhtml"></a>
+<div class="program_caption">
+headerfooter-example2.rhtml</div>
+<pre class="program">&lt;?xml version="1.0"?&gt;
+&lt;html&gt;
+<b>&lt;!--#header:</b>
+<b>def page(list)</b>
+<b>#--&gt;</b>
+ :
+<b>&lt;!--#footer:</b>
+<b>end</b>
+<b>#--&gt;</b>
+&lt;/html&gt;
 </pre>
 <div class="terminal_caption">
-output</div>
-<pre class="terminal">$ ruby example9.rb
---- script source ---
-<b>@_out =</b> _out = ''; _out &lt;&lt; "&lt;ul&gt;\n"
-  for item in list 
-_out &lt;&lt; "  &lt;li&gt;";  <b>print item</b> ; _out &lt;&lt; "&lt;/li&gt;\n"
-  end 
-_out &lt;&lt; "&lt;/ul&gt;\n"
-_out
---- result ---
-&lt;ul&gt;
-  &lt;li&gt;aaa&lt;/li&gt;
-  &lt;li&gt;bbb&lt;/li&gt;
-  &lt;li&gt;ccc&lt;/li&gt;
-&lt;/ul&gt;
+compiled source code</div>
+<pre class="terminal">$ erubis -xE HeaderFooter headerfooter-example2.rhtml
+
+<b>def page(list)</b>
+
+_buf = []; _buf &lt;&lt; '&lt;?xml version="1.0"?&gt;
+&lt;html&gt;
+'; _buf &lt;&lt; ' :
+'; _buf &lt;&lt; '&lt;/html&gt;
+';
+_buf.join
+
+<b>end</b>
+
 </pre>
-<p>Here is the definition of PrintEruby or PrintXmlEruby.
-They are subclass of Eruby and XmlEruby respectively and only include PrintEnhancer module.
-It shows that Erubis is extensible.
+<p>HeaderFooterEnhancer is experimental and is language-independent.
 </p>
+<br>
+
+
+<br>
+
+
+<a name="lang"></a>
+<h2 class="section1">Multi-Language</h2>
+<p>Erubis supports the following language currently:
+</p>
+<ul type="disc">
+<li>Ruby
+</li>
+<li>PHP
+</li>
+<li>C
+</li>
+<li>Java
+</li>
+<li>Scheme
+</li>
+<li>Perl
+</li>
+<li>JavaScript
+</li>
+</ul>
+<a name="lang-php"></a>
+<h3 class="section2">PHP</h3>
+<a name="example.ephp"></a>
 <div class="program_caption">
-definition of PrintEruby and PrintXmlEruby</div>
-<pre class="program">module Erubis
-  class PrintEruby &lt; Eruby
-    <b>include PrintEnhancer</b>
-  end
-  class PrintXmlEruby &lt; XmlEruby
-    <b>include PrintEnhancer</b>
-  end
-end
+example.ephp</div>
+<pre class="program">&lt;?xml version="1.0"?&gt;
+&lt;html&gt;
+ &lt;body&gt;
+  &lt;p&gt;Hello <b>&lt;%= $user %&gt;</b>!&lt;/p&gt;
+  &lt;table&gt;
+   &lt;tbody&gt;
+    <b>&lt;% $i = 0; %&gt;</b>
+    <b>&lt;% foreach ($list as $item) { %&gt;</b>
+    <b>&lt;%   $i++; %&gt;</b>
+    &lt;tr bgcolor=<b>"&lt;%= $i % 2 == 0 ? '#FFCCCC' : '#CCCCFF' %&gt;"</b>&gt;
+     &lt;td&gt;<b>&lt;%= $i %&gt;</b>&lt;/td&gt;
+     &lt;td&gt;<b>&lt;%== $item %&gt;</b>&lt;/td&gt;
+    &lt;/tr&gt;
+    &lt;% } %&gt;
+   &lt;/tbody&gt;
+  &lt;/table&gt;
+ &lt;/body&gt;
+&lt;/html&gt;
+</pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -l php example.ephp
+&lt;&lt;?php ?&gt;?xml version="1.0"?&gt;
+&lt;html&gt;
+ &lt;body&gt;
+  &lt;p&gt;Hello &lt;?php echo $user; ?&gt;!&lt;/p&gt;
+  &lt;table&gt;
+   &lt;tbody&gt;
+&lt;?php     $i = 0; ?&gt;
+&lt;?php     foreach ($list as $item) { ?&gt;
+&lt;?php       $i++; ?&gt;
+    &lt;tr bgcolor="&lt;?php echo $i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'; ?&gt;"&gt;
+     &lt;td&gt;&lt;?php echo $i; ?&gt;&lt;/td&gt;
+     &lt;td&gt;&lt;?php echo htmlspecialchars($item); ?&gt;&lt;/td&gt;
+    &lt;/tr&gt;
+&lt;?php     } ?&gt;
+   &lt;/tbody&gt;
+  &lt;/table&gt;
+ &lt;/body&gt;
+&lt;/html&gt;
 </pre>
 <br>
 
 
+<a name="lang-c"></a>
+<h3 class="section2">C</h3>
+<a name="example.ec"></a>
+<div class="program_caption">
+example.ec</div>
+<pre class="program"><b>&lt;%
+#include &lt;stdio.h&gt;
+
+int main(int argc, char *argv[])
+{
+    int i;
+
+%&gt;</b>
+&lt;html&gt;
+ &lt;body&gt;
+  &lt;p&gt;Hello <b>&lt;%= "%s", argv[0] %&gt;</b>!&lt;/p&gt;
+  &lt;table&gt;
+   &lt;tbody&gt;
+    <b>&lt;% for (i = 1; i &lt; argc; i++) { %&gt;</b>
+    &lt;tr bgcolor="<b>&lt;%= i % 2 == 0 ? "#FFCCCC" : "#CCCCFF" %&gt;</b>"&gt;
+      &lt;td&gt;<b>&lt;%= "%d", i %&gt;</b>&lt;/td&gt;
+      &lt;td&gt;<b>&lt;%= "%s", argv[i] %&gt;</b>&lt;/td&gt;
+    &lt;/tr&gt;
+    <b>&lt;% } %&gt;</b>
+   &lt;/tbody&gt;
+  &lt;/table&gt;
+ &lt;/body&gt;
+&lt;/html&gt;
+<b>&lt;%
+    return 0; 
+}
+%&gt;</b>
+</pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -l c example.ec
+#line 1 "example.ec"
+
+#include &lt;stdio.h&gt;
+
+int main(int argc, char *argv[])
+{
+    int i;
+
+
+fputs("&lt;html&gt;\n"
+      " &lt;body&gt;\n"
+      "  &lt;p&gt;Hello ", stdout); fprintf(stdout, "%s", argv[0]); fputs("!&lt;/p&gt;\n"
+      "  &lt;table&gt;\n"
+      "   &lt;tbody&gt;\n", stdout);
+     for (i = 1; i &lt; argc; i++) { 
+fputs("    &lt;tr bgcolor=\"", stdout); fprintf(stdout, i % 2 == 0 ? "#FFCCCC" : "#CCCCFF"); fputs("\"&gt;\n"
+      "      &lt;td&gt;", stdout); fprintf(stdout, "%d", i); fputs("&lt;/td&gt;\n"
+      "      &lt;td&gt;", stdout); fprintf(stdout, "%s", argv[i]); fputs("&lt;/td&gt;\n"
+      "    &lt;/tr&gt;\n", stdout);
+     } 
+fputs("   &lt;/tbody&gt;\n"
+      "  &lt;/table&gt;\n"
+      " &lt;/body&gt;\n"
+      "&lt;/html&gt;\n", stdout);
+
+    return 0; 
+}
+
+</pre>
+<br>
+
+
+<a name="lang-java"></a>
+<h3 class="section2">Java</h3>
+<a name="Example.ejava"></a>
+<div class="program_caption">
+Example.ejava</div>
+<pre class="program"><b>&lt;%
+import java.util.*;
+
+public class Example {
+  private String user;
+  private String[] list;
+  public example(String user, String[] list) {
+    this.user = user;
+    this.list = list;
+  }
+
+  public String view() {
+    StringBuffer _buf = new StringBuffer();
+%&gt;</b>
+&lt;html&gt;
+ &lt;body&gt;
+  &lt;p&gt;Hello <b>&lt;%= user %&gt;</b>!&lt;/p&gt;
+  &lt;table&gt;
+   &lt;tbody&gt;
+    <b>&lt;% for (int i = 0; i &lt; list.length; i++) { %&gt;</b>
+    &lt;tr bgcolor=<b>"&lt;%= i % 2 == 0 ? "#FFCCCC" : "#CCCCFF" %&gt;"</b>&gt;
+     &lt;td&gt;<b>&lt;%= i + 1 %&gt;</b>&lt;/td&gt;
+     &lt;td&gt;<b>&lt;%== list[i] %&gt;</b>&lt;/td&gt;
+    &lt;/tr&gt;
+    <b>&lt;% } %&gt;</b>
+   &lt;/tbody&gt;
+  &lt;/table&gt;
+ &lt;body&gt;
+&lt;/html&gt;
+<b>&lt;%
+    return _buf.toString();
+  }
+
+  public static void main(String[] args) {
+    String[] list = { "&lt;aaa&gt;", "b&amp;b", "\"ccc\"" };
+    Example ex = Example.new("Erubis", list);
+    System.out.print(ex.view());
+  }
+
+  public static String escape(String s) {
+    StringBuffer sb = new StringBuffer();
+    for (int i = 0; i &lt; s.length(); i++) {
+      char ch = s.charAt(i);
+      switch (ch) {
+      case '&lt;':   sb.append("&amp;lt;"); break;
+      case '&gt;':   sb.append("&amp;gt;"); break;
+      case '&amp;':   sb.append("&amp;amp;"); break;
+      case '"':   sb.append("&amp;quot;"); break;
+      default:    sb.append(ch);
+      }
+    }
+    return sb.toString();
+  }
+}
+%&gt;</b>
+</pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -b -l java example.ejava
+StringBuffer _buf = new StringBuffer();
+import java.util.*;
+
+public class Example {
+  private String user;
+  private String[] list;
+  public example(String user, String[] list) {
+    this.user = user;
+    this.list = list;
+  }
+
+  public String view() {
+    StringBuffer _buf = new StringBuffer();
+
+_buf.append("&lt;html&gt;\n"
+          + " &lt;body&gt;\n"
+          + "  &lt;p&gt;Hello "); _buf.append(user); _buf.append("!&lt;/p&gt;\n"
+          + "  &lt;table&gt;\n"
+          + "   &lt;tbody&gt;\n");
+     for (int i = 0; i &lt; list.length; i++) { 
+_buf.append("    &lt;tr bgcolor=\""); _buf.append(i % 2 == 0 ? "#FFCCCC" : "#CCCCFF"); _buf.append("\"&gt;\n"
+          + "     &lt;td&gt;"); _buf.append(i + 1); _buf.append("&lt;/td&gt;\n"
+          + "     &lt;td&gt;"); _buf.append(escape(list[i])); _buf.append("&lt;/td&gt;\n"
+          + "    &lt;/tr&gt;\n");
+     } 
+_buf.append("   &lt;/tbody&gt;\n"
+          + "  &lt;/table&gt;\n"
+          + " &lt;body&gt;\n"
+          + "&lt;/html&gt;\n");
+
+    return _buf.toString();
+  }
+
+  public static void main(String[] args) {
+    String[] list = { "&lt;aaa&gt;", "b&amp;b", "\"ccc\"" };
+    Example ex = Example.new("Erubis", list);
+    System.out.print(ex.view());
+  }
+
+  public static String escape(String s) {
+    StringBuffer sb = new StringBuffer();
+    for (int i = 0; i &lt; s.length(); i++) {
+      char ch = s.charAt(i);
+      switch (ch) {
+      case '&lt;':   sb.append("&amp;lt;"); break;
+      case '&gt;':   sb.append("&amp;gt;"); break;
+      case '&amp;':   sb.append("&amp;amp;"); break;
+      case '"':   sb.append("&amp;quot;"); break;
+      default:    sb.append(ch);
+      }
+    }
+    return sb.toString();
+  }
+}
+
+return _buf.toString();
+</pre>
+<br>
+
+
+<a name="lang-scheme"></a>
+<h3 class="section2">Scheme</h3>
+<a name="example.escheme"></a>
+<div class="program_caption">
+example.escheme</div>
+<pre class="program">&lt;html&gt;
+ &lt;body&gt;
+<b>&lt;%
+(let ((user "Erubis")
+      (items '("&lt;aaa&gt;" "b&amp;b" "\"ccc\""))
+      (i 0))
+ %&gt;</b>
+  &lt;p&gt;Hello <b>&lt;%= user %&gt;</b>!&lt;/p&gt;
+  &lt;table&gt;
+<b>&lt;%
+  (for-each
+   (lambda (item)
+     (set! i (+ i 1))
+ %&gt;</b>
+   &lt;tr bgcolor="<b>&lt;%= (if (= (modulo i 2) 0) "#FFCCCC" "#CCCCFF") %&gt;</b>"&gt;
+    &lt;td&gt;<b>&lt;%= i %&gt;</b>&lt;/td&gt;
+    &lt;td&gt;<b>&lt;%= item %&gt;</b>&lt;/td&gt;
+   &lt;/tr&gt;
+<b>&lt;%
+   ) ; lambda end
+   items) ; for-each end
+ %&gt;</b>
+  &lt;/table&gt;
+<b>&lt;%
+) ; let end
+%&gt;</b>
+ &lt;/body&gt;
+&lt;/html&gt;
+</pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -l scheme example.escheme
+(let ((_buf '())) (define (_add x) (set! _buf (cons x _buf))) (_add "&lt;html&gt;
+ &lt;body&gt;\n")
+
+(let ((user "Erubis")
+      (items '("&lt;aaa&gt;" "b&amp;b" "\"ccc\""))
+      (i 0))
+ 
+(_add "  &lt;p&gt;Hello ")(_add user)(_add "!&lt;/p&gt;
+  &lt;table&gt;\n")
+
+  (for-each
+   (lambda (item)
+     (set! i (+ i 1))
+ 
+(_add "   &lt;tr bgcolor=\"")(_add (if (= (modulo i 2) 0) "#FFCCCC" "#CCCCFF"))(_add "\"&gt;
+    &lt;td&gt;")(_add i)(_add "&lt;/td&gt;
+    &lt;td&gt;")(_add item)(_add "&lt;/td&gt;
+   &lt;/tr&gt;\n")
+
+   ) ; lambda end
+   items) ; for-each end
+ 
+(_add "  &lt;/table&gt;\n")
+
+) ; let end
+
+(_add " &lt;/body&gt;
+&lt;/html&gt;\n")
+  (reverse _buf))
+</pre>
+<div class="terminal_caption">
+compiled source code (with --func=display property)</div>
+<pre class="terminal">$ erubis -l scheme --func=display example.escheme
+(display "&lt;html&gt;
+ &lt;body&gt;\n")
+
+(let ((user "Erubis")
+      (items '("&lt;aaa&gt;" "b&amp;b" "\"ccc\""))
+      (i 0))
+ 
+(display "  &lt;p&gt;Hello ")(display user)(display "!&lt;/p&gt;
+  &lt;table&gt;\n")
+
+  (for-each
+   (lambda (item)
+     (set! i (+ i 1))
+ 
+(display "   &lt;tr bgcolor=\"")(display (if (= (modulo i 2) 0) "#FFCCCC" "#CCCCFF"))(display "\"&gt;
+    &lt;td&gt;")(display i)(display "&lt;/td&gt;
+    &lt;td&gt;")(display item)(display "&lt;/td&gt;
+   &lt;/tr&gt;\n")
+
+   ) ; lambda end
+   items) ; for-each end
+ 
+(display "  &lt;/table&gt;\n")
+
+) ; let end
+
+(display " &lt;/body&gt;
+&lt;/html&gt;\n")
+</pre>
+<br>
+
+
+<a name="lang-perl"></a>
+<h3 class="section2">Perl</h3>
+<a name="example.eperl"></a>
+<div class="program_caption">
+example.eprl</div>
+<pre class="program"><b>&lt;%
+   my $user = 'Erubis';
+   my @list = ('&lt;aaa&gt;', 'b&amp;b', '"ccc"');
+%&gt;</b>
+&lt;html&gt;
+ &lt;body&gt;
+  &lt;p&gt;Hello <b>&lt;%= $user %&gt;</b>!&lt;/p&gt;
+  &lt;table&gt;
+   <b>&lt;% $i = 0; %&gt;</b>
+   <b>&lt;% for $item (@list) { %&gt;</b>
+   &lt;tr bgcolor=<b>&lt;%= ++$i % 2 == 0 ? '#FFCCCC' : '#CCCCFF' %&gt;</b>"&gt;
+    &lt;td&gt;<b>&lt;%= $i %&gt;</b>&lt;/td&gt;
+    &lt;td&gt;<b>&lt;%= $item %&gt;</b>&lt;/td&gt;
+   &lt;/tr&gt;
+   <b>&lt;% } %&gt;</b>
+  &lt;/table&gt;
+ &lt;/body&gt;
+&lt;/html&gt;
+</pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -l perl example.eperl
+
+   my $user = 'Erubis';
+   my @list = ('&lt;aaa&gt;', 'b&amp;b', '"ccc"');
+
+print('&lt;html&gt;
+ &lt;body&gt;
+  &lt;p&gt;Hello '); print($user); print('!&lt;/p&gt;
+  &lt;table&gt;
+');     $i = 0; 
+    for $item (@list) { 
+print('   &lt;tr bgcolor='); print(++$i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'); print('"&gt;
+    &lt;td&gt;'); print($i); print('&lt;/td&gt;
+    &lt;td&gt;'); print($item); print('&lt;/td&gt;
+   &lt;/tr&gt;
+');     } 
+print('  &lt;/table&gt;
+ &lt;/body&gt;
+&lt;/html&gt;
+'); 
+</pre>
+<br>
+
+
+<a name="lang-javascript"></a>
+<h3 class="section2">JavaScript</h3>
+<p>example.ejs
+</p>
+<a name="example.ejs"></a>
+<pre class="program"><b>&lt;%
+   var user = 'Erubis';
+   var list = ['&lt;aaa&gt;', 'b&amp;b', '"ccc"'];
+ %&gt;</b>
+&lt;html&gt;
+ &lt;body&gt;
+  &lt;p&gt;Hello <b>&lt;%= user %&gt;</b>!&lt;/p&gt;
+  &lt;table&gt;
+   &lt;tbody&gt;
+    <b>&lt;% var i; %&gt;</b>
+    <b>&lt;% for (i = 0; i &lt; list.length; i++) { %&gt;</b>
+    &lt;tr bgcolor="<b>&lt;%= i % 2 == 0 ? '#FFCCCC' : '#CCCCFF' %&gt;</b>"&gt;
+     &lt;td&gt;<b>&lt;%= i + 1 %&gt;</b>&lt;/td&gt;
+     &lt;td&gt;<b>&lt;%= list[i] %&gt;</b>&lt;/td&gt;
+    &lt;/tr&gt;
+    <b>&lt;% } %&gt;</b>
+   &lt;/tbody&gt;
+  &lt;/table&gt;
+ &lt;/body&gt;
+&lt;/html&gt;
+</pre>
+<div class="terminal_caption">
+compiled source code</div>
+<pre class="terminal">$ erubis -l js example.ejs
+var _buf = [];
+   var user = 'Erubis';
+   var list = ['&lt;aaa&gt;', 'b&amp;b', '"ccc"'];
+ 
+_buf.push("&lt;html&gt;\n\
+ &lt;body&gt;\n\
+  &lt;p&gt;Hello "); _buf.push(user); _buf.push("!&lt;/p&gt;\n\
+  &lt;table&gt;\n\
+   &lt;tbody&gt;\n");
+     var i; 
+     for (i = 0; i &lt; list.length; i++) { 
+_buf.push("    &lt;tr bgcolor=\""); _buf.push(i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'); _buf.push("\"&gt;\n\
+     &lt;td&gt;"); _buf.push(i + 1); _buf.push("&lt;/td&gt;\n\
+     &lt;td&gt;"); _buf.push(list[i]); _buf.push("&lt;/td&gt;\n\
+    &lt;/tr&gt;\n");
+     } 
+_buf.push("   &lt;/tbody&gt;\n\
+  &lt;/table&gt;\n\
+ &lt;/body&gt;\n\
+&lt;/html&gt;\n");
+document.write(_buf.join(""));
+</pre>
+<br>
+
+
+<br>
+
+
+<a name="topics"></a>
+<h2 class="section1">Other Topics</h2>
+<a name="topics-tinyeruby"></a>
+<h3 class="section2">TinyEruby class</h3>
+<p>TinyEruby class in 'erubis/tiny.rb' is the smallest implementation of eRuby.
+If you don't need any enhancements of Erubis and only require simple eRuby implementation,
+try TinyEruby class.
+</p>
+<br>
+
+
+<a name="topics-php"></a>
+<h3 class="section2">NoTextEnhancer in PHP</h3>
+<p>NoTextEnhancer is quite useful not only for eRuby but also for PHP.
+It can "drop" HTML text and show up embedded Ruby/PHP code.
+</p>
+<p>For example, see the following PHP script.
+</p>
+<a name="notext-example.php"></a>
+<div class="program_caption">
+notext-example.php</div>
+<pre class="program">&lt;html&gt;
+  &lt;body&gt;
+    &lt;h3&gt;List&lt;/h3&gt;
+    &lt;?php if (!$list || count($list) == 0) { ?&gt;
+    &lt;p&gt;not found.&lt;/p&gt;
+    &lt;?php } else { ?&gt;
+    &lt;table&gt;
+      &lt;tbody&gt;
+        &lt;?php $i = 0; ?&gt;
+        &lt;?php foreach ($list as $item) { ?&gt;
+        &lt;tr bgcolor="&lt;?php echo ++$i % 2 == 1 ? '#FFCCCC' : '#CCCCFF'; ?&gt;"&gt;
+          &lt;td&gt;&lt;?php echo $item; ?&gt;&lt;/td&gt;
+        &lt;/tr&gt;
+        &lt;?php } ?&gt;
+      &lt;/tbody&gt;
+    &lt;/table&gt;
+    &lt;?php } ?&gt;
+  &lt;/body&gt;
+&lt;/html&gt;
+</pre>
+<p>This is complex because PHP code and HTML document are mixed.
+NoTextEnhancer can separate PHP code from HTML document.
+</p>
+<div class="terminal_caption">
+example of using NoTextEnhancer with PHP file</div>
+<pre class="terminal">$ erubis -T -l php -E NoText -p '&lt;\?php \?&gt;' notext-example.php | uniq
+
+    &lt;?php if (!$list || count($list) == 0) { ?&gt;
+
+    &lt;?php } else { ?&gt;
+
+        &lt;?php $i = 0; ?&gt;
+        &lt;?php foreach ($list as $item) { ?&gt;
+                     &lt;?php echo ++$i % 2 == 1 ? '#FFCCCC' : '#CCCCFF'; ?&gt;
+              &lt;?php echo $item; ?&gt;
+
+        &lt;?php } ?&gt;
+
+    &lt;?php } ?&gt;
+
+</pre>
+<br>
+
+
+<a name="topics-benchmark"></a>
+<h3 class="section2">Benchmark</h3>
+<p>A benchmark script is included in Erubis package at erubis-X.X.X/benchark directory.
+Here is an example result of benchmark.
+</p>
+<div class="output_caption">
+Env: Linux FedoraCore4, Celeron 667MHz, Mem512MB, Ruby1.8.4</div>
+<pre class="output">                                        user     system      total        real
+ERuby                             138.280000   1.900000 140.180000 (141.470426)
+ERB                               402.220000   3.190000 405.410000 (408.886894)
+Erubis::Eruby                     147.080000   2.400000 149.480000 (150.752255)
+Erubis::StringBufferEruby         186.130000   2.600000 188.730000 (190.374098)
+Erubis::SimplifiedEruby           130.100000   2.210000 132.310000 (133.426010)
+Erubis::StdoutEruby               106.010000   2.130000 108.140000 (108.999193)
+Erubis::StdoutSimplifiedEruby      97.130000   2.180000  99.310000 (100.104433)
+Erubis::TinyEruby                 118.740000   2.360000 121.100000 (122.141380)
+Erubis::TinyStdoutEruby            86.140000   1.840000  87.980000 ( 88.679196)
+</pre>
+<div class="output_caption">
+Env: MacOS X 10.4, PowerPC 1.42GHz, Mem1.5GB, Ruby1.8.4</div>
+<pre class="output">                                        user     system      total        real
+ERuby                              55.040000   2.120000  57.160000 ( 89.311397)
+ERB                               103.960000   3.480000 107.440000 (159.231792)
+Erubis::Eruby                      36.130000   1.570000  37.700000 ( 52.188574)
+Erubis::StringBufferEruby          47.270000   1.980000  49.250000 ( 73.867537)
+Erubis::SimplifiedEruby            34.310000   1.600000  35.910000 ( 51.762841)
+Erubis::StdoutEruby                26.240000   1.490000  27.730000 ( 41.840430)
+Erubis::StdoutSimplifiedEruby      25.380000   1.340000  26.720000 ( 37.231918)
+Erubis::TinyEruby                  31.690000   1.590000  33.280000 ( 49.862091)
+Erubis::TinyStdoutEruby            22.550000   1.230000  23.780000 ( 33.316978)
+</pre>
+<p>This shows that:
+</p>
+<ul type="disc">
+<li>Erubis::Eruby is about 2.7 or 2.9 times faster than ERB.
+</li>
+<li>Erubis::Eruby is about 6% slower in linux or 1.5 times faster than ERuby in Mac.
+</li>
+<li>Erubis::SimplifiedEruby (which incudes SimplifiedEnhander) is faster than ERuby.
+</li>
+<li>String buffer (StringBufferEnhancer) is slower than array buffer (ArrayBufferEnhancer which Erubis::Eruby includes)
+</li>
+<li>Using print statement or $stdout is faster than array buffer and string buffer.
+</li>
+<li>Erubis::TinyEruby (at 'erubis/tiny.rb') and it's subclasses are the fastest in all eRuby implementation.
+</li>
+</ul>
+<br>
+
+
 <br>
 
 
@@ -724,7 +1814,7 @@ end
 <h2 class="section1">Command Reference</h2>
 <a name="command-usage"></a>
 <h3 class="section2">Usage</h3>
-<p>erubis [-hvsT] [-p <i>pattern</i>] [-c <i>class</i>] [-K <i>kanji</i>] [-f <i>file.yaml</i>] [<i>file</i> ...]
+<p>erubis [..options..] [<i>file</i> ...]
 </p>
 <br>
 
@@ -743,30 +1833,52 @@ end
   	Release version.
   </dd>
   <dt class="dt3"><b>
--s            </b></dt>
+-x            </b></dt>
   <dd class="dd3">
-  	Show script source.
+  	Show compiled source.
   </dd>
   <dt class="dt3"><b>
 -T            </b></dt>
   <dd class="dd3">
   	No trimming spaces around '&lt;% %&gt;'.
+			This is equivarent to '--trim=false'.
+  </dd>
+  <dt class="dt3"><b>
+-b            </b></dt>
+  <dd class="dd3">
+  	Body only (no preamble nor postamble).
+			This is equivarent to '--preamble=false --postamble=false'.
+  </dd>
+  <dt class="dt3"><b>
+-e            </b></dt>
+  <dd class="dd3">
+  	Escape. This is equivarent to '-E Escape'.
   </dd>
   <dt class="dt3"><b>
 -p pattern    </b></dt>
   <dd class="dd3">
   	Embedded pattern (default '&lt;% %&gt;').
+			This is equivarent to '--pattern=<i>pattern</i>'.
+  </dd>
+  <dt class="dt3"><b>
+-l lang       </b></dt>
+  <dd class="dd3">
+  	Language name.
+			This option makes erubis command to compile script but no execute.
   </dd>
   <dt class="dt3"><b>
--c class      </b></dt>
+-E enhacers   </b></dt>
   <dd class="dd3">
-  	Class name (Eruby, XmlEruby, FastEruby, ...) (default Eruby).
+  	Enhancer name (Escape, PercentLine, ...).
+			It is able to specify several enhancer name separating with ','
+			(ex. -f Escape,PercentLine,HeaderFooter).
   </dd>
   <dt class="dt3"><b>
 -I path       </b></dt>
   <dd class="dd3">
   	Require library path ($:).
-			It is able to specify several paths separating with ',' (ex. -f path1,path2,path3).
+			It is able to specify several paths separating with ','
+			(ex. -f path1,path2,path3).
   </dd>
   <dt class="dt3"><b>
 -K kanji      </b></dt>
@@ -777,17 +1889,37 @@ end
 -f file.yaml  </b></dt>
   <dd class="dd3">
   	YAML file for context values (read stdin if filename is '-').
-			It is able to specify several filenames separating with ',' (ex. -f file1,file2,file3).
+			It is able to specify several filenames separating with ','
+			(ex. -f file1,file2,file3).
+  </dd>
+  <dt class="dt3"><b>
+-t            </b></dt>
+  <dd class="dd3">
+  	Expand tab characters in YAML file.
   </dd>
   <dt class="dt3"><b>
---name=value  </b></dt>
+-S            </b></dt>
   <dd class="dd3">
-  	Variable name and value
+  	Convert mapping key from string to symbol in YAML file.
+  </dd>
+  <dt class="dt3"><b>
+-B		   </b></dt>
+  <dd class="dd3">
+  	invoke Eruby#result() instead of Eruby#evaluate()
   </dd>
   </dl>
 <br>
 
 
+<a name="command-props"></a>
+<h3 class="section2">Properties</h3>
+<p>Some Eruby classes can take optional properties to change it's compile option.
+For example, property '--indent="  "' may change indentation of compiled source code.
+Try 'erubis -h' for details.
+</p>
+<br>
+
+
 <br>