liquid 1.7.0 → 1.9.0

data/test/context_test.rb

@@ -9,6 +9,10 @@ class CentsDrop < Liquid::Drop
   def amount
     HundredCentes.new
   end
+  
+  def non_zero?
+    true
+  end
 end
 
 class ContextSensitiveDrop < Liquid::Drop
@@ -17,13 +21,32 @@ class ContextSensitiveDrop < Liquid::Drop
   end
 end
 
+class Category < Liquid::Drop
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def to_liquid
+    CategoryDrop.new(self)
+  end
+end
+
+class CategoryDrop
+  attr_accessor :category, :context
+  def initialize(category)
+    @category = category
+  end
+end
+
 
 class ContextTest < Test::Unit::TestCase
   include Liquid
 
   def setup
     @template = Liquid::Template.new
-    @context = Liquid::Context.new(@template)
+    @context = Liquid::Context.new(@template.assigns, @template.registers)
   end
 
   def test_variables
@@ -53,7 +76,7 @@ class ContextTest < Test::Unit::TestCase
     assert_equal nil, @context['nil']
     assert_equal nil, @context['nil']    
   end
-
+  
   def test_variables_not_existing
     assert_equal nil, @context['does_not_exist']
   end
@@ -89,6 +112,13 @@ class ContextTest < Test::Unit::TestCase
 
     assert_equal 1000, @context['numbers.size']
     
+  end           
+  
+  def test_hyphenated_variable
+
+    @context['oh-my'] = 'godz'
+    assert_equal 'godz', @context['oh-my']
+    
   end
   
   def test_add_filter
@@ -207,6 +237,18 @@ class ContextTest < Test::Unit::TestCase
     assert_equal 'worked', @context['test[0].test']    
   end
   
+  def test_hash_to_array_transition
+    @context['colors'] = {
+     'Blue'    => ['003366','336699', '6699CC', '99CCFF'],
+     'Green'   => ['003300','336633', '669966', '99CC99'],
+     'Yellow'  => ['CC9900','FFCC00', 'FFFF99', 'FFFFCC'],
+     'Red'     => ['660000','993333', 'CC6666', 'FF9999']
+    } 
+
+    assert_equal '003366', @context['colors.Blue[0]']
+    assert_equal 'FF9999', @context['colors.Red[3]']
+  end
+  
   def test_try_first
     @context['test'] = [1,2,3,4,5]
 
@@ -229,13 +271,31 @@ class ContextTest < Test::Unit::TestCase
     @context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'}  ]}
 
 
-    assert_equal 5, @context['products[count]']
-    assert_equal 'deepsnow', @context['products[tags][0]']
-    assert_equal 'deepsnow', @context['products[tags].first']
-    assert_equal 'draft151cm', @context['product[variants][0][title]']
-    assert_equal 'element151cm', @context['product[variants][1][title]']
-    assert_equal 'draft151cm', @context['product[variants][0][title]']
-    assert_equal 'element151cm', @context['product[variants][last][title]']
+    assert_equal 5, @context['products["count"]']
+    assert_equal 'deepsnow', @context['products["tags"][0]']
+    assert_equal 'deepsnow', @context['products["tags"].first']
+    assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
+    assert_equal 'element151cm', @context['product["variants"][1]["title"]']
+    assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
+    assert_equal 'element151cm', @context['product["variants"].last["title"]']
+  end
+  
+  def test_access_variable_with_hash_notation
+    @context['foo'] = 'baz'
+    @context['bar'] = 'foo'
+    
+    assert_equal 'baz', @context['["foo"]']
+    assert_equal 'baz', @context['[bar]']
+  end
+  
+  def test_access_hashes_with_hash_access_variables
+    
+    @context['var'] = 'tags'
+    @context['nested'] = {'var' => 'tags'}
+    @context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+
+    assert_equal 'deepsnow', @context['products[var].first']
+    assert_equal 'freestyle', @context['products[nested.var].last']
   end
   
 
@@ -267,12 +327,17 @@ class ContextTest < Test::Unit::TestCase
     @context.merge( "cents" => CentsDrop.new )
     assert_equal 100, @context['cents.amount']     
   end
-
+  
   def test_nested_cents_through_drop
     @context.merge( "vars" => {"cents" => CentsDrop.new} )
     assert_equal 100, @context['vars.cents.amount']     
   end
   
+  def test_drop_methods_with_question_marks
+    @context.merge( "cents" => CentsDrop.new )
+    assert @context['cents.non_zero?']     
+  end
+
   def test_context_from_within_drop
     @context.merge( "test" => '123', "vars" => ContextSensitiveDrop.new )
     assert_equal '123', @context['vars.test']     
@@ -282,6 +347,13 @@ class ContextTest < Test::Unit::TestCase
     @context.merge( "test" => '123', "vars" => {"local" => ContextSensitiveDrop.new }  )
     assert_equal '123', @context['vars.local.test']     
   end
+  
+  def test_ranges
+    @context.merge( "test" => '5' )
+    assert_equal (1..5), @context['(1..5)']
+    assert_equal (1..5), @context['(1..test)']
+    assert_equal (5..5), @context['(test..test)']
+  end
 
   def test_cents_through_drop_nestedly
     @context.merge( "cents" => {"cents" => CentsDrop.new} )
@@ -337,4 +409,10 @@ class ContextTest < Test::Unit::TestCase
     assert_equal 345392, @context['magic']    
   end
   
+  def test_to_liquid_and_context_at_first_level
+    @context['category'] = Category.new("foobar")
+    assert_kind_of CategoryDrop, @context['category']
+    assert_equal @context, @context['category'].context
+  end
+
 end

data/test/drop_test.rb

@@ -120,8 +120,10 @@ class DropsTest < Test::Unit::TestCase
   def test_scope_with_assigns
     assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}'  ).render('context' => ContextDrop.new)    
     assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])    
+    assert_equal 'test', Liquid::Template.parse( '{% assign header_gif = "test"%}{{header_gif}}'  ).render('context' => ContextDrop.new)    
+    assert_equal 'test', Liquid::Template.parse( "{% assign header_gif = 'test'%}{{header_gif}}"  ).render('context' => ContextDrop.new)    
   end
-  
+    
   def test_scope_from_tags
     assert_equal '1', Liquid::Template.parse( '{% for i in context.scopes_as_array %}{{i}}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])    
     assert_equal '12', Liquid::Template.parse( '{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])    

data/test/error_handling_test.rb

@@ -4,15 +4,15 @@ require File.dirname(__FILE__) + '/helper'
 
 class ErrorDrop < Liquid::Drop
   def standard_error
-    raise StandardError, 'standard error'
+    raise Liquid::StandardError, 'standard error'
   end  
 
   def argument_error
-    raise ArgumentError, 'argument error'
+    raise Liquid::ArgumentError, 'argument error'
   end  
   
   def syntax_error
-    raise SyntaxError, 'syntax error'
+    raise Liquid::SyntaxError, 'syntax error'
   end  
   
 end
@@ -59,6 +59,19 @@ class ErrorHandlingTest < Test::Unit::TestCase
     
   end
   
+  def test_unrecognized_operator
+    
+    assert_nothing_raised do
+      
+      template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
+      assert_equal ' Liquid error: Unknown operator =! ', template.render
+      
+      assert_equal 1, template.errors.size
+      assert_equal Liquid::ArgumentError, template.errors.first.class
+      
+    end
+    
+  end
   
 end
 

data/test/filter_test.rb

@@ -23,7 +23,7 @@ class FiltersTest < Test::Unit::TestCase
   include Liquid
   
   def setup
-    @context = Context.new(Liquid::Template.new)
+    @context = Context.new
   end
     
   def test_local_filter    
@@ -44,9 +44,9 @@ class FiltersTest < Test::Unit::TestCase
     @context.add_filters(CanadianMoneyFilter)  
     assert_equal ' 1000$ CAD ', Variable.new("var | money").render(@context)    
   end
-
+  
   def test_size
-    @context['var'] = 1000
+    @context['var'] = 'abcd'
     @context.add_filters(MoneyFilter)
     assert_equal 4, Variable.new("var | size").render(@context)
   end

data/test/html_tag_test.rb

@@ -21,4 +21,11 @@ class HtmlTagTest < Test::Unit::TestCase
     
   end
   
+  def test_html_col_counter
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row2\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row3\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n",
+                           '{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}', 
+                           'numbers' => [1,2,3,4,5,6])
+    
+  end
+  
 end

data/test/if_else_test.rb

@@ -18,8 +18,31 @@ class IfElseTest < Test::Unit::TestCase
   
   def test_if_boolean
     assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)    
+  end        
+  
+  def test_if_or
+    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)    
+    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)    
+    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)    
+    assert_template_result('',     '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => false)        
+
+    assert_template_result(' YES ','{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)    
+    assert_template_result('',     '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => false)        
+  end
+  
+  def test_if_or_with_operators
+    assert_template_result(' YES ','{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)    
+    assert_template_result(' YES ','{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)    
+    assert_template_result('','{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)    
+  end     
+  
+  def test_if_and
+    assert_template_result(' YES ','{% if true and true %} YES {% endif %}')    
+    assert_template_result('','{% if false and true %} YES {% endif %}')    
+    assert_template_result('','{% if false and true %} YES {% endif %}')    
   end
   
+  
   def test_hash_miss_generates_false
     assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {})
   end
@@ -92,4 +115,13 @@ class IfElseTest < Test::Unit::TestCase
   def test_syntax_error_no_variable
     assert_raise(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}')}
   end
+  
+  def test_if_with_custom_condition
+    Condition.operators['contains'] = :[]
+    
+    assert_template_result('yes', %({% if 'bob' contains 'o' %}yes{% endif %}))
+    assert_template_result('no', %({% if 'bob' contains 'f' %}yes{% else %}no{% endif %}))
+  ensure
+    Condition.operators.delete 'contains'
+  end
 end

data/test/include_tag_test.rb

@@ -20,6 +20,9 @@ class TestFileSystem
       
     when "nested_product_template"
       "Product: {{ nested_product_template.title }} {%include 'details'%} "
+
+    when "recursively_nested_template"
+      "-{% include 'recursively_nested_template' %}"
       
     else
       template_path
@@ -40,6 +43,11 @@ class IncludeTagTest < Test::Unit::TestCase
                  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 ", 
@@ -78,7 +86,22 @@ class IncludeTagTest < Test::Unit::TestCase
                  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                   
+    
+    Liquid::Template.file_system = infinite_file_system.new
+    
+    assert_match /-{552}Liquid error: stack level too deep$/, 
+      Template.parse("{% include 'loop' %}").render                 
+    
+  end
+            
   def test_dynamically_choosen_template
 
     assert_equal "Test123", Template.parse("{% include template %}").render("template" => 'Test123')

data/test/module_ex_test.rb

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

data/test/parsing_quirks_test.rb

@@ -11,4 +11,19 @@ class ParsingQuirksTest < Test::Unit::TestCase
     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_error_on_empty_filter
+    assert_nothing_raised do
+      Template.parse("{{test |a|b|}}")      
+      Template.parse("{{test}}")      
+      Template.parse("{{|test|}}")      
+    end
+  end
 end