temple 0.0.1 → 0.1.0

data/test/engines/test_erb_m17n.rb

@@ -0,0 +1,132 @@
+# -*- coding: UTF-8 -*-
+require File.dirname(__FILE__) + '/../helper'
+
+if "".respond_to?(:encoding)
+  class TestTempleEnginesERBM17N < Test::Unit::TestCase
+    def setup
+      Temple::Engines::ERB.rock!
+    end
+  
+    def teardown
+      Temple::Engines::ERB.rock!
+    end
+  
+    def test_result_encoding
+      erb = ERB.new("hello")
+      assert_equal __ENCODING__, erb.result.encoding
+
+      erb = ERB.new("こんにちは".encode("EUC-JP"))
+      assert_equal Encoding::EUC_JP, erb.result.encoding
+
+      erb = ERB.new("\xC4\xE3\xBA\xC3".force_encoding("EUC-CN"))
+      assert_equal Encoding::EUC_CN, erb.result.encoding
+
+      erb = ERB.new("γεια σας".encode("ISO-8859-7"))
+      assert_equal Encoding::ISO_8859_7, erb.result.encoding
+
+      assert_raise(ArgumentError) {
+        ERB.new("こんにちは".force_encoding("ISO-2022-JP")) # dummy encoding
+      }
+    end
+
+    def test_generate_magic_comment
+      erb = ERB.new("hello")
+      assert_match(/#coding:UTF-8/, erb.src)
+
+      erb = ERB.new("hello".force_encoding("EUC-JP"))
+      assert_match(/#coding:EUC-JP/, erb.src)
+
+      erb = ERB.new("hello".force_encoding("ISO-8859-9"))
+      assert_match(/#coding:ISO-8859-9/, erb.src)
+    end
+
+    def test_literal_encoding
+      erb = ERB.new("literal encoding is <%= 'hello'.encoding  %>")
+      assert_match(/literal encoding is UTF-8/, erb.result)
+
+      erb = ERB.new("literal encoding is <%= 'こんにちは'.encoding  %>".encode("EUC-JP"))
+      assert_match(/literal encoding is EUC-JP/, erb.result)
+
+      erb = ERB.new("literal encoding is <%= '\xC4\xE3\xBA\xC3'.encoding %>".force_encoding("EUC-CN"))
+      assert_match(/literal encoding is GB2312/, erb.result)
+    end
+
+    def test___ENCODING__
+      erb = ERB.new("__ENCODING__ is <%= __ENCODING__ %>")
+      assert_match(/__ENCODING__ is UTF-8/, erb.result)
+
+      erb = ERB.new("__ENCODING__ is <%= __ENCODING__ %>".force_encoding("EUC-JP"))
+      assert_match(/__ENCODING__ is EUC-JP/, erb.result)
+
+      erb = ERB.new("__ENCODING__ is <%= __ENCODING__ %>".force_encoding("Big5"))
+      assert_match(/__ENCODING__ is Big5/, erb.result)
+    end
+
+    def test_recognize_magic_comment
+      erb = ERB.new(<<-EOS.encode("EUC-KR"))
+<%# -*- coding: EUC-KR -*- %>
+안녕하세요
+      EOS
+      assert_match(/#coding:EUC-KR/, erb.src)
+      assert_equal Encoding::EUC_KR, erb.result.encoding
+
+      erb = ERB.new(<<-EOS.encode("EUC-KR").force_encoding("ASCII-8BIT"))
+<%#-*- coding: EUC-KR -*-%>
+안녕하세요
+      EOS
+      assert_match(/#coding:EUC-KR/, erb.src)
+      assert_equal Encoding::EUC_KR, erb.result.encoding
+
+      erb = ERB.new(<<-EOS.encode("EUC-KR").force_encoding("ASCII-8BIT"))
+<%# vim: tabsize=8 encoding=EUC-KR shiftwidth=2 expandtab %>
+안녕하세요
+      EOS
+      assert_match(/#coding:EUC-KR/, erb.src)
+      assert_equal Encoding::EUC_KR, erb.result.encoding
+
+      erb = ERB.new(<<-EOS.encode("EUC-KR").force_encoding("ASCII-8BIT"))
+<%#coding:EUC-KR %>
+안녕하세요
+      EOS
+      assert_match(/#coding:EUC-KR/, erb.src)
+      assert_equal Encoding::EUC_KR, erb.result.encoding
+
+      erb = ERB.new(<<-EOS.encode("EUC-KR").force_encoding("EUC-JP"))
+<%#coding:EUC-KR %>
+안녕하세요
+      EOS
+      assert_match(/#coding:EUC-KR/, erb.src)
+      assert_equal Encoding::EUC_KR, erb.result.encoding
+    end
+
+    module M; end
+    def test_method_with_encoding
+      obj = Object.new
+      obj.extend(M)
+
+      erb = ERB.new(<<-EOS.encode("EUC-JP").force_encoding("ASCII-8BIT"))
+<%#coding:EUC-JP %>
+literal encoding is <%= 'こんにちは'.encoding %>
+__ENCODING__ is <%= __ENCODING__ %>
+    EOS
+      erb.def_method(M, :m_from_magic_comment)
+
+      result = obj.m_from_magic_comment
+      assert_equal Encoding::EUC_JP, result.encoding
+      assert_match(/literal encoding is EUC-JP/, result)
+      assert_match(/__ENCODING__ is EUC-JP/, result)
+
+      erb = ERB.new(<<-EOS.encode("EUC-KR"))
+literal encoding is <%= '안녕하세요'.encoding %>
+__ENCODING__ is <%= __ENCODING__ %>
+EOS
+      erb.def_method(M, :m_from_eval_encoding)
+      result = obj.m_from_eval_encoding
+      assert_equal Encoding::EUC_KR, result.encoding
+      assert_match(/literal encoding is EUC-KR/, result)
+      assert_match(/__ENCODING__ is EUC-KR/, result)
+    end
+  end
+end
+
+# vim:fileencoding=UTF-8

data/test/filters/test_dynamic_inliner.rb

@@ -0,0 +1,116 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class TestTempleFiltersDynamicInliner < TestFilter(:DynamicInliner)
+  def test_several_statics_into_dynamic
+    exp = @filter.compile([:multi,
+      [:static, "Hello "],
+      [:static, "World\n "],
+      [:static, "Have a nice day"]
+    ])
+    
+    assert_equal([:multi,
+      [:dynamic, "\"Hello World\n Have a nice day\""]
+    ], exp)
+  end
+
+  def test_several_dynamics_into_dynamic
+    exp = @filter.compile([:multi,
+      [:dynamic, "@hello"],
+      [:dynamic, "@world"],
+      [:dynamic, "@yeah"]
+    ])
+    
+    assert_equal([:multi,
+      [:dynamic, '"#{@hello}#{@world}#{@yeah}"']
+    ], exp)
+  end
+  
+  def test_static_and_dynamic_into_dynamic
+    exp = @filter.compile([:multi,
+      [:static, "Hello"],
+      [:dynamic, "@world"],
+      [:dynamic, "@yeah"],
+      [:static, "Nice"]
+    ])
+    
+    assert_equal([:multi,
+      [:dynamic, '"Hello#{@world}#{@yeah}Nice"']
+    ], exp)
+  end
+  
+  def test_static_and_dynamic_around_blocks
+    exp = @filter.compile([:multi,
+      [:static, "Hello "],
+      [:dynamic, "@world"],
+      [:block, "Oh yeah"],
+      [:dynamic, "@yeah"],
+      [:static, "Once more"]
+    ])
+    
+    assert_equal([:multi,
+      [:dynamic, '"Hello #{@world}"'],
+      [:block, "Oh yeah"],
+      [:dynamic, '"#{@yeah}Once more"']
+    ], exp)
+  end
+  
+  def test_keep_blocks_intact
+    exp = [:multi, [:block, 'foo']]
+    assert_equal(exp, @filter.compile(exp))
+  end
+  
+  def test_keep_single_static_intact
+    exp = [:multi, [:static, 'foo']]
+    assert_equal(exp, @filter.compile(exp))
+  end
+
+  def test_keep_single_dynamic_intact
+    exp = [:multi, [:dynamic, 'foo']]
+    assert_equal(exp, @filter.compile(exp))
+  end
+  
+  def test_inline_inside_multi
+    exp = @filter.compile([:multi,
+      [:static, "Hello "],
+      [:dynamic, "@world"],
+      [:multi,
+        [:static, "Hello "],
+        [:dynamic, "@world"]],
+      [:static, "Hello "],
+      [:dynamic, "@world"]
+    ])
+    
+    assert_equal([:multi,
+      [:dynamic, '"Hello #{@world}"'],
+      [:multi, [:dynamic, '"Hello #{@world}"']],
+      [:dynamic, '"Hello #{@world}"']
+    ], exp)
+  end
+  
+  def test_merge_across_newlines
+    exp = @filter.compile([:multi,
+      [:static, "Hello \n"],
+      [:newline],
+      [:dynamic, "@world"],
+      [:newline]
+    ])
+    
+    assert_equal([:multi,
+      [:dynamic, ["\"Hello \n\"", '"#{@world}"', '""'].join("\\\n")],
+    ], exp)
+  end
+  
+  def test_static_followed_by_newline
+    exp = @filter.compile([:multi,
+      [:static, "Hello \n"],
+      [:newline],
+      [:block, "world"]
+    ])
+    
+    assert_equal([:multi,
+      [:static, "Hello \n"],
+      [:newline],
+      [:block, "world"]
+    ], exp)
+  end
+end

data/test/filters/test_escapable.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class TestTempleFiltersEscapable < TestFilter(:Escapable)
+  def test_escape
+    exp = @filter.compile([:multi,
+      [:escape, [:dynamic, "@hello"]],
+      [:escape, [:block, "@world"]]
+    ])
+    
+    assert_equal([:multi,
+      [:dynamic, "CGI.escapeHTML((@hello).to_s)"],
+      [:block, "CGI.escapeHTML((@world).to_s)"]
+    ], exp)
+  end
+
+  def test_escape_static_content
+    exp = @filter.compile([:multi,
+      [:escape, [:static, "<hello>"]],
+      [:escape, [:block, "@world"]]
+    ])
+    
+    assert_equal([:multi,
+      [:static, "&lt;hello&gt;"],
+      [:block, "CGI.escapeHTML((@world).to_s)"]
+    ], exp)
+  end
+end
+

data/test/filters/test_static_merger.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class TestTempleFiltersStaticMerger < TestFilter(:StaticMerger)
+  def test_several_statics
+    exp = @filter.compile([:multi,
+      [:static, "Hello "],
+      [:static, "World, "],
+      [:static, "Good night"]
+    ])
+    
+    assert_equal([:multi,
+      [:static, "Hello World, Good night"]
+    ], exp)
+  end
+  
+  def test_several_statics_around_block
+    exp = @filter.compile([:multi,
+      [:static, "Hello "],
+      [:static, "World!"],
+      [:block, "123"],
+      [:static, "Good night, "],
+      [:static, "everybody"]
+    ])
+    
+    assert_equal([:multi,
+      [:static, "Hello World!"],
+      [:block, "123"],
+      [:static, "Good night, everybody"]
+    ], exp)
+  end
+  
+  def test_several_statics_across_newlines
+    exp = @filter.compile([:multi,
+      [:static, "Hello "],
+      [:static, "World, "],
+      [:newline],
+      [:static, "Good night"]
+    ])
+    
+    assert_equal([:multi,
+      [:static, "Hello World, Good night"],
+      [:newline]
+    ], exp)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'test/unit'
+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
+  end
+end

data/test/test_generator.rb

@@ -0,0 +1,122 @@
+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)
+      "S:#{s}"
+    end
+    
+    def on_dynamic(s)
+      "D:#{s}"
+    end
+    
+    def on_block(s)
+      "B:#{s}"
+    end
+  end
+  
+  def test_simple_exp
+    simple = Simple.new
+    
+    assert_equal("S:test", simple.compile([:static, "test"]))
+    assert_equal("D:test", simple.compile([:dynamic, "test"]))
+    assert_equal("B:test", simple.compile([:block, "test"]))
+  end
+  
+  def test_multi
+    simple = Simple.new(:buffer => "VAR")
+    str = simple.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)
+  end
+  
+  def test_capture
+    simple = Simple.new(:buffer => "VAR")
+    str = simple.compile([:capture, "foo", [:static, "test"]])
+    
+    assert_match(/foo = S:test/, str)
+    assert_match(/VAR\Z/, str)
+  end
+  
+  def test_capture_with_multi
+    simple = Simple.new(:buffer => "VAR")
+    str = simple.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)
+  end
+  
+  def test_newlines
+    simple = Simple.new(:buffer => "VAR")
+    str = simple.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
+    
+    {
+      "Hello"              =>   'Hello',
+      "Hello\r\nWorld"     =>   'Hello\nWorld',
+      "Hello\nWorld"       => %w|Hello World|,
+      "Hello\n\r\n\nWorld" => %w|Hello \n World|,
+      "\r\n\nHelloWorld\n" => %w|\n HelloWorld .|,
+      "\nHelloWorld\r\n"   => %w|. HelloWorld\n|,
+    }.
+    each do |actual, expected|
+      if expected.is_a?(Array)
+        expected = expected.map do |x|
+          if x == "."
+            # Use the dot so we can easily match a newline
+            # at the end or the beginning.
+            ""
+          else
+            x
+          end
+        end.join("\n") 
+      end
+      
+      expected = '"' + expected + '"'
+      assert_equal(expected, simple.to_ruby(actual))
+    end
+  end
+end