Default Block#blank? to false regardless of whether the body is blank

.github/workflows/liquid.yml

@@ -1,40 +0,0 @@
-name: Liquid
-on: [push, pull_request]
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        entry:
-          - { ruby: 2.5, allowed-failure: false }
-          - { ruby: 2.6, allowed-failure: false }
-          - { ruby: 2.7, allowed-failure: false }
-          - { ruby: ruby-head, allowed-failure: true }
-    name: test (${{ matrix.entry.ruby }})
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.entry.ruby }}
-      - uses: actions/cache@v1
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
-          restore-keys: ${{ runner.os }}-gems-
-      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
-      - run: bundle exec rake
-        continue-on-error: ${{ matrix.entry.allowed-failure }}
-  memory_profile:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 2.7
-      - uses: actions/cache@v1
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
-          restore-keys: ${{ runner.os }}-gems-
-      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
-      - run: bundle exec rake memory_profile:run

.travis.yml

@@ -0,0 +1,26 @@
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.4
+  - 2.5
+  - 2.6
+  - &latest_ruby 2.7
+  - ruby-head
+
+matrix:
+  include:
+    - rvm: *latest_ruby
+      script: bundle exec rake memory_profile:run
+      name: Profiling Memory Usage
+  allow_failures:
+    - rvm: ruby-head
+
+branches:
+  only:
+    - master
+    - gh-pages
+    - /.*-stable/
+
+notifications:
+  disable: true

Rakefile

@@ -9,17 +9,11 @@ task(default: [:test, :rubocop])
 
 desc('run test suite with default parser')
 Rake::TestTask.new(:base_test) do |t|
-  t.libs << 'lib' << 'test'
+  t.libs << '.' << 'lib' << 'test'
   t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
   t.verbose    = false
 end
 
-Rake::TestTask.new(:integration_test) do |t|
-  t.libs << 'lib' << 'test'
-  t.test_files = FileList['test/integration/**/*_test.rb']
-  t.verbose    = false
-end
-
 desc('run test suite with warn error mode')
 task :warn_test do
   ENV['LIQUID_PARSER_MODE'] = 'warn'
@@ -46,12 +40,12 @@ task :test do
     ENV['LIQUID_C'] = '1'
 
     ENV['LIQUID_PARSER_MODE'] = 'lax'
-    Rake::Task['integration_test'].reenable
-    Rake::Task['integration_test'].invoke
+    Rake::Task['base_test'].reenable
+    Rake::Task['base_test'].invoke
 
     ENV['LIQUID_PARSER_MODE'] = 'strict'
-    Rake::Task['integration_test'].reenable
-    Rake::Task['integration_test'].invoke
+    Rake::Task['base_test'].reenable
+    Rake::Task['base_test'].invoke
   end
 end
 

lib/liquid.rb

@@ -42,8 +42,6 @@ module Liquid
   TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
 
-  RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
-
   singleton_class.send(:attr_accessor, :cache_classes)
   self.cache_classes = true
 end

lib/liquid/block.rb

@@ -4,16 +4,10 @@ module Liquid
   class Block < Tag
     MAX_DEPTH = 100
 
-    def initialize(tag_name, markup, options)
-      super
-      @blank = true
-    end
-
     def parse(tokens)
-      @body = new_body
+      @body = BlockBody.new
       while parse_body(@body, tokens)
       end
-      @body.freeze
     end
 
     # For backwards compatibility
@@ -21,16 +15,12 @@ module Liquid
       @body.render(context)
     end
 
-    def blank?
-      @blank
-    end
-
     def nodelist
       @body.nodelist
     end
 
-    def unknown_tag(tag_name, _markup, _tokenizer)
-      Block.raise_unknown_tag(tag_name, block_name, block_delimiter, parse_context)
+    def unknown_tag(tag, _params, _tokens)
+      Block.raise_unknown_tag(tag, block_name, block_delimiter, parse_context)
     end
 
     # @api private
@@ -48,10 +38,6 @@ module Liquid
       end
     end
 
-    def raise_tag_never_closed(block_name)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
-    end
-
     def block_name
       @tag_name
     end
@@ -60,14 +46,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"
@@ -75,13 +55,10 @@ module Liquid
       parse_context.depth += 1
       begin
         body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
-          @blank &&= body.blank?
-
-          # Instrument for bug 1346
-          Usage.increment("end_tag_params") if end_tag_params && !end_tag_params.empty?
-
           return false if end_tag_name == block_delimiter
-          raise_tag_never_closed(block_name) unless end_tag_name
+          unless end_tag_name
+            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
+          end
 
           # this tag is not registered with the system
           # pass it to the current block for special handling or error reporting

lib/liquid/block_body.rb

@@ -19,8 +19,6 @@ module Liquid
     end
 
     def parse(tokenizer, parse_context, &block)
-      raise FrozenError, "can't modify frozen Liquid::BlockBody" if frozen?
-
       parse_context.line_number = tokenizer.line_number
 
       if tokenizer.for_liquid_tag
@@ -30,11 +28,6 @@ module Liquid
       end
     end
 
-    def freeze
-      @nodelist.freeze
-      super
-    end
-
     private def parse_for_liquid_tag(tokenizer, parse_context)
       while (token = tokenizer.shift)
         unless token.empty? || token =~ WhitespaceOrNothing
@@ -65,39 +58,6 @@ module Liquid
       Block.raise_unknown_tag(tag, 'liquid', '%}', parse_context)
     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)
       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|
@@ -114,7 +74,7 @@ module Liquid
         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)
@@ -160,11 +120,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)
@@ -199,12 +155,12 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      freeze unless frozen?
-
-      context.resource_limits.increment_render_score(@nodelist.length)
+      context.resource_limits.render_score += @nodelist.length
 
       idx = 0
       while (node = @nodelist[idx])
+        previous_output_size = output.bytesize
+
         if node.instance_of?(String)
           output << node
         else
@@ -216,7 +172,7 @@ module Liquid
         end
         idx += 1
 
-        context.resource_limits.increment_write_score(output)
+        raise_if_resource_limits_reached(context, output.bytesize - previous_output_size)
       end
 
       output
@@ -225,7 +181,18 @@ 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)
@@ -233,17 +200,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,36 +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
-    end
-
-    @@method_literals = {
-      'blank' => MethodLiteral.new(:blank?, '').freeze,
-      'empty' => MethodLiteral.new(:empty?, '').freeze,
-    }
-
     def self.operators
       @@operators
     end
 
-    def self.parse_expression(parse_context, markup)
-      @@method_literals[markup] || parse_context.parse_expression(markup)
-    end
-
-    def self.strict_parse_expression(parse_context, p)
-      if p.look(:id) && !p.look(:dot, 1) && !p.look(:open_square, 1)
-        parse_expression(parse_context, p.consume)
-      else
-        p.expression
-      end
-    end
-
     attr_reader :attachment, :child_condition
     attr_accessor :left, :operator, :right
 
@@ -117,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
@@ -125,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

@@ -34,18 +34,17 @@ module Liquid
       @strict_variables    = false
       @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
       @base_scope_depth    = 0
-      @interrupts          = []
-      @filters             = []
-      @global_filter       = nil
-      @disabled_tags       = {}
+      squash_instance_assigns_with_environments
 
       self.exception_renderer = Template.default_exception_renderer
       if rethrow_errors
-        self.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
+        self.exception_renderer = ->(_e) { raise }
       end
 
-      # Do this last, since it could result in this object being passed to a Proc in the environment
-      squash_instance_assigns_with_environments
+      @interrupts    = []
+      @filters       = []
+      @global_filter = nil
+      @disabled_tags = {}
     end
     # rubocop:enable Metrics/ParameterLists
 

lib/liquid/document.rb

@@ -1,34 +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
-      @body.freeze
     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)
@@ -36,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/expression.rb

@@ -2,38 +2,48 @@
 
 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\s*'(.*)'\s*\z/m
-    DOUBLE_QUOTED_STRING = /\A\s*"(.*)"\s*\z/m
-    INTEGERS_REGEX       = /\A\s*(-?\d+)\s*\z/
-    FLOATS_REGEX         = /\A\s*(-?\d[\d\.]+)\s*\z/
-    RANGES_REGEX         = /\A\s*\(\s*(\S+)\s*\.\.\s*(\S+)\s*\)\s*\z/
+    SINGLE_QUOTED_STRING = /\A'(.*)'\z/m
+    DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m
+    INTEGERS_REGEX       = /\A(-?\d+)\z/
+    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/
+    RANGES_REGEX         = /\A\((\S+)\.\.(\S+)\)\z/
 
     def self.parse(markup)
-      case markup
-      when nil
-        nil
-      when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
-        Regexp.last_match(1)
-      when INTEGERS_REGEX
-        Regexp.last_match(1).to_i
-      when RANGES_REGEX
-        RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2))
-      when FLOATS_REGEX
-        Regexp.last_match(1).to_f
+      if LITERALS.key?(markup)
+        LITERALS[markup]
       else
-        markup = markup.strip
-        if LITERALS.key?(markup)
-          LITERALS[markup]
+        case markup
+        when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
+          Regexp.last_match(1)
+        when INTEGERS_REGEX
+          Regexp.last_match(1).to_i
+        when RANGES_REGEX
+          RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2))
+        when FLOATS_REGEX
+          Regexp.last_match(1).to_f
         else
-          VariableLookup.lax_parse(markup)
+          VariableLookup.parse(markup)
         end
       end
     end

lib/liquid/forloop_drop.rb

@@ -9,12 +9,7 @@ module Liquid
       @index      = 0
     end
 
-    attr_reader :length, :parentloop
-
-    def name
-      Usage.increment('forloop_drop_name')
-      @name
-    end
+    attr_reader :name, :length, :parentloop
 
     def index
       @index + 1

lib/liquid/locales/en.yml

@@ -20,6 +20,7 @@
       tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
       variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
       tag_never_closed: "'%{block_name}' tag was never closed"
+      meta_syntax_error: "Liquid syntax error: #{e.message}"
       table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
       render: "Syntax error in tag 'render' - Template name must be a quoted string"
     argument:

lib/liquid/parse_context.rb

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

lib/liquid/parser.rb

@@ -46,56 +46,50 @@ module Liquid
       tok[0] == type
     end
 
+    SINGLE_TOKEN_EXPRESSION_TYPES = [:string, :number].freeze
+    private_constant :SINGLE_TOKEN_EXPRESSION_TYPES
+
     def expression
       token = @tokens[@p]
-      case token[0]
-      when :id
-        if Expression::LITERALS.key?(token[1]) && !look(:dot, 1) && !look(:open_square, 1)
-          Expression::LITERALS[consume]
-        else
-          VariableLookup.strict_parse(self)
-        end
-      when :open_square
-        VariableLookup.strict_parse(self)
-      when :string
-        consume[1..-2]
-      when :number
-        num_str = consume
-        num_str.include?('.') ? num_str.to_f : num_str.to_i
-      when :open_round
+      if token[0] == :id
+        variable_signature
+      elsif SINGLE_TOKEN_EXPRESSION_TYPES.include?(token[0])
+        consume
+      elsif token.first == :open_round
         consume
         first = expression
         consume(:dotdot)
         last = expression
         consume(:close_round)
-        RangeLookup.build(first, last)
+        "(#{first}..#{last})"
       else
         raise SyntaxError, "#{token} is not a valid expression"
       end
     end
 
-    def arguments
-      filter_args = []
-      keyword_args = nil
-
-      loop do
-        # keyword argument (identifier: expression)
-        if look(:colon, 1)
-          keyword_args ||= {}
-          k = consume(:id)
-          consume
-          v = expression
-          keyword_args[k] = v
-        else
-          filter_args << expression
-        end
-
-        break unless consume?(:comma)
+    def argument
+      str = +""
+      # might be a keyword argument (identifier: expression)
+      if look(:id) && look(:colon, 1)
+        str << consume << consume << ' '
       end
 
-      result = [filter_args]
-      result << keyword_args if keyword_args
-      result
+      str << expression
+      str
+    end
+
+    def variable_signature
+      str = consume(:id)
+      while look(:open_square)
+        str << consume
+        str << expression
+        str << consume(:close_square)
+      end
+      if look(:dot)
+        str << consume
+        str << variable_signature
+      end
+      str
     end
   end
 end

lib/liquid/parser_switching.rb

@@ -2,18 +2,6 @@
 
 module Liquid
   module ParserSwitching
-    def strict_parse_with_error_mode_fallback(markup)
-      strict_parse_with_error_context(markup)
-    rescue SyntaxError => e
-      case parse_context.error_mode
-      when :strict
-        raise
-      when :warn
-        parse_context.warnings << e
-      end
-      lax_parse(markup)
-    end
-
     def parse_with_selected_parser(markup)
       case parse_context.error_mode
       when :strict then strict_parse_with_error_context(markup)

lib/liquid/range_lookup.rb

@@ -5,43 +5,35 @@ module Liquid
     def self.parse(start_markup, end_markup)
       start_obj = Expression.parse(start_markup)
       end_obj   = Expression.parse(end_markup)
-      build(start_obj, end_obj)
-    end
-
-    def self.build(start_obj, end_obj)
       if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
         new(start_obj, end_obj)
       else
-        to_integer(start_obj)..to_integer(end_obj)
+        start_obj.to_i..end_obj.to_i
       end
     end
 
-    def self.to_integer(input)
+    def initialize(start_obj, end_obj)
+      @start_obj = start_obj
+      @end_obj   = end_obj
+    end
+
+    def evaluate(context)
+      start_int = to_integer(context.evaluate(@start_obj))
+      end_int   = to_integer(context.evaluate(@end_obj))
+      start_int..end_int
+    end
+
+    private
+
+    def to_integer(input)
       case input
       when Integer
         input
-      when NilClass, String, Float
+      when NilClass, String
         input.to_i
       else
         Utils.to_integer(input)
       end
     end
-
-    attr_reader :start_expr, :end_expr
-
-    def initialize(start_expr, end_expr)
-      @start_expr = start_expr
-      @end_expr   = end_expr
-    end
-
-    def evaluate(context)
-      start_int = self.class.to_integer(context.evaluate(@start_expr))
-      end_int   = self.class.to_integer(context.evaluate(@end_expr))
-      start_int..end_int
-    end
-
-    def ==(other)
-      self.class == other.class && start_expr == other.start_expr && end_expr == other.end_expr
-    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/tag.rb

@@ -55,11 +55,5 @@ module Liquid
     def blank?
       false
     end
-
-    private
-
-    def parse_expression(markup)
-      parse_context.parse_expression(markup)
-    end
   end
 end

lib/liquid/tags/assign.rb

@@ -12,27 +12,22 @@ module Liquid
   class Assign < Tag
     Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
-    # @api private
-    def self.raise_syntax_error(parse_context)
-      raise Liquid::SyntaxError, parse_context.locale.t('errors.syntax.assign')
-    end
-
     attr_reader :to, :from
 
-    def initialize(tag_name, markup, parse_context)
+    def initialize(tag_name, markup, options)
       super
       if markup =~ Syntax
         @to   = Regexp.last_match(1)
-        @from = Variable.new(Regexp.last_match(2), parse_context)
+        @from = Variable.new(Regexp.last_match(2), options)
       else
-        self.class.raise_syntax_error(parse_context)
+        raise SyntaxError, options[:locale].t('errors.syntax.assign')
       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
 
@@ -45,18 +40,11 @@ module Liquid
     def assign_score_of(val)
       if val.instance_of?(String)
         val.bytesize
-      elsif val.instance_of?(Array)
+      elsif val.instance_of?(Array) || val.instance_of?(Hash)
         sum = 1
         # Uses #each to avoid extra allocations.
         val.each { |child| sum += assign_score_of(child) }
         sum
-      elsif val.instance_of?(Hash)
-        sum = 1
-        val.each do |key, entry_value|
-          sum += assign_score_of(key)
-          sum += assign_score_of(entry_value)
-        end
-        sum
       else
         1
       end

lib/liquid/tags/capture.rb

@@ -25,10 +25,9 @@ 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
+      capture_output = render(context)
+      context.scopes.last[@to] = capture_output
+      context.resource_limits.assign_score += capture_output.bytesize
       output
     end
 

lib/liquid/tags/case.rb

@@ -12,24 +12,25 @@ module Liquid
       @blocks = []
 
       if markup =~ Syntax
-        @left = parse_expression(Regexp.last_match(1))
+        @left = Expression.parse(Regexp.last_match(1))
       else
         raise SyntaxError, options[:locale].t("errors.syntax.case")
       end
     end
 
     def parse(tokens)
-      body = new_body
+      body = BlockBody.new
       body = @blocks.last.attachment while parse_body(body, tokens)
-      @blocks.each do |condition|
-        body = condition.attachment
-        unless body.frozen?
-          body.remove_blank_strings if blank?
-          body.freeze
-        end
+      @blank = @blocks.all? { |condition| condition.attachment.blank? }
+      if @blank
+        @blocks.each { |condition| condition.attachment.remove_blank_strings }
       end
     end
 
+    def blank?
+      @blank
+    end
+
     def nodelist
       @blocks.map(&:attachment)
     end
@@ -63,7 +64,7 @@ module Liquid
     private
 
     def record_when_condition(markup)
-      body = new_body
+      body = BlockBody.new
 
       while markup
         unless markup =~ WhenSyntax
@@ -72,7 +73,7 @@ module Liquid
 
         markup = Regexp.last_match(2)
 
-        block = Condition.new(@left, '==', Condition.parse_expression(parse_context, Regexp.last_match(1)))
+        block = Condition.new(@left, '==', Expression.parse(Regexp.last_match(1)))
         block.attach(body)
         @blocks << block
       end
@@ -84,7 +85,7 @@ module Liquid
       end
 
       block = ElseCondition.new
-      block.attach(new_body)
+      block.attach(BlockBody.new)
       @blocks << block
     end
 

lib/liquid/tags/cycle.rb

@@ -24,7 +24,7 @@ module Liquid
       case markup
       when NamedSyntax
         @variables = variables_from_string(Regexp.last_match(2))
-        @name      = parse_expression(Regexp.last_match(1))
+        @name      = Expression.parse(Regexp.last_match(1))
       when SimpleSyntax
         @variables = variables_from_string(markup)
         @name      = @variables.to_s
@@ -61,7 +61,7 @@ module Liquid
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        Regexp.last_match(1) ? parse_expression(Regexp.last_match(1)) : nil
+        Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
       end.compact
     end
 

lib/liquid/tags/for.rb

@@ -54,7 +54,7 @@ module Liquid
       super
       @from = @limit = nil
       parse_with_selected_parser(markup)
-      @for_block = new_body
+      @for_block = BlockBody.new
       @else_block = nil
     end
 
@@ -62,12 +62,15 @@ module Liquid
       if parse_body(@for_block, tokens)
         parse_body(@else_block, tokens)
       end
-      if blank?
+      @blank = @for_block.blank? && (@else_block.nil? || @else_block.blank?)
+      if @blank
         @for_block.remove_blank_strings
         @else_block&.remove_blank_strings
       end
-      @for_block.freeze
-      @else_block&.freeze
+    end
+
+    def blank?
+      @blank
     end
 
     def nodelist
@@ -76,7 +79,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)
@@ -99,7 +102,7 @@ module Liquid
         collection_name  = Regexp.last_match(2)
         @reversed        = !!Regexp.last_match(3)
         @name            = "#{@variable_name}-#{collection_name}"
-        @collection_name = parse_expression(collection_name)
+        @collection_name = Expression.parse(collection_name)
         markup.scan(TagAttributes) do |key, value|
           set_attribute(key, value)
         end
@@ -113,9 +116,10 @@ module Liquid
       @variable_name = p.consume(:id)
       raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
 
-      @collection_name = p.expression
+      collection_name  = p.expression
+      @collection_name = Expression.parse(collection_name)
 
-      @name     = "#{@variable_name}-#{@collection_name}"
+      @name     = "#{@variable_name}-#{collection_name}"
       @reversed = p.id?('reversed')
 
       while p.look(:id) && p.look(:colon, 1)
@@ -123,18 +127,7 @@ module Liquid
           raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
         end
         p.consume
-        case attribute
-        when 'offset'
-          @from =
-            if p.id?('continue')
-              Usage.increment('for_offset_continue')
-              :continue
-            else
-              p.expression
-            end
-        when 'limit'
-          @limit = p.expression
-        end
+        set_attribute(attribute, p.expression)
       end
       p.consume(:end_of_string)
     end
@@ -208,13 +201,12 @@ module Liquid
       case key
       when 'offset'
         @from = if expr == 'continue'
-          Usage.increment('for_offset_continue')
           :continue
         else
-          parse_expression(expr)
+          Expression.parse(expr)
         end
       when 'limit'
-        @limit = parse_expression(expr)
+        @limit = Expression.parse(expr)
       end
     end
 

lib/liquid/tags/if.rb

@@ -31,17 +31,18 @@ module Liquid
     def parse(tokens)
       while parse_body(@blocks.last.attachment, tokens)
       end
-      @blocks.each do |block|
-        block.attachment.remove_blank_strings if blank?
-        block.attachment.freeze
+      @blank = @blocks.all? { |condition| condition.attachment.blank? }
+      if @blank
+        @blocks.each { |condition| condition.attachment.remove_blank_strings }
       end
     end
 
-    ELSE_TAG_NAMES = ['elsif', 'else'].freeze
-    private_constant :ELSE_TAG_NAMES
+    def blank?
+      @blank
+    end
 
     def unknown_tag(tag, markup, tokens)
-      if ELSE_TAG_NAMES.include?(tag)
+      if ['elsif', 'else'].include?(tag)
         push_block(tag, markup)
       else
         super
@@ -68,29 +69,21 @@ module Liquid
       end
 
       @blocks.push(block)
-      block.attach(new_body)
-    end
-
-    def parse_expression(markup)
-      Condition.parse_expression(parse_context, markup)
-    end
-
-    def strict_parse_expression(p)
-      Condition.strict_parse_expression(parse_context, p)
+      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
@@ -118,9 +111,9 @@ module Liquid
     end
 
     def parse_comparison(p)
-      a = strict_parse_expression(p)
+      a = Expression.parse(p.expression)
       if (op = p.consume?(:comparison))
-        b = strict_parse_expression(p)
+        b = Expression.parse(p.expression)
         Condition.new(a, op, b)
       else
         Condition.new(a)

lib/liquid/tags/include.rb

@@ -32,12 +32,12 @@ module Liquid
         variable_name = Regexp.last_match(3)
 
         @alias_name         = Regexp.last_match(5)
-        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
-        @template_name_expr = parse_expression(template_name)
+        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
+        @template_name_expr = Expression.parse(template_name)
         @attributes         = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = parse_expression(value)
+          @attributes[key] = Expression.parse(value)
         end
 
       else

lib/liquid/tags/raw.rb

@@ -14,14 +14,14 @@ module Liquid
     def parse(tokens)
       @body = +''
       while (token = tokens.shift)
-        if token =~ FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
+        if token =~ FullTokenPossiblyInvalid
           @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
-          return
+          return if block_delimiter == Regexp.last_match(2)
         end
         @body << token unless token.empty?
       end
 
-      raise_tag_never_closed(block_name)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
     end
 
     def render_to_output_buffer(_context, output)

lib/liquid/tags/render.rb

@@ -19,13 +19,13 @@ module Liquid
       variable_name = Regexp.last_match(4)
 
       @alias_name = Regexp.last_match(6)
-      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
-      @template_name_expr = parse_expression(template_name)
+      @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
+      @template_name_expr = Expression.parse(template_name)
       @for = (with_or_for == FOR)
 
       @attributes = {}
       markup.scan(TagAttributes) do |key, value|
-        @attributes[key] = parse_expression(value)
+        @attributes[key] = Expression.parse(value)
       end
     end
 

lib/liquid/tags/table_row.rb

@@ -10,10 +10,10 @@ module Liquid
       super
       if markup =~ Syntax
         @variable_name   = Regexp.last_match(1)
-        @collection_name = parse_expression(Regexp.last_match(2))
+        @collection_name = Expression.parse(Regexp.last_match(2))
         @attributes      = {}
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = parse_expression(value)
+          @attributes[key] = Expression.parse(value)
         end
       else
         raise SyntaxError, options[:locale].t("errors.syntax.table_row")

lib/liquid/template.rb

@@ -153,7 +153,7 @@ module Liquid
         c = args.shift
 
         if @rethrow_errors
-          c.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
+          c.exception_renderer = ->(_e) { raise }
         end
 
         c
@@ -191,6 +191,7 @@ module Liquid
 
       begin
         # render the nodelist.
+        # for performance reasons we get an array back here. join will make a string out of it.
         with_profiling(context) do
           @root.render_to_output_buffer(context, output || +'')
         end

lib/liquid/variable.rb

@@ -30,7 +30,7 @@ module Liquid
       @parse_context = parse_context
       @line_number   = parse_context.line_number
 
-      strict_parse_with_error_mode_fallback(markup)
+      parse_with_selected_parser(markup)
     end
 
     def raw
@@ -63,23 +63,27 @@ module Liquid
       @filters = []
       p = Parser.new(markup)
 
-      return if p.look(:end_of_string)
-
-      @name = p.expression
+      @name = Expression.parse(p.expression)
       while p.consume?(:pipe)
         filtername = p.consume(:id)
-        filterargs = p.consume?(:colon) ? p.arguments : [[]]
-        @filters << [filtername, *filterargs]
+        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
+        @filters << parse_filter_expressions(filtername, filterargs)
       end
       p.consume(:end_of_string)
     end
 
-    def render(context)
-      obj = context.evaluate(@name)
+    def parse_filterargs(p)
+      # first argument
+      filterargs = [p.argument]
+      # followed by comma separated others
+      filterargs << p.argument while p.consume?(:comma)
+      filterargs
+    end
 
-      @filters.each do |filter_name, filter_args, filter_kwargs|
+    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)
-        obj = context.invoke(filter_name, obj, *filter_args)
+        context.invoke(filter_name, output, *filter_args)
       end
 
       context.apply_global_filter(obj)

lib/liquid/variable_lookup.rb

@@ -7,66 +7,30 @@ module Liquid
 
     attr_reader :name, :lookups
 
-    class << self
-      def lax_parse(markup)
-        lookups = markup.scan(VariableParser)
-
-        name = lookups.shift
-        if name =~ SQUARE_BRACKETED
-          name = Expression.parse(Regexp.last_match(1))
-        end
-
-        command_flags = 0
-
-        lookups.each_index do |i|
-          lookup = lookups[i]
-          if lookup =~ SQUARE_BRACKETED
-            lookups[i] = Expression.parse(Regexp.last_match(1))
-          elsif COMMAND_METHODS.include?(lookup)
-            command_flags |= 1 << i
-          end
-        end
-
-        new(name, lookups, command_flags)
-      end
-
-      def strict_parse(p)
-        if p.look(:id)
-          name = p.consume
-        else
-          p.consume(:open_square)
-          name = p.expression
-          p.consume(:close_square)
-        end
-
-        lookups = []
-        command_flags = 0
-
-        loop do
-          if p.consume?(:open_square)
-            lookups << p.expression
-            p.consume(:close_square)
-          elsif p.consume?(:dot)
-            lookup = p.consume(:id)
-            lookups << lookup
-            if COMMAND_METHODS.include?(lookup)
-              command_flags |= 1 << (lookups.length - 1)
-            end
-          else
-            break
-          end
-        end
-
-        new(name, lookups, command_flags)
-      end
-
-      private :new
+    def self.parse(markup)
+      new(markup)
     end
 
-    def initialize(name, lookups, command_flags)
+    def initialize(markup)
+      lookups = markup.scan(VariableParser)
+
+      name = lookups.shift
+      if name =~ SQUARE_BRACKETED
+        name = Expression.parse(Regexp.last_match(1))
+      end
       @name = name
-      @lookups = lookups
-      @command_flags = command_flags
+
+      @lookups       = lookups
+      @command_flags = 0
+
+      @lookups.each_index do |i|
+        lookup = lookups[i]
+        if lookup =~ SQUARE_BRACKETED
+          lookups[i] = Expression.parse(Regexp.last_match(1))
+        elsif COMMAND_METHODS.include?(lookup)
+          @command_flags |= 1 << i
+        end
+      end
     end
 
     def evaluate(context)
@@ -111,19 +75,6 @@ module Liquid
       self.class == other.class && state == other.state
     end
 
-    def to_s
-      str = name.dup
-      lookups.each do |lookup|
-        str +=
-          if lookup.instance_of?(String)
-            "['#{lookup}']"
-          else
-            "[#{lookup}]"
-          end
-      end
-      str
-    end
-
     protected
 
     def state

liquid.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.license     = "MIT"
   # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
-  s.required_ruby_version     = ">= 2.5.0"
+  s.required_ruby_version     = ">= 2.4.0"
   s.required_rubygems_version = ">= 1.3.7"
 
   s.test_files  = Dir.glob("{test}/**/*")

test/integration/assign_test.rb

@@ -47,71 +47,4 @@ class AssignTest < Minitest::Test
       assert Template.parse("{% assign foo = ('X' | downcase) %}")
     end
   end
-
-  def test_expression_with_whitespace_in_square_brackets
-    source = "{% assign r = a[ 'b' ] %}{{ r }}"
-    assert_template_result('result', source, 'a' => { 'b' => 'result' })
-  end
-
-  def test_assign_score_exceeding_resource_limit
-    t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
-    t.resource_limits.assign_score_limit = 1
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
-
-    t.resource_limits.assign_score_limit = 2
-    assert_equal("", t.render!)
-    refute_nil(t.resource_limits.assign_score)
-  end
-
-  def test_assign_score_exceeding_limit_from_composite_object
-    t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
-
-    t.resource_limits.assign_score_limit = 3
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
-
-    t.resource_limits.assign_score_limit = 5
-    assert_equal("", t.render!)
-  end
-
-  def test_assign_score_of_int
-    assert_equal(1, assign_score_of(123))
-  end
-
-  def test_assign_score_of_string_counts_bytes
-    assert_equal(3, assign_score_of('123'))
-    assert_equal(5, assign_score_of('12345'))
-    assert_equal(9, assign_score_of('すごい'))
-  end
-
-  def test_assign_score_of_array
-    assert_equal(1, assign_score_of([]))
-    assert_equal(2, assign_score_of([123]))
-    assert_equal(6, assign_score_of([123, 'abcd']))
-  end
-
-  def test_assign_score_of_hash
-    assert_equal(1, assign_score_of({}))
-    assert_equal(5, assign_score_of('int' => 123))
-    assert_equal(12, assign_score_of('int' => 123, 'str' => 'abcd'))
-  end
-
-  private
-
-  class ObjectWrapperDrop < Liquid::Drop
-    def initialize(obj)
-      @obj = obj
-    end
-
-    def value
-      @obj
-    end
-  end
-
-  def assign_score_of(obj)
-    context = Liquid::Context.new('drop' => ObjectWrapperDrop.new(obj))
-    Liquid::Template.parse('{% assign obj = drop.value %}').render!(context)
-    context.resource_limits.assign_score
-  end
-end
+end # AssignTest

test/integration/block_test.rb

@@ -11,68 +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
-
-  def test_instrument_for_bug_1346
-    calls = []
-    Liquid::Usage.stub(:increment, ->(name) { calls << name }) do
-      Liquid::Template.parse("{% for i in (1..2) %}{{ i }}{% endfor {% foo %}")
-    end
-    assert_equal(["end_tag_params"], calls)
-
-    calls = []
-    Liquid::Usage.stub(:increment, ->(name) { calls << name }) do
-      Liquid::Template.parse("{% for i in (1..2) %}{{ i }}{% endfor test %}")
-    end
-    assert_equal(["end_tag_params"], calls)
-
-    calls = []
-    Liquid::Usage.stub(:increment, ->(name) { calls << name }) do
-      Liquid::Template.parse("{% for i in (1..2) %}{{ i }}{% endfor %}")
-    end
-    assert_equal([], calls)
-  end
 end

test/integration/capture_test.rb

@@ -49,10 +49,4 @@ class CaptureTest < Minitest::Test
     rendered        = template.render!
     assert_equal("3-3", rendered.gsub(/\s/, ''))
   end
-
-  def test_increment_assign_score_by_bytes_not_characters
-    t = Template.parse("{% capture foo %}すごい{% endcapture %}")
-    t.render!
-    assert_equal(9, t.resource_limits.assign_score)
-  end
-end
+end # CaptureTest

test/integration/context_test.rb

@@ -2,596 +2,9 @@
 
 require 'test_helper'
 
-class HundredCentes
-  def to_liquid
-    100
-  end
-end
-
-class CentsDrop < Liquid::Drop
-  def amount
-    HundredCentes.new
-  end
-
-  def non_zero?
-    true
-  end
-end
-
-class ContextSensitiveDrop < Liquid::Drop
-  def test
-    @context['test']
-  end
-end
-
-class Category < Liquid::Drop
-  attr_accessor :name
-
-  def initialize(name)
-    @name = name
-  end
-
-  def to_liquid
-    CategoryDrop.new(self)
-  end
-end
-
-class CategoryDrop
-  attr_accessor :category, :context
-  def initialize(category)
-    @category = category
-  end
-end
-
-class CounterDrop < Liquid::Drop
-  def count
-    @count ||= 0
-    @count  += 1
-  end
-end
-
-class ArrayLike
-  def fetch(index)
-  end
-
-  def [](index)
-    @counts        ||= []
-    @counts[index] ||= 0
-    @counts[index]  += 1
-  end
-
-  def to_liquid
-    self
-  end
-end
-
 class ContextTest < Minitest::Test
   include Liquid
 
-  def setup
-    @context = Liquid::Context.new
-  end
-
-  def test_variables
-    @context['string'] = 'string'
-    assert_equal('string', @context['string'])
-
-    @context['num'] = 5
-    assert_equal(5, @context['num'])
-
-    @context['time'] = Time.parse('2006-06-06 12:00:00')
-    assert_equal(Time.parse('2006-06-06 12:00:00'), @context['time'])
-
-    @context['date'] = Date.today
-    assert_equal(Date.today, @context['date'])
-
-    now = Time.now
-    @context['datetime'] = now
-    assert_equal(now, @context['datetime'])
-
-    @context['bool'] = true
-    assert_equal(true, @context['bool'])
-
-    @context['bool'] = false
-    assert_equal(false, @context['bool'])
-
-    @context['nil'] = nil
-    assert_nil(@context['nil'])
-    assert_nil(@context['nil'])
-  end
-
-  def test_variables_not_existing
-    assert_nil(@context['does_not_exist'])
-  end
-
-  def test_scoping
-    @context.push
-    @context.pop
-
-    assert_raises(Liquid::ContextError) do
-      @context.pop
-    end
-
-    assert_raises(Liquid::ContextError) do
-      @context.push
-      @context.pop
-      @context.pop
-    end
-  end
-
-  def test_length_query
-    @context['numbers'] = [1, 2, 3, 4]
-
-    assert_equal(4, @context['numbers.size'])
-
-    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
-
-    assert_equal(4, @context['numbers.size'])
-
-    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
-
-    assert_equal(1000, @context['numbers.size'])
-  end
-
-  def test_hyphenated_variable
-    @context['oh-my'] = 'godz'
-    assert_equal('godz', @context['oh-my'])
-  end
-
-  def test_add_filter
-    filter = Module.new do
-      def hi(output)
-        output + ' hi!'
-      end
-    end
-
-    context = Context.new
-    context.add_filters(filter)
-    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
-
-    context = Context.new
-    assert_equal('hi?', context.invoke(:hi, 'hi?'))
-
-    context.add_filters(filter)
-    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
-  end
-
-  def test_only_intended_filters_make_it_there
-    filter = Module.new do
-      def hi(output)
-        output + ' hi!'
-      end
-    end
-
-    context = Context.new
-    assert_equal("Wookie", context.invoke("hi", "Wookie"))
-
-    context.add_filters(filter)
-    assert_equal("Wookie hi!", context.invoke("hi", "Wookie"))
-  end
-
-  def test_add_item_in_outer_scope
-    @context['test'] = 'test'
-    @context.push
-    assert_equal('test', @context['test'])
-    @context.pop
-    assert_equal('test', @context['test'])
-  end
-
-  def test_add_item_in_inner_scope
-    @context.push
-    @context['test'] = 'test'
-    assert_equal('test', @context['test'])
-    @context.pop
-    assert_nil(@context['test'])
-  end
-
-  def test_hierachical_data
-    @context['hash'] = { "name" => 'tobi' }
-    assert_equal('tobi', @context['hash.name'])
-    assert_equal('tobi', @context['hash["name"]'])
-  end
-
-  def test_keywords
-    assert_equal(true, @context['true'])
-    assert_equal(false, @context['false'])
-  end
-
-  def test_digits
-    assert_equal(100, @context['100'])
-    assert_equal(100.00, @context['100.00'])
-  end
-
-  def test_strings
-    assert_equal("hello!", @context['"hello!"'])
-    assert_equal("hello!", @context["'hello!'"])
-  end
-
-  def test_merge
-    @context.merge("test" => "test")
-    assert_equal('test', @context['test'])
-    @context.merge("test" => "newvalue", "foo" => "bar")
-    assert_equal('newvalue', @context['test'])
-    assert_equal('bar', @context['foo'])
-  end
-
-  def test_array_notation
-    @context['test'] = [1, 2, 3, 4, 5]
-
-    assert_equal(1, @context['test[0]'])
-    assert_equal(2, @context['test[1]'])
-    assert_equal(3, @context['test[2]'])
-    assert_equal(4, @context['test[3]'])
-    assert_equal(5, @context['test[4]'])
-  end
-
-  def test_recoursive_array_notation
-    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
-
-    assert_equal(1, @context['test.test[0]'])
-
-    @context['test'] = [{ 'test' => 'worked' }]
-
-    assert_equal('worked', @context['test[0].test'])
-  end
-
-  def test_hash_to_array_transition
-    @context['colors'] = {
-      'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
-      'Green' => ['003300', '336633', '669966', '99CC99'],
-      'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
-      'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
-    }
-
-    assert_equal('003366', @context['colors.Blue[0]'])
-    assert_equal('FF9999', @context['colors.Red[3]'])
-  end
-
-  def test_try_first
-    @context['test'] = [1, 2, 3, 4, 5]
-
-    assert_equal(1, @context['test.first'])
-    assert_equal(5, @context['test.last'])
-
-    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
-
-    assert_equal(1, @context['test.test.first'])
-    assert_equal(5, @context['test.test.last'])
-
-    @context['test'] = [1]
-    assert_equal(1, @context['test.first'])
-    assert_equal(1, @context['test.last'])
-  end
-
-  def test_access_hashes_with_hash_notation
-    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
-    @context['product']  = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
-
-    assert_equal(5, @context['products["count"]'])
-    assert_equal('deepsnow', @context['products["tags"][0]'])
-    assert_equal('deepsnow', @context['products["tags"].first'])
-    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
-    assert_equal('element151cm', @context['product["variants"][1]["title"]'])
-    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
-    assert_equal('element151cm', @context['product["variants"].last["title"]'])
-  end
-
-  def test_access_variable_with_hash_notation
-    @context['foo'] = 'baz'
-    @context['bar'] = 'foo'
-
-    assert_equal('baz', @context['["foo"]'])
-    assert_equal('baz', @context['[bar]'])
-  end
-
-  def test_access_hashes_with_hash_access_variables
-    @context['var']      = 'tags'
-    @context['nested']   = { 'var' => 'tags' }
-    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
-
-    assert_equal('deepsnow', @context['products[var].first'])
-    assert_equal('freestyle', @context['products[nested.var].last'])
-  end
-
-  def test_hash_notation_only_for_hash_access
-    @context['array'] = [1, 2, 3, 4, 5]
-    @context['hash']  = { 'first' => 'Hello' }
-
-    assert_equal(1, @context['array.first'])
-    assert_nil(@context['array["first"]'])
-    assert_equal('Hello', @context['hash["first"]'])
-  end
-
-  def test_first_can_appear_in_middle_of_callchain
-    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
-
-    assert_equal('draft151cm', @context['product.variants[0].title'])
-    assert_equal('element151cm', @context['product.variants[1].title'])
-    assert_equal('draft151cm', @context['product.variants.first.title'])
-    assert_equal('element151cm', @context['product.variants.last.title'])
-  end
-
-  def test_cents
-    @context.merge("cents" => HundredCentes.new)
-    assert_equal(100, @context['cents'])
-  end
-
-  def test_nested_cents
-    @context.merge("cents" => { 'amount' => HundredCentes.new })
-    assert_equal(100, @context['cents.amount'])
-
-    @context.merge("cents" => { 'cents' => { 'amount' => HundredCentes.new } })
-    assert_equal(100, @context['cents.cents.amount'])
-  end
-
-  def test_cents_through_drop
-    @context.merge("cents" => CentsDrop.new)
-    assert_equal(100, @context['cents.amount'])
-  end
-
-  def test_nested_cents_through_drop
-    @context.merge("vars" => { "cents" => CentsDrop.new })
-    assert_equal(100, @context['vars.cents.amount'])
-  end
-
-  def test_drop_methods_with_question_marks
-    @context.merge("cents" => CentsDrop.new)
-    assert(@context['cents.non_zero?'])
-  end
-
-  def test_context_from_within_drop
-    @context.merge("test" => '123', "vars" => ContextSensitiveDrop.new)
-    assert_equal('123', @context['vars.test'])
-  end
-
-  def test_nested_context_from_within_drop
-    @context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
-    assert_equal('123', @context['vars.local.test'])
-  end
-
-  def test_ranges
-    @context.merge("test" => '5')
-    assert_equal((1..5), @context['(1..5)'])
-    assert_equal((1..5), @context['(1..test)'])
-    assert_equal((5..5), @context['(test..test)'])
-  end
-
-  def test_cents_through_drop_nestedly
-    @context.merge("cents" => { "cents" => CentsDrop.new })
-    assert_equal(100, @context['cents.cents.amount'])
-
-    @context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
-    assert_equal(100, @context['cents.cents.cents.amount'])
-  end
-
-  def test_drop_with_variable_called_only_once
-    @context['counter'] = CounterDrop.new
-
-    assert_equal(1, @context['counter.count'])
-    assert_equal(2, @context['counter.count'])
-    assert_equal(3, @context['counter.count'])
-  end
-
-  def test_drop_with_key_called_only_once
-    @context['counter'] = CounterDrop.new
-
-    assert_equal(1, @context['counter["count"]'])
-    assert_equal(2, @context['counter["count"]'])
-    assert_equal(3, @context['counter["count"]'])
-  end
-
-  def test_proc_as_variable
-    @context['dynamic'] = proc { 'Hello' }
-
-    assert_equal('Hello', @context['dynamic'])
-  end
-
-  def test_lambda_as_variable
-    @context['dynamic'] = proc { 'Hello' }
-
-    assert_equal('Hello', @context['dynamic'])
-  end
-
-  def test_nested_lambda_as_variable
-    @context['dynamic'] = { "lambda" => proc { 'Hello' } }
-
-    assert_equal('Hello', @context['dynamic.lambda'])
-  end
-
-  def test_array_containing_lambda_as_variable
-    @context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
-
-    assert_equal('Hello', @context['dynamic[2]'])
-  end
-
-  def test_lambda_is_called_once
-    @context['callcount'] = proc {
-      @global ||= 0
-      @global  += 1
-      @global.to_s
-    }
-
-    assert_equal('1', @context['callcount'])
-    assert_equal('1', @context['callcount'])
-    assert_equal('1', @context['callcount'])
-
-    @global = nil
-  end
-
-  def test_nested_lambda_is_called_once
-    @context['callcount'] = { "lambda" => proc {
-                                            @global ||= 0
-                                            @global  += 1
-                                            @global.to_s
-                                          } }
-
-    assert_equal('1', @context['callcount.lambda'])
-    assert_equal('1', @context['callcount.lambda'])
-    assert_equal('1', @context['callcount.lambda'])
-
-    @global = nil
-  end
-
-  def test_lambda_in_array_is_called_once
-    @context['callcount'] = [1, 2, proc {
-                                     @global ||= 0
-                                     @global  += 1
-                                     @global.to_s
-                                   }, 4, 5]
-
-    assert_equal('1', @context['callcount[2]'])
-    assert_equal('1', @context['callcount[2]'])
-    assert_equal('1', @context['callcount[2]'])
-
-    @global = nil
-  end
-
-  def test_access_to_context_from_proc
-    @context.registers[:magic] = 345392
-
-    @context['magic'] = proc { @context.registers[:magic] }
-
-    assert_equal(345392, @context['magic'])
-  end
-
-  def test_to_liquid_and_context_at_first_level
-    @context['category'] = Category.new("foobar")
-    assert_kind_of(CategoryDrop, @context['category'])
-    assert_equal(@context, @context['category'].context)
-  end
-
-  def test_interrupt_avoids_object_allocations
-    assert_no_object_allocations do
-      @context.interrupt?
-    end
-  end
-
-  def test_context_initialization_with_a_proc_in_environment
-    contx = Context.new([test: ->(c) { c['poutine'] }], test: :foo)
-
-    assert(contx)
-    assert_nil(contx['poutine'])
-  end
-
-  def test_apply_global_filter
-    global_filter_proc = ->(output) { "#{output} filtered" }
-
-    context = Context.new
-    context.global_filter = global_filter_proc
-
-    assert_equal('hi filtered', context.apply_global_filter('hi'))
-  end
-
-  def test_static_environments_are_read_with_lower_priority_than_environments
-    context = Context.build(
-      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
-      environments: { 'shadowed' => 'dynamic' }
-    )
-
-    assert_equal('dynamic', context['shadowed'])
-    assert_equal('static', context['unshadowed'])
-  end
-
-  def test_apply_global_filter_when_no_global_filter_exist
-    context = Context.new
-    assert_equal('hi', context.apply_global_filter('hi'))
-  end
-
-  def test_new_isolated_subcontext_does_not_inherit_variables
-    super_context = Context.new
-    super_context['my_variable'] = 'some value'
-    subcontext = super_context.new_isolated_subcontext
-
-    assert_nil(subcontext['my_variable'])
-  end
-
-  def test_new_isolated_subcontext_inherits_static_environment
-    super_context = Context.build(static_environments: { 'my_environment_value' => 'my value' })
-    subcontext    = super_context.new_isolated_subcontext
-
-    assert_equal('my value', subcontext['my_environment_value'])
-  end
-
-  def test_new_isolated_subcontext_inherits_resource_limits
-    resource_limits = ResourceLimits.new({})
-    super_context   = Context.new({}, {}, {}, false, resource_limits)
-    subcontext      = super_context.new_isolated_subcontext
-    assert_equal(resource_limits, subcontext.resource_limits)
-  end
-
-  def test_new_isolated_subcontext_inherits_exception_renderer
-    super_context = Context.new
-    super_context.exception_renderer = ->(_e) { 'my exception message' }
-    subcontext = super_context.new_isolated_subcontext
-    assert_equal('my exception message', subcontext.handle_error(Liquid::Error.new))
-  end
-
-  def test_new_isolated_subcontext_does_not_inherit_non_static_registers
-    registers = {
-      my_register: :my_value,
-    }
-    super_context = Context.new({}, {}, StaticRegisters.new(registers))
-    super_context.registers[:my_register] = :my_alt_value
-    subcontext                            = super_context.new_isolated_subcontext
-    assert_equal(:my_value, subcontext.registers[:my_register])
-  end
-
-  def test_new_isolated_subcontext_inherits_static_registers
-    super_context = Context.build(registers: { my_register: :my_value })
-    subcontext    = super_context.new_isolated_subcontext
-    assert_equal(:my_value, subcontext.registers[:my_register])
-  end
-
-  def test_new_isolated_subcontext_registers_do_not_pollute_context
-    super_context                      = Context.build(registers: { my_register: :my_value })
-    subcontext                         = super_context.new_isolated_subcontext
-    subcontext.registers[:my_register] = :my_alt_value
-    assert_equal(:my_value, super_context.registers[:my_register])
-  end
-
-  def test_new_isolated_subcontext_inherits_filters
-    my_filter = Module.new do
-      def my_filter(*)
-        'my filter result'
-      end
-    end
-
-    super_context = Context.new
-    super_context.add_filters([my_filter])
-    subcontext    = super_context.new_isolated_subcontext
-    template      = Template.parse('{{ 123 | my_filter }}')
-    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
-
   def test_override_global_filter
     global = Module.new do
       def notice(output)
@@ -618,18 +31,4 @@ class ContextTest < Minitest::Test
       assert_empty context.errors
     end
   end
-
-  private
-
-  def assert_no_object_allocations
-    unless RUBY_ENGINE == 'ruby'
-      skip("stackprof needed to count object allocations")
-    end
-    require 'stackprof'
-
-    profile = StackProf.run(mode: :object) do
-      yield
-    end
-    assert_equal(0, profile[:samples])
-  end
-end # ContextTest
+end

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/expression_test.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ExpressionTest < Minitest::Test
-  def test_keyword_literals
-    assert_equal(true, parse_and_eval("true"))
-    assert_equal(true, parse_and_eval(" true "))
-  end
-
-  def test_string
-    assert_equal("single quoted", parse_and_eval("'single quoted'"))
-    assert_equal("double quoted", parse_and_eval('"double quoted"'))
-    assert_equal("spaced", parse_and_eval(" 'spaced' "))
-    assert_equal("spaced2", parse_and_eval(' "spaced2" '))
-  end
-
-  def test_int
-    assert_equal(123, parse_and_eval("123"))
-    assert_equal(456, parse_and_eval(" 456 "))
-    assert_equal(12, parse_and_eval("012"))
-  end
-
-  def test_float
-    assert_equal(1.5, parse_and_eval("1.5"))
-    assert_equal(2.5, parse_and_eval(" 2.5 "))
-  end
-
-  def test_range
-    assert_equal(1..2, parse_and_eval("(1..2)"))
-    assert_equal(3..4, parse_and_eval(" ( 3 .. 4 ) "))
-    assert_equal(0..0, parse_and_eval("('a'..'b')"))
-
-    with_error_mode(:strict) do
-      assert_raises(Liquid::ArgumentError) { parse_and_eval("(1..(1..5))") }
-    end
-  end
-
-  private
-
-  def parse_and_eval(markup, **assigns)
-    expression =
-      if Liquid::Template.error_mode == :strict
-        p = Liquid::Parser.new(markup)
-        p.expression
-      else
-        Liquid::Expression.parse(markup)
-      end
-
-    context = Liquid::Context.new(assigns)
-    context.evaluate(expression)
-  end
-end

test/integration/filter_test.rb

@@ -153,15 +153,6 @@ class FiltersTest < Minitest::Test
     # tap still treated as a non-existent filter
     assert_equal("1000", Template.parse("{{var | tap}}").render!('var' => 1000))
   end
-
-  def test_liquid_argument_error
-    source = "{{ '' | size: 'too many args' }}"
-    exc = assert_raises(Liquid::ArgumentError) do
-      Template.parse(source).render!
-    end
-    assert_match(/\ALiquid error: wrong number of arguments /, exc.message)
-    assert_equal(exc.message, Template.parse(source).render)
-  end
 end
 
 class FiltersInTemplate < Minitest::Test

test/integration/parsing_quirks_test.rb

@@ -118,16 +118,6 @@ class ParsingQuirksTest < Minitest::Test
     end
   end
 
-  def test_blank_variable_markup
-    assert_template_result('', "{{}}")
-  end
-
-  def test_lookup_on_var_with_literal_name
-    assigns = { "blank" => { "x" => "result" } }
-    assert_template_result('result', "{{ blank.x }}", assigns)
-    assert_template_result('result', "{{ blank['x'] }}", assigns)
-  end
-
   def test_contains_in_id
     assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
   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

@@ -5,44 +5,36 @@ require 'test_helper'
 class TagDisableableTest < Minitest::Test
   include Liquid
 
-  module RenderTagName
-    def render(_context)
-      tag_name
-    end
+  class DisableRaw < Block
+    disable_tags "raw"
   end
 
-  class Custom < Tag
+  class DisableRawEcho < Block
+    disable_tags "raw", "echo"
+  end
+
+  class DisableableRaw < Liquid::Raw
     prepend Liquid::Tag::Disableable
-    include RenderTagName
   end
 
-  class Custom2 < Tag
+  class DisableableEcho < Liquid::Echo
     prepend Liquid::Tag::Disableable
-    include RenderTagName
   end
 
-  class DisableCustom < Block
-    disable_tags "custom"
-  end
-
-  class DisableBoth < Block
-    disable_tags "custom", "custom2"
-  end
-
-  def test_block_tag_disabling_nested_tag
+  def test_disables_raw
     with_disableable_tags do
-      with_custom_tag('disable', DisableCustom) do
-        output = Template.parse('{% disable %}{% custom %};{% custom2 %}{% enddisable %}').render
-        assert_equal('Liquid error: custom usage is not allowed in this context;custom2', output)
+      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_block_tag_disabling_multiple_nested_tags
+  def test_disables_echo_and_raw
     with_disableable_tags do
-      with_custom_tag('disable', DisableBoth) do
-        output = Template.parse('{% disable %}{% custom %};{% custom2 %}{% enddisable %}').render
-        assert_equal('Liquid error: custom usage is not allowed in this context;Liquid error: custom2 usage is not allowed in this context', output)
+      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
@@ -50,8 +42,8 @@ class TagDisableableTest < Minitest::Test
   private
 
   def with_disableable_tags
-    with_custom_tag('custom', Custom) do
-      with_custom_tag('custom2', Custom2) do
+    with_custom_tag('raw', DisableableRaw) do
+      with_custom_tag('echo', DisableableEcho) do
         yield
       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/for_tag_test.rb

@@ -437,30 +437,4 @@ HERE
 
     assert(context.registers[:for_stack].empty?)
   end
-
-  def test_instrument_for_offset_continue
-    assert_usage_increment('for_offset_continue') do
-      Template.parse('{% for item in items offset:continue %}{{item}}{% endfor %}')
-    end
-
-    assert_usage_increment('for_offset_continue', times: 0) do
-      Template.parse('{% for item in items offset:2 %}{{item}}{% endfor %}')
-    end
-  end
-
-  def test_instrument_forloop_drop_name
-    assigns = { 'items' => [1, 2, 3, 4, 5] }
-
-    assert_usage_increment('forloop_drop_name', times: 5) do
-      Template.parse('{% for item in items %}{{forloop.name}}{% endfor %}').render!(assigns)
-    end
-
-    assert_usage_increment('forloop_drop_name', times: 0) do
-      Template.parse('{% for item in items %}{{forloop.index}}{% endfor %}').render!(assigns)
-    end
-
-    assert_usage_increment('forloop_drop_name', times: 0) do
-      Template.parse('{% for item in items %}{{item}}{% endfor %}').render!(assigns)
-    end
-  end
 end

test/integration/tags/raw_tag_test.rb

@@ -23,7 +23,6 @@ class RawTagTest < Minitest::Test
     assert_template_result(' Foobar {% {% {% ', '{% raw %} Foobar {% {% {% {% endraw %}')
     assert_template_result(' test {% raw %} {% endraw %}', '{% raw %} test {% raw %} {% {% endraw %}endraw %}')
     assert_template_result(' Foobar {{ invalid 1', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}')
-    assert_template_result(' Foobar {% foo {% bar %}', '{% raw %} Foobar {% foo {% bar %}{% endraw %}')
   end
 
   def test_invalid_raw

test/integration/tags/standard_tag_test.rb

@@ -213,11 +213,6 @@ class StandardTagTest < Minitest::Test
     assert_template_result('', code, 'condition' => 'something else')
   end
 
-  def test_case_when_comma_and_blank_body
-    code = '{% case condition %}{% when 1, 2 %} {% assign r = "result" %} {% endcase %}{{ r }}'
-    assert_template_result('result', code, 'condition' => 2)
-  end
-
   def test_assign
     assert_template_result('variable', '{% assign a = "variable"%}{{a}}')
   end

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
@@ -135,6 +136,38 @@ class TemplateTest < Minitest::Test
     refute_nil(t.resource_limits.render_score)
   end
 
+  def test_resource_limits_assign_score
+    t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
+    t.resource_limits.assign_score_limit = 1
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
+
+    t.resource_limits.assign_score_limit = 2
+    assert_equal("", t.render!)
+    refute_nil(t.resource_limits.assign_score)
+  end
+
+  def test_resource_limits_assign_score_counts_bytes_not_characters
+    t = Template.parse("{% assign foo = 'すごい' %}")
+    t.render
+    assert_equal(9, t.resource_limits.assign_score)
+
+    t = Template.parse("{% capture foo %}すごい{% endcapture %}")
+    t.render
+    assert_equal(9, t.resource_limits.assign_score)
+  end
+
+  def test_resource_limits_assign_score_nested
+    t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
+
+    t.resource_limits.assign_score_limit = 3
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
+
+    t.resource_limits.assign_score_limit = 5
+    assert_equal("", t.render!)
+  end
+
   def test_resource_limits_aborts_rendering_after_first_error
     t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
     t.resource_limits.render_score_limit = 50
@@ -147,33 +180,36 @@ class TemplateTest < Minitest::Test
     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
 
@@ -183,6 +219,7 @@ class TemplateTest < Minitest::Test
     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
@@ -257,8 +294,9 @@ class TemplateTest < Minitest::Test
   end
 
   def test_nil_value_does_not_raise
-    t      = Template.parse("some{{x}}thing", error_mode: :strict)
-    result = t.render!({ 'x' => nil }, strict_variables: true)
+    Liquid::Template.error_mode = :strict
+    t                           = Template.parse("some{{x}}thing")
+    result                      = t.render!({ 'x' => nil }, strict_variables: true)
 
     assert_equal(0, t.errors.count)
     assert_equal('something', result)

test/integration/trim_mode_test.rb

@@ -528,36 +528,4 @@ class TrimModeTest < Minitest::Test
     END_EXPECTED
     assert_template_result(expected, text)
   end
-
-  def test_pre_trim_blank_preceding_text
-    template = Liquid::Template.parse("\n{%- raw %}{% endraw %}")
-    assert_equal("", template.render)
-
-    template = Liquid::Template.parse("\n{%- if true %}{% endif %}")
-    assert_equal("", template.render)
-
-    template = Liquid::Template.parse("{{ 'B' }} \n{%- if true %}C{% endif %}")
-    assert_equal("BC", template.render)
-  end
-
-  def test_bug_compatible_pre_trim
-    template = Liquid::Template.parse("\n {%- raw %}{% endraw %}", bug_compatible_whitespace_trimming: true)
-    assert_equal("\n", template.render)
-
-    template = Liquid::Template.parse("\n {%- if true %}{% endif %}", bug_compatible_whitespace_trimming: true)
-    assert_equal("\n", template.render)
-
-    template = Liquid::Template.parse("{{ 'B' }} \n{%- if true %}C{% endif %}", bug_compatible_whitespace_trimming: true)
-    assert_equal("B C", template.render)
-
-    template = Liquid::Template.parse("B\n {%- raw %}{% endraw %}", bug_compatible_whitespace_trimming: true)
-    assert_equal("B", template.render)
-
-    template = Liquid::Template.parse("B\n {%- if true %}{% endif %}", bug_compatible_whitespace_trimming: true)
-    assert_equal("B", template.render)
-  end
-
-  def test_trim_blank
-    assert_template_result('foobar', 'foo {{-}} bar')
-  end
 end # TrimModeTest

test/integration/variable_test.rb

@@ -21,11 +21,6 @@ class VariableTest < Minitest::Test
     assert_equal('  worked wonderfully  ', template.render!('test' => 'worked wonderfully'))
   end
 
-  def test_expression_with_whitespace_in_square_brackets
-    assert_template_result('result', "{{ a[ 'b' ] }}", 'a' => { 'b' => 'result' })
-    assert_template_result('result', "{{ a[ [ 'b' ] ] }}", 'b' => 'c', 'a' => { 'c' => 'result' })
-  end
-
   def test_ignore_unknown
     template = Template.parse(%({{ test }}))
     assert_equal('', template.render!)
@@ -42,8 +37,8 @@ class VariableTest < Minitest::Test
   end
 
   def test_hash_scoping
-    assert_template_result('worked', "{{ test.test }}", 'test' => { 'test' => 'worked' })
-    assert_template_result('worked', "{{ test . test }}", 'test' => { 'test' => 'worked' })
+    template = Template.parse(%({{ test.test }}))
+    assert_equal('worked', template.render!('test' => { 'test' => 'worked' }))
   end
 
   def test_false_renders_as_false
@@ -100,8 +95,4 @@ class VariableTest < Minitest::Test
   def test_render_symbol
     assert_template_result('bar', '{{ foo }}', 'foo' => :bar)
   end
-
-  def test_dynamic_find_var
-    assert_template_result('bar', '{{ [key] }}', 'key' => 'foo', 'foo' => 'bar')
-  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/condition_unit_test.rb

@@ -77,7 +77,7 @@ class ConditionUnitTest < Minitest::Test
   def test_contains_works_on_arrays
     @context          = Liquid::Context.new
     @context['array'] = [1, 2, 3, 4, 5]
-    array_expr        = parse_variable_lookup("array")
+    array_expr        = VariableLookup.new("array")
 
     assert_evaluates_false(array_expr, 'contains', 0)
     assert_evaluates_true(array_expr, 'contains', 1)
@@ -91,8 +91,8 @@ class ConditionUnitTest < Minitest::Test
 
   def test_contains_returns_false_for_nil_operands
     @context = Liquid::Context.new
-    assert_evaluates_false(parse_variable_lookup('not_assigned'), 'contains', '0')
-    assert_evaluates_false(0, 'contains', parse_variable_lookup('not_assigned'))
+    assert_evaluates_false(VariableLookup.new('not_assigned'), 'contains', '0')
+    assert_evaluates_false(0, 'contains', VariableLookup.new('not_assigned'))
   end
 
   def test_contains_return_false_on_wrong_data_type
@@ -145,20 +145,11 @@ class ConditionUnitTest < Minitest::Test
     @context        = Liquid::Context.new
     @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
 
-    assert_evaluates_true(parse_variable_lookup("one"), '==', parse_variable_lookup("another"))
+    assert_evaluates_true(VariableLookup.new("one"), '==', VariableLookup.new("another"))
   end
 
   private
 
-  def parse_variable_lookup(markup)
-    if Liquid::Template.error_mode == :strict
-      p = Liquid::Parser.new(markup)
-      VariableLookup.strict_parse(p)
-    else
-      VariableLookup.lax_parse(markup)
-    end
-  end
-
   def assert_evaluates_true(left, op, right)
     assert(Condition.new(left, op, right).evaluate(@context),
       "Evaluated false: #{left} #{op} #{right}")

test/unit/context_unit_test.rb

@@ -0,0 +1,608 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class HundredCentes
+  def to_liquid
+    100
+  end
+end
+
+class CentsDrop < Liquid::Drop
+  def amount
+    HundredCentes.new
+  end
+
+  def non_zero?
+    true
+  end
+end
+
+class ContextSensitiveDrop < Liquid::Drop
+  def test
+    @context['test']
+  end
+end
+
+class Category < Liquid::Drop
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def to_liquid
+    CategoryDrop.new(self)
+  end
+end
+
+class CategoryDrop
+  attr_accessor :category, :context
+  def initialize(category)
+    @category = category
+  end
+end
+
+class CounterDrop < Liquid::Drop
+  def count
+    @count ||= 0
+    @count  += 1
+  end
+end
+
+class ArrayLike
+  def fetch(index)
+  end
+
+  def [](index)
+    @counts        ||= []
+    @counts[index] ||= 0
+    @counts[index]  += 1
+  end
+
+  def to_liquid
+    self
+  end
+end
+
+class ContextUnitTest < Minitest::Test
+  include Liquid
+
+  def setup
+    @context = Liquid::Context.new
+  end
+
+  def test_variables
+    @context['string'] = 'string'
+    assert_equal('string', @context['string'])
+
+    @context['num'] = 5
+    assert_equal(5, @context['num'])
+
+    @context['time'] = Time.parse('2006-06-06 12:00:00')
+    assert_equal(Time.parse('2006-06-06 12:00:00'), @context['time'])
+
+    @context['date'] = Date.today
+    assert_equal(Date.today, @context['date'])
+
+    now = Time.now
+    @context['datetime'] = now
+    assert_equal(now, @context['datetime'])
+
+    @context['bool'] = true
+    assert_equal(true, @context['bool'])
+
+    @context['bool'] = false
+    assert_equal(false, @context['bool'])
+
+    @context['nil'] = nil
+    assert_nil(@context['nil'])
+    assert_nil(@context['nil'])
+  end
+
+  def test_variables_not_existing
+    assert_nil(@context['does_not_exist'])
+  end
+
+  def test_scoping
+    @context.push
+    @context.pop
+
+    assert_raises(Liquid::ContextError) do
+      @context.pop
+    end
+
+    assert_raises(Liquid::ContextError) do
+      @context.push
+      @context.pop
+      @context.pop
+    end
+  end
+
+  def test_length_query
+    @context['numbers'] = [1, 2, 3, 4]
+
+    assert_equal(4, @context['numbers.size'])
+
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
+
+    assert_equal(4, @context['numbers.size'])
+
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
+
+    assert_equal(1000, @context['numbers.size'])
+  end
+
+  def test_hyphenated_variable
+    @context['oh-my'] = 'godz'
+    assert_equal('godz', @context['oh-my'])
+  end
+
+  def test_add_filter
+    filter = Module.new do
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+
+    context = Context.new
+    context.add_filters(filter)
+    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
+
+    context = Context.new
+    assert_equal('hi?', context.invoke(:hi, 'hi?'))
+
+    context.add_filters(filter)
+    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
+  end
+
+  def test_only_intended_filters_make_it_there
+    filter = Module.new do
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+
+    context = Context.new
+    assert_equal("Wookie", context.invoke("hi", "Wookie"))
+
+    context.add_filters(filter)
+    assert_equal("Wookie hi!", context.invoke("hi", "Wookie"))
+  end
+
+  def test_add_item_in_outer_scope
+    @context['test'] = 'test'
+    @context.push
+    assert_equal('test', @context['test'])
+    @context.pop
+    assert_equal('test', @context['test'])
+  end
+
+  def test_add_item_in_inner_scope
+    @context.push
+    @context['test'] = 'test'
+    assert_equal('test', @context['test'])
+    @context.pop
+    assert_nil(@context['test'])
+  end
+
+  def test_hierachical_data
+    @context['hash'] = { "name" => 'tobi' }
+    assert_equal('tobi', @context['hash.name'])
+    assert_equal('tobi', @context['hash["name"]'])
+  end
+
+  def test_keywords
+    assert_equal(true, @context['true'])
+    assert_equal(false, @context['false'])
+  end
+
+  def test_digits
+    assert_equal(100, @context['100'])
+    assert_equal(100.00, @context['100.00'])
+  end
+
+  def test_strings
+    assert_equal("hello!", @context['"hello!"'])
+    assert_equal("hello!", @context["'hello!'"])
+  end
+
+  def test_merge
+    @context.merge("test" => "test")
+    assert_equal('test', @context['test'])
+    @context.merge("test" => "newvalue", "foo" => "bar")
+    assert_equal('newvalue', @context['test'])
+    assert_equal('bar', @context['foo'])
+  end
+
+  def test_array_notation
+    @context['test'] = [1, 2, 3, 4, 5]
+
+    assert_equal(1, @context['test[0]'])
+    assert_equal(2, @context['test[1]'])
+    assert_equal(3, @context['test[2]'])
+    assert_equal(4, @context['test[3]'])
+    assert_equal(5, @context['test[4]'])
+  end
+
+  def test_recoursive_array_notation
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
+
+    assert_equal(1, @context['test.test[0]'])
+
+    @context['test'] = [{ 'test' => 'worked' }]
+
+    assert_equal('worked', @context['test[0].test'])
+  end
+
+  def test_hash_to_array_transition
+    @context['colors'] = {
+      'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
+      'Green' => ['003300', '336633', '669966', '99CC99'],
+      'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
+      'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
+    }
+
+    assert_equal('003366', @context['colors.Blue[0]'])
+    assert_equal('FF9999', @context['colors.Red[3]'])
+  end
+
+  def test_try_first
+    @context['test'] = [1, 2, 3, 4, 5]
+
+    assert_equal(1, @context['test.first'])
+    assert_equal(5, @context['test.last'])
+
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
+
+    assert_equal(1, @context['test.test.first'])
+    assert_equal(5, @context['test.test.last'])
+
+    @context['test'] = [1]
+    assert_equal(1, @context['test.first'])
+    assert_equal(1, @context['test.last'])
+  end
+
+  def test_access_hashes_with_hash_notation
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @context['product']  = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
+
+    assert_equal(5, @context['products["count"]'])
+    assert_equal('deepsnow', @context['products["tags"][0]'])
+    assert_equal('deepsnow', @context['products["tags"].first'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"][1]["title"]'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"].last["title"]'])
+  end
+
+  def test_access_variable_with_hash_notation
+    @context['foo'] = 'baz'
+    @context['bar'] = 'foo'
+
+    assert_equal('baz', @context['["foo"]'])
+    assert_equal('baz', @context['[bar]'])
+  end
+
+  def test_access_hashes_with_hash_access_variables
+    @context['var']      = 'tags'
+    @context['nested']   = { 'var' => 'tags' }
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+
+    assert_equal('deepsnow', @context['products[var].first'])
+    assert_equal('freestyle', @context['products[nested.var].last'])
+  end
+
+  def test_hash_notation_only_for_hash_access
+    @context['array'] = [1, 2, 3, 4, 5]
+    @context['hash']  = { 'first' => 'Hello' }
+
+    assert_equal(1, @context['array.first'])
+    assert_nil(@context['array["first"]'])
+    assert_equal('Hello', @context['hash["first"]'])
+  end
+
+  def test_first_can_appear_in_middle_of_callchain
+    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
+
+    assert_equal('draft151cm', @context['product.variants[0].title'])
+    assert_equal('element151cm', @context['product.variants[1].title'])
+    assert_equal('draft151cm', @context['product.variants.first.title'])
+    assert_equal('element151cm', @context['product.variants.last.title'])
+  end
+
+  def test_cents
+    @context.merge("cents" => HundredCentes.new)
+    assert_equal(100, @context['cents'])
+  end
+
+  def test_nested_cents
+    @context.merge("cents" => { 'amount' => HundredCentes.new })
+    assert_equal(100, @context['cents.amount'])
+
+    @context.merge("cents" => { 'cents' => { 'amount' => HundredCentes.new } })
+    assert_equal(100, @context['cents.cents.amount'])
+  end
+
+  def test_cents_through_drop
+    @context.merge("cents" => CentsDrop.new)
+    assert_equal(100, @context['cents.amount'])
+  end
+
+  def test_nested_cents_through_drop
+    @context.merge("vars" => { "cents" => CentsDrop.new })
+    assert_equal(100, @context['vars.cents.amount'])
+  end
+
+  def test_drop_methods_with_question_marks
+    @context.merge("cents" => CentsDrop.new)
+    assert(@context['cents.non_zero?'])
+  end
+
+  def test_context_from_within_drop
+    @context.merge("test" => '123', "vars" => ContextSensitiveDrop.new)
+    assert_equal('123', @context['vars.test'])
+  end
+
+  def test_nested_context_from_within_drop
+    @context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
+    assert_equal('123', @context['vars.local.test'])
+  end
+
+  def test_ranges
+    @context.merge("test" => '5')
+    assert_equal((1..5), @context['(1..5)'])
+    assert_equal((1..5), @context['(1..test)'])
+    assert_equal((5..5), @context['(test..test)'])
+  end
+
+  def test_cents_through_drop_nestedly
+    @context.merge("cents" => { "cents" => CentsDrop.new })
+    assert_equal(100, @context['cents.cents.amount'])
+
+    @context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
+    assert_equal(100, @context['cents.cents.cents.amount'])
+  end
+
+  def test_drop_with_variable_called_only_once
+    @context['counter'] = CounterDrop.new
+
+    assert_equal(1, @context['counter.count'])
+    assert_equal(2, @context['counter.count'])
+    assert_equal(3, @context['counter.count'])
+  end
+
+  def test_drop_with_key_called_only_once
+    @context['counter'] = CounterDrop.new
+
+    assert_equal(1, @context['counter["count"]'])
+    assert_equal(2, @context['counter["count"]'])
+    assert_equal(3, @context['counter["count"]'])
+  end
+
+  def test_proc_as_variable
+    @context['dynamic'] = proc { 'Hello' }
+
+    assert_equal('Hello', @context['dynamic'])
+  end
+
+  def test_lambda_as_variable
+    @context['dynamic'] = proc { 'Hello' }
+
+    assert_equal('Hello', @context['dynamic'])
+  end
+
+  def test_nested_lambda_as_variable
+    @context['dynamic'] = { "lambda" => proc { 'Hello' } }
+
+    assert_equal('Hello', @context['dynamic.lambda'])
+  end
+
+  def test_array_containing_lambda_as_variable
+    @context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
+
+    assert_equal('Hello', @context['dynamic[2]'])
+  end
+
+  def test_lambda_is_called_once
+    @context['callcount'] = proc {
+      @global ||= 0
+      @global  += 1
+      @global.to_s
+    }
+
+    assert_equal('1', @context['callcount'])
+    assert_equal('1', @context['callcount'])
+    assert_equal('1', @context['callcount'])
+
+    @global = nil
+  end
+
+  def test_nested_lambda_is_called_once
+    @context['callcount'] = { "lambda" => proc {
+                                            @global ||= 0
+                                            @global  += 1
+                                            @global.to_s
+                                          } }
+
+    assert_equal('1', @context['callcount.lambda'])
+    assert_equal('1', @context['callcount.lambda'])
+    assert_equal('1', @context['callcount.lambda'])
+
+    @global = nil
+  end
+
+  def test_lambda_in_array_is_called_once
+    @context['callcount'] = [1, 2, proc {
+                                     @global ||= 0
+                                     @global  += 1
+                                     @global.to_s
+                                   }, 4, 5]
+
+    assert_equal('1', @context['callcount[2]'])
+    assert_equal('1', @context['callcount[2]'])
+    assert_equal('1', @context['callcount[2]'])
+
+    @global = nil
+  end
+
+  def test_access_to_context_from_proc
+    @context.registers[:magic] = 345392
+
+    @context['magic'] = proc { @context.registers[:magic] }
+
+    assert_equal(345392, @context['magic'])
+  end
+
+  def test_to_liquid_and_context_at_first_level
+    @context['category'] = Category.new("foobar")
+    assert_kind_of(CategoryDrop, @context['category'])
+    assert_equal(@context, @context['category'].context)
+  end
+
+  def test_interrupt_avoids_object_allocations
+    assert_no_object_allocations do
+      @context.interrupt?
+    end
+  end
+
+  def test_context_initialization_with_a_proc_in_environment
+    contx = Context.new([test: ->(c) { c['poutine'] }], test: :foo)
+
+    assert(contx)
+    assert_nil(contx['poutine'])
+  end
+
+  def test_apply_global_filter
+    global_filter_proc = ->(output) { "#{output} filtered" }
+
+    context = Context.new
+    context.global_filter = global_filter_proc
+
+    assert_equal('hi filtered', context.apply_global_filter('hi'))
+  end
+
+  def test_static_environments_are_read_with_lower_priority_than_environments
+    context = Context.build(
+      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
+      environments: { 'shadowed' => 'dynamic' }
+    )
+
+    assert_equal('dynamic', context['shadowed'])
+    assert_equal('static', context['unshadowed'])
+  end
+
+  def test_apply_global_filter_when_no_global_filter_exist
+    context = Context.new
+    assert_equal('hi', context.apply_global_filter('hi'))
+  end
+
+  def test_new_isolated_subcontext_does_not_inherit_variables
+    super_context = Context.new
+    super_context['my_variable'] = 'some value'
+    subcontext = super_context.new_isolated_subcontext
+
+    assert_nil(subcontext['my_variable'])
+  end
+
+  def test_new_isolated_subcontext_inherits_static_environment
+    super_context = Context.build(static_environments: { 'my_environment_value' => 'my value' })
+    subcontext    = super_context.new_isolated_subcontext
+
+    assert_equal('my value', subcontext['my_environment_value'])
+  end
+
+  def test_new_isolated_subcontext_inherits_resource_limits
+    resource_limits = ResourceLimits.new({})
+    super_context   = Context.new({}, {}, {}, false, resource_limits)
+    subcontext      = super_context.new_isolated_subcontext
+    assert_equal(resource_limits, subcontext.resource_limits)
+  end
+
+  def test_new_isolated_subcontext_inherits_exception_renderer
+    super_context = Context.new
+    super_context.exception_renderer = ->(_e) { 'my exception message' }
+    subcontext = super_context.new_isolated_subcontext
+    assert_equal('my exception message', subcontext.handle_error(Liquid::Error.new))
+  end
+
+  def test_new_isolated_subcontext_does_not_inherit_non_static_registers
+    registers = {
+      my_register: :my_value,
+    }
+    super_context = Context.new({}, {}, StaticRegisters.new(registers))
+    super_context.registers[:my_register] = :my_alt_value
+    subcontext                            = super_context.new_isolated_subcontext
+    assert_equal(:my_value, subcontext.registers[:my_register])
+  end
+
+  def test_new_isolated_subcontext_inherits_static_registers
+    super_context = Context.build(registers: { my_register: :my_value })
+    subcontext    = super_context.new_isolated_subcontext
+    assert_equal(:my_value, subcontext.registers[:my_register])
+  end
+
+  def test_new_isolated_subcontext_registers_do_not_pollute_context
+    super_context                      = Context.build(registers: { my_register: :my_value })
+    subcontext                         = super_context.new_isolated_subcontext
+    subcontext.registers[:my_register] = :my_alt_value
+    assert_equal(:my_value, super_context.registers[:my_register])
+  end
+
+  def test_new_isolated_subcontext_inherits_filters
+    my_filter = Module.new do
+      def my_filter(*)
+        'my filter result'
+      end
+    end
+
+    super_context = Context.new
+    super_context.add_filters([my_filter])
+    subcontext    = super_context.new_isolated_subcontext
+    template      = Template.parse('{{ 123 | my_filter }}')
+    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
+    unless RUBY_ENGINE == 'ruby'
+      skip("stackprof needed to count object allocations")
+    end
+    require 'stackprof'
+
+    profile = StackProf.run(mode: :object) do
+      yield
+    end
+    assert_equal(0, profile[:samples])
+  end
+end # ContextTest

test/unit/parser_unit_test.rb

@@ -47,41 +47,32 @@ class ParserUnitTest < Minitest::Test
 
   def test_expressions
     p = Parser.new("hi.there hi?[5].there? hi.there.bob")
-    assert_equal(VariableLookup.send(:new, 'hi', ['there'], 0), p.expression)
-    assert_equal(VariableLookup.send(:new, 'hi?', [5, 'there?'], 0), p.expression)
-    assert_equal(VariableLookup.send(:new, 'hi', ['there', 'bob'], 0), p.expression)
-
-    p = Parser.new("nil true false")
-    assert_nil(p.expression)
-    assert_equal(true, p.expression)
-    assert_equal(false, p.expression)
+    assert_equal('hi.there', p.expression)
+    assert_equal('hi?[5].there?', p.expression)
+    assert_equal('hi.there.bob', p.expression)
 
     p = Parser.new("567 6.0 'lol' \"wut\"")
-    assert_equal(567, p.expression)
-    assert_equal(6.0, p.expression)
-    assert_equal('lol', p.expression)
-    assert_equal('wut', p.expression)
+    assert_equal('567', p.expression)
+    assert_equal('6.0', p.expression)
+    assert_equal("'lol'", p.expression)
+    assert_equal('"wut"', p.expression)
   end
 
   def test_ranges
     p = Parser.new("(5..7) (1.5..9.6) (young..old) (hi[5].wat..old)")
-    assert_equal(5..7, p.expression)
-    assert_equal(1..9, p.expression)
-    assert_equal(
-      RangeLookup.new(VariableLookup.send(:new, 'young', [], 0), VariableLookup.send(:new, 'old', [], 0)),
-      p.expression
-    )
-    assert_equal(
-      RangeLookup.new(VariableLookup.send(:new, 'hi', [5, "wat"], 0), VariableLookup.send(:new, 'old', [], 0)),
-      p.expression
-    )
+    assert_equal('(5..7)', p.expression)
+    assert_equal('(1.5..9.6)', p.expression)
+    assert_equal('(young..old)', p.expression)
+    assert_equal('(hi[5].wat..old)', p.expression)
   end
 
   def test_arguments
     p = Parser.new("filter: hi.there[5], keyarg: 7")
     assert_equal('filter', p.consume(:id))
     assert_equal(':', p.consume(:colon))
-    assert_equal([[VariableLookup.send(:new, "hi", ["there", 5], 0)], { "keyarg" => 7 }], p.arguments)
+    assert_equal('hi.there[5]', p.argument)
+    assert_equal(',', p.consume(:comma))
+    assert_equal('keyarg: 7', p.argument)
   end
 
   def test_invalid_expression

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/variable_lookup_unit_test.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class VariableLookupUnitTest < Minitest::Test
-  include Liquid
-
-  def test_variable_lookup_parsing
-    lookup = parse_variable_lookup('a.b.c')
-    assert_equal('a', lookup.name)
-    assert_equal(['b', 'c'], lookup.lookups)
-
-    lookup = parse_variable_lookup('a[b]')
-    assert_equal('a', lookup.name)
-    assert_equal([parse_variable_lookup('b')], lookup.lookups)
-  end
-
-  def test_to_s
-    lookup = parse_variable_lookup('a.b.c')
-    assert_equal("a['b']['c']", lookup.to_s)
-
-    lookup = parse_variable_lookup('a[b.c].d')
-    assert_equal("a[b['c']]['d']", lookup.to_s)
-
-    lookup = parse_variable_lookup('a["foo.bar"].d')
-    assert_equal("a['foo.bar']['d']", lookup.to_s)
-  end
-
-  private
-
-  def parse_variable_lookup(markup)
-    if Liquid::Template.error_mode == :strict
-      p = Liquid::Parser.new(markup)
-      VariableLookup.strict_parse(p)
-    else
-      VariableLookup.lax_parse(markup)
-    end
-  end
-end

test/unit/variable_unit_test.rb

@@ -7,20 +7,20 @@ class VariableUnitTest < Minitest::Test
 
   def test_variable
     var = create_variable('hello')
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
   end
 
   def test_filters
     var = create_variable('hello | textileze')
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['textileze', []]], var.filters)
 
     var = create_variable('hello | textileze | paragraph')
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable(%( hello | strftime: '%Y'))
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['strftime', ['%Y']]], var.filters)
 
     var = create_variable(%( 'typo' | link_to: 'Typo', true ))
@@ -44,11 +44,11 @@ class VariableUnitTest < Minitest::Test
     assert_equal([['repeat', [3, 3, 3]]], var.filters)
 
     var = create_variable(%( hello | strftime: '%Y, okay?'))
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['strftime', ['%Y, okay?']]], var.filters)
 
     var = create_variable(%( hello | things: "%Y, okay?", 'the other one'))
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['things', ['%Y, okay?', 'the other one']]], var.filters)
   end
 
@@ -60,24 +60,22 @@ class VariableUnitTest < Minitest::Test
 
   def test_filters_without_whitespace
     var = create_variable('hello | textileze | paragraph')
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable('hello|textileze|paragraph')
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable("hello|replace:'foo','bar'|textileze")
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['replace', ['foo', 'bar']], ['textileze', []]], var.filters)
   end
 
   def test_symbol
-    with_error_mode(:lax) do
-      var = create_variable("http://disney.com/logo.gif | image: 'med' ", error_mode: :lax)
-      assert_equal(parse_variable_lookup('http://disney.com/logo.gif'), var.name)
-      assert_equal([['image', ['med']]], var.filters)
-    end
+    var = create_variable("http://disney.com/logo.gif | image: 'med' ", error_mode: :lax)
+    assert_equal(VariableLookup.new('http://disney.com/logo.gif'), var.name)
+    assert_equal([['image', ['med']]], var.filters)
   end
 
   def test_string_to_filter
@@ -107,8 +105,8 @@ class VariableUnitTest < Minitest::Test
   end
 
   def test_dashes
-    assert_equal(parse_variable_lookup('foo-bar'), create_variable('foo-bar').name)
-    assert_equal(parse_variable_lookup('foo-bar-2'), create_variable('foo-bar-2').name)
+    assert_equal(VariableLookup.new('foo-bar'), create_variable('foo-bar').name)
+    assert_equal(VariableLookup.new('foo-bar-2'), create_variable('foo-bar-2').name)
 
     with_error_mode :strict do
       assert_raises(Liquid::SyntaxError) { create_variable('foo - bar') }
@@ -124,18 +122,18 @@ class VariableUnitTest < Minitest::Test
 
   def test_string_dot
     var = create_variable(%( test.test ))
-    assert_equal(parse_variable_lookup('test.test'), var.name)
+    assert_equal(VariableLookup.new('test.test'), var.name)
   end
 
   def test_filter_with_keyword_arguments
     var = create_variable(%( hello | things: greeting: "world", farewell: 'goodbye'))
-    assert_equal(parse_variable_lookup('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['things', [], { 'greeting' => 'world', 'farewell' => 'goodbye' }]], var.filters)
   end
 
   def test_lax_filter_argument_parsing
     var = create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ), error_mode: :lax)
-    assert_equal(parse_variable_lookup('number_of_comments'), var.name)
+    assert_equal(VariableLookup.new('number_of_comments'), var.name)
     assert_equal([['pluralize', ['comment', 'comments']]], var.filters)
   end
 
@@ -152,17 +150,14 @@ class VariableUnitTest < Minitest::Test
     assert_equal(" name_of_variable | upcase ", var.raw)
   end
 
-  private
-
-  def parse_variable_lookup(markup)
-    if Liquid::Template.error_mode == :strict
-      p = Liquid::Parser.new(markup)
-      VariableLookup.strict_parse(p)
-    else
-      VariableLookup.lax_parse(markup)
-    end
+  def test_variable_lookup_interface
+    lookup = VariableLookup.new('a.b.c')
+    assert_equal('a', lookup.name)
+    assert_equal(['b', 'c'], lookup.lookups)
   end
 
+  private
+
   def create_variable(markup, options = {})
     Variable.new(markup, ParseContext.new(options))
   end