liquid 1.7.0 → 1.9.0

data/lib/liquid/tags/cycle.rb

@@ -1,9 +1,22 @@
 module Liquid
+  
+  # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
+  #
+  #   {% for item in items %}
+  #     <div class="{% cycle 'red', 'green', 'blue' %}"> {{ item }} </div>
+  #   {% end %}
+  #
+  #    <div class="red"> Item one </div>
+  #    <div class="green"> Item two </div>
+  #    <div class="blue"> Item three </div>
+  #    <div class="red"> Item four </div>
+  #    <div class="green"> Item five</div>
+  #
   class Cycle < Tag
     SimpleSyntax = /#{QuotedFragment}/        
     NamedSyntax = /(#{QuotedFragment})\s*\:\s*(.*)/
   
-    def initialize(markup, tokens)
+    def initialize(tag_name, markup, tokens)      
       case markup
       when NamedSyntax
       	@variables = variables_from_string($2)
@@ -14,7 +27,8 @@ module Liquid
       else
         raise SyntaxError.new("Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]")
       end
-    
+
+      super    
     end    
   
     def render(context)

data/lib/liquid/tags/for.rb

@@ -1,10 +1,48 @@
 module Liquid
+
+  # "For" iterates over an array or collection. 
+  # Several useful variables are available to you within the loop.
+  #
+  # == Basic usage:
+  #    {% for item in collection %}
+  #      {{ forloop.index }}: {{ item.name }}
+  #    {% endfor %}
+  #
+  # == Advanced usage:
+  #    {% for item in collection %}
+  #      <div {% if forloop.first %}class="first"{% endif %}>
+  #        Item {{ forloop.index }}: {{ item.name }}
+  #      </div>
+  #    {% endfor %}
+  #
+  # You can also define a limit and offset much like SQL.  Remember
+  # that offset starts at 0 for the first item.
+  #
+  #    {% for item in collection limit:5 offset:10 %}
+  #      {{ item.name }}
+  #    {% end %}
+  #
+  # == Available variables:
+  #
+  # forloop.name:: 'item-collection'
+  # forloop.length:: Length of the loop
+  # forloop.index:: The current item's position in the collection;
+  #                 forloop.index starts at 1. 
+  #                 This is helpful for non-programmers who start believe
+  #                 the first item in an array is 1, not 0.
+  # forloop.index0:: The current item's position in the collection
+  #                  where the first item is 0
+  # forloop.rindex:: Number of items remaining in the loop
+  #                  (length - index) where 1 is the last item.
+  # forloop.rindex0:: Number of items remaining in the loop
+  #                   where 0 is the last item.
+  # forloop.first:: Returns true if the item is the first item.
+  # forloop.last:: Returns true if the item is the last item.
+  #
   class For < Block                                             
     Syntax = /(\w+)\s+in\s+(#{VariableSignature}+)/   
   
-    def initialize(markup, tokens)
-      super
-
+    def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
         @variable_name = $1
         @collection_name = $2
@@ -16,31 +54,30 @@ module Liquid
       else
         raise SyntaxError.new("Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]")
       end
+
+      super
     end
   
     def render(context)        
       context.registers[:for] ||= Hash.new(0)
     
       collection = context[@collection_name]
+      collection = collection.to_a if collection.is_a?(Range)
     
       return '' if collection.nil? or collection.empty?
     
       range = (0..collection.length)
     
       if @attributes['limit'] or @attributes['offset']
-      
-      
         offset = 0
         if @attributes['offset'] == 'continue'
           offset = context.registers[:for][@name] 
         else          
           offset = context[@attributes['offset']] || 0
         end
-      
         limit  = context[@attributes['limit']]
 
         range_end = limit ? offset + limit : collection.length
-      
         range = (offset..range_end-1)
       
         # Save the range end in the registers so that future calls to 
@@ -76,6 +113,6 @@ module Liquid
       result 
     end           
   end
-  
+
   Template.register_tag('for', For)
 end

data/lib/liquid/tags/if.rb

@@ -1,8 +1,22 @@
 module Liquid
+
+  # If is the conditional block
+  #
+  #   {% if user.admin %}
+  #     Admin user!
+  #   {% else %}
+  #     Not admin user
+  #   {% endif %}
+  #
+  #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
+  #
+  #
   class If < Block
-    Syntax = /(#{QuotedFragment})\s*([=!<>]+)?\s*(#{QuotedFragment})?/
+    SyntaxHelp = "Syntax Error in tag 'if' - Valid syntax: if [expression]"
+    Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/
+    
+    def initialize(tag_name, markup, tokens)    
     
-    def initialize(markup, tokens)    
       @blocks = []
       
       push_block('if', markup)
@@ -32,19 +46,33 @@ module Liquid
     private
     
     def push_block(tag, markup)            
-      
       block = if tag == 'else'
         ElseCondition.new
-      elsif markup =~ Syntax
-        Condition.new($1, $2, $3)        
-      else
-        raise SyntaxError.new("Syntax Error in tag '#{tag}' - Valid syntax: #{tag} [condition]") 
+      else        
+        
+        expressions = markup.split(/\b(and|or)\b/).reverse
+        raise SyntaxHelp unless expressions.shift =~ Syntax 
+
+        condition = Condition.new($1, $2, $3)               
+        
+        while not expressions.empty?
+          operator = expressions.shift 
+          
+          raise SyntaxHelp unless expressions.shift.to_s =~ Syntax    
+          
+          new_condition = Condition.new($1, $2, $3)
+          new_condition.send(operator.to_sym, condition)     
+          condition = new_condition          
+        end                        
+                  
+        condition
       end
             
       @blocks.push(block)      
       @nodelist = block.attach(Array.new) 
     end
     
+    
   end
 
   Template.register_tag('if', If)

data/lib/liquid/tags/include.rb

@@ -2,7 +2,7 @@ module Liquid
   class Include < Tag
     Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/
   
-    def initialize(markup, tokens)
+    def initialize(tag_name, markup, tokens)      
       if markup =~ Syntax
 
         @template_name = $1        
@@ -27,8 +27,7 @@ module Liquid
       source  = Liquid::Template.file_system.read_template_file(context[@template_name])      
       partial = Liquid::Template.parse(source)      
       
-      
-      variable = context[@variable_name]
+      variable = context[@variable_name || @template_name[1..-2]]
       
       context.stack do
         @attributes.each do |key, value|

data/lib/liquid/tags/unless.rb

@@ -2,18 +2,22 @@ require File.dirname(__FILE__) + '/if'
 
 module Liquid
 
+  # Unless is a conditional just like 'if' but works on the inverse logic.
+  #
+  #   {% unless x < 0 %} x is greater than zero {% end %}
+  #
   class Unless < If
     def render(context)
       context.stack do
         
         # First condition is interpreted backwards ( if not )
-        block = @blocks.shift
+        block = @blocks.first
         unless block.evaluate(context)
           return render_all(block.attachment, context)            
         end
         
         # After the first condition unless works just like if
-        @blocks.each do |block|
+        @blocks[1..-1].each do |block|
           if block.evaluate(context)            
             return render_all(block.attachment, context)            
           end

data/lib/liquid/template.rb

@@ -70,19 +70,7 @@ module Liquid
     def errors
       @errors ||= []
     end
-    
-    def handle_error(e)
-      errors.push(e)
-      raise if @rethrow_errors
-      
-      case e
-      when SyntaxError        
-        "Liquid syntax error: #{e.message}"        
-      else
-        "Liquid error: #{e.message}"
-      end      
-    end
-    
+        
     # Render takes a hash with local variables.
     #
     # if you use the same filters over and over again consider registering them globally 
@@ -102,9 +90,11 @@ module Liquid
         args.shift
       when Hash
         self.assigns.merge!(args.shift)        
-        Context.new(self)
+        Context.new(assigns, registers, @rethrow_errors)
       when nil
-        Context.new(self)
+        Context.new(assigns, registers, @rethrow_errors)
+      else
+        raise ArgumentError, "Expect Hash or Liquid::Context as parameter"
       end
       
       case args.last
@@ -123,10 +113,15 @@ module Liquid
       when Array
         context.add_filters(args.pop)            
       end
-                                    
+                              
+                              
       # render the nodelist.
       # for performance reasons we get a array back here. to_s will make a string out of it
-      @root.render(context).to_s
+      begin
+        @root.render(context).join
+      ensure
+        @errors = context.errors
+      end
     end
     
     def render!(*args)
@@ -144,7 +139,7 @@ module Liquid
       tokens.shift if tokens[0] and tokens[0].empty? 
 
       tokens
-    end        
+    end
      
   end  
 end

data/lib/liquid/variable.rb

@@ -1,27 +1,40 @@
 module Liquid
   
-  # Hols variables. Variables are only loaded "just in time"
-  # they are not evaluated as part of the render stage
+  # Holds variables. Variables are only loaded "just in time"
+  # and are not evaluated as part of the render stage
+  #
+  #   {{ monkey }}
+  #   {{ user.name }}
+  #
+  # Variables can be combined with filters:
+  #
+  #   {{ user | link }}
+  #
   class Variable    
     attr_accessor :filters, :name
     
     def initialize(markup)
-      @markup = markup                            
-      @name = markup.match(/\s*(#{QuotedFragment})/)[1]
-      if markup.match(/#{FilterSperator}\s*(.*)/)
-        filters = Regexp.last_match(1).split(/#{FilterSperator}/)
+      @markup  = markup                            
+      @name    = nil
+      @filters = []
+      if match = markup.match(/\s*(#{QuotedFragment})/)
+        @name = match[1]
+        if markup.match(/#{FilterSperator}\s*(.*)/)
+          filters = Regexp.last_match(1).split(/#{FilterSperator}/)
         
-        @filters = filters.collect do |f|          
-          filtername = f.match(/\s*(\w+)/)[1]
-          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*(#{QuotedFragment})/).flatten            
-          [filtername.to_sym, filterargs]
+          filters.each do |f|    
+            if matches = f.match(/\s*(\w+)/)
+              filtername = matches[1]
+              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*(#{QuotedFragment})/).flatten            
+              @filters << [filtername.to_sym, filterargs]
+            end
+          end
         end
-      else
-        @filters = []
       end
     end                        
 
     def render(context)      
+      return '' if @name.nil?
       output = context[@name]
       @filters.inject(output) do |output, filter|
         filterargs = filter[1].to_a.collect do |a|

data/test/block_test.rb

@@ -42,6 +42,14 @@ class VariableTest < Test::Unit::TestCase
     assert_equal 3, template.root.nodelist.size
   end
   
+  def test_with_custom_tag 
+    Liquid::Template.register_tag("testtag", Block) 
+     
+    assert_nothing_thrown do 
+      template = Liquid::Template.parse( "{% testtag %} {% endtesttag %}") 
+    end 
+  end
+  
   private
   
   def block_types(nodelist)

data/test/condition_test.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ConditionTest < Test::Unit::TestCase
+  include Liquid
+  
+  def test_basic_condition
+    assert_equal false, Condition.new('1', '==', '2').evaluate
+    assert_equal true,  Condition.new('1', '==', '1').evaluate
+  end
+
+  def test_default_operators_evalute_true
+    assert_evalutes_true '1', '==', '1'
+    assert_evalutes_true '1', '!=', '2'
+    assert_evalutes_true '1', '<>', '2'
+    assert_evalutes_true '1', '<', '2'
+    assert_evalutes_true '2', '>', '1'
+    assert_evalutes_true '1', '>=', '1'
+    assert_evalutes_true '2', '>=', '1'
+    assert_evalutes_true '1', '<=', '2'
+    assert_evalutes_true '1', '<=', '1'
+  end
+
+  def test_default_operators_evalute_false
+    assert_evalutes_false '1', '==', '2'
+    assert_evalutes_false '1', '!=', '1'
+    assert_evalutes_false '1', '<>', '1'
+    assert_evalutes_false '1', '<', '0'
+    assert_evalutes_false '2', '>', '4'
+    assert_evalutes_false '1', '>=', '3'
+    assert_evalutes_false '2', '>=', '4'
+    assert_evalutes_false '1', '<=', '0'
+    assert_evalutes_false '1', '<=', '0'
+  end
+
+  def test_contains_works_on_strings
+    assert_evalutes_true "'bob'", 'contains', "'o'"
+    assert_evalutes_true "'bob'", 'contains', "'b'"
+    assert_evalutes_true "'bob'", 'contains', "'bo'"
+    assert_evalutes_true "'bob'", 'contains', "'ob'"
+    assert_evalutes_true "'bob'", 'contains', "'bob'"
+
+    assert_evalutes_false "'bob'", 'contains', "'bob2'"
+    assert_evalutes_false "'bob'", 'contains', "'a'"
+    assert_evalutes_false "'bob'", 'contains', "'---'"
+  end
+
+  def test_contains_works_on_arrays
+    @context = Liquid::Context.new
+    @context['array'] = [1,2,3,4,5]
+            
+    assert_evalutes_false "array", 'contains', '0'
+    assert_evalutes_true "array", 'contains', '1'
+    assert_evalutes_true "array", 'contains', '2'
+    assert_evalutes_true "array", 'contains', '3'
+    assert_evalutes_true "array", 'contains', '4'
+    assert_evalutes_true "array", 'contains', '5'
+    assert_evalutes_false "array", 'contains', '6'
+    
+    assert_evalutes_false "array", 'contains', '"1"'        
+    
+  end  
+
+  def test_or_condition     
+    condition = Condition.new('1', '==', '2')
+
+    assert_equal false, condition.evaluate
+
+    condition.or Condition.new('2', '==', '1')
+    
+    assert_equal false, condition.evaluate
+
+    condition.or Condition.new('1', '==', '1')  
+    
+    assert_equal true, condition.evaluate
+  end
+  
+  def test_and_condition     
+    condition = Condition.new('1', '==', '1')
+
+    assert_equal true, condition.evaluate
+
+    condition.and Condition.new('2', '==', '2')
+    
+    assert_equal true, condition.evaluate
+
+    condition.and Condition.new('2', '==', '1')  
+    
+    assert_equal false, condition.evaluate
+  end
+  
+
+  def test_should_allow_custom_proc_operator
+    Condition.operators['starts_with'] = Proc.new { |cond, left, right| left =~ %r{^#{right}}}
+    
+    assert_evalutes_true "'bob'", 'starts_with', "'b'"
+    assert_evalutes_false "'bob'", 'starts_with', "'o'"
+  ensure
+    Condition.operators.delete 'starts_with'
+  end
+
+  private
+    def assert_evalutes_true(left, op, right)
+      assert Condition.new(left, op, right).evaluate(@context || Liquid::Context.new), "Evaluated false: #{left} #{op} #{right}"
+    end
+    
+    def assert_evalutes_false(left, op, right)
+      assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new), "Evaluated true: #{left} #{op} #{right}"
+    end
+end