liquid 5.1.0 → 5.4.0

data/test/integration/filter_test.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module MoneyFilter
-  def money(input)
-    format(' %d$ ', input)
-  end
-
-  def money_with_underscore(input)
-    format(' %d$ ', input)
-  end
-end
-
-module CanadianMoneyFilter
-  def money(input)
-    format(' %d$ CAD ', input)
-  end
-end
-
-module SubstituteFilter
-  def substitute(input, params = {})
-    input.gsub(/%\{(\w+)\}/) { |_match| params[Regexp.last_match(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
-
-  def test_liquid_argument_error
-    source = "{{ '' | size: 'too many args' }}"
-    exc = assert_raises(Liquid::ArgumentError) do
-      Template.parse(source).render!
-    end
-    assert_match(/\ALiquid error: wrong number of arguments /, exc.message)
-    assert_equal(exc.message, Template.parse(source).render)
-  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,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class HashOrderingTest < Minitest::Test
-  module MoneyFilter
-    def money(input)
-      format(' %d$ ', input)
-    end
-  end
-
-  module CanadianMoneyFilter
-    def money(input)
-      format(' %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,125 +0,0 @@
-# frozen_string_literal: true
-
-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,134 +0,0 @@
-# frozen_string_literal: true
-
-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_blank_variable_markup
-    assert_template_result('', "{{}}")
-  end
-
-  def test_lookup_on_var_with_literal_name
-    assigns = { "blank" => { "x" => "result" } }
-    assert_template_result('result', "{{ blank.x }}", assigns)
-    assert_template_result('result', "{{ blank['x'] }}", assigns)
-  end
-
-  def test_contains_in_id
-    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
-  end
-end # ParsingQuirksTest

data/test/integration/profiler_test.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ProfilerTest < 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_render_tag
-    t = Template.parse("{% render 'a_template' %}", profile: true)
-    t.render!
-
-    render_children = t.profiler[0].children
-    render_children.each do |timing|
-      assert_equal('a_template', timing.partial)
-    end
-    assert_equal([1, 2], render_children.map(&: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
-
-  class SleepTag < Liquid::Tag
-    def initialize(tag_name, markup, parse_context)
-      super
-      @duration = Float(markup)
-    end
-
-    def render_to_output_buffer(_context, _output)
-      sleep(@duration)
-    end
-  end
-
-  def test_profiling_multiple_renders
-    with_custom_tag('sleep', SleepTag) do
-      context = Liquid::Context.new
-      t = Liquid::Template.parse("{% sleep 0.001 %}", profile: true)
-      context.template_name = 'index'
-      t.render!(context)
-      context.template_name = 'layout'
-      first_render_time = context.profiler.total_time
-      t.render!(context)
-
-      profiler = context.profiler
-      children = profiler.children
-      assert_operator(first_render_time, :>=, 0.001)
-      assert_operator(profiler.total_time, :>=, 0.001 + first_render_time)
-      assert_equal(["index", "layout"], children.map(&:template_name))
-      assert_equal([nil, nil], children.map(&:code))
-      assert_equal(profiler.total_time, children.map(&:total_time).reduce(&:+))
-    end
-  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
-
-  def test_profiling_supports_self_time
-    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
-    t.render!("collection" => ["one", "two"])
-    leaf = t.profiler[0].children[0]
-
-    assert_operator(leaf.self_time, :>, 0)
-  end
-
-  def test_profiling_supports_total_time
-    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true)
-    t.render!
-
-    assert_operator(t.profiler[0].total_time, :>, 0)
-  end
-end