Temporarily use liquid-c branch for its corresponding change

Gemfile

@@ -22,6 +22,6 @@ group :test do
   gem 'rubocop-performance', require: false
 
   platform :mri, :truffleruby do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'optimize-invoke-filter-refactor'
   end
 end

lib/liquid/block.rb

@@ -10,7 +10,7 @@ module Liquid
     end
 
     def parse(tokens)
-      @body = new_body
+      @body = BlockBody.new
       while parse_body(@body, tokens)
       end
     end
@@ -28,12 +28,7 @@ module Liquid
       @body.nodelist
     end
 
-    def unknown_tag(tag_name, _markup, _tokenizer)
-      Block.raise_unknown_tag(tag_name, block_name, block_delimiter, parse_context)
-    end
-
-    # @api private
-    def self.raise_unknown_tag(tag, block_name, block_delimiter, parse_context)
+    def unknown_tag(tag, _params, _tokens)
       if tag == 'else'
         raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else",
           block_name: block_name)
@@ -55,14 +50,8 @@ module Liquid
       @block_delimiter ||= "end#{block_name}"
     end
 
-    private
+    protected
 
-    # @api public
-    def new_body
-      BlockBody.new
-    end
-
-    # @api public
     def parse_body(body, tokens)
       if parse_context.depth >= MAX_DEPTH
         raise StackLevelError, "Nesting too deep"

lib/liquid/block_body.rb

@@ -54,49 +54,28 @@ module Liquid
     end
 
     # @api private
-    def self.unknown_tag_in_liquid_tag(tag, parse_context)
-      Block.raise_unknown_tag(tag, 'liquid', '%}', parse_context)
+    def self.unknown_tag_in_liquid_tag(end_tag_name, end_tag_markup)
+      yield end_tag_name, end_tag_markup
+    ensure
+      Usage.increment("liquid_tag_contains_outer_tag") unless $ERROR_INFO.is_a?(SyntaxError)
     end
 
-    # @api private
-    def self.raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
-    end
-
-    # @api private
-    def self.raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
-    end
-
-    # @api private
-    def self.render_node(context, output, node)
-      node.render_to_output_buffer(context, output)
-    rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
-      context.handle_error(e, node.line_number)
-    rescue MemoryError
-      raise
-    rescue ::StandardError => e
-      line_number = node.is_a?(String) ? nil : node.line_number
-      output << context.handle_error(e, line_number)
-    end
-
-    private def parse_liquid_tag(markup, parse_context)
+    private def parse_liquid_tag(markup, parse_context, &block)
       liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
-      parse_for_liquid_tag(liquid_tag_tokenizer, parse_context) do |end_tag_name, _end_tag_markup|
-        if end_tag_name
-          BlockBody.unknown_tag_in_liquid_tag(end_tag_name, parse_context)
-        end
+      parse_for_liquid_tag(liquid_tag_tokenizer, parse_context) do |end_tag_name, end_tag_markup|
+        next unless end_tag_name
+        self.class.unknown_tag_in_liquid_tag(end_tag_name, end_tag_markup, &block)
       end
     end
 
-    private def parse_for_document(tokenizer, parse_context)
+    private def parse_for_document(tokenizer, parse_context, &block)
       while (token = tokenizer.shift)
         next if token.empty?
         case
         when token.start_with?(TAGSTART)
           whitespace_handler(token, parse_context)
           unless token =~ FullToken
-            BlockBody.raise_missing_tag_terminator(token, parse_context)
+            raise_missing_tag_terminator(token, parse_context)
           end
           tag_name = Regexp.last_match(2)
           markup   = Regexp.last_match(4)
@@ -108,7 +87,7 @@ module Liquid
           end
 
           if tag_name == 'liquid'
-            parse_liquid_tag(markup, parse_context)
+            parse_liquid_tag(markup, parse_context, &block)
             next
           end
 
@@ -142,11 +121,7 @@ module Liquid
       if token[2] == WhitespaceControl
         previous_token = @nodelist.last
         if previous_token.is_a?(String)
-          first_byte = previous_token.getbyte(0)
           previous_token.rstrip!
-          if previous_token.empty? && parse_context[:bug_compatible_whitespace_trimming] && first_byte
-            previous_token << first_byte
-          end
         end
       end
       parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
@@ -156,47 +131,38 @@ module Liquid
       @blank
     end
 
-    # Remove blank strings in the block body for a control flow tag (e.g. `if`, `for`, `case`, `unless`)
-    # with a blank body.
-    #
-    # For example, in a conditional assignment like the following
-    #
-    # ```
-    # {% if size > max_size %}
-    #   {% assign size = max_size %}
-    # {% endif %}
-    # ```
-    #
-    # we assume the intention wasn't to output the blank spaces in the `if` tag's block body, so this method
-    # will remove them to reduce the render output size.
-    #
-    # Note that it is now preferred to use the `liquid` tag for this use case.
-    def remove_blank_strings
-      raise "remove_blank_strings only support being called on a blank block body" unless @blank
-      @nodelist.reject! { |node| node.instance_of?(String) }
-    end
-
     def render(context)
       render_to_output_buffer(context, +'')
     end
 
     def render_to_output_buffer(context, output)
-      context.resource_limits.increment_render_score(@nodelist.length)
+      context.resource_limits.render_score += @nodelist.length
 
       idx = 0
       while (node = @nodelist[idx])
-        if node.instance_of?(String)
+        previous_output_size = output.bytesize
+
+        case node
+        when String
           output << node
-        else
+        when Variable
           render_node(context, output, node)
+        when Block
+          render_node(context, node.blank? ? +'' : output, node)
+          break if context.interrupt? # might have happened in a for-block
+        when Continue, Break
           # If we get an Interrupt that means the block must stop processing. An
           # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}. These tags may also occur through Block or Include tags.
-          break if context.interrupt? # might have happened in a for-block
+          # or {% continue %}
+          context.push_interrupt(node.interrupt)
+          break
+        else # Other non-Block tags
+          render_node(context, output, node)
+          break if context.interrupt? # might have happened through an include
         end
         idx += 1
 
-        context.resource_limits.increment_write_score(output)
+        raise_if_resource_limits_reached(context, output.bytesize - previous_output_size)
       end
 
       output
@@ -205,25 +171,34 @@ module Liquid
     private
 
     def render_node(context, output, node)
-      BlockBody.render_node(context, output, node)
+      node.render_to_output_buffer(context, output)
+    rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
+      context.handle_error(e, node.line_number)
+    rescue ::StandardError => e
+      line_number = node.is_a?(String) ? nil : node.line_number
+      output << context.handle_error(e, line_number)
+    end
+
+    def raise_if_resource_limits_reached(context, length)
+      context.resource_limits.render_length += length
+      return unless context.resource_limits.reached?
+      raise MemoryError, "Memory limits exceeded"
     end
 
     def create_variable(token, parse_context)
-      token.scan(ContentOfVariable) do |content|
-        markup = content.first
+      if token =~ ContentOfVariable
+        markup = Regexp.last_match(1)
         return Variable.new(markup, parse_context)
       end
-      BlockBody.raise_missing_variable_terminator(token, parse_context)
+      raise_missing_variable_terminator(token, parse_context)
     end
 
-    # @deprecated Use {.raise_missing_tag_terminator} instead
     def raise_missing_tag_terminator(token, parse_context)
-      BlockBody.raise_missing_tag_terminator(token, parse_context)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
     end
 
-    # @deprecated Use {.raise_missing_variable_terminator} instead
     def raise_missing_variable_terminator(token, parse_context)
-      BlockBody.raise_missing_variable_terminator(token, parse_context)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
     end
 
     def registered_tags

lib/liquid/context.rb

@@ -93,8 +93,13 @@ module Liquid
       exception_renderer.call(e).to_s
     end
 
-    def invoke(method, *args)
-      strainer.invoke(method, *args).to_liquid
+    def invoke(method, input, *args)
+      strainer.invoke(method, input, *args).to_liquid
+    end
+
+    # @api private
+    def invoke_filter(method, input, args)
+      strainer.invoke_filter(method, input, args).to_liquid
     end
 
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead

lib/liquid/document.rb

@@ -1,33 +1,23 @@
 # frozen_string_literal: true
 
 module Liquid
-  class Document
+  class Document < BlockBody
     def self.parse(tokens, parse_context)
-      doc = new(parse_context)
+      doc = new
       doc.parse(tokens, parse_context)
       doc
     end
 
-    attr_reader :parse_context, :body
-
-    def initialize(parse_context)
-      @parse_context = parse_context
-      @body = new_body
-    end
-
-    def nodelist
-      @body.nodelist
-    end
-
-    def parse(tokenizer, parse_context)
-      while parse_body(tokenizer)
+    def parse(tokens, parse_context)
+      super do |end_tag_name, _end_tag_params|
+        unknown_tag(end_tag_name, parse_context) if end_tag_name
       end
     rescue SyntaxError => e
       e.line_number ||= parse_context.line_number
       raise
     end
 
-    def unknown_tag(tag, _markup, _tokenizer)
+    def unknown_tag(tag, parse_context)
       case tag
       when 'else', 'end'
         raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag", tag: tag)
@@ -35,30 +25,5 @@ module Liquid
         raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
       end
     end
-
-    def render_to_output_buffer(context, output)
-      @body.render_to_output_buffer(context, output)
-    end
-
-    def render(context)
-      @body.render(context)
-    end
-
-    private
-
-    def new_body
-      Liquid::BlockBody.new
-    end
-
-    def parse_body(tokenizer)
-      @body.parse(tokenizer, parse_context) do |unknown_tag_name, unknown_tag_markup|
-        if unknown_tag_name
-          unknown_tag(unknown_tag_name, unknown_tag_markup, tokenizer)
-          true
-        else
-          false
-        end
-      end
-    end
   end
 end

lib/liquid/resource_limits.rb

@@ -2,8 +2,8 @@
 
 module Liquid
   class ResourceLimits
-    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
-    attr_reader :render_score, :assign_score
+    attr_accessor :render_length, :render_score, :assign_score,
+      :render_length_limit, :render_score_limit, :assign_score_limit
 
     def initialize(limits)
       @render_length_limit = limits[:render_length_limit]
@@ -12,51 +12,14 @@ module Liquid
       reset
     end
 
-    def increment_render_score(amount)
-      @render_score += amount
-      raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
-    end
-
-    def increment_assign_score(amount)
-      @assign_score += amount
-      raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
-    end
-
-    # update either render_length or assign_score based on whether or not the writes are captured
-    def increment_write_score(output)
-      if (last_captured = @last_capture_length)
-        captured = output.bytesize
-        increment = captured - last_captured
-        @last_capture_length = captured
-        increment_assign_score(increment)
-      elsif @render_length_limit && output.bytesize > @render_length_limit
-        raise_limits_reached
-      end
-    end
-
-    def raise_limits_reached
-      @reached_limit = true
-      raise MemoryError, "Memory limits exceeded"
-    end
-
     def reached?
-      @reached_limit
+      (@render_length_limit && @render_length > @render_length_limit) ||
+        (@render_score_limit && @render_score > @render_score_limit) ||
+        (@assign_score_limit && @assign_score > @assign_score_limit)
     end
 
     def reset
-      @reached_limit = false
-      @last_capture_length = nil
-      @render_score = @assign_score = 0
-    end
-
-    def with_capture
-      old_capture_length = @last_capture_length
-      begin
-        @last_capture_length = 0
-        yield
-      ensure
-        @last_capture_length = old_capture_length
-      end
+      @render_length = @render_score = @assign_score = 0
     end
   end
 end

lib/liquid/strainer_template.rb

@@ -24,11 +24,11 @@ module Liquid
 
         include(filter)
 
-        filter_methods.merge(filter.public_instance_methods.map(&:to_s))
+        filter_methods.merge(filter.public_instance_methods)
       end
 
       def invokable?(method)
-        filter_methods.include?(method.to_s)
+        filter_methods.include?(method.to_sym)
       end
 
       private
@@ -38,13 +38,18 @@ module Liquid
       end
     end
 
-    def invoke(method, *args)
+    def invoke(method, input, *args)
+      invoke_filter(method.to_sym, input, args)
+    end
+
+    # @api private
+    def invoke_filter(method, input, args)
       if self.class.invokable?(method)
-        send(method, *args)
+        send(method, input, *args)
       elsif @context.strict_filters
         raise Liquid::UndefinedFilter, "undefined filter #{method}"
       else
-        args.first
+        input
       end
     rescue ::ArgumentError => e
       raise Liquid::ArgumentError, e.message, e.backtrace

lib/liquid/tags/assign.rb

@@ -27,7 +27,7 @@ module Liquid
     def render_to_output_buffer(context, output)
       val = @from.render(context)
       context.scopes.last[@to] = val
-      context.resource_limits.increment_assign_score(assign_score_of(val))
+      context.resource_limits.assign_score += assign_score_of(val)
       output
     end
 

lib/liquid/tags/break.rb

@@ -11,11 +11,8 @@ module Liquid
   #    {% endfor %}
   #
   class Break < Tag
-    INTERRUPT = BreakInterrupt.new.freeze
-
-    def render_to_output_buffer(context, output)
-      context.push_interrupt(INTERRUPT)
-      output
+    def interrupt
+      BreakInterrupt.new
     end
   end
 

lib/liquid/tags/capture.rb

@@ -25,10 +25,10 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      context.resource_limits.with_capture do
-        capture_output = render(context)
-        context.scopes.last[@to] = capture_output
-      end
+      previous_output_size = output.bytesize
+      super
+      context.scopes.last[@to] = output
+      context.resource_limits.assign_score += (output.bytesize - previous_output_size)
       output
     end
 

lib/liquid/tags/case.rb

@@ -19,11 +19,8 @@ module Liquid
     end
 
     def parse(tokens)
-      body = new_body
+      body = BlockBody.new
       body = @blocks.last.attachment while parse_body(body, tokens)
-      if blank?
-        @blocks.each { |condition| condition.attachment.remove_blank_strings }
-      end
     end
 
     def nodelist
@@ -59,7 +56,7 @@ module Liquid
     private
 
     def record_when_condition(markup)
-      body = new_body
+      body = BlockBody.new
 
       while markup
         unless markup =~ WhenSyntax
@@ -80,7 +77,7 @@ module Liquid
       end
 
       block = ElseCondition.new
-      block.attach(new_body)
+      block.attach(BlockBody.new)
       @blocks << block
     end
 

lib/liquid/tags/continue.rb

@@ -11,11 +11,8 @@ module Liquid
   #    {% endfor %}
   #
   class Continue < Tag
-    INTERRUPT = ContinueInterrupt.new.freeze
-
-    def render_to_output_buffer(context, output)
-      context.push_interrupt(INTERRUPT)
-      output
+    def interrupt
+      ContinueInterrupt.new
     end
   end
 

lib/liquid/tags/for.rb

@@ -54,18 +54,13 @@ module Liquid
       super
       @from = @limit = nil
       parse_with_selected_parser(markup)
-      @for_block = new_body
+      @for_block = BlockBody.new
       @else_block = nil
     end
 
     def parse(tokens)
-      if parse_body(@for_block, tokens)
-        parse_body(@else_block, tokens)
-      end
-      if blank?
-        @for_block.remove_blank_strings
-        @else_block&.remove_blank_strings
-      end
+      return unless parse_body(@for_block, tokens)
+      parse_body(@else_block, tokens)
     end
 
     def nodelist
@@ -74,7 +69,7 @@ module Liquid
 
     def unknown_tag(tag, markup, tokens)
       return super unless tag == 'else'
-      @else_block = new_body
+      @else_block = BlockBody.new
     end
 
     def render_to_output_buffer(context, output)

lib/liquid/tags/if.rb

@@ -31,9 +31,6 @@ module Liquid
     def parse(tokens)
       while parse_body(@blocks.last.attachment, tokens)
       end
-      if blank?
-        @blocks.each { |condition| condition.attachment.remove_blank_strings }
-      end
     end
 
     def unknown_tag(tag, markup, tokens)
@@ -64,7 +61,7 @@ module Liquid
       end
 
       @blocks.push(block)
-      block.attach(new_body)
+      block.attach(BlockBody.new)
     end
 
     def lax_parse(markup)

lib/liquid/variable.rb

@@ -18,7 +18,7 @@ module Liquid
     JustTagAttributes        = /\A#{TagAttributes}\z/o
     MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
 
-    attr_accessor :filters, :name, :line_number
+    attr_accessor :name, :line_number
     attr_reader :parse_context
     alias_method :options, :parse_context
 
@@ -81,12 +81,15 @@ module Liquid
     end
 
     def render(context)
-      obj = @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
-        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        context.invoke(filter_name, output, *filter_args)
+      result = context.evaluate(@name)
+      @filters.each do |filter_name, constant_args, filter_args, filter_kwargs|
+        unless constant_args
+          filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
+        end
+        result = context.invoke_filter(filter_name, result, filter_args)
       end
 
-      context.apply_global_filter(obj)
+      context.apply_global_filter(result)
     end
 
     def render_to_output_buffer(context, output)
@@ -110,21 +113,49 @@ module Liquid
       []
     end
 
+    def filters
+      @filters.map do |filter_name, constant_args, *filter_args_and_kwargs|
+        filter_name = filter_name.to_s
+        if constant_args
+          filter_args = filter_args_and_kwargs.first
+          if filter_args.last.is_a?(Hash)
+            filter_args = filter_args.dup
+            [filter_name, filter_args, filter_args.pop]
+          else
+            [filter_name, *filter_args_and_kwargs]
+          end
+        else
+          [filter_name, *filter_args_and_kwargs]
+        end
+      end
+    end
+
     private
 
     def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args  = []
+      constant_args = true
+      filter_args = []
       keyword_args = nil
       unparsed_args.each do |a|
         if (matches = a.match(JustTagAttributes))
-          keyword_args           ||= {}
-          keyword_args[matches[1]] = Expression.parse(matches[2])
+          keyword_args ||= {}
+          expression = Expression.parse(matches[2])
+          constant_args &&= !expression.is_a?(VariableLookup)
+          keyword_args[matches[1]] = expression
         else
-          filter_args << Expression.parse(a)
+          expression = Expression.parse(a)
+          constant_args &&= !expression.is_a?(VariableLookup)
+          filter_args << expression
+        end
+      end
+      result = [filter_name.to_sym, constant_args, filter_args]
+      if keyword_args
+        if constant_args
+          filter_args << keyword_args
+        else
+          result << keyword_args
         end
       end
-      result = [filter_name, filter_args]
-      result << keyword_args if keyword_args
       result
     end
 

test/integration/security_test.rb

@@ -48,10 +48,11 @@ class SecurityTest < Minitest::Test
 
     test = %( {{ "some_string" | a_bad_filter }} )
 
-    template = Template.parse(test)
-    assert_equal([], (Symbol.all_symbols - current_symbols))
+    Template.parse(test).render!
+
+    GC.start
+    GC.start
 
-    template.render!
     assert_equal([], (Symbol.all_symbols - current_symbols))
   end
 

test/integration/tags/liquid_tag_test.rb

@@ -82,13 +82,15 @@ class LiquidTagTest < Minitest::Test
   end
 
   def test_nested_liquid_tag
-    assert_template_result('good', <<~LIQUID)
-      {%- if true %}
-        {%- liquid
-          echo "good"
-        %}
-      {%- endif -%}
-    LIQUID
+    assert_usage_increment("liquid_tag_contains_outer_tag", times: 0) do
+      assert_template_result('good', <<~LIQUID)
+        {%- if true %}
+          {%- liquid
+            echo "good"
+          %}
+        {%- endif -%}
+      LIQUID
+    end
   end
 
   def test_cannot_open_blocks_living_past_a_liquid_tag
@@ -100,12 +102,14 @@ class LiquidTagTest < Minitest::Test
     LIQUID
   end
 
-  def test_cannot_close_blocks_created_before_a_liquid_tag
-    assert_match_syntax_error("syntax error (line 3): 'endif' is not a valid delimiter for liquid tags. use %}", <<~LIQUID)
-      {%- if true -%}
-      42
-      {%- liquid endif -%}
-    LIQUID
+  def test_quirk_can_close_blocks_created_before_a_liquid_tag
+    assert_usage_increment("liquid_tag_contains_outer_tag") do
+      assert_template_result("42", <<~LIQUID)
+        {%- if true -%}
+        42
+        {%- liquid endif -%}
+      LIQUID
+    end
   end
 
   def test_liquid_tag_in_raw

test/integration/template_test.rb

@@ -111,12 +111,13 @@ class TemplateTest < Minitest::Test
 
   def test_resource_limits_render_length
     t = Template.parse("0123456789")
-    t.resource_limits.render_length_limit = 9
+    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 = 10
     assert_equal("0123456789", t.render!)
+    refute_nil(t.resource_limits.render_length)
   end
 
   def test_resource_limits_render_score
@@ -175,46 +176,50 @@ class TemplateTest < Minitest::Test
   end
 
   def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
-    t = Template.parse("{% for a in (1..100) %}x{% assign foo = 1 %} {% endfor %}")
+    t = Template.parse("{% for a in (1..100) %} {% 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)
   end
 
   def test_render_length_persists_between_blocks
     t = Template.parse("{% if true %}aaaa{% endif %}")
-    t.resource_limits.render_length_limit = 3
+    t.resource_limits.render_length_limit = 7
     assert_equal("Liquid error: Memory limits exceeded", t.render)
-    t.resource_limits.render_length_limit = 4
+    t.resource_limits.render_length_limit = 8
     assert_equal("aaaa", t.render)
 
     t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
-    t.resource_limits.render_length_limit = 6
+    t.resource_limits.render_length_limit = 13
     assert_equal("Liquid error: Memory limits exceeded", t.render)
-    t.resource_limits.render_length_limit = 7
+    t.resource_limits.render_length_limit = 14
     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 = 6
+    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)
   end
 
   def test_render_length_uses_number_of_bytes_not_characters
     t = Template.parse("{% if true %}すごい{% endif %}")
-    t.resource_limits.render_length_limit = 8
+    t.resource_limits.render_length_limit = 10
     assert_equal("Liquid error: Memory limits exceeded", t.render)
-    t.resource_limits.render_length_limit = 9
+    t.resource_limits.render_length_limit = 18
     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) %}x{% assign foo = 1 %} {% endfor %}")
+    t = Template.parse("{% for a in (1..100) %} {% 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)
   end
 
   def test_can_use_drop_as_context

test/integration/trim_mode_test.rb

@@ -528,21 +528,4 @@ class TrimModeTest < Minitest::Test
     END_EXPECTED
     assert_template_result(expected, text)
   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
 end # TrimModeTest

test/unit/strainer_factory_unit_test.rb

@@ -6,11 +6,11 @@ class StrainerFactoryUnitTest < Minitest::Test
   include Liquid
 
   module AccessScopeFilters
-    def public_filter
+    def public_filter(_input)
       "public"
     end
 
-    def private_filter
+    def private_filter(_input)
       "private"
     end
     private :private_filter
@@ -31,13 +31,13 @@ class StrainerFactoryUnitTest < Minitest::Test
   def test_strainer
     strainer = StrainerFactory.create(@context)
     assert_equal(5, strainer.invoke('size', 'input'))
-    assert_equal("public", strainer.invoke("public_filter"))
+    assert_equal("public", strainer.invoke("public_filter", 'input'))
   end
 
   def test_stainer_raises_argument_error
     strainer = StrainerFactory.create(@context)
     assert_raises(Liquid::ArgumentError) do
-      strainer.invoke("public_filter", 1)
+      strainer.invoke("public_filter", 'input', 1)
     end
   end
 
@@ -45,11 +45,11 @@ class StrainerFactoryUnitTest < Minitest::Test
     strainer = StrainerFactory.create(@context)
 
     exception = assert_raises(Liquid::ArgumentError) do
-      strainer.invoke("public_filter", 1)
+      strainer.invoke("public_filter", 'input', 1)
     end
 
     assert_match(
-      /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/,
+      /\ALiquid error: wrong number of arguments \((2 for 1|given 2, expected 1)\)\z/,
       exception.message
     )
     assert_equal(exception.backtrace[0].split(':')[0], __FILE__)
@@ -66,8 +66,8 @@ class StrainerFactoryUnitTest < Minitest::Test
 
   def test_strainer_returns_nil_if_no_filter_method_found
     strainer = StrainerFactory.create(@context)
-    assert_nil(strainer.invoke("private_filter"))
-    assert_nil(strainer.invoke("undef_the_filter"))
+    assert_nil(strainer.invoke("private_filter", nil))
+    assert_nil(strainer.invoke("undef_the_filter", nil))
   end
 
   def test_strainer_returns_first_argument_if_no_method_and_arguments_given

test/unit/strainer_template_unit_test.rb

@@ -60,7 +60,7 @@ class StrainerTemplateUnitTest < Minitest::Test
     strainer = Context.new.strainer
     with_global_filter do
       strainer.class.add_filter(PublicMethodOverrideFilter)
-      assert(strainer.class.send(:filter_methods).include?('public_filter'))
+      assert(strainer.class.send(:filter_methods).include?(:public_filter))
     end
   end