liquid 3.0.0.rc1 → 3.0.0

data/lib/liquid/version.rb

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

data/test/integration/assign_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class AssignTest < Test::Unit::TestCase
+class AssignTest < Minitest::Test
   include Liquid
 
   def test_assigned_variable
@@ -24,4 +24,15 @@ class AssignTest < Test::Unit::TestCase
                        '{% assign foo not values %}.',
                        'values' => "foo,bar,baz")
   end
+
+  def test_assign_uses_error_mode
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        Template.parse("{% assign foo = ('X' | downcase) %}")
+      end
+    end
+    with_error_mode(:lax) do
+      assert Template.parse("{% assign foo = ('X' | downcase) %}")
+    end
+  end
 end # AssignTest

data/test/integration/blank_test.rb

@@ -14,7 +14,7 @@ class BlankTestFileSystem
   end
 end
 
-class BlankTest < Test::Unit::TestCase
+class BlankTest < Minitest::Test
   include Liquid
   N = 10
 

data/test/integration/capture_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class CaptureTest < Test::Unit::TestCase
+class CaptureTest < Minitest::Test
   include Liquid
 
   def test_captures_block_content_in_variable

data/test/integration/context_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ContextTest < Test::Unit::TestCase
+class ContextTest < Minitest::Test
   include Liquid
 
   def test_override_global_filter
@@ -16,18 +16,17 @@ class ContextTest < Test::Unit::TestCase
       end
     end
 
-    Template.register_filter(global)
-    assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
-    assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
+    with_global_filter(global) do
+      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
+      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
+    end
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
-    Template.error_mode = :strict
-
-    context = Context.new
-
-    context.has_key?('unknown')
-
-    assert_empty context.errors
+    with_error_mode :strict do
+      context = Context.new
+      context.has_key?('unknown')
+      assert_empty context.errors
+    end
   end
 end

data/test/integration/drop_test.rb

@@ -48,6 +48,10 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
+  def user_input
+    "foo".taint
+  end
+
   protected
     def callmenot
       "protected"
@@ -100,12 +104,34 @@ class RealEnumerableDrop < Liquid::Drop
   end
 end
 
-class DropsTest < Test::Unit::TestCase
+class DropsTest < Minitest::Test
   include Liquid
 
   def test_product_drop
-    assert_nothing_raised do
-      tpl = Liquid::Template.parse( '  '  )
+    tpl = Liquid::Template.parse('  ')
+    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
+  end
+
+  def test_rendering_raises_on_tainted_attr
+    with_taint_mode(:error) do
+      tpl = Liquid::Template.parse('{{ product.user_input }}')
+      assert_raises TaintedError do
+        tpl.render!('product' => ProductDrop.new)
+      end
+    end
+  end
+
+  def test_rendering_warns_on_tainted_attr
+    with_taint_mode(:warn) do
+      tpl = Liquid::Template.parse('{{ product.user_input }}')
+      tpl.render!('product' => ProductDrop.new)
+      assert_match /tainted/, tpl.warnings.first
+    end
+  end
+
+  def test_rendering_doesnt_raise_on_escaped_tainted_attr
+    with_taint_mode(:error) do
+      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
       tpl.render!('product' => ProductDrop.new)
     end
   end

data/test/integration/error_handling_test.rb

@@ -19,92 +19,189 @@ class ErrorDrop < Liquid::Drop
 
 end
 
-class ErrorHandlingTest < Test::Unit::TestCase
+class ErrorHandlingTest < Minitest::Test
   include Liquid
 
-  def test_standard_error
-    assert_nothing_raised do
-      template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
-      assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
+  def test_templates_parsed_with_line_numbers_renders_them_in_errors
+    template = <<-LIQUID
+      Hello,
 
-      assert_equal 1, template.errors.size
-      assert_equal StandardError, template.errors.first.class
-    end
-  end
+      {{ errors.standard_error }} will raise a standard error.
 
-  def test_syntax
+      Bla bla test.
 
-    assert_nothing_raised do
+      {{ errors.syntax_error }} will raise a syntax error.
 
-      template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
-      assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
+      This is an argument error: {{ errors.argument_error }}
 
-      assert_equal 1, template.errors.size
-      assert_equal SyntaxError, template.errors.first.class
+      Bla.
+    LIQUID
 
-    end
+    expected = <<-TEXT
+      Hello,
+
+      Liquid error (line 3): standard error will raise a standard error.
+
+      Bla bla test.
+
+      Liquid syntax error (line 7): syntax error will raise a syntax error.
+
+      This is an argument error: Liquid error (line 9): argument error
+
+      Bla.
+    TEXT
+
+    output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
+    assert_equal expected, output
   end
 
-  def test_argument
-    assert_nothing_raised do
+  def test_standard_error
+    template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
+    assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
 
-      template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
-      assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
+    assert_equal 1, template.errors.size
+    assert_equal StandardError, template.errors.first.class
+  end
 
-      assert_equal 1, template.errors.size
-      assert_equal ArgumentError, template.errors.first.class
-    end
+  def test_syntax
+    template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
+    assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
+
+    assert_equal 1, template.errors.size
+    assert_equal SyntaxError, template.errors.first.class
+  end
+
+  def test_argument
+    template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
+    assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
+
+    assert_equal 1, template.errors.size
+    assert_equal ArgumentError, template.errors.first.class
   end
 
   def test_missing_endtag_parse_time_error
-    assert_raise(Liquid::SyntaxError) do
+    assert_raises(Liquid::SyntaxError) do
       Liquid::Template.parse(' {% for a in b %} ... ')
     end
   end
 
   def test_unrecognized_operator
     with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
       end
     end
   end
-  
+
   def test_lax_unrecognized_operator
-    assert_nothing_raised do
-      template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
-      assert_equal ' Liquid error: Unknown operator =! ', template.render
-      assert_equal 1, template.errors.size
-      assert_equal Liquid::ArgumentError, template.errors.first.class
+    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
+    assert_equal ' Liquid error: Unknown operator =! ', template.render
+    assert_equal 1, template.errors.size
+    assert_equal Liquid::ArgumentError, template.errors.first.class
+  end
+
+  def test_with_line_numbers_adds_numbers_to_parser_errors
+    err = assert_raises(SyntaxError) do
+      template = Liquid::Template.parse(%q{
+          foobar
+
+          {% "cat" | foobar %}
+
+          bla
+        },
+        :line_numbers => true
+      )
+    end
+
+    assert_match /Liquid syntax error \(line 4\)/, err.message
+  end
+
+  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
+    template = Liquid::Template.parse(%q{
+        foobar
+
+        {% if 1 =! 2 %}ok{% endif %}
+
+        bla
+      },
+      :error_mode => :warn,
+      :line_numbers => true
+    )
+
+    assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
+      template.warnings.map(&:message)
+  end
+
+  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse(%q{
+          foobar
+
+          {% if 1 =! 2 %}ok{% endif %}
+
+          bla
+        },
+        :error_mode => :strict,
+        :line_numbers => true
+      )
+    end
+
+    assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
+  end
+
+  def test_syntax_errors_in_nested_blocks_have_correct_line_number
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse(%q{
+          foobar
+
+          {% if 1 != 2 %}
+            {% foo %}
+          {% endif %}
+
+          bla
+        },
+        :line_numbers => true
+      )
     end
+
+    assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
   end
 
   def test_strict_error_messages
-    err = assert_raise(SyntaxError) do
+    err = assert_raises(SyntaxError) do
       Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :strict)
     end
-    assert_equal 'Unexpected character = in "1 =! 2"', err.message
+    assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
 
-    err = assert_raise(SyntaxError) do
+    err = assert_raises(SyntaxError) do
       Liquid::Template.parse('{{%%%}}', :error_mode => :strict)
     end
-    assert_equal 'Unexpected character % in "{{%%%}}"', err.message
+    assert_equal 'Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message
   end
 
   def test_warnings
     template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', :error_mode => :warn)
     assert_equal 3, template.warnings.size
-    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].message
-    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].message
-    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
+    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
+    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
+    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
     assert_equal '', template.render
   end
 
+  def test_warning_line_numbers
+    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", :error_mode => :warn, :line_numbers => true)
+    assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
+    assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
+    assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
+    assert_equal 3, template.warnings.size
+    assert_equal [1,2,3], template.warnings.map(&:line_number)
+  end
+
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
   def test_exceptions_propagate
-    assert_raise Exception do
-      template = Liquid::Template.parse( ' {{ errors.exception }} '  )
+    assert_raises Exception do
+      template = Liquid::Template.parse('{{ errors.exception }}')
       template.render('errors' => ErrorDrop.new)
     end
   end
-end # ErrorHandlingTest
+end

data/test/integration/filter_test.rb

@@ -22,7 +22,7 @@ module SubstituteFilter
   end
 end
 
-class FiltersTest < Test::Unit::TestCase
+class FiltersTest < Minitest::Test
   include Liquid
 
   def setup
@@ -107,15 +107,15 @@ class FiltersTest < Test::Unit::TestCase
   end
 end
 
-class FiltersInTemplate < Test::Unit::TestCase
+class FiltersInTemplate < Minitest::Test
   include Liquid
 
   def test_local_global
-    Template.register_filter(MoneyFilter)
-
-    assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
+    with_global_filter(MoneyFilter) do
+      assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
+    end
   end
 
   def test_local_filter_with_deprecated_syntax

data/test/integration/hash_ordering_test.rb

@@ -12,14 +12,12 @@ module CanadianMoneyFilter
   end
 end
 
-class HashOrderingTest < Test::Unit::TestCase
+class HashOrderingTest < Minitest::Test
   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
-
+  def test_global_register_order
+    with_global_filter(MoneyFilter, CanadianMoneyFilter) do
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
+    end
+  end
 end

data/test/integration/output_test.rb

@@ -27,7 +27,7 @@ module FunnyFilter
 
 end
 
-class OutputTest < Test::Unit::TestCase
+class OutputTest < Minitest::Test
   include Liquid
 
   def setup

data/test/integration/parsing_quirks_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ParsingQuirksTest < Test::Unit::TestCase
+class ParsingQuirksTest < Minitest::Test
   include Liquid
 
   def test_parsing_css
@@ -9,30 +9,28 @@ class ParsingQuirksTest < Test::Unit::TestCase
   end
 
   def test_raise_on_single_close_bracet
-    assert_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       Template.parse("text {{method} oh nos!")
     end
   end
 
   def test_raise_on_label_and_no_close_bracets
-    assert_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       Template.parse("TEST {{ ")
     end
   end
 
   def test_raise_on_label_and_no_close_bracets_percent
-    assert_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       Template.parse("TEST {% ")
     end
   end
 
   def test_error_on_empty_filter
-    assert_nothing_raised do
-      Template.parse("{{test}}")
-      Template.parse("{{|test}}")
-    end
+    assert Template.parse("{{test}}")
+    assert Template.parse("{{|test}}")
     with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         Template.parse("{{test |a|b|}}")
       end
     end
@@ -40,7 +38,7 @@ class ParsingQuirksTest < Test::Unit::TestCase
 
   def test_meaningless_parens_error
     with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
@@ -49,11 +47,11 @@ class ParsingQuirksTest < Test::Unit::TestCase
 
   def test_unexpected_characters_syntax_error
     with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         markup = "true && false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         markup = "false || true"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
@@ -61,11 +59,9 @@ class ParsingQuirksTest < Test::Unit::TestCase
   end
 
   def test_no_error_on_lax_empty_filter
-    assert_nothing_raised do
-      Template.parse("{{test |a|b|}}", :error_mode => :lax)
-      Template.parse("{{test}}", :error_mode => :lax)
-      Template.parse("{{|test|}}", :error_mode => :lax)
-    end
+    assert Template.parse("{{test |a|b|}}", :error_mode => :lax)
+    assert Template.parse("{{test}}", :error_mode => :lax)
+    assert Template.parse("{{|test|}}", :error_mode => :lax)
   end
 
   def test_meaningless_parens_lax
@@ -86,9 +82,35 @@ class ParsingQuirksTest < Test::Unit::TestCase
   end
 
   def test_raise_on_invalid_tag_delimiter
-    assert_raise(Liquid::SyntaxError) do
+    assert_raises(Liquid::SyntaxError) do
       Template.new.parse('{% end %}')
     end
   end
 
+  def test_unanchored_filter_arguments
+    with_error_mode(:lax) do
+      assert_template_result('hi',"{{ 'hi there' | split$$$:' ' | first }}")
+
+      assert_template_result('x', "{{ 'X' | downcase) }}")
+
+      # After the messed up quotes a filter without parameters (reverse) should work
+      # but one with parameters (remove) shouldn't be detected.
+      assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
+      assert_template_result('hi ',  "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
+    end
+  end
+
+  def test_invalid_variables_work
+    with_error_mode(:lax) do
+      assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
+      assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
+    end
+  end
+
+  def test_extra_dots_in_ranges
+    with_error_mode(:lax) do
+      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
+    end
+  end
+
 end # ParsingQuirksTest