erbse 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37f385edabdf30c0807542d7c5560537b5db5f82
-  data.tar.gz: 0bd510e68988198ff9e4ef3f3e796900fde9a41a
+  metadata.gz: df7ee95b6879b5591ad8cd4ee86fd374ac12e66d
+  data.tar.gz: a4c1100201726eebaada8b091c763d1b1925892c
 SHA512:
-  metadata.gz: 69a822ab5ad04ec4495f484353b9cdce8780a9b78cb25018b57193ec670224a18e10470e0c88b84c01639cfb817456d322a77057e912e04852627209f2ae7bfb
-  data.tar.gz: 80e5540f89a2ac0922730960d1c291e7bdd117a3db70b4b9c74f03245dc1945a279d7f59a008b806d5153d53da17b0dcfe7915b6c6814a9c692dddcdf7487c59
+  metadata.gz: 999650c0c6f0e0ac13d597874b10f62010ae573f04a51964f50a43543808c58b6b1a53456d4f931a6d0cfe41f6272cb22c8cd225e21913edb961a795585663d7
+  data.tar.gz: 42fb43d4d2de42d32c97e9e752175c1170395a9361be975c6ca59c65f5c6298055aea1430f421b755d850effd776b4c85c809b6c4d7b81af46d63f1f981114be

data/CHANGES.md

@@ -1,3 +1,11 @@
+# 0.1.0
+
+* 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! 😘
+* Yielding ERB blocks will simply return the content, no output buffering with instance variables will happen.
+    This allows to pass ERB blocks around and yield them in other objects without having it output twice as in 0.0.2.
+* 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.
+* Removed `Erbse::Template`, it was completely unnecessary code.
+
 # 0.0.2
 
-* First release. No escaping is happening and I'm not sure how capture works, yet. But: it's great!
+* First release. No escaping is happening and I'm not sure how capture works, yet. But: it's great!

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
-gemspec
+gemspec
+
+gem "minitest-line"

data/README.md

@@ -2,32 +2,54 @@
 
 _An updated version of Erubis._
 
-Erbse compiles an ERB string to a string of Ruby. It is completely decoupled from any framework and does only one thing. Pretty boring, I know.
+Erbse compiles an ERB string to a string of Ruby.
 
-## Added features
+## API
 
-* Block support a la Rails.
+The API is one public method.
 
-  ```erb
-  <%= form_tag .. do |f| %>
-    <%= f.fields_for do %>
-     ...
-    <% end %>
-  <% end %>
-  ```
+```ruby
+Erbse::Engine.new.call("<% ... %>") #=> string of compiled ruby.
+```
 
-## API
+The returned string can then be `eval`uated in a certain context.
+
+## Block Yielding
 
-The API is extremely simple.
+Erbse supports blocks à la Rails.
+
+You may pass any mix of text/ERB via blocks to Ruby methods.
+
+```erb
+<%= form do %>
+  <em>Please fill out all fields!</em>
+  <%= input :email %>
+  <button type="submit">
+<% end %>
+```
+
+Here, the `form` method receives a block of compiled Ruby.
+
+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**.
 
 ```ruby
-Erbse::Template.new("<% ... %>").call #=> string of compiled ruby.
+def form(&block)
+  content = yield
+  "<form>#{content}</form>"
+end
 ```
+Usually, returning the content from the helper will be sufficient.
+
+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.
 
-Template only accepts a content string which is the ERB template. The only public `#call` method returns a string of the compiled template that can then be evaluated in a context.
+## Removed Features
 
-The user layer, like Tilt, has to take care of caching the `Erbse::Template` instances.
+Erbse does *not* support any tags other than `<% %>` and `<%= %>`. Tags such as `<%% %>`, `<%== %>`, `<%- %>` or `<% -%>` will be reduced to the supported tags.
 
+## TODO
+
+* Block comments
+* Add newlines in compiled Ruby.
 
 ## Planned
 
@@ -45,20 +67,17 @@ This fragment could then be overridden.
 
 Feel free to contribute!!!
 
+## Users
 
-## Used where?
-
-Erbse is the ERB engine in [Cells 4](https://github.com/apotonick/cells).
-
-It also hopefully gets used in Rails 5/6, so we can remove those horrible hacks from AV.
-
+Erbse is the ERB engine in [Cells](https://github.com/apotonick/cells).
 
-# License
+## License
 
 MIT License
 
-# Contributors
+## Contributors
 
+* Special thanks to [Aman Gupta](https://github.com/tmm1) for [performance tweaks](https://github.com/rails/rails/pull/9555) that are merged in Erbse.
 * @iazel
 * @seuros
 

data/erbse.gemspec

@@ -19,6 +19,8 @@ Gem::Specification.new do |spec|
   spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "temple"
+
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
 end

data/lib/erbse.rb

@@ -1,49 +1,35 @@
-##
-## an implementation of eRuby
-##
-## ex.
-##   input = <<'END'
-##    <ul>
-##     <% for item in @list %>
-##      <li><%= item %>
-##          <%== item %></li>
-##     <% end %>
-##    </ul>
-##   END
-##   list = ['<aaa>', 'b&b', '"ccc"']
-##   eruby = Erubis::Eruby.new(input)
-##   puts "--- code ---"
-##   puts eruby.src
-##   puts "--- result ---"
-##   context = Erubis::Context.new()   # or new(:list=>list)
-##   context[:list] = list
-##   puts eruby.evaluate(context)
-##
-## result:
-##   --- source ---
-##   _buf = ''; _buf << '<ul>
-##   ';  for item in @list
-##    _buf << '  <li>'; _buf << ( item ).to_s; _buf << '
-##   '; _buf << '      '; _buf << Erubis::XmlHelper.escape_xml( item ); _buf << '</li>
-##   ';  end
-##    _buf << '</ul>
-##   ';
-##   _buf.to_s
-##   --- result ---
-##    <ul>
-##      <li><aaa>
-##          &lt;aaa&gt;</li>
-##      <li>b&b
-##          b&amp;b</li>
-##      <li>"ccc"
-##          &quot;ccc&quot;</li>
-##    </ul>
-##
-
+require "temple"
+require "erbse/parser"
 
 module Erbse
+  class BlockFilter < Temple::Filter
+    # Highly inspired by https://github.com/slim-template/slim/blob/master/lib/slim/controls.rb#on_slim_output
+    def on_erb_block(code, content_ast)
+      # this is for <%= do %>
+      outter_i = unique_name
+      inner_i  = unique_name
+
+      # this still needs the Temple::Filters::ControlFlow run-through.
+      [:multi,
+        [:block, "#{outter_i} = #{code}",
+          [:capture, inner_i, compile(content_ast)] # compile() is recursion on nested block content.
+        ],
+        [:dynamic, outter_i] # return the outter buffer. # DISCUSS: why do we need that, again?
+      ]
+    end
+  end
+
+  class Engine < Temple::Engine
+    use Parser
+    use BlockFilter
+
+    # filter :MultiFlattener
+    # filter :StaticMerger
+    # filter :DynamicInliner
+    filter :ControlFlow
+
+    generator :ArrayBuffer
+  end
+  # DISCUSS: can we add more optimizers?
 end
 
-require "erbse/converter"
-require "erbse/template"
-require "erbse/eruby"

data/lib/erbse/parser.rb

@@ -0,0 +1,62 @@
+module Erbse
+  class Parser
+    # ERB_EXPR = /<%(=|\#)?(.*?)%>(\n)*/m # this is the desired pattern.
+    ERB_EXPR = /<%(=+|-|\#|%)?(.*?)[-=]?%>(\n)*/m # this is for backward-compatibility.
+    # BLOCK_EXPR     = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+    BLOCK_EXPR = /\b(if|unless)\b|\bdo\b/
+
+    def initialize(*)
+    end
+
+    def call(str)
+      pos = 0
+      buffers = []
+      result = [:multi]
+      buffers << result
+      match = nil
+
+      str.scan(ERB_EXPR) do |indicator, code, newlines|
+        match = Regexp.last_match
+        len  = match.begin(0) - pos
+
+        text = str[pos, len]
+        pos  = match.end(0)
+        ch   = indicator ? indicator[0] : nil
+
+        if text and !text.strip.empty? # text
+          buffers.last << [:static, text]
+        end
+
+        if ch == ?= # <%= %>
+          if code =~ BLOCK_EXPR
+            buffers.last << [:erb, :block, code, block = [:multi]] # picked up by our own BlockFilter.
+            buffers << block
+          else
+            buffers.last << [:dynamic, code]
+          end
+        elsif code =~ /\bend\b/ # <% end %>
+          buffers.pop
+        elsif ch =~ /#/ # DISCUSS: doesn't catch <% # this %>
+          newlines = code.count("\n")
+          buffers.last.concat  [[:newline]] * newlines if newlines > 0
+        else # <% %>
+          if code =~ BLOCK_EXPR
+            buffers.last << [:block, code, block = [:multi]] # picked up by Temple's ControlFlow filter.
+            buffers << block
+          else
+            buffers.last << [:code, code]
+          end
+        end
+
+        # FIXME: only adds one newline.
+        # TODO: does that influence speed?
+        buffers.last << [:newline] if newlines
+      end
+
+      # add text after last/none ERB tag.
+      buffers.last << [:static, str[pos..str.length]] if pos < str.length
+
+      buffers.last
+    end
+  end
+end

data/lib/erbse/version.rb

@@ -1,3 +1,3 @@
 module Erbse
-  VERSION = "0.0.2"
-end
+  VERSION = "0.1.0"
+end

data/test/erbse_test.rb

@@ -1,14 +1,116 @@
 require "test_helper"
 
-# most tests are via cells-erb.
+#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
 
-class ErbseTest < MiniTest::Spec
-  it do
-    Erbse::Template.new(%{<%- text = "Hello" %> <%= text %>}).call.must_equal "@output_buffer = output_buffer; text = \"Hello\" ;@output_buffer.safe_append=' '.freeze;@output_buffer.append=( text );@output_buffer.to_s"
+class ErbseTest < Minitest::Spec
+  let (:str) { %{
+<%= true %>
+Text
+<%= form_for do %><%= 1 %><% 2 %>
+  <%= nested do %>
+    <%= this %>
+    <a/>
+  <% end %>
+<% end %>}
+  }
+
+  it "what" do
+    Erbse::Parser.new.(str).must_equal [:multi,
+      [:dynamic, " true "], [:newline],
+      [:static, "Text\n"],
+      [:erb, :block, " form_for do ", [:multi,
+        [:dynamic, " 1 "],
+        [:code, " 2 "], [:newline],
+        [:erb, :block, " nested do ", [:multi, [:newline],
+          [:dynamic, " this "], [:newline],
+          [:static, "    <a/>\n  "],
+          ]], [:newline]]]]
+  end
+
+  it "generates ruby" do
+      code = %{_buf = []; _buf << ( true ); @; _buf << ("Text@@".freeze); _erbse_blockfilter1 =  form_for do ; _erbse_blockfilter2 = ''; _erbse_blockfilter2 << (( 1 ).to_s);  2 ; @; _erbse_blockfilter3 =  nested do ; _erbse_blockfilter4 = ''; @; _erbse_blockfilter4 << (( this ).to_s); @; _erbse_blockfilter4 << ("    <a/>@@  ".freeze); _erbse_blockfilter4; end; _erbse_blockfilter2 << ((_erbse_blockfilter3).to_s); @; _erbse_blockfilter2; end; _buf << (_erbse_blockfilter1); _buf = _buf.join("".freeze)}
+    ruby = Erbse::Engine.new.(str).gsub("\n", "@").gsub('\n', "@@")
+    # puts ruby
+    ruby.must_equal code
+  end
+
+  describe "<% %>" do
+    let (:str) { %{
+<% self %>
+<% 2.times do |i| %>
+  <%= i+1 %>
+  <% puts %>
+<% end %>
+
+<% if 1 %>
+  Hello
+<% end %>
+}
+    }
+    it "what" do
+      Erbse::Parser.new.(str).must_equal [:multi,
+        [:code, " self "], [:newline],
+        [:block, " 2.times do |i| ", [:multi, [:newline],
+          [:dynamic, " i+1 "], [:newline],
+          [:code, " puts "], [:newline]]], [:newline],
+        [:block, " if 1 ", [:multi, [:newline],
+          [:static, "  Hello
+"]]], [:newline]]
+    end
+
+    it do
+      ruby = Erbse::Engine.new.(str)
+      ruby = ruby.gsub("\n", "@")
+
+      # ruby.must_equal %{_buf = [];  self ;  2.times do |i| ; _buf << ( i+1 );  puts ; end; _buf = _buf.join(\"\".freeze)}
+      ruby.must_equal '_buf = [];  self ; @;  2.times do |i| ; @; _buf << ( i+1 ); @;  puts ; @; end; @;  if 1 ; @; _buf << ("  Hello\n".freeze); end; @; _buf = _buf.join("".freeze)'
+    end
+
+    it do
+      ruby = Erbse::Engine.new.(str)
+      eval(ruby).must_equal "12  Hello\n"
+    end
+  end
+
+  describe "pure text" do
+    let (:str) { %{Holla
+Hi}
+    }
+    it { Erbse::Parser.new.(str).must_equal [:multi, [:static, "Holla\nHi"]] }
+  end
+
+  # comments
+  describe "<%# this %>" do
+    let (:str) { %{Hello
+<%# Ignore this %>
+Hola
+<%# Ignore
+this %>
+Hi
+<% # this %>
+} }
+
+    it do
+      Erbse::Parser.new.(str).must_equal [:multi, [:static, "Hello\n"], [:newline], [:static, "Hola\n"], [:newline], [:newline], [:static, "Hi\n"], [:code, " # this "], [:newline]]
+    end
+
+    it do
+      ruby = Erbse::Engine.new.(str).gsub("\n", "@").gsub('\n', "@@")
+      code = %{_buf = []; _buf << ("Hello@@".freeze); @; _buf << ("Hola@@".freeze); @; @; _buf << ("Hi@@".freeze);  # this ; @; _buf = _buf.join("".freeze)}
+      ruby.must_equal code
+    end
+  end
+
+  describe "content after last ERB tag" do
+    let (:str) { %{<b><%= 1 %>bla
+blubb</b>} }
+
+    it { Erbse::Parser.new.(str).must_equal [:multi, [:static, "<b>"], [:dynamic, " 1 "], [:static, "bla\nblubb</b>"]] }
   end
 
-  # nested <%= block do %> syntax.
-  it do
-    Erbse::Template.new(%{<%= form_for do %><%= content_tag :div do %>DIV<% end %><% end %>}).call.must_equal "@output_buffer = output_buffer;@output_buffer.append=  form_for do @output_buffer.append=  content_tag :div do @output_buffer.safe_append='DIV'.freeze; end ; end ;@output_buffer.to_s"
+  describe "<%* %>" do
+    it { Erbse::Parser.new.(%{<%- 1 %>}).must_equal [:multi, [:code, " 1 "]] }
+    it { Erbse::Parser.new.(%{<%% 1 %>}).must_equal [:multi, [:code, " 1 "]] }
+    it { Erbse::Parser.new.(%{<%% 1 -%>}).must_equal [:multi, [:code, " 1 "]] }
   end
-end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: erbse
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-25 00:00:00.000000000 Z
+date: 2016-10-05 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: temple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -60,9 +74,7 @@ files:
 - benchmark/templates/bench_eruby.rhtml
 - erbse.gemspec
 - lib/erbse.rb
-- lib/erbse/converter.rb
-- lib/erbse/eruby.rb
-- lib/erbse/template.rb
+- lib/erbse/parser.rb
 - lib/erbse/version.rb
 - test/erbse_test.rb
 - test/test_helper.rb
@@ -86,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Updated Erubis.

data/lib/erbse/converter.rb

@@ -1,157 +0,0 @@
-module Erbse
-  # convert input string into target language
-  class Converter
-    def initialize(properties={}, generator)
-      init_converter!(properties)
-      @generator = generator
-    end
-
-    def convert(input) # TODO: rename to #call.
-      codebuf = ""    # or []
-      @preamble.nil? ? generator.add_preamble(codebuf) : (@preamble && (codebuf << @preamble))
-      convert_input(codebuf, input)
-      @postamble.nil? ? generator.add_postamble(codebuf) : (@postamble && (codebuf << @postamble))
-      @_proc = nil    # clear cached proc object
-      return codebuf  # or codebuf.join()
-    end
-
-  private
-    attr_accessor :preamble, :postamble, :escape
-
-    attr_reader :generator
-
-    def init_converter!(properties)
-      @preamble  = properties[:preamble]
-      @postamble = properties[:postamble]
-      @escape    = properties[:escape]
-    end
-
-    ##
-    ## detect spaces at beginning of line
-    ##
-    def detect_spaces_at_bol(text, is_bol)
-      lspace = nil
-      if text.empty?
-        lspace = "" if is_bol
-      elsif text[-1] == ?\n
-        lspace = ""
-      else
-        rindex = text.rindex(?\n)
-        if rindex
-          s = text[rindex+1..-1]
-          if s =~ /\A[ \t]*\z/
-            lspace = s
-            #text = text[0..rindex]
-            text[rindex+1..-1] = ''
-          end
-        else
-          if is_bol && text =~ /\A[ \t]*\z/
-            #lspace = text
-            #text = nil
-            lspace = text.dup
-            text[0..-1] = ''
-          end
-        end
-      end
-      return lspace
-    end
-  end
-
-
-  module Basic
-  end
-
-
-  ##
-  ## basic converter which supports '<% ... %>' notation.
-  ##
-  class Basic::Converter < Converter
-    def self.supported_properties    # :nodoc:
-      return [
-              [:pattern,  '<% %>', "embed pattern"],
-              [:trim,      true,   "trim spaces around <% ... %>"],
-             ]
-    end
-
-
-  private
-
-    attr_accessor :pattern, :trim
-
-    def init_converter!(properties={})
-      super(properties)
-      @pattern = properties[:pattern]
-      @trim    = properties[:trim] != false
-    end
-
-
-
-    ## return regexp of pattern to parse eRuby script
-    def self.pattern_regexp(pattern)
-      @prefix, @postfix = pattern.split()   # '<% %>' => '<%', '%>'
-      return /#{@prefix}(=+|-|\#|%)?(.*?)([-=])?#{@postfix}([ \t]*\r?\n)?/m
-    end
-
-    DEFAULT_REGEXP = pattern_regexp('<% %>')
-
-    def convert_input(src, input)
-      pat = @pattern
-      regexp = pat.nil? || pat == '<% %>' ? DEFAULT_REGEXP : pattern_regexp(pat)
-      pos = 0
-      is_bol = true     # is beginning of line
-      input.scan(regexp) do |indicator, code, tailch, rspace|
-        match = Regexp.last_match()
-        len  = match.begin(0) - pos
-        text = input[pos, len]
-        pos  = match.end(0)
-        ch   = indicator ? indicator[0] : nil
-        lspace = ch == ?= ? nil : detect_spaces_at_bol(text, is_bol)
-        is_bol = rspace ? true : false
-        generator.add_text(src, text) if text && !text.empty?
-        ## * when '<%= %>', do nothing
-        ## * when '<% %>' or '<%# %>', delete spaces iff only spaces are around '<% %>'
-        if ch == ?=              # <%= %>
-          rspace = nil if tailch && !tailch.empty?
-          generator.add_text(src, lspace) if lspace
-          add_expr(src, code, indicator)
-          generator.add_text(src, rspace) if rspace
-        elsif ch == ?\#          # <%# %>
-          n = code.count("\n") + (rspace ? 1 : 0)
-          if @trim && lspace && rspace
-            generator.add_stmt(src, "\n" * n)
-          else
-            generator.add_text(src, lspace) if lspace
-            generator.add_stmt(src, "\n" * n)
-            generator.add_text(src, rspace) if rspace
-          end
-        elsif ch == ?%           # <%% %>
-          s = "#{lspace}#{@prefix||='<%'}#{code}#{tailch}#{@postfix||='%>'}#{rspace}"
-          generator.add_text(src, s)
-        else                     # <% %>
-          if @trim && lspace && rspace
-            generator.add_stmt(src, "#{lspace}#{code}#{rspace}")
-          else
-            generator.add_text(src, lspace) if lspace
-            generator.add_stmt(src, code)
-            generator.add_text(src, rspace) if rspace
-          end
-        end
-      end
-      #rest = $' || input                        # ruby1.8
-      rest = pos == 0 ? input : input[pos..-1]   # ruby1.9
-      generator.add_text(src, rest)
-    end
-
-    ## add expression code to src
-    def add_expr(src, code, indicator)
-      case indicator
-      when '='
-        @escape ? generator.add_expr_escaped(src, code) : generator.add_expr_literal(src, code)
-      when '=='
-        @escape ? generator.add_expr_literal(src, code) : generator.add_expr_escaped(src, code)
-      when '==='
-        generator.add_expr_debug(src, code)
-      end
-    end
-  end
-end

data/lib/erbse/eruby.rb

@@ -1,114 +0,0 @@
-module Erbse
-  class RubyGenerator
-    def init_generator(properties={})
-      @escapefunc ||= "Erubis::XmlHelper.escape_xml"
-    end
-
-    def escape_text(text)
-      text.gsub(/['\\]/, '\\\\\&')   # "'" => "\\'",  '\\' => '\\\\'
-    end
-
-    def escaped_expr(code)
-      return "#{@escapefunc}(#{code})"
-    end
-
-    #--
-    #def add_preamble(src)
-    #  src << "#{@bufvar} = [];"
-    #end
-    #++
-    def add_preamble(src)
-      @newline_pending = 0
-      src << "@output_buffer = output_buffer;" # DISCUSS: i removed the output_buffer || ActionView::OB.new rubbish here.
-    end
-
-    # def add_text(src, text)
-    #   src << " #{@bufvar} << '" << escape_text(text) << "';" unless text.empty?
-    # end
-    def add_text(src, text)
-      return if text.empty?
-
-      if text == "\n"
-        @newline_pending += 1
-      else
-        src << "@output_buffer.safe_append='"
-        src << "\n" * @newline_pending if @newline_pending > 0
-        src << escape_text(text)
-        src << "'.freeze;"
-
-        @newline_pending = 0
-      end
-    end
-
-    # Erubis toggles <%= and <%== behavior when escaping is enabled.
-    # We override to always treat <%== as escaped.
-    # def add_expr(src, code, indicator)
-    #   case indicator
-    #   when '=='
-    #     add_expr_escaped(src, code)
-    #   else
-    #     super
-    #   end
-    # end
-
-    def ____add_stmt(src, code)
-      src << code
-      src << ';' unless code[-1] == ?\n
-    end
-
-    def add_stmt(src, code)
-      flush_newline_if_pending(src)
-      ____add_stmt(src, code)
-    end
-
-    # def add_expr_literal(src, code)
-    #   src << " #{@bufvar} << (" << code << ').to_s;'
-    # end
-    BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
-
-    def add_expr_literal(src, code)
-      flush_newline_if_pending(src)
-      if code =~ BLOCK_EXPR
-        src << '@output_buffer.append= ' << code
-      else
-        src << '@output_buffer.append=(' << code << ');'
-      end
-    end
-
-    def add_expr_escaped(src, code)
-      flush_newline_if_pending(src)
-      if code =~ BLOCK_EXPR
-        src << "@output_buffer.safe_expr_append= " << code
-      else
-        src << "@output_buffer.safe_expr_append=(" << code << ");"
-      end
-    end
-
-    # def add_expr_escaped(src, code)
-    #   src << " #{@bufvar} << " << escaped_expr(code) << ';'
-    # end
-
-    def add_expr_debug(src, code)
-      code.strip!
-      s = (code.dump =~ /\A"(.*)"\z/) && $1
-      src << ' $stderr.puts("*** debug: ' << s << '=#{(' << code << ').inspect}");'
-    end
-
-    #--
-    #def add_postamble(src)
-    #  src << "\n#{@bufvar}.join\n"
-    #end
-    #++
-    def add_postamble(src)
-      flush_newline_if_pending(src)
-      src << '@output_buffer.to_s'
-    end
-
-    def flush_newline_if_pending(src)
-      if @newline_pending > 0
-        src << "@output_buffer.safe_append='#{"\n" * @newline_pending}'.freeze;"
-        @newline_pending = 0
-      end
-    end
-  end
-end

data/lib/erbse/template.rb

@@ -1,14 +0,0 @@
-module Erbse
-  # Compiles the runtime method for an ERB input string.
-  class Template
-    def initialize(input, properties={})
-      generator = RubyGenerator.new
-      converter = Basic::Converter.new(properties, generator)
-      @src      = converter.convert(input)
-    end
-
-    def call
-      @src
-    end
-  end
-end