liquid 5.3.0 → 5.4.0

data/test/integration/drop_test.rb

@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ContextDrop < Liquid::Drop
-  def scopes
-    @context.scopes.size
-  end
-
-  def scopes_as_array
-    (1..@context.scopes.size).to_a
-  end
-
-  def loop_pos
-    @context['forloop.index']
-  end
-
-  def liquid_method_missing(method)
-    @context[method]
-  end
-end
-
-class ProductDrop < Liquid::Drop
-  class TextDrop < Liquid::Drop
-    def array
-      ['text1', 'text2']
-    end
-
-    def text
-      'text1'
-    end
-  end
-
-  class CatchallDrop < Liquid::Drop
-    def liquid_method_missing(method)
-      "catchall_method: #{method}"
-    end
-  end
-
-  def texts
-    TextDrop.new
-  end
-
-  def catchall
-    CatchallDrop.new
-  end
-
-  def context
-    ContextDrop.new
-  end
-
-  protected
-
-  def callmenot
-    "protected"
-  end
-end
-
-class EnumerableDrop < Liquid::Drop
-  def liquid_method_missing(method)
-    method
-  end
-
-  def size
-    3
-  end
-
-  def first
-    1
-  end
-
-  def count
-    3
-  end
-
-  def min
-    1
-  end
-
-  def max
-    3
-  end
-
-  def each
-    yield 1
-    yield 2
-    yield 3
-  end
-end
-
-class RealEnumerableDrop < Liquid::Drop
-  include Enumerable
-
-  def liquid_method_missing(method)
-    method
-  end
-
-  def each
-    yield 1
-    yield 2
-    yield 3
-  end
-end
-
-class DropsTest < Minitest::Test
-  include Liquid
-
-  def test_product_drop
-    tpl = Liquid::Template.parse('  ')
-    assert_equal('  ', tpl.render!('product' => ProductDrop.new))
-  end
-
-  def test_drop_does_only_respond_to_whitelisted_methods
-    assert_equal("", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new))
-  end
-
-  def test_drops_respond_to_to_liquid
-    assert_equal("text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new))
-    assert_equal("text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new))
-  end
-
-  def test_text_drop
-    output = Liquid::Template.parse(' {{ product.texts.text }} ').render!('product' => ProductDrop.new)
-    assert_equal(' text1 ', output)
-  end
-
-  def test_catchall_unknown_method
-    output = Liquid::Template.parse(' {{ product.catchall.unknown }} ').render!('product' => ProductDrop.new)
-    assert_equal(' catchall_method: unknown ', output)
-  end
-
-  def test_catchall_integer_argument_drop
-    output = Liquid::Template.parse(' {{ product.catchall[8] }} ').render!('product' => ProductDrop.new)
-    assert_equal(' catchall_method: 8 ', output)
-  end
-
-  def test_text_array_drop
-    output = Liquid::Template.parse('{% for text in product.texts.array %} {{text}} {% endfor %}').render!('product' => ProductDrop.new)
-    assert_equal(' text1  text2 ', output)
-  end
-
-  def test_context_drop
-    output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
-    assert_equal(' carrot ', output)
-  end
-
-  def test_context_drop_array_with_map
-    output = Liquid::Template.parse(' {{ contexts | map: "bar" }} ').render!('contexts' => [ContextDrop.new, ContextDrop.new], 'bar' => "carrot")
-    assert_equal(' carrotcarrot ', output)
-  end
-
-  def test_nested_context_drop
-    output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
-    assert_equal(' monkey ', output)
-  end
-
-  def test_protected
-    output = Liquid::Template.parse(' {{ product.callmenot }} ').render!('product' => ProductDrop.new)
-    assert_equal('  ', output)
-  end
-
-  def test_object_methods_not_allowed
-    [:dup, :clone, :singleton_class, :eval, :class_eval, :inspect].each do |method|
-      output = Liquid::Template.parse(" {{ product.#{method} }} ").render!('product' => ProductDrop.new)
-      assert_equal('  ', output)
-    end
-  end
-
-  def test_scope
-    assert_equal('1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new))
-    assert_equal('2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-    assert_equal('3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-  end
-
-  def test_scope_though_proc
-    assert_equal('1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }))
-    assert_equal('2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1]))
-    assert_equal('3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1]))
-  end
-
-  def test_scope_with_assigns
-    assert_equal('variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new))
-    assert_equal('variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-    assert_equal('test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new))
-    assert_equal('test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new))
-  end
-
-  def test_scope_from_tags
-    assert_equal('1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-    assert_equal('12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-    assert_equal('123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-  end
-
-  def test_access_context_from_drop
-    assert_equal('123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3]))
-  end
-
-  def test_enumerable_drop
-    assert_equal('123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new))
-  end
-
-  def test_enumerable_drop_size
-    assert_equal('3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new))
-  end
-
-  def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names
-    ["select", "each", "map", "cycle"].each do |method|
-      assert_equal(method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new))
-      assert_equal(method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new))
-      assert_equal(method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new))
-      assert_equal(method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new))
-    end
-  end
-
-  def test_some_enumerable_methods_still_get_invoked
-    [:count, :max].each do |method|
-      assert_equal("3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new))
-      assert_equal("3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new))
-      assert_equal("3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new))
-      assert_equal("3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new))
-    end
-
-    assert_equal("yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new))
-
-    [:min, :first].each do |method|
-      assert_equal("1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new))
-      assert_equal("1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new))
-      assert_equal("1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new))
-      assert_equal("1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new))
-    end
-  end
-
-  def test_empty_string_value_access
-    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => ''))
-  end
-
-  def test_nil_value_access
-    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil))
-  end
-
-  def test_default_to_s_on_drops
-    assert_equal('ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new))
-    assert_equal('EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new))
-  end
-
-  def test_invokable_methods
-    assert_equal(%w(to_liquid catchall context texts).to_set, ProductDrop.invokable_methods)
-    assert_equal(%w(to_liquid scopes_as_array loop_pos scopes).to_set, ContextDrop.invokable_methods)
-    assert_equal(%w(to_liquid size max min first count).to_set, EnumerableDrop.invokable_methods)
-    assert_equal(%w(to_liquid max min sort count first).to_set, RealEnumerableDrop.invokable_methods)
-  end
-end # DropsTest

data/test/integration/error_handling_test.rb

@@ -1,272 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ErrorHandlingTest < Minitest::Test
-  include Liquid
-
-  def test_templates_parsed_with_line_numbers_renders_them_in_errors
-    template = <<-LIQUID
-      Hello,
-
-      {{ errors.standard_error }} will raise a standard error.
-
-      Bla bla test.
-
-      {{ errors.syntax_error }} will raise a syntax error.
-
-      This is an argument error: {{ errors.argument_error }}
-
-      Bla.
-    LIQUID
-
-    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_standard_error
-    template = Liquid::Template.parse(' {{ errors.standard_error }} ')
-    assert_equal(' Liquid error: standard error ', template.render('errors' => ErrorDrop.new))
-
-    assert_equal(1, template.errors.size)
-    assert_equal(StandardError, 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_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse(' {% for a in b %} ... ')
-    end
-  end
-
-  def test_unrecognized_operator
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
-      end
-    end
-  end
-
-  def test_lax_unrecognized_operator
-    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
-      Liquid::Template.parse('
-          foobar
-
-          {% "cat" | foobar %}
-
-          bla
-        ',
-        line_numbers: true)
-    end
-
-    assert_match(/Liquid syntax error \(line 4\)/, err.message)
-  end
-
-  def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
-          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('
-        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('
-          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('
-          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_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
-    end
-    assert_equal('Liquid syntax error: Unexpected character = in "1 =! 2"', err.message)
-
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}', error_mode: :strict)
-    end
-    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].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_raises(Exception) do
-      template = Liquid::Template.parse('{{ errors.exception }}')
-      template.render('errors' => ErrorDrop.new)
-    end
-  end
-
-  def test_default_exception_renderer_with_internal_error
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
-
-    output = template.render('errors' => ErrorDrop.new)
-
-    assert_equal('This is a runtime error: Liquid error (line 1): internal', output)
-    assert_equal([Liquid::InternalError], template.errors.map(&:class))
-  end
-
-  def test_setting_default_exception_renderer
-    old_exception_renderer = Liquid::Template.default_exception_renderer
-    exceptions = []
-    Liquid::Template.default_exception_renderer = ->(e) {
-      exceptions << e
-      ''
-    }
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}')
-
-    output = template.render('errors' => ErrorDrop.new)
-
-    assert_equal('This is a runtime error: ', output)
-    assert_equal([Liquid::ArgumentError], template.errors.map(&:class))
-  ensure
-    Liquid::Template.default_exception_renderer = old_exception_renderer if old_exception_renderer
-  end
-
-  def test_exception_renderer_exposing_non_liquid_error
-    template   = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
-    exceptions = []
-    handler    = ->(e) {
-      exceptions << e
-      e.cause
-    }
-
-    output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler)
-
-    assert_equal('This is a runtime error: runtime error', output)
-    assert_equal([Liquid::InternalError], exceptions.map(&:class))
-    assert_equal(exceptions, template.errors)
-    assert_equal('#<RuntimeError: runtime error>', exceptions.first.cause.inspect)
-  end
-
-  class TestFileSystem
-    def read_template_file(_template_path)
-      "{{ errors.argument_error }}"
-    end
-  end
-
-  def test_included_template_name_with_line_numbers
-    old_file_system = Liquid::Template.file_system
-
-    begin
-      Liquid::Template.file_system = TestFileSystem.new
-
-      template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true)
-      page     = template.render('errors' => ErrorDrop.new)
-    ensure
-      Liquid::Template.file_system = old_file_system
-    end
-    assert_equal("Argument error:\nLiquid error (product line 1): argument error", page)
-    assert_equal("product", template.errors.first.template_name)
-  end
-
-  def test_bug_compatible_silencing_of_errors_in_blank_nodes
-    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}not blank{% assign x = 3 %}{% endif %}{{ x }}").render
-    assert_equal("Liquid error: comparison of Integer with String failed0", output)
-
-    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}{% assign x = 3 %}{% endif %}{{ x }}").render
-    assert_equal("0", output)
-  end
-end

data/test/integration/expression_test.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ExpressionTest < Minitest::Test
-  def test_keyword_literals
-    assert_equal(true, parse_and_eval("true"))
-    assert_equal(true, parse_and_eval(" true "))
-  end
-
-  def test_string
-    assert_equal("single quoted", parse_and_eval("'single quoted'"))
-    assert_equal("double quoted", parse_and_eval('"double quoted"'))
-    assert_equal("spaced", parse_and_eval(" 'spaced' "))
-    assert_equal("spaced2", parse_and_eval(' "spaced2" '))
-  end
-
-  def test_int
-    assert_equal(123, parse_and_eval("123"))
-    assert_equal(456, parse_and_eval(" 456 "))
-    assert_equal(12, parse_and_eval("012"))
-  end
-
-  def test_float
-    assert_equal(1.5, parse_and_eval("1.5"))
-    assert_equal(2.5, parse_and_eval(" 2.5 "))
-  end
-
-  def test_range
-    assert_equal(1..2, parse_and_eval("(1..2)"))
-    assert_equal(3..4, parse_and_eval(" ( 3 .. 4 ) "))
-  end
-
-  private
-
-  def parse_and_eval(markup, **assigns)
-    if Liquid::Template.error_mode == :strict
-      p = Liquid::Parser.new(markup)
-      markup = p.expression
-      p.consume(:end_of_string)
-    end
-    expression = Liquid::Expression.parse(markup)
-    context = Liquid::Context.new(assigns)
-    context.evaluate(expression)
-  end
-end

data/test/integration/filter_kwarg_test.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class FilterKwargTest < Minitest::Test
-  module KwargFilter
-    def html_tag(_tag, attributes)
-      attributes
-        .map { |key, value| "#{key}='#{value}'" }
-        .join(' ')
-    end
-  end
-
-  include Liquid
-
-  def test_can_parse_data_kwargs
-    with_global_filter(KwargFilter) do
-      assert_equal(
-        "data-src='src' data-widths='100, 200'",
-        Template.parse("{{ 'img' | html_tag: data-src: 'src', data-widths: '100, 200' }}").render(nil, nil)
-      )
-    end
-  end
-end