liquid 4.0.0 → 5.0.1

data/test/integration/tags/table_row_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class TableRowTest < Minitest::Test

data/test/integration/tags/unless_else_tag_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class UnlessElseTagTest < Minitest::Test
@@ -17,10 +19,10 @@ class UnlessElseTagTest < Minitest::Test
   end
 
   def test_unless_in_loop
-    assert_template_result '23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', 'choices' => [1, nil, false]
+    assert_template_result('23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', 'choices' => [1, nil, false])
   end
 
   def test_unless_else_in_loop
-    assert_template_result ' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false]
+    assert_template_result(' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false])
   end
 end # UnlessElseTest

data/test/integration/template_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'timeout'
 
@@ -38,8 +40,8 @@ class TemplateTest < Minitest::Test
 
   def test_instance_assigns_persist_on_same_template_object_between_parses
     t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
+    assert_equal('from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!)
+    assert_equal('from instance assigns', t.parse("{{ foo }}").render!)
   end
 
   def test_warnings_is_not_exponential_time
@@ -49,242 +51,243 @@ class TemplateTest < Minitest::Test
     end
 
     t = Template.parse(str)
-    assert_equal [], Timeout.timeout(1) { t.warnings }
+    assert_equal([], Timeout.timeout(1) { t.warnings })
   end
 
   def test_instance_assigns_persist_on_same_template_parsing_between_renders
     t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
-    assert_equal 'foo', t.render!
-    assert_equal 'foofoo', t.render!
+    assert_equal('foo', t.render!)
+    assert_equal('foofoo', t.render!)
   end
 
   def test_custom_assigns_do_not_persist_on_same_template
     t = Template.new
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
-    assert_equal '', t.parse("{{ foo }}").render!
+    assert_equal('from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns'))
+    assert_equal('', t.parse("{{ foo }}").render!)
   end
 
   def test_custom_assigns_squash_instance_assigns
     t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
+    assert_equal('from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!)
+    assert_equal('from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns'))
   end
 
   def test_persistent_assigns_squash_instance_assigns
     t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
+    assert_equal('from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!)
     t.assigns['foo'] = 'from persistent assigns'
-    assert_equal 'from persistent assigns', t.parse("{{ foo }}").render!
+    assert_equal('from persistent assigns', t.parse("{{ foo }}").render!)
   end
 
   def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
     t = Template.new
-    t.assigns['number'] = -> { @global ||= 0; @global += 1 }
-    assert_equal '1', t.parse("{{number}}").render!
-    assert_equal '1', t.parse("{{number}}").render!
-    assert_equal '1', t.render!
+    t.assigns['number'] = -> {
+      @global ||= 0
+      @global  += 1
+    }
+    assert_equal('1', t.parse("{{number}}").render!)
+    assert_equal('1', t.parse("{{number}}").render!)
+    assert_equal('1', t.render!)
     @global = nil
   end
 
   def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
     t = Template.new
-    assigns = { 'number' => -> { @global ||= 0; @global += 1 } }
-    assert_equal '1', t.parse("{{number}}").render!(assigns)
-    assert_equal '1', t.parse("{{number}}").render!(assigns)
-    assert_equal '1', t.render!(assigns)
+    assigns = { 'number' => -> {
+                              @global ||= 0
+                              @global  += 1
+                            } }
+    assert_equal('1', t.parse("{{number}}").render!(assigns))
+    assert_equal('1', t.parse("{{number}}").render!(assigns))
+    assert_equal('1', t.render!(assigns))
     @global = nil
   end
 
   def test_resource_limits_works_with_custom_length_method
     t = Template.parse("{% assign foo = bar %}")
     t.resource_limits.render_length_limit = 42
-    assert_equal "", t.render!("bar" => SomethingWithLength.new)
+    assert_equal("", t.render!("bar" => SomethingWithLength.new))
   end
 
   def test_resource_limits_render_length
     t = Template.parse("0123456789")
-    t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    t.resource_limits.render_length_limit = 9
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.render_length_limit = 10
-    assert_equal "0123456789", t.render!
-    refute_nil t.resource_limits.render_length
+    assert_equal("0123456789", t.render!)
   end
 
   def test_resource_limits_render_score
     t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.render_score_limit = 200
-    assert_equal (" foo " * 100), t.render!
-    refute_nil t.resource_limits.render_score
-  end
-
-  def test_resource_limits_assign_score
-    t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
-    t.resource_limits.assign_score_limit = 1
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
-
-    t.resource_limits.assign_score_limit = 2
-    assert_equal "", t.render!
-    refute_nil t.resource_limits.assign_score
-  end
-
-  def test_resource_limits_assign_score_nested
-    t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
-
-    t.resource_limits.assign_score_limit = 3
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
-
-    t.resource_limits.assign_score_limit = 5
-    assert_equal "", t.render!
+    assert_equal((" foo " * 100), t.render!)
+    refute_nil(t.resource_limits.render_score)
   end
 
   def test_resource_limits_aborts_rendering_after_first_error
     t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
   end
 
   def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
-    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
+    t = Template.parse("{% for a in (1..100) %}x{% assign foo = 1 %} {% endfor %}")
     t.render!
-    assert t.resource_limits.assign_score > 0
-    assert t.resource_limits.render_score > 0
-    assert t.resource_limits.render_length > 0
+    assert(t.resource_limits.assign_score > 0)
+    assert(t.resource_limits.render_score > 0)
   end
 
   def test_render_length_persists_between_blocks
     t = Template.parse("{% if true %}aaaa{% endif %}")
-    t.resource_limits.render_length_limit = 7
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    t.resource_limits.render_length_limit = 8
-    assert_equal "aaaa", t.render
+    t.resource_limits.render_length_limit = 3
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    t.resource_limits.render_length_limit = 4
+    assert_equal("aaaa", t.render)
 
     t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
-    t.resource_limits.render_length_limit = 13
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    t.resource_limits.render_length_limit = 14
-    assert_equal "aaaabbb", t.render
+    t.resource_limits.render_length_limit = 6
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    t.resource_limits.render_length_limit = 7
+    assert_equal("aaaabbb", t.render)
 
     t = Template.parse("{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}")
     t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    t.resource_limits.render_length_limit = 11
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    t.resource_limits.render_length_limit = 12
-    assert_equal "ababab", t.render
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    t.resource_limits.render_length_limit = 6
+    assert_equal("ababab", t.render)
+  end
+
+  def test_render_length_uses_number_of_bytes_not_characters
+    t = Template.parse("{% if true %}すごい{% endif %}")
+    t.resource_limits.render_length_limit = 8
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    t.resource_limits.render_length_limit = 9
+    assert_equal("すごい", t.render)
   end
 
   def test_default_resource_limits_unaffected_by_render_with_context
     context = Context.new
-    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
+    t = Template.parse("{% for a in (1..100) %}x{% assign foo = 1 %} {% endfor %}")
     t.render!(context)
-    assert context.resource_limits.assign_score > 0
-    assert context.resource_limits.render_score > 0
-    assert context.resource_limits.render_length > 0
+    assert(context.resource_limits.assign_score > 0)
+    assert(context.resource_limits.render_score > 0)
   end
 
   def test_can_use_drop_as_context
     t = Template.new
     t.registers['lulz'] = 'haha'
     drop = TemplateContextDrop.new
-    assert_equal 'fizzbuzz', t.parse('{{foo}}').render!(drop)
-    assert_equal 'bar', t.parse('{{bar}}').render!(drop)
-    assert_equal 'haha', t.parse("{{baz}}").render!(drop)
+    assert_equal('fizzbuzz', t.parse('{{foo}}').render!(drop))
+    assert_equal('bar', t.parse('{{bar}}').render!(drop))
+    assert_equal('haha', t.parse("{{baz}}").render!(drop))
   end
 
   def test_render_bang_force_rethrow_errors_on_passed_context
-    context = Context.new({ 'drop' => ErroneousDrop.new })
+    context = Context.new('drop' => ErroneousDrop.new)
     t = Template.new.parse('{{ drop.bad_method }}')
 
-    e = assert_raises RuntimeError do
+    e = assert_raises(RuntimeError) do
       t.render!(context)
     end
-    assert_equal 'ruby error in drop', e.message
+    assert_equal('ruby error in drop', e.message)
   end
 
   def test_exception_renderer_that_returns_string
     exception = nil
-    handler = ->(e) { exception = e; '<!-- error -->' }
+    handler   = ->(e) {
+      exception = e
+      '<!-- error -->'
+    }
 
     output = Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: handler)
 
-    assert exception.is_a?(Liquid::ZeroDivisionError)
-    assert_equal '<!-- error -->', output
+    assert(exception.is_a?(Liquid::ZeroDivisionError))
+    assert_equal('<!-- error -->', output)
   end
 
   def test_exception_renderer_that_raises
     exception = nil
     assert_raises(Liquid::ZeroDivisionError) do
-      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: ->(e) { exception = e; raise })
+      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: ->(e) {
+                                                                                 exception = e
+                                                                                 raise
+                                                                               })
     end
-    assert exception.is_a?(Liquid::ZeroDivisionError)
+    assert(exception.is_a?(Liquid::ZeroDivisionError))
   end
 
   def test_global_filter_option_on_render
     global_filter_proc = ->(output) { "#{output} filtered" }
-    rendered_template = Template.parse("{{name}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
+    rendered_template  = Template.parse("{{name}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
 
-    assert_equal 'bob filtered', rendered_template
+    assert_equal('bob filtered', rendered_template)
   end
 
   def test_global_filter_option_when_native_filters_exist
     global_filter_proc = ->(output) { "#{output} filtered" }
-    rendered_template = Template.parse("{{name | upcase}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
+    rendered_template  = Template.parse("{{name | upcase}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
 
-    assert_equal 'BOB filtered', rendered_template
+    assert_equal('BOB filtered', rendered_template)
   end
 
   def test_undefined_variables
-    t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
-    result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })
+    t      = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
+    result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, strict_variables: true)
+
+    assert_equal('33  32  ', result)
+    assert_equal(3, t.errors.count)
+    assert_instance_of(Liquid::UndefinedVariable, t.errors[0])
+    assert_equal('Liquid error: undefined variable y', t.errors[0].message)
+    assert_instance_of(Liquid::UndefinedVariable, t.errors[1])
+    assert_equal('Liquid error: undefined variable b', t.errors[1].message)
+    assert_instance_of(Liquid::UndefinedVariable, t.errors[2])
+    assert_equal('Liquid error: undefined variable d', t.errors[2].message)
+  end
+
+  def test_nil_value_does_not_raise
+    t      = Template.parse("some{{x}}thing", error_mode: :strict)
+    result = t.render!({ 'x' => nil }, strict_variables: true)
 
-    assert_equal '33  32  ', result
-    assert_equal 3, t.errors.count
-    assert_instance_of Liquid::UndefinedVariable, t.errors[0]
-    assert_equal 'Liquid error: undefined variable y', t.errors[0].message
-    assert_instance_of Liquid::UndefinedVariable, t.errors[1]
-    assert_equal 'Liquid error: undefined variable b', t.errors[1].message
-    assert_instance_of Liquid::UndefinedVariable, t.errors[2]
-    assert_equal 'Liquid error: undefined variable d', t.errors[2].message
+    assert_equal(0, t.errors.count)
+    assert_equal('something', result)
   end
 
   def test_undefined_variables_raise
     t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
 
-    assert_raises UndefinedVariable do
-      t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })
+    assert_raises(UndefinedVariable) do
+      t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, strict_variables: true)
     end
   end
 
   def test_undefined_drop_methods
     d = DropWithUndefinedMethod.new
     t = Template.new.parse('{{ foo }} {{ woot }}')
-    result = t.render(d, { strict_variables: true })
+    result = t.render(d, strict_variables: true)
 
-    assert_equal 'foo ', result
-    assert_equal 1, t.errors.count
-    assert_instance_of Liquid::UndefinedDropMethod, t.errors[0]
+    assert_equal('foo ', result)
+    assert_equal(1, t.errors.count)
+    assert_instance_of(Liquid::UndefinedDropMethod, t.errors[0])
   end
 
   def test_undefined_drop_methods_raise
     d = DropWithUndefinedMethod.new
     t = Template.new.parse('{{ foo }} {{ woot }}')
 
-    assert_raises UndefinedDropMethod do
-      t.render!(d, { strict_variables: true })
+    assert_raises(UndefinedDropMethod) do
+      t.render!(d, strict_variables: true)
     end
   end
 
@@ -295,29 +298,29 @@ class TemplateTest < Minitest::Test
         "-#{v}-"
       end
     end
-    result = t.render({ 'a' => 123, 'x' => 'foo' }, { filters: [filters], strict_filters: true })
+    result = t.render({ 'a' => 123, 'x' => 'foo' }, filters: [filters], strict_filters: true)
 
-    assert_equal '123 ', result
-    assert_equal 1, t.errors.count
-    assert_instance_of Liquid::UndefinedFilter, t.errors[0]
-    assert_equal 'Liquid error: undefined filter somefilter1', t.errors[0].message
+    assert_equal('123 ', result)
+    assert_equal(1, t.errors.count)
+    assert_instance_of(Liquid::UndefinedFilter, t.errors[0])
+    assert_equal('Liquid error: undefined filter somefilter1', t.errors[0].message)
   end
 
   def test_undefined_filters_raise
     t = Template.parse("{{x | somefilter1 | upcase | somefilter2}}")
 
-    assert_raises UndefinedFilter do
-      t.render!({ 'x' => 'foo' }, { strict_filters: true })
+    assert_raises(UndefinedFilter) do
+      t.render!({ 'x' => 'foo' }, strict_filters: true)
     end
   end
 
   def test_using_range_literal_works_as_expected
     t = Template.parse("{% assign foo = (x..y) %}{{ foo }}")
-    result = t.render({ 'x' => 1, 'y' => 5 })
-    assert_equal '1..5', result
+    result = t.render('x' => 1, 'y' => 5)
+    assert_equal('1..5', result)
 
     t = Template.parse("{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}")
-    result = t.render({ 'x' => 1, 'y' => 5 })
-    assert_equal '12345', result
+    result = t.render('x' => 1, 'y' => 5)
+    assert_equal('12345', result)
   end
 end

data/test/integration/trim_mode_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class TrimModeTest < Minitest::Test
@@ -67,7 +69,7 @@ class TrimModeTest < Minitest::Test
   # Make sure the trim isn't applied to standard tags
   def test_standard_tags
     whitespace = '          '
-    text = <<-END_TEMPLATE
+    text       = <<-END_TEMPLATE
       <div>
         <p>
           {% if true %}
@@ -76,14 +78,14 @@ class TrimModeTest < Minitest::Test
         </p>
       </div>
     END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-#{whitespace}
-          yes
-#{whitespace}
-        </p>
-      </div>
+    expected = <<~END_EXPECTED
+            <div>
+              <p>
+      #{whitespace}
+                yes
+      #{whitespace}
+              </p>
+            </div>
     END_EXPECTED
     assert_template_result(expected, text)
 
@@ -96,70 +98,70 @@ class TrimModeTest < Minitest::Test
         </p>
       </div>
     END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-#{whitespace}
-        </p>
-      </div>
+    expected = <<~END_EXPECTED
+            <div>
+              <p>
+      #{whitespace}
+              </p>
+            </div>
     END_EXPECTED
     assert_template_result(expected, text)
   end
 
   # Make sure the trim isn't too agressive
   def test_no_trim_output
-    text = '<p>{{- \'John\' -}}</p>'
+    text     = '<p>{{- \'John\' -}}</p>'
     expected = '<p>John</p>'
     assert_template_result(expected, text)
   end
 
   # Make sure the trim isn't too agressive
   def test_no_trim_tags
-    text = '<p>{%- if true -%}yes{%- endif -%}</p>'
+    text     = '<p>{%- if true -%}yes{%- endif -%}</p>'
     expected = '<p>yes</p>'
     assert_template_result(expected, text)
 
-    text = '<p>{%- if false -%}no{%- endif -%}</p>'
+    text     = '<p>{%- if false -%}no{%- endif -%}</p>'
     expected = '<p></p>'
     assert_template_result(expected, text)
   end
 
   def test_single_line_outer_tag
-    text = '<p> {%- if true %} yes {% endif -%} </p>'
+    text     = '<p> {%- if true %} yes {% endif -%} </p>'
     expected = '<p> yes </p>'
     assert_template_result(expected, text)
 
-    text = '<p> {%- if false %} no {% endif -%} </p>'
+    text     = '<p> {%- if false %} no {% endif -%} </p>'
     expected = '<p></p>'
     assert_template_result(expected, text)
   end
 
   def test_single_line_inner_tag
-    text = '<p> {% if true -%} yes {%- endif %} </p>'
+    text     = '<p> {% if true -%} yes {%- endif %} </p>'
     expected = '<p> yes </p>'
     assert_template_result(expected, text)
 
-    text = '<p> {% if false -%} no {%- endif %} </p>'
+    text     = '<p> {% if false -%} no {%- endif %} </p>'
     expected = '<p>  </p>'
     assert_template_result(expected, text)
   end
 
   def test_single_line_post_tag
-    text = '<p> {% if true -%} yes {% endif -%} </p>'
+    text     = '<p> {% if true -%} yes {% endif -%} </p>'
     expected = '<p> yes </p>'
     assert_template_result(expected, text)
 
-    text = '<p> {% if false -%} no {% endif -%} </p>'
+    text     = '<p> {% if false -%} no {% endif -%} </p>'
     expected = '<p> </p>'
     assert_template_result(expected, text)
   end
 
   def test_single_line_pre_tag
-    text = '<p> {%- if true %} yes {%- endif %} </p>'
+    text     = '<p> {%- if true %} yes {%- endif %} </p>'
     expected = '<p> yes </p>'
     assert_template_result(expected, text)
 
-    text = '<p> {%- if false %} no {%- endif %} </p>'
+    text     = '<p> {%- if false %} no {%- endif %} </p>'
     expected = '<p> </p>'
     assert_template_result(expected, text)
   end
@@ -328,7 +330,7 @@ class TrimModeTest < Minitest::Test
     assert_template_result(expected, text)
 
     whitespace = '          '
-    text = <<-END_TEMPLATE
+    text       = <<-END_TEMPLATE
       <div>
         <p>
           {% if false -%}
@@ -337,12 +339,12 @@ class TrimModeTest < Minitest::Test
         </p>
       </div>
     END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-#{whitespace}
-        </p>
-      </div>
+    expected = <<~END_EXPECTED
+            <div>
+              <p>
+      #{whitespace}
+              </p>
+            </div>
     END_EXPECTED
     assert_template_result(expected, text)
   end
@@ -496,9 +498,13 @@ class TrimModeTest < Minitest::Test
     assert_template_result(expected, text)
   end
 
+  def test_right_trim_followed_by_tag
+    assert_template_result('ab c', '{{ "a" -}}{{ "b" }} c')
+  end
+
   def test_raw_output
     whitespace = '        '
-    text = <<-END_TEMPLATE
+    text       = <<-END_TEMPLATE
       <div>
         {% raw %}
           {%- if true -%}
@@ -509,17 +515,49 @@ class TrimModeTest < Minitest::Test
         {% endraw %}
       </div>
     END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-#{whitespace}
-          {%- if true -%}
-            <p>
-              {{- 'John' -}}
-            </p>
-          {%- endif -%}
-#{whitespace}
-      </div>
+    expected = <<~END_EXPECTED
+            <div>
+      #{whitespace}
+                {%- if true -%}
+                  <p>
+                    {{- 'John' -}}
+                  </p>
+                {%- endif -%}
+      #{whitespace}
+            </div>
     END_EXPECTED
     assert_template_result(expected, text)
   end
+
+  def test_pre_trim_blank_preceding_text
+    template = Liquid::Template.parse("\n{%- raw %}{% endraw %}")
+    assert_equal("", template.render)
+
+    template = Liquid::Template.parse("\n{%- if true %}{% endif %}")
+    assert_equal("", template.render)
+
+    template = Liquid::Template.parse("{{ 'B' }} \n{%- if true %}C{% endif %}")
+    assert_equal("BC", template.render)
+  end
+
+  def test_bug_compatible_pre_trim
+    template = Liquid::Template.parse("\n {%- raw %}{% endraw %}", bug_compatible_whitespace_trimming: true)
+    assert_equal("\n", template.render)
+
+    template = Liquid::Template.parse("\n {%- if true %}{% endif %}", bug_compatible_whitespace_trimming: true)
+    assert_equal("\n", template.render)
+
+    template = Liquid::Template.parse("{{ 'B' }} \n{%- if true %}C{% endif %}", bug_compatible_whitespace_trimming: true)
+    assert_equal("B C", template.render)
+
+    template = Liquid::Template.parse("B\n {%- raw %}{% endraw %}", bug_compatible_whitespace_trimming: true)
+    assert_equal("B", template.render)
+
+    template = Liquid::Template.parse("B\n {%- if true %}{% endif %}", bug_compatible_whitespace_trimming: true)
+    assert_equal("B", template.render)
+  end
+
+  def test_trim_blank
+    assert_template_result('foobar', 'foo {{-}} bar')
+  end
 end # TrimModeTest