liquid 4.0.1 → 5.4.0

data/test/integration/tags/statements_test.rb

@@ -1,111 +0,0 @@
-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/integration/tags/table_row_test.rb

@@ -1,64 +0,0 @@
-require 'test_helper'
-
-class TableRowTest < Minitest::Test
-  include Liquid
-
-  class ArrayDrop < Liquid::Drop
-    include Enumerable
-
-    def initialize(array)
-      @array = array
-    end
-
-    def each(&block)
-      @array.each(&block)
-    end
-  end
-
-  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 %}',
-      'numbers' => [1, 2, 3, 4, 5, 6])
-
-    assert_template_result("<tr class=\"row1\">\n</tr>\n",
-      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-      'numbers' => [])
-  end
-
-  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_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])
-  end
-
-  def test_quoted_fragment
-    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 collections.frontpage cols:3%} {{n}} {% endtablerow %}",
-      'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
-    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 collections['frontpage'] cols:3%} {{n}} {% endtablerow %}",
-      'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
-  end
-
-  def test_enumerable_drop
-    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 %}',
-      'numbers' => ArrayDrop.new([1, 2, 3, 4, 5, 6]))
-  end
-
-  def test_offset_and_limit
-    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 offset:1 limit:6%} {{n}} {% endtablerow %}',
-      'numbers' => [0, 1, 2, 3, 4, 5, 6, 7])
-  end
-
-  def test_blank_string_not_iterable
-    assert_template_result("<tr class=\"row1\">\n</tr>\n", "{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}", 'characters' => '')
-  end
-end

data/test/integration/tags/unless_else_tag_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-class UnlessElseTagTest < Minitest::Test
-  include Liquid
-
-  def test_unless
-    assert_template_result('  ', ' {% unless true %} this text should not go into the output {% endunless %} ')
-    assert_template_result('  this text should go into the output  ',
-      ' {% unless false %} this text should go into the output {% endunless %} ')
-    assert_template_result('  you rock ?', '{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
-  end
-
-  def test_unless_else
-    assert_template_result(' YES ', '{% unless true %} NO {% else %} YES {% endunless %}')
-    assert_template_result(' YES ', '{% unless false %} YES {% else %} NO {% endunless %}')
-    assert_template_result(' YES ', '{% unless "foo" %} NO {% else %} YES {% endunless %}')
-  end
-
-  def test_unless_in_loop
-    assert_template_result '23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', 'choices' => [1, nil, false]
-  end
-
-  def test_unless_else_in_loop
-    assert_template_result ' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false]
-  end
-end # UnlessElseTest

data/test/integration/template_test.rb

@@ -1,332 +0,0 @@
-require 'test_helper'
-require 'timeout'
-
-class TemplateContextDrop < Liquid::Drop
-  def liquid_method_missing(method)
-    method
-  end
-
-  def foo
-    'fizzbuzz'
-  end
-
-  def baz
-    @context.registers['lulz']
-  end
-end
-
-class SomethingWithLength < Liquid::Drop
-  def length
-    nil
-  end
-end
-
-class ErroneousDrop < Liquid::Drop
-  def bad_method
-    raise 'ruby error in drop'
-  end
-end
-
-class DropWithUndefinedMethod < Liquid::Drop
-  def foo
-    'foo'
-  end
-end
-
-class TemplateTest < Minitest::Test
-  include Liquid
-
-  def test_instance_assigns_persist_on_same_template_object_between_parses
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
-  end
-
-  def test_warnings_is_not_exponential_time
-    str = "false"
-    100.times do
-      str = "{% if true %}true{% else %}#{str}{% endif %}"
-    end
-
-    t = Template.parse(str)
-    assert_equal [], Timeout.timeout(1) { t.warnings }
-  end
-
-  def test_instance_assigns_persist_on_same_template_parsing_between_renders
-    t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
-    assert_equal 'foo', t.render!
-    assert_equal 'foofoo', t.render!
-  end
-
-  def test_custom_assigns_do_not_persist_on_same_template
-    t = Template.new
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
-    assert_equal '', t.parse("{{ foo }}").render!
-  end
-
-  def test_custom_assigns_squash_instance_assigns
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
-  end
-
-  def test_persistent_assigns_squash_instance_assigns
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    t.assigns['foo'] = 'from persistent assigns'
-    assert_equal 'from persistent assigns', t.parse("{{ foo }}").render!
-  end
-
-  def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
-    t = Template.new
-    t.assigns['number'] = -> { @global ||= 0; @global += 1 }
-    assert_equal '1', t.parse("{{number}}").render!
-    assert_equal '1', t.parse("{{number}}").render!
-    assert_equal '1', t.render!
-    @global = nil
-  end
-
-  def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
-    t = Template.new
-    assigns = { 'number' => -> { @global ||= 0; @global += 1 } }
-    assert_equal '1', t.parse("{{number}}").render!(assigns)
-    assert_equal '1', t.parse("{{number}}").render!(assigns)
-    assert_equal '1', t.render!(assigns)
-    @global = nil
-  end
-
-  def test_resource_limits_works_with_custom_length_method
-    t = Template.parse("{% assign foo = bar %}")
-    t.resource_limits.render_length_limit = 42
-    assert_equal "", t.render!("bar" => SomethingWithLength.new)
-  end
-
-  def test_resource_limits_render_length
-    t = Template.parse("0123456789")
-    t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
-
-    t.resource_limits.render_length_limit = 10
-    assert_equal "0123456789", t.render!
-    refute_nil t.resource_limits.render_length
-  end
-
-  def test_resource_limits_render_score
-    t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
-    t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
-
-    t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
-    t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
-
-    t.resource_limits.render_score_limit = 200
-    assert_equal (" foo " * 100), t.render!
-    refute_nil t.resource_limits.render_score
-  end
-
-  def test_resource_limits_assign_score
-    t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
-    t.resource_limits.assign_score_limit = 1
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
-
-    t.resource_limits.assign_score_limit = 2
-    assert_equal "", t.render!
-    refute_nil t.resource_limits.assign_score
-  end
-
-  def test_resource_limits_assign_score_nested
-    t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
-
-    t.resource_limits.assign_score_limit = 3
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
-
-    t.resource_limits.assign_score_limit = 5
-    assert_equal "", t.render!
-  end
-
-  def test_resource_limits_aborts_rendering_after_first_error
-    t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
-    t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
-  end
-
-  def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
-    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
-    t.render!
-    assert t.resource_limits.assign_score > 0
-    assert t.resource_limits.render_score > 0
-    assert t.resource_limits.render_length > 0
-  end
-
-  def test_render_length_persists_between_blocks
-    t = Template.parse("{% if true %}aaaa{% endif %}")
-    t.resource_limits.render_length_limit = 7
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    t.resource_limits.render_length_limit = 8
-    assert_equal "aaaa", t.render
-
-    t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
-    t.resource_limits.render_length_limit = 13
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    t.resource_limits.render_length_limit = 14
-    assert_equal "aaaabbb", t.render
-
-    t = Template.parse("{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}")
-    t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    t.resource_limits.render_length_limit = 11
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    t.resource_limits.render_length_limit = 12
-    assert_equal "ababab", t.render
-  end
-
-  def test_default_resource_limits_unaffected_by_render_with_context
-    context = Context.new
-    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
-    t.render!(context)
-    assert context.resource_limits.assign_score > 0
-    assert context.resource_limits.render_score > 0
-    assert context.resource_limits.render_length > 0
-  end
-
-  def test_can_use_drop_as_context
-    t = Template.new
-    t.registers['lulz'] = 'haha'
-    drop = TemplateContextDrop.new
-    assert_equal 'fizzbuzz', t.parse('{{foo}}').render!(drop)
-    assert_equal 'bar', t.parse('{{bar}}').render!(drop)
-    assert_equal 'haha', t.parse("{{baz}}").render!(drop)
-  end
-
-  def test_render_bang_force_rethrow_errors_on_passed_context
-    context = Context.new({ 'drop' => ErroneousDrop.new })
-    t = Template.new.parse('{{ drop.bad_method }}')
-
-    e = assert_raises RuntimeError do
-      t.render!(context)
-    end
-    assert_equal 'ruby error in drop', e.message
-  end
-
-  def test_exception_renderer_that_returns_string
-    exception = nil
-    handler = ->(e) { exception = e; '<!-- error -->' }
-
-    output = Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: handler)
-
-    assert exception.is_a?(Liquid::ZeroDivisionError)
-    assert_equal '<!-- error -->', output
-  end
-
-  def test_exception_renderer_that_raises
-    exception = nil
-    assert_raises(Liquid::ZeroDivisionError) do
-      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: ->(e) { exception = e; raise })
-    end
-    assert exception.is_a?(Liquid::ZeroDivisionError)
-  end
-
-  def test_global_filter_option_on_render
-    global_filter_proc = ->(output) { "#{output} filtered" }
-    rendered_template = Template.parse("{{name}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
-
-    assert_equal 'bob filtered', rendered_template
-  end
-
-  def test_global_filter_option_when_native_filters_exist
-    global_filter_proc = ->(output) { "#{output} filtered" }
-    rendered_template = Template.parse("{{name | upcase}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
-
-    assert_equal 'BOB filtered', rendered_template
-  end
-
-  def test_undefined_variables
-    t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
-    result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })
-
-    assert_equal '33  32  ', result
-    assert_equal 3, t.errors.count
-    assert_instance_of Liquid::UndefinedVariable, t.errors[0]
-    assert_equal 'Liquid error: undefined variable y', t.errors[0].message
-    assert_instance_of Liquid::UndefinedVariable, t.errors[1]
-    assert_equal 'Liquid error: undefined variable b', t.errors[1].message
-    assert_instance_of Liquid::UndefinedVariable, t.errors[2]
-    assert_equal 'Liquid error: undefined variable d', t.errors[2].message
-  end
-
-  def test_nil_value_does_not_raise
-    Liquid::Template.error_mode = :strict
-    t = Template.parse("some{{x}}thing")
-    result = t.render!({ 'x' => nil }, strict_variables: true)
-
-    assert_equal 0, t.errors.count
-    assert_equal 'something', result
-  end
-
-  def test_undefined_variables_raise
-    t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
-
-    assert_raises UndefinedVariable do
-      t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })
-    end
-  end
-
-  def test_undefined_drop_methods
-    d = DropWithUndefinedMethod.new
-    t = Template.new.parse('{{ foo }} {{ woot }}')
-    result = t.render(d, { strict_variables: true })
-
-    assert_equal 'foo ', result
-    assert_equal 1, t.errors.count
-    assert_instance_of Liquid::UndefinedDropMethod, t.errors[0]
-  end
-
-  def test_undefined_drop_methods_raise
-    d = DropWithUndefinedMethod.new
-    t = Template.new.parse('{{ foo }} {{ woot }}')
-
-    assert_raises UndefinedDropMethod do
-      t.render!(d, { strict_variables: true })
-    end
-  end
-
-  def test_undefined_filters
-    t = Template.parse("{{a}} {{x | upcase | somefilter1 | somefilter2 | somefilter3}}")
-    filters = Module.new do
-      def somefilter3(v)
-        "-#{v}-"
-      end
-    end
-    result = t.render({ 'a' => 123, 'x' => 'foo' }, { filters: [filters], strict_filters: true })
-
-    assert_equal '123 ', result
-    assert_equal 1, t.errors.count
-    assert_instance_of Liquid::UndefinedFilter, t.errors[0]
-    assert_equal 'Liquid error: undefined filter somefilter1', t.errors[0].message
-  end
-
-  def test_undefined_filters_raise
-    t = Template.parse("{{x | somefilter1 | upcase | somefilter2}}")
-
-    assert_raises UndefinedFilter do
-      t.render!({ 'x' => 'foo' }, { strict_filters: true })
-    end
-  end
-
-  def test_using_range_literal_works_as_expected
-    t = Template.parse("{% assign foo = (x..y) %}{{ foo }}")
-    result = t.render({ 'x' => 1, 'y' => 5 })
-    assert_equal '1..5', result
-
-    t = Template.parse("{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}")
-    result = t.render({ 'x' => 1, 'y' => 5 })
-    assert_equal '12345', result
-  end
-end