liquid 4.0.1 → 5.4.0

data/test/integration/filter_test.rb

@@ -1,178 +0,0 @@
-require 'test_helper'
-
-module MoneyFilter
-  def money(input)
-    sprintf(' %d$ ', input)
-  end
-
-  def money_with_underscore(input)
-    sprintf(' %d$ ', input)
-  end
-end
-
-module CanadianMoneyFilter
-  def money(input)
-    sprintf(' %d$ CAD ', input)
-  end
-end
-
-module SubstituteFilter
-  def substitute(input, params = {})
-    input.gsub(/%\{(\w+)\}/) { |match| params[$1] }
-  end
-end
-
-class FiltersTest < Minitest::Test
-  include Liquid
-
-  module OverrideObjectMethodFilter
-    def tap(input)
-      "tap overridden"
-    end
-  end
-
-  def setup
-    @context = Context.new
-  end
-
-  def test_local_filter
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-
-    assert_equal ' 1000$ ', Template.parse("{{var | money}}").render(@context)
-  end
-
-  def test_underscore_in_filter_name
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-    assert_equal ' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context)
-  end
-
-  def test_second_filter_overwrites_first
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-    @context.add_filters(CanadianMoneyFilter)
-
-    assert_equal ' 1000$ CAD ', Template.parse("{{var | money}}").render(@context)
-  end
-
-  def test_size
-    @context['var'] = 'abcd'
-    @context.add_filters(MoneyFilter)
-
-    assert_equal '4', Template.parse("{{var | size}}").render(@context)
-  end
-
-  def test_join
-    @context['var'] = [1, 2, 3, 4]
-
-    assert_equal "1 2 3 4", Template.parse("{{var | join}}").render(@context)
-  end
-
-  def test_sort
-    @context['value'] = 3
-    @context['numbers'] = [2, 1, 4, 3]
-    @context['words'] = ['expected', 'as', 'alphabetic']
-    @context['arrays'] = ['flower', 'are']
-    @context['case_sensitive'] = ['sensitive', 'Expected', 'case']
-
-    assert_equal '1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context)
-    assert_equal 'alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context)
-    assert_equal '3', Template.parse("{{value | sort}}").render(@context)
-    assert_equal 'are flower', Template.parse("{{arrays | sort | join}}").render(@context)
-    assert_equal 'Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context)
-  end
-
-  def test_sort_natural
-    @context['words'] = ['case', 'Assert', 'Insensitive']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
-    @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
-
-    # Test strings
-    assert_equal 'Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context)
-
-    # Test hashes
-    assert_equal 'A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context)
-
-    # Test objects
-    assert_equal 'A b C', Template.parse("{{objects | sort_natural: 'a' | map: 'a' | join}}").render(@context)
-  end
-
-  def test_compact
-    @context['words'] = ['a', nil, 'b', nil, 'c']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
-    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
-
-    # Test strings
-    assert_equal 'a b c', Template.parse("{{words | compact | join}}").render(@context)
-
-    # Test hashes
-    assert_equal 'A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context)
-
-    # Test objects
-    assert_equal 'A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context)
-  end
-
-  def test_strip_html
-    @context['var'] = "<b>bla blub</a>"
-
-    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
-  end
-
-  def test_strip_html_ignore_comments_with_html
-    @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
-
-    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
-  end
-
-  def test_capitalize
-    @context['var'] = "blub"
-
-    assert_equal "Blub", Template.parse("{{ var | capitalize }}").render(@context)
-  end
-
-  def test_nonexistent_filter_is_ignored
-    @context['var'] = 1000
-
-    assert_equal '1000', Template.parse("{{ var | xyzzy }}").render(@context)
-  end
-
-  def test_filter_with_keyword_arguments
-    @context['surname'] = 'john'
-    @context['input'] = 'hello %{first_name}, %{last_name}'
-    @context.add_filters(SubstituteFilter)
-    output = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
-    assert_equal 'hello john, doe', output
-  end
-
-  def test_override_object_method_in_filter
-    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])
-
-    # tap still treated as a non-existent filter
-    assert_equal "1000", Template.parse("{{var | tap}}").render!({ 'var' => 1000 })
-  end
-end
-
-class FiltersInTemplate < Minitest::Test
-  include Liquid
-
-  def test_local_global
-    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
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
-  end
-end # FiltersTest
-
-class TestObject < Liquid::Drop
-  attr_accessor :a
-  def initialize(a)
-    @a = a
-  end
-end

data/test/integration/hash_ordering_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-class HashOrderingTest < Minitest::Test
-  module MoneyFilter
-    def money(input)
-      sprintf(' %d$ ', input)
-    end
-  end
-
-  module CanadianMoneyFilter
-    def money(input)
-      sprintf(' %d$ CAD ', input)
-    end
-  end
-
-  include Liquid
-
-  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

@@ -1,123 +0,0 @@
-require 'test_helper'
-
-module FunnyFilter
-  def make_funny(input)
-    'LOL'
-  end
-
-  def cite_funny(input)
-    "LOL: #{input}"
-  end
-
-  def add_smiley(input, smiley = ":-)")
-    "#{input} #{smiley}"
-  end
-
-  def add_tag(input, tag = "p", id = "foo")
-    %(<#{tag} id="#{id}">#{input}</#{tag}>)
-  end
-
-  def paragraph(input)
-    "<p>#{input}</p>"
-  end
-
-  def link_to(name, url)
-    %(<a href="#{url}">#{name}</a>)
-  end
-end
-
-class OutputTest < Minitest::Test
-  include Liquid
-
-  def setup
-    @assigns = {
-      'best_cars' => 'bmw',
-      'car' => { 'bmw' => 'good', 'gm' => 'bad' }
-    }
-  end
-
-  def test_variable
-    text = %( {{best_cars}} )
-
-    expected = %( bmw )
-    assert_equal expected, Template.parse(text).render!(@assigns)
-  end
-
-  def test_variable_traversing_with_two_brackets
-    text = %({{ site.data.menu[include.menu][include.locale] }})
-    assert_equal "it works!", Template.parse(text).render!(
-      "site" => { "data" => { "menu" => { "foo" => { "bar" => "it works!" } } } },
-      "include" => { "menu" => "foo", "locale" => "bar" }
-    )
-  end
-
-  def test_variable_traversing
-    text = %( {{car.bmw}} {{car.gm}} {{car.bmw}} )
-
-    expected = %( good bad good )
-    assert_equal expected, Template.parse(text).render!(@assigns)
-  end
-
-  def test_variable_piping
-    text = %( {{ car.gm | make_funny }} )
-    expected = %( LOL )
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
-  end
-
-  def test_variable_piping_with_input
-    text = %( {{ car.gm | cite_funny }} )
-    expected = %( LOL: bad )
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
-  end
-
-  def test_variable_piping_with_args
-    text = %! {{ car.gm | add_smiley : ':-(' }} !
-    expected = %| bad :-( |
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
-  end
-
-  def test_variable_piping_with_no_args
-    text = %( {{ car.gm | add_smiley }} )
-    expected = %| bad :-) |
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
-  end
-
-  def test_multiple_variable_piping_with_args
-    text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
-    expected = %| bad :-( :-( |
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
-  end
-
-  def test_variable_piping_with_multiple_args
-    text = %( {{ car.gm | add_tag : 'span', 'bar'}} )
-    expected = %( <span id="bar">bad</span> )
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
-  end
-
-  def test_variable_piping_with_variable_args
-    text = %( {{ car.gm | add_tag : 'span', car.bmw}} )
-    expected = %( <span id="good">bad</span> )
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
-  end
-
-  def test_multiple_pipings
-    text = %( {{ best_cars | cite_funny | paragraph }} )
-    expected = %( <p>LOL: bmw</p> )
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
-  end
-
-  def test_link_to
-    text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
-    expected = %( <a href="http://typo.leetsoft.com">Typo</a> )
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
-  end
-end # OutputTest

data/test/integration/parsing_quirks_test.rb

@@ -1,122 +0,0 @@
-require 'test_helper'
-
-class ParsingQuirksTest < Minitest::Test
-  include Liquid
-
-  def test_parsing_css
-    text = " div { font-weight: bold; } "
-    assert_equal text, Template.parse(text).render!
-  end
-
-  def test_raise_on_single_close_bracet
-    assert_raises(SyntaxError) do
-      Template.parse("text {{method} oh nos!")
-    end
-  end
-
-  def test_raise_on_label_and_no_close_bracets
-    assert_raises(SyntaxError) do
-      Template.parse("TEST {{ ")
-    end
-  end
-
-  def test_raise_on_label_and_no_close_bracets_percent
-    assert_raises(SyntaxError) do
-      Template.parse("TEST {% ")
-    end
-  end
-
-  def test_error_on_empty_filter
-    assert Template.parse("{{test}}")
-
-    with_error_mode(:lax) do
-      assert Template.parse("{{|test}}")
-    end
-
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) { Template.parse("{{|test}}") }
-      assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
-    end
-  end
-
-  def test_meaningless_parens_error
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-    end
-  end
-
-  def test_unexpected_characters_syntax_error
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        markup = "true && false"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-      assert_raises(SyntaxError) do
-        markup = "false || true"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-    end
-  end
-
-  def test_no_error_on_lax_empty_filter
-    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
-    with_error_mode(:lax) do
-      assigns = { 'b' => 'bar', 'c' => 'baz' }
-      markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
-    end
-  end
-
-  def test_unexpected_characters_silently_eat_logic_lax
-    with_error_mode(:lax) do
-      markup = "true && false"
-      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
-      markup = "false || true"
-      assert_template_result('', "{% if #{markup} %} YES {% endif %}")
-    end
-  end
-
-  def test_raise_on_invalid_tag_delimiter
-    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
-
-  def test_contains_in_id
-    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
-  end
-end # ParsingQuirksTest

data/test/integration/render_profiling_test.rb

@@ -1,154 +0,0 @@
-require 'test_helper'
-
-class RenderProfilingTest < Minitest::Test
-  include Liquid
-
-  class ProfilingFileSystem
-    def read_template_file(template_path)
-      "Rendering template {% assign template_name = '#{template_path}'%}\n{{ template_name }}"
-    end
-  end
-
-  def setup
-    Liquid::Template.file_system = ProfilingFileSystem.new
-  end
-
-  def test_template_allows_flagging_profiling
-    t = Template.parse("{{ 'a string' | upcase }}")
-    t.render!
-
-    assert_nil t.profiler
-  end
-
-  def test_parse_makes_available_simple_profiling
-    t = Template.parse("{{ 'a string' | upcase }}", profile: true)
-    t.render!
-
-    assert_equal 1, t.profiler.length
-
-    node = t.profiler[0]
-    assert_equal " 'a string' | upcase ", node.code
-  end
-
-  def test_render_ignores_raw_strings_when_profiling
-    t = Template.parse("This is raw string\nstuff\nNewline", profile: true)
-    t.render!
-
-    assert_equal 0, t.profiler.length
-  end
-
-  def test_profiling_includes_line_numbers_of_liquid_nodes
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", profile: true)
-    t.render!
-    assert_equal 2, t.profiler.length
-
-    # {{ 'a string' | upcase }}
-    assert_equal 1, t.profiler[0].line_number
-    # {{ increment test }}
-    assert_equal 2, t.profiler[1].line_number
-  end
-
-  def test_profiling_includes_line_numbers_of_included_partials
-    t = Template.parse("{% include 'a_template' %}", profile: true)
-    t.render!
-
-    included_children = t.profiler[0].children
-
-    # {% assign template_name = 'a_template' %}
-    assert_equal 1, included_children[0].line_number
-    # {{ template_name }}
-    assert_equal 2, included_children[1].line_number
-  end
-
-  def test_profiling_times_the_rendering_of_tokens
-    t = Template.parse("{% include 'a_template' %}", profile: true)
-    t.render!
-
-    node = t.profiler[0]
-    refute_nil node.render_time
-  end
-
-  def test_profiling_times_the_entire_render
-    t = Template.parse("{% include 'a_template' %}", profile: true)
-    t.render!
-
-    assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
-  end
-
-  def test_profiling_uses_include_to_mark_children
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", profile: true)
-    t.render!
-
-    include_node = t.profiler[1]
-    assert_equal 2, include_node.children.length
-  end
-
-  def test_profiling_marks_children_with_the_name_of_included_partial
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", profile: true)
-    t.render!
-
-    include_node = t.profiler[1]
-    include_node.children.each do |child|
-      assert_equal "a_template", child.partial
-    end
-  end
-
-  def test_profiling_supports_multiple_templates
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'b_template' %}", profile: true)
-    t.render!
-
-    a_template = t.profiler[1]
-    a_template.children.each do |child|
-      assert_equal "a_template", child.partial
-    end
-
-    b_template = t.profiler[2]
-    b_template.children.each do |child|
-      assert_equal "b_template", child.partial
-    end
-  end
-
-  def test_profiling_supports_rendering_the_same_partial_multiple_times
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'a_template' %}", profile: true)
-    t.render!
-
-    a_template1 = t.profiler[1]
-    a_template1.children.each do |child|
-      assert_equal "a_template", child.partial
-    end
-
-    a_template2 = t.profiler[2]
-    a_template2.children.each do |child|
-      assert_equal "a_template", child.partial
-    end
-  end
-
-  def test_can_iterate_over_each_profiling_entry
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", profile: true)
-    t.render!
-
-    timing_count = 0
-    t.profiler.each do |timing|
-      timing_count += 1
-    end
-
-    assert_equal 2, timing_count
-  end
-
-  def test_profiling_marks_children_of_if_blocks
-    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true)
-    t.render!
-
-    assert_equal 1, t.profiler.length
-    assert_equal 2, t.profiler[0].children.length
-  end
-
-  def test_profiling_marks_children_of_for_blocks
-    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
-    t.render!({ "collection" => ["one", "two"] })
-
-    assert_equal 1, t.profiler.length
-    # Will profile each invocation of the for block
-    assert_equal 2, t.profiler[0].children.length
-  end
-end

data/test/integration/security_test.rb

@@ -1,80 +0,0 @@
-require 'test_helper'
-
-module SecurityFilter
-  def add_one(input)
-    "#{input} + 1"
-  end
-end
-
-class SecurityTest < Minitest::Test
-  include Liquid
-
-  def setup
-    @assigns = {}
-  end
-
-  def test_no_instance_eval
-    text = %( {{ '1+1' | instance_eval }} )
-    expected = %( 1+1 )
-
-    assert_equal expected, Template.parse(text).render!(@assigns)
-  end
-
-  def test_no_existing_instance_eval
-    text = %( {{ '1+1' | __instance_eval__ }} )
-    expected = %( 1+1 )
-
-    assert_equal expected, Template.parse(text).render!(@assigns)
-  end
-
-  def test_no_instance_eval_after_mixing_in_new_filter
-    text = %( {{ '1+1' | instance_eval }} )
-    expected = %( 1+1 )
-
-    assert_equal expected, Template.parse(text).render!(@assigns)
-  end
-
-  def test_no_instance_eval_later_in_chain
-    text = %( {{ '1+1' | add_one | instance_eval }} )
-    expected = %( 1+1 + 1 )
-
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: SecurityFilter)
-  end
-
-  def test_does_not_add_filters_to_symbol_table
-    current_symbols = Symbol.all_symbols
-
-    test = %( {{ "some_string" | a_bad_filter }} )
-
-    template = Template.parse(test)
-    assert_equal [], (Symbol.all_symbols - current_symbols)
-
-    template.render!
-    assert_equal [], (Symbol.all_symbols - current_symbols)
-  end
-
-  def test_does_not_add_drop_methods_to_symbol_table
-    current_symbols = Symbol.all_symbols
-
-    assigns = { 'drop' => Drop.new }
-    assert_equal "", Template.parse("{{ drop.custom_method_1 }}", assigns).render!
-    assert_equal "", Template.parse("{{ drop.custom_method_2 }}", assigns).render!
-    assert_equal "", Template.parse("{{ drop.custom_method_3 }}", assigns).render!
-
-    assert_equal [], (Symbol.all_symbols - current_symbols)
-  end
-
-  def test_max_depth_nested_blocks_does_not_raise_exception
-    depth = Liquid::Block::MAX_DEPTH
-    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
-    assert_equal "rendered", Template.parse(code).render!
-  end
-
-  def test_more_than_max_depth_nested_blocks_raises_exception
-    depth = Liquid::Block::MAX_DEPTH + 1
-    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
-    assert_raises(Liquid::StackLevelError) do
-      Template.parse(code).render!
-    end
-  end
-end # SecurityTest