Improve error message of Liquid::MemoryLimit.

The existing error message is too generic since there are three types of limits in place.
It is useful to know which limit was reached to make it easier to debug the error.

.travis.yml

@@ -13,8 +13,6 @@ matrix:
     - rvm: *latest_ruby
       script: bundle exec rake memory_profile:run
       name: Profiling Memory Usage
-  allow_failures:
-    - rvm: ruby-head
 
 branches:
   only:

History.md

@@ -4,7 +4,7 @@
 
 * Split Strainer class as a factory and a template (#1208) [Thierry Joyal]
 * Remove handling of a nil context in the Strainer class (#1218) [Thierry Joyal]
-* StaticRegisters#fetch to raise on missing key (#1250) [Thierry Joyal]
+* Change `Liquid::MemoryError` message to be more specific about which limit was reached. (#1206) [Alan Tan]
 
 ## 4.0.3 / 2019-03-12
 

lib/liquid.rb

@@ -63,8 +63,6 @@ require 'liquid/expression'
 require 'liquid/context'
 require 'liquid/parser_switching'
 require 'liquid/tag'
-require 'liquid/tag/disabler'
-require 'liquid/tag/disableable'
 require 'liquid/block'
 require 'liquid/block_body'
 require 'liquid/document'
@@ -88,3 +86,4 @@ require 'liquid/template_factory'
 # Load all the tags of the standard library
 #
 Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
+Dir["#{__dir__}/liquid/registers/*.rb"].each { |f| require f }

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
-      parse_context.new_block_body
-    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,60 +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 => exc
-      blank_tag = !node.instance_of?(Variable) && node.blank?
-      rescue_render_node(context, output, node.line_number, exc, blank_tag)
-    end
-
-    # @api private
-    def self.rescue_render_node(context, output, line_number, exc, blank_tag)
-      case exc
-      when MemoryError
-        raise
-      when UndefinedVariable, UndefinedDropMethod, UndefinedFilter
-        context.handle_error(exc, line_number)
-      else
-        error_message = context.handle_error(exc, line_number)
-        unless blank_tag # conditional for backwards compatibility
-          output << error_message
-        end
-      end
-    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)
@@ -119,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
 
@@ -163,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
@@ -212,7 +171,39 @@ module Liquid
     private
 
     def render_node(context, output, node)
-      BlockBody.render_node(context, output, node)
+      if node.disabled?(context)
+        output << node.disabled_error_message
+        return
+      end
+      disable_tags(context, node.disabled_tags) do
+        node.render_to_output_buffer(context, output)
+      end
+    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 disable_tags(context, tags, &block)
+      return yield if tags.empty?
+      context.registers[:disabled_tags].disable(tags, &block)
+    end
+
+    def raise_if_resource_limits_reached(context, length)
+      context.resource_limits.render_length += length
+
+      error_message =
+        if context.resource_limits.render_length_reached?
+          MemoryError::RENDER_LENGTH_ERROR_MESSAGE
+        elsif context.resource_limits.render_score_reached?
+          MemoryError::RENDER_SCORE_ERROR_MESSAGE
+        elsif context.resource_limits.assign_score_reached?
+          MemoryError::ASSIGN_SCORE_ERROR_MESSAGE
+        end
+
+      return unless error_message
+      raise MemoryError, error_message
     end
 
     def create_variable(token, parse_context)
@@ -220,17 +211,15 @@ module Liquid
         markup = content.first
         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/condition.rb

@@ -27,32 +27,10 @@ module Liquid
       end,
     }
 
-    class MethodLiteral
-      attr_reader :method_name, :to_s
-
-      def initialize(method_name, to_s)
-        @method_name = method_name
-        @to_s = to_s
-      end
-
-      def to_liquid
-        to_s
-      end
-    end
-
-    @@method_literals = {
-      'blank' => MethodLiteral.new(:blank?, '').freeze,
-      'empty' => MethodLiteral.new(:empty?, '').freeze,
-    }
-
     def self.operators
       @@operators
     end
 
-    def self.parse_expression(markup)
-      @@method_literals[markup] || Expression.parse(markup)
-    end
-
     attr_reader :attachment, :child_condition
     attr_accessor :left, :operator, :right
 
@@ -113,7 +91,7 @@ module Liquid
     private
 
     def equal_variables(left, right)
-      if left.is_a?(MethodLiteral)
+      if left.is_a?(Liquid::Expression::MethodLiteral)
         if right.respond_to?(left.method_name)
           return right.send(left.method_name)
         else
@@ -121,7 +99,7 @@ module Liquid
         end
       end
 
-      if right.is_a?(MethodLiteral)
+      if right.is_a?(Liquid::Expression::MethodLiteral)
         if left.respond_to?(right.method_name)
           return left.send(right.method_name)
         else

lib/liquid/context.rb

@@ -44,7 +44,6 @@ module Liquid
       @interrupts    = []
       @filters       = []
       @global_filter = nil
-      @disabled_tags = {}
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -145,7 +144,6 @@ module Liquid
         subcontext.strainer = nil
         subcontext.errors   = errors
         subcontext.warnings = warnings
-        subcontext.disabled_tags = @disabled_tags
       end
     end
 
@@ -210,24 +208,9 @@ module Liquid
       end
     end
 
-    def with_disabled_tags(tag_names)
-      tag_names.each do |name|
-        @disabled_tags[name] = @disabled_tags.fetch(name, 0) + 1
-      end
-      yield
-    ensure
-      tag_names.each do |name|
-        @disabled_tags[name] -= 1
-      end
-    end
-
-    def tag_disabled?(tag_name)
-      @disabled_tags.fetch(tag_name, 0) > 0
-    end
-
     protected
 
-    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
 
     private
 

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
-      parse_context.new_block_body
-    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/errors.rb

@@ -23,11 +23,14 @@ module Liquid
 
     def message_prefix
       str = +""
-      str << if is_a?(SyntaxError)
-        "Liquid syntax error"
-      else
-        "Liquid error"
-      end
+      str <<
+        if is_a?(SyntaxError)
+          "Liquid syntax error"
+        elsif is_a?(MemoryError)
+          "Liquid memory limit error"
+        else
+          "Liquid error"
+        end
 
       if line_number
         str << " ("
@@ -40,19 +43,24 @@ module Liquid
     end
   end
 
+  class MemoryError < Error
+    RENDER_LENGTH_ERROR_MESSAGE = 'Too many bytes rendered.'
+    RENDER_SCORE_ERROR_MESSAGE = 'Too many tags rendered.'
+    ASSIGN_SCORE_ERROR_MESSAGE = 'Too many bytes assigned to variables.'
+  end
+
   ArgumentError       = Class.new(Error)
   ContextError        = Class.new(Error)
   FileSystemError     = Class.new(Error)
   StandardError       = Class.new(Error)
   SyntaxError         = Class.new(Error)
   StackLevelError     = Class.new(Error)
-  MemoryError         = Class.new(Error)
+  TaintedError        = Class.new(Error)
   ZeroDivisionError   = Class.new(Error)
   FloatDomainError    = Class.new(Error)
   UndefinedVariable   = Class.new(Error)
   UndefinedDropMethod = Class.new(Error)
   UndefinedFilter     = Class.new(Error)
   MethodOverrideError = Class.new(Error)
-  DisabledError       = Class.new(Error)
   InternalError       = Class.new(Error)
 end

lib/liquid/expression.rb

@@ -2,12 +2,25 @@
 
 module Liquid
   class Expression
+    class MethodLiteral
+      attr_reader :method_name, :to_s
+
+      def initialize(method_name, to_s)
+        @method_name = method_name
+        @to_s = to_s
+      end
+
+      def to_liquid
+        to_s
+      end
+    end
+
     LITERALS = {
       nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
       'true' => true,
       'false' => false,
-      'blank' => '',
-      'empty' => ''
+      'blank' => MethodLiteral.new(:blank?, '').freeze,
+      'empty' => MethodLiteral.new(:empty?, '').freeze
     }.freeze
 
     SINGLE_QUOTED_STRING = /\A'(.*)'\z/m

lib/liquid/parse_context.rb

@@ -19,10 +19,6 @@ module Liquid
       @options[option_key]
     end
 
-    def new_block_body
-      Liquid::BlockBody.new
-    end
-
     def partial=(value)
       @partial = value
       @options = value ? partial_options : @template_options

lib/liquid/profiler/hooks.rb

@@ -1,21 +1,25 @@
 # frozen_string_literal: true
 
 module Liquid
-  module BlockBodyProfilingHook
-    def render_node(context, output, node)
+  class BlockBody
+    def render_node_with_profiling(context, output, node)
       Profiler.profile_node_render(node) do
-        super
+        render_node_without_profiling(context, output, node)
       end
     end
-  end
-  BlockBody.prepend(BlockBodyProfilingHook)
 
-  module IncludeProfilingHook
-    def render_to_output_buffer(context, output)
+    alias_method :render_node_without_profiling, :render_node
+    alias_method :render_node, :render_node_with_profiling
+  end
+
+  class Include < Tag
+    def render_to_output_buffer_with_profiling(context, output)
       Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        super
+        render_to_output_buffer_without_profiling(context, output)
       end
     end
+
+    alias_method :render_to_output_buffer_without_profiling, :render_to_output_buffer
+    alias_method :render_to_output_buffer, :render_to_output_buffer_with_profiling
   end
-  Include.prepend(IncludeProfilingHook)
 end

lib/liquid/registers/disabled_tags.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Liquid
+  class DisabledTags < Register
+    def initialize
+      @disabled_tags = {}
+    end
+
+    def disabled?(tag)
+      @disabled_tags.key?(tag) && @disabled_tags[tag] > 0
+    end
+
+    def disable(tags)
+      tags.each(&method(:increment))
+      yield
+    ensure
+      tags.each(&method(:decrement))
+    end
+
+    private
+
+    def increment(tag)
+      @disabled_tags[tag] ||= 0
+      @disabled_tags[tag]  += 1
+    end
+
+    def decrement(tag)
+      @disabled_tags[tag] -= 1
+    end
+  end
+
+  Template.add_register(:disabled_tags, DisabledTags.new)
+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,20 @@ module Liquid
       reset
     end
 
-    def increment_render_score(amount)
-      @render_score += amount
-      raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
+    def render_length_reached?
+      @render_length_limit && @render_length > @render_length_limit
     end
 
-    def increment_assign_score(amount)
-      @assign_score += amount
-      raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
+    def render_score_reached?
+      @render_score_limit && @render_score > @render_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
+    def assign_score_reached?
+      @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/standardfilters.rb

@@ -41,7 +41,7 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input.to_s) unless input.nil?
+      CGI.escapeHTML(input.to_s).untaint unless input.nil?
     end
     alias_method :h, :escape
 

lib/liquid/static_registers.rb

@@ -2,7 +2,7 @@
 
 module Liquid
   class StaticRegisters
-    attr_reader :static
+    attr_reader :static, :registers
 
     def initialize(registers = {})
       @static    = registers.is_a?(StaticRegisters) ? registers.static : registers
@@ -25,16 +25,8 @@ module Liquid
       @registers.delete(key)
     end
 
-    UNDEFINED = Object.new
-
-    def fetch(key, default = UNDEFINED, &block)
-      if @registers.key?(key)
-        @registers.fetch(key)
-      elsif default != UNDEFINED
-        @static.fetch(key, default, &block)
-      else
-        @static.fetch(key, &block)
-      end
+    def fetch(key, default = nil)
+      key?(key) ? self[key] : default
     end
 
     def key?(key)

lib/liquid/tag.rb

@@ -13,13 +13,15 @@ module Liquid
         tag
       end
 
-      def disable_tags(*tag_names)
-        @disabled_tags ||= []
-        @disabled_tags.concat(tag_names)
-        prepend(Disabler)
+      def disable_tags(*tags)
+        disabled_tags.push(*tags)
       end
 
       private :new
+
+      def disabled_tags
+        @disabled_tags ||= []
+      end
     end
 
     def initialize(tag_name, markup, parse_context)
@@ -44,6 +46,14 @@ module Liquid
       ''
     end
 
+    def disabled?(context)
+      context.registers[:disabled_tags].disabled?(tag_name)
+    end
+
+    def disabled_error_message
+      "#{tag_name} #{options[:locale].t('errors.disabled.tag')}"
+    end
+
     # For backwards compatibility with custom tags. In a future release, the semantics
     # of the `render_to_output_buffer` method will become the default and the `render`
     # method will be removed.
@@ -55,5 +65,9 @@ module Liquid
     def blank?
       false
     end
+
+    def disabled_tags
+      self.class.disabled_tags
+    end
   end
 end

lib/liquid/tag/disableable.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Tag
-    module Disableable
-      def render_to_output_buffer(context, output)
-        if context.tag_disabled?(tag_name)
-          output << disabled_error(context)
-          return
-        end
-        super
-      end
-
-      def disabled_error(context)
-        # raise then rescue the exception so that the Context#exception_renderer can re-raise it
-        raise DisabledError, "#{tag_name} #{parse_context[:locale].t('errors.disabled.tag')}"
-      rescue DisabledError => exc
-        context.handle_error(exc, line_number)
-      end
-    end
-  end
-end

lib/liquid/tag/disabler.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Tag
-    module Disabler
-      module ClassMethods
-        attr_reader :disabled_tags
-      end
-
-      def self.prepended(base)
-        base.extend(ClassMethods)
-      end
-
-      def render_to_output_buffer(context, output)
-        context.with_disabled_tags(self.class.disabled_tags) do
-          super
-        end
-      end
-    end
-  end
-end

lib/liquid/tags/assign.rb

@@ -12,6 +12,10 @@ module Liquid
   class Assign < Tag
     Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
+    def self.syntax_error_translation_key
+      "errors.syntax.assign"
+    end
+
     attr_reader :to, :from
 
     def initialize(tag_name, markup, options)
@@ -20,14 +24,14 @@ module Liquid
         @to   = Regexp.last_match(1)
         @from = Variable.new(Regexp.last_match(2), options)
       else
-        raise SyntaxError, options[:locale].t('errors.syntax.assign')
+        raise SyntaxError, options[:locale].t(self.class.syntax_error_translation_key)
       end
     end
 
     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
@@ -68,7 +65,7 @@ module Liquid
 
         markup = Regexp.last_match(2)
 
-        block = Condition.new(@left, '==', Condition.parse_expression(Regexp.last_match(1)))
+        block = Condition.new(@left, '==', Expression.parse(Regexp.last_match(1)))
         block.attach(body)
         @blocks << block
       end
@@ -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,25 +61,21 @@ module Liquid
       end
 
       @blocks.push(block)
-      block.attach(new_body)
-    end
-
-    def parse_expression(markup)
-      Condition.parse_expression(markup)
+      block.attach(BlockBody.new)
     end
 
     def lax_parse(markup)
       expressions = markup.scan(ExpressionsAndOperators)
       raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
 
-      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+      condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
 
       until expressions.empty?
         operator = expressions.pop.to_s.strip
 
         raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
 
-        new_condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+        new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
         raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
         new_condition.send(operator, condition)
         condition = new_condition
@@ -110,9 +103,9 @@ module Liquid
     end
 
     def parse_comparison(p)
-      a = parse_expression(p.expression)
+      a = Expression.parse(p.expression)
       if (op = p.consume?(:comparison))
-        b = parse_expression(p.expression)
+        b = Expression.parse(p.expression)
         Condition.new(a, op, b)
       else
         Condition.new(a)

lib/liquid/tags/include.rb

@@ -16,8 +16,6 @@ module Liquid
   #   {% include 'product' for products %}
   #
   class Include < Tag
-    prepend Tag::Disableable
-
     SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
     Syntax = SYNTAX
 

lib/liquid/template.rb

@@ -64,6 +64,23 @@ module Liquid
       attr_accessor :error_mode
       Template.error_mode = :lax
 
+      attr_reader :taint_mode
+
+      # Sets how strict the taint checker should be.
+      # :lax is the default, and ignores the taint flag completely
+      # :warn adds a warning, but does not interrupt the rendering
+      # :error raises an error when tainted output is used
+      # @deprecated Since it is being deprecated in ruby itself.
+      def taint_mode=(mode)
+        taint_supported = Object.new.taint.tainted?
+        if mode != :lax && !taint_supported
+          raise NotImplementedError, "#{RUBY_ENGINE} #{RUBY_VERSION} doesn't support taint checking"
+        end
+        @taint_mode = mode
+      end
+
+      Template.taint_mode = :lax
+
       attr_accessor :default_exception_renderer
       Template.default_exception_renderer = lambda do |exception|
         exception
@@ -80,6 +97,14 @@ module Liquid
         tags[name.to_s] = klass
       end
 
+      attr_accessor :registers
+      Template.registers = {}
+      private :registers=
+
+      def add_register(name, klass)
+        registers[name.to_sym] = klass
+      end
+
       # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
       def register_filter(mod)
@@ -94,13 +119,14 @@ module Liquid
       # To enable profiling, pass in <tt>profile: true</tt> as an option.
       # See Liquid::Profiler for more information
       def parse(source, options = {})
-        new.parse(source, options)
+        template = Template.new
+        template.parse(source, options)
       end
     end
 
     def initialize
       @rethrow_errors  = false
-      @resource_limits = ResourceLimits.new(Template.default_resource_limits)
+      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
     end
 
     # Parse source code.
@@ -186,6 +212,10 @@ module Liquid
         context.add_filters(args.pop)
       end
 
+      Template.registers.each do |key, register|
+        context_register[key] = register
+      end
+
       # Retrying a render resets resource usage
       context.resource_limits.reset
 

lib/liquid/variable.rb

@@ -86,7 +86,9 @@ module Liquid
         context.invoke(filter_name, output, *filter_args)
       end
 
-      context.apply_global_filter(obj)
+      obj = context.apply_global_filter(obj)
+      taint_check(context, obj)
+      obj
     end
 
     def render_to_output_buffer(context, output)
@@ -140,6 +142,25 @@ module Liquid
       parsed_args
     end
 
+    def taint_check(context, obj)
+      return if Template.taint_mode == :lax
+      return unless obj.tainted?
+
+      @markup =~ QuotedFragment
+      name = Regexp.last_match(0)
+
+      error               = TaintedError.new("variable '#{name}' is tainted and was not escaped")
+      error.line_number   = line_number
+      error.template_name = context.template_name
+
+      case Template.taint_mode
+      when :warn
+        context.warnings << error
+      when :error
+        raise error
+      end
+    end
+
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [@node.name] + @node.filters.flatten

liquid.gemspec

@@ -27,6 +27,6 @@ Gem::Specification.new do |s|
 
   s.require_path = "lib"
 
-  s.add_development_dependency('rake', '~> 13.0')
+  s.add_development_dependency('rake', '~> 11.3')
   s.add_development_dependency('minitest')
 end

test/integration/block_test.rb

@@ -11,48 +11,4 @@ class BlockTest < Minitest::Test
     end
     assert_equal(exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif")
   end
-
-  def test_with_custom_tag
-    with_custom_tag('testtag', Block) do
-      assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
-    end
-  end
-
-  def test_custom_block_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
-    klass1 = Class.new(Block) do
-      def render(*)
-        'hello'
-      end
-    end
-
-    with_custom_tag('blabla', klass1) do
-      template = Liquid::Template.parse("{% blabla %} bla {% endblabla %}")
-
-      assert_equal 'hello', template.render
-
-      buf    = +''
-      output = template.render({}, output: buf)
-      assert_equal 'hello', output
-      assert_equal 'hello', buf
-      assert_equal buf.object_id, output.object_id
-    end
-
-    klass2 = Class.new(klass1) do
-      def render(*)
-        'foo' + super + 'bar'
-      end
-    end
-
-    with_custom_tag('blabla', klass2) do
-      template = Liquid::Template.parse("{% blabla %} foo {% endblabla %}")
-
-      assert_equal 'foohellobar', template.render
-
-      buf    = +''
-      output = template.render({}, output: buf)
-      assert_equal 'foohellobar', output
-      assert_equal 'foohellobar', buf
-      assert_equal buf.object_id, output.object_id
-    end
-  end
 end

test/integration/drop_test.rb

@@ -49,6 +49,10 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
+  def user_input
+    (+"foo").taint
+  end
+
   protected
 
   def callmenot
@@ -110,6 +114,34 @@ class DropsTest < Minitest::Test
     assert_equal('  ', tpl.render!('product' => ProductDrop.new))
   end
 
+  if taint_supported?
+    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 }}')
+        context = Context.new('product' => ProductDrop.new)
+        tpl.render!(context)
+        assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
+        assert_equal "variable 'product.user_input' is tainted and was not escaped", context.warnings.first.to_s(false)
+      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
+  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))
@@ -249,7 +281,7 @@ class DropsTest < Minitest::Test
   end
 
   def test_invokable_methods
-    assert_equal(%w(to_liquid catchall context texts).to_set, ProductDrop.invokable_methods)
+    assert_equal(%w(to_liquid catchall user_input context texts).to_set, ProductDrop.invokable_methods)
     assert_equal(%w(to_liquid scopes_as_array loop_pos scopes).to_set, ContextDrop.invokable_methods)
     assert_equal(%w(to_liquid size max min first count).to_set, EnumerableDrop.invokable_methods)
     assert_equal(%w(to_liquid max min sort count first).to_set, RealEnumerableDrop.invokable_methods)

test/integration/error_handling_test.rb

@@ -261,12 +261,4 @@ class ErrorHandlingTest < Minitest::Test
     assert_equal("Argument error:\nLiquid error (product line 1): argument error", page)
     assert_equal("product", template.errors.first.template_name)
   end
-
-  def test_bug_compatible_silencing_of_errors_in_blank_nodes
-    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}not blank{% assign x = 3 %}{% endif %}{{ x }}").render
-    assert_equal("Liquid error: comparison of Integer with String failed0", output)
-
-    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}{% assign x = 3 %}{% endif %}{{ x }}").render
-    assert_equal("0", output)
-  end
 end

test/integration/parse_tree_visitor_test.rb

@@ -238,7 +238,7 @@ class ParseTreeVisitorTest < Minitest::Test
   def traversal(template)
     ParseTreeVisitor
       .for(Template.parse(template).root)
-      .add_callback_for(VariableLookup) { |node| node.name } # rubocop:disable Style/SymbolProc
+      .add_callback_for(VariableLookup, &:name)
   end
 
   def visit(template)

test/integration/registers/disabled_tags_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class DisabledTagsTest < Minitest::Test
+  include Liquid
+
+  class DisableRaw < Block
+    disable_tags "raw"
+  end
+
+  class DisableRawEcho < Block
+    disable_tags "raw", "echo"
+  end
+
+  def test_disables_raw
+    with_custom_tag('disable', DisableRaw) do
+      assert_template_result 'raw usage is not allowed in this contextfoo', '{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}'
+    end
+  end
+
+  def test_disables_echo_and_raw
+    with_custom_tag('disable', DisableRawEcho) do
+      assert_template_result 'raw usage is not allowed in this contextecho usage is not allowed in this context', '{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}'
+    end
+  end
+end

test/integration/security_test.rb

@@ -43,22 +43,15 @@ class SecurityTest < Minitest::Test
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: SecurityFilter))
   end
 
-  def test_does_not_permanently_add_filters_to_symbol_table
+  def test_does_not_add_filters_to_symbol_table
     current_symbols = Symbol.all_symbols
 
-    # MRI imprecisely marks objects found on the C stack, which can result
-    # in uninitialized memory being marked. This can even result in the test failing
-    # deterministically for a given compilation of ruby. Using a separate thread will
-    # keep these writes of the symbol pointer on a separate stack that will be garbage
-    # collected after Thread#join.
-    Thread.new do
-      test = %( {{ "some_string" | a_bad_filter }} )
-      Template.parse(test).render!
-      nil
-    end.join
+    test = %( {{ "some_string" | a_bad_filter }} )
 
-    GC.start
+    template = Template.parse(test)
+    assert_equal([], (Symbol.all_symbols - current_symbols))
 
+    template.render!
     assert_equal([], (Symbol.all_symbols - current_symbols))
   end
 

test/integration/tag/disableable_test.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TagDisableableTest < Minitest::Test
-  include Liquid
-
-  class DisableRaw < Block
-    disable_tags "raw"
-  end
-
-  class DisableRawEcho < Block
-    disable_tags "raw", "echo"
-  end
-
-  class DisableableRaw < Liquid::Raw
-    prepend Liquid::Tag::Disableable
-  end
-
-  class DisableableEcho < Liquid::Echo
-    prepend Liquid::Tag::Disableable
-  end
-
-  def test_disables_raw
-    with_disableable_tags do
-      with_custom_tag('disable', DisableRaw) do
-        output = Template.parse('{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}').render
-        assert_equal('Liquid error: raw usage is not allowed in this contextfoo', output)
-      end
-    end
-  end
-
-  def test_disables_echo_and_raw
-    with_disableable_tags do
-      with_custom_tag('disable', DisableRawEcho) do
-        output = Template.parse('{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}').render
-        assert_equal('Liquid error: raw usage is not allowed in this contextLiquid error: echo usage is not allowed in this context', output)
-      end
-    end
-  end
-
-  private
-
-  def with_disableable_tags
-    with_custom_tag('raw', DisableableRaw) do
-      with_custom_tag('echo', DisableableEcho) do
-        yield
-      end
-    end
-  end
-end

test/integration/tag_test.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TagTest < Minitest::Test
-  include Liquid
-
-  def test_custom_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
-    klass1 = Class.new(Tag) do
-      def render(*)
-        'hello'
-      end
-    end
-
-    with_custom_tag('blabla', klass1) do
-      template = Liquid::Template.parse("{% blabla %}")
-
-      assert_equal 'hello', template.render
-
-      buf    = +''
-      output = template.render({}, output: buf)
-      assert_equal 'hello', output
-      assert_equal 'hello', buf
-      assert_equal buf.object_id, output.object_id
-    end
-
-    klass2 = Class.new(klass1) do
-      def render(*)
-        'foo' + super + 'bar'
-      end
-    end
-
-    with_custom_tag('blabla', klass2) do
-      template = Liquid::Template.parse("{% blabla %}")
-
-      assert_equal 'foohellobar', template.render
-
-      buf    = +''
-      output = template.render({}, output: buf)
-      assert_equal 'foohellobar', output
-      assert_equal 'foohellobar', buf
-      assert_equal buf.object_id, output.object_id
-    end
-  end
-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/tags/render_tag_test.rb

@@ -42,6 +42,34 @@ class RenderTagTest < Minitest::Test
     assert_template_result('', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}")
   end
 
+  if taint_supported?
+    def test_render_sets_the_correct_template_name_for_errors
+      Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
+
+      with_taint_mode :error do
+        template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
+        context  = Context.new('unsafe' => (+'unsafe').tap(&:taint))
+        template.render(context)
+
+        assert_equal [Liquid::TaintedError], template.errors.map(&:class)
+        assert_equal 'snippet', template.errors.first.template_name
+      end
+    end
+
+    def test_render_sets_the_correct_template_name_for_warnings
+      Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
+
+      with_taint_mode :warn do
+        template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
+        context  = Context.new('unsafe' => (+'unsafe').tap(&:taint))
+        template.render(context)
+
+        assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
+        assert_equal 'snippet', context.warnings.first.template_name
+      end
+    end
+  end
+
   def test_render_does_not_mutate_parent_scope
     Liquid::Template.file_system = StubFileSystem.new('snippet' => '{% assign inner = 1 %}')
     assert_template_result('', "{% render 'snippet' %}{{ inner }}")
@@ -127,10 +155,7 @@ class RenderTagTest < Minitest::Test
       'test_include' => '{% include "foo" %}'
     )
 
-    exc = assert_raises(Liquid::DisabledError) do
-      Liquid::Template.parse('{% render "test_include" %}').render!
-    end
-    assert_equal('Liquid error: include usage is not allowed in this context', exc.message)
+    assert_template_result('include usage is not allowed in this context', '{% render "test_include" %}')
   end
 
   def test_includes_will_not_render_inside_nested_sibling_tags
@@ -140,8 +165,7 @@ class RenderTagTest < Minitest::Test
       'test_include' => '{% include "foo" %}'
     )
 
-    output = Liquid::Template.parse('{% render "nested_render_with_sibling_include" %}').render
-    assert_equal('Liquid error: include usage is not allowed in this contextLiquid error: include usage is not allowed in this context', output)
+    assert_template_result('include usage is not allowed in this contextinclude usage is not allowed in this context', '{% render "nested_render_with_sibling_include" %}')
   end
 
   def test_render_tag_with

test/integration/template_test.rb

@@ -111,24 +111,25 @@ class TemplateTest < Minitest::Test
 
   def test_resource_limits_render_length
     t = Template.parse("0123456789")
-    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 = 5
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.render_length_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
     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 memory limit error: #{Liquid::MemoryError::RENDER_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.render_score_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 memory limit error: #{Liquid::MemoryError::RENDER_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.render_score_reached?)
 
     t.resource_limits.render_score_limit = 200
     assert_equal((" foo " * 100), t.render!)
@@ -138,8 +139,8 @@ class TemplateTest < Minitest::Test
   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?)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::ASSIGN_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.assign_score_reached?)
 
     t.resource_limits.assign_score_limit = 2
     assert_equal("", t.render!)
@@ -160,8 +161,8 @@ class TemplateTest < Minitest::Test
     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?)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::ASSIGN_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.assign_score_reached?)
 
     t.resource_limits.assign_score_limit = 5
     assert_equal("", t.render!)
@@ -170,51 +171,55 @@ class TemplateTest < Minitest::Test
   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 memory limit error: #{Liquid::MemoryError::RENDER_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.render_score_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) %}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
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    t.resource_limits.render_length_limit = 4
+    t.resource_limits.render_length_limit = 7
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    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
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    t.resource_limits.render_length_limit = 7
+    t.resource_limits.render_length_limit = 13
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    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
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    t.resource_limits.render_length_limit = 11
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", 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
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    t.resource_limits.render_length_limit = 9
+    t.resource_limits.render_length_limit = 10
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    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
@@ -356,4 +361,12 @@ class TemplateTest < Minitest::Test
     result = t.render('x' => 1, 'y' => 5)
     assert_equal('12345', result)
   end
+
+  unless taint_supported?
+    def test_taint_mode
+      assert_raises(NotImplementedError) do
+        Template.taint_mode = :warn
+      end
+    end
+  end
 end

test/test_helper.rb

@@ -32,6 +32,10 @@ module Minitest
     def fixture(name)
       File.join(File.expand_path(__dir__), "fixtures", name)
     end
+
+    def self.taint_supported?
+      Object.new.taint.tainted?
+    end
   end
 
   module Assertions
@@ -89,6 +93,14 @@ module Minitest
       Liquid::StrainerFactory.instance_variable_set(:@global_filters, original_global_filters)
     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
+    end
+
     def with_error_mode(mode)
       old_mode = Liquid::Template.error_mode
       Liquid::Template.error_mode = mode
@@ -98,17 +110,10 @@ module Minitest
     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
+      Liquid::Template.register_tag(tag_name, tag_class)
+      yield
+    ensure
+      Liquid::Template.tags.delete(tag_name)
     end
   end
 end

test/unit/block_unit_test.rb

@@ -45,9 +45,53 @@ class BlockUnitTest < Minitest::Test
     assert_equal(3, template.root.nodelist.size)
   end
 
+  def test_with_custom_tag
+    with_custom_tag('testtag', Block) do
+      assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
+    end
+  end
+
+  def test_custom_block_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
+    klass1 = Class.new(Block) do
+      def render(*)
+        'hello'
+      end
+    end
+
+    with_custom_tag('blabla', klass1) do
+      template = Liquid::Template.parse("{% blabla %} bla {% endblabla %}")
+
+      assert_equal 'hello', template.render
+
+      buf    = +''
+      output = template.render({}, output: buf)
+      assert_equal 'hello', output
+      assert_equal 'hello', buf
+      assert_equal buf.object_id, output.object_id
+    end
+
+    klass2 = Class.new(klass1) do
+      def render(*)
+        'foo' + super + 'bar'
+      end
+    end
+
+    with_custom_tag('blabla', klass2) do
+      template = Liquid::Template.parse("{% blabla %} foo {% endblabla %}")
+
+      assert_equal 'foohellobar', template.render
+
+      buf    = +''
+      output = template.render({}, output: buf)
+      assert_equal 'foohellobar', output
+      assert_equal 'foohellobar', buf
+      assert_equal buf.object_id, output.object_id
+    end
+  end
+
   private
 
   def block_types(nodelist)
     nodelist.collect(&:class)
   end
-end
+end # VariableTest

test/unit/context_unit_test.rb

@@ -65,7 +65,7 @@ class ArrayLike
   end
 end
 
-class ContextTest < Minitest::Test
+class ContextUnitTest < Minitest::Test
   include Liquid
 
   def setup
@@ -563,35 +563,6 @@ class ContextTest < Minitest::Test
     assert_equal('my filter result', template.render(subcontext))
   end
 
-  def test_disables_tag_specified
-    context = Context.new
-    context.with_disabled_tags(%w(foo bar)) do
-      assert_equal true, context.tag_disabled?("foo")
-      assert_equal true, context.tag_disabled?("bar")
-      assert_equal false, context.tag_disabled?("unknown")
-    end
-  end
-
-  def test_disables_nested_tags
-    context = Context.new
-    context.with_disabled_tags(["foo"]) do
-      context.with_disabled_tags(["foo"]) do
-        assert_equal true, context.tag_disabled?("foo")
-        assert_equal false, context.tag_disabled?("bar")
-      end
-      context.with_disabled_tags(["bar"]) do
-        assert_equal true, context.tag_disabled?("foo")
-        assert_equal true, context.tag_disabled?("bar")
-        context.with_disabled_tags(["foo"]) do
-          assert_equal true, context.tag_disabled?("foo")
-          assert_equal true, context.tag_disabled?("bar")
-        end
-      end
-      assert_equal true, context.tag_disabled?("foo")
-      assert_equal false, context.tag_disabled?("bar")
-    end
-  end
-
   private
 
   def assert_no_object_allocations

test/unit/registers/disabled_tags_unit_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class DisabledTagsUnitTest < Minitest::Test
+  include Liquid
+
+  def test_disables_tag_specified
+    register = DisabledTags.new
+    register.disable(%w(foo bar)) do
+      assert_equal true, register.disabled?("foo")
+      assert_equal true, register.disabled?("bar")
+      assert_equal false, register.disabled?("unknown")
+    end
+  end
+
+  def test_disables_nested_tags
+    register = DisabledTags.new
+    register.disable(["foo"]) do
+      register.disable(["foo"]) do
+        assert_equal true, register.disabled?("foo")
+        assert_equal false, register.disabled?("bar")
+      end
+      register.disable(["bar"]) do
+        assert_equal true, register.disabled?("foo")
+        assert_equal true, register.disabled?("bar")
+        register.disable(["foo"]) do
+          assert_equal true, register.disabled?("foo")
+          assert_equal true, register.disabled?("bar")
+        end
+      end
+      assert_equal true, register.disabled?("foo")
+      assert_equal false, register.disabled?("bar")
+    end
+  end
+end

test/unit/static_registers_unit_test.rb

@@ -5,152 +5,244 @@ require 'test_helper'
 class StaticRegistersUnitTest < Minitest::Test
   include Liquid
 
-  def test_set
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
+  def set
+    static_register        = StaticRegisters.new
+    static_register[nil]   = true
+    static_register[1]     = :one
+    static_register[:one]  = "one"
+    static_register["two"] = "three"
+    static_register["two"] = 3
+    static_register[false] = nil
 
-    assert_equal(1, static_register[:a])
-    assert_equal(22, static_register[:b])
-    assert_equal(33, static_register[:c])
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.registers)
+
+    static_register
   end
 
-  def test_get_missing_key
-    static_register = StaticRegisters.new
+  def test_get
+    static_register = set
 
-    assert_nil(static_register[:missing])
+    assert_equal(true, static_register[nil])
+    assert_equal(:one, static_register[1])
+    assert_equal("one", static_register[:one])
+    assert_equal(3, static_register["two"])
+    assert_nil(static_register[false])
+    assert_nil(static_register["unknown"])
   end
 
   def test_delete
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
+    static_register = set
 
-    assert_nil(static_register.delete(:a))
+    assert_equal(true, static_register.delete(nil))
+    assert_equal(:one, static_register.delete(1))
+    assert_equal("one", static_register.delete(:one))
+    assert_equal(3, static_register.delete("two"))
+    assert_nil(static_register.delete(false))
+    assert_nil(static_register.delete("unknown"))
 
-    assert_equal(22, static_register.delete(:b))
-
-    assert_equal(33, static_register.delete(:c))
-    assert_nil(static_register[:c])
-
-    assert_nil(static_register.delete(:d))
+    assert_equal({}, static_register.registers)
   end
 
   def test_fetch
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
+    static_register = set
 
-    assert_equal(1, static_register.fetch(:a))
-    assert_equal(1, static_register.fetch(:a, "default"))
-    assert_equal(22, static_register.fetch(:b))
-    assert_equal(22, static_register.fetch(:b, "default"))
-    assert_equal(33, static_register.fetch(:c))
-    assert_equal(33, static_register.fetch(:c, "default"))
+    assert_equal(true, static_register.fetch(nil))
+    assert_equal(:one, static_register.fetch(1))
+    assert_equal("one", static_register.fetch(:one))
+    assert_equal(3, static_register.fetch("two"))
+    assert_nil(static_register.fetch(false))
+    assert_nil(static_register.fetch("unknown"))
+  end
 
-    assert_raises(KeyError) do
-      static_register.fetch(:d)
-    end
-    assert_equal("default", static_register.fetch(:d, "default"))
+  def test_fetch_default
+    static_register = StaticRegisters.new
 
-    result = static_register.fetch(:d) { "default" }
-    assert_equal("default", result)
-
-    result = static_register.fetch(:d, "default 1") { "default 2" }
-    assert_equal("default 2", result)
+    assert_equal(true, static_register.fetch(nil, true))
+    assert_equal(:one, static_register.fetch(1, :one))
+    assert_equal("one", static_register.fetch(:one, "one"))
+    assert_equal(3, static_register.fetch("two", 3))
+    assert_nil(static_register.fetch(false, nil))
   end
 
   def test_key
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
+    static_register = set
 
-    assert_equal(true, static_register.key?(:a))
-    assert_equal(true, static_register.key?(:b))
-    assert_equal(true, static_register.key?(:c))
-    assert_equal(false, static_register.key?(:d))
+    assert_equal(true, static_register.key?(nil))
+    assert_equal(true, static_register.key?(1))
+    assert_equal(true, static_register.key?(:one))
+    assert_equal(true, static_register.key?("two"))
+    assert_equal(true, static_register.key?(false))
+    assert_equal(false, static_register.key?("unknown"))
+    assert_equal(false, static_register.key?(true))
+  end
+
+  def set_with_static
+    static_register        = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
+    static_register[nil]   = false
+    static_register["two"] = 4
+    static_register[true]  = "foo"
+
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
+    assert_equal({ nil => false, "two" => 4, true => "foo" }, static_register.registers)
+
+    static_register
+  end
+
+  def test_get_with_static
+    static_register = set_with_static
+
+    assert_equal(false, static_register[nil])
+    assert_equal(:one, static_register[1])
+    assert_equal("one", static_register[:one])
+    assert_equal(4, static_register["two"])
+    assert_equal("foo", static_register[true])
+    assert_nil(static_register[false])
+  end
+
+  def test_delete_with_static
+    static_register = set_with_static
+
+    assert_equal(false, static_register.delete(nil))
+    assert_equal(4, static_register.delete("two"))
+    assert_equal("foo", static_register.delete(true))
+    assert_nil(static_register.delete("unknown"))
+    assert_nil(static_register.delete(:one))
+
+    assert_equal({}, static_register.registers)
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
+  end
+
+  def test_fetch_with_static
+    static_register = set_with_static
+
+    assert_equal(false, static_register.fetch(nil))
+    assert_equal(:one, static_register.fetch(1))
+    assert_equal("one", static_register.fetch(:one))
+    assert_equal(4, static_register.fetch("two"))
+    assert_equal("foo", static_register.fetch(true))
+    assert_nil(static_register.fetch(false))
+  end
+
+  def test_key_with_static
+    static_register = set_with_static
+
+    assert_equal(true, static_register.key?(nil))
+    assert_equal(true, static_register.key?(1))
+    assert_equal(true, static_register.key?(:one))
+    assert_equal(true, static_register.key?("two"))
+    assert_equal(true, static_register.key?(false))
+    assert_equal(false, static_register.key?("unknown"))
+    assert_equal(true, static_register.key?(true))
   end
 
   def test_static_register_can_be_frozen
-    static_register = StaticRegisters.new(a: 1)
+    static_register = set_with_static
 
-    static_register.static.freeze
+    static = static_register.static.freeze
 
     assert_raises(RuntimeError) do
-      static_register.static[:a] = "foo"
+      static["two"] = "foo"
     end
 
     assert_raises(RuntimeError) do
-      static_register.static[:b] = "foo"
+      static["unknown"] = "foo"
     end
 
     assert_raises(RuntimeError) do
-      static_register.static.delete(:a)
-    end
-
-    assert_raises(RuntimeError) do
-      static_register.static.delete(:c)
+      static.delete("two")
     end
   end
 
   def test_new_static_retains_static
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
+    static_register          = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
+    static_register["one"]   = 1
+    static_register["two"]   = 2
+    static_register["three"] = 3
 
-    new_static_register = StaticRegisters.new(static_register)
-    new_static_register[:b] = 222
+    new_register = StaticRegisters.new(static_register)
+    assert_equal({}, new_register.registers)
 
-    newest_static_register = StaticRegisters.new(new_static_register)
-    newest_static_register[:c] = 333
+    new_register["one"]   = 4
+    new_register["two"]   = 5
+    new_register["three"] = 6
 
-    assert_equal(1, static_register[:a])
-    assert_equal(22, static_register[:b])
-    assert_equal(33, static_register[:c])
+    newest_register = StaticRegisters.new(new_register)
+    assert_equal({}, newest_register.registers)
 
-    assert_equal(1, new_static_register[:a])
-    assert_equal(222, new_static_register[:b])
-    assert_nil(new_static_register[:c])
+    newest_register["one"]   = 7
+    newest_register["two"]   = 8
+    newest_register["three"] = 9
 
-    assert_equal(1, newest_static_register[:a])
-    assert_equal(2, newest_static_register[:b])
-    assert_equal(333, newest_static_register[:c])
+    assert_equal({ "one" => 1, "two" => 2, "three" => 3 }, static_register.registers)
+    assert_equal({ "one" => 4, "two" => 5, "three" => 6 }, new_register.registers)
+    assert_equal({ "one" => 7, "two" => 8, "three" => 9 }, newest_register.registers)
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, new_register.static)
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, newest_register.static)
   end
 
   def test_multiple_instances_are_unique
-    static_register_1 = StaticRegisters.new(a: 1, b: 2)
-    static_register_1[:b] = 22
-    static_register_1[:c] = 33
+    static_register          = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
+    static_register["one"]   = 1
+    static_register["two"]   = 2
+    static_register["three"] = 3
 
-    static_register_2 = StaticRegisters.new(a: 10, b: 20)
-    static_register_2[:b] = 220
-    static_register_2[:c] = 330
+    new_register = StaticRegisters.new(foo: :bar)
+    assert_equal({}, new_register.registers)
 
-    assert_equal({ a: 1, b: 2 }, static_register_1.static)
-    assert_equal(1, static_register_1[:a])
-    assert_equal(22, static_register_1[:b])
-    assert_equal(33, static_register_1[:c])
+    new_register["one"]   = 4
+    new_register["two"]   = 5
+    new_register["three"] = 6
 
-    assert_equal({ a: 10, b: 20 }, static_register_2.static)
-    assert_equal(10, static_register_2[:a])
-    assert_equal(220, static_register_2[:b])
-    assert_equal(330, static_register_2[:c])
+    newest_register = StaticRegisters.new(bar: :foo)
+    assert_equal({}, newest_register.registers)
+
+    newest_register["one"]   = 7
+    newest_register["two"]   = 8
+    newest_register["three"] = 9
+
+    assert_equal({ "one" => 1, "two" => 2, "three" => 3 }, static_register.registers)
+    assert_equal({ "one" => 4, "two" => 5, "three" => 6 }, new_register.registers)
+    assert_equal({ "one" => 7, "two" => 8, "three" => 9 }, newest_register.registers)
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
+    assert_equal({ foo: :bar }, new_register.static)
+    assert_equal({ bar: :foo }, newest_register.static)
   end
 
-  def test_initialization_reused_static_same_memory_object
-    static_register_1 = StaticRegisters.new(a: 1, b: 2)
-    static_register_1[:b] = 22
-    static_register_1[:c] = 33
+  def test_can_update_static_directly_and_updates_all_instances
+    static_register          = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
+    static_register["one"]   = 1
+    static_register["two"]   = 2
+    static_register["three"] = 3
 
-    static_register_2 = StaticRegisters.new(static_register_1)
+    new_register = StaticRegisters.new(static_register)
+    assert_equal({}, new_register.registers)
 
-    assert_equal(1, static_register_2[:a])
-    assert_equal(2, static_register_2[:b])
-    assert_nil(static_register_2[:c])
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
 
-    static_register_1.static[:b] = 222
-    static_register_1.static[:c] = 333
+    new_register["one"]         = 4
+    new_register["two"]         = 5
+    new_register["three"]       = 6
+    new_register.static["four"] = 10
 
-    assert_same(static_register_1.static, static_register_2.static)
+    newest_register = StaticRegisters.new(new_register)
+    assert_equal({}, newest_register.registers)
+
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 10 }, new_register.static)
+
+    newest_register["one"]      = 7
+    newest_register["two"]      = 8
+    newest_register["three"]    = 9
+    new_register.static["four"] = 5
+    new_register.static["five"] = 15
+
+    assert_equal({ "one" => 1, "two" => 2, "three" => 3 }, static_register.registers)
+    assert_equal({ "one" => 4, "two" => 5, "three" => 6 }, new_register.registers)
+    assert_equal({ "one" => 7, "two" => 8, "three" => 9 }, newest_register.registers)
+
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 5, "five" => 15 }, newest_register.static)
+
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 5, "five" => 15 }, static_register.static)
+    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 5, "five" => 15 }, new_register.static)
   end
 end

test/unit/tag_unit_test.rb

@@ -20,4 +20,42 @@ class TagUnitTest < Minitest::Test
     tag = Tag.parse("some_tag", "", Tokenizer.new(""), ParseContext.new)
     assert_equal('some_tag', tag.tag_name)
   end
+
+  def test_custom_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
+    klass1 = Class.new(Tag) do
+      def render(*)
+        'hello'
+      end
+    end
+
+    with_custom_tag('blabla', klass1) do
+      template = Liquid::Template.parse("{% blabla %}")
+
+      assert_equal 'hello', template.render
+
+      buf    = +''
+      output = template.render({}, output: buf)
+      assert_equal 'hello', output
+      assert_equal 'hello', buf
+      assert_equal buf.object_id, output.object_id
+    end
+
+    klass2 = Class.new(klass1) do
+      def render(*)
+        'foo' + super + 'bar'
+      end
+    end
+
+    with_custom_tag('blabla', klass2) do
+      template = Liquid::Template.parse("{% blabla %}")
+
+      assert_equal 'foohellobar', template.render
+
+      buf    = +''
+      output = template.render({}, output: buf)
+      assert_equal 'foohellobar', output
+      assert_equal 'foohellobar', buf
+      assert_equal buf.object_id, output.object_id
+    end
+  end
 end

test/unit/template_unit_test.rb

@@ -77,11 +77,4 @@ class TemplateUnitTest < Minitest::Test
   ensure
     Template.tags.delete('fake')
   end
-
-  class TemplateSubclass < Liquid::Template
-  end
-
-  def test_template_inheritance
-    assert_equal("foo", TemplateSubclass.parse("foo").render)
-  end
 end