liquid 2.2.2 → 2.3.0

data/lib/liquid/tags/decrement.rb

@@ -0,0 +1,39 @@
+module Liquid
+  
+  # decrement is used in a place where one needs to insert a counter
+  #     into a template, and needs the counter to survive across
+  #     multiple instantiations of the template.
+  #     NOTE: decrement is a pre-decrement, --i,
+  #           while increment is post:      i++.
+  #
+  #     (To achieve the survival, the application must keep the context)
+  #
+  #     if the variable does not exist, it is created with value 0.
+
+  #   Hello: {% decrement variable %}
+  #
+  # gives you:
+  #
+  #    Hello: -1
+  #    Hello: -2
+  #    Hello: -3
+  #
+  class Decrement < Tag
+    def initialize(tag_name, markup, tokens)      
+      @variable = markup.strip
+
+      super    
+    end    
+  
+    def render(context)
+      value = context.environments.first[@variable] ||= 0
+      value = value - 1
+      context.environments.first[@variable] = value
+      value.to_s
+    end
+  
+    private
+  end
+  
+  Template.register_tag('decrement', Decrement)
+end

data/lib/liquid/tags/for.rb

@@ -13,6 +13,8 @@ module Liquid
   #      <div {% if forloop.first %}class="first"{% endif %}>
   #        Item {{ forloop.index }}: {{ item.name }}
   #      </div>
+  #    {% else %}
+  #      There is nothing in the collection.
   #    {% endfor %}
   #
   # You can also define a limit and offset much like SQL.  Remember
@@ -58,8 +60,14 @@ module Liquid
         raise SyntaxError.new("Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]")
       end
 
+      @nodelist = @for_block = []
       super
     end
+
+    def unknown_tag(tag, markup, tokens)
+      return super unless tag == 'else'
+      @nodelist = @else_block = []
+    end
   
     def render(context)        
       context.registers[:for] ||= Hash.new(0)
@@ -67,7 +75,7 @@ module Liquid
       collection = context[@collection_name]
       collection = collection.to_a if collection.is_a?(Range)
     
-      return '' unless collection.respond_to?(:each) 
+      return render_else(context) unless collection.respond_to?(:each) 
                                                  
       from = if @attributes['offset'] == 'continue'
         context.registers[:for][@name].to_i
@@ -81,11 +89,11 @@ module Liquid
                        
       segment = slice_collection_using_each(collection, from, to)      
       
-      return '' if segment.empty?
+      return render_else(context) if segment.empty?
       
       segment.reverse! if @reversed
 
-      result = []
+      result = ''
         
       length = segment.length            
             
@@ -105,7 +113,7 @@ module Liquid
             'first'   => (index == 0),
             'last'    => (index == length - 1) }
 
-          result << render_all(@nodelist, context)
+          result << render_all(@for_block, context)
         end
       end
       result     
@@ -130,7 +138,14 @@ module Liquid
 
       segments
     end
+
+    private
+
+      def render_else(context)
+        return @else_block ? [render_all(@else_block, context)] : ''
+      end
+
   end
 
   Template.register_tag('for', For)
-end
+end

data/lib/liquid/tags/include.rb

@@ -20,14 +20,12 @@ module Liquid
       super
     end
   
-    def parse(tokens)      
+    def parse(tokens)
     end
-  
-    def render(context)      
-      file_system = context.registers[:file_system] || Liquid::Template.file_system
-      source  = file_system.read_template_file(context[@template_name])      
-      partial = Liquid::Template.parse(source)      
-      
+    
+    def render(context)
+      source = _read_template_from_file_system(context)
+      partial = Liquid::Template.parse(source)
       variable = context[@variable_name || @template_name[1..-2]]
       
       context.stack do
@@ -36,20 +34,31 @@ module Liquid
         end
 
         if variable.is_a?(Array)
-          
-          variable.collect do |variable|            
+          variable.collect do |variable|
             context[@template_name[1..-2]] = variable
             partial.render(context)
           end
-
         else
-                    
           context[@template_name[1..-2]] = variable
           partial.render(context)
-          
         end
       end
     end
+   
+    private
+      def _read_template_from_file_system(context)
+        file_system = context.registers[:file_system] || Liquid::Template.file_system
+      
+        # make read_template_file call backwards-compatible.
+        case file_system.method(:read_template_file).arity
+        when 1
+          file_system.read_template_file(context[@template_name])
+        when 2
+          file_system.read_template_file(context[@template_name], context)
+        else
+          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
+        end
+      end
   end
 
   Template.register_tag('include', Include)  

data/lib/liquid/tags/increment.rb

@@ -0,0 +1,35 @@
+module Liquid
+  
+  # increment is used in a place where one needs to insert a counter
+  #     into a template, and needs the counter to survive across
+  #     multiple instantiations of the template.
+  #     (To achieve the survival, the application must keep the context)
+  #
+  #     if the variable does not exist, it is created with value 0.
+
+  #   Hello: {% increment variable %}
+  #
+  # gives you:
+  #
+  #    Hello: 0
+  #    Hello: 1
+  #    Hello: 2
+  #
+  class Increment < Tag
+    def initialize(tag_name, markup, tokens)      
+      @variable = markup.strip
+
+      super    
+    end    
+  
+    def render(context)
+      value = context.environments.first[@variable] ||= 0
+      context.environments.first[@variable] = value + 1
+      value.to_s
+    end
+  
+    private
+  end
+  
+  Template.register_tag('increment', Increment)
+end

data/lib/liquid/tags/raw.rb

@@ -0,0 +1,21 @@
+module Liquid
+  class Raw < Block
+    def parse(tokens)
+      @nodelist ||= []
+      @nodelist.clear
+
+      while token = tokens.shift
+        if token =~ FullToken
+          if block_delimiter == $1
+            end_tag
+            return
+          end
+        end
+        @nodelist << token if not token.empty?
+      end
+    end
+  end
+
+  Template.register_tag('raw', Raw)
+end
+

data/lib/liquid/tags/unless.rb

@@ -13,19 +13,19 @@ module Liquid
         # First condition is interpreted backwards ( if not )
         block = @blocks.first
         unless block.evaluate(context)
-          return render_all(block.attachment, context)            
+          return render_all(block.attachment, context)
         end
         
         # After the first condition unless works just like if
         @blocks[1..-1].each do |block|
-          if block.evaluate(context)            
-            return render_all(block.attachment, context)            
+          if block.evaluate(context)
+            return render_all(block.attachment, context)
           end
-        end 
+        end
         
         ''
       end
-    end    
+    end
   end
   
 

data/lib/liquid/template.rb

@@ -55,7 +55,7 @@ module Liquid
     # Parse source code.
     # Returns self for easy chaining
     def parse(source)
-      @root = Document.new(tokenize(Liquid::Literal.from_shorthand(source)))
+      @root = Document.new(tokenize(source))
       self
     end
 
@@ -121,7 +121,8 @@ module Liquid
       begin
         # render the nodelist.
         # for performance reasons we get a array back here. join will make a string out of it
-        @root.render(context).join
+        result = @root.render(context)
+        result.respond_to?(:join) ? result.join : result
       ensure
         @errors = context.errors
       end

data/lib/liquid/variable.rb

@@ -37,7 +37,7 @@ module Liquid
       return '' if @name.nil?
       @filters.inject(context[@name]) do |output, filter|
         filterargs = filter[1].to_a.collect do |a|
-         context[a]
+          context[a]
         end
         begin
           output = context.invoke(filter[0], output, *filterargs)

data/test/liquid/assign_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class AssignTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_assigned_variable
+    assert_template_result('.foo.',
+                           '{% assign foo = values %}.{{ foo[0] }}.',
+                           'values' => %w{foo bar baz})
+
+    assert_template_result('.bar.',
+                           '{% assign foo = values %}.{{ foo[1] }}.',
+                           'values' => %w{foo bar baz})
+  end
+end # AssignTest

data/test/liquid/block_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class VariableTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_blankspace
+    template = Liquid::Template.parse("  ")
+    assert_equal ["  "], template.root.nodelist
+  end
+
+  def test_variable_beginning
+    template = Liquid::Template.parse("{{funk}}  ")
+    assert_equal 2, template.root.nodelist.size
+    assert_equal Variable, template.root.nodelist[0].class
+    assert_equal String, template.root.nodelist[1].class
+  end
+
+  def test_variable_end
+    template = Liquid::Template.parse("  {{funk}}")
+    assert_equal 2, template.root.nodelist.size
+    assert_equal String, template.root.nodelist[0].class
+    assert_equal Variable, template.root.nodelist[1].class
+  end
+
+  def test_variable_middle
+    template = Liquid::Template.parse("  {{funk}}  ")
+    assert_equal 3, template.root.nodelist.size
+    assert_equal String, template.root.nodelist[0].class
+    assert_equal Variable, template.root.nodelist[1].class
+    assert_equal String, template.root.nodelist[2].class
+  end
+
+  def test_variable_many_embedded_fragments
+    template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
+    assert_equal 7, template.root.nodelist.size
+    assert_equal [String, Variable, String, Variable, String, Variable, String],
+                 block_types(template.root.nodelist)
+  end
+
+  def test_with_block
+    template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
+    assert_equal [String, Comment, String], block_types(template.root.nodelist)
+    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)
+      nodelist.collect { |node| node.class }
+    end
+end # VariableTest

data/test/liquid/capture_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class CaptureTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_captures_block_content_in_variable
+    assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
+  end
+
+  def test_capture_to_variable_from_outer_scope_if_existing
+    template_source = <<-END_TEMPLATE
+    {% assign var = '' %}
+    {% if true %}
+    {% capture var %}first-block-string{% endcapture %}
+    {% endif %}
+    {% if true %}
+    {% capture var %}test-string{% endcapture %}
+    {% endif %}
+    {{var}}
+    END_TEMPLATE
+    template = Template.parse(template_source)
+    rendered = template.render
+    assert_equal "test-string", rendered.gsub(/\s/, '')
+  end
+
+  def test_assigning_from_capture
+    template_source = <<-END_TEMPLATE
+    {% assign first = '' %}
+    {% assign second = '' %}
+    {% for number in (1..3) %}
+    {% capture first %}{{number}}{% endcapture %}
+    {% assign second = first %}
+    {% endfor %}
+    {{ first }}-{{ second }}
+    END_TEMPLATE
+    template = Template.parse(template_source)
+    rendered = template.render
+    assert_equal "3-3", rendered.gsub(/\s/, '')
+  end
+end # CaptureTest

data/test/liquid/condition_test.rb

@@ -0,0 +1,122 @@
+require 'test_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_contains_returns_false_for_nil_operands
+    @context = Liquid::Context.new
+    assert_evalutes_false "not_assigned", 'contains', '0'
+    assert_evalutes_false "0", 'contains', 'not_assigned'
+  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
+
+  def test_left_or_right_may_contain_operators
+    @context = Liquid::Context.new
+    @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
+
+    assert_evalutes_true "one", '==', "another"
+  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 # ConditionTest