liquor 0.1.0

data/test/statements_test.rb

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/helper'
+
+class StatementsTest < Test::Unit::TestCase
+  include Liquor
+
+
+  def test_true_eql_true
+    text = %| {% if true == true %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
+  end
+
+  def test_true_not_eql_true
+    text = %| {% if true != true %} true {% else %} false {% endif %} |
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
+  end
+
+  def test_true_lq_true
+    text = %| {% if 0 > 0 %} true {% else %} false {% endif %} |
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
+  end
+
+  def test_one_lq_zero
+    text = %| {% if 1 > 0 %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
+  end
+
+  def test_zero_lq_one
+    text = %| {% if 0 < 1 %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
+  end
+
+  def test_zero_lq_or_equal_one
+    text = %| {% if 0 <= 0 %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
+  end
+
+  def test_zero_lq_or_equal_one_involving_nil
+    text = %| {% if null <= 0 %} true {% else %} false {% endif %} |
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
+
+
+    text = %| {% if 0 <= null %} true {% else %} false {% endif %} |
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
+  end
+
+  def test_zero_lqq_or_equal_one
+    text = %| {% if 0 >= 0 %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
+  end
+
+  def test_strings
+    text = %| {% if 'test' == 'test' %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
+  end
+
+  def test_strings_not_equal
+    text = %| {% if 'test' != 'test' %} true {% else %} false {% endif %} |
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
+  end
+  
+  def test_var_strings_equal
+    text = %| {% if var == "hello there!" %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => 'hello there!')
+  end
+  
+  def test_var_strings_are_not_equal
+    text = %| {% if "hello there!" == var %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => 'hello there!')
+  end
+  
+  def test_var_and_long_string_are_equal
+    text = %| {% if var == 'hello there!' %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => 'hello there!')
+  end
+  
+
+  def test_var_and_long_string_are_equal_backwards
+    text = %| {% if 'hello there!' == var %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => 'hello there!')
+  end
+  
+  #def test_is_nil    
+  #  text = %| {% if var != nil %} true {% else %} false {% end %} |
+  #  @template.assigns = { 'var' => 'hello there!'}
+  #  expected = %|  true  |
+  #  assert_equal expected, @template.parse(text)
+  #end
+    
+  def test_is_collection_empty    
+    text = %| {% if array == empty %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('array' => [])
+  end
+
+  def test_is_not_collection_empty    
+    text = %| {% if array == empty %} true {% else %} false {% endif %} |
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render('array' => [1,2,3])
+  end
+
+  def test_nil
+    text = %| {% if var == nil %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => nil)
+
+    text = %| {% if var == null %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => nil)
+  end
+
+  def test_not_nil
+    text = %| {% if var != nil %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => 1 )
+
+    text = %| {% if var != null %} true {% else %} false {% endif %} |
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => 1 )
+  end
+
+end

data/test/strainer_test.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/helper'
+
+class StrainerTest < Test::Unit::TestCase
+  include Liquor
+
+  def test_strainer
+    strainer = Strainer.create(nil)
+    assert_equal false, strainer.respond_to?('__test__')
+    assert_equal false, strainer.respond_to?('test')
+    assert_equal false, strainer.respond_to?('instance_eval')
+    assert_equal false, strainer.respond_to?('__send__')
+    assert_equal true, strainer.respond_to?('size') # from the standard lib
+  end
+  
+  def test_should_respond_to_two_parameters
+    strainer = Strainer.create(nil)
+    assert_equal true, strainer.respond_to?('size', false)
+  end
+  
+  # Asserts that Object#respond_to_missing? is not being undefined in Ruby versions where it has been implemented
+  # Currently this method is only present in Ruby v1.9.2, or higher
+  def test_object_respond_to_missing	
+    assert_equal Object.respond_to?(:respond_to_missing?), Strainer.create(nil).respond_to?(:respond_to_missing?)	
+  end
+  
+end

data/test/template_test.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TemplateTest < Test::Unit::TestCase
+  include Liquor
+  
+  def test_tokenize_strings
+    assert_equal [' '], Template.new.send(:tokenize, ' ')
+    assert_equal ['hello world'], Template.new.send(:tokenize, 'hello world')
+  end                         
+  
+  def test_tokenize_variables
+    assert_equal ['{{funk}}'], Template.new.send(:tokenize, '{{funk}}')
+    assert_equal [' ', '{{funk}}', ' '], Template.new.send(:tokenize, ' {{funk}} ')
+    assert_equal [' ', '{{funk}}', ' ', '{{so}}', ' ', '{{brother}}', ' '], Template.new.send(:tokenize, ' {{funk}} {{so}} {{brother}} ')
+    assert_equal [' ', '{{  funk  }}', ' '], Template.new.send(:tokenize, ' {{  funk  }} ')
+  end                             
+  
+  def test_tokenize_blocks    
+    assert_equal ['{%comment%}'], Template.new.send(:tokenize, '{%comment%}')
+    assert_equal [' ', '{%comment%}', ' '], Template.new.send(:tokenize, ' {%comment%} ')
+    
+    assert_equal [' ', '{%comment%}', ' ', '{%endcomment%}', ' '], Template.new.send(:tokenize, ' {%comment%} {%endcomment%} ')
+    assert_equal ['  ', '{% comment %}', ' ', '{% endcomment %}', ' '], Template.new.send(:tokenize, "  {% comment %} {% endcomment %} ")    
+  end                                                          
+  
+  def test_instance_assigns_persist_on_same_template_object_between_parses
+    t = Template.new
+    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
+    assert_equal 'from instance assigns', t.parse("{{ foo }}").render
+  end
+  
+  def test_instance_assigns_persist_on_same_template_parsing_between_renders
+    t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
+    assert_equal 'foo', t.render
+    assert_equal 'foofoo', t.render
+  end
+  
+  def test_custom_assigns_do_not_persist_on_same_template
+    t = Template.new
+    assert_equal 'from custom assigns', t.parse("{{ foo }}").render('foo' => 'from custom assigns')
+    assert_equal '', t.parse("{{ foo }}").render
+  end
+  
+  def test_custom_assigns_squash_instance_assigns
+    t = Template.new
+    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
+    assert_equal 'from custom assigns', t.parse("{{ foo }}").render('foo' => 'from custom assigns')
+  end
+  
+  def test_persistent_assigns_squash_instance_assigns
+    t = Template.new
+    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
+    t.assigns['foo'] = 'from persistent assigns'
+    assert_equal 'from persistent assigns', t.parse("{{ foo }}").render
+  end
+
+  def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
+    t = Template.new
+    t.assigns['number'] = lambda { @global ||= 0; @global += 1 }
+    assert_equal '1', t.parse("{{number}}").render
+    assert_equal '1', t.parse("{{number}}").render
+    assert_equal '1', t.render
+    @global = nil
+  end
+
+  def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
+    t = Template.new
+    assigns = {'number' => lambda { @global ||= 0; @global += 1 }}
+    assert_equal '1', t.parse("{{number}}").render(assigns)
+    assert_equal '1', t.parse("{{number}}").render(assigns)
+    assert_equal '1', t.render(assigns)
+    @global = nil
+  end
+  
+  def test_raise_exception_when_layout_is_not_a_template_object
+    layout_template = '<title>{% yield title %}</title> <body>{% yield %}</body>'
+    view_template = '{% content_for title %}{% assign text="aaa" %}{{ text }}{% end_content_for %}{% assign text="body" %}{{ text }}'
+        
+    assert_raise (ArgumentError) { Template.parse(view_template).render({ :layout => layout_template }) }
+  end  
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.dirname(__FILE__)+ '/extra')
+
+require 'test/unit'
+require 'test/unit/assertions'
+require 'caller'
+require 'breakpoint'
+require 'active_record'
+require 'action_controller'
+require File.dirname(__FILE__) + '/../lib/liquid'
+
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :database => ":memory:"
+)
+
+
+module Test
+  module Unit
+    module Assertions
+        include Liquor
+        def assert_template_result(expected, template, assigns={}, message=nil)
+          assert_equal expected, Template.parse(template).render(assigns)
+        end 
+    end
+  end
+end

data/test/unless_else_test.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/helper'
+
+class UnlessElseTest < Test::Unit::TestCase
+  include Liquor
+
+  def test_unless
+    assert_template_result('  ',' {% unless true %} this text should not go into the output {% endunless %} ')
+    assert_template_result('  this text should go into the output  ',
+              ' {% unless false %} this text should go into the output {% endunless %} ')
+    assert_template_result('  you rock ?','{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
+  end
+
+  def test_unless_else
+    assert_template_result(' YES ','{% unless true %} NO {% else %} YES {% endunless %}')
+    assert_template_result(' YES ','{% unless false %} YES {% else %} NO {% endunless %}')
+    assert_template_result(' YES ','{% unless "foo" %} NO {% else %} YES {% endunless %}')
+  end
+
+  def test_unless_in_loop
+    assert_template_result '23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', 'choices' => [1, nil, false]
+  end
+
+  def test_unless_else_in_loop
+    assert_template_result ' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false]
+  end
+
+end

data/test/variable_test.rb

@@ -0,0 +1,173 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/helper'
+
+class VariableTest < Test::Unit::TestCase
+  include Liquor
+
+  def test_variable
+    var = Variable.new('hello')
+    assert_equal 'hello', var.name
+  end
+
+  def test_filters
+    var = Variable.new('hello | textileze')
+    assert_equal 'hello', var.name
+    assert_equal [[:textileze,[]]], var.filters
+
+    var = Variable.new('hello | textileze | paragraph')
+    assert_equal 'hello', var.name
+    assert_equal [[:textileze,[]], [:paragraph,[]]], var.filters
+
+    var = Variable.new(%! hello | strftime: '%Y'!)
+    assert_equal 'hello', var.name
+    assert_equal [[:strftime,["'%Y'"]]], var.filters
+
+    var = Variable.new(%! 'typo' | link_to: 'Typo', true !)
+    assert_equal %!'typo'!, var.name
+    assert_equal [[:link_to,["'Typo'", "true"]]], var.filters
+
+    var = Variable.new(%! 'typo' | link_to: 'Typo', false !)
+    assert_equal %!'typo'!, var.name
+    assert_equal [[:link_to,["'Typo'", "false"]]], var.filters
+
+    var = Variable.new(%! 'foo' | repeat: 3 !)
+    assert_equal %!'foo'!, var.name
+    assert_equal [[:repeat,["3"]]], var.filters
+
+    var = Variable.new(%! 'foo' | repeat: 3, 3 !)
+    assert_equal %!'foo'!, var.name
+    assert_equal [[:repeat,["3","3"]]], var.filters
+
+    var = Variable.new(%! 'foo' | repeat: 3, 3, 3 !)
+    assert_equal %!'foo'!, var.name
+    assert_equal [[:repeat,["3","3","3"]]], var.filters
+
+    var = Variable.new(%! hello | strftime: '%Y, okay?'!)
+    assert_equal 'hello', var.name
+    assert_equal [[:strftime,["'%Y, okay?'"]]], var.filters
+
+    var = Variable.new(%! hello | things: "%Y, okay?", 'the other one'!)
+    assert_equal 'hello', var.name
+    assert_equal [[:things,["\"%Y, okay?\"","'the other one'"]]], var.filters
+  end
+
+  def test_filter_with_date_parameter
+
+    var = Variable.new(%! '2006-06-06' | date: "%m/%d/%Y"!)
+    assert_equal "'2006-06-06'", var.name
+    assert_equal [[:date,["\"%m/%d/%Y\""]]], var.filters
+
+  end
+
+  def test_filters_without_whitespace
+    var = Variable.new('hello | textileze | paragraph')
+    assert_equal 'hello', var.name
+    assert_equal [[:textileze,[]], [:paragraph,[]]], var.filters
+
+    var = Variable.new('hello|textileze|paragraph')
+    assert_equal 'hello', var.name
+    assert_equal [[:textileze,[]], [:paragraph,[]]], var.filters
+  end
+
+  def test_symbol
+    var = Variable.new("http://disney.com/logo.gif | image: 'med' ")
+    assert_equal 'http://disney.com/logo.gif', var.name
+    assert_equal [[:image,["'med'"]]], var.filters
+  end
+
+  def test_string_single_quoted
+    var = Variable.new(%| "hello" |)
+    assert_equal '"hello"', var.name
+  end
+
+  def test_string_double_quoted
+    var = Variable.new(%| 'hello' |)
+    assert_equal "'hello'", var.name
+  end
+
+  def test_integer
+    var = Variable.new(%| 1000 |)
+    assert_equal "1000", var.name
+  end
+
+  def test_float
+    var = Variable.new(%| 1000.01 |)
+    assert_equal "1000.01", var.name
+  end
+
+  def test_string_with_special_chars
+    var = Variable.new(%| 'hello! $!@.;"ddasd" ' |)
+    assert_equal %|'hello! $!@.;"ddasd" '|, var.name
+  end
+
+  def test_string_dot
+    var = Variable.new(%| test.test |)
+    assert_equal 'test.test', var.name
+  end
+end
+
+
+class VariableResolutionTest < Test::Unit::TestCase
+  include Liquor
+
+  def test_simple_variable
+    template = Template.parse(%|{{test}}|)
+    assert_equal 'worked', template.render('test' => 'worked')
+    assert_equal 'worked wonderfully', template.render('test' => 'worked wonderfully')
+  end
+
+  def test_simple_with_whitespaces
+    template = Template.parse(%|  {{ test }}  |)
+    assert_equal '  worked  ', template.render('test' => 'worked')
+    assert_equal '  worked wonderfully  ', template.render('test' => 'worked wonderfully')
+  end
+
+  def test_ignore_unknown
+    template = Template.parse(%|{{ test }}|)
+    assert_equal '', template.render
+  end
+
+  def test_hash_scoping
+    template = Template.parse(%|{{ test.test }}|)
+    assert_equal 'worked', template.render('test' => {'test' => 'worked'})
+  end
+  
+  def test_preset_assigns
+    template = Template.parse(%|{{ test }}|)
+    template.assigns['test'] = 'worked'
+    assert_equal 'worked', template.render
+  end
+
+  def test_reuse_parsed_template
+    template = Template.parse(%|{{ greeting }} {{ name }}|)
+    template.assigns['greeting'] = 'Goodbye'
+    assert_equal 'Hello Tobi', template.render('greeting' => 'Hello', 'name' => 'Tobi')
+    assert_equal 'Hello ', template.render('greeting' => 'Hello', 'unknown' => 'Tobi')
+    assert_equal 'Hello Brian', template.render('greeting' => 'Hello', 'name' => 'Brian')
+    assert_equal 'Goodbye Brian', template.render('name' => 'Brian')
+    assert_equal({'greeting'=>'Goodbye'}, template.assigns)
+  end
+
+  def test_assigns_not_polluted_from_template
+    template = Template.parse(%|{{ test }}{% assign test = 'bar' %}{{ test }}|)
+    template.assigns['test'] = 'baz'
+    assert_equal 'bazbar', template.render
+    assert_equal 'bazbar', template.render
+    assert_equal 'foobar', template.render('test' => 'foo')
+    assert_equal 'bazbar', template.render
+  end
+
+  def test_hash_with_default_proc
+    template = Template.parse(%|Hello {{ test }}|)
+    assigns = Hash.new { |h,k| raise "Unknown variable '#{k}'" }
+    assigns['test'] = 'Tobi'
+    assert_equal 'Hello Tobi', template.render!(assigns, {})
+    
+    assigns = Hash.new { |h,k| raise "Unknown variable '#{k}'" }
+    e = assert_raises(RuntimeError) {
+      template.render!(assigns, {})
+    }
+    assert_equal "Unknown variable 'test'", e.message
+  end
+
+end