PageRenderTime 41ms CodeModel.GetById 6ms RepoModel.GetById 1ms app.codeStats 0ms

/External.LCA_RESTRICTED/Languages/Ruby/ruby19/lib/ruby/gems/1.9.1/gems/erubis-2.6.6/doc/users-guide.html

http://github.com/IronLanguages/main
HTML | 3286 lines | 3057 code | 229 blank | 0 comment | 0 complexity | 82a50bbe1552bf9bf0ed09a0ea043ad5 MD5 | raw file
Possible License(s): CPL-1.0, BSD-3-Clause, ISC, GPL-2.0, MPL-2.0-no-copyleft-exception 
    

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    2. 

  2. <html>
    3. 

  3. <head>
    4. 

  4.   <meta http-equiv="Content-Type" content="text/html">
    5. 

  5.   <title>Erubis Users' Guide</title>
    6. 

  6.   <meta name="generator" content="kwaser">
    7. 

  7.   <meta http-equiv="Content-Style-Type" content="text/css">
    8. 

  8.   <link rel="stylesheet" href="docstyle.css" type="text/css">
    9. 

  9.  </head>
    10. 

  10.  <body>
    11. 

  11. 

  12.   <blockquote>
    13. 

  13.    <div class="mainbody">
    14. 

  14. 

  15.     <div align="left"><h1>Erubis Users' Guide</h1></div>
    16. 

  16.     <div align="left">
    17. 

  17.       release:     2.6.6<br>
    18. 

  18.       last update: $Date$<br>
    19. 

  19.     </div>
    20. 

  20. 

  21. <p>release: 2.6.6
    22. 

  22. </p>
    23. 

  23. <a name="preface"></a>
    24. 

  24. <h2 class="section1">Preface</h2>
    25. 

  25. <p>Erubis is an implementation of eRuby.
    26. 

  26. It has the following features.
    27. 

  27. </p>
    28. 

  28. <ul type="disc">
    29. 

  29. <li>Very fast, almost three times faster than ERB and about ten percent faster than eruby (implemented in C)
    30. 

  30. </li>
    31. 

  31. <li>File caching of converted Ruby script support
    32. 

  32. </li>
    33. 

  33. <li>Auto escaping support
    34. 

  34. </li>
    35. 

  35. <li>Auto trimming spaces around '&lt;% %&gt;'
    36. 

  36. </li>
    37. 

  37. <li>Embedded pattern changeable (default '&lt;% %&gt;')
    38. 

  38. </li>
    39. 

  39. <li>Enable to handle Processing Instructions (PI) as embedded pattern (ex. '&lt;?rb ... ?&gt;')
    40. 

  40. </li>
    41. 

  41. <li>Multi-language support (Ruby/PHP/C/Java/Scheme/Perl/Javascript)
    42. 

  42. </li>
    43. 

  43. <li>Context object available and easy to combine eRuby template with YAML datafile
    44. 

  44. </li>
    45. 

  45. <li>Print statement available
    46. 

  46. </li>
    47. 

  47. <li>Easy to expand and customize in subclass
    48. 

  48. </li>
    49. 

  49. <li><a href="#rails">Ruby on Rails support</a>
    50. 

  50. </li>
    51. 

  51. <li>mod_ruby support|#topcs-modruby
    52. 

  52. </li>
    53. 

  53. </ul>
    54. 

  54. <p>Erubis is implemented in pure Ruby.  It requires Ruby 1.8 or higher.
    55. 

  55. Erubis now supports Ruby 1.9.
    56. 

  56. </p>
    57. 

  57. <a name="toc"></a>
    58. 

  58. <h3 class="section2">Table of Contents</h3>
    59. 

  59. <ul>
    60. 

  60.   <li><a href="#preface">Preface</a>
    61. 

  61.   <ul>
    62. 

  62.     <li><a href="#toc">Table of Contents</a>
    63. 

  63.     </li>
    64. 

  64.   </ul>
    65. 

  65.   </li>
    66. 

  66.   <li><a href="#install">Installation</a>
    67. 

  67.   </li>
    68. 

  68.   <li><a href="#tutorial">Tutorial</a>
    69. 

  69.   <ul>
    70. 

  70.     <li><a href="#tut-basic">Basic Example</a>
    71. 

  71.     </li>
    72. 

  72.     <li><a href="#tut-trim">Trimming Spaces</a>
    73. 

  73.     </li>
    74. 

  74.     <li><a href="#tut-escape">Escape</a>
    75. 

  75.     </li>
    76. 

  76.     <li><a href="#tut-pattern">Embedded Pattern</a>
    77. 

  77.     </li>
    78. 

  78.     <li><a href="#tut-context">Context Object</a>
    79. 

  79.     </li>
    80. 

  80.     <li><a href="#tut-datafile">Context Data File</a>
    81. 

  81.     </li>
    82. 

  82.     <li><a href="#tut-datastr">Context Data String</a>
    83. 

  83.     </li>
    84. 

  84.     <li><a href="#tut-preamble">Preamble and Postamble</a>
    85. 

  85.     </li>
    86. 

  86.     <li><a href="#tut-pi">Processing Instruction (PI) Converter</a>
    87. 

  87.     </li>
    88. 

  88.     <li><a href="#tut-notext">Retrieve Ruby Code</a>
    89. 

  89.     </li>
    90. 

  90.   </ul>
    91. 

  91.   </li>
    92. 

  92.   <li><a href="#enhancer">Enhancer</a>
    93. 

  93.   <ul>
    94. 

  94.     <li><a href="#escape-enhancer">EscapeEnhancer</a>
    95. 

  95.     </li>
    96. 

  96.     <li><a href="#stdout-enhancer">StdoutEnhancer</a>
    97. 

  97.     </li>
    98. 

  98.     <li><a href="#printout-enhancer">PrintOutEnhancer</a>
    99. 

  99.     </li>
    100. 

  100.     <li><a href="#printenabled-enhancer">PrintEnabledEnhancer</a>
    101. 

  101.     </li>
    102. 

  102.     <li><a href="#array-enhancer">ArrayEnhancer</a>
    103. 

  103.     </li>
    104. 

  104.     <li><a href="#arraybuffer-enhancer">ArrayBufferEnhancer</a>
    105. 

  105.     </li>
    106. 

  106.     <li><a href="#stringbuffer-enhancer">StringBufferEnhancer</a>
    107. 

  107.     </li>
    108. 

  108.     <li><a href="#erbout-enhancer">ErboutEnhancer</a>
    109. 

  109.     </li>
    110. 

  110.     <li><a href="#notext-enhancer">NoTextEnhancer</a>
    111. 

  111.     </li>
    112. 

  112.     <li><a href="#nocode-enhancer">NoCodeEnhancer</a>
    113. 

  113.     </li>
    114. 

  114.     <li><a href="#simplify-enhancer">SimplifyEnhancer</a>
    115. 

  115.     </li>
    116. 

  116.     <li><a href="#bipattern-enhancer">BiPatternEnhancer</a>
    117. 

  117.     </li>
    118. 

  118.     <li><a href="#percentline-enhancer">PercentLineEnhancer</a>
    119. 

  119.     </li>
    120. 

  120.     <li><a href="#headerfooter-enhancer">HeaderFooterEnhancer</a>
    121. 

  121.     </li>
    122. 

  122.     <li><a href="#interpolation-enhancer">InterpolationEnhancer</a>
    123. 

  123.     </li>
    124. 

  124.     <li><a href="#deleteindent-enhancer">DeleteIndentEnhancer</a>
    125. 

  125.     </li>
    126. 

  126.   </ul>
    127. 

  127.   </li>
    128. 

  128.   <li><a href="#lang">Multi-Language Support</a>
    129. 

  129.   <ul>
    130. 

  130.     <li><a href="#lang-php">PHP</a>
    131. 

  131.     </li>
    132. 

  132.     <li><a href="#lang-c">C</a>
    133. 

  133.     </li>
    134. 

  134.     <li><a href="#lang-java">Java</a>
    135. 

  135.     </li>
    136. 

  136.     <li><a href="#lang-scheme">Scheme</a>
    137. 

  137.     </li>
    138. 

  138.     <li><a href="#lang-perl">Perl</a>
    139. 

  139.     </li>
    140. 

  140.     <li><a href="#lang-javascript">JavaScript</a>
    141. 

  141.     </li>
    142. 

  142.   </ul>
    143. 

  143.   </li>
    144. 

  144.   <li><a href="#rails">Ruby on Rails Support</a>
    145. 

  145.   <ul>
    146. 

  146.     <li><a href="#rails-settings">Settings</a>
    147. 

  147.     </li>
    148. 

  148.     <li><a href="#rails-preprocessing">Preprosessing</a>
    149. 

  149.     </li>
    150. 

  150.     <li><a href="#rails-formhelpers">Form Helpers for Preprocessing</a>
    151. 

  151.     </li>
    152. 

  152.     <li><a href="#rails-others">Others</a>
    153. 

  153.     </li>
    154. 

  154.   </ul>
    155. 

  155.   </li>
    156. 

  156.   <li><a href="#topics">Other Topics</a>
    157. 

  157.   <ul>
    158. 

  158.     <li><a href="#'&lt;%= =%&gt;' and '&lt;%= -%&gt;'">'&lt;%= =%&gt;' and '&lt;%= -%&gt;'</a>
    159. 

  159.     </li>
    160. 

  160.     <li><a href="#'&lt;%% %&gt;' and '&lt;%%= %&gt;'">'&lt;%% %&gt;' and '&lt;%%= %&gt;'</a>
    161. 

  161.     </li>
    162. 

  162.     <li><a href="#topics-context-vs-binding">evaluate(context) v.s. result(binding)</a>
    163. 

  163.     </li>
    164. 

  164.     <li><a href="#topics-fasteruby">Class Erubis::FastEruby</a>
    165. 

  165.     </li>
    166. 

  166.     <li><a href="#topics-syntax">Syntax Checking</a>
    167. 

  167.     </li>
    168. 

  168.     <li><a href="#topics-caching">File Caching</a>
    169. 

  169.     </li>
    170. 

  170.     <li><a href="#topics-tinyeruby">Erubis::TinyEruby class</a>
    171. 

  171.     </li>
    172. 

  172.     <li><a href="#topics-php">NoTextEnhancer and NoCodeEnhancer in PHP</a>
    173. 

  173.     </li>
    174. 

  174.     <li><a href="#topcs-modruby">Helper Class for mod_ruby</a>
    175. 

  175.     </li>
    176. 

  176.     <li><a href="#topics-defmethod">Define method</a>
    177. 

  177.     </li>
    178. 

  178.     <li><a href="#topics-benchmark">Benchmark</a>
    179. 

  179.     </li>
    180. 

  180.   </ul>
    181. 

  181.   </li>
    182. 

  182.   <li><a href="#command">Command Reference</a>
    183. 

  183.   <ul>
    184. 

  184.     <li><a href="#command-usage">Usage</a>
    185. 

  185.     </li>
    186. 

  186.     <li><a href="#command-options">Options</a>
    187. 

  187.     </li>
    188. 

  188.     <li><a href="#command-props">Properties</a>
    189. 

  189.     </li>
    190. 

  190.   </ul>
    191. 

  191.   </li>
    192. 

  192. </ul>
    193. 

  193. <br>
    194. 

  194. 

  195. 

  196. <br>
    197. 

  197. 

  198. 

  199. <a name="install"></a>
    200. 

  200. <h2 class="section1">Installation</h2>
    201. 

  201. <ul type="disc">
    202. 

  202. <li>If you have installed RubyGems, just type <code>gem install --remote erubis</code>.
    203. 

  203. <pre class="terminal">$ sudo gem install --remote erubis
    204. 

  204. </pre>
    205. 

  205. </li>
    206. 

  206. </ul>
    207. 

  207. <ul type="disc">
    208. 

  208. <li>Else install <a href="http://rubyforge.org/projects/erubis/">abstract</a> at first,
    209. 

  209.    and download erubis_X.X.X.tar.bz2 and install it by setup.rb.
    210. 

  210. <pre class="terminal">$ tar xjf abstract_X.X.X.tar.bz2
    211. 

  211. $ cd abstract_X.X.X/
    212. 

  212. $ sudo ruby setup.rb
    213. 

  213. $ cd ..
    214. 

  214. $ tar xjf erubis_X.X.X.tar.bz2
    215. 

  215. $ cd erubis_X.X.X/
    216. 

  216. $ sudo ruby setup.rb
    217. 

  217. </pre>
    218. 

  218. </li>
    219. 

  219. </ul>
    220. 

  220. <ul type="disc">
    221. 

  221. <li>(Optional) 'contrib/inline-require' enables you to merge 'lib/**/*.rb' into 'bin/erubis'.
    222. 

  222. <pre class="terminal">$ tar xjf erubis_X.X.X.tar.bz2
    223. 

  223. $ cd erubis_X.X.X/
    224. 

  224. $ unset RUBYLIB
    225. 

  225. $ contrib/inline-require -I lib bin/erubis &gt; contrib/erubis
    226. 

  226. </pre>
    227. 

  227. </li>
    228. 

  228. </ul>
    229. 

  229. <br>
    230. 

  230. 

  231. 

  232. <a name="tutorial"></a>
    233. 

  233. <h2 class="section1">Tutorial</h2>
    234. 

  234. <a name="tut-basic"></a>
    235. 

  235. <h3 class="section2">Basic Example</h3>
    236. 

  236. <p>Here is a basic example of Erubis.
    237. 

  237. </p>
    238. 

  238. <a name="example1.eruby"></a>
    239. 

  239. <div class="program_caption">
    240. 

  240. example1.eruby</div>
    241. 

  241. <pre class="program">&lt;ul&gt;
    242. 

  242.   <strong>&lt;% for item in list %&gt;</strong>
    243. 

  243.   &lt;li&gt;<strong>&lt;%= item %&gt;</strong>&lt;/li&gt;
    244. 

  244.   <strong>&lt;% end %&gt;</strong>
    245. 

  245.   <strong>&lt;%# here is ignored because starting with '#' %&gt;</strong>
    246. 

  246. &lt;/ul&gt;
    247. 

  247. </pre>
    248. 

  248. <a name="example1.rb"></a>
    249. 

  249. <div class="program_caption">
    250. 

  250. example1.rb</div>
    251. 

  251. <pre class="program">require 'erubis'
    252. 

  252. input = File.read('example1.eruby')
    253. 

  253. eruby = <strong>Erubis::Eruby.new(input)</strong>    # create Eruby object
    254. 

  254. 

  255. puts "---------- script source ---"
    256. 

  256. puts <strong>eruby.src</strong>                      # print script source
    257. 

  257. 

  258. puts "---------- result ----------"
    259. 

  259. list = ['aaa', 'bbb', 'ccc']
    260. 

  260. puts <strong>eruby.result(binding())</strong>        # get result
    261. 

  261. ## or puts eruby.result(<strong>:list=&gt;list</strong>)  # or pass Hash instead of Binding
    262. 

  262. 

  263. ## # or
    264. 

  264. ## eruby = Erubis::Eruby.new
    265. 

  265. ## input = File.read('example1.eruby')
    266. 

  266. ## src = eruby.convert(input)
    267. 

  267. ## eval src
    268. 

  268. </pre>
    269. 

  269. <a name="example1.result"></a>
    270. 

  270. <div class="terminal_caption">
    271. 

  271. output</div>
    272. 

  272. <pre class="terminal">$ ruby example1.rb
    273. 

  273. ---------- script source ---
    274. 

  274. _buf = ''; _buf &lt;&lt; '&lt;ul&gt;
    275. 

  275. ';   for item in list 
    276. 

  276.  _buf &lt;&lt; '  &lt;li&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/li&gt;
    277. 

  277. ';   end 
    278. 

    279. 

  279.  _buf &lt;&lt; '&lt;/ul&gt;
    280. 

  280. ';
    281. 

  281. _buf.to_s
    282. 

  282. ---------- result ----------
    283. 

  283. &lt;ul&gt;
    284. 

  284.   &lt;li&gt;aaa&lt;/li&gt;
    285. 

  285.   &lt;li&gt;bbb&lt;/li&gt;
    286. 

  286.   &lt;li&gt;ccc&lt;/li&gt;
    287. 

  287. &lt;/ul&gt;
    288. 

  288. </pre>
    289. 

  289. <p>Erubis has command 'erubis'.  Command-line option '-x' shows the compiled source code of eRuby script.
    290. 

  290. </p>
    291. 

  291. <a name="example1_x.result"></a>
    292. 

  292. <div class="terminal_caption">
    293. 

  293. example of command-line option '-x'</div>
    294. 

  294. <pre class="terminal">$ erubis <strong>-x</strong> example1.eruby
    295. 

  295. _buf = ''; _buf &lt;&lt; '&lt;ul&gt;
    296. 

  296. ';   for item in list 
    297. 

  297.  _buf &lt;&lt; '  &lt;li&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/li&gt;
    298. 

  298. ';   end 
    299. 

    300. 

  300.  _buf &lt;&lt; '&lt;/ul&gt;
    301. 

  301. ';
    302. 

  302. _buf.to_s
    303. 

  303. </pre>
    304. 

  304. <br>
    305. 

  305. 

  306. 

  307. <a name="tut-trim"></a>
    308. 

  308. <h3 class="section2">Trimming Spaces</h3>
    309. 

  309. <p>Erubis deletes spaces around '&lt;% %&gt;' automatically, while it leaves spaces around '&lt;%= %&gt;'.
    310. 

  310. </p>
    311. 

  311. <a name="example2.eruby.comment_filter"></a>
    312. 

  312. <div class="program_caption">
    313. 

  313. example2.eruby</div>
    314. 

  314. <pre class="program">&lt;ul&gt;
    315. 

  315.   &lt;% for item in list %&gt;      # trimmed
    316. 

  316.   &lt;li&gt;
    317. 

  317.     &lt;%= item %&gt;               # not trimmed
    318. 

  318.   &lt;/li&gt;
    319. 

  319.   &lt;% end %&gt;                   # trimmed
    320. 

  320. &lt;/ul&gt;
    321. 

  321. </pre>
    322. 

  322. <a name="example2_x.result"></a>
    323. 

  323. <div class="terminal_caption">
    324. 

  324. compiled source code</div>
    325. 

  325. <pre class="terminal">$ erubis -x example2.eruby
    326. 

  326. _buf = ''; _buf &lt;&lt; '&lt;ul&gt;
    327. 

  327. ';   for item in list 
    328. 

  328.  _buf &lt;&lt; '  &lt;li&gt;
    329. 

  329.     '; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '
    330. 

  330. '; _buf &lt;&lt; '  &lt;/li&gt;
    331. 

  331. ';   end 
    332. 

  332.  _buf &lt;&lt; '&lt;/ul&gt;
    333. 

  333. ';
    334. 

  334. _buf.to_s
    335. 

  335. </pre>
    336. 

  336. <p>If you want leave spaces around '&lt;% %&gt;', add command-line property '--trim=false'.
    337. 

  337. </p>
    338. 

  338. <a name="example2_trim.result"></a>
    339. 

  339. <div class="terminal_caption">
    340. 

  340. compiled source code with command-line property '--trim=false'</div>
    341. 

  341. <pre class="terminal">$ erubis -x <strong>--trim=false</strong> example2.eruby
    342. 

  342. _buf = ''; _buf &lt;&lt; '&lt;ul&gt;
    343. 

  343. '; _buf &lt;&lt; '  '; for item in list ; _buf &lt;&lt; '
    344. 

  344. '; _buf &lt;&lt; '  &lt;li&gt;
    345. 

  345.     '; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '
    346. 

  346. '; _buf &lt;&lt; '  &lt;/li&gt;
    347. 

  347. '; _buf &lt;&lt; '  '; end ; _buf &lt;&lt; '
    348. 

  348. '; _buf &lt;&lt; '&lt;/ul&gt;
    349. 

  349. ';
    350. 

  350. _buf.to_s
    351. 

  351. </pre>
    352. 

  352. <p>Or add option <code>:trim=&gt;false</code> to Erubis::Eruby.new().
    353. 

  353. </p>
    354. 

  354. <a name="example2.rb"></a>
    355. 

  355. <div class="program_caption">
    356. 

  356. example2.rb</div>
    357. 

  357. <pre class="program">require 'erubis'
    358. 

  358. input = File.read('example2.eruby')
    359. 

  359. eruby = Erubis::Eruby.new(input<strong>, :trim=&gt;false</strong>)
    360. 

  360. 

  361. puts "----- script source ---"
    362. 

  362. puts eruby.src                            # print script source
    363. 

  363. 

  364. puts "----- result ----------"
    365. 

  365. list = ['aaa', 'bbb', 'ccc']
    366. 

  366. puts eruby.result(binding())              # get result
    367. 

  367. </pre>
    368. 

  368. <a name="example2.result"></a>
    369. 

  369. <div class="terminal_caption">
    370. 

  370. output</div>
    371. 

  371. <pre class="terminal">$ ruby example2.rb
    372. 

  372. ----- script source ---
    373. 

  373. _buf = ''; _buf &lt;&lt; '&lt;ul&gt;
    374. 

  374. '; <strong>_buf &lt;&lt; '  ';</strong> for item in list ; _buf &lt;&lt; '
    375. 

  375. '; _buf &lt;&lt; '  &lt;li&gt;
    376. 

  376.     '; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '
    377. 

  377. '; _buf &lt;&lt; '  &lt;/li&gt;
    378. 

  378. '; <strong>_buf &lt;&lt; '  ';</strong> end ; _buf &lt;&lt; '
    379. 

  379. '; _buf &lt;&lt; '&lt;/ul&gt;
    380. 

  380. ';
    381. 

  381. _buf.to_s
    382. 

  382. ----- result ----------
    383. 

  383. &lt;ul&gt;
    384. 

  384.   
    385. 

  385.   &lt;li&gt;
    386. 

  386.     aaa
    387. 

  387.   &lt;/li&gt;
    388. 

  388.   
    389. 

  389.   &lt;li&gt;
    390. 

  390.     bbb
    391. 

  391.   &lt;/li&gt;
    392. 

  392.   
    393. 

  393.   &lt;li&gt;
    394. 

  394.     ccc
    395. 

  395.   &lt;/li&gt;
    396. 

  396.   
    397. 

  397. &lt;/ul&gt;
    398. 

  398. </pre>
    399. 

  399. <br>
    400. 

  400. 

  401. 

  402. <a name="tut-escape"></a>
    403. 

  403. <h3 class="section2">Escape</h3>
    404. 

  404. <p>Erubis has ability to escape (sanitize) expression.
    405. 

  405. Erubis::Eruby class act as the following:
    406. 

  406. </p>
    407. 

  407. <ul type="disc">
    408. 

  408. <li><code>&lt;%= <em>expr</em> %&gt;</code> -  not escaped.
    409. 

  409. </li>
    410. 

  410. <li><code>&lt;%== <em>expr</em> %&gt;</code> - escaped.
    411. 

  411. </li>
    412. 

  412. <li><code>&lt;%=== <em>expr</em> %&gt;</code> - out to $stderr.
    413. 

  413. </li>
    414. 

  414. <li><code>&lt;%==== <em>expr</em> %&gt;</code> - ignored.
    415. 

  415. </li>
    416. 

  416. </ul>
    417. 

  417. <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.
    418. 

  418. It means that using Erubis::EscapedEruby you can escape expression by default.
    419. 

  419. Also Erubis::XmlEruby class (which is equivalent to Erubis::EscapedEruby) is provided for compatibility with Erubis 1.1.
    420. 

  420. </p>
    421. 

  421. <a name="example3.eruby"></a>
    422. 

  422. <div class="program_caption">
    423. 

  423. example3.eruby</div>
    424. 

  424. <pre class="program">&lt;% for item in list %&gt;
    425. 

  425.   &lt;p&gt;<strong>&lt;%=</strong> item <strong>%&gt;</strong>&lt;/p&gt;
    426. 

  426.   &lt;p&gt;<strong>&lt;%==</strong> item <strong>%&gt;</strong>&lt;/p&gt;
    427. 

  427.   &lt;p&gt;<strong>&lt;%===</strong> item <strong>%&gt;</strong>&lt;/p&gt;
    428. 

  428. 

  429. &lt;% end %&gt;
    430. 

  430. </pre>
    431. 

  431. <a name="example3.rb"></a>
    432. 

  432. <div class="program_caption">
    433. 

  433. example3.rb</div>
    434. 

  434. <pre class="program">require 'erubis'
    435. 

  435. input = File.read('example3.eruby')
    436. 

  436. eruby = Erubis::<strong>EscapedEruby</strong>.new(input)    # or Erubis::XmlEruby
    437. 

  437. 

  438. puts "----- script source ---"
    439. 

  439. puts eruby.src                             # print script source
    440. 

  440. 

  441. puts "----- result ----------"
    442. 

  442. <strong>list = ['&lt;aaa&gt;', 'b&amp;b', '"ccc"']</strong>
    443. 

  443. puts eruby.result(binding())               # get result
    444. 

  444. </pre>
    445. 

  445. <a name="example3.result.split_filter"></a>
    446. 

  446. <div class="terminal_caption">
    447. 

  447. output</div>
    448. 

  448. <pre class="terminal">$ ruby example3.rb 2&gt; stderr.log
    449. 

  449. ----- script source ---
    450. 

  450. _buf = ''; for item in list 
    451. 

  451.  _buf &lt;&lt; '  &lt;p&gt;'; <strong>_buf &lt;&lt; Erubis::XmlHelper.escape_xml( item )</strong>; _buf &lt;&lt; '&lt;/p&gt;
    452. 

  452.   &lt;p&gt;'; <strong>_buf &lt;&lt; ( item ).to_s</strong>; _buf &lt;&lt; '&lt;/p&gt;
    453. 

  453.   &lt;p&gt;'; <strong>$stderr.puts("*** debug: item=#{(item).inspect}")</strong>; _buf &lt;&lt; '&lt;/p&gt;
    454. 

  454. 

  455. '; end 
    456. 

  456. _buf.to_s
    457. 

  457. ----- result ----------
    458. 

  458.   &lt;p&gt;<strong>&amp;lt;aaa&amp;gt;</strong>&lt;/p&gt;
    459. 

  459.   &lt;p&gt;&lt;aaa&gt;&lt;/p&gt;
    460. 

  460.   &lt;p&gt;&lt;/p&gt;
    461. 

  461. 

  462.   &lt;p&gt;<strong>b&amp;amp;b</strong>&lt;/p&gt;
    463. 

  463.   &lt;p&gt;b&amp;b&lt;/p&gt;
    464. 

  464.   &lt;p&gt;&lt;/p&gt;
    465. 

  465. 

  466.   &lt;p&gt;<strong>&amp;quot;ccc&amp;quot;</strong>&lt;/p&gt;
    467. 

  467.   &lt;p&gt;"ccc"&lt;/p&gt;
    468. 

  468.   &lt;p&gt;&lt;/p&gt;
    469. 

  469. 

  470. $ cat stderr.log
    471. 

  471. *** debug: item="&lt;aaa&gt;"
    472. 

  472. *** debug: item="b&amp;b"
    473. 

  473. *** debug: item="\"ccc\""
    474. 

  474. </pre>
    475. 

  475. <p>The command-line option '-e' will do the same action as Erubis::EscapedEruby.
    476. 

  476. This option is available for any language.
    477. 

  477. </p>
    478. 

  478. <a name="example3_e.result"></a>
    479. 

  479. <pre class="terminal">$ erubis -l ruby <strong>-e</strong> example3.eruby
    480. 

  480. _buf = ''; for item in list 
    481. 

  481.  _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
    482. 

  482.   &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    483. 

  483.   &lt;p&gt;'; $stderr.puts("*** debug: item=#{(item).inspect}"); _buf &lt;&lt; '&lt;/p&gt;
    484. 

  484. 

  485. '; end 
    486. 

  486. _buf.to_s
    487. 

  487. </pre>
    488. 

  488. <p>Escaping function (default 'Erubis::XmlHelper.escape_xml()') can be changed by command-line property '--escapefunc=xxx' or by overriding Erubis::Eruby#escaped_expr() in subclass.
    489. 

  489. </p>
    490. 

  490. <div class="program_caption">
    491. 

  491. example to override Erubis::Eruby#escaped_expr()</div>
    492. 

  492. <pre class="program">class CGIEruby &lt; Erubis::Eruby
    493. 

  493.   def <strong>escaped_expr(code)</strong>
    494. 

  494.     return "CGI.escapeHTML((#{code.strip}).to_s)"
    495. 

  495.     #return "h(#{code.strip})"
    496. 

  496.   end
    497. 

  497. end
    498. 

  498. 

  499. class LatexEruby &lt; Erubi::Eruby
    500. 

  500.   def <strong>escaped_expr(code)</strong>
    501. 

  501.     return "(#{code}).gsub(/[%\\]/,'\\\\\&amp;')"
    502. 

  502.   end
    503. 

  503. end
    504. 

  504. </pre>
    505. 

  505. <div class="footnote">
    506. 

  506.  <dl compact>
    507. 

  507.   <dt>(<a name="fnref:1" href="#fnlink:1">*1</a>)</dt>
    508. 

  508.   <dd>Erubis::EscapedEruby class includes Erubis::EscapeEnhancer which swtches the action of '&lt;%= %&gt;' and '&lt;%== %&gt;'.</dd>
    509. 

  509.  </dl>
    510. 

  510. </div>
    511. 

  511. <br>
    512. 

  512. 

  513. 

  514. <a name="tut-pattern"></a>
    515. 

  515. <h3 class="section2">Embedded Pattern</h3>
    516. 

  516. <p>You can change embedded pattern '<code>&lt;% %&gt;</code>' to another by command-line option '-p' or option '<code>:pattern=&gt;...</code>' of Erubis::Eruby.new().
    517. 

  517. </p>
    518. 

  518. <a name="example4.eruby"></a>
    519. 

  519. <div class="program_caption">
    520. 

  520. example4.eruby</div>
    521. 

  521. <pre class="program"><strong>&lt;!--%</strong> for item in list <strong>%--&gt;</strong>
    522. 

  522.   &lt;p&gt;<strong>&lt;!--%=</strong> item <strong>%--&gt;</strong>&lt;/p&gt;
    523. 

  523. <strong>&lt;!--%</strong> end <strong>%--&gt;</strong>
    524. 

  524. </pre>
    525. 

  525. <a name="example4_x.result"></a>
    526. 

  526. <div class="terminal_caption">
    527. 

  527. compiled source code with command-line option '-p'</div>
    528. 

  528. <pre class="terminal">$ erubis -x <strong>-p '&lt;!--% %--&gt;'</strong> example4.eruby
    529. 

  529. _buf = ''; for item in list 
    530. 

  530.  _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    531. 

  531. '; end 
    532. 

  532. _buf.to_s
    533. 

  533. </pre>
    534. 

  534. <a name="example4.rb"></a>
    535. 

  535. <div class="program_caption">
    536. 

  536. example4.rb</div>
    537. 

  537. <pre class="program">require 'erubis'
    538. 

  538. input = File.read('example4.eruby')
    539. 

  539. eruby = Erubis::Eruby.new(input<strong>, :pattern=&gt;'&lt;!--% %--&gt;'</strong>)
    540. 

  540.                                       # or '&lt;(?:!--)?% %(?:--)?&gt;'
    541. 

  541. 

  542. puts "---------- script source ---"
    543. 

  543. puts eruby.src                            # print script source
    544. 

  544. 

  545. puts "---------- result ----------"
    546. 

  546. list = ['aaa', 'bbb', 'ccc']
    547. 

  547. puts eruby.result(binding())              # get result
    548. 

  548. </pre>
    549. 

  549. <a name="example4.result"></a>
    550. 

  550. <div class="terminal_caption">
    551. 

  551. output</div>
    552. 

  552. <pre class="terminal">$ ruby example4.rb
    553. 

  553. ---------- script source ---
    554. 

  554. _buf = ''; for item in list 
    555. 

  555.  _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    556. 

  556. '; end 
    557. 

  557. _buf.to_s
    558. 

  558. ---------- result ----------
    559. 

  559.   &lt;p&gt;aaa&lt;/p&gt;
    560. 

  560.   &lt;p&gt;bbb&lt;/p&gt;
    561. 

  561.   &lt;p&gt;ccc&lt;/p&gt;
    562. 

  562. </pre>
    563. 

  563. <p>It is able to specify regular expression with :pattern option.
    564. 

  564. Notice that you must use '<code>(?: )</code>' instead of '<code>( )</code>' for grouping.
    565. 

  565. For example, '<code>&lt;(!--)?% %(--)?&gt;</code>' will not work while '<code>&lt;(?:!--)?% %(?:--)?&gt;</code>' will work.
    566. 

  566. </p>
    567. 

  567. <br>
    568. 

  568. 

  569. 

  570. <a name="tut-context"></a>
    571. 

  571. <h3 class="section2">Context Object</h3>
    572. 

  572. <p>Context object is a set of data which are used in eRuby script.
    573. 

  573. Using context object makes clear which data to be used.
    574. 

  574. In Erubis, Hash object and Erubis::Context object are available as context object.
    575. 

  575. </p>
    576. 

  576. <p>Context data can be accessible via instance variables in eRuby script.
    577. 

  577. </p>
    578. 

  578. <a name="example5.eruby"></a>
    579. 

  579. <div class="program_caption">
    580. 

  580. example5.eruby</div>
    581. 

  581. <pre class="program">&lt;span&gt;&lt;%= <strong>@val</strong> %&gt;&lt;/span&gt;
    582. 

  582. &lt;ul&gt;
    583. 

  583.  &lt;% for item in <strong>@list</strong> %&gt;
    584. 

  584.   &lt;li&gt;&lt;%= item %&gt;&lt;/li&gt;
    585. 

  585.  &lt;% end %&gt;
    586. 

  586. &lt;/ul&gt;
    587. 

  587. </pre>
    588. 

  588. <a name="example5.rb"></a>
    589. 

  589. <div class="program_caption">
    590. 

  590. example5.rb</div>
    591. 

  591. <pre class="program">require 'erubis'
    592. 

  592. input = File.read('example5.eruby')
    593. 

  593. eruby = Erubis::Eruby.new(input)      # create Eruby object
    594. 

  594. 

  595. ## create context object
    596. 

  596. ## (key means var name, which may be string or symbol.)
    597. 

  597. <strong>context = {
    598. 

  598.   :val   =&gt; 'Erubis Example',
    599. 

  599.   'list' =&gt; ['aaa', 'bbb', 'ccc'],
    600. 

  600. }</strong>
    601. 

  601. ## or
    602. 

  602. # context = Erubis::Context.new()
    603. 

  603. # context['val'] = 'Erubis Example'
    604. 

  604. # context[:list] = ['aaa', 'bbb', 'ccc'],
    605. 

  605. 

  606. puts <strong>eruby.evaluate(context)</strong>         # get result
    607. 

  607. </pre>
    608. 

  608. <a name="example5.result"></a>
    609. 

  609. <div class="terminal_caption">
    610. 

  610. output</div>
    611. 

  611. <pre class="terminal">$ ruby example5.rb
    612. 

  612. &lt;span&gt;Erubis Example&lt;/span&gt;
    613. 

  613. &lt;ul&gt;
    614. 

  614.   &lt;li&gt;aaa&lt;/li&gt;
    615. 

  615.   &lt;li&gt;bbb&lt;/li&gt;
    616. 

  616.   &lt;li&gt;ccc&lt;/li&gt;
    617. 

  617. &lt;/ul&gt;
    618. 

  618. </pre>
    619. 

  619. <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'.
    620. 

  620. This means that data is passed into eRuby script via local variables when Eruby::binding() is called, or passed via instance variables when Eruby::evaluate() is called.
    621. 

  621. </p>
    622. 

  622. <p>Here is the definition of Erubis#result() and Erubis#evaluate().
    623. 

  623. </p>
    624. 

  624. <div class="program_caption">
    625. 

  625. definition of result(binding) and evaluate(context)</div>
    626. 

  626. <pre class="program">def result(_binding=TOPLEVEL_BINDING)
    627. 

  627.   if _binding.is_a?(Hash)
    628. 

  628.     # load hash data as local variable
    629. 

  629.     _h = _binding
    630. 

  630.     _binding = binding()
    631. 

  631.     eval _h.collect{|k,v| "#{k} = _h[#{k.inspect}];"}.join, _binding
    632. 

  632.   end
    633. 

  633.   return <strong>eval(@src, _binding)</strong>
    634. 

  634. end
    635. 

  635. 

  636. def evaluate(_context=Erubis::Context.new)
    637. 

  637.   if _context.is_a?(Hash)
    638. 

  638.     # convert hash object to Context object
    639. 

  639.     _hash = _context
    640. 

  640.     _context = Erubis::Context.new
    641. 

  641.     _hash.each {|k, v| _context[k] = v }
    642. 

  642.   end
    643. 

  643.   return <strong>_context.instance_eval(@src)</strong>
    644. 

  644. end
    645. 

  645. </pre>
    646. 

  646. <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.
    647. 

  647. </p>
    648. 

  648. <a name="example6.rb"></a>
    649. 

  649. <div class="program_caption">
    650. 

  650. example6.rb</div>
    651. 

  651. <pre class="program">class MyData
    652. 

  652.   attr_accessor :val, :list
    653. 

  653. end
    654. 

  654. 

  655. ## any object can be a context object
    656. 

  656. <strong>mydata = MyData.new</strong>
    657. 

  657. <strong>mydata.val = 'Erubis Example'</strong>
    658. 

  658. <strong>mydata.list = ['aaa', 'bbb', 'ccc']</strong>
    659. 

  659. 

  660. require 'erubis'
    661. 

  661. eruby = Erubis::Eruby.new(File.read('example5.eruby'))
    662. 

  662. puts eruby.evaluate(<strong>mydata</strong>)
    663. 

  663. </pre>
    664. 

  664. <a name="example6.result"></a>
    665. 

  665. <div class="terminal_caption">
    666. 

  666. output</div>
    667. 

  667. <pre class="terminal">$ ruby example6.rb
    668. 

  668. &lt;span&gt;Erubis Example&lt;/span&gt;
    669. 

  669. &lt;ul&gt;
    670. 

  670.   &lt;li&gt;aaa&lt;/li&gt;
    671. 

  671.   &lt;li&gt;bbb&lt;/li&gt;
    672. 

  672.   &lt;li&gt;ccc&lt;/li&gt;
    673. 

  673. &lt;/ul&gt;
    674. 

  674. </pre>
    675. 

  675. <p>It is recommended to use 'Erubis::Eruby#evaluate(context)' rather than 'Erubis::Eruby#result(binding())' because the latter has some problems.
    676. 

  676. See <a href="#topics-context-vs-binding">evaluate(context) v.s. result(binding)</a> section for details.
    677. 

  677. </p>
    678. 

  678. <br>
    679. 

  679. 

  680. 

  681. <a name="tut-datafile"></a>
    682. 

  682. <h3 class="section2">Context Data File</h3>
    683. 

  683. <p>Command-line option '-f' specifies context data file.
    684. 

  684. Erubis load context data file and use it as context data.
    685. 

  685. Context data file can be YAML file ('*.yaml' or '*.yml') or Ruby script ('*.rb').
    686. 

  686. </p>
    687. 

  687. <a name="example7.eruby"></a>
    688. 

  688. <div class="program_caption">
    689. 

  689. example7.eruby</div>
    690. 

  690. <pre class="program">&lt;h1&gt;&lt;%= <strong>@title</strong> %&gt;&lt;/h1&gt;
    691. 

  691. &lt;ul&gt;
    692. 

  692.  &lt;% for user in <strong>@users</strong> %&gt;
    693. 

  693.   &lt;li&gt;
    694. 

  694.     &lt;a href="mailto:&lt;%= user['mail']%&gt;"&gt;&lt;%= user['name'] %&gt;&lt;/a&gt;
    695. 

  695.   &lt;/li&gt;
    696. 

  696.  &lt;% end %&gt;
    697. 

  697. &lt;/ul&gt;
    698. 

  698. </pre>
    699. 

  699. <a name="context.yaml"></a>
    700. 

  700. <div class="program_caption">
    701. 

  701. context.yaml</div>
    702. 

  702. <pre class="program"><strong>title:</strong> Users List
    703. 

  703. <strong>users:</strong>
    704. 

  704.   - name:  foo
    705. 

  705.     mail:  foo@mail.com
    706. 

  706.   - name:  bar
    707. 

  707.     mail:  bar@mail.net
    708. 

  708.   - name:  baz
    709. 

  709.     mail:  baz@mail.org
    710. 

  710. </pre>
    711. 

  711. <a name="context.rb"></a>
    712. 

  712. <div class="program_caption">
    713. 

  713. context.rb</div>
    714. 

  714. <pre class="program">@title = 'Users List'
    715. 

  715. @users = [
    716. 

  716.    { 'name'=&gt;'foo', 'mail'=&gt;'foo@mail.com' },
    717. 

  717.    { 'name'=&gt;'bar', 'mail'=&gt;'bar@mail.net' },
    718. 

  718.    { 'name'=&gt;'baz', 'mail'=&gt;'baz@mail.org' },
    719. 

  719. ]
    720. 

  720. </pre>
    721. 

  721. <a name="example7.result.split_filter"></a>
    722. 

  722. <div class="terminal_caption">
    723. 

  723. example of command-line option '-f'</div>
    724. 

  724. <pre class="terminal">$ erubis <strong>-f context.yaml</strong> example7.eruby
    725. 

  725. &lt;h1&gt;Users List&lt;/h1&gt;
    726. 

  726. &lt;ul&gt;
    727. 

  727.   &lt;li&gt;
    728. 

  728.     &lt;a href="mailto:foo@mail.com"&gt;foo&lt;/a&gt;
    729. 

  729.   &lt;/li&gt;
    730. 

  730.   &lt;li&gt;
    731. 

  731.     &lt;a href="mailto:bar@mail.net"&gt;bar&lt;/a&gt;
    732. 

  732.   &lt;/li&gt;
    733. 

  733.   &lt;li&gt;
    734. 

  734.     &lt;a href="mailto:baz@mail.org"&gt;baz&lt;/a&gt;
    735. 

  735.   &lt;/li&gt;
    736. 

  736. &lt;/ul&gt;
    737. 

  737. $ erubis <strong>-f context.rb</strong> example7.eruby
    738. 

  738. &lt;h1&gt;Users List&lt;/h1&gt;
    739. 

  739. &lt;ul&gt;
    740. 

  740.   &lt;li&gt;
    741. 

  741.     &lt;a href="mailto:foo@mail.com"&gt;foo&lt;/a&gt;
    742. 

  742.   &lt;/li&gt;
    743. 

  743.   &lt;li&gt;
    744. 

  744.     &lt;a href="mailto:bar@mail.net"&gt;bar&lt;/a&gt;
    745. 

  745.   &lt;/li&gt;
    746. 

  746.   &lt;li&gt;
    747. 

  747.     &lt;a href="mailto:baz@mail.org"&gt;baz&lt;/a&gt;
    748. 

  748.   &lt;/li&gt;
    749. 

  749. &lt;/ul&gt;
    750. 

  750. </pre>
    751. 

  751. <p>Command-line option '-S' converts keys of mapping in YAML data file from string into symbol.
    752. 

  752. Command-line option '-B' invokes 'Erubis::Eruby#result(binding())' instead of 'Erubis::Eruby#evaluate(context)'.
    753. 

  753. </p>
    754. 

  754. <br>
    755. 

  755. 

  756. 

  757. <a name="tut-datastr"></a>
    758. 

  758. <h3 class="section2">Context Data String</h3>
    759. 

  759. <p>Command-line option '-c <em>str</em>' enables you to specify context data in command-line.
    760. 

  760. <em>str</em> can be YAML flow-style or Ruby code.
    761. 

  761. </p>
    762. 

  762. <a name="example8.eruby"></a>
    763. 

  763. <div class="program_caption">
    764. 

  764. example8.eruby</div>
    765. 

  765. <pre class="program">&lt;h1&gt;&lt;%= @title %&gt;&lt;/h1&gt;
    766. 

  766. &lt;ul&gt;
    767. 

  767. &lt;% for item in @list %&gt;
    768. 

  768.  &lt;li&gt;&lt;%= item %&gt;&lt;/li&gt;
    769. 

  769. &lt;% end %&gt;
    770. 

  770. &lt;/ul&gt;
    771. 

  771. </pre>
    772. 

  772. <a name="example8_yaml.result"></a>
    773. 

  773. <div class="terminal_caption">
    774. 

  774. example of YAML flow style</div>
    775. 

  775. <pre class="terminal">$ erubis <strong>-c '{title: Example, list: [AAA, BBB, CCC]}'</strong> example8.eruby
    776. 

  776. &lt;h1&gt;Example&lt;/h1&gt;
    777. 

  777. &lt;ul&gt;
    778. 

  778.  &lt;li&gt;AAA&lt;/li&gt;
    779. 

  779.  &lt;li&gt;BBB&lt;/li&gt;
    780. 

  780.  &lt;li&gt;CCC&lt;/li&gt;
    781. 

  781. &lt;/ul&gt;
    782. 

  782. </pre>
    783. 

  783. <a name="example8_ruby.result"></a>
    784. 

  784. <div class="terminal_caption">
    785. 

  785. example of Ruby code</div>
    786. 

  786. <pre class="terminal">$ erubis <strong>-c '@title="Example"; @list=%w[AAA BBB CCC]'</strong> example8.eruby
    787. 

  787. &lt;h1&gt;Example&lt;/h1&gt;
    788. 

  788. &lt;ul&gt;
    789. 

  789.  &lt;li&gt;AAA&lt;/li&gt;
    790. 

  790.  &lt;li&gt;BBB&lt;/li&gt;
    791. 

  791.  &lt;li&gt;CCC&lt;/li&gt;
    792. 

  792. &lt;/ul&gt;
    793. 

  793. </pre>
    794. 

  794. <br>
    795. 

  795. 

  796. 

  797. <a name="tut-preamble"></a>
    798. 

  798. <h3 class="section2">Preamble and Postamble</h3>
    799. 

  799. <p>The first line ('_buf = '';') in the compiled source code is called preamble
    800. 

  800. and the last line ('_buf.to_s') is called postamble.
    801. 

  801. </p>
    802. 

  802. <p>Command-line option '-b' skips the output of preamble and postamble.
    803. 

  803. </p>
    804. 

  804. <a name="example9.eruby"></a>
    805. 

  805. <div class="program_caption">
    806. 

  806. example9.eruby</div>
    807. 

  807. <pre class="program">&lt;% for item in @list %&gt;
    808. 

  808.  &lt;b&gt;&lt;%= item %&gt;&lt;/b&gt;
    809. 

  809. &lt;% end %&gt;
    810. 

  810. </pre>
    811. 

  811. <a name="example9.result.split_filter"></a>
    812. 

  812. <div class="terminal_caption">
    813. 

  813. compiled source code with and without command-line option '-b'</div>
    814. 

  814. <pre class="terminal">$ erubis -x example9.eruby
    815. 

  815. <strong>_buf = '';</strong> for item in @list 
    816. 

  816.  _buf &lt;&lt; ' &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
    817. 

  817. '; end 
    818. 

  818. <strong>_buf.to_s</strong>
    819. 

  819. $ erubis -x <strong>-b</strong> example9.eruby
    820. 

  820.  for item in @list 
    821. 

  821.  _buf &lt;&lt; ' &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
    822. 

  822. '; end 
    823. 

  823. </pre>
    824. 

  824. <p>Erubis::Eruby.new option '<code>:preamble=&gt;false</code>' and '<code>:postamble=&gt;false</code>' also suppress output of preamble or postamle.
    825. 

  825. </p>
    826. 

  826. <a name="example9.rb"></a>
    827. 

  827. <div class="program_caption">
    828. 

  828. example9.rb</div>
    829. 

  829. <pre class="program">require 'erubis'
    830. 

  830. input = File.read('example9.eruby')
    831. 

  831. eruby1 = Erubis::Eruby.new(input)
    832. 

  832. eruby2 = Erubis::Eruby.new(input, <strong>:preamble=&gt;false, :postamble=&gt;false</strong>)
    833. 

  833. 

  834. puts eruby1.src   # print preamble and postamble
    835. 

  835. puts "--------------"
    836. 

  836. puts eruby2.src   # don't print preamble and postamble
    837. 

  837. </pre>
    838. 

  838. <a name="example9.result"></a>
    839. 

  839. <div class="terminal_caption">
    840. 

  840. output</div>
    841. 

  841. <pre class="terminal">$ ruby example9.rb
    842. 

  842. _buf = ''; for item in @list 
    843. 

  843.  _buf &lt;&lt; ' &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
    844. 

  844. '; end 
    845. 

  845. _buf.to_s
    846. 

  846. --------------
    847. 

  847.  for item in @list 
    848. 

  848.  _buf &lt;&lt; ' &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
    849. 

  849. '; end 
    850. 

  850. </pre>
    851. 

  851. <br>
    852. 

  852. 

  853. 

  854. <a name="tut-pi"></a>
    855. 

  855. <h3 class="section2">Processing Instruction (PI) Converter</h3>
    856. 

  856. <p>Erubis can parse Processing Instructions (PI) as embedded pattern.
    857. 

  857. </p>
    858. 

  858. <ul type="disc">
    859. 

  859. <li>'<code>&lt;?rb <em>...</em> ?&gt;</code>' represents Ruby statement.
    860. 

  860. </li>
    861. 

  861. <li>'<code>@{<em>...</em>}@</code>' represents escaped expression value.
    862. 

  862. </li>
    863. 

  863. <li>'<code>@!{<em>...</em>}@</code>' represents normal expression value.
    864. 

  864. </li>
    865. 

  865. <li>'<code>@!!{<em>...</em>}@</code>' prints expression value to standard output.
    866. 

  866. </li>
    867. 

  867. <li>(experimental) '<code>&lt;%= <em>...</em> %&gt;</code>' is also available to print expression value.
    868. 

  868. </li>
    869. 

  869. </ul>
    870. 

  870. <p>This is more useful than basic embedded pattern ('<code>&lt;% ... &gt;</code>') because PI doesn't break XML or HTML at all.
    871. 

  871. For example the following XHTML file is well-formed and HTML validator got no errors on this example.
    872. 

  872. </p>
    873. 

  873. <a name="example10.xhtml"></a>
    874. 

  874. <div class="program_caption">
    875. 

  875. example10.xhtml</div>
    876. 

  876. <pre class="program">&lt;?xml version="1.0" ?&gt;
    877. 

  877. <strong>&lt;?rb
    878. 

  878.   lang = 'en'
    879. 

  879.   list = ['&lt;aaa&gt;', 'b&amp;b', '"ccc"']
    880. 

  880. ?&gt;</strong>
    881. 

  881. &lt;html lang="<strong>@!{lang}@</strong>"&gt;
    882. 

  882.  &lt;body&gt;
    883. 

  883.   &lt;ul&gt;
    884. 

  884.   <strong>&lt;?rb for item in list ?&gt;</strong>
    885. 

  885.    &lt;li&gt;<strong>@{item}@</strong>&lt;/li&gt;
    886. 

  886.   <strong>&lt;?rb end ?&gt;</strong>
    887. 

  887.   &lt;/ul&gt;
    888. 

  888.  &lt;/body&gt;
    889. 

  889. &lt;/html&gt;
    890. 

  890. </pre>
    891. 

  891. <p>If the command-line property '--pi=<em>name</em>' is specified, erubis command parses input with PI converter.
    892. 

  892. If <em>name</em> is omitted then the following name is used according to '-l <em>lang</em>'.
    893. 

  893. </p>
    894. 

  894. <div align="center">
    895. 

  895. <table class="table1" border="1" cellspacing="0">
    896. 

  896.  <tr class="tr1">
    897. 

  897.   <th class="th1">'-l' option</th>
    898. 

  898.   <th class="th1">PI name</th>
    899. 

  899.  </tr>
    900. 

  900.  <tr class="tr1">
    901. 

  901.   <td class="td1">-l ruby</td>
    902. 

  902.   <td class="td1">&lt;?rb ... ?&gt;</td>
    903. 

  903.  </tr>
    904. 

  904.  <tr class="tr1">
    905. 

  905.   <td class="td1">-l php</td>
    906. 

  906.   <td class="td1">&lt;?php ... ?&gt;</td>
    907. 

  907.  </tr>
    908. 

  908.  <tr class="tr1">
    909. 

  909.   <td class="td1">-l perl</td>
    910. 

  910.   <td class="td1">&lt;?perl ... ?&gt;</td>
    911. 

  911.  </tr>
    912. 

  912.  <tr class="tr1">
    913. 

  913.   <td class="td1">-l java</td>
    914. 

  914.   <td class="td1">&lt;?java ... ?&gt;</td>
    915. 

  915.  </tr>
    916. 

  916.  <tr class="tr1">
    917. 

  917.   <td class="td1">-l javascript</td>
    918. 

  918.   <td class="td1">&lt;?js ... ?&gt;</td>
    919. 

  919.  </tr>
    920. 

  920.  <tr class="tr1">
    921. 

  921.   <td class="td1">-l scheme</td>
    922. 

  922.   <td class="td1">&lt;?scheme ... ?&gt;</td>
    923. 

  923.  </tr>
    924. 

  924. </table>
    925. 

  925. </div>
    926. 

  926. <a name="example10_x.result"></a>
    927. 

  927. <div class="terminal_caption">
    928. 

  928. output</div>
    929. 

  929. <pre class="terminal">$ erubis -x <strong>--pi</strong> example10.xhtml
    930. 

  930. _buf = ''; _buf &lt;&lt; '&lt;?xml version="1.0" ?&gt;
    931. 

  931. ';
    932. 

  932.   lang = 'en'
    933. 

  933.   list = ['&lt;aaa&gt;', 'b&amp;b', '"ccc"']
    934. 

  934. 

  935.  _buf &lt;&lt; '&lt;html lang="'; _buf &lt;&lt; (lang).to_s; _buf &lt;&lt; '"&gt;
    936. 

  936.  &lt;body&gt;
    937. 

  937.   &lt;ul&gt;
    938. 

  938. ';   for item in list 
    939. 

  939.  _buf &lt;&lt; '   &lt;li&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml(item); _buf &lt;&lt; '&lt;/li&gt;
    940. 

  940. ';   end 
    941. 

  941.  _buf &lt;&lt; '  &lt;/ul&gt;
    942. 

  942.  &lt;/body&gt;
    943. 

  943. &lt;/html&gt;
    944. 

  944. ';
    945. 

  945. _buf.to_s
    946. 

  946. </pre>
    947. 

  947. <p>Expression character can be changeable by command-line property '--embchar=<em>char</em>. Default is '<code>@</code>'.
    948. 

  948. </p>
    949. 

  949. <p>Use Erubis::PI::Eruby instead of Erubis::Eruby if you want to use PI as embedded pattern.
    950. 

  950. </p>
    951. 

  951. <a name="example10.rb"></a>
    952. 

  952. <div class="program_caption">
    953. 

  953. example10.rb</div>
    954. 

  954. <pre class="program">require 'erubis'
    955. 

  955. input = File.read('example10.xhtml')
    956. 

  956. eruby = Erubis::PI::Eruby.new(input)
    957. 

  957. print eruby.src
    958. 

  958. </pre>
    959. 

  959. <a name="example10.result"></a>
    960. 

  960. <div class="terminal_caption">
    961. 

  961. output</div>
    962. 

  962. <pre class="terminal">$ ruby example10.rb
    963. 

  963. _buf = ''; _buf &lt;&lt; '&lt;?xml version="1.0" ?&gt;
    964. 

  964. ';
    965. 

  965.   lang = 'en'
    966. 

  966.   list = ['&lt;aaa&gt;', 'b&amp;b', '"ccc"']
    967. 

  967. 

  968.  _buf &lt;&lt; '&lt;html lang="'; _buf &lt;&lt; (lang).to_s; _buf &lt;&lt; '"&gt;
    969. 

  969.  &lt;body&gt;
    970. 

  970.   &lt;ul&gt;
    971. 

  971. ';   for item in list 
    972. 

  972.  _buf &lt;&lt; '   &lt;li&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml(item); _buf &lt;&lt; '&lt;/li&gt;
    973. 

  973. ';   end 
    974. 

  974.  _buf &lt;&lt; '  &lt;/ul&gt;
    975. 

  975.  &lt;/body&gt;
    976. 

  976. &lt;/html&gt;
    977. 

  977. ';
    978. 

  978. _buf.to_s
    979. 

  979. </pre>
    980. 

  980. <p><strong>(experimental)</strong> Erubis supports '&lt;%= ... %&gt;' pattern with PI pattern.
    981. 

  981. </p>
    982. 

  982. <div class="program_caption">
    983. 

  983. example of Rails view template</div>
    984. 

  984. <pre class="program">&lt;table&gt;
    985. 

  985.   &lt;tr&gt;
    986. 

  986. &lt;?rb for item in @list ?&gt;
    987. 

  987.     &lt;td&gt;@{item.id}@&lt;/td&gt;
    988. 

  988.     &lt;td&gt;@{item.name}@&lt;/td&gt;
    989. 

  989.     &lt;td&gt;
    990. 

  990.        <strong>&lt;%=</strong> link_to 'Destroy', {:action=&gt;'destroy', :id=&gt;item.id},
    991. 

  991.                        :confirm=&gt;'Are you OK?' <strong>%&gt;</strong>
    992. 

  992.     &lt;/td&gt;
    993. 

  993. &lt;?rb end ?&gt;
    994. 

  994.   &lt;/tr&gt;
    995. 

  995. &lt;/table&gt;
    996. 

  996. </pre>
    997. 

  997. <br>
    998. 

  998. 

  999. 

  1000. <a name="tut-notext"></a>
    1001. 

  1001. <h3 class="section2">Retrieve Ruby Code</h3>
    1002. 

  1002. <p>Similar to '-x', ommand-line option '-X' shows converted Ruby source code.
    1003. 

  1003. The difference between '-x' and 'X' is that the former converts text part but the latter ignores it.
    1004. 

  1004. It means that you can retrieve Ruby code from eRuby script by '-X' option.
    1005. 

  1005. </p>
    1006. 

  1006. <p>For example, see the following eRuby script.
    1007. 

  1007. This is some complex, so it is difficult to grasp the program code.
    1008. 

  1008. </p>
    1009. 

  1009. <a name="example11.rhtml"></a>
    1010. 

  1010. <div class="program_caption">
    1011. 

  1011. example11.rhtml</div>
    1012. 

  1012. <pre class="program">&lt;?xml version="1.0" encoding="UTF-8"?&gt;
    1013. 

  1013. &lt;!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    1014. 

  1014.           "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"&gt;
    1015. 

  1015. &lt;html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"&gt;
    1016. 

  1016.   &lt;body&gt;
    1017. 

  1017.     &lt;h3&gt;List&lt;/h3&gt;
    1018. 

  1018.     &lt;% if @list.nil? || @list.empty? %&gt;
    1019. 

  1019.     &lt;p&gt;not found.&lt;/p&gt;
    1020. 

  1020.     &lt;% else %&gt;
    1021. 

  1021.     &lt;table&gt;
    1022. 

  1022.       &lt;tbody&gt;
    1023. 

  1023.         &lt;% @list.each_with_index do |item, i| %&gt;
    1024. 

  1024.         &lt;tr bgcolor="&lt;%= i % 2 == 0 ? '#FCC' : '#CCF' %&gt;"&gt;
    1025. 

  1025.           &lt;td&gt;&lt;%= item %&gt;&lt;/td&gt;
    1026. 

  1026.         &lt;/tr&gt;
    1027. 

  1027.         &lt;% end %&gt;
    1028. 

  1028.       &lt;/tbody&gt;
    1029. 

  1029.     &lt;/table&gt;
    1030. 

  1030.     &lt;% end %&gt;
    1031. 

  1031.   &lt;/body&gt;
    1032. 

  1032. &lt;/html&gt;
    1033. 

  1033. </pre>
    1034. 

  1034. <p>Command-line option '-X' extracts only the ruby code from eRuby script.
    1035. 

  1035. </p>
    1036. 

  1036. <a name="example11.result"></a>
    1037. 

  1037. <div class="terminal_caption">
    1038. 

  1038. result</div>
    1039. 

  1039. <pre class="terminal">$ erubis <strong>-X</strong> example11.rhtml
    1040. 

  1040. _buf = '';
    1041. 

  1041. 

  1042. 

  1043. 

  1044. 

  1045. 

  1046.      if @list.nil? || @list.empty? 
    1047. 

  1047. 

  1048.      else 
    1049. 

  1049. 

  1050. 

  1051.          @list.each_with_index do |item, i| 
    1052. 

  1052.                       _buf &lt;&lt; ( i % 2 == 0 ? '#FCC' : '#CCF' ).to_s;
    1053. 

  1053.                _buf &lt;&lt; ( item ).to_s;
    1054. 

  1054. 

  1055.          end 
    1056. 

  1056. 

  1057. 

  1058.      end 
    1059. 

  1059. 

  1060. 

  1061. _buf.to_s
    1062. 

  1062. </pre>
    1063. 

  1063. <p>Command-line option '-C' (<strong>c</strong>mpact) deletes empty lines.
    1064. 

  1064. </p>
    1065. 

  1065. <a name="example11_C.result"></a>
    1066. 

  1066. <div class="terminal_caption">
    1067. 

  1067. result</div>
    1068. 

  1068. <pre class="terminal">$ erubis <strong>-XC</strong> example11.rhtml
    1069. 

  1069. _buf = '';
    1070. 

  1070.      if @list.nil? || @list.empty? 
    1071. 

  1071.      else 
    1072. 

  1072.          @list.each_with_index do |item, i| 
    1073. 

  1073.                       _buf &lt;&lt; ( i % 2 == 0 ? '#FCC' : '#CCF' ).to_s;
    1074. 

  1074.                _buf &lt;&lt; ( item ).to_s;
    1075. 

  1075.          end 
    1076. 

  1076.      end 
    1077. 

  1077. _buf.to_s
    1078. 

  1078. </pre>
    1079. 

  1079. <p>Option '-U' (<strong>u</strong>nique) converts empty lines into a line.
    1080. 

  1080. </p>
    1081. 

  1081. <a name="example11_U.result"></a>
    1082. 

  1082. <div class="terminal_caption">
    1083. 

  1083. result</div>
    1084. 

  1084. <pre class="terminal">$ erubis <strong>-XU</strong> example11.rhtml
    1085. 

  1085. _buf = '';
    1086. 

  1086. 

  1087.      if @list.nil? || @list.empty? 
    1088. 

  1088. 

  1089.      else 
    1090. 

  1090. 

  1091.          @list.each_with_index do |item, i| 
    1092. 

  1092.                       _buf &lt;&lt; ( i % 2 == 0 ? '#FCC' : '#CCF' ).to_s;
    1093. 

  1093.                _buf &lt;&lt; ( item ).to_s;
    1094. 

  1094. 

  1095.          end 
    1096. 

  1096. 

  1097.      end 
    1098. 

  1098. 

  1099. _buf.to_s
    1100. 

  1100. </pre>
    1101. 

  1101. <p>Option '-N' (<strong>n</strong>umber) adds line number.
    1102. 

  1102. It is available with '-C' or '-U'.
    1103. 

  1103. </p>
    1104. 

  1104. <a name="example11_N.result"></a>
    1105. 

  1105. <div class="terminal_caption">
    1106. 

  1106. result</div>
    1107. 

  1107. <pre class="terminal">$ erubis <strong>-XNU</strong> example11.rhtml
    1108. 

  1108.     1:  _buf = '';
    1109. 

  1109. 

  1110.     7:       if @list.nil? || @list.empty? 
    1111. 

  1111. 

  1112.     9:       else 
    1113. 

  1113. 

  1114.    12:           @list.each_with_index do |item, i| 
    1115. 

  1115.    13:                        _buf &lt;&lt; ( i % 2 == 0 ? '#FCC' : '#CCF' ).to_s;
    1116. 

  1116.    14:                 _buf &lt;&lt; ( item ).to_s;
    1117. 

  1117. 

  1118.    16:           end 
    1119. 

  1119. 

  1120.    19:       end 
    1121. 

  1121. 

  1122.    22:  _buf.to_s
    1123. 

  1123. </pre>
    1124. 

  1124. <p>Command-line option '-X' is available with PHP script.
    1125. 

  1125. </p>
    1126. 

  1126. <a name="example11.php"></a>
    1127. 

  1127. <div class="program_caption">
    1128. 

  1128. example11.php</div>
    1129. 

  1129. <pre class="program">&lt;?xml version="1.0"?&gt;
    1130. 

  1130. &lt;html&gt;
    1131. 

  1131.   &lt;body&gt;
    1132. 

  1132.     &lt;h3&gt;List&lt;/h3&gt;
    1133. 

  1133.     &lt;?php if (!$list) { ?&gt;
    1134. 

  1134.     &lt;p&gt;not found.&lt;/p&gt;
    1135. 

  1135.     &lt;?php } else { ?&gt;
    1136. 

  1136.     &lt;table&gt;
    1137. 

  1137.       &lt;tbody&gt;
    1138. 

  1138.         &lt;?php $i = 0; ?&gt;
    1139. 

  1139.         &lt;?php foreach ($list as $item) { ?&gt;
    1140. 

  1140.         &lt;tr bgcolor="&lt;?php echo ++$i % 2 == 1 ? '#FCC' : '#CCF'; ?&gt;"&gt;
    1141. 

  1141.           &lt;td&gt;&lt;?php echo $item; ?&gt;&lt;/td&gt;
    1142. 

  1142.         &lt;/tr&gt;
    1143. 

  1143.         &lt;?php } ?&gt;
    1144. 

  1144.       &lt;/tbody&gt;
    1145. 

  1145.     &lt;/table&gt;
    1146. 

  1146.     &lt;?php } ?&gt;
    1147. 

  1147.   &lt;/body&gt;
    1148. 

  1148. &lt;/html&gt;
    1149. 

  1149. </pre>
    1150. 

  1150. <a name="example11_php.result"></a>
    1151. 

  1151. <div class="terminal_caption">
    1152. 

  1152. result</div>
    1153. 

  1153. <pre class="terminal">$ erubis -XNU <strong>-l php</strong> <strong>--pi=php</strong> --trim=false example11.php
    1154. 

  1154. 

  1155.     5:      &lt;?php if (!$list) { ?&gt;
    1156. 

  1156. 

  1157.     7:      &lt;?php } else { ?&gt;
    1158. 

  1158. 

  1159.    10:          &lt;?php $i = 0; ?&gt;
    1160. 

  1160.    11:          &lt;?php foreach ($list as $item) { ?&gt;
    1161. 

  1161.    12:                       &lt;?php echo ++$i % 2 == 1 ? '#FCC' : '#CCF'; ?&gt;
    1162. 

  1162.    13:                &lt;?php echo $item; ?&gt;
    1163. 

  1163. 

  1164.    15:          &lt;?php } ?&gt;
    1165. 

  1165. 

  1166.    18:      &lt;?php } ?&gt;
    1167. 

  1167. 

  1168. </pre>
    1169. 

  1169. <br>
    1170. 

  1170. 

  1171. 

  1172. <br>
    1173. 

  1173. 

  1174. 

  1175. <a name="enhancer"></a>
    1176. 

  1176. <h2 class="section1">Enhancer</h2>
    1177. 

  1177. <p>Enhancer is a module to add a certain feature into Erubis::Eruby class.
    1178. 

  1178. Enhancer may be language-independent or only for Erubis::Eruby class.
    1179. 

  1179. </p>
    1180. 

  1180. <p>To use enhancers, define subclass and include them.
    1181. 

  1181. 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>.
    1182. 

  1182. </p>
    1183. 

  1183. <pre class="program">class MyEruby &lt; Erubis::Eruby
    1184. 

  1184.   include EscapeEnhancer
    1185. 

  1185.   include PercentLineEnhancer
    1186. 

  1186.   include BiPatternEnhancer
    1187. 

  1187. end
    1188. 

  1188. </pre>
    1189. 

  1189. <p>You can specify enhancers in command-line with option '-E'.
    1190. 

  1190. The following is an example to use some enhancers in command-line.
    1191. 

  1191. </p>
    1192. 

  1192. <pre class="terminal">$ erubis -xE Escape,PercentLine,BiPattern example.eruby
    1193. 

  1193. </pre>
    1194. 

  1194. <p>The following is the list of enhancers.
    1195. 

  1195. </p>
    1196. 

  1196. <dl class="dl1">
    1197. 

  1197. <dt class="dt1">
    1198. 

  1198. <a href="#escape-enhancer">EscapeEnhander</a> (language-independent)</dt>
    1199. 

  1199. <dd class="dd1">
    1200. 

  1200. 	Switch '&lt;%= %&gt;' to escaped and '&lt;%== %&gt;' to unescaped.
    1201. 

  1201. </dd>
    1202. 

  1202. <dt class="dt1">
    1203. 

  1203. <a href="#stdout-enhancer">StdoutEnhancer</a> (only for Eruby)</dt>
    1204. 

  1204. <dd class="dd1">
    1205. 

  1205. 	Use $stdout instead of array buffer.
    1206. 

  1206. </dd>
    1207. 

  1207. <dt class="dt1">
    1208. 

  1208. <a href="#printout-enhancer">PrintOutEnhancer</a> (only for Eruby)</dt>
    1209. 

  1209. <dd class="dd1">
    1210. 

  1210. 	Use "print(...)" statement insead of "_buf &lt;&lt; ...".
    1211. 

  1211. </dd>
    1212. 

  1212. <dt class="dt1">
    1213. 

  1213. <a href="#printenabled-enhancer">PrintEnabledEnhancer</a> (only for Eruby)</dt>
    1214. 

  1214. <dd class="dd1">
    1215. 

  1215. 	Enable to use print() in '&lt;% ... %&gt;'.
    1216. 

  1216. </dd>
    1217. 

  1217. <dt class="dt1">
    1218. 

  1218. <a href="#array-enhancer">ArrayEnhancer</a> (only for Eruby)</dt>
    1219. 

  1219. <dd class="dd1">
    1220. 

  1220. 	Return array of string instead of returning string.
    1221. 

  1221. </dd>
    1222. 

  1222. <dt class="dt1">
    1223. 

  1223. <a href="#arraybuffer-enhancer">ArrayBufferEnhancer</a> (only for Eruby)</dt>
    1224. 

  1224. <dd class="dd1">
    1225. 

  1225. 	Use array buffer. It is a little slower than StringBufferEnhancer.
    1226. 

  1226. </dd>
    1227. 

  1227. <dt class="dt1">
    1228. 

  1228. <a href="#stringbuffer-enhancer">StringBufferEnhancer</a> (only for Eruby)</dt>
    1229. 

  1229. <dd class="dd1">
    1230. 

  1230. 	Use string buffer. This is included in Erubis::Eruby by default.
    1231. 

  1231. </dd>
    1232. 

  1232. <dt class="dt1">
    1233. 

  1233. <a href="#erbout-enhancer">ErboutEnhancer</a> (only for Eruby)</dt>
    1234. 

  1234. <dd class="dd1">
    1235. 

  1235. 	Set '_erbout = _buf = "";' to be compatible with ERB.
    1236. 

  1236. </dd>
    1237. 

  1237. <dt class="dt1">
    1238. 

  1238. <a href="#notext-enhancer">NoTextEnhancer</a> (language-independent)</dt>
    1239. 

  1239. <dd class="dd1">
    1240. 

  1240. 	Print embedded code only and ignore normal text.
    1241. 

  1241. </dd>
    1242. 

  1242. <dt class="dt1">
    1243. 

  1243. <a href="#nocode-enhancer">NoCodeEnhancer</a> (language-independent)</dt>
    1244. 

  1244. <dd class="dd1">
    1245. 

  1245. 	Print normal text only and ignore code.
    1246. 

  1246. </dd>
    1247. 

  1247. <dt class="dt1">
    1248. 

  1248. <a href="#simplify-enhancer">SimplifyEnhancer</a> (language-independent)</dt>
    1249. 

  1249. <dd class="dd1">
    1250. 

  1250. 	Make compile faster but don't trim spaces around '&lt;% %&gt;'.
    1251. 

  1251. </dd>
    1252. 

  1252. <dt class="dt1">
    1253. 

  1253. <a href="#bipattern-enhancer">BiPatternEnhancer</a> (language-independent)</dt>
    1254. 

  1254. <dd class="dd1">
    1255. 

  1255. 	[experimental] Enable to use another embedded pattern with '&lt;% %&gt;'.
    1256. 

  1256. </dd>
    1257. 

  1257. <dt class="dt1">
    1258. 

  1258. <a href="#percentline-enhancer">PercentLineEnhancer</a> (language-independent)</dt>
    1259. 

  1259. <dd class="dd1">
    1260. 

  1260. 	Regard lines starting with '%' as Ruby code. This is for compatibility with eruby and ERB.
    1261. 

  1261. </dd>
    1262. 

  1262. <dt class="dt1">
    1263. 

  1263. <a href="#headerfooter-enhancer">HeaderFooterEnhancer</a> (language-independent)</dt>
    1264. 

  1264. <dd class="dd1">
    1265. 

  1265. 	[experimental] Enable you to add header and footer in eRuby script.
    1266. 

  1266. </dd>
    1267. 

  1267. <dt class="dt1">
    1268. 

  1268. <a href="#interpolation-enhancer">InterpolationEnhancer</a> (only for Eruby)</dt>
    1269. 

  1269. <dd class="dd1">
    1270. 

  1270. 	[experimental] convert '&lt;p&gt;&lt;%= text %&gt;&lt;/p&gt;' into '_buf &lt;&lt; %Q`&lt;p&gt;#{text}&lt;/p&gt;`'.
    1271. 

  1271. </dd>
    1272. 

  1272. <dt class="dt1">
    1273. 

  1273. <a href="#deleteindent-enhancer">DeleteIndentEnhancer</a> (language-independent)</dt>
    1274. 

  1274. <dd class="dd1">
    1275. 

  1275. 	[experimental] delete indentation of HTML file and eliminate page size.
    1276. 

  1276. </dd>
    1277. 

  1277. </dl>
    1278. 

  1278. <p>If you required 'erubis/engine/enhanced', Eruby subclasses which include each enhancers are defined.
    1279. 

  1279. For example, class BiPatternEruby includes BiPatternEnhancer.
    1280. 

  1280. </p>
    1281. 

  1281. <a name="escape-enhancer"></a>
    1282. 

  1282. <h3 class="section2">EscapeEnhancer</h3>
    1283. 

  1283. <p>EscapeEnhancer switches '&lt;%= ... %&gt;' to escaped and '&lt;%== ... %&gt;' to unescaped.
    1284. 

  1284. </p>
    1285. 

  1285. <a name="example.eruby"></a>
    1286. 

  1286. <div class="program_caption">
    1287. 

  1287. example.eruby</div>
    1288. 

  1288. <pre class="program">&lt;div&gt;
    1289. 

  1289. &lt;% for item in list %&gt;
    1290. 

  1290.   &lt;p&gt;&lt;%= item %&gt;&lt;/p&gt;
    1291. 

  1291.   &lt;p&gt;&lt;%== item %&gt;&lt;/p&gt;
    1292. 

  1292. &lt;% end %&gt;
    1293. 

  1293. &lt;/div&gt;
    1294. 

  1294. </pre>
    1295. 

  1295. <a name="escape_example.result"></a>
    1296. 

  1296. <div class="terminal_caption">
    1297. 

  1297. compiled source code</div>
    1298. 

  1298. <pre class="terminal">$ erubis -xE Escape example.eruby
    1299. 

  1299. _buf = ''; _buf &lt;&lt; '&lt;div&gt;
    1300. 

  1300. '; for item in list 
    1301. 

  1301.  _buf &lt;&lt; '  &lt;p&gt;'; <strong>_buf &lt;&lt; Erubis::XmlHelper.escape_xml( item );</strong> _buf &lt;&lt; '&lt;/p&gt;
    1302. 

  1302.   &lt;p&gt;'; <strong>_buf &lt;&lt; ( item ).to_s;</strong> _buf &lt;&lt; '&lt;/p&gt;
    1303. 

  1303. '; end 
    1304. 

  1304.  _buf &lt;&lt; '&lt;/div&gt;
    1305. 

  1305. ';
    1306. 

  1306. _buf.to_s
    1307. 

  1307. </pre>
    1308. 

  1308. <p>EscapeEnhancer is language-independent.
    1309. 

  1309. </p>
    1310. 

  1310. <br>
    1311. 

  1311. 

  1312. 

  1313. <a name="stdout-enhancer"></a>
    1314. 

  1314. <h3 class="section2">StdoutEnhancer</h3>
    1315. 

  1315. <p>StdoutEnhancer use $sdtdout instead of array buffer.
    1316. 

  1316. Therefore, you can use 'print' statement in embedded ruby code.
    1317. 

  1317. </p>
    1318. 

  1318. <a name="stdout_exmple.result"></a>
    1319. 

  1319. <div class="terminal_caption">
    1320. 

  1320. compiled source code</div>
    1321. 

  1321. <pre class="terminal">$ erubis -xE Stdout example.eruby
    1322. 

  1322. <strong>_buf = $stdout;</strong> _buf &lt;&lt; '&lt;div&gt;
    1323. 

  1323. '; for item in list 
    1324. 

  1324.  _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    1325. 

  1325.   &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
    1326. 

  1326. '; end 
    1327. 

  1327.  _buf &lt;&lt; '&lt;/div&gt;
    1328. 

  1328. ';
    1329. 

  1329. <strong>''</strong>
    1330. 

  1330. </pre>
    1331. 

  1331. <p>StdoutEnhancer is only for Eruby.
    1332. 

  1332. </p>
    1333. 

  1333. <br>
    1334. 

  1334. 

  1335. 

  1336. <a name="printout-enhancer"></a>
    1337. 

  1337. <h3 class="section2">PrintOutEnhancer</h3>
    1338. 

  1338. <p>PrintOutEnhancer makes compiled source code to use 'print(...)' instead of '_buf &lt;&lt; ...'.
    1339. 

  1339. </p>
    1340. 

  1340. <a name="printstatement_example.result"></a>
    1341. 

  1341. <div class="terminal_caption">
    1342. 

  1342. compiled source code</div>
    1343. 

  1343. <pre class="terminal">$ erubis -xE PrintOut example.eruby
    1344. 

  1344.  <strong>print</strong> '&lt;div&gt;
    1345. 

  1345. '; for item in list 
    1346. 

  1346.  <strong>print</strong> '  &lt;p&gt;'; <strong>print</strong>(( item ).to_s); <strong>print</strong> '&lt;/p&gt;
    1347. 

  1347.   &lt;p&gt;'; <strong>print</strong> Erubis::XmlHelper.escape_xml( item ); <strong>print</strong> '&lt;/p&gt;
    1348. 

  1348. '; end 
    1349. 

  1349.  <strong>print</strong> '&lt;/div&gt;
    1350. 

  1350. ';
    1351. 

  1351. </pre>
    1352. 

  1352. <p>PrintOutEnhancer is only for Eruby.
    1353. 

  1353. </p>
    1354. 

  1354. <br>
    1355. 

  1355. 

  1356. 

  1357. <a name="printenabled-enhancer"></a>
    1358. 

  1358. <h3 class="section2">PrintEnabledEnhancer</h3>
    1359. 

  1359. <p>PrintEnabledEnhancer enables you to use print() method in '&lt;% ... %&gt;'.
    1360. 

  1360. </p>
    1361. 

  1361. <a name="printenabled-example.eruby"></a>
    1362. 

  1362. <div class="program_caption">
    1363. 

  1363. printenabled-example.eruby</div>
    1364. 

  1364. <pre class="program">&lt;% for item in @list %&gt;
    1365. 

  1365.   &lt;b&gt;<strong>&lt;% print item %&gt;</strong>&lt;/b&gt;
    1366. 

  1366. &lt;% end %&gt;
    1367. 

  1367. </pre>
    1368. 

  1368. <a name="printenabled-example.rb"></a>
    1369. 

  1369. <div class="program_caption">
    1370. 

  1370. printenabled-example.rb</div>
    1371. 

  1371. <pre class="program">require 'erubis'
    1372. 

  1372. class PrintEnabledEruby &lt; Erubis::Eruby
    1373. 

  1373.   include Erubis::PrintEnabledEnhancer
    1374. 

  1374. end
    1375. 

  1375. input = File.read('printenabled-example.eruby')
    1376. 

  1376. eruby = PrintEnabledEruby.new(input)
    1377. 

  1377. list = ['aaa', 'bbb', 'ccc']
    1378. 

  1378. print eruby.evaluate(:list=&gt;list)
    1379. 

  1379. </pre>
    1380. 

  1380. <a name="printenable_example.result"></a>
    1381. 

  1381. <div class="terminal_caption">
    1382. 

  1382. output result</div>
    1383. 

  1383. <pre class="terminal">$ ruby printenabled-example.rb
    1384. 

  1384.   &lt;b&gt;aaa&lt;/b&gt;
    1385. 

  1385.   &lt;b&gt;bbb&lt;/b&gt;
    1386. 

  1386.   &lt;b&gt;ccc&lt;/b&gt;
    1387. 

  1387. </pre>
    1388. 

  1388. <p>Notice to use Eruby#evaluate() and not to use Eruby#result(),
    1389. 

  1389. because print() method in '&lt;% ... %&gt;' invokes not Kernel#print() but PrintEnabledEnhancer#print().
    1390. 

  1390. </p>
    1391. 

  1391. <p>PrintEnabledEnhancer is only for Eruby.
    1392. 

  1392. </p>
    1393. 

  1393. <br>
    1394. 

  1394. 

  1395. 

  1396. <a name="array-enhancer"></a>
    1397. 

  1397. <h3 class="section2">ArrayEnhancer</h3>
    1398. 

  1398. <p>ArrayEnhancer makes Eruby to return an array of strings.
    1399. 

  1399. </p>
    1400. 

  1400. <a name="array_example.result"></a>
    1401. 

  1401. <div class="terminal_caption">
    1402. 

  1402. compiled source code</div>
    1403. 

  1403. <pre class="terminal">$ erubis -xE Array example.eruby
    1404. 

  1404. <strong>_buf = [];</strong> _buf &lt;&lt; '&lt;div&gt;
    1405. 

  1405. '; for item in list 
    1406. 

  1406.  _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    1407. 

  1407.   &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
    1408. 

  1408. '; end 
    1409. 

  1409.  _buf &lt;&lt; '&lt;/div&gt;
    1410. 

  1410. ';
    1411. 

  1411. <strong>_buf</strong>
    1412. 

  1412. </pre>
    1413. 

  1413. <p>ArrayEnhancer is only for Eruby.
    1414. 

  1414. </p>
    1415. 

  1415. <br>
    1416. 

  1416. 

  1417. 

  1418. <a name="arraybuffer-enhancer"></a>
    1419. 

  1419. <h3 class="section2">ArrayBufferEnhancer</h3>
    1420. 

  1420. <p>ArrayBufferEnhancer makes Eruby to use array buffer.
    1421. 

  1421. Array buffer is a litte slower than String buffer.
    1422. 

  1422. </p>
    1423. 

  1423. <p>ArrayBufferEnhancer is only for Eruby.
    1424. 

  1424. </p>
    1425. 

  1425. <a name="arraybuffer_example.result"></a>
    1426. 

  1426. <div class="terminal_caption">
    1427. 

  1427. compiled source code</div>
    1428. 

  1428. <pre class="terminal">$ erubis -xE ArrayBuffer example.eruby
    1429. 

  1429. <strong>_buf = [];</strong> _buf &lt;&lt; '&lt;div&gt;
    1430. 

  1430. '; for item in list 
    1431. 

  1431.  _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    1432. 

  1432.   &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
    1433. 

  1433. '; end 
    1434. 

  1434.  _buf &lt;&lt; '&lt;/div&gt;
    1435. 

  1435. ';
    1436. 

  1436. <strong>_buf.join</strong>
    1437. 

  1437. </pre>
    1438. 

  1438. <br>
    1439. 

  1439. 

  1440. 

  1441. <a name="stringbuffer-enhancer"></a>
    1442. 

  1442. <h3 class="section2">StringBufferEnhancer</h3>
    1443. 

  1443. <p>StringBufferEnhancer makes Eruby to use string buffer.
    1444. 

  1444. String buffer is a little faster than array buffer.
    1445. 

  1445. Erubis::Eruby includes this enhancer by default.
    1446. 

  1446. </p>
    1447. 

  1447. <a name="stringbuffer_example.result"></a>
    1448. 

  1448. <div class="terminal_caption">
    1449. 

  1449. compiled source code</div>
    1450. 

  1450. <pre class="terminal">$ erubis -xE StringBuffer example.eruby
    1451. 

  1451. <strong>_buf = '';</strong> _buf &lt;&lt; '&lt;div&gt;
    1452. 

  1452. '; for item in list 
    1453. 

  1453.  _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    1454. 

  1454.   &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
    1455. 

  1455. '; end 
    1456. 

  1456.  _buf &lt;&lt; '&lt;/div&gt;
    1457. 

  1457. ';
    1458. 

  1458. <strong>_buf.to_s</strong>
    1459. 

  1459. </pre>
    1460. 

  1460. <p>StringBufferEnhancer is only for Eruby.
    1461. 

  1461. </p>
    1462. 

  1462. <br>
    1463. 

  1463. 

  1464. 

  1465. <a name="erbout-enhancer"></a>
    1466. 

  1466. <h3 class="section2">ErboutEnhancer</h3>
    1467. 

  1467. <p>ErboutEnhancer makes Eruby to be compatible with ERB.
    1468. 

  1468. This is useful especially for Ruby on Rails.
    1469. 

  1469. </p>
    1470. 

  1470. <div class="terminal_caption">
    1471. 

  1471. compiled source code</div>
    1472. 

  1472. <pre class="terminal">$ erubis -xE Erbout example.eruby
    1473. 

  1473. <strong>_erbout = _buf = '';</strong> _buf &lt;&lt; '&lt;div&gt;
    1474. 

  1474. '; for item in list 
    1475. 

  1475.  _buf &lt;&lt; '  &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    1476. 

  1476.   &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
    1477. 

  1477. '; end 
    1478. 

  1478.  _buf &lt;&lt; '&lt;/div&gt;
    1479. 

  1479. ';
    1480. 

  1480. _buf.to_s
    1481. 

  1481. </pre>
    1482. 

  1482. <p>ErboutEnhancer is only for Eruby.
    1483. 

  1483. </p>
    1484. 

  1484. <br>
    1485. 

  1485. 

  1486. 

  1487. <a name="notext-enhancer"></a>
    1488. 

  1488. <h3 class="section2">NoTextEnhancer</h3>
    1489. 

  1489. <p>NoTextEnhancer suppress output of text and prints only embedded code.
    1490. 

  1490. This is useful especially when debugging a complex eRuby script.
    1491. 

  1491. </p>
    1492. 

  1492. <a name="notext-example.eruby"></a>
    1493. 

  1493. <div class="program_caption">
    1494. 

  1494. notext-example.eruby</div>
    1495. 

  1495. <pre class="program">&lt;h3&gt;List&lt;/h3&gt;
    1496. 

  1496. &lt;% if !@list || @list.empty? %&gt;
    1497. 

  1497. &lt;p&gt;not found.&lt;/p&gt;
    1498. 

  1498. &lt;% else %&gt;
    1499. 

  1499. &lt;table&gt;
    1500. 

  1500.   &lt;tbody&gt;
    1501. 

  1501.     &lt;% @list.each_with_index do |item, i| %&gt;
    1502. 

  1502.     &lt;tr bgcolor="&lt;%= i%2 == 0 ? '#FFCCCC' : '#CCCCFF' %&gt;"&gt;
    1503. 

  1503.       &lt;td&gt;&lt;%= item %&gt;&lt;/td&gt;
    1504. 

  1504.     &lt;/tr&gt;
    1505. 

  1505.     &lt;% end %&gt;
    1506. 

  1506.   &lt;/tbody&gt;
    1507. 

  1507. &lt;/table&gt;
    1508. 

  1508. &lt;% end %&gt;
    1509. 

  1509. </pre>
    1510. 

  1510. <a name="notext_example.result"></a>
    1511. 

  1511. <div class="terminal_caption">
    1512. 

  1512. output example of NoTextEnhancer</div>
    1513. 

  1513. <pre class="terminal">$ erubis -xE NoText notext-example.eruby
    1514. 

  1514. _buf = '';
    1515. 

  1515.  if !@list || @list.empty? 
    1516. 

  1516. 

  1517.  else 
    1518. 

  1518. 

  1519. 

  1520.      @list.each_with_index do |item, i| 
    1521. 

  1521.                   _buf &lt;&lt; ( i%2 == 0 ? '#FFCCCC' : '#CCCCFF' ).to_s;
    1522. 

  1522.            _buf &lt;&lt; ( item ).to_s;
    1523. 

  1523. 

  1524.      end 
    1525. 

  1525. 

  1526. 

  1527.  end 
    1528. 

  1528. _buf.to_s
    1529. 

  1529. </pre>
    1530. 

  1530. <p>NoTextEnhancer is language-independent. It is useful even if you are PHP user, see <a href="#topics-php">this section</a>.
    1531. 

  1531. </p>
    1532. 

  1532. <br>
    1533. 

  1533. 

  1534. 

  1535. <a name="nocode-enhancer"></a>
    1536. 

  1536. <h3 class="section2">NoCodeEnhancer</h3>
    1537. 

  1537. <p>NoCodeEnhancer suppress output of embedded code and prints only normal text.
    1538. 

  1538. This is useful especially when validating HTML tags.
    1539. 

  1539. </p>
    1540. 

  1540. <a name="nocode-example.eruby"></a>
    1541. 

  1541. <div class="program_caption">
    1542. 

  1542. nocode-example.eruby</div>
    1543. 

  1543. <pre class="program">&lt;h3&gt;List&lt;/h3&gt;
    1544. 

  1544. &lt;% if !@list || @list.empty? %&gt;
    1545. 

  1545. &lt;p&gt;not found.&lt;/p&gt;
    1546. 

  1546. &lt;% else %&gt;
    1547. 

  1547. &lt;table&gt;
    1548. 

  1548.   &lt;tbody&gt;
    1549. 

  1549.     &lt;% @list.each_with_index do |item, i| %&gt;
    1550. 

  1550.     &lt;tr bgcolor="&lt;%= i%2 == 0 ? '#FFCCCC' : '#CCCCFF' %&gt;"&gt;
    1551. 

  1551.       &lt;td&gt;&lt;%= item %&gt;&lt;/td&gt;
    1552. 

  1552.     &lt;/tr&gt;
    1553. 

  1553.     &lt;% end %&gt;
    1554. 

  1554.   &lt;/tbody&gt;
    1555. 

  1555. &lt;/table&gt;
    1556. 

  1556. &lt;% end %&gt;
    1557. 

  1557. </pre>
    1558. 

  1558. <a name="nocode_example.result"></a>
    1559. 

  1559. <div class="terminal_caption">
    1560. 

  1560. output example of NoCodeEnhancer</div>
    1561. 

  1561. <pre class="terminal">$ erubis -xE NoCode notext-example.eruby
    1562. 

  1562. &lt;h3&gt;List&lt;/h3&gt;
    1563. 

  1563. 

  1564. &lt;p&gt;not found.&lt;/p&gt;
    1565. 

  1565. 

  1566. &lt;table&gt;
    1567. 

  1567.   &lt;tbody&gt;
    1568. 

  1568. 

  1569.     &lt;tr bgcolor=""&gt;
    1570. 

  1570.       &lt;td&gt;&lt;/td&gt;
    1571. 

  1571.     &lt;/tr&gt;
    1572. 

  1572. 

  1573.   &lt;/tbody&gt;
    1574. 

  1574. &lt;/table&gt;
    1575. 

  1575. 

  1576. </pre>
    1577. 

  1577. <p>NoCodeEnhancer is language-independent. It is useful even if you are PHP user, see <a href="#topics-php">this section</a>.
    1578. 

  1578. </p>
    1579. 

  1579. <br>
    1580. 

  1580. 

  1581. 

  1582. <a name="simplify-enhancer"></a>
    1583. 

  1583. <h3 class="section2">SimplifyEnhancer</h3>
    1584. 

  1584. <p>SimplifyEnhancer makes compiling a little faster but don't trim spaces around '&lt;% %&gt;'.
    1585. 

  1585. </p>
    1586. 

  1586. <a name="simplify_example.result"></a>
    1587. 

  1587. <div class="terminal_caption">
    1588. 

  1588. compiled source code</div>
    1589. 

  1589. <pre class="terminal">$ erubis -xE Simplify example.eruby
    1590. 

  1590. _buf = ''; _buf &lt;&lt; '&lt;div&gt;
    1591. 

  1591. '; for item in list ; _buf &lt;&lt; '
    1592. 

  1592.   &lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    1593. 

  1593.   &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
    1594. 

  1594. '; end ; _buf &lt;&lt; '
    1595. 

  1595. &lt;/div&gt;
    1596. 

  1596. ';
    1597. 

  1597. _buf.to_s
    1598. 

  1598. </pre>
    1599. 

  1599. <p>SimplifyEnhancer is language-independent.
    1600. 

  1600. </p>
    1601. 

  1601. <br>
    1602. 

  1602. 

  1603. 

  1604. <a name="bipattern-enhancer"></a>
    1605. 

  1605. <h3 class="section2">BiPatternEnhancer</h3>
    1606. 

  1606. <p>BiPatternEnhancer enables to use another embedded pattern with '&lt;% %&gt;'.
    1607. 

  1607. By Default, '[= ... =]' is available for expression.
    1608. 

  1608. You can specify pattern by :bipattern property.
    1609. 

  1609. </p>
    1610. 

  1610. <a name="bipattern-example.rhtml"></a>
    1611. 

  1611. <div class="program_caption">
    1612. 

  1612. bipattern-example.rhtml</div>
    1613. 

  1613. <pre class="program">&lt;% for item in list %&gt;
    1614. 

  1614.   &lt;b&gt;<strong>[= item =]</strong>&lt;/b&gt;
    1615. 

  1615.   &lt;b&gt;<strong>[== item =]</strong>&lt;/b&gt;
    1616. 

  1616. &lt;% end %&gt;
    1617. 

  1617. </pre>
    1618. 

  1618. <a name="bipattern_example.result"></a>
    1619. 

  1619. <div class="terminal_caption">
    1620. 

  1620. compiled source code</div>
    1621. 

  1621. <pre class="terminal">$ erubis -xE BiPattern bipattern-example.rhtml
    1622. 

  1622. _buf = ''; for item in list 
    1623. 

  1623.  _buf &lt;&lt; '  &lt;b&gt;'; <strong>_buf &lt;&lt; ( item ).to_s;</strong> _buf &lt;&lt; '&lt;/b&gt;
    1624. 

  1624.   &lt;b&gt;'; <strong>_buf &lt;&lt; Erubis::XmlHelper.escape_xml( item );</strong> _buf &lt;&lt; '&lt;/b&gt;
    1625. 

  1625. '; end 
    1626. 

  1626. _buf.to_s
    1627. 

  1627. </pre>
    1628. 

  1628. <p>BiPatternEnhancer is language-independent.
    1629. 

  1629. </p>
    1630. 

  1630. <br>
    1631. 

  1631. 

  1632. 

  1633. <a name="percentline-enhancer"></a>
    1634. 

  1634. <h3 class="section2">PercentLineEnhancer</h3>
    1635. 

  1635. <p>PercentLineEnhancer regards lines starting with '%' as Ruby code.
    1636. 

  1636. This is for compatibility with eruby and ERB.
    1637. 

  1637. </p>
    1638. 

  1638. <a name="percentline-example.rhtml"></a>
    1639. 

  1639. <div class="program_caption">
    1640. 

  1640. percentline-example.rhtml</div>
    1641. 

  1641. <pre class="program"><strong>% for item in list</strong>
    1642. 

  1642.   &lt;b&gt;&lt;%= item %&gt;&lt;/b&gt;
    1643. 

  1643. <strong>% end</strong>
    1644. 

  1644. %% lines with '%%'
    1645. 

  1645. </pre>
    1646. 

  1646. <a name="percentline_example.result"></a>
    1647. 

  1647. <div class="terminal_caption">
    1648. 

  1648. compiled source code</div>
    1649. 

  1649. <pre class="terminal">$ erubis -xE PercentLine percentline-example.rhtml
    1650. 

  1650. _buf = ''; <strong>for item in list</strong>
    1651. 

  1651.  _buf &lt;&lt; '  &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
    1652. 

  1652. '; <strong>end</strong>
    1653. 

  1653.  _buf &lt;&lt; '% lines with \'%%\'
    1654. 

  1654. ';
    1655. 

  1655. _buf.to_s
    1656. 

  1656. </pre>
    1657. 

  1657. <p>PercentLineEnhancer is language-independent.
    1658. 

  1658. </p>
    1659. 

  1659. <br>
    1660. 

  1660. 

  1661. 

  1662. <a name="headerfooter-enhancer"></a>
    1663. 

  1663. <h3 class="section2">HeaderFooterEnhancer</h3>
    1664. 

  1664. <p>[experimental]
    1665. 

  1665. </p>
    1666. 

  1666. <p>HeaderFooterEnhancer enables you to add header and footer in eRuby script.
    1667. 

  1667. </p>
    1668. 

  1668. <a name="headerfooter-example.eruby"></a>
    1669. 

  1669. <div class="program_caption">
    1670. 

  1670. headerfooter-example.eruby</div>
    1671. 

  1671. <pre class="program"><strong>&lt;!--#header:</strong>
    1672. 

  1672. <strong>def list_items(items)</strong>
    1673. 

  1673. <strong>#--&gt;</strong>
    1674. 

  1674. &lt;% for item in items %&gt;
    1675. 

  1675.   &lt;b&gt;&lt;%= item %&gt;&lt;/b&gt;
    1676. 

  1676. &lt;% end %&gt;
    1677. 

  1677. <strong>&lt;!--#footer:</strong>
    1678. 

  1678. <strong>end</strong>
    1679. 

  1679. <strong>#--&gt;</strong>
    1680. 

  1680. </pre>
    1681. 

  1681. <a name="headerfooter_example.result"></a>
    1682. 

  1682. <div class="terminal_caption">
    1683. 

  1683. compiled source code</div>
    1684. 

  1684. <pre class="terminal">$ erubis -xE HeaderFooter headerfooter-example.eruby
    1685. 

  1685. 

  1686. <strong>def list_items(items)</strong>
    1687. 

  1687. 

  1688. _buf = ''; for item in items 
    1689. 

  1689.  _buf &lt;&lt; '  &lt;b&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/b&gt;
    1690. 

  1690. '; end 
    1691. 

  1691. _buf.to_s
    1692. 

  1692. 

  1693. <strong>end</strong>
    1694. 

  1694. 

  1695. </pre>
    1696. 

  1696. <p>Compare to the following:
    1697. 

  1697. </p>
    1698. 

  1698. <a name="normal-eruby-test.eruby"></a>
    1699. 

  1699. <div class="program_caption">
    1700. 

  1700. normal-eruby-test.eruby</div>
    1701. 

  1701. <pre class="program"><strong>&lt;%</strong>
    1702. 

  1702. <strong>def list_items(items)</strong>
    1703. 

  1703. <strong>%&gt;</strong>
    1704. 

  1704. &lt;% for item in items %&gt;
    1705. 

  1705. &lt;li&gt;&lt;%= item %&gt;&lt;/li&gt;
    1706. 

  1706. &lt;% end %&gt;
    1707. 

  1707. <strong>&lt;%</strong>
    1708. 

  1708. <strong>end</strong>
    1709. 

  1709. <strong>%&gt;</strong>
    1710. 

  1710. </pre>
    1711. 

  1711. <a name="normal_eruby_test.result"></a>
    1712. 

  1712. <div class="terminal_caption">
    1713. 

  1713. compiled source code</div>
    1714. 

  1714. <pre class="terminal">$ erubis -x normal-eruby-test.eruby
    1715. 

  1715. _buf = '';
    1716. 

  1716. <strong>def list_items(items)</strong>
    1717. 

  1717. 

  1718.  for item in items 
    1719. 

  1719.  _buf &lt;&lt; '&lt;li&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/li&gt;
    1720. 

  1720. '; end 
    1721. 

    1722. 

  1722. <strong>end</strong>
    1723. 

  1723. 

  1724. _buf.to_s
    1725. 

  1725. </pre>
    1726. 

  1726. <p>Header and footer can be in any position in eRuby script,
    1727. 

  1727. that is, header is no need to be in the head of eRuby script.
    1728. 

  1728. </p>
    1729. 

  1729. <a name="headerfooter-example2.rhtml"></a>
    1730. 

  1730. <div class="program_caption">
    1731. 

  1731. headerfooter-example2.rhtml</div>
    1732. 

  1732. <pre class="program">&lt;?xml version="1.0"?&gt;
    1733. 

  1733. &lt;html&gt;
    1734. 

  1734. <strong>&lt;!--#header:</strong>
    1735. 

  1735. <strong>def page(list)</strong>
    1736. 

  1736. <strong>#--&gt;</strong>
    1737. 

  1737.  :
    1738. 

  1738. <strong>&lt;!--#footer:</strong>
    1739. 

  1739. <strong>end</strong>
    1740. 

  1740. <strong>#--&gt;</strong>
    1741. 

  1741. &lt;/html&gt;
    1742. 

  1742. </pre>
    1743. 

  1743. <a name="headerfooter_example2.result"></a>
    1744. 

  1744. <div class="terminal_caption">
    1745. 

  1745. compiled source code</div>
    1746. 

  1746. <pre class="terminal">$ erubis -xE HeaderFooter headerfooter-example2.rhtml
    1747. 

  1747. 

  1748. <strong>def page(list)</strong>
    1749. 

  1749. 

  1750. _buf = ''; _buf &lt;&lt; '&lt;?xml version="1.0"?&gt;
    1751. 

  1751. &lt;html&gt;
    1752. 

  1752. '; _buf &lt;&lt; ' :
    1753. 

  1753. '; _buf &lt;&lt; '&lt;/html&gt;
    1754. 

  1754. ';
    1755. 

  1755. _buf.to_s
    1756. 

  1756. 

  1757. <strong>end</strong>
    1758. 

  1758. 

  1759. </pre>
    1760. 

  1760. <p>HeaderFooterEnhancer is experimental and is language-independent.
    1761. 

  1761. </p>
    1762. 

  1762. <br>
    1763. 

  1763. 

  1764. 

  1765. <a name="interpolation-enhancer"></a>
    1766. 

  1766. <h3 class="section2">InterpolationEnhancer</h3>
    1767. 

  1767. <p>[experimental]
    1768. 

  1768. </p>
    1769. 

  1769. <p>InterpolationEnhancer converts "&lt;h1&gt;&lt;%= title %&gt;&lt;/h1&gt;" into
    1770. 

  1770. "_buf &lt;&lt; %Q`&lt;h1&gt;#{ title }&lt;/h1&gt;`".
    1771. 

  1771. This makes Eruby a litter faster because method call of String#&lt;&lt; are eliminated
    1772. 

  1772. by expression interpolations.
    1773. 

  1773. </p>
    1774. 

  1774. <div class="program_caption">
    1775. 

  1775. InterpolationEnhancer elmininates method call of String#&lt;&lt;.</div>
    1776. 

  1776. <pre class="program">## Assume that input is '&lt;a href="&lt;%=url%&gt;"&gt;&lt;%=name%&gt;&lt;/a&gt;'.
    1777. 

  1777. ## Eruby convert input into the following code.  String#&lt;&lt; is called 5 times.
    1778. 

  1778. _buf &lt;&lt; '&lt;a href="'; _buf &lt;&lt; (url).to_s; _buf &lt;&lt; '"&gt;'; _buf &lt;&lt; (name).to_s; _buf &lt;&lt; '&lt;/a&gt;';
    1779. 

  1779. 

  1780. ## If InterpolationEnhancer is used, String#&lt;&lt; is called only once.
    1781. 

  1781. _buf &lt;&lt; %Q`&lt;a href="#{url}"&gt;#{name}&lt;/a&gt;`;
    1782. 

  1782. </pre>
    1783. 

  1783. <a name="interpolation_example.result"></a>
    1784. 

  1784. <div class="terminal_caption">
    1785. 

  1785. compiled source code</div>
    1786. 

  1786. <pre class="terminal">$ erubis -xE Interpolation example.eruby
    1787. 

  1787. _buf = ''; _buf &lt;&lt; <strong>%Q`</strong>&lt;div&gt;\n<strong>`</strong>
    1788. 

  1788.  for item in list 
    1789. 

  1789.  _buf &lt;&lt; <strong>%Q`</strong>  &lt;p&gt;<strong>#{ item }</strong>&lt;/p&gt;
    1790. 

  1790.   &lt;p&gt;<strong>#{Erubis::XmlHelper.escape_xml( item )}</strong>&lt;/p&gt;\n<strong>`</strong>
    1791. 

  1791.  end 
    1792. 

  1792.  _buf &lt;&lt; <strong>%Q`</strong>&lt;/div&gt;\n<strong>`</strong>
    1793. 

  1793. _buf.to_s
    1794. 

  1794. </pre>
    1795. 

  1795. <p>Erubis provides Erubis::FastEruby class which includes InterpolationEnhancer.
    1796. 

  1796. You can use Erubis::FastEruby class instead of Erubis::Eruby class.
    1797. 

  1797. </p>
    1798. 

  1798. <p>InterpolationEnhancer is only for Eruby.
    1799. 

  1799. </p>
    1800. 

  1800. <br>
    1801. 

  1801. 

  1802. 

  1803. <a name="deleteindent-enhancer"></a>
    1804. 

  1804. <h3 class="section2">DeleteIndentEnhancer</h3>
    1805. 

  1805. <p>[experimental]
    1806. 

  1806. DeleteIndentEnhancer deletes indentation of HTML file.
    1807. 

  1807. </p>
    1808. 

  1808. <a name="interpolation_example.result"></a>
    1809. 

  1809. <div class="terminal_caption">
    1810. 

  1810. compiled source code</div>
    1811. 

  1811. <pre class="terminal">$ erubis -xE DeleteIndent example.eruby
    1812. 

  1812. _buf = ''; _buf &lt;&lt; '&lt;div&gt;
    1813. 

  1813. '; for item in list 
    1814. 

  1814.  _buf &lt;&lt; '&lt;p&gt;'; _buf &lt;&lt; ( item ).to_s; _buf &lt;&lt; '&lt;/p&gt;
    1815. 

  1815. &lt;p&gt;'; _buf &lt;&lt; Erubis::XmlHelper.escape_xml( item ); _buf &lt;&lt; '&lt;/p&gt;
    1816. 

  1816. '; end 
    1817. 

  1817.  _buf &lt;&lt; '&lt;/div&gt;
    1818. 

  1818. ';
    1819. 

  1819. _buf.to_s
    1820. 

  1820. </pre>
    1821. 

  1821. <p>Notice that DeleteIndentEnhancer isn't intelligent.
    1822. 

  1822. It deletes indentations even if they are in &lt;PRE&gt;&lt;/PRE&gt;.
    1823. 

  1823. </p>
    1824. 

  1824. <p>DeleteIndentEnhancer is language-independent.
    1825. 

  1825. </p>
    1826. 

  1826. <br>
    1827. 

  1827. 

  1828. 

  1829. <br>
    1830. 

  1830. 

  1831. 

  1832. <a name="lang"></a>
    1833. 

  1833. <h2 class="section1">Multi-Language Support</h2>
    1834. 

  1834. <p>Erubis supports the following languages<sup>(<a href="#fnref:2" name="fnlink:2">*2</a>)</sup>:
    1835. 

  1835. </p>
    1836. 

  1836. <ul type="disc">
    1837. 

  1837. <li>Ruby
    1838. 

  1838. </li>
    1839. 

  1839. <li><a href="#lang-php">PHP</a>
    1840. 

  1840. </li>
    1841. 

  1841. <li><a href="#lang-c">C</a>
    1842. 

  1842. </li>
    1843. 

  1843. <li><a href="#lang-java">Java</a>
    1844. 

  1844. </li>
    1845. 

  1845. <li><a href="#lang-scheme">Scheme</a>
    1846. 

  1846. </li>
    1847. 

  1847. <li><a href="#lang-perl">Perl</a>
    1848. 

  1848. </li>
    1849. 

  1849. <li><a href="#lang-javascript">JavaScript</a>
    1850. 

  1850. </li>
    1851. 

  1851. </ul>
    1852. 

  1852. <div class="footnote">
    1853. 

  1853.  <dl compact>
    1854. 

  1854.   <dt>(<a name="fnref:2" href="#fnlink:2">*2</a>)</dt>
    1855. 

  1855.   <dd>If you need template engine in pure PHP/Perl/JavaScript, try <a href="http://www.kuwata-lab.com/tenjin/">Tenjin</a> (<a href="http://www.kuwata-lab.com/tenjin/">http://www.kuwata-lab.com/tenjin/</a>). Tenjin is a very fast and full-featured template engine implemented in pure PHP/Perl/JavaScript.</dd>
    1856. 

  1856.  </dl>
    1857. 

  1857. </div>
    1858. 

  1858. <a name="lang-php"></a>
    1859. 

  1859. <h3 class="section2">PHP</h3>
    1860. 

  1860. <a name="example.ephp"></a>
    1861. 

  1861. <div class="program_caption">
    1862. 

  1862. example.ephp</div>
    1863. 

  1863. <pre class="program">&lt;?xml version="1.0"?&gt;
    1864. 

  1864. &lt;html&gt;
    1865. 

  1865.  &lt;body&gt;
    1866. 

  1866.   &lt;p&gt;Hello <strong>&lt;%= $user %&gt;</strong>!&lt;/p&gt;
    1867. 

  1867.   &lt;table&gt;
    1868. 

  1868.    &lt;tbody&gt;
    1869. 

  1869.     <strong>&lt;% $i = 0; %&gt;</strong>
    1870. 

  1870.     <strong>&lt;% foreach ($list as $item) { %&gt;</strong>
    1871. 

  1871.     <strong>&lt;%   $i++; %&gt;</strong>
    1872. 

  1872.     &lt;tr bgcolor=<strong>"&lt;%= $i % 2 == 0 ? '#FFCCCC' : '#CCCCFF' %&gt;"</strong>&gt;
    1873. 

  1873.      &lt;td&gt;<strong>&lt;%= $i %&gt;</strong>&lt;/td&gt;
    1874. 

  1874.      &lt;td&gt;<strong>&lt;%== $item %&gt;</strong>&lt;/td&gt;
    1875. 

  1875.     &lt;/tr&gt;
    1876. 

  1876.     <strong>&lt;% } %&gt;</strong>
    1877. 

  1877.    &lt;/tbody&gt;
    1878. 

  1878.   &lt;/table&gt;
    1879. 

  1879.  &lt;/body&gt;
    1880. 

  1880. &lt;/html&gt;
    1881. 

  1881. </pre>
    1882. 

  1882. <a name="example_php.result"></a>
    1883. 

  1883. <div class="terminal_caption">
    1884. 

  1884. compiled source code</div>
    1885. 

  1885. <pre class="terminal">$ erubis -l php example.ephp
    1886. 

  1886. &lt;&lt;?php ?&gt;?xml version="1.0"?&gt;
    1887. 

  1887. &lt;html&gt;
    1888. 

  1888.  &lt;body&gt;
    1889. 

  1889.   &lt;p&gt;Hello &lt;?php echo $user; ?&gt;!&lt;/p&gt;
    1890. 

  1890.   &lt;table&gt;
    1891. 

  1891.    &lt;tbody&gt;
    1892. 

  1892. &lt;?php     $i = 0; ?&gt;
    1893. 

  1893. &lt;?php     foreach ($list as $item) { ?&gt;
    1894. 

  1894. &lt;?php       $i++; ?&gt;
    1895. 

  1895.     &lt;tr bgcolor="&lt;?php echo $i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'; ?&gt;"&gt;
    1896. 

  1896.      &lt;td&gt;&lt;?php echo $i; ?&gt;&lt;/td&gt;
    1897. 

  1897.      &lt;td&gt;&lt;?php echo htmlspecialchars($item); ?&gt;&lt;/td&gt;
    1898. 

  1898.     &lt;/tr&gt;
    1899. 

  1899. &lt;?php     } ?&gt;
    1900. 

  1900.    &lt;/tbody&gt;
    1901. 

  1901.   &lt;/table&gt;
    1902. 

  1902.  &lt;/body&gt;
    1903. 

  1903. &lt;/html&gt;
    1904. 

  1904. </pre>
    1905. 

  1905. <br>
    1906. 

  1906. 

  1907. 

  1908. <a name="lang-c"></a>
    1909. 

  1909. <h3 class="section2">C</h3>
    1910. 

  1910. <a name="example.ec"></a>
    1911. 

  1911. <div class="program_caption">
    1912. 

  1912. example.ec</div>
    1913. 

  1913. <pre class="program"><strong>&lt;%
    1914. 

  1914. #include &lt;stdio.h&gt;
    1915. 

  1915. 

  1916. int main(int argc, char *argv[])
    1917. 

  1917. {
    1918. 

  1918.     int i;
    1919. 

  1919. 

  1920. %&gt;</strong>
    1921. 

  1921. &lt;html&gt;
    1922. 

  1922.  &lt;body&gt;
    1923. 

  1923.   &lt;p&gt;Hello <strong>&lt;%= "%s", argv[0] %&gt;</strong>!&lt;/p&gt;
    1924. 

  1924.   &lt;table&gt;
    1925. 

  1925.    &lt;tbody&gt;
    1926. 

  1926.     <strong>&lt;% for (i = 1; i &lt; argc; i++) { %&gt;</strong>
    1927. 

  1927.     &lt;tr bgcolor="<strong>&lt;%= i % 2 == 0 ? "#FFCCCC" : "#CCCCFF" %&gt;</strong>"&gt;
    1928. 

  1928.       &lt;td&gt;<strong>&lt;%= "%d", i %&gt;</strong>&lt;/td&gt;
    1929. 

  1929.       &lt;td&gt;<strong>&lt;%= "%s", argv[i] %&gt;</strong>&lt;/td&gt;
    1930. 

  1930.     &lt;/tr&gt;
    1931. 

  1931.     <strong>&lt;% } %&gt;</strong>
    1932. 

  1932.    &lt;/tbody&gt;
    1933. 

  1933.   &lt;/table&gt;
    1934. 

  1934.  &lt;/body&gt;
    1935. 

  1935. &lt;/html&gt;
    1936. 

  1936. <strong>&lt;%
    1937. 

  1937.     return 0; 
    1938. 

  1938. }
    1939. 

  1939. %&gt;</strong>
    1940. 

  1940. </pre>
    1941. 

  1941. <a name="example_c.result"></a>
    1942. 

  1942. <div class="terminal_caption">
    1943. 

  1943. compiled source code</div>
    1944. 

  1944. <pre class="terminal">$ erubis -l c example.ec
    1945. 

  1945. #line 1 "example.ec"
    1946. 

  1946. 

  1947. #include &lt;stdio.h&gt;
    1948. 

  1948. 

  1949. int main(int argc, char *argv[])
    1950. 

  1950. {
    1951. 

  1951.     int i;
    1952. 

  1952. 

  1953. 

  1954. fputs("&lt;html&gt;\n"
    1955. 

  1955.       " &lt;body&gt;\n"
    1956. 

  1956.       "  &lt;p&gt;Hello ", stdout); fprintf(stdout, "%s", argv[0]); fputs("!&lt;/p&gt;\n"
    1957. 

  1957.       "  &lt;table&gt;\n"
    1958. 

  1958.       "   &lt;tbody&gt;\n", stdout);
    1959. 

  1959.      for (i = 1; i &lt; argc; i++) { 
    1960. 

  1960. fputs("    &lt;tr bgcolor=\"", stdout); fprintf(stdout, i % 2 == 0 ? "#FFCCCC" : "#CCCCFF"); fputs("\"&gt;\n"
    1961. 

  1961.       "      &lt;td&gt;", stdout); fprintf(stdout, "%d", i); fputs("&lt;/td&gt;\n"
    1962. 

  1962.       "      &lt;td&gt;", stdout); fprintf(stdout, "%s", argv[i]); fputs("&lt;/td&gt;\n"
    1963. 

  1963.       "    &lt;/tr&gt;\n", stdout);
    1964. 

  1964.      } 
    1965. 

  1965. fputs("   &lt;/tbody&gt;\n"
    1966. 

  1966.       "  &lt;/table&gt;\n"
    1967. 

  1967.       " &lt;/body&gt;\n"
    1968. 

  1968.       "&lt;/html&gt;\n", stdout);
    1969. 

  1969. 

  1970.     return 0; 
    1971. 

  1971. }
    1972. 

  1972. 

  1973. </pre>
    1974. 

  1974. <br>
    1975. 

  1975. 

  1976. 

  1977. <a name="lang-java"></a>
    1978. 

  1978. <h3 class="section2">Java</h3>
    1979. 

  1979. <a name="Example.ejava"></a>
    1980. 

  1980. <div class="program_caption">
    1981. 

  1981. Example.ejava</div>
    1982. 

  1982. <pre class="program"><strong>&lt;%
    1983. 

  1983. import java.util.*;
    1984. 

  1984. 

  1985. public class Example {
    1986. 

  1986.   private String user;
    1987. 

  1987.   private String[] list;
    1988. 

  1988.   public example(String user, String[] list) {
    1989. 

  1989.     this.user = user;
    1990. 

  1990.     this.list = list;
    1991. 

  1991.   }
    1992. 

  1992. 

  1993.   public String view() {
    1994. 

  1994.     StringBuffer _buf = new StringBuffer();
    1995. 

  1995. %&gt;</strong>
    1996. 

  1996. &lt;html&gt;
    1997. 

  1997.  &lt;body&gt;
    1998. 

  1998.   &lt;p&gt;Hello <strong>&lt;%= user %&gt;</strong>!&lt;/p&gt;
    1999. 

  1999.   &lt;table&gt;
    2000. 

  2000.    &lt;tbody&gt;
    2001. 

  2001.     <strong>&lt;% for (int i = 0; i &lt; list.length; i++) { %&gt;</strong>
    2002. 

  2002.     &lt;tr bgcolor=<strong>"&lt;%= i % 2 == 0 ? "#FFCCCC" : "#CCCCFF" %&gt;"</strong>&gt;
    2003. 

  2003.      &lt;td&gt;<strong>&lt;%= i + 1 %&gt;</strong>&lt;/td&gt;
    2004. 

  2004.      &lt;td&gt;<strong>&lt;%== list[i] %&gt;</strong>&lt;/td&gt;
    2005. 

  2005.     &lt;/tr&gt;
    2006. 

  2006.     <strong>&lt;% } %&gt;</strong>
    2007. 

  2007.    &lt;/tbody&gt;
    2008. 

  2008.   &lt;/table&gt;
    2009. 

  2009.  &lt;body&gt;
    2010. 

  2010. &lt;/html&gt;
    2011. 

  2011. <strong>&lt;%
    2012. 

  2012.     return _buf.toString();
    2013. 

  2013.   }
    2014. 

  2014. 

  2015.   public static void main(String[] args) {
    2016. 

  2016.     String[] list = { "&lt;aaa&gt;", "b&amp;b", "\"ccc\"" };
    2017. 

  2017.     Example ex = Example.new("Erubis", list);
    2018. 

  2018.     System.out.print(ex.view());
    2019. 

  2019.   }
    2020. 

  2020. 

  2021.   public static String escape(String s) {
    2022. 

  2022.     StringBuffer sb = new StringBuffer();
    2023. 

  2023.     for (int i = 0; i &lt; s.length(); i++) {
    2024. 

  2024.       char ch = s.charAt(i);
    2025. 

  2025.       switch (ch) {
    2026. 

  2026.       case '&lt;':   sb.append("&amp;lt;"); break;
    2027. 

  2027.       case '&gt;':   sb.append("&amp;gt;"); break;
    2028. 

  2028.       case '&amp;':   sb.append("&amp;amp;"); break;
    2029. 

  2029.       case '"':   sb.append("&amp;quot;"); break;
    2030. 

  2030.       default:    sb.append(ch);
    2031. 

  2031.       }
    2032. 

  2032.     }
    2033. 

  2033.     return sb.toString();
    2034. 

  2034.   }
    2035. 

  2035. }
    2036. 

  2036. %&gt;</strong>
    2037. 

  2037. </pre>
    2038. 

  2038. <a name="example_java.result"></a>
    2039. 

  2039. <div class="terminal_caption">
    2040. 

  2040. compiled source code</div>
    2041. 

  2041. <pre class="terminal">$ erubis -b -l java example.ejava
    2042. 

  2042. 

  2043. import java.util.*;
    2044. 

  2044. 

  2045. public class Example {
    2046. 

  2046.   private String user;
    2047. 

  2047.   private String[] list;
    2048. 

  2048.   public example(String user, String[] list) {
    2049. 

  2049.     this.user = user;
    2050. 

  2050.     this.list = list;
    2051. 

  2051.   }
    2052. 

  2052. 

  2053.   public String view() {
    2054. 

  2054.     StringBuffer _buf = new StringBuffer();
    2055. 

  2055. 

  2056. _buf.append("&lt;html&gt;\n"
    2057. 

  2057.           + " &lt;body&gt;\n"
    2058. 

  2058.           + "  &lt;p&gt;Hello "); _buf.append(user); _buf.append("!&lt;/p&gt;\n"
    2059. 

  2059.           + "  &lt;table&gt;\n"
    2060. 

  2060.           + "   &lt;tbody&gt;\n");
    2061. 

  2061.      for (int i = 0; i &lt; list.length; i++) { 
    2062. 

  2062. _buf.append("    &lt;tr bgcolor=\""); _buf.append(i % 2 == 0 ? "#FFCCCC" : "#CCCCFF"); _buf.append("\"&gt;\n"
    2063. 

  2063.           + "     &lt;td&gt;"); _buf.append(i + 1); _buf.append("&lt;/td&gt;\n"
    2064. 

  2064.           + "     &lt;td&gt;"); _buf.append(escape(list[i])); _buf.append("&lt;/td&gt;\n"
    2065. 

  2065.           + "    &lt;/tr&gt;\n");
    2066. 

  2066.      } 
    2067. 

  2067. _buf.append("   &lt;/tbody&gt;\n"
    2068. 

  2068.           + "  &lt;/table&gt;\n"
    2069. 

  2069.           + " &lt;body&gt;\n"
    2070. 

  2070.           + "&lt;/html&gt;\n");
    2071. 

  2071. 

  2072.     return _buf.toString();
    2073. 

  2073.   }
    2074. 

  2074. 

  2075.   public static void main(String[] args) {
    2076. 

  2076.     String[] list = { "&lt;aaa&gt;", "b&amp;b", "\"ccc\"" };
    2077. 

  2077.     Example ex = Example.new("Erubis", list);
    2078. 

  2078.     System.out.print(ex.view());
    2079. 

  2079.   }
    2080. 

  2080. 

  2081.   public static String escape(String s) {
    2082. 

  2082.     StringBuffer sb = new StringBuffer();
    2083. 

  2083.     for (int i = 0; i &lt; s.length(); i++) {
    2084. 

  2084.       char ch = s.charAt(i);
    2085. 

  2085.       switch (ch) {
    2086. 

  2086.       case '&lt;':   sb.append("&amp;lt;"); break;
    2087. 

  2087.       case '&gt;':   sb.append("&amp;gt;"); break;
    2088. 

  2088.       case '&amp;':   sb.append("&amp;amp;"); break;
    2089. 

  2089.       case '"':   sb.append("&amp;quot;"); break;
    2090. 

  2090.       default:    sb.append(ch);
    2091. 

  2091.       }
    2092. 

  2092.     }
    2093. 

  2093.     return sb.toString();
    2094. 

  2094.   }
    2095. 

  2095. }
    2096. 

  2096. 

  2097. </pre>
    2098. 

  2098. <br>
    2099. 

  2099. 

  2100. 

  2101. <a name="lang-scheme"></a>
    2102. 

  2102. <h3 class="section2">Scheme</h3>
    2103. 

  2103. <a name="example.escheme"></a>
    2104. 

  2104. <div class="program_caption">
    2105. 

  2105. example.escheme</div>
    2106. 

  2106. <pre class="program">&lt;html&gt;
    2107. 

  2107.  &lt;body&gt;
    2108. 

  2108. <strong>&lt;%
    2109. 

  2109. (let ((user "Erubis")
    2110. 

  2110.       (items '("&lt;aaa&gt;" "b&amp;b" "\"ccc\""))
    2111. 

  2111.       (i 0))
    2112. 

  2112.  %&gt;</strong>
    2113. 

  2113.   &lt;p&gt;Hello <strong>&lt;%= user %&gt;</strong>!&lt;/p&gt;
    2114. 

  2114.   &lt;table&gt;
    2115. 

  2115. <strong>&lt;%
    2116. 

  2116.   (for-each
    2117. 

  2117.    (lambda (item)
    2118. 

  2118.      (set! i (+ i 1))
    2119. 

  2119.  %&gt;</strong>
    2120. 

  2120.    &lt;tr bgcolor="<strong>&lt;%= (if (= (modulo i 2) 0) "#FFCCCC" "#CCCCFF") %&gt;</strong>"&gt;
    2121. 

  2121.     &lt;td&gt;<strong>&lt;%= i %&gt;</strong>&lt;/td&gt;
    2122. 

  2122.     &lt;td&gt;<strong>&lt;%= item %&gt;</strong>&lt;/td&gt;
    2123. 

  2123.    &lt;/tr&gt;
    2124. 

  2124. <strong>&lt;%
    2125. 

  2125.    ) ; lambda end
    2126. 

  2126.    items) ; for-each end
    2127. 

  2127.  %&gt;</strong>
    2128. 

  2128.   &lt;/table&gt;
    2129. 

  2129. <strong>&lt;%
    2130. 

  2130. ) ; let end
    2131. 

  2131. %&gt;</strong>
    2132. 

  2132.  &lt;/body&gt;
    2133. 

  2133. &lt;/html&gt;
    2134. 

  2134. </pre>
    2135. 

  2135. <a name="example_scheme.result"></a>
    2136. 

  2136. <div class="terminal_caption">
    2137. 

  2137. compiled source code</div>
    2138. 

  2138. <pre class="terminal">$ erubis -l scheme example.escheme
    2139. 

  2139. (let ((_buf '())) (define (_add x) (set! _buf (cons x _buf))) (_add "&lt;html&gt;
    2140. 

  2140.  &lt;body&gt;\n")
    2141. 

    2142. 

  2142. (let ((user "Erubis")
    2143. 

  2143.       (items '("&lt;aaa&gt;" "b&amp;b" "\"ccc\""))
    2144. 

  2144.       (i 0))
    2145. 

  2145.  
    2146. 

  2146. (_add "  &lt;p&gt;Hello ")(_add user)(_add "!&lt;/p&gt;
    2147. 

  2147.   &lt;table&gt;\n")
    2148. 

    2149. 

  2149.   (for-each
    2150. 

  2150.    (lambda (item)
    2151. 

  2151.      (set! i (+ i 1))
    2152. 

  2152.  
    2153. 

  2153. (_add "   &lt;tr bgcolor=\"")(_add (if (= (modulo i 2) 0) "#FFCCCC" "#CCCCFF"))(_add "\"&gt;
    2154. 

  2154.     &lt;td&gt;")(_add i)(_add "&lt;/td&gt;
    2155. 

  2155.     &lt;td&gt;")(_add item)(_add "&lt;/td&gt;
    2156. 

  2156.    &lt;/tr&gt;\n")
    2157. 

    2158. 

  2158.    ) ; lambda end
    2159. 

  2159.    items) ; for-each end
    2160. 

  2160.  
    2161. 

  2161. (_add "  &lt;/table&gt;\n")
    2162. 

  2162. 

  2163. ) ; let end
    2164. 

  2164. 

  2165. (_add " &lt;/body&gt;
    2166. 

  2166. &lt;/html&gt;\n")
    2167. 

  2167.   (reverse _buf))
    2168. 

  2168. </pre>
    2169. 

  2169. <a name="example_scheme_display.result"></a>
    2170. 

  2170. <div class="terminal_caption">
    2171. 

  2171. compiled source code (with <code>--func=display</code> property)</div>
    2172. 

  2172. <pre class="terminal">$ erubis -l scheme --func=display example.escheme
    2173. 

  2173. (display "&lt;html&gt;
    2174. 

  2174.  &lt;body&gt;\n")
    2175. 

    2176. 

  2176. (let ((user "Erubis")
    2177. 

  2177.       (items '("&lt;aaa&gt;" "b&amp;b" "\"ccc\""))
    2178. 

  2178.       (i 0))
    2179. 

  2179.  
    2180. 

  2180. (display "  &lt;p&gt;Hello ")(display user)(display "!&lt;/p&gt;
    2181. 

  2181.   &lt;table&gt;\n")
    2182. 

    2183. 

  2183.   (for-each
    2184. 

  2184.    (lambda (item)
    2185. 

  2185.      (set! i (+ i 1))
    2186. 

  2186.  
    2187. 

  2187. (display "   &lt;tr bgcolor=\"")(display (if (= (modulo i 2) 0) "#FFCCCC" "#CCCCFF"))(display "\"&gt;
    2188. 

  2188.     &lt;td&gt;")(display i)(display "&lt;/td&gt;
    2189. 

  2189.     &lt;td&gt;")(display item)(display "&lt;/td&gt;
    2190. 

  2190.    &lt;/tr&gt;\n")
    2191. 

    2192. 

  2192.    ) ; lambda end
    2193. 

  2193.    items) ; for-each end
    2194. 

  2194.  
    2195. 

  2195. (display "  &lt;/table&gt;\n")
    2196. 

  2196. 

  2197. ) ; let end
    2198. 

  2198. 

  2199. (display " &lt;/body&gt;
    2200. 

  2200. &lt;/html&gt;\n")
    2201. 

  2201. </pre>
    2202. 

  2202. <br>
    2203. 

  2203. 

  2204. 

  2205. <a name="lang-perl"></a>
    2206. 

  2206. <h3 class="section2">Perl</h3>
    2207. 

  2207. <a name="example.eperl"></a>
    2208. 

  2208. <div class="program_caption">
    2209. 

  2209. example.eprl</div>
    2210. 

  2210. <pre class="program"><strong>&lt;%
    2211. 

  2211.    my $user = 'Erubis';
    2212. 

  2212.    my @list = ('&lt;aaa&gt;', 'b&amp;b', '"ccc"');
    2213. 

  2213. %&gt;</strong>
    2214. 

  2214. &lt;html&gt;
    2215. 

  2215.  &lt;body&gt;
    2216. 

  2216.   &lt;p&gt;Hello <strong>&lt;%= $user %&gt;</strong>!&lt;/p&gt;
    2217. 

  2217.   &lt;table&gt;
    2218. 

  2218.    <strong>&lt;% $i = 0; %&gt;</strong>
    2219. 

  2219.    <strong>&lt;% for $item (@list) { %&gt;</strong>
    2220. 

  2220.    &lt;tr bgcolor=<strong>&lt;%= ++$i % 2 == 0 ? '#FFCCCC' : '#CCCCFF' %&gt;</strong>"&gt;
    2221. 

  2221.     &lt;td&gt;<strong>&lt;%= $i %&gt;</strong>&lt;/td&gt;
    2222. 

  2222.     &lt;td&gt;<strong>&lt;%= $item %&gt;</strong>&lt;/td&gt;
    2223. 

  2223.    &lt;/tr&gt;
    2224. 

  2224.    <strong>&lt;% } %&gt;</strong>
    2225. 

  2225.   &lt;/table&gt;
    2226. 

  2226.  &lt;/body&gt;
    2227. 

  2227. &lt;/html&gt;
    2228. 

  2228. </pre>
    2229. 

  2229. <a name="example_perl.result"></a>
    2230. 

  2230. <div class="terminal_caption">
    2231. 

  2231. compiled source code</div>
    2232. 

  2232. <pre class="terminal">$ erubis -l perl example.eperl
    2233. 

  2233. use HTML::Entities; 
    2234. 

  2234.    my $user = 'Erubis';
    2235. 

  2235.    my @list = ('&lt;aaa&gt;', 'b&amp;b', '"ccc"');
    2236. 

  2236. 

  2237. print('&lt;html&gt;
    2238. 

  2238.  &lt;body&gt;
    2239. 

  2239.   &lt;p&gt;Hello '); print($user); print('!&lt;/p&gt;
    2240. 

  2240.   &lt;table&gt;
    2241. 

  2241. ');     $i = 0; 
    2242. 

  2242.     for $item (@list) { 
    2243. 

  2243. print('   &lt;tr bgcolor='); print(++$i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'); print('"&gt;
    2244. 

  2244.     &lt;td&gt;'); print($i); print('&lt;/td&gt;
    2245. 

  2245.     &lt;td&gt;'); print($item); print('&lt;/td&gt;
    2246. 

  2246.    &lt;/tr&gt;
    2247. 

  2247. ');     } 
    2248. 

  2248. print('  &lt;/table&gt;
    2249. 

  2249.  &lt;/body&gt;
    2250. 

  2250. &lt;/html&gt;
    2251. 

  2251. '); 
    2252. 

  2252. </pre>
    2253. 

  2253. <br>
    2254. 

  2254. 

  2255. 

  2256. <a name="lang-javascript"></a>
    2257. 

  2257. <h3 class="section2">JavaScript</h3>
    2258. 

  2258. <a name="example.ejs"></a>
    2259. 

  2259. <div class="program_caption">
    2260. 

  2260. example.ejs</div>
    2261. 

  2261. <pre class="program"><strong>&lt;%
    2262. 

  2262.    var user = 'Erubis';
    2263. 

  2263.    var list = ['&lt;aaa&gt;', 'b&amp;b', '"ccc"'];
    2264. 

  2264.  %&gt;</strong>
    2265. 

  2265. &lt;html&gt;
    2266. 

  2266.  &lt;body&gt;
    2267. 

  2267.   &lt;p&gt;Hello <strong>&lt;%= user %&gt;</strong>!&lt;/p&gt;
    2268. 

  2268.   &lt;table&gt;
    2269. 

  2269.    &lt;tbody&gt;
    2270. 

  2270.     <strong>&lt;% var i; %&gt;</strong>
    2271. 

  2271.     <strong>&lt;% for (i = 0; i &lt; list.length; i++) { %&gt;</strong>
    2272. 

  2272.     &lt;tr bgcolor="<strong>&lt;%= i % 2 == 0 ? '#FFCCCC' : '#CCCCFF' %&gt;</strong>"&gt;
    2273. 

  2273.      &lt;td&gt;<strong>&lt;%= i + 1 %&gt;</strong>&lt;/td&gt;
    2274. 

  2274.      &lt;td&gt;<strong>&lt;%= list[i] %&gt;</strong>&lt;/td&gt;
    2275. 

  2275.     &lt;/tr&gt;
    2276. 

  2276.     <strong>&lt;% } %&gt;</strong>
    2277. 

  2277.    &lt;/tbody&gt;
    2278. 

  2278.   &lt;/table&gt;
    2279. 

  2279.  &lt;/body&gt;
    2280. 

  2280. &lt;/html&gt;
    2281. 

  2281. </pre>
    2282. 

  2282. <a name="example_js.result"></a>
    2283. 

  2283. <div class="terminal_caption">
    2284. 

  2284. compiled source code</div>
    2285. 

  2285. <pre class="terminal">$ erubis -l js example.ejs
    2286. 

  2286. var _buf = [];
    2287. 

  2287.    var user = 'Erubis';
    2288. 

  2288.    var list = ['&lt;aaa&gt;', 'b&amp;b', '"ccc"'];
    2289. 

  2289.  
    2290. 

  2290. _buf.push("&lt;html&gt;\n\
    2291. 

  2291.  &lt;body&gt;\n\
    2292. 

  2292.   &lt;p&gt;Hello "); _buf.push(user); _buf.push("!&lt;/p&gt;\n\
    2293. 

  2293.   &lt;table&gt;\n\
    2294. 

  2294.    &lt;tbody&gt;\n");
    2295. 

  2295.      var i; 
    2296. 

  2296.      for (i = 0; i &lt; list.length; i++) { 
    2297. 

  2297. _buf.push("    &lt;tr bgcolor=\""); _buf.push(i % 2 == 0 ? '#FFCCCC' : '#CCCCFF'); _buf.push("\"&gt;\n\
    2298. 

  2298.      &lt;td&gt;"); _buf.push(i + 1); _buf.push("&lt;/td&gt;\n\
    2299. 

  2299.      &lt;td&gt;"); _buf.push(list[i]); _buf.push("&lt;/td&gt;\n\
    2300. 

  2300.     &lt;/tr&gt;\n");
    2301. 

  2301.      } 
    2302. 

  2302. _buf.push("   &lt;/tbody&gt;\n\
    2303. 

  2303.   &lt;/table&gt;\n\
    2304. 

  2304.  &lt;/body&gt;\n\
    2305. 

  2305. &lt;/html&gt;\n");
    2306. 

  2306. document.write(_buf.join(""));
    2307. 

  2307. </pre>
    2308. 

  2308. <p>If command-line option '<code>--docwrite=false</code>' is specified,
    2309. 

  2309. '<code>_buf.join("");</code>' is used instead of '<code>document.write(_buf.join(""));</code>'.
    2310. 

  2310. This is useful when passing converted source code to eval() function in JavaScript.
    2311. 

  2311. </p>
    2312. 

  2312. <p>You can pass <code>:docwrite=&gt;false</code> to Erubis::Ejavascript.new() in your Ruby script.
    2313. 

  2313. </p>
    2314. 

  2314. <pre class="program">s = File.read('example.jshtml')
    2315. 

  2315. engine = Erubis::Ejavascript.new(s, <code>:docwrite=&gt;false</code>)
    2316. 

  2316. </pre>
    2317. 

  2317. <p>If you want to specify any JavaScript code, use '--postamble=...'.
    2318. 

  2318. </p>
    2319. 

  2319. <p>Notice that default value of 'docwrite' property will be false in the future release.
    2320. 

  2320. </p>
    2321. 

  2321. <br>
    2322. 

  2322. 

  2323. 

  2324. <br>
    2325. 

  2325. 

  2326. 

  2327. <a name="rails"></a>
    2328. 

  2328. <h2 class="section1">Ruby on Rails Support</h2>
    2329. 

  2329. <p>Erubis supports Ruby on Rails. 
    2330. 

  2330. This section describes how to use Erubis with Ruby on Rails.
    2331. 

  2331. </p>
    2332. 

  2332. <a name="rails-settings"></a>
    2333. 

  2333. <h3 class="section2">Settings</h3>
    2334. 

  2334. <p>Add the following code to your 'config/environment.rb' and restart web server.
    2335. 

  2335. This replaces ERB in Rails by Erubis entirely.
    2336. 

  2336. </p>
    2337. 

  2337. <div class="program_caption">
    2338. 

  2338. config/environment.rb</div>
    2339. 

  2339. <pre class="program">require 'erubis/helpers/rails_helper'
    2340. 

  2340. #Erubis::Helpers::RailsHelper.engine_class = Erubis::Eruby # or Erubis::FastEruby
    2341. 

  2341. #Erubis::Helpers::RailsHelper.init_properties = {}
    2342. 

  2342. #Erubis::Helpers::RailsHelper.show_src = nil
    2343. 

  2343. #Erubis::Helpers::RailsHelper.preprocessing = false
    2344. 

  2344. </pre>
    2345. 

  2345. <p>Options:
    2346. 

  2346. </p>
    2347. 

  2347. <dl class="dl2">
    2348. 

  2348. <dt class="dt2">
    2349. 

  2349. Erubis::Helpers::RailsHelper.engine_class (=Erubis::Eruby)</dt>
    2350. 

  2350. <dd class="dd2">
    2351. 

  2351. <p>	Erubis engine class (default Erubis::Eruby).
    2352. 

  2352. </p>
    2353. 

  2353. </dd>
    2354. 

  2354. <dt class="dt2">
    2355. 

  2355. Erubis::Helpers::RailsHelper.init_properties (={})</dt>
    2356. 

  2356. <dd class="dd2">
    2357. 

  2357. <p>	Optional arguments for Erubis::Eruby#initialize() method (default {}).
    2358. 

  2358. </p>
    2359. 

  2359. </dd>
    2360. 

  2360. <dt class="dt2">
    2361. 

  2361. Erubis::Helpers::RailsHelper.show_src (=nil)</dt>
    2362. 

  2362. <dd class="dd2">
    2363. 

  2363. <p>	Whether to print converted Ruby code into log file.
    2364. 

  2364. 	If true, Erubis prints coverted code into log file.
    2365. 

  2365. 	If false, Erubis doesn't.
    2366. 

  2366. 	If nil, Erubis prints when ENV['RAILS_ENV'] == 'development'.
    2367. 

  2367. 	Default is nil.
    2368. 

  2368. </p>
    2369. 

  2369. </dd>
    2370. 

  2370. <dt class="dt2">
    2371. 

  2371. Erubis::Helpers::RailsHelper.preprocessing (=false)</dt>
    2372. 

  2372. <dd class="dd2">
    2373. 

  2373. <p>	Enable preprocessing if true (default false).
    2374. 

  2374. </p>
    2375. 

  2375. </dd>
    2376. 

  2376. </dl>
    2377. 

  2377. <br>
    2378. 

  2378. 

  2379. 

  2380. <a name="rails-preprocessing"></a>
    2381. 

  2381. <h3 class="section2">Preprosessing</h3>
    2382. 

  2382. <p>Erubis supports preprocessing of template files.
    2383. 

  2383. Preprocessing make your Ruby on Rails application about 20-40 percent faster.
    2384. 

  2384. To enable preprocessing, set Erubis::Helpers::RailsHelper.preprocessing to true in your 'environment.rb' file.
    2385. 

  2385. </p>
    2386. 

  2386. <p>For example, assume the following template.
    2387. 

  2387. This is slow because link_to() method is called every time when template is rendered.
    2388. 

  2388. </p>
    2389. 

  2389. <pre class="program">&lt;%= link_to 'Create', :action=&gt;'create' %&gt;
    2390. 

  2390. </pre>
    2391. 

  2391. <p>The following is faster than the above, but not flexible because url is fixed.
    2392. 

  2392. </p>
    2393. 

  2393. <pre class="program">&lt;a href="/users/create"&gt;Create&lt;/a&gt;
    2394. 

  2394. </pre>
    2395. 

  2395. <p>Preprocessing solves this problem.
    2396. 

  2396. If you use '[%= %]' instead of '&lt;%= %&gt;', preprocessor evaluate it only once when template is loaded.
    2397. 

  2397. </p>
    2398. 

  2398. <pre class="program"><strong>[%= link_to 'Create', :action=&gt;'create'%]</strong>
    2399. 

  2399. </pre>
    2400. 

  2400. <p>The above is evaluated by preprocessor and replaced to the following code automatically.
    2401. 

  2401. </p>
    2402. 

  2402. <pre class="program">&lt;a href="/users/create"&gt;Create&lt;/a&gt;
    2403. 

  2403. </pre>
    2404. 

  2404. <p>Notice that this is done only once when template file is loaded.
    2405. 

  2405. It means that link_to() method is not called when template is rendered.
    2406. 

  2406. </p>
    2407. 

  2407. <p>If link_to() method have variable arguments, use <code>_?()</code> helper method.
    2408. 

  2408. </p>
    2409. 

  2409. <pre class="program">&lt;% for user in @users %&gt;
    2410. 

  2410. [%= link_to <strong>_?('user.name')</strong>, :action=&gt;'show', :id=&gt;<strong>_?('user.id')</strong> %]
    2411. 

  2411. &lt;% end %&gt;
    2412. 

  2412. </pre>
    2413. 

  2413. <p>The above is evaluated by preprocessor when template is loaded and expanded into the following code.
    2414. 

  2414. This will be much faster because link_to() method is not called when rendering.
    2415. 

  2415. </p>
    2416. 

  2416. <pre class="program">&lt;% for user in @users %&gt;
    2417. 

  2417. &lt;a href="/users/show/<strong>&lt;%=user.id%&gt;</strong>"&gt;<strong>&lt;%=user.name%&gt;</strong>&lt;/a&gt;
    2418. 

  2418. &lt;% end %&gt;
    2419. 

  2419. </pre>
    2420. 

  2420. <p>Preprocessing statement (<code>[% %]</code>) is also available as well as preprocessing expression (<code>[%= %]</code>).
    2421. 

  2421. </p>
    2422. 

  2422. <pre class="program">&lt;select name="state"&gt;
    2423. 

  2423.   &lt;option value=""&gt;-&lt;/option&gt;
    2424. 

  2424. <strong>[% for code in states.keys.sort %]</strong>
    2425. 

  2425.   &lt;option value="<strong>[%= code %]</strong>"&gt;<strong>[%= states[code] %]</strong>&lt;/option&gt;
    2426. 

  2426. <strong>[% end %]</strong>
    2427. 

  2427. &lt;/select&gt;
    2428. 

  2428. </pre>
    2429. 

  2429. <p>The above will be evaluated by preprocessor and expanded into the following when template is loaded.
    2430. 

  2430. In the result, rendering speed will be much faster because for-loop is not executed when rendering.
    2431. 

  2431. </p>
    2432. 

  2432. <pre class="program">&lt;select name="state"&gt;
    2433. 

  2433.   &lt;option value=""&gt;-&lt;/option&gt;
    2434. 

  2434.   &lt;option value="AK"&gt;Alaska&lt;/option&gt;
    2435. 

  2435.   &lt;option value="AL"&gt;Alabama&lt;/option&gt;
    2436. 

  2436.   &lt;option value="AR"&gt;Arkansas&lt;/option&gt;
    2437. 

  2437.   &lt;option value="AS"&gt;American Samoa&lt;/option&gt;
    2438. 

  2438.   &lt;option value="AZ"&gt;Arizona&lt;/option&gt;
    2439. 

  2439.   &lt;option value="CA"&gt;California&lt;/option&gt;
    2440. 

  2440.   &lt;option value="CO"&gt;Colorado&lt;/option&gt;
    2441. 

  2441.    ....
    2442. 

  2442. &lt;/select&gt;
    2443. 

  2443. </pre>
    2444. 

  2444. <p>Notice that it is not recommended to use preprocessing with tag helpers,
    2445. 

  2445. because tag helpers generate different html code when form parameter has errors or not.
    2446. 

  2446. </p>
    2447. 

  2447. <p>Helper methods of Ruby on Rails are divided into two groups.
    2448. 

  2448. </p>
    2449. 

  2449. <ul type="disc">
    2450. 

  2450. <li>link_to() or _() (method of gettext package) are not need to call for every time
    2451. 

  2451.    as template is rendered because it returns same value when same arguments are passed.
    2452. 

  2452.    These methods can be got faster by preprocessing.
    2453. 

  2453. </li>
    2454. 

  2454. <li>Tag helper methods should be called for every time as template is rendered
    2455. 

  2455.    because it may return differrent value even if the same arguments are passed.
    2456. 

  2456.    Preprocessing is not available with these methods.
    2457. 

  2457. </li>
    2458. 

  2458. </ul>
    2459. 

  2459. <p>In Ruby on Rails 2.0, <code>_?('user_id')</code> is OK but <code>_?('user.id')</code> is NG
    2460. 

  2460. because the latter contains period ('.') character.
    2461. 

  2461. </p>
    2462. 

  2462. <pre class="program">&lt;!-- NG in Rails 2.0, because _?('') contains period --&gt;
    2463. 

  2463. [%= link_to 'Edit', edit_user_path(<strong>_?('@user.id')</strong>) %]
    2464. 

  2464. [%= link_to 'Show', <strong>@user</strong> %]
    2465. 

  2465. [%= link_to 'Delete', <strong>@user</strong>, :confirm=&gt;'OK?', :method=&gt;:delete %]
    2466. 

  2466. 

  2467. &lt;!-- OK in Rails 2.0 --&gt;
    2468. 

  2468. <strong>&lt;%= user_id = @user.id %&gt;</strong>
    2469. 

  2469. [%= link_to 'Edit', edit_user_path(<strong>_?('user_id')</strong>) %]
    2470. 

  2470. [%= link_to 'Show', <strong>:action=&gt;'show', :id=&gt;_?('user_id')</strong> %]
    2471. 

  2471. [%= link_to 'Delete', <strong>{:action=&gt;'destroy', :id=&gt;_?('user_id')}</strong>,
    2472. 

  2472.                       {:confirm=&gt;'OK?', :method=&gt;:delete} %]
    2473. 

  2473. </pre>
    2474. 

  2474. <br>
    2475. 

  2475. 

  2476. 

  2477. <a name="rails-formhelpers"></a>
    2478. 

  2478. <h3 class="section2">Form Helpers for Preprocessing</h3>
    2479. 

  2479. <p><strong>(Experimental)</strong>
    2480. 

  2480. </p>
    2481. 

  2481. <p>Erubis provides form helper methods for preprocessing.
    2482. 

  2482. These are defined in 'erubis/helpers/rails_form_helper.rb'.
    2483. 

  2483. If you want to use it, require it and include Erubis::Helpers::RailsFormHelper in 'app/helpers/applition_helper.rb'
    2484. 

  2484. </p>
    2485. 

  2485. <div class="program_caption">
    2486. 

  2486. app/helpers/xxx_helper.rb</div>
    2487. 

  2487. <pre class="program">require 'erubis/helpers/rails_form_helper'
    2488. 

  2488. module ApplicationHelper
    2489. 

  2489.   include Erubis::Helpers::RailsFormHelper
    2490. 

  2490. end
    2491. 

  2491. </pre>
    2492. 

  2492. <p>Form helper methods defined in Erubis::Helpers::RailsFormHelper are named as 'pp_xxxx'
    2493. 

  2493. ('pp' represents preprocessing).
    2494. 

  2494. </p>
    2495. 

  2495. <p>Assume the following view template:
    2496. 

  2496. </p>
    2497. 

  2497. <div class="program_caption">
    2498. 

  2498. _form.rhtml</div>
    2499. 

  2499. <pre class="program"> &lt;p&gt;
    2500. 

  2500.   Name: &lt;%= text_field :user, :name %&gt;
    2501. 

  2501.  &lt;/p&gt;
    2502. 

  2502.  &lt;p&gt;
    2503. 

  2503.   Name: <strong>[%= pp_text_field :user, :name %]</strong>
    2504. 

  2504.  &lt;/p&gt;
    2505. 

  2505. </pre>
    2506. 

  2506. <p>Erubis preprocessor converts it to the following eRuby string:
    2507. 

  2507. </p>
    2508. 

  2508. <div class="program_caption">
    2509. 

  2509. preprocessed</div>
    2510. 

  2510. <pre class="program"> &lt;p&gt;
    2511. 

  2511.   Name: &lt;%= text_field :user, :name %&gt;
    2512. 

  2512.  &lt;/p&gt;
    2513. 

  2513.  &lt;p&gt;
    2514. 

  2514.   Name: <strong>&lt;input id="stock_name" name="stock[name]" size="30" type="text" value="&lt;%=h @stock.name%&gt;" /&gt;</strong>
    2515. 

  2515.  &lt;/p&gt;
    2516. 

  2516. </pre>
    2517. 

  2517. <p>Erubis converts it to the following Ruby code:
    2518. 

  2518. </p>
    2519. 

  2519. <div class="program_caption">
    2520. 

  2520. Ruby code</div>
    2521. 

  2521. <pre class="program"> _buf &lt;&lt; ' &lt;p&gt;
    2522. 

  2522.   Name: '; _buf &lt;&lt; ( text_field :stock, :name ).to_s; _buf &lt;&lt; '
    2523. 

  2523. '; _buf &lt;&lt; ' &lt;/p&gt;
    2524. 

  2524.  &lt;p&gt;
    2525. 

  2525.   Name: &lt;input id="stock_name" name="stock[name]" size="30" type="text" value="'; _buf &lt;&lt; (h @stock.name).to_s; _buf &lt;&lt; '" /&gt;
    2526. 

  2526.  &lt;/p&gt;
    2527. 

  2527. ';
    2528. 

  2528. </pre>
    2529. 

  2529. <p>The above Ruby code shows that text_field() is called everytime when rendering,
    2530. 

  2530. but pp_text_field() is called only once when template is loaded.
    2531. 

  2531. This means that pp_text_field() with preprocessing makes view layer very fast.
    2532. 

  2532. </p>
    2533. 

  2533. <p>Module Erubis::Helpers::RailsFormHelper defines the following form helper methods.
    2534. 

  2534. </p>
    2535. 

  2535. <ul type="disc">
    2536. 

  2536. <li>pp_render_partial(basename)
    2537. 

  2537. </li>
    2538. 

  2538. <li>pp_form_tag(url_for_options={}, options={}, *parameters_for_url, &amp;block)
    2539. 

  2539. </li>
    2540. 

  2540. <li>pp_text_field(object_name, method, options={})
    2541. 

  2541. </li>
    2542. 

  2542. <li>pp_password_field(object_name, method, options={})
    2543. 

  2543. </li>
    2544. 

  2544. <li>pp_hidden_field(object_name, method, options={})
    2545. 

  2545. </li>
    2546. 

  2546. <li>pp_file_field(object_name, method, options={})
    2547. 

  2547. </li>
    2548. 

  2548. <li>pp_text_area(object_name, method, options={})
    2549. 

  2549. </li>
    2550. 

  2550. <li>pp_check_box(object_name, method, options={}, checked_value="1", unchecked_value="0")
    2551. 

  2551. </li>
    2552. 

  2552. <li>pp_radio_button(object_name, method, tag_value, options={})
    2553. 

  2553. </li>
    2554. 

  2554. <li>pp_select(object, method, collection, options={}, html_options={})
    2555. 

  2555. </li>
    2556. 

  2556. <li>pp_collection_select(object, method, collection, value_method, text_method, options={}, html_options={})
    2557. 

  2557. </li>
    2558. 

  2558. <li>pp_country_select(object, method, priority_countries=nil, options={}, html_options={})
    2559. 

  2559. </li>
    2560. 

  2560. <li>pp_time_zone_select(object, method, priority_zones=nil, options={}, html_options={})
    2561. 

  2561. </li>
    2562. 

  2562. <li>pp_submit_tag(value="Save changes", options={})
    2563. 

  2563. </li>
    2564. 

  2564. <li>pp_image_submit_tag(source, options={})
    2565. 

  2565. </li>
    2566. 

  2566. </ul>
    2567. 

  2567. <p>Notice that pp_form_for() is not provided.
    2568. 

  2568. </p>
    2569. 

  2569. <p><span style="color:#FF0000">CAUTION:</span> These are experimental and may not work in Ruby on Rails 2.0.
    2570. 

  2570. </p>
    2571. 

  2571. <br>
    2572. 

  2572. 

  2573. 

  2574. <a name="rails-others"></a>
    2575. 

  2575. <h3 class="section2">Others</h3>
    2576. 

  2576. <ul type="disc">
    2577. 

  2577. <li>ActionView::Helpers::CaptureHelper#capture() and ActionView::Helpers::Texthelper#concat() are available.
    2578. 

  2578. </li>
    2579. 

  2579. </ul>
    2580. 

  2580. <ul type="disc">
    2581. 

  2581. <li>Form helper methods are not tested in Ruby on Rails 2.0.
    2582. 

  2582. </li>
    2583. 

  2583. </ul>
    2584. 

  2584. <ul type="disc">
    2585. 

  2585. <li>ERB::Util.h() is redefined if you require 'erubis/helpers/rails_helper.rb'.
    2586. 

  2586.    Original definition of ERB::Util.h() is the following and it is slow
    2587. 

  2587.    because it scans string four times.
    2588. 

  2588. <pre class="program"> def html_escape(s)
    2589. 

  2589.    s.to_s.gsub(/&amp;/, "&amp;amp;").gsub(/\"/, "&amp;quot;").gsub(/&gt;/, "&amp;gt;").gsub(/&lt;/, "&amp;lt;")
    2590. 

  2590.  end
    2591. 

  2591.  alias h html_escape
    2592. 

  2592. </pre>
    2593. 

  2593. <p>   New definition in 'erubis/helpers/rails_helper.rb' is faster than the above
    2594. 

  2594.    because it scans string only once.
    2595. 

  2595. </p>
    2596. 

  2596. <pre class="program"> ESCAPE_TABLE = { '&amp;'=&gt;'&amp;amp;', '&lt;'=&gt;'&amp;lt;', '&gt;'=&gt;'&amp;gt;', '"'=&gt;'&amp;quot;', "'"=&gt;'&amp;#039;', }
    2597. 

  2597.  def h(value)
    2598. 

  2598.    value.to_s.gsub(/[&amp;&lt;&gt;"]/) { |s| ESCAPE_TABLE[s] }
    2599. 

  2599.  end
    2600. 

  2600. </pre>
    2601. 

  2601. <p>   Notice that the new definition may be slow if string contains
    2602. 

  2602.    many '&lt; &gt; &amp; "' characters because block is call many time.
    2603. 

  2603.    You should use ERB::Util.html_hscape() if string contains a lot of '&lt; &gt; &amp; "'
    2604. 

  2604.    characters.
    2605. 

  2605. </p>
    2606. 

  2606. </li>
    2607. 

  2607. </ul>
    2608. 

  2608. <br>
    2609. 

  2609. 

  2610. 

  2611. <br>
    2612. 

  2612. 

  2613. 

  2614. <a name="topics"></a>
    2615. 

  2615. <h2 class="section1">Other Topics</h2>
    2616. 

  2616. <a name="'&lt;%= =%&gt;' and '&lt;%= -%&gt;'"></a>
    2617. 

  2617. <h3 class="section2">'&lt;%= =%&gt;' and '&lt;%= -%&gt;'</h3>
    2618. 

  2618. <p>Since 2.6.0, '&lt;%= -%&gt;' remove tail spaces and newline.
    2619. 

  2619. This is for compatibiliy with ERB when trim mode is '-'.
    2620. 

  2620. '&lt;%= =%&gt;' also removes tail spaces and newlines, and this is
    2621. 

  2621. Erubis-original enhancement (cooler than '&lt;%= -%&gt;', isn't it?).
    2622. 

  2622. </p>
    2623. 

  2623. <a name="tailnewline.rhtml.comment_filter"></a>
    2624. 

  2624. <div class="program_caption">
    2625. 

  2625. tailnewline.rhtml</div>
    2626. 

  2626. <pre class="program">&lt;div&gt;
    2627. 

  2627. &lt;%= @var -%&gt;          # or &lt;%= @var =%&gt;
    2628. 

  2628. &lt;/div&gt;
    2629. 

  2629. </pre>
    2630. 

  2630. <div class="terminal_caption">
    2631. 

  2631. result (version 2.5.0):</div>
    2632. 

  2632. <pre class="terminal">$ erubis -c '{var: "AAA\n"}' tailnewline.rhtml
    2633. 

  2633. &lt;div&gt;
    2634. 

  2634. AAA
    2635. 

  2635. 

  2636. &lt;/div&gt;
    2637. 

  2637. </pre>
    2638. 

  2638. <a name="tail_260.result"></a>
    2639. 

  2639. <div class="terminal_caption">
    2640. 

  2640. result (version 2.6.0):</div>
    2641. 

  2641. <pre class="terminal">$ erubis -c '{var: "AAA\n"}' tailnewline.rhtml
    2642. 

  2642. &lt;div&gt;
    2643. 

  2643. AAA
    2644. 

  2644. &lt;/div&gt;
    2645. 

  2645. </pre>
    2646. 

  2646. <br>
    2647. 

  2647. 

  2648. 

  2649. <a name="'&lt;%% %&gt;' and '&lt;%%= %&gt;'"></a>
    2650. 

  2650. <h3 class="section2">'&lt;%% %&gt;' and '&lt;%%= %&gt;'</h3>
    2651. 

  2651. <p>Since 2.6.0, '&lt;%% %&gt;' and '&lt;%%= %&gt;' are converted into '&lt;% %&gt;' and '&lt;%= %&gt;' respectively.
    2652. 

  2652. This is for compatibility with ERB.
    2653. 

  2653. </p>
    2654. 

  2654. <div class="program_caption">
    2655. 

  2655. doublepercent.rhtml:</div>
    2656. 

  2656. <pre class="program">&lt;ul&gt;
    2657. 

  2657. &lt;%% for item in @list %&gt;
    2658. 

  2658.   &lt;li&gt;&lt;%%= item %&gt;&lt;/li&gt;
    2659. 

  2659. &lt;%% end %&gt;
    2660. 

  2660. &lt;/ul&gt;
    2661. 

  2661. </pre>
    2662. 

  2662. <div class="terminal_caption">
    2663. 

  2663. result:</div>
    2664. 

  2664. <pre class="terminal">$ erubis doublepercent.rhtml
    2665. 

  2665. &lt;ul&gt;
    2666. 

  2666. &lt;% for item in @list %&gt;
    2667. 

  2667.   &lt;li&gt;&lt;%= item %&gt;&lt;/li&gt;
    2668. 

  2668. &lt;% end %&gt;
    2669. 

  2669. &lt;/ul&gt;
    2670. 

  2670. </pre>
    2671. 

  2671. <br>
    2672. 

  2672. 

  2673. 

  2674. <a name="topics-context-vs-binding"></a>
    2675. 

  2675. <h3 class="section2">evaluate(context) v.s. result(binding)</h3>
    2676. 

  2676. <p>It is recommended to use 'Erubis::Eruby#evaluate(context)' instead of 'Erubis::Eruby#result(binding)' because Ruby's Binding object has some problems.
    2677. 

  2677. </p>
    2678. 

  2678. <ul type="disc">
    2679. 

  2679. <li>It is not able to specify variables to use.
    2680. 

  2680.    Using binding() method, all of local variables are passed to templates.
    2681. 

  2681. </li>
    2682. 

  2682. <li>Changing local variables in templates may affect to varialbes in main program.
    2683. 

  2683.    If you assign '10' to local variable 'x' in templates, it may change variable 'x' in main program unintendedly.
    2684. 

  2684. </li>
    2685. 

  2685. </ul>
    2686. 

  2686. <p>The following example shows that assignment of some values into variable 'x' in templates affect to local variable 'x' in main program unintendedly.
    2687. 

  2687. </p>
    2688. 

  2688. <a name="template1.rhtml"></a>
    2689. 

  2689. <div class="program_caption">
    2690. 

  2690. template1.rhtml (intended to be passed 'items' from main program)</div>
    2691. 

  2691. <pre class="program">&lt;% for <strong>x</strong> in <strong>items</strong> %&gt;
    2692. 

  2692. item = &lt;%= x %&gt;
    2693. 

  2693. &lt;% end %&gt;
    2694. 

  2694. ** debug: local variables=&lt;%= local_variables().inspect() %&gt;
    2695. 

  2695. </pre>
    2696. 

  2696. <a name="main_program1.rb"></a>
    2697. 

  2697. <div class="program_caption">
    2698. 

  2698. main_program1.rb (intended to pass 'items' to template)</div>
    2699. 

  2699. <pre class="program">require 'erubis'
    2700. 

  2700. eruby = Erubis::Eruby.new(File.read('template1.rhtml'))
    2701. 

  2701. items = ['foo', 'bar', 'baz']
    2702. 

  2702. x = 1
    2703. 

  2703. ## local variable 'x' and 'eruby' are passed to template as well as 'items'!
    2704. 

  2704. print <strong>eruby.result(binding())</strong>    
    2705. 

  2705. ## local variable 'x' is changed unintendedly because it is changed in template!
    2706. 

  2706. puts "** debug: x=#{x.inspect}"  #=&gt; "baz"
    2707. 

  2707. </pre>
    2708. 

  2708. <a name="main_program1.result"></a>
    2709. 

  2709. <div class="terminal_caption">
    2710. 

  2710. Result:</div>
    2711. 

  2711. <pre class="terminal">$ ruby main_program1.rb
    2712. 

  2712. item = foo
    2713. 

  2713. item = bar
    2714. 

  2714. item = baz
    2715. 

  2715. ** debug: local variables=["eruby", "items", "x", "_buf"]
    2716. 

  2716. ** debug: x="baz"
    2717. 

  2717. </pre>
    2718. 

  2718. <p>This problem is caused because Ruby's Binding class is poor to use in template engine.
    2719. 

  2719. Binding class should support the following features.
    2720. 

  2720. </p>
    2721. 

  2721. <pre class="program">b = Binding.new     # create empty Binding object
    2722. 

  2722. b['x'] = 1          # set local variables using binding object
    2723. 

  2723. </pre>
    2724. 

  2724. <p>But the above features are not implemented in Ruby.
    2725. 

  2725. </p>
    2726. 

  2726. <p>A pragmatic solution is to use 'Erubis::Eruby#evaluate(context)' instead of 'Erubis::Eruby#result(binding)'.
    2727. 

  2727. 'evaluate(context)' uses Erubis::Context object and instance variables instead of Binding object and local variables.
    2728. 

  2728. </p>
    2729. 

  2729. <a name="template2.rhtml"></a>
    2730. 

  2730. <div class="program_caption">
    2731. 

  2731. template2.rhtml (intended to be passed '@items' from main program)</div>
    2732. 

  2732. <pre class="program">&lt;% for <strong>x</strong> in <strong>@items</strong> %&gt;
    2733. 

  2733. item = &lt;%= x %&gt;
    2734. 

  2734. &lt;% end %&gt;
    2735. 

  2735. ** debug: local variables=&lt;%= local_variables().inspect() %&gt;
    2736. 

  2736. </pre>
    2737. 

  2737. <a name="main_program2.rb"></a>
    2738. 

  2738. <div class="program_caption">
    2739. 

  2739. main_program2.rb (intended to pass '@items' to template)</div>
    2740. 

  2740. <pre class="program">require 'erubis'
    2741. 

  2741. eruby = Erubis::Eruby.new(File.read('template2.rhtml'))
    2742. 

  2742. items = ['foo', 'bar', 'baz']
    2743. 

  2743. x = 1
    2744. 

  2744. ## only 'items' are passed to template
    2745. 

  2745. print <strong>eruby.evaluate(:items=&gt;items)</strong>    
    2746. 

  2746. ## local variable 'x' is not changed!
    2747. 

  2747. puts "** debug: x=#{x.inspect}"  #=&gt; 1
    2748. 

  2748. </pre>
    2749. 

  2749. <a name="main_program2.result"></a>
    2750. 

  2750. <div class="terminal_caption">
    2751. 

  2751. Result:</div>
    2752. 

  2752. <pre class="terminal">$ ruby main_program2.rb
    2753. 

  2753. item = foo
    2754. 

  2754. item = bar
    2755. 

  2755. item = baz
    2756. 

  2756. ** debug: local variables=["_context", "x", "_buf"]
    2757. 

  2757. ** debug: x=1
    2758. 

  2758. </pre>
    2759. 

  2759. <br>
    2760. 

  2760. 

  2761. 

  2762. <a name="topics-fasteruby"></a>
    2763. 

  2763. <h3 class="section2">Class Erubis::FastEruby</h3>
    2764. 

  2764. <p>[experimental]
    2765. 

  2765. </p>
    2766. 

  2766. <p>Erubis provides Erubis::FastEruby class which includes <a href="#interpolation-enhancer">InterpolationEnhancer</a> and <a href="#topics-benchmark">works faster than Erubis::Eruby class</a>.
    2767. 

  2767. If you desire more speed, try Erubis::FastEruby class.
    2768. 

  2768. </p>
    2769. 

  2769. <a name="fasteruby.rhtml"></a>
    2770. 

  2770. <div class="program_caption">
    2771. 

  2771. File 'fasteruby.rhtml':</div>
    2772. 

  2772. <pre class="program">&lt;html&gt;
    2773. 

  2773.   &lt;body&gt;
    2774. 

  2774.     &lt;h1&gt;&lt;%== @title %&gt;&lt;/h1&gt;
    2775. 

  2775.     &lt;table&gt;
    2776. 

  2776. &lt;% i = 0 %&gt;
    2777. 

  2777. &lt;% for item in @list %&gt;
    2778. 

  2778. &lt;%   i += 1 %&gt;
    2779. 

  2779.       &lt;tr&gt;
    2780. 

  2780.         &lt;td&gt;&lt;%= i %&gt;&lt;/td&gt;
    2781. 

  2781.         &lt;td&gt;&lt;%== item %&gt;&lt;/td&gt;
    2782. 

  2782.       &lt;/tr&gt;
    2783. 

  2783. &lt;% end %&gt;
    2784. 

  2784.     &lt;/table&gt;
    2785. 

  2785.   &lt;/body&gt;
    2786. 

  2786. &lt;/html&gt;
    2787. 

  2787. </pre>
    2788. 

  2788. <a name="fasteruby.rb"></a>
    2789. 

  2789. <div class="program_caption">
    2790. 

  2790. File 'fasteruby.rb':</div>
    2791. 

  2791. <pre class="program">require 'erubis'
    2792. 

  2792. input = File.read('fasteruby.rhtml')
    2793. 

  2793. eruby = <strong>Erubis::FastEruby.new(input)</strong>    # create Eruby object
    2794. 

  2794. 

  2795. puts "---------- script source ---"
    2796. 

  2796. puts eruby.src
    2797. 

  2797. 

  2798. puts "---------- result ----------"
    2799. 

  2799. context = { :title=&gt;'Example', :list=&gt;['aaa', 'bbb', 'ccc'] }
    2800. 

  2800. output = eruby.evaluate(context)
    2801. 

  2801. print output
    2802. 

  2802. </pre>
    2803. 

  2803. <a name="fasteruby.result"></a>
    2804. 

  2804. <div class="terminal_caption">
    2805. 

  2805. output</div>
    2806. 

  2806. <pre class="terminal">$ ruby fasteruby.rb
    2807. 

  2807. ---------- script source ---
    2808. 

  2808. _buf = ''; _buf &lt;&lt; <strong>%Q`</strong>&lt;html&gt;
    2809. 

  2809.   &lt;body&gt;
    2810. 

  2810.     &lt;h1&gt;<strong>#{Erubis::XmlHelper.escape_xml( @title )}</strong>&lt;/h1&gt;
    2811. 

  2811.     &lt;table&gt;\n<strong>`</strong>
    2812. 

  2812.  i = 0 
    2813. 

  2813.  for item in @list 
    2814. 

  2814.    i += 1 
    2815. 

  2815.  _buf &lt;&lt; <strong>%Q`</strong>      &lt;tr&gt;
    2816. 

  2816.         &lt;td&gt;<strong>#{ i }</strong>&lt;/td&gt;
    2817. 

  2817.         &lt;td&gt;<strong>#{Erubis::XmlHelper.escape_xml( item )}</strong>&lt;/td&gt;
    2818. 

  2818.       &lt;/tr&gt;\n<strong>`</strong>
    2819. 

  2819.  end 
    2820. 

  2820.  _buf &lt;&lt; <strong>%Q`</strong>    &lt;/table&gt;
    2821. 

  2821.   &lt;/body&gt;
    2822. 

  2822. &lt;/html&gt;\n<strong>`</strong>
    2823. 

  2823. _buf.to_s
    2824. 

  2824. ---------- result ----------
    2825. 

  2825. &lt;html&gt;
    2826. 

  2826.   &lt;body&gt;
    2827. 

  2827.     &lt;h1&gt;Example&lt;/h1&gt;
    2828. 

  2828.     &lt;table&gt;
    2829. 

  2829.       &lt;tr&gt;
    2830. 

  2830.         &lt;td&gt;1&lt;/td&gt;
    2831. 

  2831.         &lt;td&gt;aaa&lt;/td&gt;
    2832. 

  2832.       &lt;/tr&gt;
    2833. 

  2833.       &lt;tr&gt;
    2834. 

  2834.         &lt;td&gt;2&lt;/td&gt;
    2835. 

  2835.         &lt;td&gt;bbb&lt;/td&gt;
    2836. 

  2836.       &lt;/tr&gt;
    2837. 

  2837.       &lt;tr&gt;
    2838. 

  2838.         &lt;td&gt;3&lt;/td&gt;
    2839. 

  2839.         &lt;td&gt;ccc&lt;/td&gt;
    2840. 

  2840.       &lt;/tr&gt;
    2841. 

  2841.     &lt;/table&gt;
    2842. 

  2842.   &lt;/body&gt;
    2843. 

  2843. &lt;/html&gt;
    2844. 

  2844. </pre>
    2845. 

  2845. <br>
    2846. 

  2846. 

  2847. 

  2848. <a name="topics-syntax"></a>
    2849. 

  2849. <h3 class="section2">Syntax Checking</h3>
    2850. 

  2850. <p>Command-line option '-z' checks syntax. It is similar to 'erubis -x file.rhtml | ruby -wc', but it can take several file names.
    2851. 

  2851. </p>
    2852. 

  2852. <div class="terminal_caption">
    2853. 

  2853. example of command-line option '-z'</div>
    2854. 

  2854. <pre class="terminal">$ erubis <strong>-z</strong> app/views/*/*.rhtml
    2855. 

  2855. Syntax OK
    2856. 

  2856. </pre>
    2857. 

  2857. <br>
    2858. 

    2859. 

    2860. 

  2860. <a name="topics-caching"></a>
    2861. 

  2861. <h3 class="section2">File Caching</h3>
    2862. 

  2862. <p>Erubis::Eruby.load_file(filename) convert file into Ruby script and return Eruby object.
    2863. 

  2863. In addition, it caches converted Ruby script into cache file (filename + '.cache') if cache file is old or not exist.
    2864. 

  2864. If cache file exists and is newer than eruby file, Erubis::Eruby.load_file() loads cache file.
    2865. 

  2865. </p>
    2866. 

  2866. <div class="program_caption">
    2867. 

  2867. example of Erubis::Eruby.load_file()</div>
    2868. 

  2868. <pre class="program">require 'erubis'
    2869. 

  2869. filename = 'example.rhtml'
    2870. 

  2870. eruby = <strong>Erubis::Eruby.load_file(filename)</strong>
    2871. 

  2871. cachename = filename + '.cache'
    2872. 

  2872. if test(?f, cachename)
    2873. 

  2873.   puts "*** cache file '#{cachename}' created."
    2874. 

  2874. end
    2875. 

  2875. </pre>
    2876. 

  2876. <p>Since 2.6.0, it is able to specify cache filename.
    2877. 

  2877. </p>
    2878. 

  2878. <div class="program_caption">
    2879. 

  2879. specify cache filename.</div>
    2880. 

  2880. <pre class="program">filename = 'example.rhtml'
    2881. 

  2881. eruby = Erubis::Eruby.load_file(filename, :cachename=&gt;filename+'.cache')
    2882. 

  2882. </pre>
    2883. 

  2883. <p>Caching makes Erubis about 40-50 percent faster than no-caching.
    2884. 

  2884. See <a href="#topics-benchmark">benchmark</a> for details.
    2885. 

  2885. </p>
    2886. 

  2886. <br>
    2887. 

    2888. 

    2889. 

  2889. <a name="topics-tinyeruby"></a>
    2890. 

  2890. <h3 class="section2">Erubis::TinyEruby class</h3>
    2891. 

  2891. <p>Erubis::TinyEruby class in 'erubis/tiny.rb' is the smallest implementation of eRuby.
    2892. 

  2892. If you don't need any enhancements of Erubis and only require simple eRuby implementation,
    2893. 

  2893. try Erubis::TinyEruby class.
    2894. 

  2894. </p>
    2895. 

  2895. <br>
    2896. 

    2897. 

    2898. 

  2898. <a name="topics-php"></a>
    2899. 

  2899. <h3 class="section2">NoTextEnhancer and NoCodeEnhancer in PHP</h3>
    2900. 

  2900. <p>NoTextEnhancer and NoCodEnahncer are quite useful not only for eRuby but also for PHP.
    2901. 

  2901. The former "drops" HTML text and show up embedded Ruby/PHP code
    2902. 

  2902. and the latter drops embedded Ruby/PHP code and leave HTML text.
    2903. 

  2903. </p>
    2904. 

  2904. <p>For example, see the following PHP script.
    2905. 

  2905. </p>
    2906. 

  2906. <a name="notext-example.php"></a>
    2907. 

  2907. <div class="program_caption">
    2908. 

  2908. notext-example.php</div>
    2909. 

  2909. <pre class="program">&lt;html&gt;
    2910. 

  2910.   &lt;body&gt;
    2911. 

  2911.     &lt;h3&gt;List&lt;/h3&gt;
    2912. 

  2912.     &lt;?php if (!$list || count($list) == 0) { ?&gt;
    2913. 

  2913.     &lt;p&gt;not found.&lt;/p&gt;
    2914. 

  2914.     &lt;?php } else { ?&gt;
    2915. 

  2915.     &lt;table&gt;
    2916. 

  2916.       &lt;tbody&gt;
    2917. 

  2917.         &lt;?php $i = 0; ?&gt;
    2918. 

  2918.         &lt;?php foreach ($list as $item) { ?&gt;
    2919. 

  2919.         &lt;tr bgcolor="&lt;?php echo ++$i % 2 == 1 ? '#FFCCCC' : '#CCCCFF'; ?&gt;"&gt;
    2920. 

  2920.           &lt;td&gt;&lt;?php echo $item; ?&gt;&lt;/td&gt;
    2921. 

  2921.         &lt;/tr&gt;
    2922. 

  2922.         &lt;?php } ?&gt;
    2923. 

  2923.       &lt;/tbody&gt;
    2924. 

  2924.     &lt;/table&gt;
    2925. 

  2925.     &lt;?php } ?&gt;
    2926. 

  2926.   &lt;/body&gt;
    2927. 

  2927. &lt;/html&gt;
    2928. 

  2928. </pre>
    2929. 

  2929. <p>This is complex because PHP code and HTML document are mixed.
    2930. 

  2930. NoTextEnhancer can separate PHP code from HTML document.
    2931. 

  2931. </p>
    2932. 

  2932. <a name="notext-php.result"></a>
    2933. 

  2933. <div class="terminal_caption">
    2934. 

  2934. example of using NoTextEnhancer with PHP file</div>
    2935. 

  2935. <pre class="terminal">$ erubis -l php --pi=php -N -E NoText --trim=false notext-example.php
    2936. 

  2936.     1:  
    2937. 

  2937.     2:  
    2938. 

  2938.     3:  
    2939. 

  2939.     4:      &lt;?php if (!$list || count($list) == 0) { ?&gt;
    2940. 

  2940.     5:  
    2941. 

  2941.     6:      &lt;?php } else { ?&gt;
    2942. 

  2942.     7:  
    2943. 

  2943.     8:  
    2944. 

  2944.     9:          &lt;?php $i = 0; ?&gt;
    2945. 

  2945.    10:          &lt;?php foreach ($list as $item) { ?&gt;
    2946. 

  2946.    11:                       &lt;?php echo ++$i % 2 == 1 ? '#FFCCCC' : '#CCCCFF'; ?&gt;
    2947. 

  2947.    12:                &lt;?php echo $item; ?&gt;
    2948. 

  2948.    13:  
    2949. 

  2949.    14:          &lt;?php } ?&gt;
    2950. 

  2950.    15:  
    2951. 

  2951.    16:  
    2952. 

  2952.    17:      &lt;?php } ?&gt;
    2953. 

  2953.    18:  
    2954. 

  2954.    19:  
    2955. 

  2955. </pre>
    2956. 

  2956. <p>In the same way, NoCodeEnhancer can extract HTML tags.
    2957. 

  2957. </p>
    2958. 

  2958. <a name="nocode-php.result"></a>
    2959. 

  2959. <div class="terminal_caption">
    2960. 

  2960. example of using NoCodeEnhancer with PHP file</div>
    2961. 

  2961. <pre class="terminal">$ erubis -l php --pi=php -N -E NoCode --trim=false notext-example.php
    2962. 

  2962.     1:  &lt;html&gt;
    2963. 

  2963.     2:    &lt;body&gt;
    2964. 

  2964.     3:      &lt;h3&gt;List&lt;/h3&gt;
    2965. 

  2965.     4:      
    2966. 

  2966.     5:      &lt;p&gt;not found.&lt;/p&gt;
    2967. 

  2967.     6:      
    2968. 

  2968.     7:      &lt;table&gt;
    2969. 

  2969.     8:        &lt;tbody&gt;
    2970. 

  2970.     9:          
    2971. 

  2971.    10:          
    2972. 

  2972.    11:          &lt;tr bgcolor=""&gt;
    2973. 

  2973.    12:            &lt;td&gt;&lt;/td&gt;
    2974. 

  2974.    13:          &lt;/tr&gt;
    2975. 

  2975.    14:          
    2976. 

  2976.    15:        &lt;/tbody&gt;
    2977. 

  2977.    16:      &lt;/table&gt;
    2978. 

  2978.    17:      
    2979. 

  2979.    18:    &lt;/body&gt;
    2980. 

  2980.    19:  &lt;/html&gt;
    2981. 

  2981. </pre>
    2982. 

  2982. <br>
    2983. 

    2984. 

    2985. 

  2985. <a name="topcs-modruby"></a>
    2986. 

  2986. <h3 class="section2">Helper Class for mod_ruby</h3>
    2987. 

  2987. <p>Thanks Andrew R Jackson, he developed 'erubis-run.rb' which enables you to use Erubis with mod_ruby.
    2988. 

  2988. </p>
    2989. 

  2989. <ol type="1">
    2990. 

  2990. <li>Copy 'erubis-2.6.6/contrib/erubis-run.rb' to the 'RUBYLIBDIR/apache' directory (for example '/usr/local/lib/ruby/1.8/apache') which contains 'ruby-run.rb', 'eruby-run.rb', and so on.
    2991. 

  2991. <pre class="terminal">$ cd erubis-2.6.6/
    2992. 

  2992. $ sudo copy contrib/erubis-run.rb /usr/local/lib/ruby/1.8/apache/
    2993. 

  2993. </pre>
    2994. 

  2994. </li>
    2995. 

  2995. <li>Add the following example to your 'httpd.conf' (for example '/usr/local/apache2/conf/httpd.conf')
    2996. 

  2996. <pre class="program">LoadModule ruby_module modules/mod_ruby.so
    2997. 

  2997. &lt;IfModule mod_ruby.c&gt;
    2998. 

  2998.   RubyRequire apache/ruby-run
    2999. 

  2999.   RubyRequire apache/eruby-run
    3000. 

  3000.   RubyRequire apache/erubis-run
    3001. 

  3001.   &lt;Location /erubis&gt;
    3002. 

  3002.     SetHandler ruby-object
    3003. 

  3003.     RubyHandler Apache::ErubisRun.instance
    3004. 

  3004.   &lt;/Location&gt;
    3005. 

  3005.   &lt;Files *.rhtml&gt;
    3006. 

  3006.     SetHandler ruby-object
    3007. 

  3007.     RubyHandler Apache::ErubisRun.instance
    3008. 

  3008.   &lt;/Files&gt;
    3009. 

  3009. &lt;/IfModule&gt;
    3010. 

  3010. </pre>
    3011. 

  3011. </li>
    3012. 

  3012. <li>Restart Apache web server.
    3013. 

  3013. <pre class="terminal">$ sudo /usr/local/apache2/bin/apachectl stop
    3014. 

  3014. $ sudo /usr/local/apache2/bin/apachectl start
    3015. 

  3015. </pre>
    3016. 

  3016. </li>
    3017. 

  3017. <li>Create *.rhtml file, for example:
    3018. 

  3018. <pre class="program">&lt;html&gt;
    3019. 

  3019.  &lt;body&gt;
    3020. 

  3020.   Now is &lt;%= Time.now %&gt;
    3021. 

  3021.   Erubis version is &lt;%= Erubis::VERSION %&gt;
    3022. 

  3022.  &lt;/body&gt;
    3023. 

  3023. &lt;/html&gt;
    3024. 

  3024. </pre>
    3025. 

  3025. </li>
    3026. 

  3026. <li>Change mode of your directory to be writable by web server process.
    3027. 

  3027. <pre class="terminal">$ cd /usr/local/apache2/htdocs/erubis
    3028. 

  3028. $ sudo chgrp daemon .
    3029. 

  3029. $ sudo chmod 775 .
    3030. 

  3030. </pre>
    3031. 

  3031. </li>
    3032. 

  3032. <li>Access the *.rhtml file and you'll get the web page.
    3033. 

  3033. </li>
    3034. 

  3034. </ol>
    3035. 

  3035. <p>You must set your directories to be writable by web server process, because
    3036. 

  3036. Apache::ErubisRun calls Erubis::Eruby.load_file() internally which creates cache files
    3037. 

  3037. in the same directory in which '*.rhtml' file exists.
    3038. 

  3038. </p>
    3039. 

  3039. <br>
    3040. 

    3041. 

    3042. 

  3042. <a name="topics-defmethod"></a>
    3043. 

  3043. <h3 class="section2">Define method</h3>
    3044. 

  3044. <p>Erubis::Eruby#def_method() defines instance method or singleton method.
    3045. 

  3045. </p>
    3046. 

  3046. <a name="def_method.rb"></a>
    3047. 

  3047. <pre class="program">require 'erubis'
    3048. 

  3048. s = "hello &lt;%= name %&gt;"
    3049. 

  3049. eruby = Erubis::Eruby.new(s)
    3050. 

  3050. filename = 'hello.rhtml'
    3051. 

    3052. 

  3052. ## define instance method to Dummy class (or module)
    3053. 

  3053. class Dummy; end
    3054. 

  3054. <strong>eruby.def_method(Dummy, 'render(name)', filename)</strong>  # filename is optional
    3055. 

  3055. p Dummy.new.render('world')    #=&gt; "hello world"
    3056. 

    3057. 

  3057. ## define singleton method to dummy object
    3058. 

  3058. obj = Object.new
    3059. 

  3059. <strong>eruby.def_method(obj, 'render(name)', filename)</strong>    # filename is optional
    3060. 

  3060. p obj.render('world')          #=&gt; "hello world"
    3061. 

  3061. </pre>
    3062. 

  3062. <br>
    3063. 

    3064. 

    3065. 

  3065. <a name="topics-benchmark"></a>
    3066. 

  3066. <h3 class="section2">Benchmark</h3>
    3067. 

  3067. <p>A benchmark script is included in Erubis package at 'erubis-2.6.6/benchark/' directory.
    3068. 

  3068. Here is an example result of benchmark.
    3069. 

  3069. </p>
    3070. 

  3070. <div class="terminal_caption">
    3071. 

  3071. MacOS X 10.4 Tiger, Intel CoreDuo 1.83GHz, Ruby1.8.6, eruby1.0.5, gcc4.0.1</div>
    3072. 

  3072. <pre class="terminal">$ cd erubis-2.6.6/benchmark/
    3073. 

  3073. $ ruby bench.rb -n 10000 -m execute
    3074. 

  3074. *** ntimes=10000, testmode=execute
    3075. 

  3075.                                     user     system      total        real
    3076. 

  3076. eruby                          12.720000   0.240000  <strong>12.960000</strong> ( 12.971888)
    3077. 

  3077. ERB                            36.760000   0.350000  <strong>37.110000</strong> ( 37.112019)
    3078. 

  3078. ERB(cached)                    11.990000   0.440000  <strong>12.430000</strong> ( 12.430375)
    3079. 

  3079. Erubis::Eruby                  10.840000   0.300000  <strong>11.140000</strong> ( 11.144426)
    3080. 

  3080. Erubis::Eruby(cached)           7.540000   0.410000   <strong>7.950000</strong> (  7.969305)
    3081. 

  3081. Erubis::FastEruby              10.440000   0.300000  <strong>10.740000</strong> ( 10.737808)
    3082. 

  3082. Erubis::FastEruby(cached)       6.940000   0.410000   <strong>7.350000</strong> (  7.353666)
    3083. 

  3083. Erubis::TinyEruby               9.550000   0.290000   9.840000 (  9.851729)
    3084. 

  3084. Erubis::ArrayBufferEruby       11.010000   0.300000  11.310000 ( 11.314339)
    3085. 

  3085. Erubis::PrintOutEruby          11.640000   0.290000  11.930000 ( 11.942141)
    3086. 

  3086. Erubis::StdoutEruby            11.590000   0.300000  11.890000 ( 11.886512)
    3087. 

  3087. </pre>
    3088. 

  3088. <p>This shows that...
    3089. 

  3089. </p>
    3090. 

  3090. <ul type="disc">
    3091. 

  3091. <li>Erubis::Eruby runs more than 10 percent faster than eruby.
    3092. 

  3092. </li>
    3093. 

  3093. <li>Erubis::Eruby runs about 3 times faster than ERB.
    3094. 

  3094. </li>
    3095. 

  3095. <li>Caching (by Erubis::Eruby.load_file()) makes Erubis about 40-50 percent faster.
    3096. 

  3096. </li>
    3097. 

  3097. <li>Erubis::FastEruby is a litte faster than Erubis::Eruby.
    3098. 

  3098. </li>
    3099. 

  3099. <li>Array buffer (ArrayBufferEnhancer) is a little slower than string buffer (StringBufferEnhancer which Erubis::Eruby includes)
    3100. 

  3100. </li>
    3101. 

  3101. <li>$stdout and print() make Erubis a little slower.
    3102. 

  3102. </li>
    3103. 

  3103. <li>Erubis::TinyEruby (at 'erubis/tiny.rb') is the fastest in all eRuby implementations when no caching.
    3104. 

  3104. </li>
    3105. 

  3105. </ul>
    3106. 

  3106. <p>Escaping HTML characters (such as '&lt; &gt; &amp; "') makes Erubis more faster than eruby and ERB,
    3107. 

  3107. because Erubis::XmlHelper#escape_xml() works faster than CGI.escapeHTML() and ERB::Util#h().
    3108. 

  3108. The following shows that Erubis runs more than 40 percent (when no-cached) or 90 percent (when cached) faster than eruby if HTML characters are escaped.
    3109. 

  3109. </p>
    3110. 

  3110. <div class="terminal_caption">
    3111. 

  3111. When escaping HTML characters with option '-e'</div>
    3112. 

  3112. <pre class="terminal">$ ruby bench.rb -n 10000 -m execute -ep
    3113. 

  3113. *** ntimes=10000, testmode=execute
    3114. 

  3114.                                     user     system      total        real
    3115. 

  3115. eruby                          21.700000   0.290000  <strong>21.990000</strong> ( 22.050687)
    3116. 

  3116. ERB                            45.140000   0.390000  <strong>45.530000</strong> ( 45.536976)
    3117. 

  3117. ERB(cached)                    20.340000   0.470000  <strong>20.810000</strong> ( 20.822653)
    3118. 

  3118. Erubis::Eruby                  14.830000   0.310000  <strong>15.140000</strong> ( 15.147930)
    3119. 

  3119. Erubis::Eruby(cached)          11.090000   0.420000  <strong>11.510000</strong> ( 11.514954)
    3120. 

  3120. Erubis::FastEruby              14.850000   0.310000  <strong>15.160000</strong> ( 15.172499)
    3121. 

  3121. Erubis::FastEruby(cached)      10.970000   0.430000  <strong>11.400000</strong> ( 11.399605)
    3122. 

  3122. Erubis::ArrayBufferEruby       14.970000   0.300000  15.270000 ( 15.281061)
    3123. 

  3123. Erubis::PrintOutEruby          15.780000   0.300000  16.080000 ( 16.088289)
    3124. 

  3124. Erubis::StdoutEruby            15.840000   0.310000  16.150000 ( 16.235338)
    3125. 

  3125. </pre>
    3126. 

  3126. <br>
    3127. 

    3128. 

    3129. 

  3129. <br>
    3130. 

    3131. 

    3132. 

  3132. <a name="command"></a>
    3133. 

  3133. <h2 class="section1">Command Reference</h2>
    3134. 

  3134. <a name="command-usage"></a>
    3135. 

  3135. <h3 class="section2">Usage</h3>
    3136. 

  3136. <p>erubis [..options..] [<em>file</em> ...]
    3137. 

  3137. </p>
    3138. 

  3138. <br>
    3139. 

    3140. 

    3141. 

  3141. <a name="command-options"></a>
    3142. 

  3142. <h3 class="section2">Options</h3>
    3143. 

  3143.   <dl class="dl3" compact>
    3144. 

  3144.   <dt class="dt3"><b>
    3145. 

  3145. -h, --help    </b></dt>
    3146. 

  3146.   <dd class="dd3">
    3147. 

  3147.   	Help.
    3148. 

  3148.   </dd>
    3149. 

  3149.   <dt class="dt3"><b>
    3150. 

  3150. -v            </b></dt>
    3151. 

  3151.   <dd class="dd3">
    3152. 

  3152.   	Release version.
    3153. 

  3153.   </dd>
    3154. 

  3154.   <dt class="dt3"><b>
    3155. 

  3155. -x            </b></dt>
    3156. 

  3156.   <dd class="dd3">
    3157. 

  3157.   	Show compiled source.
    3158. 

  3158.   </dd>
    3159. 

  3159.   <dt class="dt3"><b>
    3160. 

  3160. -X            </b></dt>
    3161. 

  3161.   <dd class="dd3">
    3162. 

  3162.   	Show compiled source but only Ruby code.
    3163. 

  3163. 			This is equivarent to '-E NoText'.
    3164. 

  3164.   </dd>
    3165. 

  3165.   <dt class="dt3"><b>
    3166. 

  3166. -N            </b></dt>
    3167. 

  3167.   <dd class="dd3">
    3168. 

  3168.   	Numbering: add line numbers. (for '-x/-X')
    3169. 

  3169.   </dd>
    3170. 

  3170.   <dt class="dt3"><b>
    3171. 

  3171. -U            </b></dt>
    3172. 

  3172.   <dd class="dd3">
    3173. 

  3173.   	Unique mode: zip empty lines into a line. (for '-x/-X')
    3174. 

  3174.   </dd>
    3175. 

  3175.   <dt class="dt3"><b>
    3176. 

  3176. -C            </b></dt>
    3177. 

  3177.   <dd class="dd3">
    3178. 

  3178.   	Compact: remove empty lines. (for '-x/-X')
    3179. 

  3179.   </dd>
    3180. 

  3180.   <dt class="dt3"><b>
    3181. 

  3181. -b            </b></dt>
    3182. 

  3182.   <dd class="dd3">
    3183. 

  3183.   	Body only: no preamble nor postamble. (for '-x/-X')
    3184. 

  3184. 			This is equivarent to '--preamble=false --postamble=false'.
    3185. 

  3185.   </dd>
    3186. 

  3186.   <dt class="dt3"><b>
    3187. 

  3187. -z            </b></dt>
    3188. 

  3188.   <dd class="dd3">
    3189. 

  3189.   	Syntax checking.
    3190. 

  3190.   </dd>
    3191. 

  3191.   <dt class="dt3"><b>
    3192. 

  3192. -e            </b></dt>
    3193. 

  3193.   <dd class="dd3">
    3194. 

  3194.   	Escape. This is equivarent to '-E Escape'.
    3195. 

  3195.   </dd>
    3196. 

  3196.   <dt class="dt3"><b>
    3197. 

  3197. -p pattern    </b></dt>
    3198. 

  3198.   <dd class="dd3">
    3199. 

  3199.   	Embedded pattern (default '&lt;% %&gt;').
    3200. 

  3200. 			This is equivarent to '--pattern=<em>pattern</em>'.
    3201. 

  3201.   </dd>
    3202. 

  3202.   <dt class="dt3"><b>
    3203. 

  3203. -l lang       </b></dt>
    3204. 

  3204.   <dd class="dd3">
    3205. 

  3205.   	Language name.
    3206. 

  3206. 			This option makes erubis command to compile script but no execute.
    3207. 

  3207.   </dd>
    3208. 

  3208.   <dt class="dt3"><b>
    3209. 

  3209. -E enhacers   </b></dt>
    3210. 

  3210.   <dd class="dd3">
    3211. 

  3211.   	Enhancer name (Escape, PercentLine, ...).
    3212. 

  3212. 			It is able to specify several enhancer name separating with ','
    3213. 

  3213. 			(ex. -f Escape,PercentLine,HeaderFooter).
    3214. 

  3214.   </dd>
    3215. 

  3215.   <dt class="dt3"><b>
    3216. 

  3216. -I path       </b></dt>
    3217. 

  3217.   <dd class="dd3">
    3218. 

  3218.   	Require library path ($:).
    3219. 

  3219. 			It is able to specify several paths separating with ','
    3220. 

  3220. 			(ex. -f path1,path2,path3).
    3221. 

  3221.   </dd>
    3222. 

  3222.   <dt class="dt3"><b>
    3223. 

  3223. -K kanji      </b></dt>
    3224. 

  3224.   <dd class="dd3">
    3225. 

  3225.   	Kanji code (euc, sjis, utf8, or none) (default none).
    3226. 

  3226.   </dd>
    3227. 

  3227.   <dt class="dt3"><b>
    3228. 

  3228. -f datafile   </b></dt>
    3229. 

  3229.   <dd class="dd3">
    3230. 

  3230.   	Context data file in YAML format ('*.yaml', '*.yml') or
    3231. 

  3231.                         Ruby script ('*.rb').
    3232. 

  3232. 			It is able to specify several filenames separating with ','
    3233. 

  3233. 			(ex. -f file1,file2,file3).
    3234. 

  3234.   </dd>
    3235. 

  3235.   <dt class="dt3"><b>
    3236. 

  3236. -c context    </b></dt>
    3237. 

  3237.   <dd class="dd3">
    3238. 

  3238.   	Context data string in YAML inline style or Ruby code.
    3239. 

  3239.   </dd>
    3240. 

  3240.   <dt class="dt3"><b>
    3241. 

  3241. -T            </b></dt>
    3242. 

  3242.   <dd class="dd3">
    3243. 

  3243.   	Don't expand tab characters in YAML file.
    3244. 

  3244.   </dd>
    3245. 

  3245.   <dt class="dt3"><b>
    3246. 

  3246. -S            </b></dt>
    3247. 

  3247.   <dd class="dd3">
    3248. 

  3248.   	Convert mapping key from string to symbol in YAML file.
    3249. 

  3249.   </dd>
    3250. 

  3250.   <dt class="dt3"><b>
    3251. 

  3251. -B		   </b></dt>
    3252. 

  3252.   <dd class="dd3">
    3253. 

  3253.   	invoke Eruby#result() instead of Eruby#evaluate()
    3254. 

  3254.   </dd>
    3255. 

  3255.   <dt class="dt3"><b>
    3256. 

  3256. --pi[=name]   </b></dt>
    3257. 

  3257.   <dd class="dd3">
    3258. 

  3258.   	parse '&lt;?name ... ?&gt;' instead of '&lt;% ... %&gt;'
    3259. 

  3259.   </dd>
    3260. 

  3260.   <dt class="dt3"><b>
    3261. 

  3261. --trim=false  </b></dt>
    3262. 

  3262.   <dd class="dd3">
    3263. 

  3263.   	No trimming spaces around '&lt;% %&gt;'.
    3264. 

  3264.   </dd>
    3265. 

  3265.   </dl>
    3266. 

  3266. <br>
    3267. 

    3268. 

    3269. 

  3269. <a name="command-props"></a>
    3270. 

  3270. <h3 class="section2">Properties</h3>
    3271. 

  3271. <p>Some Eruby classes can take optional properties to change it's compile option.
    3272. 

  3272. For example, property '--indent="  "' may change indentation of compiled source code.
    3273. 

  3273. Try 'erubis -h' for details.
    3274. 

  3274. </p>
    3275. 

  3275. <br>
    3276. 

    3277. 

    3278. 

  3278. <br>
    3279. 

    3280. 

    3281. 

    3282. 

  3282.    </div>
    3283. 

  3283.   </blockquote>
    3284. 

    3285. 

  3285.  </body>
    3286. 

  3286. </html>
    3287. 

    3288.