locomotivecms-liquid 2.6.0 → 4.0.0.alpha

data/test/integration/context_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class ContextTest < Minitest::Test
+  include Liquid
+
+  def test_override_global_filter
+    global = Module.new do
+      def notice(output)
+        "Global #{output}"
+      end
+    end
+
+    local = Module.new do
+      def notice(output)
+        "Local #{output}"
+      end
+    end
+
+    with_global_filter(global) do
+      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
+      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
+    end
+  end
+
+  def test_has_key_will_not_add_an_error_for_missing_keys
+    with_error_mode :strict do
+      context = Context.new
+      context.has_key?('unknown')
+      assert_empty context.errors
+    end
+  end
+end

data/test/integration/document_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class DocumentTest < Minitest::Test
+  include Liquid
+
+  def test_unexpected_outer_tag
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% else %}")
+    end
+    assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
+  end
+
+  def test_unknown_tag
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% foo %}")
+    end
+    assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
+  end
+end

data/test/integration/drop_test.rb

@@ -0,0 +1,271 @@
+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

@@ -0,0 +1,207 @@
+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