liquor 0.1.1 → 0.9.1

data/test/include_tag_test.rb

@@ -1,129 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestFileSystem 
-  def read_template_file(template_path)
-    case template_path
-    when "product"
-      "Product: {{ product.title }} "
-
-    when "locale_variables"
-      "Locale: {{echo1}} {{echo2}}"
-
-    when "variant"
-      "Variant: {{ variant.title }}"
-      
-    when "nested_template"
-      "{% include 'header' %} {% include 'body' %} {% include 'footer' %}"
-      
-    when "body"
-      "body {% include 'body_detail' %}"
-      
-    when "nested_product_template"
-      "Product: {{ nested_product_template.title }} {%include 'details'%} "
-
-    when "recursively_nested_template"
-      "-{% include 'recursively_nested_template' %}"
-
-    when "pick_a_source"
-      "from TestFileSystem"
-      
-    else
-      template_path
-    end
-  end
-end
-
-class OtherFileSystem
-  def read_template_file(template_path)
-    'from OtherFileSystem'
-  end
-end
-
-class IncludeTagTest < Test::Unit::TestCase
-  include Liquor
-  
-  def setup
-    Liquor::Template.file_system = TestFileSystem.new    
-  end
-  
-  def test_include_tag_looks_for_file_system_in_registers_first
-    assert_equal 'from OtherFileSystem',
-                 Template.parse("{% include 'pick_a_source' %}").render({}, :registers => {:file_system => OtherFileSystem.new})
-  end
-  
-
-  def test_include_tag_with    
-    assert_equal "Product: Draft 151cm ", 
-                 Template.parse("{% include 'product' with products[0] %}").render( "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]  )
-  end
-
-  def test_include_tag_with_default_name    
-    assert_equal "Product: Draft 151cm ", 
-                 Template.parse("{% include 'product' %}").render( "product" => {'title' => 'Draft 151cm'}  )
-  end
-
-  def test_include_tag_for
-    
-    assert_equal "Product: Draft 151cm Product: Element 155cm ", 
-                 Template.parse("{% include 'product' for products %}").render( "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]  )
-  end
-
-  def test_include_tag_with_local_variables    
-    assert_equal "Locale: test123 ", 
-                 Template.parse("{% include 'locale_variables' echo1: 'test123' %}").render
-  end
-
-  def test_include_tag_with_multiple_local_variables    
-    assert_equal "Locale: test123 test321", 
-                 Template.parse("{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}").render
-  end
-
-  def test_include_tag_with_multiple_local_variables_from_context    
-    assert_equal "Locale: test123 test321", 
-                 Template.parse("{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}").render('echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'})
-  end
-
-  def test_nested_include_tag
-    assert_equal "body body_detail", 
-                 Template.parse("{% include 'body' %}").render
-
-    assert_equal "header body body_detail footer", 
-                 Template.parse("{% include 'nested_template' %}").render
-  end
-  
-  def test_nested_include_with_variable
-
-    assert_equal "Product: Draft 151cm details ", 
-                 Template.parse("{% include 'nested_product_template' with product %}").render("product" => {"title" => 'Draft 151cm'})
-
-    assert_equal "Product: Draft 151cm details Product: Element 155cm details ", 
-                 Template.parse("{% include 'nested_product_template' for products %}").render("products" => [{"title" => 'Draft 151cm'}, {"title" => 'Element 155cm'}])
-    
-  end
-  
-  def test_recursively_included_template_does_not_produce_endless_loop
-        
-    infinite_file_system = Class.new do  
-      def read_template_file(template_path)
-        "-{% include 'loop' %}"
-      end
-    end                   
-    
-    Liquor::Template.file_system = infinite_file_system.new
-                   
-    assert_raise(Liquor::StackLevelError) do
-      Template.parse("{% include 'loop' %}").render!
-    end
-    
-  end
-            
-  def test_dynamically_choosen_template
-
-    assert_equal "Test123", Template.parse("{% include template %}").render("template" => 'Test123')
-    assert_equal "Test321", Template.parse("{% include template %}").render("template" => 'Test321')
-
-    assert_equal "Product: Draft 151cm ", Template.parse("{% include template for product %}").render("template" => 'product', 'product' => { 'title' => 'Draft 151cm'})
-    
-  end
-  
-end

data/test/module_ex_test.rb

@@ -1,89 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
-
-class TestClassA
-  liquor_methods :allowedA, :chainedB
-  def allowedA
-    'allowedA'
-  end
-  def restrictedA
-    'restrictedA'
-  end
-  def chainedB
-    TestClassB.new
-  end
-end
-
-class TestClassB
-  liquor_methods :allowedB, :chainedC
-  def allowedB
-    'allowedB'
-  end
-  def chainedC
-    TestClassC.new
-  end
-end
-
-class TestClassC
-  liquor_methods :allowedC
-  def allowedC
-    'allowedC'
-  end
-end
-
-class TestClassC::LiquorDropClass
-  def another_allowedC
-    'another_allowedC'
-  end
-end
-
-class ModuleExTest < Test::Unit::TestCase
-  include Liquor
-  
-  def setup
-    @a = TestClassA.new
-    @b = TestClassB.new
-    @c = TestClassC.new
-  end
-  
-  def test_should_create_LiquorDropClass
-    assert TestClassA::LiquorDropClass
-    assert TestClassB::LiquorDropClass
-    assert TestClassC::LiquorDropClass
-  end
-  
-  def test_should_respond_to_liquor
-    assert @a.respond_to?(:to_liquor)
-    assert @b.respond_to?(:to_liquor)
-    assert @c.respond_to?(:to_liquor)
-  end
-  
-  def test_should_return_LiquorDropClass_object
-    assert @a.to_liquor.is_a?(TestClassA::LiquorDropClass)
-    assert @b.to_liquor.is_a?(TestClassB::LiquorDropClass)
-    assert @c.to_liquor.is_a?(TestClassC::LiquorDropClass)
-  end
-  
-  def test_should_respond_to_liquor_methods
-    assert @a.to_liquor.respond_to?(:allowedA)
-    assert @a.to_liquor.respond_to?(:chainedB)
-    assert @b.to_liquor.respond_to?(:allowedB)
-    assert @b.to_liquor.respond_to?(:chainedC)
-    assert @c.to_liquor.respond_to?(:allowedC)
-    assert @c.to_liquor.respond_to?(:another_allowedC)
-  end
-
-  def test_should_not_respond_to_restricted_methods
-    assert ! @a.to_liquor.respond_to?(:restricted)
-  end
-
-  def test_should_use_regular_objects_as_drops
-    assert_equal 'allowedA', Liquor::Template.parse("{{ a.allowedA }}").render('a'=>@a)
-    assert_equal 'allowedB', Liquor::Template.parse("{{ a.chainedB.allowedB }}").render('a'=>@a)
-    assert_equal 'allowedC', Liquor::Template.parse("{{ a.chainedB.chainedC.allowedC }}").render('a'=>@a)
-    assert_equal 'another_allowedC', Liquor::Template.parse("{{ a.chainedB.chainedC.another_allowedC }}").render('a'=>@a)
-    assert_equal '', Liquor::Template.parse("{{ a.restricted }}").render('a'=>@a)
-    assert_equal '', Liquor::Template.parse("{{ a.unknown }}").render('a'=>@a)
- end
-
-end

data/test/output_test.rb

@@ -1,121 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
-
-module FunnyFilter
-  
-  def make_funny(input)
-    'LOL'             
-  end
-
-  def cite_funny(input)
-    "LOL: #{input}"
-  end             
-
-  def add_smiley(input, smiley = ":-)")
-    "#{input} #{smiley}"
-  end
-  
-  def add_tag(input, tag = "p", id = "foo")
-    %|<#{tag} id="#{id}">#{input}</#{tag}>|
-  end
-
-  def paragraph(input)
-    "<p>#{input}</p>"
-  end
-  
-  def link_to(name, url)
-    %|<a href="#{url}">#{name}</a>|
-  end
-end                 
-
-
-class OutputTest < Test::Unit::TestCase
-  include Liquor
-
-  def setup
-    @assigns = {     
-      'best_cars' => 'bmw',
-      'car' => {'bmw' => 'good', 'gm' => 'bad'}
-      }
-
-  end
-
-  def test_variable  
-    text = %| {{best_cars}} |
-
-    expected = %| bmw |
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end
-
-  def test_variable_traversing
-    text = %| {{car.bmw}} {{car.gm}} {{car.bmw}} |
-
-    expected = %| good bad good |
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end               
-  
-  def test_variable_piping
-    text = %( {{ car.gm | make_funny }} )
-    expected = %| LOL |               
-    
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_variable_piping_with_input
-    text = %( {{ car.gm | cite_funny }} )
-    expected = %| LOL: bad |               
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-  
-  def test_variable_piping_with_args
-    text = %! {{ car.gm | add_smiley : ':-(' }} !
-    expected = %| bad :-( |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-  
-  def test_variable_piping_with_no_args
-    text = %! {{ car.gm | add_smiley }} !
-    expected = %| bad :-) |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-  
-  def test_multiple_variable_piping_with_args
-    text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
-    expected = %| bad :-( :-( |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_variable_piping_with_args
-    text = %! {{ car.gm | add_tag : 'span', 'bar'}} !
-    expected = %| <span id="bar">bad</span> |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_variable_piping_with_variable_args
-    text = %! {{ car.gm | add_tag : 'span', car.bmw}} !
-    expected = %| <span id="good">bad</span> |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_multiple_pipings
-    text = %( {{ best_cars | cite_funny | paragraph }} )
-    expected = %| <p>LOL: bmw</p> |               
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-  
-  def test_link_to
-    text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
-    expected = %| <a href="http://typo.leetsoft.com">Typo</a> |               
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])    
-  end
-  
-
-end 

data/test/parsing_quirks_test.rb

@@ -1,54 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
-
-class ParsingQuirksTest < Test::Unit::TestCase
-  include Liquor
-
-  def test_error_with_css
-    text = %| div { font-weight: bold; } |
-    template = Template.parse(text)
-                                                    
-    assert_equal text, template.render
-    assert_equal [String], template.root.nodelist.collect {|i| i.class}
-  end
-  
-  def test_raise_on_single_close_bracet
-    assert_raise(SyntaxError) do
-      Template.parse("text {{method} oh nos!")      
-    end
-  end
-  
-  def test_raise_on_label_and_no_close_bracets
-    assert_raise(SyntaxError) do
-      Template.parse("TEST {{ ")
-    end
-  end    
-  
-  def test_raise_on_label_and_no_close_bracets_percent
-    assert_raise(SyntaxError) do
-      Template.parse("TEST {% ")
-    end
-  end
-  
-  def test_error_on_empty_filter
-    assert_nothing_raised do
-      Template.parse("{{test |a|b|}}")      
-      Template.parse("{{test}}")      
-      Template.parse("{{|test|}}")      
-    end
-  end
-  
-  def test_meaningless_parens
-    assigns = {'b' => 'bar', 'c' => 'baz'}
-    markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-    assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}", assigns)
-  end
-  
-  def test_unexpected_characters_silently_eat_logic
-    markup = "true && false"
-    assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}")
-    markup = "false || true"
-    assert_template_result('',"{% if #{markup} %} YES {% endif %}")
-  end
-  
-end

data/test/regexp_test.rb

@@ -1,45 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-   
-class RegexpTest < Test::Unit::TestCase
-  include Liquor
-
-  def test_empty
-    assert_equal [], ''.scan(QuotedFragment)
-  end
-  
-  def test_quote
-    assert_equal ['"arg 1"'], '"arg 1"'.scan(QuotedFragment)
-  end
-  
-  def test_words
-    assert_equal ['arg1', 'arg2'], 'arg1 arg2'.scan(QuotedFragment)
-  end
-  
-  def test_tags
-    assert_equal ['<tr>', '</tr>'], '<tr> </tr>'.scan(QuotedFragment)
-    assert_equal ['<tr></tr>'], '<tr></tr>'.scan(QuotedFragment)
-    assert_equal ['<style', 'class="hello">', '</style>'], %|<style class="hello">' </style>|.scan(QuotedFragment)
-  end
-
-  def test_quoted_words
-    assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment)
-  end
-
-  def test_quoted_words
-    assert_equal ['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment)
-  end
-
-  def test_quoted_words_in_the_middle
-    assert_equal ['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4   '.scan(QuotedFragment)
-  end
-  
-  def test_variable_parser
-    assert_equal ['var'],                 'var'.scan(VariableParser)
-    assert_equal ['var', 'method'],       'var.method'.scan(VariableParser)
-    assert_equal ['var', '[method]'],       'var[method]'.scan(VariableParser)
-    assert_equal ['var', '[method]', '[0]'],  'var[method][0]'.scan(VariableParser)
-    assert_equal ['var', '["method"]', '[0]'],  'var["method"][0]'.scan(VariableParser)
-    assert_equal ['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VariableParser)    
-  end
- 
-end

data/test/security_test.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-module SecurityFilter
-  def add_one(input)
-    "#{input} + 1"
-  end
-end
-
-class SecurityTest < Test::Unit::TestCase
-  include Liquor
-
-  def test_no_instance_eval
-    text = %( {{ '1+1' | instance_eval }} )
-    expected = %| 1+1 |
-        
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end
-  
-  def test_no_existing_instance_eval
-    text = %( {{ '1+1' | __instance_eval__ }} )
-    expected = %| 1+1 |
-        
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end
-  
-
-  def test_no_instance_eval_after_mixing_in_new_filter
-    text = %( {{ '1+1' | instance_eval }} )
-    expected = %| 1+1 |
-  
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end
-
-
-  def test_no_instance_eval_later_in_chain
-    text = %( {{ '1+1' | add_one | instance_eval }} )
-    expected = %| 1+1 + 1 |
-  
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => SecurityFilter)
-  end
-end