erubi 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cefbc9c1251647b1876b855e13cde7e22fe0877b
+  data.tar.gz: b237d3a6ad613c5f48a1fafa65aa01675fcfb59a
+SHA512:
+  metadata.gz: 18e593606c5c1b881bd52f20a5b9800b5dd058264cc38f609c8251e3be220d8d1a3540066dc7dfffe9143ebfdacc5af6dab7c21e22aaea9ea945dc9ecaaa0b62
+  data.tar.gz: 13a3fa3d9d49edc442a32f4d4ee41d1262e471dd524b6693af392019d04d4563ff632a3e55c8e01d37fca1650b42ce07335e0abc8dbda243dd17f9d3437bd339

data/CHANGELOG

@@ -0,0 +1,3 @@
+=== 1.0.0 (2016-11-10)
+
+* Initial Public Release

data/MIT-LICENSE

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

data/README.rdoc

@@ -0,0 +1,59 @@
+= Erubi
+
+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>)
+* 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
+* 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)
+* Has an open development model (Erubis doesn't have a public source control repository or bug tracker)
+* Is not dead (Erubis hasn't been updated since 2011)
+
+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
+
+  gem install erubi
+
+= Source Code
+
+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:
+
+  require 'tilt/erubi'
+  Tilt.new("filename.erb").render
+
+Requiring +tilt/erubi+ sets erubi as the default erb/rhtml template processor
+for tilt.  In most cases, you can use Erubi as a replacement for Erubis if
+you are using tilt.
+
+You can use the library manually, but it's only useful to get the generated
+source:
+
+  require 'erubi'
+  eval(Erubi::Engine.new(File.read('filename.erb')).src)
+
+= Reporting Bugs
+
+The bug tracker is located at https://github.com/jeremyevans/erubi/issues
+
+= License
+
+MIT
+
+= Authors
+
+Jeremy Evans <code@jeremyevans.net>
+kuwata-lab.com

data/Rakefile

@@ -0,0 +1,78 @@
+require "rake"
+require "rake/clean"
+
+NAME = 'erubi'
+CLEAN.include ["#{NAME}-*.gem", "rdoc", "coverage"]
+
+# Gem Packaging and Release
+
+desc "Packages #{NAME}"
+task :package=>[:clean] do |p|
+  sh %{gem build #{NAME}.gemspec}
+end
+
+### RDoc
+
+RDOC_DEFAULT_OPTS = ["--line-numbers", "--inline-source", '--title', 'Erubi: Small ERB Implementation']
+
+begin
+  gem 'hanna-nouveau'
+  RDOC_DEFAULT_OPTS.concat(['-f', 'hanna'])
+rescue Gem::LoadError
+end
+
+rdoc_task_class = begin
+  require "rdoc/task"
+  RDoc::Task
+rescue LoadError
+  require "rake/rdoctask"
+  Rake::RDocTask
+end
+
+RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
+RDOC_FILES = %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb"
+
+rdoc_task_class.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.options += RDOC_OPTS
+  rdoc.rdoc_files.add RDOC_FILES
+end
+
+### Specs
+
+spec = proc do |env|
+  env.each{|k,v| ENV[k] = v}
+  sh "#{FileUtils::RUBY} test/test.rb"
+  env.each{|k,v| ENV.delete(k)}
+end
+
+desc "Run specs"
+task "spec" do
+  spec.call({})
+end
+
+task :default=>:spec
+
+desc "Run specs with coverage"
+task "spec_cov" do
+  spec.call('COVERAGE'=>'1')
+end
+  
+desc "Run specs with -w, some warnings filtered"
+task "spec_w" do
+  ENV['RUBYOPT'] ? (ENV['RUBYOPT'] += " -w") : (ENV['RUBYOPT'] = '-w')
+  rake = ENV['RAKE'] || "#{FileUtils::RUBY} -S rake"
+  sh %{#{rake} 2>&1 | egrep -v \": warning: instance variable @.* not initialized|: warning: method redefined; discarding old|: warning: previous definition of|: warning: statement not reached"}
+end
+
+### Other
+
+desc "Start an IRB shell using the extension"
+task :irb do
+  require 'rbconfig'
+  ruby = ENV['RUBY'] || File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  irb = ENV['IRB'] || File.join(RbConfig::CONFIG['bindir'], File.basename(ruby).sub('ruby', 'irb'))
+  sh %{#{irb} -I lib -r #{NAME}}
+end
+
+

data/lib/erubi.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+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'
+    # Escape the following characters with their HTML/XML
+    # equivalents.
+    def self.h(value)
+      value.to_s.gsub(/[&<>"']/, ESCAPE_TABLE)
+    end
+  else
+    # :nocov:
+    def self.h(value)
+      value.to_s.gsub(/[&<>"']/){|s| ESCAPE_TABLE[s]}
+    end
+    # :nocov:
+  end
+
+  class Engine
+    # The ruby source code generated from the template, which can be evaled.
+    attr_reader :src
+
+    # The filename of the template, if one was given.
+    attr_reader :filename
+
+    # The variable name used for the buffer variable.
+    attr_reader :bufvar
+
+    # Initialize a new Erubi::Engine.  Options:
+    # :bufvar :: The variable name to use for the buffer variable, as a string.
+    # :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.
+    # :preamble :: The preamble for the template, by default initializes up the buffer variable.
+    # :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;"
+      postamble  = properties[:postamble] || "#{bufvar}.to_s\n"
+
+      @src = src = String.new
+      src << "# frozen_string_literal: true\n" if properties[:freeze]
+
+      unless escapefunc = properties[:escapefunc]
+        if escape
+          escapefunc = '__erubi.h'
+          src << "__erubi = ::Erubi;"
+        else
+          escapefunc = '::Erubi.h'
+        end
+      end
+
+      src << preamble
+
+      pos = 0
+      is_bol = true
+      input.scan(/<%(={1,2}|-|\#|%)?(.*?)([-=])?%>([ \t]*\r?\n)?/m) 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 == '='
+          if text.empty?
+            lspace = "" if is_bol
+          elsif text[RANGE_LAST] == "\n"
+            lspace = ""
+          else
+            rindex = text.rindex("\n")
+            if rindex
+              range = rindex+1..-1
+              s = text[range]
+              if s =~ /\A[ \t]*\z/
+                lspace = s
+                text[range] = ''
+              end
+            else
+              if is_bol && text =~ /\A[ \t]*\z/
+                lspace = text.dup
+                text[RANGE_ALL] = ''
+              end
+            end
+          end
+        end
+
+        is_bol = rspace ? true : false
+        add_text(text) if text && !text.empty?
+        if ch == '='
+          rspace = nil if tailch && !tailch.empty?
+          add_text(lspace) if lspace
+          if ((indicator == '=') ^ escape)
+            src << " #{bufvar} << (" << code << ').to_s;'
+          else
+            src << " #{bufvar} << #{escapefunc}((" << code << '));'
+          end
+          add_text(rspace) if rspace
+        elsif ch == '#'
+          n = code.count("\n") + (rspace ? 1 : 0)
+          if trim
+            add_code("\n" * n)
+          else
+            add_text(lspace) if lspace
+            add_code("\n" * n)
+            add_text(rspace) if rspace
+          end
+        elsif ch == '%'
+          add_text("#{lspace}#{prefix||='<%'}#{code}#{tailch}#{postfix||='%>'}#{rspace}")
+        else
+          if trim
+            add_code("#{lspace}#{code}#{rspace}")
+          else
+            add_text(lspace) if lspace
+            add_code(code)
+            add_text(rspace) if rspace
+          end
+        end
+      end
+      rest = pos == 0 ? input : input[pos..-1]
+      add_text(rest)
+
+      src << "\n" unless src[RANGE_LAST] == "\n"
+      src << postamble
+      freeze
+    end
+
+    private
+
+    # Add raw text to the template
+    def add_text(text)
+      @src << " #{@bufvar} << '" << text.gsub(/['\\]/, '\\\\\&') << "';" unless text.empty?
+    end
+
+    # Add ruby code to the template
+    def add_code(code)
+      @src << code
+      @src << ';' unless code[RANGE_LAST] == "\n"
+    end
+  end
+end

data/lib/tilt/erubi.rb

@@ -0,0 +1,34 @@
+require 'tilt'
+require 'tilt/erb'
+require 'erubi'
+
+module Tilt
+  # Erubi (a simplified version of Erubis) template implementation
+  class ErubiTemplate < ERBTemplate
+    def prepare
+      @options.merge!(:preamble => false, :postamble => false)
+      @engine = Erubi::Engine.new(data, @options)
+      @outvar = @engine.bufvar
+      @engine
+    end
+
+    def precompiled_preamble(locals)
+      [super, "#{@outvar} = _buf = String.new"].join("\n")
+    end
+
+    def precompiled_postamble(locals)
+      [@outvar, super].join("\n")
+    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
+    end
+
+    Tilt.register self, 'erb', 'rhtml', 'erubi'
+  end
+end

data/test/test.rb

@@ -0,0 +1,370 @@
+require 'rubygems'
+
+unless defined?(TESTDIR)
+  TESTDIR = File.dirname(__FILE__)
+  LIBDIR  = TESTDIR == '.' ? '../lib' : File.dirname(TESTDIR) + '/lib'
+  $: << TESTDIR
+  $: << LIBDIR
+end
+
+if ENV['COVERAGE']
+  require 'coverage'
+  require 'simplecov'
+
+  ENV.delete('COVERAGE')
+  SimpleCov.instance_eval do
+    start do
+      add_filter "/test/"
+      add_group('Missing'){|src| src.covered_percent < 100}
+      add_group('Covered'){|src| src.covered_percent == 100}
+    end
+  end
+end
+
+require 'erubi'
+require 'minitest/spec'
+require 'minitest/autorun'
+
+describe Erubi::Engine do
+  before do
+    @options = {}
+  end
+
+  def check_output(input, src, result, &block)
+    t = Erubi::Engine.new(input, @options)
+    t.src.must_equal src
+    eval(t.src, block.binding).must_equal result
+  end
+
+  it "should handle no options" do
+    list = ['&\'<>"2']
+    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
+_buf = String.new; _buf << '<table>
+ <tbody>
+';   i = 0
+     list.each_with_index do |item, i| 
+ _buf << '  <tr>
+   <td>'; _buf << ( i+1 ).to_s; _buf << '</td>
+   <td>'; _buf << ::Erubi.h(( item )); _buf << '</td>
+  </tr>
+';  end 
+ _buf << ' </tbody>
+</table>
+'; _buf << ::Erubi.h(( i+1 )); _buf << '
+';
+_buf.to_s
+END2
+<table>
+ <tbody>
+  <tr>
+   <td>1</td>
+   <td>&amp;&#039;&lt;&gt;&quot;2</td>
+  </tr>
+ </tbody>
+</table>
+1
+END3
+  end
+
+  [:outvar, :bufvar].each do |var|
+    it "should handle :#{var} and :freeze options" do
+      @options[var] = "@_out_buf"
+      @options[:freeze] = true
+      @items = [2]
+      i = 0
+      check_output(<<END1, <<END2, <<END3){}
+<table>
+  <% for item in @items %>
+  <tr>
+    <td><%= i+1 %></td>
+    <td><%== item %></td>
+  </tr>
+  <% end %>
+</table>
+END1
+# frozen_string_literal: true
+@_out_buf = String.new; @_out_buf << '<table>
+';   for item in @items 
+ @_out_buf << '  <tr>
+    <td>'; @_out_buf << ( i+1 ).to_s; @_out_buf << '</td>
+    <td>'; @_out_buf << ::Erubi.h(( item )); @_out_buf << '</td>
+  </tr>
+';   end 
+ @_out_buf << '</table>
+';
+@_out_buf.to_s
+END2
+<table>
+  <tr>
+    <td>1</td>
+    <td>2</td>
+  </tr>
+</table>
+END3
+    end
+  end
+
+  it "should handle <%% and <%# syntax" do
+    @items = [2]
+    i = 0
+    check_output(<<END1, <<END2, <<END3){}
+<table>
+<%% for item in @items %>
+  <tr>
+    <td><%# i+1 %></td>
+    <td><%# item %></td>
+  </tr>
+  <%% end %>
+</table>
+END1
+_buf = String.new; _buf << '<table>
+'; _buf << '<% for item in @items %>
+'; _buf << '  <tr>
+    <td>';; _buf << '</td>
+    <td>';; _buf << '</td>
+  </tr>
+'; _buf << '  <% end %>
+'; _buf << '</table>
+';
+_buf.to_s
+END2
+<table>
+<% for item in @items %>
+  <tr>
+    <td></td>
+    <td></td>
+  </tr>
+  <% end %>
+</table>
+END3
+  end
+
+  it "should handle :trim => false option" do
+    @options[:trim] = false
+    @items = [2]
+    i = 0
+    check_output(<<END1, <<END2, <<END3){}
+<table>
+  <% for item in @items %>
+  <tr>
+    <td><%# 
+    i+1
+    %></td>
+    <td><%== item %></td>
+  </tr>
+  <% end %><%#%>
+  <% i %>a
+  <% i %>
+</table>
+END1
+_buf = String.new; _buf << '<table>
+'; _buf << '  '; for item in @items ; _buf << '
+'; _buf << '  <tr>
+    <td>';
+
+ _buf << '</td>
+    <td>'; _buf << ::Erubi.h(( item )); _buf << '</td>
+  </tr>
+'; _buf << '  '; end ;
+ _buf << '
+'; _buf << '  '; i ; _buf << 'a
+'; _buf << '  '; i ; _buf << '
+'; _buf << '</table>
+';
+_buf.to_s
+END2
+<table>
+  
+  <tr>
+    <td></td>
+    <td>2</td>
+  </tr>
+  
+  a
+  
+</table>
+END3
+  end
+
+  [:escape, :escape_html].each do  |opt|
+    it "should handle :#{opt} and :escapefunc options" do
+      @options[opt] = true
+      @options[:escapefunc] = 'h.call'
+      h = proc{|s| s.to_s*2}
+      list = ['2']
+      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
+_buf = String.new; _buf << '<table>
+ <tbody>
+';   i = 0
+     list.each_with_index do |item, i| 
+ _buf << '  <tr>
+   <td>'; _buf << h.call(( i+1 )); _buf << '</td>
+   <td>'; _buf << ( item ).to_s; _buf << '</td>
+  </tr>
+';  end 
+ _buf << ' </tbody>
+</table>
+'; _buf << ( i+1 ).to_s; _buf << '
+';
+_buf.to_s
+END2
+<table>
+ <tbody>
+  <tr>
+   <td>11</td>
+   <td>2</td>
+  </tr>
+ </tbody>
+</table>
+1
+END3
+    end
+  end
+
+  it "should handle :escape option without :escapefunc option" do
+    @options[:escape] = true
+    list = ['&\'<>"2']
+    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>
+END1
+__erubi = ::Erubi;_buf = String.new; _buf << '<table>
+ <tbody>
+';   i = 0
+     list.each_with_index do |item, i| 
+ _buf << '  <tr>
+   <td>'; _buf << ( i+1 ).to_s; _buf << '</td>
+   <td>'; _buf << __erubi.h(( item )); _buf << '</td>
+  </tr>
+';  end 
+ _buf << ' </tbody>
+</table>
+';
+_buf.to_s
+END2
+<table>
+ <tbody>
+  <tr>
+   <td>1</td>
+   <td>&amp;&#039;&lt;&gt;&quot;2</td>
+  </tr>
+ </tbody>
+</table>
+END3
+  end
+
+  it "should handle :preamble and :postamble options" do
+    @options[:preamble] = '_buf = String.new("1");'
+    @options[:postamble] = "_buf[0...18]\n"
+    list = ['2']
+    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
+_buf = String.new("1"); _buf << '<table>
+ <tbody>
+';   i = 0
+     list.each_with_index do |item, i| 
+ _buf << '  <tr>
+   <td>'; _buf << ( i+1 ).to_s; _buf << '</td>
+   <td>'; _buf << ::Erubi.h(( item )); _buf << '</td>
+  </tr>
+';  end 
+ _buf << ' </tbody>
+</table>
+'; _buf << ::Erubi.h(( i+1 )); _buf << '
+';
+_buf[0...18]
+END2
+1<table>
+ <tbody>
+END3
+  end
+
+  it "should have working filename accessor" do
+    Erubi::Engine.new('', :filename=>'foo.rb').filename.must_equal 'foo.rb'
+  end
+
+  it "should have working bufvar accessor" do
+    Erubi::Engine.new('', :bufvar=>'foo').bufvar.must_equal 'foo'
+    Erubi::Engine.new('', :outvar=>'foo').bufvar.must_equal 'foo'
+  end
+
+  it "should return frozen object" do
+    Erubi::Engine.new('').frozen?.must_equal true
+  end
+
+  it "should have working tilt support" do
+    require 'tilt/erubi'
+    @list = ['&\'<>"2']
+    Tilt::ErubiTemplate.new{<<END1}.render(self).must_equal(<<END2)
+<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
+<table>
+ <tbody>
+  <tr>
+   <td>1</td>
+   <td>&amp;&#039;&lt;&gt;&quot;2</td>
+  </tr>
+ </tbody>
+</table>
+1
+END2
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: erubi
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jeremy Evans
+- kuwata-lab.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-10 00:00:00.000000000 Z
+dependencies: []
+description: Erubi is a ERB template engine for ruby. It is a simplified fork of Erubis
+email: code@jeremyevans.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- CHANGELOG
+- MIT-LICENSE
+files:
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/erubi.rb
+- lib/tilt/erubi.rb
+- test/test.rb
+homepage: https://github.com/jeremyevans/erubi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--quiet"
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- 'Erubi: Small ERB Implementation'
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Small ERB Implementation
+test_files: []