liquid 4.0.3 → 5.1.0

data/test/integration/variable_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class VariableTest < Minitest::Test
@@ -5,92 +7,132 @@ class VariableTest < Minitest::Test
 
   def test_simple_variable
     template = Template.parse(%({{test}}))
-    assert_equal 'worked', template.render!('test' => 'worked')
-    assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
+    assert_equal('worked', template.render!('test' => 'worked'))
+    assert_equal('worked wonderfully', template.render!('test' => 'worked wonderfully'))
   end
 
   def test_variable_render_calls_to_liquid
-    assert_template_result 'foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new
+    assert_template_result('foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new)
+  end
+
+  def test_variable_lookup_calls_to_liquid_value
+    assert_template_result('1', '{{ foo }}', 'foo' => IntegerDrop.new('1'))
+    assert_template_result('2', '{{ list[foo] }}', 'foo' => IntegerDrop.new('1'), 'list' => [1, 2, 3])
+    assert_template_result('one', '{{ list[foo] }}', 'foo' => IntegerDrop.new('1'), 'list' => { 1 => 'one' })
+    assert_template_result('Yay', '{{ foo }}', 'foo' => BooleanDrop.new(true))
+    assert_template_result('YAY', '{{ foo | upcase }}', 'foo' => BooleanDrop.new(true))
+  end
+
+  def test_if_tag_calls_to_liquid_value
+    assert_template_result('one', '{% if foo == 1 %}one{% endif %}', 'foo' => IntegerDrop.new('1'))
+    assert_template_result('one', '{% if 0 < foo %}one{% endif %}', 'foo' => IntegerDrop.new('1'))
+    assert_template_result('one', '{% if foo > 0 %}one{% endif %}', 'foo' => IntegerDrop.new('1'))
+    assert_template_result('true', '{% if foo == true %}true{% endif %}', 'foo' => BooleanDrop.new(true))
+    assert_template_result('true', '{% if foo %}true{% endif %}', 'foo' => BooleanDrop.new(true))
+
+    assert_template_result('', '{% if foo %}true{% endif %}', 'foo' => BooleanDrop.new(false))
+    assert_template_result('', '{% if foo == true %}True{% endif %}', 'foo' => BooleanDrop.new(false))
+  end
+
+  def test_unless_tag_calls_to_liquid_value
+    assert_template_result('', '{% unless foo %}true{% endunless %}', 'foo' => BooleanDrop.new(true))
+  end
+
+  def test_case_tag_calls_to_liquid_value
+    assert_template_result('One', '{% case foo %}{% when 1 %}One{% endcase %}', 'foo' => IntegerDrop.new('1'))
   end
 
   def test_simple_with_whitespaces
     template = Template.parse(%(  {{ test }}  ))
-    assert_equal '  worked  ', template.render!('test' => 'worked')
-    assert_equal '  worked wonderfully  ', template.render!('test' => 'worked wonderfully')
+    assert_equal('  worked  ', template.render!('test' => 'worked'))
+    assert_equal('  worked wonderfully  ', template.render!('test' => 'worked wonderfully'))
+  end
+
+  def test_expression_with_whitespace_in_square_brackets
+    assert_template_result('result', "{{ a[ 'b' ] }}", 'a' => { 'b' => 'result' })
+    assert_template_result('result', "{{ a[ [ 'b' ] ] }}", 'b' => 'c', 'a' => { 'c' => 'result' })
   end
 
   def test_ignore_unknown
     template = Template.parse(%({{ test }}))
-    assert_equal '', template.render!
+    assert_equal('', template.render!)
   end
 
   def test_using_blank_as_variable_name
     template = Template.parse("{% assign foo = blank %}{{ foo }}")
-    assert_equal '', template.render!
+    assert_equal('', template.render!)
   end
 
   def test_using_empty_as_variable_name
     template = Template.parse("{% assign foo = empty %}{{ foo }}")
-    assert_equal '', template.render!
+    assert_equal('', template.render!)
   end
 
   def test_hash_scoping
-    template = Template.parse(%({{ test.test }}))
-    assert_equal 'worked', template.render!('test' => { 'test' => 'worked' })
+    assert_template_result('worked', "{{ test.test }}", 'test' => { 'test' => 'worked' })
+    assert_template_result('worked', "{{ test . test }}", 'test' => { 'test' => 'worked' })
   end
 
   def test_false_renders_as_false
-    assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false)
-    assert_equal 'false', Template.parse("{{ false }}").render!
+    assert_equal('false', Template.parse("{{ foo }}").render!('foo' => false))
+    assert_equal('false', Template.parse("{{ false }}").render!)
   end
 
   def test_nil_renders_as_empty_string
-    assert_equal '', Template.parse("{{ nil }}").render!
-    assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
+    assert_equal('', Template.parse("{{ nil }}").render!)
+    assert_equal('cat', Template.parse("{{ nil | append: 'cat' }}").render!)
   end
 
   def test_preset_assigns
-    template = Template.parse(%({{ test }}))
+    template                 = Template.parse(%({{ test }}))
     template.assigns['test'] = 'worked'
-    assert_equal 'worked', template.render!
+    assert_equal('worked', template.render!)
   end
 
   def test_reuse_parsed_template
-    template = Template.parse(%({{ greeting }} {{ name }}))
+    template                     = Template.parse(%({{ greeting }} {{ name }}))
     template.assigns['greeting'] = 'Goodbye'
-    assert_equal 'Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi')
-    assert_equal 'Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi')
-    assert_equal 'Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian')
-    assert_equal 'Goodbye Brian', template.render!('name' => 'Brian')
+    assert_equal('Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi'))
+    assert_equal('Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi'))
+    assert_equal('Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian'))
+    assert_equal('Goodbye Brian', template.render!('name' => 'Brian'))
     assert_equal({ 'greeting' => 'Goodbye' }, template.assigns)
   end
 
   def test_assigns_not_polluted_from_template
-    template = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
+    template                 = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
     template.assigns['test'] = 'baz'
-    assert_equal 'bazbar', template.render!
-    assert_equal 'bazbar', template.render!
-    assert_equal 'foobar', template.render!('test' => 'foo')
-    assert_equal 'bazbar', template.render!
+    assert_equal('bazbar', template.render!)
+    assert_equal('bazbar', template.render!)
+    assert_equal('foobar', template.render!('test' => 'foo'))
+    assert_equal('bazbar', template.render!)
   end
 
   def test_hash_with_default_proc
-    template = Template.parse(%(Hello {{ test }}))
-    assigns = Hash.new { |h, k| raise "Unknown variable '#{k}'" }
+    template        = Template.parse(%(Hello {{ test }}))
+    assigns         = Hash.new { |_h, k| raise "Unknown variable '#{k}'" }
     assigns['test'] = 'Tobi'
-    assert_equal 'Hello Tobi', template.render!(assigns)
+    assert_equal('Hello Tobi', template.render!(assigns))
     assigns.delete('test')
     e = assert_raises(RuntimeError) do
       template.render!(assigns)
     end
-    assert_equal "Unknown variable 'test'", e.message
+    assert_equal("Unknown variable 'test'", e.message)
   end
 
   def test_multiline_variable
-    assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
+    assert_equal('worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked'))
   end
 
   def test_render_symbol
-    assert_template_result 'bar', '{{ foo }}', 'foo' => :bar
+    assert_template_result('bar', '{{ foo }}', 'foo' => :bar)
+  end
+
+  def test_dynamic_find_var
+    assert_template_result('bar', '{{ [key] }}', 'key' => 'foo', 'foo' => 'bar')
+  end
+
+  def test_raw_value_variable
+    assert_template_result('bar', '{{ [key] }}', 'key' => 'foo', 'foo' => 'bar')
   end
 end

data/test/test_helper.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 ENV["MT_NO_EXPECTATIONS"] = "1"
 require 'minitest/autorun'
@@ -8,13 +9,13 @@ require 'liquid.rb'
 require 'liquid/profiler'
 
 mode = :strict
-if env_mode = ENV['LIQUID_PARSER_MODE']
+if (env_mode = ENV['LIQUID_PARSER_MODE'])
   puts "-- #{env_mode.upcase} ERROR MODE"
   mode = env_mode.to_sym
 end
 Liquid::Template.error_mode = mode
 
-if ENV['LIQUID-C'] == '1'
+if ENV['LIQUID_C'] == '1'
   puts "-- LIQUID C"
   require 'liquid/c'
 end
@@ -37,44 +38,55 @@ module Minitest
     include Liquid
 
     def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template).render!(assigns), message
+      assert_equal(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
     end
 
     def assert_template_result_matches(expected, template, assigns = {}, message = nil)
-      return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
+      return assert_template_result(expected, template, assigns, message) unless expected.is_a?(Regexp)
 
-      assert_match expected, Template.parse(template).render!(assigns), message
+      assert_match(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
     end
 
     def assert_match_syntax_error(match, template, assigns = {})
       exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template).render(assigns)
+        Template.parse(template, line_numbers: true).render(assigns)
       end
-      assert_match match, exception.message
+      assert_match(match, exception.message)
+    end
+
+    def assert_usage_increment(name, times: 1)
+      old_method = Liquid::Usage.method(:increment)
+      calls = 0
+      begin
+        Liquid::Usage.singleton_class.send(:remove_method, :increment)
+        Liquid::Usage.define_singleton_method(:increment) do |got_name|
+          calls += 1 if got_name == name
+          old_method.call(got_name)
+        end
+        yield
+      ensure
+        Liquid::Usage.singleton_class.send(:remove_method, :increment)
+        Liquid::Usage.define_singleton_method(:increment, old_method)
+      end
+      assert_equal(times, calls, "Number of calls to Usage.increment with #{name.inspect}")
     end
 
     def with_global_filter(*globals)
-      original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
-      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
-        @filter_methods = Set.new
-      end)
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
+      original_global_filters = Liquid::StrainerFactory.instance_variable_get(:@global_filters)
+      Liquid::StrainerFactory.instance_variable_set(:@global_filters, [])
+      globals.each do |global|
+        Liquid::StrainerFactory.add_global_filter(global)
+      end
+
+      Liquid::StrainerFactory.send(:strainer_class_cache).clear
 
       globals.each do |global|
         Liquid::Template.register_filter(global)
       end
       yield
     ensure
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
-    end
-
-    def with_taint_mode(mode)
-      old_mode = Liquid::Template.taint_mode
-      Liquid::Template.taint_mode = mode
-      yield
-    ensure
-      Liquid::Template.taint_mode = old_mode
+      Liquid::StrainerFactory.send(:strainer_class_cache).clear
+      Liquid::StrainerFactory.instance_variable_set(:@global_filters, original_global_filters)
     end
 
     def with_error_mode(mode)
@@ -84,6 +96,20 @@ module Minitest
     ensure
       Liquid::Template.error_mode = old_mode
     end
+
+    def with_custom_tag(tag_name, tag_class)
+      old_tag = Liquid::Template.tags[tag_name]
+      begin
+        Liquid::Template.register_tag(tag_name, tag_class)
+        yield
+      ensure
+        if old_tag
+          Liquid::Template.tags[tag_name] = old_tag
+        else
+          Liquid::Template.tags.delete(tag_name)
+        end
+      end
+    end
   end
 end
 
@@ -93,6 +119,44 @@ class ThingWithToLiquid
   end
 end
 
+class IntegerDrop < Liquid::Drop
+  def initialize(value)
+    super()
+    @value = value.to_i
+  end
+
+  def ==(other)
+    @value == other
+  end
+
+  def to_s
+    @value.to_s
+  end
+
+  def to_liquid_value
+    @value
+  end
+end
+
+class BooleanDrop < Liquid::Drop
+  def initialize(value)
+    super()
+    @value = value
+  end
+
+  def ==(other)
+    @value == other
+  end
+
+  def to_liquid_value
+    @value
+  end
+
+  def to_s
+    @value ? "Yay" : "Nay"
+  end
+end
+
 class ErrorDrop < Liquid::Drop
   def standard_error
     raise Liquid::StandardError, 'standard error'
@@ -114,3 +178,30 @@ class ErrorDrop < Liquid::Drop
     raise Exception, 'exception'
   end
 end
+
+class StubFileSystem
+  attr_reader :file_read_count
+
+  def initialize(values)
+    @file_read_count = 0
+    @values          = values
+  end
+
+  def read_template_file(template_path)
+    @file_read_count += 1
+    @values.fetch(template_path)
+  end
+end
+
+class StubTemplateFactory
+  attr_reader :count
+
+  def initialize
+    @count = 0
+  end
+
+  def for(_template_name)
+    @count += 1
+    Liquid::Template.new
+  end
+end

data/test/unit/block_unit_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class BlockUnitTest < Minitest::Test
@@ -5,49 +7,42 @@ class BlockUnitTest < Minitest::Test
 
   def test_blankspace
     template = Liquid::Template.parse("  ")
-    assert_equal ["  "], template.root.nodelist
+    assert_equal(["  "], template.root.nodelist)
   end
 
   def test_variable_beginning
     template = Liquid::Template.parse("{{funk}}  ")
-    assert_equal 2, template.root.nodelist.size
-    assert_equal Variable, template.root.nodelist[0].class
-    assert_equal String, template.root.nodelist[1].class
+    assert_equal(2, template.root.nodelist.size)
+    assert_equal(Variable, template.root.nodelist[0].class)
+    assert_equal(String, template.root.nodelist[1].class)
   end
 
   def test_variable_end
     template = Liquid::Template.parse("  {{funk}}")
-    assert_equal 2, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
-    assert_equal Variable, template.root.nodelist[1].class
+    assert_equal(2, template.root.nodelist.size)
+    assert_equal(String, template.root.nodelist[0].class)
+    assert_equal(Variable, template.root.nodelist[1].class)
   end
 
   def test_variable_middle
     template = Liquid::Template.parse("  {{funk}}  ")
-    assert_equal 3, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
-    assert_equal Variable, template.root.nodelist[1].class
-    assert_equal String, template.root.nodelist[2].class
+    assert_equal(3, template.root.nodelist.size)
+    assert_equal(String, template.root.nodelist[0].class)
+    assert_equal(Variable, template.root.nodelist[1].class)
+    assert_equal(String, template.root.nodelist[2].class)
   end
 
   def test_variable_many_embedded_fragments
     template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
-    assert_equal 7, template.root.nodelist.size
-    assert_equal [String, Variable, String, Variable, String, Variable, String],
-      block_types(template.root.nodelist)
+    assert_equal(7, template.root.nodelist.size)
+    assert_equal([String, Variable, String, Variable, String, Variable, String],
+      block_types(template.root.nodelist))
   end
 
   def test_with_block
     template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
-    assert_equal [String, Comment, String], block_types(template.root.nodelist)
-    assert_equal 3, template.root.nodelist.size
-  end
-
-  def test_with_custom_tag
-    Liquid::Template.register_tag("testtag", Block)
-    assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
-  ensure
-    Liquid::Template.tags.delete('testtag')
+    assert_equal([String, Comment, String], block_types(template.root.nodelist))
+    assert_equal(3, template.root.nodelist.size)
   end
 
   private
@@ -55,4 +50,4 @@ class BlockUnitTest < Minitest::Test
   def block_types(nodelist)
     nodelist.collect(&:class)
   end
-end # VariableTest
+end