Make whitespace filters Unicode-aware

Previously we were only leveraging Ruby's `String#strip` to handle the
logic in these filters but that only covers ASCII whitespace. When
rendering Liquid templates into HTML it would be confusing for these
filters to not strip *all* whitespace.

Additionally, it's helpful when trying to compare two values in, say, a
Liquid conditional.

.github/workflows/liquid.yml

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

.ruby-version

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

Rakefile

@@ -151,6 +151,8 @@ end
 
 desc('run liquid-spec suite across all adapters')
 task :spec do
-  adapters = Dir['./spec/*.rb'].join(',')
-  sh "bundle exec liquid-spec matrix --adapters=#{adapters} --reference=ruby_liquid"
+  Dir['./spec/*.rb'].sort.each do |adapter|
+    puts "=== Running #{adapter} ==="
+    sh 'bundle', 'exec', 'liquid-spec', 'run', adapter, '--no-max-failures'
+  end
 end

lib/liquid.rb

@@ -65,6 +65,7 @@ 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'

lib/liquid/context.rb

@@ -187,6 +187,15 @@ 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
@@ -197,6 +206,10 @@ module Liquid
       # path and find_index() is optimized in MRI to reduce object allocation
       index = @scopes.find_index { |s| s.key?(key) }
 
+      # `self` resolves to a SelfDrop (enabling `self['var']` lookups),
+      # but only when it hasn't been explicitly assigned as a local variable.
+      return SelfDrop.new(self) if key == Expression::SELF && !index
+
       variable = if index
         lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
       else

lib/liquid/expression.rb

@@ -2,6 +2,8 @@
 
 module Liquid
   class Expression
+    SELF = 'self'
+
     LITERALS = {
       nil => nil,
       'nil' => nil,

lib/liquid/parse_context.rb

@@ -38,7 +38,7 @@ module Liquid
 
     def new_parser(input)
       @string_scanner.string = input
-      Parser.new(@string_scanner)
+      Parser.new(@string_scanner, reject_bare_brackets: @error_mode == :strict2 || @error_mode == :rigid)
     end
 
     def new_tokenizer(source, start_line_number: nil, for_liquid_tag: false)

lib/liquid/parser.rb

@@ -2,10 +2,11 @@
 
 module Liquid
   class Parser
-    def initialize(input)
+    def initialize(input, reject_bare_brackets: false)
       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)
@@ -53,6 +54,9 @@ 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/self_drop.rb

@@ -0,0 +1,38 @@
+# 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(context)
+      super()
+      @context = context
+    end
+
+    def [](key)
+      @context.find_variable(key)
+    rescue UndefinedVariable
+      nil
+    end
+
+    def key?(key)
+      @context.variable_defined?(key)
+    end
+
+    def to_liquid
+      self
+    end
+  end
+end

lib/liquid/standardfilters.rb

@@ -8,10 +8,19 @@ module Liquid
     MAX_I32 = (1 << 31) - 1
     private_constant :MAX_I32
 
-    MIN_I64 = -(1 << 63)
-    MAX_I64 = (1 << 63) - 1
-    I64_RANGE = MIN_I64..MAX_I64
-    private_constant :MIN_I64, :MAX_I64, :I64_RANGE
+    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
 
     HTML_ESCAPE = {
       '&' => '&amp;',
@@ -27,6 +36,19 @@ module Liquid
       %r{<style.*?</style>}m,
     )
     STRIP_HTML_TAGS = /<.*?>/m
+    # Use POSIX whitespace matching so filters handle whitespace beyond Ruby String#strip's ASCII set.
+    WHITESPACE_LEFT = /\A[[:space:]]+/
+    WHITESPACE_RIGHT = /[[:space:]]+\z/
+    WHITESPACE_EDGES = Regexp.union(WHITESPACE_LEFT, WHITESPACE_RIGHT)
+    # Optimized runs regex to find 2 or more [[:space:]] OR a single [[:space:]]
+    # that isn't already `" " `.
+    WHITESPACE_RUNS = /([[:space:]]{2,}|[[[:space:]]&&[^ ]])/
+    private_constant(
+      :WHITESPACE_EDGES,
+      :WHITESPACE_LEFT,
+      :WHITESPACE_RIGHT,
+      :WHITESPACE_RUNS,
+    )
 
     class << self
       def try_coerce_encoding(input, encoding:)
@@ -214,11 +236,11 @@ module Liquid
           Utils.to_s(input).slice(offset, length) || ''
         end
       rescue RangeError
-        if I64_RANGE.cover?(length) && I64_RANGE.cover?(offset)
+        if INDEX_RANGE.cover?(length) && INDEX_RANGE.cover?(offset)
           raise # unexpected error
         end
-        offset = offset.clamp(I64_RANGE)
-        length = length.clamp(I64_RANGE)
+        offset = offset.clamp(INDEX_RANGE)
+        length = length.clamp(INDEX_RANGE)
         retry
       end
     end
@@ -303,7 +325,7 @@ module Liquid
     def squish(input)
       return if input.nil?
 
-      Utils.to_s(input).strip.gsub(/\s+/, ' ')
+      Utils.to_s(input).gsub(WHITESPACE_RUNS, ' ').strip
     end
 
     # @liquid_public_docs
@@ -315,7 +337,7 @@ module Liquid
     # @liquid_return [string]
     def strip(input)
       input = Utils.to_s(input)
-      input.strip
+      input.gsub(WHITESPACE_EDGES, ' ').strip
     end
 
     # @liquid_public_docs
@@ -327,7 +349,7 @@ module Liquid
     # @liquid_return [string]
     def lstrip(input)
       input = Utils.to_s(input)
-      input.lstrip
+      input.gsub(WHITESPACE_LEFT, ' ').lstrip
     end
 
     # @liquid_public_docs
@@ -339,7 +361,7 @@ module Liquid
     # @liquid_return [string]
     def rstrip(input)
       input = Utils.to_s(input)
-      input.rstrip
+      input.gsub(WHITESPACE_RIGHT, ' ').rstrip
     end
 
     # @liquid_public_docs

lib/liquid/tags/assign.rb

@@ -18,6 +18,8 @@ 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
@@ -29,6 +31,10 @@ 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)
@@ -37,6 +43,25 @@ 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,10 +20,18 @@ 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
@@ -31,6 +39,16 @@ 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/decrement.rb

@@ -23,13 +23,29 @@ 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/include.rb

@@ -20,7 +20,8 @@ module Liquid
   class Include < Tag
     prepend Tag::Disableable
 
-    SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    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
@@ -84,12 +85,18 @@ module Liquid
     alias_method :parse_context, :options
     private :parse_context
 
+    def for_loop?
+      @is_for_loop
+    end
+
     def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @template_name_expr = safe_parse_expression(p)
-      @variable_name_expr = safe_parse_expression(p) if p.id?("for") || p.id?("with")
+      with_or_for         = p.id?("for") || p.id?("with")
+      @variable_name_expr = safe_parse_expression(p) if with_or_for
       @alias_name         = p.consume(:id) if p.id?("as")
+      @is_for_loop        = (with_or_for == FOR)
 
       p.consume?(:comma)
 
@@ -111,11 +118,13 @@ module Liquid
     def lax_parse(markup)
       if markup =~ SYNTAX
         template_name = Regexp.last_match(1)
-        variable_name = Regexp.last_match(3)
+        with_or_for   = Regexp.last_match(3)
+        variable_name = Regexp.last_match(4)
 
-        @alias_name         = Regexp.last_match(5)
+        @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|

lib/liquid/tags/increment.rb

@@ -23,13 +23,29 @@ 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/variable.rb

@@ -37,6 +37,10 @@ module Liquid
       @markup
     end
 
+    def ==(other)
+      self.class == other.class && name == other.name && filters == other.filters
+    end
+
     def markup_context(markup)
       "in \"{{#{markup}}}\""
     end

spec/ruby_liquid.rb

@@ -6,14 +6,24 @@
 
 $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 require 'liquid'
+require_relative 'support/liquid_spec_adapter_helper'
 
 LiquidSpec.configure do |config|
-  # Run core Liquid specs
-  config.features = [:core]
+  config.missing_features = [
+    :activesupport,
+    :lax_parsing,
+    :shopify_filters,
+    :shopify_includes,
+    :shopify_blank,
+    :shopify_error_handling,
+    :shopify_error_format,
+    :shopify_string_access,
+  ]
 end
 
 # Compile a template string into a Liquid::Template
 LiquidSpec.compile do |ctx, source, options|
+  options[:error_mode] ||= :strict
   ctx[:template] = Liquid::Template.parse(source, **options)
 end
 
@@ -28,9 +38,12 @@ 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]
 
-  ctx[:template].render(context)
+  LiquidSpecAdapterHelper.with_frozen_time do
+    ctx[:template].render(context)
+  end
 end

spec/ruby_liquid_lax.rb

@@ -6,15 +6,24 @@
 
 $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 require 'liquid'
+require_relative 'support/liquid_spec_adapter_helper'
 
 LiquidSpec.configure do |config|
-  config.features = [:core, :lax_parsing]
+  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|
-  # Force lax mode
-  options = options.merge(error_mode: :lax)
+  # 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
 
@@ -26,9 +35,12 @@ 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]
 
-  ctx[:template].render(context)
+  LiquidSpecAdapterHelper.with_frozen_time do
+    ctx[:template].render(context)
+  end
 end

spec/ruby_liquid_with_active_support.rb

@@ -7,14 +7,23 @@
 $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|
-  # Run core Liquid specs plus ActiveSupport SafeBuffer tests
-  config.features = [:core, :activesupport]
+  config.missing_features = [
+    :lax_parsing,
+    :shopify_filters,
+    :shopify_includes,
+    :shopify_blank,
+    :shopify_error_handling,
+    :shopify_error_format,
+    :shopify_string_access,
+  ]
 end
 
 # Compile a template string into a Liquid::Template
 LiquidSpec.compile do |ctx, source, options|
+  options[:error_mode] ||= :strict
   ctx[:template] = Liquid::Template.parse(source, **options)
 end
 
@@ -29,9 +38,12 @@ 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]
 
-  ctx[:template].render(context)
+  LiquidSpecAdapterHelper.with_frozen_time do
+    ctx[:template].render(context)
+  end
 end

spec/ruby_liquid_yjit.rb

@@ -13,9 +13,18 @@ end
 
 require 'active_support/all'
 require 'liquid'
+require_relative 'support/liquid_spec_adapter_helper'
 
 LiquidSpec.configure do |config|
-  config.features = [:core, :activesupport]
+  config.missing_features = [
+    :lax_parsing,
+    :shopify_filters,
+    :shopify_includes,
+    :shopify_blank,
+    :shopify_error_handling,
+    :shopify_error_format,
+    :shopify_string_access,
+  ]
 end
 
 # Compile a template string into a Liquid::Template
@@ -33,9 +42,12 @@ 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]
 
-  ctx[:template].render(context)
+  LiquidSpecAdapterHelper.with_frozen_time do
+    ctx[:template].render(context)
+  end
 end

spec/support/liquid_spec_adapter_helper.rb

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

test/integration/assign_test.rb

@@ -97,6 +97,46 @@ 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/capture_test.rb

@@ -6,7 +6,11 @@ class CaptureTest < Minitest::Test
   include Liquid
 
   def test_captures_block_content_in_variable
-    assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
+    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)
   end
 
   def test_capture_with_hyphen_in_variable_name
@@ -49,4 +53,35 @@ 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', '{{ [bar] }}', { 'foo' => 'baz', 'bar' => 'foo' })
+    assert_template_result('baz', '{{ foo }}', { "foo" => "baz" })
+    assert_template_result('baz', '{{ self[bar] }}', { 'foo' => 'baz', 'bar' => 'foo' })
   end
 
   def test_access_hashes_with_hash_access_variables

test/integration/security_test.rb

@@ -44,32 +44,39 @@ class SecurityTest < Minitest::Test
   end
 
   def test_does_not_permanently_add_filters_to_symbol_table
-    current_symbols = Symbol.all_symbols
+    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
 
-    # 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)
+      GC.start
+    end
   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
-
-    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!)
-
+    yield
     assert_equal([], Symbol.all_symbols - current_symbols)
   end
 

test/integration/standard_filter_test.rb

@@ -169,6 +169,15 @@ class StandardFiltersTest < Minitest::Test
 \t   boo   " | squish }})).render)
     assert_equal("", Liquid::Template.parse('{{ nil | squish }}').render)
     assert_equal("", Liquid::Template.parse('{{ " " | squish }}').render)
+
+    unicode_spaces = "\u00A0\u202F\u2009\u2007"
+
+    assert_template_result(
+      "foo bar boo",
+      "{{ source | squish }}",
+      { 'source' => "#{unicode_spaces}foo\u202F\u2009bar\t\n\u2007boo#{unicode_spaces}" },
+    )
+    assert_template_result("\u200Bfoo\u200B", "{{ source | squish }}", { 'source' => "\u200Bfoo\u200B" })
   end
 
   def test_escape
@@ -703,16 +712,42 @@ class StandardFiltersTest < Minitest::Test
   def test_strip
     assert_template_result('ab c', "{{ source | strip }}", { 'source' => " ab c  " })
     assert_template_result('ab c', "{{ source | strip }}", { 'source' => " \tab c  \n \t" })
+
+    unicode_spaces = "\u00A0\u202F\u2009\u2007"
+
+    assert_template_result(
+      'ab c',
+      "{{ source | strip }}",
+      { 'source' => "#{unicode_spaces}ab c#{unicode_spaces}" },
+    )
+    assert_template_result("a\u00A0b\u202Fc", "{{ source | strip }}", { 'source' => "a\u00A0b\u202Fc" })
+    assert_template_result("\u200Bfoo\u200B", "{{ source | strip }}", { 'source' => "\u200Bfoo\u200B" })
   end
 
   def test_lstrip
     assert_template_result('ab c  ', "{{ source | lstrip }}", { 'source' => " ab c  " })
     assert_template_result("ab c  \n \t", "{{ source | lstrip }}", { 'source' => " \tab c  \n \t" })
+
+    unicode_spaces = "\u00A0\u202F\u2009\u2007"
+
+    assert_template_result(
+      "ab c#{unicode_spaces}",
+      "{{ source | lstrip }}",
+      { 'source' => "#{unicode_spaces}ab c#{unicode_spaces}" },
+    )
   end
 
   def test_rstrip
     assert_template_result(" ab c", "{{ source | rstrip }}", { 'source' => " ab c  " })
     assert_template_result(" \tab c", "{{ source | rstrip }}", { 'source' => " \tab c  \n \t" })
+
+    unicode_spaces = "\u00A0\u202F\u2009\u2007"
+
+    assert_template_result(
+      "#{unicode_spaces}ab c",
+      "{{ source | rstrip }}",
+      { 'source' => "#{unicode_spaces}ab c#{unicode_spaces}" },
+    )
   end
 
   def test_strip_newlines
@@ -1181,6 +1216,8 @@ 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

@@ -105,10 +105,8 @@ class CycleTagTest < Minitest::Test
       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(expected_error, error1.message)
-      assert_match(expected_error, error2.message)
+      assert_match(/Liquid syntax error:/, error1.message)
+      assert_match(/Liquid syntax error: \[:dot, "."\] is not a valid expression/, error2.message)
     end
   end
 

test/integration/tags/include_tag_test.rb

@@ -439,4 +439,49 @@ class IncludeTagTest < Minitest::Test
       assert_match(/Unexpected character =/, error.message)
     end
   end
+
+  def test_include_for_loop_true_with_for_keyword
+    with_error_modes(:lax, :strict, :strict2) do
+      template = Template.parse("{% include 'product' for products %}")
+      include_node = template.root.nodelist.first
+
+      assert(include_node.for_loop?, "Expected for_loop? to be true for 'for' keyword")
+    end
+  end
+
+  def test_include_for_loop_false_with_with_keyword
+    with_error_modes(:lax, :strict, :strict2) do
+      template = Template.parse("{% include 'product' with product %}")
+      include_node = template.root.nodelist.first
+
+      refute(include_node.for_loop?, "Expected for_loop? to be false for 'with' keyword")
+    end
+  end
+
+  def test_include_for_loop_false_without_keyword
+    with_error_modes(:lax, :strict, :strict2) do
+      template = Template.parse("{% include 'header' %}")
+      include_node = template.root.nodelist.first
+
+      refute(include_node.for_loop?, "Expected for_loop? to be false when no keyword")
+    end
+  end
+
+  def test_include_for_loop_with_alias
+    with_error_modes(:lax, :strict, :strict2) do
+      template = Template.parse("{% include 'product' for products as item %}")
+      include_node = template.root.nodelist.first
+
+      assert(include_node.for_loop?, "Expected for_loop? to be true for 'for' with alias")
+    end
+  end
+
+  def test_include_with_keyword_and_alias
+    with_error_modes(:lax, :strict, :strict2) do
+      template = Template.parse("{% include 'product' with products[0] as item %}")
+      include_node = template.root.nodelist.first
+
+      refute(include_node.for_loop?, "Expected for_loop? to be false for 'with' with alias")
+    end
+  end
 end # IncludeTagTest

test/integration/tags/increment_tag_test.rb

@@ -27,4 +27,50 @@ 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

@@ -174,16 +174,16 @@ class RenderTagTest < Minitest::Test
   def test_increment_is_isolated_between_renders
     assert_template_result(
       '010',
-      '{% increment %}{% increment %}{% render "incr" %}',
-      partials: { 'incr' => '{% increment %}' },
+      '{% increment port %}{% increment port %}{% render "incr" %}',
+      partials: { 'incr' => '{% increment port %}' },
     )
   end
 
   def test_decrement_is_isolated_between_renders
     assert_template_result(
       '-1-2-1',
-      '{% decrement %}{% decrement %}{% render "decr" %}',
-      partials: { 'decr' => '{% decrement %}' },
+      '{% decrement port %}{% decrement port %}{% render "decr" %}',
+      partials: { 'decr' => '{% decrement port %}' },
     )
   end
 

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[ [ 'b' ] ] }}", { 'b' => 'c', 'a' => { 'c' => 'result' } })
+    assert_template_result('result', "{{ a[ self[ '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', '{{ [key] }}', { 'key' => 'foo', 'foo' => 'bar' })
+    assert_template_result('bar', '{{ self[key] }}', { 'key' => 'foo', 'foo' => 'bar' })
   end
 
   def test_raw_value_variable
-    assert_template_result('bar', '{{ [key] }}', { 'key' => 'foo', 'foo' => 'bar' })
+    assert_template_result('bar', '{{ self[key] }}', { 'key' => 'foo', 'foo' => 'bar' })
   end
 
   def test_dynamic_find_var_with_drop
     assert_template_result(
       'bar',
-      '{{ [list[settings.zero]] }}',
+      '{{ self[list[settings.zero]] }}',
       {
         'list' => ['foo'],
         'settings' => SettingsDrop.new("zero" => 0),
@@ -155,7 +155,7 @@ class VariableTest < Minitest::Test
 
     assert_template_result(
       'foo',
-      '{{ [list[settings.zero]["foo"]] }}',
+      '{{ self[list[settings.zero]["foo"]] }}',
       {
         'list' => [{ 'foo' => 'bar' }],
         'settings' => SettingsDrop.new("zero" => 0),