temple 0.1.3 → 0.1.4

data/test/filters/test_escape_html.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+describe Temple::Filters::EscapeHTML do
+  before do
+    @filter = Temple::Filters::EscapeHTML.new
+  end
+
+  it 'should handle escape expressions' do
+    @filter.compile([:multi,
+      [:escape, :static, "a < b"],
+      [:escape, :dynamic, "ruby_method"]
+    ]).should.equal [:multi,
+      [:static, "a &lt; b"],
+      [:dynamic, "Temple::Utils.escape_html((ruby_method))"],
+    ]
+  end
+
+  it 'should keep blocks intact' do
+    exp = [:multi, [:block, 'foo']]
+    @filter.compile(exp).should.equal exp
+  end
+
+  it 'should keep statics intact' do
+    exp = [:multi, [:static, '<']]
+    @filter.compile(exp).should.equal exp
+  end
+
+  it 'should keep dynamic intact' do
+    exp = [:multi, [:dynamic, 'foo']]
+    @filter.compile(exp).should.equal exp
+  end
+end

data/test/filters/test_multi_flattener.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+describe Temple::Filters::MultiFlattener do
+  before do
+    @filter = Temple::Filters::MultiFlattener.new
+  end
+
+  it 'should flatten nested multi expressions' do
+    @filter.compile([:multi,
+      [:static, "a"],
+      [:multi,
+       [:dynamic, "aa"],
+       [:multi,
+        [:static, "aaa"],
+        [:static, "aab"],
+       ],
+       [:dynamic, "ab"],
+      ],
+      [:static, "b"],
+    ]).should.equal [:multi,
+      [:static, "a"],
+      [:dynamic, "aa"],
+      [:static, "aaa"],
+      [:static, "aab"],
+      [:dynamic, "ab"],
+      [:static, "b"],
+    ]
+  end
+
+  it 'should return first element' do
+    @filter.compile([:multi, [:block, 'foo']]).should.equal [:block, 'foo']
+  end
+end

data/test/filters/test_static_merger.rb

@@ -1,45 +1,43 @@
-require File.dirname(__FILE__) + '/../helper'
+require 'helper'
 
-class TestTempleFiltersStaticMerger < TestFilter(:StaticMerger)
-  def test_several_statics
-    exp = @filter.compile([:multi,
+describe Temple::Filters::StaticMerger do
+  before do
+    @filter = Temple::Filters::StaticMerger.new
+  end
+
+  it 'should merge serveral statics' do
+    @filter.compile([:multi,
       [:static, "Hello "],
       [:static, "World, "],
       [:static, "Good night"]
-    ])
-    
-    assert_equal([:multi,
+    ]).should.equal [:multi,
       [:static, "Hello World, Good night"]
-    ], exp)
+    ]
   end
-  
-  def test_several_statics_around_block
-    exp = @filter.compile([:multi,
+
+  it 'should merge serveral statics around block' do
+    @filter.compile([:multi,
       [:static, "Hello "],
       [:static, "World!"],
       [:block, "123"],
       [:static, "Good night, "],
       [:static, "everybody"]
-    ])
-    
-    assert_equal([:multi,
+    ]).should.equal [:multi,
       [:static, "Hello World!"],
       [:block, "123"],
       [:static, "Good night, everybody"]
-    ], exp)
+    ]
   end
-  
-  def test_several_statics_across_newlines
-    exp = @filter.compile([:multi,
+
+  it 'should merge serveral statics across newlines' do
+    @filter.compile([:multi,
       [:static, "Hello "],
       [:static, "World, "],
       [:newline],
       [:static, "Good night"]
-    ])
-    
-    assert_equal([:multi,
+    ]).should.equal [:multi,
       [:static, "Hello World, Good night"],
       [:newline]
-    ], exp)
+    ]
   end
-end
+end

data/test/helper.rb

@@ -1,21 +1,15 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-require 'test/unit'
+require 'bacon'
 require 'temple'
 
-def TestFilter(klass)
-  klass = Temple::Filters.const_get(klass.to_s) unless klass.is_a?(Class)
-  
-  Class.new(Test::Unit::TestCase) do
-    define_method(:setup) do
-      @filter = klass.new
-    end
-    
-    # Dummy test so Turn doesn't complain
-    def test_void
-    end
-    
-    def self.name
-      super || "<anonymous>"
-    end
+module TestHelper
+  def with_html_safe(flag)
+    String.send(:define_method, :html_safe?) { flag }
+    yield
+  ensure
+    String.send(:undef_method, :html_safe?) if String.method_defined?(:html_safe?)
   end
 end
+
+class Bacon::Context
+  include TestHelper
+end

data/test/html/test_fast.rb

@@ -0,0 +1,153 @@
+require 'helper'
+
+describe Temple::HTML::Fast do
+  before do
+    @html = Temple::HTML::Fast.new
+  end
+
+  it 'should compile html doctype' do
+    @html.compile([:multi, [:html, :doctype, '5']]).should.equal [:multi, [:static, '<!DOCTYPE html>']]
+    @html.compile([: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.compile([:html, :doctype, 'xml latin1']).should.equal [:static, "<?xml version='1.0' encoding='latin1' ?>"]
+  end
+
+  it 'should compile html comment' do
+    @html.compile([:html, :comment, 'test']).should.equal [:multi, [:static, "<!--"], "test", [:static, "-->"]]
+  end
+
+  it 'should compile autoclosed html tag' do
+    @html.compile([:html, :tag,
+      'img', [:attrs],
+      false, [:multi]
+    ]).should.equal [:multi,
+                     [:static, "<img"],
+                     [:attrs],
+                     [:static, " /"],
+                     [:static, ">"], [:multi]]
+  end
+
+  it 'should compile explicitly closed html tag' do
+    @html.compile([:html, :tag,
+      'closed', [:attrs],
+       true, [:multi]
+    ]).should.equal [:multi,
+                     [:static, "<closed"],
+                     [:attrs],
+                     [:static, " /"],
+                     [:static, ">"], [:multi]]
+  end
+
+  it 'should raise error on closed tag with content' do
+    lambda {
+      @html.compile([:html, :tag,
+                     'img', [:attrs],
+                     false, [:content]
+                    ])
+    }.should.raise(RuntimeError).message.should.equal 'Closed tag img has content'
+  end
+
+  it 'should compile html with content' do
+    @html.compile([:html, :tag,
+      'div', [:attrs],
+      false, [:content]
+    ]).should.equal [:multi,
+                     [:static, "<div"],
+                     [:attrs],
+                     [:static, ">"],
+                     [:content],
+                     [:static, "</div>"]]
+  end
+
+  it 'should compile html with static attrs' do
+    @html.compile([:html, :tag,
+      'div',
+      [:html, :staticattrs,
+       ['id', [:static, 'test']],
+       ['class', [:dynamic, 'block']]],
+       false, [:content]
+    ]).should.equal [:multi,
+                     [:static,
+                      "<div"],
+                     [:multi,
+                      [:multi,
+                       [:static, " "],
+                       [:static, "class"],
+                       [:static, "="],
+                       [:static, "'"],
+                       [:dynamic, "block"],
+                       [:static, "'"]],
+                      [:multi,
+                       [:static, " "],
+                       [:static, "id"],
+                       [:static, "="],
+                       [:static, "'"],
+                       [:static, "test"],
+                       [:static, "'"]]],
+                     [:static, ">"],
+                     [:content],
+                     [:static, "</div>"]]
+  end
+
+  it 'should compile html with merged ids' do
+    @html.compile([:html, :tag,
+      'div', [:html, :staticattrs, ['id', [:static, 'a']], ['id', [:dynamic, 'b']]],
+      false, [:content]
+    ]).should.equal [:multi,
+                     [:static, "<div"],
+                     [:multi,
+                      [:multi,
+                       [:static, " "],
+                       [:static, "id"],
+                       [:static, "="],
+                       [:static, "'"],
+                       [:multi,
+                        [:static, 'a'],
+                        [:static, '_'],
+                        [:dynamic, 'b']],
+                       [:static, "'"]]],
+                     [:static, ">"],
+                     [:content],
+                     [:static, "</div>"]]
+  end
+
+  it 'should compile html with merged classes' do
+    @html.compile([:html, :tag,
+      'div', [:html, :staticattrs, ['class', [:static, 'a']], ['class', [:dynamic, 'b']]],
+      false, [:content]
+    ]).should.equal [:multi,
+                     [:static, "<div"],
+                     [:multi,
+                      [:multi,
+                       [:static, " "],
+                       [:static, "class"],
+                       [:static, "="],
+                       [:static, "'"],
+                       [:multi,
+                        [:static, 'a'],
+                        [:static, ' '],
+                        [:dynamic, 'b']],
+                       [:static, "'"]]],
+                     [:static, ">"],
+                     [:content],
+                     [:static, "</div>"]]
+  end
+
+  it 'should keep blocks intact' do
+    exp = [:multi, [:block, 'foo']]
+    @html.compile(exp).should.equal exp
+  end
+
+  it 'should keep statics intact' do
+    exp = [:multi, [:static, '<']]
+    @html.compile(exp).should.equal exp
+  end
+
+  it 'should keep dynamic intact' do
+    exp = [:multi, [:dynamic, 'foo']]
+    @html.compile(exp).should.equal exp
+  end
+end

data/test/test_erb.rb

@@ -0,0 +1,68 @@
+require 'helper'
+require 'erb'
+
+class Bacon::Context
+  def erb(src, options = {})
+    Temple::ERB::Template.new(options) { src }.render
+  end
+end
+
+describe Temple::ERB::Template do
+
+  it 'should compile erb' do
+    src = %q{
+%% hi
+= hello
+<% 3.times do |n| %>
+* <%= n %>
+<% end %>
+}
+
+    erb(src).should.equal ERB.new(src).result
+  end
+
+  it 'should recognize comments' do
+    src = %q{
+hello
+  <%# comment -- ignored -- useful in testing %>
+world}
+
+    erb(src).should.equal ERB.new(src).result
+  end
+
+  it 'should recognize <%% and %%>' do
+    src = %q{
+<%%
+<% if true %>
+  %%>
+<% end %>
+}
+
+    erb(src).should.equal "\n<%\n\n  %>\n\n" #ERB.new(src).result
+  end
+
+  it 'should escape automatically' do
+    src = '<%= "<" %>'
+    ans = '&lt;'
+    erb(src, :auto_escape => true).should.equal ans
+  end
+
+  it 'should support == to disable automatic escape' do
+    src = '<%== "<" %>'
+    ans = '<'
+    erb(src, :auto_escape => true).should.equal ans
+  end
+
+  it 'should support trim mode' do
+    src = %q{
+%% hi
+= hello
+<% 3.times do |n| %>
+* <%= n %>
+<% end %>
+}
+
+    erb(src, :trim_mode => '>').should.equal ERB.new(src, nil, '>').result
+    erb(src, :trim_mode => '<>').should.equal ERB.new(src, nil, '<>').result
+  end
+end

data/test/test_generator.rb

@@ -1,101 +1,94 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestTempleGenerator < Test::Unit::TestCase
-  class Simple < 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_block(s)
-      "B:#{s}"
-    end
+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_block(s)
+    "B:#{s}"
   end
-  
-  def test_simple_exp
-    simple = Simple.new
-    
-    assert_match(/ << \(S:test\)/, simple.compile([:static, "test"]))
-    assert_match(/ << \(D:test\)/, simple.compile([:dynamic, "test"]))
-    assert_match(/B:test/, simple.compile([:block, "test"]))
+end
+
+describe Temple::Generator do
+  it 'should compile simple expressions' do
+    gen = SimpleGenerator.new
+
+    gen.compile([:static, "test"]).should.match(/ << \(S:test\)/)
+    gen.compile([:dynamic, "test"]).should.match(/ << \(D:test\)/)
+    gen.compile([:block, "test"]).should.match(/B:test/)
   end
-  
-  def test_multi
-    simple = Simple.new(:buffer => "VAR")
-    str = simple.compile([:multi,
+
+  it 'should compile multi expression' do
+    gen = SimpleGenerator.new(:buffer => "VAR")
+    str = gen.compile([:multi,
       [:static, "static"],
       [:dynamic, "dynamic"],
       [:block, "block"]
     ])
-    
-    assert_match(/VAR = BUFFER/, str)
-    assert_match(/VAR << \(S:static\)/, str)
-    assert_match(/VAR << \(D:dynamic\)/, str)
-    assert_match(/ B:block /, str)
+
+    str.should.match(/VAR = BUFFER/)
+    str.should.match(/VAR << \(S:static\)/)
+    str.should.match(/VAR << \(D:dynamic\)/)
+    str.should.match(/ B:block /)
   end
-  
-  def test_capture
-    simple = Simple.new(:buffer => "VAR", :capture_generator => Simple)
-    str = simple.compile([:capture, "foo", [:static, "test"]])
-    
-    assert_match(/foo = BUFFER/, str)
-    assert_match(/foo << \(S:test\)/, str)
-    assert_match(/VAR\Z/, str)
+
+  it 'should compile capture' do
+    gen = SimpleGenerator.new(:buffer => "VAR", :capture_generator => SimpleGenerator)
+    str = gen.compile([:capture, "foo", [:static, "test"]])
+
+    str.should.match(/foo = BUFFER/)
+    str.should.match(/foo << \(S:test\)/)
+    str.should.match(/VAR\Z/)
   end
-  
-  def test_capture_with_multi
-    simple = Simple.new(:buffer => "VAR", :capture_generator => Simple)
-    str = simple.compile([:multi,
+
+  it 'should compile capture with multi' do
+    gen = SimpleGenerator.new(:buffer => "VAR", :capture_generator => SimpleGenerator)
+    str = gen.compile([:multi,
       [:static, "before"],
-      
+
       [:capture, "foo", [:multi,
         [:static, "static"],
         [:dynamic, "dynamic"],
         [:block, "block"]]],
-        
+
       [:static, "after"]
     ])
-    
-    assert_match(/VAR << \(S:before\)/, str)
-    assert_match(/foo = BUFFER/, str)
-    assert_match(/foo << \(S:static\)/, str)
-    assert_match(/foo << \(D:dynamic\)/, str)
-    assert_match(/ B:block /, str)
-    assert_match(/VAR << \(S:after\)/, str)
-    assert_match(/VAR\Z/, str)
+
+    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/)
   end
-  
-  def test_newlines
-    simple = Simple.new(:buffer => "VAR")
-    str = simple.compile([:multi,
+
+  it 'should compile newlines' do
+    gen = SimpleGenerator.new(:buffer => "VAR")
+    str = gen.compile([:multi,
       [:static, "static"],
       [:newline],
       [:dynamic, "dynamic"],
       [:newline],
       [:block, "block"]
     ])
-    
-    lines = str.split("\n")
-    assert_match(/VAR << \(S:static\)/, lines[0])
-    assert_match(/VAR << \(D:dynamic\)/, lines[1])
-    assert_match(/ B:block /, lines[2])
-  end
-  
-  def test_to_ruby
-    simple = Simple.new
 
-    assert_equal('"Hello"', simple.to_ruby("Hello"))
-    assert_equal('"Hello\nWorld"', simple.to_ruby("Hello\nWorld"))
+    lines = str.split("\n")
+    lines[0].should.match(/VAR << \(S:static\)/)
+    lines[1].should.match(/VAR << \(D:dynamic\)/)
+    lines[2].should.match(/ B:block /)
   end
 end