erubi 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cefbc9c1251647b1876b855e13cde7e22fe0877b
-  data.tar.gz: b237d3a6ad613c5f48a1fafa65aa01675fcfb59a
+  metadata.gz: ba16a36a1aa6da80b461f49724bf565bbd3245e5
+  data.tar.gz: 91c6545b66c34061ed72b00292a1a882cb4b6d45
 SHA512:
-  metadata.gz: 18e593606c5c1b881bd52f20a5b9800b5dd058264cc38f609c8251e3be220d8d1a3540066dc7dfffe9143ebfdacc5af6dab7c21e22aaea9ea945dc9ecaaa0b62
-  data.tar.gz: 13a3fa3d9d49edc442a32f4d4ee41d1262e471dd524b6693af392019d04d4563ff632a3e55c8e01d37fca1650b42ce07335e0abc8dbda243dd17f9d3437bd339
+  metadata.gz: 75fb3e6d36720ceefec4de3358b7052de90e6de7bb1d28570878f3bfc38fda5a2696c0c66e0b4159a22fdb5c5c63d95aeed78bbd5b3caeb0fc417a044679bb4d
+  data.tar.gz: f7edc95fef95ffce7537ea88ac3a68216c56cb999977b2008da27c50e9577e644776b44d6eda8d18366ee3235d0ee819e6552deb3d354b3ca67308aebe35a6a7

data/CHANGELOG

@@ -1,3 +1,23 @@
+=== 1.1.0 (2016-11-14)
+
+* Add :ensure option to supporting restoring bufvar to original value (jeremyevans)
+
+* Don't have tilt support require erb (jeremyevans)
+
+* Support :engine_class option in tilt support to override engine class used (jeremyevans)
+
+* Support :capture option in tilt support to use Erubi::CaptureEngine (jeremyevans)
+
+* Add erubi/capture file containing Erubi::CaptureEngine, allowing <%|= and <%|== for capture (and escaping) blocks in templates (jeremyevans)
+
+* Raise ArgumentError if template source code contains indicators matched by regexp but not handled (jeremyevans)
+
+* Add :bufval option to support arbitrary buffer values (jeremyevans)
+
+* Add :regexp option to specify regexp used for scanning (jeremyevans)
+
+* Add :src option to specify initial template source (jeremyevans)
+
 === 1.0.0 (2016-11-10)
 
 * Initial Public Release

data/README.rdoc

@@ -3,11 +3,12 @@
 Erubi is a ERB template engine for ruby. It is a simplified fork of Erubis, with
 the following differences:
 
-* Handles postfix conditionals when using escaping (e.g. <tt><%= foo if bar %><tt>)
+* Handles postfix conditionals when using escaping (e.g. <tt><%= foo if bar %></tt>)
 * Supports frozen_string_literal: true in templates via :freeze option
 * Works with ruby's --enable-frozen-string-literal option
 * Escapes ' (apostrophe) when escaping for better XSS protection 
-* Has 90% smaller memory footprint
+* Has 90% smaller memory footprint for base engine
+* Has 75% smaller memory footprint for tilt support
 * Does no monkey patching (Erubis adds a method to Kernel)
 * Uses an immutable design (all options passed to the constructor, which returns a frozen object)
 * Has simpler internals (1 file, <100 lines of code)
@@ -18,7 +19,6 @@ It is not designed with Erubis API compatibility in mind, though most Erubis
 ERB syntax works, with the following exceptions:
 
 * No support for <tt><%===</tt> for debug output
-* No support for custom patterns
 
 = Installation
 
@@ -30,7 +30,7 @@ Source code is available on GitHub at https://github.com/jeremyevans/erubi
 
 = Usage
 
-The expected usage is via tilt, and erubi ships with tilt integration:
+The expected usage is via tilt, and erubi ships with tilt 2 integration:
 
   require 'tilt/erubi'
   Tilt.new("filename.erb").render
@@ -45,6 +45,23 @@ source:
   require 'erubi'
   eval(Erubi::Engine.new(File.read('filename.erb')).src)
 
+== Capturing
+
+Erubi does not support capturing block output into the template by default.
+However, it comes with an +erubi/capture+ file that supports capturing
+via <tt><%|=</tt> and <tt><%|==</tt> tags:
+
+  <%|= form do %>
+    <input>
+  <% end %>
+
+This offers similar functionality to that offered by Rails' <tt><%=</tt>
+tags, but without the corner cases with that approach (which are due to
+attempting to parse ruby code via a regexp).  Similar to the <tt><%=</tt>
+and <tt><%==</tt> tags, <tt><%|=</tt> captures by default and
+<tt><%|==</tt> captures and escapes by default, but this can be reversed
+via the +:escape_capture+ or +:escape+ options.
+
 = Reporting Bugs
 
 The bug tracker is located at https://github.com/jeremyevans/erubi/issues

data/lib/erubi.rb

@@ -2,11 +2,12 @@
 
 module Erubi
   ESCAPE_TABLE = {'&' => '&amp;'.freeze, '<' => '&lt;'.freeze, '>' => '&gt;'.freeze, '"' => '&quot;'.freeze, "'" => '&#039;'.freeze}.freeze
-  RANGE_FIRST = 0..0
   RANGE_ALL = 0..-1
-  RANGE_LAST = -1..-1
 
   if RUBY_VERSION >= '1.9'
+    RANGE_FIRST = 0
+    RANGE_LAST = -1
+
     # Escape the following characters with their HTML/XML
     # equivalents.
     def self.h(value)
@@ -14,6 +15,9 @@ module Erubi
     end
   else
     # :nocov:
+    RANGE_FIRST = 0..0
+    RANGE_LAST = -1..-1
+
     def self.h(value)
       value.to_s.gsub(/[&<>"']/){|s| ESCAPE_TABLE[s]}
     end
@@ -31,26 +35,33 @@ module Erubi
     attr_reader :bufvar
 
     # Initialize a new Erubi::Engine.  Options:
+    # :bufval :: The value to use for the buffer variable, as a string.
     # :bufvar :: The variable name to use for the buffer variable, as a string.
+    # :ensure :: Wrap the template in a begin/ensure block restoring the previous value of bufvar.
     # :escapefunc :: The function to use for escaping, as a string (default: ::Erubi.h).
     # :escape :: Whether to make <%= escape by default, and <%== not escape by default.
     # :escape_html :: Same as :escape, with lower priority.
     # :filename :: The filename for the template.
     # :freeze :: Whether to enable frozen string literals in the resulting source code.
     # :outvar :: Same as bufvar, with lower priority.
-    # :postable :: the postamble for the template, by default returns the resulting source code.
+    # :postamble :: The postamble for the template, by default returns the resulting source code.
     # :preamble :: The preamble for the template, by default initializes up the buffer variable.
+    # :regexp :: The regexp to use for scanning.
+    # :src :: The initial value to use for the source code
     # :trim :: Whether to trim leading and trailing whitespace, true by default.
     def initialize(input, properties={})
       escape     = properties.fetch(:escape){properties.fetch(:escape_html, false)}
       trim       = properties[:trim] != false
       @filename  = properties[:filename]
       @bufvar = bufvar = properties[:bufvar] || properties[:outvar] || "_buf"
-      preamble   = properties[:preamble] || "#{bufvar} = String.new;"
+      bufval = properties[:bufval] || 'String.new'
+      regexp = properties[:regexp] || /<%(={1,2}|-|\#|%)?(.*?)([-=])?%>([ \t]*\r?\n)?/m
+      preamble   = properties[:preamble] || "#{bufvar} = #{bufval};"
       postamble  = properties[:postamble] || "#{bufvar}.to_s\n"
 
-      @src = src = String.new
+      @src = src = properties[:src] || String.new
       src << "# frozen_string_literal: true\n" if properties[:freeze]
+      src << "begin; __original_outvar = #{bufvar} if defined?(#{bufvar}); " if properties[:ensure]
 
       unless escapefunc = properties[:escapefunc]
         if escape
@@ -65,12 +76,13 @@ module Erubi
 
       pos = 0
       is_bol = true
-      input.scan(/<%(={1,2}|-|\#|%)?(.*?)([-=])?%>([ \t]*\r?\n)?/m) do |indicator, code, tailch, rspace|
+      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[RANGE_FIRST] : nil
+
         lspace = nil
 
         unless ch == '='
@@ -98,7 +110,8 @@ module Erubi
 
         is_bol = rspace ? true : false
         add_text(text) if text && !text.empty?
-        if ch == '='
+        case ch
+        when '='
           rspace = nil if tailch && !tailch.empty?
           add_text(lspace) if lspace
           if ((indicator == '=') ^ escape)
@@ -107,7 +120,7 @@ module Erubi
             src << " #{bufvar} << #{escapefunc}((" << code << '));'
           end
           add_text(rspace) if rspace
-        elsif ch == '#'
+        when '#'
           n = code.count("\n") + (rspace ? 1 : 0)
           if trim
             add_code("\n" * n)
@@ -116,9 +129,9 @@ module Erubi
             add_code("\n" * n)
             add_text(rspace) if rspace
           end
-        elsif ch == '%'
+        when '%'
           add_text("#{lspace}#{prefix||='<%'}#{code}#{tailch}#{postfix||='%>'}#{rspace}")
-        else
+        when nil, '-'
           if trim
             add_code("#{lspace}#{code}#{rspace}")
           else
@@ -126,6 +139,8 @@ module Erubi
             add_code(code)
             add_text(rspace) if rspace
           end
+        else
+          handle(indicator, code, tailch, rspace, lspace)
         end
       end
       rest = pos == 0 ? input : input[pos..-1]
@@ -133,6 +148,7 @@ module Erubi
 
       src << "\n" unless src[RANGE_LAST] == "\n"
       src << postamble
+      src << "; ensure\n  #{bufvar} = __original_outvar\nend\n" if properties[:ensure]
       freeze
     end
 
@@ -148,5 +164,10 @@ module Erubi
       @src << code
       @src << ';' unless code[RANGE_LAST] == "\n"
     end
+
+    # Raise an exception, as the base engine class does not support handling other indicators.
+    def handle(indicator, code, tailch, rspace, lspace)
+      raise ArgumentError, "Invalid indicator: #{indicator}"
+    end
   end
 end

data/lib/erubi/capture.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'erubi'
+
+module Erubi
+  # A buffer class used for templates that support captures
+  class Buffer
+    def initialize
+      @bufs = [new_buffer]
+    end
+
+    # Return the current buffer
+    def buffer
+      @bufs.last
+    end
+
+    # Append to the current buffer
+    def <<(str)
+      buffer << str
+    end
+
+    # Add a new buffer, that future appends will go to.
+    def before_append!
+      @bufs << new_buffer
+    end
+
+    # Take the current buffer and append it to the previous buffer.
+    def append=(_)
+      buf = @bufs.pop
+      buffer << buf.to_s
+    end
+
+    # Escape the current buffer and append it to the previous buffer,
+    def escape=(_)
+      buf = @bufs.pop
+      buffer << escape(buf.to_s)
+    end
+
+    # Return the current buffer, as a string.
+    def to_s
+      buffer.to_s
+    end
+
+    private
+
+    # An object to use for the underlying buffers.
+    def new_buffer
+      String.new
+    end
+
+    # HTML/XML escape the given string.
+    def escape(str)
+      ::Erubi.h(str)
+    end
+  end
+
+  # An engine class that supports capturing blocks via the <%|= and <%|== tags.
+  class CaptureEngine < Engine
+    # Initializes the engine.  Accepts the same arguments as ::Erubi::Engine, and these
+    # additional options:
+    # :escape_capture :: Whether to make <%|= escape by default, and <%|== not escape by default,
+    #                    defaults to the same value as :escape.
+    def initialize(input, properties={})
+      properties = Hash[properties]
+      escape = properties.fetch(:escape){properties.fetch(:escape_html, false)}
+      @escape_capture = properties.fetch(:escape_capture, escape)
+      properties[:regexp] ||= /<%(\|?={1,2}|-|\#|%)?(.*?)([-=])?%>([ \t]*\r?\n)?/m
+      properties[:bufval] ||= "::Erubi::Buffer.new"
+      super
+    end
+
+    private
+
+    # Handle the <%|= and <%|== tags
+    def handle(indicator, code, tailch, rspace, lspace)
+      case indicator
+      when '|=', '|=='
+        rspace = nil if tailch && !tailch.empty?
+        add_text(lspace) if lspace
+        meth = ((indicator == '|=') ^ @escape_capture) ? 'append' : 'escape'
+        src << " #{@bufvar}.before_append!; #{@bufvar}.#{meth}= " << code
+        add_text(rspace) if rspace
+      else
+        super
+      end
+    end
+  end
+end

data/lib/tilt/erubi.rb

@@ -1,32 +1,28 @@
 require 'tilt'
-require 'tilt/erb'
+require 'tilt/template'
 require 'erubi'
 
 module Tilt
   # Erubi (a simplified version of Erubis) template implementation
-  class ErubiTemplate < ERBTemplate
+  class ErubiTemplate < Template
     def prepare
-      @options.merge!(:preamble => false, :postamble => false)
-      @engine = Erubi::Engine.new(data, @options)
-      @outvar = @engine.bufvar
-      @engine
-    end
+      @options.merge!(:preamble => false, :postamble => false, :ensure=>true)
 
-    def precompiled_preamble(locals)
-      [super, "#{@outvar} = _buf = String.new"].join("\n")
-    end
+      engine_class = if @options[:engine_class]
+        @options[:engine_class]
+      elsif @options[:capture]
+        Erubi::CaptureEngine
+      else
+        Erubi::Engine
+      end
 
-    def precompiled_postamble(locals)
-      [@outvar, super].join("\n")
+      @engine = engine_class.new(data, @options)
+      @outvar = @engine.bufvar
+      @engine
     end
 
-    # Erubi doesn't have ERB's line-off-by-one under 1.9 problem.
-    # Override and adjust back.
-    if RUBY_VERSION >= '1.9.0'
-      def precompiled(locals)
-        source, offset = super
-        [source, offset - 1]
-      end
+    def precompiled_template(locals)
+      @engine.src
     end
 
     Tilt.register self, 'erb', 'rhtml', 'erubi'

data/test/test.rb

@@ -22,6 +22,8 @@ if ENV['COVERAGE']
 end
 
 require 'erubi'
+require 'erubi/capture'
+require 'tilt/erubi'
 require 'minitest/spec'
 require 'minitest/autorun'
 
@@ -31,9 +33,21 @@ describe Erubi::Engine do
   end
 
   def check_output(input, src, result, &block)
-    t = Erubi::Engine.new(input, @options)
-    t.src.must_equal src
+    t = (@options[:engine] || Erubi::Engine).new(input, @options)
     eval(t.src, block.binding).must_equal result
+    t.src.must_equal src
+  end
+
+  def setup_foo
+    @foo = Object.new
+    @foo.instance_variable_set(:@t, self)
+    def self.a; @a; end
+    def @foo.bar
+      @t.a << "a"
+      yield
+      @t.a << 'b'
+      @t.a.buffer.upcase!
+    end
   end
 
   it "should handle no options" do
@@ -79,6 +93,138 @@ END2
 END3
   end
 
+  it "should handle ensure option" do
+    list = ['&\'<>"2']
+    @options[:ensure] = true
+    @options[:bufvar] = '@a'
+    @a = 'bar'
+    check_output(<<END1, <<END2, <<END3){}
+<table>
+ <tbody>
+  <% i = 0
+     list.each_with_index do |item, i| %>
+  <tr>
+   <td><%= i+1 %></td>
+   <td><%== item %></td>
+  </tr>
+ <% end %>
+ </tbody>
+</table>
+<%== i+1 %>
+END1
+begin; __original_outvar = @a if defined?(@a); @a = String.new; @a << '<table>
+ <tbody>
+';   i = 0
+     list.each_with_index do |item, i| 
+ @a << '  <tr>
+   <td>'; @a << ( i+1 ).to_s; @a << '</td>
+   <td>'; @a << ::Erubi.h(( item )); @a << '</td>
+  </tr>
+';  end 
+ @a << ' </tbody>
+</table>
+'; @a << ::Erubi.h(( i+1 )); @a << '
+';
+@a.to_s
+; ensure
+  @a = __original_outvar
+end
+END2
+<table>
+ <tbody>
+  <tr>
+   <td>1</td>
+   <td>&amp;&#039;&lt;&gt;&quot;2</td>
+  </tr>
+ </tbody>
+</table>
+1
+END3
+    @a.must_equal 'bar'
+  end
+
+  [['', false], ['=', true]].each do |ind, escape|
+    it "should allow <%|=#{ind} for capturing without escaping when :escape_capture => #{escape}" do
+      @options[:bufvar] = '@a'
+      @options[:capture] = true
+      @options[:escape_capture] = escape
+      @options[:escape] = !escape
+      @options[:engine] = ::Erubi::CaptureEngine
+      setup_foo
+      check_output(<<END1, <<END2, <<END3){}
+<table>
+ <tbody>
+  <%|=#{ind} @foo.bar do %>
+  <tr>
+   <td><%=#{ind} 1 %></td>
+   <td><%=#{ind} '&' %></td>
+  </tr>
+ <% end %>
+ </tbody>
+</table>
+END1
+#{'__erubi = ::Erubi;' unless escape}@a = ::Erubi::Buffer.new; @a << '<table>
+ <tbody>
+'; @a << '  '; @a.before_append!; @a.append=  @foo.bar do  @a << '
+'; @a << '  <tr>
+   <td>'; @a << #{!escape ? '__erubi' : '::Erubi'}.h(( 1 )); @a << '</td>
+   <td>'; @a << #{!escape ? '__erubi' : '::Erubi'}.h(( '&' )); @a << '</td>
+  </tr>
+';  end 
+ @a << ' </tbody>
+</table>
+';
+@a.to_s
+END2
+<table>
+ <tbody>
+  A
+  <TR>
+   <TD>1</TD>
+   <TD>&AMP;</TD>
+  </TR>
+B </tbody>
+</table>
+END3
+    end
+  end
+
+  [['', true], ['=', false]].each do |ind, escape|
+    it "should allow <%|=#{ind} for capturing with escaping when :escape => #{escape}" do
+      @options[:bufvar] = '@a'
+      @options[:capture] = true
+      @options[:escape] = escape
+      @options[:engine] = ::Erubi::CaptureEngine
+      setup_foo
+      check_output(<<END1, <<END2, <<END3){}
+<table>
+ <tbody>
+  <%|=#{ind} @foo.bar do %>
+   <b><%=#{ind} '&' %></b>
+ <% end %>
+ </tbody>
+</table>
+END1
+#{'__erubi = ::Erubi;' if escape}@a = ::Erubi::Buffer.new; @a << '<table>
+ <tbody>
+'; @a << '  '; @a.before_append!; @a.escape=  @foo.bar do  @a << '
+'; @a << '   <b>'; @a << #{escape ? '__erubi' : '::Erubi'}.h(( '&' )); @a << '</b>
+';  end 
+ @a << ' </tbody>
+</table>
+';
+@a.to_s
+END2
+<table>
+ <tbody>
+  A
+   &lt;B&gt;&amp;AMP;&lt;/B&gt;
+B </tbody>
+</table>
+END3
+    end
+  end
+
   [:outvar, :bufvar].each do |var|
     it "should handle :#{var} and :freeze options" do
       @options[var] = "@_out_buf"
@@ -339,8 +485,12 @@ END3
     Erubi::Engine.new('').frozen?.must_equal true
   end
 
+  it "should raise an error if a tag is not handled when a custom regexp is used" do
+    proc{Erubi::Engine.new('<%] %>', :regexp =>/<%(={1,2}|\]|-|\#|%)?(.*?)([-=])?%>([ \t]*\r?\n)?/m)}.must_raise ArgumentError
+    proc{Erubi::CaptureEngine.new('<%] %>', :regexp =>/<%(={1,2}|\]|-|\#|%)?(.*?)([-=])?%>([ \t]*\r?\n)?/m)}.must_raise ArgumentError
+  end
+
   it "should have working tilt support" do
-    require 'tilt/erubi'
     @list = ['&\'<>"2']
     Tilt::ErubiTemplate.new{<<END1}.render(self).must_equal(<<END2)
 <table>
@@ -365,6 +515,34 @@ END1
  </tbody>
 </table>
 1
+END2
+  end
+
+  it "should have working tilt support for capturing" do
+    setup_foo
+    Tilt::ErubiTemplate.new(:capture=>true, :outvar=>'@a'){<<END1}.render(self).must_equal(<<END2)
+1<%|= @foo.bar do %>bar<% end %>2
+END1
+1ABARB2
+END2
+  end
+
+  it "should have working tilt support for specifying engine class" do
+    setup_foo
+    @a = 1
+    Tilt::ErubiTemplate.new(:engine_class=>Erubi::CaptureEngine, :outvar=>'@a'){<<END1}.render(self).must_equal(<<END2)
+1<%|= @foo.bar do %>bar<% end %>2
+END1
+1ABARB2
+END2
+    @a.must_equal 1
+  end
+
+  it "should have working tilt support for locals" do
+    Tilt::ErubiTemplate.new{<<END1}.render(self, :b=>3).must_equal(<<END2)
+<%= b %>
+END1
+3
 END2
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: erubi
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Jeremy Evans
@@ -9,8 +9,36 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-10 00:00:00.000000000 Z
-dependencies: []
+date: 2016-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Erubi is a ERB template engine for ruby. It is a simplified fork of Erubis
 email: code@jeremyevans.net
 executables: []
@@ -25,6 +53,7 @@ files:
 - README.rdoc
 - Rakefile
 - lib/erubi.rb
+- lib/erubi/capture.rb
 - lib/tilt/erubi.rb
 - test/test.rb
 homepage: https://github.com/jeremyevans/erubi