├── lib
    ├── erbse
    │   ├── version.rb
    │   └── parser.rb
    └── erbse.rb
├── test
    ├── test_helper.rb
    └── erbse_test.rb
├── benchmark
    ├── templates
    │   ├── _footer.html
    │   ├── bench_erb.rhtml
    │   ├── bench_erubis.rhtml
    │   ├── bench_eruby.rhtml
    │   └── _header.html
    ├── Makefile
    ├── bench_context.yaml
    └── bench.rb
├── Gemfile
├── Rakefile
├── erbse.gemspec
├── MIT-LICENSE
├── CHANGES.md
└── README.md


/lib/erbse/version.rb:
--------------------------------------------------------------------------------
1 | module Erbse
2 |   VERSION = "0.1.4"
3 | end
4 | 


--------------------------------------------------------------------------------
/test/test_helper.rb:
--------------------------------------------------------------------------------
1 | require "erbse"
2 | require "minitest/autorun"
3 | 


--------------------------------------------------------------------------------
/benchmark/templates/_footer.html:
--------------------------------------------------------------------------------
1 |   </table>
2 | 
3 |  </body>
4 | </html>
5 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source 'https://rubygems.org'
2 | 
3 | gemspec
4 | 
5 | gem "minitest-line"
6 | 


--------------------------------------------------------------------------------
/benchmark/Makefile:
--------------------------------------------------------------------------------
1 | 
2 | bench:
3 | 	ruby bench.rb -n 10000
4 | 
5 | clean:
6 | 	rm -rf bench_*.rhtml*
7 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | require 'bundler'
 2 | Bundler::GemHelper.install_tasks
 3 | 
 4 | require 'rake/testtask'
 5 | 
 6 | desc 'Default: run unit tests.'
 7 | task :default => :test
 8 | 
 9 | Rake::TestTask.new(:test) do |test|
10 |   test.libs << 'test'
11 |   test.pattern = 'test/*_test.rb'
12 |   test.verbose = true
13 | end
14 | 


--------------------------------------------------------------------------------
/benchmark/templates/bench_erb.rhtml:
--------------------------------------------------------------------------------
 1 |    <tbody>
 2 | <%
 3 | n = 0
 4 | for item in list
 5 |     n += 1
 6 |  %>
 7 |     <tr class="<%= n % 2 == 0 ? 'even' : 'odd' %>">
 8 |      <td style="text-align: center"><%= n %></td>
 9 |      <td>
10 |       <a href="/stocks/<%= item['symbol'] %>"><%= item['symbol'] %></a>
11 |      </td>
12 |      <td>
13 |       <a href="<%= item['url'] %>"><%= item['name'] %></a>
14 |      </td>
15 |      <td>
16 |       <strong><%= item['price'] %></strong>
17 |      </td>
18 | <% if item['change'] < 0.0 %>
19 |      <td class="minus"><%= item['change'] %></td>
20 |      <td class="minus"><%= item['ratio'] %></td>
21 | <% else %>
22 |      <td><%= item['change'] %></td>
23 |      <td><%= item['ratio'] %></td>
24 | <% end %>
25 |     </tr>
26 | <%
27 | end
28 |  %>
29 |    </tbody>
30 | 


--------------------------------------------------------------------------------
/benchmark/templates/bench_erubis.rhtml:
--------------------------------------------------------------------------------
 1 |    <tbody>
 2 | <%
 3 | n = 0
 4 | for item in list
 5 |     n += 1
 6 |  %>
 7 |     <tr class="<%= n % 2 == 0 ? 'even' : 'odd' %>">
 8 |      <td style="text-align: center"><%= n %></td>
 9 |      <td>
10 |       <a href="/stocks/<%= item['symbol'] %>"><%= item['symbol'] %></a>
11 |      </td>
12 |      <td>
13 |       <a href="<%= item['url'] %>"><%= item['name'] %></a>
14 |      </td>
15 |      <td>
16 |       <strong><%= item['price'] %></strong>
17 |      </td>
18 | <% if item['change'] < 0.0 %>
19 |      <td class="minus"><%= item['change'] %></td>
20 |      <td class="minus"><%= item['ratio'] %></td>
21 | <% else %>
22 |      <td><%= item['change'] %></td>
23 |      <td><%= item['ratio'] %></td>
24 | <% end %>
25 |     </tr>
26 | <%
27 | end
28 |  %>
29 |    </tbody>
30 | 


--------------------------------------------------------------------------------
/benchmark/templates/bench_eruby.rhtml:
--------------------------------------------------------------------------------
 1 |    <tbody>
 2 | <%
 3 | n = 0
 4 | for item in list
 5 |     n += 1
 6 |  %>
 7 |     <tr class="<%= n % 2 == 0 ? 'even' : 'odd' %>">
 8 |      <td style="text-align: center"><%= n %></td>
 9 |      <td>
10 |       <a href="/stocks/<%= item['symbol'] %>"><%= item['symbol'] %></a>
11 |      </td>
12 |      <td>
13 |       <a href="<%= item['url'] %>"><%= item['name'] %></a>
14 |      </td>
15 |      <td>
16 |       <strong><%= item['price'] %></strong>
17 |      </td>
18 | <% if item['change'] < 0.0 %>
19 |      <td class="minus"><%= item['change'] %></td>
20 |      <td class="minus"><%= item['ratio'] %></td>
21 | <% else %>
22 |      <td><%= item['change'] %></td>
23 |      <td><%= item['ratio'] %></td>
24 | <% end %>
25 |     </tr>
26 | <%
27 | end
28 |  %>
29 |    </tbody>
30 | 


--------------------------------------------------------------------------------
/erbse.gemspec:
--------------------------------------------------------------------------------
 1 | lib = File.expand_path('../lib/', __FILE__)
 2 | $:.unshift lib unless $:.include?(lib)
 3 | 
 4 | require 'erbse/version'
 5 | 
 6 | Gem::Specification.new do |spec|
 7 |   spec.name        = "erbse"
 8 |   spec.version     = Erbse::VERSION
 9 |   spec.platform    = Gem::Platform::RUBY
10 |   spec.authors     = ["Nick Sutterer"]
11 |   spec.email       = ["apotonick@gmail.com"]
12 |   spec.homepage    = "https://github.com/apotonick/erbse"
13 |   spec.summary     = %q{Updated Erubis.}
14 |   spec.description = %q{An updated Erubis with block support. Block inheritance soon to come.}
15 |   spec.license     = 'MIT'
16 | 
17 |   spec.files         = `git ls-files`.split("\n")
18 |   spec.test_files    = `git ls-files -- {test}/*`.split("\n")
19 |   spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
20 |   spec.require_paths = ["lib"]
21 | 
22 |   spec.add_dependency "temple"
23 | 
24 |   spec.add_development_dependency "rake"
25 |   spec.add_development_dependency "minitest"
26 | end
27 | 


--------------------------------------------------------------------------------
/MIT-LICENSE:
--------------------------------------------------------------------------------
 1 | copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/lib/erbse.rb:
--------------------------------------------------------------------------------
 1 | require "temple"
 2 | require "erbse/parser"
 3 | 
 4 | module Erbse
 5 |   class BlockFilter < Temple::Filter
 6 |     # Highly inspired by https://github.com/slim-template/slim/blob/master/lib/slim/controls.rb#on_slim_output
 7 |     def on_erb_block(code, content_ast)
 8 |       # this is for <%= do %>
 9 |       outter_i = unique_name
10 |       inner_i  = unique_name
11 | 
12 |       # this still needs the Temple::Filters::ControlFlow run-through.
13 |       [:multi,
14 |         [:block, "#{outter_i} = #{code}",
15 |           [:capture, inner_i, compile(content_ast)]
16 |         ],
17 |         [:dynamic, outter_i] # return the outter buffer. # DISCUSS: why do we need that, again?
18 |       ]
19 |     end
20 | 
21 |     # assign all code in the block to new local output buffer without outputting it.
22 |     # handles <%@ do %>
23 |     def on_capture_block(code, content_ast)
24 |       [:multi,
25 |         [:block, code, # var = capture do
26 |           [:capture, unique_name, compile(content_ast)]
27 |         ]
28 |       ]
29 |     end
30 |   end
31 | 
32 |   class Engine < Temple::Engine
33 |     use Parser
34 |     use BlockFilter
35 | 
36 |     # filter :MultiFlattener
37 |     # filter :StaticMerger
38 |     # filter :DynamicInliner
39 |     filter :ControlFlow
40 | 
41 |     generator :ArrayBuffer
42 |   end
43 |   # DISCUSS: can we add more optimizers?
44 | end
45 | 
46 | 


--------------------------------------------------------------------------------
/benchmark/templates/_header.html:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 3 |           "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 4 | <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 5 |  <head>
 6 |   <title>Stock Prices</title>
 7 |   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
 8 |   <meta http-equiv="Content-Style-Type" content="text/css" />
 9 |   <meta http-equiv="Content-Script-Type" content="text/javascript" />
10 |   <link rel="shortcut icon" href="/images/favicon.ico" />
11 |   <link rel="stylesheet" type="text/css" href="/css/style.css" media="all" />
12 |   <script type="text/javascript" src="/js/util.js"></script>
13 |   <style type="text/css">
14 |   /*<![CDATA[*/
15 | 
16 | body {
17 |     color: #333333;
18 |     line-height: 150%;
19 | }
20 | 
21 | thead {
22 |     font-weight: bold;
23 |     background-color: #CCCCCC;
24 | }
25 | 
26 | .odd {
27 |     background-color: #FFCCCC;
28 | }
29 | 
30 | .even {
31 |     background-color: #CCCCFF;
32 | }
33 | 
34 | .minus {
35 |     color: #FF0000;
36 | }
37 | 
38 |   /*]]>*/
39 |   </style>
40 | 
41 |  </head>
42 | 
43 |  <body>
44 | 
45 |   <h1>Stock Prices</h1>
46 | 
47 |   <table>
48 |    <thead>
49 |     <tr>
50 |      <th>#</th><th>symbol</th><th>name</th><th>price</th><th>change</th><th>ratio</th>
51 |     </tr>
52 |    </thead>
53 | 


--------------------------------------------------------------------------------
/CHANGES.md:
--------------------------------------------------------------------------------
 1 | # 0.1.4
 2 | 
 3 | * Newlines are now properly reflected in the compiled code.
 4 | 
 5 | # 0.1.3
 6 | 
 7 | * Do not trim whitespace between ERB tags.
 8 | 
 9 | # 0.1.2
10 | 
11 | * Postfix conditionals are now parsed properly: code such as `<% puts if true %>` now works, thanks to @aiomaster's work.
12 | * `<%@ code %>` now requires an explicit whitespace after the `@` for backward-compatibility.
13 | 
14 | # 0.1.1
15 | 
16 | * Introduce the `<%@ %>` tag. This is a built-in capture mechanism. It will assign all block content to a local variable but *not* output it.
17 | * Make comments be recognized before `end`, which fixes a syntax error with `<%# end %>`.
18 | * Don't recognize ERB tags with a string containing "do" as a block.
19 | 
20 | # 0.1.0
21 | 
22 | * Internally, we're parsing the ERB template into a SEXP structure and let [Temple](https://github.com/judofyr/temple) compile it to Ruby. Many thanks to the Temple team! 😘
23 | * Yielding ERB blocks will simply return the content, no output buffering with instance variables will happen.
24 |     This allows to pass ERB blocks around and yield them in other objects without having it output twice as in 0.0.2.
25 | * No instance variables are used anymore, output buffering always happens via locals the way [Slim](https://github.com/slim-template/slim) does it. This might result in a minimal speed decrease but cleans up the code and architecture immensely.
26 | * Removed `Erbse::Template`, it was completely unnecessary code.
27 | 
28 | # 0.0.2
29 | 
30 | * First release. No escaping is happening and I'm not sure how capture works, yet. But: it's great!
31 | 


--------------------------------------------------------------------------------
/lib/erbse/parser.rb:
--------------------------------------------------------------------------------
 1 | module Erbse
 2 |   class Parser
 3 |     # ERB_EXPR = /(\n)|<%(=|\#)?(.*?)%>(\n)*/m # this is the desired pattern.
 4 |     ERB_EXPR = /(\n)|<=|<%(=+|-|\#|@\s|%)?(.*?)[-=]?%>/m # this is for backward-compatibility.
 5 |     # BLOCK_EXPR     = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 6 |     BLOCK_EXPR = /\sdo\s*\z|\sdo\s+\|[^|]*\|\s*\z/
 7 |     BLOCK_EXEC = /\A\s*(if|unless)\b|#{BLOCK_EXPR}/
 8 | 
 9 |     # Parsing patterns
10 |     #
11 |     # Blocks will be recognized when written:
12 |     # <% ... do %> or <% ... do |...| %>
13 | 
14 |     def initialize(*)
15 |     end
16 | 
17 |     def call(str)
18 |       pos = 0
19 |       buffers = []
20 |       result = [:multi]
21 |       buffers << result
22 |       match = nil
23 | 
24 |       str.scan(ERB_EXPR) do |newline, indicator, code|
25 |         match = Regexp.last_match
26 |         len  = match.begin(0) - pos
27 | 
28 |         text = str[pos, len]
29 |         pos  = match.end(0)
30 |         ch   = indicator ? indicator[0] : nil
31 | 
32 |         if newline
33 |           buffers.last << [:static, "#{text}\n"] << [:newline]
34 |           next
35 |         end
36 | 
37 |         if text and !text.empty? # text
38 |           buffers.last << [:static, text]
39 |         end
40 | 
41 |         if ch == ?= # <%= %>
42 |           if code =~ BLOCK_EXPR
43 |             buffers.last << [:erb, :block, code, block = [:multi]] # picked up by our own BlockFilter.
44 |             buffers << block
45 |           else
46 |             buffers.last << [:dynamic, code]
47 |           end
48 |         elsif ch =~ /#/ # DISCUSS: doesn't catch <% # this %>
49 |           newlines = code.count("\n")
50 |           buffers.last.concat  [[:newline]] * newlines if newlines > 0
51 |         elsif code =~ /\bend\b/ # <% end %>
52 |           buffers.pop
53 |         elsif ch == ?@
54 |           buffers.last << [:capture, :block, code, block = [:multi]] # picked up by our own BlockFilter. # TODO: merge with %= ?
55 |           buffers << block
56 |         else # <% %>
57 |           if code =~ BLOCK_EXEC
58 |             buffers.last << [:block, code, block = [:multi]] # picked up by Temple's ControlFlow filter.
59 |             buffers << block
60 |           else
61 |             buffers.last << [:code, code]
62 |           end
63 |         end
64 |       end
65 | 
66 |       # add text after last/none ERB tag.
67 |       buffers.last << [:static, str[pos..str.length]] if pos < str.length
68 | 
69 |       buffers.last
70 |     end
71 |   end
72 | end
73 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Erbse
  2 | 
  3 | _An updated version of Erubis._
  4 | 
  5 | Erbse compiles an ERB string to a string of Ruby.
  6 | 
  7 | ## API
  8 | 
  9 | The API is one public method.
 10 | 
 11 | ```ruby
 12 | Erbse::Engine.new.call("<% ... %>") #=> string of compiled ruby.
 13 | ```
 14 | 
 15 | The returned string can then be `eval`uated in a certain context.
 16 | 
 17 | ## Output Buffers
 18 | 
 19 | Erbse does not use instance variables as output buffer, only local variables.
 20 | 
 21 | | Tag | Behavior |
 22 | | --- | --- |
 23 | | `<% %>` | Executes the code but does not output anything. |
 24 | | `<% .. do %>` | Executes the code but does not output anything. In the block, output is written to the current buffer. |
 25 | | `<%= %>` | Executes the code, outputs to current buffer. |
 26 | | `<%= .. do %>` | Executes the code and appends returned value to the current buffer. In the block, output is written to a new buffer that is returned when `yield`ing. |
 27 | | `<%@ .. do %>` | Executes the code but does not output anything. In the block, output is written to a new buffer that is returned when `yield`ing. |
 28 | 
 29 | 
 30 | ## Block Yielding
 31 | 
 32 | Erbse supports blocks à la Rails.
 33 | 
 34 | You may pass any mix of text/ERB via blocks to Ruby methods.
 35 | 
 36 | ```erb
 37 | <%= form do %>
 38 |   <em>Please fill out all fields!</em>
 39 |   <%= input :email %>
 40 |   <button type="submit">
 41 | <% end %>
 42 | ```
 43 | 
 44 | Here, the `form` method receives a block of compiled Ruby.
 45 | 
 46 | When `yield`ed, the block simply returns its evaluated content as a string. It's your job to assign it to an output buffer, **no instance variables are used**.
 47 | 
 48 | ```ruby
 49 | def form(&block)
 50 |   content = yield
 51 |   "<form>#{content}</form>"
 52 | end
 53 | ```
 54 | Usually, returning the content from the helper will be sufficient.
 55 | 
 56 | However, you can totally pass that block to a completely different object and yield it there. Since there's no global state as in ERB, this will work.
 57 | 
 58 | ## Capture
 59 | 
 60 | With the `<%= helper do %>` tag, block content is assigned to a new output buffer and the result of `helper` rendered.
 61 | 
 62 | To capture the block without outputting anything, use the `<%@ %>` tag. This will still use a new output buffer for the block, but not output anything.
 63 | 
 64 | ```erb
 65 | <%@ content = capture do %>
 66 |   Whatever
 67 | <% end %>
 68 | 
 69 | <%= content %>
 70 | ```
 71 | 
 72 | The `capture` method will receive a block, what you do with it is up to you. It would usually simply yield the block.
 73 | 
 74 | ```ruby
 75 | def capture(&block)
 76 |   yield
 77 | end
 78 | ```
 79 | 
 80 | ## Removed Features
 81 | 
 82 | Erbse does *not* support any tags other than `<% %>`, `<%= %>` and `<%@ %>`. Tags such as `<%% %>`, `<%== %>`, `<%- %>` or `<% -%>` will be reduced to the supported tags.
 83 | 
 84 | ## TODO
 85 | 
 86 | The parser code got drastically reduced and might be missing essential features. [Please report](https://github.com/apotonick/erbse/issues) compiled syntax errors.
 87 | 
 88 | * Block comments
 89 | * Add newlines in compiled Ruby.
 90 | 
 91 | ## Planned
 92 | 
 93 | Block inheritance.
 94 | 
 95 | ```erb
 96 | <h1><%= title %></h1>
 97 | 
 98 | <% fragment :subheader do %>
 99 |   Or: <%= subheader %>
100 | <% end %>
101 | ```
102 | 
103 | This fragment could then be overridden.
104 | 
105 | Feel free to contribute!!!
106 | 
107 | ## Users
108 | 
109 | Erbse is the ERB engine in [Cells](https://github.com/apotonick/cells).
110 | 
111 | ## License
112 | 
113 | MIT License
114 | 
115 | ## Contributors
116 | 
117 | * Special thanks to [Aman Gupta](https://github.com/tmm1) for [performance tweaks](https://github.com/rails/rails/pull/9555) that are merged in Erbse.
118 | * @iazel
119 | * @seuros
120 | 
121 | 
122 | # Authors
123 | 
124 | * Copyright 2015 Nick Sutterer <apotonick@gmail.com>
125 | * Copyright 2006-2011 makoto kuwata <kwa(at)kuwata-lab.com>
126 | 


--------------------------------------------------------------------------------
/benchmark/bench_context.yaml:
--------------------------------------------------------------------------------
  1 | list:
  2 |   - name:       Adobe Systems
  3 |     name2:      Adobe Systems Inc.
  4 |     url:        http://www.adobe.com
  5 |     symbol:     ADBE
  6 |     price:      39.26
  7 |     change:     0.13
  8 |     ratio:      0.33
  9 |   - name:       Advanced Micro Devices
 10 |     name2:      Advanced Micro Devices Inc.
 11 |     url:        http://www.amd.com
 12 |     symbol:     AMD
 13 |     price:      16.22
 14 |     change:     0.17
 15 |     ratio:      1.06
 16 |   - name:       Amazon.com
 17 |     name2:      Amazon.com Inc
 18 |     url:        http://www.amazon.com
 19 |     symbol:     AMZN
 20 |     price:      36.85
 21 |     change:     -0.23
 22 |     ratio:      -0.62
 23 |   - name:       Apple
 24 |     name2:      Apple Inc.
 25 |     url:        http://www.apple.com
 26 |     symbol:     AAPL
 27 |     price:      85.38
 28 |     change:     -0.87
 29 |     ratio:      -1.01
 30 |   - name:       BEA Systems
 31 |     name2:      BEA Systems Inc.
 32 |     url:        http://www.bea.com
 33 |     symbol:     BEAS
 34 |     price:      12.46
 35 |     change:     0.09
 36 |     ratio:      0.73
 37 |   - name:       CA
 38 |     name2:      CA, Inc.
 39 |     url:        http://www.ca.com
 40 |     symbol:     CA
 41 |     price:      24.66
 42 |     change:     0.38
 43 |     ratio:      1.57
 44 |   - name:       Cisco Systems
 45 |     name2:      Cisco Systems Inc.
 46 |     url:        http://www.cisco.com
 47 |     symbol:     CSCO
 48 |     price:      26.35
 49 |     change:     0.13
 50 |     ratio:      0.5
 51 |   - name:       Dell
 52 |     name2:      Dell Corp.
 53 |     url:        http://www.dell.com/
 54 |     symbol:     DELL
 55 |     price:      23.73
 56 |     change:     -0.42
 57 |     ratio:      -1.74
 58 |   - name:       eBay
 59 |     name2:      eBay Inc.
 60 |     url:        http://www.ebay.com
 61 |     symbol:     EBAY
 62 |     price:      31.65
 63 |     change:     -0.8
 64 |     ratio:      -2.47
 65 |   - name:       Google
 66 |     name2:      Google Inc.
 67 |     url:        http://www.google.com
 68 |     symbol:     GOOG
 69 |     price:      495.84
 70 |     change:     7.75
 71 |     ratio:      1.59
 72 |   - name:       Hewlett-Packard
 73 |     name2:      Hewlett-Packard Co.
 74 |     url:        http://www.hp.com
 75 |     symbol:     HPQ
 76 |     price:      41.69
 77 |     change:     -0.02
 78 |     ratio:      -0.05
 79 |   - name:       IBM
 80 |     name2:      International Business Machines Corp.
 81 |     url:        http://www.ibm.com
 82 |     symbol:     IBM
 83 |     price:      97.45
 84 |     change:     -0.06
 85 |     ratio:      -0.06
 86 |   - name:       Intel
 87 |     name2:      Intel Corp.
 88 |     url:        http://www.intel.com
 89 |     symbol:     INTC
 90 |     price:      20.53
 91 |     change:     -0.07
 92 |     ratio:      -0.34
 93 |   - name:       Juniper Networks
 94 |     name2:      Juniper Networks, Inc
 95 |     url:        http://www.juniper.net/
 96 |     symbol:     JNPR
 97 |     price:      18.96
 98 |     change:     0.5
 99 |     ratio:      2.71
100 |   - name:       Microsoft
101 |     name2:      Microsoft Corp
102 |     url:        http://www.microsoft.com
103 |     symbol:     MSFT
104 |     price:      30.6
105 |     change:     0.15
106 |     ratio:      0.49
107 |   - name:       Oracle
108 |     name2:      Oracle Corp.
109 |     url:        http://www.oracle.com
110 |     symbol:     ORCL
111 |     price:      17.15
112 |     change:     0.17
113 |     ratio:      1.0
114 |   - name:       SAP
115 |     name2:      SAP AG
116 |     url:        http://www.sap.com
117 |     symbol:     SAP
118 |     price:      46.2
119 |     change:     -0.16
120 |     ratio:      -0.35
121 |   - name:       Seagate Technology
122 |     name2:      Seagate Technology
123 |     url:        http://www.seagate.com/
124 |     symbol:     STX
125 |     price:      27.35
126 |     change:     -0.36
127 |     ratio:      -1.3
128 |   - name:       Sun Microsystems
129 |     name2:      Sun Microsystems Inc.
130 |     url:        http://www.sun.com
131 |     symbol:     SUNW
132 |     price:      6.33
133 |     change:     -0.01
134 |     ratio:      -0.16
135 |   - name:       Yahoo
136 |     name2:      Yahoo! Inc.
137 |     url:        http://www.yahoo.com
138 |     symbol:     YHOO
139 |     price:      28.04
140 |     change:     -0.17
141 |     ratio:      -0.6
142 | 


--------------------------------------------------------------------------------
/benchmark/bench.rb:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env ruby
  2 | 
  3 | ###
  4 | ### $Release: 2.7.0 $
  5 | ### copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
  6 | ###
  7 | 
  8 | require 'erb'
  9 | require 'erubis'
 10 | require 'erubis/tiny'
 11 | require 'erubis/engine/enhanced'
 12 | require 'yaml'
 13 | require 'cgi'
 14 | include ERB::Util
 15 | 
 16 | begin
 17 |   require 'eruby'
 18 | rescue LoadError
 19 |   ERuby = nil
 20 | end
 21 | 
 22 | def File.write(filename, content)
 23 |   File.open(filename, 'w') { |f| f.write(content) }
 24 | end
 25 | 
 26 | 
 27 | ## change benchmark library to use $stderr instead of $stdout
 28 | require 'benchmark'
 29 | module Benchmark
 30 |   class Report
 31 |     def print(*args)
 32 |       $stderr.print(*args)
 33 |     end
 34 |   end
 35 |   module_function
 36 |   def print(*args)
 37 |     $stderr.print(*args)
 38 |   end
 39 | end
 40 | 
 41 | 
 42 | class BenchmarkApplication
 43 | 
 44 |   TARGETS = %w[eruby
 45 |                ERB               ERB(cached)
 46 |                Erubis::Eruby     Erubis::Eruby(cached)
 47 |                Erubis::FastEruby Erubis::FastEruby(cached)
 48 |                Erubis::TinyEruby
 49 |                Erubis::ArrayBufferEruby
 50 |                Erubis::PrintOutEruby
 51 |                Erubis::StdoutEruby
 52 |               ]
 53 | 
 54 |   def initialize(ntimes, context, targets=nil, params={})
 55 |     @ntimes      = ntimes
 56 |     @context     = context
 57 |     @targets     = targets && !targets.empty? ? targets : TARGETS.dup
 58 |     @testmode    = params[:testmode]    || 'execute'
 59 |     @erubyfile   = params[:erubyfile]   || 'erubybench.rhtml'
 60 |     @printout    = params[:printout]    || false
 61 |   end
 62 | 
 63 |   attr_accessor :ntimes, :targets
 64 |   attr_accessor :testmode, :erubyfile, :contextfile, :printout
 65 | 
 66 |   def context2code(context, varname='context')
 67 |     s = ''
 68 |     context.each { |k, | s << "#{k} = #{varname}[#{k.inspect}]; " }
 69 |     return s
 70 |   end
 71 | 
 72 |   def perform_benchmark
 73 |     width = 30
 74 |     $stderr.puts "*** ntimes=#{@ntimes}, testmode=#{@testmode}"
 75 |     Benchmark.bm(width) do |job|
 76 |       for target in @targets do
 77 |         method = "#{@testmode}_#{target.gsub(/::|-|\(/, '_').gsub(/\)/, '').downcase}"
 78 |         #$stderr.puts "*** debug: method=#{method.inspect}"
 79 |         next unless self.respond_to?(method)
 80 |         filename = "bench_#{(target =~ /^(\w+)/) && $1.downcase}.rhtml"
 81 |         title = target
 82 |         output = nil
 83 |         job.report(title) do
 84 |           output = self.__send__(method, filename, @context)
 85 |         end
 86 |         File.write("output.#{target.gsub(/[^\w]/,'')}", output) if @printout && output && !output.empty?
 87 |       end
 88 |     end
 89 |   end
 90 | 
 91 |   ##
 92 | 
 93 |   def execute_eruby(filename, context)
 94 |     return unless ERuby
 95 |     #eval context2code(context)
 96 |     list = context['list']
 97 |     @ntimes.times do
 98 |       ERuby.import(filename)
 99 |     end
100 |     return nil
101 |   end
102 | 
103 |   def execute_erb(filename, context)
104 |     #eval context2code(context)
105 |     list = context['list']
106 |     output = nil
107 |     @ntimes.times do
108 |       eruby = ERB.new(File.read(filename))
109 |       output = eruby.result(binding())
110 |       print output
111 |     end
112 |     return output
113 |   end
114 | 
115 |   def execute_erb_cached(filename, context)
116 |     #eval context2code(context)
117 |     list = context['list']
118 |     output = nil
119 |     cachefile = filename + '.cache'
120 |     File.unlink(cachefile) if test(?f, cachefile)
121 |     @ntimes.times do
122 |       if !test(?f, cachefile) || File.mtime(filename) > File.mtime(cachefile)
123 |         eruby = ERB.new(File.read(filename))
124 |         File.write(cachefile, eruby.src)
125 |       else
126 |         eruby = ERB.new('')
127 |         #eruby.src = File.read(cachefile)
128 |         eruby.instance_variable_set("@src", File.read(cachefile))
129 |       end
130 |       output = eruby.result(binding())
131 |       print output
132 |     end
133 |     return output
134 |   end
135 | 
136 |   ## no cached
137 |   for klass in %w[Eruby FastEruby TinyEruby ArrayBufferEruby PrintOutEruby StdoutEruby] do
138 |     s = <<-END
139 |     def execute_erubis_#{klass.downcase}(filename, context)
140 |       #eval context2code(context)
141 |       list = context['list']
142 |       output = nil
143 |       @ntimes.times do
144 |         eruby = Erubis::#{klass}.new(File.read(filename))
145 |         output = eruby.result(binding())
146 |         print output
147 |       end
148 |       return output
149 |     end
150 |     END
151 |     eval s
152 |   end
153 | 
154 |   ## cached
155 |   for klass in %w[Eruby FastEruby] do
156 |     s = <<-END
157 |     def execute_erubis_#{klass.downcase}_cached(filename, context)
158 |       #eval context2code(context)
159 |       list = context['list']
160 |       cachefile = filename + '.cache'
161 |       File.unlink(cachefile) if test(?f, cachefile)
162 |       output = nil
163 |       @ntimes.times do
164 |         eruby = Erubis::#{klass}.load_file(filename)
165 |         output = eruby.result(binding())
166 |         print output
167 |       end
168 |       savefile = cachefile.sub(/\\.cache$/, '.#{klass.downcase}.cache')
169 |       File.rename(cachefile, savefile)
170 |       return output
171 |     end
172 |     END
173 |     eval s
174 |   end
175 | 
176 |   ##
177 | 
178 |   def convert_eruby(filename, context)
179 |     return unless ERuby
180 |     #eval context2code(context)
181 |     list = context['list']
182 |     output = nil
183 |     @ntimes.times do
184 |       output = ERuby::Compiler.new.compile_string(File.read(filename))
185 |     end
186 |     return output
187 |   end
188 | 
189 |   def convert_erb(filename, context)
190 |     #eval context2code(context)
191 |     list = context['list']
192 |     output = nil
193 |     @ntimes.times do
194 |       eruby = ERB.new(File.read(filename))
195 |       output = eruby.src
196 |     end
197 |     return output
198 |   end
199 | 
200 |   for klass in %w[Eruby FastEruby TinyEruby]
201 |     s = <<-END
202 |       def convert_erubis_#{klass.downcase}(filename, context)
203 |         #eval context2code(context)
204 |         list = context['list']
205 |         output = nil
206 |         @ntimes.times do
207 |           eruby = Erubis::#{klass}.new(File.read(filename))
208 |           output = eruby.src
209 |         end
210 |         return output
211 |       end
212 |     END
213 |     eval s
214 |   end
215 | 
216 | end
217 | 
218 | 
219 | require 'optparse'
220 | 
221 | class MainApplication
222 | 
223 |   def parse_argv(argv=ARGV)
224 |     optparser = OptionParser.new
225 |     options = {}
226 |     ['-h', '-n N', '-t erubyfile', '-f contextfile', '-A', '-e',
227 |       '-x exclude', '-m testmode', '-X', '-p', '-D'].each do |opt|
228 |       optparser.on(opt) { |val| options[opt[1].chr] = val }
229 |     end
230 |     begin
231 |       targets = optparser.parse!(argv)
232 |     rescue => ex
233 |       $stderr.puts "#{@script}: #{ex.to_s}"
234 |       exit(1)
235 |     end
236 |     return options, targets
237 |   end
238 | 
239 |   def execute
240 |     @script = File.basename($0)
241 |     ntimes = 1000
242 |     targets = BenchmarkApplication::TARGETS.dup
243 |     testmode = 'execute'
244 |     contextfile = 'bench_context.yaml'
245 |     #
246 |     options, args = parse_argv(ARGV)
247 |     ntimes      = options['n'].to_i if options['n']
248 |     targets     = args if args && !args.empty?
249 |     targets     = targets - options['x'].split(/,/) if options['x']
250 |     testmode    = options['m'] if options['m']
251 |     contextfile = options['f'] if options['f']
252 |     erubyfile   = options['t'] if options['t']
253 |     #
254 |     if options['h']
255 |       $stderr.puts "Usage: ruby #{@script} [..options..] [..targets..]"
256 |       $stderr.puts "  -h           :  help"
257 |       $stderr.puts "  -n N         :  loop N times"
258 |       $stderr.puts "  -f datafile  :  context data filename (*.yaml)"
259 |       $stderr.puts "  -x exclude   :  exclude target name"
260 |       $stdout.puts "  -m testmode  :  'execute' or 'convert' (default 'execute')"
261 |       $stderr.puts "  -p           :  print output to file (filename: 'output.TARGETNAME')"
262 |       return
263 |     end
264 |     #
265 |     #if ! options['t']
266 |     for item in %w[eruby erb erubis]
267 |       fname = "bench_#{item}.rhtml"
268 |       header = File.read("templates/_header.html")
269 |       #body   = File.read("templates/#{erubyfile}")
270 |       body   = File.read("templates/#{fname}")
271 |       footer = File.read("templates/_footer.html")
272 |       content = header + body + footer
273 |       File.write(fname, content)
274 |     end
275 |     #
276 |     if options['e']   # escape
277 |       tuples = [
278 |         [ 'bench_eruby.rhtml',  '<%= CGI.escapeHTML((\1).to_s) %>' ],
279 |         [ 'bench_erb.rhtml',    '<%=h \1 %>' ],
280 |         [ 'bench_erubis.rhtml', '<%== \1 %>' ],
281 |       ]
282 |       for fname, replace in tuples
283 |         content = File.read(fname).gsub(/<%= ?(.*?) ?%>/, replace)
284 |         File.write(fname, content)
285 |       end
286 |       targets.delete('Erubis::TinyEruby')   ## because TinyEruby doesn't support '<%== =>'
287 |     end
288 |     #
289 |     context = YAML.load_file(contextfile)
290 |     #
291 |     params = {
292 |       :printout=>options['p'],
293 |       :testmode=>testmode,
294 |     }
295 |     app = BenchmarkApplication.new(ntimes, context, targets, params)
296 |     app.perform_benchmark()
297 |   end
298 | 
299 | end
300 | 
301 | 
302 | if __FILE__ == $0
303 | 
304 |   ## open /dev/null
305 |   $stdout = File.open('/dev/null', 'w')
306 |   at_exit do
307 |     $stdout.close()
308 |   end
309 | 
310 |   ## start benchmark
311 |   MainApplication.new().execute()
312 | 
313 | end
314 | 


--------------------------------------------------------------------------------
/test/erbse_test.rb:
--------------------------------------------------------------------------------
  1 | require "test_helper"
  2 | 
  3 | #ob_0 = '';;ob_0<< ( true ).to_s;ob_0 << ' '.freeze;;ob_1 =  form_for do ; ob_2='';;ob_2<< ( 1 ).to_s;;ob_2<< ( 2 ).to_s;;ob_3 =  nested do ; ob_4='';;ob_4<< ( 3 ).to_s;;ob_4<< ( 4 ).to_s;ob_4; end ;ob_2 << ob_3;ob_3; end ;ob_1 << ob_2;ob_0.to_s
  4 | 
  5 | class ErbseTest < Minitest::Spec
  6 |   let (:str) { %{
  7 | <%= true %>
  8 | Text
  9 | <%= form_for do %><%= 1 %><% 2 %>
 10 |   <%= nested do %>
 11 |     <%= this %>
 12 |     <a/>
 13 |   <% end %>
 14 | <% end %>}
 15 |   }
 16 | 
 17 |   it "what" do
 18 |     Erbse::Parser.new.(str).must_equal [:multi,
 19 |       [:static, "\n"], [:newline],
 20 |       [:dynamic, " true "],
 21 |       [:static, "\n"], [:newline],
 22 |       [:static, "Text\n"], [:newline],
 23 |       [:erb, :block, " form_for do ", [:multi,
 24 |         [:dynamic, " 1 "],
 25 |         [:code, " 2 "], 
 26 |         [:static, "\n"], [:newline],
 27 |         [:static, "  "],
 28 |         [:erb, :block, " nested do ", [:multi, 
 29 |           [:static, "\n"], [:newline],
 30 |           [:static, "    "],
 31 |           [:dynamic, " this "],
 32 |           [:static, "\n"], [:newline],
 33 |           [:static, "    <a/>\n"], [:newline],
 34 |           [:static, "  "],
 35 |           ]], 
 36 |         [:static, "\n"], [:newline]]]]
 37 |   end
 38 | 
 39 |   it "generates ruby" do
 40 |       code = %{_buf = []; _buf << (\"@@\".freeze); @; _buf << ( true ); _buf << (\"@@\".freeze); @; _buf << (\"Text@@\".freeze); @; _erbse_blockfilter1 =  form_for do ; _erbse_blockfilter2 = ''; _erbse_blockfilter2 << (( 1 ).to_s);  2 ; _erbse_blockfilter2 << (\"@@\".freeze); @; _erbse_blockfilter2 << (\"  \".freeze); _erbse_blockfilter3 =  nested do ; _erbse_blockfilter4 = ''; _erbse_blockfilter4 << (\"@@\".freeze); @; _erbse_blockfilter4 << (\"    \".freeze); _erbse_blockfilter4 << (( this ).to_s); _erbse_blockfilter4 << (\"@@\".freeze); @; _erbse_blockfilter4 << (\"    <a/>@@\".freeze); @; _erbse_blockfilter4 << (\"  \".freeze); _erbse_blockfilter4; end; _erbse_blockfilter2 << ((_erbse_blockfilter3).to_s); _erbse_blockfilter2 << (\"@@\".freeze); @; _erbse_blockfilter2; end; _buf << (_erbse_blockfilter1); _buf = _buf.join(\"\".freeze)}
 41 |     ruby = Erbse::Engine.new.(str).gsub("\n", "@").gsub('\n', "@@")
 42 |     # puts ruby
 43 |     ruby.must_equal code
 44 |   end
 45 | 
 46 |   describe "<% %>" do
 47 |     let (:str) { %{
 48 | <% 2.times do |i| %>
 49 |   <%= i+1 %>
 50 |   <% puts %>
 51 | <% end %>
 52 | 
 53 | <% if 1 == 1 %>
 54 |   Hello
 55 | <% end %>
 56 | }
 57 |     }
 58 |     it "what" do
 59 |       Erbse::Parser.new.(str).must_equal [:multi,
 60 |         [:static, "\n"], [:newline],
 61 |         [:block, " 2.times do |i| ", [:multi,
 62 |           [:static, "\n"], [:newline],
 63 |           [:static, "  "],
 64 |           [:dynamic, " i+1 "], 
 65 |           [:static, "\n"], [:newline], [:static, "  "],
 66 |           [:code, " puts "], 
 67 |           [:static, "\n"], [:newline]
 68 |           ]],
 69 |           [:static, "\n"], [:newline],
 70 |           [:static, "\n"], [:newline],
 71 |         [:block, " if 1 == 1 ", [:multi,
 72 |           [:static, "\n"], [:newline],
 73 |           [:static, "  Hello\n"], [:newline]]],
 74 |           [:static, "\n"], [:newline]]
 75 |     end
 76 | 
 77 |     it do
 78 |       ruby = Erbse::Engine.new.(str)
 79 |       ruby = ruby.gsub("\n", "@")
 80 |       # ruby.must_equal %{_buf = [];  self ;  2.times do |i| ; _buf << ( i+1 );  puts ; end; _buf = _buf.join(\"\".freeze)}
 81 |       ruby.must_equal '_buf = []; _buf << ("\n".freeze); @;  2.times do |i| ; _buf << ("\n".freeze); @; _buf << ("  ".freeze); _buf << ( i+1 ); _buf << ("\n".freeze); @; _buf << ("  ".freeze);  puts ; _buf << ("\n".freeze); @; end; _buf << ("\n".freeze); @; _buf << ("\n".freeze); @;  if 1 == 1 ; _buf << ("\n".freeze); @; _buf << ("  Hello\n".freeze); @; end; _buf << ("\n".freeze); @; _buf = _buf.join("".freeze)'
 82 |     end
 83 | 
 84 |     it do
 85 |       ruby = Erbse::Engine.new.(str)
 86 |       eval(ruby).must_equal "\n\n  1\n  \n\n  2\n  \n\n\n\n  Hello\n\n"
 87 |     end
 88 |   end
 89 | 
 90 |   describe "pure text" do
 91 |     let (:str) { %{Holla
 92 | Hi}
 93 |     }
 94 |     it { Erbse::Parser.new.(str).must_equal [:multi, [:static, "Holla\n"], [:newline], [:static, "Hi"]] }
 95 |   end
 96 | 
 97 |   # comments
 98 |   describe "<%# this %>" do
 99 |     let (:str) { %{Hello
100 | <%# Ignore this %>
101 | Hola
102 | <%# Ignore
103 | this %>
104 | Hi
105 | <% # this %>
106 | } }
107 | 
108 |     it do
109 |       Erbse::Parser.new.(str).must_equal [:multi, [:static, "Hello\n"], [:newline], [:static, "\n"], [:newline], [:static, "Hola\n"], [:newline], [:newline], [:static, "\n"], [:newline], [:static, "Hi\n"], [:newline], [:code, " # this "], [:static, "\n"], [:newline]]
110 |     end
111 | 
112 |     it do
113 |       ruby = Erbse::Engine.new.(str).gsub("\n", "@").gsub('\n', "@@")
114 |       code = %{_buf = []; _buf << (\"Hello@@\".freeze); @; _buf << (\"@@\".freeze); @; _buf << (\"Hola@@\".freeze); @; @; _buf << (\"@@\".freeze); @; _buf << (\"Hi@@\".freeze); @;  # this ; _buf << (\"@@\".freeze); @; _buf = _buf.join(\"\".freeze)}
115 |       ruby.must_equal code
116 |     end
117 | 
118 |     # <%# end %>
119 |     it { Erbse::Parser.new.(%{Yo
120 | <%# bla do %>
121 | <%# end %>
122 | 1}).must_equal [:multi, [:static, "Yo\n"], [:newline], [:static, "\n"], [:newline], [:static, "\n"], [:newline], [:static, "1"]] }
123 |   end
124 | 
125 |   describe "content after last ERB tag" do
126 |     let (:str) { %{<b><%= 1 %>bla
127 | blubb</b>} }
128 | 
129 |     it { Erbse::Parser.new.(str).must_equal [:multi, [:static, "<b>"], [:dynamic, " 1 "], [:static, "bla\n"], [:newline], [:static, "blubb</b>"]] }
130 |   end
131 | 
132 |   describe "<%* %>" do
133 |     it { Erbse::Parser.new.(%{<%- 1 %>}).must_equal [:multi, [:code, " 1 "]] }
134 |     it { Erbse::Parser.new.(%{<%% 1 %>}).must_equal [:multi, [:code, " 1 "]] }
135 |     it { Erbse::Parser.new.(%{<%% 1 -%>}).must_equal [:multi, [:code, " 1 "]] }
136 |   end
137 | 
138 |   describe "<% var = 1 %>" do
139 |     let (:str) { %{<% var = 1 %><%= var %>} }
140 |     it { eval(Erbse::Engine.new.(str)).must_equal "1" }
141 |   end
142 | 
143 |   describe "postfix conditional in expression tag" do
144 |     let (:str) { %{<p><%= 'test' if true %></p>} }
145 |     it { eval(Erbse::Engine.new.(str)).must_equal "<p>test</p>" }
146 |   end
147 | 
148 |   describe "postfix conditional in execution tag" do
149 |     let (:str) { %{<p><% foo = 'test' if true %><%= foo %></p>} }
150 |     it { eval(Erbse::Engine.new.(str)).must_equal "<p>test</p>" }
151 |   end
152 | 
153 |   describe "condition in multiline expression tag" do
154 |     let (:str) { %{<p><%= if true
155 |                            'test'
156 |                           end %></p>} }
157 |     it { eval(Erbse::Engine.new.(str)).must_equal "<p>test</p>" }
158 |   end
159 | 
160 |   describe "multiline do-end-block in expression tag" do
161 |     let (:str) { %{<%= [1,2].map do |i|
162 |                  i+1
163 |                end.join %>} }
164 |     it { eval(Erbse::Engine.new.(str)).must_equal "23" }
165 |   end
166 | 
167 |   describe "multiline {}-block in expression tag" do
168 |     let (:str) { %(<%= [3,1].map { |i|
169 |                  i+1
170 |                }.join %>) }
171 |     it { eval(Erbse::Engine.new.(str)).must_equal "42" }
172 |   end
173 | 
174 |   describe "<% \"string with do\" %>" do
175 |     it { Erbse::Parser.new.(%{<% var = "do 1" %><%= var %>}).must_equal [:multi, [:code, " var = \"do 1\" "], [:dynamic, " var "]] }
176 |     it { Erbse::Parser.new.(%{<% var = " do 1" %><%= var %>}).must_equal [:multi, [:code, " var = \" do 1\" "], [:dynamic, " var "]] }
177 |   end
178 | 
179 |   describe "do" do
180 |     it { Erbse::Parser.new.(%{<% form do %>1<% end %>}).must_equal [:multi, [:block, " form do ", [:multi, [:static, "1"]]]] }
181 |     it { Erbse::Parser.new.(%{<% form do |i| %>1<% end %>}).must_equal [:multi, [:block, " form do |i| ", [:multi, [:static, "1"]]]] }
182 |   end
183 | 
184 |   describe "quoted conditional" do
185 |     let (:str2) { %{
186 |   <%= form_for do %>
187 |     <%= link_to "string", path, "v-if" => "trigger" %>
188 |   <% end %>}
189 |     }
190 | 
191 |     it "parses quoted conditionals correctly" do
192 |       Erbse::Parser.new.(str2).must_equal [:multi,
193 |         [:static, "\n"],
194 |         [:newline],
195 |         [:static, "  "],
196 |         [:erb, :block, " form_for do ", [:multi,
197 |           [:static, "\n"],
198 |           [:newline],
199 |           [:static, "    "],
200 |           [:dynamic, " link_to \"string\", path, \"v-if\" => \"trigger\" "],
201 |           [:static, "\n"],
202 |           [:newline],
203 |           [:static, "  "]
204 |         ]]]
205 |     end
206 |   end
207 |   
208 |   describe "newlines" do
209 |     let (:str2) { %{
210 |   abc
211 |   <%= 'foo' %>
212 |   def}
213 |     }
214 | 
215 |     it "puts newlines after code" do
216 |       Erbse::Parser.new.(str2).must_equal [:multi,
217 |         [:static, "\n"],
218 |         [:newline],
219 |         [:static, "  abc\n"],
220 |         [:newline],
221 |         [:static, "  "],
222 |         [:dynamic, " 'foo' "],
223 |         [:static, "\n"],
224 |         [:newline],
225 |         [:static, '  def'],
226 |       ]
227 |     end
228 |   end
229 | 
230 |   describe "<%@ %>" do
231 |     let (:str) { %{<%@ content = capture do %>
232 |   Yo!
233 |   <%= 1 %>
234 | <% end %>} }
235 | 
236 |     it do
237 |       ruby = Erbse::Engine.new.(str).gsub("\n", "@").gsub('\n', "@@")
238 |       code = %{_buf = []; content = capture do ; _erbse_blockfilter1 = ''; _erbse_blockfilter1 << (\"@@\".freeze); @; _erbse_blockfilter1 << (\"  Yo!@@\".freeze); @; _erbse_blockfilter1 << (\"  \".freeze); _erbse_blockfilter1 << (( 1 ).to_s); _erbse_blockfilter1 << (\"@@\".freeze); @; _erbse_blockfilter1; end; _buf = _buf.join(\"\".freeze)}
239 |       ruby.must_equal code
240 |     end
241 | 
242 |     it do
243 |       Erbse::Parser.new.(%{<%@content = capture do %><% end %>}).must_equal [:multi, [:block, "@content = capture do ", [:multi]]]
244 |     end
245 |   end
246 | end
247 | 


--------------------------------------------------------------------------------