TDD: Unit tests for infix operators (no functionality yet)

.github/dependabot.yaml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: github-actions
-    directory: "/"
-    schedule:
-      interval: weekly

.github/workflows/liquid.yml

@@ -1,5 +1,5 @@
 name: Liquid
-on: [push]
+on: [push, pull_request]
 
 env:
   BUNDLE_JOBS: 4
@@ -9,34 +9,30 @@ jobs:
   test:
     runs-on: ubuntu-latest
     strategy:
-      fail-fast: false
       matrix:
         entry:
-          - { ruby: 3.3, allowed-failure: false } # minimum supported
-          - { ruby: 3.4, allowed-failure: false, rubyopt: "--yjit" }
-          - { ruby: 4.0, allowed-failure: false } # latest stable
+          - { ruby: 3.0, allowed-failure: false } # minimum supported
+          - { ruby: 3.2, allowed-failure: false }
+          - { ruby: 3.3, allowed-failure: false }
+          - { ruby: 3.3, allowed-failure: false }
+          - { ruby: 3.4, allowed-failure: false } # latest
           - {
-              ruby: 4.0,
+              ruby: 3.4,
               allowed-failure: false,
               rubyopt: "--enable-frozen-string-literal",
             }
-          - { ruby: 4.0, allowed-failure: false, rubyopt: "--yjit" }
-          - { ruby: 4.0, allowed-failure: false, rubyopt: "--zjit" }
-          - { ruby: truffleruby, allowed-failure: false }
-
-          # Head can have failures due to being in development
-          - { ruby: head, allowed-failure: true }
+          - { ruby: 3.4, allowed-failure: false, rubyopt: "--yjit" }
+          - { ruby: ruby-head, allowed-failure: false }
           - {
-              ruby: head,
-              allowed-failure: true,
+              ruby: ruby-head,
+              allowed-failure: false,
               rubyopt: "--enable-frozen-string-literal",
             }
-          - { ruby: head, allowed-failure: true, rubyopt: "--yjit" }
-          - { ruby: head, allowed-failure: true, rubyopt: "--zjit" }
-    name: Test Ruby ${{ matrix.entry.ruby }} ${{ matrix.entry.rubyopt }} --${{ matrix.entry.allowed-failure && 'allowed-failure' || 'strict' }}
+          - { ruby: ruby-head, allowed-failure: false, rubyopt: "--yjit" }
+    name: Test Ruby ${{ matrix.entry.ruby }}
     steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.entry.ruby }}
           bundler-cache: true
@@ -46,28 +42,11 @@ jobs:
         env:
           RUBYOPT: ${{ matrix.entry.rubyopt }}
 
-  spec:
-    runs-on: ubuntu-latest
-    env:
-      BUNDLE_WITH: spec
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
-        with:
-          bundler-cache: true
-          bundler: latest
-      - name: Run liquid-spec for all adapters
-        run: |
-          for adapter in spec/*.rb; do
-            echo "=== Running $adapter ==="
-            bundle exec liquid-spec run "$adapter" --no-max-failures
-          done
-
   memory_profile:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
         with:
           bundler-cache: true
       - run: bundle exec rake memory_profile:run

.rubocop_todo.yml

@@ -174,16 +174,7 @@ Style/WordArray:
 
 # Offense count: 117
 # This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, AllowCopDirectives, AllowedPatterns.
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, AllowedPatterns, IgnoredPatterns.
 # URISchemes: http, https
 Layout/LineLength:
   Max: 260
-
-Naming/PredicatePrefix:
-  Enabled: false
-
-# Offense count: 1
-# This is intentional - early return from begin/rescue in assignment context
-Lint/NoReturnInBeginEndBlocks:
-  Exclude:
-    - 'lib/liquid/standardfilters.rb'

.ruby-version

@@ -1 +1 @@
-4.0.2
+3.4.1

Gemfile

@@ -25,13 +25,7 @@ group :development do
 end
 
 group :test do
-  gem 'benchmark'
-  gem 'rubocop', '~> 1.82.0'
-  gem 'rubocop-shopify', '~> 2.18.0', require: false
+  gem 'rubocop', '~> 1.61.0'
+  gem 'rubocop-shopify', '~> 2.12.0', require: false
   gem 'rubocop-performance', require: false
 end
-
-group :spec do
-  gem 'liquid-spec', github: 'Shopify/liquid-spec'
-  gem 'activesupport', require: false
-end

History.md

@@ -1,29 +1,6 @@
 # Liquid Change Log
 
-## 5.13.0
-
-* Add TruffleRuby in CI [Benoit Daloze]
-* Skip slow test raising many exceptions on non-CRuby [Benoit Daloze]
-* Reject bare-bracket syntax in strict2 and introduce `self` keyword by [Alok Swamy]
-* Add strict2_parse to assign and capture tags by [Alok Swamy]
-* Add strict2_parse to increment and decrement tags by [Alok Swamy]
-* Update liquid-spec adapters for `missing_features` [Ian Ker-Seymer]
-* Prevent `SelfDrop` context mutation across render boundaries [Guilherme Carreiro]
-* Fix `SelfDrop` equality [Guilherme Carreiro]
-* Let environment `self` shadow `SelfDrop` [Ian Ker-Seymer]
-
-## 5.11.0
-* Revert the Inline Snippets tag (#2001), treat its inclusion in the latest Liquid release as a bug, and allow for feedback on RFC#1916 to better support Liquid developers [Guilherme Carreiro]
-* Rename the `:rigid` error mode to `:strict2` and display a warning when users attempt to use the `:rigid` mode [Guilherme Carreiro]
-
-## 5.10.0
-* Introduce support for Inline Snippets [Julia Boutin]
-
-## 5.9.0
-* Introduce `:rigid` error mode for stricter, safer parsing of all tags [CP Clermont, Guilherme Carreiro]
-
-## 5.8.7
-* Expose body content in the `Doc` tag [James Meng]
+## 5.8.1 (unreleased)
 
 ## 5.8.1
 

README.md

@@ -99,14 +99,14 @@ Setting the error mode of Liquid lets you specify how strictly you want your tem
 Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
 it very hard to debug and can lead to unexpected behaviour.
 
-Liquid also comes with different parsers that can be used when editing templates to give better error messages
+Liquid also comes with a stricter parser that can be used when editing templates to give better error messages
 when templates are invalid. You can enable this new parser like this:
 
 ```ruby
-Liquid::Environment.default.error_mode = :strict2 # Raises a SyntaxError when invalid syntax is used in all tags
-Liquid::Environment.default.error_mode = :strict  # Raises a SyntaxError when invalid syntax is used in some tags
-Liquid::Environment.default.error_mode = :warn    # Adds strict errors to template.errors but continues as normal
-Liquid::Environment.default.error_mode = :lax     # The default mode, accepts almost anything.
+Liquid::Environment.default.error_mode = :strict
+Liquid::Environment.default.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
+Liquid::Environment.default.error_mode = :warn # Adds strict errors to template.errors but continues as normal
+Liquid::Environment.default.error_mode = :lax # The default mode, accepts almost anything.
 ```
 
 If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:

Rakefile

@@ -33,7 +33,7 @@ task :rubocop do
   end
 end
 
-desc('runs test suite with lax, strict, and strict2 parsers')
+desc('runs test suite with both strict and lax parsers')
 task :test do
   ENV['LIQUID_PARSER_MODE'] = 'lax'
   Rake::Task['base_test'].invoke
@@ -42,10 +42,6 @@ task :test do
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
-  ENV['LIQUID_PARSER_MODE'] = 'strict2'
-  Rake::Task['base_test'].reenable
-  Rake::Task['base_test'].invoke
-
   if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
     ENV['LIQUID_PARSER_MODE'] = 'lax'
     Rake::Task['integration_test'].reenable
@@ -54,10 +50,6 @@ task :test do
     ENV['LIQUID_PARSER_MODE'] = 'strict'
     Rake::Task['integration_test'].reenable
     Rake::Task['integration_test'].invoke
-
-    ENV['LIQUID_PARSER_MODE'] = 'strict2'
-    Rake::Task['integration_test'].reenable
-    Rake::Task['integration_test'].invoke
   end
 end
 
@@ -88,13 +80,8 @@ namespace :benchmark do
     ruby "./performance/benchmark.rb strict"
   end
 
-  desc "Run the liquid benchmark with strict2 parsing"
-  task :strict2 do
-    ruby "./performance/benchmark.rb strict2"
-  end
-
-  desc "Run the liquid benchmark with lax, strict, and strict2 parsing"
-  task run: [:lax, :strict, :strict2]
+  desc "Run the liquid benchmark with both lax and strict parsing"
+  task run: [:lax, :strict]
 
   desc "Run unit benchmarks"
   namespace :unit do
@@ -148,11 +135,3 @@ end
 task :console do
   exec 'irb -I lib -r liquid'
 end
-
-desc('run liquid-spec suite across all adapters')
-task :spec do
-  Dir['./spec/*.rb'].sort.each do |adapter|
-    puts "=== Running #{adapter} ==="
-    sh 'bundle', 'exec', 'liquid-spec', 'run', adapter, '--no-max-failures'
-  end
-end

bin/render

@@ -1,46 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'liquid'
-
-class VirtualFileSystem
-  def initialize
-    snippet_1 = <<~LIQUID
-      <h1>
-        {{- greating | default: 'Hello' }}, {{ name | default: 'world' -}}!
-      </h1>
-    LIQUID
-    snippet_2 = <<~LIQUID
-      {%- for i in (1..5) -%}
-        > {{ i }}
-      {%- endfor -%}
-    LIQUID
-
-    @templates = {
-      'snippet-1' => snippet_1,
-      'snippet-2' => snippet_2,
-    }
-  end
-
-  def read_template_file(key)
-    @templates[key] || raise(Liquid::FileSystemError, "No such template '#{key}'")
-  end
-end
-
-def source
-  File.read(ARGV[0])
-rescue StandardError
-  'Usage: bin/render example/server/templates/index.liquid'
-end
-
-def assigns
-  {
-    'date' => Time.now,
-  }
-end
-
-puts Liquid::Template
-  .parse(source, error_mode: :strict2)
-  .tap { |t| t.registers[:file_system] = VirtualFileSystem.new }
-  .render(assigns)

docs/template_recorder.md

@@ -1,72 +0,0 @@
-# Recording and replaying renders
-
-`Liquid::TemplateRecorder` captures successful template renders so they can be
-replayed without the application's file system or Drop implementations.
-Recording does not wrap or replace assigns, so the recorded render has the same
-semantics as a normal render.
-
-```ruby
-Liquid::TemplateRecorder.record("render.json") do
-  template = Liquid::Template.parse(source)
-  template.render!(assigns)
-end
-
-replayer = Liquid::TemplateRecorder.replay_from("render.json", mode: :verify)
-replayer.render # raises if the output changed
-```
-
-A recording contains the root template, every parsed partial, partial contents,
-plain Hash/Array values resolved by the template, properties actually read from `Liquid::Drop` objects,
-filter-call diagnostics, engine options, and the rendered output. Drop instance
-variables are never inspected. An unsupported Ruby object raises
-`Liquid::TemplateRecorder::SerializationError` rather than silently producing a
-recording that cannot be replayed.
-
-## Storage formats
-
-A `.json` destination is written atomically after the recording block succeeds.
-It contains a session with every render performed by the block.
-
-A `.jsonl` destination is append-only. Each successful top-level render is one
-compact, self-contained JSON line. This is the recommended format for production
-sampling: a process failure can lose at most the render being written, writers
-are serialized with `flock`, and a recording can be replayed by index.
-
-A destination may instead be any writer object responding to `write(record)`. The
-writer receives one self-contained recording Hash per successful render. Liquid
-does not own or close injected writers, so applications can publish records to
-Kafka, object storage, or another transport without coupling that transport to
-the recorder.
-Pass `on_error:` to keep serialization or sink failures out of the render path;
-the callback receives the error and should not raise.
-
-```ruby
-Liquid::TemplateRecorder.record(kafka_writer) do
-  template.render!(assigns)
-end
-```
-
-```ruby
-Liquid::TemplateRecorder.replay_from("renders.jsonl")           # last render
-Liquid::TemplateRecorder.replay_from("renders.jsonl", index: 0) # first render
-Liquid::TemplateRecorder.records("renders.jsonl")               # inspect all
-```
-
-Compression is intentionally separate from the schema. In particular, one
-long-lived compressed stream makes appending, recovery, and selecting a render
-harder. Compress rotated `.jsonl` files with the storage system of your choice;
-a future compressed writer can use one independent frame per record without a
-schema change.
-
-Recording sessions are thread-local. Nested sessions in the same thread are
-rejected. Existing application register names and the one-argument
-`FileSystem#read_template_file` API remain unchanged.
-
-## Replay modes
-
-* `:compute` runs filters normally. Pass application filters with
-  `replayer.render(filters: MyFilters)`.
-* `:strict` returns each exact recorded filter result and rejects a changed
-  filter sequence. This can replay application-specific or nondeterministic
-  filters without loading their implementations.
-* `:verify` computes normally and raises when the final output differs.

lib/liquid.rb

@@ -65,7 +65,6 @@ require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
 require 'liquid/drop'
-require 'liquid/self_drop'
 require 'liquid/tablerowloop_drop'
 require 'liquid/forloop_drop'
 require 'liquid/extensions'
@@ -90,4 +89,3 @@ require 'liquid/partial_cache'
 require 'liquid/usage'
 require 'liquid/registers'
 require 'liquid/template_factory'
-require "liquid/template_recorder"

lib/liquid/block_body.rb

@@ -84,15 +84,10 @@ module Liquid
 
     # @api private
     def self.render_node(context, output, node)
-      recorder = TemplateRecorder.current
-      tag_call = recorder&.begin_tag_render(node, context)
-      output_start = output.length
       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)
-    ensure
-      recorder&.finish_tag_render(tag_call, output[output_start..]) if output_start
     end
 
     # @api private
@@ -104,9 +99,7 @@ module Liquid
         context.handle_error(exc, line_number)
       else
         error_message = context.handle_error(exc, line_number)
-        error_mode = context.registers.static[:template_error_mode]
-        suppress_error_text = blank_tag && error_mode != :strict2 && error_mode != :rigid
-        unless suppress_error_text # blank-tag suppression is kept for backwards compatibility outside strict2
+        unless blank_tag # conditional for backwards compatibility
           output << error_message
         end
       end

lib/liquid/condition.rb

@@ -48,8 +48,8 @@ module Liquid
       @@operators
     end
 
-    def self.parse_expression(parse_context, markup, safe: false)
-      @@method_literals[markup] || parse_context.parse_expression(markup, safe: safe)
+    def self.parse_expression(parse_context, markup)
+      @@method_literals[markup] || parse_context.parse_expression(markup)
     end
 
     attr_reader :attachment, :child_condition
@@ -113,67 +113,24 @@ module Liquid
 
     def equal_variables(left, right)
       if left.is_a?(MethodLiteral)
-        return call_method_literal(left, right)
+        if right.respond_to?(left.method_name)
+          return right.send(left.method_name)
+        else
+          return nil
+        end
       end
 
       if right.is_a?(MethodLiteral)
-        return call_method_literal(right, left)
+        if left.respond_to?(right.method_name)
+          return left.send(right.method_name)
+        else
+          return nil
+        end
       end
 
       left == right
     end
 
-    def call_method_literal(literal, value)
-      method_name = literal.method_name
-
-      # If the object responds to the method (e.g., ActiveSupport is loaded), use it
-      if value.respond_to?(method_name)
-        value.send(method_name)
-      else
-        # Emulate ActiveSupport's blank?/empty? to make Liquid invariant
-        # to whether ActiveSupport is loaded or not
-        case method_name
-        when :blank?
-          liquid_blank?(value)
-        when :empty?
-          liquid_empty?(value)
-        else
-          false
-        end
-      end
-    end
-
-    # Implement blank? semantics matching ActiveSupport
-    # blank? returns true for nil, false, empty strings, whitespace-only strings,
-    # empty arrays, and empty hashes
-    def liquid_blank?(value)
-      case value
-      when NilClass, FalseClass
-        true
-      when TrueClass, Numeric
-        false
-      when String
-        # Blank if empty or whitespace only (matches ActiveSupport)
-        value.empty? || value.match?(/\A\s*\z/)
-      when Array, Hash
-        value.empty?
-      else
-        # Fall back to empty? if available, otherwise false
-        value.respond_to?(:empty?) ? value.empty? : false
-      end
-    end
-
-    # Implement empty? semantics
-    # Note: nil is NOT empty. empty? checks if a collection has zero elements.
-    def liquid_empty?(value)
-      case value
-      when String, Array, Hash
-        value.empty?
-      else
-        value.respond_to?(:empty?) ? value.empty? : false
-      end
-    end
-
     def interpret_condition(left, right, op, context)
       # If the operator is empty this means that the decision statement is just
       # a single variable. We can just poll this variable from the context and
@@ -197,8 +154,8 @@ module Liquid
     end
 
     def deprecated_default_context
-      warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated " \
-        "and will be removed from Liquid 6.0.0.")
+      warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \
+        " and will be removed from Liquid 6.0.0.")
       Context.new
     end
 

lib/liquid/context.rb

@@ -184,16 +184,7 @@ module Liquid
     end
 
     def key?(key)
-      find_variable(key, raise_on_not_found: false) != nil
-    end
-
-    # Checks whether a variable is defined in any scope, including nil-valued keys.
-    # Unlike #key?, this uses Hash#key? so that variables explicitly set to nil
-    # are still considered defined.
-    def variable_defined?(key)
-      @scopes.any? { |s| s.key?(key) } ||
-        @environments.any? { |e| e.key?(key) } ||
-        @static_environments.any? { |e| e.key?(key) }
+      self[key] != nil
     end
 
     def evaluate(object)
@@ -206,21 +197,12 @@ module Liquid
       # path and find_index() is optimized in MRI to reduce object allocation
       index = @scopes.find_index { |s| s.key?(key) }
 
-      fallback_to_self_drop = key == Expression::SELF && index.nil?
-
       variable = if index
         lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
       else
-        try_variable_find_in_environments(
-          key,
-          raise_on_not_found: raise_on_not_found && !fallback_to_self_drop,
-        )
+        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
       end
 
-      # `self` resolves to a SelfDrop (enabling `self['var']` lookups),
-      # but only after the normal environment lookup doesn't find a value.
-      return @self_drop ||= SelfDrop.new(self) if fallback_to_self_drop && variable.nil?
-
       # update variable's context before invoking #to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
@@ -228,8 +210,6 @@ module Liquid
 
       liquid_variable.context = self if variable != liquid_variable && liquid_variable.respond_to?(:context=)
 
-      recorder = @registers[TemplateRecorder::REGISTER_KEY] if defined?(TemplateRecorder)
-      recorder&.emit_variable_read(key, liquid_variable)
       liquid_variable
     end
 

lib/liquid/drop.rb

@@ -31,21 +31,17 @@ module Liquid
 
     # Catch all for the method
     def liquid_method_missing(method)
-      return unless @context&.strict_variables
+      return nil unless @context&.strict_variables
       raise Liquid::UndefinedDropMethod, "undefined method #{method}"
     end
 
     # called by liquid to invoke a drop
     def invoke_drop(method_or_key)
-      result = if self.class.invokable?(method_or_key)
+      if self.class.invokable?(method_or_key)
         send(method_or_key)
       else
         liquid_method_missing(method_or_key)
       end
-
-      recorder = @context&.registers&.[](TemplateRecorder::REGISTER_KEY) if defined?(TemplateRecorder)
-      recorder&.emit_drop_read(self, method_or_key, result)
-      result
     end
 
     def key?(_name)

lib/liquid/environment.rb

@@ -34,7 +34,7 @@ module Liquid
       # @param file_system The default file system that is used
       #  to load templates from.
       # @param error_mode [Symbol] The default error mode for all templates
-      #  (either :strict2, :strict, :warn, or :lax).
+      #  (either :strict, :warn, or :lax).
       # @param exception_renderer [Proc] The exception renderer that is used to
       #   render exceptions.
       # @yieldparam environment [Environment] The environment instance that is being built.

lib/liquid/expression.rb

@@ -2,8 +2,6 @@
 
 module Liquid
   class Expression
-    SELF = 'self'
-
     LITERALS = {
       nil => nil,
       'nil' => nil,
@@ -30,10 +28,6 @@ module Liquid
     FLOAT_REGEX = /\A(-?\d+)\.\d+\z/
 
     class << self
-      def safe_parse(parser, ss = StringScanner.new(""), cache = nil)
-        parse(parser.expression, ss, cache)
-      end
-
       def parse(markup, ss = StringScanner.new(""), cache = nil)
         return unless markup
 
@@ -57,7 +51,7 @@ module Liquid
       end
 
       def inner_parse(markup, ss, cache)
-        if markup.start_with?("(") && markup.end_with?(")") && markup =~ RANGES_REGEX
+        if (markup.start_with?("(") && markup.end_with?(")")) && markup =~ RANGES_REGEX
           return RangeLookup.parse(
             Regexp.last_match(1),
             Regexp.last_match(2),

lib/liquid/i18n.rb

@@ -28,7 +28,7 @@ module Liquid
     def interpolate(name, vars)
       name.gsub(/%\{(\w+)\}/) do
         # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        vars[Regexp.last_match(1).to_sym].to_s
+        (vars[Regexp.last_match(1).to_sym]).to_s
       end
     end
 

lib/liquid/locales/en.yml

@@ -20,7 +20,6 @@
       invalid_template_encoding: "Invalid template encoding"
       render: "Syntax error in tag 'render' - Template name must be a quoted string"
       table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
-      table_row_invalid_attribute: "Invalid attribute '%{attribute}' in tablerow loop. Valid attributes are cols, limit, offset, and range"
       tag_never_closed: "'%{block_name}' tag was never closed"
       tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
       unexpected_else: "%{block_name} tag does not expect 'else' tag"

lib/liquid/parse_context.rb

@@ -38,7 +38,7 @@ module Liquid
 
     def new_parser(input)
       @string_scanner.string = input
-      Parser.new(@string_scanner, reject_bare_brackets: @error_mode == :strict2 || @error_mode == :rigid)
+      Parser.new(@string_scanner)
     end
 
     def new_tokenizer(source, start_line_number: nil, for_liquid_tag: false)
@@ -50,22 +50,7 @@ module Liquid
       )
     end
 
-    def safe_parse_expression(parser)
-      Expression.safe_parse(parser, @string_scanner, @expression_cache)
-    end
-
-    def parse_expression(markup, safe: false)
-      if !safe && @error_mode == :strict2
-        # parse_expression is a widely used API. To maintain backward
-        # compatibility while raising awareness about strict2 parser standards,
-        # the safe flag supports API users make a deliberate decision.
-        #
-        # In strict2 mode, markup MUST come from a string returned by the parser
-        # (e.g., parser.expression). We're not calling the parser here to
-        # prevent redundant parser overhead.
-        raise Liquid::InternalError, "unsafe parse_expression cannot be used in strict2 mode"
-      end
-
+    def parse_expression(markup)
       Expression.parse(markup, @string_scanner, @expression_cache)
     end
 

lib/liquid/parser.rb

@@ -2,11 +2,10 @@
 
 module Liquid
   class Parser
-    def initialize(input, reject_bare_brackets: false)
+    def initialize(input)
       ss = input.is_a?(StringScanner) ? input : StringScanner.new(input)
       @tokens = Lexer.tokenize(ss)
       @p      = 0 # pointer to current location
-      @reject_bare_brackets = reject_bare_brackets
     end
 
     def jump(point)
@@ -54,9 +53,6 @@ module Liquid
         str = consume
         str << variable_lookups
       when :open_square
-        if @reject_bare_brackets
-          raise SyntaxError, "Bare bracket access is not allowed. Use #{Expression::SELF}['...'] instead"
-        end
         str = consume.dup
         str << expression
         str << consume(:close_square)

lib/liquid/parser_switching.rb

@@ -2,25 +2,10 @@
 
 module Liquid
   module ParserSwitching
-    # Do not use this.
-    #
-    # It's basically doing the same thing the {#parse_with_selected_parser},
-    # except this will try the strict parser regardless of the error mode,
-    # and fall back to the lax parser if the error mode is lax or warn,
-    # except when in strict2 mode where it uses the strict2 parser.
-    #
-    # @deprecated Use {#parse_with_selected_parser} instead.
     def strict_parse_with_error_mode_fallback(markup)
-      return strict2_parse_with_error_context(markup) if strict2_mode?
-
       strict_parse_with_error_context(markup)
     rescue SyntaxError => e
       case parse_context.error_mode
-      when :rigid
-        rigid_warn
-        raise
-      when :strict2
-        raise
       when :strict
         raise
       when :warn
@@ -31,13 +16,11 @@ module Liquid
 
     def parse_with_selected_parser(markup)
       case parse_context.error_mode
-      when :rigid   then rigid_warn && strict2_parse_with_error_context(markup)
-      when :strict2 then strict2_parse_with_error_context(markup)
-      when :strict  then strict_parse_with_error_context(markup)
-      when :lax     then lax_parse(markup)
+      when :strict then strict_parse_with_error_context(markup)
+      when :lax    then lax_parse(markup)
       when :warn
         begin
-          strict2_parse_with_error_context(markup)
+          strict_parse_with_error_context(markup)
         rescue SyntaxError => e
           parse_context.warnings << e
           lax_parse(markup)
@@ -45,24 +28,8 @@ module Liquid
       end
     end
 
-    def strict2_mode?
-      parse_context.error_mode == :strict2 || parse_context.error_mode == :rigid
-    end
-
     private
 
-    def rigid_warn
-      Deprecations.warn(':rigid', ':strict2')
-    end
-
-    def strict2_parse_with_error_context(markup)
-      strict2_parse(markup)
-    rescue SyntaxError => e
-      e.line_number    = line_number
-      e.markup_context = markup_context(markup)
-      raise e
-    end
-
     def strict_parse_with_error_context(markup)
       strict_parse(markup)
     rescue SyntaxError => e

lib/liquid/partial_cache.rb

@@ -10,8 +10,6 @@ module Liquid
 
       file_system = context.registers[:file_system]
       source      = file_system.read_template_file(template_name)
-      recorder = context.registers[TemplateRecorder::REGISTER_KEY] if defined?(TemplateRecorder)
-      recorder&.emit_file_read(template_name, source)
 
       parse_context.partial = true
 

lib/liquid/resource_limits.rb

@@ -2,39 +2,24 @@
 
 module Liquid
   class ResourceLimits
-    attr_accessor :render_length_limit,
-      :render_score_limit,
-      :assign_score_limit,
-      :cumulative_render_score_limit,
-      :cumulative_assign_score_limit
-    attr_reader :render_score,
-      :assign_score,
-      :cumulative_render_score,
-      :cumulative_assign_score
+    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
+    attr_reader :render_score, :assign_score
 
     def initialize(limits)
-      @render_length_limit           = limits[:render_length_limit]
-      @render_score_limit            = limits[:render_score_limit]
-      @assign_score_limit            = limits[:assign_score_limit]
-      @cumulative_render_score_limit = limits[:cumulative_render_score_limit]
-      @cumulative_assign_score_limit = limits[:cumulative_assign_score_limit]
-      @cumulative_render_score = 0
-      @cumulative_assign_score = 0
+      @render_length_limit = limits[:render_length_limit]
+      @render_score_limit  = limits[:render_score_limit]
+      @assign_score_limit  = limits[:assign_score_limit]
       reset
     end
 
     def increment_render_score(amount)
       @render_score += amount
-      @cumulative_render_score += amount
       raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
-      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
     end
 
     def increment_assign_score(amount)
       @assign_score += amount
-      @cumulative_assign_score += amount
       raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
-      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_assign_score_limit
     end
 
     # update either render_length or assign_score based on whether or not the writes are captured
@@ -62,8 +47,6 @@ module Liquid
       @reached_limit = false
       @last_capture_length = nil
       @render_score = @assign_score = 0
-      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
-      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_assign_score_limit
     end
 
     def with_capture

lib/liquid/self_drop.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # @liquid_public_docs
-  # @liquid_type object
-  # @liquid_name self
-  # @liquid_summary
-  #   Provides access to variables through the current scope chain.
-  # @liquid_description
-  #   The `self` object resolves variables through the normal lookup hierarchy
-  #   (local > file > global) without exposing filters, interrupts, errors,
-  #   or other context internals. It's used when bare bracket notation
-  #   (`['variable']`) needs to be replaced with an explicit variable lookup.
-  #
-  #   If `self` is explicitly assigned as a local variable (e.g. `{% assign self = 'value' %}`),
-  #   then the local value takes precedence over the `self` object.
-  # @liquid_access global
-  class SelfDrop < Drop
-    def initialize(self_context)
-      super()
-      @self_context = self_context
-    end
-
-    def [](key)
-      @self_context.find_variable(key)
-    rescue UndefinedVariable
-      nil
-    end
-
-    def key?(key)
-      @self_context.variable_defined?(key)
-    end
-
-    def to_liquid
-      self
-    end
-
-    def ==(other)
-      other.is_a?(SelfDrop) && other.self_context.equal?(@self_context)
-    end
-
-    alias_method :eql?, :==
-
-    def hash
-      @self_context.object_id.hash
-    end
-
-    protected
-
-    attr_reader :self_context
-
-    undef context=
-  end
-end

lib/liquid/standardfilters.rb

@@ -3,24 +3,16 @@
 require 'cgi'
 require 'base64'
 require 'bigdecimal'
+
 module Liquid
   module StandardFilters
     MAX_I32 = (1 << 31) - 1
     private_constant :MAX_I32
 
-    supports_64bit_indices = begin
-      [][1 << 33, 1 << 33]
-      true
-    rescue RangeError
-      false
-    end
-
-    INDEX_RANGE = if supports_64bit_indices
-      (-(1 << 63))..((1 << 63) - 1)
-    else
-      (-(1 << 31))..((1 << 31) - 1)
-    end
-    private_constant :INDEX_RANGE
+    MIN_I64 = -(1 << 63)
+    MAX_I64 = (1 << 63) - 1
+    I64_RANGE = MIN_I64..MAX_I64
+    private_constant :MIN_I64, :MAX_I64, :I64_RANGE
 
     HTML_ESCAPE = {
       '&' => '&amp;',
@@ -223,11 +215,11 @@ module Liquid
           Utils.to_s(input).slice(offset, length) || ''
         end
       rescue RangeError
-        if INDEX_RANGE.cover?(length) && INDEX_RANGE.cover?(offset)
+        if I64_RANGE.cover?(length) && I64_RANGE.cover?(offset)
           raise # unexpected error
         end
-        offset = offset.clamp(INDEX_RANGE)
-        length = length.clamp(INDEX_RANGE)
+        offset = offset.clamp(I64_RANGE)
+        length = length.clamp(I64_RANGE)
         retry
       end
     end
@@ -302,19 +294,6 @@ module Liquid
       input.split(pattern)
     end
 
-    # @liquid_public_docs
-    # @liquid_type filter
-    # @liquid_category string
-    # @liquid_summary
-    #   Removes leading and trailing whitespace and collapses consecutive whitespace to a single space.
-    # @liquid_syntax string | squish
-    # @liquid_return [string]
-    def squish(input)
-      return if input.nil?
-
-      Utils.to_s(input).strip.gsub(/\s+/, ' ')
-    end
-
     # @liquid_public_docs
     # @liquid_type filter
     # @liquid_category string
@@ -733,16 +712,7 @@ module Liquid
       input.gsub(/\r?\n/, "<br />\n")
     end
 
-    # @liquid_public_docs
-    # @liquid_type filter
-    # @liquid_category date
-    # @liquid_summary
-    #   Formats a date according to a specified format string.
-    # @liquid_description
-    #   This filter formats a date using various format specifiers. If the format string is empty,
-    #   the original input is returned. If the input cannot be converted to a date, the original input is returned.
-    #
-    #   The following format specifiers can be used:
+    # Reformat a date using Ruby's core Time#strftime( string ) -> string
     #
     #   %a - The abbreviated weekday name (``Sun'')
     #   %A - The  full  weekday  name (``Sunday'')
@@ -771,8 +741,8 @@ module Liquid
     #   %Y - Year with century
     #   %Z - Time zone name
     #   %% - Literal ``%'' character
-    # @liquid_syntax date | date: string
-    # @liquid_return [string]
+    #
+    #   See also: http://www.ruby-doc.org/core/Time.html#method-i-strftime
     def date(input, format)
       str_format = Utils.to_s(format)
       return input if str_format.empty?
@@ -790,8 +760,6 @@ module Liquid
     # @liquid_syntax array | first
     # @liquid_return [untyped]
     def first(array)
-      # ActiveSupport returns "" for empty strings, not nil
-      return array[0] || "" if array.is_a?(String)
       array.first if array.respond_to?(:first)
     end
 
@@ -803,8 +771,6 @@ module Liquid
     # @liquid_syntax array | last
     # @liquid_return [untyped]
     def last(array)
-      # ActiveSupport returns "" for empty strings, not nil
-      return array[-1] || "" if array.is_a?(String)
       array.last if array.respond_to?(:last)
     end
 
@@ -1023,7 +989,7 @@ module Liquid
     end
 
     def raise_property_error(property)
-      raise Liquid::ArgumentError, "cannot select the property '#{Utils.to_s(property)}'"
+      raise Liquid::ArgumentError, "cannot select the property '#{property}'"
     end
 
     def apply_operation(input, operand, operation)
@@ -1095,10 +1061,7 @@ module Liquid
       end
 
       def uniq(&block)
-        to_a.uniq do |item|
-          item = Utils.to_liquid_value(item)
-          block ? yield(item) : item
-        end
+        to_a.uniq(&block)
       end
 
       def compact

lib/liquid/strainer_template.rb

@@ -48,17 +48,13 @@ module Liquid
     end
 
     def invoke(method, *args)
-      result = if self.class.invokable?(method)
+      if self.class.invokable?(method)
         send(method, *args)
       elsif @context.strict_filters
         raise Liquid::UndefinedFilter, "undefined filter #{method}"
       else
         args.first
       end
-
-      recorder = @context&.registers&.[](TemplateRecorder::REGISTER_KEY) if defined?(TemplateRecorder)
-      recorder&.emit_filter_call(method, args.first, args.drop(1), result)
-      result
     rescue ::ArgumentError => e
       raise Liquid::ArgumentError, e.message, e.backtrace
     end

lib/liquid/tag.rb

@@ -68,12 +68,8 @@ module Liquid
 
     private
 
-    def safe_parse_expression(parser)
-      parse_context.safe_parse_expression(parser)
-    end
-
-    def parse_expression(markup, safe: false)
-      parse_context.parse_expression(markup, safe: safe)
+    def parse_expression(markup)
+      parse_context.parse_expression(markup)
     end
   end
 end

lib/liquid/tags/assign.rb

@@ -9,17 +9,11 @@ module Liquid
   #   Creates a new variable.
   # @liquid_description
   #   You can create variables of any [basic type](/docs/api/liquid/basics#types), [object](/docs/api/liquid/objects), or object property.
-  #
-  #   > Caution:
-  #   > Predefined Liquid objects can be overridden by variables with the same name.
-  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
   # @liquid_syntax
   #   {% assign variable_name = value %}
   # @liquid_syntax_keyword variable_name The name of the variable being created.
   # @liquid_syntax_keyword value The value you want to assign to the variable.
   class Assign < Tag
-    include ParserSwitching
-
     Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
     # @api private
@@ -31,10 +25,6 @@ module Liquid
 
     def initialize(tag_name, markup, parse_context)
       super
-      parse_with_selected_parser(markup)
-    end
-
-    def lax_parse(markup)
       if markup =~ Syntax
         @to   = Regexp.last_match(1)
         @from = Variable.new(Regexp.last_match(2), parse_context)
@@ -43,25 +33,6 @@ module Liquid
       end
     end
 
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def strict2_parse(markup)
-      unless markup =~ Syntax
-        self.class.raise_syntax_error(parse_context)
-      end
-
-      lhs = Regexp.last_match(1).strip
-      rhs = Regexp.last_match(2)
-
-      p = @parse_context.new_parser(lhs)
-      @to = p.consume(:id)
-      p.consume(:end_of_string)
-
-      @from = Variable.new(rhs, parse_context)
-    end
-
     def render_to_output_buffer(context, output)
       val = @from.render(context)
       context.scopes.last[@to] = val

lib/liquid/tags/capture.rb

@@ -9,10 +9,6 @@ module Liquid
   #   Creates a new variable with a string value.
   # @liquid_description
   #   You can create complex strings with Liquid logic and variables.
-  #
-  #   > Caution:
-  #   > Predefined Liquid objects can be overridden by variables with the same name.
-  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
   # @liquid_syntax
   #   {% capture variable %}
   #     value
@@ -20,18 +16,10 @@ module Liquid
   # @liquid_syntax_keyword variable The name of the variable being created.
   # @liquid_syntax_keyword value The value you want to assign to the variable.
   class Capture < Block
-    include ParserSwitching
-
     Syntax = /(#{VariableSignature}+)/o
 
-    attr_reader :to
-
     def initialize(tag_name, markup, options)
       super
-      parse_with_selected_parser(markup)
-    end
-
-    def lax_parse(markup)
       if markup =~ Syntax
         @to = Regexp.last_match(1)
       else
@@ -39,16 +27,6 @@ module Liquid
       end
     end
 
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def strict2_parse(markup)
-      p = @parse_context.new_parser(markup.strip)
-      @to = p.consume(:id)
-      p.consume(:end_of_string)
-    end
-
     def render_to_output_buffer(context, output)
       context.resource_limits.with_capture do
         capture_output = render(context)

lib/liquid/tags/case.rb

@@ -31,7 +31,12 @@ module Liquid
     def initialize(tag_name, markup, options)
       super
       @blocks = []
-      parse_with_selected_parser(markup)
+
+      if markup =~ Syntax
+        @left = parse_expression(Regexp.last_match(1))
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.case")
+      end
     end
 
     def parse(tokens)
@@ -86,50 +91,9 @@ module Liquid
 
     private
 
-    def strict2_parse(markup)
-      parser = @parse_context.new_parser(markup)
-      @left = safe_parse_expression(parser)
-      parser.consume(:end_of_string)
-    end
-
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      if markup =~ Syntax
-        @left = parse_expression(Regexp.last_match(1))
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.case")
-      end
-    end
-
     def record_when_condition(markup)
       body = new_body
 
-      if strict2_mode?
-        parse_strict2_when(markup, body)
-      else
-        parse_lax_when(markup, body)
-      end
-    end
-
-    def parse_strict2_when(markup, body)
-      parser = @parse_context.new_parser(markup)
-
-      loop do
-        expr = Condition.parse_expression(parse_context, parser.expression, safe: true)
-        block = Condition.new(@left, '==', expr)
-        block.attach(body)
-        @blocks << block
-
-        break unless parser.id?('or') || parser.consume?(:comma)
-      end
-
-      parser.consume(:end_of_string)
-    end
-
-    def parse_lax_when(markup, body)
       while markup
         unless markup =~ WhenSyntax
           raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")

lib/liquid/tags/cycle.rb

@@ -17,13 +17,23 @@ module Liquid
   class Cycle < Tag
     SimpleSyntax = /\A#{QuotedFragment}+/o
     NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
-    UNNAMED_CYCLE_PATTERN = /\w+:0x\h{8}/
 
     attr_reader :variables
 
     def initialize(tag_name, markup, options)
       super
-      parse_with_selected_parser(markup)
+      case markup
+      when NamedSyntax
+        @variables = variables_from_string(Regexp.last_match(2))
+        @name      = parse_expression(Regexp.last_match(1))
+        @is_named = true
+      when SimpleSyntax
+        @variables = variables_from_string(markup)
+        @name      = @variables.to_s
+        @is_named = !@name.match?(/\w+:0x\h{8}/)
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+      end
     end
 
     def named?
@@ -55,82 +65,19 @@ module Liquid
 
     private
 
-    # cycle [name:] expression(, expression)*
-    def strict2_parse(markup)
-      p = @parse_context.new_parser(markup)
-
-      @variables = []
-
-      raise SyntaxError, options[:locale].t("errors.syntax.cycle") if p.look(:end_of_string)
-
-      first_expression = safe_parse_expression(p)
-      if p.look(:colon)
-        # cycle name: expr1, expr2, ...
-        @name = first_expression
-        @is_named = true
-        p.consume(:colon)
-        # After the colon, parse the first variable (required for named cycles)
-        @variables << maybe_dup_lookup(safe_parse_expression(p))
-      else
-        # cycle expr1, expr2, ...
-        @variables << maybe_dup_lookup(first_expression)
-      end
-
-      # Parse remaining comma-separated expressions
-      while p.consume?(:comma)
-        break if p.look(:end_of_string)
-
-        @variables << maybe_dup_lookup(safe_parse_expression(p))
-      end
-
-      p.consume(:end_of_string)
-
-      unless @is_named
-        @name = @variables.to_s
-        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
-      end
-    end
-
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      case markup
-      when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
-        @name      = parse_expression(Regexp.last_match(1))
-        @is_named = true
-      when SimpleSyntax
-        @variables = variables_from_string(markup)
-        @name      = @variables.to_s
-        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
-      end
-    end
-
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
         next unless Regexp.last_match(1)
 
+        # Expression Parser returns cached objects, and we need to dup them to
+        # start the cycle over for each new cycle call.
+        # Liquid-C does not have a cache, so we don't need to dup the object.
         var = parse_expression(Regexp.last_match(1))
-        maybe_dup_lookup(var)
+        var.is_a?(VariableLookup) ? var.dup : var
       end.compact
     end
 
-    # For backwards compatibility, whenever a lookup is used in an unnamed cycle,
-    # we make it so that the @variables.to_s produces different strings for cycles
-    # called with the same arguments (since @variables.to_s is used as the cycle counter key)
-    # This makes it so {% cycle a, b %} and {% cycle a, b %} have independent counters even if a and b share value.
-    # This is not true for literal values, {% cycle "a", "b" %} and {% cycle "a", "b" %} share the same counter.
-    # I was really scratching my head about this one, but migrating away from this would be more headache
-    # than it's worth. So we're keeping this quirk for now.
-    def maybe_dup_lookup(var)
-      var.is_a?(VariableLookup) ? var.dup : var
-    end
-
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         Array(@node.variables)

lib/liquid/tags/decrement.rb

@@ -7,14 +7,10 @@ module Liquid
   # @liquid_name decrement
   # @liquid_summary
   #   Creates a new variable, with a default value of -1, that's decreased by 1 with each subsequent call.
-  #
-  #   > Caution:
-  #   > Predefined Liquid objects can be overridden by variables with the same name.
-  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
   # @liquid_description
   #   Variables that are declared with `decrement` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
   #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
-  #   [snippets](/themes/architecture/snippets) included in the file.
+  #   [snippets](/themes/architecture#snippets) included in the file.
   #
   #   Similarly, variables that are created with `decrement` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
   #   and [`capture`](/docs/api/liquid/tags/capture). However, `decrement` and [`increment`](/docs/api/liquid/tags/increment) share
@@ -23,29 +19,13 @@ module Liquid
   #   {% decrement variable_name %}
   # @liquid_syntax_keyword variable_name The name of the variable being decremented.
   class Decrement < Tag
-    include ParserSwitching
-
     attr_reader :variable_name
 
     def initialize(tag_name, markup, options)
       super
-      parse_with_selected_parser(markup)
-    end
-
-    def lax_parse(markup)
       @variable_name = markup.strip
     end
 
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def strict2_parse(markup)
-      p = @parse_context.new_parser(markup.strip)
-      @variable_name = p.consume(:id)
-      p.consume(:end_of_string)
-    end
-
     def render_to_output_buffer(context, output)
       counter_environment = context.environments.first
       value = counter_environment[@variable_name] || 0

lib/liquid/tags/doc.rb

@@ -13,20 +13,17 @@ module Liquid
   #   Liquid code inside will be parsed but not executed. This facilitates
   #   tooling support for features like code completion, linting, and inline
   #   documentation.
-  #
-  #   For detailed documentation syntax and examples, see the
-  #   [`LiquidDoc` reference](/docs/storefronts/themes/tools/liquid-doc).
-  #
   # @liquid_syntax
   #   {% doc %}
   #     Renders a message.
   #
-  #     @param {string} foo - A string value.
-  #     @param {string} [bar] - An optional string value.
+  #     @param {string} foo - A foo value.
+  #     @param {string} [bar] - An optional bar value.
   #
   #     @example
   #     {% render 'message', foo: 'Hello', bar: 'World' %}
   #   {% enddoc %}
+  #   {{ foo }}, {{ bar }}!
   class Doc < Block
     NO_UNEXPECTED_ARGS = /\A\s*\z/
 
@@ -36,8 +33,6 @@ module Liquid
     end
 
     def parse(tokens)
-      @body = +""
-
       while (token = tokens.shift)
         tag_name = token =~ BlockBody::FullTokenPossiblyInvalid && Regexp.last_match(2)
 
@@ -45,10 +40,8 @@ module Liquid
 
         if tag_name == block_delimiter
           parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
           return
         end
-        @body << token unless token.empty?
       end
 
       raise_tag_never_closed(block_name)
@@ -59,11 +52,11 @@ module Liquid
     end
 
     def blank?
-      @body.empty?
+      true
     end
 
     def nodelist
-      [@body]
+      []
     end
 
     private

lib/liquid/tags/for.rb

@@ -20,8 +20,8 @@ module Liquid
   # @liquid_syntax_keyword variable The current item in the array.
   # @liquid_syntax_keyword array The array to iterate over.
   # @liquid_syntax_keyword expression The expression to render for each iteration.
-  # @liquid_optional_param limit: [number] The number of iterations to perform.
-  # @liquid_optional_param offset: [number] The 1-based index to start iterating at.
+  # @liquid_optional_param limit [number] The number of iterations to perform.
+  # @liquid_optional_param offset [number] The 1-based index to start iterating at.
   # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
   # @liquid_optional_param reversed [untyped] Iterate in reverse order.
   class For < Block
@@ -93,7 +93,7 @@ module Liquid
       raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
 
       collection_name  = p.expression
-      @collection_name = parse_expression(collection_name, safe: true)
+      @collection_name = parse_expression(collection_name)
 
       @name     = "#{@variable_name}-#{collection_name}"
       @reversed = p.id?('reversed')
@@ -104,17 +104,13 @@ module Liquid
           raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
         end
         p.consume(:colon)
-        set_attribute(attribute, p.expression, safe: true)
+        set_attribute(attribute, p.expression)
       end
       p.consume(:end_of_string)
     end
 
     private
 
-    def strict2_parse(markup)
-      strict_parse(markup)
-    end
-
     def collection_segment(context)
       offsets = context.registers[:for] ||= {}
 
@@ -178,16 +174,16 @@ module Liquid
       output
     end
 
-    def set_attribute(key, expr, safe: false)
+    def set_attribute(key, expr)
       case key
       when 'offset'
         @from = if expr == 'continue'
           :continue
         else
-          parse_expression(expr, safe: safe)
+          parse_expression(expr)
         end
       when 'limit'
-        @limit = parse_expression(expr, safe: safe)
+        @limit = parse_expression(expr)
       end
     end
 

lib/liquid/tags/if.rb

@@ -66,10 +66,6 @@ module Liquid
 
     private
 
-    def strict2_parse(markup)
-      strict_parse(markup)
-    end
-
     def push_block(tag, markup)
       block = if tag == 'else'
         ElseCondition.new
@@ -81,8 +77,8 @@ module Liquid
       block.attach(new_body)
     end
 
-    def parse_expression(markup, safe: false)
-      Condition.parse_expression(parse_context, markup, safe: safe)
+    def parse_expression(markup)
+      Condition.parse_expression(parse_context, markup)
     end
 
     def lax_parse(markup)
@@ -124,9 +120,9 @@ module Liquid
     end
 
     def parse_comparison(p)
-      a = parse_expression(p.expression, safe: true)
+      a = parse_expression(p.expression)
       if (op = p.consume?(:comparison))
-        b = parse_expression(p.expression, safe: true)
+        b = parse_expression(p.expression)
         Condition.new(a, op, b)
       else
         Condition.new(a)

lib/liquid/tags/include.rb

@@ -6,7 +6,7 @@ module Liquid
   # @liquid_category theme
   # @liquid_name include
   # @liquid_summary
-  #   Renders a [snippet](/themes/architecture/snippets).
+  #   Renders a [snippet](/themes/architecture#snippets).
   # @liquid_description
   #   Inside the snippet, you can access and alter variables that are [created](/docs/api/liquid/tags/variable-tags) outside of the
   #   snippet.
@@ -20,15 +20,31 @@ module Liquid
   class Include < Tag
     prepend Tag::Disableable
 
-    FOR = 'for'
-    SYNTAX = /(#{QuotedFragment}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
     Syntax = SYNTAX
 
     attr_reader :template_name_expr, :variable_name_expr, :attributes
 
     def initialize(tag_name, markup, options)
       super
-      parse_with_selected_parser(markup)
+
+      if markup =~ SYNTAX
+
+        template_name = Regexp.last_match(1)
+        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)
+        @attributes         = {}
+
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = parse_expression(value)
+        end
+
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.include")
+      end
     end
 
     def parse(_tokens)
@@ -85,57 +101,6 @@ module Liquid
     alias_method :parse_context, :options
     private :parse_context
 
-    def for_loop?
-      @is_for_loop
-    end
-
-    def strict2_parse(markup)
-      p = @parse_context.new_parser(markup)
-
-      @template_name_expr = safe_parse_expression(p)
-      with_or_for         = p.id?("for") || p.id?("with")
-      @variable_name_expr = safe_parse_expression(p) if with_or_for
-      @alias_name         = p.consume(:id) if p.id?("as")
-      @is_for_loop        = (with_or_for == FOR)
-
-      p.consume?(:comma)
-
-      @attributes = {}
-      while p.look(:id)
-        key = p.consume
-        p.consume(:colon)
-        @attributes[key] = safe_parse_expression(p)
-        p.consume?(:comma)
-      end
-
-      p.consume(:end_of_string)
-    end
-
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      if markup =~ SYNTAX
-        template_name = Regexp.last_match(1)
-        with_or_for   = Regexp.last_match(3)
-        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)
-        @is_for_loop        = (with_or_for == FOR)
-        @attributes         = {}
-
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = parse_expression(value)
-        end
-
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.include")
-      end
-    end
-
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [

lib/liquid/tags/increment.rb

@@ -7,14 +7,10 @@ module Liquid
   # @liquid_name increment
   # @liquid_summary
   #   Creates a new variable, with a default value of 0, that's increased by 1 with each subsequent call.
-  #
-  #   > Caution:
-  #   > Predefined Liquid objects can be overridden by variables with the same name.
-  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
   # @liquid_description
   #   Variables that are declared with `increment` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
   #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
-  #   [snippets](/themes/architecture/snippets) included in the file.
+  #   [snippets](/themes/architecture#snippets) included in the file.
   #
   #   Similarly, variables that are created with `increment` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
   #   and [`capture`](/docs/api/liquid/tags/capture). However, `increment` and [`decrement`](/docs/api/liquid/tags/decrement) share
@@ -23,29 +19,13 @@ module Liquid
   #   {% increment variable_name %}
   # @liquid_syntax_keyword variable_name The name of the variable being incremented.
   class Increment < Tag
-    include ParserSwitching
-
     attr_reader :variable_name
 
     def initialize(tag_name, markup, options)
       super
-      parse_with_selected_parser(markup)
-    end
-
-    def lax_parse(markup)
       @variable_name = markup.strip
     end
 
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def strict2_parse(markup)
-      p = @parse_context.new_parser(markup.strip)
-      @variable_name = p.consume(:id)
-      p.consume(:end_of_string)
-    end
-
     def render_to_output_buffer(context, output)
       counter_environment = context.environments.first
       value = counter_environment[@variable_name] || 0

lib/liquid/tags/render.rb

@@ -6,7 +6,7 @@ module Liquid
   # @liquid_category theme
   # @liquid_name render
   # @liquid_summary
-  #   Renders a [snippet](/themes/architecture/snippets) or [app block](/themes/architecture/sections/section-schema#render-app-blocks).
+  #   Renders a [snippet](/themes/architecture#snippets) or [app block](/themes/architecture/sections/section-schema#render-app-blocks).
   # @liquid_description
   #   Inside snippets and app blocks, you can't directly access variables that are [created](/docs/api/liquid/tags/variable-tags) outside
   #   of the snippet or app block. However, you can [specify variables as parameters](/docs/api/liquid/tags/render#render-passing-variables-to-a-snippet)
@@ -35,7 +35,22 @@ module Liquid
 
     def initialize(tag_name, markup, options)
       super
-      parse_with_selected_parser(markup)
+
+      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
+
+      template_name = Regexp.last_match(1)
+      with_or_for = Regexp.last_match(3)
+      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)
+      @is_for_loop = (with_or_for == FOR)
+
+      @attributes = {}
+      markup.scan(TagAttributes) do |key, value|
+        @attributes[key] = parse_expression(value)
+      end
     end
 
     def for_loop?
@@ -84,55 +99,6 @@ module Liquid
       output
     end
 
-    # render (string) (with|for expression)? (as id)? (key: value)*
-    def strict2_parse(markup)
-      p = @parse_context.new_parser(markup)
-
-      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
-      with_or_for         = p.id?("for") || p.id?("with")
-      @variable_name_expr = safe_parse_expression(p) if with_or_for
-      @alias_name         = p.consume(:id) if p.id?("as")
-      @is_for_loop        = (with_or_for == FOR)
-
-      p.consume?(:comma)
-
-      @attributes = {}
-      while p.look(:id)
-        key = p.consume
-        p.consume(:colon)
-        @attributes[key] = safe_parse_expression(p)
-        p.consume?(:comma)
-      end
-
-      p.consume(:end_of_string)
-    end
-
-    def strict2_template_name(p)
-      p.consume(:string)
-    end
-
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
-
-      template_name = Regexp.last_match(1)
-      with_or_for = Regexp.last_match(3)
-      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)
-      @is_for_loop = (with_or_for == FOR)
-
-      @attributes = {}
-      markup.scan(TagAttributes) do |key, value|
-        @attributes[key] = parse_expression(value)
-      end
-    end
-
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [

lib/liquid/tags/table_row.rb

@@ -19,54 +19,17 @@ module Liquid
   # @liquid_syntax_keyword variable The current item in the array.
   # @liquid_syntax_keyword array The array to iterate over.
   # @liquid_syntax_keyword expression The expression to render.
-  # @liquid_optional_param cols: [number] The number of columns that the table should have.
-  # @liquid_optional_param limit: [number] The number of iterations to perform.
-  # @liquid_optional_param offset: [number] The 1-based index to start iterating at.
+  # @liquid_optional_param cols [number] The number of columns that the table should have.
+  # @liquid_optional_param limit [number] The number of iterations to perform.
+  # @liquid_optional_param offset [number] The 1-based index to start iterating at.
   # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
   class TableRow < Block
     Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
-    ALLOWED_ATTRIBUTES = ['cols', 'limit', 'offset', 'range'].freeze
 
     attr_reader :variable_name, :collection_name, :attributes
 
     def initialize(tag_name, markup, options)
       super
-      parse_with_selected_parser(markup)
-    end
-
-    def strict2_parse(markup)
-      p = @parse_context.new_parser(markup)
-
-      @variable_name = p.consume(:id)
-
-      unless p.id?("in")
-        raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in")
-      end
-
-      @collection_name = safe_parse_expression(p)
-
-      p.consume?(:comma)
-
-      @attributes = {}
-      while p.look(:id)
-        key = p.consume
-        unless ALLOWED_ATTRIBUTES.include?(key)
-          raise SyntaxError, options[:locale].t("errors.syntax.table_row_invalid_attribute", attribute: key)
-        end
-
-        p.consume(:colon)
-        @attributes[key] = safe_parse_expression(p)
-        p.consume?(:comma)
-      end
-
-      p.consume(:end_of_string)
-    end
-
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
       if markup =~ Syntax
         @variable_name   = Regexp.last_match(1)
         @collection_name = parse_expression(Regexp.last_match(2))

lib/liquid/template.rb

@@ -2,7 +2,7 @@
 
 module Liquid
   # Templates are central to liquid.
-  # Interpreting templates is a two step process. First you compile the
+  # Interpretating templates is a two step process. First you compile the
   # source code you got. During compile time some extensive error checking is performed.
   # your code should expect to get some SyntaxErrors.
   #
@@ -24,8 +24,7 @@ module Liquid
       # Sets how strict the parser should be.
       # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
       # :warn is the default and will give deprecation warnings when invalid syntax is used.
-      # :strict enforces correct syntax for most tags
-      # :strict2 enforces correct syntax for all tags
+      # :strict will enforce correct syntax.
       def error_mode=(mode)
         Deprecations.warn("Template.error_mode=", "Environment#error_mode=")
         Environment.default.error_mode = mode
@@ -105,7 +104,6 @@ module Liquid
 
       tokenizer     = parse_context.new_tokenizer(source, start_line_number: @line_numbers && 1)
       @root         = Document.parse(tokenizer, parse_context)
-      @template_recorder_source = source.dup.freeze if defined?(TemplateRecorder) && TemplateRecorder.current
       self
     end
 
@@ -142,8 +140,6 @@ module Liquid
     def render(*args)
       return '' if @root.nil?
 
-      recording_session = TemplateRecorder.current if defined?(TemplateRecorder)
-      recording_assigns = args.first
       context = case args.first
       when Liquid::Context
         c = args.shift
@@ -154,10 +150,8 @@ module Liquid
 
         c
       when Liquid::Drop
-        drop = args.shift
-        c    = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
-        drop.context = c if drop.respond_to?(:context=)
-        c
+        drop         = args.shift
+        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
       when Hash
         Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
       when nil
@@ -183,13 +177,6 @@ module Liquid
         context.add_filters(args.pop)
       end
 
-      recording = recording_session&.begin_render(self, recording_assigns, context)
-      if recording
-        recorder_registers = context.registers.static
-        previous_recorder = recorder_registers[TemplateRecorder::REGISTER_KEY]
-        recorder_registers[TemplateRecorder::REGISTER_KEY] = recording
-      end
-
       # Retrying a render resets resource usage
       context.resource_limits.reset
 
@@ -199,34 +186,12 @@ module Liquid
 
       context.template_name ||= name
 
-      previous_error_mode = context.registers.static[:template_error_mode]
-      context.registers.static[:template_error_mode] = @error_mode
-
-      rendered_output = nil
-      render_succeeded = false
       begin
         # render the nodelist.
-        rendered_output = @root.render_to_output_buffer(context, output || +'')
-        render_succeeded = true
-        rendered_output
+        @root.render_to_output_buffer(context, output || +'')
       rescue Liquid::MemoryError => e
-        rendered_output = context.handle_error(e)
-        render_succeeded = true
-        rendered_output
+        context.handle_error(e)
       ensure
-        if previous_error_mode
-          context.registers.static[:template_error_mode] = previous_error_mode
-        else
-          context.registers.static.delete(:template_error_mode)
-        end
-        if recording
-          if previous_recorder
-            recorder_registers[TemplateRecorder::REGISTER_KEY] = previous_recorder
-          else
-            recorder_registers.delete(TemplateRecorder::REGISTER_KEY)
-          end
-          recording_session.finish_render(recording, rendered_output, context, success: render_succeeded)
-        end
         @errors = context.errors
       end
     end
@@ -258,7 +223,6 @@ module Liquid
       end
 
       @warnings = parse_context.warnings
-      @error_mode = parse_context.error_mode
       parse_context
     end
 

lib/liquid/template_recorder.rb

@@ -1,550 +0,0 @@
-# frozen_string_literal: true
-
-require 'English'
-require "digest/sha2"
-require "json"
-require "securerandom"
-require "tempfile"
-require "time"
-
-module Liquid
-  # Records complete Liquid renders without changing the objects being rendered.
-  # A .json file contains one session; a .jsonl file is an append-only sequence
-  # of independently replayable renders.
-  class TemplateRecorder
-    FORMAT = "liquid-render"
-    SCHEMA_VERSION = 1
-    REGISTER_KEY = :__liquid_template_recorder
-    REPLAYER_REGISTER_KEY = :__liquid_template_recorder_replayer
-
-    class Error < StandardError; end
-    class ReplayError < Error; end
-    class SerializationError < Error; end
-
-    class << self
-      def record(destination, on_error: nil)
-        raise ArgumentError, "a block is required" unless block_given?
-
-        previous_session = current
-        raise Error, "nested recording sessions are not supported" if previous_session
-
-        session = Session.new(destination, on_error: on_error)
-        Thread.current[thread_key] = session
-        yield
-      ensure
-        if session
-          Thread.current[thread_key] = previous_session
-          session.close if $ERROR_INFO.nil?
-        end
-      end
-
-      def current
-        Thread.current[thread_key]
-      end
-
-      def replay_from(path, mode: :compute, index: -1)
-        records = Store.read(path)
-        raise ReplayError, "recording contains no renders" if records.empty?
-
-        record = records.fetch(index)
-        Replayer.new(record, mode: mode)
-      rescue IndexError
-        raise ReplayError, "render index #{index} does not exist"
-      end
-
-      def records(path)
-        Store.read(path)
-      end
-
-      private
-
-      def thread_key
-        :__liquid_template_recorder_session
-      end
-    end
-
-    class Session
-      def initialize(destination, on_error:)
-        @path = destination.to_s if destination.is_a?(String) || destination.respond_to?(:to_path)
-        @writer = destination unless @path
-        @on_error = on_error
-        @records = []
-        @active = nil
-        @pending_files = {}
-      end
-
-      def begin_render(template, _assigns, context)
-        if @active
-          @active.add_template(template)
-          @active.nesting += 1
-          return @active
-        end
-
-        @active = Render.new(template, context)
-        @pending_files.each { |path, source| @active.emit_file_read(path, source) }
-        @pending_files.clear
-        @active
-      end
-
-      def emit_file_read(path, source)
-        if @active
-          @active.emit_file_read(path, source)
-        else
-          @pending_files[path.to_s] = source
-        end
-      end
-
-      def emit_variable_output(output)
-        @active&.emit_variable_output(output)
-      end
-
-      def begin_tag_render(node, context)
-        @active&.begin_tag_render(node, context)
-      end
-
-      def finish_tag_render(call, output)
-        @active&.finish_tag_render(call, output)
-      end
-
-      def finish_render(render, output, context, success:)
-        return unless render.equal?(@active)
-
-        if render.nesting.positive?
-          render.nesting -= 1
-          return
-        end
-
-        if success
-          begin
-            record = render.finish(output, context)
-            if @writer
-              @writer.write(record)
-            elsif Store.jsonl?(@path)
-              Store.append(@path, record)
-            else
-              @records << record
-            end
-          rescue => error
-            handle_error(error)
-          end
-        end
-        @active = nil
-      end
-
-      def close
-        return if @writer || Store.jsonl?(@path)
-
-        Store.write_session(@path, @records)
-      rescue => error
-        handle_error(error)
-      end
-
-      private
-
-      def handle_error(error)
-        raise error unless @on_error
-
-        @on_error.call(error)
-      end
-    end
-
-    class Render
-      attr_accessor :nesting
-
-      def initialize(template, _context)
-        @nesting = 0
-        @templates = []
-        @files = {}
-        @filter_calls = []
-        @tag_calls = []
-        @tag_render_depth = 0
-        @variables = {}
-        @variable_outputs = []
-        @drop_values = {}
-        @bindings = {}.compare_by_identity
-        @root_template = template
-        add_template(template)
-      end
-
-      def add_template(template)
-        source = template.instance_variable_get(:@template_recorder_source)
-        return unless source
-
-        entrypoint = template.name
-        digest = Digest::SHA256.hexdigest(source)
-        return if @templates.any? { |item| item["sha256"] == digest && item["entrypoint"] == entrypoint }
-
-        @templates << { "source" => source, "entrypoint" => entrypoint, "sha256" => digest }
-      end
-
-      def emit_variable_output(output)
-        return if @tag_render_depth.positive?
-
-        @variable_outputs << output
-      end
-
-      def begin_tag_render(node, context)
-        name = context.environment.tags.key(node.class)
-        return unless name
-
-        @tag_render_depth += 1
-        return :nested if @tag_render_depth > 1
-
-        call = { "name" => name.to_s, "output" => nil }
-        @tag_calls << call
-        call
-      end
-
-      def finish_tag_render(call, output)
-        return unless call
-
-        @tag_render_depth -= 1
-        call["output"] = output unless call == :nested
-      end
-
-      def emit_variable_read(name, value)
-        path = [name.to_s]
-        @variables[name.to_s] = serialize(value, path, bind: true)
-      rescue SerializationError
-        # Unsupported values must not affect the render being observed.
-      end
-
-      def emit_drop_read(drop, key, value)
-        base = @bindings[drop]
-        return unless base
-
-        path = base + [key.to_s]
-        set_path(@drop_values, path, serialize(value, path, bind: true))
-      rescue SerializationError
-        # Unsupported values must not affect the render being observed.
-      end
-
-      def emit_file_read(path, source)
-        @files[path.to_s] = source.to_s
-      end
-
-      def emit_filter_call(name, input, arguments, output)
-        return if @tag_render_depth.positive?
-
-        @filter_calls << {
-          "name" => name.to_s,
-          "input" => serialize(input, ["filters", @filter_calls.length, "input"]),
-          "arguments" => serialize(arguments, ["filters", @filter_calls.length, "arguments"]),
-          "output" => serialize(output, ["filters", @filter_calls.length, "output"]),
-        }
-      rescue SerializationError
-        # Filter diagnostics must never make an otherwise replayable render fail.
-      end
-
-      def finish(output, context)
-        variables = deep_merge(@variables, @drop_values)
-        source = @root_template.instance_variable_get(:@template_recorder_source)
-        raise Error, "the rendered template was parsed outside the recording block" unless source
-
-        {
-          "format" => FORMAT,
-          "schema_version" => SCHEMA_VERSION,
-          "id" => SecureRandom.uuid,
-          "recorded_at" => Time.now.utc.iso8601,
-          "engine" => {
-            "liquid_version" => Liquid::VERSION,
-            "ruby_version" => RUBY_VERSION,
-            "strict_variables" => !!context.strict_variables,
-            "strict_filters" => !!context.strict_filters,
-          },
-          "template" => @templates.first,
-          "templates" => @templates,
-          "assigns" => variables,
-          "variable_outputs" => @variable_outputs,
-          "file_system" => @files,
-          "filter_calls" => @filter_calls,
-          "tag_calls" => @tag_calls,
-          "output" => output.to_s,
-        }
-      end
-
-      private
-
-      def serialize(value, path, seen = {}.compare_by_identity, bind: false)
-        case value
-        when nil, true, false, String, Integer, Float
-          value
-        when Symbol
-          value.to_s
-        when Liquid::Drop
-          @bindings[value] ||= path if bind
-          existing = value_at(@drop_values, @bindings[value])
-          existing || {}
-        when Hash
-          raise SerializationError, "circular value at #{format_path(path)}" if seen.key?(value)
-
-          seen[value] = true
-          result = value.each_with_object({}) do |(key, child), hash|
-            string_key = key.to_s
-            hash[string_key] = serialize(child, path + [string_key], seen, bind: bind)
-          end
-          seen.delete(value)
-          result
-        when Array
-          raise SerializationError, "circular value at #{format_path(path)}" if seen.key?(value)
-
-          seen[value] = true
-          result = value.each_with_index.map { |child, index| serialize(child, path + [index], seen, bind: bind) }
-          seen.delete(value)
-          result
-        else
-          raise SerializationError, "cannot record #{value.class} at #{format_path(path)}"
-        end
-      end
-
-      def set_path(root, path, value)
-        return root.replace(value) if path.empty? && value.is_a?(Hash)
-
-        cursor = root
-        path.each_with_index do |segment, index|
-          last = index == path.length - 1
-          if segment.is_a?(Integer)
-            break unless cursor.is_a?(Array)
-
-          end
-          cursor[segment] = last ? value : (cursor[segment] ||= container_for(path[index + 1]))
-          cursor = cursor[segment] unless last
-        end
-      end
-
-      def value_at(root, path)
-        return unless path
-
-        path.reduce(root) { |value, segment| value.respond_to?(:[]) ? value[segment] : nil }
-      end
-
-      def container_for(segment)
-        segment.is_a?(Integer) ? [] : {}
-      end
-
-      def deep_merge(left, right)
-        return right unless left.is_a?(Hash) && right.is_a?(Hash)
-
-        left.merge(right) { |_key, a, b| deep_merge(a, b) }
-      end
-
-      def format_path(path)
-        path.empty? ? "<root>" : path.join(".")
-      end
-    end
-
-    class Store
-      class << self
-        def jsonl?(path)
-          path.end_with?(".jsonl")
-        end
-
-        def append(path, record)
-          line = JSON.generate(record) << "\n"
-          File.open(path, File::WRONLY | File::CREAT | File::APPEND, 0o600) do |file|
-            file.flock(File::LOCK_EX)
-            file.write(line)
-            file.flush
-          end
-        end
-
-        def write_session(path, records)
-          payload = JSON.pretty_generate(
-            "format" => "liquid-recording-session",
-            "schema_version" => SCHEMA_VERSION,
-            "renders" => records,
-          ) << "\n"
-          directory = File.dirname(File.expand_path(path))
-          Tempfile.create([".liquid-recording", ".tmp"], directory, mode: File::RDWR, perm: 0o600) do |file|
-            file.write(payload)
-            file.flush
-            file.fsync
-            File.rename(file.path, path)
-          end
-        end
-
-        def read(path)
-          content = File.binread(path)
-          records = if jsonl?(path)
-            read_jsonl(content)
-          else
-            parsed = JSON.parse(content)
-            parsed["renders"] || [parsed]
-          end
-          records.each { |record| validate!(record) }
-          records
-        rescue Errno::ENOENT
-          raise ReplayError, "recording file not found: #{path}"
-        rescue JSON::ParserError => error
-          raise ReplayError, "invalid recording JSON: #{error.message}"
-        end
-
-        def read_jsonl(content)
-          lines = content.lines
-          lines.filter_map.with_index do |line, index|
-            next if line.strip.empty?
-
-            JSON.parse(line)
-          rescue JSON::ParserError
-            last_truncated_line = index == lines.length - 1 && !content.end_with?("\n")
-            raise unless last_truncated_line
-          end
-        end
-
-        def validate!(record)
-          raise ReplayError, "unsupported recording format" unless record["format"] == FORMAT
-          raise ReplayError, "unsupported schema version #{record["schema_version"].inspect}" unless record["schema_version"] == SCHEMA_VERSION
-
-          ['template', 'assigns', 'file_system', 'output'].each do |key|
-            raise ReplayError, "recording is missing #{key}" unless record.key?(key)
-          end
-          template = record["template"]
-          expected = Digest::SHA256.hexdigest(template.fetch("source"))
-          raise ReplayError, "template checksum does not match" unless template["sha256"] == expected
-        rescue KeyError, TypeError => error
-          raise ReplayError, "invalid recording schema: #{error.message}"
-        end
-      end
-    end
-
-    class MemoryFileSystem
-      def initialize(files)
-        @files = files
-      end
-
-      def read_template_file(path)
-        @files.fetch(path.to_s) { raise FileSystemError, "No such template '#{path}'" }
-      end
-    end
-
-    class Replayer
-      def initialize(record, mode: :compute, environment: nil)
-        @record = record
-        @mode = mode.to_sym
-        @environment = environment
-        unless [:compute, :strict, :verify].include?(@mode)
-          raise ReplayError, "mode must be :compute, :strict, or :verify"
-        end
-      end
-
-      def render(to: nil, filters: nil)
-        @filter_index = 0
-        @tag_index = 0
-        @variable_index = 0
-        parse_options = {}
-        parse_options[:environment] = strict_environment if @mode == :strict
-        template = Liquid::Template.parse(@record.dig("template", "source"), parse_options)
-        registers = { file_system: MemoryFileSystem.new(@record["file_system"]) }
-        registers[REPLAYER_REGISTER_KEY] = self if @mode == :strict && @record.key?("variable_outputs")
-        options = {
-          registers: registers,
-          strict_variables: @record.dig("engine", "strict_variables"),
-          strict_filters: @record.dig("engine", "strict_filters"),
-        }
-        options[:filters] = filters if filters
-        output = template.render!(@record["assigns"], options)
-        if @mode == :strict
-          verify_filter_count! unless @record.key?("variable_outputs")
-          verify_tag_count!
-          verify_variable_count!
-        end
-        if [:strict, :verify].include?(@mode) && output != @record["output"]
-          raise ReplayError, "replayed output does not match the recording"
-        end
-
-        File.binwrite(to, output) if to
-        output
-      end
-
-      def replay_filter(name)
-        call = @record["filter_calls"].fetch(@filter_index) do
-          raise ReplayError, "unexpected filter call #{name}"
-        end
-        if call["name"] != name.to_s
-          raise ReplayError, "expected filter #{call["name"]}, got #{name}"
-        end
-
-        @filter_index += 1
-        JSON.parse(JSON.generate(call["output"]))
-      end
-
-      def replay_variable
-        value = @record.fetch("variable_outputs").fetch(@variable_index) do
-          raise ReplayError, "unexpected variable render"
-        end
-        @variable_index += 1
-        value
-      end
-
-      def replay_tag(name)
-        call = @record.fetch("tag_calls", []).fetch(@tag_index) do
-          raise ReplayError, "unexpected tag call #{name}"
-        end
-        if call["name"] != name.to_s
-          raise ReplayError, "expected tag #{call["name"]}, got #{name}"
-        end
-
-        @tag_index += 1
-        call["output"]
-      end
-
-      def recorded_output
-        @record["output"]
-      end
-
-      def templates
-        @record["templates"]
-      end
-
-      private
-
-      def strict_environment
-        replayer = self
-        strainer = Class.new(Liquid::StrainerTemplate) do
-          define_method(:invoke) do |name, *_args|
-            replayer.replay_filter(name)
-          end
-        end
-        tags = (@environment || Liquid::Environment.default).tags.dup
-        tags&.each do |name, tag_class|
-          tags[name] = replay_tag_class(tag_class, name)
-        end
-        Liquid::Environment.build(tags: tags) do |environment|
-          environment.strainer_template = strainer
-        end
-      end
-
-      def replay_tag_class(tag_class, name)
-        replayer = self
-        Class.new(tag_class) do
-          define_method(:render_to_output_buffer) do |_context, output|
-            output << replayer.replay_tag(name)
-          end
-        end
-      end
-
-      def verify_variable_count!
-        return unless @record.key?("variable_outputs")
-
-        expected = @record["variable_outputs"].length
-        return if @variable_index == expected
-
-        raise ReplayError, "expected #{expected} variable renders, got #{@variable_index}"
-      end
-
-      def verify_tag_count!
-        expected = @record.fetch("tag_calls", []).length
-        return if @tag_index == expected
-
-        raise ReplayError, "expected #{expected} tag calls, got #{@tag_index}"
-      end
-
-      def verify_filter_count!
-        expected = @record["filter_calls"].length
-        return if @filter_index == expected
-
-        raise ReplayError, "expected #{expected} filter calls, got #{@filter_index}"
-      end
-    end
-  end
-end

lib/liquid/tokenizer.rb

@@ -117,7 +117,7 @@ module Liquid
       byte_a = byte_b = @ss.scan_byte
 
       while byte_b
-        byte_a = @ss.scan_byte while byte_a && byte_a != CLOSE_CURLEY && byte_a != OPEN_CURLEY
+        byte_a = @ss.scan_byte while byte_a && (byte_a != CLOSE_CURLEY && byte_a != OPEN_CURLEY)
 
         break unless byte_a
 

lib/liquid/utils.rb

@@ -2,9 +2,6 @@
 
 module Liquid
   module Utils
-    DECIMAL_REGEX = /\A-?\d+\.\d+\z/
-    UNIX_TIMESTAMP_REGEX = /\A\d+\z/
-
     def self.slice_collection(collection, from, to)
       if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
         collection.load_slice(from, to)
@@ -55,7 +52,7 @@ module Liquid
       when Numeric
         obj
       when String
-        DECIMAL_REGEX.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
       else
         if obj.respond_to?(:to_number)
           obj.to_number
@@ -69,14 +66,14 @@ module Liquid
       return obj if obj.respond_to?(:strftime)
 
       if obj.is_a?(String)
-        return if obj.empty?
+        return nil if obj.empty?
         obj = obj.downcase
       end
 
       case obj
       when 'now', 'today'
         Time.now
-      when UNIX_TIMESTAMP_REGEX, Integer
+      when /\A\d+\z/, Integer
         Time.at(obj.to_i)
       when String
         Time.parse(obj)
@@ -95,8 +92,6 @@ module Liquid
 
     def self.to_s(obj, seen = {})
       case obj
-      when BigDecimal
-        obj.to_s("F")
       when Hash
         # If the custom hash implementation overrides `#to_s`, use their
         # custom implementation. Otherwise we use Liquid's default

lib/liquid/variable.rb

@@ -37,10 +37,6 @@ module Liquid
       @markup
     end
 
-    def ==(other)
-      self.class == other.class && name == other.name && filters == other.filters
-    end
-
     def markup_context(markup)
       "in \"{{#{markup}}}\""
     end
@@ -58,7 +54,7 @@ module Liquid
           next unless f =~ /\w+/
           filtername = Regexp.last_match(0)
           filterargs = f.scan(FilterArgsRegex).flatten
-          @filters << lax_parse_filter_expressions(filtername, filterargs)
+          @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
     end
@@ -69,26 +65,15 @@ module Liquid
 
       return if p.look(:end_of_string)
 
-      @name = parse_context.safe_parse_expression(p)
+      @name = parse_context.parse_expression(p.expression)
       while p.consume?(:pipe)
         filtername = p.consume(:id)
         filterargs = p.consume?(:colon) ? parse_filterargs(p) : Const::EMPTY_ARRAY
-        @filters << lax_parse_filter_expressions(filtername, filterargs)
+        @filters << parse_filter_expressions(filtername, filterargs)
       end
       p.consume(:end_of_string)
     end
 
-    def strict2_parse(markup)
-      @filters = []
-      p = @parse_context.new_parser(markup)
-
-      return if p.look(:end_of_string)
-
-      @name = parse_context.safe_parse_expression(p)
-      @filters << strict2_parse_filter_expressions(p) while p.consume?(:pipe)
-      p.consume(:end_of_string)
-    end
-
     def parse_filterargs(p)
       # first argument
       filterargs = [p.argument]
@@ -109,14 +94,8 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      if (replayer = context.registers[TemplateRecorder::REPLAYER_REGISTER_KEY])
-        return output << replayer.replay_variable
-      end
-
-      output_start = output.length
       obj = render(context)
       render_obj_to_output(obj, output)
-      TemplateRecorder.current&.emit_variable_output(output[output_start..])
       output
     end
 
@@ -143,7 +122,7 @@ module Liquid
 
     private
 
-    def lax_parse_filter_expressions(filter_name, unparsed_args)
+    def parse_filter_expressions(filter_name, unparsed_args)
       filter_args  = []
       keyword_args = nil
       unparsed_args.each do |a|
@@ -159,46 +138,6 @@ module Liquid
       result
     end
 
-    # Surprisingly, positional and keyword arguments can be mixed.
-    #
-    # filter = filtername [":" filterargs?]
-    # filterargs = argument ("," argument)*
-    # argument = (positional_argument | keyword_argument)
-    # positional_argument = expression
-    # keyword_argument = id ":" expression
-    def strict2_parse_filter_expressions(p)
-      filtername = p.consume(:id)
-      filter_args = []
-      keyword_args = {}
-
-      if p.consume?(:colon)
-        # Parse first argument (no leading comma)
-        argument(p, filter_args, keyword_args) unless end_of_arguments?(p)
-
-        # Parse remaining arguments (with leading commas) and optional trailing comma
-        argument(p, filter_args, keyword_args) while p.consume?(:comma) && !end_of_arguments?(p)
-      end
-
-      result = [filtername, filter_args]
-      result << keyword_args unless keyword_args.empty?
-      result
-    end
-
-    def argument(p, positional_arguments, keyword_arguments)
-      if p.look(:id) && p.look(:colon, 1)
-        key = p.consume(:id)
-        p.consume(:colon)
-        value = parse_context.safe_parse_expression(p)
-        keyword_arguments[key] = value
-      else
-        positional_arguments << parse_context.safe_parse_expression(p)
-      end
-    end
-
-    def end_of_arguments?(p)
-      p.look(:pipe) || p.look(:end_of_string)
-    end
-
     def evaluate_filter_expressions(context, filter_args, filter_kwargs)
       parsed_args = filter_args.map { |expr| context.evaluate(expr) }
       if filter_kwargs

lib/liquid/variable_lookup.rb

@@ -70,11 +70,6 @@ module Liquid
         elsif lookup_command?(i) && object.respond_to?(key)
           object = object.send(key).to_liquid
 
-        # Handle string first/last like ActiveSupport does (returns first/last character)
-        # ActiveSupport returns "" for empty strings, not nil
-        elsif lookup_command?(i) && object.is_a?(String) && (key == "first" || key == "last")
-          object = key == "first" ? (object[0] || "") : (object[-1] || "")
-
           # No key was present with the desired value and it wasn't one of the directly supported
           # keywords either. The only thing we got left is to return nil or
           # raise an exception if `strict_variables` option is set to true

lib/liquid/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Liquid
-  VERSION = "5.13.0"
+  VERSION = "5.8.1"
 end

spec/ruby_liquid.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-# Liquid Spec Adapter for Shopify/liquid (Ruby reference implementation)
-#
-# Run with: bundle exec liquid-spec run spec/ruby_liquid.rb
-
-$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
-require 'liquid'
-require_relative 'support/liquid_spec_adapter_helper'
-
-LiquidSpec.configure do |config|
-  config.missing_features = [
-    :activesupport,
-    :lax_parsing,
-    :shopify_filters,
-    :shopify_includes,
-    :shopify_blank,
-    :shopify_error_handling,
-    :shopify_error_format,
-    :shopify_string_access,
-  ]
-end
-
-# Compile a template string into a Liquid::Template
-LiquidSpec.compile do |ctx, source, options|
-  options[:error_mode] ||= :strict
-  ctx[:template] = Liquid::Template.parse(source, **options)
-end
-
-# Render a compiled template with the given context
-# @param ctx [Hash] adapter context containing :template
-# @param assigns [Hash] environment variables
-# @param options [Hash] :registers, :strict_errors, :exception_renderer
-LiquidSpec.render do |ctx, assigns, options|
-  registers = Liquid::Registers.new(options[:registers] || {})
-
-  context = Liquid::Context.build(
-    static_environments: assigns,
-    registers: registers,
-    rethrow_errors: options[:strict_errors],
-    resource_limits: LiquidSpecAdapterHelper.resource_limits(options),
-  )
-
-  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-
-  LiquidSpecAdapterHelper.with_frozen_time do
-    ctx[:template].render(context)
-  end
-end

spec/ruby_liquid_lax.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-# Liquid Spec Adapter for Shopify/liquid with lax parsing mode
-#
-# Run with: bundle exec liquid-spec run spec/ruby_liquid_lax.rb
-
-$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
-require 'liquid'
-require_relative 'support/liquid_spec_adapter_helper'
-
-LiquidSpec.configure do |config|
-  config.missing_features = [
-    :activesupport,
-    :shopify_filters,
-    :shopify_includes,
-    :shopify_blank,
-    :shopify_error_handling,
-    :shopify_error_format,
-    :shopify_string_access,
-  ]
-end
-
-# Compile a template string into a Liquid::Template
-LiquidSpec.compile do |ctx, source, options|
-  # Default to lax mode while still honoring specs that explicitly set error_mode.
-  options = { error_mode: :lax }.merge(options)
-  ctx[:template] = Liquid::Template.parse(source, **options)
-end
-
-# Render a compiled template with the given context
-LiquidSpec.render do |ctx, assigns, options|
-  registers = Liquid::Registers.new(options[:registers] || {})
-
-  context = Liquid::Context.build(
-    static_environments: assigns,
-    registers: registers,
-    rethrow_errors: options[:strict_errors],
-    resource_limits: LiquidSpecAdapterHelper.resource_limits(options),
-  )
-
-  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-
-  LiquidSpecAdapterHelper.with_frozen_time do
-    ctx[:template].render(context)
-  end
-end

spec/ruby_liquid_with_active_support.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-# Liquid Spec Adapter for Shopify/liquid with ActiveSupport loaded
-#
-# Run with: bundle exec liquid-spec run spec/ruby_liquid_with_active_support.rb
-
-$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
-require 'active_support/all'
-require 'liquid'
-require_relative 'support/liquid_spec_adapter_helper'
-
-LiquidSpec.configure do |config|
-  config.missing_features = [
-    :lax_parsing,
-    :shopify_filters,
-    :shopify_includes,
-    :shopify_blank,
-    :shopify_error_handling,
-    :shopify_error_format,
-    :shopify_string_access,
-  ]
-end
-
-# Compile a template string into a Liquid::Template
-LiquidSpec.compile do |ctx, source, options|
-  options[:error_mode] ||= :strict
-  ctx[:template] = Liquid::Template.parse(source, **options)
-end
-
-# Render a compiled template with the given context
-# @param ctx [Hash] adapter context containing :template
-# @param assigns [Hash] environment variables
-# @param options [Hash] :registers, :strict_errors, :exception_renderer
-LiquidSpec.render do |ctx, assigns, options|
-  registers = Liquid::Registers.new(options[:registers] || {})
-
-  context = Liquid::Context.build(
-    static_environments: assigns,
-    registers: registers,
-    rethrow_errors: options[:strict_errors],
-    resource_limits: LiquidSpecAdapterHelper.resource_limits(options),
-  )
-
-  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-
-  LiquidSpecAdapterHelper.with_frozen_time do
-    ctx[:template].render(context)
-  end
-end

spec/ruby_liquid_yjit.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-# Liquid Spec Adapter for Shopify/liquid with YJIT + strict mode + ActiveSupport
-#
-# Run with: bundle exec liquid-spec run spec/ruby_liquid_yjit.rb
-
-$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
-
-# Enable YJIT if available
-if defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enable)
-  RubyVM::YJIT.enable
-end
-
-require 'active_support/all'
-require 'liquid'
-require_relative 'support/liquid_spec_adapter_helper'
-
-LiquidSpec.configure do |config|
-  config.missing_features = [
-    :lax_parsing,
-    :shopify_filters,
-    :shopify_includes,
-    :shopify_blank,
-    :shopify_error_handling,
-    :shopify_error_format,
-    :shopify_string_access,
-  ]
-end
-
-# Compile a template string into a Liquid::Template
-LiquidSpec.compile do |ctx, source, options|
-  # Force strict mode
-  options = { error_mode: :strict }.merge(options)
-  ctx[:template] = Liquid::Template.parse(source, **options)
-end
-
-# Render a compiled template with the given context
-LiquidSpec.render do |ctx, assigns, options|
-  registers = Liquid::Registers.new(options[:registers] || {})
-
-  context = Liquid::Context.build(
-    static_environments: assigns,
-    registers: registers,
-    rethrow_errors: options[:strict_errors],
-    resource_limits: LiquidSpecAdapterHelper.resource_limits(options),
-  )
-
-  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-
-  LiquidSpecAdapterHelper.with_frozen_time do
-    ctx[:template].render(context)
-  end
-end

spec/support/liquid_spec_adapter_helper.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module LiquidSpecAdapterHelper
-  extend self
-
-  def resource_limits(render_options)
-    return unless render_options[:resource_limits]
-
-    Liquid::ResourceLimits.new({}).tap do |limits|
-      render_options[:resource_limits].each do |key, value|
-        limits.public_send(:"#{key}=", value)
-      end
-    end
-  end
-
-  def with_frozen_time(&block)
-    original_tz = ENV['TZ']
-    ENV['TZ'] = 'UTC'
-
-    Liquid::Spec::TimeFreezer.freeze(Liquid::Spec::AdapterRunner::TEST_TIME, &block)
-  ensure
-    ENV['TZ'] = original_tz
-  end
-end

test/integration/assign_test.rb

@@ -97,46 +97,6 @@ class AssignTest < Minitest::Test
     assert_equal(12, assign_score_of('int' => 123, 'str' => 'abcd'))
   end
 
-  def test_assign_with_valid_identifier_in_strict2
-    assert_template_result("hello", "{% assign my_var = 'hello' %}{{ my_var }}", error_mode: :strict2)
-  end
-
-  def test_assign_with_hyphen_in_strict2
-    assert_template_result("hello", "{% assign my-var = 'hello' %}{{ my-var }}", error_mode: :strict2)
-  end
-
-  def test_assign_rejects_parentheses_in_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% assign (a(b(c) = 1234 %}", error_mode: :strict2)
-    end
-  end
-
-  def test_assign_rejects_brackets_in_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% assign [x.y] = 'hello' %}", error_mode: :strict2)
-    end
-  end
-
-  def test_assign_rejects_dot_in_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% assign a.b = 'hello' %}", error_mode: :strict2)
-    end
-  end
-
-  def test_assign_rejects_numeric_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% assign 1abc = 'hello' %}", error_mode: :strict2)
-    end
-  end
-
-  def test_assign_allows_invalid_names_in_lax
-    assert_template_result("1234", "{% assign (a(b(c) = 1234 %}{{ self['(a(b(c)'] }}", error_mode: :lax)
-  end
-
-  def test_assign_with_filter_in_strict2
-    assert_template_result("HELLO", "{% assign my_var = 'hello' | upcase %}{{ my_var }}", error_mode: :strict2)
-  end
-
   private
 
   class ObjectWrapperDrop < Liquid::Drop

test/integration/blank_body_error_handling_test.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BlankBodyErrorHandlingTest < Minitest::Test
-  COMPARISON_ERROR = 'Liquid error (line 1): comparison of Integer with String failed'
-  INVALID_INTEGER_ERROR = 'Liquid error (line 1): invalid integer'
-
-  def render_inline(source, error_mode:, assigns: {})
-    Liquid::Template.parse(source, line_numbers: true, error_mode: error_mode).render(assigns, render_errors: true)
-  end
-
-  def assert_render_raises(source, error_mode:, assigns: {}, message: nil)
-    error = assert_raises(Liquid::ArgumentError) do
-      Liquid::Template.parse(source, line_numbers: true, error_mode: error_mode).render!(assigns)
-    end
-    assert_includes(error.message, message) if message
-  end
-
-  def test_blank_if_body_suppresses_inline_error_text_in_lax_and_strict
-    [:lax, :strict].each do |mode|
-      assert_equal('', render_inline('{% if 5 > "x" %}{% endif %}', error_mode: mode))
-    end
-  end
-
-  def test_blank_unless_body_suppresses_inline_error_text_in_lax_and_strict
-    [:lax, :strict].each do |mode|
-      assert_equal('', render_inline('{% unless 5 > "x" %} {% endunless %}', error_mode: mode))
-    end
-  end
-
-  def test_blank_for_body_suppresses_inline_error_text_in_lax_and_strict
-    [:lax, :strict].each do |mode|
-      assert_equal('', render_inline('{% for i in (1..3) offset: xs %}{% endfor %}', error_mode: mode, assigns: { 'xs' => 'bad' }))
-    end
-  end
-
-  def test_strict2_blank_if_body_shows_inline_error_text
-    assert_equal(COMPARISON_ERROR, render_inline('{% if 5 > "x" %}{% endif %}', error_mode: :strict2))
-  end
-
-  def test_strict2_whitespace_if_body_shows_inline_error_text
-    assert_equal(COMPARISON_ERROR, render_inline('{% if 5 > "x" %}   {% endif %}', error_mode: :strict2))
-  end
-
-  def test_strict2_assign_if_body_shows_inline_error_text
-    assert_equal(COMPARISON_ERROR, render_inline('{% if 5 > "x" %}{% assign a = 1 %}{% endif %}', error_mode: :strict2))
-  end
-
-  def test_strict2_comment_if_body_shows_inline_error_text
-    assert_equal(COMPARISON_ERROR, render_inline('{% if 5 > "x" %}{% comment %}c{% endcomment %}{% endif %}', error_mode: :strict2))
-  end
-
-  def test_strict2_capture_if_body_shows_inline_error_text
-    assert_equal(COMPARISON_ERROR, render_inline('{% if 5 > "x" %}{% capture c %}text{% endcapture %}{% endif %}', error_mode: :strict2))
-  end
-
-  def test_strict2_blank_unless_body_shows_inline_error_text
-    assert_equal(COMPARISON_ERROR, render_inline('{% unless 5 > "x" %} {% endunless %}', error_mode: :strict2))
-  end
-
-  def test_strict2_blank_for_body_shows_inline_error_text
-    assert_equal(INVALID_INTEGER_ERROR, render_inline('{% for i in (1..3) offset: xs %}{% endfor %}', error_mode: :strict2, assigns: { 'xs' => 'bad' }))
-  end
-
-  def test_nonblank_bodies_show_inline_error_text_in_all_modes
-    [:lax, :strict, :strict2].each do |mode|
-      assert_equal(COMPARISON_ERROR, render_inline('{% if 5 > "x" %}{% echo 1 %}{% endif %}', error_mode: mode))
-      assert_equal(COMPARISON_ERROR, render_inline('{% if 5 > "x" %}{{ "" }}{% endif %}', error_mode: mode))
-      assert_equal(COMPARISON_ERROR, render_inline('{% if 5 > "x" %}{% else %}E{% endif %}', error_mode: mode))
-    end
-  end
-
-  def test_raised_errors_are_not_swallowed_by_blank_if_body
-    [:lax, :strict, :strict2].each do |mode|
-      assert_render_raises('{% if 5 > "x" %}{% endif %}', error_mode: mode, message: 'comparison of Integer with String failed')
-    end
-  end
-
-  def test_raised_errors_are_not_swallowed_by_blank_for_body
-    [:lax, :strict, :strict2].each do |mode|
-      assert_render_raises('{% for i in (1..3) offset: xs %}{% endfor %}', error_mode: mode, assigns: { 'xs' => 'bad' }, message: 'invalid integer')
-    end
-  end
-end

test/integration/capture_test.rb

@@ -6,11 +6,7 @@ class CaptureTest < Minitest::Test
   include Liquid
 
   def test_captures_block_content_in_variable
-    assert_template_result("test string", "{% capture var %}test string{% endcapture %}{{var}}", {})
-  end
-
-  def test_captures_block_content_in_quoted_variable_in_lax
-    assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {}, error_mode: :lax)
+    assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
   end
 
   def test_capture_with_hyphen_in_variable_name
@@ -53,35 +49,4 @@ class CaptureTest < Minitest::Test
     t.render!
     assert_equal(9, t.resource_limits.assign_score)
   end
-
-  def test_capture_with_valid_identifier_in_strict2
-    assert_template_result("hello", "{% capture my_var %}hello{% endcapture %}{{ my_var }}", error_mode: :strict2)
-  end
-
-  def test_capture_with_hyphen_in_strict2
-    assert_template_result("hello", "{% capture my-var %}hello{% endcapture %}{{ my-var }}", error_mode: :strict2)
-  end
-
-  def test_capture_rejects_parentheses_in_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% capture (x[y %}hello{% endcapture %}", error_mode: :strict2)
-    end
-  end
-
-  def test_capture_rejects_dot_in_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% capture a.b %}hello{% endcapture %}", error_mode: :strict2)
-    end
-  end
-
-  def test_capture_rejects_numeric_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% capture 1abc %}hello{% endcapture %}", error_mode: :strict2)
-    end
-  end
-
-  def test_capture_allows_invalid_names_in_lax
-    t = Liquid::Template.parse("{% capture (x[y %}hello{% endcapture %}", error_mode: :lax)
-    assert_equal("(x[y", t.root.nodelist.first.to)
-  end
 end

test/integration/context_test.rb

@@ -296,8 +296,8 @@ class ContextTest < Minitest::Test
   end
 
   def test_access_variable_with_hash_notation
-    assert_template_result('baz', '{{ foo }}', { "foo" => "baz" })
-    assert_template_result('baz', '{{ self[bar] }}', { 'foo' => 'baz', 'bar' => 'foo' })
+    assert_template_result('baz', '{{ ["foo"] }}', { "foo" => "baz" })
+    assert_template_result('baz', '{{ [bar] }}', { 'foo' => 'baz', 'bar' => 'foo' })
   end
 
   def test_access_hashes_with_hash_access_variables
@@ -632,28 +632,13 @@ class ContextTest < Minitest::Test
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_modes(:strict) do
+    with_error_mode(:strict) do
       context = Context.new
       context.key?('unknown')
       assert_empty(context.errors)
     end
   end
 
-  def test_key_lookup_will_raise_for_missing_keys_when_strict_variables_is_enabled
-    context = Context.new
-    context.strict_variables = true
-    assert_raises(Liquid::UndefinedVariable) do
-      context['unknown']
-    end
-  end
-
-  def test_has_key_will_not_raise_for_missing_keys_when_strict_variables_is_enabled
-    context = Context.new
-    context.strict_variables = true
-    refute(context.key?('unknown'))
-    assert_empty(context.errors)
-  end
-
   def test_context_always_uses_static_registers
     registers = {
       my_register: :my_value,

test/integration/error_handling_test.rb

@@ -67,7 +67,7 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_unrecognized_operator
-    with_error_modes(:strict) do
+    with_error_mode(:strict) do
       assert_raises(SyntaxError) do
         Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
       end
@@ -269,8 +269,7 @@ class ErrorHandlingTest < Minitest::Test
     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
-    expected = ENV["LIQUID_PARSER_MODE"] == "strict2" ? "Liquid error: comparison of Integer with String failed0" : "0"
-    assert_equal(expected, output)
+    assert_equal("0", output)
   end
 
   def test_syntax_error_is_raised_with_template_name

test/integration/expression_test.rb

@@ -26,12 +26,8 @@ class ExpressionTest < Minitest::Test
   def test_float
     assert_template_result("-17.42", "{{ -17.42 }}")
     assert_template_result("2.5", "{{ 2.5 }}")
-
-    with_error_modes(:lax) do
-      assert_expression_result(0.0, "0.....5")
-      assert_expression_result(0.0, "-0..1")
-    end
-
+    assert_expression_result(0.0, "0.....5")
+    assert_expression_result(0.0, "-0..1")
     assert_expression_result(1.5, "1.5")
 
     # this is a unfortunate quirky behavior of Liquid
@@ -65,7 +61,6 @@ class ExpressionTest < Minitest::Test
     assert_template_result(
       "",
       "{{ - 'theme.css' - }}",
-      error_mode: :lax,
     )
   end
 
@@ -152,35 +147,6 @@ class ExpressionTest < Minitest::Test
     assert(parse_context.instance_variable_get(:@expression_cache).nil?)
   end
 
-  def test_safe_parse_with_variable_lookup
-    parse_context = Liquid::ParseContext.new
-    parser = parse_context.new_parser('product.title')
-    result = Liquid::Expression.safe_parse(parser)
-
-    assert_instance_of(Liquid::VariableLookup, result)
-    assert_equal('product', result.name)
-    assert_equal(['title'], result.lookups)
-  end
-
-  def test_safe_parse_with_number
-    parse_context = Liquid::ParseContext.new
-    parser = parse_context.new_parser('42')
-    result = Liquid::Expression.safe_parse(parser)
-
-    assert_equal(42, result)
-  end
-
-  def test_safe_parse_raises_syntax_error_for_invalid_expression
-    parse_context = Liquid::ParseContext.new
-    parser = parse_context.new_parser('')
-
-    error = assert_raises(Liquid::SyntaxError) do
-      Liquid::Expression.safe_parse(parser)
-    end
-
-    assert_match(/is not a valid expression/, error.message)
-  end
-
   private
 
   def assert_expression_result(expect, markup, **assigns)

test/integration/hash_rendering_test.rb

@@ -88,11 +88,17 @@ class HashRenderingTest < Minitest::Test
   end
 
   def test_rendering_hash_with_custom_to_s_method_uses_custom_to_s
-    assert_template_result("kewl", "{{ my_hash }}", { "my_hash" => HashWithCustomToS.new })
+    my_hash = Class.new(Hash) do
+      def to_s
+        "kewl"
+      end
+    end.new
+
+    assert_template_result("kewl", "{{ my_hash }}", { "my_hash" => my_hash })
   end
 
   def test_rendering_hash_without_custom_to_s_uses_default_inspect
-    my_hash = HashWithoutCustomToS.new
+    my_hash = Class.new(Hash).new
     my_hash[:foo] = :bar
 
     assert_template_result("{:foo=>:bar}", "{{ my_hash }}", { "my_hash" => my_hash })

test/integration/parsing_quirks_test.rb

@@ -31,18 +31,18 @@ class ParsingQuirksTest < Minitest::Test
   def test_error_on_empty_filter
     assert(Template.parse("{{test}}"))
 
-    with_error_modes(:lax) do
+    with_error_mode(:lax) do
       assert(Template.parse("{{|test}}"))
     end
 
-    with_error_modes(:strict) do
+    with_error_mode(:strict) do
       assert_raises(SyntaxError) { Template.parse("{{|test}}") }
       assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
     end
   end
 
   def test_meaningless_parens_error
-    with_error_modes(:strict) do
+    with_error_mode(:strict) do
       assert_raises(SyntaxError) do
         markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
@@ -51,7 +51,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_unexpected_characters_syntax_error
-    with_error_modes(:strict) do
+    with_error_mode(:strict) do
       assert_raises(SyntaxError) do
         markup = "true && false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
@@ -70,7 +70,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_meaningless_parens_lax
-    with_error_modes(:lax) do
+    with_error_mode(:lax) do
       assigns = { 'b' => 'bar', 'c' => 'baz' }
       markup  = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
       assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
@@ -78,7 +78,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_unexpected_characters_silently_eat_logic_lax
-    with_error_modes(:lax) do
+    with_error_mode(:lax) do
       markup = "true && false"
       assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
       markup = "false || true"
@@ -93,7 +93,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_unanchored_filter_arguments
-    with_error_modes(:lax) do
+    with_error_mode(:lax) do
       assert_template_result('hi', "{{ 'hi there' | split$$$:' ' | first }}")
 
       assert_template_result('x', "{{ 'X' | downcase) }}")
@@ -106,14 +106,14 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_invalid_variables_work
-    with_error_modes(:lax) do
+    with_error_mode(:lax) do
       assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
       assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
     end
   end
 
   def test_extra_dots_in_ranges
-    with_error_modes(:lax) do
+    with_error_mode(:lax) do
       assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
     end
   end
@@ -133,7 +133,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_incomplete_expression
-    with_error_modes(:lax) do
+    with_error_mode(:lax) do
       assert_template_result("false", "{{ false - }}")
       assert_template_result("false", "{{ false > }}")
       assert_template_result("false", "{{ false < }}")

test/integration/security_test.rb

@@ -44,40 +44,33 @@ class SecurityTest < Minitest::Test
   end
 
   def test_does_not_permanently_add_filters_to_symbol_table
-    assert_no_new_symbols do
-      # 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
+    current_symbols = Symbol.all_symbols
 
-      GC.start
-    end
+    # 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
+
+    GC.start
+
+    assert_equal([], (Symbol.all_symbols - current_symbols))
   end
 
   def test_does_not_add_drop_methods_to_symbol_table
-    assert_no_new_symbols do
-      assigns = { 'drop' => Drop.new }
-      assert_equal("", Template.parse("{{ drop.custom_method_1 }}", assigns).render!)
-      assert_equal("", Template.parse("{{ drop.custom_method_2 }}", assigns).render!)
-      assert_equal("", Template.parse("{{ drop.custom_method_3 }}", assigns).render!)
-    end
-  end
-
-  def assert_no_new_symbols
-    # Run once to trigger any first-time initialization which might create some symbols,
-    # for example autoload or lazy method parsing might create symbols on first execution.
-    yield
-
-    # Ensure no new symbols for further runs, i.e. the code does not leak symbols
     current_symbols = Symbol.all_symbols
-    yield
-    assert_equal([], Symbol.all_symbols - current_symbols)
+
+    assigns = { 'drop' => Drop.new }
+    assert_equal("", Template.parse("{{ drop.custom_method_1 }}", assigns).render!)
+    assert_equal("", Template.parse("{{ drop.custom_method_2 }}", assigns).render!)
+    assert_equal("", Template.parse("{{ drop.custom_method_3 }}", assigns).render!)
+
+    assert_equal([], (Symbol.all_symbols - current_symbols))
   end
 
   def test_max_depth_nested_blocks_does_not_raise_exception

test/integration/self_drop_context_test.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class SelfDropContextTest < Minitest::Test
-  include Liquid
-
-  def test_self_drop_passed_as_render_param_preserves_original_scope
-    source = <<~LIQUID
-      {%- assign var = 42 -%}
-      {%- assign s = self -%}
-      {%- render "snippet1", other_self: s -%}
-    LIQUID
-
-    partials = {
-      'snippet1' => <<~LIQUID,
-        {%- assign var = 43 -%}
-        {{- other_self.var }}|{{ self.var -}}
-      LIQUID
-    }
-
-    assert_template_result('42|43', source, partials: partials)
-  end
-
-  def test_self_drop_in_render_without_passing_resolves_inner_scope
-    source = <<~LIQUID
-      {%- assign var = 42 -%}
-      {%- render "snippet1" -%}
-    LIQUID
-
-    partials = {
-      'snippet1' => <<~LIQUID,
-        {%- assign var = 99 -%}
-        {{- self.var -}}
-      LIQUID
-    }
-
-    assert_template_result('99', source, partials: partials)
-  end
-
-  def test_self_drop_passed_to_nested_renders_preserves_each_level
-    source = <<~LIQUID
-      {%- assign a = 1 -%}
-      {%- assign s1 = self -%}
-      {%- render "snippet1", outer: s1 -%}
-    LIQUID
-
-    partials = {
-      'snippet1' => <<~LIQUID,
-        {%- assign a = 2 -%}
-        {%- assign s2 = self -%}
-        {%- render "snippet2", outer: outer, middle: s2 -%}
-      LIQUID
-      'snippet2' => <<~LIQUID,
-        {%- assign a = 3 -%}
-        {{- outer.a }}|{{ middle.a }}|{{ self.a -}}
-      LIQUID
-    }
-
-    assert_template_result('1|2|3', source, partials: partials)
-  end
-
-  def test_self_drop_reflects_variables_assigned_after_creation
-    source = <<~LIQUID
-      {%- assign s = self -%}
-      {%- assign x = 42 %}{{ s.x -}}
-    LIQUID
-
-    assert_template_result('42', source)
-  end
-
-  def test_self_drop_context_setter_is_undefined
-    context = Context.new
-    drop = SelfDrop.new(context)
-    refute(drop.respond_to?(:context=))
-
-    assert_template_result('42', '{{ self.x }}', { 'x' => 42 })
-  end
-
-  def test_self_drop_repeated_lookups_compare_equal_for_same_context
-    context = Context.new
-    drop = context.find_variable("self")
-    cached_drop = context.find_variable("self")
-
-    assert_same(drop, cached_drop)
-    assert_equal(drop.object_id, cached_drop.object_id)
-    assert_equal(drop, cached_drop)
-  end
-
-  def test_assigned_self_drop_compares_equal_to_itself
-    assert_template_result('T', '{% assign s = self %}{% if s == s %}T{% else %}F{% endif %}')
-  end
-
-  def test_distinct_self_assignments_compare_equal_for_same_context
-    assert_template_result('T', '{% assign a = self %}{% assign b = self %}{% if a == b %}T{% else %}F{% endif %}')
-  end
-
-  def test_bare_self_compares_equal_to_bare_self
-    assert_template_result('T', '{% if self == self %}T{% else %}F{% endif %}')
-  end
-
-  def test_self_drop_with_strict_variables_does_not_raise_for_defined_var
-    t = Template.parse('{{ self.x }}')
-    result = t.render({ 'x' => 42 }, strict_variables: true)
-    assert_equal('42', result)
-  end
-
-  def test_self_drop_with_strict_variables_returns_nil_for_undefined_var
-    t = Template.parse('{{ self.x }}')
-    result = t.render({}, strict_variables: true)
-    assert_equal('', result)
-  end
-
-  def test_self_drop_can_be_passed_as_bare_drop_to_render
-    t = Template.parse('{{ self.x }}')
-    drop = SelfDrop.new(Context.new({ 'x' => 42 }))
-    result = t.render(drop)
-    assert_equal('42', result)
-  end
-end

test/integration/standard_filter_test.rb

@@ -116,7 +116,7 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_slice_on_arrays
-    input = 'foobar'.split('')
+    input = 'foobar'.split(//)
     assert_equal(%w(o o b), @filters.slice(input, 1, 3))
     assert_equal(%w(o o b a r), @filters.slice(input, 1, 1000))
     assert_equal(%w(), @filters.slice(input, 1, 0))
@@ -164,13 +164,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal(['A', 'Z'], @filters.split('A1Z', 1))
   end
 
-  def test_squish_filter
-    assert_equal("foo bar boo", Liquid::Template.parse(%({{ " foo   bar
-\t   boo   " | squish }})).render)
-    assert_equal("", Liquid::Template.parse('{{ nil | squish }}').render)
-    assert_equal("", Liquid::Template.parse('{{ " " | squish }}').render)
-  end
-
   def test_escape
     assert_equal('&lt;strong&gt;', @filters.escape('<strong>'))
     assert_equal('1', @filters.escape(1))
@@ -301,7 +294,13 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_join_calls_to_liquid_on_each_element
-    assert_equal('i did it, i did it', @filters.join([CustomToLiquidDrop.new('i did it'), CustomToLiquidDrop.new('i did it')], ", "))
+    drop = Class.new(Liquid::Drop) do
+      def to_liquid
+        'i did it'
+      end
+    end
+
+    assert_equal('i did it, i did it', @filters.join([drop.new, drop.new], ", "))
   end
 
   def test_sort
@@ -561,23 +560,12 @@ class StandardFiltersTest < Minitest::Test
     end
   end
 
-  def test_map_with_value_property
-    array = [
-      { "handle" => "alpha", "value" => "A" },
-      { "handle" => "beta", "value" => "B" },
-      { "handle" => "gamma", "value" => "C" }
-    ]
-
-    assert_template_result("A B C", "{{ array | map: 'value' | join: ' ' }}", { "array" => array })
-  end
-
-  def test_map_returns_input_with_no_property
+  def test_map_returns_empty_with_no_property
     foo = [
       [1],
       [2],
       [3],
     ]
-
     assert_raises(Liquid::ArgumentError) do
       @filters.map(foo, nil)
     end
@@ -634,40 +622,6 @@ class StandardFiltersTest < Minitest::Test
     assert_nil(@filters.last([]))
   end
 
-  def test_first_last_on_strings
-    # Ruby's String class does not have first/last methods by default.
-    # ActiveSupport adds String#first and String#last to return the first/last character.
-    # Liquid must work without ActiveSupport, so the first/last filters handle strings specially.
-    #
-    # This enables template patterns like:
-    #   {{ product.title | first }}  => "S" (for "Snowboard")
-    #   {{ customer.name | last }}   => "h" (for "Smith")
-    #
-    # Note: ActiveSupport returns "" for empty strings, not nil.
-    assert_equal('f', @filters.first('foo'))
-    assert_equal('o', @filters.last('foo'))
-    assert_equal('', @filters.first(''))
-    assert_equal('', @filters.last(''))
-  end
-
-  def test_first_last_on_unicode_strings
-    # Unicode strings should return the first/last grapheme cluster (character),
-    # not the first/last byte. Ruby's String#[] handles this correctly with index 0/-1.
-    # This ensures international text works properly:
-    #   {{ korean_name | first }} => "고" (not a partial byte sequence)
-    assert_equal('고', @filters.first('고스트빈'))
-    assert_equal('빈', @filters.last('고스트빈'))
-  end
-
-  def test_first_last_on_strings_via_template
-    # Integration test to verify the filter works end-to-end in templates.
-    # Empty strings return empty output (nil renders as empty string).
-    assert_template_result('f', '{{ name | first }}', { 'name' => 'foo' })
-    assert_template_result('o', '{{ name | last }}', { 'name' => 'foo' })
-    assert_template_result('', '{{ name | first }}', { 'name' => '' })
-    assert_template_result('', '{{ name | last }}', { 'name' => '' })
-  end
-
   def test_replace
     assert_equal('b b b b', @filters.replace('a a a a', 'a', 'b'))
     assert_equal('2 2 2 2', @filters.replace('1 1 1 1', 1, 2))
@@ -1079,23 +1033,6 @@ class StandardFiltersTest < Minitest::Test
     assert_template_result(expected_output, template, { "array" => array })
   end
 
-  def test_where_with_empty_string_is_a_no_op
-    environment = { "array" => ["alpha", "beta", "gamma"] }
-    expected_output = "alpha beta gamma"
-    template = "{{ array | where: '' | join: ' ' }}"
-
-    assert_template_result(expected_output, template, environment)
-  end
-
-  def test_where_with_nil_is_a_no_op
-    environment = { "array" => ["alpha", "beta", "gamma"] }
-    template = "{{ array | where: nil | join: ' ' }}"
-
-    assert_raises(Liquid::ArgumentError) do
-      assert_template_result("alpha beta gamma", template, environment)
-    end
-  end
-
   def test_where_with_value
     array = [
       { "handle" => "alpha", "ok" => true },
@@ -1181,8 +1118,6 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_all_filters_never_raise_non_liquid_exception
-    skip("too slow on non-CRuby due to many exceptions") unless RUBY_ENGINE == 'ruby'
-
     test_drop = TestDrop.new(value: "test")
     test_drop.context = Context.new
     test_enum = TestEnumerable.new
@@ -1333,33 +1268,6 @@ class StandardFiltersTest < Minitest::Test
     assert_template_result("0", "{{ input | sum: 'subtotal' }}", { "input" => input })
   end
 
-  def test_sum_with_non_string_property
-    input = [{ true => 1 }, { 1.0 => 0.2, 1 => -0.3 }, { 1..5 => 0.4 }]
-
-    assert_equal(1, @filters.sum(input, true))
-    assert_equal(0.2, @filters.sum(input, 1.0))
-    assert_equal(-0.3, @filters.sum(input, 1))
-    assert_equal(0.4, @filters.sum(input, 1..5))
-    assert_equal(0, @filters.sum(input, nil))
-    assert_equal(0, @filters.sum(input, ""))
-  end
-
-  def test_uniq_with_to_liquid_value
-    input = [StringDrop.new("foo"), StringDrop.new("bar"), "foo"]
-    expected = [StringDrop.new("foo"), StringDrop.new("bar")]
-    result = @filters.uniq(input)
-
-    assert_equal(expected, result)
-  end
-
-  def test_uniq_with_to_liquid_value_pick_correct_classes
-    input = ["foo", StringDrop.new("foo"), StringDrop.new("bar")]
-    expected = [String, StringDrop]
-    result = @filters.uniq(input).map(&:class)
-
-    assert_equal(expected, result)
-  end
-
   private
 
   def with_timezone(tz)

test/integration/tags/cycle_tag_test.rb

@@ -3,10 +3,20 @@
 require 'test_helper'
 
 class CycleTagTest < Minitest::Test
+  def test_simple_cycle
+    template = <<~LIQUID
+      {%- cycle '1', '2', '3' -%}
+      {%- cycle '1', '2', '3' -%}
+      {%- cycle '1', '2', '3' -%}
+    LIQUID
+
+    assert_template_result("123", template)
+  end
+
   def test_simple_cycle_inside_for_loop
     template = <<~LIQUID
       {%- for i in (1..3) -%}
-        {%- cycle '1', '2', '3' -%}
+        {% cycle '1', '2', '3' %}
       {%- endfor -%}
     LIQUID
 
@@ -26,155 +36,13 @@ class CycleTagTest < Minitest::Test
     assert_template_result("123", template)
   end
 
-  def test_cycle_named_groups_string
-    template = <<~LIQUID
-      {%- for i in (1..3) -%}
-        {%- cycle 'placeholder1': 1, 2, 3 -%}
-        {%- cycle 'placeholder2': 1, 2, 3 -%}
-      {%- endfor -%}
-    LIQUID
-
-    assert_template_result("112233", template)
-  end
-
-  def test_cycle_named_groups_vlookup
-    template = <<~LIQUID
-      {%- assign placeholder1 = 'placeholder1' -%}
-      {%- assign placeholder2 = 'placeholder2' -%}
-      {%- for i in (1..3) -%}
-        {%- cycle placeholder1: 1, 2, 3 -%}
-        {%- cycle placeholder2: 1, 2, 3 -%}
-      {%- endfor -%}
-    LIQUID
-
-    assert_template_result("112233", template)
-  end
-
-  def test_unnamed_cycle_have_independent_counters_when_used_with_lookups
+  def test_cycle_tag_always_resets_cycle
     template = <<~LIQUID
       {%- assign a = "1" -%}
-      {%- for i in (1..3) -%}
-        {%- cycle a, "2" -%}
-        {%- cycle a, "2" -%}
-      {%- endfor -%}
+      {%- cycle a, "2" -%}
+      {%- cycle a, "2" -%}
     LIQUID
 
-    assert_template_result("112211", template)
-  end
-
-  def test_unnamed_cycle_dependent_counter_when_used_with_literal_values
-    template = <<~LIQUID
-      {%- cycle "1", "2" -%}
-      {%- cycle "1", "2" -%}
-      {%- cycle "1", "2" -%}
-    LIQUID
-
-    assert_template_result("121", template)
-  end
-
-  def test_optional_trailing_comma
-    template = <<~LIQUID
-      {%- cycle "1", "2", -%}
-      {%- cycle "1", "2", -%}
-      {%- cycle "1", "2", -%}
-      {%- cycle "1", -%}
-    LIQUID
-
-    assert_template_result("1211", template)
-  end
-
-  def test_cycle_tag_without_arguments
-    error = assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% cycle %}")
-    end
-
-    assert_match(/Syntax Error in 'cycle' - Valid syntax: cycle \[name :\] var/, error.message)
-  end
-
-  def test_cycle_tag_with_error_mode
-    # QuotedFragment is more permissive than what Parser#expression allows.
-    template1 = "{% assign 5 = 'b' %}{% cycle .5, .4 %}"
-    template2 = "{% cycle .5: 'a', 'b' %}"
-
-    with_error_modes(:lax, :strict) do
-      assert_template_result("b", template1)
-      assert_template_result("a", template2)
-    end
-
-    with_error_modes(:strict2) do
-      error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
-      error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
-
-      assert_match(/Liquid syntax error:/, error1.message)
-      assert_match(/Liquid syntax error: \[:dot, "."\] is not a valid expression/, error2.message)
-    end
-  end
-
-  def test_cycle_with_trailing_elements
-    assignments = "{% assign a = 'A' %}{% assign n = 'N' %}"
-
-    template1 = "#{assignments}{% cycle       'a'  'b', 'c' %}"
-    template2 = "#{assignments}{% cycle name: 'a'  'b', 'c' %}"
-    template3 = "#{assignments}{% cycle name: 'a', 'b'  'c' %}"
-    template4 = "#{assignments}{% cycle n  e: 'a', 'b', 'c' %}"
-    template5 = "#{assignments}{% cycle n  e  'a', 'b', 'c' %}"
-
-    with_error_modes(:lax, :strict) do
-      assert_template_result("a", template1)
-      assert_template_result("a", template2)
-      assert_template_result("a", template3)
-      assert_template_result("N", template4)
-      assert_template_result("N", template5)
-    end
-
-    with_error_modes(:strict2) do
-      error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
-      error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
-      error3 = assert_raises(Liquid::SyntaxError) { Template.parse(template3) }
-      error4 = assert_raises(Liquid::SyntaxError) { Template.parse(template4) }
-      error5 = assert_raises(Liquid::SyntaxError) { Template.parse(template5) }
-
-      expected_error = /Expected end_of_string but found/
-
-      assert_match(expected_error, error1.message)
-      assert_match(expected_error, error2.message)
-      assert_match(expected_error, error3.message)
-      assert_match(expected_error, error4.message)
-      assert_match(expected_error, error5.message)
-    end
-  end
-
-  def test_cycle_name_with_invalid_expression
-    template = <<~LIQUID
-      {% for i in (1..3) %}
-        {% cycle foo=>bar: "a", "b" %}
-      {% endfor %}
-    LIQUID
-
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
-
-  def test_cycle_variable_with_invalid_expression
-    template = <<~LIQUID
-      {% for i in (1..3) %}
-        {% cycle foo=>bar, "a", "b" %}
-      {% endfor %}
-    LIQUID
-
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
+    assert_template_result("11", template)
   end
 end

test/integration/tags/include_tag_test.rb

@@ -204,32 +204,6 @@ class IncludeTagTest < Minitest::Test
     )
   end
 
-  def test_strict2_parsing_errors
-    with_error_modes(:lax, :strict) do
-      assert_template_result(
-        'hello value1 value2',
-        '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-        partials: { 'snippet' => 'hello {{ arg1 }} {{ arg2 }}' },
-      )
-    end
-
-    with_error_modes(:strict2) do
-      assert_syntax_error(
-        '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-      )
-      assert_syntax_error(
-        '{% include "snippet" | filter %}',
-      )
-    end
-  end
-
-  def test_optional_commas
-    partials = { 'snippet' => 'hello {{ arg1 }} {{ arg2 }}' }
-    assert_template_result('hello value1 value2', '{% include "snippet", arg1: "value1", arg2: "value2" %}', partials: partials)
-    assert_template_result('hello value1 value2', '{% include "snippet"  arg1: "value1", arg2: "value2" %}', partials: partials)
-    assert_template_result('hello value1 value2', '{% include "snippet"  arg1: "value1"  arg2: "value2" %}', partials: partials)
-  end
-
   def test_include_tag_caches_second_read_of_same_partial
     file_system = CountingFileSystem.new
     environment = Liquid::Environment.build(file_system: file_system)
@@ -303,13 +277,13 @@ class IncludeTagTest < Minitest::Test
     assert_raises(Liquid::SyntaxError) do
       Template.parse("{% include template %}", error_mode: :strict, environment: env).render!("template" => '{{ "X" || downcase }}')
     end
-    with_error_modes(:lax) do
+    with_error_mode(:lax) do
       assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true, environment: env).render!("template" => '{{ "X" || downcase }}'))
     end
     assert_raises(Liquid::SyntaxError) do
       Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale], environment: env).render!("template" => '{{ "X" || downcase }}')
     end
-    with_error_modes(:lax) do
+    with_error_mode(:lax) do
       assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode], environment: env).render!("template" => '{{ "X" || downcase }}'))
     end
   end
@@ -400,88 +374,4 @@ class IncludeTagTest < Minitest::Test
       render_errors: true,
     )
   end
-
-  def test_include_template_with_invalid_expression
-    template = "{% include foo=>bar %}"
-
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
-
-  def test_include_with_invalid_expression
-    template = '{% include "snippet" with foo=>bar %}'
-
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
-
-  def test_include_attribute_with_invalid_expression
-    template = '{% include "snippet", key: foo=>bar %}'
-
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
-
-  def test_include_for_loop_true_with_for_keyword
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'product' for products %}")
-      include_node = template.root.nodelist.first
-
-      assert(include_node.for_loop?, "Expected for_loop? to be true for 'for' keyword")
-    end
-  end
-
-  def test_include_for_loop_false_with_with_keyword
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'product' with product %}")
-      include_node = template.root.nodelist.first
-
-      refute(include_node.for_loop?, "Expected for_loop? to be false for 'with' keyword")
-    end
-  end
-
-  def test_include_for_loop_false_without_keyword
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'header' %}")
-      include_node = template.root.nodelist.first
-
-      refute(include_node.for_loop?, "Expected for_loop? to be false when no keyword")
-    end
-  end
-
-  def test_include_for_loop_with_alias
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'product' for products as item %}")
-      include_node = template.root.nodelist.first
-
-      assert(include_node.for_loop?, "Expected for_loop? to be true for 'for' with alias")
-    end
-  end
-
-  def test_include_with_keyword_and_alias
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'product' with products[0] as item %}")
-      include_node = template.root.nodelist.first
-
-      refute(include_node.for_loop?, "Expected for_loop? to be false for 'with' with alias")
-    end
-  end
 end # IncludeTagTest

test/integration/tags/increment_tag_test.rb

@@ -27,50 +27,4 @@ class IncrementTagTest < Minitest::Test
       '{%decrement starboard %}',
     )
   end
-
-  def test_increment_strict2_rejects_invalid_variable_name
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse('{% increment foo bar %}', error_mode: :strict2)
-    end
-  end
-
-  def test_increment_strict2_rejects_variable_starting_with_number
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse('{% increment 11aa %}', error_mode: :strict2)
-    end
-  end
-
-  def test_increment_strict2_accepts_valid_variable_name
-    template = Template.parse('{% increment my-var %}', error_mode: :strict2)
-    assert_equal('0', template.render)
-  end
-
-  def test_decrement_strict2_rejects_invalid_variable_name
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse('{% decrement foo bar %}', error_mode: :strict2)
-    end
-  end
-
-  def test_decrement_strict2_rejects_variable_starting_with_number
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse('{% decrement 11aa %}', error_mode: :strict2)
-    end
-  end
-
-  def test_decrement_strict2_accepts_valid_variable_name
-    template = Template.parse('{% decrement my-var %}', error_mode: :strict2)
-    assert_equal('-1', template.render)
-  end
-
-  def test_increment_strict2_rejects_empty_variable_name
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse('{% increment %}', error_mode: :strict2)
-    end
-  end
-
-  def test_decrement_strict2_rejects_empty_variable_name
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse('{% decrement %}', error_mode: :strict2)
-    end
-  end
 end

test/integration/tags/render_tag_test.rb

@@ -105,33 +105,7 @@ class RenderTagTest < Minitest::Test
     assert_syntax_error("{% assign name = 'snippet' %}{% render name %}")
   end
 
-  def test_strict2_parsing_errors
-    with_error_modes(:lax, :strict) do
-      assert_template_result(
-        'hello value1 value2',
-        '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-        partials: { 'snippet' => 'hello {{ arg1 }} {{ arg2 }}' },
-      )
-    end
-
-    with_error_modes(:strict2) do
-      assert_syntax_error(
-        '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-      )
-      assert_syntax_error(
-        '{% render "snippet" | filter %}',
-      )
-    end
-  end
-
-  def test_optional_commas
-    partials = { 'snippet' => 'hello {{ arg1 }} {{ arg2 }}' }
-    assert_template_result('hello value1 value2', '{% render "snippet", arg1: "value1", arg2: "value2" %}', partials: partials)
-    assert_template_result('hello value1 value2', '{% render "snippet"  arg1: "value1", arg2: "value2" %}', partials: partials)
-    assert_template_result('hello value1 value2', '{% render "snippet"  arg1: "value1"  arg2: "value2" %}', partials: partials)
-  end
-
-  def test_render_tag_caches_second_read_of_same_partial
+  def test_include_tag_caches_second_read_of_same_partial
     file_system = StubFileSystem.new('snippet' => 'echo')
     assert_equal(
       'echoecho',
@@ -174,16 +148,16 @@ class RenderTagTest < Minitest::Test
   def test_increment_is_isolated_between_renders
     assert_template_result(
       '010',
-      '{% increment port %}{% increment port %}{% render "incr" %}',
-      partials: { 'incr' => '{% increment port %}' },
+      '{% increment %}{% increment %}{% render "incr" %}',
+      partials: { 'incr' => '{% increment %}' },
     )
   end
 
   def test_decrement_is_isolated_between_renders
     assert_template_result(
       '-1-2-1',
-      '{% decrement port %}{% decrement port %}{% render "decr" %}',
-      partials: { 'decr' => '{% decrement port %}' },
+      '{% decrement %}{% decrement %}{% render "decr" %}',
+      partials: { 'decr' => '{% decrement %}' },
     )
   end
 
@@ -314,30 +288,4 @@ class RenderTagTest < Minitest::Test
       render_errors: true,
     )
   end
-
-  def test_render_with_invalid_expression
-    template = '{% render "snippet" with foo=>bar %}'
-
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
-
-  def test_render_attribute_with_invalid_expression
-    template = '{% render "snippet", key: foo=>bar %}'
-
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
 end

test/integration/tags/standard_tag_test.rb

@@ -117,7 +117,7 @@ class StandardTagTest < Minitest::Test
     assigns = { 'condition' => "bad string here" }
     assert_template_result(
       '',
-      '{% case condition %}{% when "string here" %} hit {% endcase %}',
+      '{% case condition %}{% when "string here" %} hit {% endcase %}',\
       assigns,
     )
   end

test/integration/tags/table_row_test.rb

@@ -138,7 +138,7 @@ class TableRowTest < Minitest::Test
 
   def test_tablerow_loop_drop_attributes
     template = <<~LIQUID.chomp
-      {% tablerow i in (1..2) %}
+      {% tablerow i in (1...2) %}
       col: {{ tablerowloop.col }}
       col0: {{ tablerowloop.col0 }}
       col_first: {{ tablerowloop.col_first }}
@@ -192,14 +192,12 @@ class TableRowTest < Minitest::Test
     assert_template_result(
       "Liquid error (line 1): invalid integer",
       '{% tablerow n in (1...10) limit:true %} {{n}} {% endtablerow %}',
-      error_mode: :warn,
       render_errors: true,
     )
 
     assert_template_result(
       "Liquid error (line 1): invalid integer",
       '{% tablerow n in (1...10) offset:true %} {{n}} {% endtablerow %}',
-      error_mode: :warn,
       render_errors: true,
     )
 
@@ -207,19 +205,18 @@ class TableRowTest < Minitest::Test
       "Liquid error (line 1): invalid integer",
       '{% tablerow n in (1...10) cols:true %} {{n}} {% endtablerow %}',
       render_errors: true,
-      error_mode: :warn,
     )
   end
 
   def test_table_row_handles_interrupts
     assert_template_result(
       "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td></tr>\n",
-      '{% tablerow n in (1..3) cols:2 %} {{n}} {% break %} {{n}} {% endtablerow %}',
+      '{% tablerow n in (1...3) cols:2 %} {{n}} {% break %} {{n}} {% endtablerow %}',
     )
 
     assert_template_result(
       "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 3 </td></tr>\n",
-      '{% tablerow n in (1..3) cols:2 %} {{n}} {% continue %} {{n}} {% endtablerow %}',
+      '{% tablerow n in (1...3) cols:2 %} {{n}} {% continue %} {{n}} {% endtablerow %}',
     )
   end
 
@@ -258,211 +255,4 @@ class TableRowTest < Minitest::Test
       template,
     )
   end
-
-  def test_tablerow_with_cols_attribute_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow i in (1..6) cols: 3 %}{{ i }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
-      <tr class="row2"><td class="col1">4</td><td class="col2">5</td><td class="col3">6</td></tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template)
-    end
-  end
-
-  def test_tablerow_with_limit_attribute_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow i in (1..10) limit: 3 %}{{ i }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template)
-    end
-  end
-
-  def test_tablerow_with_offset_attribute_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow i in (1..5) offset: 2 %}{{ i }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">3</td><td class="col2">4</td><td class="col3">5</td></tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template)
-    end
-  end
-
-  def test_tablerow_with_range_attribute_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow i in (1..3) range: (1..10) %}{{ i }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template)
-    end
-  end
-
-  def test_tablerow_with_multiple_attributes_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow i in (1..10) cols: 2, limit: 4, offset: 1 %}{{ i }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">2</td><td class="col2">3</td></tr>
-      <tr class="row2"><td class="col1">4</td><td class="col2">5</td></tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template)
-    end
-  end
-
-  def test_tablerow_with_variable_collection_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow n in numbers cols: 2 %}{{ n }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">1</td><td class="col2">2</td></tr>
-      <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template, { 'numbers' => [1, 2, 3, 4] })
-    end
-  end
-
-  def test_tablerow_with_dotted_access_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow n in obj.numbers cols: 2 %}{{ n }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">1</td><td class="col2">2</td></tr>
-      <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template, { 'obj' => { 'numbers' => [1, 2, 3, 4] } })
-    end
-  end
-
-  def test_tablerow_with_bracketed_access_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow n in obj["numbers"] cols: 2 %}{{ n }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">10</td><td class="col2">20</td></tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template, { 'obj' => { 'numbers' => [10, 20] } })
-    end
-  end
-
-  def test_tablerow_without_attributes_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow i in (1..3) %}{{ i }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template)
-    end
-  end
-
-  def test_tablerow_without_in_keyword_in_strict2_mode
-    template = '{% tablerow i (1..10) %}{{ i }}{% endtablerow %}'
-
-    with_error_modes(:strict2) do
-      error = assert_raises(SyntaxError) { Template.parse(template) }
-      assert_equal("Liquid syntax error: For loops require an 'in' clause in \"i (1..10)\"", error.message)
-    end
-  end
-
-  def test_tablerow_with_multiple_invalid_attributes_reports_first_in_strict2_mode
-    template = '{% tablerow i in (1..10) invalid1: 5, invalid2: 10 %}{{ i }}{% endtablerow %}'
-
-    with_error_modes(:strict2) do
-      error = assert_raises(SyntaxError) { Template.parse(template) }
-      assert_equal("Liquid syntax error: Invalid attribute 'invalid1' in tablerow loop. Valid attributes are cols, limit, offset, and range in \"i in (1..10) invalid1: 5, invalid2: 10\"", error.message)
-    end
-  end
-
-  def test_tablerow_with_empty_collection_in_strict2_mode
-    template = <<~LIQUID.chomp
-      {% tablerow i in empty_array cols: 2 %}{{ i }}{% endtablerow %}
-    LIQUID
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      </tr>
-    OUTPUT
-
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template, { 'empty_array' => [] })
-    end
-  end
-
-  def test_tablerow_with_invalid_attribute_strict_vs_strict2
-    template = '{% tablerow i in (1..5) invalid_attr: 10 %}{{ i }}{% endtablerow %}'
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td><td class="col4">4</td><td class="col5">5</td></tr>
-    OUTPUT
-
-    with_error_modes(:lax, :strict) do
-      assert_template_result(expected, template)
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(SyntaxError) { Template.parse(template) }
-      assert_match(/Invalid attribute 'invalid_attr'/, error.message)
-    end
-  end
-
-  def test_tablerow_with_invalid_expression_strict_vs_strict2
-    template = '{% tablerow i in (1..5) limit: foo=>bar %}{{ i }}{% endtablerow %}'
-
-    with_error_modes(:lax, :strict) do
-      expected = <<~OUTPUT
-        <tr class="row1">
-        </tr>
-      OUTPUT
-      assert_template_result(expected, template)
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
 end

test/integration/template_recorder_test.rb

@@ -1,360 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../test_helper"
-require "tmpdir"
-
-class TemplateRecorderTest < Minitest::Test
-  class ProductDrop < Liquid::Drop
-    def initialize(title, secret)
-      super()
-      @title = title
-      @secret = secret
-    end
-
-    attr_reader :title
-
-    def details
-      DetailsDrop.new
-    end
-  end
-
-  class DetailsDrop < Liquid::Drop
-    def count
-      3
-    end
-  end
-
-  class LegacyFileSystem
-    attr_reader :reads
-
-    def initialize
-      @reads = []
-    end
-
-    def read_template_file(name)
-      @reads << name
-      "partial={{ product.title }}"
-    end
-  end
-
-  class UnsupportedLiquidValue
-    def to_liquid
-      self
-    end
-
-    def to_s
-      "unsupported"
-    end
-  end
-
-  class WrapperTag < Liquid::Block
-  end
-
-  class MarkerTag < Liquid::Tag
-    def render(_context)
-      "custom"
-    end
-  end
-
-  class CollectingWriter
-    attr_reader :records
-
-    def initialize
-      @records = []
-    end
-
-    def write(record)
-      @records << record
-    end
-  end
-
-  def setup
-    @directory = Dir.mktmpdir
-  end
-
-  def teardown
-    FileUtils.remove_entry(@directory)
-  end
-
-  def path(name = "recording.json")
-    File.join(@directory, name)
-  end
-
-  def test_records_and_verifies_a_render_without_changing_drop_behavior
-    product = ProductDrop.new("Computed", "must not be recorded")
-    template_source = "{{ product.title }} ({{ product.details.count }})"
-
-    output = Liquid::TemplateRecorder.record(path) do
-      Liquid::Template.parse(template_source).render!("product" => product)
-    end
-
-    assert_equal("Computed (3)", output)
-    record = Liquid::TemplateRecorder.records(path).first
-    assert_equal({ "title" => "Computed", "details" => { "count" => 3 } }, record.dig("assigns", "product"))
-    refute_includes(File.read(path), "must not be recorded")
-    assert_equal(output, Liquid::TemplateRecorder.replay_from(path, mode: :verify).render)
-  end
-
-  def test_preserves_the_legacy_one_argument_file_system_contract
-    file_system = LegacyFileSystem.new
-    environment = Liquid::Environment.build { |env| env.file_system = file_system }
-
-    output = Liquid::TemplateRecorder.record(path) do
-      Liquid::Template.parse("before {% include 'card' %}", environment: environment)
-        .render!("product" => ProductDrop.new("Hat", "secret"))
-    end
-
-    assert_equal("before partial=Hat", output)
-    assert_equal(["card"], file_system.reads)
-    record = Liquid::TemplateRecorder.records(path).first
-    assert_equal({ "card" => "partial={{ product.title }}" }, record["file_system"])
-    assert_equal(2, record["templates"].length)
-    assert_equal(output, Liquid::TemplateRecorder.replay_from(path, mode: :verify).render)
-  end
-
-  def test_jsonl_appends_one_self_contained_record_per_render
-    recording = path("renders.jsonl")
-
-    2.times do |sequence|
-      Liquid::TemplateRecorder.record(recording) do
-        Liquid::Template.parse("value={{ value }}").render!("value" => sequence)
-      end
-    end
-
-    assert_equal(2, File.readlines(recording).length)
-    assert_equal(["value=0", "value=1"], Liquid::TemplateRecorder.records(recording).map { |item| item["output"] })
-    assert_equal("value=0", Liquid::TemplateRecorder.replay_from(recording, index: 0).render)
-    assert_equal("value=1", Liquid::TemplateRecorder.replay_from(recording).render)
-  end
-
-  def test_json_session_supports_multiple_renders
-    Liquid::TemplateRecorder.record(path) do
-      Liquid::Template.parse("one={{ value }}").render!("value" => 1)
-      Liquid::Template.new.parse("two={{ value }}").render!("value" => 2)
-    end
-
-    records = Liquid::TemplateRecorder.records(path)
-    assert_equal(["one=1", "two=2"], records.map { |item| item["output"] })
-    assert_equal("two=2", Liquid::TemplateRecorder.replay_from(path).render)
-  end
-
-  def test_failed_recording_does_not_delete_an_existing_json_file
-    File.write(path, "existing")
-
-    assert_raises(RuntimeError) do
-      Liquid::TemplateRecorder.record(path) { raise "boom" }
-    end
-
-    assert_equal("existing", File.read(path))
-  end
-
-  def test_render_failure_is_not_written_to_jsonl
-    recording = path("renders.jsonl")
-
-    assert_raises(Liquid::UndefinedVariable) do
-      Liquid::TemplateRecorder.record(recording) do
-        Liquid::Template.parse("{{ missing }}").render!(nil, strict_variables: true)
-      end
-    end
-
-    refute_path_exists(recording)
-  end
-
-  def test_tampered_template_is_rejected
-    Liquid::TemplateRecorder.record(path) { Liquid::Template.parse("safe").render! }
-    session = JSON.parse(File.read(path))
-    session["renders"][0]["template"]["source"] = "changed"
-    File.write(path, JSON.generate(session))
-
-    error = assert_raises(Liquid::TemplateRecorder::ReplayError) do
-      Liquid::TemplateRecorder.replay_from(path)
-    end
-    assert_match(/checksum/, error.message)
-  end
-
-  def test_recordings_are_thread_local
-    paths = [path("a.json"), path("b.json")]
-    ready = Queue.new
-    release = Queue.new
-    threads = Array.new(2) do |index|
-      Thread.new do
-        Liquid::TemplateRecorder.record(paths[index]) do
-          ready << true
-          release.pop
-          Liquid::Template.parse("thread={{ value }}").render!("value" => index)
-        end
-      end
-    end
-    2.times { ready.pop }
-    2.times { release << true }
-    threads.each(&:join)
-
-    assert_equal("thread=0", Liquid::TemplateRecorder.records(paths[0]).first["output"])
-    assert_equal("thread=1", Liquid::TemplateRecorder.records(paths[1]).first["output"])
-  end
-
-  def test_nested_sessions_fail_without_corrupting_outer_session
-    error = nil
-    Liquid::TemplateRecorder.record(path) do
-      error = assert_raises(Liquid::TemplateRecorder::Error) do
-        Liquid::TemplateRecorder.record(path("inner.json")) { flunk }
-      end
-      Liquid::Template.parse("outer").render!
-    end
-
-    assert_match(/nested/, error.message)
-    assert_equal("outer", Liquid::TemplateRecorder.replay_from(path).render)
-  end
-
-  def test_supported_render_argument_forms_keep_working
-    filter = Module.new do
-      def decorate(input)
-        "[#{input}]"
-      end
-    end
-    template = nil
-    context = Liquid::Context.new([{ "value" => "context" }])
-
-    Liquid::TemplateRecorder.record(path) do
-      template = Liquid::Template.parse("{{ value | decorate }}")
-      assert_equal("[hash]", template.render({ "value" => "hash" }, filter))
-      context.add_filters(filter)
-      assert_equal("[context]", template.render(context))
-    end
-
-    assert_equal(2, Liquid::TemplateRecorder.records(path).length)
-  end
-
-  def test_strict_replay_uses_exact_recorded_filter_outputs
-    filter = Module.new do
-      def external_lookup(_input)
-        "x" * 150
-      end
-    end
-
-    output = Liquid::TemplateRecorder.record(path) do
-      Liquid::Template.parse("{{ key | external_lookup }}").render!({ "key" => "a" }, filter)
-    end
-
-    assert_equal("x" * 150, output)
-    assert_equal(output, Liquid::TemplateRecorder.replay_from(path, mode: :strict).render)
-    assert_equal("a", Liquid::TemplateRecorder.replay_from(path, mode: :compute).render)
-  end
-
-  def test_jsonl_reader_ignores_only_a_truncated_final_record
-    recording = path("renders.jsonl")
-    Liquid::TemplateRecorder.record(recording) { Liquid::Template.parse("complete").render! }
-    File.open(recording, "ab") { |file| file.write('{"format":') }
-
-    assert_equal(["complete"], Liquid::TemplateRecorder.records(recording).map { |item| item["output"] })
-  end
-
-  def test_accepts_a_pluggable_writer
-    writer = CollectingWriter.new
-
-    output = Liquid::TemplateRecorder.record(writer) do
-      Liquid::Template.parse("Hello {{ name }}").render!("name" => "Shopify")
-    end
-
-    assert_equal("Hello Shopify", output)
-    assert_equal(["Hello Shopify"], writer.records.map { |record| record["output"] })
-  end
-
-  def test_records_only_variables_resolved_by_the_template
-    unused = Object.new
-    assigns = { "visible" => "yes", "unused" => unused }
-
-    Liquid::TemplateRecorder.record(path) do
-      Liquid::Template.parse("{{ visible }}").render!(assigns)
-    end
-
-    assert_equal({ "visible" => "yes" }, Liquid::TemplateRecorder.records(path).first["assigns"])
-  end
-
-  def test_recording_scope_is_fiber_local
-    writer = CollectingWriter.new
-    ordinary_output = nil
-
-    Liquid::TemplateRecorder.record(writer) do
-      Fiber.new do
-        ordinary_output = Liquid::Template.parse("ordinary").render!
-      end.resume
-      Liquid::Template.parse("recorded").render!
-    end
-
-    assert_equal("ordinary", ordinary_output)
-    assert_equal(["recorded"], writer.records.map { |record| record["output"] })
-  end
-
-  def test_on_error_keeps_recording_failures_out_of_the_render_path
-    writer = Object.new
-    writer.define_singleton_method(:write) { |_record| raise "sink unavailable" }
-    errors = []
-
-    output = Liquid::TemplateRecorder.record(writer, on_error: errors.method(:<<)) do
-      Liquid::Template.parse("still rendered").render!
-    end
-
-    assert_equal("still rendered", output)
-    assert_equal(["sink unavailable"], errors.map(&:message))
-  end
-
-  def test_unsupported_accessed_values_do_not_affect_the_render
-    value = UnsupportedLiquidValue.new
-    writer = CollectingWriter.new
-
-    output = Liquid::TemplateRecorder.record(writer) do
-      Liquid::Template.parse("{{ value }}").render!("value" => value)
-    end
-
-    assert_equal(value.to_s, output)
-    assert_equal({}, writer.records.first["assigns"])
-  end
-
-  def test_strict_replay_accepts_the_application_environment
-    environment = Liquid::Environment.build(
-      tags: Liquid::Environment.default.tags.merge("marker" => MarkerTag),
-    )
-    writer = CollectingWriter.new
-    Liquid::TemplateRecorder.record(writer) do
-      Liquid::Template.parse("{% marker %}", environment: environment).render!
-    end
-
-    replay = Liquid::TemplateRecorder::Replayer.new(
-      writer.records.first,
-      mode: :strict,
-      environment: environment,
-    )
-
-    assert_equal("custom", replay.render)
-  end
-
-  def test_captures_file_reads_that_happen_before_the_template_starts_rendering
-    writer = CollectingWriter.new
-    Liquid::TemplateRecorder.record(writer) do
-      Liquid::TemplateRecorder.current.emit_file_read("card", "Card")
-      file_system = LegacyFileSystem.new
-      Liquid::Template.parse("{% render 'card' %}").render!({}, registers: { file_system: file_system })
-    end
-
-    replay = Liquid::TemplateRecorder::Replayer.new(writer.records.first, mode: :strict)
-
-    assert_equal("partial=", replay.render)
-  end
-
-  def test_strict_replay_skips_nested_custom_tag_calls
-    environment = Liquid::Environment.build(
-      tags: Liquid::Environment.default.tags.merge("wrapper" => WrapperTag, "marker" => MarkerTag),
-    )
-    writer = CollectingWriter.new
-    Liquid::TemplateRecorder.record(writer) do
-      Liquid::Template.parse("{% wrapper %}{% marker %}{% endwrapper %}", environment: environment).render!
-    end
-
-    record = writer.records.first
-    replay = Liquid::TemplateRecorder::Replayer.new(record, mode: :strict, environment: environment)
-
-    assert_equal(["wrapper"], record["tag_calls"].map { |call| call["name"] })
-    assert_equal("custom", replay.render)
-  end
-end

test/integration/template_test.rb

@@ -133,7 +133,7 @@ class TemplateTest < Minitest::Test
     assert(t.resource_limits.reached?)
 
     t.resource_limits.render_score_limit = 200
-    assert_equal(" foo " * 100, t.render!)
+    assert_equal((" foo " * 100), t.render!)
     refute_nil(t.resource_limits.render_score)
   end
 
@@ -179,86 +179,6 @@ class TemplateTest < Minitest::Test
     assert_equal("すごい", t.render)
   end
 
-  def test_cumulative_render_score_limit_across_render_tags
-    file_system = StubFileSystem.new(
-      'loop' => '{% for a in (1..10) %} foo {% endfor %}',
-    )
-    environment = Liquid::Environment.build(file_system: file_system)
-
-    # Without cumulative limit, all 5 partials render successfully
-    t = Template.parse(
-      '{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}',
-      environment: environment,
-    )
-    unlimited_output = t.render!
-    total_cumulative = t.resource_limits.cumulative_render_score
-
-    # With cumulative limit set below the total, rendering stops early
-    t2 = Template.parse(
-      '{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}',
-      environment: environment,
-    )
-    t2.resource_limits.cumulative_render_score_limit = total_cumulative / 2
-    limited_output = t2.render
-    assert(t2.resource_limits.reached?)
-    assert_operator(limited_output.length, :<, unlimited_output.length)
-  end
-
-  def test_cumulative_render_score_limit_raises_on_render_bang
-    file_system = StubFileSystem.new(
-      'loop' => '{% for a in (1..10) %} foo {% endfor %}',
-    )
-    environment = Liquid::Environment.build(file_system: file_system)
-    t = Template.parse(
-      '{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}',
-      environment: environment,
-    )
-    t.resource_limits.cumulative_render_score_limit = 20
-    assert_raises(Liquid::MemoryError) do
-      t.render!
-    end
-  end
-
-  def test_cumulative_assign_score_limit_across_include_tags
-    file_system = StubFileSystem.new(
-      'assign_partial' => '{% assign x = "a long string value here" %}',
-    )
-    environment = Liquid::Environment.build(file_system: file_system)
-
-    # Without cumulative limit, all 5 partials render
-    t = Template.parse(
-      '{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}',
-      environment: environment,
-    )
-    t.render!
-    total_cumulative = t.resource_limits.cumulative_assign_score
-
-    # With cumulative limit set below the total, rendering stops early
-    t2 = Template.parse(
-      '{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}',
-      environment: environment,
-    )
-    t2.resource_limits.cumulative_assign_score_limit = total_cumulative / 2
-    t2.render
-    assert(t2.resource_limits.reached?)
-  end
-
-  def test_cumulative_render_score_tracks_across_partials_without_limit
-    file_system = StubFileSystem.new(
-      'loop' => '{% for a in (1..10) %} foo {% endfor %}',
-    )
-    environment = Liquid::Environment.build(file_system: file_system)
-    t = Template.parse(
-      '{% render "loop" %}{% render "loop" %}{% render "loop" %}',
-      environment: environment,
-    )
-    t.render!
-    assert(
-      t.resource_limits.cumulative_render_score > t.resource_limits.render_score,
-      "cumulative should exceed per-template score after multiple partials",
-    )
-  end
-
   def test_default_resource_limits_unaffected_by_render_with_context
     context = Context.new
     t = Template.parse("{% for a in (1..100) %}x{% assign foo = 1 %} {% endfor %}")

test/integration/variable_test.rb

@@ -55,7 +55,7 @@ class VariableTest < Minitest::Test
 
   def test_expression_with_whitespace_in_square_brackets
     assert_template_result('result', "{{ a[ 'b' ] }}", { 'a' => { 'b' => 'result' } })
-    assert_template_result('result', "{{ a[ self[ 'b' ] ] }}", { 'b' => 'c', 'a' => { 'c' => 'result' } })
+    assert_template_result('result', "{{ a[ [ 'b' ] ] }}", { 'b' => 'c', 'a' => { 'c' => 'result' } })
   end
 
   def test_ignore_unknown
@@ -135,17 +135,17 @@ class VariableTest < Minitest::Test
   end
 
   def test_dynamic_find_var
-    assert_template_result('bar', '{{ self[key] }}', { 'key' => 'foo', 'foo' => 'bar' })
+    assert_template_result('bar', '{{ [key] }}', { 'key' => 'foo', 'foo' => 'bar' })
   end
 
   def test_raw_value_variable
-    assert_template_result('bar', '{{ self[key] }}', { 'key' => 'foo', 'foo' => 'bar' })
+    assert_template_result('bar', '{{ [key] }}', { 'key' => 'foo', 'foo' => 'bar' })
   end
 
   def test_dynamic_find_var_with_drop
     assert_template_result(
       'bar',
-      '{{ self[list[settings.zero]] }}',
+      '{{ [list[settings.zero]] }}',
       {
         'list' => ['foo'],
         'settings' => SettingsDrop.new("zero" => 0),
@@ -155,7 +155,7 @@ class VariableTest < Minitest::Test
 
     assert_template_result(
       'foo',
-      '{{ self[list[settings.zero]["foo"]] }}',
+      '{{ [list[settings.zero]["foo"]] }}',
       {
         'list' => [{ 'foo' => 'bar' }],
         'settings' => SettingsDrop.new("zero" => 0),
@@ -209,69 +209,4 @@ class VariableTest < Minitest::Test
       end
     end
   end
-
-  def test_filter_with_single_trailing_comma
-    template = '{{ "hello" | append: "world", }}'
-
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('helloworld', template)
-    end
-  end
-
-  def test_multiple_filters_with_trailing_commas
-    template = '{{ "hello" | append: "1", | append: "2", }}'
-
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('hello12', template)
-    end
-  end
-
-  def test_filter_with_colon_but_no_arguments
-    template = '{{ "test" | upcase: }}'
-
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('TEST', template)
-    end
-  end
-
-  def test_filter_chain_with_colon_no_args
-    template = '{{ "test" | append: "x" | upcase: }}'
-
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('TESTX', template)
-    end
-  end
-
-  def test_combining_trailing_comma_and_empty_args
-    template = '{{ "test" | append: "x", | upcase: }}'
-
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('TESTX', template)
-    end
-  end
 end

test/test_helper.rb

@@ -34,7 +34,7 @@ module Minitest
 
     def assert_template_result(
       expected, template, assigns = {},
-      message: nil, partials: nil, error_mode: Liquid::Environment.default.error_mode, render_errors: false,
+      message: nil, partials: nil, error_mode: nil, render_errors: false,
       template_factory: nil
     )
       file_system = StubFileSystem.new(partials || {})
@@ -82,12 +82,10 @@ module Minitest
       Environment.dangerously_override(environment, &blk)
     end
 
-    def with_error_modes(*modes)
+    def with_error_mode(mode)
       old_mode = Liquid::Environment.default.error_mode
-      modes.each do |mode|
-        Liquid::Environment.default.error_mode = mode
-        yield
-      end
+      Liquid::Environment.default.error_mode = mode
+      yield
     ensure
       Liquid::Environment.default.error_mode = old_mode
     end
@@ -148,35 +146,6 @@ class BooleanDrop < Liquid::Drop
   end
 end
 
-class StringDrop < Liquid::Drop
-  include Comparable
-
-  def initialize(value)
-    super()
-    @value = value
-  end
-
-  def to_liquid_value
-    @value
-  end
-
-  def to_s
-    @value
-  end
-
-  def to_str
-    @value
-  end
-
-  def inspect
-    "#<StringDrop @value=#{@value.inspect}>"
-  end
-
-  def <=>(other)
-    to_liquid_value <=> Liquid::Utils.to_liquid_value(other)
-  end
-end
-
 class ErrorDrop < Liquid::Drop
   def standard_error
     raise Liquid::StandardError, 'standard error'
@@ -199,26 +168,6 @@ class ErrorDrop < Liquid::Drop
   end
 end
 
-class CustomToLiquidDrop < Liquid::Drop
-  def initialize(value)
-    @value = value
-    super()
-  end
-
-  def to_liquid
-    @value
-  end
-end
-
-class HashWithCustomToS < Hash
-  def to_s
-    "kewl"
-  end
-end
-
-class HashWithoutCustomToS < Hash
-end
-
 class StubFileSystem
   attr_reader :file_read_count
 

test/unit/condition_unit_test.rb

@@ -161,208 +161,11 @@ class ConditionUnitTest < Minitest::Test
       assert_equal(true, Condition.new(1, '==', 1).evaluate)
     end
 
-    expected = "DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated " \
-      "and will be removed from Liquid 6.0.0."
+    expected = "DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \
+      " and will be removed from Liquid 6.0.0."
     assert_includes(err.lines.map(&:strip), expected)
   end
 
-  def test_parse_expression_in_strict_mode
-    environment = Environment.build(error_mode: :strict)
-    parse_context = ParseContext.new(environment: environment)
-    result = Condition.parse_expression(parse_context, 'product.title')
-
-    assert_instance_of(VariableLookup, result)
-    assert_equal('product', result.name)
-    assert_equal(['title'], result.lookups)
-  end
-
-  def test_parse_expression_in_strict2_mode_raises_internal_error
-    environment = Environment.build(error_mode: :strict2)
-    parse_context = ParseContext.new(environment: environment)
-
-    error = assert_raises(Liquid::InternalError) do
-      Condition.parse_expression(parse_context, 'product.title')
-    end
-
-    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
-  end
-
-  def test_parse_expression_with_safe_true_in_strict2_mode
-    environment = Environment.build(error_mode: :strict2)
-    parse_context = ParseContext.new(environment: environment)
-    result = Condition.parse_expression(parse_context, 'product.title', safe: true)
-
-    assert_instance_of(VariableLookup, result)
-    assert_equal('product', result.name)
-    assert_equal(['title'], result.lookups)
-  end
-
-  # Tests for blank? comparison without ActiveSupport
-  #
-  # Ruby's standard library does not include blank? on String, Array, Hash, etc.
-  # ActiveSupport adds blank? but Liquid must work without it. These tests verify
-  # that Liquid implements blank? semantics internally for use in templates like:
-  #   {% if x == blank %}...{% endif %}
-  #
-  # The blank? semantics match ActiveSupport's behavior:
-  # - nil and false are blank
-  # - Strings are blank if empty or contain only whitespace
-  # - Arrays and Hashes are blank if empty
-  # - true and numbers are never blank
-
-  def test_blank_with_whitespace_string
-    # Template authors expect "   " to be blank since it has no visible content.
-    # This matches ActiveSupport's String#blank? which returns true for whitespace-only strings.
-    @context['whitespace'] = '   '
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_true(VariableLookup.new('whitespace'), '==', blank_literal)
-  end
-
-  def test_blank_with_empty_string
-    # An empty string has no content, so it should be considered blank.
-    # This is the most basic case of a blank string.
-    @context['empty_string'] = ''
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_true(VariableLookup.new('empty_string'), '==', blank_literal)
-  end
-
-  def test_blank_with_empty_array
-    # Empty arrays have no elements, so they are blank.
-    # Useful for checking if a collection has items: {% if products == blank %}
-    @context['empty_array'] = []
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_true(VariableLookup.new('empty_array'), '==', blank_literal)
-  end
-
-  def test_blank_with_empty_hash
-    # Empty hashes have no key-value pairs, so they are blank.
-    # Useful for checking if settings/options exist: {% if settings == blank %}
-    @context['empty_hash'] = {}
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_true(VariableLookup.new('empty_hash'), '==', blank_literal)
-  end
-
-  def test_blank_with_nil
-    # nil represents "nothing" and is the canonical blank value.
-    # Unassigned variables resolve to nil, so this enables: {% if missing_var == blank %}
-    @context['nil_value'] = nil
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_true(VariableLookup.new('nil_value'), '==', blank_literal)
-  end
-
-  def test_blank_with_false
-    # false is considered blank to match ActiveSupport semantics.
-    # This allows {% if some_flag == blank %} to work when flag is false.
-    @context['false_value'] = false
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_true(VariableLookup.new('false_value'), '==', blank_literal)
-  end
-
-  def test_not_blank_with_true
-    # true is a definite value, not blank.
-    # Ensures {% if flag == blank %} works correctly for boolean flags.
-    @context['true_value'] = true
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_false(VariableLookup.new('true_value'), '==', blank_literal)
-  end
-
-  def test_not_blank_with_number
-    # Numbers (including zero) are never blank - they represent actual values.
-    # 0 is a valid quantity, not the absence of a value.
-    @context['number'] = 42
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_false(VariableLookup.new('number'), '==', blank_literal)
-  end
-
-  def test_not_blank_with_string_content
-    # A string with actual content is not blank.
-    # This is the expected behavior for most template string comparisons.
-    @context['string'] = 'hello'
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_false(VariableLookup.new('string'), '==', blank_literal)
-  end
-
-  def test_not_blank_with_non_empty_array
-    # An array with elements has content, so it's not blank.
-    # Enables patterns like {% unless products == blank %}Show products{% endunless %}
-    @context['array'] = [1, 2, 3]
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_false(VariableLookup.new('array'), '==', blank_literal)
-  end
-
-  def test_not_blank_with_non_empty_hash
-    # A hash with key-value pairs has content, so it's not blank.
-    # Useful for checking if configuration exists: {% if config != blank %}
-    @context['hash'] = { 'a' => 1 }
-    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
-
-    assert_evaluates_false(VariableLookup.new('hash'), '==', blank_literal)
-  end
-
-  # Tests for empty? comparison without ActiveSupport
-  #
-  # empty? is distinct from blank? - it only checks if a collection has zero elements.
-  # For strings, empty? checks length == 0, NOT whitespace content.
-  # Ruby's standard library has empty? on String, Array, and Hash, but Liquid
-  # provides a fallback implementation for consistency.
-
-  def test_empty_with_empty_string
-    # An empty string ("") has length 0, so it's empty.
-    # Different from blank - empty is a stricter check.
-    @context['empty_string'] = ''
-    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
-
-    assert_evaluates_true(VariableLookup.new('empty_string'), '==', empty_literal)
-  end
-
-  def test_empty_with_whitespace_string_not_empty
-    # Whitespace strings have length > 0, so they are NOT empty.
-    # This is the key difference between empty and blank:
-    # "   ".empty? => false, but "   ".blank? => true
-    @context['whitespace'] = '   '
-    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
-
-    assert_evaluates_false(VariableLookup.new('whitespace'), '==', empty_literal)
-  end
-
-  def test_empty_with_empty_array
-    # An array with no elements is empty.
-    # [].empty? => true
-    @context['empty_array'] = []
-    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
-
-    assert_evaluates_true(VariableLookup.new('empty_array'), '==', empty_literal)
-  end
-
-  def test_empty_with_empty_hash
-    # A hash with no key-value pairs is empty.
-    # {}.empty? => true
-    @context['empty_hash'] = {}
-    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
-
-    assert_evaluates_true(VariableLookup.new('empty_hash'), '==', empty_literal)
-  end
-
-  def test_nil_is_not_empty
-    # nil is NOT empty - empty? checks if a collection has zero elements.
-    # nil is not a collection, so it cannot be empty.
-    # This differs from blank: nil IS blank, but nil is NOT empty.
-    @context['nil_value'] = nil
-    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
-
-    assert_evaluates_false(VariableLookup.new('nil_value'), '==', empty_literal)
-  end
-
   private
 
   def assert_evaluates_true(left, op, right)

test/unit/environment_test.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class EnvironmentTest < Minitest::Test
-  include Liquid
-
-  class UnsubscribeFooter < Liquid::Tag
-    def render(_context)
-      'Unsubscribe Footer'
-    end
-  end
-
-  def test_custom_tag
-    email_environment = Liquid::Environment.build do |environment|
-      environment.register_tag("unsubscribe_footer", UnsubscribeFooter)
-    end
-
-    assert(email_environment.tags["unsubscribe_footer"])
-    assert(email_environment.tag_for_name("unsubscribe_footer"))
-    template = Liquid::Template.parse("{% unsubscribe_footer %}", environment: email_environment)
-
-    assert_equal('Unsubscribe Footer', template.render)
-  end
-end

test/unit/infix_operators_unit_test.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class InfixOperatorsUnitTest < Minitest::Test
+  include Liquid
+
+  def test_addition_operator
+    # Filter syntax
+    filter_template = Liquid::Template.parse("{{ num | plus: 3 }}")
+    # Infix syntax
+    infix_template = Liquid::Template.parse("{{ num + 3 }}")
+
+    assert_equal(filter_template.render("num" => 5), infix_template.render("num" => 5))
+    assert_equal("8", infix_template.render("num" => 5))
+  end
+
+  def test_subtraction_operator
+    # Filter syntax
+    filter_template = Liquid::Template.parse("{{ num | minus: 3 }}")
+    # Infix syntax
+    infix_template = Liquid::Template.parse("{{ num - 3 }}")
+
+    assert_equal(filter_template.render("num" => 5), infix_template.render("num" => 5))
+    assert_equal("2", infix_template.render("num" => 5))
+  end
+
+  def test_multiplication_operator
+    # Filter syntax
+    filter_template = Liquid::Template.parse("{{ num | times: 3 }}")
+    # Infix syntax
+    infix_template = Liquid::Template.parse("{{ num * 3 }}")
+
+    assert_equal(filter_template.render("num" => 5), infix_template.render("num" => 5))
+    assert_equal("15", infix_template.render("num" => 5))
+  end
+
+  def test_division_operator
+    # Filter syntax
+    filter_template = Liquid::Template.parse("{{ num | divided_by: 2 }}")
+    # Infix syntax
+    infix_template = Liquid::Template.parse("{{ num / 2 }}")
+
+    assert_equal(filter_template.render("num" => 10), infix_template.render("num" => 10))
+    assert_equal("5", infix_template.render("num" => 10))
+  end
+
+  def test_comparison_operators
+    # Greater than
+    assert_equal("true", Liquid::Template.parse("{{ 5 > 3 }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ 3 > 5 }}").render)
+
+    # Greater than or equal
+    assert_equal("true", Liquid::Template.parse("{{ 5 >= 5 }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ 3 >= 5 }}").render)
+
+    # Equal to
+    assert_equal("true", Liquid::Template.parse("{{ 5 == 5 }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ 3 == 5 }}").render)
+
+    # Less than or equal
+    assert_equal("true", Liquid::Template.parse("{{ 5 <= 5 }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ 6 <= 5 }}").render)
+
+    # Less than
+    assert_equal("true", Liquid::Template.parse("{{ 3 < 5 }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ 5 < 3 }}").render)
+  end
+
+  def test_logical_operators
+    # AND operator
+    assert_equal("true", Liquid::Template.parse("{{ true && true }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ true && false }}").render)
+
+    # OR operator
+    assert_equal("true", Liquid::Template.parse("{{ true || false }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ false || false }}").render)
+  end
+
+  def test_xor_operator
+    assert_equal("true", Liquid::Template.parse("{{ true ^ false }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ true ^ true }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ false ^ false }}").render)
+  end
+
+  def test_operator_precedence
+    # (10 - 2) * 3 = 24
+    assert_equal("24", Liquid::Template.parse("{{ (10 - 2) * 3 }}").render)
+    # 10 - (2 * 3) = 4
+    assert_equal("4", Liquid::Template.parse("{{ 10 - (2 * 3) }}").render)
+    # Without parentheses, multiplication has higher precedence
+    # 10 - 2 * 3 = 10 - 6 = 4
+    assert_equal("4", Liquid::Template.parse("{{ 10 - 2 * 3 }}").render)
+  end
+
+  def test_complex_expressions
+    # Multiple operations
+    assert_equal("9", Liquid::Template.parse("{{ 3 + 2 * 3 }}").render)
+    assert_equal("15", Liquid::Template.parse("{{ (3 + 2) * 3 }}").render)
+
+    # Mixed arithmetic and comparison
+    assert_equal("true", Liquid::Template.parse("{{ 3 + 2 > 4 }}").render)
+    assert_equal("false", Liquid::Template.parse("{{ 3 + 2 < 4 }}").render)
+
+    # Mixed arithmetic and logical
+    assert_equal("true", Liquid::Template.parse("{{ 3 + 2 > 4 && 10 / 2 == 5 }}").render)
+  end
+
+  def test_combined_operations
+    # In the proposed example
+    infix_template = Liquid::Template.parse("{% assign media_count = media_count - variant_images.size + 1 %}")
+    filter_template = Liquid::Template.parse("{% assign media_count = media_count | minus: variant_images.size | plus: 1 %}")
+
+    # Check that both templates have the same effect
+    context1 = Context.new("media_count" => 10, "variant_images" => [1, 2, 3])
+    context2 = Context.new("media_count" => 10, "variant_images" => [1, 2, 3])
+
+    infix_template.render(context1)
+    filter_template.render(context2)
+
+    assert_equal(context1["media_count"], context2["media_count"])
+    assert_equal(8, context1["media_count"])
+  end
+
+  def test_with_variables
+    template = Liquid::Template.parse("{{ a + b * c }}")
+    assert_equal("11", template.render("a" => 5, "b" => 2, "c" => 3))
+
+    template = Liquid::Template.parse("{{ (a + b) * c }}")
+    assert_equal("21", template.render("a" => 5, "b" => 2, "c" => 3))
+  end
+
+  def test_chained_comparisons
+    template = Liquid::Template.parse("{{ a < b && b < c }}")
+    assert_equal("true", template.render("a" => 1, "b" => 5, "c" => 10))
+    assert_equal("false", template.render("a" => 1, "b" => 15, "c" => 10))
+  end
+end

test/unit/parse_context_unit_test.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ParseContextUnitTest < Minitest::Test
-  include Liquid
-
-  def test_safe_parse_expression_with_variable_lookup
-    parser_strict = strict_parse_context.new_parser('product.title')
-    result_strict = strict_parse_context.safe_parse_expression(parser_strict)
-
-    parser_strict2 = strict2_parse_context.new_parser('product.title')
-    result_strict2 = strict2_parse_context.safe_parse_expression(parser_strict2)
-
-    assert_instance_of(VariableLookup, result_strict)
-    assert_equal('product', result_strict.name)
-    assert_equal(['title'], result_strict.lookups)
-
-    assert_instance_of(VariableLookup, result_strict2)
-    assert_equal('product', result_strict2.name)
-    assert_equal(['title'], result_strict2.lookups)
-  end
-
-  def test_safe_parse_expression_raises_syntax_error_for_invalid_expression
-    parser_strict = strict_parse_context.new_parser('')
-    parser_strict2 = strict2_parse_context.new_parser('')
-
-    error_strict = assert_raises(Liquid::SyntaxError) do
-      strict_parse_context.safe_parse_expression(parser_strict)
-    end
-    assert_match(/is not a valid expression/, error_strict.message)
-
-    error_strict2 = assert_raises(Liquid::SyntaxError) do
-      strict2_parse_context.safe_parse_expression(parser_strict2)
-    end
-
-    assert_match(/is not a valid expression/, error_strict2.message)
-  end
-
-  def test_parse_expression_with_variable_lookup
-    result_strict = strict_parse_context.parse_expression('product.title')
-
-    assert_instance_of(VariableLookup, result_strict)
-    assert_equal('product', result_strict.name)
-    assert_equal(['title'], result_strict.lookups)
-
-    error = assert_raises(Liquid::InternalError) do
-      strict2_parse_context.parse_expression('product.title')
-    end
-
-    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
-  end
-
-  def test_parse_expression_with_safe_true
-    result_strict = strict_parse_context.parse_expression('product.title', safe: true)
-
-    assert_instance_of(VariableLookup, result_strict)
-    assert_equal('product', result_strict.name)
-    assert_equal(['title'], result_strict.lookups)
-
-    result_strict2 = strict2_parse_context.parse_expression('product.title', safe: true)
-
-    assert_instance_of(VariableLookup, result_strict2)
-    assert_equal('product', result_strict2.name)
-    assert_equal(['title'], result_strict2.lookups)
-  end
-
-  def test_parse_expression_with_empty_string
-    result_strict = strict_parse_context.parse_expression('')
-    assert_nil(result_strict)
-
-    error = assert_raises(Liquid::InternalError) do
-      strict2_parse_context.parse_expression('')
-    end
-
-    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
-  end
-
-  def test_parse_expression_with_empty_string_and_safe_true
-    result_strict = strict_parse_context.parse_expression('', safe: true)
-    assert_nil(result_strict)
-
-    result_strict2 = strict2_parse_context.parse_expression('', safe: true)
-    assert_nil(result_strict2)
-  end
-
-  def test_safe_parse_expression_advances_parser_pointer
-    parser = strict2_parse_context.new_parser('foo, bar')
-
-    # safe_parse_expression consumes "foo"
-    first_result = strict2_parse_context.safe_parse_expression(parser)
-    assert_instance_of(VariableLookup, first_result)
-    assert_equal('foo', first_result.name)
-
-    parser.consume(:comma)
-
-    # safe_parse_expression consumes "bar"
-    second_result = strict2_parse_context.safe_parse_expression(parser)
-    assert_instance_of(VariableLookup, second_result)
-    assert_equal('bar', second_result.name)
-
-    parser.consume(:end_of_string)
-  end
-
-  def test_parse_expression_with_whitespace_in_strict2_mode
-    result = strict2_parse_context.parse_expression('   ', safe: true)
-    assert_nil(result)
-  end
-
-  private
-
-  def strict_parse_context
-    @strict_parse_context ||= ParseContext.new(
-      environment: Environment.build(error_mode: :strict),
-    )
-  end
-
-  def strict2_parse_context
-    @strict2_parse_context ||= ParseContext.new(
-      environment: Environment.build(error_mode: :strict2),
-    )
-  end
-end

test/unit/partial_cache_unit_test.rb

@@ -184,7 +184,7 @@ class PartialCacheUnitTest < Minitest::Test
       },
     )
 
-    [:lax, :warn, :strict, :strict2].each do |error_mode|
+    [:lax, :warn, :strict].each do |error_mode|
       Liquid::PartialCache.load(
         'my_partial',
         context: context,
@@ -193,7 +193,7 @@ class PartialCacheUnitTest < Minitest::Test
     end
 
     assert_equal(
-      ["my_partial:lax", "my_partial:warn", "my_partial:strict", "my_partial:strict2"],
+      ["my_partial:lax", "my_partial:warn", "my_partial:strict"],
       context.registers[:cached_partials].keys,
     )
   end

test/unit/resource_limits_unit_test.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ResourceLimitsUnitTest < Minitest::Test
-  def test_cumulative_scores_initialize_to_zero
-    limits = Liquid::ResourceLimits.new({})
-    assert_equal(0, limits.cumulative_render_score)
-    assert_equal(0, limits.cumulative_assign_score)
-  end
-
-  def test_cumulative_limits_default_to_nil
-    limits = Liquid::ResourceLimits.new({})
-    assert_nil(limits.cumulative_render_score_limit)
-    assert_nil(limits.cumulative_assign_score_limit)
-  end
-
-  def test_cumulative_limits_configurable_via_hash
-    limits = Liquid::ResourceLimits.new(
-      cumulative_render_score_limit: 500,
-      cumulative_assign_score_limit: 300,
-    )
-    assert_equal(500, limits.cumulative_render_score_limit)
-    assert_equal(300, limits.cumulative_assign_score_limit)
-  end
-
-  def test_cumulative_limits_configurable_via_accessor
-    limits = Liquid::ResourceLimits.new({})
-    limits.cumulative_render_score_limit = 500
-    assert_equal(500, limits.cumulative_render_score_limit)
-  end
-
-  def test_cumulative_scores_survive_reset
-    limits = Liquid::ResourceLimits.new({})
-    limits.increment_render_score(10)
-    limits.increment_assign_score(5)
-
-    limits.reset
-
-    assert_equal(0, limits.render_score)
-    assert_equal(0, limits.assign_score)
-    assert_equal(10, limits.cumulative_render_score)
-    assert_equal(5, limits.cumulative_assign_score)
-  end
-
-  def test_cumulative_scores_accumulate_across_resets
-    limits = Liquid::ResourceLimits.new({})
-    limits.increment_render_score(10)
-    limits.reset
-    limits.increment_render_score(20)
-    limits.reset
-    limits.increment_render_score(30)
-
-    assert_equal(30, limits.render_score)
-    assert_equal(60, limits.cumulative_render_score)
-  end
-
-  def test_cumulative_render_score_limit_raises
-    limits = Liquid::ResourceLimits.new(cumulative_render_score_limit: 25)
-    limits.increment_render_score(10)
-    limits.reset
-    limits.increment_render_score(10)
-    limits.reset
-
-    assert_raises(Liquid::MemoryError) do
-      limits.increment_render_score(10)
-    end
-    assert(limits.reached?)
-  end
-
-  def test_cumulative_assign_score_limit_raises
-    limits = Liquid::ResourceLimits.new(cumulative_assign_score_limit: 15)
-    limits.increment_assign_score(8)
-    limits.reset
-
-    assert_raises(Liquid::MemoryError) do
-      limits.increment_assign_score(8)
-    end
-    assert(limits.reached?)
-  end
-
-  def test_per_template_limits_still_work_with_cumulative
-    limits = Liquid::ResourceLimits.new(
-      render_score_limit: 50,
-      cumulative_render_score_limit: 1000,
-    )
-    assert_raises(Liquid::MemoryError) do
-      limits.increment_render_score(51)
-    end
-  end
-end

test/unit/strainer_template_unit_test.rb

@@ -8,7 +8,7 @@ class StrainerTemplateUnitTest < Minitest::Test
   def test_add_filter_when_wrong_filter_class
     c = Context.new
     s = c.strainer
-    wrong_filter = lambda(&:reverse)
+    wrong_filter = ->(v) { v.reverse }
 
     exception = assert_raises(TypeError) do
       s.class.add_filter(wrong_filter)

test/unit/tags/case_tag_unit_test.rb

@@ -9,140 +9,4 @@ class CaseTagUnitTest < Minitest::Test
     template = Liquid::Template.parse('{% case var %}{% when true %}WHEN{% else %}ELSE{% endcase %}')
     assert_equal(['WHEN', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten)
   end
-
-  def test_case_with_trailing_element
-    template = <<~LIQUID
-      {%- case 1 bar -%}
-        {%- when 1 -%}
-          one
-        {%- else -%}
-          two
-      {%- endcase -%}
-    LIQUID
-
-    with_error_modes(:lax, :strict) do
-      assert_template_result("one", template)
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-
-      assert_match(/Expected end_of_string but found/, error.message)
-    end
-  end
-
-  def test_case_when_with_trailing_element
-    template = <<~LIQUID
-      {%- case 1 -%}
-        {%- when 1 bar -%}
-          one
-        {%- else -%}
-          two
-      {%- endcase -%}
-    LIQUID
-
-    with_error_modes(:lax, :strict) do
-      assert_template_result("one", template)
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-
-      assert_match(/Expected end_of_string but found/, error.message)
-    end
-  end
-
-  def test_case_when_with_comma
-    template = <<~LIQUID
-      {%- case 1 -%}
-        {%- when 2, 1 -%}
-          one
-        {%- else -%}
-          two
-      {%- endcase -%}
-    LIQUID
-
-    with_error_modes(:lax, :strict, :strict2) do
-      assert_template_result("one", template)
-    end
-  end
-
-  def test_case_when_with_or
-    template = <<~LIQUID
-      {%- case 1 -%}
-        {%- when 2 or 1 -%}
-          one
-        {%- else -%}
-          two
-      {%- endcase -%}
-    LIQUID
-
-    with_error_modes(:lax, :strict, :strict2) do
-      assert_template_result("one", template)
-    end
-  end
-
-  def test_case_when_empty
-    template = <<~LIQUID
-      {%- case x -%}
-        {%- when 2 or empty -%}
-          2 or empty
-        {%- else -%}
-          not 2 or empty
-      {%- endcase -%}
-    LIQUID
-
-    with_error_modes(:lax, :strict, :strict2) do
-      assert_template_result("2 or empty", template, { 'x' => 2 })
-      assert_template_result("2 or empty", template, { 'x' => {} })
-      assert_template_result("2 or empty", template, { 'x' => [] })
-      assert_template_result("not 2 or empty", template, { 'x' => { 'a' => 'b' } })
-      assert_template_result("not 2 or empty", template, { 'x' => ['a'] })
-      assert_template_result("not 2 or empty", template, { 'x' => 4 })
-    end
-  end
-
-  def test_case_with_invalid_expression
-    template = <<~LIQUID
-      {%- case foo=>bar -%}
-        {%- when 'baz' -%}
-          one
-        {%- else -%}
-          two
-      {%- endcase -%}
-    LIQUID
-    assigns = { 'foo' => { 'bar' => 'baz' } }
-
-    with_error_modes(:lax, :strict) do
-      assert_template_result("one", template, assigns)
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
-
-  def test_case_when_with_invalid_expression
-    template = <<~LIQUID
-      {%- case 'baz' -%}
-        {%- when foo=>bar -%}
-          one
-        {%- else -%}
-          two
-      {%- endcase -%}
-    LIQUID
-    assigns = { 'foo' => { 'bar' => 'baz' } }
-
-    with_error_modes(:lax, :strict) do
-      assert_template_result("one", template, assigns)
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
 end

test/unit/tags/doc_tag_unit_test.rb

@@ -20,21 +20,6 @@ class DocTagUnitTest < Minitest::Test
     assert_template_result('', template)
   end
 
-  def test_doc_tag_body_content
-    doc_content = "  Documentation content\n  @param {string} foo - test\n"
-    template_source = "{% doc %}#{doc_content}{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal(doc_content, doc_tag.nodelist.first.to_s)
-  end
-
   def test_doc_tag_does_not_support_extra_arguments
     error = assert_raises(Liquid::SyntaxError) do
       template = <<~LIQUID.chomp
@@ -131,20 +116,6 @@ class DocTagUnitTest < Minitest::Test
     assert_template_result('', template)
   end
 
-  def test_doc_tag_captures_token_before_enddoc
-    template_source = "{% doc %}{{ incomplete{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal("{{ incomplete", doc_tag.nodelist.first.to_s)
-  end
-
   def test_doc_tag_preserves_error_line_numbers
     template = Liquid::Template.parse(<<~LIQUID.chomp, line_numbers: true)
       {% doc %}
@@ -174,11 +145,11 @@ class DocTagUnitTest < Minitest::Test
 
   def test_doc_tag_delimiter_handling
     assert_template_result('', <<~LIQUID.chomp)
-      {%- if true -%}
-        {%- doc -%}
-          {%- docEXTRA -%}wut{% enddocEXTRA -%}xyz
-        {%- enddoc -%}
-      {%- endif -%}
+      {% if true %}
+        {% doc %}
+          {% docEXTRA %}wut{% enddocEXTRA %}xyz
+        {% enddoc %}
+      {% endif %}
     LIQUID
 
     assert_template_result('', "{% doc %}123{% enddoc xyz %}")
@@ -196,80 +167,6 @@ class DocTagUnitTest < Minitest::Test
     )
   end
 
-  def test_doc_tag_blank_with_empty_content
-    template_source = "{% doc %}{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal(true, doc_tag.blank?)
-  end
-
-  def test_doc_tag_blank_with_content
-    template_source = "{% doc %}Some documentation{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal(false, doc_tag.blank?)
-  end
-
-  def test_doc_tag_blank_with_whitespace_only
-    template_source = "{% doc %}    {% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal(false, doc_tag.blank?)
-  end
-
-  def test_doc_tag_nodelist_returns_array_with_body
-    doc_content = "Documentation content\n@param {string} foo"
-    template_source = "{% doc %}#{doc_content}{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal([doc_content], doc_tag.nodelist)
-    assert_equal(1, doc_tag.nodelist.length)
-    assert_equal(doc_content, doc_tag.nodelist.first)
-  end
-
-  def test_doc_tag_nodelist_with_empty_content
-    template_source = "{% doc %}{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal([""], doc_tag.nodelist)
-    assert_equal(1, doc_tag.nodelist.length)
-  end
-
   private
 
   def traversal(template)

test/unit/variable_unit_test.rb

@@ -108,7 +108,7 @@ class VariableUnitTest < Minitest::Test
     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_modes(:strict) do
+    with_error_mode(:strict) do
       assert_raises(Liquid::SyntaxError) { create_variable('foo - bar') }
       assert_raises(Liquid::SyntaxError) { create_variable('-foo') }
       assert_raises(Liquid::SyntaxError) { create_variable('2foo') }
@@ -135,68 +135,16 @@ class VariableUnitTest < Minitest::Test
     var = create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ), error_mode: :lax)
     assert_equal(VariableLookup.new('number_of_comments'), var.name)
     assert_equal([['pluralize', ['comment', 'comments']]], var.filters)
-
-    # missing does not throws error
-    create_variable(%(n | f1: ,), error_mode: :lax)
-    create_variable(%(n | f1: ,| f2), error_mode: :lax)
-
-    # arg does not require colon, but ignores args :O, also ignores first kwarg since it splits on ':'
-    var = create_variable(%(n | f1 1 | f2 k1: v1), error_mode: :lax)
-    assert_equal([['f1', []], ['f2', [VariableLookup.new('v1')]]], var.filters)
-
-    # positional and kwargs parsing
-    var = create_variable(%(n | filter: 1, 2, 3 | filter2: k1: 1, k2: 2), error_mode: :lax)
-    assert_equal([['filter', [1, 2, 3]], ['filter2', [], { "k1" => 1, "k2" => 2 }]], var.filters)
-
-    # positional and kwargs intermixed (pos1, key1: val1, pos2)
-    var = create_variable(%(n | link_to: class: "black", "https://example.com", title: "title"), error_mode: :lax)
-    assert_equal([['link_to', ["https://example.com"], { "class" => "black", "title" => "title" }]], var.filters)
   end
 
   def test_strict_filter_argument_parsing
-    with_error_modes(:strict) do
+    with_error_mode(:strict) do
       assert_raises(SyntaxError) do
         create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ))
       end
     end
   end
 
-  def test_strict2_filter_argument_parsing
-    with_error_modes(:strict2) do
-      # optional colon
-      var = create_variable(%(n | f1 | f2:))
-      assert_equal([['f1', []], ['f2', []]], var.filters)
-
-      # missing argument throws error
-      assert_raises(SyntaxError) { create_variable(%(n | f1: ,)) }
-      assert_raises(SyntaxError) { create_variable(%(n | f1: ,| f2)) }
-
-      # arg requires colon
-      assert_raises(SyntaxError) { create_variable(%(n | f1 1)) }
-
-      # trailing comma doesn't throw
-      create_variable(%(n | f1: 1, 2, 3, | f2:))
-
-      # missing comma throws error
-      assert_raises(SyntaxError) { create_variable(%(n | filter: 1 2, 3)) }
-
-      # positional and kwargs parsing
-      var = create_variable(%(n | filter: 1, 2, 3 | filter2: k1: 1, k2: 2))
-      assert_equal([['filter', [1, 2, 3]], ['filter2', [], { "k1" => 1, "k2" => 2 }]], var.filters)
-
-      # positional and kwargs mixed
-      var = create_variable(%(n | filter: 'a', 'b', key1: 1, key2: 2, 'c'))
-      assert_equal([["filter", ["a", "b", "c"], { "key1" => 1, "key2" => 2 }]], var.filters)
-
-      # positional and kwargs intermixed (pos1, key1: val1, pos2)
-      var = create_variable(%(n | link_to: class: "black", "https://example.com", title: "title"))
-      assert_equal([['link_to', ["https://example.com"], { "class" => "black", "title" => "title" }]], var.filters)
-
-      # string key throws
-      assert_raises(SyntaxError) { create_variable(%(n | pluralize: 'comment': 'comments')) }
-    end
-  end
-
   def test_output_raw_source_of_variable
     var = create_variable(%( name_of_variable | upcase ))
     assert_equal(" name_of_variable | upcase ", var.raw)