Bump ruby/setup-ruby from 1.295.0 to 1.314.0

Bumps [ruby/setup-ruby](https://github.com/ruby/setup-ruby) from 1.295.0 to 1.314.0.
- [Release notes](https://github.com/ruby/setup-ruby/releases)
- [Changelog](https://github.com/ruby/setup-ruby/blob/master/release.rb)
- [Commits](https://github.com/ruby/setup-ruby/compare/319994f95fa847cf3fb3cd3dbe89f6dcde9f178f...9eb537ca036ebaed86729dcb9309076e4c5c3b74)

---
updated-dependencies:
- dependency-name: ruby/setup-ruby
  dependency-version: 1.314.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <[email protected]>

.github/dependabot.yaml

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

.github/probots.yml

@@ -1,2 +0,0 @@
-enabled:
-  - cla

.github/workflows/cla.yml

@@ -0,0 +1,22 @@
+name: Contributor License Agreement (CLA)
+
+on:
+  pull_request_target:
+    types: [opened, synchronize]
+  issue_comment:
+    types: [created]
+
+jobs:
+  cla:
+    runs-on: ubuntu-latest
+    if: |
+      (github.event.issue.pull_request 
+        && !github.event.issue.pull_request.merged_at
+        && contains(github.event.comment.body, 'signed')
+      ) 
+      || (github.event.pull_request && !github.event.pull_request.merged)
+    steps:
+      - uses: Shopify/shopify-cla-action@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cla-token: ${{ secrets.CLA_TOKEN }}

.github/workflows/liquid.yml

@@ -1,39 +1,73 @@
 name: Liquid
-on: [push, pull_request]
+on: [push]
+
+env:
+  BUNDLE_JOBS: 4
+  BUNDLE_RETRY: 3
+
 jobs:
   test:
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         entry:
-          - { ruby: 2.5, allowed-failure: false } # minimum supported
-          - { ruby: 3.1, allowed-failure: false } # latest
-          - { ruby: ruby-head, allowed-failure: true }
-    name: test (${{ matrix.entry.ruby }})
+          - { ruby: 3.3, allowed-failure: false } # minimum supported
+          - { ruby: 3.4, allowed-failure: false, rubyopt: "--yjit" }
+          - { ruby: 4.0, allowed-failure: false } # latest stable
+          - {
+              ruby: 4.0,
+              allowed-failure: false,
+              rubyopt: "--enable-frozen-string-literal",
+            }
+          - { ruby: 4.0, allowed-failure: false, rubyopt: "--yjit" }
+          - { ruby: 4.0, allowed-failure: false, rubyopt: "--zjit" }
+          - { ruby: truffleruby, allowed-failure: false }
+
+          # Head can have failures due to being in development
+          - { ruby: head, allowed-failure: true }
+          - {
+              ruby: head,
+              allowed-failure: true,
+              rubyopt: "--enable-frozen-string-literal",
+            }
+          - { ruby: head, allowed-failure: true, rubyopt: "--yjit" }
+          - { ruby: head, allowed-failure: true, rubyopt: "--zjit" }
+    name: Test Ruby ${{ matrix.entry.ruby }} ${{ matrix.entry.rubyopt }} --${{ matrix.entry.allowed-failure && 'allowed-failure' || 'strict' }}
     steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+      - uses: ruby/setup-ruby@9eb537ca036ebaed86729dcb9309076e4c5c3b74 # v1.314.0
         with:
           ruby-version: ${{ matrix.entry.ruby }}
-      - uses: actions/cache@v1
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
-          restore-keys: ${{ runner.os }}-gems-
-      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
+          bundler-cache: true
+          bundler: latest
       - run: bundle exec rake
         continue-on-error: ${{ matrix.entry.allowed-failure }}
+        env:
+          RUBYOPT: ${{ matrix.entry.rubyopt }}
+
+  spec:
+    runs-on: ubuntu-latest
+    env:
+      BUNDLE_WITH: spec
+    steps:
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+      - uses: ruby/setup-ruby@9eb537ca036ebaed86729dcb9309076e4c5c3b74 # v1.314.0
+        with:
+          bundler-cache: true
+          bundler: latest
+      - name: Run liquid-spec for all adapters
+        run: |
+          for adapter in spec/*.rb; do
+            echo "=== Running $adapter ==="
+            bundle exec liquid-spec run "$adapter" --no-max-failures
+          done
+
   memory_profile:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+      - uses: ruby/setup-ruby@9eb537ca036ebaed86729dcb9309076e4c5c3b74 # v1.314.0
         with:
-          ruby-version: 2.7
-      - uses: actions/cache@v1
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
-          restore-keys: ${{ runner.os }}-gems-
-      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
+          bundler-cache: true
       - run: bundle exec rake memory_profile:run

.gitignore

@@ -4,7 +4,6 @@
 pkg
 *.rbc
 .rvmrc
-.ruby-version
-Gemfile.lock
 .bundle
 .byebug_history
+Gemfile.lock

.rubocop.yml

@@ -10,8 +10,8 @@ Performance:
   Enabled: true
 
 AllCops:
-  TargetRubyVersion: 2.5
   NewCops: disable
+  SuggestExtensions: false
   Exclude:
     - 'vendor/bundle/**/*'
 
@@ -19,6 +19,10 @@ Naming/MethodName:
   Exclude:
     - 'example/server/liquid_servlet.rb'
 
-# Backport https://github.com/Shopify/ruby-style-guide/pull/258
-Layout/BeginEndAlignment:
-  Enabled: true
+Style/ClassMethodsDefinitions:
+  Enabled: false
+
+# liquid filter calls were being mistaken to be calls on arrays
+Style/ConcatArrayLiterals:
+  Exclude:
+    - 'test/integration/standard_filter_test.rb'

.rubocop_todo.yml

@@ -1,27 +1,74 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2020-12-11 18:53:41 UTC using RuboCop version 1.6.1.
+# on 2022-05-18 19:25:47 UTC using RuboCop version 1.29.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 2
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: runtime_error, standard_error
-Lint/InheritException:
+# Offense count: 1
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: TreatCommentsAsGroupSeparators, ConsiderPunctuation, Include.
+# Include: **/*.gemspec
+Gemspec/OrderedDependencies:
   Exclude:
-    - 'lib/liquid/interrupts.rb'
+    - 'liquid.gemspec'
 
-# Offense count: 113
-# Cop supports --auto-correct.
-# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
-# URISchemes: http, https
-Layout/LineLength:
-  Max: 260
+# Offense count: 6
+# This cop supports safe auto-correction (--auto-correct).
+Layout/ClosingHeredocIndentation:
+  Exclude:
+    - 'test/integration/tags/for_tag_test.rb'
+
+# Offense count: 34
+# This cop supports safe auto-correction (--auto-correct).
+Layout/EmptyLineAfterGuardClause:
+  Exclude:
+    - 'lib/liquid/block.rb'
+    - 'lib/liquid/block_body.rb'
+    - 'lib/liquid/context.rb'
+    - 'lib/liquid/drop.rb'
+    - 'lib/liquid/lexer.rb'
+    - 'lib/liquid/parser.rb'
+    - 'lib/liquid/profiler/hooks.rb'
+    - 'lib/liquid/standardfilters.rb'
+    - 'lib/liquid/tags/for.rb'
+    - 'lib/liquid/tags/if.rb'
+    - 'lib/liquid/utils.rb'
+    - 'lib/liquid/variable.rb'
+    - 'lib/liquid/variable_lookup.rb'
+    - 'performance/shopify/money_filter.rb'
+    - 'performance/shopify/paginate.rb'
 
 # Offense count: 8
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: AllowAliasSyntax, AllowedMethods.
+# AllowedMethods: alias_method, public, protected, private
+Layout/EmptyLinesAroundAttributeAccessor:
+  Exclude:
+    - 'lib/liquid/template.rb'
+    - 'test/integration/filter_test.rb'
+    - 'test/integration/tags/include_tag_test.rb'
+    - 'test/unit/strainer_template_unit_test.rb'
+
+# Offense count: 17
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: aligned, indented
+Layout/LineEndStringConcatenationIndentation:
+  Exclude:
+    - 'test/integration/tags/for_tag_test.rb'
+    - 'test/integration/tags/increment_tag_test.rb'
+
+# Offense count: 1
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: aligned, indented
+Layout/MultilineOperationIndentation:
+  Exclude:
+    - 'lib/liquid/expression.rb'
+
+# Offense count: 9
 Lint/MissingSuper:
   Exclude:
     - 'lib/liquid/forloop_drop.rb'
@@ -33,7 +80,7 @@ Lint/MissingSuper:
     - 'test/integration/tags/for_tag_test.rb'
     - 'test/integration/tags/table_row_test.rb'
 
-# Offense count: 43
+# Offense count: 44
 Naming/ConstantName:
   Exclude:
     - 'lib/liquid.rb'
@@ -51,7 +98,92 @@ Naming/ConstantName:
     - 'performance/shopify/paginate.rb'
     - 'test/integration/tags/include_tag_test.rb'
 
+# Offense count: 9
+# Configuration parameters: CheckIdentifiers, CheckConstants, CheckVariables, CheckStrings, CheckSymbols, CheckComments, CheckFilepaths, FlaggedTerms.
+Naming/InclusiveLanguage:
+  Exclude:
+    - 'lib/liquid/drop.rb'
+    - 'lib/liquid/parse_context.rb'
+    - 'test/integration/drop_test.rb'
+    - 'test/integration/tags/if_else_tag_test.rb'
+
 # Offense count: 2
 Style/ClassVars:
   Exclude:
     - 'lib/liquid/condition.rb'
+
+# Offense count: 3
+# This cop supports safe auto-correction (--auto-correct).
+Style/ExplicitBlockArgument:
+  Exclude:
+    - 'test/integration/context_test.rb'
+    - 'test/integration/tag/disableable_test.rb'
+    - 'test/integration/tags/for_tag_test.rb'
+
+# Offense count: 2982
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: EnforcedStyle, ConsistentQuotesInMultiline.
+# SupportedStyles: single_quotes, double_quotes
+Style/StringLiterals:
+  Enabled: false
+
+# Offense count: 20
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: single_quotes, double_quotes
+Style/StringLiteralsInInterpolation:
+  Exclude:
+    - 'lib/liquid/condition.rb'
+    - 'lib/liquid/strainer_template.rb'
+    - 'lib/liquid/tag/disableable.rb'
+    - 'performance/shopify/shop_filter.rb'
+    - 'performance/shopify/tag_filter.rb'
+
+# Offense count: 6
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: EnforcedStyleForMultiline.
+# SupportedStylesForMultiline: comma, consistent_comma, no_comma
+Style/TrailingCommaInArrayLiteral:
+  Exclude:
+    - 'example/server/example_servlet.rb'
+    - 'lib/liquid/condition.rb'
+    - 'test/integration/context_test.rb'
+    - 'test/integration/standard_filter_test.rb'
+    - 'test/unit/parse_tree_visitor_test.rb'
+
+# Offense count: 1
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: EnforcedStyleForMultiline.
+# SupportedStylesForMultiline: comma, consistent_comma, no_comma
+Style/TrailingCommaInHashLiteral:
+  Exclude:
+    - 'lib/liquid/expression.rb'
+
+# Offense count: 19
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: EnforcedStyle, MinSize, WordRegex.
+# SupportedStyles: percent, brackets
+Style/WordArray:
+  Exclude:
+    - 'lib/liquid/tags/if.rb'
+    - 'liquid.gemspec'
+    - 'test/integration/assign_test.rb'
+    - 'test/integration/context_test.rb'
+    - 'test/integration/drop_test.rb'
+    - 'test/integration/standard_filter_test.rb'
+
+# Offense count: 117
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, AllowCopDirectives, AllowedPatterns.
+# URISchemes: http, https
+Layout/LineLength:
+  Max: 260
+
+Naming/PredicatePrefix:
+  Enabled: false
+
+# Offense count: 1
+# This is intentional - early return from begin/rescue in assignment context
+Lint/NoReturnInBeginEndBlocks:
+  Exclude:
+    - 'lib/liquid/standardfilters.rb'

.ruby-version

@@ -0,0 +1 @@
+4.0.2

CONTRIBUTING.md

@@ -26,3 +26,11 @@
 * If it makes sense, add tests for your code and/or run a performance benchmark
 * Make sure all tests pass (`bundle exec rake`)
 * Create a pull request
+
+## Releasing
+
+* Bump the version in `lib/liquid/version.rb`
+* Update the `History.md` file
+* Open a PR like [this one](https://github.com/Shopify/liquid/pull/1894) and merge it to `main`
+* Create a new release using the [GitHub UI](https://github.com/Shopify/liquid/releases/new)
+

Gemfile

@@ -7,11 +7,13 @@ end
 
 gemspec
 
+gem "base64"
+
 group :benchmark, :test do
   gem 'benchmark-ips'
   gem 'memory_profiler'
   gem 'terminal-table'
-  gem 'unicode_plot'
+  gem "lru_redux"
 
   install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
     gem 'stackprof'
@@ -19,15 +21,18 @@ group :benchmark, :test do
 end
 
 group :development do
-  gem 'pry-byebug'
+  gem "webrick"
 end
 
 group :test do
-  gem 'rubocop', '~> 1.4', require: false
-  gem 'rubocop-shopify', '~> 1.0.7', require: false
+  gem 'benchmark'
+  gem 'rubocop', '~> 1.82.0'
+  gem 'rubocop-shopify', '~> 2.18.0', require: false
   gem 'rubocop-performance', require: false
-
-  platform :mri, :truffleruby do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
-  end
+end
+
+group :spec do
+  # Using feature branch until https://github.com/Shopify/liquid-spec/pull/144 is merged
+  gem 'liquid-spec', github: 'Shopify/liquid-spec', branch: 'self-drop-env-lookup-specs'
+  gem 'activesupport', require: false
 end

History.md

@@ -1,5 +1,107 @@
 # Liquid Change Log
 
+## 5.11.0
+* Revert the Inline Snippets tag (#2001), treat its inclusion in the latest Liquid release as a bug, and allow for feedback on RFC#1916 to better support Liquid developers [Guilherme Carreiro]
+* Rename the `:rigid` error mode to `:strict2` and display a warning when users attempt to use the `:rigid` mode [Guilherme Carreiro]
+
+## 5.10.0
+* Introduce support for Inline Snippets [Julia Boutin]
+
+## 5.9.0
+* Introduce `:rigid` error mode for stricter, safer parsing of all tags [CP Clermont, Guilherme Carreiro]
+
+## 5.8.7
+* Expose body content in the `Doc` tag [James Meng]
+
+## 5.8.1
+
+* Fix `{% doc %}` tag to be visitable [Guilherme Carreiro]
+
+## 5.8.0
+
+* Introduce the new `{% doc %}` tag [Guilherme Carreiro]
+
+## 5.7.3
+
+* Raise Liquid::SyntaxError when parsing invalidly encoded strings [Chris AtLee]
+
+## 5.7.2 2025-01-31
+
+* Fix array filters to not support nested properties [Guilherme Carreiro]
+
+## 5.7.1 2025-01-24
+
+* Fix the `find` and `find_index`filters to return `nil` when filtering empty arrays [Guilherme Carreiro]
+* Fix the `has` filter to return `false` when filtering empty arrays [Guilherme Carreiro]
+
+## 5.7.0 2025-01-16
+
+### Features
+
+* Add `find`, `find_index`, `has`, and `reject` filters to arrays [Guilherme Carreiro]
+* Compatibility with Ruby 3.4 [Ian Ker-Seymer]
+
+## 5.6.4 2025-01-14
+
+### Fixes
+* Add a default `string_scanner` to avoid errors with `Liquid::VariableLookup.parse("foo.bar")` [Ian Ker-Seymer]
+
+## 5.6.3 2025-01-13
+* Remove `lru_redux` dependency [Michael Go]
+
+## 5.6.2 2025-01-13
+
+### Fixes
+* Preserve the old behavior of requiring floats to start with a digit [Michael Go]
+
+## 5.6.1 2025-01-13
+
+### Performance improvements
+* Faster Expression parser / Tokenizer with StringScanner [Michael Go]
+
+## 5.6.0 2024-12-19
+
+### Architectural changes
+* Added new `Environment` class to manage configuration and state that was previously stored in `Template` [Ian Ker-Seymer]
+* Moved tag registration from `Template` to `Environment` [Ian Ker-Seymer]
+* Removed `StrainerFactory` in favor of `Environment`-based strainer creation [Ian Ker-Seymer]
+* Consolidated standard tags into a new `Tags` module with `STANDARD_TAGS` constant [Ian Ker-Seymer]
+
+### Performance improvements
+* Optimized `Lexer` with a new `Lexer2` implementation using jump tables for faster tokenization, requires Ruby 3.4 [Ian Ker-Seymer]
+* Improved variable rendering with specialized handling for different types [Michael Go]
+* Reduced array allocations by using frozen empty constants [Michael Go]
+
+### API changes
+* Deprecated several `Template` class methods in favor of `Environment` methods [Ian Ker-Seymer]
+* Added deprecation warnings system [Ian Ker-Seymer]
+* Changed how filters and tags are registered to use Environment [Ian Ker-Seymer]
+
+### Fixes
+* Fixed table row handling of break interrupts [Alex Coco]
+* Improved variable output handling for arrays [Ian Ker-Seymer]
+* Fix Tokenizer to handle null source value (#1873) [Bahar Pourazar]
+
+## 5.5.0 2024-03-21
+
+Please reference the GitHub release for more information.
+
+## 5.4.0 2022-07-29
+
+### Breaking Changes
+* Drop support for end-of-life Ruby versions (2.5 and 2.6) (#1578) [Andy Waite]
+
+### Features
+* Allow `#` to be used as an inline comment tag (#1498) [CP Clermont]
+
+### Fixes
+* `PartialCache` now shares snippet cache with subcontexts by default (#1553) [Chris AtLee]
+* Hash registers no longer leak into subcontexts as static registers (#1564) [Chris AtLee]
+* Fix `ParseTreeVisitor` for `with` variable expressions in `Render` tag (#1596) [CP Clermont]
+
+### Changed
+* Liquid::Context#registers now always returns a Liquid::Registers object, though supports the most used Hash functions for compatibility (#1553)
+
 ## 5.3.0 2022-03-22
 
 ### Fixes

README.md

@@ -1,11 +1,11 @@
-[![Build Status](https://api.travis-ci.org/Shopify/liquid.svg?branch=master)](http://travis-ci.org/Shopify/liquid)
+[![Build status](https://github.com/Shopify/liquid/actions/workflows/liquid.yml/badge.svg)](https://github.com/Shopify/liquid/actions/workflows/liquid.yml)
 [![Inline docs](http://inch-ci.org/github/Shopify/liquid.svg?branch=master)](http://inch-ci.org/github/Shopify/liquid)
 
 # Liquid template engine
 
 * [Contributing guidelines](CONTRIBUTING.md)
 * [Version history](History.md)
-* [Liquid documentation from Shopify](https://shopify.dev/api/liquid)
+* [Liquid documentation from Shopify](https://shopify.dev/docs/api/liquid)
 * [Liquid Wiki at GitHub](https://github.com/Shopify/liquid/wiki)
 * [Website](http://liquidmarkup.org/)
 
@@ -52,24 +52,66 @@ For standard use you can just pass it the content of a file and call render with
 @template.render('name' => 'tobi')                # => "hi tobi"
 ```
 
+### Concept of Environments
+
+In Liquid, a "Environment" is a scoped environment that encapsulates custom tags, filters, and other configurations. This allows you to define and isolate different sets of functionality for different contexts, avoiding global overrides that can lead to conflicts and unexpected behavior.
+
+By using environments, you can:
+
+1. **Encapsulate Logic**: Keep the logic for different parts of your application separate.
+2. **Avoid Conflicts**: Prevent custom tags and filters from clashing with each other.
+3. **Improve Maintainability**: Make it easier to manage and understand the scope of customizations.
+4. **Enhance Security**: Limit the availability of certain tags and filters to specific contexts.
+
+We encourage the use of Environments over globally overriding things because it promotes better software design principles such as modularity, encapsulation, and separation of concerns.
+
+Here's an example of how you can define and use Environments in Liquid:
+
+```ruby
+user_environment = Liquid::Environment.build do |environment|
+  environment.register_tag("renderobj", RenderObjTag)
+end
+
+Liquid::Template.parse(<<~LIQUID, environment: user_environment)
+  {% renderobj src: "path/to/model.obj" %}
+LIQUID
+```
+
+In this example, `RenderObjTag` is a custom tag that is only available within the `user_environment`.
+
+Similarly, you can define another environment for a different context, such as email templates:
+
+```ruby
+email_environment = Liquid::Environment.build do |environment|
+  environment.register_tag("unsubscribe_footer", UnsubscribeFooter)
+end
+
+Liquid::Template.parse(<<~LIQUID, environment: email_environment)
+  {% unsubscribe_footer %}
+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 a stricter parser that can be used when editing templates to give better error messages
+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::Template.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
-Liquid::Template.error_mode = :warn # Adds errors to template.errors but continues as normal
-Liquid::Template.error_mode = :lax # The default mode, accepts almost anything.
+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)
+Liquid::Template.parse(source, error_mode: :strict)
 ```
 This is useful for doing things like enabling strict mode only in the theme editor.
 
@@ -111,4 +153,4 @@ template.render!({ 'x' => 1}, { strict_variables: true })
 
 To help track usages of a feature or code path in production, we have released opt-in usage tracking. To enable this, we provide an empty `Liquid:: Usage.increment` method which you can customize to your needs. The feature is well suited to https://github.com/Shopify/statsd-instrument. However, the choice of implementation is up to you.
 
-Once you have enabled usage tracking, we recommend reporting any events through Github Issues that your system may be logging. It is highly likely this event has been added to consider deprecating or improving code specific to this event, so please raise any concerns.
+Once you have enabled usage tracking, we recommend reporting any events through Github Issues that your system may be logging. It is highly likely this event has been added to consider deprecating or improving code specific to this event, so please raise any concerns.

Rakefile

@@ -33,7 +33,7 @@ task :rubocop do
   end
 end
 
-desc('runs test suite with both strict and lax parsers')
+desc('runs test suite with lax, strict, and strict2 parsers')
 task :test do
   ENV['LIQUID_PARSER_MODE'] = 'lax'
   Rake::Task['base_test'].invoke
@@ -42,9 +42,11 @@ task :test do
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
-  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
-    ENV['LIQUID_C'] = '1'
+  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
@@ -52,22 +54,11 @@ task :test do
     ENV['LIQUID_PARSER_MODE'] = 'strict'
     Rake::Task['integration_test'].reenable
     Rake::Task['integration_test'].invoke
+
+    ENV['LIQUID_PARSER_MODE'] = 'strict2'
+    Rake::Task['integration_test'].reenable
+    Rake::Task['integration_test'].invoke
   end
-
-  if RUBY_ENGINE == 'ruby'
-    Rake::Task['test_compile'].invoke
-  end
-end
-
-task :test_compile do
-  ENV['LIQUID_COMPILE'] = '1'
-  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
 end
 
 task(gem: :build)
@@ -88,30 +79,46 @@ end
 
 namespace :benchmark do
   desc "Run the liquid benchmark with lax parsing"
-  task :run do
+  task :lax do
     ruby "./performance/benchmark.rb lax"
   end
 
-  desc "Compare the render performance of compiled Liquid to standard Liquid and Liquid-C"
-  task :compare_render do
-    ENV.delete("LIQUID_C")
-    ENV.delete("RENDER_ONLY")
-
-    ENV["LIQUID_COMPILE"] = "1"
-    ruby "./performance/benchmark.rb strict"
-
-    ENV.delete("LIQUID_COMPILE")
-    ruby "./performance/benchmark.rb strict"
-
-    ENV["LIQUID_C"] = "1"
-    ruby "./performance/benchmark.rb strict"
-
-  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
+      Dir["./performance/unit/*_benchmark.rb"].each do |file|
+        puts "🧪 Running #{file}"
+        ruby file
+      end
+    end
+
+    task :lexer do
+      Dir["./performance/unit/lexer_benchmark.rb"].each do |file|
+        puts "🧪 Running #{file}"
+        ruby file
+      end
+    end
+
+    task :expression do
+      Dir["./performance/unit/expression_benchmark.rb"].each do |file|
+        puts "🧪 Running #{file}"
+        ruby file
+      end
+    end
+  end
 end
 
 namespace :profile do
@@ -141,3 +148,11 @@ end
 task :console do
   exec 'irb -I lib -r liquid'
 end
+
+desc('run liquid-spec suite across all adapters')
+task :spec do
+  Dir['./spec/*.rb'].sort.each do |adapter|
+    puts "=== Running #{adapter} ==="
+    sh 'bundle', 'exec', 'liquid-spec', 'run', adapter, '--no-max-failures'
+  end
+end

bin/render

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

example/server/example_servlet.rb

@@ -30,14 +30,18 @@ class Servlet < LiquidServlet
   private
 
   def products_list
-    [{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
-     { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
-     { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }]
+    [
+      { 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
+      { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
+      { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }
+    ]
   end
 
   def more_products_list
-    [{ 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-     { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
+    [
+      { 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
+      { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }
+    ]
   end
 
   def description

fluid-bench/benchmark.rb

@@ -1,26 +0,0 @@
-# https://github.com/evanphx/benchmark-ips
-require 'liquid'
-#require 'liquid/c'
-require 'benchmark/ips'
-
-require_relative '../lib/liquid/compile'
-
-require_relative 'shop_filter'
-require_relative 'money_filter'
-
-# Each database table is a hash
-require_relative 'database'
-tables = Database.tables
-
-Liquid::Template.register_filter(MoneyFilter)
-Liquid::Template.register_filter(ShopFilter)
-@template = Liquid::Template.parse(File.read("product.liquid"))
-
-context = Liquid::Context.new([tables, {}], {}, {}, false, Liquid::ResourceLimits.new(Liquid::Template.default_resource_limits))
-
-Benchmark.ips do |x|
-    x.report("render") { @template.render(context) }
-
-    # Compare the iterations per second of the various reports
-    x.compare!
-end

fluid-bench/database.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'stackprof'
-
-module Database
-  DATABASE_FILE_PATH = "#{__dir__}/vision.database.yml"
-
-  # Load the standard vision toolkit database and re-arrage it to be simply exportable
-  # to liquid as assigns. All this is based on Shopify
-  def self.tables
-    @tables ||= begin
-      db =
-        if YAML.respond_to?(:unsafe_load_file) # Only Psych 4+ can use unsafe_load_file
-          # unsafe_load_file is needed for YAML references
-          YAML.unsafe_load_file(DATABASE_FILE_PATH, symbolize_names: true)
-        else
-          YAML.load_file(DATABASE_FILE_PATH, symbolize_names: true)
-        end
-
-      # From vision source
-      db[:products].each do |product|
-        collections = db[:collections].find_all do |collection|
-          collection[:products].any? { |p| p[:id].to_i == product[:id].to_i }
-        end
-        product[:collections] = collections
-      end
-
-      # key the tables by handles, as this is how liquid expects it.
-      db = db.each_with_object({}) do |(key, values), assigns|
-        assigns[key] = values.each_with_object({}) do |v, h|
-          h[v[:handle]] = v
-        end
-      end
-
-      # Some standard direct accessors so that the specialized templates
-      # render correctly
-      db[:collection] = db[:collections].values.first
-      db[:product]    = db[:products].values.first
-      db[:blog]       = db[:blogs].values.first
-      db[:article]    = db[:blog][:articles].first
-
-      db[:cart]       = {
-        :total_price => db[:line_items].values.inject(0) { |sum, item| sum + item[:line_price] * item[:quantity] },
-        :item_count => db[:line_items].values.inject(0) { |sum, item| sum + item[:quantity] },
-        :items => db[:line_items].values,
-      }
-
-      db
-    end
-  end
-end
-
-if __FILE__ == $PROGRAM_NAME
-  p(Database.tables[:collections][:frontpage].keys)
-  # p Database.tables[:blog][:articles]
-end

fluid-bench/money_filter.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module MoneyFilter
-  def money_with_currency(money)
-    return '' if money.nil?
-    format("$ %.2f USD", money / 100.0)
-  end
-
-  def money(money)
-    return '' if money.nil?
-    format("$ %.2f", money / 100.0)
-  end
-
-  private
-
-  def currency
-    ShopDrop.new.currency
-  end
-end

fluid-bench/product.liquid

@@ -1,36 +0,0 @@
-<div id="product-left">
-  {% for image in product.images %}{% if forloop.first %}<div id="product-image">
-    <a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'medium' }}" alt="{{ product.title | escape }}" /></a>
-  </div>{% else %}
-  <div class="product-images">
-    <a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
-  </div>{% endif %}{% endfor %}
-</div>
-<div id="product-right">
-  <h1>{{ product.title }}</h1>
-  {{ product.description }}
-
-  {% if product.available %}
-  <form action="/cart/add" method="post">
-
-    <div id="product-variants">
-      <div id="price-field"></div>
-
-      <select id="product-select" name='id'>
-        {% for variant in product.variants %}
-          <option value="{{ variant.id }}">{{ variant.title }} - {{ variant.price | money }}</option>
-        {% endfor %}
-      </select>
-    </div>
-
-    <input type="image" src="{{ 'purchase.png' | asset_url }}" name="add" value="Purchase" id="purchase" />
-  </form>
-  {% else %}
-    <p class="bold-red">This product is temporarily unavailable</p>
-  {% endif %}
-
-  <div id="product-details">
-    <strong>Continue Shopping</strong><br />
-    Browse more {{ product.type | link_to_type }} or additional {{ product.vendor | link_to_vendor }} products.
-  </div>
-</div>

fluid-bench/shop_filter.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module ShopFilter
-  def asset_url(input)
-    "/files/1/[shop_id]/[shop_id]/assets/#{input}"
-  end
-
-  def global_asset_url(input)
-    "/global/#{input}"
-  end
-
-  def shopify_asset_url(input)
-    "/shopify/#{input}"
-  end
-
-  def script_tag(url)
-    %(<script src="#{url}" type="text/javascript"></script>)
-  end
-
-  def stylesheet_tag(url, media = "all")
-    %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
-  end
-
-  def link_to(link, url, title = "")
-    %(<a href="#{url}" title="#{title}">#{link}</a>)
-  end
-
-  def img_tag(url, alt = "")
-    %(<img src="#{url}" alt="#{alt}" />)
-  end
-
-  def link_to_vendor(vendor)
-    if vendor
-      link_to(vendor, url_for_vendor(vendor), vendor)
-    else
-      'Unknown Vendor'
-    end
-  end
-
-  def link_to_type(type)
-    if type
-      link_to(type, url_for_type(type), type)
-    else
-      'Unknown Vendor'
-    end
-  end
-
-  def url_for_vendor(vendor_title)
-    "/collections/#{to_handle(vendor_title)}"
-  end
-
-  def url_for_type(type_title)
-    "/collections/#{to_handle(type_title)}"
-  end
-
-  def product_img_url(url, style = 'small')
-    unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
-      raise ArgumentError, 'filter "size" can only be called on product images'
-    end
-
-    case style
-    when 'original'
-      '/files/shops/random_number/' + url
-    when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
-    else
-      raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '
-    end
-  end
-
-  def default_pagination(paginate)
-    html = []
-    html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
-
-    paginate['parts'].each do |part|
-      html << if part['is_link']
-        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
-      elsif part['title'].to_i == paginate['current_page'].to_i
-        %(<span class="page current">#{part['title']}</span>)
-      else
-        %(<span class="deco">#{part['title']}</span>)
-      end
-    end
-
-    html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
-    html.join(' ')
-  end
-
-  # Accepts a number, and two words - one for singular, one for plural
-  # Returns the singular word if input equals 1, otherwise plural
-  def pluralize(input, singular, plural)
-    input == 1 ? singular : plural
-  end
-
-  private
-
-  def to_handle(str)
-    result = str.dup
-    result.downcase!
-    result.delete!("'\"()[]")
-    result.gsub!(/\W+/, '-')
-    result.gsub!(/-+\z/, '') if result[-1] == '-'
-    result.gsub!(/\A-+/, '') if result[0] == '-'
-    result
-  end
-end

fluid-bench/vision.database.yml

@@ -1,945 +0,0 @@
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-#   Variants
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-
-product_variants:
-  - &product-1-var-1
-    id: 1
-    title: 151cm / Normal
-    price: 19900
-    weight: 1000
-    compare_at_price: 49900
-    available: true
-    inventory_quantity: 5
-    option1: 151cm
-    option2: Normal
-    option3:
-  - &product-1-var-2
-    id: 2
-    title: 155cm / Normal
-    price: 31900
-    weight: 1000
-    compare_at_price: 50900
-    available: true
-    inventory_quantity: 2
-    option1: 155cm
-    option2: Normal
-    option3:
-  - &product-2-var-1
-    id: 3
-    title: 162cm
-    price: 29900
-    weight: 1000
-    compare_at_price: 52900
-    available: true
-    inventory_quantity: 3
-    option1: 162cm
-    option2:
-    option3:
-  - &product-3-var-1
-    id: 4
-    title: 159cm
-    price: 19900
-    weight: 1000
-    compare_at_price:
-    available: true
-    inventory_quantity: 4
-    option1: 159cm
-    option2:
-    option3:
-  - &product-4-var-1
-    id: 5
-    title: 159cm
-    price: 19900
-    weight: 1000
-    compare_at_price: 32900
-    available: true
-    inventory_quantity: 6
-    option1: 159cm
-    option2:
-    option3:
-  - &product-1-var-3
-    id: 6
-    title: 158cm / Wide
-    price: 23900
-    weight: 1000
-    compare_at_price: 99900
-    available: false
-    inventory_quantity: 0
-    option1: 158cm
-    option2: Wide
-    option3:
-  - &product-3-var-2
-    id: 7
-    title: 162cm
-    price: 19900
-    weight: 1000
-    compare_at_price:
-    available: false
-    inventory_quantity: 0
-    option1: 162cm
-    option2:
-    option3:
-  - &product-3-var-3
-    id: 8
-    title: 165cm
-    price: 22900
-    weight: 1000
-    compare_at_price:
-    available: true
-    inventory_quantity: 4
-    option1: 165cm
-    option2:
-    option3:
-  - &product-5-var-1
-    id: 9
-    title: black / 42
-    price: 11900
-    weight: 500
-    compare_at_price: 22900
-    available: true
-    inventory_quantity: 1
-    option1: black
-    option2: 42
-    option3:
-  - &product-5-var-2
-    id: 10
-    title: beige / 42
-    price: 11900
-    weight: 500
-    compare_at_price: 22900
-    available: true
-    inventory_quantity: 3
-    option1: beige
-    option2: 42
-    option3:
-  - &product-5-var-3
-    id: 11
-    title: white / 42
-    price: 13900
-    weight: 500
-    compare_at_price: 24900
-    available: true
-    inventory_quantity: 1
-    option1: white
-    option2: 42
-    option3:
-  - &product-5-var-4
-    id: 12
-    title: black / 44
-    price: 11900
-    weight: 500
-    compare_at_price: 22900
-    available: true
-    inventory_quantity: 2
-    option1: black
-    option2: 44
-    option3:
-  - &product-5-var-5
-    id: 13
-    title: beige / 44
-    price: 11900
-    weight: 500
-    compare_at_price: 22900
-    available: false
-    inventory_quantity: 0
-    option1: beige
-    option2: 44
-    option3:
-  - &product-5-var-6
-    id: 14
-    title: white / 44
-    price: 13900
-    weight: 500
-    compare_at_price: 24900
-    available: false
-    inventory_quantity: 0
-    option1: white
-    option2: 44
-    option3:
-  - &product-6-var-1
-    id: 15
-    title: red
-    price: 2179500
-    weight: 200000
-    compare_at_price:
-    available: true
-    inventory_quantity: 0
-    option1: red
-    option2:
-    option3:
-  - &product-7-var-1
-    id: 16
-    title: black / small
-    price: 1900
-    weight: 200
-    compare_at_price:
-    available: true
-    inventory_quantity: 20
-    option1: black
-    option2: small
-    option3:
-  - &product-7-var-2
-    id: 17
-    title: black / medium
-    price: 1900
-    weight: 200
-    compare_at_price:
-    available: false
-    inventory_quantity: 0
-    option1: black
-    option2: medium
-    option3:
-  - &product-7-var-3
-    id: 18
-    title: black / large
-    price: 1900
-    weight: 200
-    compare_at_price:
-    available: true
-    inventory_quantity: 10
-    option1: black
-    option2: large
-    option3:
-  - &product-7-var-4
-    id: 19
-    title: black / extra large
-    price: 1900
-    weight: 200
-    compare_at_price:
-    available: false
-    inventory_quantity: 0
-    option1: black
-    option2: extra large
-    option3:
-  - &product-8-var-1
-    id: 20
-    title: brown / small
-    price: 5900
-    weight: 400
-    compare_at_price: 6900
-    available: true
-    inventory_quantity: 5
-    option1: brown
-    option2: small
-    option3:
-  - &product-8-var-2
-    id: 21
-    title: brown / medium
-    price: 5900
-    weight: 400
-    compare_at_price: 6900
-    available: false
-    inventory_quantity: 0
-    option1: brown
-    option2: medium
-    option3:
-  - &product-8-var-3
-    id: 22
-    title: brown / large
-    price: 5900
-    weight: 400
-    compare_at_price: 6900
-    available: true
-    inventory_quantity: 10
-    option1: brown
-    option2: large
-    option3:
-  - &product-8-var-4
-    id: 23
-    title: black / small
-    price: 5900
-    weight: 400
-    compare_at_price: 6900
-    available: true
-    inventory_quantity: 10
-    option1: black
-    option2: small
-    option3:
-  - &product-8-var-5
-    id: 24
-    title: black / medium
-    price: 5900
-    weight: 400
-    compare_at_price: 6900
-    available: true
-    inventory_quantity: 10
-    option1: black
-    option2: medium
-    option3:
-  - &product-8-var-6
-    id: 25
-    title: black / large
-    price: 5900
-    weight: 400
-    compare_at_price: 6900
-    available: false
-    inventory_quantity: 0
-    option1: black
-    option2: large
-    option3:
-  - &product-9-var-1
-    id: 26
-    title: Body Only
-    price: 499995
-    weight: 2000
-    compare_at_price:
-    available: true
-    inventory_quantity: 3
-    option1: Body Only
-    option2:
-    option3:
-  - &product-9-var-2
-    id: 27
-    title: Kit with 18-55mm VR lens
-    price: 523995
-    weight: 2000
-    compare_at_price:
-    available: true
-    inventory_quantity: 2
-    option1: Kit with 18-55mm VR lens
-    option2:
-    option3:
-  - &product-9-var-3
-    id: 28
-    title: Kit with 18-200 VR lens
-    price: 552500
-    weight: 2000
-    compare_at_price:
-    available: true
-    inventory_quantity: 3
-    option1: Kit with 18-200 VR lens
-    option2:
-    option3:
-
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-#   Products
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-
-products:
-  - &product-1
-    id: 1
-    title: Arbor Draft
-    handle: arbor-draft
-    type: Snowboards
-    vendor: Arbor
-    price: 23900
-    price_max: 31900
-    price_min: 23900
-    price_varies: true
-    available: true
-    tags:
-      - season2005
-      - pro
-      - intermediate
-      - wooden
-      - freestyle
-    options:
-      - Length
-      - Style
-    compare_at_price: 49900
-    compare_at_price_max: 50900
-    compare_at_price_min: 49900
-    compare_at_price_varies: true
-    url: /products/arbor-draft
-    featured_image: products/arbor_draft.jpg
-    images:
-      - products/arbor_draft.jpg
-    description:
-      The Arbor Draft snowboard wouldn't exist if Polynesians hadn't figured out how to surf hundreds of years ago. But the Draft does exist, and it's here to bring your urban and park riding to a new level. The board's freaky Tiki design pays homage to culture that inspired snowboarding. It's designed to spin with ease, land smoothly, lock hook-free onto rails, and take the abuse of a pavement pounding or twelve. The Draft will pop off kickers with authority and carve solidly across the pipe. The Draft features targeted Koa wood die cuts inlayed into the deck that enhance the flex pattern. Now bow down to riding's ancestors.
-    variants:
-      - *product-1-var-1
-      - *product-1-var-2
-      - *product-1-var-3
-  - &product-2
-    id: 2
-    title: Arbor Element
-    handle: arbor-element
-    type: Snowboards
-    vendor: Arbor
-    price: 29900
-    price_max: 29900
-    price_min: 29900
-    price_varies: false
-    available: true
-    tags:
-      - season2005
-      - pro
-      - wooden
-      - freestyle
-    options:
-      - Length
-    compare_at_price: 52900
-    compare_at_price_max: 52900
-    compare_at_price_min: 52900
-    compare_at_price_varies: false
-    url: /products/arbor-element
-    featured_image: products/element58.jpg
-    images:
-      - products/element58.jpg
-    description:
-      The Element is a technically advanced all-mountain board for riders who readily transition from one terrain, snow condition, or riding style to another. Its balanced design provides the versatility needed for the true ride-it-all experience. The Element is exceedingly lively, freely initiates, and holds a tight edge at speed. Its structural real-wood topsheet is made with book-matched Koa.
-    variants:
-      - *product-2-var-1
-
-  - &product-3
-    id: 3
-    title: Comic ~ Pastel
-    handle: comic-pastel
-    type: Snowboards
-    vendor: Technine
-    price: 19900
-    price_max: 22900
-    price_min: 19900
-    tags:
-      - season2006
-      - beginner
-      - intermediate
-      - freestyle
-      - purple
-    options:
-      - Length
-    price_varies: true
-    available: true
-    compare_at_price:
-    compare_at_price_max: 0
-    compare_at_price_min: 0
-    compare_at_price_varies: false
-    url: /products/comic-pastel
-    featured_image: products/technine1.jpg
-    images:
-      - products/technine1.jpg
-      - products/technine2.jpg
-      - products/technine_detail.jpg
-    description:
-      2005 Technine Comic Series Description The Comic series was developed to be the ultimate progressive freestyle board in the Technine line. Dependable edge control and a perfect flex pattern for jumping in the park or out of bounds. Landins and progression will come easy with this board and it will help your riding progress to the next level. Street rails, park jibs, backcountry booters and park jumps, this board will do it all.
-    variants:
-      - *product-3-var-1
-      - *product-3-var-2
-      - *product-3-var-3
-
-  - &product-4
-    id: 4
-    title: Comic ~ Orange
-    handle: comic-orange
-    type: Snowboards
-    vendor: Technine
-    price: 19900
-    price_max: 19900
-    price_min: 19900
-    price_varies: false
-    available: true
-    tags:
-      - season2006
-      - beginner
-      - intermediate
-      - freestyle
-      - orange
-    options:
-      - Length
-    compare_at_price: 32900
-    compare_at_price_max: 32900
-    compare_at_price_min: 32900
-    compare_at_price_varies: false
-    url: /products/comic-orange
-    featured_image: products/technine3.jpg
-    images:
-      - products/technine3.jpg
-      - products/technine4.jpg
-    description:
-      2005 Technine Comic Series Description The Comic series was developed to be the ultimate progressive freestyle board in the Technine line. Dependable edge control and a perfect flex pattern for jumping in the park or out of bounds. Landins and progression will come easy with this board and it will help your riding progress to the next level. Street rails, park jibs, backcountry booters and park jumps, this board will do it all.
-    variants:
-      - *product-4-var-1
-
-  - &product-5
-    id: 5
-    title: Burton Boots
-    handle: burton-boots
-    type: Boots
-    vendor: Burton
-    price: 11900
-    price_max: 11900
-    price_min: 11900
-    price_varies: false
-    available: true
-    tags:
-      - season2006
-      - beginner
-      - intermediate
-      - boots
-    options:
-      - Color
-      - Shoe Size
-    compare_at_price: 22900
-    compare_at_price_max: 22900
-    compare_at_price_min: 22900
-    compare_at_price_varies: false
-    url: /products/burton-boots
-    featured_image: products/burton.jpg
-    images:
-      - products/burton.jpg
-    description:
-      The Burton boots are particularly well on snowboards. The very best thing about them is that the according picture is cubic. This makes testing in a Vision testing environment very easy.
-    variants:
-      - *product-5-var-1
-      - *product-5-var-2
-      - *product-5-var-3
-      - *product-5-var-4
-      - *product-5-var-5
-      - *product-5-var-6
-
-  - &product-6
-    id: 6
-    title: Superbike 1198 S
-    handle: superbike
-    type: Superbike
-    vendor: Ducati
-    price: 2179500
-    price_max: 2179500
-    price_min: 2179500
-    price_varies: false
-    available: true
-    tags:
-      - ducati
-      - superbike
-      - bike
-      - street
-      - racing
-      - performance
-    options:
-      - Color
-    compare_at_price:
-    compare_at_price_max: 0
-    compare_at_price_min: 0
-    compare_at_price_varies: false
-    url: /products/superbike
-    featured_image: products/ducati.jpg
-    images:
-      - products/ducati.jpg
-    description:
-      <h3>‘S’ PERFORMANCE</h3>
-      <p>Producing 170hp (125kW) and with a dry weight of just 169kg (372.6lb), the new 1198 S now incorporates more World Superbike technology than ever before by taking the 1198 motor and adding top-of-the-range suspension, lightweight chassis components and a true racing-style traction control system designed for road use.</p>
-      <p>The high performance, fully adjustable 43mm Öhlins forks, which sport low friction titanium nitride-treated fork sliders, respond effortlessly to every imperfection in the tarmac. Beyond their advanced engineering solutions, one of the most important characteristics of Öhlins forks is their ability to communicate the condition and quality of the tyre-to-road contact patch, a feature that puts every rider in superior control. The suspension set-up at the rear is complemented with a fully adjustable Öhlins rear shock equipped with a ride enhancing top-out spring and mounted to a single-sided swingarm for outstanding drive and traction. The front-to-rear Öhlins package is completed with a control-enhancing adjustable steering damper.</p>
-    variants:
-      - *product-6-var-1
-
-  - &product-7
-    id: 7
-    title: Shopify Shirt
-    handle: shopify-shirt
-    type: Shirt
-    vendor: Shopify
-    price: 1900
-    price_max: 1900
-    price_min: 1900
-    price_varies: false
-    available: true
-    tags:
-      - shopify
-      - shirt
-      - apparel
-      - tshirt
-      - clothing
-    options:
-      - Color
-      - Size
-    compare_at_price:
-    compare_at_price_max: 0
-    compare_at_price_min: 0
-    compare_at_price_varies: false
-    url: /products/shopify-shirt
-    featured_image: products/shopify_shirt.png
-    images:
-      - products/shopify_shirt.png
-    description:
-      <p>High Quality Shopify Shirt. Wear your e-commerce solution with pride and attract attention anywhere you go.</p>
-      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
-    variants:
-      - *product-7-var-1
-      - *product-7-var-2
-      - *product-7-var-3
-      - *product-7-var-4
-
-  - &product-8
-    id: 8
-    title: Hooded Sweater
-    handle: hooded-sweater
-    type: Sweater
-    vendor: Stormtech
-    price: 5900
-    price_max: 5900
-    price_min: 5900
-    price_varies: false
-    available: true
-    tags:
-      - sweater
-      - hooded
-      - apparel
-      - clothing
-    options:
-      - Color
-      - Size
-    compare_at_price: 6900
-    compare_at_price_max: 6900
-    compare_at_price_min: 6900
-    compare_at_price_varies: false
-    url: /products/hooded-sweater
-    featured_image: products/hooded-sweater.jpg
-    images:
-      - products/hooded-sweater.jpg
-      - products/hooded-sweater-b.jpg
-    description:
-      <p>Extra comfortable zip up sweater. Durable quality, ideal for any outdoor activities.</p>
-      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
-    variants:
-      - *product-8-var-1
-      - *product-8-var-2
-      - *product-8-var-3
-      - *product-8-var-4
-      - *product-8-var-5
-      - *product-8-var-6
-
-  - &product-9
-    id: 9
-    title: D3 Digital SLR Camera
-    handle: d3
-    type: SLR
-    vendor: Nikon
-    price: 499995
-    price_max: 552500
-    price_min: 499995
-    price_varies: true
-    available: true
-    tags:
-      - camera
-      - slr
-      - nikon
-      - professional
-    options:
-      - Bundle
-    compare_at_price:
-    compare_at_price_max: 0
-    compare_at_price_min: 0
-    compare_at_price_varies: false
-    url: /products/d3
-    featured_image: products/d3.jpg
-    images:
-      - products/d3.jpg
-      - products/d3_2.jpg
-      - products/d3_3.jpg
-    description:
-      <p>Flagship pro D-SLR with a 12.1-MP FX-format CMOS sensor, blazing 9 fps shooting at full FX resolution and low-noise performance up to 6400 ISO.</p>
-      <p><strong>Nikon's original 12.1-megapixel FX-format (23.9 x 36mm) CMOS sensor:</strong> Couple Nikon's exclusive digital image processing system with the 12.1-megapixel FX-format and you'll get breathtakingly rich images while also reducing noise to unprecedented levels with even higher ISOs.</p>
-      <p><strong>Continuous shooting at up to 9 frames per second:</strong> At full FX resolution and up to 11fps in the DX crop mode, the D3 offers uncompromised shooting speeds for fast-action and sports photography.</p>
-    variants:
-      - *product-9-var-1
-      - *product-9-var-2
-      - *product-9-var-3
-
-
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-#   Line Items
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-
-line_items:
-  - &line_item-1
-    id: 1
-    title: 'Arbor Draft'
-    subtitle: '151cm'
-    price: 29900
-    line_price: 29900
-    quantity: 1
-    variant: *product-1-var-1
-    product: *product-1
-
-  - &line_item-2
-    id: 2
-    title: 'Comic ~ Orange'
-    subtitle: '159cm'
-    price: 19900
-    line_price: 39800
-    quantity: 2
-    variant: *product-4-var-1
-    product: *product-4
-
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-#   Link Lists
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-links:
-  - &link-1
-    id: 1
-    title: Our Sale
-    url: /collections/sale
-  - &link-2
-    id: 2
-    title: Arbor Stuff
-    url: /collections/arbor
-  - &link-3
-    id: 3
-    title: All our Snowboards
-    url: /collections/snowboards
-  - &link-4
-    id: 4
-    title: Powered by Shopify
-    url: 'http://shopify.com'
-  - &link-5
-    id: 5
-    title: About Us
-    url: /pages/about-us
-  - &link-6
-    id: 6
-    title: Policies
-    url: /pages/shipping
-  - &link-7
-    id: 7
-    title: Contact Us
-    url: /pages/contact
-  - &link-8
-    id: 8
-    title: Our blog
-    url: /blogs/bigcheese-blog
-  - &link-9
-    id: 9
-    title: New Boots
-    url: /products/burton-boots
-  - &link-10
-    id: 10
-    title: Paginated Sale
-    url: /collections/paginated-sale
-  - &link-11
-    id: 11
-    title: Our Paginated blog
-    url: /blogs/paginated-blog
-  - &link-12
-    id: 12
-    title: Catalog
-    url: /collections/all
-
-
-
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-#   Link Lists
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-
-link_lists:
-  - &link-list-1
-    id: 1
-    title: 'Main Menu'
-    handle: 'main-menu'
-    links:
-      - *link-12
-      - *link-5
-      - *link-7
-      - *link-8
-  - &link-list-2
-    id: 1
-    title: 'Footer Menu'
-    handle: 'footer'
-    links:
-      - *link-5
-      - *link-6
-
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-#   Collections
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-
-collections:
-  - &collection-1
-    id: 1
-    title: Frontpage
-    handle: frontpage
-    url: /collections/frontpage
-    products:
-      - *product-7
-      - *product-8
-      - *product-9
-
-  - &collection-2
-    id: 2
-    title: Arbor
-    handle: arbor
-    url: /collections/arbor
-    products:
-      - *product-1
-      - *product-2
-
-  - &collection-3
-    id: 3
-    title: Snowboards
-    handle: snowboards
-    url: /collections/snowboards
-    description:
-      <p>This is a description for my <strong>Snowboards</strong> collection.</p>
-    products:
-      - *product-1
-      - *product-2
-      - *product-3
-      - *product-4
-
-  - &collection-4
-    id: 4
-    title: Items On Sale
-    handle: sale
-    url: /collections/sale
-    products:
-      - *product-1
-
-  - &collection-5
-    id: 5
-    title: Paginated Sale
-    handle: 'paginated-sale'
-    url: '/collections/paginated-sale'
-    products:
-      - *product-1
-      - *product-2
-      - *product-3
-      - *product-4
-    products_count: 210
-
-  - &collection-6
-    id: 6
-    title: All products
-    handle: 'all'
-    url: '/collections/all'
-    products:
-      - *product-7
-      - *product-8
-      - *product-9
-      - *product-6
-      - *product-1
-      - *product-2
-      - *product-3
-      - *product-4
-      - *product-5
-
-
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-#   Pages and Blogs
-# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-pages:
-  - &page-2
-    id: 1
-    title: Contact Us
-    handle: contact
-    url: /pages/contact
-    author: Tobi
-    content:
-      "<p>You can contact us via phone under (555) 567-2222.</p>
-      <p>Our retail store is located at <em>Rue d'Avignon 32, Avignon (Provence)</em>.</p>
-      <p><strong>Opening Hours:</strong><br />Monday through Friday: 9am - 6pm<br />Saturday: 10am - 3pm<br />Sunday: closed</p>"
-    created_at: 2005-04-04 12:00
-
-  - &page-3
-    id: 2
-    title: About Us
-    handle: about-us
-    url: /pages/about-us
-    author: Tobi
-    content:
-      "<p>Our company was founded in 1894 and we are since operating out of Avignon from the beautiful Provence.</p>
-      <p>We offer the highest quality products and are proud to serve our customers to their heart's content.</p>"
-    created_at: 2005-04-04 12:00
-
-  - &page-4
-    id: 3
-    title: Shopping Cart
-    handle: shopping-cart
-    url: /pages/shopping-cart
-    author: Tobi
-    content: "<ul><li>Your order is safe with us. Our checkout uses industry standard security to protect your information.</li><li>Your order will be billed immediately upon checkout.</li><li><b>ALL SALES ARE FINAL:</b> Defective or damaged product will be exchanged</li><li>All orders are processed expediently: usually in under 24 hours.</li></ul>"
-    created_at: 2005-04-04 12:00
-
-  - &page-5
-    id: 4
-    title: Shipping and Handling
-    handle: shipping
-    url: /pages/shipping
-    author: Tobi
-    content: <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
-    created_at: 2005-04-04 12:00
-
-  - &page-6
-    id: 5
-    title: Frontpage
-    handle: frontpage
-    url: /pages/frontpage
-    author: Tobi
-    content: <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
-    created_at: 2005-04-04 12:00
-
-blogs:
-  - id: 1
-    handle: news
-    title: News
-    url: /blogs/news
-    articles:
-      - id: 3
-        title: 'Welcome to the new Foo Shop'
-        author: Daniel
-        content: <p><strong>Welcome to your Shopify store! The jaded Pixel crew is really glad you decided to take Shopify for a spin.</strong></p><p>To help you get you started with Shopify, here are a couple of tips regarding what you see on this page.</p><p>The text you see here is an article. To edit this article, create new articles or create new pages you can go to the <a href="/admin/pages">Blogs &amp; Pages</a> tab of the administration menu.</p><p>The Shopify t-shirt above is a product and selling products is what Shopify is all about. To edit this product, or create new products you can go to the <a href="/admin/products">Products Tab</a> in of the administration menu.</p><p>While you're looking around be sure to check out the <a href="/admin/collections">Collections</a> and <a href="/admin/links">Navigations</a> tabs and soon you will be well on your way to populating your site.</p><p>And of course don't forget to browse the <a href="admin/design/appearance/themes">theme gallery</a> to pick a new look for your shop!</p><p><strong>Shopify is in beta</strong><br />If you would like to make comments or suggestions please visit us in the <a href="http://forums.shopify.com/community">Shopify Forums</a> or drop us an <a href="mailto:[email protected]">email</a>.</p>
-        created_at: 2005-04-04 16:00
-      - id: 4
-        title: 'Breaking News: Restock on all sales products'
-        author: Tobi
-        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-        created_at: 2005-04-04 12:00
-    articles_count: 2
-
-  - id: 2
-    handle: bigcheese-blog
-    title: Bigcheese blog
-    url: /blogs/bigcheese-blog
-    articles:
-      - id: 1
-        title: 'One thing you probably did not know yet...'
-        author: Justin
-        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-        created_at: 2005-04-04 16:00
-        comments:
-          -
-            id: 1
-            author: John Smith
-            email: [email protected]
-            content: Wow...great article man.
-            status: published
-            created_at: 2009-01-01 12:00
-            updated_at: 2009-02-01 12:00
-            url: ""
-          -
-            id: 2
-            author: John Jones
-            email: [email protected]
-            content: I really enjoyed this article. And I love your shop! It's awesome. Shopify rocks!
-            status: published
-            created_at: 2009-03-01 12:00
-            updated_at: 2009-02-01 12:00
-            url: "http://somesite.com/"
-      - id: 2
-        title: Fascinating
-        author: Tobi
-        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-        created_at: 2005-04-06 12:00
-        comments:
-    articles_count: 2
-    comments_enabled?: true
-    comment_post_url: ""
-    comments_count: 2
-    moderated?: true
-
-  - id: 3
-    handle: paginated-blog
-    title: Paginated blog
-    url: /blogs/paginated-blog
-    articles:
-      - id: 6
-        title: 'One thing you probably did not know yet...'
-        author: Justin
-        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-        created_at: 2005-04-04 16:00
-
-      - id: 7
-        title: Fascinating
-        author: Tobi
-        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-        created_at: 2005-04-06 12:00
-    articles_count: 200

lib/liquid.rb

@@ -21,6 +21,8 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+require "strscan"
+
 module Liquid
   FilterSeparator             = /\|/
   ArgumentSeparator           = ','
@@ -29,6 +31,7 @@ module Liquid
   WhitespaceControl           = '-'
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
+  TagName                     = /#|\w+/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
   VariableSegment             = /[\w\-]/
   VariableStart               = /\{\{/
@@ -40,53 +43,50 @@ module Liquid
   AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
   PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
   TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
-  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
+  VariableParser              = /\[(?>[^\[\]]+|\g<0>)*\]|#{VariableSegment}+\??/o
 
   RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
-
-  singleton_class.send(:attr_accessor, :cache_classes)
-  self.cache_classes = true
+  HAS_STRING_SCANNER_SCAN_BYTE = StringScanner.instance_methods.include?(:scan_byte)
 end
 
 require "liquid/version"
+require "liquid/deprecations"
+require "liquid/const"
+require 'liquid/standardfilters'
+require 'liquid/file_system'
+require 'liquid/parser_switching'
+require 'liquid/tag'
+require 'liquid/block'
 require 'liquid/parse_tree_visitor'
+require 'liquid/interrupts'
+require 'liquid/tags'
+require "liquid/environment"
 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'
 require 'liquid/errors'
 require 'liquid/interrupts'
 require 'liquid/strainer_template'
-require 'liquid/strainer_factory'
-require 'liquid/expression'
 require 'liquid/context'
-require 'liquid/parser_switching'
 require 'liquid/tag'
-require 'liquid/tag/disabler'
-require 'liquid/tag/disableable'
-require 'liquid/block'
 require 'liquid/block_body'
 require 'liquid/document'
 require 'liquid/variable'
 require 'liquid/variable_lookup'
 require 'liquid/range_lookup'
-require 'liquid/file_system'
 require 'liquid/resource_limits'
+require 'liquid/expression'
 require 'liquid/template'
-require 'liquid/standardfilters'
 require 'liquid/condition'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'
 require 'liquid/partial_cache'
 require 'liquid/usage'
-require 'liquid/register'
-require 'liquid/static_registers'
+require 'liquid/registers'
 require 'liquid/template_factory'
-
-# Load all the tags of the standard library
-#
-Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }

lib/liquid/block.rb

@@ -36,13 +36,17 @@ module Liquid
     # @api private
     def self.raise_unknown_tag(tag, block_name, block_delimiter, parse_context)
       if tag == 'else'
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else",
-          block_name: block_name)
+        raise SyntaxError, parse_context.locale.t(
+          "errors.syntax.unexpected_else",
+          block_name: block_name,
+        )
       elsif tag.start_with?('end')
-        raise SyntaxError, parse_context.locale.t("errors.syntax.invalid_delimiter",
+        raise SyntaxError, parse_context.locale.t(
+          "errors.syntax.invalid_delimiter",
           tag: tag,
           block_name: block_name,
-          block_delimiter: block_delimiter)
+          block_delimiter: block_delimiter,
+        )
       else
         raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
       end

lib/liquid/block_body.rb

@@ -4,8 +4,9 @@ require 'English'
 
 module Liquid
   class BlockBody
-    LiquidTagToken      = /\A\s*(\w+)\s*(.*?)\z/o
-    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    LiquidTagToken      = /\A\s*(#{TagName})\s*(.*?)\z/o
+    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(#{TagName})(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*)?#{WhitespaceControl}?#{TagEnd}\z/om
     ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
     WhitespaceOrNothing = /\A\s*\z/
     TAGSTART            = "{%"
@@ -45,7 +46,13 @@ module Liquid
           end
           tag_name = Regexp.last_match(1)
           markup   = Regexp.last_match(2)
-          unless (tag = registered_tags[tag_name])
+
+          if tag_name == 'liquid'
+            parse_context.line_number -= 1
+            next parse_liquid_tag(markup, parse_context)
+          end
+
+          unless (tag = parse_context.environment.tag_for_name(tag_name))
             # end parsing if we reach an unknown tag and let the caller decide
             # determine how to proceed
             return yield tag_name, markup
@@ -109,14 +116,22 @@ module Liquid
       end
     end
 
-    private def parse_for_document(tokenizer, parse_context)
+    private def handle_invalid_tag_token(token, parse_context)
+      if token.end_with?('%}')
+        yield token, token
+      else
+        BlockBody.raise_missing_tag_terminator(token, parse_context)
+      end
+    end
+
+    private def parse_for_document(tokenizer, parse_context, &block)
       while (token = tokenizer.shift)
         next if token.empty?
         case
         when token.start_with?(TAGSTART)
           whitespace_handler(token, parse_context)
           unless token =~ FullToken
-            BlockBody.raise_missing_tag_terminator(token, parse_context)
+            return handle_invalid_tag_token(token, parse_context, &block)
           end
           tag_name = Regexp.last_match(2)
           markup   = Regexp.last_match(4)
@@ -132,7 +147,7 @@ module Liquid
             next
           end
 
-          unless (tag = registered_tags[tag_name])
+          unless (tag = parse_context.environment.tag_for_name(tag_name))
             # end parsing if we reach an unknown tag and let the caller decide
             # determine how to proceed
             return yield tag_name, markup
@@ -231,10 +246,17 @@ module Liquid
     end
 
     def create_variable(token, parse_context)
-      if token =~ ContentOfVariable
-        markup = Regexp.last_match(1)
+      if token.end_with?("}}")
+        i = 2
+        i = 3 if token[i] == "-"
+        parse_end = token.length - 3
+        parse_end -= 1 if token[parse_end] == "-"
+        markup_end = parse_end - i + 1
+        markup = markup_end <= 0 ? "" : token.slice(i, markup_end)
+
         return Variable.new(markup, parse_context)
       end
+
       BlockBody.raise_missing_variable_terminator(token, parse_context)
     end
 
@@ -247,9 +269,5 @@ module Liquid
     def raise_missing_variable_terminator(token, parse_context)
       BlockBody.raise_missing_variable_terminator(token, parse_context)
     end
-
-    def registered_tags
-      Template.tags
-    end
   end
 end

lib/liquid/compile.rb

@@ -1,330 +0,0 @@
-# frozen_string_literal: true
-
-require 'pry-byebug'
-require 'set'
-
-module Liquid
-  class Compiler
-    def initialize
-      @ruby = +""
-      @nodes = {}
-      @declared = Set.new(['__l_product'])
-    end
-
-    def <<(line)
-      @ruby << line
-    end
-
-    def var_name(name)
-      "__l_#{name}"
-    end
-
-    def declare(name)
-      @declared << name
-    end
-
-    def declared?(name)
-      @declared.member?(name)
-    end
-
-    def to_proc
-      show_ruby = ENV["SHOW_RUBY"] && ENV["SHOW_RUBY"].to_i || 0
-      STDERR.puts @ruby if show_ruby >= 1
-      res = RubyVM::InstructionSequence.compile(<<~RUBY).eval.call(@nodes)
-      # frozen_string_literal: true
-      ->(__nodes) {
-        ->(__context, __output, __l_product) {
-          __assigns = __context.scopes.last
-          #{@ruby}
-          __output
-        }
-      }
-      RUBY
-
-      STDERR.puts RubyVM::InstructionSequence.disasm(res) if show_ruby >= 2
-      res
-    end
-
-    def compile_expr(node)
-      if node.respond_to?(:compile_expr)
-        node.compile_expr(self)
-      else
-        case node
-        when Range # returned by RangeLookup when range contains only literals
-          node.inspect
-        when Integer, Float, nil, true, false, String
-          node.inspect
-        else
-          raise ArgumentError, "cannot compile node #{node.inspect}"
-        end
-      end
-    end
-
-    def output(node)
-      compiled = compile_expr(node)
-      self << if compiled.is_a?(String)
-        "__output << #{compiled}\n"
-      else
-        "__output << #{compiled}.to_s\n"
-      end
-    end
-
-    def fallback_evaluate_expr(node)
-      "__nodes[#{node.object_id}].evaluate(__context)"
-    end
-
-    def to_integer_expr(var_name)
-      <<~RUBY.strip
-      (begin
-        if #{var_name}.is_a?(Integer)
-          #{var_name}
-        else
-          begin
-            Integer(#{var_name}.to_s)
-          rescue ::ArgumentError
-            raise Liquid::ArgumentError, "invalid integer"
-          end
-        end
-      end)
-      RUBY
-    end
-
-    def compile(node)
-      if node.instance_of?(String)
-        self << "__output << #{node.inspect}\n"
-      else
-        @nodes[node.object_id] = node
-        if node.respond_to?(:compile)
-          node.compile(self)
-        else
-          line_number = if node.respond_to?(:line_number) && node.line_number.is_a?(Integer)
-            node.line_number
-          else
-            nil
-          end
-          catch_errors(line_number, show_message: !node.blank?) do
-            self << "__nodes[#{node.object_id}].render_to_output_buffer(__context, __output) # #{node.inspect} \n"
-          end
-        end
-      end
-    end
-
-    def catch_errors(line_number, show_message: true)
-      self << "begin\n"
-      yield
-      self << <<~RUBY
-        rescue => __exc
-          case __exc
-          when Liquid::MemoryError
-            raise
-          when Liquid::UndefinedVariable, Liquid::UndefinedDropMethod, Liquid::UndefinedFilter
-            __context.handle_error(__exc, #{line_number.inspect})
-          else
-            __error_message = __context.handle_error(__exc, #{line_number.inspect})
-      RUBY
-      self << "__output << __error_message\n" if show_message
-      self << "end\nend\n"
-    end
-  end
-
-  class BlockBody
-    def render_to_output_buffer(context, output)
-      raise "Tried to render uncompiled block" unless @compiled
-      @compiled.call(context, output, context.environments[0][:product])
-    end
-
-    def compile_top_level
-      compiler = Compiler.new
-      compile(compiler)
-      @compiled = compiler.to_proc
-    end
-
-    def compile(compiler)
-      nodelist.each { |node| compiler.compile(node) }
-    end
-  end
-
-  class Document
-    def parse(tokenizer, parse_context)
-      while parse_body(tokenizer)
-      end
-      @body.compile_top_level
-      @body.freeze
-    rescue SyntaxError => e
-      e.line_number ||= parse_context.line_number
-      raise
-    end
-  end
-
-  class VariableLookup
-    def compile_expr(compiler)
-      # HACK
-      if @name == "forloop" && @lookups == ["first"]
-        return "forloop_first"
-      end
-
-      var_name = compiler.var_name(@name)
-      root = if compiler.declared?(var_name)
-        var_name
-      else
-        "__scope[#{@name.inspect}]"
-      end
-
-      @lookups.reduce(root) do |prev, lookup|
-        "#{prev}[:#{lookup}]"
-      end
-    end
-  end
-
-  class Variable
-    FILTERS = {
-      "modulo" => ->(compiler, expr, args, kwargs) {
-        "(#{expr} % #{args[0]})"
-      },
-      "product_img_url" => ->(compiler, expr, args, kwargs) {
-        style = args.fetch(0, 'small')
-
-        rest = case style
-        when 'original'
-          "\"/files/shops/random_number/\#{url}\""
-        when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-          "\"/files/shops/random_number/products/\#{$1}_#{style}.\#{$2}\""
-        else
-          "raise ArgumentError, 'valid parameters for filter \"size\" are: original, grande, large, medium, compact, small, thumb and icon '"
-        end
-
-        <<~RUBY.strip
-        (begin
-          if #{expr} =~ %r{\\Aproducts/([\\w\\-\\_]+)\\.(\\w{2,4})}
-            #{rest}
-          else
-            raise ArgumentError, 'filter \"size\" can only be called on product images'
-          end
-        end)
-        RUBY
-      },
-      "escape" => ->(compiler, expr, args, kwargs) {
-        "(_t = #{expr}; CGI.escapeHTML(_t) if _t)"
-      },
-      "money" => ->(compiler, expr, args, kwargs) {
-        "(_m = #{expr}; _m.nil? ? '' : \"$ \#{(_m / 100.0).round(2)}\")"
-      },
-    }
-
-    def compile(compiler)
-      if const?
-        compiler.output(name)
-      else
-        compiler.catch_errors(@line_number, show_message: true) do
-          compiler.output(self)
-        end
-      end
-    end
-
-    def const?
-      @filters.empty? && !name.respond_to?(:compile_expr)
-    end
-
-    def compile_expr(compiler)
-      @filters.reduce(compiler.compile_expr(name)) do |expr, (name, args, kwargs)|
-        if FILTERS.key?(name)
-          FILTERS[name].call(compiler, expr, args, kwargs)
-        else
-          expr
-        end
-      end
-    end
-  end
-
-  class Echo
-    def compile(compiler)
-      compiler.compile(variable)
-    end
-  end
-
-  class For
-    def compile(compiler)
-      compiler << "collection = #{compiler.compile_expr(@collection_name)}\n"
-    
-      unless @from.nil?
-        compiler << <<~RUBY
-          from_value = #{compiler.compile_expr(@from)}
-          from = if from_value.nil?
-            0
-          else
-            #{compiler.to_integer_expr(:from_value)}
-          end
-
-          limit_value = #{compiler.compile_expr(@limit)}
-          to = if limit_value.nil?
-            nil
-          else
-            #{compiler.to_integer_expr(:limit_value)} + from
-          end
-
-          collection = #{compiler.slice_collection_expr(:collection, :from, :to)}
-          #{@reversed ? "segment.reverse!" : "" }
-        RUBY
-      end
-
-      item_var = compiler.var_name(variable_name)
-      compiler << <<~RUBY
-        forloop_first = true
-        for #{item_var} in collection
-      RUBY
-      compiler.declare(item_var)
-      compiler.compile(@for_block)
-      compiler << <<~RUBY
-          forloop_first = false
-        end
-      RUBY
-
-    end
-  end
-
-  class If
-    def compile(compiler)
-      compiler << "if #{compiler.compile_expr(blocks[0])}\n"
-      compiler.compile(blocks[0].attachment)
-      blocks.drop(1).each do |block|
-        if block.else?
-          compiler << "else\n"
-        else
-          compiler << "elsif #{block.compile_expr(compiler)}\n"
-        end
-        compiler.compile(block.attachment)
-      end
-      compiler << "end\n"
-    end
-  end
-
-  class Comment
-    def compile(_compiler); end
-  end
-
-  class Condition
-    def compile_expr(compiler)
-      if operator
-        left_expr = compiler.compile_expr(left)
-        right_expr = compiler.compile_expr(right)
-        if child_relation
-          child_expr = compiler.compile_expr(child_condition)
-          expr = "((#{left_expr} #{operator} #{right_expr}) #{child_relation} #{child_expr})"
-        else
-          expr = "(#{left_expr} #{operator} #{right_expr})"
-        end
-        expr
-      else
-        left_expr = compiler.compile_expr(left)
-        expr = "#{left_expr}"
-      end
-    end
-  end
-
-  class Assign
-    def compile(compiler)
-      compiler.declare(compiler.var_name(@to))
-      compiler << "#{compiler.var_name(@to)} = #{compiler.compile_expr(@from)}\n"
-    end
-  end
-end

lib/liquid/condition.rb

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

lib/liquid/const.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Liquid
+  module Const
+    EMPTY_HASH = {}.freeze
+    EMPTY_ARRAY = [].freeze
+  end
+end

lib/liquid/context.rb

@@ -15,31 +15,40 @@ module Liquid
   #   context['bob']  #=> nil  class Context
   class Context
     attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
-    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
+    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters, :environment
 
     # rubocop:disable Metrics/ParameterLists
-    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {}, &block)
-      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments, &block)
+    def self.build(environment: Environment.default, environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {}, &block)
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments, environment, &block)
     end
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {})
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {}, environment = Environment.default)
+      @environment = environment
       @environments = [environments]
       @environments.flatten!
 
-      @static_environments = [static_environments].flat_map(&:freeze).freeze
-      @scopes              = [(outer_scope || {})]
-      @registers           = registers
+      @static_environments = [static_environments].flatten(1).freeze
+      @scopes              = [outer_scope || {}]
+      @registers           = registers.is_a?(Registers) ? registers : Registers.new(registers)
       @errors              = []
       @partial             = false
       @strict_variables    = false
-      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+      @resource_limits     = resource_limits || ResourceLimits.new(environment.default_resource_limits)
       @base_scope_depth    = 0
       @interrupts          = []
       @filters             = []
       @global_filter       = nil
       @disabled_tags       = {}
 
-      self.exception_renderer = Template.default_exception_renderer
+      # Instead of constructing new StringScanner objects for each Expression parse,
+      # we recycle the same one.
+      @string_scanner = StringScanner.new("")
+
+      @registers.static[:cached_partials] ||= {}
+      @registers.static[:file_system] ||= environment.file_system
+      @registers.static[:template_factory] ||= Liquid::TemplateFactory.new
+
+      self.exception_renderer = environment.exception_renderer
       if rethrow_errors
         self.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
       end
@@ -56,7 +65,7 @@ module Liquid
     end
 
     def strainer
-      @strainer ||= StrainerFactory.create(self, @filters)
+      @strainer ||= @environment.create_strainer(self, @filters)
     end
 
     # Adds filters to this context.
@@ -138,9 +147,10 @@ module Liquid
       check_overflow
 
       self.class.build(
+        environment: @environment,
         resource_limits: resource_limits,
         static_environments: static_environments,
-        registers: StaticRegisters.new(registers)
+        registers: Registers.new(registers),
       ).tap do |subcontext|
         subcontext.base_scope_depth   = base_scope_depth + 1
         subcontext.exception_renderer = exception_renderer
@@ -170,11 +180,20 @@ module Liquid
     # Example:
     #   products == empty #=> products.empty?
     def [](expression)
-      evaluate(Expression.parse(expression))
+      evaluate(Expression.parse(expression, @string_scanner))
     end
 
     def key?(key)
-      self[key] != nil
+      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)
@@ -187,16 +206,29 @@ 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)
+        try_variable_find_in_environments(
+          key,
+          raise_on_not_found: raise_on_not_found && !fallback_to_self_drop,
+        )
       end
 
-      variable         = variable.to_liquid
+      # `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=)
 
-      variable
+      liquid_variable = variable.to_liquid
+
+      liquid_variable.context = self if variable != liquid_variable && liquid_variable.respond_to?(:context=)
+
+      liquid_variable
     end
 
     def lookup_and_evaluate(obj, key, raise_on_not_found: true)

lib/liquid/deprecations.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Liquid
+  class Deprecations
+    class << self
+      attr_accessor :warned
+
+      Deprecations.warned = Set.new
+
+      def warn(name, alternative)
+        return if warned.include?(name)
+
+        warned << name
+
+        caller_location = caller_locations(2, 1).first
+        Warning.warn("[DEPRECATION] #{name} is deprecated. Use #{alternative} instead. Called from #{caller_location}\n")
+      end
+    end
+  end
+end

lib/liquid/drop.rb

@@ -25,9 +25,13 @@ module Liquid
   class Drop
     attr_writer :context
 
+    def initialize
+      @context = nil
+    end
+
     # Catch all for the method
     def liquid_method_missing(method)
-      return nil unless @context&.strict_variables
+      return unless @context&.strict_variables
       raise Liquid::UndefinedDropMethod, "undefined method #{method}"
     end
 

lib/liquid/environment.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+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
+
+    # The strainer template which is used to store filters that are available to
+    # use in templates.
+    attr_accessor :strainer_template
+
+    # The exception renderer that is used to render exceptions that are raised
+    # when rendering a template
+    attr_accessor :exception_renderer
+
+    # The default file system that is used to load templates from.
+    attr_accessor :file_system
+
+    # The default resource limits that are used to limit the resources that a
+    # template can consume.
+    attr_accessor :default_resource_limits
+
+    class << self
+      # Creates a new environment instance.
+      #
+      # @param tags [Hash] The tags that are available to use in
+      #  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)
+        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
+      end
+
+      # Returns the default environment instance.
+      #
+      # @return [Environment] The default environment instance.
+      def default
+        @default ||= new
+      end
+
+      # Sets the default environment instance for the duration of the block
+      #
+      # @param environment [Environment] The environment instance to use as the default for the
+      #   duration of the block.
+      # @yield
+      # @return [Object] The return value of the block.
+      def dangerously_override(environment)
+        original_default = @default
+        @default = environment
+        yield
+      ensure
+        @default = original_default
+      end
+    end
+
+    # Initializes a new environment instance.
+    # @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
+      @exception_renderer = ->(exception) { exception }
+      @file_system = BlankFileSystem.new
+      @default_resource_limits = Const::EMPTY_HASH
+      @strainer_template_class_cache = {}
+    end
+
+    # Registers a new tag with the environment.
+    #
+    # @param name [String] The name of the tag.
+    # @param klass [Liquid::Tag] The class that implements the tag.
+    # @return [void]
+    def register_tag(name, klass)
+      @tags[name] = klass
+    end
+
+    # Registers a new filter with the environment.
+    #
+    # @param filter [Module] The module that contains the filter methods.
+    # @return [void]
+    def register_filter(filter)
+      @strainer_template_class_cache.clear
+      @strainer_template.add_filter(filter)
+    end
+
+    # Registers multiple filters with this environment.
+    #
+    # @param filters [Array<Module>] The modules that contain the filter methods.
+    # @return [self]
+    def register_filters(filters)
+      @strainer_template_class_cache.clear
+      filters.each { |f| @strainer_template.add_filter(f) }
+      self
+    end
+
+    # Creates a new strainer instance with the given filters, caching the result
+    # for faster lookup.
+    #
+    # @param context [Liquid::Context] The context that the strainer will be
+    #   used in.
+    # @param filters [Array<Module>] The filters that the strainer will have
+    #   access to.
+    # @return [Liquid::Strainer] The new strainer instance.
+    def create_strainer(context, filters = Const::EMPTY_ARRAY)
+      return @strainer_template.new(context) if filters.empty?
+
+      strainer_template = @strainer_template_class_cache[filters] ||= begin
+        klass = Class.new(@strainer_template)
+        filters.each { |f| klass.add_filter(f) }
+        klass
+      end
+
+      strainer_template.new(context)
+    end
+
+    # Returns the names of all the filter methods that are available to use in
+    # the strainer template.
+    #
+    # @return [Array<String>] The names of all the filter methods.
+    def filter_method_names
+      @strainer_template.filter_method_names
+    end
+
+    # Returns the tag class for the given tag name.
+    #
+    # @param name [String] The name of the tag.
+    # @return [Liquid::Tag] The tag class.
+    def tag_for_name(name)
+      @tags[name]
+    end
+
+    def freeze
+      @tags.freeze
+      # TODO: freeze the tags, currently this is not possible because of liquid-c
+      # @strainer_template.freeze
+      super
+    end
+  end
+end

lib/liquid/errors.rb

@@ -40,19 +40,20 @@ module Liquid
     end
   end
 
-  ArgumentError       = Class.new(Error)
-  ContextError        = Class.new(Error)
-  FileSystemError     = Class.new(Error)
-  StandardError       = Class.new(Error)
-  SyntaxError         = Class.new(Error)
-  StackLevelError     = Class.new(Error)
-  MemoryError         = Class.new(Error)
-  ZeroDivisionError   = Class.new(Error)
-  FloatDomainError    = Class.new(Error)
-  UndefinedVariable   = Class.new(Error)
-  UndefinedDropMethod = Class.new(Error)
-  UndefinedFilter     = Class.new(Error)
-  MethodOverrideError = Class.new(Error)
-  DisabledError       = Class.new(Error)
-  InternalError       = Class.new(Error)
+  ArgumentError         = Class.new(Error)
+  ContextError          = Class.new(Error)
+  FileSystemError       = Class.new(Error)
+  StandardError         = Class.new(Error)
+  SyntaxError           = Class.new(Error)
+  StackLevelError       = Class.new(Error)
+  MemoryError           = Class.new(Error)
+  ZeroDivisionError     = Class.new(Error)
+  FloatDomainError      = Class.new(Error)
+  UndefinedVariable     = Class.new(Error)
+  UndefinedDropMethod   = Class.new(Error)
+  UndefinedFilter       = Class.new(Error)
+  MethodOverrideError   = Class.new(Error)
+  DisabledError         = Class.new(Error)
+  InternalError         = Class.new(Error)
+  TemplateEncodingError = Class.new(Error)
 end

lib/liquid/expression.rb

@@ -2,42 +2,127 @@
 
 module Liquid
   class Expression
+    SELF = 'self'
+
     LITERALS = {
-      nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
+      nil => nil,
+      'nil' => nil,
+      'null' => nil,
+      '' => nil,
       'true' => true,
       'false' => false,
       'blank' => '',
-      'empty' => ''
+      '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
 
-    INTEGERS_REGEX       = /\A(-?\d+)\z/
-    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/
+    DOT = ".".ord
+    ZERO = "0".ord
+    NINE = "9".ord
+    DASH = "-".ord
 
     # Use an atomic group (?>...) to avoid pathological backtracing from
     # malicious input as described in https://github.com/Shopify/liquid/issues/1357
-    RANGES_REGEX         = /\A\(\s*(?>(\S+)\s*\.\.)\s*(\S+)\s*\)\z/
+    RANGES_REGEX = /\A\(\s*(?>(\S+)\s*\.\.)\s*(\S+)\s*\)\z/
+    INTEGER_REGEX = /\A(-?\d+)\z/
+    FLOAT_REGEX = /\A(-?\d+)\.\d+\z/
 
-    def self.parse(markup)
-      return nil unless markup
-
-      markup = markup.strip
-      if (markup.start_with?('"') && markup.end_with?('"')) ||
-         (markup.start_with?("'") && markup.end_with?("'"))
-        return markup[1..-2]
+    class << self
+      def safe_parse(parser, ss = StringScanner.new(""), cache = nil)
+        parse(parser.expression, ss, cache)
       end
 
-      case markup
-      when INTEGERS_REGEX
-        Regexp.last_match(1).to_i
-      when RANGES_REGEX
-        RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2))
-      when FLOATS_REGEX
-        Regexp.last_match(1).to_f
-      else
-        if LITERALS.key?(markup)
-          LITERALS[markup]
+      def parse(markup, ss = StringScanner.new(""), cache = nil)
+        return unless markup
+
+        markup = markup.strip # markup can be a frozen string
+
+        if (markup.start_with?('"') && markup.end_with?('"')) ||
+          (markup.start_with?("'") && markup.end_with?("'"))
+          return markup[1..-2]
+        elsif LITERALS.key?(markup)
+          return LITERALS[markup]
+        end
+
+        # Cache only exists during parsing
+        if cache
+          return cache[markup] if cache.key?(markup)
+
+          cache[markup] = inner_parse(markup, ss, cache).freeze
         else
-          VariableLookup.parse(markup)
+          inner_parse(markup, ss, nil).freeze
+        end
+      end
+
+      def inner_parse(markup, ss, cache)
+        if markup.start_with?("(") && markup.end_with?(")") && markup =~ RANGES_REGEX
+          return RangeLookup.parse(
+            Regexp.last_match(1),
+            Regexp.last_match(2),
+            ss,
+            cache,
+          )
+        end
+
+        if (num = parse_number(markup, ss))
+          num
+        else
+          VariableLookup.parse(markup, ss, cache)
+        end
+      end
+
+      def parse_number(markup, ss)
+        # check if the markup is simple integer or float
+        case markup
+        when INTEGER_REGEX
+          return Integer(markup, 10)
+        when FLOAT_REGEX
+          return markup.to_f
+        end
+
+        ss.string = markup
+        # the first byte must be a digit or  a dash
+        byte = ss.scan_byte
+
+        return false if byte != DASH && (byte < ZERO || byte > NINE)
+
+        if byte == DASH
+          peek_byte = ss.peek_byte
+
+          # if it starts with a dash, the next byte must be a digit
+          return false if peek_byte.nil? || !(peek_byte >= ZERO && peek_byte <= NINE)
+        end
+
+        # The markup could be a float with multiple dots
+        first_dot_pos = nil
+        num_end_pos = nil
+
+        while (byte = ss.scan_byte)
+          return false if byte != DOT && (byte < ZERO || byte > NINE)
+
+          # we found our number and now we are just scanning the rest of the string
+          next if num_end_pos
+
+          if byte == DOT
+            if first_dot_pos.nil?
+              first_dot_pos = ss.pos
+            else
+              # we found another dot, so we know that the number ends here
+              num_end_pos = ss.pos - 1
+            end
+          end
+        end
+
+        num_end_pos = markup.length if ss.eos?
+
+        if num_end_pos
+          # number ends with a number "123.123"
+          markup.byteslice(0, num_end_pos).to_f
+        else
+          # number ends with a dot "123."
+          markup.byteslice(0, first_dot_pos).to_f
         end
       end
     end

lib/liquid/forloop_drop.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type object
+  # @liquid_name forloop
+  # @liquid_summary
+  #   Information about a parent [`for` loop](/docs/api/liquid/tags/for).
   class ForloopDrop < Drop
     def initialize(name, length, parentloop)
       @name       = name
@@ -9,33 +14,68 @@ module Liquid
       @index      = 0
     end
 
-    attr_reader :length, :parentloop
+    # @liquid_public_docs
+    # @liquid_name length
+    # @liquid_summary
+    #   The total number of iterations in the loop.
+    # @liquid_return [number]
+    attr_reader :length
 
-    def name
-      Usage.increment('forloop_drop_name')
-      @name
-    end
+    # @liquid_public_docs
+    # @liquid_name parentloop
+    # @liquid_summary
+    #   The parent `forloop` object.
+    # @liquid_description
+    #   If the current `for` loop isn't nested inside another `for` loop, then `nil` is returned.
+    # @liquid_return [forloop]
+    attr_reader :parentloop
 
+    attr_reader :name
+
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 1-based index of the current iteration.
+    # @liquid_return [number]
     def index
       @index + 1
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 0-based index of the current iteration.
+    # @liquid_return [number]
     def index0
       @index
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 1-based index of the current iteration, in reverse order.
+    # @liquid_return [number]
     def rindex
       @length - @index
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 0-based index of the current iteration, in reverse order.
+    # @liquid_return [number]
     def rindex0
       @length - @index - 1
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   Returns `true` if the current iteration is the first. Returns `false` if not.
+    # @liquid_return [boolean]
     def first
       @index == 0
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   Returns `true` if the current iteration is the last. Returns `false` if not.
+    # @liquid_return [boolean]
     def last
       @index == @length - 1
     end

lib/liquid/i18n.rb

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

lib/liquid/lexer.rb

@@ -1,62 +1,179 @@
 # frozen_string_literal: true
 
-require "strscan"
 module Liquid
   class Lexer
-    SPECIALS = {
-      '|' => :pipe,
-      '.' => :dot,
-      ':' => :colon,
-      ',' => :comma,
-      '[' => :open_square,
-      ']' => :close_square,
-      '(' => :open_round,
-      ')' => :close_round,
-      '?' => :question,
-      '-' => :dash,
-    }.freeze
-    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
-    SINGLE_STRING_LITERAL = /'[^\']*'/
+    CLOSE_ROUND = [:close_round, ")"].freeze
+    CLOSE_SQUARE = [:close_square, "]"].freeze
+    COLON = [:colon, ":"].freeze
+    COMMA = [:comma, ","].freeze
+    COMPARISION_NOT_EQUAL = [:comparison, "!="].freeze
+    COMPARISON_CONTAINS = [:comparison, "contains"].freeze
+    COMPARISON_EQUAL = [:comparison, "=="].freeze
+    COMPARISON_GREATER_THAN = [:comparison, ">"].freeze
+    COMPARISON_GREATER_THAN_OR_EQUAL = [:comparison, ">="].freeze
+    COMPARISON_LESS_THAN = [:comparison, "<"].freeze
+    COMPARISON_LESS_THAN_OR_EQUAL = [:comparison, "<="].freeze
+    COMPARISON_NOT_EQUAL_ALT = [:comparison, "<>"].freeze
+    DASH = [:dash, "-"].freeze
+    DOT = [:dot, "."].freeze
+    DOTDOT = [:dotdot, ".."].freeze
+    DOT_ORD = ".".ord
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
+    EOS = [:end_of_string].freeze
+    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
     NUMBER_LITERAL        = /-?\d+(\.\d+)?/
-    DOTDOT                = /\.\./
-    COMPARISON_OPERATOR   = /==|!=|<>|<=?|>=?|contains(?=\s)/
+    OPEN_ROUND = [:open_round, "("].freeze
+    OPEN_SQUARE = [:open_square, "["].freeze
+    PIPE = [:pipe, "|"].freeze
+    QUESTION = [:question, "?"].freeze
+    RUBY_WHITESPACE = [" ", "\t", "\r", "\n", "\f"].freeze
+    SINGLE_STRING_LITERAL = /'[^\']*'/
     WHITESPACE_OR_NOTHING = /\s*/
 
-    def initialize(input)
-      @ss = StringScanner.new(input)
+    SINGLE_COMPARISON_TOKENS = [].tap do |table|
+      table["<".ord] = COMPARISON_LESS_THAN
+      table[">".ord] = COMPARISON_GREATER_THAN
+      table.freeze
     end
 
-    def tokenize
-      @output = []
+    TWO_CHARS_COMPARISON_JUMP_TABLE = [].tap do |table|
+      table["=".ord] = [].tap do |sub_table|
+        sub_table["=".ord] = COMPARISON_EQUAL
+        sub_table.freeze
+      end
+      table["!".ord] = [].tap do |sub_table|
+        sub_table["=".ord] = COMPARISION_NOT_EQUAL
+        sub_table.freeze
+      end
+      table.freeze
+    end
 
-      until @ss.eos?
-        @ss.skip(WHITESPACE_OR_NOTHING)
-        break if @ss.eos?
-        tok      = if (t = @ss.scan(COMPARISON_OPERATOR))
-          [:comparison, t]
-        elsif (t = @ss.scan(SINGLE_STRING_LITERAL))
-          [:string, t]
-        elsif (t = @ss.scan(DOUBLE_STRING_LITERAL))
-          [:string, t]
-        elsif (t = @ss.scan(NUMBER_LITERAL))
-          [:number, t]
-        elsif (t = @ss.scan(IDENTIFIER))
-          [:id, t]
-        elsif (t = @ss.scan(DOTDOT))
-          [:dotdot, t]
-        else
-          c     = @ss.getch
-          if (s = SPECIALS[c])
-            [s, c]
+    COMPARISON_JUMP_TABLE = [].tap do |table|
+      table["<".ord] = [].tap do |sub_table|
+        sub_table["=".ord] = COMPARISON_LESS_THAN_OR_EQUAL
+        sub_table[">".ord] = COMPARISON_NOT_EQUAL_ALT
+        sub_table.freeze
+      end
+      table[">".ord] = [].tap do |sub_table|
+        sub_table["=".ord] = COMPARISON_GREATER_THAN_OR_EQUAL
+        sub_table.freeze
+      end
+      table.freeze
+    end
+
+    NEXT_MATCHER_JUMP_TABLE = [].tap do |table|
+      "a".upto("z") do |c|
+        table[c.ord] = [:id, IDENTIFIER].freeze
+        table[c.upcase.ord] = [:id, IDENTIFIER].freeze
+      end
+      table["_".ord] = [:id, IDENTIFIER].freeze
+
+      "0".upto("9") do |c|
+        table[c.ord] = [:number, NUMBER_LITERAL].freeze
+      end
+      table["-".ord] = [:number, NUMBER_LITERAL].freeze
+
+      table["'".ord] = [:string, SINGLE_STRING_LITERAL].freeze
+      table["\"".ord] = [:string, DOUBLE_STRING_LITERAL].freeze
+      table.freeze
+    end
+
+    SPECIAL_TABLE = [].tap do |table|
+      table["|".ord] = PIPE
+      table[".".ord] = DOT
+      table[":".ord] = COLON
+      table[",".ord] = COMMA
+      table["[".ord] = OPEN_SQUARE
+      table["]".ord] = CLOSE_SQUARE
+      table["(".ord] = OPEN_ROUND
+      table[")".ord] = CLOSE_ROUND
+      table["?".ord] = QUESTION
+      table["-".ord] = DASH
+    end
+
+    NUMBER_TABLE = [].tap do |table|
+      "0".upto("9") do |c|
+        table[c.ord] = true
+      end
+      table.freeze
+    end
+
+    # rubocop:disable Metrics/BlockNesting
+    class << self
+      def tokenize(ss)
+        output = []
+
+        until ss.eos?
+          ss.skip(WHITESPACE_OR_NOTHING)
+
+          break if ss.eos?
+
+          start_pos = ss.pos
+          peeked = ss.peek_byte
+
+          if (special = SPECIAL_TABLE[peeked])
+            ss.scan_byte
+            # Special case for ".."
+            if special == DOT && ss.peek_byte == DOT_ORD
+              ss.scan_byte
+              output << DOTDOT
+            elsif special == DASH
+              # Special case for negative numbers
+              if (peeked_byte = ss.peek_byte) && NUMBER_TABLE[peeked_byte]
+                ss.pos -= 1
+                output << [:number, ss.scan(NUMBER_LITERAL)]
+              else
+                output << special
+              end
+            else
+              output << special
+            end
+          elsif (sub_table = TWO_CHARS_COMPARISON_JUMP_TABLE[peeked])
+            ss.scan_byte
+            if (peeked_byte = ss.peek_byte) && (found = sub_table[peeked_byte])
+              output << found
+              ss.scan_byte
+            else
+              raise_syntax_error(start_pos, ss)
+            end
+          elsif (sub_table = COMPARISON_JUMP_TABLE[peeked])
+            ss.scan_byte
+            if (peeked_byte = ss.peek_byte) && (found = sub_table[peeked_byte])
+              output << found
+              ss.scan_byte
+            else
+              output << SINGLE_COMPARISON_TOKENS[peeked]
+            end
           else
-            raise SyntaxError, "Unexpected character #{c}"
+            type, pattern = NEXT_MATCHER_JUMP_TABLE[peeked]
+
+            if type && (t = ss.scan(pattern))
+              # Special case for "contains"
+              output << if type == :id && t == "contains" && output.last&.first != :dot
+                COMPARISON_CONTAINS
+              else
+                [type, t]
+              end
+            else
+              raise_syntax_error(start_pos, ss)
+            end
           end
         end
-        @output << tok
+        # rubocop:enable Metrics/BlockNesting
+        output << EOS
+      rescue ::ArgumentError => e
+        if e.message == "invalid byte sequence in #{ss.string.encoding}"
+          raise SyntaxError, "Invalid byte sequence in #{ss.string.encoding}"
+        else
+          raise
+        end
       end
 
-      @output << [:end_of_string]
+      def raise_syntax_error(start_pos, ss)
+        ss.pos = start_pos
+        # the character could be a UTF-8 character, use getch to get all the bytes
+        raise SyntaxError, "Unexpected character #{ss.getch}"
+      end
     end
   end
 end

lib/liquid/locales/en.yml

@@ -2,26 +2,31 @@
   errors:
     syntax:
       tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: %{tag}"
+      block_tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: {% %{tag} %}{% end%{tag} %}"
       assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
       capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
       case: "Syntax Error in 'case' - Valid syntax: case [condition]"
       case_invalid_when: "Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %}"
       case_invalid_else: "Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) "
       cycle: "Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]"
+      doc_invalid_nested: "Syntax Error in 'doc' - Nested doc tags are not allowed"
       for: "Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]"
       for_invalid_in: "For loops require an 'in' clause"
       for_invalid_attribute: "Invalid attribute in for loop. Valid attributes are limit and offset"
       if: "Syntax Error in tag 'if' - Valid syntax: if [expression]"
       include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
-      unknown_tag: "Unknown tag '%{tag}'"
+      inline_comment_invalid: "Syntax error in tag '#' - Each line of comments must be prefixed by the '#' character"
       invalid_delimiter: "'%{tag}' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      invalid_template_encoding: "Invalid template encoding"
+      render: "Syntax error in tag 'render' - Template name must be a quoted string"
+      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
+      table_row_invalid_attribute: "Invalid attribute '%{attribute}' in tablerow loop. Valid attributes are cols, limit, offset, and range"
+      tag_never_closed: "'%{block_name}' tag was never closed"
+      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
       unexpected_else: "%{block_name} tag does not expect 'else' tag"
       unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
-      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
+      unknown_tag: "Unknown tag '%{tag}'"
       variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
-      tag_never_closed: "'%{block_name}' tag was never closed"
-      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
-      render: "Syntax error in tag 'render' - Template name must be a quoted string"
     argument:
       include: "Argument error in tag 'include' - Illegal template name"
     disabled:

lib/liquid/parse_context.rb

@@ -3,14 +3,27 @@
 module Liquid
   class ParseContext
     attr_accessor :locale, :line_number, :trim_whitespace, :depth
-    attr_reader :partial, :warnings, :error_mode
+    attr_reader :partial, :warnings, :error_mode, :environment
 
-    def initialize(options = {})
+    def initialize(options = Const::EMPTY_HASH)
+      @environment = options.fetch(:environment, Environment.default)
       @template_options = options ? options.dup : {}
 
       @locale   = @template_options[:locale] ||= I18n.new
       @warnings = []
 
+      # constructing new StringScanner in Lexer, Tokenizer, etc is expensive
+      # This StringScanner will be shared by all of them
+      @string_scanner = StringScanner.new("")
+
+      @expression_cache = if options[:expression_cache].nil?
+        {}
+      elsif options[:expression_cache].respond_to?(:[]) && options[:expression_cache].respond_to?(:[]=)
+        options[:expression_cache]
+      elsif options[:expression_cache]
+        {}
+      end
+
       self.depth   = 0
       self.partial = false
     end
@@ -23,19 +36,44 @@ module Liquid
       Liquid::BlockBody.new
     end
 
-    def new_tokenizer(markup, start_line_number: nil, for_liquid_tag: false)
-      Tokenizer.new(markup, line_number: start_line_number, for_liquid_tag: for_liquid_tag)
+    def new_parser(input)
+      @string_scanner.string = input
+      Parser.new(@string_scanner, reject_bare_brackets: @error_mode == :strict2 || @error_mode == :rigid)
     end
 
-    def parse_expression(markup)
-      Expression.parse(markup)
+    def new_tokenizer(source, start_line_number: nil, for_liquid_tag: false)
+      Tokenizer.new(
+        source: source,
+        string_scanner: @string_scanner,
+        line_number: start_line_number,
+        for_liquid_tag: for_liquid_tag,
+      )
+    end
+
+    def safe_parse_expression(parser)
+      Expression.safe_parse(parser, @string_scanner, @expression_cache)
+    end
+
+    def parse_expression(markup, safe: false)
+      if !safe && @error_mode == :strict2
+        # parse_expression is a widely used API. To maintain backward
+        # compatibility while raising awareness about strict2 parser standards,
+        # the safe flag supports API users make a deliberate decision.
+        #
+        # In strict2 mode, markup MUST come from a string returned by the parser
+        # (e.g., parser.expression). We're not calling the parser here to
+        # prevent redundant parser overhead.
+        raise Liquid::InternalError, "unsafe parse_expression cannot be used in strict2 mode"
+      end
+
+      Expression.parse(markup, @string_scanner, @expression_cache)
     end
 
     def partial=(value)
       @partial = value
       @options = value ? partial_options : @template_options
 
-      @error_mode = @options[:error_mode] || Template.error_mode
+      @error_mode = @options[:error_mode] || @environment.error_mode
     end
 
     def partial_options

lib/liquid/parse_tree_visitor.rb

@@ -36,7 +36,7 @@ module Liquid
     protected
 
     def children
-      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : []
+      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : Const::EMPTY_ARRAY
     end
   end
 end

lib/liquid/parser.rb

@@ -2,10 +2,11 @@
 
 module Liquid
   class Parser
-    def initialize(input)
-      l       = Lexer.new(input)
-      @tokens = l.tokenize
+    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,7 +54,10 @@ module Liquid
         str = consume
         str << variable_lookups
       when :open_square
-        str = consume
+        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)
         str << variable_lookups

lib/liquid/parser_switching.rb

@@ -2,10 +2,25 @@
 
 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
@@ -16,11 +31,13 @@ module Liquid
 
     def parse_with_selected_parser(markup)
       case parse_context.error_mode
-      when :strict then strict_parse_with_error_context(markup)
-      when :lax    then lax_parse(markup)
+      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
-          strict_parse_with_error_context(markup)
+          strict2_parse_with_error_context(markup)
         rescue SyntaxError => e
           parse_context.warnings << e
           lax_parse(markup)
@@ -28,8 +45,24 @@ module Liquid
       end
     end
 
+    def strict2_mode?
+      parse_context.error_mode == :strict2 || parse_context.error_mode == :rigid
+    end
+
     private
 
+    def rigid_warn
+      Deprecations.warn(':rigid', ':strict2')
+    end
+
+    def strict2_parse_with_error_context(markup)
+      strict2_parse(markup)
+    rescue SyntaxError => e
+      e.line_number    = line_number
+      e.markup_context = markup_context(markup)
+      raise e
+    end
+
     def strict_parse_with_error_context(markup)
       strict_parse(markup)
     rescue SyntaxError => e

lib/liquid/partial_cache.rb

@@ -3,20 +3,29 @@
 module Liquid
   class PartialCache
     def self.load(template_name, context:, parse_context:)
-      cached_partials = (context.registers[:cached_partials] ||= {})
-      cached = cached_partials[template_name]
+      cached_partials = context.registers[:cached_partials]
+      cache_key = "#{template_name}:#{parse_context.error_mode}"
+      cached = cached_partials[cache_key]
       return cached if cached
 
-      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
+      file_system = context.registers[:file_system]
       source      = file_system.read_template_file(template_name)
 
       parse_context.partial = true
 
-      template_factory = (context.registers[:template_factory] ||= Liquid::TemplateFactory.new)
+      template_factory = context.registers[:template_factory]
       template = template_factory.for(template_name)
 
-      partial = template.parse(source, parse_context)
-      cached_partials[template_name] = partial
+      begin
+        partial = template.parse(source, parse_context)
+      rescue Liquid::Error => e
+        e.template_name = template&.name || template_name
+        raise e
+      end
+
+      partial.name ||= template_name
+
+      cached_partials[cache_key] = partial
     ensure
       parse_context.partial = false
     end

lib/liquid/range_lookup.rb

@@ -2,13 +2,23 @@
 
 module Liquid
   class RangeLookup
-    def self.parse(start_markup, end_markup)
-      start_obj = Expression.parse(start_markup)
-      end_obj   = Expression.parse(end_markup)
+    def self.parse(start_markup, end_markup, string_scanner, cache = nil)
+      start_obj = Expression.parse(start_markup, string_scanner, cache)
+      end_obj   = Expression.parse(end_markup, string_scanner, cache)
       if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
         new(start_obj, end_obj)
       else
-        start_obj.to_i..end_obj.to_i
+        begin
+          start_obj.to_i..end_obj.to_i
+        rescue NoMethodError
+          invalid_expr = start_markup unless start_obj.respond_to?(:to_i)
+          invalid_expr ||= end_markup unless end_obj.respond_to?(:to_i)
+          if invalid_expr
+            raise Liquid::SyntaxError, "Invalid expression type '#{invalid_expr}' in range expression"
+          end
+
+          raise
+        end
       end
     end
 
@@ -25,10 +35,6 @@ module Liquid
       start_int..end_int
     end
 
-    def compile_expr(compiler)
-      compiler.fallback_evaluate_expr(self)
-    end
-
     private
 
     def to_integer(input)

lib/liquid/register.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Register
-  end
-end

lib/liquid/registers.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
 module Liquid
-  class StaticRegisters
+  class Registers
     attr_reader :static
 
     def initialize(registers = {})
-      @static    = registers.is_a?(StaticRegisters) ? registers.static : registers
-      @registers = {}
+      @static = registers.is_a?(Registers) ? registers.static : registers
+      @changes = {}
     end
 
     def []=(key, value)
-      @registers[key] = value
+      @changes[key] = value
     end
 
     def [](key)
-      if @registers.key?(key)
-        @registers[key]
+      if @changes.key?(key)
+        @changes[key]
       else
         @static[key]
       end
     end
 
     def delete(key)
-      @registers.delete(key)
+      @changes.delete(key)
     end
 
     UNDEFINED = Object.new
 
     def fetch(key, default = UNDEFINED, &block)
-      if @registers.key?(key)
-        @registers.fetch(key)
+      if @changes.key?(key)
+        @changes.fetch(key)
       elsif default != UNDEFINED
         if block_given?
           @static.fetch(key, &block)
@@ -42,7 +42,10 @@ module Liquid
     end
 
     def key?(key)
-      @registers.key?(key) || @static.key?(key)
+      @changes.key?(key) || @static.key?(key)
     end
   end
+
+  # Alias for backwards compatibility
+  StaticRegisters = Registers
 end

lib/liquid/resource_limits.rb

@@ -2,24 +2,39 @@
 
 module Liquid
   class ResourceLimits
-    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
-    attr_reader :render_score, :assign_score
+    attr_accessor :render_length_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
 
     def initialize(limits)
-      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit  = limits[:render_score_limit]
-      @assign_score_limit  = limits[:assign_score_limit]
+      @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
       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
@@ -47,6 +62,8 @@ 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

@@ -0,0 +1,54 @@
+# 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/strainer_factory.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # StrainerFactory is the factory for the filters system.
-  module StrainerFactory
-    extend self
-
-    def add_global_filter(filter)
-      strainer_class_cache.clear
-      GlobalCache.add_filter(filter)
-    end
-
-    def create(context, filters = [])
-      strainer_from_cache(filters).new(context)
-    end
-
-    GlobalCache = Class.new(StrainerTemplate)
-
-    private
-
-    def strainer_from_cache(filters)
-      if filters.empty?
-        GlobalCache
-      else
-        strainer_class_cache[filters] ||= begin
-          klass = Class.new(GlobalCache)
-          filters.each { |f| klass.add_filter(f) }
-          klass
-        end
-      end
-    end
-
-    def strainer_class_cache
-      @strainer_class_cache ||= {}
-    end
-  end
-end

lib/liquid/strainer_template.rb

@@ -36,6 +36,10 @@ module Liquid
         subclass.instance_variable_set(:@filter_methods, @filter_methods.dup)
       end
 
+      def filter_method_names
+        filter_methods.map(&:to_s).to_a
+      end
+
       private
 
       def filter_methods

lib/liquid/tablerowloop_drop.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type object
+  # @liquid_name tablerowloop
+  # @liquid_summary
+  #   Information about a parent [`tablerow` loop](/docs/api/liquid/tags/tablerow).
   class TablerowloopDrop < Drop
     def initialize(length, cols)
       @length = length
@@ -10,40 +15,92 @@ module Liquid
       @index  = 0
     end
 
-    attr_reader :length, :col, :row
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The total number of iterations in the loop.
+    # @liquid_return [number]
+    attr_reader :length
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 1-based index of the current column.
+    # @liquid_return [number]
+    attr_reader :col
+
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 1-based index of current row.
+    # @liquid_return [number]
+    attr_reader :row
+
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 1-based index of the current iteration.
+    # @liquid_return [number]
     def index
       @index + 1
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 0-based index of the current iteration.
+    # @liquid_return [number]
     def index0
       @index
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 0-based index of the current column.
+    # @liquid_return [number]
     def col0
       @col - 1
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 1-based index of the current iteration, in reverse order.
+    # @liquid_return [number]
     def rindex
       @length - @index
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 0-based index of the current iteration, in reverse order.
+    # @liquid_return [number]
     def rindex0
       @length - @index - 1
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   Returns `true` if the current iteration is the first. Returns `false` if not.
+    # @liquid_return [boolean]
     def first
       @index == 0
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   Returns `true` if the current iteration is the last. Returns `false` if not.
+    # @liquid_return [boolean]
     def last
       @index == @length - 1
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   Returns `true` if the current column is the first in the row. Returns `false` if not.
+    # @liquid_return [boolean]
     def col_first
       @col == 1
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   Returns `true` if the current column is the last in the row. Returns `false` if not.
+    # @liquid_return [boolean]
     def col_last
       @col == @cols
     end

lib/liquid/tag.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'liquid/tag/disabler'
+require 'liquid/tag/disableable'
+
 module Liquid
   class Tag
     attr_reader :nodelist, :tag_name, :line_number, :parse_context
@@ -14,12 +17,18 @@ module Liquid
       end
 
       def disable_tags(*tag_names)
-        @disabled_tags ||= []
-        @disabled_tags.concat(tag_names)
+        tag_names += disabled_tags
+        define_singleton_method(:disabled_tags) { tag_names }
         prepend(Disabler)
       end
 
       private :new
+
+      protected
+
+      def disabled_tags
+        []
+      end
     end
 
     def initialize(tag_name, markup, parse_context)
@@ -48,7 +57,8 @@ module Liquid
     # of the `render_to_output_buffer` method will become the default and the `render`
     # method will be removed.
     def render_to_output_buffer(context, output)
-      output << render(context)
+      render_result = render(context)
+      output << render_result if render_result
       output
     end
 
@@ -58,8 +68,12 @@ module Liquid
 
     private
 
-    def parse_expression(markup)
-      parse_context.parse_expression(markup)
+    def safe_parse_expression(parser)
+      parse_context.safe_parse_expression(parser)
+    end
+
+    def parse_expression(markup, safe: false)
+      parse_context.parse_expression(markup, safe: safe)
     end
   end
 end

lib/liquid/tag/disabler.rb

@@ -3,14 +3,6 @@
 module Liquid
   class Tag
     module Disabler
-      module ClassMethods
-        attr_reader :disabled_tags
-      end
-
-      def self.prepended(base)
-        base.extend(ClassMethods)
-      end
-
       def render_to_output_buffer(context, output)
         context.with_disabled_tags(self.class.disabled_tags) do
           super

lib/liquid/tags.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "tags/table_row"
+require_relative "tags/echo"
+require_relative "tags/if"
+require_relative "tags/break"
+require_relative "tags/inline_comment"
+require_relative "tags/for"
+require_relative "tags/assign"
+require_relative "tags/ifchanged"
+require_relative "tags/case"
+require_relative "tags/include"
+require_relative "tags/continue"
+require_relative "tags/capture"
+require_relative "tags/decrement"
+require_relative "tags/unless"
+require_relative "tags/increment"
+require_relative "tags/comment"
+require_relative "tags/raw"
+require_relative "tags/render"
+require_relative "tags/cycle"
+require_relative "tags/doc"
+
+module Liquid
+  module Tags
+    STANDARD_TAGS = {
+      'cycle' => Cycle,
+      'render' => Render,
+      'raw' => Raw,
+      'comment' => Comment,
+      'increment' => Increment,
+      'unless' => Unless,
+      'decrement' => Decrement,
+      'capture' => Capture,
+      'continue' => Continue,
+      'include' => Include,
+      'case' => Case,
+      'ifchanged' => Ifchanged,
+      'assign' => Assign,
+      'for' => For,
+      '#' => InlineComment,
+      'break' => Break,
+      'if' => If,
+      'echo' => Echo,
+      'tablerow' => TableRow,
+      'doc' => Doc,
+    }.freeze
+  end
+end

lib/liquid/tags/assign.rb

@@ -1,15 +1,25 @@
 # frozen_string_literal: true
 
 module Liquid
-  # Assign sets a variable in your template.
-  #
-  #   {% assign foo = 'monkey' %}
-  #
-  # You can then use the variable later in the page.
-  #
-  #  {{ foo }}
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category variable
+  # @liquid_name assign
+  # @liquid_summary
+  #   Creates a new variable.
+  # @liquid_description
+  #   You can create variables of any [basic type](/docs/api/liquid/basics#types), [object](/docs/api/liquid/objects), or object property.
   #
+  #   > Caution:
+  #   > Predefined Liquid objects can be overridden by variables with the same name.
+  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
+  # @liquid_syntax
+  #   {% assign variable_name = value %}
+  # @liquid_syntax_keyword variable_name The name of the variable being created.
+  # @liquid_syntax_keyword value The value you want to assign to the variable.
   class Assign < Tag
+    include ParserSwitching
+
     Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
     # @api private
@@ -21,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)
@@ -29,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
@@ -68,6 +101,4 @@ module Liquid
       end
     end
   end
-
-  Template.register_tag('assign', Assign)
 end

lib/liquid/tags/break.rb

@@ -10,6 +10,14 @@ module Liquid
   #      {% endif %}
   #    {% endfor %}
   #
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category iteration
+  # @liquid_name break
+  # @liquid_summary
+  #   Stops a [`for` loop](/docs/api/liquid/tags/for) from iterating.
+  # @liquid_syntax
+  #   {% break %}
   class Break < Tag
     INTERRUPT = BreakInterrupt.new.freeze
 
@@ -18,6 +26,4 @@ module Liquid
       output
     end
   end
-
-  Template.register_tag('break', Break)
 end

lib/liquid/tags/capture.rb

@@ -1,22 +1,37 @@
 # frozen_string_literal: true
 
 module Liquid
-  # Capture stores the result of a block into a variable without rendering it inplace.
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category variable
+  # @liquid_name capture
+  # @liquid_summary
+  #   Creates a new variable with a string value.
+  # @liquid_description
+  #   You can create complex strings with Liquid logic and variables.
   #
-  #   {% capture heading %}
-  #     Monkeys!
+  #   > Caution:
+  #   > Predefined Liquid objects can be overridden by variables with the same name.
+  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
+  # @liquid_syntax
+  #   {% capture variable %}
+  #     value
   #   {% endcapture %}
-  #   ...
-  #   <h1>{{ heading }}</h1>
-  #
-  # Capture is useful for saving content for use later in your template, such as
-  # in a sidebar or footer.
-  #
+  # @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
@@ -24,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)
@@ -36,6 +61,4 @@ module Liquid
       true
     end
   end
-
-  Template.register_tag('capture', Capture)
 end

lib/liquid/tags/case.rb

@@ -1,6 +1,27 @@
 # frozen_string_literal: true
 
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category conditional
+  # @liquid_name case
+  # @liquid_summary
+  #   Renders a specific expression depending on the value of a specific variable.
+  # @liquid_syntax
+  #   {% case variable %}
+  #     {% when first_value %}
+  #       first_expression
+  #     {% when second_value %}
+  #       second_expression
+  #     {% else %}
+  #       third_expression
+  #   {% endcase %}
+  # @liquid_syntax_keyword variable The name of the variable you want to base your case statement on.
+  # @liquid_syntax_keyword first_value A specific value to check for.
+  # @liquid_syntax_keyword second_value A specific value to check for.
+  # @liquid_syntax_keyword first_expression An expression to be rendered when the variable's value matches `first_value`.
+  # @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
@@ -10,12 +31,7 @@ module Liquid
     def initialize(tag_name, markup, options)
       super
       @blocks = []
-
-      if markup =~ Syntax
-        @left = parse_expression(Regexp.last_match(1))
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.case")
-      end
+      parse_with_selected_parser(markup)
     end
 
     def parse(tokens)
@@ -56,7 +72,7 @@ module Liquid
         end
 
         result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context)
+          block.evaluate(context),
         )
 
         if result
@@ -70,9 +86,50 @@ module Liquid
 
     private
 
+    def strict2_parse(markup)
+      parser = @parse_context.new_parser(markup)
+      @left = safe_parse_expression(parser)
+      parser.consume(:end_of_string)
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      if markup =~ Syntax
+        @left = parse_expression(Regexp.last_match(1))
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.case")
+      end
+    end
+
     def record_when_condition(markup)
       body = new_body
 
+      if strict2_mode?
+        parse_strict2_when(markup, body)
+      else
+        parse_lax_when(markup, body)
+      end
+    end
+
+    def parse_strict2_when(markup, body)
+      parser = @parse_context.new_parser(markup)
+
+      loop do
+        expr = Condition.parse_expression(parse_context, parser.expression, safe: true)
+        block = Condition.new(@left, '==', expr)
+        block.attach(body)
+        @blocks << block
+
+        break unless parser.id?('or') || parser.consume?(:comma)
+      end
+
+      parser.consume(:end_of_string)
+    end
+
+    def parse_lax_when(markup, body)
       while markup
         unless markup =~ WhenSyntax
           raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
@@ -102,6 +159,4 @@ module Liquid
       end
     end
   end
-
-  Template.register_tag('case', Case)
 end

lib/liquid/tags/comment.rb

@@ -1,6 +1,19 @@
 # frozen_string_literal: true
 
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category syntax
+  # @liquid_name comment
+  # @liquid_summary
+  #   Prevents an expression from being rendered or output.
+  # @liquid_description
+  #   Any text inside `comment` tags won't be output, and any Liquid code will be parsed, but not executed.
+  # @liquid_syntax
+  #   {% comment %}
+  #     content
+  #   {% endcomment %}
+  # @liquid_syntax_keyword content The content of the comment.
   class Comment < Block
     def render_to_output_buffer(_context, output)
       output
@@ -12,7 +25,64 @@ module Liquid
     def blank?
       true
     end
-  end
 
-  Template.register_tag('comment', Comment)
+    private
+
+    def parse_body(body, tokenizer)
+      if parse_context.depth >= MAX_DEPTH
+        raise StackLevelError, "Nesting too deep"
+      end
+
+      parse_context.depth += 1
+      comment_tag_depth = 1
+
+      begin
+        # Consume tokens without creating child nodes.
+        # The children tag doesn't require to be a valid Liquid except the comment and raw tag.
+        # The child comment and raw tag must be closed.
+        while (token = tokenizer.send(:shift))
+          tag_name = if tokenizer.for_liquid_tag
+            next if token.empty? || token.match?(BlockBody::WhitespaceOrNothing)
+
+            tag_name_match = BlockBody::LiquidTagToken.match(token)
+
+            next if tag_name_match.nil?
+
+            tag_name_match[1]
+          else
+            token =~ BlockBody::FullToken
+            Regexp.last_match(2)
+          end
+
+          case tag_name
+          when "raw"
+            parse_raw_tag_body(tokenizer)
+          when "comment"
+            comment_tag_depth += 1
+          when "endcomment"
+            comment_tag_depth -= 1
+          end
+
+          if comment_tag_depth.zero?
+            parse_context.trim_whitespace = (token[-3] == WhitespaceControl) unless tokenizer.for_liquid_tag
+            return false
+          end
+        end
+
+        raise_tag_never_closed(block_name)
+      ensure
+        parse_context.depth -= 1
+      end
+
+      false
+    end
+
+    def parse_raw_tag_body(tokenizer)
+      while (token = tokenizer.send(:shift))
+        return if token =~ BlockBody::FullTokenPossiblyInvalid && "endraw" == Regexp.last_match(2)
+      end
+
+      raise_tag_never_closed("raw")
+    end
+  end
 end

lib/liquid/tags/continue.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
 module Liquid
-  # Continue tag to be used to break out of a for loop.
-  #
-  # == Basic Usage:
-  #    {% for item in collection %}
-  #      {% if item.condition %}
-  #        {% continue %}
-  #      {% endif %}
-  #    {% endfor %}
-  #
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category iteration
+  # @liquid_name continue
+  # @liquid_summary
+  #   Causes a [`for` loop](/docs/api/liquid/tags/for) to skip to the next iteration.
+  # @liquid_syntax
+  #   {% continue %}
   class Continue < Tag
     INTERRUPT = ContinueInterrupt.new.freeze
 
@@ -18,6 +17,4 @@ module Liquid
       output
     end
   end
-
-  Template.register_tag('continue', Continue)
 end

lib/liquid/tags/cycle.rb

@@ -1,36 +1,33 @@
 # frozen_string_literal: true
 
 module Liquid
-  # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
-  #
-  #   {% for item in items %}
-  #     <div class="{% cycle 'red', 'green', 'blue' %}"> {{ item }} </div>
-  #   {% end %}
-  #
-  #    <div class="red"> Item one </div>
-  #    <div class="green"> Item two </div>
-  #    <div class="blue"> Item three </div>
-  #    <div class="red"> Item four </div>
-  #    <div class="green"> Item five</div>
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category iteration
+  # @liquid_name cycle
+  # @liquid_summary
+  #   Loops through a group of strings and outputs them one at a time for each iteration of a [`for` loop](/docs/api/liquid/tags/for).
+  # @liquid_description
+  #   The `cycle` tag must be used inside a `for` loop.
   #
+  #   > Tip:
+  #   > Use the `cycle` tag to output text in a predictable pattern. For example, to apply odd/even classes to rows in a table.
+  # @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
 
     def initialize(tag_name, markup, options)
       super
-      case markup
-      when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
-        @name      = parse_expression(Regexp.last_match(1))
-      when SimpleSyntax
-        @variables = variables_from_string(markup)
-        @name      = @variables.to_s
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
-      end
+      parse_with_selected_parser(markup)
+    end
+
+    def named?
+      @is_named
     end
 
     def render_to_output_buffer(context, output)
@@ -58,19 +55,86 @@ module Liquid
 
     private
 
+    # cycle [name:] expression(, expression)*
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup)
+
+      @variables = []
+
+      raise SyntaxError, options[:locale].t("errors.syntax.cycle") if p.look(:end_of_string)
+
+      first_expression = safe_parse_expression(p)
+      if p.look(:colon)
+        # cycle name: expr1, expr2, ...
+        @name = first_expression
+        @is_named = true
+        p.consume(:colon)
+        # After the colon, parse the first variable (required for named cycles)
+        @variables << maybe_dup_lookup(safe_parse_expression(p))
+      else
+        # cycle expr1, expr2, ...
+        @variables << maybe_dup_lookup(first_expression)
+      end
+
+      # Parse remaining comma-separated expressions
+      while p.consume?(:comma)
+        break if p.look(:end_of_string)
+
+        @variables << maybe_dup_lookup(safe_parse_expression(p))
+      end
+
+      p.consume(:end_of_string)
+
+      unless @is_named
+        @name = @variables.to_s
+        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
+      end
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      case markup
+      when NamedSyntax
+        @variables = variables_from_string(Regexp.last_match(2))
+        @name      = parse_expression(Regexp.last_match(1))
+        @is_named = true
+      when SimpleSyntax
+        @variables = variables_from_string(markup)
+        @name      = @variables.to_s
+        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+      end
+    end
+
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        Regexp.last_match(1) ? parse_expression(Regexp.last_match(1)) : nil
+        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)
+    # This makes it so {% cycle a, b %} and {% cycle a, b %} have independent counters even if a and b share value.
+    # This is not true for literal values, {% cycle "a", "b" %} and {% cycle "a", "b" %} share the same counter.
+    # I was really scratching my head about this one, but migrating away from this would be more headache
+    # than it's worth. So we're keeping this quirk for now.
+    def maybe_dup_lookup(var)
+      var.is_a?(VariableLookup) ? var.dup : var
+    end
+
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         Array(@node.variables)
       end
     end
   end
-
-  Template.register_tag('cycle', Cycle)
 end

lib/liquid/tags/decrement.rb

@@ -1,38 +1,58 @@
 # frozen_string_literal: true
 
 module Liquid
-  # decrement is used in a place where one needs to insert a counter
-  #     into a template, and needs the counter to survive across
-  #     multiple instantiations of the template.
-  #     NOTE: decrement is a pre-decrement, --i,
-  #           while increment is post:      i++.
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category variable
+  # @liquid_name decrement
+  # @liquid_summary
+  #   Creates a new variable, with a default value of -1, that's decreased by 1 with each subsequent call.
   #
-  #     (To achieve the survival, the application must keep the context)
-  #
-  #     if the variable does not exist, it is created with value 0.
-
-  #   Hello: {% decrement variable %}
-  #
-  # gives you:
-  #
-  #    Hello: -1
-  #    Hello: -2
-  #    Hello: -3
+  #   > Caution:
+  #   > Predefined Liquid objects can be overridden by variables with the same name.
+  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
+  # @liquid_description
+  #   Variables that are declared with `decrement` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
+  #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
+  #   [snippets](/themes/architecture/snippets) included in the file.
   #
+  #   Similarly, variables that are created with `decrement` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
+  #   and [`capture`](/docs/api/liquid/tags/capture). However, `decrement` and [`increment`](/docs/api/liquid/tags/increment) share
+  #   variables.
+  # @liquid_syntax
+  #   {% 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
-      @variable = markup.strip
+      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)
-      value = context.environments.first[@variable] ||= 0
+      counter_environment = context.environments.first
+      value = counter_environment[@variable_name] || 0
       value -= 1
-      context.environments.first[@variable] = value
+      counter_environment[@variable_name] = value
       output << value.to_s
       output
     end
   end
-
-  Template.register_tag('decrement', Decrement)
 end

lib/liquid/tags/doc.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category syntax
+  # @liquid_name doc
+  # @liquid_summary
+  #   Documents template elements with annotations.
+  # @liquid_description
+  #   The `doc` tag allows developers to include documentation within Liquid
+  #   templates. Any content inside `doc` tags is not rendered or outputted.
+  #   Liquid code inside will be parsed but not executed. This facilitates
+  #   tooling support for features like code completion, linting, and inline
+  #   documentation.
+  #
+  #   For detailed documentation syntax and examples, see the
+  #   [`LiquidDoc` reference](/docs/storefronts/themes/tools/liquid-doc).
+  #
+  # @liquid_syntax
+  #   {% doc %}
+  #     Renders a message.
+  #
+  #     @param {string} foo - A string value.
+  #     @param {string} [bar] - An optional string value.
+  #
+  #     @example
+  #     {% render 'message', foo: 'Hello', bar: 'World' %}
+  #   {% enddoc %}
+  class Doc < Block
+    NO_UNEXPECTED_ARGS = /\A\s*\z/
+
+    def initialize(tag_name, markup, parse_context)
+      super
+      ensure_valid_markup(tag_name, markup, parse_context)
+    end
+
+    def parse(tokens)
+      @body = +""
+
+      while (token = tokens.shift)
+        tag_name = token =~ BlockBody::FullTokenPossiblyInvalid && Regexp.last_match(2)
+
+        raise_nested_doc_error if tag_name == @tag_name
+
+        if tag_name == block_delimiter
+          parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
+          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
+          return
+        end
+        @body << token unless token.empty?
+      end
+
+      raise_tag_never_closed(block_name)
+    end
+
+    def render_to_output_buffer(_context, output)
+      output
+    end
+
+    def blank?
+      @body.empty?
+    end
+
+    def nodelist
+      [@body]
+    end
+
+    private
+
+    def ensure_valid_markup(tag_name, markup, parse_context)
+      unless NO_UNEXPECTED_ARGS.match?(markup)
+        raise SyntaxError, parse_context.locale.t("errors.syntax.block_tag_unexpected_args", tag: tag_name)
+      end
+    end
+
+    def raise_nested_doc_error
+      raise SyntaxError, parse_context.locale.t("errors.syntax.doc_invalid_nested")
+    end
+  end
+end

lib/liquid/tags/echo.rb

@@ -1,16 +1,23 @@
 # frozen_string_literal: true
 
 module Liquid
-  # Echo outputs an expression
-  #
-  #   {% echo monkey %}
-  #   {% echo user.name %}
-  #
-  # This is identical to variable output syntax, like {{ foo }}, but works
-  # inside {% liquid %} tags. The full syntax is supported, including filters:
-  #
-  #   {% echo user | link %}
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category syntax
+  # @liquid_name echo
+  # @liquid_summary
+  #   Outputs an expression.
+  # @liquid_description
+  #   Using the `echo` tag is the same as wrapping an expression in curly brackets (`{{` and `}}`). However, unlike the curly
+  #   bracket method, you can use the `echo` tag inside [`liquid` tags](/docs/api/liquid/tags/liquid).
   #
+  #   > Tip:
+  #   > You can use [filters](/docs/api/liquid/filters) on expressions inside `echo` tags.
+  # @liquid_syntax
+  #   {% liquid
+  #     echo expression
+  #   %}
+  # @liquid_syntax_keyword expression The expression to be output.
   class Echo < Tag
     attr_reader :variable
 
@@ -29,6 +36,4 @@ module Liquid
       end
     end
   end
-
-  Template.register_tag('echo', Echo)
 end

lib/liquid/tags/for.rb

@@ -1,50 +1,29 @@
 # frozen_string_literal: true
 
 module Liquid
-  # "For" iterates over an array or collection.
-  # Several useful variables are available to you within the loop.
-  #
-  # == Basic usage:
-  #    {% for item in collection %}
-  #      {{ forloop.index }}: {{ item.name }}
-  #    {% endfor %}
-  #
-  # == Advanced usage:
-  #    {% for item in collection %}
-  #      <div {% if forloop.first %}class="first"{% endif %}>
-  #        Item {{ forloop.index }}: {{ item.name }}
-  #      </div>
-  #    {% else %}
-  #      There is nothing in the collection.
-  #    {% endfor %}
-  #
-  # You can also define a limit and offset much like SQL.  Remember
-  # that offset starts at 0 for the first item.
-  #
-  #    {% for item in collection limit:5 offset:10 %}
-  #      {{ item.name }}
-  #    {% end %}
-  #
-  #  To reverse the for loop simply use {% for item in collection reversed %} (note that the flag's spelling is different to the filter `reverse`)
-  #
-  # == Available variables:
-  #
-  # forloop.name:: 'item-collection'
-  # forloop.length:: Length of the loop
-  # forloop.index:: The current item's position in the collection;
-  #                 forloop.index starts at 1.
-  #                 This is helpful for non-programmers who start believe
-  #                 the first item in an array is 1, not 0.
-  # forloop.index0:: The current item's position in the collection
-  #                  where the first item is 0
-  # forloop.rindex:: Number of items remaining in the loop
-  #                  (length - index) where 1 is the last item.
-  # forloop.rindex0:: Number of items remaining in the loop
-  #                   where 0 is the last item.
-  # forloop.first:: Returns true if the item is the first item.
-  # forloop.last:: Returns true if the item is the last item.
-  # forloop.parentloop:: Provides access to the parent loop, if present.
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category iteration
+  # @liquid_name for
+  # @liquid_summary
+  #   Renders an expression for every item in an array.
+  # @liquid_description
+  #   You can do a maximum of 50 iterations with a `for` loop. If you need to iterate over more than 50 items, then use the
+  #   [`paginate` tag](/docs/api/liquid/tags/paginate) to split the items over multiple pages.
   #
+  #   > Tip:
+  #   > Every `for` loop has an associated [`forloop` object](/docs/api/liquid/objects/forloop) with information about the loop.
+  # @liquid_syntax
+  #   {% for variable in array %}
+  #     expression
+  #   {% endfor %}
+  # @liquid_syntax_keyword variable The current item in the array.
+  # @liquid_syntax_keyword array The array to iterate over.
+  # @liquid_syntax_keyword expression The expression to render for each iteration.
+  # @liquid_optional_param limit: [number] The number of iterations to perform.
+  # @liquid_optional_param offset: [number] The 1-based index to start iterating at.
+  # @liquid_optional_param 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
 
@@ -109,28 +88,33 @@ module Liquid
     end
 
     def strict_parse(markup)
-      p = Parser.new(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')
 
       collection_name  = p.expression
-      @collection_name = parse_expression(collection_name)
+      @collection_name = parse_expression(collection_name, safe: true)
 
       @name     = "#{@variable_name}-#{collection_name}"
       @reversed = p.id?('reversed')
 
-      while p.look(:id) && p.look(:colon, 1)
+      while p.look(:comma) || p.look(:id)
+        p.consume?(:comma)
         unless (attribute = p.id?('limit') || p.id?('offset'))
           raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
         end
-        p.consume
-        set_attribute(attribute, p.expression)
+        p.consume(:colon)
+        set_attribute(attribute, p.expression, safe: true)
       end
       p.consume(:end_of_string)
     end
 
     private
 
+    def strict2_parse(markup)
+      strict_parse(markup)
+    end
+
     def collection_segment(context)
       offsets = context.registers[:for] ||= {}
 
@@ -194,17 +178,16 @@ module Liquid
       output
     end
 
-    def set_attribute(key, expr)
+    def set_attribute(key, expr, safe: false)
       case key
       when 'offset'
         @from = if expr == 'continue'
-          Usage.increment('for_offset_continue')
           :continue
         else
-          parse_expression(expr)
+          parse_expression(expr, safe: safe)
         end
       when 'limit'
-        @limit = parse_expression(expr)
+        @limit = parse_expression(expr, safe: safe)
       end
     end
 
@@ -222,6 +205,4 @@ module Liquid
       end
     end
   end
-
-  Template.register_tag('for', For)
 end

lib/liquid/tags/if.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 module Liquid
-  # If is the conditional block
-  #
-  #   {% if user.admin %}
-  #     Admin user!
-  #   {% else %}
-  #     Not admin user
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category conditional
+  # @liquid_name if
+  # @liquid_summary
+  #   Renders an expression if a specific condition is `true`.
+  # @liquid_syntax
+  #   {% if condition %}
+  #     expression
   #   {% endif %}
-  #
-  #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
-  #
+  # @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
@@ -51,7 +53,7 @@ module Liquid
     def render_to_output_buffer(context, output)
       @blocks.each do |block|
         result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context)
+          block.evaluate(context),
         )
 
         if result
@@ -64,6 +66,10 @@ module Liquid
 
     private
 
+    def strict2_parse(markup)
+      strict_parse(markup)
+    end
+
     def push_block(tag, markup)
       block = if tag == 'else'
         ElseCondition.new
@@ -75,8 +81,8 @@ module Liquid
       block.attach(new_body)
     end
 
-    def parse_expression(markup)
-      Condition.parse_expression(parse_context, markup)
+    def parse_expression(markup, safe: false)
+      Condition.parse_expression(parse_context, markup, safe: safe)
     end
 
     def lax_parse(markup)
@@ -100,7 +106,7 @@ module Liquid
     end
 
     def strict_parse(markup)
-      p = Parser.new(markup)
+      p = @parse_context.new_parser(markup)
       condition = parse_binary_comparisons(p)
       p.consume(:end_of_string)
       condition
@@ -109,7 +115,7 @@ module Liquid
     def parse_binary_comparisons(p)
       condition = parse_comparison(p)
       first_condition = condition
-      while (op = (p.id?('and') || p.id?('or')))
+      while (op = p.id?('and') || p.id?('or'))
         child_condition = parse_comparison(p)
         condition.send(op, child_condition)
         condition = child_condition
@@ -118,9 +124,9 @@ module Liquid
     end
 
     def parse_comparison(p)
-      a = parse_expression(p.expression)
+      a = parse_expression(p.expression, safe: true)
       if (op = p.consume?(:comparison))
-        b = parse_expression(p.expression)
+        b = parse_expression(p.expression, safe: true)
         Condition.new(a, op, b)
       else
         Condition.new(a)
@@ -133,6 +139,4 @@ module Liquid
       end
     end
   end
-
-  Template.register_tag('if', If)
 end

lib/liquid/tags/ifchanged.rb

@@ -14,6 +14,4 @@ module Liquid
       output
     end
   end
-
-  Template.register_tag('ifchanged', Ifchanged)
 end

lib/liquid/tags/include.rb

@@ -1,48 +1,34 @@
 # frozen_string_literal: true
 
 module Liquid
-  # Include allows templates to relate with other templates
-  #
-  # Simply include another template:
-  #
-  #   {% include 'product' %}
-  #
-  # Include a template with a local variable:
-  #
-  #   {% include 'product' with products[0] %}
-  #
-  # Include a template for a collection:
-  #
-  #   {% include 'product' for products %}
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category theme
+  # @liquid_name include
+  # @liquid_summary
+  #   Renders a [snippet](/themes/architecture/snippets).
+  # @liquid_description
+  #   Inside the snippet, you can access and alter variables that are [created](/docs/api/liquid/tags/variable-tags) outside of the
+  #   snippet.
+  # @liquid_syntax
+  #   {% include 'filename' %}
+  # @liquid_syntax_keyword filename The name of the snippet to render, without the `.liquid` extension.
+  # @liquid_deprecated
+  #   Deprecated because the way that variables are handled reduces performance and makes code harder to both read and maintain.
   #
+  #   The `include` tag has been replaced by [`render`](/docs/api/liquid/tags/render).
   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
 
     def initialize(tag_name, markup, options)
       super
-
-      if markup =~ SYNTAX
-
-        template_name = Regexp.last_match(1)
-        variable_name = Regexp.last_match(3)
-
-        @alias_name         = Regexp.last_match(5)
-        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
-        @template_name_expr = parse_expression(template_name)
-        @attributes         = {}
-
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = parse_expression(value)
-        end
-
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.include")
-      end
+      parse_with_selected_parser(markup)
     end
 
     def parse(_tokens)
@@ -50,12 +36,12 @@ module Liquid
 
     def render_to_output_buffer(context, output)
       template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
+      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name.is_a?(String)
 
       partial = PartialCache.load(
         template_name,
         context: context,
-        parse_context: parse_context
+        parse_context: parse_context,
       )
 
       context_variable_name = @alias_name || template_name.split('/').last
@@ -68,9 +54,11 @@ module Liquid
 
       old_template_name = context.template_name
       old_partial       = context.partial
+
       begin
-        context.template_name = template_name
-        context.partial       = true
+        context.template_name = partial.name
+        context.partial = true
+
         context.stack do
           @attributes.each do |key, value|
             context[key] = context.evaluate(value)
@@ -97,6 +85,57 @@ module Liquid
     alias_method :parse_context, :options
     private :parse_context
 
+    def for_loop?
+      @is_for_loop
+    end
+
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup)
+
+      @template_name_expr = safe_parse_expression(p)
+      with_or_for         = p.id?("for") || p.id?("with")
+      @variable_name_expr = safe_parse_expression(p) if with_or_for
+      @alias_name         = p.consume(:id) if p.id?("as")
+      @is_for_loop        = (with_or_for == FOR)
+
+      p.consume?(:comma)
+
+      @attributes = {}
+      while p.look(:id)
+        key = p.consume
+        p.consume(:colon)
+        @attributes[key] = safe_parse_expression(p)
+        p.consume?(:comma)
+      end
+
+      p.consume(:end_of_string)
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      if markup =~ SYNTAX
+        template_name = Regexp.last_match(1)
+        with_or_for   = Regexp.last_match(3)
+        variable_name = Regexp.last_match(4)
+
+        @alias_name         = Regexp.last_match(6)
+        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+        @template_name_expr = parse_expression(template_name)
+        @is_for_loop        = (with_or_for == FOR)
+        @attributes         = {}
+
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = parse_expression(value)
+        end
+
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.include")
+      end
+    end
+
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [
@@ -106,6 +145,4 @@ module Liquid
       end
     end
   end
-
-  Template.register_tag('include', Include)
 end

lib/liquid/tags/increment.rb

@@ -1,35 +1,58 @@
 # frozen_string_literal: true
 
 module Liquid
-  # increment is used in a place where one needs to insert a counter
-  #     into a template, and needs the counter to survive across
-  #     multiple instantiations of the template.
-  #     (To achieve the survival, the application must keep the context)
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category variable
+  # @liquid_name increment
+  # @liquid_summary
+  #   Creates a new variable, with a default value of 0, that's increased by 1 with each subsequent call.
   #
-  #     if the variable does not exist, it is created with value 0.
-  #
-  #   Hello: {% increment variable %}
-  #
-  # gives you:
-  #
-  #    Hello: 0
-  #    Hello: 1
-  #    Hello: 2
+  #   > Caution:
+  #   > Predefined Liquid objects can be overridden by variables with the same name.
+  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
+  # @liquid_description
+  #   Variables that are declared with `increment` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
+  #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
+  #   [snippets](/themes/architecture/snippets) included in the file.
   #
+  #   Similarly, variables that are created with `increment` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
+  #   and [`capture`](/docs/api/liquid/tags/capture). However, `increment` and [`decrement`](/docs/api/liquid/tags/decrement) share
+  #   variables.
+  # @liquid_syntax
+  #   {% 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
-      @variable = markup.strip
+      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)
-      value = context.environments.first[@variable] ||= 0
-      context.environments.first[@variable] = value + 1
+      counter_environment = context.environments.first
+      value = counter_environment[@variable_name] || 0
+      counter_environment[@variable_name] = value + 1
 
       output << value.to_s
       output
     end
   end
-
-  Template.register_tag('increment', Increment)
 end

lib/liquid/tags/inline_comment.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Liquid
+  class InlineComment < Tag
+    def initialize(tag_name, markup, options)
+      super
+
+      # Semantically, a comment should only ignore everything after it on the line.
+      # Currently, this implementation doesn't support mixing a comment with another tag
+      # but we need to reserve future support for this and prevent the introduction
+      # of inline comments from being backward incompatible change.
+      #
+      # As such, we're forcing users to put a # symbol on every line otherwise this
+      # tag will throw an error.
+      if markup.match?(/\n\s*[^#\s]/)
+        raise SyntaxError, options[:locale].t("errors.syntax.inline_comment_invalid")
+      end
+    end
+
+    def render_to_output_buffer(_context, output)
+      output
+    end
+
+    def blank?
+      true
+    end
+  end
+end

lib/liquid/tags/raw.rb

@@ -1,9 +1,19 @@
 # frozen_string_literal: true
 
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category syntax
+  # @liquid_name raw
+  # @liquid_summary
+  #   Outputs any Liquid code as text instead of rendering it.
+  # @liquid_syntax
+  #   {% raw %}
+  #     expression
+  #   {% endraw %}
+  # @liquid_syntax_keyword expression The expression to be output without being rendered.
   class Raw < Block
     Syntax = /\A\s*\z/
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
 
     def initialize(tag_name, markup, parse_context)
       super
@@ -14,7 +24,8 @@ module Liquid
     def parse(tokens)
       @body = +''
       while (token = tokens.shift)
-        if token =~ FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
+        if token =~ BlockBody::FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
+          parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
           @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
           return
         end
@@ -45,6 +56,4 @@ module Liquid
       end
     end
   end
-
-  Template.register_tag('raw', Raw)
 end

lib/liquid/tags/render.rb

@@ -1,32 +1,45 @@
 # frozen_string_literal: true
 
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category theme
+  # @liquid_name render
+  # @liquid_summary
+  #   Renders a [snippet](/themes/architecture/snippets) or [app block](/themes/architecture/sections/section-schema#render-app-blocks).
+  # @liquid_description
+  #   Inside snippets and app blocks, you can't directly access variables that are [created](/docs/api/liquid/tags/variable-tags) outside
+  #   of the snippet or app block. However, you can [specify variables as parameters](/docs/api/liquid/tags/render#render-passing-variables-to-a-snippet)
+  #   to pass outside variables to snippets.
+  #
+  #   While you can't directly access created variables, you can access global objects, as well as any objects that are
+  #   directly accessible outside the snippet or app block. For example, a snippet or app block inside the [product template](/themes/architecture/templates/product)
+  #   can access the [`product` object](/docs/api/liquid/objects/product), and a snippet or app block inside a [section](/themes/architecture/sections)
+  #   can access the [`section` object](/docs/api/liquid/objects/section).
+  #
+  #   Outside a snippet or app block, you can't access variables created inside the snippet or app block.
+  #
+  #   > Note:
+  #   > When you render a snippet using the `render` tag, you can't use the [`include` tag](/docs/api/liquid/tags/include)
+  #   > inside the snippet.
+  # @liquid_syntax
+  #   {% render 'filename' %}
+  # @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"
 
-    attr_reader :template_name_expr, :attributes
+    attr_reader :template_name_expr, :variable_name_expr, :attributes, :alias_name
 
     def initialize(tag_name, markup, options)
       super
+      parse_with_selected_parser(markup)
+    end
 
-      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)
-      @for = (with_or_for == FOR)
-
-      @attributes = {}
-      markup.scan(TagAttributes) do |key, value|
-        @attributes[key] = parse_expression(value)
-      end
+    def for_loop?
+      @is_for_loop
     end
 
     def render_to_output_buffer(context, output)
@@ -34,21 +47,21 @@ module Liquid
     end
 
     def render_tag(context, output)
-      # Though we evaluate this here we will only ever parse it as a string literal.
-      template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
+      # The expression should be a String literal, which parses to a String object
+      template_name = @template_name_expr
+      raise ::ArgumentError unless template_name.is_a?(String)
 
       partial = PartialCache.load(
         template_name,
         context: context,
-        parse_context: parse_context
+        parse_context: parse_context,
       )
 
       context_variable_name = @alias_name || template_name.split('/').last
 
       render_partial_func = ->(var, forloop) {
         inner_context               = context.new_isolated_subcontext
-        inner_context.template_name = template_name
+        inner_context.template_name = partial.name
         inner_context.partial       = true
         inner_context['forloop']    = forloop if forloop
 
@@ -61,7 +74,7 @@ module Liquid
       }
 
       variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
-      if @for && variable.respond_to?(:each) && variable.respond_to?(:count)
+      if @is_for_loop && variable.respond_to?(:each) && variable.respond_to?(:count)
         forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
         variable.each { |var| render_partial_func.call(var, forloop) }
       else
@@ -71,14 +84,62 @@ module Liquid
       output
     end
 
+    # render (string) (with|for expression)? (as id)? (key: value)*
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup)
+
+      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
+      with_or_for         = p.id?("for") || p.id?("with")
+      @variable_name_expr = safe_parse_expression(p) if with_or_for
+      @alias_name         = p.consume(:id) if p.id?("as")
+      @is_for_loop        = (with_or_for == FOR)
+
+      p.consume?(:comma)
+
+      @attributes = {}
+      while p.look(:id)
+        key = p.consume
+        p.consume(:colon)
+        @attributes[key] = safe_parse_expression(p)
+        p.consume?(:comma)
+      end
+
+      p.consume(:end_of_string)
+    end
+
+    def strict2_template_name(p)
+      p.consume(:string)
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
+
+      template_name = Regexp.last_match(1)
+      with_or_for = Regexp.last_match(3)
+      variable_name = Regexp.last_match(4)
+
+      @alias_name = Regexp.last_match(6)
+      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+      @template_name_expr = parse_expression(template_name)
+      @is_for_loop = (with_or_for == FOR)
+
+      @attributes = {}
+      markup.scan(TagAttributes) do |key, value|
+        @attributes[key] = parse_expression(value)
+      end
+    end
+
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [
           @node.template_name_expr,
+          @node.variable_name_expr,
         ] + @node.attributes.values
       end
     end
   end
-
-  Template.register_tag('render', Render)
 end

lib/liquid/tags/table_row.rb

@@ -1,13 +1,72 @@
 # frozen_string_literal: true
 
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category iteration
+  # @liquid_name tablerow
+  # @liquid_summary
+  #   Generates HTML table rows for every item in an array.
+  # @liquid_description
+  #   The `tablerow` tag must be wrapped in HTML `<table>` and `</table>` tags.
+  #
+  #   > Tip:
+  #   > Every `tablerow` loop has an associated [`tablerowloop` object](/docs/api/liquid/objects/tablerowloop) with information about the loop.
+  # @liquid_syntax
+  #   {% tablerow variable in array %}
+  #     expression
+  #   {% endtablerow %}
+  # @liquid_syntax_keyword variable The current item in the array.
+  # @liquid_syntax_keyword array The array to iterate over.
+  # @liquid_syntax_keyword expression The expression to render.
+  # @liquid_optional_param cols: [number] The number of columns that the table should have.
+  # @liquid_optional_param limit: [number] The number of iterations to perform.
+  # @liquid_optional_param offset: [number] The 1-based index to start iterating at.
+  # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
   class TableRow < Block
     Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
+    ALLOWED_ATTRIBUTES = ['cols', 'limit', 'offset', 'range'].freeze
 
     attr_reader :variable_name, :collection_name, :attributes
 
     def initialize(tag_name, markup, options)
       super
+      parse_with_selected_parser(markup)
+    end
+
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup)
+
+      @variable_name = p.consume(:id)
+
+      unless p.id?("in")
+        raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in")
+      end
+
+      @collection_name = safe_parse_expression(p)
+
+      p.consume?(:comma)
+
+      @attributes = {}
+      while p.look(:id)
+        key = p.consume
+        unless ALLOWED_ATTRIBUTES.include?(key)
+          raise SyntaxError, options[:locale].t("errors.syntax.table_row_invalid_attribute", attribute: key)
+        end
+
+        p.consume(:colon)
+        @attributes[key] = safe_parse_expression(p)
+        p.consume?(:comma)
+      end
+
+      p.consume(:end_of_string)
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
       if markup =~ Syntax
         @variable_name   = Regexp.last_match(1)
         @collection_name = parse_expression(Regexp.last_match(2))
@@ -23,13 +82,13 @@ module Liquid
     def render_to_output_buffer(context, output)
       (collection = context.evaluate(@collection_name)) || (return '')
 
-      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
-      to   = @attributes.key?('limit')  ? from + context.evaluate(@attributes['limit']).to_i : nil
+      from = @attributes.key?('offset') ? to_integer(context.evaluate(@attributes['offset'])) : 0
+      to = @attributes.key?('limit') ? from + to_integer(context.evaluate(@attributes['limit'])) : nil
 
       collection = Utils.slice_collection(collection, from, to)
       length     = collection.length
 
-      cols = context.evaluate(@attributes['cols']).to_i
+      cols = @attributes.key?('cols') ? to_integer(context.evaluate(@attributes['cols'])) : length
 
       output << "<tr class=\"row1\">\n"
       context.stack do
@@ -43,6 +102,12 @@ module Liquid
           super
           output << '</td>'
 
+          # Handle any interrupts if they exist.
+          if context.interrupt?
+            interrupt = context.pop_interrupt
+            break if interrupt.is_a?(BreakInterrupt)
+          end
+
           if tablerowloop.col_last && !tablerowloop.last
             output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
           end
@@ -60,7 +125,13 @@ module Liquid
         super + @node.attributes.values + [@node.collection_name]
       end
     end
-  end
 
-  Template.register_tag('tablerow', TableRow)
+    private
+
+    def to_integer(value)
+      value.to_i
+    rescue NoMethodError
+      raise Liquid::ArgumentError, "invalid integer"
+    end
+  end
 end

lib/liquid/tags/unless.rb

@@ -3,16 +3,27 @@
 require_relative 'if'
 
 module Liquid
-  # Unless is a conditional just like 'if' but works on the inverse logic.
-  #
-  #   {% unless x < 0 %} x is greater than zero {% endunless %}
-  #
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category conditional
+  # @liquid_name unless
+  # @liquid_summary
+  #   Renders an expression unless a specific condition is `true`.
+  # @liquid_description
+  #   > Tip:
+  #   > Similar to the [`if` tag](/docs/api/liquid/tags/if), you can use `elsif` to add more conditions to an `unless` tag.
+  # @liquid_syntax
+  #   {% unless condition %}
+  #     expression
+  #   {% endunless %}
+  # @liquid_syntax_keyword condition The condition to evaluate.
+  # @liquid_syntax_keyword expression The expression to render unless the condition is met.
   class Unless < If
     def render_to_output_buffer(context, output)
       # First condition is interpreted backwards ( if not )
       first_block = @blocks.first
       result = Liquid::Utils.to_liquid_value(
-        first_block.evaluate(context)
+        first_block.evaluate(context),
       )
 
       unless result
@@ -22,7 +33,7 @@ module Liquid
       # After the first condition unless works just like if
       @blocks[1..-1].each do |block|
         result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context)
+          block.evaluate(context),
         )
 
         if result
@@ -33,6 +44,4 @@ module Liquid
       output
     end
   end
-
-  Template.register_tag('unless', Unless)
 end

lib/liquid/template.rb

@@ -2,7 +2,7 @@
 
 module Liquid
   # Templates are central to liquid.
-  # Interpretating templates is a two step process. First you compile the
+  # Interpreting templates is a two step process. First you compile the
   # source code you got. During compile time some extensive error checking is performed.
   # your code should expect to get some SyntaxErrors.
   #
@@ -15,98 +15,94 @@ module Liquid
   #   template.render('user_name' => 'bob')
   #
   class Template
-    attr_accessor :root
+    attr_accessor :root, :name
     attr_reader :resource_limits, :warnings
 
-    class TagRegistry
-      include Enumerable
-
-      def initialize
-        @tags  = {}
-        @cache = {}
-      end
-
-      def [](tag_name)
-        return nil unless @tags.key?(tag_name)
-        return @cache[tag_name] if Liquid.cache_classes
-
-        lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
-      end
-
-      def []=(tag_name, klass)
-        @tags[tag_name]  = klass.name
-        @cache[tag_name] = klass
-      end
-
-      def delete(tag_name)
-        @tags.delete(tag_name)
-        @cache.delete(tag_name)
-      end
-
-      def each(&block)
-        @tags.each(&block)
-      end
-
-      private
-
-      def lookup_class(name)
-        Object.const_get(name)
-      end
-    end
-
     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 will enforce correct syntax.
-      attr_accessor :error_mode
-      Template.error_mode = :lax
-
-      attr_accessor :default_exception_renderer
-      Template.default_exception_renderer = lambda do |exception|
-        exception
+      # :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
 
-      attr_accessor :file_system
-      Template.file_system = BlankFileSystem.new
+      def error_mode
+        Environment.default.error_mode
+      end
 
-      attr_accessor :tags
-      Template.tags = TagRegistry.new
-      private :tags=
+      def default_exception_renderer=(renderer)
+        Deprecations.warn("Template.default_exception_renderer=", "Environment#exception_renderer=")
+        Environment.default.exception_renderer = renderer
+      end
+
+      def default_exception_renderer
+        Environment.default.exception_renderer
+      end
+
+      def file_system=(file_system)
+        Deprecations.warn("Template.file_system=", "Environment#file_system=")
+        Environment.default.file_system = file_system
+      end
+
+      def file_system
+        Environment.default.file_system
+      end
+
+      def tags
+        Environment.default.tags
+      end
 
       def register_tag(name, klass)
-        tags[name.to_s] = klass
+        Deprecations.warn("Template.register_tag", "Environment#register_tag")
+        Environment.default.register_tag(name, klass)
       end
 
       # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
       def register_filter(mod)
-        StrainerFactory.add_global_filter(mod)
+        Deprecations.warn("Template.register_filter", "Environment#register_filter")
+        Environment.default.register_filter(mod)
       end
 
-      attr_accessor :default_resource_limits
-      Template.default_resource_limits = {}
-      private :default_resource_limits=
+      private def default_resource_limits=(limits)
+        Deprecations.warn("Template.default_resource_limits=", "Environment#default_resource_limits=")
+        Environment.default.default_resource_limits = limits
+      end
+
+      def default_resource_limits
+        Environment.default.default_resource_limits
+      end
 
       # creates a new <tt>Template</tt> object from liquid source code
       # To enable profiling, pass in <tt>profile: true</tt> as an option.
       # See Liquid::Profiler for more information
       def parse(source, options = {})
-        new.parse(source, options)
+        environment = options[:environment] || Environment.default
+        new(environment: environment).parse(source, options)
       end
     end
 
-    def initialize
+    def initialize(environment: Environment.default)
+      @environment = environment
       @rethrow_errors  = false
-      @resource_limits = ResourceLimits.new(Template.default_resource_limits)
+      @resource_limits = ResourceLimits.new(environment.default_resource_limits)
     end
 
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, options = {})
       parse_context = configure_options(options)
+      source = source.to_s.to_str
+
+      unless source.valid_encoding?
+        raise TemplateEncodingError, parse_context.locale.t("errors.syntax.invalid_template_encoding")
+      end
+
       tokenizer     = parse_context.new_tokenizer(source, start_line_number: @line_numbers && 1)
       @root         = Document.parse(tokenizer, parse_context)
       self
@@ -155,27 +151,28 @@ module Liquid
 
         c
       when Liquid::Drop
-        drop         = args.shift
-        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
+        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
       when Hash
-        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
       when nil
-        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
       else
         raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
       end
 
       output = nil
 
-      context_register = context.registers.is_a?(StaticRegisters) ? context.registers.static : context.registers
-
       case args.last
       when Hash
         options = args.pop
         output  = options[:output] if options[:output]
+        static_registers = context.registers.static
 
         options[:registers]&.each do |key, register|
-          context_register[key] = register
+          static_registers[key] = register
         end
 
         apply_options_to_context(context, options)
@@ -190,6 +187,8 @@ module Liquid
         @profiler = context.profiler = Liquid::Profiler.new
       end
 
+      context.template_name ||= name
+
       begin
         # render the nodelist.
         @root.render_to_output_buffer(context, output || +'')
@@ -219,8 +218,14 @@ module Liquid
       @options      = options
       @profiling    = profiling
       @line_numbers = options[:line_numbers] || @profiling
-      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
-      @warnings     = parse_context.warnings
+      parse_context = if options.is_a?(ParseContext)
+        options
+      else
+        opts = options.key?(:environment) ? options : options.merge(environment: @environment)
+        ParseContext.new(opts)
+      end
+
+      @warnings = parse_context.warnings
       parse_context
     end
 

lib/liquid/tokenizer.rb

@@ -1,18 +1,45 @@
 # frozen_string_literal: true
 
+require "strscan"
+
 module Liquid
   class Tokenizer
     attr_reader :line_number, :for_liquid_tag
 
-    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
-      @source         = source.to_s.to_str
-      @line_number    = line_number || (line_numbers ? 1 : nil)
+    TAG_END = /%\}/
+    TAG_OR_VARIABLE_START = /\{[\{\%]/
+    NEWLINE = /\n/
+
+    OPEN_CURLEY = "{".ord
+    CLOSE_CURLEY = "}".ord
+    PERCENTAGE = "%".ord
+
+    def initialize(
+      source:,
+      string_scanner:,
+      line_numbers: false,
+      line_number: nil,
+      for_liquid_tag: false
+    )
+      @line_number = line_number || (line_numbers ? 1 : nil)
       @for_liquid_tag = for_liquid_tag
-      @tokens         = tokenize
+      @source = source.to_s.to_str
+      @offset = 0
+      @tokens = []
+
+      if @source
+        @ss = string_scanner
+        @ss.string = @source
+        tokenize
+      end
     end
 
     def shift
-      (token = @tokens.shift) || return
+      token = @tokens[@offset]
+
+      return unless token
+
+      @offset += 1
 
       if @line_number
         @line_number += @for_liquid_tag ? 1 : token.count("\n")
@@ -24,16 +51,111 @@ module Liquid
     private
 
     def tokenize
-      return [] if @source.empty?
+      if @for_liquid_tag
+        @tokens = @source.split("\n")
+      else
+        @tokens << shift_normal until @ss.eos?
+      end
 
-      return @source.split("\n") if @for_liquid_tag
+      @source = nil
+      @ss = nil
+    end
 
-      tokens = @source.split(TemplateParser)
+    def shift_normal
+      token = next_token
 
-      # removes the rogue empty element at the beginning of the array
-      tokens.shift if tokens[0]&.empty?
+      return unless token
 
-      tokens
+      token
+    end
+
+    def next_token
+      # possible states: :text, :tag, :variable
+      byte_a = @ss.peek_byte
+
+      if byte_a == OPEN_CURLEY
+        @ss.scan_byte
+
+        byte_b = @ss.peek_byte
+
+        if byte_b == PERCENTAGE
+          @ss.scan_byte
+          return next_tag_token
+        elsif byte_b == OPEN_CURLEY
+          @ss.scan_byte
+          return next_variable_token
+        end
+
+        @ss.pos -= 1
+      end
+
+      next_text_token
+    end
+
+    def next_text_token
+      start = @ss.pos
+
+      unless @ss.skip_until(TAG_OR_VARIABLE_START)
+        token = @ss.rest
+        @ss.terminate
+        return token
+      end
+
+      pos = @ss.pos -= 2
+      @source.byteslice(start, pos - start)
+    rescue ::ArgumentError => e
+      if e.message == "invalid byte sequence in #{@ss.string.encoding}"
+        raise SyntaxError, "Invalid byte sequence in #{@ss.string.encoding}"
+      else
+        raise
+      end
+    end
+
+    def next_variable_token
+      start = @ss.pos - 2
+
+      byte_a = byte_b = @ss.scan_byte
+
+      while byte_b
+        byte_a = @ss.scan_byte while byte_a && byte_a != CLOSE_CURLEY && byte_a != OPEN_CURLEY
+
+        break unless byte_a
+
+        if @ss.eos?
+          return byte_a == CLOSE_CURLEY ? @source.byteslice(start, @ss.pos - start) : "{{"
+        end
+
+        byte_b = @ss.scan_byte
+
+        if byte_a == CLOSE_CURLEY
+          if byte_b == CLOSE_CURLEY
+            return @source.byteslice(start, @ss.pos - start)
+          elsif byte_b != CLOSE_CURLEY
+            @ss.pos -= 1
+            return @source.byteslice(start, @ss.pos - start)
+          end
+        elsif byte_a == OPEN_CURLEY && byte_b == PERCENTAGE
+          return next_tag_token_with_start(start)
+        end
+
+        byte_a = byte_b
+      end
+
+      "{{"
+    end
+
+    def next_tag_token
+      start = @ss.pos - 2
+      if (len = @ss.skip_until(TAG_END))
+        @source.byteslice(start, len + 2)
+      else
+        "{%"
+      end
+    end
+
+    def next_tag_token_with_start(start)
+      @ss.skip_until(TAG_END)
+      @source.byteslice(start, @ss.pos - start)
     end
   end
 end

lib/liquid/utils.rb

@@ -2,6 +2,9 @@
 
 module Liquid
   module Utils
+    DECIMAL_REGEX = /\A-?\d+\.\d+\z/
+    UNIX_TIMESTAMP_REGEX = /\A\d+\z/
+
     def self.slice_collection(collection, from, to)
       if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
         collection.load_slice(from, to)
@@ -52,7 +55,7 @@ module Liquid
       when Numeric
         obj
       when String
-        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+        DECIMAL_REGEX.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
       else
         if obj.respond_to?(:to_number)
           obj.to_number
@@ -66,14 +69,14 @@ module Liquid
       return obj if obj.respond_to?(:strftime)
 
       if obj.is_a?(String)
-        return nil if obj.empty?
+        return if obj.empty?
         obj = obj.downcase
       end
 
       case obj
       when 'now', 'today'
         Time.now
-      when /\A\d+\z/, Integer
+      when UNIX_TIMESTAMP_REGEX, Integer
         Time.at(obj.to_i)
       when String
         Time.parse(obj)
@@ -89,5 +92,103 @@ module Liquid
       # Otherwise return the object itself
       obj
     end
+
+    def self.to_s(obj, seen = {})
+      case obj
+      when BigDecimal
+        obj.to_s("F")
+      when Hash
+        # If the custom hash implementation overrides `#to_s`, use their
+        # custom implementation. Otherwise we use Liquid's default
+        # implementation.
+        if obj.class.instance_method(:to_s) == HASH_TO_S_METHOD
+          hash_inspect(obj, seen)
+        else
+          obj.to_s
+        end
+      when Array
+        array_inspect(obj, seen)
+      else
+        obj.to_s
+      end
+    end
+
+    def self.inspect(obj, seen = {})
+      case obj
+      when Hash
+        # If the custom hash implementation overrides `#inspect`, use their
+        # custom implementation. Otherwise we use Liquid's default
+        # implementation.
+        if obj.class.instance_method(:inspect) == HASH_INSPECT_METHOD
+          hash_inspect(obj, seen)
+        else
+          obj.inspect
+        end
+      when Array
+        array_inspect(obj, seen)
+      else
+        obj.inspect
+      end
+    end
+
+    def self.array_inspect(arr, seen = {})
+      if seen[arr.object_id]
+        return "[...]"
+      end
+
+      seen[arr.object_id] = true
+      str = +"["
+      cursor = 0
+      len = arr.length
+
+      while cursor < len
+        if cursor > 0
+          str << ", "
+        end
+
+        item_str = inspect(arr[cursor], seen)
+        str << item_str
+        cursor += 1
+      end
+
+      str << "]"
+      str
+    ensure
+      seen.delete(arr.object_id)
+    end
+
+    def self.hash_inspect(hash, seen = {})
+      if seen[hash.object_id]
+        return "{...}"
+      end
+      seen[hash.object_id] = true
+
+      str = +"{"
+      first = true
+      hash.each do |key, value|
+        if first
+          first = false
+        else
+          str << ", "
+        end
+
+        key_str = inspect(key, seen)
+        str << key_str
+        str << "=>"
+
+        value_str = inspect(value, seen)
+        str << value_str
+      end
+      str << "}"
+      str
+    ensure
+      seen.delete(hash.object_id)
+    end
+
+    HASH_TO_S_METHOD = Hash.instance_method(:to_s)
+    private_constant :HASH_TO_S_METHOD
+
+    HASH_INSPECT_METHOD = Hash.instance_method(:inspect)
+    private_constant :HASH_INSPECT_METHOD
   end
 end

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
@@ -47,33 +51,44 @@ module Liquid
 
       name_markup   = Regexp.last_match(1)
       filter_markup = Regexp.last_match(2)
-      @name         = Expression.parse(name_markup)
+      @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 << parse_filter_expressions(filtername, filterargs)
+          @filters << lax_parse_filter_expressions(filtername, filterargs)
         end
       end
     end
 
     def strict_parse(markup)
       @filters = []
-      p = Parser.new(markup)
+      p = @parse_context.new_parser(markup)
 
       return if p.look(:end_of_string)
 
-      @name = Expression.parse(p.expression)
+      @name = parse_context.safe_parse_expression(p)
       while p.consume?(:pipe)
         filtername = p.consume(:id)
-        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
-        @filters << parse_filter_expressions(filtername, filterargs)
+        filterargs = p.consume?(:colon) ? parse_filterargs(p) : Const::EMPTY_ARRAY
+        @filters << lax_parse_filter_expressions(filtername, filterargs)
       end
       p.consume(:end_of_string)
     end
 
+    def strict2_parse(markup)
+      @filters = []
+      p = @parse_context.new_parser(markup)
+
+      return if p.look(:end_of_string)
+
+      @name = parse_context.safe_parse_expression(p)
+      @filters << strict2_parse_filter_expressions(p) while p.consume?(:pipe)
+      p.consume(:end_of_string)
+    end
+
     def parse_filterargs(p)
       # first argument
       filterargs = [p.argument]
@@ -93,23 +108,25 @@ module Liquid
       context.apply_global_filter(obj)
     end
 
-    def compile
-      "__output << #{@name}\n"
-    end
-
     def render_to_output_buffer(context, output)
       obj = render(context)
-
-      if obj.is_a?(Array)
-        output << obj.join
-      elsif obj.nil?
-      else
-        output << obj.to_s
-      end
-
+      render_obj_to_output(obj, output)
       output
     end
 
+    def render_obj_to_output(obj, output)
+      case obj
+      when NilClass
+        # Do nothing
+      when Array
+        obj.each do |o|
+          render_obj_to_output(o, output)
+        end
+      else
+        output << Liquid::Utils.to_s(obj)
+      end
+    end
+
     def disabled?(_context)
       false
     end
@@ -120,15 +137,15 @@ module Liquid
 
     private
 
-    def parse_filter_expressions(filter_name, unparsed_args)
+    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]] = Expression.parse(matches[2])
+          keyword_args[matches[1]] = parse_context.parse_expression(matches[2])
         else
-          filter_args << Expression.parse(a)
+          filter_args << parse_context.parse_expression(a)
         end
       end
       result = [filter_name, filter_args]
@@ -136,6 +153,46 @@ module Liquid
       result
     end
 
+    # Surprisingly, positional and keyword arguments can be mixed.
+    #
+    # filter = filtername [":" filterargs?]
+    # filterargs = argument ("," argument)*
+    # argument = (positional_argument | keyword_argument)
+    # positional_argument = expression
+    # keyword_argument = id ":" expression
+    def strict2_parse_filter_expressions(p)
+      filtername = p.consume(:id)
+      filter_args = []
+      keyword_args = {}
+
+      if p.consume?(:colon)
+        # Parse first argument (no leading comma)
+        argument(p, filter_args, keyword_args) unless end_of_arguments?(p)
+
+        # Parse remaining arguments (with leading commas) and optional trailing comma
+        argument(p, filter_args, keyword_args) while p.consume?(:comma) && !end_of_arguments?(p)
+      end
+
+      result = [filtername, filter_args]
+      result << keyword_args unless keyword_args.empty?
+      result
+    end
+
+    def argument(p, positional_arguments, keyword_arguments)
+      if p.look(:id) && p.look(:colon, 1)
+        key = p.consume(:id)
+        p.consume(:colon)
+        value = parse_context.safe_parse_expression(p)
+        keyword_arguments[key] = value
+      else
+        positional_arguments << parse_context.safe_parse_expression(p)
+      end
+    end
+
+    def end_of_arguments?(p)
+      p.look(:pipe) || p.look(:end_of_string)
+    end
+
     def evaluate_filter_expressions(context, filter_args, filter_kwargs)
       parsed_args = filter_args.map { |expr| context.evaluate(expr) }
       if filter_kwargs

lib/liquid/variable_lookup.rb

@@ -6,16 +6,20 @@ module Liquid
 
     attr_reader :name, :lookups
 
-    def self.parse(markup)
-      new(markup)
+    def self.parse(markup, string_scanner = StringScanner.new(""), cache = nil)
+      new(markup, string_scanner, cache)
     end
 
-    def initialize(markup)
+    def initialize(markup, string_scanner = StringScanner.new(""), cache = nil)
       lookups = markup.scan(VariableParser)
 
       name = lookups.shift
       if name&.start_with?('[') && name&.end_with?(']')
-        name = Expression.parse(name[1..-2])
+        name = Expression.parse(
+          name[1..-2],
+          string_scanner,
+          cache,
+        )
       end
       @name = name
 
@@ -25,13 +29,21 @@ module Liquid
       @lookups.each_index do |i|
         lookup = lookups[i]
         if lookup&.start_with?('[') && lookup&.end_with?(']')
-          lookups[i] = Expression.parse(lookup[1..-2])
+          lookups[i] = Expression.parse(
+            lookup[1..-2],
+            string_scanner,
+            cache,
+          )
         elsif COMMAND_METHODS.include?(lookup)
           @command_flags |= 1 << i
         end
       end
     end
 
+    def lookup_command?(lookup_index)
+      @command_flags & (1 << lookup_index) != 0
+    end
+
     def evaluate(context)
       name   = context.evaluate(@name)
       object = context.find_variable(name)
@@ -55,9 +67,14 @@ module Liquid
           # Some special cases. If the part wasn't in square brackets and
           # no key with the same name was found we interpret following calls
           # as commands and call them on the current object
-        elsif @command_flags & (1 << i) != 0 && object.respond_to?(key)
+        elsif lookup_command?(i) && object.respond_to?(key)
           object = object.send(key).to_liquid
 
+        # Handle string first/last like ActiveSupport does (returns first/last character)
+        # ActiveSupport returns "" for empty strings, not nil
+        elsif lookup_command?(i) && object.is_a?(String) && (key == "first" || key == "last")
+          object = key == "first" ? (object[0] || "") : (object[-1] || "")
+
           # No key was present with the desired value and it wasn't one of the directly supported
           # keywords either. The only thing we got left is to return nil or
           # raise an exception if `strict_variables` option is set to true

lib/liquid/version.rb

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

liquid.gemspec

@@ -13,22 +13,24 @@ Gem::Specification.new do |s|
   s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
   s.authors     = ["Tobias Lütke"]
   s.email       = ["[email protected]"]
-  s.homepage    = "http://www.liquidmarkup.org"
+  s.homepage    = "https://shopify.github.io/liquid/"
   s.license     = "MIT"
   # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
-  s.required_ruby_version     = ">= 2.5.0"
+  s.required_ruby_version     = ">= 3.0.0"
   s.required_rubygems_version = ">= 1.3.7"
 
   s.metadata['allowed_push_host'] = 'https://rubygems.org'
 
-  s.test_files  = Dir.glob("{test}/**/*")
-  s.files       = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
+  s.files = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
 
   s.extra_rdoc_files = ["History.md", "README.md"]
 
   s.require_path = "lib"
 
+  s.add_dependency("strscan", ">= 3.1.1")
+  s.add_dependency("bigdecimal")
+
   s.add_development_dependency('rake', '~> 13.0')
   s.add_development_dependency('minitest')
 end

performance/benchmark

@@ -1,224 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-unless ENV.key?("BUNDLE_BIN_PATH")
-  exec("bundle", "exec", "ruby",  __FILE__, *ARGV)
-end
-
-require "pry"
-require "liquid"
-require "unicode_plot"
-require "optparse"
-require "open3"
-require "csv"
-require "io/console"
-
-TERM_ROWS, TERM_COLS = IO.console.winsize
-
-def record
-  if ARGV.count != 2
-    STDERR.puts "Usage: benchmark.rb record [output_path]"
-    exit(1)
-  end
-  output_path = ARGV[1]
-  out, status = Open3.capture2("ruby", "#{__dir__}/benchmark_child.rb")
-  File.write(output_path, out)
-end
-
-def calc_stats(nums)
-  mean = nums.reduce(:+) / nums.length
-  variance = nums.map { |n| (n - mean).pow(2) }.reduce(:+) / nums.length
-  stddev = Math.sqrt(variance)
-  {
-    mean: mean,
-    variance: variance,
-    stddev: stddev,
-    normalized: normalize_outliers(mean, stddev, nums),
-    raw: nums
-  }
-end
-
-def normalize_outliers(mean, stddev, nums)
-  cutoff = stddev * 3
-  nums.map do |n|
-    if (n - mean).abs < cutoff
-      n
-    else
-      mean
-    end
-  end
-end
-
-
-def show
-  if ARGV.count < 2
-    STDERR.puts "Usage: benchmark.rb show [path1] [path2]? ..."
-    exit(1)
-  end
-
-  recordings = ARGV.drop(1).to_h do |path|
-    [File.basename(path), CSV.parse(
-      File.open(path),
-      col_sep: "\t",
-      headers: true,
-      converters: :integer
-    )]
-  end
-
-  runs = (1..1000).to_a
-  recordings.values.first.headers.each do |benchmark|
-    colors = [:green, :blue, :red]
-
-    10.times { puts }
-    title = "Benchmark: #{benchmark} (times in µs)"
-    print " " * (TERM_COLS / 2 - title.length)
-    puts title
-    puts
-
-    all_stats = recordings.transform_values do |csv|
-      stats = calc_stats(csv.map { |row| row[benchmark] })
-      stats[:color] = colors.shift
-      stats
-    end
-
-    line_plots = []
-    distributions = []
-    shared_line_plot = nil
-
-    max_mean_stats = all_stats.values.max_by { |stats| stats[:mean] }
-    max_y = (max_mean_stats[:mean] + max_mean_stats[:stddev] * 3).to_i
-
-    all_stats.each do |name, stats|
-      if shared_line_plot == nil
-        shared_line_plot = UnicodePlot.lineplot(
-          runs,
-          stats[:normalized],
-          name: name,
-          width: TERM_COLS - 25,
-          ylim: [0, max_y],
-          color: stats[:color]
-        )
-      else
-        UnicodePlot.lineplot!(shared_line_plot, stats[:normalized], name: name, color: stats[:color])
-      end
-
-      line_plots << render_to_s(UnicodePlot.lineplot(
-        runs,
-        stats[:normalized],
-        name: name,
-        color: stats[:color],
-        width: 40
-      ))
-
-      distributions << render_to_s(UnicodePlot.histogram(
-        stats[:normalized],
-        title: name,
-        color: stats[:color]
-      ))
-    end
-
-    shared_line_plot.render
-    print_columns(line_plots)
-    print_columns(distributions)
-
-    all_times = all_stats.transform_values { |stats| stats[:normalized] }
-    UnicodePlot.boxplot(data: all_times, title: "Comparison", width: TERM_COLS - 25).render
-  end
-end
-
-def render_to_s(plot)
-  io = StringIO.new
-  plot.render(io, color: true)
-  io.string
-end
-
-def visual_length(line)
-  line.gsub(/\e\[(\d+)m/, '').length
-end
-
-def print_columns(cols)
-  col_lines = cols.map { |col| col.split("\n") }
-  col_width = col_lines.map do |lines|
-    lines.map { |line| visual_length(line) }.max
-  end.max
-  col_height = col_lines.map { |lines| lines.length }.max
-
-  (0...col_height).each do |i|
-    col_lines.each do |lines|
-      line = lines[i] || ""
-      vis_length = visual_length(line)
-      print line
-      print(" " * (col_width - vis_length))
-    end
-    puts
-  end
-end
-
-ITERS = 1
-Benchmarks = Class.new do
-  def define(_name, benchmark)
-    @benchmark = benchmark
-  end
-
-  def run
-    start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-    @benchmark.compile
-    parsed = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-
-    # warmup
-    ITERS.times { @benchmark.render}
-    warm = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-
-    res = nil
-    ITERS.times { res = @benchmark.render }
-    ran = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-
-    if res.is_a?(String)
-      puts res
-      puts "Output digest: #{Digest::SHA2.hexdigest(res)}"
-    end
-
-    if ENV['SHOW_RUBY'] == '1'
-      STDERR.puts "note: SHOW_RUBY prevents gathering parse metrics"
-      STDERR.puts "render: #{(ran - warm) / ITERS}µs"
-    else
-      STDERR.puts "parse: #{parsed - start}µs"
-      STDERR.puts "render: #{(ran - warm) / ITERS}µs"
-      STDERR.puts "total: #{(ran - warm) / ITERS + (parsed - start)}µs"
-    end
-  end
-end.new
-
-def execute
-  require 'digest'
-
-  if ARGV.count != 2
-    STDERR.puts "Usage: benchmark.rb record [output_path]"
-    exit(1)
-  end
-
-  case ENV['ENGINE']
-  when 'LIQUID_COMPILE'
-    require_relative '../lib/liquid/compile'
-  when 'LIQUID_C'
-    require 'liquid/c'
-  when 'LIQUID_RUBY'
-  else
-    raise "Invalid ENGINE: #{ENV['ENGINE'].inspect}, expected ENGINE=(LIQUID_RUBY|LIQUID_COMPILE)"
-  end
-
-  require_relative "./benchmarks/#{ARGV[1]}.rb"
-  Benchmarks.run
-end
-
-case ARGV.first
-when "record", "r"
-  record
-when "show", "s"
-  show
-when "execute", "x"
-  execute
-else
-  puts "Invalid command. Expected benchmark [record|show|execute] ..."
-  exit 1
-end

performance/benchmark.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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
+
+Benchmark.ips do |x|
+  x.time   = 20
+  x.warmup = 10
+
+  puts
+  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
+  puts
+
+  phase = ENV["PHASE"] || "all"
+
+  x.report("tokenize:") { profiler.tokenize } if phase == "all" || phase == "tokenize"
+  x.report("parse:") { profiler.compile } if phase == "all" || phase == "parse"
+  x.report("render:") { profiler.render } if phase == "all" || phase == "render"
+  x.report("parse & render:") { profiler.run } if phase == "all" || phase == "run"
+end

performance/benchmark_child.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'liquid'
-
-Liquid::Template.error_mode = :strict
-
-case ENV['ENGINE']
-when 'LIQUID_COMPILE'
-  require_relative '../lib/liquid/compile'
-when 'LIQUID_C'
-  require 'liquid/c'
-when 'LIQUID_RUBY'
-else
-  raise "Invalid engine: #{ENV['ENGINE'].inspect}"
-end
-
-OPTIONS = {
-  render_iters: 1000
-}
-
-def get_time_us
-  Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-end
-
-Benchmarks = Class.new do
-  def initialize
-    @by_name = {}
-  end
-
-  def define(name, benchmark)
-    @by_name[name] = benchmark
-  end
-
-  def run
-    times = {}
-    @by_name.each do |name, benchmark|
-      benchmark.compile
-
-      times[name] = OPTIONS[:render_iters].times.map do
-        before = get_time_us
-        benchmark.render
-        get_time_us - before
-      end
-    end
-
-    puts times.keys.join("\t")
-    cols = times.values
-    OPTIONS[:render_iters].times do |i|
-      cols.each do |values|
-        print values[i]
-        print "\t" unless values == cols.last
-      end
-      puts
-    end
-  end
-end.new
-
-Dir[__dir__ + "/benchmarks/*.rb", base: __dir__].each do |path|
-  require_relative path
-end
-
-Benchmarks.run

performance/benchmarks/fizzbuzz_10000.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-Benchmarks.define('fizzbuzz_10000', Class.new do
-  TEMPLATE = <<~LIQUID
-  {% for i in (1..#{ENV['COUNT'].to_i}) %}
-    {% liquid
-      assign rem_3 = i | modulo: 3
-      assign rem_5 = i | modulo: 5
-      if rem_3 == 0 and rem_5 == 0
-        echo "Fizzbuzz"
-      elsif rem_3 == 0
-        echo "Fizz"
-      elsif rem_5 == 0
-        echo "Buzz"
-      else
-        echo i
-      endif
-    %}{% endfor %}
-  LIQUID
-
-  def compile
-    @parsed = Liquid::Template.parse(TEMPLATE)
-  end
-
-  def render
-    @parsed.render
-  end
-end.new)

performance/benchmarks/simple_loop.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-Benchmarks.define('simple_loop', Class.new do
-  TEMPLATE = "{% for i in (1..1000) %}{{ i }}{% endfor %}"
-
-  def compile
-    @parsed = Liquid::Template.parse(TEMPLATE)
-  end
-
-  def render
-    @parsed.render
-  end
-end.new)

performance/benchmarks/theme_runner.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../theme_runner'
-
-#Benchmarks.define('theme_runner', ThemeRunner.new) 

performance/profile.rb

@@ -3,16 +3,6 @@
 require 'stackprof'
 require_relative 'theme_runner'
 
-if ENV['LIQUID_C'] == '1'
-  puts "-- LIQUID C"
-  require 'liquid/c'
-end
-
-if ENV['LIQUID_COMPILE'] == '1'
-  puts "-- COMPILED"
-  require 'liquid/compile'
-end
-
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run

performance/shopify/database.rb

@@ -49,8 +49,3 @@ module Database
     end
   end
 end
-
-if __FILE__ == $PROGRAM_NAME
-  p(Database.tables['collections']['frontpage'].keys)
-  # p Database.tables['blog']['articles']
-end

performance/shopify/liquid.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 $LOAD_PATH.unshift(__dir__ + '/../../lib')
+require_relative '../../lib/liquid'
+
 require_relative 'comment_form'
 require_relative 'paginate'
 require_relative 'json_filter'
@@ -9,11 +11,12 @@ require_relative 'shop_filter'
 require_relative 'tag_filter'
 require_relative 'weight_filter'
 
-Liquid::Template.register_tag('paginate', Paginate)
-Liquid::Template.register_tag('form', CommentForm)
+default_environment = Liquid::Environment.default
+default_environment.register_tag('paginate', Paginate)
+default_environment.register_tag('form', CommentForm)
 
-Liquid::Template.register_filter(JsonFilter)
-Liquid::Template.register_filter(MoneyFilter)
-Liquid::Template.register_filter(WeightFilter)
-Liquid::Template.register_filter(ShopFilter)
-Liquid::Template.register_filter(TagFilter)
+default_environment.register_filter(JsonFilter)
+default_environment.register_filter(MoneyFilter)
+default_environment.register_filter(WeightFilter)
+default_environment.register_filter(ShopFilter)
+default_environment.register_filter(TagFilter)

performance/shopify/paginate.rb

@@ -45,8 +45,8 @@ class Paginate < Liquid::Block
 
       pagination['items']      = collection_size
       pagination['pages']      = page_count - 1
-      pagination['previous']   = link('&laquo; Previous', current_page - 1)  unless 1 >= current_page
-      pagination['next']       = link('Next &raquo;', current_page + 1)      unless page_count <= current_page + 1
+      pagination['previous']   = link('&laquo; Previous', current_page - 1)  if 1 < current_page
+      pagination['next']       = link('Next &raquo;', current_page + 1)      if page_count > current_page + 1
       pagination['parts']      = []
 
       hellip_break = false

performance/theme_runner.rb

@@ -3,7 +3,7 @@
 # This profiler run simulates Shopify.
 # We are looking in the tests directory for liquid files and render them within the designated layout file.
 # We will also export a substantial database to liquid which the templates can render values of.
-# All this is to make the benchmark as non syntetic as possible. All templates and tests are lifted from
+# All this is to make the benchmark as non synthetic as possible. All templates and tests are lifted from
 # direct real-world usage and the profiler measures code that looks very similar to the way it looks in
 # Shopify which is likely the biggest user of liquid in the world which something to the tune of several
 # million Template#render calls a day.
@@ -48,6 +48,19 @@ class ThemeRunner
     end
   end
 
+  # `tokenize` will just test the tokenizen portion of liquid without any templates
+  def tokenize
+    ss = StringScanner.new("")
+    @tests.each do |test_hash|
+      tokenizer = Liquid::Tokenizer.new(
+        source: test_hash[:liquid],
+        string_scanner: ss,
+        line_numbers: true,
+      )
+      while tokenizer.shift; end
+    end
+  end
+
   # `run` is called to benchmark rendering and compiling at the same time
   def run
     each_test do |liquid, layout, assigns, page_template, template_name|

performance/unit/expression_benchmark.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+
+# benchmark liquid lexing
+
+require 'liquid'
+
+RubyVM::YJIT.enable
+
+STRING_MARKUPS = [
+  "\"foo\"",
+  "\"fooooooooooo\"",
+  "\"foooooooooooooooooooooooooooooo\"",
+  "'foo'",
+  "'fooooooooooo'",
+  "'foooooooooooooooooooooooooooooo'",
+]
+
+VARIABLE_MARKUPS = [
+  "article",
+  "article.title",
+  "article.title.size",
+  "very_long_variable_name_2024_11_05",
+  "very_long_variable_name_2024_11_05.size",
+]
+
+NUMBER_MARKUPS = [
+  "0",
+  "35",
+  "1241891024912849",
+  "3.5",
+  "3.51214128409128",
+  "12381902839.123819283910283",
+  "123.456.789",
+  "-123",
+  "-12.33",
+  "-405.231",
+  "-0",
+  "0",
+  "0.0",
+  "0.0000000000000000000000",
+  "0.00000000001",
+]
+
+RANGE_MARKUPS = [
+  "(1..30)",
+  "(1...30)",
+  "(1..30..5)",
+  "(1.0...30.0)",
+  "(1.........30)",
+  "(1..foo)",
+  "(foo..30)",
+  "(foo..bar)",
+  "(foo...bar...100)",
+  "(foo...bar...100.0)",
+]
+
+LITERAL_MARKUPS = [
+  nil,
+  'nil',
+  'null',
+  '',
+  'true',
+  'false',
+  'blank',
+  'empty',
+]
+
+MARKUPS = {
+  "string" => STRING_MARKUPS,
+  "literal" => LITERAL_MARKUPS,
+  "variable" => VARIABLE_MARKUPS,
+  "number" => NUMBER_MARKUPS,
+  "range" => RANGE_MARKUPS,
+}
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 5)
+
+  MARKUPS.each do |type, markups|
+    x.report("Liquid::Expression#parse: #{type}") do
+      markups.each do |markup|
+        Liquid::Expression.parse(markup)
+      end
+    end
+  end
+
+  x.report("Liquid::Expression#parse: all") do
+    MARKUPS.values.flatten.each do |markup|
+      Liquid::Expression.parse(markup)
+    end
+  end
+end

performance/unit/lexer_benchmark.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+
+# benchmark liquid lexing
+
+require 'liquid'
+
+RubyVM::YJIT.enable
+
+EXPRESSIONS = [
+  "foo[1..2].baz",
+  "12.0",
+  "foo.bar.based",
+  "21 - 62",
+  "foo.bar.baz",
+  "foo > 12",
+  "foo < 12",
+  "foo <= 12",
+  "foo >= 12",
+  "foo <> 12",
+  "foo == 12",
+  "foo != 12",
+  "foo contains 12",
+  "foo contains 'bar'",
+  "foo != 'bar'",
+  "'foo' contains 'bar'",
+  '234089',
+  "foo | default: -1",
+]
+
+Benchmark.ips do |x|
+  x.config(time: 10, warmup: 5)
+
+  x.report("Liquid::Lexer#tokenize") do
+    EXPRESSIONS.each do |expr|
+      l = Liquid::Lexer.new(expr)
+      l.tokenize
+    end
+  end
+
+  x.compare!
+end

spec/ruby_liquid.rb

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

spec/ruby_liquid_lax.rb

@@ -0,0 +1,46 @@
+# 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

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

spec/ruby_liquid_yjit.rb

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