temple 0.8.2 → 0.10.4

data/test/filters/test_static_analyzer.rb

@@ -1,37 +0,0 @@
-require 'helper'
-
-describe Temple::Filters::StaticAnalyzer do
-  before do
-    @filter = Temple::Filters::StaticAnalyzer.new
-    @generator = Temple::Generator.new
-  end
-
-  if Temple::StaticAnalyzer.available?
-    it 'should convert :dynamic to :static if code is static' do
-      @filter.call([:dynamic, '"#{"hello"}#{100}"']
-      ).should.equal [:static, 'hello100']
-    end
-
-    it 'should not convert :dynamic if code is dynamic' do
-      exp = [:dynamic, '"#{hello}#{100}"']
-      @filter.call(exp).should.equal(exp)
-    end
-
-    it 'should not change number of newlines in generated code' do
-      exp = [:dynamic, "[100,\n200,\n]"]
-      @filter.call(exp).should.equal([:multi, [:static, '[100, 200]'], [:newline], [:newline]])
-
-      @generator.call(@filter.call(exp)).count("\n").
-        should.equal(@generator.call(exp).count("\n"))
-    end
-  else
-    it 'should do nothing' do
-      [
-        [:dynamic, '"#{"hello"}#{100}"'],
-        [:dynamic, '"#{hello}#{100}"'],
-      ].each do |exp|
-        @filter.call(exp).should.equal(exp)
-      end
-    end
-  end
-end

data/test/filters/test_static_merger.rb

@@ -1,41 +0,0 @@
-require 'helper'
-
-describe Temple::Filters::StaticMerger do
-  before do
-    @filter = Temple::Filters::StaticMerger.new
-  end
-
-  it 'should merge serveral statics' do
-    @filter.call([:multi,
-      [:static, "Hello "],
-      [:static, "World, "],
-      [:static, "Good night"]
-    ]).should.equal [:static, "Hello World, Good night"]
-  end
-
-  it 'should merge serveral statics around code' do
-    @filter.call([:multi,
-      [:static, "Hello "],
-      [:static, "World!"],
-      [:code, "123"],
-      [:static, "Good night, "],
-      [:static, "everybody"]
-    ]).should.equal [:multi,
-      [:static, "Hello World!"],
-      [:code, "123"],
-      [:static, "Good night, everybody"]
-    ]
-  end
-
-  it 'should merge serveral statics across newlines' do
-    @filter.call([:multi,
-      [:static, "Hello "],
-      [:static, "World, "],
-      [:newline],
-      [:static, "Good night"]
-    ]).should.equal [:multi,
-      [:static, "Hello World, Good night"],
-      [:newline]
-    ]
-  end
-end

data/test/filters/test_string_splitter.rb

@@ -1,25 +0,0 @@
-require 'helper'
-begin
-  require 'ripper'
-rescue LoadError
-end
-
-if defined?(Ripper) && RUBY_VERSION >= "2.0.0"
-  describe Temple::Filters::StringSplitter do
-    before do
-      @filter = Temple::Filters::StringSplitter.new
-    end
-
-    it 'should split :dynamic with string literal' do
-      @filter.call([:dynamic, '"static#{dynamic}"']
-      ).should.equal [:multi, [:static, 'static'], [:dynamic, 'dynamic']]
-    end
-
-    describe '.compile' do
-      it 'should raise CompileError for non-string literals' do
-        lambda { Temple::Filters::StringSplitter.compile('1') }.
-          should.raise(Temple::FilterError)
-      end
-    end
-  end
-end

data/test/helper.rb

@@ -1,30 +0,0 @@
-require 'bacon'
-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)
-    lambda { grammar.validate!(exp) }.should.raise(Temple::InvalidExpression).message.should.equal message
-  end
-
-  def erb(src, options = {})
-    Temple::ERB::Template.new(options) { src }.render
-  end
-
-  def erubis(src, options = {})
-    Tilt::ErubisTemplate.new(options) { src }.render
-  end
-end
-
-class Bacon::Context
-  include TestHelper
-end

data/test/html/test_attribute_merger.rb

@@ -1,76 +0,0 @@
-require 'helper'
-
-describe Temple::HTML::AttributeMerger do
-  before do
-    @merger = Temple::HTML::AttributeMerger.new
-  end
-
-  it 'should pass static attributes through' do
-    @merger.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'class', [:static, 'b']]],
-      [:content]
-    ]).should.equal [:html, :tag, "div",
-                     [:html, :attrs,
-                      [:html, :attr, "class", [:static, "b"]]],
-                     [:content]]
-  end
-
-  it 'should preserve the order of html attributes' do
-    @merger.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']]]
-    ]).should.equal [: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:
-    @merger.call([:html, :tag,
-      'meta',
-      [:html, :attrs, [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
-                      [:html, :attr, 'content', [:static, '']]]
-    ]).should.equal [:html, :tag, 'meta',
-                     [:html, :attrs,
-                      [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
-                      [:html, :attr, 'content', [:static, '']]]]
-  end
-
-  it 'should merge ids' do
-    @merger.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'id', [:dynamic, 'a']], [:html, :attr, 'id', [:dynamic, 'b']]],
-      [:content]
-    ]).should.equal [:html, :tag, "div",
-                     [:html, :attrs,
-                      [:html, :attr, "id",
-                       [:multi,
-                        [:code, "_temple_html_attributemerger1 = []"],
-                        [:capture, "_temple_html_attributemerger1[0]", [:dynamic, "a"]],
-                        [:capture, "_temple_html_attributemerger1[1]", [:dynamic, "b"]],
-                        [:dynamic, "_temple_html_attributemerger1.reject(&:empty?).join(\"_\")"]]]],
-                     [:content]]
-  end
-
-  it 'should merge classes' do
-    @merger.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'class', [:static, 'a']], [:html, :attr, 'class', [:dynamic, 'b']]],
-      [:content]
-    ]).should.equal [:html, :tag, "div",
-                     [:html, :attrs,
-                      [:html, :attr, "class",
-                       [:multi,
-                        [:code, "_temple_html_attributemerger1 = []"],
-                        [:capture, "_temple_html_attributemerger1[0]", [:static, "a"]],
-                        [:capture, "_temple_html_attributemerger1[1]", [:dynamic, "b"]],
-                        [:dynamic, "_temple_html_attributemerger1.reject(&:empty?).join(\" \")"]]]],
-                     [:content]]
-  end
-end
-

data/test/html/test_attribute_remover.rb

@@ -1,43 +0,0 @@
-require 'helper'
-
-describe Temple::HTML::AttributeRemover do
-  before do
-    @remover = Temple::HTML::AttributeRemover.new
-  end
-
-  it 'should pass static attributes through' do
-    @remover.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'class', [:static, 'b']]],
-      [:content]
-    ]).should.equal [: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
-    @remover.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'class', [:dynamic, 'b']]],
-      [:content]
-    ]).should.equal [: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
-    @remover.call([:html, :tag,
-      'div',
-      [:html, :attrs, [:html, :attr, 'name', [:dynamic, 'b']]],
-      [:content]
-    ]).should.equal [:html, :tag, "div",
-                     [:multi,
-                      [:html, :attr, "name", [:dynamic, "b"]]],
-                     [:content]]
-  end
-end

data/test/html/test_attribute_sorter.rb

@@ -1,48 +0,0 @@
-require '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
-    @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']]]
-    ]).should.equal [: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
-    @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']]]
-    ]).should.equal [: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:
-    @unordered.call([:html, :tag,
-      'meta',
-      [:html, :attrs, [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
-                      [:html, :attr, 'content', [:static, '']]]
-    ]).should.equal [:html, :tag, 'meta',
-                     [:html, :attrs,
-                      [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
-                      [:html, :attr, 'content', [:static, '']]]]
-  end
-end

data/test/html/test_fast.rb

@@ -1,97 +0,0 @@
-require 'helper'
-
-describe Temple::HTML::Fast do
-  before do
-    @html = Temple::HTML::Fast.new
-  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,
-      [: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\" ?>"]
-  end
-
-  it 'should compile html comment' do
-    @html.call([:html, :comment, [:static, 'test']]).should.equal [: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//-->"]]
-  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//-->"]]
-  end
-
-  it 'should compile autoclosed html tag' do
-    @html.call([:html, :tag,
-      'img', [:attrs],
-      [:multi, [:newline]]
-    ]).should.equal [:multi,
-                     [:static, "<img"],
-                     [:attrs],
-                     [:static, " />"],
-                     [:multi, [:newline]]]
-  end
-
-  it 'should compile explicitly closed html tag' do
-    @html.call([:html, :tag,
-      'closed', [:attrs]
-    ]).should.equal [:multi,
-                     [:static, "<closed"],
-                     [:attrs],
-                     [:static, " />"]]
-  end
-
-  it 'should compile html with content' do
-    @html.call([:html, :tag,
-      'div', [:attrs], [:content]
-    ]).should.equal [:multi,
-                     [:static, "<div"],
-                     [:attrs],
-                     [:static, ">"],
-                     [:content],
-                     [:static, "</div>"]]
-  end
-
-  it 'should compile html with attrs' do
-    @html.call([:html, :tag,
-      'div',
-      [:html, :attrs,
-       [:html, :attr, 'id', [:static, 'test']],
-       [:html, :attr, 'class', [:dynamic, 'block']]],
-       [:content]
-    ]).should.equal [: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']]
-    @html.call(exp).should.equal exp
-  end
-
-  it 'should keep statics intact' do
-    exp = [:multi, [:static, '<']]
-    @html.call(exp).should.equal exp
-  end
-
-  it 'should keep dynamic intact' do
-    exp = [:multi, [:dynamic, 'foo']]
-    @html.call(exp).should.equal exp
-  end
-end

data/test/html/test_pretty.rb

@@ -1,55 +0,0 @@
-require 'helper'
-
-describe Temple::HTML::Pretty do
-  before do
-    @html = Temple::HTML::Pretty.new
-  end
-
-  it 'should indent nested tags' do
-    @html.call([:html, :tag, 'div', [:multi],
-      [:html, :tag, 'p', [:multi], [:multi, [:static, 'text'], [:dynamic, 'code']]]
-    ]).should.equal [: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
-    @html.call([:html, :tag, 'pre', [:multi],
-      [:html, :tag, 'p', [:multi], [:static, 'text']]
-    ]).should.equal [: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
-      @html.call(
-        [:dynamic, '"text<".html_safe']
-      ).should.equal [: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/test/mixins/test_dispatcher.rb

@@ -1,70 +0,0 @@
-require '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
-    @filter.call([:unhandled]).should.equal [:unhandled]
-  end
-
-  it 'should dispatch first level' do
-    @filter.call([:test, 42]).should.equal [:on_test, 42]
-  end
-
-  it 'should dispatch second level' do
-    @filter.call([:second, :test, 42]).should.equal [:on_second_test, 42]
-  end
-
-  it 'should dispatch second level if prefixed' do
-    @filter.call([:test, :check, 42]).should.equal [: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]
-  end
-
-  it 'should dispatch zero level' do
-    FilterWithDispatcherMixinAndOn.new.call([:foo,42]).should == [:on_zero, :foo, 42]
-  end
-end

data/test/mixins/test_grammar_dsl.rb

@@ -1,86 +0,0 @@
-require '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
-    BasicGrammar.should.match :symbol
-    BasicGrammar.should.not.match [:symbol]
-    BasicGrammar.should.not.match 'string'
-    BasicGrammar.should.not.match ['string']
-  end
-
-  it 'should support value types' do
-    BasicGrammar.should.match 42
-    BasicGrammar.should.not.match 43
-  end
-
-  it 'should support nesting' do
-    BasicGrammar.should.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]
-  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]
-  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]
-  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]]
-  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