RubyGems - temple - Versions diffs - 0.10.1 → 0.10.3 - Mend

temple 0.10.1 → 0.10.3

Files changed (34) hide show

checksums.yaml +4 -4
data/CHANGES +9 -0
data/Rakefile +0 -13
data/lib/temple/filters/dynamic_merger.rb +69 -0
data/lib/temple/generator.rb +3 -1
data/lib/temple/version.rb +1 -1
data/lib/temple.rb +1 -0
data/temple.gemspec +1 -2
metadata +4 -28
data/spec/engine_spec.rb +0 -189
data/spec/erb_spec.rb +0 -61
data/spec/filter_spec.rb +0 -29
data/spec/filters/code_merger_spec.rb +0 -38
data/spec/filters/control_flow_spec.rb +0 -90
data/spec/filters/dynamic_inliner_spec.rb +0 -95
data/spec/filters/eraser_spec.rb +0 -55
data/spec/filters/escapable_spec.rb +0 -49
data/spec/filters/multi_flattener_spec.rb +0 -33
data/spec/filters/static_analyzer_spec.rb +0 -35
data/spec/filters/static_merger_spec.rb +0 -41
data/spec/filters/string_splitter_spec.rb +0 -50
data/spec/generator_spec.rb +0 -179
data/spec/grammar_spec.rb +0 -47
data/spec/html/attribute_merger_spec.rb +0 -76
data/spec/html/attribute_remover_spec.rb +0 -43
data/spec/html/attribute_sorter_spec.rb +0 -48
data/spec/html/fast_spec.rb +0 -97
data/spec/html/pretty_spec.rb +0 -55
data/spec/map_spec.rb +0 -39
data/spec/mixins/dispatcher_spec.rb +0 -70
data/spec/mixins/grammar_dsl_spec.rb +0 -86
data/spec/spec_helper.rb +0 -29
data/spec/static_analyzer_spec.rb +0 -39
data/spec/utils_spec.rb +0 -39

data/spec/html/attribute_remover_spec.rb DELETED Viewed

@@ -1,43 +0,0 @@
-require 'spec_helper'
-describe Temple::HTML::AttributeRemover do
-  before do
-    @remover = Temple::HTML::AttributeRemover.new
-  end
-  it 'should pass static attributes through' do
-    expect(@remover.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'class', [:static, 'b']]],
-      [:content]
-    ])).to eq [:html, :tag, "div",
-                     [:multi,
-                      [:html, :attr, "class", [:static, "b"]]],
-                     [:content]]
-  end
-  it 'should check for empty dynamic attribute if it is included in :remove_empty_attrs' do
-    expect(@remover.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'class', [:dynamic, 'b']]],
-      [:content]
-    ])).to eq [:html, :tag, "div",
-                    [:multi,
-                      [:multi,
-                       [:capture, "_temple_html_attributeremover1", [:dynamic, "b"]],
-                       [:if, "!_temple_html_attributeremover1.empty?",
-                        [:html, :attr, "class", [:dynamic, "_temple_html_attributeremover1"]]]]],
-                     [:content]]
-  end
-  it 'should not check for empty dynamic attribute if it is not included in :remove_empty_attrs' do
-    expect(@remover.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'name', [:dynamic, 'b']]],
-      [:content]
-    ])).to eq [:html, :tag, "div",
-                     [:multi,
-                      [:html, :attr, "name", [:dynamic, "b"]]],
-                     [:content]]
-  end
-end

data/spec/html/attribute_sorter_spec.rb DELETED Viewed

@@ -1,48 +0,0 @@
-require 'spec_helper'
-describe Temple::HTML::AttributeSorter do
-  before do
-    @ordered   = Temple::HTML::AttributeSorter.new
-    @unordered = Temple::HTML::AttributeSorter.new sort_attrs: false
-  end
-  it 'should sort html attributes by name by default, when :sort_attrs is true' do
-    expect(@ordered.call([:html, :tag,
-      'meta',
-      [:html, :attrs, [:html, :attr, 'c', [:static, '1']],
-                      [:html, :attr, 'd', [:static, '2']],
-                      [:html, :attr, 'a', [:static, '3']],
-                      [:html, :attr, 'b', [:static, '4']]]
-    ])).to eq [:html, :tag, 'meta',
-                     [:html, :attrs,
-                      [:html, :attr, 'a', [:static, '3']],
-                      [:html, :attr, 'b', [:static, '4']],
-                      [:html, :attr, 'c', [:static, '1']],
-                      [:html, :attr, 'd', [:static, '2']]]]
-  end
-  it 'should preserve the order of html attributes when :sort_attrs is false' do
-    expect(@unordered.call([:html, :tag,
-      'meta',
-      [:html, :attrs, [:html, :attr, 'c', [:static, '1']],
-                      [:html, :attr, 'd', [:static, '2']],
-                      [:html, :attr, 'a', [:static, '3']],
-                      [:html, :attr, 'b', [:static, '4']]]
-    ])).to eq [:html, :tag, 'meta',
-                     [:html, :attrs,
-                      [:html, :attr, 'c', [:static, '1']],
-                      [:html, :attr, 'd', [:static, '2']],
-                      [:html, :attr, 'a', [:static, '3']],
-                      [:html, :attr, 'b', [:static, '4']]]]
-    # Use case:
-    expect(@unordered.call([:html, :tag,
-      'meta',
-      [:html, :attrs, [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
-                      [:html, :attr, 'content', [:static, '']]]
-    ])).to eq [:html, :tag, 'meta',
-                     [:html, :attrs,
-                      [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
-                      [:html, :attr, 'content', [:static, '']]]]
-  end
-end

data/spec/html/fast_spec.rb DELETED Viewed

@@ -1,97 +0,0 @@
-require 'spec_helper'
-describe Temple::HTML::Fast do
-  before do
-    @html = Temple::HTML::Fast.new
-  end
-  it 'should compile html doctype' do
-    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
-    expect(@html.call([:html, :doctype, 'xml latin1'])).to eq([:static, "<?xml version=\"1.0\" encoding=\"latin1\" ?>"])
-  end
-  it 'should compile html comment' do
-    expect(@html.call([:html, :comment, [:static, 'test']])).to eq([:multi, [:static, "<!--"], [:static, "test"], [:static, "-->"]])
-  end
-  it 'should compile js wrapped in comments' do
-    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
-    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
-    expect(@html.call([:html, :tag,
-      'img', [:attrs],
-      [:multi, [:newline]]
-    ])).to eq [:multi,
-                     [:static, "<img"],
-                     [:attrs],
-                     [:static, " />"],
-                     [:multi, [:newline]]]
-  end
-  it 'should compile explicitly closed html tag' do
-    expect(@html.call([:html, :tag,
-      'closed', [:attrs]
-    ])).to eq [:multi,
-                     [:static, "<closed"],
-                     [:attrs],
-                     [:static, " />"]]
-  end
-  it 'should compile html with content' do
-    expect(@html.call([:html, :tag,
-      'div', [:attrs], [:content]
-    ])).to eq [:multi,
-                     [:static, "<div"],
-                     [:attrs],
-                     [:static, ">"],
-                     [:content],
-                     [:static, "</div>"]]
-  end
-  it 'should compile html with attrs' do
-    expect(@html.call([:html, :tag,
-      'div',
-      [:html, :attrs,
-       [:html, :attr, 'id', [:static, 'test']],
-       [:html, :attr, 'class', [:dynamic, 'block']]],
-       [:content]
-    ])).to eq [:multi,
-                     [:static, "<div"],
-                     [:multi,
-                      [:multi, [:static, " id=\""], [:static, "test"], [:static, '"']],
-                      [:multi, [:static, " class=\""], [:dynamic, "block"], [:static, '"']]],
-                     [:static, ">"],
-                     [:content],
-                     [:static, "</div>"]]
-  end
-  it 'should keep codes intact' do
-    exp = [:multi, [:code, 'foo']]
-    expect(@html.call(exp)).to eq(exp)
-  end
-  it 'should keep statics intact' do
-    exp = [:multi, [:static, '<']]
-    expect(@html.call(exp)).to eq(exp)
-  end
-  it 'should keep dynamic intact' do
-    exp = [:multi, [:dynamic, 'foo']]
-    expect(@html.call(exp)).to eq(exp)
-  end
-end

data/spec/html/pretty_spec.rb DELETED Viewed

@@ -1,55 +0,0 @@
-require 'spec_helper'
-describe Temple::HTML::Pretty do
-  before do
-    @html = Temple::HTML::Pretty.new
-  end
-  it 'should indent nested tags' do
-    expect(@html.call([:html, :tag, 'div', [:multi],
-      [:html, :tag, 'p', [:multi], [:multi, [:static, 'text'], [:dynamic, 'code']]]
-    ])).to eq [:multi,
-                     [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
-                     [:multi,
-                      [:static, "<div"],
-                      [:multi],
-                      [:static, ">"],
-                      [:multi,
-                       [:static, "\n  <p"],
-                       [:multi],
-                       [:static, ">"],
-                       [:multi,
-                        [:static, "\n    text"],
-                        [: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
-    expect(@html.call([:html, :tag, 'pre', [:multi],
-      [:html, :tag, 'p', [:multi], [:static, 'text']]
-    ])).to eq [:multi,
-                     [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
-                     [:multi,
-                      [:static, "<pre"],
-                      [:multi],
-                      [:static, ">"],
-                      [:multi,
-                       [:static, "<p"],
-                       [:multi],
-                       [:static, ">"],
-                       [:static, "text"],
-                       [:static, "</p>"]],
-                      [:static, "</pre>"]]]
-  end
-  it 'should not escape html_safe strings' do
-    with_html_safe do
-      expect(@html.call(
-        [:dynamic, '"text<".html_safe']
-      )).to eq [:multi,
-                      [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
-                      [:dynamic, "::Temple::Utils.indent_dynamic((\"text<\".html_safe), nil, \"\\n\", _temple_html_pretty1)"]]
-    end
-  end
-end

data/spec/map_spec.rb DELETED Viewed

@@ -1,39 +0,0 @@
-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/spec/mixins/dispatcher_spec.rb DELETED Viewed

@@ -1,70 +0,0 @@
-require 'spec_helper'
-class FilterWithDispatcherMixin
-  include Temple::Mixins::Dispatcher
-  def on_test(arg)
-    [:on_test, arg]
-  end
-  def on_test_check(arg)
-    [:on_check, arg]
-  end
-  def on_second_test(arg)
-    [:on_second_test, arg]
-  end
-  def on_a_b(*arg)
-    [:on_ab, *arg]
-  end
-  def on_a_b_test(arg)
-    [:on_ab_test, arg]
-  end
-  def on_a_b_c_d_test(arg)
-    [:on_abcd_test, arg]
-  end
-end
-class FilterWithDispatcherMixinAndOn < FilterWithDispatcherMixin
-  def on(*args)
-    [:on_zero, *args]
-  end
-end
-describe Temple::Mixins::Dispatcher do
-  before do
-    @filter = FilterWithDispatcherMixin.new
-  end
-  it 'should return unhandled expressions' do
-    expect(@filter.call([:unhandled])).to eq([:unhandled])
-  end
-  it 'should dispatch first level' do
-    expect(@filter.call([:test, 42])).to eq([:on_test, 42])
-  end
-  it 'should dispatch second level' do
-    expect(@filter.call([:second, :test, 42])).to eq([:on_second_test, 42])
-  end
-  it 'should dispatch second level if prefixed' do
-    expect(@filter.call([:test, :check, 42])).to eq([:on_check, 42])
-  end
-  it 'should dispatch parent level' do
-    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
-    expect(FilterWithDispatcherMixinAndOn.new.call([:foo,42])).to eq [:on_zero, :foo, 42]
-  end
-end

data/spec/mixins/grammar_dsl_spec.rb DELETED Viewed

@@ -1,86 +0,0 @@
-require 'spec_helper'
-module BasicGrammar
-  extend Temple::Mixins::GrammarDSL
-  Expression <<
-    Symbol |
-    Answer |
-    [:zero_or_more, 'Expression*'] |
-    [:one_or_more,  'Expression+'] |
-    [:zero_or_one,  'Expression?'] |
-    [:bool, Bool] |
-    nil
-  Bool <<
-    true | false
-  Answer <<
-    Value(42)
-end
-module ExtendedGrammar
-  extend BasicGrammar
-  Expression << [:extended, Expression]
-end
-describe Temple::Mixins::GrammarDSL do
-  it 'should support class types' do
-    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
-    expect(BasicGrammar).to be_match(42)
-    expect(BasicGrammar).not_to be_match(43)
-  end
-  it 'should support nesting' do
-    expect(BasicGrammar).to be_match([:zero_or_more, [:zero_or_more]])
-  end
-  it 'should support *' do
-    expect(BasicGrammar).to be_match([:zero_or_more])
-    expect(BasicGrammar).to be_match([:zero_or_more, nil, 42])
-  end
-  it 'should support +' do
-    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
-    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
-    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
-    grammar_validate BasicGrammar,
-                     [:zero_or_more, [:zero_or_more, [:unknown]]],
-                     "BasicGrammar::Expression did not match\n[:unknown]\n"
-    grammar_validate BasicGrammar,
-                     [:zero_or_more, [:one_or_more]],
-                     "BasicGrammar::Expression did not match\n[:one_or_more]\n"
-    grammar_validate BasicGrammar,
-                     [:zero_or_more, 123, [:unknown]],
-                     "BasicGrammar::Expression did not match\n123\n"
-    grammar_validate BasicGrammar,
-                     [:bool, 123],
-                     "BasicGrammar::Bool did not match\n123\n"
-  end
-end

data/spec/spec_helper.rb DELETED Viewed

@@ -1,29 +0,0 @@
-require 'temple'
-module TestHelper
-  def with_html_safe
-    require 'temple/html/safe'
-    String.send(:define_method, :html_safe?) { false }
-    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?)
-    String.send(:undef_method, :html_safe) if String.method_defined?(:html_safe)
-  end
-  def grammar_validate(grammar, exp, 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
-RSpec.configure do |config|
-  config.include TestHelper
-end

data/spec/static_analyzer_spec.rb DELETED Viewed

@@ -1,39 +0,0 @@
-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 DELETED Viewed

@@ -1,39 +0,0 @@
-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