temple 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 527609e09539e1854fc16e48ac864d23ce89584ec8c0cb3f3cf1f4ee4d6e8101
-  data.tar.gz: eee6b6dd3a38dde73365469c10b5cf7f8b6a35dd6797268b104e50cef27b4863
+  metadata.gz: c7475d628203a95d9ec067ac1388f8428cb213f4534a2fd2ed1b9cf0be7d3293
+  data.tar.gz: d828006ab486aee65e70e8e321022d28191deba994d43c1141dccad2815f41f2
 SHA512:
-  metadata.gz: 17e8c7410950492aa3fdc41cb91f1ad40613324a411d77fcded2667ecb6ac137956e4bee64a9d0b038bb7cd9dc1098ae9e095ca59ba2a4a370e7a7a3cd62a4bd
-  data.tar.gz: 317d066d2e989072f0182d688845691573a74a31a7365883534c66571986bc2f0503df0a6a389d086cfba1eb0da69734a751a91691efa49772ebfb7a6c58f1b2
+  metadata.gz: d74cc956889989a4d65f6727d7f521cbcbf3d9c2de1a6abda92b4957a7e3992de2b7de6c7634b4dfafe9d4ce1a505f22b8f5af1ef9a217876d6d67f276e04557
+  data.tar.gz: 1958e441fbab605e06f560db0f4c26e5fecf7c673a12a5aad843a3bd5bb4c0ce77e3c2ea13f46b22d962770898587b7f76bd0ad2b11377898e61924e7bc20c87

data/.github/workflows/test.yml

@@ -30,11 +30,5 @@ jobs:
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-      - uses: actions/cache@v2
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-${{ matrix.ruby }}-gems-${{ hashFiles('**/Gemfile.lock') }}
-          restore-keys: ${{ runner.os }}-gems-
-      - name: bundle install
-        run: bundle config path vendor/bundle && bundle install -j$(nproc) --retry 3
-      - run: bundle exec rake test
+          bundler-cache: true
+      - run: bundle exec rake spec

data/.gitignore

@@ -2,3 +2,4 @@ coverage
 .yardoc
 doc
 Gemfile.lock
+/pkg/

data/CHANGES

@@ -1,3 +1,15 @@
+0.10.0
+
+  * Regression: Revert changes to :capture_generator since 0.8.2 (#112, #113, #137)
+  * Regression: Ensure that output buffer is not reused for capturing in Rails (#135)
+  * Drop support for Rails 4.x
+
+0.9.1
+
+  * Fix Slim's error in AttributeMerger due to 0.9.0's :capture_generator (#137)
+  * Use specified :capture_generator for nested captures (#112)
+  * Fix Temple::ERB::Engine's <%= to not escape and <%== to escape expressions
+
 0.9.0
 
   * Require Ruby 2.5+ (#131)

data/Gemfile

@@ -1,3 +1,2 @@
 source 'https://rubygems.org/'
 gemspec
-gem 'escape_utils' if ENV['ESCAPE_UTILS']

data/README.md

@@ -1,7 +1,7 @@
 Temple
 ======
 
-[![Build Status](https://secure.travis-ci.org/judofyr/temple.svg?branch=master)](http://travis-ci.org/judofyr/temple) [![Code Climate](https://codeclimate.com/github/judofyr/temple.svg)](https://codeclimate.com/github/judofyr/temple) [![Gem Version](https://badge.fury.io/rb/temple.svg)](https://rubygems.org/gems/temple)
+[![test](https://github.com/judofyr/temple/actions/workflows/test.yml/badge.svg)](https://github.com/judofyr/temple/actions/workflows/test.yml) [![Code Climate](https://codeclimate.com/github/judofyr/temple.svg)](https://codeclimate.com/github/judofyr/temple) [![Gem Version](https://badge.fury.io/rb/temple.svg)](https://rubygems.org/gems/temple) [![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/temple/frames)
 
 Temple is an abstraction and a framework for compiling templates to pure Ruby.
 It's all about making it easier to experiment, implement and optimize template

data/Rakefile

@@ -1,16 +1,8 @@
 require 'bundler/gem_tasks'
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
-task default: :test
-task :test do
-  sh "bacon -Ilib -Itest --automatic --quiet"
-end
-
-#Rake::TestTask.new(:test) do |t|
-#  t.libs << 'lib' << 'test'
-#  t.pattern = 'test/**/test_*.rb'
-#  t.verbose = false
-#end
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
 
 begin
   require 'rcov/rcovtask'

data/lib/temple/erb/engine.rb

@@ -7,6 +7,8 @@ module Temple
       use Temple::ERB::Parser
       use Temple::ERB::Trimming
       filter :Escapable
+      filter :StringSplitter
+      filter :StaticAnalyzer
       filter :MultiFlattener
       filter :StaticMerger
       generator :ArrayBuffer

data/lib/temple/erb/parser.rb

@@ -27,7 +27,7 @@ module Temple
             when '#'
               result << [:code, "\n" * code.count("\n")]
             when /=/
-              result << [:escape, indicator.size <= 1, [:dynamic, code]]
+              result << [:escape, indicator.size == 2, [:dynamic, code]]
             else
               result << [:code, code]
             end

data/lib/temple/filters/string_splitter.rb

@@ -7,7 +7,7 @@ module Temple
   module Filters
     # Compile [:dynamic, "foo#{bar}"] to [:multi, [:static, 'foo'], [:dynamic, 'bar']]
     class StringSplitter < Filter
-      if defined?(Ripper) && RUBY_VERSION >= "2.0.0" && Ripper.respond_to?(:lex)
+      if defined?(Ripper) && Ripper.respond_to?(:lex)
         class << self
           # `code` param must be valid string literal
           def compile(code)

data/lib/temple/generator.rb

@@ -10,9 +10,9 @@ module Temple
     include Mixins::Options
 
     define_options :save_buffer,
-                   capture_generator: self,
+                   capture_generator: 'StringBuffer',
                    buffer: '_buf',
-                   freeze_static: RUBY_VERSION >= '2.1'
+                   freeze_static: true
 
     def call(exp)
       [preamble, compile(exp), postamble].flatten.compact.join('; ')

data/lib/temple/generators/rails_output_buffer.rb

@@ -9,10 +9,9 @@ module Temple
     #
     # @api public
     class RailsOutputBuffer < StringBuffer
-      define_options :streaming,
+      define_options :streaming, # ignored
                      buffer_class: 'ActionView::OutputBuffer',
                      buffer: '@output_buffer',
-                     # output_buffer is needed for Rails 3.1 Streaming support
                      capture_generator: RailsOutputBuffer
 
       def call(exp)
@@ -20,7 +19,11 @@ module Temple
       end
 
       def create_buffer
-        "#{buffer} = output_buffer || #{options[:buffer_class]}.new"
+        if buffer == '@output_buffer'
+          "#{buffer} = output_buffer || #{options[:buffer_class]}.new"
+        else
+          "#{buffer} = #{options[:buffer_class]}.new"
+        end
       end
 
       def concat(str)

data/lib/temple/templates/rails.rb

@@ -18,8 +18,8 @@ module Temple
 
       def self.register_as(*names)
         raise 'Rails is not loaded - Temple::Templates::Rails cannot be used' unless defined?(::ActionView)
-        if ::ActiveSupport::VERSION::MAJOR < 3 || ::ActiveSupport::VERSION::MAJOR == 3 && ::ActiveSupport::VERSION::MINOR < 1
-          raise "Temple supports only Rails 3.1 and greater, your Rails version is #{::ActiveSupport::VERSION::STRING}"
+        if ::ActiveSupport::VERSION::MAJOR < 5
+          raise "Temple supports only Rails 5 and greater, your Rails version is #{::ActiveSupport::VERSION::STRING}"
         end
         names.each do |name|
           ::ActionView::Template.register_template_handler name.to_sym, new

data/lib/temple/utils.rb

@@ -14,7 +14,8 @@ module Temple
     # @param html [String] The string to escape
     # @return [String] The escaped string
     def escape_html_safe(html)
-      html.html_safe? ? html : escape_html(html)
+      s = html.to_s
+      s.html_safe? || html.html_safe? ? s : escape_html(s)
     end
 
     if defined?(CGI.escapeHTML)

data/lib/temple/version.rb

@@ -1,3 +1,3 @@
 module Temple
-  VERSION = '0.9.0'
+  VERSION = '0.10.0'
 end

data/spec/engine_spec.rb

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+class Callable1
+  def call(exp)
+    exp
+  end
+end
+
+class Callable2
+  def call(exp)
+    exp
+  end
+end
+
+class MySpecialFilter
+  def initialize(opts = {})
+  end
+
+  def call(exp)
+    exp
+  end
+end
+
+class TestEngine < Temple::Engine
+  use(:Parser) do |input|
+    [:static, input]
+  end
+  use :MyFilter1, proc {|exp| exp }
+  use :MyFilter2, proc {|exp| exp }
+  use Temple::HTML::Pretty, pretty: true
+  filter :MultiFlattener
+  generator :ArrayBuffer
+  use(:BeforeBeforeLast) { MySpecialFilter }
+  use :BeforeLast, Callable1.new
+  use(:Last) { Callable2.new }
+end
+
+describe Temple::Engine do
+  it 'should build chain' do
+    expect(TestEngine.chain.size).to eq(9)
+
+    expect(TestEngine.chain[0].first).to eq(:Parser)
+    expect(TestEngine.chain[0].size).to eq(2)
+    expect(TestEngine.chain[0].last).to be_a(Proc)
+
+    expect(TestEngine.chain[1].first).to eq(:MyFilter1)
+    expect(TestEngine.chain[1].size).to eq(2)
+    expect(TestEngine.chain[1].last).to be_a(Proc)
+
+    expect(TestEngine.chain[2].first).to eq(:MyFilter2)
+    expect(TestEngine.chain[2].size).to eq(2)
+    expect(TestEngine.chain[2].last).to be_a(Proc)
+
+    expect(TestEngine.chain[3].first).to eq(:'Temple::HTML::Pretty')
+    expect(TestEngine.chain[3].size).to eq(2)
+    expect(TestEngine.chain[3].last).to be_a(Proc)
+
+    expect(TestEngine.chain[4].first).to eq(:MultiFlattener)
+    expect(TestEngine.chain[4].size).to eq(2)
+    expect(TestEngine.chain[4].last).to be_a(Proc)
+
+    expect(TestEngine.chain[5].first).to eq(:ArrayBuffer)
+    expect(TestEngine.chain[5].size).to eq(2)
+    expect(TestEngine.chain[5].last).to be_a(Proc)
+
+    expect(TestEngine.chain[6].first).to eq(:BeforeBeforeLast)
+    expect(TestEngine.chain[6].size).to eq(2)
+    expect(TestEngine.chain[6].last).to be_a(Proc)
+
+    expect(TestEngine.chain[7].first).to eq(:BeforeLast)
+    expect(TestEngine.chain[7].size).to eq(2)
+    expect(TestEngine.chain[7].last).to be_a(Proc)
+
+    expect(TestEngine.chain[8].first).to eq(:Last)
+    expect(TestEngine.chain[8].size).to eq(2)
+    expect(TestEngine.chain[8].last).to be_a(Proc)
+  end
+
+  it 'should instantiate chain' do
+    call_chain = TestEngine.new.send(:call_chain)
+    expect(call_chain[0]).to be_a(Method)
+    expect(call_chain[1]).to be_a(Method)
+    expect(call_chain[2]).to be_a(Method)
+    expect(call_chain[3]).to be_a(Temple::HTML::Pretty)
+    expect(call_chain[4]).to be_a(Temple::Filters::MultiFlattener)
+    expect(call_chain[5]).to be_a(Temple::Generators::ArrayBuffer)
+    expect(call_chain[6]).to be_a(MySpecialFilter)
+    expect(call_chain[7]).to be_a(Callable1)
+    expect(call_chain[8]).to be_a(Callable2)
+  end
+
+  it 'should have #append' do
+    engine = TestEngine.new
+    call_chain = engine.send(:call_chain)
+    expect(call_chain.size).to eq(9)
+
+    engine.append :MyFilter3 do |exp|
+      exp
+    end
+
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(10)
+    expect(engine.chain[9].first).to eq(:MyFilter3)
+    expect(engine.chain[9].size).to eq(2)
+    expect(engine.chain[9].last).to be_a(Proc)
+
+    call_chain = engine.send(:call_chain)
+    expect(call_chain.size).to eq(10)
+    expect(call_chain[9]).to be_a(Method)
+  end
+
+  it 'should have #prepend' do
+    engine = TestEngine.new
+    call_chain = engine.send(:call_chain)
+    expect(call_chain.size).to eq(9)
+
+    engine.prepend :MyFilter0 do |exp|
+      exp
+    end
+
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(10)
+    expect(engine.chain[0].first).to eq(:MyFilter0)
+    expect(engine.chain[0].size).to eq(2)
+    expect(engine.chain[0].last).to be_a(Proc)
+    expect(engine.chain[1].first).to eq(:Parser)
+
+    call_chain = engine.send(:call_chain)
+    expect(call_chain.size).to eq(10)
+    expect(call_chain[0]).to be_a(Method)
+  end
+
+  it 'should have #after' do
+    engine = TestEngine.new
+    engine.after :Parser, :MyFilter0 do |exp|
+      exp
+    end
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(10)
+    expect(engine.chain[0].first).to eq(:Parser)
+    expect(engine.chain[1].first).to eq(:MyFilter0)
+    expect(engine.chain[2].first).to eq(:MyFilter1)
+  end
+
+  it 'should have #before' do
+    engine = TestEngine.new
+    engine.before :MyFilter1, :MyFilter0 do |exp|
+      exp
+    end
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(10)
+    expect(engine.chain[0].first).to eq(:Parser)
+    expect(engine.chain[1].first).to eq(:MyFilter0)
+    expect(engine.chain[2].first).to eq(:MyFilter1)
+  end
+
+  it 'should have #remove' do
+    engine = TestEngine.new
+    engine.remove :MyFilter1
+    expect(TestEngine.chain.size).to eq(9)
+    expect(engine.chain.size).to eq(8)
+    expect(engine.chain[0].first).to eq(:Parser)
+    expect(engine.chain[1].first).to eq(:MyFilter2)
+
+    engine = TestEngine.new
+    engine.remove /Last/
+    expect(engine.chain.size).to eq(6)
+  end
+
+  it 'should have #replace' do
+    engine = TestEngine.new
+    engine.replace :Parser, :MyParser do |exp|
+      exp
+    end
+    expect(engine.chain.size).to eq(9)
+    expect(engine.chain[0].first).to eq(:MyParser)
+  end
+
+  it 'should work with inheritance' do
+    inherited_engine = Class.new(TestEngine)
+    expect(inherited_engine.chain.size).to eq(9)
+    inherited_engine.append :MyFilter3 do |exp|
+      exp
+    end
+    expect(inherited_engine.chain.size).to eq(10)
+    expect(TestEngine.chain.size).to eq(9)
+  end
+end

data/{test/test_erb.rb → spec/erb_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 require 'tilt/erubi'
 
 describe Temple::ERB::Engine do
@@ -11,7 +11,7 @@ describe Temple::ERB::Engine do
 <% end %>
 }
 
-    erb(src).should.equal erubi(src)
+    expect(erb(src)).to eq(erubi(src))
   end
 
   it 'should recognize comments' do
@@ -20,7 +20,7 @@ hello
   <%# comment -- ignored -- useful in testing %>
 world}
 
-    erb(src).should.equal erubi(src)
+    expect(erb(src)).to eq(erubi(src))
   end
 
   it 'should recognize <%% and %%>' do
@@ -31,19 +31,19 @@ world}
 <% end %>
 }
 
-    erb(src).should.equal "\n<%\n  %>\n"
+    expect(erb(src)).to eq("\n<%\n  %>\n")
   end
 
   it 'should escape automatically' do
-    src = '<%= "<" %>'
+    src = '<%== "<" %>'
     ans = '&lt;'
-    erb(src).should.equal ans
+    expect(erb(src)).to eq(ans)
   end
 
-  it 'should support == to disable automatic escape' do
-    src = '<%== "<" %>'
+  it 'should support = to disable automatic escape' do
+    src = '<%= "<" %>'
     ans = '<'
-    erb(src).should.equal ans
+    expect(erb(src)).to eq(ans)
   end
 
   it 'should support trim mode' do
@@ -55,7 +55,7 @@ world}
 <% end %>
 }
 
-    erb(src, trim: true).should.equal erubi(src, trim: true)
-    erb(src, trim: false).should.equal erubi(src, trim: false)
+    expect(erb(src, trim: true)).to eq(erubi(src, trim: true))
+    expect(erb(src, trim: false)).to eq(erubi(src, trim: false))
   end
 end

data/spec/filter_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+class SimpleFilter < Temple::Filter
+  define_options :key
+
+  def on_test(arg)
+    [:on_test, arg]
+  end
+end
+
+describe Temple::Filter do
+  it 'should support options' do
+    expect(Temple::Filter).to respond_to(:default_options)
+    expect(Temple::Filter).to respond_to(:set_default_options)
+    expect(Temple::Filter).to respond_to(:define_options)
+    expect(Temple::Filter.new.options).to be_a(Temple::ImmutableMap)
+    expect(SimpleFilter.new(key: 3).options[:key]).to eq(3)
+  end
+
+  it 'should implement call' do
+    expect(Temple::Filter.new.call([:exp])).to eq([:exp])
+  end
+
+  it 'should process expressions' do
+    filter = SimpleFilter.new
+    expect(filter.call([:unhandled])).to eq([:unhandled])
+    expect(filter.call([:test, 42])).to eq([:on_test, 42])
+  end
+end

data/{test/filters/test_code_merger.rb → spec/filters/code_merger_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::CodeMerger do
   before do
@@ -6,21 +6,21 @@ describe Temple::Filters::CodeMerger do
   end
 
   it 'should merge serveral codes' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:code, "a"],
       [:code, "b"],
       [:code, "c"]
-    ]).should.equal [:code, "a; b; c"]
+    ])).to eq [:code, "a; b; c"]
   end
 
   it 'should merge serveral codes around static' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:code, "a"],
       [:code, "b"],
       [:static, "123"],
       [:code, "a"],
       [:code, "b"]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, "a; b"],
       [:static, "123"],
       [:code, "a; b"]
@@ -28,11 +28,11 @@ describe Temple::Filters::CodeMerger do
   end
 
   it 'should merge serveral codes with newlines' do
-    @filter.call([:multi,
+    expect(@filter.call([:multi,
       [:code, "a"],
       [:code, "b"],
       [:newline],
       [:code, "c"]
-    ]).should.equal [:code, "a; b\nc"]
+    ])).to eq [:code, "a; b\nc"]
   end
 end

data/{test/filters/test_control_flow.rb → spec/filters/control_flow_spec.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 
 describe Temple::Filters::ControlFlow do
   before do
@@ -6,18 +6,18 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should process blocks' do
-    @filter.call([:block, 'loop do',
+    expect(@filter.call([:block, 'loop do',
       [:static, 'Hello']
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:code, 'loop do'],
                      [:static, 'Hello'],
                      [:code, 'end']]
   end
 
   it 'should process if' do
-    @filter.call([:if, 'condition',
+    expect(@filter.call([:if, 'condition',
       [:static, 'Hello']
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'if condition'],
       [:static, 'Hello'],
       [:code, 'end']
@@ -25,10 +25,10 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should process if with else' do
-    @filter.call([:if, 'condition',
+    expect(@filter.call([:if, 'condition',
       [:static, 'True'],
       [:static, 'False']
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'if condition'],
       [:static, 'True'],
       [:code, 'else'],
@@ -38,12 +38,12 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should create elsif' do
-    @filter.call([:if, 'condition1',
+    expect(@filter.call([:if, 'condition1',
       [:static, '1'],
       [:if, 'condition2',
        [:static, '2'],
        [:static, '3']]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'if condition1'],
       [:static, '1'],
       [:code, 'elsif condition2'],
@@ -55,11 +55,11 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should process cond' do
-    @filter.call([:cond,
+    expect(@filter.call([:cond,
       ['cond1', [:exp1]],
       ['cond2', [:exp2]],
       [:else,   [:exp3]],
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'case'],
       [:code, 'when cond1'],
       [:exp1],
@@ -72,11 +72,11 @@ describe Temple::Filters::ControlFlow do
   end
 
   it 'should process case' do
-    @filter.call([:case, 'var',
+    expect(@filter.call([:case, 'var',
       ['Array',  [:exp1]],
       ['String', [:exp2]],
       [:else,    [:exp3]],
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
       [:code, 'case (var)'],
       [:code, 'when Array'],
       [:exp1],