Point liquid-spec to cp-gate-lax-specs-ai branch

This branch gates lax-mode-only specs behind lax_parsing feature:
- shopify_production_recordings: 22 specs
- liquid_ruby: 16 specs
- basics: error regex updated

Co-Authored-By: Claude Opus 4.5 <[email protected]>

.github/workflows/liquid.yml

@@ -22,7 +22,6 @@ jobs:
             }
           - { 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 }
@@ -36,7 +35,7 @@ jobs:
     name: Test Ruby ${{ matrix.entry.ruby }} ${{ matrix.entry.rubyopt }} --${{ matrix.entry.allowed-failure && 'allowed-failure' || 'strict' }}
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
+      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
         with:
           ruby-version: ${{ matrix.entry.ruby }}
           bundler-cache: true
@@ -52,7 +51,7 @@ jobs:
       BUNDLE_WITH: spec
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
+      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
         with:
           bundler-cache: true
           bundler: latest
@@ -67,7 +66,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
+      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
         with:
           bundler-cache: true
       - run: bundle exec rake memory_profile:run

.ruby-version

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

Gemfile

@@ -32,6 +32,7 @@ group :test do
 end
 
 group :spec do
-  gem 'liquid-spec', github: 'Shopify/liquid-spec'
+  # TODO: temporary - using cp-gate-lax-specs-ai branch until lax specs are properly gated
+  gem 'liquid-spec', github: 'Shopify/liquid-spec', branch: 'cp-gate-lax-specs-ai'
   gem 'activesupport', require: false
 end

History.md

@@ -1,16 +1,37 @@
 # Liquid Change Log
 
-## 5.13.0
+## 6.0.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]
+### Architectural changes
+
+### Features
+* (TODO) Add support for boolean expressions everywhere
+  * As variable output `{{ a or b }}`
+  * As filter argument `{{ collection | where: 'prop', a or b }}`
+  * As tag argument `{% render 'snip', enabled: a or b %}`
+  * As conditional tag argument `{% if cond %}` (extending previous behaviour)
+* (TODO) Add support for subexpression prioritization and associativity
+  * In ascending order of priority:
+    * Logical: `and`, `or` (right to left)
+    * Equality: `==`, `!=`, `<>` (left to right)
+    * Comparison: `>`, `>=`, `<`, `<=`, `contains` (left to right)
+  - For example, this is now supported
+    * `{{ a > b == c < d or e == f }}` which is equivalent to
+    * `{{ ((a > b) == (c < d)) or (e == f) }}`
+- (TODO) Add support for parenthesized expressions
+  * e.g. `(a or b) and c`
+
+### Breaking changes
+* The Environment's `error_mode` option has been removed.
+  * `:warn` is no longer supported
+  * `:lax` and `lax_parse` is no longer supported
+  * `:strict` and `strict_parse` is no longer supported
+  * `strict2_parse` is renamed to `parse_markup`
+* The `warnings` system has been removed.
+
+### Migrating from `^5.11.0`
+- In custom tags that include `ParserSwitching`, rename `strict2_parse` to `parse_markup`
+- Remove code depending on `:error_mode`
 
 ## 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]

README.md

@@ -93,31 +93,6 @@ LIQUID
 
 By using Environments, you ensure that custom tags and filters are only available in the contexts where they are needed, making your Liquid templates more robust and easier to manage. For smaller projects, a global environment is available via `Liquid::Environment.default`.
 
-### Error Modes
-
-Setting the error mode of Liquid lets you specify how strictly you want your templates to be interpreted.
-Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
-it very hard to debug and can lead to unexpected behaviour.
-
-Liquid also comes with different parsers that can be used when editing templates to give better error messages
-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.
-```
-
-If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
-```ruby
-Liquid::Template.parse(source, error_mode: :strict)
-```
-This is useful for doing things like enabling strict mode only in the theme editor.
-
-It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
-It is also recommended that you use it in the template editors of existing apps to give editors better error messages.
-
 ### Undefined variables and filters
 
 By default, the renderer doesn't raise or in any other way notify you if some variables or filters are missing, i.e. not passed to the `render` method.

Rakefile

@@ -33,29 +33,12 @@ task :rubocop do
   end
 end
 
-desc('runs test suite with lax, strict, and strict2 parsers')
+desc('runs test suite')
 task :test do
-  ENV['LIQUID_PARSER_MODE'] = 'lax'
-  Rake::Task['base_test'].invoke
-
-  ENV['LIQUID_PARSER_MODE'] = 'strict'
-  Rake::Task['base_test'].reenable
-  Rake::Task['base_test'].invoke
-
-  ENV['LIQUID_PARSER_MODE'] = 'strict2'
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
   if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
-    ENV['LIQUID_PARSER_MODE'] = 'lax'
-    Rake::Task['integration_test'].reenable
-    Rake::Task['integration_test'].invoke
-
-    ENV['LIQUID_PARSER_MODE'] = 'strict'
-    Rake::Task['integration_test'].reenable
-    Rake::Task['integration_test'].invoke
-
-    ENV['LIQUID_PARSER_MODE'] = 'strict2'
     Rake::Task['integration_test'].reenable
     Rake::Task['integration_test'].invoke
   end
@@ -78,24 +61,11 @@ task release: :build do
 end
 
 namespace :benchmark do
-  desc "Run the liquid benchmark with lax parsing"
-  task :lax do
-    ruby "./performance/benchmark.rb lax"
+  desc "Run the liquid benchmark"
+  task :run do
+    ruby "./performance/benchmark.rb"
   end
 
-  desc "Run the liquid benchmark with strict parsing"
-  task :strict do
-    ruby "./performance/benchmark.rb strict"
-  end
-
-  desc "Run the liquid benchmark with strict2 parsing"
-  task :strict2 do
-    ruby "./performance/benchmark.rb strict2"
-  end
-
-  desc "Run the liquid benchmark with lax, strict, and strict2 parsing"
-  task run: [:lax, :strict, :strict2]
-
   desc "Run unit benchmarks"
   namespace :unit do
     task :all do
@@ -126,11 +96,6 @@ namespace :profile do
   task :run do
     ruby "./performance/profile.rb"
   end
-
-  desc "Run the liquid profile/performance coverage with strict parsing"
-  task :strict do
-    ruby "./performance/profile.rb strict"
-  end
 end
 
 namespace :memory_profile do
@@ -151,8 +116,6 @@ 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
+  adapters = Dir['./spec/*.rb'].join(',')
+  sh "bundle exec liquid-spec matrix --adapters=#{adapters} --reference=ruby_liquid"
 end

docs/template_recorder.md

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

lib/liquid.rb

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

lib/liquid/block_body.rb

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

lib/liquid/context.rb

@@ -60,10 +60,6 @@ module Liquid
     end
     # rubocop:enable Metrics/ParameterLists
 
-    def warnings
-      @warnings ||= []
-    end
-
     def strainer
       @strainer ||= @environment.create_strainer(self, @filters)
     end
@@ -157,7 +153,6 @@ module Liquid
         subcontext.filters  = @filters
         subcontext.strainer = nil
         subcontext.errors   = errors
-        subcontext.warnings = warnings
         subcontext.disabled_tags = @disabled_tags
       end
     end
@@ -187,15 +182,6 @@ module Liquid
       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) }
-    end
-
     def evaluate(object)
       object.respond_to?(:evaluate) ? object.evaluate(self) : object
     end
@@ -206,21 +192,12 @@ module Liquid
       # path and find_index() is optimized in MRI to reduce object allocation
       index = @scopes.find_index { |s| s.key?(key) }
 
-      fallback_to_self_drop = key == Expression::SELF && index.nil?
-
       variable = if index
         lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
       else
-        try_variable_find_in_environments(
-          key,
-          raise_on_not_found: raise_on_not_found && !fallback_to_self_drop,
-        )
+        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
       end
 
-      # `self` resolves to a SelfDrop (enabling `self['var']` lookups),
-      # but only after the normal environment lookup doesn't find a value.
-      return @self_drop ||= SelfDrop.new(self) if fallback_to_self_drop && variable.nil?
-
       # update variable's context before invoking #to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
@@ -228,8 +205,6 @@ module Liquid
 
       liquid_variable.context = self if variable != liquid_variable && liquid_variable.respond_to?(:context=)
 
-      recorder = @registers[TemplateRecorder::REGISTER_KEY] if defined?(TemplateRecorder)
-      recorder&.emit_variable_read(key, liquid_variable)
       liquid_variable
     end
 
@@ -264,7 +239,7 @@ module Liquid
 
     protected
 
-    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags
+    attr_writer :base_scope_depth, :errors, :strainer, :filters, :disabled_tags
 
     private
 

lib/liquid/drop.rb

@@ -37,15 +37,11 @@ module Liquid
 
     # called by liquid to invoke a drop
     def invoke_drop(method_or_key)
-      result = if self.class.invokable?(method_or_key)
+      if self.class.invokable?(method_or_key)
         send(method_or_key)
       else
         liquid_method_missing(method_or_key)
       end
-
-      recorder = @context&.registers&.[](TemplateRecorder::REGISTER_KEY) if defined?(TemplateRecorder)
-      recorder&.emit_drop_read(self, method_or_key, result)
-      result
     end
 
     def key?(_name)

lib/liquid/environment.rb

@@ -4,10 +4,6 @@ module Liquid
   # The Environment is the container for all configuration options of Liquid, such as
   # the registered tags, filters, and the default error mode.
   class Environment
-    # The default error mode for all templates. This can be overridden on a
-    # per-template basis.
-    attr_accessor :error_mode
-
     # The tags that are available to use in the template.
     attr_accessor :tags
 
@@ -33,17 +29,14 @@ module Liquid
       #  the template.
       # @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).
       # @param exception_renderer [Proc] The exception renderer that is used to
       #   render exceptions.
       # @yieldparam environment [Environment] The environment instance that is being built.
       # @return [Environment] The new environment instance.
-      def build(tags: nil, file_system: nil, error_mode: nil, exception_renderer: nil)
+      def build(tags: nil, file_system: nil, exception_renderer: nil)
         ret = new
         ret.tags = tags if tags
         ret.file_system = file_system if file_system
-        ret.error_mode = error_mode if error_mode
         ret.exception_renderer = exception_renderer if exception_renderer
         yield ret if block_given?
         ret.freeze
@@ -75,7 +68,6 @@ module Liquid
     # @api private
     def initialize
       @tags = Tags::STANDARD_TAGS.dup
-      @error_mode = :lax
       @strainer_template = Class.new(StrainerTemplate).tap do |klass|
         klass.add_filter(StandardFilters)
       end

lib/liquid/expression.rb

@@ -2,8 +2,6 @@
 
 module Liquid
   class Expression
-    SELF = 'self'
-
     LITERALS = {
       nil => nil,
       'nil' => nil,
@@ -13,9 +11,6 @@ module Liquid
       'false' => false,
       'blank' => '',
       'empty' => '',
-      # in lax mode, minus sign can be a VariableLookup
-      # For simplicity and performace, we treat it like a literal
-      '-' => VariableLookup.parse("-", nil).freeze,
     }.freeze
 
     DOT = ".".ord

lib/liquid/parse_context.rb

@@ -3,14 +3,13 @@
 module Liquid
   class ParseContext
     attr_accessor :locale, :line_number, :trim_whitespace, :depth
-    attr_reader :partial, :warnings, :error_mode, :environment
+    attr_reader :partial, :environment
 
     def initialize(options = Const::EMPTY_HASH)
       @environment = options.fetch(:environment, Environment.default)
       @template_options = options ? options.dup : {}
 
-      @locale   = @template_options[:locale] ||= I18n.new
-      @warnings = []
+      @locale = @template_options[:locale] ||= I18n.new
 
       # constructing new StringScanner in Lexer, Tokenizer, etc is expensive
       # This StringScanner will be shared by all of them
@@ -38,7 +37,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,16 +54,12 @@ module Liquid
     end
 
     def parse_expression(markup, safe: false)
-      if !safe && @error_mode == :strict2
-        # parse_expression is a widely used API. To maintain backward
-        # compatibility while raising awareness about strict2 parser standards,
-        # the safe flag supports API users make a deliberate decision.
-        #
-        # In strict2 mode, markup MUST come from a string returned by the parser
-        # (e.g., parser.expression). We're not calling the parser here to
-        # prevent redundant parser overhead.
-        raise Liquid::InternalError, "unsafe parse_expression cannot be used in strict2 mode"
-      end
+      # 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. The `safe` opt-in
+      # exists to ensure it is not accidentally still called with
+      # the result of a regex.
+      raise Liquid::InternalError, "unsafe parse_expression cannot be used" unless safe
 
       Expression.parse(markup, @string_scanner, @expression_cache)
     end
@@ -72,8 +67,6 @@ module Liquid
     def partial=(value)
       @partial = value
       @options = value ? partial_options : @template_options
-
-      @error_mode = @options[:error_mode] || @environment.error_mode
     end
 
     def partial_options

lib/liquid/parser.rb

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

lib/liquid/parser_switching.rb

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

lib/liquid/partial_cache.rb

@@ -4,14 +4,12 @@ module Liquid
   class PartialCache
     def self.load(template_name, context:, parse_context:)
       cached_partials = context.registers[:cached_partials]
-      cache_key = "#{template_name}:#{parse_context.error_mode}"
+      cache_key = template_name.to_s
       cached = cached_partials[cache_key]
       return cached if cached
 
       file_system = context.registers[:file_system]
       source      = file_system.read_template_file(template_name)
-      recorder = context.registers[TemplateRecorder::REGISTER_KEY] if defined?(TemplateRecorder)
-      recorder&.emit_file_read(template_name, source)
 
       parse_context.partial = true
 

lib/liquid/resource_limits.rb

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

lib/liquid/self_drop.rb

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

lib/liquid/standardfilters.rb

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

lib/liquid/strainer_template.rb

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

lib/liquid/tags/assign.rb

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

lib/liquid/tags/capture.rb

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

lib/liquid/tags/case.rb

@@ -23,9 +23,6 @@ module Liquid
   # @liquid_syntax_keyword second_expression An expression to be rendered when the variable's value matches `second_value`.
   # @liquid_syntax_keyword third_expression An expression to be rendered when the variable's value has no match.
   class Case < Block
-    Syntax     = /(#{QuotedFragment})/o
-    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
-
     attr_reader :blocks, :left
 
     def initialize(tag_name, markup, options)
@@ -86,35 +83,19 @@ module Liquid
 
     private
 
-    def strict2_parse(markup)
+    def parse_markup(markup)
       parser = @parse_context.new_parser(markup)
       @left = safe_parse_expression(parser)
       parser.consume(:end_of_string)
     end
 
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      if markup =~ Syntax
-        @left = parse_expression(Regexp.last_match(1))
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.case")
-      end
-    end
-
     def record_when_condition(markup)
       body = new_body
 
-      if strict2_mode?
-        parse_strict2_when(markup, body)
-      else
-        parse_lax_when(markup, body)
-      end
+      parse_when(markup, body)
     end
 
-    def parse_strict2_when(markup, body)
+    def parse_when(markup, body)
       parser = @parse_context.new_parser(markup)
 
       loop do
@@ -129,20 +110,6 @@ module Liquid
       parser.consume(:end_of_string)
     end
 
-    def parse_lax_when(markup, body)
-      while markup
-        unless markup =~ WhenSyntax
-          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
-        end
-
-        markup = Regexp.last_match(2)
-
-        block = Condition.new(@left, '==', Condition.parse_expression(parse_context, Regexp.last_match(1)))
-        block.attach(body)
-        @blocks << block
-      end
-    end
-
     def record_else_condition(markup)
       unless markup.strip.empty?
         raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else")

lib/liquid/tags/cycle.rb

@@ -15,8 +15,6 @@ module Liquid
   # @liquid_syntax
   #   {% cycle string, string, ... %}
   class Cycle < Tag
-    SimpleSyntax = /\A#{QuotedFragment}+/o
-    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
     UNNAMED_CYCLE_PATTERN = /\w+:0x\h{8}/
 
     attr_reader :variables
@@ -56,7 +54,7 @@ module Liquid
     private
 
     # cycle [name:] expression(, expression)*
-    def strict2_parse(markup)
+    def parse_markup(markup)
       p = @parse_context.new_parser(markup)
 
       @variables = []
@@ -91,35 +89,6 @@ module Liquid
       end
     end
 
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      case markup
-      when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
-        @name      = parse_expression(Regexp.last_match(1))
-        @is_named = true
-      when SimpleSyntax
-        @variables = variables_from_string(markup)
-        @name      = @variables.to_s
-        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
-      end
-    end
-
-    def variables_from_string(markup)
-      markup.split(',').collect do |var|
-        var =~ /\s*(#{QuotedFragment})\s*/o
-        next unless Regexp.last_match(1)
-
-        var = parse_expression(Regexp.last_match(1))
-        maybe_dup_lookup(var)
-      end.compact
-    end
-
     # For backwards compatibility, whenever a lookup is used in an unnamed cycle,
     # we make it so that the @variables.to_s produces different strings for cycles
     # called with the same arguments (since @variables.to_s is used as the cycle counter key)

lib/liquid/tags/decrement.rb

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

lib/liquid/tags/for.rb

@@ -25,8 +25,6 @@ module Liquid
   # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
   # @liquid_optional_param reversed [untyped] Iterate in reverse order.
   class For < Block
-    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
-
     attr_reader :collection_name, :variable_name, :limit, :from
 
     def initialize(tag_name, markup, options)
@@ -72,22 +70,7 @@ module Liquid
 
     protected
 
-    def lax_parse(markup)
-      if markup =~ Syntax
-        @variable_name   = Regexp.last_match(1)
-        collection_name  = Regexp.last_match(2)
-        @reversed        = !!Regexp.last_match(3)
-        @name            = "#{@variable_name}-#{collection_name}"
-        @collection_name = parse_expression(collection_name)
-        markup.scan(TagAttributes) do |key, value|
-          set_attribute(key, value)
-        end
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.for")
-      end
-    end
-
-    def strict_parse(markup)
+    def parse_markup(markup)
       p = @parse_context.new_parser(markup)
       @variable_name = p.consume(:id)
       raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
@@ -111,10 +94,6 @@ module Liquid
 
     private
 
-    def strict2_parse(markup)
-      strict_parse(markup)
-    end
-
     def collection_segment(context)
       offsets = context.registers[:for] ||= {}
 

lib/liquid/tags/if.rb

@@ -14,10 +14,6 @@ module Liquid
   # @liquid_syntax_keyword condition The condition to evaluate.
   # @liquid_syntax_keyword expression The expression to render if the condition is met.
   class If < Block
-    Syntax                  = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
-    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS       = %w(and or).freeze
-
     attr_reader :blocks
 
     def initialize(tag_name, markup, options)
@@ -66,10 +62,6 @@ module Liquid
 
     private
 
-    def strict2_parse(markup)
-      strict_parse(markup)
-    end
-
     def push_block(tag, markup)
       block = if tag == 'else'
         ElseCondition.new
@@ -85,27 +77,7 @@ module Liquid
       Condition.parse_expression(parse_context, markup, safe: safe)
     end
 
-    def lax_parse(markup)
-      expressions = markup.scan(ExpressionsAndOperators)
-      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
-
-      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
-
-      until expressions.empty?
-        operator = expressions.pop.to_s.strip
-
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
-
-        new_condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
-        new_condition.send(operator, condition)
-        condition = new_condition
-      end
-
-      condition
-    end
-
-    def strict_parse(markup)
+    def parse_markup(markup)
       p = @parse_context.new_parser(markup)
       condition = parse_binary_comparisons(p)
       p.consume(:end_of_string)

lib/liquid/tags/include.rb

@@ -20,10 +20,6 @@ module Liquid
   class Include < Tag
     prepend Tag::Disableable
 
-    FOR = 'for'
-    SYNTAX = /(#{QuotedFragment}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
-    Syntax = SYNTAX
-
     attr_reader :template_name_expr, :variable_name_expr, :attributes
 
     def initialize(tag_name, markup, options)
@@ -85,18 +81,12 @@ module Liquid
     alias_method :parse_context, :options
     private :parse_context
 
-    def for_loop?
-      @is_for_loop
-    end
-
-    def strict2_parse(markup)
+    def parse_markup(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)
 
@@ -111,31 +101,6 @@ module Liquid
       p.consume(:end_of_string)
     end
 
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      if markup =~ SYNTAX
-        template_name = Regexp.last_match(1)
-        with_or_for   = Regexp.last_match(3)
-        variable_name = Regexp.last_match(4)
-
-        @alias_name         = Regexp.last_match(6)
-        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
-        @template_name_expr = parse_expression(template_name)
-        @is_for_loop        = (with_or_for == FOR)
-        @attributes         = {}
-
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = parse_expression(value)
-        end
-
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.include")
-      end
-    end
-
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [

lib/liquid/tags/increment.rb

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

lib/liquid/tags/render.rb

@@ -27,7 +27,6 @@ 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
 
     disable_tags "include"
 
@@ -85,10 +84,10 @@ module Liquid
     end
 
     # render (string) (with|for expression)? (as id)? (key: value)*
-    def strict2_parse(markup)
+    def parse_markup(markup)
       p = @parse_context.new_parser(markup)
 
-      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
+      @template_name_expr = parse_expression(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")
@@ -107,32 +106,10 @@ module Liquid
       p.consume(:end_of_string)
     end
 
-    def strict2_template_name(p)
+    def template_name(p)
       p.consume(:string)
     end
 
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
-
-      template_name = Regexp.last_match(1)
-      with_or_for = Regexp.last_match(3)
-      variable_name = Regexp.last_match(4)
-
-      @alias_name = Regexp.last_match(6)
-      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
-      @template_name_expr = parse_expression(template_name)
-      @is_for_loop = (with_or_for == FOR)
-
-      @attributes = {}
-      markup.scan(TagAttributes) do |key, value|
-        @attributes[key] = parse_expression(value)
-      end
-    end
-
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [

lib/liquid/tags/table_row.rb

@@ -24,7 +24,6 @@ module Liquid
   # @liquid_optional_param offset: [number] The 1-based index to start iterating at.
   # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
   class TableRow < Block
-    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
     ALLOWED_ATTRIBUTES = ['cols', 'limit', 'offset', 'range'].freeze
 
     attr_reader :variable_name, :collection_name, :attributes
@@ -34,7 +33,7 @@ module Liquid
       parse_with_selected_parser(markup)
     end
 
-    def strict2_parse(markup)
+    def parse_markup(markup)
       p = @parse_context.new_parser(markup)
 
       @variable_name = p.consume(:id)
@@ -62,23 +61,6 @@ module Liquid
       p.consume(:end_of_string)
     end
 
-    def strict_parse(markup)
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      if markup =~ Syntax
-        @variable_name   = Regexp.last_match(1)
-        @collection_name = parse_expression(Regexp.last_match(2))
-        @attributes      = {}
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = parse_expression(value)
-        end
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.table_row")
-      end
-    end
-
     def render_to_output_buffer(context, output)
       (collection = context.evaluate(@collection_name)) || (return '')
 

lib/liquid/template.rb

@@ -16,25 +16,11 @@ module Liquid
   #
   class Template
     attr_accessor :root, :name
-    attr_reader :resource_limits, :warnings
+    attr_reader :resource_limits
 
     attr_reader :profiler
 
     class << self
-      # Sets how strict the parser should be.
-      # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
-      # :warn is the default and will give deprecation warnings when invalid syntax is used.
-      # :strict enforces correct syntax for most tags
-      # :strict2 enforces correct syntax for all tags
-      def error_mode=(mode)
-        Deprecations.warn("Template.error_mode=", "Environment#error_mode=")
-        Environment.default.error_mode = mode
-      end
-
-      def error_mode
-        Environment.default.error_mode
-      end
-
       def default_exception_renderer=(renderer)
         Deprecations.warn("Template.default_exception_renderer=", "Environment#exception_renderer=")
         Environment.default.exception_renderer = renderer
@@ -105,7 +91,6 @@ module Liquid
 
       tokenizer     = parse_context.new_tokenizer(source, start_line_number: @line_numbers && 1)
       @root         = Document.parse(tokenizer, parse_context)
-      @template_recorder_source = source.dup.freeze if defined?(TemplateRecorder) && TemplateRecorder.current
       self
     end
 
@@ -142,8 +127,6 @@ module Liquid
     def render(*args)
       return '' if @root.nil?
 
-      recording_session = TemplateRecorder.current if defined?(TemplateRecorder)
-      recording_assigns = args.first
       context = case args.first
       when Liquid::Context
         c = args.shift
@@ -154,10 +137,8 @@ module Liquid
 
         c
       when Liquid::Drop
-        drop = args.shift
-        c    = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
-        drop.context = c if drop.respond_to?(:context=)
-        c
+        drop         = args.shift
+        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
       when Hash
         Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
       when nil
@@ -183,13 +164,6 @@ module Liquid
         context.add_filters(args.pop)
       end
 
-      recording = recording_session&.begin_render(self, recording_assigns, context)
-      if recording
-        recorder_registers = context.registers.static
-        previous_recorder = recorder_registers[TemplateRecorder::REGISTER_KEY]
-        recorder_registers[TemplateRecorder::REGISTER_KEY] = recording
-      end
-
       # Retrying a render resets resource usage
       context.resource_limits.reset
 
@@ -199,34 +173,12 @@ module Liquid
 
       context.template_name ||= name
 
-      previous_error_mode = context.registers.static[:template_error_mode]
-      context.registers.static[:template_error_mode] = @error_mode
-
-      rendered_output = nil
-      render_succeeded = false
       begin
         # render the nodelist.
-        rendered_output = @root.render_to_output_buffer(context, output || +'')
-        render_succeeded = true
-        rendered_output
+        @root.render_to_output_buffer(context, output || +'')
       rescue Liquid::MemoryError => e
-        rendered_output = context.handle_error(e)
-        render_succeeded = true
-        rendered_output
+        context.handle_error(e)
       ensure
-        if previous_error_mode
-          context.registers.static[:template_error_mode] = previous_error_mode
-        else
-          context.registers.static.delete(:template_error_mode)
-        end
-        if recording
-          if previous_recorder
-            recorder_registers[TemplateRecorder::REGISTER_KEY] = previous_recorder
-          else
-            recorder_registers.delete(TemplateRecorder::REGISTER_KEY)
-          end
-          recording_session.finish_render(recording, rendered_output, context, success: render_succeeded)
-        end
         @errors = context.errors
       end
     end
@@ -257,8 +209,6 @@ module Liquid
         ParseContext.new(opts)
       end
 
-      @warnings = parse_context.warnings
-      @error_mode = parse_context.error_mode
       parse_context
     end
 

lib/liquid/template_recorder.rb

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

lib/liquid/variable.rb

@@ -30,73 +30,28 @@ module Liquid
       @parse_context = parse_context
       @line_number   = parse_context.line_number
 
-      strict_parse_with_error_mode_fallback(markup)
+      parse_with_selected_parser(markup)
     end
 
     def raw
       @markup
     end
 
-    def ==(other)
-      self.class == other.class && name == other.name && filters == other.filters
-    end
-
     def markup_context(markup)
       "in \"{{#{markup}}}\""
     end
 
-    def lax_parse(markup)
-      @filters = []
-      return unless markup =~ MarkupWithQuotedFragment
-
-      name_markup   = Regexp.last_match(1)
-      filter_markup = Regexp.last_match(2)
-      @name         = parse_context.parse_expression(name_markup)
-      if filter_markup =~ FilterMarkupRegex
-        filters = Regexp.last_match(1).scan(FilterParser)
-        filters.each do |f|
-          next unless f =~ /\w+/
-          filtername = Regexp.last_match(0)
-          filterargs = f.scan(FilterArgsRegex).flatten
-          @filters << lax_parse_filter_expressions(filtername, filterargs)
-        end
-      end
-    end
-
-    def strict_parse(markup)
+    def parse_markup(markup)
       @filters = []
       p = @parse_context.new_parser(markup)
 
       return if p.look(:end_of_string)
 
       @name = parse_context.safe_parse_expression(p)
-      while p.consume?(:pipe)
-        filtername = p.consume(:id)
-        filterargs = p.consume?(:colon) ? parse_filterargs(p) : Const::EMPTY_ARRAY
-        @filters << lax_parse_filter_expressions(filtername, filterargs)
-      end
+      @filters << parse_filter_expressions(p) while p.consume?(:pipe)
       p.consume(:end_of_string)
     end
 
-    def strict2_parse(markup)
-      @filters = []
-      p = @parse_context.new_parser(markup)
-
-      return if p.look(:end_of_string)
-
-      @name = parse_context.safe_parse_expression(p)
-      @filters << strict2_parse_filter_expressions(p) while p.consume?(:pipe)
-      p.consume(:end_of_string)
-    end
-
-    def parse_filterargs(p)
-      # first argument
-      filterargs = [p.argument]
-      # followed by comma separated others
-      filterargs << p.argument while p.consume?(:comma)
-      filterargs
-    end
-
     def render(context)
       obj = context.evaluate(@name)
 
@@ -109,14 +64,8 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      if (replayer = context.registers[TemplateRecorder::REPLAYER_REGISTER_KEY])
-        return output << replayer.replay_variable
-      end
-
-      output_start = output.length
       obj = render(context)
       render_obj_to_output(obj, output)
-      TemplateRecorder.current&.emit_variable_output(output[output_start..])
       output
     end
 
@@ -143,22 +92,6 @@ module Liquid
 
     private
 
-    def lax_parse_filter_expressions(filter_name, unparsed_args)
-      filter_args  = []
-      keyword_args = nil
-      unparsed_args.each do |a|
-        if (matches = a.match(JustTagAttributes))
-          keyword_args           ||= {}
-          keyword_args[matches[1]] = parse_context.parse_expression(matches[2])
-        else
-          filter_args << parse_context.parse_expression(a)
-        end
-      end
-      result = [filter_name, filter_args]
-      result << keyword_args if keyword_args
-      result
-    end
-
     # Surprisingly, positional and keyword arguments can be mixed.
     #
     # filter = filtername [":" filterargs?]
@@ -166,7 +99,7 @@ module Liquid
     # argument = (positional_argument | keyword_argument)
     # positional_argument = expression
     # keyword_argument = id ":" expression
-    def strict2_parse_filter_expressions(p)
+    def parse_filter_expressions(p)
       filtername = p.consume(:id)
       filter_args = []
       keyword_args = {}

lib/liquid/version.rb

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

performance/benchmark.rb

@@ -4,7 +4,6 @@ require 'benchmark/ips'
 require_relative 'theme_runner'
 
 RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
-Liquid::Environment.default.error_mode = ARGV.first.to_sym if ARGV.first
 
 profiler = ThemeRunner.new
 

performance/memory_profile.rb

@@ -53,8 +53,6 @@ class Profiler
   end
 end
 
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
-
 runner = ThemeRunner.new
 Profiler.run do |x|
   x.profile('parse') { runner.compile }

performance/profile.rb

@@ -3,7 +3,6 @@
 require 'stackprof'
 require_relative 'theme_runner'
 
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run
 

spec/ruby_liquid.rb

@@ -6,24 +6,14 @@
 
 $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,
-  ]
+  # Run core Liquid specs
+  config.features = [:core]
 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
 
@@ -38,12 +28,9 @@ LiquidSpec.render do |ctx, assigns, options|
     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
+  ctx[:template].render(context)
 end

spec/ruby_liquid_lax.rb

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

spec/ruby_liquid_with_active_support.rb

@@ -7,23 +7,14 @@
 $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,
-  ]
+  # Run core Liquid specs plus ActiveSupport SafeBuffer tests
+  config.features = [:core, :activesupport]
 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
 
@@ -38,12 +29,9 @@ LiquidSpec.render do |ctx, assigns, options|
     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
+  ctx[:template].render(context)
 end

spec/ruby_liquid_yjit.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Liquid Spec Adapter for Shopify/liquid with YJIT + strict mode + ActiveSupport
+# Liquid Spec Adapter for Shopify/liquid with YJIT + ActiveSupport
 #
 # Run with: bundle exec liquid-spec run spec/ruby_liquid_yjit.rb
 
@@ -13,24 +13,13 @@ 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,
-  ]
+  config.features = [:core, :activesupport]
 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
 
@@ -42,12 +31,9 @@ LiquidSpec.render do |ctx, assigns, options|
     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
+  ctx[:template].render(context)
 end

spec/support/liquid_spec_adapter_helper.rb

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

test/integration/assign_test.rb

@@ -39,13 +39,11 @@ class AssignTest < Minitest::Test
     assert_match_syntax_error(/assign/, '{% assign foo not values %}.')
   end
 
-  def test_assign_uses_error_mode
+  def test_assign_throws_on_unsupported_syntax
     assert_match_syntax_error(
-      "Expected dotdot but found pipe in ",
+      "Expected dotdot but found pipe",
       "{% assign foo = ('X' | downcase) %}",
-      error_mode: :strict,
     )
-    assert_template_result("", "{% assign foo = ('X' | downcase) %}", error_mode: :lax)
   end
 
   def test_expression_with_whitespace_in_square_brackets
@@ -97,46 +95,6 @@ class AssignTest < Minitest::Test
     assert_equal(12, assign_score_of('int' => 123, 'str' => 'abcd'))
   end
 
-  def test_assign_with_valid_identifier_in_strict2
-    assert_template_result("hello", "{% assign my_var = 'hello' %}{{ my_var }}", error_mode: :strict2)
-  end
-
-  def test_assign_with_hyphen_in_strict2
-    assert_template_result("hello", "{% assign my-var = 'hello' %}{{ my-var }}", error_mode: :strict2)
-  end
-
-  def test_assign_rejects_parentheses_in_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% assign (a(b(c) = 1234 %}", error_mode: :strict2)
-    end
-  end
-
-  def test_assign_rejects_brackets_in_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% assign [x.y] = 'hello' %}", error_mode: :strict2)
-    end
-  end
-
-  def test_assign_rejects_dot_in_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% assign a.b = 'hello' %}", error_mode: :strict2)
-    end
-  end
-
-  def test_assign_rejects_numeric_variable_name_in_strict2
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse("{% assign 1abc = 'hello' %}", error_mode: :strict2)
-    end
-  end
-
-  def test_assign_allows_invalid_names_in_lax
-    assert_template_result("1234", "{% assign (a(b(c) = 1234 %}{{ self['(a(b(c)'] }}", error_mode: :lax)
-  end
-
-  def test_assign_with_filter_in_strict2
-    assert_template_result("HELLO", "{% assign my_var = 'hello' | upcase %}{{ my_var }}", error_mode: :strict2)
-  end
-
   private
 
   class ObjectWrapperDrop < Liquid::Drop

test/integration/blank_body_error_handling_test.rb

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

test/integration/capture_test.rb

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

test/integration/context_test.rb

@@ -296,8 +296,8 @@ class ContextTest < Minitest::Test
   end
 
   def test_access_variable_with_hash_notation
-    assert_template_result('baz', '{{ foo }}', { "foo" => "baz" })
-    assert_template_result('baz', '{{ self[bar] }}', { 'foo' => 'baz', 'bar' => 'foo' })
+    assert_template_result('baz', '{{ ["foo"] }}', { "foo" => "baz" })
+    assert_template_result('baz', '{{ [bar] }}', { 'foo' => 'baz', 'bar' => 'foo' })
   end
 
   def test_access_hashes_with_hash_access_variables
@@ -632,11 +632,9 @@ class ContextTest < Minitest::Test
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_modes(:strict) do
-      context = Context.new
-      context.key?('unknown')
-      assert_empty(context.errors)
-    end
+    context = Context.new
+    context.key?('unknown')
+    assert_empty(context.errors)
   end
 
   def test_key_lookup_will_raise_for_missing_keys_when_strict_variables_is_enabled

test/integration/error_handling_test.rb

@@ -67,20 +67,11 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_unrecognized_operator
-    with_error_modes(:strict) do
-      assert_raises(SyntaxError) do
-        Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
-      end
+    assert_raises(SyntaxError) do
+      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
     end
   end
 
-  def test_lax_unrecognized_operator
-    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
-    assert_equal(' Liquid error: Unknown operator =! ', template.render)
-    assert_equal(1, template.errors.size)
-    assert_equal(Liquid::ArgumentError, template.errors.first.class)
-  end
-
   def test_with_line_numbers_adds_numbers_to_parser_errors
     source = <<~LIQUID
       foobar
@@ -104,25 +95,6 @@ class ErrorHandlingTest < Minitest::Test
     assert_match_syntax_error(/Liquid syntax error \(line 3\)/, source)
   end
 
-  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
-    template = Liquid::Template.parse(
-      '
-        foobar
-
-        {% if 1 =! 2 %}ok{% endif %}
-
-        bla
-            ',
-      error_mode: :warn,
-      line_numbers: true,
-    )
-
-    assert_equal(
-      ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
-      template.warnings.map(&:message),
-    )
-  end
-
   def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
     err = assert_raises(SyntaxError) do
       Liquid::Template.parse(
@@ -133,7 +105,6 @@ class ErrorHandlingTest < Minitest::Test
 
           bla
                 ',
-        error_mode: :strict,
         line_numbers: true,
       )
     end
@@ -157,34 +128,16 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_strict_error_messages
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
+      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
     end
     assert_equal('Liquid syntax error: Unexpected character = in "1 =! 2"', err.message)
 
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}', error_mode: :strict)
+      Liquid::Template.parse('{{%%%}}')
     end
     assert_equal('Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message)
   end
 
-  def test_warnings
-    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
-    assert_equal(3, template.warnings.size)
-    assert_equal('Unexpected character ~ in "~~~"', template.warnings[0].to_s(false))
-    assert_equal('Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false))
-    assert_equal('Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false))
-    assert_equal('', template.render)
-  end
-
-  def test_warning_line_numbers
-    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
-    assert_equal('Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message)
-    assert_equal('Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message)
-    assert_equal('Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message)
-    assert_equal(3, template.warnings.size)
-    assert_equal([1, 2, 3], template.warnings.map(&:line_number))
-  end
-
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
   def test_exceptions_propagate
     assert_raises(Exception) do
@@ -269,8 +222,7 @@ class ErrorHandlingTest < Minitest::Test
     assert_equal("Liquid error: comparison of Integer with String failed0", output)
 
     output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}{% assign x = 3 %}{% endif %}{{ x }}").render
-    expected = ENV["LIQUID_PARSER_MODE"] == "strict2" ? "Liquid error: comparison of Integer with String failed0" : "0"
-    assert_equal(expected, output)
+    assert_equal("0", output)
   end
 
   def test_syntax_error_is_raised_with_template_name

test/integration/expression_test.rb

@@ -27,11 +27,6 @@ class ExpressionTest < Minitest::Test
     assert_template_result("-17.42", "{{ -17.42 }}")
     assert_template_result("2.5", "{{ 2.5 }}")
 
-    with_error_modes(:lax) do
-      assert_expression_result(0.0, "0.....5")
-      assert_expression_result(0.0, "-0..1")
-    end
-
     assert_expression_result(1.5, "1.5")
 
     # this is a unfortunate quirky behavior of Liquid
@@ -56,19 +51,6 @@ class ExpressionTest < Minitest::Test
     )
   end
 
-  def test_quirky_negative_sign_expression_markup
-    result = Expression.parse("-", nil)
-    assert(result.is_a?(VariableLookup))
-    assert_equal("-", result.name)
-
-    # for this template, the expression markup is "-"
-    assert_template_result(
-      "",
-      "{{ - 'theme.css' - }}",
-      error_mode: :lax,
-    )
-  end
-
   def test_expression_cache
     skip("Liquid-C does not support Expression caching") if defined?(Liquid::C) && Liquid::C.enabled
 

test/integration/parsing_quirks_test.rb

@@ -31,58 +31,25 @@ class ParsingQuirksTest < Minitest::Test
   def test_error_on_empty_filter
     assert(Template.parse("{{test}}"))
 
-    with_error_modes(:lax) do
-      assert(Template.parse("{{|test}}"))
-    end
-
-    with_error_modes(:strict) do
-      assert_raises(SyntaxError) { Template.parse("{{|test}}") }
-      assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
-    end
+    assert_raises(Liquid::SyntaxError) { Template.parse("{{|test}}") }
+    assert_raises(Liquid::SyntaxError) { Template.parse("{{test |a|b|}}") }
   end
 
   def test_meaningless_parens_error
-    with_error_modes(:strict) do
-      assert_raises(SyntaxError) do
-        markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
+    assert_raises(SyntaxError) do
+      markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+      Template.parse("{% if #{markup} %} YES {% endif %}")
     end
   end
 
   def test_unexpected_characters_syntax_error
-    with_error_modes(:strict) do
-      assert_raises(SyntaxError) do
-        markup = "true && false"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-      assert_raises(SyntaxError) do
-        markup = "false || true"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-    end
-  end
-
-  def test_no_error_on_lax_empty_filter
-    assert(Template.parse("{{test |a|b|}}", error_mode: :lax))
-    assert(Template.parse("{{test}}", error_mode: :lax))
-    assert(Template.parse("{{|test|}}", error_mode: :lax))
-  end
-
-  def test_meaningless_parens_lax
-    with_error_modes(:lax) do
-      assigns = { 'b' => 'bar', 'c' => 'baz' }
-      markup  = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
-    end
-  end
-
-  def test_unexpected_characters_silently_eat_logic_lax
-    with_error_modes(:lax) do
+    assert_raises(SyntaxError) do
       markup = "true && false"
-      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
+      Template.parse("{% if #{markup} %} YES {% endif %}")
+    end
+    assert_raises(SyntaxError) do
       markup = "false || true"
-      assert_template_result('', "{% if #{markup} %} YES {% endif %}")
+      Template.parse("{% if #{markup} %} YES {% endif %}")
     end
   end
 
@@ -92,32 +59,6 @@ class ParsingQuirksTest < Minitest::Test
     end
   end
 
-  def test_unanchored_filter_arguments
-    with_error_modes(:lax) do
-      assert_template_result('hi', "{{ 'hi there' | split$$$:' ' | first }}")
-
-      assert_template_result('x', "{{ 'X' | downcase) }}")
-
-      # After the messed up quotes a filter without parameters (reverse) should work
-      # but one with parameters (remove) shouldn't be detected.
-      assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
-      assert_template_result('hi ', "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
-    end
-  end
-
-  def test_invalid_variables_work
-    with_error_modes(:lax) do
-      assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
-      assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
-    end
-  end
-
-  def test_extra_dots_in_ranges
-    with_error_modes(:lax) do
-      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
-    end
-  end
-
   def test_blank_variable_markup
     assert_template_result('', "{{}}")
   end
@@ -131,24 +72,4 @@ class ParsingQuirksTest < Minitest::Test
   def test_contains_in_id
     assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', { 'containsallshipments' => true })
   end
-
-  def test_incomplete_expression
-    with_error_modes(:lax) do
-      assert_template_result("false", "{{ false - }}")
-      assert_template_result("false", "{{ false > }}")
-      assert_template_result("false", "{{ false < }}")
-      assert_template_result("false", "{{ false = }}")
-      assert_template_result("false", "{{ false ! }}")
-      assert_template_result("false", "{{ false 1 }}")
-      assert_template_result("false", "{{ false a }}")
-
-      assert_template_result("false", "{% liquid assign foo = false -\n%}{{ foo }}")
-      assert_template_result("false", "{% liquid assign foo = false >\n%}{{ foo }}")
-      assert_template_result("false", "{% liquid assign foo = false <\n%}{{ foo }}")
-      assert_template_result("false", "{% liquid assign foo = false =\n%}{{ foo }}")
-      assert_template_result("false", "{% liquid assign foo = false !\n%}{{ foo }}")
-      assert_template_result("false", "{% liquid assign foo = false 1\n%}{{ foo }}")
-      assert_template_result("false", "{% liquid assign foo = false a\n%}{{ foo }}")
-    end
-  end
 end # ParsingQuirksTest

test/integration/security_test.rb

@@ -44,39 +44,32 @@ class SecurityTest < Minitest::Test
   end
 
   def test_does_not_permanently_add_filters_to_symbol_table
-    assert_no_new_symbols do
-      # MRI imprecisely marks objects found on the C stack, which can result
-      # in uninitialized memory being marked. This can even result in the test failing
-      # deterministically for a given compilation of ruby. Using a separate thread will
-      # keep these writes of the symbol pointer on a separate stack that will be garbage
-      # collected after Thread#join.
-      Thread.new do
-        test = %( {{ "some_string" | a_bad_filter }} )
-        Template.parse(test).render!
-        nil
-      end.join
+    current_symbols = Symbol.all_symbols
 
-      GC.start
-    end
+    # MRI imprecisely marks objects found on the C stack, which can result
+    # in uninitialized memory being marked. This can even result in the test failing
+    # deterministically for a given compilation of ruby. Using a separate thread will
+    # keep these writes of the symbol pointer on a separate stack that will be garbage
+    # collected after Thread#join.
+    Thread.new do
+      test = %( {{ "some_string" | a_bad_filter }} )
+      Template.parse(test).render!
+      nil
+    end.join
+
+    GC.start
+
+    assert_equal([], Symbol.all_symbols - current_symbols)
   end
 
   def test_does_not_add_drop_methods_to_symbol_table
-    assert_no_new_symbols do
-      assigns = { 'drop' => Drop.new }
-      assert_equal("", Template.parse("{{ drop.custom_method_1 }}", assigns).render!)
-      assert_equal("", Template.parse("{{ drop.custom_method_2 }}", assigns).render!)
-      assert_equal("", Template.parse("{{ drop.custom_method_3 }}", assigns).render!)
-    end
-  end
-
-  def assert_no_new_symbols
-    # Run once to trigger any first-time initialization which might create some symbols,
-    # for example autoload or lazy method parsing might create symbols on first execution.
-    yield
-
-    # Ensure no new symbols for further runs, i.e. the code does not leak symbols
     current_symbols = Symbol.all_symbols
-    yield
+
+    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
 

test/integration/self_drop_context_test.rb

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

test/integration/standard_filter_test.rb

@@ -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))
@@ -1181,8 +1174,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

test/integration/tags/cycle_tag_test.rb

@@ -91,26 +91,21 @@ class CycleTagTest < Minitest::Test
     assert_match(/Syntax Error in 'cycle' - Valid syntax: cycle \[name :\] var/, error.message)
   end
 
-  def test_cycle_tag_with_error_mode
+  def test_cycle_tag_unsupported_legacy_quirk
     # QuotedFragment is more permissive than what Parser#expression allows.
     template1 = "{% assign 5 = 'b' %}{% cycle .5, .4 %}"
     template2 = "{% cycle .5: 'a', 'b' %}"
 
-    with_error_modes(:lax, :strict) do
-      assert_template_result("b", template1)
-      assert_template_result("a", template2)
-    end
+    error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
+    error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
 
-    with_error_modes(:strict2) do
-      error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
-      error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
+    expected_error = /Liquid syntax error: \[:dot, "."\] is not a valid expression/
 
-      assert_match(/Liquid syntax error:/, error1.message)
-      assert_match(/Liquid syntax error: \[:dot, "."\] is not a valid expression/, error2.message)
-    end
+    assert_match(expected_error, error1.message)
+    assert_match(expected_error, error2.message)
   end
 
-  def test_cycle_with_trailing_elements
+  def test_cycle_with_trailing_elements_legacy_syntax
     assignments = "{% assign a = 'A' %}{% assign n = 'N' %}"
 
     template1 = "#{assignments}{% cycle       'a'  'b', 'c' %}"
@@ -119,29 +114,19 @@ class CycleTagTest < Minitest::Test
     template4 = "#{assignments}{% cycle n  e: 'a', 'b', 'c' %}"
     template5 = "#{assignments}{% cycle n  e  'a', 'b', 'c' %}"
 
-    with_error_modes(:lax, :strict) do
-      assert_template_result("a", template1)
-      assert_template_result("a", template2)
-      assert_template_result("a", template3)
-      assert_template_result("N", template4)
-      assert_template_result("N", template5)
-    end
+    error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
+    error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
+    error3 = assert_raises(Liquid::SyntaxError) { Template.parse(template3) }
+    error4 = assert_raises(Liquid::SyntaxError) { Template.parse(template4) }
+    error5 = assert_raises(Liquid::SyntaxError) { Template.parse(template5) }
 
-    with_error_modes(:strict2) do
-      error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
-      error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
-      error3 = assert_raises(Liquid::SyntaxError) { Template.parse(template3) }
-      error4 = assert_raises(Liquid::SyntaxError) { Template.parse(template4) }
-      error5 = assert_raises(Liquid::SyntaxError) { Template.parse(template5) }
+    expected_error = /Expected end_of_string but found/
 
-      expected_error = /Expected end_of_string but found/
-
-      assert_match(expected_error, error1.message)
-      assert_match(expected_error, error2.message)
-      assert_match(expected_error, error3.message)
-      assert_match(expected_error, error4.message)
-      assert_match(expected_error, error5.message)
-    end
+    assert_match(expected_error, error1.message)
+    assert_match(expected_error, error2.message)
+    assert_match(expected_error, error3.message)
+    assert_match(expected_error, error4.message)
+    assert_match(expected_error, error5.message)
   end
 
   def test_cycle_name_with_invalid_expression
@@ -151,14 +136,8 @@ class CycleTagTest < Minitest::Test
       {% endfor %}
     LIQUID
 
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+    assert_match(/Unexpected character =/, error.message)
   end
 
   def test_cycle_variable_with_invalid_expression
@@ -168,13 +147,7 @@ class CycleTagTest < Minitest::Test
       {% endfor %}
     LIQUID
 
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+    assert_match(/Unexpected character =/, error.message)
   end
 end

test/integration/tags/include_tag_test.rb

@@ -204,23 +204,13 @@ class IncludeTagTest < Minitest::Test
     )
   end
 
-  def test_strict2_parsing_errors
-    with_error_modes(:lax, :strict) do
-      assert_template_result(
-        'hello value1 value2',
-        '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-        partials: { 'snippet' => 'hello {{ arg1 }} {{ arg2 }}' },
-      )
-    end
-
-    with_error_modes(:strict2) do
-      assert_syntax_error(
-        '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-      )
-      assert_syntax_error(
-        '{% include "snippet" | filter %}',
-      )
-    end
+  def test_parsing_errors_for_legacy_quirk
+    assert_syntax_error(
+      '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
+    )
+    assert_syntax_error(
+      '{% include "snippet" | filter %}',
+    )
   end
 
   def test_optional_commas
@@ -301,16 +291,10 @@ class IncludeTagTest < Minitest::Test
     env = Liquid::Environment.build(file_system: TestFileSystem.new)
 
     assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", error_mode: :strict, environment: env).render!("template" => '{{ "X" || downcase }}')
-    end
-    with_error_modes(:lax) do
-      assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true, environment: env).render!("template" => '{{ "X" || downcase }}'))
+      Template.parse("{% include template %}", environment: env).render!("template" => '{{ "X" || downcase }}')
     end
     assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale], environment: env).render!("template" => '{{ "X" || downcase }}')
-    end
-    with_error_modes(:lax) do
-      assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode], environment: env).render!("template" => '{{ "X" || downcase }}'))
+      Template.parse("{% include template %}", include_options_blacklist: [:locale], environment: env).render!("template" => '{{ "X" || downcase }}')
     end
   end
 
@@ -365,7 +349,7 @@ class IncludeTagTest < Minitest::Test
       file_system: StubFileSystem.new('simple' => 'simple'),
     )
 
-    template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn, environment: env)
+    template = Liquid::Template.parse("{% include 'simple' %}", environment: env)
     template.render(nil, strict_variables: true)
 
     assert_equal([], template.errors)
@@ -404,84 +388,21 @@ class IncludeTagTest < Minitest::Test
   def test_include_template_with_invalid_expression
     template = "{% include foo=>bar %}"
 
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+    assert_match(/Unexpected character =/, error.message)
   end
 
   def test_include_with_invalid_expression
     template = '{% include "snippet" with foo=>bar %}'
 
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+    assert_match(/Unexpected character =/, error.message)
   end
 
   def test_include_attribute_with_invalid_expression
     template = '{% include "snippet", key: foo=>bar %}'
 
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
-  end
-
-  def test_include_for_loop_true_with_for_keyword
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'product' for products %}")
-      include_node = template.root.nodelist.first
-
-      assert(include_node.for_loop?, "Expected for_loop? to be true for 'for' keyword")
-    end
-  end
-
-  def test_include_for_loop_false_with_with_keyword
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'product' with product %}")
-      include_node = template.root.nodelist.first
-
-      refute(include_node.for_loop?, "Expected for_loop? to be false for 'with' keyword")
-    end
-  end
-
-  def test_include_for_loop_false_without_keyword
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'header' %}")
-      include_node = template.root.nodelist.first
-
-      refute(include_node.for_loop?, "Expected for_loop? to be false when no keyword")
-    end
-  end
-
-  def test_include_for_loop_with_alias
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'product' for products as item %}")
-      include_node = template.root.nodelist.first
-
-      assert(include_node.for_loop?, "Expected for_loop? to be true for 'for' with alias")
-    end
-  end
-
-  def test_include_with_keyword_and_alias
-    with_error_modes(:lax, :strict, :strict2) do
-      template = Template.parse("{% include 'product' with products[0] as item %}")
-      include_node = template.root.nodelist.first
-
-      refute(include_node.for_loop?, "Expected for_loop? to be false for 'with' with alias")
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+    assert_match(/Unexpected character =/, error.message)
   end
 end # IncludeTagTest

test/integration/tags/increment_tag_test.rb

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

test/integration/tags/render_tag_test.rb

@@ -105,23 +105,13 @@ class RenderTagTest < Minitest::Test
     assert_syntax_error("{% assign name = 'snippet' %}{% render name %}")
   end
 
-  def test_strict2_parsing_errors
-    with_error_modes(:lax, :strict) do
-      assert_template_result(
-        'hello value1 value2',
-        '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-        partials: { 'snippet' => 'hello {{ arg1 }} {{ arg2 }}' },
-      )
-    end
-
-    with_error_modes(:strict2) do
-      assert_syntax_error(
-        '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-      )
-      assert_syntax_error(
-        '{% render "snippet" | filter %}',
-      )
-    end
+  def test_parsing_errors_legacy_syntax
+    assert_syntax_error(
+      '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
+    )
+    assert_syntax_error(
+      '{% render "snippet" | filter %}',
+    )
   end
 
   def test_optional_commas
@@ -174,16 +164,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
 
@@ -317,27 +307,13 @@ class RenderTagTest < Minitest::Test
 
   def test_render_with_invalid_expression
     template = '{% render "snippet" with foo=>bar %}'
-
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+    assert_match(/Unexpected character =/, error.message)
   end
 
   def test_render_attribute_with_invalid_expression
     template = '{% render "snippet", key: foo=>bar %}'
-
-    with_error_modes(:lax, :strict) do
-      refute_nil(Template.parse(template))
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+    assert_match(/Unexpected character =/, error.message)
   end
 end

test/integration/tags/table_row_test.rb

@@ -188,29 +188,6 @@ class TableRowTest < Minitest::Test
     assert_template_result(expected_output, template)
   end
 
-  def test_table_row_renders_correct_error_message_for_invalid_parameters
-    assert_template_result(
-      "Liquid error (line 1): invalid integer",
-      '{% tablerow n in (1...10) limit:true %} {{n}} {% endtablerow %}',
-      error_mode: :warn,
-      render_errors: true,
-    )
-
-    assert_template_result(
-      "Liquid error (line 1): invalid integer",
-      '{% tablerow n in (1...10) offset:true %} {{n}} {% endtablerow %}',
-      error_mode: :warn,
-      render_errors: true,
-    )
-
-    assert_template_result(
-      "Liquid error (line 1): invalid integer",
-      '{% tablerow n in (1...10) cols:true %} {{n}} {% endtablerow %}',
-      render_errors: true,
-      error_mode: :warn,
-    )
-  end
-
   def test_table_row_handles_interrupts
     assert_template_result(
       "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td></tr>\n",
@@ -259,7 +236,7 @@ class TableRowTest < Minitest::Test
     )
   end
 
-  def test_tablerow_with_cols_attribute_in_strict2_mode
+  def test_tablerow_with_cols_attribute
     template = <<~LIQUID.chomp
       {% tablerow i in (1..6) cols: 3 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -270,12 +247,10 @@ 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
-      assert_template_result(expected, template)
-    end
+    assert_template_result(expected, template)
   end
 
-  def test_tablerow_with_limit_attribute_in_strict2_mode
+  def test_tablerow_with_limit_attribute
     template = <<~LIQUID.chomp
       {% tablerow i in (1..10) limit: 3 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -285,12 +260,10 @@ 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
-      assert_template_result(expected, template)
-    end
+    assert_template_result(expected, template)
   end
 
-  def test_tablerow_with_offset_attribute_in_strict2_mode
+  def test_tablerow_with_offset_attribute
     template = <<~LIQUID.chomp
       {% tablerow i in (1..5) offset: 2 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -300,12 +273,10 @@ 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
-      assert_template_result(expected, template)
-    end
+    assert_template_result(expected, template)
   end
 
-  def test_tablerow_with_range_attribute_in_strict2_mode
+  def test_tablerow_with_range_attribute
     template = <<~LIQUID.chomp
       {% tablerow i in (1..3) range: (1..10) %}{{ i }}{% endtablerow %}
     LIQUID
@@ -315,12 +286,10 @@ 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
-      assert_template_result(expected, template)
-    end
+    assert_template_result(expected, template)
   end
 
-  def test_tablerow_with_multiple_attributes_in_strict2_mode
+  def test_tablerow_with_multiple_attributes
     template = <<~LIQUID.chomp
       {% tablerow i in (1..10) cols: 2, limit: 4, offset: 1 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -331,12 +300,10 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">4</td><td class="col2">5</td></tr>
     OUTPUT
 
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template)
-    end
+    assert_template_result(expected, template)
   end
 
-  def test_tablerow_with_variable_collection_in_strict2_mode
+  def test_tablerow_with_variable_collection
     template = <<~LIQUID.chomp
       {% tablerow n in numbers cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -347,12 +314,10 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template, { 'numbers' => [1, 2, 3, 4] })
-    end
+    assert_template_result(expected, template, { 'numbers' => [1, 2, 3, 4] })
   end
 
-  def test_tablerow_with_dotted_access_in_strict2_mode
+  def test_tablerow_with_dotted_access
     template = <<~LIQUID.chomp
       {% tablerow n in obj.numbers cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -363,12 +328,10 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template, { 'obj' => { 'numbers' => [1, 2, 3, 4] } })
-    end
+    assert_template_result(expected, template, { 'obj' => { 'numbers' => [1, 2, 3, 4] } })
   end
 
-  def test_tablerow_with_bracketed_access_in_strict2_mode
+  def test_tablerow_with_bracketed_access
     template = <<~LIQUID.chomp
       {% tablerow n in obj["numbers"] cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -378,12 +341,10 @@ class TableRowTest < Minitest::Test
       <td class="col1">10</td><td class="col2">20</td></tr>
     OUTPUT
 
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template, { 'obj' => { 'numbers' => [10, 20] } })
-    end
+    assert_template_result(expected, template, { 'obj' => { 'numbers' => [10, 20] } })
   end
 
-  def test_tablerow_without_attributes_in_strict2_mode
+  def test_tablerow_without_attributes
     template = <<~LIQUID.chomp
       {% tablerow i in (1..3) %}{{ i }}{% endtablerow %}
     LIQUID
@@ -393,30 +354,24 @@ 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
-      assert_template_result(expected, template)
-    end
+    assert_template_result(expected, template)
   end
 
-  def test_tablerow_without_in_keyword_in_strict2_mode
+  def test_tablerow_without_in_keyword
     template = '{% tablerow i (1..10) %}{{ i }}{% endtablerow %}'
 
-    with_error_modes(:strict2) do
-      error = assert_raises(SyntaxError) { Template.parse(template) }
-      assert_equal("Liquid syntax error: For loops require an 'in' clause in \"i (1..10)\"", error.message)
-    end
+    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
 
-  def test_tablerow_with_multiple_invalid_attributes_reports_first_in_strict2_mode
+  def test_tablerow_with_multiple_invalid_attributes_reports_first
     template = '{% tablerow i in (1..10) invalid1: 5, invalid2: 10 %}{{ i }}{% endtablerow %}'
 
-    with_error_modes(:strict2) do
-      error = assert_raises(SyntaxError) { Template.parse(template) }
-      assert_equal("Liquid syntax error: Invalid attribute 'invalid1' in tablerow loop. Valid attributes are cols, limit, offset, and range in \"i in (1..10) invalid1: 5, invalid2: 10\"", error.message)
-    end
+    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
 
-  def test_tablerow_with_empty_collection_in_strict2_mode
+  def test_tablerow_with_empty_collection
     template = <<~LIQUID.chomp
       {% tablerow i in empty_array cols: 2 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -426,43 +381,18 @@ class TableRowTest < Minitest::Test
       </tr>
     OUTPUT
 
-    with_error_modes(:strict2) do
-      assert_template_result(expected, template, { 'empty_array' => [] })
-    end
+    assert_template_result(expected, template, { 'empty_array' => [] })
   end
 
-  def test_tablerow_with_invalid_attribute_strict_vs_strict2
+  def test_tablerow_with_invalid_attribute
     template = '{% tablerow i in (1..5) invalid_attr: 10 %}{{ i }}{% endtablerow %}'
-
-    expected = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td><td class="col4">4</td><td class="col5">5</td></tr>
-    OUTPUT
-
-    with_error_modes(:lax, :strict) do
-      assert_template_result(expected, template)
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(SyntaxError) { Template.parse(template) }
-      assert_match(/Invalid attribute 'invalid_attr'/, error.message)
-    end
+    error = assert_raises(SyntaxError) { Template.parse(template) }
+    assert_match(/Invalid attribute 'invalid_attr'/, error.message)
   end
 
-  def test_tablerow_with_invalid_expression_strict_vs_strict2
+  def test_tablerow_with_invalid_expression
     template = '{% tablerow i in (1..5) limit: foo=>bar %}{{ i }}{% endtablerow %}'
-
-    with_error_modes(:lax, :strict) do
-      expected = <<~OUTPUT
-        <tr class="row1">
-        </tr>
-      OUTPUT
-      assert_template_result(expected, template)
-    end
-
-    with_error_modes(:strict2) do
-      error = assert_raises(SyntaxError) { Template.parse(template) }
-      assert_match(/Unexpected character =/, error.message)
-    end
+    error = assert_raises(SyntaxError) { Template.parse(template) }
+    assert_match(/Unexpected character =/, error.message)
   end
 end

test/integration/template_recorder_test.rb

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

test/integration/template_test.rb

@@ -44,16 +44,6 @@ class TemplateTest < Minitest::Test
     assert_equal('from instance assigns', t.parse("{{ foo }}").render!)
   end
 
-  def test_warnings_is_not_exponential_time
-    str = "false"
-    100.times do
-      str = "{% if true %}true{% else %}#{str}{% endif %}"
-    end
-
-    t = Template.parse(str)
-    assert_equal([], Timeout.timeout(1) { t.warnings })
-  end
-
   def test_instance_assigns_persist_on_same_template_parsing_between_renders
     t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
     assert_equal('foo', t.render!)
@@ -179,86 +169,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 %}")
@@ -339,7 +249,7 @@ class TemplateTest < Minitest::Test
   end
 
   def test_nil_value_does_not_raise
-    t      = Template.parse("some{{x}}thing", error_mode: :strict)
+    t      = Template.parse("some{{x}}thing")
     result = t.render!({ 'x' => nil }, strict_variables: true)
 
     assert_equal(0, t.errors.count)

test/integration/variable_test.rb

@@ -55,7 +55,7 @@ class VariableTest < Minitest::Test
 
   def test_expression_with_whitespace_in_square_brackets
     assert_template_result('result', "{{ a[ 'b' ] }}", { 'a' => { 'b' => 'result' } })
-    assert_template_result('result', "{{ a[ self[ 'b' ] ] }}", { 'b' => 'c', 'a' => { 'c' => 'result' } })
+    assert_template_result('result', "{{ a[ [ 'b' ] ] }}", { 'b' => 'c', 'a' => { 'c' => 'result' } })
   end
 
   def test_ignore_unknown
@@ -135,17 +135,17 @@ class VariableTest < Minitest::Test
   end
 
   def test_dynamic_find_var
-    assert_template_result('bar', '{{ self[key] }}', { 'key' => 'foo', 'foo' => 'bar' })
+    assert_template_result('bar', '{{ [key] }}', { 'key' => 'foo', 'foo' => 'bar' })
   end
 
   def test_raw_value_variable
-    assert_template_result('bar', '{{ self[key] }}', { 'key' => 'foo', 'foo' => 'bar' })
+    assert_template_result('bar', '{{ [key] }}', { 'key' => 'foo', 'foo' => 'bar' })
   end
 
   def test_dynamic_find_var_with_drop
     assert_template_result(
       'bar',
-      '{{ self[list[settings.zero]] }}',
+      '{{ [list[settings.zero]] }}',
       {
         'list' => ['foo'],
         'settings' => SettingsDrop.new("zero" => 0),
@@ -155,7 +155,7 @@ class VariableTest < Minitest::Test
 
     assert_template_result(
       'foo',
-      '{{ self[list[settings.zero]["foo"]] }}',
+      '{{ [list[settings.zero]["foo"]] }}',
       {
         'list' => [{ 'foo' => 'bar' }],
         'settings' => SettingsDrop.new("zero" => 0),
@@ -176,102 +176,33 @@ class VariableTest < Minitest::Test
     )
   end
 
-  def test_variable_lookup_should_not_hang_with_invalid_syntax
-    Timeout.timeout(1) do
-      assert_template_result(
-        'bar',
-        "{{['foo'}}",
-        {
-          'foo' => 'bar',
-        },
-        error_mode: :lax,
-      )
-    end
-
-    very_long_key = "1234567890" * 100
-
-    template_list = [
-      "{{['#{very_long_key}']}}", # valid
-      "{{['#{very_long_key}'}}", # missing closing bracket
-      "{{[['#{very_long_key}']}}", # extra open bracket
-    ]
-
-    template_list.each do |template|
-      Timeout.timeout(1) do
-        assert_template_result(
-          'bar',
-          template,
-          {
-            very_long_key => 'bar',
-          },
-          error_mode: :lax,
-        )
-      end
-    end
-  end
-
   def test_filter_with_single_trailing_comma
     template = '{{ "hello" | append: "world", }}'
 
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('helloworld', template)
-    end
+    assert_template_result('helloworld', template)
   end
 
   def test_multiple_filters_with_trailing_commas
     template = '{{ "hello" | append: "1", | append: "2", }}'
 
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('hello12', template)
-    end
+    assert_template_result('hello12', template)
   end
 
   def test_filter_with_colon_but_no_arguments
     template = '{{ "test" | upcase: }}'
 
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('TEST', template)
-    end
+    assert_template_result('TEST', template)
   end
 
   def test_filter_chain_with_colon_no_args
     template = '{{ "test" | append: "x" | upcase: }}'
 
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('TESTX', template)
-    end
+    assert_template_result('TESTX', template)
   end
 
   def test_combining_trailing_comma_and_empty_args
     template = '{{ "test" | append: "x", | upcase: }}'
 
-    with_error_modes(:strict) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-      assert_match(/is not a valid expression/, error.message)
-    end
-
-    with_error_modes(:strict2) do
-      assert_template_result('TESTX', template)
-    end
+    assert_template_result('TESTX', template)
   end
 end

test/test_helper.rb

@@ -8,13 +8,6 @@ $LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
 require 'liquid.rb'
 require 'liquid/profiler'
 
-mode = :strict
-if (env_mode = ENV['LIQUID_PARSER_MODE'])
-  puts "-- #{env_mode.upcase} ERROR MODE"
-  mode = env_mode.to_sym
-end
-Liquid::Environment.default.error_mode = mode
-
 if Minitest.const_defined?('Test')
   # We're on Minitest 5+. Nothing to do here.
 else
@@ -34,27 +27,27 @@ module Minitest
 
     def assert_template_result(
       expected, template, assigns = {},
-      message: nil, partials: nil, error_mode: Liquid::Environment.default.error_mode, render_errors: false,
+      message: nil, partials: nil, render_errors: false,
       template_factory: nil
     )
       file_system = StubFileSystem.new(partials || {})
       environment = Liquid::Environment.build(file_system: file_system)
-      template = Liquid::Template.parse(template, line_numbers: true, error_mode: error_mode&.to_sym, environment: environment)
+      template = Liquid::Template.parse(template, line_numbers: true, environment: environment)
       registers = Liquid::Registers.new(file_system: file_system, template_factory: template_factory)
       context = Liquid::Context.build(static_environments: assigns, rethrow_errors: !render_errors, registers: registers, environment: environment)
       output = template.render(context)
       assert_equal(expected, output, message)
     end
 
-    def assert_match_syntax_error(match, template, error_mode: nil)
+    def assert_match_syntax_error(match, template)
       exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template, line_numbers: true, error_mode: error_mode&.to_sym).render
+        Template.parse(template, line_numbers: true).render
       end
       assert_match(match, exception.message)
     end
 
-    def assert_syntax_error(template, error_mode: nil)
-      assert_match_syntax_error("", template, error_mode: error_mode)
+    def assert_syntax_error(template)
+      assert_match_syntax_error("", template)
     end
 
     def assert_usage_increment(name, times: 1)
@@ -82,16 +75,6 @@ module Minitest
       Environment.dangerously_override(environment, &blk)
     end
 
-    def with_error_modes(*modes)
-      old_mode = Liquid::Environment.default.error_mode
-      modes.each do |mode|
-        Liquid::Environment.default.error_mode = mode
-        yield
-      end
-    ensure
-      Liquid::Environment.default.error_mode = old_mode
-    end
-
     def with_custom_tag(tag_name, tag_class, &block)
       environment = Liquid::Environment.default.dup
       environment.register_tag(tag_name, tag_class)

test/unit/condition_unit_test.rb

@@ -166,29 +166,8 @@ class ConditionUnitTest < Minitest::Test
     assert_includes(err.lines.map(&:strip), expected)
   end
 
-  def test_parse_expression_in_strict_mode
-    environment = Environment.build(error_mode: :strict)
-    parse_context = ParseContext.new(environment: environment)
-    result = Condition.parse_expression(parse_context, 'product.title')
-
-    assert_instance_of(VariableLookup, result)
-    assert_equal('product', result.name)
-    assert_equal(['title'], result.lookups)
-  end
-
-  def test_parse_expression_in_strict2_mode_raises_internal_error
-    environment = Environment.build(error_mode: :strict2)
-    parse_context = ParseContext.new(environment: environment)
-
-    error = assert_raises(Liquid::InternalError) do
-      Condition.parse_expression(parse_context, 'product.title')
-    end
-
-    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
-  end
-
-  def test_parse_expression_with_safe_true_in_strict2_mode
-    environment = Environment.build(error_mode: :strict2)
+  def test_parse_expression_with_safe_true
+    environment = Environment.build
     parse_context = ParseContext.new(environment: environment)
     result = Condition.parse_expression(parse_context, 'product.title', safe: true)
 
@@ -197,6 +176,17 @@ class ConditionUnitTest < Minitest::Test
     assert_equal(['title'], result.lookups)
   end
 
+  def test_parse_expression_raises_internal_error_if_not_safe
+    environment = Environment.build
+    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/, error.message)
+  end
+
   # Tests for blank? comparison without ActiveSupport
   #
   # Ruby's standard library does not include blank? on String, Array, Hash, etc.

test/unit/parse_context_unit_test.rb

@@ -6,118 +6,81 @@ class ParseContextUnitTest < Minitest::Test
   include Liquid
 
   def test_safe_parse_expression_with_variable_lookup
-    parser_strict = strict_parse_context.new_parser('product.title')
-    result_strict = strict_parse_context.safe_parse_expression(parser_strict)
+    parser = parse_context.new_parser('product.title')
+    result = parse_context.safe_parse_expression(parser)
 
-    parser_strict2 = strict2_parse_context.new_parser('product.title')
-    result_strict2 = strict2_parse_context.safe_parse_expression(parser_strict2)
-
-    assert_instance_of(VariableLookup, result_strict)
-    assert_equal('product', result_strict.name)
-    assert_equal(['title'], result_strict.lookups)
-
-    assert_instance_of(VariableLookup, result_strict2)
-    assert_equal('product', result_strict2.name)
-    assert_equal(['title'], result_strict2.lookups)
+    assert_instance_of(VariableLookup, result)
+    assert_equal('product', result.name)
+    assert_equal(['title'], result.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 = 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 = assert_raises(Liquid::SyntaxError) do
+      parse_context.safe_parse_expression(parser)
     end
 
-    assert_match(/is not a valid expression/, error_strict2.message)
+    assert_match(/is not a valid expression/, error.message)
   end
 
   def test_parse_expression_with_variable_lookup
-    result_strict = strict_parse_context.parse_expression('product.title')
-
-    assert_instance_of(VariableLookup, result_strict)
-    assert_equal('product', result_strict.name)
-    assert_equal(['title'], result_strict.lookups)
-
     error = assert_raises(Liquid::InternalError) do
-      strict2_parse_context.parse_expression('product.title')
+      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/, error.message)
   end
 
   def test_parse_expression_with_safe_true
-    result_strict = strict_parse_context.parse_expression('product.title', safe: true)
+    result = parse_context.parse_expression('product.title', safe: true)
 
-    assert_instance_of(VariableLookup, result_strict)
-    assert_equal('product', result_strict.name)
-    assert_equal(['title'], result_strict.lookups)
-
-    result_strict2 = strict2_parse_context.parse_expression('product.title', safe: true)
-
-    assert_instance_of(VariableLookup, result_strict2)
-    assert_equal('product', result_strict2.name)
-    assert_equal(['title'], result_strict2.lookups)
+    assert_instance_of(VariableLookup, result)
+    assert_equal('product', result.name)
+    assert_equal(['title'], result.lookups)
   end
 
   def test_parse_expression_with_empty_string
-    result_strict = strict_parse_context.parse_expression('')
-    assert_nil(result_strict)
-
     error = assert_raises(Liquid::InternalError) do
-      strict2_parse_context.parse_expression('')
+      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/, 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 = parse_context.parse_expression('', safe: true)
+    assert_nil(result)
   end
 
   def test_safe_parse_expression_advances_parser_pointer
-    parser = strict2_parse_context.new_parser('foo, bar')
+    parser = parse_context.new_parser('foo, bar')
 
     # safe_parse_expression consumes "foo"
-    first_result = strict2_parse_context.safe_parse_expression(parser)
+    first_result = 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 = 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
+    result = parse_context.parse_expression('   ', safe: true)
     assert_nil(result)
   end
 
   private
 
-  def strict_parse_context
-    @strict_parse_context ||= ParseContext.new(
-      environment: Environment.build(error_mode: :strict),
-    )
-  end
-
-  def strict2_parse_context
-    @strict2_parse_context ||= ParseContext.new(
-      environment: Environment.build(error_mode: :strict2),
+  def parse_context
+    @parse_context ||= ParseContext.new(
+      environment: Environment.build,
     )
   end
 end

test/unit/partial_cache_unit_test.rb

@@ -175,7 +175,7 @@ class PartialCacheUnitTest < Minitest::Test
     assert_equal('some/path/my_partial', partial.name)
   end
 
-  def test_includes_error_mode_into_template_cache
+  def test_cache_key
     template_factory = StubTemplateFactory.new
     context = Liquid::Context.build(
       registers: {
@@ -184,16 +184,14 @@ class PartialCacheUnitTest < Minitest::Test
       },
     )
 
-    [:lax, :warn, :strict, :strict2].each do |error_mode|
-      Liquid::PartialCache.load(
-        'my_partial',
-        context: context,
-        parse_context: Liquid::ParseContext.new(error_mode: error_mode),
-      )
-    end
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new,
+    )
 
     assert_equal(
-      ["my_partial:lax", "my_partial:warn", "my_partial:strict", "my_partial:strict2"],
+      ["my_partial"],
       context.registers[:cached_partials].keys,
     )
   end

test/unit/resource_limits_unit_test.rb

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

test/unit/tags/case_tag_unit_test.rb

@@ -20,15 +20,9 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_modes(:lax, :strict) do
-      assert_template_result("one", template)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-
-      assert_match(/Expected end_of_string but found/, error.message)
-    end
+    assert_match(/Expected end_of_string but found/, error.message)
   end
 
   def test_case_when_with_trailing_element
@@ -41,15 +35,9 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_modes(:lax, :strict) do
-      assert_template_result("one", template)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-
-      assert_match(/Expected end_of_string but found/, error.message)
-    end
+    assert_match(/Expected end_of_string but found/, error.message)
   end
 
   def test_case_when_with_comma
@@ -62,9 +50,7 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_modes(:lax, :strict, :strict2) do
-      assert_template_result("one", template)
-    end
+    assert_template_result("one", template)
   end
 
   def test_case_when_with_or
@@ -77,9 +63,7 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_modes(:lax, :strict, :strict2) do
-      assert_template_result("one", template)
-    end
+    assert_template_result("one", template)
   end
 
   def test_case_when_empty
@@ -92,14 +76,12 @@ class CaseTagUnitTest < Minitest::Test
       {%- 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
+    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
 
   def test_case_with_invalid_expression
@@ -113,15 +95,9 @@ class CaseTagUnitTest < Minitest::Test
     LIQUID
     assigns = { 'foo' => { 'bar' => 'baz' } }
 
-    with_error_modes(:lax, :strict) do
-      assert_template_result("one", template, assigns)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template, assigns) }
 
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-
-      assert_match(/Unexpected character =/, error.message)
-    end
+    assert_match(/Unexpected character =/, error.message)
   end
 
   def test_case_when_with_invalid_expression
@@ -135,14 +111,8 @@ class CaseTagUnitTest < Minitest::Test
     LIQUID
     assigns = { 'foo' => { 'bar' => 'baz' } }
 
-    with_error_modes(:lax, :strict) do
-      assert_template_result("one", template, assigns)
-    end
+    error = assert_raises(Liquid::SyntaxError) { Template.parse(template, assigns) }
 
-    with_error_modes(:strict2) do
-      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-
-      assert_match(/Unexpected character =/, error.message)
-    end
+    assert_match(/Unexpected character =/, error.message)
   end
 end

test/unit/variable_unit_test.rb

@@ -72,12 +72,6 @@ class VariableUnitTest < Minitest::Test
     assert_equal([['replace', ['foo', 'bar']], ['textileze', []]], var.filters)
   end
 
-  def test_symbol
-    var = create_variable("http://disney.com/logo.gif | image: 'med' ", error_mode: :lax)
-    assert_equal(VariableLookup.new('http://disney.com/logo.gif'), var.name)
-    assert_equal([['image', ['med']]], var.filters)
-  end
-
   def test_string_to_filter
     var = create_variable("'http://disney.com/logo.gif' | image: 'med' ")
     assert_equal('http://disney.com/logo.gif', var.name)
@@ -108,11 +102,9 @@ class VariableUnitTest < Minitest::Test
     assert_equal(VariableLookup.new('foo-bar'), create_variable('foo-bar').name)
     assert_equal(VariableLookup.new('foo-bar-2'), create_variable('foo-bar-2').name)
 
-    with_error_modes(:strict) do
-      assert_raises(Liquid::SyntaxError) { create_variable('foo - bar') }
-      assert_raises(Liquid::SyntaxError) { create_variable('-foo') }
-      assert_raises(Liquid::SyntaxError) { create_variable('2foo') }
-    end
+    assert_raises(Liquid::SyntaxError) { create_variable('foo - bar') }
+    assert_raises(Liquid::SyntaxError) { create_variable('-foo') }
+    assert_raises(Liquid::SyntaxError) { create_variable('2foo') }
   end
 
   def test_string_with_special_chars
@@ -131,70 +123,38 @@ class VariableUnitTest < Minitest::Test
     assert_equal([['things', [], { 'greeting' => 'world', 'farewell' => 'goodbye' }]], var.filters)
   end
 
-  def test_lax_filter_argument_parsing
-    var = create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ), error_mode: :lax)
-    assert_equal(VariableLookup.new('number_of_comments'), var.name)
-    assert_equal([['pluralize', ['comment', 'comments']]], var.filters)
+  def test_filter_argument_parsing
+    # optional colon
+    var = create_variable(%(n | f1 | f2:))
+    assert_equal([['f1', []], ['f2', []]], var.filters)
 
-    # missing does not throws error
-    create_variable(%(n | f1: ,), error_mode: :lax)
-    create_variable(%(n | f1: ,| f2), error_mode: :lax)
+    # missing argument throws error
+    assert_raises(SyntaxError) { create_variable(%(n | f1: ,)) }
+    assert_raises(SyntaxError) { create_variable(%(n | f1: ,| f2)) }
 
-    # arg does not require colon, but ignores args :O, also ignores first kwarg since it splits on ':'
-    var = create_variable(%(n | f1 1 | f2 k1: v1), error_mode: :lax)
-    assert_equal([['f1', []], ['f2', [VariableLookup.new('v1')]]], var.filters)
+    # arg requires colon
+    assert_raises(SyntaxError) { create_variable(%(n | f1 1)) }
+
+    # trailing comma doesn't throw
+    create_variable(%(n | f1: 1, 2, 3, | f2:))
+
+    # missing comma throws error
+    assert_raises(SyntaxError) { create_variable(%(n | filter: 1 2, 3)) }
 
     # positional and kwargs parsing
-    var = create_variable(%(n | filter: 1, 2, 3 | filter2: k1: 1, k2: 2), error_mode: :lax)
+    var = create_variable(%(n | filter: 1, 2, 3 | filter2: k1: 1, k2: 2))
     assert_equal([['filter', [1, 2, 3]], ['filter2', [], { "k1" => 1, "k2" => 2 }]], var.filters)
 
+    # positional and kwargs mixed
+    var = create_variable(%(n | filter: 'a', 'b', key1: 1, key2: 2, 'c'))
+    assert_equal([["filter", ["a", "b", "c"], { "key1" => 1, "key2" => 2 }]], var.filters)
+
     # positional and kwargs intermixed (pos1, key1: val1, pos2)
-    var = create_variable(%(n | link_to: class: "black", "https://example.com", title: "title"), error_mode: :lax)
+    var = create_variable(%(n | link_to: class: "black", "https://example.com", title: "title"))
     assert_equal([['link_to', ["https://example.com"], { "class" => "black", "title" => "title" }]], var.filters)
-  end
 
-  def test_strict_filter_argument_parsing
-    with_error_modes(:strict) do
-      assert_raises(SyntaxError) do
-        create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ))
-      end
-    end
-  end
-
-  def test_strict2_filter_argument_parsing
-    with_error_modes(:strict2) do
-      # optional colon
-      var = create_variable(%(n | f1 | f2:))
-      assert_equal([['f1', []], ['f2', []]], var.filters)
-
-      # missing argument throws error
-      assert_raises(SyntaxError) { create_variable(%(n | f1: ,)) }
-      assert_raises(SyntaxError) { create_variable(%(n | f1: ,| f2)) }
-
-      # arg requires colon
-      assert_raises(SyntaxError) { create_variable(%(n | f1 1)) }
-
-      # trailing comma doesn't throw
-      create_variable(%(n | f1: 1, 2, 3, | f2:))
-
-      # missing comma throws error
-      assert_raises(SyntaxError) { create_variable(%(n | filter: 1 2, 3)) }
-
-      # positional and kwargs parsing
-      var = create_variable(%(n | filter: 1, 2, 3 | filter2: k1: 1, k2: 2))
-      assert_equal([['filter', [1, 2, 3]], ['filter2', [], { "k1" => 1, "k2" => 2 }]], var.filters)
-
-      # positional and kwargs mixed
-      var = create_variable(%(n | filter: 'a', 'b', key1: 1, key2: 2, 'c'))
-      assert_equal([["filter", ["a", "b", "c"], { "key1" => 1, "key2" => 2 }]], var.filters)
-
-      # positional and kwargs intermixed (pos1, key1: val1, pos2)
-      var = create_variable(%(n | link_to: class: "black", "https://example.com", title: "title"))
-      assert_equal([['link_to', ["https://example.com"], { "class" => "black", "title" => "title" }]], var.filters)
-
-      # string key throws
-      assert_raises(SyntaxError) { create_variable(%(n | pluralize: 'comment': 'comments')) }
-    end
+    # string key throws
+    assert_raises(SyntaxError) { create_variable(%(n | pluralize: 'comment': 'comments')) }
   end
 
   def test_output_raw_source_of_variable