temple 0.2.0 → 0.3.0

data/lib/temple/version.rb

@@ -1,3 +1,3 @@
 module Temple
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/test/filters/test_control_flow.rb

@@ -0,0 +1,92 @@
+require 'helper'
+
+describe Temple::Filters::ControlFlow do
+  before do
+    @filter = Temple::Filters::ControlFlow.new
+  end
+
+  it 'should process blocks' do
+    @filter.call([:block, 'loop do',
+      [:static, 'Hello']
+    ]).should.equal [:multi,
+                     [:code, 'loop do'],
+                     [:static, 'Hello'],
+                     [:code, 'end']]
+  end
+
+  it 'should process if' do
+    @filter.call([:if, 'condition',
+      [:static, 'Hello']
+    ]).should.equal [:multi,
+      [:code, 'if condition'],
+      [:static, 'Hello'],
+      [:code, 'end']
+    ]
+  end
+
+  it 'should process if with else' do
+    @filter.call([:if, 'condition',
+      [:static, 'True'],
+      [:static, 'False']
+    ]).should.equal [:multi,
+      [:code, 'if condition'],
+      [:static, 'True'],
+      [:code, 'else'],
+      [:static, 'False'],
+      [:code, 'end']
+    ]
+  end
+
+  it 'should create elsif' do
+    @filter.call([:if, 'condition1',
+      [:static, '1'],
+      [:if, 'condition2',
+       [:static, '2'],
+       [:static, '3']]
+    ]).should.equal [:multi,
+      [:code, 'if condition1'],
+      [:static, '1'],
+      [:code, 'elsif condition2'],
+      [:static, '2'],
+      [:code, 'else'],
+      [:static, '3'],
+      [:code, 'end']
+    ]
+  end
+
+  it 'should process cond' do
+    @filter.call([:cond,
+      ['cond1', [:exp11], [:exp12]],
+      ['cond2', [:exp2]],
+      [:else,   [:exp3]],
+    ]).should.equal [:multi,
+      [:code, 'case'],
+      [:code, 'when cond1'],
+      [:exp11],
+      [:exp12],
+      [:code, 'when cond2'],
+      [:exp2],
+      [:code, 'else'],
+      [:exp3],
+      [:code, 'end']
+    ]
+  end
+
+  it 'should process case' do
+    @filter.call([:case, 'var',
+      ['Array',  [:exp11], [:exp12]],
+      ['String', [:exp2]],
+      [:else,    [:exp3]],
+    ]).should.equal [:multi,
+      [:code, 'case (var)'],
+      [:code, 'when Array'],
+      [:exp11],
+      [:exp12],
+      [:code, 'when String'],
+      [:exp2],
+      [:code, 'else'],
+      [:exp3],
+      [:code, 'end']
+    ]
+  end
+end

data/test/filters/test_dynamic_inliner.rb

@@ -30,22 +30,22 @@ describe Temple::Filters::DynamicInliner do
     ]).should.equal [:multi, [:dynamic, '"Hello#{@world}#{@yeah}Nice"']]
   end
 
-  it 'should merge statics and dynamics around a block' do
+  it 'should merge statics and dynamics around a code' do
     exp = @filter.call([:multi,
       [:static, "Hello "],
       [:dynamic, "@world"],
-      [:block, "Oh yeah"],
+      [:code, "Oh yeah"],
       [:dynamic, "@yeah"],
       [:static, "Once more"]
     ]).should.equal [:multi,
       [:dynamic, '"Hello #{@world}"'],
-      [:block, "Oh yeah"],
+      [:code, "Oh yeah"],
       [:dynamic, '"#{@yeah}Once more"']
     ]
   end
 
-  it 'should keep blocks intact' do
-    exp = [:multi, [:block, 'foo']]
+  it 'should keep codes intact' do
+    exp = [:multi, [:code, 'foo']]
     @filter.call(exp).should.equal exp
   end
 
@@ -90,11 +90,11 @@ describe Temple::Filters::DynamicInliner do
     @filter.call([:multi,
       [:static, "Hello \n"],
       [:newline],
-      [:block, "world"]
+      [:code, "world"]
     ]).should.equal [:multi,
       [:static, "Hello \n"],
       [:newline],
-      [:block, "world"]
+      [:code, "world"]
     ]
   end
 end

data/test/filters/test_eraser.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+describe Temple::Filters::Eraser do
+  it 'should respect keep' do
+    eraser = Temple::Filters::Eraser.new(:keep => [:a])
+    eraser.call([:multi,
+      [:a],
+      [:b],
+      [:c]
+    ]).should.equal [:multi,
+      [:a],
+      [:multi],
+      [:multi]
+    ]
+  end
+
+  it 'should respect erase' do
+    eraser = Temple::Filters::Eraser.new(:erase => [:a])
+    eraser.call([:multi,
+      [:a],
+      [:b],
+      [:c]
+    ]).should.equal [:multi,
+      [:multi],
+      [:b],
+      [:c]
+    ]
+  end
+
+  it 'should choose erase over keep' do
+    eraser = Temple::Filters::Eraser.new(:keep => [:a, :b], :erase => [:a])
+    eraser.call([:multi,
+      [:a],
+      [:b],
+      [:c]
+    ]).should.equal [:multi,
+      [:multi],
+      [:b],
+      [:multi]
+    ]
+  end
+
+  it 'should erase nested types' do
+    eraser = Temple::Filters::Eraser.new(:erase => [[:a, :b]])
+    eraser.call([:multi,
+      [:a, :a],
+      [:a, :b],
+      [:b]
+    ]).should.equal [:multi,
+      [:a, :a],
+      [:multi],
+      [:b]
+    ]
+  end
+end

data/test/filters/{test_escape_html.rb → test_escapable.rb}

@@ -6,9 +6,9 @@ class HtmlSafeString < String
   end
 end
 
-describe Temple::Filters::EscapeHTML do
+describe Temple::Filters::Escapable do
   before do
-    @filter = Temple::Filters::EscapeHTML.new
+    @filter = Temple::Filters::Escapable.new
   end
 
   it 'should handle escape expressions' do
@@ -22,8 +22,8 @@ describe Temple::Filters::EscapeHTML do
     ]
   end
 
-  it 'should keep blocks intact' do
-    exp = [:multi, [:block, 'foo']]
+  it 'should keep codes intact' do
+    exp = [:multi, [:code, 'foo']]
     @filter.call(exp).should.equal exp
   end
 
@@ -38,9 +38,16 @@ describe Temple::Filters::EscapeHTML do
   end
 
   it 'should have use_html_safe option' do
-    filter = Temple::Filters::EscapeHTML.new(:use_html_safe => true)
+    filter = Temple::Filters::Escapable.new(:use_html_safe => true)
     filter.call([:escape, true,
-      [:static, HtmlSafeString.new("a < b")],
+      [:static, HtmlSafeString.new("a < b")]
     ]).should.equal [:static, "a < b"]
   end
+
+  it 'should support censoring' do
+    filter = Temple::Filters::Escapable.new(:escape_code => '(%s).gsub("Temple sucks", "Temple rocks")')
+    filter.call([:escape, true,
+      [:static, "~~ Temple sucks ~~"]
+    ]).should.equal [:static, "~~ Temple rocks ~~"]
+  end
 end

data/test/filters/test_multi_flattener.rb

@@ -28,6 +28,6 @@ describe Temple::Filters::MultiFlattener do
   end
 
   it 'should return first element' do
-    @filter.call([:multi, [:block, 'foo']]).should.equal [:block, 'foo']
+    @filter.call([:multi, [:code, 'foo']]).should.equal [:code, 'foo']
   end
 end

data/test/filters/test_static_merger.rb

@@ -15,16 +15,16 @@ describe Temple::Filters::StaticMerger do
     ]
   end
 
-  it 'should merge serveral statics around block' do
+  it 'should merge serveral statics around code' do
     @filter.call([:multi,
       [:static, "Hello "],
       [:static, "World!"],
-      [:block, "123"],
+      [:code, "123"],
       [:static, "Good night, "],
       [:static, "everybody"]
     ]).should.equal [:multi,
       [:static, "Hello World!"],
-      [:block, "123"],
+      [:code, "123"],
       [:static, "Good night, everybody"]
     ]
   end

data/test/helper.rb

@@ -8,6 +8,14 @@ module TestHelper
   ensure
     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
 end
 
 class Bacon::Context

data/test/html/test_fast.rb

@@ -17,44 +17,32 @@ describe Temple::HTML::Fast do
   end
 
   it 'should compile html comment' do
-    @html.call([:html, :comment, 'test']).should.equal [:multi, [:static, "<!--"], "test", [:static, "-->"]]
+    @html.call([:html, :comment, [:static, 'test']]).should.equal [:multi, [:static, "<!--"], [:static, "test"], [:static, "-->"]]
   end
 
   it 'should compile autoclosed html tag' do
     @html.call([:html, :tag,
       'img', [:attrs],
-      false, [:multi]
+      [:multi, [:newline]]
     ]).should.equal [:multi,
                      [:static, "<img"],
                      [:attrs],
-                     [:static, " /"],
-                     [:static, ">"], [:multi]]
+                     [:static, " />"],
+                     [:multi, [:newline]]]
   end
 
   it 'should compile explicitly closed html tag' do
     @html.call([:html, :tag,
-      'closed', [:attrs],
-       true, [:multi]
+      'closed', [:attrs]
     ]).should.equal [:multi,
                      [:static, "<closed"],
                      [:attrs],
-                     [:static, " /"],
-                     [:static, ">"], [:multi]]
-  end
-
-  it 'should raise error on closed tag with content' do
-    lambda {
-      @html.call([:html, :tag,
-                     'img', [:attrs],
-                     false, [:content]
-                    ])
-    }.should.raise(RuntimeError).message.should.equal 'Closed tag img has content'
+                     [:static, " />"]]
   end
 
   it 'should compile html with content' do
     @html.call([:html, :tag,
-      'div', [:attrs],
-      false, [:content]
+      'div', [:attrs], [:content]
     ]).should.equal [:multi,
                      [:static, "<div"],
                      [:attrs],
@@ -66,31 +54,24 @@ describe Temple::HTML::Fast do
   it 'should compile html with static attrs' do
     @html.call([:html, :tag,
       'div',
-      [:html, :staticattrs,
-       ['id', [:static, 'test']],
-       ['class', [:dynamic, 'block']]],
-       false, [:content]
+      [:html, :attrs,
+       [:html, :attr, 'id', [:static, 'test']],
+       [:html, :attr, 'class', [:dynamic, 'block']]],
+       [:content]
     ]).should.equal [:multi,
                      [:static,
                       "<div"],
                      [:multi,
                       [:multi,
-                       [:capture, "_temple_htmlattr1",
+                       [:capture, "_temple_html_fast1",
                         [:dynamic, "block"]],
-                       [:block, "unless _temple_htmlattr1.empty?"],
-                       [:multi,
-                        [:static, " "],
-                        [:static, "class"],
-                        [:static, "="],
-                        [:static, "'"],
-                        [:dynamic, "_temple_htmlattr1"],
-                        [:static, "'"]],
-                       [:block, "end"]],
+                       [:if, "!_temple_html_fast1.empty?",
+                        [:multi,
+                         [:static, " class='"],
+                         [:dynamic, "_temple_html_fast1"],
+                         [:static, "'"]]]],
                       [:multi,
-                       [:static, " "],
-                       [:static, "id"],
-                       [:static, "="],
-                       [:static, "'"],
+                       [:static, " id='"],
                        [:static, "test"],
                        [:static, "'"]]],
                      [:static, ">"],
@@ -100,20 +81,22 @@ describe Temple::HTML::Fast do
 
   it 'should compile html with merged ids' do
     @html.call([:html, :tag,
-      'div', [:html, :staticattrs, ['id', [:static, 'a']], ['id', [:dynamic, 'b']]],
-      false, [:content]
+      'div',
+      [:html, :attrs, [:html, :attr, 'id', [:static, 'a']], [:html, :attr, 'id', [:dynamic, 'b']]],
+      [:content]
     ]).should.equal [:multi,
                      [:static, "<div"],
                      [:multi,
                       [:multi,
-                       [:static, " "],
-                       [:static, "id"],
-                       [:static, "="],
-                       [:static, "'"],
+                       [:static, " id='"],
                        [:multi,
-                        [:static, 'a'],
-                        [:static, '_'],
-                        [:dynamic, 'b']],
+                        [:static, "a"],
+                        [:capture, "_temple_html_fast1",
+                         [:dynamic, "b"]],
+                        [:if, "!_temple_html_fast1.empty?",
+                         [:multi,
+                          [:static, "_"],
+                          [:dynamic, "_temple_html_fast1"]]]],
                        [:static, "'"]]],
                      [:static, ">"],
                      [:content],
@@ -122,28 +105,30 @@ describe Temple::HTML::Fast do
 
   it 'should compile html with merged classes' do
     @html.call([:html, :tag,
-      'div', [:html, :staticattrs, ['class', [:static, 'a']], ['class', [:dynamic, 'b']]],
-      false, [:content]
+      'div',
+      [:html, :attrs, [:html, :attr, 'class', [:static, 'a']], [:html, :attr, 'class', [:dynamic, 'b']]],
+      [:content]
     ]).should.equal [:multi,
                      [:static, "<div"],
                      [:multi,
                       [:multi,
-                       [:static, " "],
-                       [:static, "class"],
-                       [:static, "="],
-                       [:static, "'"],
+                       [:static, " class='"],
                        [:multi,
-                        [:static, 'a'],
-                        [:static, ' '],
-                        [:dynamic, 'b']],
+                        [:static, "a"],
+                        [:capture, "_temple_html_fast1",
+                         [:dynamic, "b"]],
+                        [:if, "!_temple_html_fast1.empty?",
+                         [:multi,
+                          [:static, " "],
+                          [:dynamic, "_temple_html_fast1"]]]],
                        [:static, "'"]]],
                      [:static, ">"],
                      [:content],
                      [:static, "</div>"]]
   end
 
-  it 'should keep blocks intact' do
-    exp = [:multi, [:block, 'foo']]
+  it 'should keep codes intact' do
+    exp = [:multi, [:code, 'foo']]
     @html.call(exp).should.equal exp
   end