liquid 2.6.3 → 3.0.0

data/lib/liquid.rb

@@ -21,9 +21,9 @@
 
 module Liquid
   FilterSeparator             = /\|/
-  ArgumentSeparator           = ','
-  FilterArgumentSeparator     = ':'
-  VariableAttributeSeparator  = '.'
+  ArgumentSeparator           = ','.freeze
+  FilterArgumentSeparator     = ':'.freeze
+  VariableAttributeSeparator  = '.'.freeze
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -33,37 +33,45 @@ module Liquid
   VariableIncompleteEnd       = /\}\}?/
   QuotedString                = /"[^"]*"|'[^']*'/
   QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
-  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s|:,]+/
-  FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/o
-  OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/o
-  SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/o
-  Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/o
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
   AnyStartingTag              = /\{\{|\{\%/
-  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/o
-  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/o
+  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
+
+  singleton_class.send(:attr_accessor, :cache_classes)
+  self.cache_classes = true
 end
 
 require "liquid/version"
+require 'liquid/lexer'
+require 'liquid/parser'
+require 'liquid/i18n'
 require 'liquid/drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
 require 'liquid/strainer'
+require 'liquid/expression'
 require 'liquid/context'
+require 'liquid/parser_switching'
 require 'liquid/tag'
 require 'liquid/block'
 require 'liquid/document'
 require 'liquid/variable'
+require 'liquid/variable_lookup'
+require 'liquid/range_lookup'
 require 'liquid/file_system'
 require 'liquid/template'
-require 'liquid/htmltags'
 require 'liquid/standardfilters'
 require 'liquid/condition'
 require 'liquid/module_ex'
 require 'liquid/utils'
+require 'liquid/token'
 
 # Load all the tags of the standard library
 #
 Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
+
+require 'liquid/profiler'
+require 'liquid/profiler/hooks'

data/test/fixtures/en_locale.yml

@@ -0,0 +1,9 @@
+---
+  simple: "less is more"
+  whatever: "something %{something}"
+  errors:
+    i18n:
+      undefined_interpolation: "undefined key %{key}"
+      unknown_translation: "translation '%{name}' wasn't found"
+    syntax:
+      oops: "something wasn't right"

data/test/{liquid → integration}/assign_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class AssignTest < Test::Unit::TestCase
+class AssignTest < Minitest::Test
   include Liquid
 
   def test_assigned_variable
@@ -18,4 +18,21 @@ class AssignTest < Test::Unit::TestCase
                            '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
                            'values' => "foo,bar,baz")
   end
+
+  def test_assign_syntax_error
+    assert_match_syntax_error(/assign/,
+                       '{% assign foo not values %}.',
+                       'values' => "foo,bar,baz")
+  end
+
+  def test_assign_uses_error_mode
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        Template.parse("{% assign foo = ('X' | downcase) %}")
+      end
+    end
+    with_error_mode(:lax) do
+      assert Template.parse("{% assign foo = ('X' | downcase) %}")
+    end
+  end
 end # AssignTest

data/test/integration/blank_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+class FoobarTag < Liquid::Tag
+  def render(*args)
+    " "
+  end
+
+  Liquid::Template.register_tag('foobar', FoobarTag)
+end
+
+class BlankTestFileSystem
+  def read_template_file(template_path, context)
+    template_path
+  end
+end
+
+class BlankTest < Minitest::Test
+  include Liquid
+  N = 10
+
+  def wrap_in_for(body)
+    "{% for i in (1..#{N}) %}#{body}{% endfor %}"
+  end
+
+  def wrap_in_if(body)
+    "{% if true %}#{body}{% endif %}"
+  end
+
+  def wrap(body)
+    wrap_in_for(body) + wrap_in_if(body)
+  end
+
+  def test_new_tags_are_not_blank_by_default
+    assert_template_result(" "*N, wrap_in_for("{% foobar %}"))
+  end
+
+  def test_loops_are_blank
+    assert_template_result("", wrap_in_for(" "))
+  end
+
+  def test_if_else_are_blank
+    assert_template_result("", "{% if true %} {% elsif false %} {% else %} {% endif %}")
+  end
+
+  def test_unless_is_blank
+    assert_template_result("", wrap("{% unless true %} {% endunless %}"))
+  end
+
+  def test_mark_as_blank_only_during_parsing
+    assert_template_result(" "*(N+1), wrap(" {% if false %} this never happens, but still, this block is not blank {% endif %}"))
+  end
+
+  def test_comments_are_blank
+    assert_template_result("", wrap(" {% comment %} whatever {% endcomment %} "))
+  end
+
+  def test_captures_are_blank
+    assert_template_result("", wrap(" {% capture foo %} whatever {% endcapture %} "))
+  end
+
+  def test_nested_blocks_are_blank_but_only_if_all_children_are
+    assert_template_result("", wrap(wrap(" ")))
+    assert_template_result("\n       but this is not "*(N+1),
+      wrap(%q{{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
+      {% if true %} but this is not {% endif %}}))
+  end
+
+  def test_assigns_are_blank
+    assert_template_result("", wrap(' {% assign foo = "bar" %} '))
+  end
+
+  def test_whitespace_is_blank
+    assert_template_result("", wrap(" "))
+    assert_template_result("", wrap("\t"))
+  end
+
+  def test_whitespace_is_not_blank_if_other_stuff_is_present
+    body = "     x "
+    assert_template_result(body*(N+1), wrap(body))
+  end
+
+  def test_increment_is_not_blank
+    assert_template_result(" 0"*2*(N+1), wrap("{% assign foo = 0 %} {% increment foo %} {% decrement foo %}"))
+  end
+
+  def test_cycle_is_not_blank
+    assert_template_result("  "*((N+1)/2)+" ", wrap("{% cycle ' ', ' ' %}"))
+  end
+
+  def test_raw_is_not_blank
+    assert_template_result("  "*(N+1), wrap(" {% raw %} {% endraw %}"))
+  end
+
+  def test_include_is_blank
+    Liquid::Template.file_system = BlankTestFileSystem.new
+    assert_template_result "foobar"*(N+1), wrap("{% include 'foobar' %}")
+    assert_template_result " foobar "*(N+1), wrap("{% include ' foobar ' %}")
+    assert_template_result "   "*(N+1), wrap(" {% include ' ' %} ")
+  end
+
+  def test_case_is_blank
+    assert_template_result("", wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
+    assert_template_result("", wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
+    assert_template_result("   x  "*(N+1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
+  end
+end

data/test/{liquid → integration}/capture_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class CaptureTest < Test::Unit::TestCase
+class CaptureTest < Minitest::Test
   include Liquid
 
   def test_captures_block_content_in_variable
@@ -19,7 +19,7 @@ class CaptureTest < Test::Unit::TestCase
     {{var}}
     END_TEMPLATE
     template = Template.parse(template_source)
-    rendered = template.render
+    rendered = template.render!
     assert_equal "test-string", rendered.gsub(/\s/, '')
   end
 
@@ -34,7 +34,7 @@ class CaptureTest < Test::Unit::TestCase
     {{ first }}-{{ second }}
     END_TEMPLATE
     template = Template.parse(template_source)
-    rendered = template.render
+    rendered = template.render!
     assert_equal "3-3", rendered.gsub(/\s/, '')
   end
 end # CaptureTest

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/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