RubyGems - temple - Versions diffs - 0.6.7 → 0.10.0 - Mend

temple 0.6.7 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (79) hide show

checksums.yaml +5 -5
data/.github/workflows/test.yml +34 -0
data/.gitignore +1 -0
data/CHANGES +106 -1
data/EXPRESSIONS.md +3 -2
data/Gemfile +0 -1
data/README.md +14 -10
data/Rakefile +4 -11
data/lib/temple/engine.rb +7 -3
data/lib/temple/erb/engine.rb +5 -3
data/lib/temple/erb/parser.rb +1 -1
data/lib/temple/erb/trimming.rb +11 -26
data/lib/temple/filters/ambles.rb +21 -0
data/lib/temple/filters/encoding.rb +1 -1
data/lib/temple/filters/eraser.rb +1 -1
data/lib/temple/filters/escapable.rb +2 -2
data/lib/temple/filters/remove_bom.rb +2 -9
data/lib/temple/filters/static_analyzer.rb +30 -0
data/lib/temple/filters/string_splitter.rb +141 -0
data/lib/temple/filters/validator.rb +1 -1
data/lib/temple/generator.rb +32 -6
data/lib/temple/generators/array.rb +2 -2
data/lib/temple/generators/array_buffer.rb +6 -5
data/lib/temple/generators/erb.rb +1 -5
data/lib/temple/generators/rails_output_buffer.rb +7 -8
data/lib/temple/generators/string_buffer.rb +2 -2
data/lib/temple/html/attribute_merger.rb +6 -11
data/lib/temple/html/attribute_remover.rb +1 -1
data/lib/temple/html/attribute_sorter.rb +1 -1
data/lib/temple/html/fast.rb +49 -44
data/lib/temple/html/pretty.rb +34 -43
data/lib/temple/html/safe.rb +23 -0
data/lib/temple/map.rb +105 -0
data/lib/temple/mixins/dispatcher.rb +10 -7
data/lib/temple/mixins/engine_dsl.rb +42 -67
data/lib/temple/mixins/grammar_dsl.rb +10 -8
data/lib/temple/mixins/options.rb +26 -24
data/lib/temple/mixins/template.rb +3 -3
data/lib/temple/static_analyzer.rb +77 -0
data/lib/temple/templates/rails.rb +17 -36
data/lib/temple/templates/tilt.rb +7 -13
data/lib/temple/utils.rb +27 -29
data/lib/temple/version.rb +1 -1
data/lib/temple.rb +8 -4
data/spec/engine_spec.rb +189 -0
data/{test/test_erb.rb → spec/erb_spec.rb} +12 -13
data/spec/filter_spec.rb +29 -0
data/{test/filters/test_code_merger.rb → spec/filters/code_merger_spec.rb} +7 -7
data/{test/filters/test_control_flow.rb → spec/filters/control_flow_spec.rb} +13 -13
data/{test/filters/test_dynamic_inliner.rb → spec/filters/dynamic_inliner_spec.rb} +18 -18
data/{test/filters/test_eraser.rb → spec/filters/eraser_spec.rb} +13 -13
data/{test/filters/test_escapable.rb → spec/filters/escapable_spec.rb} +15 -13
data/{test/filters/test_multi_flattener.rb → spec/filters/multi_flattener_spec.rb} +4 -4
data/spec/filters/static_analyzer_spec.rb +35 -0
data/{test/filters/test_static_merger.rb → spec/filters/static_merger_spec.rb} +7 -7
data/spec/filters/string_splitter_spec.rb +50 -0
data/spec/generator_spec.rb +158 -0
data/spec/grammar_spec.rb +47 -0
data/{test/html/test_attribute_merger.rb → spec/html/attribute_merger_spec.rb} +11 -11
data/{test/html/test_attribute_remover.rb → spec/html/attribute_remover_spec.rb} +7 -7
data/{test/html/test_attribute_sorter.rb → spec/html/attribute_sorter_spec.rb} +8 -8
data/{test/html/test_fast.rb → spec/html/fast_spec.rb} +23 -23
data/{test/html/test_pretty.rb → spec/html/pretty_spec.rb} +9 -15
data/spec/map_spec.rb +39 -0
data/{test/mixins/test_dispatcher.rb → spec/mixins/dispatcher_spec.rb} +12 -12
data/{test/mixins/test_grammar_dsl.rb → spec/mixins/grammar_dsl_spec.rb} +19 -19
data/{test/helper.rb → spec/spec_helper.rb} +9 -15
data/spec/static_analyzer_spec.rb +39 -0
data/spec/utils_spec.rb +39 -0
data/temple.gemspec +4 -2
metadata +62 -63
data/.travis.yml +0 -13
data/lib/temple/hash.rb +0 -104
data/test/test_engine.rb +0 -170
data/test/test_filter.rb +0 -29
data/test/test_generator.rb +0 -136
data/test/test_grammar.rb +0 -47
data/test/test_hash.rb +0 -39
data/test/test_utils.rb +0 -39

data/{test/html/test_fast.rb → spec/html/fast_spec.rb} RENAMED Viewed

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 describe Temple::HTML::Fast do
   before do
@@ -6,37 +6,37 @@ describe Temple::HTML::Fast do
   end
   it 'should compile html doctype' do
-    @html.call([:multi, [:html, :doctype, '5']]).should.equal [:multi, [:static, '<!DOCTYPE html>']]
-    @html.call([:multi, [:html, :doctype, 'html']]).should.equal [:multi, [:static, '<!DOCTYPE html>']]
-    @html.call([:multi, [:html, :doctype, '1.1']]).should.equal [:multi,
+    expect(@html.call([:multi, [:html, :doctype, '5']])).to eq([:multi, [:static, '<!DOCTYPE html>']])
+    expect(@html.call([:multi, [:html, :doctype, 'html']])).to eq([:multi, [:static, '<!DOCTYPE html>']])
+    expect(@html.call([:multi, [:html, :doctype, '1.1']])).to eq [:multi,
       [:static, '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">']]
   end
   it 'should compile xml encoding' do
-    @html.call([:html, :doctype, 'xml latin1']).should.equal [:static, "<?xml version=\"1.0\" encoding=\"latin1\" ?>"]
+    expect(@html.call([:html, :doctype, 'xml latin1'])).to eq([:static, "<?xml version=\"1.0\" encoding=\"latin1\" ?>"])
   end
   it 'should compile html comment' do
-    @html.call([:html, :comment, [:static, 'test']]).should.equal [:multi, [:static, "<!--"], [:static, "test"], [:static, "-->"]]
+    expect(@html.call([:html, :comment, [:static, 'test']])).to eq([:multi, [:static, "<!--"], [:static, "test"], [:static, "-->"]])
   end
   it 'should compile js wrapped in comments' do
-    Temple::HTML::Fast.new(:js_wrapper => nil).call([:html, :js, [:static, 'test']]).should.equal [:static, "test"]
-    Temple::HTML::Fast.new(:js_wrapper => :comment).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
-    Temple::HTML::Fast.new(:js_wrapper => :cdata).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
-    Temple::HTML::Fast.new(:js_wrapper => :both).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n//-->"]]
+    expect(Temple::HTML::Fast.new(js_wrapper: nil).call([:html, :js, [:static, 'test']])).to eq([:static, "test"])
+    expect(Temple::HTML::Fast.new(js_wrapper: :comment).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]])
+    expect(Temple::HTML::Fast.new(js_wrapper: :cdata).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]])
+    expect(Temple::HTML::Fast.new(js_wrapper: :both).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "<!--\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n//-->"]])
   end
   it 'should guess default js comment' do
-    Temple::HTML::Fast.new(:js_wrapper => :guess, :format => :xhtml).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
-    Temple::HTML::Fast.new(:js_wrapper => :guess, :format => :html).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
+    expect(Temple::HTML::Fast.new(js_wrapper: :guess, format: :xhtml).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]])
+    expect(Temple::HTML::Fast.new(js_wrapper: :guess, format: :html).call([:html, :js, [:static, 'test']])).to eq([:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]])
   end
   it 'should compile autoclosed html tag' do
-    @html.call([:html, :tag,
+    expect(@html.call([:html, :tag,
       'img', [:attrs],
       [:multi, [:newline]]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:static, "<img"],
                      [:attrs],
                      [:static, " />"],
@@ -44,18 +44,18 @@ describe Temple::HTML::Fast do
   end
   it 'should compile explicitly closed html tag' do
-    @html.call([:html, :tag,
+    expect(@html.call([:html, :tag,
       'closed', [:attrs]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:static, "<closed"],
                      [:attrs],
                      [:static, " />"]]
   end
   it 'should compile html with content' do
-    @html.call([:html, :tag,
+    expect(@html.call([:html, :tag,
       'div', [:attrs], [:content]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:static, "<div"],
                      [:attrs],
                      [:static, ">"],
@@ -64,13 +64,13 @@ describe Temple::HTML::Fast do
   end
   it 'should compile html with attrs' do
-    @html.call([:html, :tag,
+    expect(@html.call([:html, :tag,
       'div',
       [:html, :attrs,
        [:html, :attr, 'id', [:static, 'test']],
        [:html, :attr, 'class', [:dynamic, 'block']]],
        [:content]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:static, "<div"],
                      [:multi,
                       [:multi, [:static, " id=\""], [:static, "test"], [:static, '"']],
@@ -82,16 +82,16 @@ describe Temple::HTML::Fast do
   it 'should keep codes intact' do
     exp = [:multi, [:code, 'foo']]
-    @html.call(exp).should.equal exp
+    expect(@html.call(exp)).to eq(exp)
   end
   it 'should keep statics intact' do
     exp = [:multi, [:static, '<']]
-    @html.call(exp).should.equal exp
+    expect(@html.call(exp)).to eq(exp)
   end
   it 'should keep dynamic intact' do
     exp = [:multi, [:dynamic, 'foo']]
-    @html.call(exp).should.equal exp
+    expect(@html.call(exp)).to eq(exp)
   end
 end

data/{test/html/test_pretty.rb → spec/html/pretty_spec.rb} RENAMED Viewed

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 describe Temple::HTML::Pretty do
   before do
@@ -6,9 +6,9 @@ describe Temple::HTML::Pretty do
   end
   it 'should indent nested tags' do
-    @html.call([:html, :tag, 'div', [:multi],
+    expect(@html.call([:html, :tag, 'div', [:multi],
       [:html, :tag, 'p', [:multi], [:multi, [:static, 'text'], [:dynamic, 'code']]]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
                      [:multi,
                       [:static, "<div"],
@@ -20,18 +20,15 @@ describe Temple::HTML::Pretty do
                        [:static, ">"],
                        [:multi,
                         [:static, "\n    text"],
-                        [:multi,
-                         [:code, "_temple_html_pretty2 = (code).to_s"],
-                         [:code, "if _temple_html_pretty1 !~ _temple_html_pretty2; _temple_html_pretty2 = _temple_html_pretty2.gsub(\"\n\", \"\\n    \"); end"],
-                         [:dynamic, "_temple_html_pretty2"]]],
+                        [:dynamic, "::Temple::Utils.indent_dynamic((code), false, \"\\n    \", _temple_html_pretty1)"]],
                        [:static, "\n  </p>"]],
                       [:static, "\n</div>"]]]
   end
   it 'should not indent preformatted tags' do
-    @html.call([:html, :tag, 'pre', [:multi],
+    expect(@html.call([:html, :tag, 'pre', [:multi],
       [:html, :tag, 'p', [:multi], [:static, 'text']]
-    ]).should.equal [:multi,
+    ])).to eq [:multi,
                      [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
                      [:multi,
                       [:static, "<pre"],
@@ -48,14 +45,11 @@ describe Temple::HTML::Pretty do
   it 'should not escape html_safe strings' do
     with_html_safe do
-      @html.call(
+      expect(@html.call(
         [:dynamic, '"text<".html_safe']
-      ).should.equal [:multi,
+      )).to eq [:multi,
                       [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
-                      [:multi,
-                       [:code, "_temple_html_pretty2 = (\"text<\".html_safe).to_s"],
-                       [:code, "if _temple_html_pretty1 !~ _temple_html_pretty2; _temple_html_pretty3 = _temple_html_pretty2.html_safe?; _temple_html_pretty2 = _temple_html_pretty2.gsub(\"\n\", \"\\n\"); _temple_html_pretty2 = _temple_html_pretty2.html_safe if _temple_html_pretty3; end"],
-                       [:dynamic, "_temple_html_pretty2"]]]
+                      [:dynamic, "::Temple::Utils.indent_dynamic((\"text<\".html_safe), nil, \"\\n\", _temple_html_pretty1)"]]
     end
   end
 end

data/spec/map_spec.rb ADDED Viewed

@@ -0,0 +1,39 @@
+require 'spec_helper'
+describe Temple::ImmutableMap do
+  it 'has read accessor' do
+    hash = Temple::ImmutableMap.new({a: 1},{b: 2, a: 3})
+    expect(hash[:a]).to eq(1)
+    expect(hash[:b]).to eq(2)
+  end
+  it 'has include?' do
+    hash = Temple::ImmutableMap.new({a: 1},{b: 2, a: 3})
+    expect(hash).to include(:a)
+    expect(hash).to include(:b)
+    expect(hash).not_to include(:c)
+  end
+  it 'has values' do
+    expect(Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).values.sort).to eq([1,2])
+  end
+  it 'has keys' do
+    expect(Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).keys).to eq([:a,:b])
+  end
+  it 'has to_a' do
+    expect(Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).to_a).to eq([[:a, 1], [:b, 2]])
+  end
+end
+describe Temple::MutableMap do
+  it 'has write accessor' do
+    parent = {a: 1}
+    hash = Temple::MutableMap.new(parent)
+    expect(hash[:a]).to eq(1)
+    hash[:a] = 2
+    expect(hash[:a]).to eq(2)
+    expect(parent[:a]).to eq(1)
+  end
+end

data/{test/mixins/test_dispatcher.rb → spec/mixins/dispatcher_spec.rb} RENAMED Viewed

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 class FilterWithDispatcherMixin
   include Temple::Mixins::Dispatcher
@@ -40,31 +40,31 @@ describe Temple::Mixins::Dispatcher do
   end
   it 'should return unhandled expressions' do
-    @filter.call([:unhandled]).should.equal [:unhandled]
+    expect(@filter.call([:unhandled])).to eq([:unhandled])
   end
   it 'should dispatch first level' do
-    @filter.call([:test, 42]).should.equal [:on_test, 42]
+    expect(@filter.call([:test, 42])).to eq([:on_test, 42])
   end
   it 'should dispatch second level' do
-    @filter.call([:second, :test, 42]).should.equal [:on_second_test, 42]
+    expect(@filter.call([:second, :test, 42])).to eq([:on_second_test, 42])
   end
   it 'should dispatch second level if prefixed' do
-    @filter.call([:test, :check, 42]).should.equal [:on_check, 42]
+    expect(@filter.call([:test, :check, 42])).to eq([:on_check, 42])
   end
   it 'should dispatch parent level' do
-    @filter.call([:a, 42]).should == [:a, 42]
-    @filter.call([:a, :b, 42]).should == [:on_ab, 42]
-    @filter.call([:a, :b, :test, 42]).should == [:on_ab_test, 42]
-    @filter.call([:a, :b, :c, 42]).should == [:on_ab, :c, 42]
-    @filter.call([:a, :b, :c, :d, 42]).should == [:on_ab, :c, :d, 42]
-    @filter.call([:a, :b, :c, :d, :test, 42]).should == [:on_abcd_test, 42]
+    expect(@filter.call([:a, 42])).to eq [:a, 42]
+    expect(@filter.call([:a, :b, 42])).to eq [:on_ab, 42]
+    expect(@filter.call([:a, :b, :test, 42])).to eq [:on_ab_test, 42]
+    expect(@filter.call([:a, :b, :c, 42])).to eq [:on_ab, :c, 42]
+    expect(@filter.call([:a, :b, :c, :d, 42])).to eq [:on_ab, :c, :d, 42]
+    expect(@filter.call([:a, :b, :c, :d, :test, 42])).to eq [:on_abcd_test, 42]
   end
   it 'should dispatch zero level' do
-    FilterWithDispatcherMixinAndOn.new.call([:foo,42]).should == [:on_zero, :foo, 42]
+    expect(FilterWithDispatcherMixinAndOn.new.call([:foo,42])).to eq [:on_zero, :foo, 42]
   end
 end

data/{test/mixins/test_grammar_dsl.rb → spec/mixins/grammar_dsl_spec.rb} RENAMED Viewed

@@ -1,4 +1,4 @@
-require 'helper'
+require 'spec_helper'
 module BasicGrammar
   extend Temple::Mixins::GrammarDSL
@@ -28,42 +28,42 @@ end
 describe Temple::Mixins::GrammarDSL do
   it 'should support class types' do
-    BasicGrammar.should.match :symbol
-    BasicGrammar.should.not.match [:symbol]
-    BasicGrammar.should.not.match 'string'
-    BasicGrammar.should.not.match ['string']
+    expect(BasicGrammar).to be_match(:symbol)
+    expect(BasicGrammar).not_to be_match([:symbol])
+    expect(BasicGrammar).not_to be_match('string')
+    expect(BasicGrammar).not_to be_match(['string'])
   end
   it 'should support value types' do
-    BasicGrammar.should.match 42
-    BasicGrammar.should.not.match 43
+    expect(BasicGrammar).to be_match(42)
+    expect(BasicGrammar).not_to be_match(43)
   end
   it 'should support nesting' do
-    BasicGrammar.should.match [:zero_or_more, [:zero_or_more]]
+    expect(BasicGrammar).to be_match([:zero_or_more, [:zero_or_more]])
   end
   it 'should support *' do
-    BasicGrammar.should.match [:zero_or_more]
-    BasicGrammar.should.match [:zero_or_more, nil, 42]
+    expect(BasicGrammar).to be_match([:zero_or_more])
+    expect(BasicGrammar).to be_match([:zero_or_more, nil, 42])
   end
   it 'should support +' do
-    BasicGrammar.should.not.match [:one_or_more]
-    BasicGrammar.should.match     [:one_or_more, 42]
-    BasicGrammar.should.match     [:one_or_more, 42, nil]
+    expect(BasicGrammar).not_to be_match([:one_or_more])
+    expect(BasicGrammar).to be_match(    [:one_or_more, 42])
+    expect(BasicGrammar).to be_match(    [:one_or_more, 42, nil])
   end
   it 'should support ?' do
-    BasicGrammar.should.not.match [:zero_or_one, nil, 42]
-    BasicGrammar.should.match     [:zero_or_one]
-    BasicGrammar.should.match     [:zero_or_one, 42]
+    expect(BasicGrammar).not_to be_match([:zero_or_one, nil, 42])
+    expect(BasicGrammar).to be_match(    [:zero_or_one])
+    expect(BasicGrammar).to be_match(    [:zero_or_one, 42])
   end
   it 'should support extended grammars' do
-    ExtendedGrammar.should.match [:extended, [:extended, 42]]
-    BasicGrammar.should.not.match [:zero_or_more, [:extended, nil]]
-    BasicGrammar.should.not.match [:extended, [:extended, 42]]
+    expect(ExtendedGrammar).to be_match([:extended, [:extended, 42]])
+    expect(BasicGrammar).not_to be_match([:zero_or_more, [:extended, nil]])
+    expect(BasicGrammar).not_to be_match([:extended, [:extended, 42]])
   end
   it 'should have validate!' do

data/{test/helper.rb → spec/spec_helper.rb} RENAMED Viewed

@@ -1,20 +1,10 @@
-require 'bacon'
 require 'temple'
-class HtmlSafeString < String
-  def html_safe?
-    true
-  end
-  def to_s
-    self
-  end
-end
 module TestHelper
   def with_html_safe
+    require 'temple/html/safe'
     String.send(:define_method, :html_safe?) { false }
-    String.send(:define_method, :html_safe) { HtmlSafeString.new(self) }
+    String.send(:define_method, :html_safe) { Temple::HTML::SafeString.new(self) }
     yield
   ensure
     String.send(:undef_method, :html_safe?) if String.method_defined?(:html_safe?)
@@ -22,14 +12,18 @@ module TestHelper
   end
   def grammar_validate(grammar, exp, message)
-    lambda { grammar.validate!(exp) }.should.raise(Temple::InvalidExpression).message.should.equal message
+    expect { grammar.validate!(exp) }.to raise_error(Temple::InvalidExpression, message)
   end
   def erb(src, options = {})
     Temple::ERB::Template.new(options) { src }.render
   end
+  def erubi(src, options = {})
+    Tilt::ErubiTemplate.new(options) { src }.render
+  end
 end
-class Bacon::Context
-  include TestHelper
+RSpec.configure do |config|
+  config.include TestHelper
 end

data/spec/static_analyzer_spec.rb ADDED Viewed

@@ -0,0 +1,39 @@
+require 'spec_helper'
+describe Temple::StaticAnalyzer do
+  describe '.available?' do
+    it 'should return true if its dependency is available' do
+      expect(Temple::StaticAnalyzer.available?).to eq(defined?(Ripper) && Ripper.respond_to?(:lex))
+    end
+  end
+  if Temple::StaticAnalyzer.available?
+    describe '.static?' do
+      it 'should return true if given Ruby expression is static' do
+        ['true', 'false', '"hello world"', "[1, { 2 => 3 }]", "[\n1,\n]"].each do |exp|
+          expect(Temple::StaticAnalyzer.static?(exp)).to eq(true)
+        end
+      end
+      it 'should return false if given Ruby expression is dynamic' do
+        ['1 + 2', 'variable', 'method_call(a)', 'CONSTANT'].each do |exp|
+          expect(Temple::StaticAnalyzer.static?(exp)).to eq(false)
+        end
+      end
+    end
+    describe '.syntax_error?' do
+      it 'should return false if given Ruby expression is valid' do
+        ['Foo.bar.baz { |c| c.d! }', '{ foo: bar }'].each do |exp|
+          expect(Temple::StaticAnalyzer.syntax_error?(exp)).to eq(false)
+        end
+      end
+      it 'should return true if given Ruby expression is invalid' do
+        ['Foo.bar.baz { |c| c.d! ', ' foo: bar '].each do |exp|
+          expect(Temple::StaticAnalyzer.syntax_error?(exp)).to eq(true)
+        end
+      end
+    end
+  end
+end

data/spec/utils_spec.rb ADDED Viewed

@@ -0,0 +1,39 @@
+require 'spec_helper'
+class UniqueTest
+  include Temple::Utils
+end
+describe Temple::Utils do
+  it 'has empty_exp?' do
+    expect(Temple::Utils.empty_exp?([:multi])).to eq(true)
+    expect(Temple::Utils.empty_exp?([:multi, [:multi]])).to eq(true)
+    expect(Temple::Utils.empty_exp?([:multi, [:multi, [:newline]], [:newline]])).to eq(true)
+    expect(Temple::Utils.empty_exp?([:multi])).to eq(true)
+    expect(Temple::Utils.empty_exp?([:multi, [:multi, [:static, 'text']]])).to eq(false)
+    expect(Temple::Utils.empty_exp?([:multi, [:newline], [:multi, [:dynamic, 'text']]])).to eq(false)
+  end
+  it 'has unique_name' do
+    u = UniqueTest.new
+    expect(u.unique_name).to eq('_uniquetest1')
+    expect(u.unique_name).to eq('_uniquetest2')
+    expect(UniqueTest.new.unique_name).to eq('_uniquetest1')
+  end
+  it 'has escape_html' do
+    expect(Temple::Utils.escape_html('<')).to eq('&lt;')
+  end
+  it 'should escape unsafe html strings' do
+    with_html_safe do
+      expect(Temple::Utils.escape_html_safe('<')).to eq('&lt;')
+    end
+  end
+  it 'should not escape safe html strings' do
+    with_html_safe do
+      expect(Temple::Utils.escape_html_safe('<'.html_safe)).to eq('<')
+    end
+  end
+end

data/temple.gemspec CHANGED Viewed

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 require File.dirname(__FILE__) + '/lib/temple/version'
 require 'date'
@@ -18,9 +17,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.license       = 'MIT'
+  s.required_ruby_version = '>= 2.5.0'
   # Tilt is only development dependency because most parts of Temple
   # can be used without it.
   s.add_development_dependency('tilt')
-  s.add_development_dependency('bacon')
+  s.add_development_dependency('rspec')
   s.add_development_dependency('rake')
+  s.add_development_dependency('erubi')
 end