Update resource limit handling

This commit aligns snippet tag's resource limit handling with assign tag's `assign_score_of` method where the snippet variable acts as a pointer to a block body - increasing assign score by one
Ensure render tag checks for most common type first
2026-09-29 23:25:14 -07:00 · 2025-11-04 14:53:08 -07:00 · 2025-11-04 13:11:18 -07:00
77 changed files with 1448 additions and 2041 deletions
@@ -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: ruby/setup-ruby@dffc446db9ba5a0c4446edb5bca1c5c473a806c5 # v1.235.0
        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: ruby/setup-ruby@dffc446db9ba5a0c4446edb5bca1c5c473a806c5 # v1.235.0
        with:
          bundler-cache: true
      - run: bundle exec rake memory_profile:run
@@ -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'
@@ -1 +1 @@
-4.0.2
+3.4.1
@@ -25,14 +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
-  # Includes the range resource-limit specs from https://github.com/Shopify/liquid-spec/pull/165.
-  gem 'liquid-spec', github: 'Shopify/liquid-spec', ref: '84bf25e0edbca5f7e530574788b0f875ab331f50'
-  gem 'activesupport', require: false
-end
@@ -1,27 +1,13 @@
 # Liquid Change Log

-## 5.14.0
-
-* Avoid materializing integer ranges in `for` and `tablerow` loops, and account for each visited range item [Ian Ker-Seymer]
-
-## 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]
+  ```
+  {%- snippet snowdevil -%}
+    Snowdevil
+  {%- endsnippet -%}
+  {% render snowdevil %}
+  ```

 ## 5.9.0
 * Introduce `:rigid` error mode for stricter, safer parsing of all tags [CP Clermont, Guilherme Carreiro]
@@ -103,10 +103,10 @@ Liquid also comes with different parsers that can be used when editing templates
 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 = :rigid  # 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.
 ```

 If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
@@ -149,13 +149,6 @@ template.render!({ 'x' => 1}, { strict_variables: true })
 #=> Liquid::UndefinedVariable: Liquid error: undefined variable y
 ```

-### Resource limits
-
-`render_score_limit` and `cumulative_render_score_limit` account for each item visited by
-integer-range `for` and `tablerow` loops, including loops with empty bodies. This bounds range
-iteration work when a score limit is configured; `render_length_limit` only bounds generated
-output and does not by itself limit CPU work for output-free loops.
-
 ### Usage tracking

 To help track usages of a feature or code path in production, we have released opt-in usage tracking. To enable this, we provide an empty `Liquid:: Usage.increment` method which you can customize to your needs. The feature is well suited to https://github.com/Shopify/statsd-instrument. However, the choice of implementation is up to you.
@@ -33,7 +33,7 @@ task :rubocop do
  end
 end

-desc('runs test suite with lax, strict, and strict2 parsers')
+desc('runs test suite with lax, strict, and rigid parsers')
 task :test do
  ENV['LIQUID_PARSER_MODE'] = 'lax'
  Rake::Task['base_test'].invoke
@@ -42,7 +42,7 @@ task :test do
  Rake::Task['base_test'].reenable
  Rake::Task['base_test'].invoke

-  ENV['LIQUID_PARSER_MODE'] = 'strict2'
+  ENV['LIQUID_PARSER_MODE'] = 'rigid'
  Rake::Task['base_test'].reenable
  Rake::Task['base_test'].invoke

@@ -55,7 +55,7 @@ task :test do
    Rake::Task['integration_test'].reenable
    Rake::Task['integration_test'].invoke

-    ENV['LIQUID_PARSER_MODE'] = 'strict2'
+    ENV['LIQUID_PARSER_MODE'] = 'rigid'
    Rake::Task['integration_test'].reenable
    Rake::Task['integration_test'].invoke
  end
@@ -88,13 +88,13 @@ 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"
+  desc "Run the liquid benchmark with rigid parsing"
+  task :rigid do
+    ruby "./performance/benchmark.rb rigid"
  end

-  desc "Run the liquid benchmark with lax, strict, and strict2 parsing"
-  task run: [:lax, :strict, :strict2]
+  desc "Run the liquid benchmark with lax, strict, and rigid parsing"
+  task run: [:lax, :strict, :rigid]

  desc "Run unit benchmarks"
  namespace :unit do
@@ -148,11 +148,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
@@ -41,6 +41,6 @@ def assigns
 end

 puts Liquid::Template
-  .parse(source, error_mode: :strict2)
+  .parse(source, error_mode: :rigid)
  .tap { |t| t.registers[:file_system] = VirtualFileSystem.new }
  .render(assigns)
@@ -65,9 +65,9 @@ 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/snippet_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
@@ -83,7 +83,6 @@ require 'liquid/resource_limits'
 require 'liquid/expression'
 require 'liquid/template'
 require 'liquid/condition'
-require 'liquid/range_slice'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'
@@ -99,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
@@ -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

@@ -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=)

@@ -31,7 +31,7 @@ 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

@@ -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 :rigid, :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.
@@ -2,8 +2,6 @@

 module Liquid
  class Expression
-    SELF = 'self'
-
    LITERALS = {
      nil => nil,
      'nil' => nil,
@@ -57,7 +55,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),
@@ -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

@@ -5,6 +5,7 @@
      block_tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: {% %{tag} %}{% end%{tag} %}"
      assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
      capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
+      snippet: "Syntax Error in 'snippet' - Valid syntax: snippet [var]"
      case: "Syntax Error in 'case' - Valid syntax: case [condition]"
      case_invalid_when: "Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %}"
      case_invalid_else: "Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) "
@@ -19,6 +20,7 @@
      invalid_delimiter: "'%{tag}' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
      invalid_template_encoding: "Invalid template encoding"
      render: "Syntax error in tag 'render' - Template name must be a quoted string"
+      render_invalid_template_name: "Syntax error in tag 'render' - Expected a string or identifier, found %{found}"
      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"
@@ -29,5 +31,6 @@
      variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
    argument:
      include: "Argument error in tag 'include' - Illegal template name"
+      render: "Argument error in tag 'render' - Dynamically chosen templates are not allowed"
    disabled:
      tag: "usage is not allowed in this context"
@@ -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)
@@ -55,15 +55,15 @@ module Liquid
    end

    def parse_expression(markup, safe: false)
-      if !safe && @error_mode == :strict2
+      if !safe && @error_mode == :rigid
        # parse_expression is a widely used API. To maintain backward
-        # compatibility while raising awareness about strict2 parser standards,
+        # compatibility while raising awareness about rigid 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
+        # In rigid 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"
+        raise Liquid::InternalError, "unsafe parse_expression cannot be used in rigid mode"
      end

      Expression.parse(markup, @string_scanner, @expression_cache)
@@ -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)
@@ -7,19 +7,16 @@ module Liquid
    # 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.
+    # except when in rigid mode where it uses the rigid 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?
+      return rigid_parse_with_error_context(markup) if rigid_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
@@ -31,13 +28,12 @@ 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 :rigid  then rigid_parse_with_error_context(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)
+          rigid_parse_with_error_context(markup)
        rescue SyntaxError => e
          parse_context.warnings << e
          lax_parse(markup)
@@ -45,18 +41,14 @@ module Liquid
      end
    end

-    def strict2_mode?
-      parse_context.error_mode == :strict2 || parse_context.error_mode == :rigid
+    def rigid_mode?
+      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)
+    def rigid_parse_with_error_context(markup)
+      rigid_parse(markup)
    rescue SyntaxError => e
      e.line_number    = line_number
      e.markup_context = markup_context(markup)
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class RangeSlice
-    attr_reader :length
-
-    def initialize(range, from, to, resource_limits)
-      range_length = range.end - range.begin
-      range_length += 1 unless range.exclude_end?
-      range_length = 0 if range_length.negative?
-
-      start = [from, 0].max
-      finish = [to || range_length, range_length].min
-
-      @first = range.begin + start
-      @length = [finish - start, 0].max
-      @direction = 1
-      @resource_limits = resource_limits
-    end
-
-    def empty?
-      @length.zero?
-    end
-
-    def each
-      return enum_for(:each) unless block_given?
-
-      value = @first
-      @length.times do
-        @resource_limits.increment_render_score(1)
-        yield value
-        value += @direction
-      end
-    end
-
-    def reverse!
-      unless empty?
-        @first += @direction * (@length - 1)
-        @direction = -@direction
-      end
-      self
-    end
-  end
-end
@@ -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
@@ -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
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Liquid
+  class SnippetDrop < Drop
+    attr_reader :body, :name, :filename
+
+    def initialize(body, name, filename)
+      super()
+      @body = body
+      @name = name
+      @filename = filename
+    end
+
+    def to_partial
+      @body
+    end
+
+    def to_s
+      'SnippetDrop'
+    end
+  end
+end
@@ -8,19 +8,10 @@ module Liquid
    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 +214,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 +293,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
@@ -790,8 +768,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 +779,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

@@ -20,6 +20,7 @@ require_relative "tags/raw"
 require_relative "tags/render"
 require_relative "tags/cycle"
 require_relative "tags/doc"
+require_relative "tags/snippet"

 module Liquid
  module Tags
@@ -44,6 +45,7 @@ module Liquid
      'echo' => Echo,
      'tablerow' => TableRow,
      'doc' => Doc,
+      'snippet' => Snippet,
    }.freeze
  end
 end
@@ -18,8 +18,6 @@ module Liquid
  # @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 +29,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 +37,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
@@ -20,18 +20,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 +31,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)
@@ -86,7 +86,7 @@ module Liquid

    private

-    def strict2_parse(markup)
+    def rigid_parse(markup)
      parser = @parse_context.new_parser(markup)
      @left = safe_parse_expression(parser)
      parser.consume(:end_of_string)
@@ -107,18 +107,18 @@ module Liquid
    def record_when_condition(markup)
      body = new_body

-      if strict2_mode?
-        parse_strict2_when(markup, body)
+      if rigid_mode?
+        parse_rigid_when(markup, body)
      else
        parse_lax_when(markup, body)
      end
    end

-    def parse_strict2_when(markup, body)
+    def parse_rigid_when(markup, body)
      parser = @parse_context.new_parser(markup)

      loop do
-        expr = Condition.parse_expression(parse_context, parser.expression, safe: true)
+        expr = safe_parse_expression(parser)
        block = Condition.new(@left, '==', expr)
        block.attach(body)
        @blocks << block
@@ -56,7 +56,7 @@ module Liquid
    private

    # cycle [name:] expression(, expression)*
-    def strict2_parse(markup)
+    def rigid_parse(markup)
      p = @parse_context.new_parser(markup)

      @variables = []
@@ -23,29 +23,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
@@ -111,7 +111,7 @@ module Liquid

    private

-    def strict2_parse(markup)
+    def rigid_parse(markup)
      strict_parse(markup)
    end

@@ -130,6 +130,7 @@ module Liquid
      end

      collection = context.evaluate(@collection_name)
+      collection = collection.to_a if collection.is_a?(Range)

      limit_value = context.evaluate(@limit)
      to = if limit_value.nil?
@@ -138,9 +139,7 @@ module Liquid
        Utils.to_integer(limit_value) + from
      end

-      segment = Utils.slice_collection_for_iteration(
-        collection, from, to, context.resource_limits, use_range_to_a: true
-      )
+      segment = Utils.slice_collection(collection, from, to)
      segment.reverse! if @reversed

      offsets[@name] = from + segment.length
@@ -66,7 +66,7 @@ module Liquid

    private

-    def strict2_parse(markup)
+    def rigid_parse(markup)
      strict_parse(markup)
    end

@@ -20,8 +20,7 @@ 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
@@ -85,18 +84,12 @@ module Liquid
    alias_method :parse_context, :options
    private :parse_context

-    def for_loop?
-      @is_for_loop
-    end
-
-    def strict2_parse(markup)
+    def rigid_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
+      @variable_name_expr = safe_parse_expression(p) if p.id?("for") || p.id?("with")
      @alias_name         = p.consume(:id) if p.id?("as")
-      @is_for_loop        = (with_or_for == FOR)

      p.consume?(:comma)

@@ -118,13 +111,11 @@ module Liquid
    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)
+        variable_name = Regexp.last_match(3)

-        @alias_name         = Regexp.last_match(6)
+        @alias_name         = Regexp.last_match(5)
        @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|
@@ -23,29 +23,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
@@ -27,7 +27,7 @@ module Liquid
  # @liquid_syntax_keyword filename The name of the snippet to render, without the `.liquid` extension.
  class Render < Tag
    FOR = 'for'
-    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    SYNTAX = /(#{QuotedString}+|#{VariableSegment}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o

    disable_tags "include"

@@ -47,21 +47,23 @@ module Liquid
    end

    def render_tag(context, output)
-      # The expression should be a String literal, which parses to a String object
-      template_name = @template_name_expr
-      raise ::ArgumentError unless template_name.is_a?(String)
+      template = context.evaluate(@template_name_expr)

-      partial = PartialCache.load(
-        template_name,
-        context: context,
-        parse_context: parse_context,
-      )
-
-      context_variable_name = @alias_name || template_name.split('/').last
+      if @template_name_expr.is_a?(String)
+        partial = PartialCache.load(template, context: context, parse_context: parse_context)
+        template_name = partial.name
+        context_variable_name = @alias_name || template_name.split('/').last
+      elsif template.respond_to?(:to_partial) && template.respond_to?(:name)
+        partial = template.to_partial
+        template_name = template.filename
+        context_variable_name = @alias_name || template.name
+      else
+        raise ::ArgumentError
+      end

      render_partial_func = ->(var, forloop) {
        inner_context               = context.new_isolated_subcontext
-        inner_context.template_name = partial.name
+        inner_context.template_name = template_name
        inner_context.partial       = true
        inner_context['forloop']    = forloop if forloop

@@ -85,10 +87,10 @@ module Liquid
    end

    # render (string) (with|for expression)? (as id)? (key: value)*
-    def strict2_parse(markup)
+    def rigid_parse(markup)
      p = @parse_context.new_parser(markup)

-      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
+      @template_name_expr = parse_expression(rigid_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")
@@ -101,14 +103,18 @@ module Liquid
        key = p.consume
        p.consume(:colon)
        @attributes[key] = safe_parse_expression(p)
-        p.consume?(:comma)
+        p.consume?(:comma) # optional comma
      end

      p.consume(:end_of_string)
    end

-    def strict2_template_name(p)
-      p.consume(:string)
+    def rigid_template_name(p)
+      return p.consume(:string) if p.look(:string)
+      return p.consume(:id) if p.look(:id)
+
+      found = p.consume || "nothing"
+      raise SyntaxError, options[:locale].t("errors.syntax.render_invalid_template_name", found: found)
    end

    def strict_parse(markup)
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category variable
+  # @liquid_name snippet
+  # @liquid_summary
+  #   Creates a new inline snippet.
+  # @liquid_description
+  #   You can create inline snippets to make your Liquid code more modular.
+  # @liquid_syntax
+  #   {% snippet snippet_name %}
+  #     value
+  #   {% endsnippet %}
+  class Snippet < Block
+    def initialize(tag_name, markup, options)
+      super
+      p = @parse_context.new_parser(markup)
+      if p.look(:id)
+        @to = p.consume(:id)
+        p.consume(:end_of_string)
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.snippet")
+      end
+    end
+
+    def render_to_output_buffer(context, output)
+      snippet_drop = SnippetDrop.new(@body, @to, context.template_name)
+      context.scopes.last[@to] = snippet_drop
+      context.resource_limits.increment_assign_score(1)
+      output
+    end
+
+    def blank?
+      true
+    end
+  end
+end
@@ -34,7 +34,7 @@ module Liquid
      parse_with_selected_parser(markup)
    end

-    def strict2_parse(markup)
+    def rigid_parse(markup)
      p = @parse_context.new_parser(markup)

      @variable_name = p.consume(:id)
@@ -85,13 +85,12 @@ module Liquid
      from = @attributes.key?('offset') ? to_integer(context.evaluate(@attributes['offset'])) : 0
      to = @attributes.key?('limit') ? from + to_integer(context.evaluate(@attributes['limit'])) : nil

-      collection = Utils.slice_collection_for_iteration(collection, from, to, context.resource_limits, allow_endless: true)
+      collection = Utils.slice_collection(collection, from, to)
      length     = collection.length

      cols = @attributes.key?('cols') ? to_integer(context.evaluate(@attributes['cols'])) : length

      output << "<tr class=\"row1\">\n"
-      context.resource_limits.increment_write_score(output)
      context.stack do
        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
        context['tablerowloop'] = tablerowloop
@@ -102,7 +101,6 @@ module Liquid
          output << "<td class=\"col#{tablerowloop.col}\">"
          super
          output << '</td>'
-          context.resource_limits.increment_write_score(output)

          # Handle any interrupts if they exist.
          if context.interrupt?
@@ -112,7 +110,6 @@ module Liquid

          if tablerowloop.col_last && !tablerowloop.last
            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
-            context.resource_limits.increment_write_score(output)
          end

          tablerowloop.send(:increment!)
@@ -120,7 +117,6 @@ module Liquid
      end

      output << "</tr>\n"
-      context.resource_limits.increment_write_score(output)
      output
    end

@@ -25,7 +25,7 @@ module Liquid
      # :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
+      # :rigid enforces correct syntax for all tags
      def error_mode=(mode)
        Deprecations.warn("Template.error_mode=", "Environment#error_mode=")
        Environment.default.error_mode = mode
@@ -151,10 +151,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
@@ -189,20 +187,12 @@ module Liquid

      context.template_name ||= name

-      previous_error_mode = context.registers.static[:template_error_mode]
-      context.registers.static[:template_error_mode] = @error_mode
-
      begin
        # render the nodelist.
        @root.render_to_output_buffer(context, output || +'')
      rescue Liquid::MemoryError => e
        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
        @errors = context.errors
      end
    end
@@ -234,7 +224,6 @@ module Liquid
      end

      @warnings = parse_context.warnings
-      @error_mode = parse_context.error_mode
      parse_context
    end

@@ -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

@@ -13,26 +13,6 @@ module Liquid
      end
    end

-    # This is intentionally separate from slice_collection, whose Array-returning
-    # behavior is used outside of the iteration tags.
-    def self.slice_collection_for_iteration(
-      collection, from, to, resource_limits, allow_endless: false, use_range_to_a: false
-    )
-      if integer_range?(collection)
-        RangeSlice.new(collection, from, to, resource_limits)
-      elsif collection.is_a?(Range)
-        if use_range_to_a && range_method_overridden?(collection, :to_a)
-          # For historically honored custom Range#to_a. Charge the resulting
-          # selection before buffering it, just as for a custom #each.
-          slice_collection_for_iteration_using_each(collection.to_a, from, to, resource_limits)
-        else
-          slice_range_using_each(collection, from, to, resource_limits, allow_endless: allow_endless)
-        end
-      else
-        slice_collection(collection, from, to)
-      end
-    end
-
    def self.slice_collection_using_each(collection, from, to)
      segments = []
      index    = 0
@@ -58,55 +38,6 @@ module Liquid
      segments
    end

-    # Arithmetic slicing must not bypass a Range subclass's custom #each.
-    def self.integer_range?(collection)
-      collection.instance_of?(Range) && collection.begin.is_a?(Integer) && collection.end.is_a?(Integer)
-    end
-    private_class_method :integer_range?
-
-    # Preserve support for Ruby-supplied string ranges and custom Range#each.
-    # Their selected length cannot be inferred from integer bounds, but the tags
-    # need it before rendering for loop metadata, continuation offsets, and columns.
-    # Buffer the selection so we do not have to replay a potentially custom iterator.
-    def self.slice_range_using_each(collection, from, to, resource_limits, allow_endless:)
-      # TableRow historically accepted an endless subclass when its custom #each
-      # was finite, while For historically raised through Range#to_a.
-      if collection.end.nil? && !(allow_endless && (!to.nil? || range_method_overridden?(collection, :each)))
-        raise RangeError, "cannot convert endless range to an array"
-      end
-      if collection.begin.nil? && !range_method_overridden?(collection, :each)
-        raise TypeError, "can't iterate from NilClass"
-      end
-
-      slice_collection_for_iteration_using_each(collection, from, to, resource_limits)
-    end
-    private_class_method :slice_range_using_each
-
-    # Custom Range#each can make a nominally beginless range finite; standard
-    # beginless ranges were rejected before reaching this budgeted traversal.
-    def self.slice_collection_for_iteration_using_each(collection, from, to, resource_limits)
-      return [] if to && to <= from
-
-      segments = []
-      index = 0
-      collection.each do |item|
-        break if to && to <= index
-
-        # Charge preparation, including skipped offsets, before buffering; checking
-        # only while rendering the buffered values would leave this work unbudgeted.
-        resource_limits.increment_render_score(1)
-        segments << item if from <= index
-        index += 1
-      end
-      segments
-    end
-    private_class_method :slice_collection_for_iteration_using_each
-
-    def self.range_method_overridden?(collection, method_name)
-      collection.method(method_name).owner != Range.instance_method(method_name).owner
-    end
-    private_class_method :range_method_overridden?
-
    def self.to_integer(num)
      return num if num.is_a?(Integer)
      num = num.to_s
@@ -138,7 +69,7 @@ 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

@@ -164,8 +95,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
@@ -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
@@ -78,14 +74,14 @@ module Liquid
      p.consume(:end_of_string)
    end

-    def strict2_parse(markup)
+    def rigid_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)
+      @filters << rigid_parse_filter_expressions(p) while p.consume?(:pipe)
      p.consume(:end_of_string)
    end

@@ -160,7 +156,7 @@ module Liquid
    # argument = (positional_argument | keyword_argument)
    # positional_argument = expression
    # keyword_argument = id ":" expression
-    def strict2_parse_filter_expressions(p)
+    def rigid_parse_filter_expressions(p)
      filtername = p.consume(:id)
      filter_args = []
      keyword_args = {}
@@ -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
@@ -2,5 +2,5 @@
 # frozen_string_literal: true

 module Liquid
-  VERSION = "5.14.0"
+  VERSION = "5.10.0"
 end
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -639,21 +639,6 @@ class ContextTest < Minitest::Test
    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,
@@ -265,13 +265,11 @@ class ErrorHandlingTest < Minitest::Test
  end

  def test_bug_compatible_silencing_of_errors_in_blank_nodes
-    with_error_modes(:lax, :strict) do
-      output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}not blank{% assign x = 3 %}{% endif %}{{ x }}").render
-      assert_equal("Liquid error: comparison of Integer with String failed0", output)
+    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}not blank{% assign x = 3 %}{% endif %}{{ x }}").render
+    assert_equal("Liquid error: comparison of Integer with String failed0", output)

-      output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}{% assign x = 3 %}{% endif %}{{ x }}").render
-      assert_equal("0", output)
-    end
+    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}{% assign x = 3 %}{% endif %}{{ x }}").render
+    assert_equal("0", output)
  end

  def test_syntax_error_is_raised_with_template_name
@@ -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 })
@@ -44,43 +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
-    assigns = { 'drop' => Drop.new }
-    method_names = Array.new(3) { |index| "untrusted_drop_method_#{object_id}_#{index}" }
-
-    method_names.each do |method_name|
-      assert_equal("", Template.parse("{{ drop.#{method_name} }}").render!(assigns))
-    end
-
-    # JITs can intern internal metadata; untrusted Drop method names must not be interned.
-    assert_equal([], Symbol.all_symbols.map(&:to_s) & method_names)
-  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
@@ -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
@@ -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
@@ -634,40 +633,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))
@@ -1181,8 +1146,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
@@ -1339,7 +1302,7 @@ class StandardFiltersTest < Minitest::Test
    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.4, @filters.sum(input, (1..5)))
    assert_equal(0, @filters.sum(input, nil))
    assert_equal(0, @filters.sum(input, ""))
  end
@@ -101,12 +101,14 @@ class CycleTagTest < Minitest::Test
      assert_template_result("a", template2)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) 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)
+      expected_error = /Liquid syntax error: \[:dot, "."\] is not a valid expression/
+
+      assert_match(expected_error, error1.message)
+      assert_match(expected_error, error2.message)
    end
  end

@@ -127,7 +129,7 @@ class CycleTagTest < Minitest::Test
      assert_template_result("N", template5)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) 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) }
@@ -155,7 +157,7 @@ class CycleTagTest < Minitest::Test
      refute_nil(Template.parse(template))
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
      assert_match(/Unexpected character =/, error.message)
    end
@@ -172,7 +174,7 @@ class CycleTagTest < Minitest::Test
      refute_nil(Template.parse(template))
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
      assert_match(/Unexpected character =/, error.message)
    end
@@ -465,85 +465,4 @@ HERE

    assert(context.registers[:for_stack].empty?)
  end
-
-  def test_integer_range_is_not_materialized_and_charges_empty_iterations
-    range = bounded_integer_range_with_tripwires
-    template = Template.parse('{% for i in numbers %}{% endfor %}')
-    template.resource_limits.render_score_limit = 3
-
-    assert_raises(Liquid::MemoryError) { template.render!('numbers' => range) }
-
-    assert(template.resource_limits.reached?)
-    assert_equal(4, template.resource_limits.render_score)
-  end
-
-  def test_integer_range_uses_arithmetic_offsets_reversal_and_metadata
-    range = bounded_integer_range_with_tripwires
-    template = Template.parse(
-      '{% for i in numbers reversed offset:997 limit:2 %}{{ forloop.length }}:{{ i }}{% endfor %}',
-    )
-    template.resource_limits.render_score_limit = 10
-
-    assert_equal('2:9992:998', template.render!('numbers' => range))
-  end
-
-  def test_range_scores_cannot_be_bypassed_by_repeated_renders
-    template = Template.parse('{% for i in (1..2) %}{% endfor %}')
-    template.resource_limits.cumulative_render_score_limit = 3
-    assert_equal('', template.render!)
-    assert_raises(Liquid::MemoryError) { template.render! }
-  end
-
-  def test_range_break_charges_only_visited_items_and_preserves_full_metadata
-    range = bounded_integer_range_with_tripwires
-    template = Template.parse(
-      '{% for i in numbers reversed %}{{ forloop.length }}:{{ i }}{% break %}{% endfor %}',
-    )
-    template.resource_limits.render_score_limit = 10
-
-    assert_equal('1000:1000', template.render!('numbers' => range))
-    assert_operator(template.resource_limits.render_score, :<=, 10)
-  end
-
-  def test_range_subclass_uses_its_custom_each
-    range = Class.new(Range) do
-      def each
-        yield 10
-        yield 20
-      end
-    end.new(nil, 3)
-
-    assert_template_result('1020', '{% for i in numbers %}{{ i }}{% endfor %}', { 'numbers' => range })
-  end
-
-  def test_range_subclass_custom_to_a_is_honored_for_finite_and_open_bounds
-    range_class = Class.new(Range) do
-      def to_a
-        [42]
-      end
-    end
-
-    [range_class.new(1, 3), range_class.new(nil, 3), range_class.new(1, nil)].each do |range|
-      assert_template_result('42', '{% for i in numbers %}{{ i }}{% endfor %}', { 'numbers' => range })
-    end
-  end
-
-  def test_endless_range_remains_unsupported_with_a_limit
-    template = Template.parse('{% for i in numbers limit:2 %}{{ i }}{% endfor %}')
-
-    assert_raises(RangeError) { template.render!('numbers' => (1..)) }
-  end
-
-  def test_endless_range_subclass_with_custom_each_remains_unsupported
-    range = Class.new(Range) do
-      def each
-        yield 10
-        yield 20
-      end
-    end.new(1, nil)
-
-    assert_raises(RangeError) do
-      Template.parse('{% for i in numbers %}{{ i }}{% endfor %}').render!('numbers' => range)
-    end
-  end
 end
@@ -204,7 +204,7 @@ class IncludeTagTest < Minitest::Test
    )
  end

-  def test_strict2_parsing_errors
+  def test_rigid_parsing_errors
    with_error_modes(:lax, :strict) do
      assert_template_result(
        'hello value1 value2',
@@ -213,7 +213,7 @@ class IncludeTagTest < Minitest::Test
      )
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_syntax_error(
        '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
      )
@@ -408,7 +408,7 @@ class IncludeTagTest < Minitest::Test
      refute_nil(Template.parse(template))
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
      assert_match(/Unexpected character =/, error.message)
    end
@@ -421,7 +421,7 @@ class IncludeTagTest < Minitest::Test
      refute_nil(Template.parse(template))
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
      assert_match(/Unexpected character =/, error.message)
    end
@@ -434,54 +434,9 @@ class IncludeTagTest < Minitest::Test
      refute_nil(Template.parse(template))
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) 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
@@ -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
@@ -101,11 +101,7 @@ class RenderTagTest < Minitest::Test
    end
  end

-  def test_dynamically_choosen_templates_are_not_allowed
-    assert_syntax_error("{% assign name = 'snippet' %}{% render name %}")
-  end
-
-  def test_strict2_parsing_errors
+  def test_rigid_parsing_errors
    with_error_modes(:lax, :strict) do
      assert_template_result(
        'hello value1 value2',
@@ -114,7 +110,7 @@ class RenderTagTest < Minitest::Test
      )
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_syntax_error(
        '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
      )
@@ -174,16 +170,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

@@ -294,6 +290,13 @@ class RenderTagTest < Minitest::Test
    )
  end

+  def test_render_tag_with_snippet_drop
+    assert_template_result(
+      "Hello from snippet",
+      "{% snippet my_snippet %}Hello from snippet{% endsnippet %}{% render my_snippet %}",
+    )
+  end
+
  def test_render_tag_renders_error_with_template_name
    assert_template_result(
      'Liquid error (foo line 1): standard error',
@@ -322,7 +325,7 @@ class RenderTagTest < Minitest::Test
      refute_nil(Template.parse(template))
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
      assert_match(/Unexpected character =/, error.message)
    end
@@ -335,7 +338,7 @@ class RenderTagTest < Minitest::Test
      refute_nil(Template.parse(template))
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
      assert_match(/Unexpected character =/, error.message)
    end
@@ -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
@@ -259,7 +259,7 @@ class TableRowTest < Minitest::Test
    )
  end

-  def test_tablerow_with_cols_attribute_in_strict2_mode
+  def test_tablerow_with_cols_attribute_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow i in (1..6) cols: 3 %}{{ i }}{% endtablerow %}
    LIQUID
@@ -270,12 +270,12 @@ class TableRowTest < Minitest::Test
      <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
+    with_error_modes(:rigid) do
      assert_template_result(expected, template)
    end
  end

-  def test_tablerow_with_limit_attribute_in_strict2_mode
+  def test_tablerow_with_limit_attribute_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow i in (1..10) limit: 3 %}{{ i }}{% endtablerow %}
    LIQUID
@@ -285,12 +285,12 @@ class TableRowTest < Minitest::Test
      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
    OUTPUT

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result(expected, template)
    end
  end

-  def test_tablerow_with_offset_attribute_in_strict2_mode
+  def test_tablerow_with_offset_attribute_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow i in (1..5) offset: 2 %}{{ i }}{% endtablerow %}
    LIQUID
@@ -300,12 +300,12 @@ class TableRowTest < Minitest::Test
      <td class="col1">3</td><td class="col2">4</td><td class="col3">5</td></tr>
    OUTPUT

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result(expected, template)
    end
  end

-  def test_tablerow_with_range_attribute_in_strict2_mode
+  def test_tablerow_with_range_attribute_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow i in (1..3) range: (1..10) %}{{ i }}{% endtablerow %}
    LIQUID
@@ -315,12 +315,12 @@ class TableRowTest < Minitest::Test
      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
    OUTPUT

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result(expected, template)
    end
  end

-  def test_tablerow_with_multiple_attributes_in_strict2_mode
+  def test_tablerow_with_multiple_attributes_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow i in (1..10) cols: 2, limit: 4, offset: 1 %}{{ i }}{% endtablerow %}
    LIQUID
@@ -331,12 +331,12 @@ class TableRowTest < Minitest::Test
      <tr class="row2"><td class="col1">4</td><td class="col2">5</td></tr>
    OUTPUT

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result(expected, template)
    end
  end

-  def test_tablerow_with_variable_collection_in_strict2_mode
+  def test_tablerow_with_variable_collection_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow n in numbers cols: 2 %}{{ n }}{% endtablerow %}
    LIQUID
@@ -347,12 +347,12 @@ class TableRowTest < Minitest::Test
      <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
    OUTPUT

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result(expected, template, { 'numbers' => [1, 2, 3, 4] })
    end
  end

-  def test_tablerow_with_dotted_access_in_strict2_mode
+  def test_tablerow_with_dotted_access_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow n in obj.numbers cols: 2 %}{{ n }}{% endtablerow %}
    LIQUID
@@ -363,12 +363,12 @@ class TableRowTest < Minitest::Test
      <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
    OUTPUT

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result(expected, template, { 'obj' => { 'numbers' => [1, 2, 3, 4] } })
    end
  end

-  def test_tablerow_with_bracketed_access_in_strict2_mode
+  def test_tablerow_with_bracketed_access_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow n in obj["numbers"] cols: 2 %}{{ n }}{% endtablerow %}
    LIQUID
@@ -378,12 +378,12 @@ class TableRowTest < Minitest::Test
      <td class="col1">10</td><td class="col2">20</td></tr>
    OUTPUT

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result(expected, template, { 'obj' => { 'numbers' => [10, 20] } })
    end
  end

-  def test_tablerow_without_attributes_in_strict2_mode
+  def test_tablerow_without_attributes_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow i in (1..3) %}{{ i }}{% endtablerow %}
    LIQUID
@@ -393,30 +393,30 @@ class TableRowTest < Minitest::Test
      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
    OUTPUT

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result(expected, template)
    end
  end

-  def test_tablerow_without_in_keyword_in_strict2_mode
+  def test_tablerow_without_in_keyword_in_rigid_mode
    template = '{% tablerow i (1..10) %}{{ i }}{% endtablerow %}'

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) 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
+  def test_tablerow_with_multiple_invalid_attributes_reports_first_in_rigid_mode
    template = '{% tablerow i in (1..10) invalid1: 5, invalid2: 10 %}{{ i }}{% endtablerow %}'

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) 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
+  def test_tablerow_with_empty_collection_in_rigid_mode
    template = <<~LIQUID.chomp
      {% tablerow i in empty_array cols: 2 %}{{ i }}{% endtablerow %}
    LIQUID
@@ -426,12 +426,12 @@ class TableRowTest < Minitest::Test
      </tr>
    OUTPUT

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result(expected, template, { 'empty_array' => [] })
    end
  end

-  def test_tablerow_with_invalid_attribute_strict_vs_strict2
+  def test_tablerow_with_invalid_attribute_strict_vs_rigid
    template = '{% tablerow i in (1..5) invalid_attr: 10 %}{{ i }}{% endtablerow %}'

    expected = <<~OUTPUT
@@ -443,13 +443,13 @@ class TableRowTest < Minitest::Test
      assert_template_result(expected, template)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) 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
+  def test_tablerow_with_invalid_expression_strict_vs_rigid
    template = '{% tablerow i in (1..5) limit: foo=>bar %}{{ i }}{% endtablerow %}'

    with_error_modes(:lax, :strict) do
@@ -460,99 +460,9 @@ class TableRowTest < Minitest::Test
      assert_template_result(expected, template)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(SyntaxError) { Template.parse(template) }
      assert_match(/Unexpected character =/, error.message)
    end
  end
-
-  def test_integer_range_is_not_materialized_and_charges_empty_iterations
-    range = bounded_integer_range_with_tripwires
-    template = Template.parse('{% tablerow i in numbers %}{% endtablerow %}')
-    template.resource_limits.render_score_limit = 3
-
-    assert_raises(Liquid::MemoryError) { template.render!('numbers' => range) }
-
-    assert(template.resource_limits.reached?)
-    assert_equal(4, template.resource_limits.render_score)
-  end
-
-  def test_integer_range_uses_arithmetic_offsets_limit_and_full_metadata
-    range = bounded_integer_range_with_tripwires
-    template = Template.parse(
-      '{% tablerow i in numbers offset:997 limit:2 %}{{ tablerowloop.length }}:{{ tablerowloop.index }}:{{ i }}{% endtablerow %}',
-    )
-
-    assert_equal(
-      "<tr class=\"row1\">\n<td class=\"col1\">2:1:998</td><td class=\"col2\">2:2:999</td></tr>\n",
-      template.render!('numbers' => range),
-    )
-  end
-
-  def test_tablerow_checks_generated_output_during_empty_body_iteration
-    template = Template.parse('{% tablerow i in (1..100) %}{% endtablerow %}')
-    template.resource_limits.render_length_limit = 40
-    checked_lengths = []
-    limits = template.resource_limits
-    original_increment_write_score = limits.method(:increment_write_score)
-    limits.define_singleton_method(:increment_write_score) do |output|
-      checked_lengths << output.bytesize
-      original_increment_write_score.call(output)
-    end
-
-    assert_equal('Liquid error: Memory limits exceeded', template.render)
-    assert(template.resource_limits.reached?)
-    assert_operator(checked_lengths.last, :<, 1000)
-  end
-
-  def test_tablerow_range_scores_persist_across_renders
-    template = Template.parse('{% tablerow i in (1..2) %}{% endtablerow %}')
-    template.resource_limits.cumulative_render_score_limit = 3
-    template.render!
-    assert_raises(Liquid::MemoryError) { template.render! }
-  end
-
-  def test_range_subclass_uses_its_custom_each_with_beginless_bounds
-    range = Class.new(Range) do
-      def each
-        yield 10
-        yield 20
-      end
-    end.new(nil, 3)
-
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\">10</td><td class=\"col2\">20</td></tr>\n",
-      '{% tablerow i in numbers %}{{ i }}{% endtablerow %}',
-      { 'numbers' => range },
-    )
-  end
-
-  def test_endless_range_subclass_uses_its_custom_each_without_a_limit
-    range = Class.new(Range) do
-      def each
-        yield 10
-        yield 20
-      end
-    end.new(1, nil)
-
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\">10</td><td class=\"col2\">20</td></tr>\n",
-      '{% tablerow i in numbers %}{{ i }}{% endtablerow %}',
-      { 'numbers' => range },
-    )
-  end
-
-  def test_range_subclass_custom_to_a_is_not_used
-    range = Class.new(Range) do
-      def to_a
-        [42]
-      end
-    end.new(1, 3)
-
-    assert_template_result(
-      "<tr class=\"row1\">\n<td class=\"col1\">1</td><td class=\"col2\">2</td><td class=\"col3\">3</td></tr>\n",
-      '{% tablerow i in numbers %}{{ i }}{% endtablerow %}',
-      { 'numbers' => range },
-    )
-  end
 end
@@ -132,8 +132,8 @@ class TemplateTest < Minitest::Test
    assert_equal("Liquid error: Memory limits exceeded", t.render)
    assert(t.resource_limits.reached?)

-    t.resource_limits.render_score_limit = 201
-    assert_equal(" foo " * 100, t.render!)
+    t.resource_limits.render_score_limit = 200
+    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 %}")
@@ -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),
@@ -218,7 +218,7 @@ class VariableTest < Minitest::Test
      assert_match(/is not a valid expression/, error.message)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result('helloworld', template)
    end
  end
@@ -231,7 +231,7 @@ class VariableTest < Minitest::Test
      assert_match(/is not a valid expression/, error.message)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result('hello12', template)
    end
  end
@@ -244,7 +244,7 @@ class VariableTest < Minitest::Test
      assert_match(/is not a valid expression/, error.message)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result('TEST', template)
    end
  end
@@ -257,7 +257,7 @@ class VariableTest < Minitest::Test
      assert_match(/is not a valid expression/, error.message)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result('TESTX', template)
    end
  end
@@ -270,7 +270,7 @@ class VariableTest < Minitest::Test
      assert_match(/is not a valid expression/, error.message)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      assert_template_result('TESTX', template)
    end
  end
@@ -32,15 +32,6 @@ module Minitest
  module Assertions
    include Liquid

-    # Exact Range fixture for fast-path tests; singleton tripwires must remain
-    # untouched because the arithmetic path does not materialize or traverse it.
-    def bounded_integer_range_with_tripwires
-      range = (1..1000).dup
-      range.define_singleton_method(:to_a) { raise 'range was materialized' }
-      range.define_singleton_method(:each) { raise 'range was traversed' }
-      range
-    end
-
    def assert_template_result(
      expected, template, assigns = {},
      message: nil, partials: nil, error_mode: Liquid::Environment.default.error_mode, render_errors: false,
@@ -208,26 +199,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

@@ -161,8 +161,8 @@ 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

@@ -176,19 +176,19 @@ class ConditionUnitTest < Minitest::Test
    assert_equal(['title'], result.lookups)
  end

-  def test_parse_expression_in_strict2_mode_raises_internal_error
-    environment = Environment.build(error_mode: :strict2)
+  def test_parse_expression_in_rigid_mode_raises_internal_error
+    environment = Environment.build(error_mode: :rigid)
    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)
+    assert_match(/unsafe parse_expression cannot be used in rigid mode/, error.message)
  end

-  def test_parse_expression_with_safe_true_in_strict2_mode
-    environment = Environment.build(error_mode: :strict2)
+  def test_parse_expression_with_safe_true_in_rigid_mode
+    environment = Environment.build(error_mode: :rigid)
    parse_context = ParseContext.new(environment: environment)
    result = Condition.parse_expression(parse_context, 'product.title', safe: true)

@@ -197,172 +197,6 @@ class ConditionUnitTest < Minitest::Test
    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)
@@ -9,32 +9,32 @@ class ParseContextUnitTest < Minitest::Test
    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)
+    parser_rigid = rigid_parse_context.new_parser('product.title')
+    result_rigid = rigid_parse_context.safe_parse_expression(parser_rigid)

    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)
+    assert_instance_of(VariableLookup, result_rigid)
+    assert_equal('product', result_rigid.name)
+    assert_equal(['title'], result_rigid.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('')
+    parser_rigid = rigid_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)
+    error_rigid = assert_raises(Liquid::SyntaxError) do
+      rigid_parse_context.safe_parse_expression(parser_rigid)
    end

-    assert_match(/is not a valid expression/, error_strict2.message)
+    assert_match(/is not a valid expression/, error_rigid.message)
  end

  def test_parse_expression_with_variable_lookup
@@ -45,10 +45,10 @@ class ParseContextUnitTest < Minitest::Test
    assert_equal(['title'], result_strict.lookups)

    error = assert_raises(Liquid::InternalError) do
-      strict2_parse_context.parse_expression('product.title')
+      rigid_parse_context.parse_expression('product.title')
    end

-    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
+    assert_match(/unsafe parse_expression cannot be used in rigid mode/, error.message)
  end

  def test_parse_expression_with_safe_true
@@ -58,11 +58,11 @@ class ParseContextUnitTest < Minitest::Test
    assert_equal('product', result_strict.name)
    assert_equal(['title'], result_strict.lookups)

-    result_strict2 = strict2_parse_context.parse_expression('product.title', safe: true)
+    result_rigid = rigid_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)
+    assert_instance_of(VariableLookup, result_rigid)
+    assert_equal('product', result_rigid.name)
+    assert_equal(['title'], result_rigid.lookups)
  end

  def test_parse_expression_with_empty_string
@@ -70,40 +70,40 @@ class ParseContextUnitTest < Minitest::Test
    assert_nil(result_strict)

    error = assert_raises(Liquid::InternalError) do
-      strict2_parse_context.parse_expression('')
+      rigid_parse_context.parse_expression('')
    end

-    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
+    assert_match(/unsafe parse_expression cannot be used in rigid 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)
+    result_rigid = rigid_parse_context.parse_expression('', safe: true)
+    assert_nil(result_rigid)
  end

  def test_safe_parse_expression_advances_parser_pointer
-    parser = strict2_parse_context.new_parser('foo, bar')
+    parser = rigid_parse_context.new_parser('foo, bar')

    # safe_parse_expression consumes "foo"
-    first_result = strict2_parse_context.safe_parse_expression(parser)
+    first_result = rigid_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)
+    second_result = rigid_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)
+  def test_parse_expression_with_whitespace_in_rigid_mode
+    result = rigid_parse_context.parse_expression('   ', safe: true)
    assert_nil(result)
  end

@@ -115,9 +115,9 @@ class ParseContextUnitTest < Minitest::Test
    )
  end

-  def strict2_parse_context
-    @strict2_parse_context ||= ParseContext.new(
-      environment: Environment.build(error_mode: :strict2),
+  def rigid_parse_context
+    @rigid_parse_context ||= ParseContext.new(
+      environment: Environment.build(error_mode: :rigid),
    )
  end
 end
@@ -184,7 +184,7 @@ class PartialCacheUnitTest < Minitest::Test
      },
    )

-    [:lax, :warn, :strict, :strict2].each do |error_mode|
+    [:lax, :warn, :strict, :rigid].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", "my_partial:rigid"],
      context.registers[:cached_partials].keys,
    )
  end
@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class RangeSliceUnitTest < Minitest::Test
-  def test_selects_and_reverses_an_integer_range_without_enumerating_it
-    limits = Liquid::ResourceLimits.new({})
-    slice = Liquid::RangeSlice.new(bounded_integer_range_with_tripwires, 997, 999, limits)
-
-    assert_equal(2, slice.length)
-    refute(slice.empty?)
-    slice.reverse!
-    assert_equal([999, 998], slice.each.to_a)
-    assert_equal(2, limits.render_score)
-  end
-
-  def test_charges_only_values_yielded_before_a_break
-    limits = Liquid::ResourceLimits.new({})
-    slice = Liquid::RangeSlice.new(bounded_integer_range_with_tripwires, 0, nil, limits)
-
-    slice.each { break }
-
-    assert_equal(1, limits.render_score)
-  end
-
-  def test_non_integer_ranges_are_sliced_without_to_a_and_charge_visited_values
-    limits = Liquid::ResourceLimits.new({})
-    range = Class.new(Range) do
-      def to_a
-        raise 'range was materialized'
-      end
-    end.new('a', 'c')
-
-    assert_equal(['b', 'c'], Liquid::Utils.slice_collection_for_iteration(range, 1, nil, limits))
-    assert_equal(3, limits.render_score)
-
-    limited = Liquid::ResourceLimits.new(render_score_limit: 2)
-    assert_raises(Liquid::MemoryError) do
-      Liquid::Utils.slice_collection_for_iteration('a'..'z', 10, 11, limited)
-    end
-  end
-
-  def test_non_integer_range_empty_windows_do_not_visit_a_sentinel_value
-    limits = Liquid::ResourceLimits.new({})
-
-    assert_equal([], Liquid::Utils.slice_collection_for_iteration('a'..'z', 2, 2, limits))
-    assert_equal(0, limits.render_score)
-    assert_equal(['a', 'b'], Liquid::Utils.slice_collection_for_iteration('a'..'z', 0, 2, limits))
-    assert_equal(2, limits.render_score)
-  end
-
-  def test_standard_beginless_range_raises_for_empty_windows
-    [[0, 0], [1, 0]].each do |from, to|
-      assert_raises(TypeError) do
-        Liquid::Utils.slice_collection_for_iteration(Range.new(nil, 3), from, to, Liquid::ResourceLimits.new({}))
-      end
-    end
-  end
-
-  def test_custom_range_to_a_is_sliced_with_a_budget
-    range = Class.new(Range) do
-      def to_a
-        [1, 2, 3]
-      end
-    end.new(nil, 3)
-    limits = Liquid::ResourceLimits.new(render_score_limit: 2)
-
-    assert_raises(Liquid::MemoryError) do
-      Liquid::Utils.slice_collection_for_iteration(range, 1, 3, limits, use_range_to_a: true)
-    end
-    assert_equal(3, limits.render_score)
-  end
-
-  def test_preserves_slice_bounds_for_negative_offsets_and_limits
-    limits = Liquid::ResourceLimits.new({})
-
-    assert_equal([1, 2], Liquid::RangeSlice.new(1..5, -2, 2, limits).each.to_a)
-    empty = Liquid::RangeSlice.new(1..5, 2, 1, limits)
-    assert(empty.empty?)
-    assert_equal([], empty.each.to_a)
-    assert_equal(2, limits.render_score) # the empty window performs no work
-    assert(Liquid::RangeSlice.new(5..1, 0, nil, limits).empty?)
-    assert_equal([1, 2, 3, 4], Liquid::RangeSlice.new(1...5, 0, nil, limits).each.to_a)
-  end
-end
@@ -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
@@ -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)
@@ -24,7 +24,7 @@ class CaseTagUnitTest < Minitest::Test
      assert_template_result("one", template)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }

      assert_match(/Expected end_of_string but found/, error.message)
@@ -45,7 +45,7 @@ class CaseTagUnitTest < Minitest::Test
      assert_template_result("one", template)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }

      assert_match(/Expected end_of_string but found/, error.message)
@@ -62,7 +62,7 @@ class CaseTagUnitTest < Minitest::Test
      {%- endcase -%}
    LIQUID

-    with_error_modes(:lax, :strict, :strict2) do
+    with_error_modes(:lax, :strict, :rigid) do
      assert_template_result("one", template)
    end
  end
@@ -77,31 +77,11 @@ class CaseTagUnitTest < Minitest::Test
      {%- endcase -%}
    LIQUID

-    with_error_modes(:lax, :strict, :strict2) do
+    with_error_modes(:lax, :strict, :rigid) 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 -%}
@@ -117,7 +97,7 @@ class CaseTagUnitTest < Minitest::Test
      assert_template_result("one", template, assigns)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }

      assert_match(/Unexpected character =/, error.message)
@@ -139,7 +119,7 @@ class CaseTagUnitTest < Minitest::Test
      assert_template_result("one", template, assigns)
    end

-    with_error_modes(:strict2) do
+    with_error_modes(:rigid) do
      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }

      assert_match(/Unexpected character =/, error.message)
@@ -161,8 +161,8 @@ class VariableUnitTest < Minitest::Test
    end
  end

-  def test_strict2_filter_argument_parsing
-    with_error_modes(:strict2) do
+  def test_rigid_filter_argument_parsing
+    with_error_modes(:rigid) do
      # optional colon
      var = create_variable(%(n | f1 | f2:))
      assert_equal([['f1', []], ['f2', []]], var.filters)
@@ -1 +1 @@
 .0.2
 .4.1