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

temple 0.10.2 → 0.10.3

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 (33) hide show

checksums.yaml +4 -4
data/CHANGES +5 -0
data/Rakefile +0 -13
data/lib/temple/filters/dynamic_merger.rb +69 -0
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