temple 0.9.0 → 0.9.1

data/test/test_engine.rb

@@ -1,189 +0,0 @@
-# -*- coding: utf-8 -*-
-require '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
-    TestEngine.chain.size.should.equal 9
-
-    TestEngine.chain[0].first.should.equal :Parser
-    TestEngine.chain[0].size.should.equal 2
-    TestEngine.chain[0].last.should.be.instance_of Proc
-
-    TestEngine.chain[1].first.should.equal :MyFilter1
-    TestEngine.chain[1].size.should.equal 2
-    TestEngine.chain[1].last.should.be.instance_of Proc
-
-    TestEngine.chain[2].first.should.equal :MyFilter2
-    TestEngine.chain[2].size.should.equal 2
-    TestEngine.chain[2].last.should.be.instance_of Proc
-
-    TestEngine.chain[3].first.should.equal :'Temple::HTML::Pretty'
-    TestEngine.chain[3].size.should.equal 2
-    TestEngine.chain[3].last.should.be.instance_of Proc
-
-    TestEngine.chain[4].first.should.equal :MultiFlattener
-    TestEngine.chain[4].size.should.equal 2
-    TestEngine.chain[4].last.should.be.instance_of Proc
-
-    TestEngine.chain[5].first.should.equal :ArrayBuffer
-    TestEngine.chain[5].size.should.equal 2
-    TestEngine.chain[5].last.should.be.instance_of Proc
-
-    TestEngine.chain[6].first.should.equal :BeforeBeforeLast
-    TestEngine.chain[6].size.should.equal 2
-    TestEngine.chain[6].last.should.be.instance_of Proc
-
-    TestEngine.chain[7].first.should.equal :BeforeLast
-    TestEngine.chain[7].size.should.equal 2
-    TestEngine.chain[7].last.should.be.instance_of Proc
-
-    TestEngine.chain[8].first.should.equal :Last
-    TestEngine.chain[8].size.should.equal 2
-    TestEngine.chain[8].last.should.be.instance_of Proc
-  end
-
-  it 'should instantiate chain' do
-    call_chain = TestEngine.new.send(:call_chain)
-    call_chain[0].should.be.instance_of Method
-    call_chain[1].should.be.instance_of Method
-    call_chain[2].should.be.instance_of Method
-    call_chain[3].should.be.instance_of Temple::HTML::Pretty
-    call_chain[4].should.be.instance_of Temple::Filters::MultiFlattener
-    call_chain[5].should.be.instance_of Temple::Generators::ArrayBuffer
-    call_chain[6].should.be.instance_of MySpecialFilter
-    call_chain[7].should.be.instance_of Callable1
-    call_chain[8].should.be.instance_of Callable2
-  end
-
-  it 'should have #append' do
-    engine = TestEngine.new
-    call_chain = engine.send(:call_chain)
-    call_chain.size.should.equal 9
-
-    engine.append :MyFilter3 do |exp|
-      exp
-    end
-
-    TestEngine.chain.size.should.equal 9
-    engine.chain.size.should.equal 10
-    engine.chain[9].first.should.equal :MyFilter3
-    engine.chain[9].size.should.equal 2
-    engine.chain[9].last.should.be.instance_of Proc
-
-    call_chain = engine.send(:call_chain)
-    call_chain.size.should.equal 10
-    call_chain[9].should.be.instance_of Method
-  end
-
-  it 'should have #prepend' do
-    engine = TestEngine.new
-    call_chain = engine.send(:call_chain)
-    call_chain.size.should.equal 9
-
-    engine.prepend :MyFilter0 do |exp|
-      exp
-    end
-
-    TestEngine.chain.size.should.equal 9
-    engine.chain.size.should.equal 10
-    engine.chain[0].first.should.equal :MyFilter0
-    engine.chain[0].size.should.equal 2
-    engine.chain[0].last.should.be.instance_of Proc
-    engine.chain[1].first.should.equal :Parser
-
-    call_chain = engine.send(:call_chain)
-    call_chain.size.should.equal 10
-    call_chain[0].should.be.instance_of Method
-  end
-
-  it 'should have #after' do
-    engine = TestEngine.new
-    engine.after :Parser, :MyFilter0 do |exp|
-      exp
-    end
-    TestEngine.chain.size.should.equal 9
-    engine.chain.size.should.equal 10
-    engine.chain[0].first.should.equal :Parser
-    engine.chain[1].first.should.equal :MyFilter0
-    engine.chain[2].first.should.equal :MyFilter1
-  end
-
-  it 'should have #before' do
-    engine = TestEngine.new
-    engine.before :MyFilter1, :MyFilter0 do |exp|
-      exp
-    end
-    TestEngine.chain.size.should.equal 9
-    engine.chain.size.should.equal 10
-    engine.chain[0].first.should.equal :Parser
-    engine.chain[1].first.should.equal :MyFilter0
-    engine.chain[2].first.should.equal :MyFilter1
-  end
-
-  it 'should have #remove' do
-    engine = TestEngine.new
-    engine.remove :MyFilter1
-    TestEngine.chain.size.should.equal 9
-    engine.chain.size.should.equal 8
-    engine.chain[0].first.should.equal :Parser
-    engine.chain[1].first.should.equal :MyFilter2
-
-    engine = TestEngine.new
-    engine.remove /Last/
-    engine.chain.size.should.equal 6
-  end
-
-  it 'should have #replace' do
-    engine = TestEngine.new
-    engine.replace :Parser, :MyParser do |exp|
-      exp
-    end
-    engine.chain.size.should.equal 9
-    engine.chain[0].first.should.equal :MyParser
-  end
-
-  it 'should work with inheritance' do
-    inherited_engine = Class.new(TestEngine)
-    inherited_engine.chain.size.should.equal 9
-    inherited_engine.append :MyFilter3 do |exp|
-      exp
-    end
-    inherited_engine.chain.size.should.equal 10
-    TestEngine.chain.size.should.equal 9
-  end
-end

data/test/test_filter.rb

@@ -1,29 +0,0 @@
-require '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
-    Temple::Filter.should.respond_to :default_options
-    Temple::Filter.should.respond_to :set_default_options
-    Temple::Filter.should.respond_to :define_options
-    Temple::Filter.new.options.should.be.instance_of Temple::ImmutableMap
-    SimpleFilter.new(key: 3).options[:key].should.equal 3
-  end
-
-  it 'should implement call' do
-    Temple::Filter.new.call([:exp]).should.equal [:exp]
-  end
-
-  it 'should process expressions' do
-    filter = SimpleFilter.new
-    filter.call([:unhandled]).should.equal [:unhandled]
-    filter.call([:test, 42]).should.equal [:on_test, 42]
-  end
-end

data/test/test_generator.rb

@@ -1,158 +0,0 @@
-require 'helper'
-
-class SimpleGenerator < Temple::Generator
-  def preamble
-    "#{buffer} = BUFFER"
-  end
-
-  def postamble
-    buffer
-  end
-
-  def on_static(s)
-    concat "S:#{s}"
-  end
-
-  def on_dynamic(s)
-    concat "D:#{s}"
-  end
-
-  def on_code(s)
-    "C:#{s}"
-  end
-end
-
-describe Temple::Generator do
-  it 'should compile simple expressions' do
-    gen = SimpleGenerator.new
-
-    gen.call([:static,  'test']).should.equal '_buf = BUFFER; _buf << (S:test); _buf'
-    gen.call([:dynamic, 'test']).should.equal '_buf = BUFFER; _buf << (D:test); _buf'
-    gen.call([:code,    'test']).should.equal '_buf = BUFFER; C:test; _buf'
-  end
-
-  it 'should compile multi expression' do
-    gen = SimpleGenerator.new(buffer: "VAR")
-    gen.call([:multi,
-      [:static, "static"],
-      [:dynamic, "dynamic"],
-      [:code, "code"]
-    ]).should.equal 'VAR = BUFFER; VAR << (S:static); VAR << (D:dynamic); C:code; VAR'
-  end
-
-  it 'should compile capture' do
-    gen = SimpleGenerator.new(buffer: "VAR", capture_generator: SimpleGenerator)
-    gen.call([:capture, "foo",
-      [:static, "test"]
-    ]).should.equal 'VAR = BUFFER; foo = BUFFER; foo << (S:test); foo; VAR'
-  end
-
-  it 'should compile capture with multi' do
-    gen = SimpleGenerator.new(buffer: "VAR", capture_generator: SimpleGenerator)
-    gen.call([:multi,
-      [:static, "before"],
-
-      [:capture, "foo", [:multi,
-        [:static, "static"],
-        [:dynamic, "dynamic"],
-        [:code, "code"]]],
-
-      [:static, "after"]
-    ]).should.equal 'VAR = BUFFER; VAR << (S:before); foo = BUFFER; foo << (S:static); ' +
-      'foo << (D:dynamic); C:code; foo; VAR << (S:after); VAR'
-  end
-
-  it 'should compile newlines' do
-    gen = SimpleGenerator.new(buffer: "VAR")
-    gen.call([:multi,
-      [:static, "static"],
-      [:newline],
-      [:dynamic, "dynamic"],
-      [:newline],
-      [:code, "code"]
-    ]).should.equal "VAR = BUFFER; VAR << (S:static); \n; " +
-      "VAR << (D:dynamic); \n; C:code; VAR"
-  end
-end
-
-describe Temple::Generators::Array do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::Array.new(freeze_static: false)
-    gen.call([:static,  'test']).should.equal '_buf = []; _buf << ("test"); _buf'
-    gen.call([:dynamic, 'test']).should.equal '_buf = []; _buf << (test); _buf'
-    gen.call([:code,    'test']).should.equal '_buf = []; test; _buf'
-
-    gen.call([:multi, [:static, 'a'], [:static,  'b']]).should.equal '_buf = []; _buf << ("a"); _buf << ("b"); _buf'
-    gen.call([:multi, [:static, 'a'], [:dynamic, 'b']]).should.equal '_buf = []; _buf << ("a"); _buf << (b); _buf'
-  end
-
-  it 'should freeze static' do
-    gen = Temple::Generators::Array.new(freeze_static: true)
-    gen.call([:static,  'test']).should.equal '_buf = []; _buf << ("test".freeze); _buf'
-  end
-end
-
-describe Temple::Generators::ArrayBuffer do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::ArrayBuffer.new(freeze_static: false)
-    gen.call([:static,  'test']).should.equal '_buf = "test"'
-    gen.call([:dynamic, 'test']).should.equal '_buf = (test).to_s'
-    gen.call([:code,    'test']).should.equal '_buf = []; test; _buf = _buf.join("")'
-
-    gen.call([:multi, [:static, 'a'], [:static,  'b']]).should.equal '_buf = []; _buf << ("a"); _buf << ("b"); _buf = _buf.join("")'
-    gen.call([:multi, [:static, 'a'], [:dynamic, 'b']]).should.equal '_buf = []; _buf << ("a"); _buf << (b); _buf = _buf.join("")'
-  end
-
-  it 'should freeze static' do
-    gen = Temple::Generators::ArrayBuffer.new(freeze_static: true)
-    gen.call([:static,  'test']).should.equal '_buf = "test"'
-    gen.call([:multi, [:dynamic, '1'], [:static,  'test']]).should.equal '_buf = []; _buf << (1); _buf << ("test".freeze); _buf = _buf.join("".freeze)'
-  end
-end
-
-describe Temple::Generators::StringBuffer do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::StringBuffer.new(freeze_static: false)
-    gen.call([:static,  'test']).should.equal '_buf = "test"'
-    gen.call([:dynamic, 'test']).should.equal '_buf = (test).to_s'
-    gen.call([:code,    'test']).should.equal '_buf = \'\'; test; _buf'
-
-    gen.call([:multi, [:static, 'a'], [:static,  'b']]).should.equal '_buf = \'\'; _buf << ("a"); _buf << ("b"); _buf'
-    gen.call([:multi, [:static, 'a'], [:dynamic, 'b']]).should.equal '_buf = \'\'; _buf << ("a"); _buf << ((b).to_s); _buf'
-  end
-
-  it 'should freeze static' do
-    gen = Temple::Generators::StringBuffer.new(freeze_static: true)
-    gen.call([:static,  'test']).should.equal '_buf = "test"'
-    gen.call([:multi, [:dynamic, '1'], [:static,  'test']]).should.equal '_buf = \'\'; _buf << ((1).to_s); _buf << ("test".freeze); _buf'
-  end
-end
-
-describe Temple::Generators::ERB do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::ERB.new
-    gen.call([:static,  'test']).should.equal 'test'
-    gen.call([:dynamic, 'test']).should.equal '<%= test %>'
-    gen.call([:code,    'test']).should.equal '<% test %>'
-
-    gen.call([:multi, [:static, 'a'], [:static,  'b']]).should.equal 'ab'
-    gen.call([:multi, [:static, 'a'], [:dynamic, 'b']]).should.equal 'a<%= b %>'
-  end
-end
-
-describe Temple::Generators::RailsOutputBuffer do
-  it 'should compile simple expressions' do
-    gen = Temple::Generators::RailsOutputBuffer.new(freeze_static: false)
-    gen.call([:static,  'test']).should.equal '@output_buffer = output_buffer || ActionView::OutputBuffer.new; ' +
-      '@output_buffer.safe_concat(("test")); @output_buffer'
-    gen.call([:dynamic, 'test']).should.equal '@output_buffer = output_buffer || ActionView::OutputBuffer.new; ' +
-      '@output_buffer.safe_concat(((test).to_s)); @output_buffer'
-    gen.call([:code,    'test']).should.equal '@output_buffer = output_buffer || ActionView::OutputBuffer.new; ' +
-      'test; @output_buffer'
-  end
-
-  it 'should freeze static' do
-    gen = Temple::Generators::RailsOutputBuffer.new(freeze_static: true)
-    gen.call([:static,  'test']).should.equal '@output_buffer = output_buffer || ActionView::OutputBuffer.new; @output_buffer.safe_concat(("test".freeze)); @output_buffer'
-  end
-end

data/test/test_grammar.rb

@@ -1,47 +0,0 @@
-require 'helper'
-
-describe Temple::Grammar do
-  it 'should match core expressions' do
-    Temple::Grammar.should.match [:multi]
-    Temple::Grammar.should.match [:multi, [:multi]]
-    Temple::Grammar.should.match [:static, 'Text']
-    Temple::Grammar.should.match [:dynamic, 'Text']
-    Temple::Grammar.should.match [:code, 'Text']
-    Temple::Grammar.should.match [:capture, 'Text', [:multi]]
-    Temple::Grammar.should.match [:newline]
-  end
-
-  it 'should not match invalid core expressions' do
-    Temple::Grammar.should.not.match [:multi, 'String']
-    Temple::Grammar.should.not.match [:static]
-    Temple::Grammar.should.not.match [:dynamic, 1]
-    Temple::Grammar.should.not.match [:code, :sym]
-    Temple::Grammar.should.not.match [:capture, [:multi]]
-    Temple::Grammar.should.not.match [:newline, [:multi]]
-  end
-
-  it 'should match control flow expressions' do
-    Temple::Grammar.should.match [:if, 'Condition', [:multi]]
-    Temple::Grammar.should.match [:if, 'Condition', [:multi], [:multi]]
-    Temple::Grammar.should.match [:block, 'Loop', [:multi]]
-    Temple::Grammar.should.match [:case, 'Arg', ['Cond1', [:multi]], ['Cond1', [:multi]], [:else, [:multi]]]
-    Temple::Grammar.should.not.match [:case, 'Arg', [:sym, [:multi]]]
-    Temple::Grammar.should.match [:cond, ['Cond1', [:multi]], ['Cond2', [:multi]], [:else, [:multi]]]
-    Temple::Grammar.should.not.match [:cond, [:sym, [:multi]]]
-  end
-
-  it 'should match escape expression' do
-    Temple::Grammar.should.match [:escape, true, [:multi]]
-    Temple::Grammar.should.match [:escape, false, [:multi]]
-  end
-
-  it 'should match html expressions' do
-    Temple::Grammar.should.match [:html, :doctype, 'Doctype']
-    Temple::Grammar.should.match [:html, :comment, [:multi]]
-    Temple::Grammar.should.match [:html, :tag, 'Tag', [:multi]]
-    Temple::Grammar.should.match [:html, :tag, 'Tag', [:multi], [:multi]]
-    Temple::Grammar.should.match [:html, :tag, 'Tag', [:multi], [:static, 'Text']]
-    Temple::Grammar.should.match [:html, :tag, 'Tag', [:html, :attrs, [:html, :attr, 'id',
-                                  [:static, 'val']]], [:static, 'Text']]
-  end
-end

data/test/test_map.rb

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

data/test/test_utils.rb

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