liquid 2.6.3 → 3.0.0

data/test/integration/tags/include_tag_test.rb

@@ -0,0 +1,234 @@
+require 'test_helper'
+
+class TestFileSystem
+  def read_template_file(template_path, context)
+    case template_path
+    when "product"
+      "Product: {{ product.title }} "
+
+    when "locale_variables"
+      "Locale: {{echo1}} {{echo2}}"
+
+    when "variant"
+      "Variant: {{ variant.title }}"
+
+    when "nested_template"
+      "{% include 'header' %} {% include 'body' %} {% include 'footer' %}"
+
+    when "body"
+      "body {% include 'body_detail' %}"
+
+    when "nested_product_template"
+      "Product: {{ nested_product_template.title }} {%include 'details'%} "
+
+    when "recursively_nested_template"
+      "-{% include 'recursively_nested_template' %}"
+
+    when "pick_a_source"
+      "from TestFileSystem"
+
+    when 'assignments'
+      "{% assign foo = 'bar' %}"
+
+    else
+      template_path
+    end
+  end
+end
+
+class OtherFileSystem
+  def read_template_file(template_path, context)
+    'from OtherFileSystem'
+  end
+end
+
+class CountingFileSystem
+  attr_reader :count
+  def read_template_file(template_path, context)
+    @count ||= 0
+    @count += 1
+    'from CountingFileSystem'
+  end
+end
+
+class CustomInclude < Liquid::Tag
+  Syntax = /(#{Liquid::QuotedFragment}+)(\s+(?:with|for)\s+(#{Liquid::QuotedFragment}+))?/o
+
+  def initialize(tag_name, markup, tokens)
+    markup =~ Syntax
+    @template_name = $1
+    super
+  end
+
+  def parse(tokens)
+  end
+
+  def render(context)
+    @template_name[1..-2]
+  end
+end
+
+class IncludeTagTest < Minitest::Test
+  include Liquid
+
+  def setup
+    Liquid::Template.file_system = TestFileSystem.new
+  end
+
+  def test_include_tag_looks_for_file_system_in_registers_first
+    assert_equal 'from OtherFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => OtherFileSystem.new})
+  end
+
+
+  def test_include_tag_with
+    assert_template_result "Product: Draft 151cm ",
+      "{% include 'product' with products[0] %}", "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]
+  end
+
+  def test_include_tag_with_default_name
+    assert_template_result "Product: Draft 151cm ",
+      "{% include 'product' %}", "product" => {'title' => 'Draft 151cm'}
+  end
+
+  def test_include_tag_for
+    assert_template_result "Product: Draft 151cm Product: Element 155cm ",
+      "{% include 'product' for products %}", "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]
+  end
+
+  def test_include_tag_with_local_variables
+    assert_template_result "Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}"
+  end
+
+  def test_include_tag_with_multiple_local_variables
+    assert_template_result "Locale: test123 test321",
+      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}"
+  end
+
+  def test_include_tag_with_multiple_local_variables_from_context
+    assert_template_result "Locale: test123 test321",
+      "{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}",
+      'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'}
+  end
+
+  def test_included_templates_assigns_variables
+    assert_template_result "bar", "{% include 'assignments' %}{{ foo }}"
+  end
+
+  def test_nested_include_tag
+    assert_template_result "body body_detail", "{% include 'body' %}"
+
+    assert_template_result "header body body_detail footer", "{% include 'nested_template' %}"
+  end
+
+  def test_nested_include_with_variable
+    assert_template_result "Product: Draft 151cm details ",
+      "{% include 'nested_product_template' with product %}", "product" => {"title" => 'Draft 151cm'}
+
+    assert_template_result "Product: Draft 151cm details Product: Element 155cm details ",
+      "{% include 'nested_product_template' for products %}", "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, context)
+        "-{% include 'loop' %}"
+      end
+    end
+
+    Liquid::Template.file_system = infinite_file_system.new
+
+    assert_raises(Liquid::StackLevelError, SystemStackError) do
+      Template.parse("{% include 'loop' %}").render!
+    end
+
+  end
+
+  def test_backwards_compatability_support_for_overridden_read_template_file
+    infinite_file_system = Class.new do
+      def read_template_file(template_path) # testing only one argument here.
+        "- hi mom"
+      end
+    end
+
+    Liquid::Template.file_system = infinite_file_system.new
+
+    Template.parse("{% include 'hi_mom' %}").render!
+  end
+
+  def test_dynamically_choosen_template
+    assert_template_result "Test123", "{% include template %}", "template" => 'Test123'
+    assert_template_result "Test321", "{% include template %}", "template" => 'Test321'
+
+    assert_template_result "Product: Draft 151cm ", "{% include template for product %}",
+      "template" => 'product', 'product' => { 'title' => 'Draft 151cm'}
+  end
+
+  def test_include_tag_caches_second_read_of_same_partial
+    file_system = CountingFileSystem.new
+    assert_equal 'from CountingFileSystemfrom CountingFileSystem',
+      Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
+    assert_equal 1, file_system.count
+  end
+
+  def test_include_tag_doesnt_cache_partials_across_renders
+    file_system = CountingFileSystem.new
+    assert_equal 'from CountingFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
+    assert_equal 1, file_system.count
+
+    assert_equal 'from CountingFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
+    assert_equal 2, file_system.count
+  end
+
+  def test_include_tag_within_if_statement
+    assert_template_result "foo_if_true", "{% if true %}{% include 'foo_if_true' %}{% endif %}"
+  end
+
+  def test_custom_include_tag
+    original_tag = Liquid::Template.tags['include']
+    Liquid::Template.tags['include'] = CustomInclude
+    begin
+      assert_equal "custom_foo",
+        Template.parse("{% include 'custom_foo' %}").render!
+    ensure
+      Liquid::Template.tags['include'] = original_tag
+    end
+  end
+
+  def test_custom_include_tag_within_if_statement
+    original_tag = Liquid::Template.tags['include']
+    Liquid::Template.tags['include'] = CustomInclude
+    begin
+      assert_equal "custom_foo_if_true",
+        Template.parse("{% if true %}{% include 'custom_foo_if_true' %}{% endif %}").render!
+    ensure
+      Liquid::Template.tags['include'] = original_tag
+    end
+  end
+
+  def test_does_not_add_error_in_strict_mode_for_missing_variable
+    Liquid::Template.file_system = TestFileSystem.new
+
+    a = Liquid::Template.parse(' {% include "nested_template" %}')
+    a.render!
+    assert_empty a.errors
+  end
+
+  def test_passing_options_to_included_templates
+    assert_raises(Liquid::SyntaxError) do
+      Template.parse("{% include template %}", error_mode: :strict).render!("template" => '{{ "X" || downcase }}')
+    end
+    with_error_mode(:lax) do
+      assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true).render!("template" => '{{ "X" || downcase }}')
+    end
+    assert_raises(Liquid::SyntaxError) do
+      Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale]).render!("template" => '{{ "X" || downcase }}')
+    end
+    with_error_mode(:lax) do
+      assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode]).render!("template" => '{{ "X" || downcase }}')
+    end
+  end
+end # IncludeTagTest

data/test/{liquid → integration}/tags/increment_tag_test.rb

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

data/test/{liquid → integration}/tags/raw_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class RawTagTest < Test::Unit::TestCase
+class RawTagTest < Minitest::Test
   include Liquid
 
   def test_tag_in_raw
@@ -20,5 +20,6 @@ class RawTagTest < Test::Unit::TestCase
     assert_template_result ' Foobar {% invalid {% {% endraw ', '{% raw %} Foobar {% invalid {% {% endraw {% endraw %}'
     assert_template_result ' Foobar {% {% {% ', '{% raw %} Foobar {% {% {% {% endraw %}'
     assert_template_result ' test {% raw %} {% endraw %}', '{% raw %} test {% raw %} {% {% endraw %}endraw %}'
+    assert_template_result ' Foobar {{ invalid 1', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}'
   end
 end

data/test/{liquid → integration}/tags/standard_tag_test.rb

@@ -1,14 +1,8 @@
 require 'test_helper'
 
-class StandardTagTest < Test::Unit::TestCase
+class StandardTagTest < Minitest::Test
   include Liquid
 
-  def test_tag
-    tag = Tag.new('tag', [], [])
-    assert_equal 'liquid::tag', tag.name
-    assert_equal '', tag.render(Context.new)
-  end
-
   def test_no_transform
     assert_template_result('this text should come out of the template without change...',
                            'this text should come out of the template without change...')
@@ -33,6 +27,13 @@ class StandardTagTest < Test::Unit::TestCase
     assert_template_result('','{% comment %}{% endcomment %}')
     assert_template_result('','{%comment%}comment{%endcomment%}')
     assert_template_result('','{% comment %}comment{% endcomment %}')
+    assert_template_result('','{% comment %} 1 {% comment %} 2 {% endcomment %} 3 {% endcomment %}')
+
+    assert_template_result('','{%comment%}{%blabla%}{%endcomment%}')
+    assert_template_result('','{% comment %}{% blabla %}{% endcomment %}')
+    assert_template_result('','{%comment%}{% endif %}{%endcomment%}')
+    assert_template_result('','{% comment %}{% endwhatever %}{% endcomment %}')
+    assert_template_result('','{% comment %}{% raw %} {{%%%%}}  }} { {% endcomment %} {% comment {% endraw %} {% endcomment %}')
 
     assert_template_result('foobar','foo{%comment%}comment{%endcomment%}bar')
     assert_template_result('foobar','foo{% comment %}comment{% endcomment %}bar')
@@ -47,16 +48,9 @@ class StandardTagTest < Test::Unit::TestCase
                                      {%endcomment%}bar')
   end
 
-  def test_assign
-    assigns = {'var' => 'content' }
-    assert_template_result('var2:  var2:content', 'var2:{{var2}} {%assign var2 = var%} var2:{{var2}}', assigns)
-
-  end
-
   def test_hyphenated_assign
     assigns = {'a-b' => '1' }
     assert_template_result('a-b:1 a-b:2', 'a-b:{{a-b}} {%assign a-b = 2 %}a-b:{{a-b}}', assigns)
-
   end
 
   def test_assign_with_colon_and_spaces
@@ -72,7 +66,7 @@ class StandardTagTest < Test::Unit::TestCase
   end
 
   def test_capture_detects_bad_syntax
-    assert_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       assert_template_result('content foo content foo ',
                              '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
                              {'var' => 'content' })
@@ -180,11 +174,11 @@ class StandardTagTest < Test::Unit::TestCase
     # Example from the shopify forums
     code = %q({% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }})
     template = Liquid::Template.parse(code)
-    assert_equal "menswear",   template.render("collection" => {'handle' => 'menswear-jackets'})
-    assert_equal "menswear",   template.render("collection" => {'handle' => 'menswear-t-shirts'})
-    assert_equal "womenswear", template.render("collection" => {'handle' => 'x'})
-    assert_equal "womenswear", template.render("collection" => {'handle' => 'y'})
-    assert_equal "womenswear", template.render("collection" => {'handle' => 'z'})
+    assert_equal "menswear",   template.render!("collection" => {'handle' => 'menswear-jackets'})
+    assert_equal "menswear",   template.render!("collection" => {'handle' => 'menswear-t-shirts'})
+    assert_equal "womenswear", template.render!("collection" => {'handle' => 'x'})
+    assert_equal "womenswear", template.render!("collection" => {'handle' => 'y'})
+    assert_equal "womenswear", template.render!("collection" => {'handle' => 'z'})
   end
 
   def test_case_when_or
@@ -218,24 +212,28 @@ class StandardTagTest < Test::Unit::TestCase
   end
 
   def test_assign
-    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}'  ).render
+    assert_template_result 'variable', '{% assign a = "variable"%}{{a}}'
+  end
+
+  def test_assign_unassigned
+    assigns = { 'var' => 'content' }
+    assert_template_result('var2:  var2:content', 'var2:{{var2}} {%assign var2 = var%} var2:{{var2}}', assigns)
   end
 
   def test_assign_an_empty_string
-    assert_equal '', Liquid::Template.parse( '{% assign a = ""%}{{a}}'  ).render
+    assert_template_result '', '{% assign a = ""%}{{a}}'
   end
 
   def test_assign_is_global
-    assert_equal 'variable',
-                 Liquid::Template.parse( '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}'  ).render
+    assert_template_result 'variable', '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}'
   end
 
   def test_case_detects_bad_syntax
-    assert_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       assert_template_result('',  '{% case false %}{% when %}true{% endcase %}', {})
     end
 
-    assert_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       assert_template_result('',  '{% case false %}{% huh %}true{% endcase %}', {})
     end
 
@@ -292,4 +290,8 @@ class StandardTagTest < Test::Unit::TestCase
     assigns = {'array' => [ 1, 1, 1, 1] }
     assert_template_result('1','{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}',assigns)
   end
+
+  def test_multiline_tag
+    assert_template_result '0 1 2 3', "0{%\nfor i in (1..3)\n%} {{\ni\n}}{%\nendfor\n%}"
+  end
 end # StandardTagTest

data/test/integration/tags/statements_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class StatementsTest < Minitest::Test
+  include Liquid
+
+  def test_true_eql_true
+    text = ' {% if true == true %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_true_not_eql_true
+    text = ' {% if true != true %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text
+  end
+
+  def test_true_lq_true
+    text = ' {% if 0 > 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text
+  end
+
+  def test_one_lq_zero
+    text = ' {% if 1 > 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_zero_lq_one
+    text = ' {% if 0 < 1 %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_zero_lq_or_equal_one
+    text = ' {% if 0 <= 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_zero_lq_or_equal_one_involving_nil
+    text = ' {% if null <= 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text
+
+
+    text = ' {% if 0 <= null %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text
+  end
+
+  def test_zero_lqq_or_equal_one
+    text = ' {% if 0 >= 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_strings
+    text = " {% if 'test' == 'test' %} true {% else %} false {% endif %} "
+    assert_template_result '  true  ', text
+  end
+
+  def test_strings_not_equal
+    text = " {% if 'test' != 'test' %} true {% else %} false {% endif %} "
+    assert_template_result '  false  ', text
+  end
+
+  def test_var_strings_equal
+    text = ' {% if var == "hello there!" %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => 'hello there!'
+  end
+
+  def test_var_strings_are_not_equal
+    text = ' {% if "hello there!" == var %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => 'hello there!'
+  end
+
+  def test_var_and_long_string_are_equal
+    text = " {% if var == 'hello there!' %} true {% else %} false {% endif %} "
+    assert_template_result '  true  ', text, 'var' => 'hello there!'
+  end
+
+
+  def test_var_and_long_string_are_equal_backwards
+    text = " {% if 'hello there!' == var %} true {% else %} false {% endif %} "
+    assert_template_result '  true  ', text, 'var' => 'hello there!'
+  end
+
+  #def test_is_nil
+  #  text = %| {% if var != nil %} true {% else %} false {% end %} |
+  #  @template.assigns = { 'var' => 'hello there!'}
+  #  expected = %|  true  |
+  #  assert_equal expected, @template.parse(text)
+  #end
+
+  def test_is_collection_empty
+    text = ' {% if array == empty %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'array' => []
+  end
+
+  def test_is_not_collection_empty
+    text = ' {% if array == empty %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text, 'array' => [1,2,3]
+  end
+
+  def test_nil
+    text = ' {% if var == nil %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => nil
+
+    text = ' {% if var == null %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => nil
+  end
+
+  def test_not_nil
+    text = ' {% if var != nil %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => 1
+
+    text = ' {% if var != null %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => 1
+  end
+end # StatementsTest

data/test/{liquid/tags/html_tag_test.rb → integration/tags/table_row_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class HtmlTagTest < Test::Unit::TestCase
+class TableRowTest < Minitest::Test
   include Liquid
 
   class ArrayDrop < Liquid::Drop
@@ -15,7 +15,7 @@ class HtmlTagTest < Test::Unit::TestCase
     end
   end
 
-  def test_html_table
+  def test_table_row
 
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
                            '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
@@ -26,14 +26,14 @@ class HtmlTagTest < Test::Unit::TestCase
                            'numbers' => [])
   end
 
-  def test_html_table_with_different_cols
+  def test_table_row_with_different_cols
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td><td class=\"col4\"> 4 </td><td class=\"col5\"> 5 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 6 </td></tr>\n",
                            '{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
                            'numbers' => [1,2,3,4,5,6])
 
   end
 
-  def test_html_col_counter
+  def test_table_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])
@@ -60,4 +60,4 @@ class HtmlTagTest < Test::Unit::TestCase
                            '{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
                            'numbers' => [0,1,2,3,4,5,6,7])
   end
-end # HtmlTagTest
+end

data/test/{liquid → integration}/tags/unless_else_tag_test.rb

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