temple 0.2.0 → 0.3.0

data/test/html/test_pretty.rb

@@ -6,10 +6,10 @@ describe Temple::HTML::Pretty do
   end
 
   it 'should indent nested tags' do
-    @html.call([:html, :tag, 'div', [:multi], false,
-      [:html, :tag, 'p', [:multi], false, [:multi, [:static, 'text'], [:dynamic, 'code']]]
+    @html.call([:html, :tag, 'div', [:multi],
+      [:html, :tag, 'p', [:multi], [:multi, [:static, 'text'], [:dynamic, 'code']]]
     ]).should.equal [:multi,
-                     [:block, "_temple_pre_tags = /<pre|<textarea/"],
+                     [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
                      [:multi,
                       [:static, "<div"],
                       [:multi],
@@ -20,17 +20,20 @@ describe Temple::HTML::Pretty do
                        [:static, ">"],
                        [:multi,
                         [:static, "text"],
-                       [:dynamic, 'Temple::Utils.indent((code), "\n    ", _temple_pre_tags)']],
+                        [:multi,
+                         [:code, "_temple_html_pretty2 = (code).to_s"],
+                         [:code, '_temple_html_pretty2.gsub!("\n", "\n    ") if _temple_html_pretty1 !~ _temple_html_pretty2'],
+                         [:dynamic, "_temple_html_pretty2"]]],
                        [:static, "</p>"]],
                       [:static, "\n</div>"]]]
   end
 
 
   it 'should not indent preformatted tags' do
-    @html.call([:html, :tag, 'pre', [:multi], false,
-      [:html, :tag, 'p', [:multi], false, [:static, 'text']]
+    @html.call([:html, :tag, 'pre', [:multi],
+      [:html, :tag, 'p', [:multi], [:static, 'text']]
     ]).should.equal [:multi,
-                     [:block, "_temple_pre_tags = /<pre|<textarea/"],
+                     [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
                      [:multi,
                       [:static, "<pre"],
                       [:multi],

data/test/mixins/test_dispatcher.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+class FilterWithDispatcherMixin
+  include Temple::Mixins::Dispatcher
+
+  def on_test(arg)
+    [:on_test, arg]
+  end
+
+  def on_second_test(arg)
+    [:on_second_test, arg]
+  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
+end

data/test/mixins/test_grammar_dsl.rb

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

data/test/test_engine.rb

@@ -50,86 +50,94 @@ describe Temple::Engine do
   end
 
   it 'should instantiate chain' do
-    e = TestEngine.new
-    e.chain[0].should.be.instance_of Method
-    e.chain[1].should.be.instance_of Method
-    e.chain[2].should.be.instance_of Method
-    e.chain[3].should.be.instance_of Temple::HTML::Pretty
-    e.chain[4].should.be.instance_of Temple::Filters::MultiFlattener
-    e.chain[5].should.be.instance_of Temple::Generators::ArrayBuffer
-    e.chain[6].should.be.instance_of OtherCallable
+    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 OtherCallable
   end
 
   it 'should have #append' do
-    e = TestEngine.new do |engine|
-      engine.append :MyFilter3 do |exp|
-        exp
-      end
-      engine.chain.size.should.equal 8
-      engine.chain[7].first.should.equal :MyFilter3
-      engine.chain[7].size.should.equal 2
-      engine.chain[7].last.should.be.instance_of Method
+    engine = TestEngine.new
+    call_chain = engine.send(:call_chain)
+    call_chain.size.should.equal 7
+
+    engine.append :MyFilter3 do |exp|
+      exp
     end
-    e.chain.size.should.equal 8
-    e.chain[7].should.be.instance_of Method
+
+    TestEngine.chain.size.should.equal 7
+    engine.chain.size.should.equal 8
+    engine.chain[7].first.should.equal :MyFilter3
+    engine.chain[7].size.should.equal 2
+    engine.chain[7].last.should.be.instance_of Method
+
+    call_chain = engine.send(:call_chain)
+    call_chain.size.should.equal 8
+    call_chain[7].should.be.instance_of Method
   end
 
   it 'should have #prepend' do
-    e = TestEngine.new do |engine|
-      engine.prepend :MyFilter0 do |exp|
-        exp
-      end
-      engine.chain.size.should.equal 8
-      engine.chain[0].first.should.equal :MyFilter0
-      engine.chain[0].size.should.equal 2
-      engine.chain[0].last.should.be.instance_of Method
-      engine.chain[1].first.should.equal :Parser
+    engine = TestEngine.new
+    call_chain = engine.send(:call_chain)
+    call_chain.size.should.equal 7
+
+    engine.prepend :MyFilter0 do |exp|
+      exp
     end
-    e.chain.size.should.equal 8
-    e.chain[0].should.be.instance_of Method
+
+    TestEngine.chain.size.should.equal 7
+    engine.chain.size.should.equal 8
+    engine.chain[0].first.should.equal :MyFilter0
+    engine.chain[0].size.should.equal 2
+    engine.chain[0].last.should.be.instance_of Method
+    engine.chain[1].first.should.equal :Parser
+
+    call_chain = engine.send(:call_chain)
+    call_chain.size.should.equal 8
+    call_chain[0].should.be.instance_of Method
   end
 
   it 'should have #after' do
-    e = TestEngine.new do |engine|
-      engine.after :Parser, :MyFilter0 do |exp|
-        exp
-      end
-      engine.chain.size.should.equal 8
-      engine.chain[0].first.should.equal :Parser
-      engine.chain[1].first.should.equal :MyFilter0
-      engine.chain[2].first.should.equal :MyFilter1
+    engine = TestEngine.new
+    engine.after :Parser, :MyFilter0 do |exp|
+      exp
     end
+    engine.chain.size.should.equal 8
+    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
-    e = TestEngine.new do |engine|
-      engine.before :MyFilter1, :MyFilter0 do |exp|
-        exp
-      end
-      engine.chain.size.should.equal 8
-      engine.chain[0].first.should.equal :Parser
-      engine.chain[1].first.should.equal :MyFilter0
-      engine.chain[2].first.should.equal :MyFilter1
+    engine = TestEngine.new
+    engine.before :MyFilter1, :MyFilter0 do |exp|
+      exp
     end
+    engine.chain.size.should.equal 8
+    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
-    e = TestEngine.new do |engine|
-      engine.remove :MyFilter1
-      engine.chain.size.should.equal 6
-      engine.chain[0].first.should.equal :Parser
-      engine.chain[1].first.should.equal :MyFilter2
-    end
+    engine = TestEngine.new
+    engine.remove :MyFilter1
+    engine.chain.size.should.equal 6
+    engine.chain[0].first.should.equal :Parser
+    engine.chain[1].first.should.equal :MyFilter2
   end
 
   it 'should have #replace' do
-    e = TestEngine.new do |engine|
-      engine.before :Parser, :MyParser do |exp|
-        exp
-      end
-      engine.chain.size.should.equal 8
-      engine.chain[0].first.should.equal :MyParser
+    engine = TestEngine.new
+    engine.before :Parser, :MyParser do |exp|
+      exp
     end
+    engine.chain.size.should.equal 8
+    engine.chain[0].first.should.equal :MyParser
   end
 
   it 'should work with inheritance' do
@@ -141,4 +149,12 @@ describe Temple::Engine do
     inherited_engine.chain.size.should.equal 8
     TestEngine.chain.size.should.equal 7
   end
+
+  it 'should support chain option' do
+    engine = TestEngine.new(:chain => proc {|e| e.remove :MyFilter1 })
+    TestEngine.chain.size.should.equal 7
+    engine.chain.size.should.equal 6
+    engine.chain[0].first.should.equal :Parser
+    engine.chain[1].first.should.equal :MyFilter2
+  end
 end

data/test/test_erb.rb

@@ -2,14 +2,7 @@ require 'helper'
 require 'erb'
 require 'tilt'
 
-class Bacon::Context
-  def erb(src, options = {})
-    Temple::Templates::Tilt(Temple::ERB::Engine).new(options) { src }.render
-  end
-end
-
 describe Temple::ERB::Engine do
-
   it 'should compile erb' do
     src = %q{
 %% hi

data/test/test_filter.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+class SimpleFilter < Temple::Filter
+  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.new.options.should.be.instance_of Temple::ImmutableHash
+    Temple::Filter.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

@@ -17,8 +17,8 @@ class SimpleGenerator < Temple::Generator
     concat "D:#{s}"
   end
 
-  def on_block(s)
-    "B:#{s}"
+  def on_code(s)
+    "C:#{s}"
   end
 end
 
@@ -26,69 +26,90 @@ describe Temple::Generator do
   it 'should compile simple expressions' do
     gen = SimpleGenerator.new
 
-    gen.call([:static, "test"]).should.match(/ << \(S:test\)/)
-    gen.call([:dynamic, "test"]).should.match(/ << \(D:test\)/)
-    gen.call([:block, "test"]).should.match(/B:test/)
+    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")
-    str = gen.call([:multi,
+    gen.call([:multi,
       [:static, "static"],
       [:dynamic, "dynamic"],
-      [:block, "block"]
-    ])
-
-    str.should.match(/VAR = BUFFER/)
-    str.should.match(/VAR << \(S:static\)/)
-    str.should.match(/VAR << \(D:dynamic\)/)
-    str.should.match(/ B:block /)
+      [: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)
-    str = gen.call([:capture, "foo", [:static, "test"]])
-
-    str.should.match(/foo = BUFFER/)
-    str.should.match(/foo << \(S:test\)/)
-    str.should.match(/VAR\Z/)
+    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)
-    str = gen.call([:multi,
+    gen.call([:multi,
       [:static, "before"],
 
       [:capture, "foo", [:multi,
         [:static, "static"],
         [:dynamic, "dynamic"],
-        [:block, "block"]]],
+        [:code, "code"]]],
 
       [:static, "after"]
-    ])
-
-    str.should.match(/VAR << \(S:before\)/)
-    str.should.match(     /foo = BUFFER/)
-    str.should.match(     /foo << \(S:static\)/)
-    str.should.match(     /foo << \(D:dynamic\)/)
-    str.should.match(     / B:block /)
-    str.should.match(/VAR << \(S:after\)/)
-    str.should.match(/VAR\Z/)
+    ]).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")
-    str = gen.call([:multi,
+    gen.call([:multi,
       [:static, "static"],
       [:newline],
       [:dynamic, "dynamic"],
       [:newline],
-      [:block, "block"]
-    ])
+      [:code, "code"]
+    ]).should.equal "VAR = BUFFER; VAR << (S:static); \n; " +
+      "VAR << (D:dynamic); \n; C:code; VAR"
+  end
+end
 
-    lines = str.split("\n")
-    lines[0].should.match(/VAR << \(S:static\)/)
-    lines[1].should.match(/VAR << \(D:dynamic\)/)
-    lines[2].should.match(/ B:block /)
+describe Temple::Generators::Array do
+  it 'should compile simple expressions' do
+    gen = Temple::Generators::Array.new
+    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'
+  end
+end
+
+describe Temple::Generators::ArrayBuffer do
+  it 'should compile simple expressions' do
+    gen = Temple::Generators::ArrayBuffer.new
+    gen.call([:static,  'test']).should.equal '_buf = []; _buf << ("test"); _buf = _buf.join'
+    gen.call([:dynamic, 'test']).should.equal '_buf = []; _buf << (test); _buf = _buf.join'
+    gen.call([:code,    'test']).should.equal '_buf = []; test; _buf = _buf.join'
+  end
+end
+
+describe Temple::Generators::StringBuffer do
+  it 'should compile simple expressions' do
+    gen = Temple::Generators::StringBuffer.new
+    gen.call([:static,  'test']).should.equal '_buf = \'\'; _buf << ("test"); _buf'
+    gen.call([:dynamic, 'test']).should.equal '_buf = \'\'; _buf << ((test).to_s); _buf'
+    gen.call([:code,    'test']).should.equal '_buf = \'\'; test; _buf'
+  end
+end
+
+describe Temple::Generators::RailsOutputBuffer do
+  it 'should compile simple expressions' do
+    gen = Temple::Generators::RailsOutputBuffer.new
+    gen.call([:static,  'test']).should.equal '@output_buffer = ActionView::OutputBuffer.new; ' +
+      '@output_buffer.safe_concat(("test")); @output_buffer'
+    gen.call([:dynamic, 'test']).should.equal '@output_buffer = ActionView::OutputBuffer.new; ' +
+      '@output_buffer.safe_concat(((test).to_s)); @output_buffer'
+    gen.call([:code,    'test']).should.equal '@output_buffer = ActionView::OutputBuffer.new; ' +
+      'test; @output_buffer'
   end
 end