liquid 3.0.6 → 5.4.0

data/test/integration/drop_test.rb

@@ -1,271 +0,0 @@
-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 before_method(method)
-    return @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 before_method(method)
-      return 'method: ' << method.to_s
-    end
-  end
-
-  def texts
-    TextDrop.new
-  end
-
-  def catchall
-    CatchallDrop.new
-  end
-
-  def context
-    ContextDrop.new
-  end
-
-  def user_input
-    "foo".taint
-  end
-
-  protected
-    def callmenot
-      "protected"
-    end
-end
-
-class EnumerableDrop < Liquid::Drop
-  def before_method(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 before_method(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_rendering_raises_on_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      assert_raises TaintedError do
-        tpl.render!('product' => ProductDrop.new)
-      end
-    end
-  end
-
-  def test_rendering_warns_on_tainted_attr
-    with_taint_mode(:warn) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      tpl.render!('product' => ProductDrop.new)
-      assert_match /tainted/, tpl.warnings.first
-    end
-  end
-
-  def test_rendering_doesnt_raise_on_escaped_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
-      tpl.render!('product' => ProductDrop.new)
-    end
-  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_unknown_method
-    output = Liquid::Template.parse( ' {{ product.catchall.unknown }} '  ).render!('product' => ProductDrop.new)
-    assert_equal ' method: unknown ', output
-  end
-
-  def test_integer_argument_drop
-    output = Liquid::Template.parse( ' {{ product.catchall[8] }} '  ).render!('product' => ProductDrop.new)
-    assert_equal ' 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_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.new{|c| c['context.scopes'] })
-    assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ s }}{%endfor%}'  ).render!('context' => ContextDrop.new, 's' => Proc.new{|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.new{|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_before_method_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
-end # DropsTest

data/test/integration/error_handling_test.rb

@@ -1,207 +0,0 @@
-require 'test_helper'
-
-class ErrorDrop < Liquid::Drop
-  def standard_error
-    raise Liquid::StandardError, 'standard error'
-  end
-
-  def argument_error
-    raise Liquid::ArgumentError, 'argument error'
-  end
-
-  def syntax_error
-    raise Liquid::SyntaxError, 'syntax error'
-  end
-
-  def exception
-    raise Exception, 'exception'
-  end
-
-end
-
-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
-      template = Liquid::Template.parse(%q{
-          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(%q{
-        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(%q{
-          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(%q{
-          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
-end

data/test/integration/filter_test.rb

@@ -1,138 +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$ ', Variable.new("var | money").render(@context)
-  end
-
-  def test_underscore_in_filter_name
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-    assert_equal ' 1000$ ', Variable.new("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 ', Variable.new("var | money").render(@context)
-  end
-
-  def test_size
-    @context['var'] = 'abcd'
-    @context.add_filters(MoneyFilter)
-
-    assert_equal 4, Variable.new("var | size").render(@context)
-  end
-
-  def test_join
-    @context['var'] = [1,2,3,4]
-
-    assert_equal "1 2 3 4", Variable.new("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']
-
-    assert_equal [1,2,3,4], Variable.new("numbers | sort").render(@context)
-    assert_equal ['alphabetic', 'as', 'expected'], Variable.new("words | sort").render(@context)
-    assert_equal [3], Variable.new("value | sort").render(@context)
-    assert_equal ['are', 'flower'], Variable.new("arrays | sort").render(@context)
-  end
-
-  def test_strip_html
-    @context['var'] = "<b>bla blub</a>"
-
-    assert_equal "bla blub", Variable.new("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", Variable.new("var | strip_html").render(@context)
-  end
-
-  def test_capitalize
-    @context['var'] = "blub"
-
-    assert_equal "Blub", Variable.new("var | capitalize").render(@context)
-  end
-
-  def test_nonexistent_filter_is_ignored
-    @context['var'] = 1000
-
-    assert_equal 1000, Variable.new("var | xyzzy").render(@context)
-  end
-
-  def test_filter_with_keyword_arguments
-    @context['surname'] = 'john'
-    @context.add_filters(SubstituteFilter)
-    output = Variable.new(%! 'hello %{first_name}, %{last_name}' | 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

data/test/integration/hash_ordering_test.rb

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