liquid 2.5.5 → 2.6.0.rc1

data/lib/liquid/tags/ifchanged.rb

@@ -1,20 +1,20 @@
 module Liquid
   class Ifchanged < Block
-            
+
     def render(context)
-      context.stack do 
-        
+      context.stack do
+
         output = render_all(@nodelist, context)
-        
+
         if output != context.registers[:ifchanged]
           context.registers[:ifchanged] = output
           output
         else
           ''
-        end              
+        end
       end
     end
-  end  
-  
-  Template.register_tag('ifchanged', Ifchanged)  
-end
+  end
+
+  Template.register_tag('ifchanged', Ifchanged)
+end

data/lib/liquid/tags/include.rb

@@ -1,11 +1,26 @@
 module Liquid
+
+  # Include allows templates to relate with other templates
+  #
+  # Simply include another template:
+  #
+  #   {% include 'product' %}
+  #
+  # Include a template with a local variable:
+  #
+  #   {% include 'product' with products[0] %}
+  #
+  # Include a template for a collection:
+  #
+  #   {% include 'product' for products %}
+  #
   class Include < Tag
     Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
-  
-    def initialize(tag_name, markup, tokens)      
+
+    def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
 
-        @template_name = $1        
+        @template_name = $1
         @variable_name = $3
         @attributes    = {}
 
@@ -19,23 +34,22 @@ module Liquid
 
       super
     end
-  
+
     def parse(tokens)
     end
-    
+
     def render(context)
-      source = _read_template_from_file_system(context)
-      partial = Liquid::Template.parse(source)
+      partial = load_cached_partial(context)
       variable = context[@variable_name || @template_name[1..-2]]
-      
+
       context.stack do
         @attributes.each do |key, value|
           context[key] = context[value]
         end
 
         if variable.is_a?(Array)
-          variable.collect do |variable|
-            context[@template_name[1..-2]] = variable
+          variable.collect do |var|
+            context[@template_name[1..-2]] = var
             partial.render(context)
           end
         else
@@ -44,11 +58,25 @@ module Liquid
         end
       end
     end
-   
+
     private
-      def _read_template_from_file_system(context)
+      def load_cached_partial(context)
+        cached_partials = context.registers[:cached_partials] || {}
+        template_name = context[@template_name]
+
+        if cached = cached_partials[template_name]
+          return cached
+        end
+        source = read_template_from_file_system(context)
+        partial = Liquid::Template.parse(source)
+        cached_partials[template_name] = partial
+        context.registers[:cached_partials] = cached_partials
+        partial
+      end
+
+      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
@@ -61,5 +89,5 @@ module Liquid
       end
   end
 
-  Template.register_tag('include', Include)  
+  Template.register_tag('include', Include)
 end

data/lib/liquid/tags/increment.rb

@@ -1,5 +1,5 @@
 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.
@@ -16,20 +16,20 @@ module Liquid
   #    Hello: 2
   #
   class Increment < Tag
-    def initialize(tag_name, markup, tokens)      
+    def initialize(tag_name, markup, tokens)
       @variable = markup.strip
 
-      super    
-    end    
-  
+      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

@@ -1,12 +1,14 @@
 module Liquid
   class Raw < Block
+    FullTokenPossiblyInvalid = /^(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/o
+
     def parse(tokens)
       @nodelist ||= []
       @nodelist.clear
-
       while token = tokens.shift
-        if token =~ FullToken
-          if block_delimiter == $1
+        if token =~ FullTokenPossiblyInvalid
+          @nodelist << $1 if $1 != ""
+          if block_delimiter == $2
             end_tag
             return
           end
@@ -18,4 +20,3 @@ module Liquid
 
   Template.register_tag('raw', Raw)
 end
-

data/lib/liquid/tags/unless.rb

@@ -9,25 +9,25 @@ module Liquid
   class Unless < If
     def render(context)
       context.stack do
-        
+
         # First condition is interpreted backwards ( if not )
-        block = @blocks.first
-        unless block.evaluate(context)
-          return render_all(block.attachment, context)
+        first_block = @blocks.first
+        unless first_block.evaluate(context)
+          return render_all(first_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)
           end
         end
-        
+
         ''
       end
     end
   end
-  
+
 
   Template.register_tag('unless', Unless)
-end
+end

data/lib/liquid/template.rb

@@ -14,7 +14,7 @@ module Liquid
   #   template.render('user_name' => 'bob')
   #
   class Template
-    attr_accessor :root
+    attr_accessor :root, :resource_limits
     @@file_system = BlankFileSystem.new
 
     class << self
@@ -50,6 +50,7 @@ module Liquid
 
     # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
     def initialize
+      @resource_limits = {}
     end
 
     # Parse source code.
@@ -88,14 +89,17 @@ module Liquid
     #
     def render(*args)
       return '' if @root.nil?
-      
+
       context = case args.first
       when Liquid::Context
         args.shift
+      when Liquid::Drop
+        drop = args.shift
+        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when Hash
-        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors)
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when nil
-        Context.new(assigns, instance_assigns, registers, @rethrow_errors)
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
       else
         raise ArgumentError, "Expect Hash or Liquid::Context as parameter"
       end
@@ -120,9 +124,11 @@ module Liquid
 
       begin
         # render the nodelist.
-        # for performance reasons we get a array back here. join will make a string out of it
+        # for performance reasons we get an array back here. join will make a string out of it.
         result = @root.render(context)
         result.respond_to?(:join) ? result.join : result
+      rescue Liquid::MemoryError => e
+        context.handle_error(e)
       ensure
         @errors = context.errors
       end

data/lib/liquid/utils.rb

@@ -3,7 +3,6 @@ module Liquid
     def self.slice_collection_using_each(collection, from, to)
       segments = []
       index = 0
-      yielded = 0
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
       return [collection] if non_blank_string?(collection)

data/lib/liquid/variable.rb

@@ -23,9 +23,9 @@ module Liquid
         if match[2].match(/#{FilterSeparator}\s*(.*)/o)
           filters = Regexp.last_match(1).scan(FilterParser)
           filters.each do |f|
-            if matches = f.match(/\s*(\w+)(?:\s*#{FilterArgumentSeparator}(.*))?/)
+            if matches = f.match(/\s*(\w+)/)
               filtername = matches[1]
-              filterargs = matches[2].to_s.scan(/(?:\A|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
+              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
               @filters << [filtername, filterargs]
             end
           end

data/lib/liquid/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Liquid
+  VERSION = "2.6.0.rc1"
+end

data/test/liquid/assign_test.rb

@@ -12,7 +12,7 @@ class AssignTest < Test::Unit::TestCase
                            '{% assign foo = values %}.{{ foo[1] }}.',
                            'values' => %w{foo bar baz})
   end
-  
+
   def test_assign_with_filter
     assert_template_result('.bar.',
                            '{% assign foo = values | split: "," %}.{{ foo[1] }}.',

data/test/liquid/condition_test.rb

@@ -124,4 +124,4 @@ class ConditionTest < Test::Unit::TestCase
       assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
              "Evaluated true: #{left} #{op} #{right}"
     end
-end # ConditionTest
+end # ConditionTest

data/test/liquid/hash_ordering_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module MoneyFilter
+  def money(input)
+    sprintf(' %d$ ', input)
+  end
+end
+
+module CanadianMoneyFilter
+  def money(input)
+    sprintf(' %d$ CAD ', input)
+  end
+end
+
+class HashOrderingTest < Test::Unit::TestCase
+  include Liquid
+
+ def test_global_register_order
+    Template.register_filter(MoneyFilter)
+    Template.register_filter(CanadianMoneyFilter)
+
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
+ end
+
+end

data/test/liquid/output_test.rb

@@ -49,7 +49,7 @@ class OutputTest < Test::Unit::TestCase
 
     expected = %| good bad good |
     assert_equal expected, Template.parse(text).render(@assigns)
-  end               
+  end
 
   def test_variable_piping
     text = %( {{ car.gm | make_funny }} )
@@ -113,4 +113,4 @@ class OutputTest < Test::Unit::TestCase
 
     assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
-end # OutputTest
+end # OutputTest

data/test/liquid/standard_filter_test.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'test_helper'
 
 class Filters
@@ -58,6 +60,7 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_equal '1234567890', @filters.truncate('1234567890', 20)
     assert_equal '...', @filters.truncate('1234567890', 0)
     assert_equal '1234567890', @filters.truncate('1234567890')
+    assert_equal "测试...", @filters.truncate("测试测试测试测试", 5)
   end
 
   def test_strip
@@ -82,12 +85,16 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_equal 'one two...', @filters.truncatewords('one two three', 2)
     assert_equal 'one two three', @filters.truncatewords('one two three')
     assert_equal 'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...', @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
+    assert_equal "测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5)
   end
 
   def test_strip_html
     assert_equal 'test', @filters.strip_html("<div>test</div>")
     assert_equal 'test', @filters.strip_html("<div id='test'>test</div>")
     assert_equal '', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>")
+    assert_equal '', @filters.strip_html("<style type='text/css'>foo bar</style>")
+    assert_equal 'test', @filters.strip_html("<div\nclass='multiline'>test</div>")
+    assert_equal 'test', @filters.strip_html("<!-- foo bar \n test -->test")
     assert_equal '', @filters.strip_html(nil)
   end
 
@@ -101,6 +108,10 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_equal [{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], @filters.sort([{"a" => 4}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
   end
 
+  def test_reverse
+    assert_equal [4,3,2,1], @filters.reverse([1,2,3,4])
+  end
+
   def test_map
     assert_equal [1,2,3,4], @filters.map([{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], 'a')
     assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
@@ -141,6 +152,8 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")
 
     assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
+    assert_equal "#{Date.today.year}", @filters.date('now', '%Y')
+    assert_equal "#{Date.today.year}", @filters.date('today', '%Y')
 
     assert_equal nil, @filters.date(nil, "%B")
 
@@ -174,6 +187,7 @@ class StandardFiltersTest < Test::Unit::TestCase
 
   def test_strip_newlines
     assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc"
+    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc"
   end
 
   def test_newlines_to_br
@@ -198,6 +212,8 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_match(/(6\.3)|(6\.(0{13})1)/, Template.parse("{{ '2.1' | times:3 }}").render)
 
     assert_template_result "6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
+
+    assert_template_result "7.25", "{{ 0.0725 | times:100 }}"
   end
 
   def test_divided_by
@@ -209,6 +225,8 @@ class StandardFiltersTest < Test::Unit::TestCase
 
     assert_template_result "5", "{{ 15 | divided_by:3 }}"
     assert_template_result "Liquid error: divided by 0", "{{ 5 | divided_by:0 }}"
+
+    assert_template_result "0.5", "{{ 2.0 | divided_by:4 }}"
   end
 
   def test_modulo

data/test/liquid/tags/for_tag_test.rb

@@ -187,16 +187,16 @@ HERE
     expected = "1234"
     assert_template_result(expected,markup,assigns)
 
-    # tests to ensure it only breaks out of the local for loop 
+    # tests to ensure it only breaks out of the local for loop
     # and not all of them.
     assigns = {'array' => [[1,2],[3,4],[5,6]] }
-    markup = '{% for item in array %}' + 
-               '{% for i in item %}' + 
-                 '{% if i == 1 %}' + 
-                   '{% break %}' + 
-                 '{% endif %}' + 
-                 '{{ i }}' + 
-               '{% endfor %}' + 
+    markup = '{% for item in array %}' +
+               '{% for i in item %}' +
+                 '{% if i == 1 %}' +
+                   '{% break %}' +
+                 '{% endif %}' +
+                 '{{ i }}' +
+               '{% endfor %}' +
              '{% endfor %}'
     expected = '3456'
     assert_template_result(expected, markup, assigns)
@@ -213,15 +213,15 @@ HERE
 
     markup = '{% for i in array.items %}{% continue %}{% endfor %}'
     expected = ""
-    assert_template_result(expected,markup,assigns) 
+    assert_template_result(expected,markup,assigns)
 
     markup = '{% for i in array.items %}{{ i }}{% continue %}{% endfor %}'
     expected = "12345"
-    assert_template_result(expected,markup,assigns) 
+    assert_template_result(expected,markup,assigns)
 
     markup = '{% for i in array.items %}{% continue %}{{ i }}{% endfor %}'
     expected = ""
-    assert_template_result(expected,markup,assigns) 
+    assert_template_result(expected,markup,assigns)
 
     markup = '{% for i in array.items %}{% if i > 3 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
     expected = "123"
@@ -233,13 +233,13 @@ HERE
 
     # tests to ensure it only continues the local for loop and not all of them.
     assigns = {'array' => [[1,2],[3,4],[5,6]] }
-    markup = '{% for item in array %}' + 
-               '{% for i in item %}' + 
-                 '{% if i == 1 %}' + 
-                   '{% continue %}' + 
-                 '{% endif %}' + 
-                 '{{ i }}' + 
-               '{% endfor %}' + 
+    markup = '{% for item in array %}' +
+               '{% for i in item %}' +
+                 '{% if i == 1 %}' +
+                   '{% continue %}' +
+                 '{% endif %}' +
+                 '{{ i }}' +
+               '{% endfor %}' +
              '{% endfor %}'
     expected = '23456'
     assert_template_result(expected, markup, assigns)
@@ -253,32 +253,45 @@ HERE
 
   def test_for_tag_string
     # ruby 1.8.7 "String".each => Enumerator with single "String" element.
-    # ruby 1.9.3 no longer supports .each on String though we mimic 
+    # ruby 1.9.3 no longer supports .each on String though we mimic
     # the functionality for backwards compatibility
 
-    assert_template_result('test string', 
-                '{%for val in string%}{{val}}{%endfor%}', 
+    assert_template_result('test string',
+                '{%for val in string%}{{val}}{%endfor%}',
                 'string' => "test string")
 
-    assert_template_result('test string', 
-                '{%for val in string limit:1%}{{val}}{%endfor%}', 
+    assert_template_result('test string',
+                '{%for val in string limit:1%}{{val}}{%endfor%}',
                 'string' => "test string")
 
-    assert_template_result('val-string-1-1-0-1-0-true-true-test string', 
-                '{%for val in string%}' + 
-                '{{forloop.name}}-' + 
-                '{{forloop.index}}-' + 
-                '{{forloop.length}}-' + 
-                '{{forloop.index0}}-' + 
-                '{{forloop.rindex}}-' + 
-                '{{forloop.rindex0}}-' + 
-                '{{forloop.first}}-' + 
-                '{{forloop.last}}-' + 
-                '{{val}}{%endfor%}', 
+    assert_template_result('val-string-1-1-0-1-0-true-true-test string',
+                '{%for val in string%}' +
+                '{{forloop.name}}-' +
+                '{{forloop.index}}-' +
+                '{{forloop.length}}-' +
+                '{{forloop.index0}}-' +
+                '{{forloop.rindex}}-' +
+                '{{forloop.rindex0}}-' +
+                '{{forloop.first}}-' +
+                '{{forloop.last}}-' +
+                '{{val}}{%endfor%}',
                 'string' => "test string")
   end
 
   def test_blank_string_not_iterable
     assert_template_result('', "{% for char in characters %}I WILL NOT BE OUTPUT{% endfor %}", 'characters' => '')
   end
+
+  def test_bad_variable_naming_in_for_loop
+    assert_raise(Liquid::SyntaxError) do
+      Liquid::Template.parse('{% for a/b in x %}{% endfor %}')
+    end
+  end
+
+  def test_spacing_with_variable_naming_in_for_loop
+    expected = '12345'
+    template = '{% for       item   in   items %}{{item}}{% endfor %}'
+    assigns  = {'items' => [1,2,3,4,5]}
+    assert_template_result(expected, template, assigns)
+  end
 end