Potential fix

Test parsing of Liquid code in comments
2026-09-13 07:50:43 -07:00 · 2021-11-30 14:10:34 -05:00 · 2021-11-30 11:56:49 -05:00
140 changed files with 2446 additions and 7761 deletions
@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: github-actions
-    directory: "/"
-    schedule:
-      interval: weekly
@@ -0,0 +1,2 @@
+enabled:
+  - cla
@@ -1,22 +0,0 @@
-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 }}
@@ -1,72 +1,39 @@
 name: Liquid
-on: [push]
-
-env:
-  BUNDLE_JOBS: 4
-  BUNDLE_RETRY: 3
-
+on: [push, pull_request]
 jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
-      fail-fast: false
      matrix:
        entry:
-          - { ruby: 3.3, allowed-failure: false } # minimum supported
-          - { ruby: 3.4, allowed-failure: false, rubyopt: "--yjit" }
-          - { ruby: 4.0, allowed-failure: false } # latest stable
-          - {
-              ruby: 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" }
-
-          # 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' }}
+          - { ruby: 2.5, allowed-failure: false } # minimum supported
+          - { ruby: 3.0, allowed-failure: false } # latest
+          - { ruby: ruby-head, allowed-failure: true }
+    name: test (${{ matrix.entry.ruby }})
    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: ${{ matrix.entry.ruby }}
-          bundler-cache: true
-          bundler: latest
+      - 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
      - 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@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
-        with:
-          bundler-cache: true
-          bundler: latest
-      - name: Run liquid-spec for all adapters
-        run: |
-          for adapter in spec/*.rb; do
-            echo "=== Running $adapter ==="
-            bundle exec liquid-spec run "$adapter" --no-max-failures
-          done
-
  memory_profile:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
        with:
-          bundler-cache: true
+          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
      - run: bundle exec rake memory_profile:run
@@ -4,6 +4,7 @@
 pkg
 *.rbc
 .rvmrc
+.ruby-version
+Gemfile.lock
 .bundle
 .byebug_history
-Gemfile.lock
@@ -10,8 +10,8 @@ Performance:
  Enabled: true

 AllCops:
+  TargetRubyVersion: 2.5
  NewCops: disable
-  SuggestExtensions: false
  Exclude:
    - 'vendor/bundle/**/*'

@@ -19,10 +19,6 @@ Naming/MethodName:
  Exclude:
    - 'example/server/liquid_servlet.rb'

-Style/ClassMethodsDefinitions:
-  Enabled: false
-
-# liquid filter calls were being mistaken to be calls on arrays
-Style/ConcatArrayLiterals:
-  Exclude:
-    - 'test/integration/standard_filter_test.rb'
+# Backport https://github.com/Shopify/ruby-style-guide/pull/258
+Layout/BeginEndAlignment:
+  Enabled: true
@@ -1,74 +1,27 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2022-05-18 19:25:47 UTC using RuboCop version 1.29.1.
+# on 2020-12-11 18:53:41 UTC using RuboCop version 1.6.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: 1
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: TreatCommentsAsGroupSeparators, ConsiderPunctuation, Include.
-# Include: **/*.gemspec
-Gemspec/OrderedDependencies:
+# Offense count: 2
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: runtime_error, standard_error
+Lint/InheritException:
  Exclude:
-    - 'liquid.gemspec'
+    - 'lib/liquid/interrupts.rb'

-# 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: 113
+# Cop supports --auto-correct.
+# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# URISchemes: http, https
+Layout/LineLength:
+  Max: 260

 # 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'
@@ -80,7 +33,7 @@ Lint/MissingSuper:
    - 'test/integration/tags/for_tag_test.rb'
    - 'test/integration/tags/table_row_test.rb'

-# Offense count: 44
+# Offense count: 43
 Naming/ConstantName:
  Exclude:
    - 'lib/liquid.rb'
@@ -98,92 +51,7 @@ 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'
@@ -1 +0,0 @@
-3.4.1
@@ -26,11 +26,3 @@
 * 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)
-
@@ -7,32 +7,22 @@ end

 gemspec

-gem "base64"
-
 group :benchmark, :test do
  gem 'benchmark-ips'
  gem 'memory_profiler'
  gem 'terminal-table'
-  gem "lru_redux"

  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
    gem 'stackprof'
  end
 end

-group :development do
-  gem "webrick"
-end
-
 group :test do
-  gem 'benchmark'
-  gem 'rubocop', '~> 1.82.0'
-  gem 'rubocop-shopify', '~> 2.18.0', require: false
+  gem 'rubocop', '~> 1.4', require: false
+  gem 'rubocop-shopify', '~> 1.0.7', require: false
  gem 'rubocop-performance', require: false
-end

-group :spec do
-  # TODO: temporary - using cp-gate-lax-specs-ai branch until lax specs are properly gated
-  gem 'liquid-spec', github: 'Shopify/liquid-spec', branch: 'cp-gate-lax-specs-ai'
-  gem 'activesupport', require: false
+  platform :mri, :truffleruby do
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
+  end
 end
@@ -1,159 +1,5 @@
 # Liquid Change Log

-## 6.0.0
-
-### Architectural changes
-
-### Features
-* (TODO) Add support for boolean expressions everywhere
-  * As variable output `{{ a or b }}`
-  * As filter argument `{{ collection | where: 'prop', a or b }}`
-  * As tag argument `{% render 'snip', enabled: a or b %}`
-  * As conditional tag argument `{% if cond %}` (extending previous behaviour)
-* (TODO) Add support for subexpression prioritization and associativity
-  * In ascending order of priority:
-    * Logical: `and`, `or` (right to left)
-    * Equality: `==`, `!=`, `<>` (left to right)
-    * Comparison: `>`, `>=`, `<`, `<=`, `contains` (left to right)
-  - For example, this is now supported
-    * `{{ a > b == c < d or e == f }}` which is equivalent to
-    * `{{ ((a > b) == (c < d)) or (e == f) }}`
- (TODO) Add support for parenthesized expressions
-  * e.g. `(a or b) and c`
-
-### Breaking changes
-* The Environment's `error_mode` option has been removed.
-  * `:warn` is no longer supported
-  * `:lax` and `lax_parse` is no longer supported
-  * `:strict` and `strict_parse` is no longer supported
-  * `strict2_parse` is renamed to `parse_markup`
-* The `warnings` system has been removed.
-
-### Migrating from `^5.11.0`
- In custom tags that include `ParserSwitching`, rename `strict2_parse` to `parse_markup`
- Remove code depending on `:error_mode`
-
-## 5.11.0
-* Revert the Inline Snippets tag (#2001), treat its inclusion in the latest Liquid release as a bug, and allow for feedback on RFC#1916 to better support Liquid developers [Guilherme Carreiro]
-* 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
-* StandardFilter: Fix missing @context on iterations (#1525) [Thierry Joyal]
-* Fix warning about block and default value in `static_registers.rb` (#1531) [Peter Zhu]
-
-### Deprecation
-* Condition#evaluate to require mandatory context argument in Liquid 6.0.0 (#1527) [Thierry Joyal]
-
-## 5.2.0 2022-03-01
-
-### Features
-* Add `remove_last`, and `replace_last` filters (#1422) [Anders Hagbard]
-* Eagerly cache global filters (#1524) [Jean Boussier]
-
-### Fixes
-* Fix some internal errors in filters from invalid input (#1476) [Dylan Thacker-Smith]
-* Allow dash in filter kwarg name for consistency with Liquid::C (#1518) [CP Clermont]
-
 ## 5.1.0 / 2021-09-09

 ### Features
@@ -1,11 +1,11 @@
-[![Build status](https://github.com/Shopify/liquid/actions/workflows/liquid.yml/badge.svg)](https://github.com/Shopify/liquid/actions/workflows/liquid.yml)
+[![Build Status](https://api.travis-ci.org/Shopify/liquid.svg?branch=master)](http://travis-ci.org/Shopify/liquid)
 [![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/docs/api/liquid)
+* [Liquid documentation from Shopify](http://docs.shopify.com/themes/liquid-basics)
 * [Liquid Wiki at GitHub](https://github.com/Shopify/liquid/wiki)
 * [Website](http://liquidmarkup.org/)

@@ -52,46 +52,29 @@ 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
+### Error Modes

-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.
+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. 

-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:
+Liquid also comes with a stricter parser that can be used when editing templates to give better error messages
+when templates are invalid. You can enable this new parser like this:

 ```ruby
-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
+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.
 ```

-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:
-
+If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
 ```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
+Liquid::Template.parse(source, :error_mode => :strict)
 ```
+This is useful for doing things like enabling strict mode only in the theme editor.

-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`.
+It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
+It is also recommended that you use it in the template editors of existing apps to give editors better error messages.

 ### Undefined variables and filters

@@ -128,4 +111,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.
@@ -33,12 +33,23 @@ task :rubocop do
  end
 end

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

  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
+    ENV['LIQUID_C'] = '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
@@ -61,33 +72,14 @@ task release: :build do
 end

 namespace :benchmark do
-  desc "Run the liquid benchmark"
+  desc "Run the liquid benchmark with lax parsing"
  task :run do
-    ruby "./performance/benchmark.rb"
+    ruby "./performance/benchmark.rb lax"
  end

-  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
+  desc "Run the liquid benchmark with strict parsing"
+  task :strict do
+    ruby "./performance/benchmark.rb strict"
  end
 end

@@ -96,6 +88,11 @@ namespace :profile do
  task :run do
    ruby "./performance/profile.rb"
  end
+
+  desc "Run the liquid profile/performance coverage with strict parsing"
+  task :strict do
+    ruby "./performance/profile.rb strict"
+  end
 end

 namespace :memory_profile do
@@ -113,9 +110,3 @@ end
 task :console do
  exec 'irb -I lib -r liquid'
 end
-
-desc('run liquid-spec suite across all adapters')
-task :spec do
-  adapters = Dir['./spec/*.rb'].join(',')
-  sh "bundle exec liquid-spec matrix --adapters=#{adapters} --reference=ruby_liquid"
-end
@@ -1,46 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'liquid'
-
-class VirtualFileSystem
-  def initialize
-    snippet_1 = <<~LIQUID
-      <h1>
-        {{- greating | default: 'Hello' }}, {{ name | default: 'world' -}}!
-      </h1>
-    LIQUID
-    snippet_2 = <<~LIQUID
-      {%- for i in (1..5) -%}
-        > {{ i }}
-      {%- endfor -%}
-    LIQUID
-
-    @templates = {
-      'snippet-1' => snippet_1,
-      'snippet-2' => snippet_2,
-    }
-  end
-
-  def read_template_file(key)
-    @templates[key] || raise(Liquid::FileSystemError, "No such template '#{key}'")
-  end
-end
-
-def source
-  File.read(ARGV[0])
-rescue StandardError
-  'Usage: bin/render example/server/templates/index.liquid'
-end
-
-def assigns
-  {
-    'date' => Time.now,
-  }
-end
-
-puts Liquid::Template
-  .parse(source, error_mode: :strict2)
-  .tap { |t| t.registers[:file_system] = VirtualFileSystem.new }
-  .render(assigns)
@@ -30,18 +30,14 @@ 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
@@ -21,8 +21,6 @@
 # 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           = ','
@@ -31,7 +29,6 @@ module Liquid
  WhitespaceControl           = '-'
  TagStart                    = /\{\%/
  TagEnd                      = /\%\}/
-  TagName                     = /#|\w+/
  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
  VariableSegment             = /[\w\-]/
  VariableStart               = /\{\{/
@@ -39,28 +36,20 @@ module Liquid
  VariableIncompleteEnd       = /\}\}?/
  QuotedString                = /"[^"]*"|'[^']*'/
  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
-  TagAttributes               = /(\w[\w-]*)\s*\:\s*(#{QuotedFragment})/o
+  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
-  VariableParser              = /\[(?>[^\[\]]+|\g<0>)*\]|#{VariableSegment}+\??/o
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o

  RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
-  HAS_STRING_SCANNER_SCAN_BYTE = StringScanner.instance_methods.include?(:scan_byte)
+
+  singleton_class.send(:attr_accessor, :cache_classes)
+  self.cache_classes = true
 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'
@@ -70,22 +59,34 @@ require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
+require 'liquid/strainer_factory'
 require 'liquid/strainer_template'
+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/registers'
+require 'liquid/register'
+require 'liquid/static_registers'
 require 'liquid/template_factory'
+
+# Load all the tags of the standard library
+#
+Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
@@ -36,17 +36,13 @@ 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
@@ -4,9 +4,8 @@ require 'English'

 module Liquid
  class BlockBody
-    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
+    LiquidTagToken      = /\A\s*(\w+)\s*(.*?)\z/o
+    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
    ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
    WhitespaceOrNothing = /\A\s*\z/
    TAGSTART            = "{%"
@@ -38,7 +37,7 @@ module Liquid

    private def parse_for_liquid_tag(tokenizer, parse_context)
      while (token = tokenizer.shift)
-        unless token.empty? || token.match?(WhitespaceOrNothing)
+        unless token.empty? || token =~ WhitespaceOrNothing
          unless token =~ LiquidTagToken
            # line isn't empty but didn't match tag syntax, yield and let the
            # caller raise a syntax error
@@ -46,13 +45,7 @@ module Liquid
          end
          tag_name = Regexp.last_match(1)
          markup   = Regexp.last_match(2)
-
-          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))
+          unless (tag = registered_tags[tag_name])
            # end parsing if we reach an unknown tag and let the caller decide
            # determine how to proceed
            return yield tag_name, markup
@@ -116,22 +109,14 @@ module Liquid
      end
    end

-    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)
+    private def parse_for_document(tokenizer, parse_context)
      while (token = tokenizer.shift)
        next if token.empty?
        case
        when token.start_with?(TAGSTART)
          whitespace_handler(token, parse_context)
          unless token =~ FullToken
-            return handle_invalid_tag_token(token, parse_context, &block)
+            BlockBody.raise_missing_tag_terminator(token, parse_context)
          end
          tag_name = Regexp.last_match(2)
          markup   = Regexp.last_match(4)
@@ -147,7 +132,7 @@ module Liquid
            next
          end

-          unless (tag = parse_context.environment.tag_for_name(tag_name))
+          unless (tag = registered_tags[tag_name])
            # end parsing if we reach an unknown tag and let the caller decide
            # determine how to proceed
            return yield tag_name, markup
@@ -165,7 +150,7 @@ module Liquid
          end
          parse_context.trim_whitespace = false
          @nodelist << token
-          @blank &&= token.match?(WhitespaceOrNothing)
+          @blank &&= !!(token =~ WhitespaceOrNothing)
        end
        parse_context.line_number = tokenizer.line_number
      end
@@ -246,17 +231,10 @@ module Liquid
    end

    def create_variable(token, parse_context)
-      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)
-
+      token.scan(ContentOfVariable) do |content|
+        markup = content.first
        return Variable.new(markup, parse_context)
      end
-
      BlockBody.raise_missing_variable_terminator(token, parse_context)
    end

@@ -269,5 +247,9 @@ 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
@@ -24,9 +24,6 @@ module Liquid
        else
          false
        end
-      rescue Encoding::CompatibilityError
-        # "✅".b.include?("✅") raises Encoding::CompatibilityError despite being materially equal
-        left.b.include?(right.b)
      end,
    }

@@ -48,8 +45,8 @@ module Liquid
      @@operators
    end

-    def self.parse_expression(parse_context, markup, safe: false)
-      @@method_literals[markup] || parse_context.parse_expression(markup, safe: safe)
+    def self.parse_expression(parse_context, markup)
+      @@method_literals[markup] || parse_context.parse_expression(markup)
    end

    attr_reader :attachment, :child_condition
@@ -64,7 +61,7 @@ module Liquid
      @child_condition = nil
    end

-    def evaluate(context = deprecated_default_context)
+    def evaluate(context = Context.new)
      condition = self
      result = nil
      loop do
@@ -72,9 +69,9 @@ module Liquid

        case condition.child_relation
        when :or
-          break if Liquid::Utils.to_liquid_value(result)
+          break if result
        when :and
-          break unless Liquid::Utils.to_liquid_value(result)
+          break unless result
        else
          break
        end
@@ -113,67 +110,24 @@ module Liquid

    def equal_variables(left, right)
      if left.is_a?(MethodLiteral)
-        return call_method_literal(left, right)
+        if right.respond_to?(left.method_name)
+          return right.send(left.method_name)
+        else
+          return nil
+        end
      end

      if right.is_a?(MethodLiteral)
-        return call_method_literal(right, left)
+        if left.respond_to?(right.method_name)
+          return left.send(right.method_name)
+        else
+          return nil
+        end
      end

      left == right
    end

-    def call_method_literal(literal, value)
-      method_name = literal.method_name
-
-      # If the object responds to the method (e.g., ActiveSupport is loaded), use it
-      if value.respond_to?(method_name)
-        value.send(method_name)
-      else
-        # Emulate ActiveSupport's blank?/empty? to make Liquid invariant
-        # to whether ActiveSupport is loaded or not
-        case method_name
-        when :blank?
-          liquid_blank?(value)
-        when :empty?
-          liquid_empty?(value)
-        else
-          false
-        end
-      end
-    end
-
-    # Implement blank? semantics matching ActiveSupport
-    # blank? returns true for nil, false, empty strings, whitespace-only strings,
-    # empty arrays, and empty hashes
-    def liquid_blank?(value)
-      case value
-      when NilClass, FalseClass
-        true
-      when TrueClass, Numeric
-        false
-      when String
-        # Blank if empty or whitespace only (matches ActiveSupport)
-        value.empty? || value.match?(/\A\s*\z/)
-      when Array, Hash
-        value.empty?
-      else
-        # Fall back to empty? if available, otherwise false
-        value.respond_to?(:empty?) ? value.empty? : false
-      end
-    end
-
-    # Implement empty? semantics
-    # Note: nil is NOT empty. empty? checks if a collection has zero elements.
-    def liquid_empty?(value)
-      case value
-      when String, Array, Hash
-        value.empty?
-      else
-        value.respond_to?(:empty?) ? value.empty? : false
-      end
-    end
-
    def interpret_condition(left, right, op, context)
      # If the operator is empty this means that the decision statement is just
      # a single variable. We can just poll this variable from the context and
@@ -196,19 +150,11 @@ module Liquid
      end
    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.")
-      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
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Const
-    EMPTY_HASH = {}.freeze
-    EMPTY_ARRAY = [].freeze
-  end
-end
@@ -15,40 +15,31 @@ 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, :environment
+    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters

    # rubocop:disable Metrics/ParameterLists
-    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)
+    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)
    end

-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {}, environment = Environment.default)
-      @environment = environment
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {})
      @environments = [environments]
      @environments.flatten!

-      @static_environments = [static_environments].flatten(1).freeze
-      @scopes              = [outer_scope || {}]
-      @registers           = registers.is_a?(Registers) ? registers : Registers.new(registers)
+      @static_environments = [static_environments].flat_map(&:freeze).freeze
+      @scopes              = [(outer_scope || {})]
+      @registers           = registers
      @errors              = []
      @partial             = false
      @strict_variables    = false
-      @resource_limits     = resource_limits || ResourceLimits.new(environment.default_resource_limits)
+      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
      @base_scope_depth    = 0
      @interrupts          = []
      @filters             = []
      @global_filter       = nil
      @disabled_tags       = {}

-      # 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
+      self.exception_renderer = Template.default_exception_renderer
      if rethrow_errors
        self.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
      end
@@ -60,8 +51,12 @@ module Liquid
    end
    # rubocop:enable Metrics/ParameterLists

+    def warnings
+      @warnings ||= []
+    end
+
    def strainer
-      @strainer ||= @environment.create_strainer(self, @filters)
+      @strainer ||= StrainerFactory.create(self, @filters)
    end

    # Adds filters to this context.
@@ -143,16 +138,16 @@ module Liquid
      check_overflow

      self.class.build(
-        environment: @environment,
        resource_limits: resource_limits,
        static_environments: static_environments,
-        registers: Registers.new(registers),
+        registers: StaticRegisters.new(registers)
      ).tap do |subcontext|
        subcontext.base_scope_depth   = base_scope_depth + 1
        subcontext.exception_renderer = exception_renderer
        subcontext.filters  = @filters
        subcontext.strainer = nil
        subcontext.errors   = errors
+        subcontext.warnings = warnings
        subcontext.disabled_tags = @disabled_tags
      end
    end
@@ -175,11 +170,11 @@ module Liquid
    # Example:
    #   products == empty #=> products.empty?
    def [](expression)
-      evaluate(Expression.parse(expression, @string_scanner))
+      evaluate(Expression.parse(expression))
    end

    def key?(key)
-      find_variable(key, raise_on_not_found: false) != nil
+      self[key] != nil
    end

    def evaluate(object)
@@ -198,14 +193,10 @@ module Liquid
        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
      end

-      # update variable's context before invoking #to_liquid
+      variable         = variable.to_liquid
      variable.context = self if variable.respond_to?(:context=)

-      liquid_variable = variable.to_liquid
-
-      liquid_variable.context = self if variable != liquid_variable && liquid_variable.respond_to?(:context=)
-
-      liquid_variable
+      variable
    end

    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
@@ -239,7 +230,7 @@ module Liquid

    protected

-    attr_writer :base_scope_depth, :errors, :strainer, :filters, :disabled_tags
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags

    private

@@ -1,22 +0,0 @@
-# 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
@@ -25,13 +25,9 @@ module Liquid
  class Drop
    attr_writer :context

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

@@ -1,151 +0,0 @@
-# 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 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 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, exception_renderer: nil)
-        ret = new
-        ret.tags = tags if tags
-        ret.file_system = file_system if file_system
-        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
-      @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
@@ -40,20 +40,19 @@ 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)
-  TemplateEncodingError = 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)
 end
@@ -3,121 +3,40 @@
 module Liquid
  class Expression
    LITERALS = {
-      nil => nil,
-      'nil' => nil,
-      'null' => nil,
-      '' => nil,
+      nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
      'true' => true,
      'false' => false,
      'blank' => '',
-      'empty' => '',
+      'empty' => ''
    }.freeze

-    DOT = ".".ord
-    ZERO = "0".ord
-    NINE = "9".ord
-    DASH = "-".ord
+    SINGLE_QUOTED_STRING = /\A\s*'(.*)'\s*\z/m
+    DOUBLE_QUOTED_STRING = /\A\s*"(.*)"\s*\z/m
+    INTEGERS_REGEX       = /\A\s*(-?\d+)\s*\z/
+    FLOATS_REGEX         = /\A\s*(-?\d[\d\.]+)\s*\z/

    # 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/
-    INTEGER_REGEX = /\A(-?\d+)\z/
-    FLOAT_REGEX = /\A(-?\d+)\.\d+\z/
+    RANGES_REGEX         = /\A\s*\(\s*(?>(\S+)\s*\.\.)\s*(\S+)\s*\)\s*\z/

-    class << self
-      def safe_parse(parser, ss = StringScanner.new(""), cache = nil)
-        parse(parser.expression, ss, cache)
-      end
-
-      def parse(markup, ss = StringScanner.new(""), cache = nil)
-        return unless markup
-
-        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
+    def self.parse(markup)
+      case markup
+      when nil
+        nil
+      when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
+        Regexp.last_match(1)
+      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
+        markup = markup.strip
+        if LITERALS.key?(markup)
+          LITERALS[markup]
        else
-          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
+          VariableLookup.parse(markup)
        end
      end
    end
@@ -1,11 +1,6 @@
 # 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
@@ -14,68 +9,33 @@ module Liquid
      @index      = 0
    end

-    # @liquid_public_docs
-    # @liquid_name length
-    # @liquid_summary
-    #   The total number of iterations in the loop.
-    # @liquid_return [number]
-    attr_reader :length
+    attr_reader :length, :parentloop

-    # @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
+    def name
+      Usage.increment('forloop_drop_name')
+      @name
+    end

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

@@ -1,179 +1,62 @@
 # frozen_string_literal: true

+require "strscan"
 module Liquid
  class Lexer
-    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
+    SPECIALS = {
+      '|' => :pipe,
+      '.' => :dot,
+      ':' => :colon,
+      ',' => :comma,
+      '[' => :open_square,
+      ']' => :close_square,
+      '(' => :open_round,
+      ')' => :close_round,
+      '?' => :question,
+      '-' => :dash,
+    }.freeze
    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
-    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
-    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 = /'[^\']*'/
+    DOUBLE_STRING_LITERAL = /"[^\"]*"/
+    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
+    DOTDOT                = /\.\./
+    COMPARISON_OPERATOR   = /==|!=|<>|<=?|>=?|contains(?=\s)/
    WHITESPACE_OR_NOTHING = /\s*/

-    SINGLE_COMPARISON_TOKENS = [].tap do |table|
-      table["<".ord] = COMPARISON_LESS_THAN
-      table[">".ord] = COMPARISON_GREATER_THAN
-      table.freeze
+    def initialize(input)
+      @ss = StringScanner.new(input)
    end

-    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
+    def tokenize
+      @output = []

-    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
+      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]
          else
-            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
+            raise SyntaxError, "Unexpected character #{c}"
          end
        end
-        # 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
+        @output << tok
      end

-      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
+      @output << [:end_of_string]
    end
  end
 end
@@ -2,31 +2,26 @@
  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]"
-      inline_comment_invalid: "Syntax error in tag '#' - Each line of comments must be prefixed by the '#' character"
+      unknown_tag: "Unknown tag '%{tag}'"
      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"
-      unknown_tag: "Unknown tag '%{tag}'"
+      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
      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:
@@ -3,25 +3,13 @@
 module Liquid
  class ParseContext
    attr_accessor :locale, :line_number, :trim_whitespace, :depth
-    attr_reader :partial, :environment
+    attr_reader :partial, :warnings, :error_mode

-    def initialize(options = Const::EMPTY_HASH)
-      @environment = options.fetch(:environment, Environment.default)
+    def initialize(options = {})
      @template_options = options ? options.dup : {}

-      @locale = @template_options[:locale] ||= I18n.new
-
-      # 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
+      @locale   = @template_options[:locale] ||= I18n.new
+      @warnings = []

      self.depth   = 0
      self.partial = false
@@ -35,38 +23,19 @@ module Liquid
      Liquid::BlockBody.new
    end

-    def new_parser(input)
-      @string_scanner.string = input
-      Parser.new(@string_scanner)
+    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)
    end

-    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)
-      # markup MUST come from a string returned by the parser
-      # (e.g., parser.expression). We're not calling the parser here to
-      # prevent redundant parser overhead. The `safe` opt-in
-      # exists to ensure it is not accidentally still called with
-      # the result of a regex.
-      raise Liquid::InternalError, "unsafe parse_expression cannot be used" unless safe
-
-      Expression.parse(markup, @string_scanner, @expression_cache)
+    def parse_expression(markup)
+      Expression.parse(markup)
    end

    def partial=(value)
      @partial = value
      @options = value ? partial_options : @template_options
+
+      @error_mode = @options[:error_mode] || Template.error_mode
    end

    def partial_options
@@ -36,7 +36,7 @@ module Liquid
    protected

    def children
-      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : Const::EMPTY_ARRAY
+      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : []
    end
  end
 end
@@ -3,8 +3,8 @@
 module Liquid
  class Parser
    def initialize(input)
-      ss = input.is_a?(StringScanner) ? input : StringScanner.new(input)
-      @tokens = Lexer.tokenize(ss)
+      l       = Lexer.new(input)
+      @tokens = l.tokenize
      @p      = 0 # pointer to current location
    end

@@ -53,7 +53,7 @@ module Liquid
        str = consume
        str << variable_lookups
      when :open_square
-        str = consume.dup
+        str = consume
        str << expression
        str << consume(:close_square)
        str << variable_lookups
@@ -2,16 +2,42 @@

 module Liquid
  module ParserSwitching
+    def strict_parse_with_error_mode_fallback(markup)
+      strict_parse_with_error_context(markup)
+    rescue SyntaxError => e
+      case parse_context.error_mode
+      when :strict
+        raise
+      when :warn
+        parse_context.warnings << e
+      end
+      lax_parse(markup)
+    end
+
    def parse_with_selected_parser(markup)
-      parse_markup(markup)
+      case parse_context.error_mode
+      when :strict then strict_parse_with_error_context(markup)
+      when :lax    then lax_parse(markup)
+      when :warn
+        begin
+          strict_parse_with_error_context(markup)
+        rescue SyntaxError => e
+          parse_context.warnings << e
+          lax_parse(markup)
+        end
+      end
+    end
+
+    private
+
+    def strict_parse_with_error_context(markup)
+      strict_parse(markup)
    rescue SyntaxError => e
      e.line_number    = line_number
      e.markup_context = markup_context(markup)
      raise e
    end

-    private
-
    def markup_context(markup)
      "in \"#{markup.strip}\""
    end
@@ -3,29 +3,20 @@
 module Liquid
  class PartialCache
    def self.load(template_name, context:, parse_context:)
-      cached_partials = context.registers[:cached_partials]
-      cache_key = template_name.to_s
-      cached = cached_partials[cache_key]
+      cached_partials = (context.registers[:cached_partials] ||= {})
+      cached = cached_partials[template_name]
      return cached if cached

-      file_system = context.registers[:file_system]
+      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
      source      = file_system.read_template_file(template_name)

      parse_context.partial = true

-      template_factory = context.registers[:template_factory]
+      template_factory = (context.registers[:template_factory] ||= Liquid::TemplateFactory.new)
      template = template_factory.for(template_name)

-      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
+      partial = template.parse(source, parse_context)
+      cached_partials[template_name] = partial
    ensure
      parse_context.partial = false
    end
@@ -2,23 +2,13 @@

 module Liquid
  class RangeLookup
-    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)
+    def self.parse(start_markup, end_markup)
+      start_obj = Expression.parse(start_markup)
+      end_obj   = Expression.parse(end_markup)
      if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
        new(start_obj, end_obj)
      else
-        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
+        start_obj.to_i..end_obj.to_i
      end
    end

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Register
+  end
+end
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Registers
-    attr_reader :static
-
-    def initialize(registers = {})
-      @static = registers.is_a?(Registers) ? registers.static : registers
-      @changes = {}
-    end
-
-    def []=(key, value)
-      @changes[key] = value
-    end
-
-    def [](key)
-      if @changes.key?(key)
-        @changes[key]
-      else
-        @static[key]
-      end
-    end
-
-    def delete(key)
-      @changes.delete(key)
-    end
-
-    UNDEFINED = Object.new
-
-    def fetch(key, default = UNDEFINED, &block)
-      if @changes.key?(key)
-        @changes.fetch(key)
-      elsif default != UNDEFINED
-        if block_given?
-          @static.fetch(key, &block)
-        else
-          @static.fetch(key, default)
-        end
-      else
-        @static.fetch(key, &block)
-      end
-    end
-
-    def key?(key)
-      @changes.key?(key) || @static.key?(key)
-    end
-  end
-
-  # Alias for backwards compatibility
-  StaticRegisters = Registers
-end
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Liquid
+  class StaticRegisters
+    attr_reader :static
+
+    def initialize(registers = {})
+      @static    = registers.is_a?(StaticRegisters) ? registers.static : registers
+      @registers = {}
+    end
+
+    def []=(key, value)
+      @registers[key] = value
+    end
+
+    def [](key)
+      if @registers.key?(key)
+        @registers[key]
+      else
+        @static[key]
+      end
+    end
+
+    def delete(key)
+      @registers.delete(key)
+    end
+
+    UNDEFINED = Object.new
+
+    def fetch(key, default = UNDEFINED, &block)
+      if @registers.key?(key)
+        @registers.fetch(key)
+      elsif default != UNDEFINED
+        @static.fetch(key, default, &block)
+      else
+        @static.fetch(key, &block)
+      end
+    end
+
+    def key?(key)
+      @registers.key?(key) || @static.key?(key)
+    end
+  end
+end
@@ -0,0 +1,36 @@
+# 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
+      global_filters << filter
+    end
+
+    def create(context, filters = [])
+      strainer_from_cache(filters).new(context)
+    end
+
+    private
+
+    def global_filters
+      @global_filters ||= []
+    end
+
+    def strainer_from_cache(filters)
+      strainer_class_cache[filters] ||= begin
+        klass = Class.new(StrainerTemplate)
+        global_filters.each { |f| klass.add_filter(f) }
+        filters.each { |f| klass.add_filter(f) }
+        klass
+      end
+    end
+
+    def strainer_class_cache
+      @strainer_class_cache ||= {}
+    end
+  end
+end
@@ -31,15 +31,6 @@ module Liquid
        filter_methods.include?(method.to_s)
      end

-      def inherited(subclass)
-        super
-        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
@@ -1,11 +1,6 @@
 # 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
@@ -15,92 +10,40 @@ module Liquid
      @index  = 0
    end

-    # @liquid_public_docs
-    # @liquid_summary
-    #   The total number of iterations in the loop.
-    # @liquid_return [number]
-    attr_reader :length
+    attr_reader :length, :col, :row

-    # @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
@@ -1,8 +1,5 @@
 # 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
@@ -17,18 +14,12 @@ module Liquid
      end

      def disable_tags(*tag_names)
-        tag_names += disabled_tags
-        define_singleton_method(:disabled_tags) { tag_names }
+        @disabled_tags ||= []
+        @disabled_tags.concat(tag_names)
        prepend(Disabler)
      end

      private :new
-
-      protected
-
-      def disabled_tags
-        []
-      end
    end

    def initialize(tag_name, markup, parse_context)
@@ -57,8 +48,7 @@ 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)
-      render_result = render(context)
-      output << render_result if render_result
+      output << render(context)
      output
    end

@@ -68,12 +58,8 @@ module Liquid

    private

-    def safe_parse_expression(parser)
-      parse_context.safe_parse_expression(parser)
-    end
-
-    def parse_expression(markup, safe: false)
-      parse_context.parse_expression(markup, safe: safe)
+    def parse_expression(markup)
+      parse_context.parse_expression(markup)
    end
  end
 end
@@ -3,6 +3,14 @@
 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
@@ -1,49 +0,0 @@
-# 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
@@ -1,22 +1,14 @@
 # frozen_string_literal: true

 module Liquid
-  # @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.
+  # Assign sets a variable in your template.
+  #
+  #   {% assign foo = 'monkey' %}
+  #
+  # You can then use the variable later in the page.
+  #
+  #  {{ foo }}
  #
-  #   > 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
    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om

@@ -76,4 +68,6 @@ module Liquid
      end
    end
  end
+
+  Template.register_tag('assign', Assign)
 end
@@ -10,14 +10,6 @@ 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

@@ -26,4 +18,6 @@ module Liquid
      output
    end
  end
+
+  Template.register_tag('break', Break)
 end
@@ -1,24 +1,17 @@
 # frozen_string_literal: true

 module Liquid
-  # @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 stores the result of a block into a variable without rendering it inplace.
  #
-  #   > 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
+  #   {% capture heading %}
+  #     Monkeys!
  #   {% endcapture %}
-  # @liquid_syntax_keyword variable The name of the variable being created.
-  # @liquid_syntax_keyword value The value you want to assign to the variable.
+  #   ...
+  #   <h1>{{ heading }}</h1>
+  #
+  # Capture is useful for saving content for use later in your template, such as
+  # in a sidebar or footer.
+  #
  class Capture < Block
    Syntax = /(#{VariableSignature}+)/o

@@ -43,4 +36,6 @@ module Liquid
      true
    end
  end
+
+  Template.register_tag('capture', Capture)
 end
@@ -1,34 +1,21 @@
 # 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
+
    attr_reader :blocks, :left

    def initialize(tag_name, markup, options)
      super
      @blocks = []
-      parse_with_selected_parser(markup)
+
+      if markup =~ Syntax
+        @left = parse_expression(Regexp.last_match(1))
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.case")
+      end
    end

    def parse(tokens)
@@ -69,7 +56,7 @@ module Liquid
        end

        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context),
+          block.evaluate(context)
        )

        if result
@@ -83,31 +70,20 @@ module Liquid

    private

-    def parse_markup(markup)
-      parser = @parse_context.new_parser(markup)
-      @left = safe_parse_expression(parser)
-      parser.consume(:end_of_string)
-    end
-
    def record_when_condition(markup)
      body = new_body

-      parse_when(markup, body)
-    end
+      while markup
+        unless markup =~ WhenSyntax
+          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
+        end

-    def parse_when(markup, body)
-      parser = @parse_context.new_parser(markup)
+        markup = Regexp.last_match(2)

-      loop do
-        expr = Condition.parse_expression(parse_context, parser.expression, safe: true)
-        block = Condition.new(@left, '==', expr)
+        block = Condition.new(@left, '==', Condition.parse_expression(parse_context, Regexp.last_match(1)))
        block.attach(body)
        @blocks << block
-
-        break unless parser.id?('or') || parser.consume?(:comma)
      end
-
-      parser.consume(:end_of_string)
    end

    def record_else_condition(markup)
@@ -126,4 +102,6 @@ module Liquid
      end
    end
  end
+
+  Template.register_tag('case', Case)
 end
@@ -1,20 +1,20 @@
 # 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
+    # Potential fix
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*)?#{WhitespaceControl}?#{TagEnd}\z/om
+
+    def parse(tokens)
+      while (token = tokens.shift)
+        if token =~ FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
+          return
+        end
+      end
+
+      raise_tag_never_closed(block_name)
+    end
+
    def render_to_output_buffer(_context, output)
      output
    end
@@ -25,64 +25,7 @@ module Liquid
    def blank?
      true
    end
-
-    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
+
+  Template.register_tag('comment', Comment)
 end
@@ -1,14 +1,15 @@
 # frozen_string_literal: true

 module Liquid
-  # @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 %}
+  # Continue tag to be used to break out of a for loop.
+  #
+  # == Basic Usage:
+  #    {% for item in collection %}
+  #      {% if item.condition %}
+  #        {% continue %}
+  #      {% endif %}
+  #    {% endfor %}
+  #
  class Continue < Tag
    INTERRUPT = ContinueInterrupt.new.freeze

@@ -17,4 +18,6 @@ module Liquid
      output
    end
  end
+
+  Template.register_tag('continue', Continue)
 end
@@ -1,31 +1,36 @@
 # frozen_string_literal: true

 module Liquid
-  # @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.
+  # 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>
  #
-  #   > 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
-    UNNAMED_CYCLE_PATTERN = /\w+:0x\h{8}/
+    SimpleSyntax = /\A#{QuotedFragment}+/o
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om

    attr_reader :variables

    def initialize(tag_name, markup, options)
      super
-      parse_with_selected_parser(markup)
-    end
-
-    def named?
-      @is_named
+      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
    end

    def render_to_output_buffer(context, output)
@@ -53,51 +58,11 @@ module Liquid

    private

-    # cycle [name:] expression(, expression)*
-    def parse_markup(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
-
-    # 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
+    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
+      end.compact
    end

    class ParseTreeVisitor < Liquid::ParseTreeVisitor
@@ -106,4 +71,6 @@ module Liquid
      end
    end
  end
+
+  Template.register_tag('cycle', Cycle)
 end
@@ -1,42 +1,38 @@
 # frozen_string_literal: true

 module Liquid
-  # @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.
+  # 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++.
  #
-  #   > 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.
+  #     (To achieve the survival, the application must keep the context)
  #
-  #   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
-    attr_reader :variable_name
+  #     if the variable does not exist, it is created with value 0.

+  #   Hello: {% decrement variable %}
+  #
+  # gives you:
+  #
+  #    Hello: -1
+  #    Hello: -2
+  #    Hello: -3
+  #
+  class Decrement < Tag
    def initialize(tag_name, markup, options)
      super
-      @variable_name = markup.strip
+      @variable = markup.strip
    end

    def render_to_output_buffer(context, output)
-      counter_environment = context.environments.first
-      value = counter_environment[@variable_name] || 0
+      value = context.environments.first[@variable] ||= 0
      value -= 1
-      counter_environment[@variable_name] = value
+      context.environments.first[@variable] = value
      output << value.to_s
      output
    end
  end
+
+  Template.register_tag('decrement', Decrement)
 end
@@ -1,81 +0,0 @@
-# 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
@@ -1,39 +1,38 @@
 # frozen_string_literal: true

 module Liquid
-  # @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).
+  # 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 %}
  #
-  #   > 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

    def initialize(tag_name, markup, parse_context)
+      puts "Initializing Echo tag"
      super
      @variable = Variable.new(markup, parse_context)
    end

    def render(context)
+      puts "Render Echo tag"
      @variable.render_to_output_buffer(context, +'')
    end

    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      puts "ParseTreeVisitor Echo tag"
+
      def children
        [@node.variable]
      end
    end
  end
+
+  Template.register_tag('echo', Echo)
 end
@@ -1,30 +1,53 @@
 # frozen_string_literal: true

 module Liquid
-  # @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.
+  # "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.
  #
-  #   > 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
+
    attr_reader :collection_name, :variable_name, :limit, :from

    def initialize(tag_name, markup, options)
@@ -70,24 +93,38 @@ module Liquid

    protected

-    def parse_markup(markup)
-      p = @parse_context.new_parser(markup)
+    def lax_parse(markup)
+      if markup =~ Syntax
+        @variable_name   = Regexp.last_match(1)
+        collection_name  = Regexp.last_match(2)
+        @reversed        = !!Regexp.last_match(3)
+        @name            = "#{@variable_name}-#{collection_name}"
+        @collection_name = parse_expression(collection_name)
+        markup.scan(TagAttributes) do |key, value|
+          set_attribute(key, value)
+        end
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.for")
+      end
+    end
+
+    def strict_parse(markup)
+      p = Parser.new(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, safe: true)
+      @collection_name = parse_expression(collection_name)

      @name     = "#{@variable_name}-#{collection_name}"
      @reversed = p.id?('reversed')

-      while p.look(:comma) || p.look(:id)
-        p.consume?(:comma)
+      while p.look(:id) && p.look(:colon, 1)
        unless (attribute = p.id?('limit') || p.id?('offset'))
          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
        end
-        p.consume(:colon)
-        set_attribute(attribute, p.expression, safe: true)
+        p.consume
+        set_attribute(attribute, p.expression)
      end
      p.consume(:end_of_string)
    end
@@ -157,16 +194,17 @@ module Liquid
      output
    end

-    def set_attribute(key, expr, safe: false)
+    def set_attribute(key, expr)
      case key
      when 'offset'
        @from = if expr == 'continue'
+          Usage.increment('for_offset_continue')
          :continue
        else
-          parse_expression(expr, safe: safe)
+          parse_expression(expr)
        end
      when 'limit'
-        @limit = parse_expression(expr, safe: safe)
+        @limit = parse_expression(expr)
      end
    end

@@ -184,4 +222,6 @@ module Liquid
      end
    end
  end
+
+  Template.register_tag('for', For)
 end
@@ -1,19 +1,21 @@
 # frozen_string_literal: true

 module Liquid
-  # @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
+  # If is the conditional block
+  #
+  #   {% if user.admin %}
+  #     Admin user!
+  #   {% else %}
+  #     Not admin user
  #   {% endif %}
-  # @liquid_syntax_keyword condition The condition to evaluate.
-  # @liquid_syntax_keyword expression The expression to render if the condition is met.
+  #
+  #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
+  #
  class If < Block
+    Syntax                  = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
+    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
+    BOOLEAN_OPERATORS       = %w(and or).freeze
+
    attr_reader :blocks

    def initialize(tag_name, markup, options)
@@ -49,7 +51,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
@@ -73,12 +75,32 @@ module Liquid
      block.attach(new_body)
    end

-    def parse_expression(markup, safe: false)
-      Condition.parse_expression(parse_context, markup, safe: safe)
+    def parse_expression(markup)
+      Condition.parse_expression(parse_context, markup)
    end

-    def parse_markup(markup)
-      p = @parse_context.new_parser(markup)
+    def lax_parse(markup)
+      expressions = markup.scan(ExpressionsAndOperators)
+      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
+
+      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+
+      until expressions.empty?
+        operator = expressions.pop.to_s.strip
+
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
+
+        new_condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
+        new_condition.send(operator, condition)
+        condition = new_condition
+      end
+
+      condition
+    end
+
+    def strict_parse(markup)
+      p = Parser.new(markup)
      condition = parse_binary_comparisons(p)
      p.consume(:end_of_string)
      condition
@@ -87,7 +109,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
@@ -96,9 +118,9 @@ module Liquid
    end

    def parse_comparison(p)
-      a = parse_expression(p.expression, safe: true)
+      a = parse_expression(p.expression)
      if (op = p.consume?(:comparison))
-        b = parse_expression(p.expression, safe: true)
+        b = parse_expression(p.expression)
        Condition.new(a, op, b)
      else
        Condition.new(a)
@@ -111,4 +133,6 @@ module Liquid
      end
    end
  end
+
+  Template.register_tag('if', If)
 end
@@ -14,4 +14,6 @@ module Liquid
      output
    end
  end
+
+  Template.register_tag('ifchanged', Ifchanged)
 end
@@ -1,30 +1,48 @@
 # frozen_string_literal: true

 module Liquid
-  # @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.
+  # 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 %}
  #
-  #   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
+    Syntax = SYNTAX
+
    attr_reader :template_name_expr, :variable_name_expr, :attributes

    def initialize(tag_name, markup, options)
      super
-      parse_with_selected_parser(markup)
+
+      if markup =~ SYNTAX
+
+        template_name = Regexp.last_match(1)
+        variable_name = Regexp.last_match(3)
+
+        @alias_name         = Regexp.last_match(5)
+        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+        @template_name_expr = parse_expression(template_name)
+        @attributes         = {}
+
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = parse_expression(value)
+        end
+
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.include")
+      end
    end

    def parse(_tokens)
@@ -32,12 +50,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.is_a?(String)
+      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name

      partial = PartialCache.load(
        template_name,
        context: context,
-        parse_context: parse_context,
+        parse_context: parse_context
      )

      context_variable_name = @alias_name || template_name.split('/').last
@@ -50,11 +68,9 @@ module Liquid

      old_template_name = context.template_name
      old_partial       = context.partial
-
      begin
-        context.template_name = partial.name
-        context.partial = true
-
+        context.template_name = template_name
+        context.partial       = true
        context.stack do
          @attributes.each do |key, value|
            context[key] = context.evaluate(value)
@@ -81,26 +97,6 @@ module Liquid
    alias_method :parse_context, :options
    private :parse_context

-    def parse_markup(markup)
-      p = @parse_context.new_parser(markup)
-
-      @template_name_expr = safe_parse_expression(p)
-      @variable_name_expr = safe_parse_expression(p) if p.id?("for") || p.id?("with")
-      @alias_name         = p.consume(:id) if p.id?("as")
-
-      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
-
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [
@@ -110,4 +106,6 @@ module Liquid
      end
    end
  end
+
+  Template.register_tag('include', Include)
 end
@@ -1,42 +1,35 @@
 # frozen_string_literal: true

 module Liquid
-  # @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.
+  # 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)
  #
-  #   > 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.
+  #     if the variable does not exist, it is created with value 0.
+  #
+  #   Hello: {% increment variable %}
+  #
+  # gives you:
+  #
+  #    Hello: 0
+  #    Hello: 1
+  #    Hello: 2
  #
-  #   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
-    attr_reader :variable_name
-
    def initialize(tag_name, markup, options)
      super
-      @variable_name = markup.strip
+      @variable = markup.strip
    end

    def render_to_output_buffer(context, output)
-      counter_environment = context.environments.first
-      value = counter_environment[@variable_name] || 0
-      counter_environment[@variable_name] = value + 1
+      value = context.environments.first[@variable] ||= 0
+      context.environments.first[@variable] = value + 1

      output << value.to_s
      output
    end
  end
+
+  Template.register_tag('increment', Increment)
 end
@@ -1,28 +0,0 @@
-# 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
@@ -1,19 +1,9 @@
 # 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
@@ -24,8 +14,7 @@ module Liquid
    def parse(tokens)
      @body = +''
      while (token = tokens.shift)
-        if token =~ BlockBody::FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
-          parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
+        if token =~ FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
          return
        end
@@ -56,4 +45,6 @@ module Liquid
      end
    end
  end
+
+  Template.register_tag('raw', Raw)
 end
@@ -1,44 +1,32 @@
 # 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, :variable_name_expr, :attributes, :alias_name
+    attr_reader :template_name_expr, :attributes

    def initialize(tag_name, markup, options)
      super
-      parse_with_selected_parser(markup)
-    end

-    def for_loop?
-      @is_for_loop
+      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
    end

    def render_to_output_buffer(context, output)
@@ -46,21 +34,21 @@ module Liquid
    end

    def render_tag(context, output)
-      # The expression should be a String literal, which parses to a String object
-      template_name = @template_name_expr
-      raise ::ArgumentError unless template_name.is_a?(String)
+      # 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

      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 = partial.name
+        inner_context.template_name = template_name
        inner_context.partial       = true
        inner_context['forloop']    = forloop if forloop

@@ -73,7 +61,7 @@ module Liquid
      }

      variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
-      if @is_for_loop && variable.respond_to?(:each) && variable.respond_to?(:count)
+      if @for && 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
@@ -83,40 +71,14 @@ module Liquid
      output
    end

-    # render (string) (with|for expression)? (as id)? (key: value)*
-    def parse_markup(markup)
-      p = @parse_context.new_parser(markup)
-
-      @template_name_expr = parse_expression(template_name(p), safe: true)
-      with_or_for         = p.id?("for") || p.id?("with")
-      @variable_name_expr = safe_parse_expression(p) if with_or_for
-      @alias_name         = p.consume(:id) if p.id?("as")
-      @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 template_name(p)
-      p.consume(:string)
-    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
@@ -1,76 +1,35 @@
 # 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
-    ALLOWED_ATTRIBUTES = ['cols', 'limit', 'offset', 'range'].freeze
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o

    attr_reader :variable_name, :collection_name, :attributes

    def initialize(tag_name, markup, options)
      super
-      parse_with_selected_parser(markup)
-    end
-
-    def parse_markup(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)
+      if markup =~ Syntax
+        @variable_name   = Regexp.last_match(1)
+        @collection_name = parse_expression(Regexp.last_match(2))
+        @attributes      = {}
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = parse_expression(value)
        end
-
-        p.consume(:colon)
-        @attributes[key] = safe_parse_expression(p)
-        p.consume?(:comma)
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.table_row")
      end
-
-      p.consume(:end_of_string)
    end

    def render_to_output_buffer(context, output)
      (collection = context.evaluate(@collection_name)) || (return '')

-      from = @attributes.key?('offset') ? to_integer(context.evaluate(@attributes['offset'])) : 0
-      to = @attributes.key?('limit') ? from + to_integer(context.evaluate(@attributes['limit'])) : nil
+      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
+      to   = @attributes.key?('limit')  ? from + context.evaluate(@attributes['limit']).to_i : nil

      collection = Utils.slice_collection(collection, from, to)
      length     = collection.length

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

      output << "<tr class=\"row1\">\n"
      context.stack do
@@ -84,12 +43,6 @@ 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
@@ -107,13 +60,7 @@ module Liquid
        super + @node.attributes.values + [@node.collection_name]
      end
    end
-
-    private
-
-    def to_integer(value)
-      value.to_i
-    rescue NoMethodError
-      raise Liquid::ArgumentError, "invalid integer"
-    end
  end
+
+  Template.register_tag('tablerow', TableRow)
 end
@@ -3,27 +3,16 @@
 require_relative 'if'

 module Liquid
-  # @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.
+  # Unless is a conditional just like 'if' but works on the inverse logic.
+  #
+  #   {% unless x < 0 %} x is greater than zero {% endunless %}
+  #
  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
@@ -33,7 +22,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
@@ -44,4 +33,6 @@ module Liquid
      output
    end
  end
+
+  Template.register_tag('unless', Unless)
 end
@@ -2,7 +2,7 @@

 module Liquid
  # Templates are central to liquid.
-  # Interpreting templates is a two step process. First you compile the
+  # Interpretating templates is a two step process. First you compile the
  # source code you got. During compile time some extensive error checking is performed.
  # your code should expect to get some SyntaxErrors.
  #
@@ -15,80 +15,98 @@ module Liquid
  #   template.render('user_name' => 'bob')
  #
  class Template
-    attr_accessor :root, :name
-    attr_reader :resource_limits
+    attr_accessor :root
+    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
-      def default_exception_renderer=(renderer)
-        Deprecations.warn("Template.default_exception_renderer=", "Environment#exception_renderer=")
-        Environment.default.exception_renderer = renderer
+      # 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
      end

-      def default_exception_renderer
-        Environment.default.exception_renderer
-      end
+      attr_accessor :file_system
+      Template.file_system = BlankFileSystem.new

-      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
+      attr_accessor :tags
+      Template.tags = TagRegistry.new
+      private :tags=

      def register_tag(name, klass)
-        Deprecations.warn("Template.register_tag", "Environment#register_tag")
-        Environment.default.register_tag(name, klass)
+        tags[name.to_s] = 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)
-        Deprecations.warn("Template.register_filter", "Environment#register_filter")
-        Environment.default.register_filter(mod)
+        StrainerFactory.add_global_filter(mod)
      end

-      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
+      attr_accessor :default_resource_limits
+      Template.default_resource_limits = {}
+      private :default_resource_limits=

      # 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 = {})
-        environment = options[:environment] || Environment.default
-        new(environment: environment).parse(source, options)
+        new.parse(source, options)
      end
    end

-    def initialize(environment: Environment.default)
-      @environment = environment
+    def initialize
      @rethrow_errors  = false
-      @resource_limits = ResourceLimits.new(environment.default_resource_limits)
+      @resource_limits = ResourceLimits.new(Template.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
@@ -138,25 +156,26 @@ module Liquid
        c
      when Liquid::Drop
        drop         = args.shift
-        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
+        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
      when Hash
-        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
      when nil
-        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
      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|
-          static_registers[key] = register
+          context_register[key] = register
        end

        apply_options_to_context(context, options)
@@ -171,8 +190,6 @@ module Liquid
        @profiler = context.profiler = Liquid::Profiler.new
      end

-      context.template_name ||= name
-
      begin
        # render the nodelist.
        @root.render_to_output_buffer(context, output || +'')
@@ -202,13 +219,8 @@ module Liquid
      @options      = options
      @profiling    = profiling
      @line_numbers = options[:line_numbers] || @profiling
-      parse_context = if options.is_a?(ParseContext)
-        options
-      else
-        opts = options.key?(:environment) ? options : options.merge(environment: @environment)
-        ParseContext.new(opts)
-      end
-
+      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
+      @warnings     = parse_context.warnings
      parse_context
    end

@@ -1,45 +1,18 @@
 # frozen_string_literal: true

-require "strscan"
-
 module Liquid
  class Tokenizer
    attr_reader :line_number, :for_liquid_tag

-    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)
+    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)
      @for_liquid_tag = for_liquid_tag
-      @source = source.to_s.to_str
-      @offset = 0
-      @tokens = []
-
-      if @source
-        @ss = string_scanner
-        @ss.string = @source
-        tokenize
-      end
+      @tokens         = tokenize
    end

    def shift
-      token = @tokens[@offset]
-
-      return unless token
-
-      @offset += 1
+      (token = @tokens.shift) || return

      if @line_number
        @line_number += @for_liquid_tag ? 1 : token.count("\n")
@@ -51,111 +24,16 @@ module Liquid
    private

    def tokenize
-      if @for_liquid_tag
-        @tokens = @source.split("\n")
-      else
-        @tokens << shift_normal until @ss.eos?
-      end
+      return [] if @source.empty?

-      @source = nil
-      @ss = nil
-    end
+      return @source.split("\n") if @for_liquid_tag

-    def shift_normal
-      token = next_token
+      tokens = @source.split(TemplateParser)

-      return unless token
+      # removes the rogue empty element at the beginning of the array
+      tokens.shift if tokens[0]&.empty?

-      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)
+      tokens
    end
  end
 end
@@ -2,9 +2,6 @@

 module Liquid
  module Utils
-    DECIMAL_REGEX = /\A-?\d+\.\d+\z/
-    UNIX_TIMESTAMP_REGEX = /\A\d+\z/
-
    def self.slice_collection(collection, from, to)
      if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
        collection.load_slice(from, to)
@@ -55,7 +52,7 @@ module Liquid
      when Numeric
        obj
      when String
-        DECIMAL_REGEX.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
      else
        if obj.respond_to?(:to_number)
          obj.to_number
@@ -69,14 +66,14 @@ module Liquid
      return obj if obj.respond_to?(:strftime)

      if obj.is_a?(String)
-        return if obj.empty?
+        return nil if obj.empty?
        obj = obj.downcase
      end

      case obj
      when 'now', 'today'
        Time.now
-      when UNIX_TIMESTAMP_REGEX, Integer
+      when /\A\d+\z/, Integer
        Time.at(obj.to_i)
      when String
        Time.parse(obj)
@@ -92,103 +89,5 @@ 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
@@ -30,7 +30,7 @@ module Liquid
      @parse_context = parse_context
      @line_number   = parse_context.line_number

-      parse_with_selected_parser(markup)
+      strict_parse_with_error_mode_fallback(markup)
    end

    def raw
@@ -41,17 +41,47 @@ module Liquid
      "in \"{{#{markup}}}\""
    end

-    def parse_markup(markup)
+    def lax_parse(markup)
      @filters = []
-      p = @parse_context.new_parser(markup)
+      return unless markup =~ MarkupWithQuotedFragment
+
+      name_markup   = Regexp.last_match(1)
+      filter_markup = Regexp.last_match(2)
+      @name         = Expression.parse(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)
+        end
+      end
+    end
+
+    def strict_parse(markup)
+      @filters = []
+      p = Parser.new(markup)

      return if p.look(:end_of_string)

-      @name = parse_context.safe_parse_expression(p)
-      @filters << parse_filter_expressions(p) while p.consume?(:pipe)
+      @name = Expression.parse(p.expression)
+      while p.consume?(:pipe)
+        filtername = p.consume(:id)
+        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
+        @filters << parse_filter_expressions(filtername, filterargs)
+      end
      p.consume(:end_of_string)
    end

+    def parse_filterargs(p)
+      # first argument
+      filterargs = [p.argument]
+      # followed by comma separated others
+      filterargs << p.argument while p.consume?(:comma)
+      filterargs
+    end
+
    def render(context)
      obj = context.evaluate(@name)

@@ -65,21 +95,15 @@ module Liquid

    def render_to_output_buffer(context, output)
      obj = render(context)
-      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
+      if obj.is_a?(Array)
+        output << obj.join
+      elsif obj.nil?
      else
-        output << Liquid::Utils.to_s(obj)
+        output << obj.to_s
      end
+
+      output
    end

    def disabled?(_context)
@@ -92,46 +116,22 @@ module Liquid

    private

-    # 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 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)
+    def 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])
+        else
+          filter_args << Expression.parse(a)
+        end
      end
-
-      result = [filtername, filter_args]
-      result << keyword_args unless keyword_args.empty?
+      result = [filter_name, filter_args]
+      result << keyword_args if keyword_args
      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
@@ -2,24 +2,21 @@

 module Liquid
  class VariableLookup
-    COMMAND_METHODS = ['size', 'first', 'last'].freeze
+    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
+    COMMAND_METHODS  = ['size', 'first', 'last'].freeze

    attr_reader :name, :lookups

-    def self.parse(markup, string_scanner = StringScanner.new(""), cache = nil)
-      new(markup, string_scanner, cache)
+    def self.parse(markup)
+      new(markup)
    end

-    def initialize(markup, string_scanner = StringScanner.new(""), cache = nil)
+    def initialize(markup)
      lookups = markup.scan(VariableParser)

      name = lookups.shift
-      if name&.start_with?('[') && name&.end_with?(']')
-        name = Expression.parse(
-          name[1..-2],
-          string_scanner,
-          cache,
-        )
+      if name =~ SQUARE_BRACKETED
+        name = Expression.parse(Regexp.last_match(1))
      end
      @name = name

@@ -28,22 +25,14 @@ module Liquid

      @lookups.each_index do |i|
        lookup = lookups[i]
-        if lookup&.start_with?('[') && lookup&.end_with?(']')
-          lookups[i] = Expression.parse(
-            lookup[1..-2],
-            string_scanner,
-            cache,
-          )
+        if lookup =~ SQUARE_BRACKETED
+          lookups[i] = Expression.parse(Regexp.last_match(1))
        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)
@@ -67,14 +56,9 @@ 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 lookup_command?(i) && object.respond_to?(key)
+        elsif @command_flags & (1 << i) != 0 && object.respond_to?(key)
          object = object.send(key).to_liquid

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

 module Liquid
-  VERSION = "5.11.0"
+  VERSION = "5.1.0"
 end
@@ -13,24 +13,22 @@ 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    = "https://shopify.github.io/liquid/"
+  s.homepage    = "http://www.liquidmarkup.org"
  s.license     = "MIT"
  # s.description = "A secure, non-evaling end user template engine with aesthetic markup."

-  s.required_ruby_version     = ">= 3.0.0"
+  s.required_ruby_version     = ">= 2.5.0"
  s.required_rubygems_version = ">= 1.3.7"

  s.metadata['allowed_push_host'] = 'https://rubygems.org'

-  s.files = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
+  s.test_files  = Dir.glob("{test}/**/*")
+  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
@@ -3,22 +3,18 @@
 require 'benchmark/ips'
 require_relative 'theme_runner'

-RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
-
+Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new

 Benchmark.ips do |x|
-  x.time   = 20
-  x.warmup = 10
+  x.time   = 10
+  x.warmup = 5

  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"
+  x.report("parse:") { profiler.compile }
+  x.report("render:") { profiler.render }
+  x.report("parse & render:") { profiler.run }
 end
@@ -53,6 +53,8 @@ class Profiler
  end
 end

+Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
+
 runner = ThemeRunner.new
 Profiler.run do |x|
  x.profile('parse') { runner.compile }
@@ -3,6 +3,7 @@
 require 'stackprof'
 require_relative 'theme_runner'

+Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run

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

-default_environment = Liquid::Environment.default
-default_environment.register_tag('paginate', Paginate)
-default_environment.register_tag('form', CommentForm)
+Liquid::Template.register_tag('paginate', Paginate)
+Liquid::Template.register_tag('form', CommentForm)

-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)
+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)
@@ -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)  if 1 < current_page
-      pagination['next']       = link('Next &raquo;', current_page + 1)      if page_count > current_page + 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['parts']      = []

      hellip_break = false
@@ -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 synthetic as possible. All templates and tests are lifted from
+# All this is to make the benchmark as non syntetic 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,19 +48,6 @@ 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|
@@ -1,94 +0,0 @@
-# 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
@@ -1,43 +0,0 @@
-# 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
@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-# Liquid Spec Adapter for Shopify/liquid (Ruby reference implementation)
-#
-# Run with: bundle exec liquid-spec run spec/ruby_liquid.rb
-
-$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
-require 'liquid'
-
-LiquidSpec.configure do |config|
-  # Run core Liquid specs
-  config.features = [:core]
-end
-
-# Compile a template string into a Liquid::Template
-LiquidSpec.compile do |ctx, source, options|
-  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],
-  )
-
-  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-
-  ctx[:template].render(context)
-end
@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-# Liquid Spec Adapter for Shopify/liquid with ActiveSupport loaded
-#
-# Run with: bundle exec liquid-spec run spec/ruby_liquid_with_active_support.rb
-
-$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
-require 'active_support/all'
-require 'liquid'
-
-LiquidSpec.configure do |config|
-  # Run core Liquid specs plus ActiveSupport SafeBuffer tests
-  config.features = [:core, :activesupport]
-end
-
-# Compile a template string into a Liquid::Template
-LiquidSpec.compile do |ctx, source, options|
-  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],
-  )
-
-  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-
-  ctx[:template].render(context)
-end
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-# Liquid Spec Adapter for Shopify/liquid with YJIT + 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'
-
-LiquidSpec.configure do |config|
-  config.features = [:core, :activesupport]
-end
-
-# Compile a template string into a Liquid::Template
-LiquidSpec.compile do |ctx, source, 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],
-  )
-
-  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-
-  ctx[:template].render(context)
-end
@@ -6,49 +6,51 @@ class AssignTest < Minitest::Test
  include Liquid

  def test_assign_with_hyphen_in_variable_name
-    template_source = <<~END_TEMPLATE
-      {% assign this-thing = 'Print this-thing' -%}
-      {{ this-thing -}}
+    template_source = <<-END_TEMPLATE
+    {% assign this-thing = 'Print this-thing' %}
+    {{ this-thing }}
    END_TEMPLATE
-    assert_template_result("Print this-thing", template_source)
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("Print this-thing", rendered.strip)
  end

  def test_assigned_variable
-    assert_template_result(
-      '.foo.',
+    assert_template_result('.foo.',
      '{% assign foo = values %}.{{ foo[0] }}.',
-      { 'values' => %w(foo bar baz) },
-    )
+      'values' => %w(foo bar baz))

-    assert_template_result(
-      '.bar.',
+    assert_template_result('.bar.',
      '{% assign foo = values %}.{{ foo[1] }}.',
-      { 'values' => %w(foo bar baz) },
-    )
+      'values' => %w(foo bar baz))
  end

  def test_assign_with_filter
-    assert_template_result(
-      '.bar.',
+    assert_template_result('.bar.',
      '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
-      { 'values' => "foo,bar,baz" },
-    )
+      'values' => "foo,bar,baz")
  end

  def test_assign_syntax_error
-    assert_match_syntax_error(/assign/, '{% assign foo not values %}.')
+    assert_match_syntax_error(/assign/,
+      '{% assign foo not values %}.',
+      'values' => "foo,bar,baz")
  end

-  def test_assign_throws_on_unsupported_syntax
-    assert_match_syntax_error(
-      "Expected dotdot but found pipe",
-      "{% assign foo = ('X' | downcase) %}",
-    )
+  def test_assign_uses_error_mode
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        Template.parse("{% assign foo = ('X' | downcase) %}")
+      end
+    end
+    with_error_mode(:lax) do
+      assert(Template.parse("{% assign foo = ('X' | downcase) %}"))
+    end
  end

  def test_expression_with_whitespace_in_square_brackets
    source = "{% assign r = a[ 'b' ] %}{{ r }}"
-    assert_template_result('result', source, { 'a' => { 'b' => 'result' } })
+    assert_template_result('result', source, 'a' => { 'b' => 'result' })
  end

  def test_assign_score_exceeding_resource_limit
@@ -9,6 +9,12 @@ class FoobarTag < Liquid::Tag
  end
 end

+class BlankTestFileSystem
+  def read_template_file(template_path)
+    template_path
+  end
+end
+
 class BlankTest < Minitest::Test
  include Liquid
  N = 10
@@ -27,7 +33,7 @@ class BlankTest < Minitest::Test

  def test_new_tags_are_not_blank_by_default
    with_custom_tag('foobar', FoobarTag) do
-      assert_equal(" " * N, Liquid::Template.parse(wrap_in_for("{% foobar %}")).render!)
+      assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
    end
  end

@@ -57,11 +63,9 @@ class BlankTest < Minitest::Test

  def test_nested_blocks_are_blank_but_only_if_all_children_are
    assert_template_result("", wrap(wrap(" ")))
-    assert_template_result(
-      "\n       but this is not " * (N + 1),
+    assert_template_result("\n       but this is not " * (N + 1),
      wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
-      {% if true %} but this is not {% endif %}'),
-    )
+      {% if true %} but this is not {% endif %}'))
  end

  def test_assigns_are_blank
@@ -91,21 +95,10 @@ class BlankTest < Minitest::Test
  end

  def test_include_is_blank
-    assert_template_result(
-      "foobar" * (N + 1),
-      wrap("{% include 'foobar' %}"),
-      partials: { 'foobar' => 'foobar' },
-    )
-    assert_template_result(
-      " foobar " * (N + 1),
-      wrap("{% include ' foobar ' %}"),
-      partials: { ' foobar ' => ' foobar ' },
-    )
-    assert_template_result(
-      "   " * (N + 1),
-      wrap(" {% include ' ' %} "),
-      partials: { ' ' => ' ' },
-    )
+    Liquid::Template.file_system = BlankTestFileSystem.new
+    assert_template_result("foobar" * (N + 1), wrap("{% include 'foobar' %}"))
+    assert_template_result(" foobar " * (N + 1), wrap("{% include ' foobar ' %}"))
+    assert_template_result("   " * (N + 1), wrap(" {% include ' ' %} "))
  end

  def test_case_is_blank
@@ -6,8 +6,10 @@ class BlockTest < Minitest::Test
  include Liquid

  def test_unexpected_end_tag
-    source = '{% if true %}{% endunless %}'
-    assert_match_syntax_error("Liquid syntax error (line 1): 'endunless' is not a valid delimiter for if tags. use endif", source)
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% if true %}{% endunless %}")
+    end
+    assert_equal(exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif")
  end

  def test_with_custom_tag
@@ -10,38 +10,44 @@ class CaptureTest < Minitest::Test
  end

  def test_capture_with_hyphen_in_variable_name
-    template_source = <<~END_TEMPLATE
-      {% capture this-thing %}Print this-thing{% endcapture -%}
-      {{ this-thing -}}
+    template_source = <<-END_TEMPLATE
+    {% capture this-thing %}Print this-thing{% endcapture %}
+    {{ this-thing }}
    END_TEMPLATE
-    assert_template_result("Print this-thing", template_source)
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("Print this-thing", rendered.strip)
  end

  def test_capture_to_variable_from_outer_scope_if_existing
-    template_source = <<~END_TEMPLATE
-      {% assign var = '' -%}
-      {% if true -%}
-        {% capture var %}first-block-string{% endcapture -%}
-      {% endif -%}
-      {% if true -%}
-        {% capture var %}test-string{% endcapture -%}
-      {% endif -%}
-      {{var-}}
+    template_source = <<-END_TEMPLATE
+    {% assign var = '' %}
+    {% if true %}
+    {% capture var %}first-block-string{% endcapture %}
+    {% endif %}
+    {% if true %}
+    {% capture var %}test-string{% endcapture %}
+    {% endif %}
+    {{var}}
    END_TEMPLATE
-    assert_template_result("test-string", template_source)
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("test-string", rendered.gsub(/\s/, ''))
  end

  def test_assigning_from_capture
-    template_source = <<~END_TEMPLATE
-      {% assign first = '' -%}
-      {% assign second = '' -%}
-      {% for number in (1..3) -%}
-        {% capture first %}{{number}}{% endcapture -%}
-        {% assign second = first -%}
-      {% endfor -%}
-      {{ first }}-{{ second -}}
+    template_source = <<-END_TEMPLATE
+    {% assign first = '' %}
+    {% assign second = '' %}
+    {% for number in (1..3) %}
+    {% capture first %}{{number}}{% endcapture %}
+    {% assign second = first %}
+    {% endfor %}
+    {{ first }}-{{ second }}
    END_TEMPLATE
-    assert_template_result("3-3", template_source)
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("3-3", rendered.gsub(/\s/, ''))
  end

  def test_increment_assign_score_by_bytes_not_characters
@@ -24,7 +24,7 @@ class ContextSensitiveDrop < Liquid::Drop
  end
 end

-class Category
+class Category < Liquid::Drop
  attr_accessor :name

  def initialize(name)
@@ -36,27 +36,8 @@ class Category
  end
 end

-class ProductsDrop < Liquid::Drop
-  def initialize(products)
-    @products = products
-  end
-
-  def size
-    @products.size
-  end
-
-  def to_liquid
-    if @context["forloop"]
-      @products.first(@context["forloop"].length)
-    else
-      @products
-    end
-  end
-end
-
-class CategoryDrop < Liquid::Drop
+class CategoryDrop
  attr_accessor :category, :context
-
  def initialize(category)
    @category = category
  end
@@ -120,7 +101,7 @@ class ContextTest < Minitest::Test
  end

  def test_variables_not_existing
-    assert_template_result("true", "{% if does_not_exist == nil %}true{% endif %}")
+    assert_nil(@context['does_not_exist'])
  end

  def test_scoping
@@ -139,27 +120,22 @@ class ContextTest < Minitest::Test
  end

  def test_length_query
-    assert_template_result(
-      "true",
-      "{% if numbers.size == 4 %}true{% endif %}",
-      { "numbers" => [1, 2, 3, 4] },
-    )
+    @context['numbers'] = [1, 2, 3, 4]

-    assert_template_result(
-      "true",
-      "{% if numbers.size == 4 %}true{% endif %}",
-      { "numbers" => { 1 => 1, 2 => 2, 3 => 3, 4 => 4 } },
-    )
+    assert_equal(4, @context['numbers.size'])

-    assert_template_result(
-      "true",
-      "{% if numbers.size == 1000 %}true{% endif %}",
-      { "numbers" => { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 } },
-    )
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
+
+    assert_equal(4, @context['numbers.size'])
+
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
+
+    assert_equal(1000, @context['numbers.size'])
  end

  def test_hyphenated_variable
-    assert_template_result("godz", "{{ oh-my }}", { "oh-my" => 'godz' })
+    @context['oh-my'] = 'godz'
+    assert_equal('godz', @context['oh-my'])
  end

  def test_add_filter
@@ -211,24 +187,24 @@ class ContextTest < Minitest::Test
  end

  def test_hierachical_data
-    assigns = { 'hash' => { "name" => 'tobi' } }
-    assert_template_result("tobi", "{{ hash.name }}", assigns)
-    assert_template_result("tobi", '{{ hash["name"] }}', assigns)
+    @context['hash'] = { "name" => 'tobi' }
+    assert_equal('tobi', @context['hash.name'])
+    assert_equal('tobi', @context['hash["name"]'])
  end

  def test_keywords
-    assert_template_result("pass", "{% if true == expect %}pass{% endif %}", { "expect" => true })
-    assert_template_result("pass", "{% if false == expect %}pass{% endif %}", { "expect" => false })
+    assert_equal(true, @context['true'])
+    assert_equal(false, @context['false'])
  end

  def test_digits
-    assert_template_result("pass", "{% if 100 == expect %}pass{% endif %}", { "expect" => 100 })
-    assert_template_result("pass", "{% if 100.00 == expect %}pass{% endif %}", { "expect" => 100.00 })
+    assert_equal(100, @context['100'])
+    assert_equal(100.00, @context['100.00'])
  end

  def test_strings
-    assert_template_result("hello!", '{{ "hello!" }}')
-    assert_template_result("hello!", "{{ 'hello!' }}")
+    assert_equal("hello!", @context['"hello!"'])
+    assert_equal("hello!", @context["'hello!'"])
  end

  def test_merge
@@ -240,92 +216,99 @@ class ContextTest < Minitest::Test
  end

  def test_array_notation
-    assigns = { "test" => ["a", "b"] }
-    assert_template_result("a", "{{ test[0] }}", assigns)
-    assert_template_result("b", "{{ test[1] }}", assigns)
-    assert_template_result("pass", "{% if test[2] == nil %}pass{% endif %}", assigns)
+    @context['test'] = [1, 2, 3, 4, 5]
+
+    assert_equal(1, @context['test[0]'])
+    assert_equal(2, @context['test[1]'])
+    assert_equal(3, @context['test[2]'])
+    assert_equal(4, @context['test[3]'])
+    assert_equal(5, @context['test[4]'])
  end

  def test_recoursive_array_notation
-    assigns = { "test" => { 'test' => [1, 2, 3, 4, 5] } }
-    assert_template_result("1", "{{ test.test[0] }}", assigns)
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }

-    assigns = { "test" => [{ 'test' => 'worked' }] }
-    assert_template_result("worked", "{{ test[0].test }}", assigns)
+    assert_equal(1, @context['test.test[0]'])
+
+    @context['test'] = [{ 'test' => 'worked' }]
+
+    assert_equal('worked', @context['test[0].test'])
  end

  def test_hash_to_array_transition
-    assigns = {
-      'colors' => {
-        'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
-        'Green' => ['003300', '336633', '669966', '99CC99'],
-        'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
-        'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
-      },
+    @context['colors'] = {
+      'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
+      'Green' => ['003300', '336633', '669966', '99CC99'],
+      'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
+      'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
    }

-    assert_template_result("003366", "{{ colors.Blue[0] }}", assigns)
-    assert_template_result("FF9999", "{{ colors.Red[3] }}", assigns)
+    assert_equal('003366', @context['colors.Blue[0]'])
+    assert_equal('FF9999', @context['colors.Red[3]'])
  end

  def test_try_first
-    assigns = { 'test' => [1, 2, 3, 4, 5] }
-    assert_template_result("1", "{{ test.first }}", assigns)
-    assert_template_result("pass", "{% if test.last == 5 %}pass{% endif %}", assigns)
+    @context['test'] = [1, 2, 3, 4, 5]

-    assigns = { "test" => { "test" => [1, 2, 3, 4, 5] } }
-    assert_template_result("1", "{{ test.test.first }}", assigns)
-    assert_template_result("5", "{{ test.test.last }}", assigns)
+    assert_equal(1, @context['test.first'])
+    assert_equal(5, @context['test.last'])

-    assigns = { "test" => [1] }
-    assert_template_result("1", "{{ test.first }}", assigns)
-    assert_template_result("1", "{{ test.last }}", assigns)
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
+
+    assert_equal(1, @context['test.test.first'])
+    assert_equal(5, @context['test.test.last'])
+
+    @context['test'] = [1]
+    assert_equal(1, @context['test.first'])
+    assert_equal(1, @context['test.last'])
  end

  def test_access_hashes_with_hash_notation
-    assigns = { 'products' => { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] } }
-    assert_template_result("5", '{{ products["count"] }}', assigns)
-    assert_template_result("deepsnow", '{{ products["tags"][0] }}', assigns)
-    assert_template_result("deepsnow", '{{ products["tags"].first }}', assigns)
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @context['product']  = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }

-    assigns = { 'product' => { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] } }
-    assert_template_result("draft151cm", '{{ product["variants"][0]["title"] }}', assigns)
-    assert_template_result("element151cm", '{{ product["variants"][1]["title"] }}', assigns)
-    assert_template_result("draft151cm", '{{ product["variants"].first["title"] }}', assigns)
-    assert_template_result("element151cm", '{{ product["variants"].last["title"] }}', assigns)
+    assert_equal(5, @context['products["count"]'])
+    assert_equal('deepsnow', @context['products["tags"][0]'])
+    assert_equal('deepsnow', @context['products["tags"].first'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"][1]["title"]'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"].last["title"]'])
  end

  def test_access_variable_with_hash_notation
-    assert_template_result('baz', '{{ ["foo"] }}', { "foo" => "baz" })
-    assert_template_result('baz', '{{ [bar] }}', { 'foo' => 'baz', 'bar' => 'foo' })
+    @context['foo'] = 'baz'
+    @context['bar'] = 'foo'
+
+    assert_equal('baz', @context['["foo"]'])
+    assert_equal('baz', @context['[bar]'])
  end

  def test_access_hashes_with_hash_access_variables
-    assigns = {
-      'var' => 'tags',
-      'nested' => { 'var' => 'tags' },
-      'products' => { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] },
-    }
+    @context['var']      = 'tags'
+    @context['nested']   = { 'var' => 'tags' }
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }

-    assert_template_result('deepsnow', '{{ products[var].first }}', assigns)
-    assert_template_result('freestyle', '{{ products[nested.var].last }}', assigns)
+    assert_equal('deepsnow', @context['products[var].first'])
+    assert_equal('freestyle', @context['products[nested.var].last'])
  end

  def test_hash_notation_only_for_hash_access
-    assigns = { "array" => [1, 2, 3, 4, 5] }
-    assert_template_result("1", "{{ array.first }}", assigns)
-    assert_template_result("pass", '{% if array["first"] == nil %}pass{% endif %}', assigns)
+    @context['array'] = [1, 2, 3, 4, 5]
+    @context['hash']  = { 'first' => 'Hello' }

-    assert_template_result("Hello", '{{ hash["first"] }}', { "hash" => { "first" => "Hello" } })
+    assert_equal(1, @context['array.first'])
+    assert_nil(@context['array["first"]'])
+    assert_equal('Hello', @context['hash["first"]'])
  end

  def test_first_can_appear_in_middle_of_callchain
-    assigns = { "product" => { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] } }
+    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }

-    assert_template_result('draft151cm', '{{ product.variants[0].title }}', assigns)
-    assert_template_result('element151cm', '{{ product.variants[1].title }}', assigns)
-    assert_template_result('draft151cm', '{{ product.variants.first.title }}', assigns)
-    assert_template_result('element151cm', '{{ product.variants.last.title }}', assigns)
+    assert_equal('draft151cm', @context['product.variants[0].title'])
+    assert_equal('element151cm', @context['product.variants[1].title'])
+    assert_equal('draft151cm', @context['product.variants.first.title'])
+    assert_equal('element151cm', @context['product.variants.last.title'])
  end

  def test_cents
@@ -367,12 +350,10 @@ class ContextTest < Minitest::Test
  end

  def test_ranges
-    assert_template_result("1..5", '{{ (1..5) }}')
-    assert_template_result("pass", '{% if (1..5) == expect %}pass{% endif %}', { "expect" => (1..5) })
-
-    assigns = { "test" => '5' }
-    assert_template_result("1..5", "{{ (1..test) }}", assigns)
-    assert_template_result("5..5", "{{ (test..test) }}", assigns)
+    @context.merge("test" => '5')
+    assert_equal((1..5), @context['(1..5)'])
+    assert_equal((1..5), @context['(1..test)'])
+    assert_equal((5..5), @context['(test..test)'])
  end

  def test_cents_through_drop_nestedly
@@ -424,45 +405,45 @@ class ContextTest < Minitest::Test
  end

  def test_lambda_is_called_once
-    @global = 0
-
    @context['callcount'] = proc {
-      @global += 1
+      @global ||= 0
+      @global  += 1
      @global.to_s
    }

    assert_equal('1', @context['callcount'])
    assert_equal('1', @context['callcount'])
    assert_equal('1', @context['callcount'])
+
+    @global = nil
  end

  def test_nested_lambda_is_called_once
-    @global = 0
-
-    @context['callcount'] = {
-      "lambda" => proc {
-                    @global += 1
-                    @global.to_s
-                  },
-    }
+    @context['callcount'] = { "lambda" => proc {
+                                            @global ||= 0
+                                            @global  += 1
+                                            @global.to_s
+                                          } }

    assert_equal('1', @context['callcount.lambda'])
    assert_equal('1', @context['callcount.lambda'])
    assert_equal('1', @context['callcount.lambda'])
+
+    @global = nil
  end

  def test_lambda_in_array_is_called_once
-    @global = 0
-
-    p = proc {
-      @global += 1
-      @global.to_s
-    }
-    @context['callcount'] = [1, 2, p, 4, 5]
+    @context['callcount'] = [1, 2, proc {
+                                     @global ||= 0
+                                     @global  += 1
+                                     @global.to_s
+                                   }, 4, 5]

    assert_equal('1', @context['callcount[2]'])
    assert_equal('1', @context['callcount[2]'])
    assert_equal('1', @context['callcount[2]'])
+
+    @global = nil
  end

  def test_access_to_context_from_proc
@@ -505,7 +486,7 @@ class ContextTest < Minitest::Test
  def test_static_environments_are_read_with_lower_priority_than_environments
    context = Context.build(
      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
-      environments: { 'shadowed' => 'dynamic' },
+      environments: { 'shadowed' => 'dynamic' }
    )

    assert_equal('dynamic', context['shadowed'])
@@ -550,7 +531,7 @@ class ContextTest < Minitest::Test
    registers = {
      my_register: :my_value,
    }
-    super_context = Context.new({}, {}, Registers.new(registers))
+    super_context = Context.new({}, {}, StaticRegisters.new(registers))
    super_context.registers[:my_register] = :my_alt_value
    subcontext                            = super_context.new_isolated_subcontext
    assert_equal(:my_value, subcontext.registers[:my_register])
@@ -632,74 +613,13 @@ class ContextTest < Minitest::Test
  end

  def test_has_key_will_not_add_an_error_for_missing_keys
-    context = Context.new
-    context.key?('unknown')
-    assert_empty(context.errors)
-  end
-
-  def test_key_lookup_will_raise_for_missing_keys_when_strict_variables_is_enabled
-    context = Context.new
-    context.strict_variables = true
-    assert_raises(Liquid::UndefinedVariable) do
-      context['unknown']
+    with_error_mode(:strict) do
+      context = Context.new
+      context.key?('unknown')
+      assert_empty(context.errors)
    end
  end

-  def test_has_key_will_not_raise_for_missing_keys_when_strict_variables_is_enabled
-    context = Context.new
-    context.strict_variables = true
-    refute(context.key?('unknown'))
-    assert_empty(context.errors)
-  end
-
-  def test_context_always_uses_static_registers
-    registers = {
-      my_register: :my_value,
-    }
-    c = Context.new({}, {}, registers)
-    assert_instance_of(Registers, c.registers)
-    assert_equal(:my_value, c.registers[:my_register])
-
-    r = Registers.new(registers)
-    c = Context.new({}, {}, r)
-    assert_instance_of(Registers, c.registers)
-    assert_equal(:my_value, c.registers[:my_register])
-  end
-
-  def test_variable_to_liquid_returns_contextual_drop
-    context = {
-      "products" => ProductsDrop.new(["A", "B", "C", "D", "E"]),
-    }
-
-    template = Liquid::Template.parse(<<~LIQUID)
-      {%- for i in (1..3) -%}
-        for_loop_products_count: {{ products | size }}
-      {% endfor %}
-
-      unscoped_products_count: {{ products | size }}
-    LIQUID
-
-    result = template.render(context)
-
-    assert_includes(result, "for_loop_products_count: 3")
-    assert_includes(result, "unscoped_products_count: 5")
-  end
-
-  def test_new_isolated_context_inherits_parent_environment
-    global_environment = Liquid::Environment.build(tags: {})
-    context = Context.build(environment: global_environment)
-
-    subcontext = context.new_isolated_subcontext
-    assert_equal(global_environment, subcontext.environment)
-  end
-
-  def test_newly_built_context_inherits_parent_environment
-    global_environment = Liquid::Environment.build(tags: {})
-    context = Context.build(environment: global_environment)
-    assert_equal(global_environment, context.environment)
-    assert(context.environment.tags.each.to_a.empty?)
-  end
-
  private

  def assert_no_object_allocations
@@ -6,12 +6,16 @@ class DocumentTest < Minitest::Test
  include Liquid

  def test_unexpected_outer_tag
-    source = "{% else %}"
-    assert_match_syntax_error("Liquid syntax error (line 1): Unexpected outer 'else' tag", source)
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% else %}")
+    end
+    assert_equal(exc.message, "Liquid syntax error: Unexpected outer 'else' tag")
  end

  def test_unknown_tag
-    source = "{% foo %}"
-    assert_match_syntax_error("Liquid syntax error (line 1): Unknown tag 'foo'", source)
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% foo %}")
+    end
+    assert_equal(exc.message, "Liquid syntax error: Unknown tag 'foo'")
  end
 end
@@ -63,81 +63,134 @@ class ErrorHandlingTest < Minitest::Test
  end

  def test_missing_endtag_parse_time_error
-    assert_match_syntax_error(/: 'for' tag was never closed\z/, ' {% for a in b %} ... ')
-  end
-
-  def test_unrecognized_operator
-    assert_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
+    assert_raises(Liquid::SyntaxError) do
+      Liquid::Template.parse(' {% for a in b %} ... ')
    end
  end

+  def test_unrecognized_operator
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
+      end
+    end
+  end
+
+  def test_lax_unrecognized_operator
+    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
+    assert_equal(' Liquid error: Unknown operator =! ', template.render)
+    assert_equal(1, template.errors.size)
+    assert_equal(Liquid::ArgumentError, template.errors.first.class)
+  end
+
  def test_with_line_numbers_adds_numbers_to_parser_errors
-    source = <<~LIQUID
-      foobar
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar

-      {% "cat" | foobar %}
+          {% "cat" | foobar %}

-      bla
-    LIQUID
-    assert_match_syntax_error(/Liquid syntax error \(line 3\)/, source)
+          bla
+        ',
+        line_numbers: true)
+    end
+
+    assert_match(/Liquid syntax error \(line 4\)/, err.message)
  end

  def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim
-    source = <<~LIQUID
-      foobar
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar

-      {%- "cat" | foobar -%}
+          {%- "cat" | foobar -%}

-      bla
-    LIQUID
+          bla
+        ',
+        line_numbers: true)
+    end

-    assert_match_syntax_error(/Liquid syntax error \(line 3\)/, source)
+    assert_match(/Liquid syntax error \(line 4\)/, err.message)
+  end
+
+  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
+    template = Liquid::Template.parse('
+        foobar
+
+        {% if 1 =! 2 %}ok{% endif %}
+
+        bla
+            ',
+      error_mode: :warn,
+      line_numbers: true)
+
+    assert_equal(['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
+      template.warnings.map(&:message))
  end

  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(
-        '
+      Liquid::Template.parse('
          foobar

          {% if 1 =! 2 %}ok{% endif %}

          bla
                ',
-        line_numbers: true,
-      )
+        error_mode: :strict,
+        line_numbers: true)
    end

    assert_equal('Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message)
  end

  def test_syntax_errors_in_nested_blocks_have_correct_line_number
-    source = <<~LIQUID
-      foobar
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar

-      {% if 1 != 2 %}
-        {% foo %}
-      {% endif %}
+          {% if 1 != 2 %}
+            {% foo %}
+          {% endif %}

-      bla
-    LIQUID
+          bla
+                ',
+        line_numbers: true)
+    end

-    assert_match_syntax_error("Liquid syntax error (line 4): Unknown tag 'foo'", source)
+    assert_equal("Liquid syntax error (line 5): Unknown tag 'foo'", err.message)
  end

  def test_strict_error_messages
    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
+      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
    end
    assert_equal('Liquid syntax error: Unexpected character = in "1 =! 2"', err.message)

    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}')
+      Liquid::Template.parse('{{%%%}}', error_mode: :strict)
    end
    assert_equal('Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message)
  end

+  def test_warnings
+    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
+    assert_equal(3, template.warnings.size)
+    assert_equal('Unexpected character ~ in "~~~"', template.warnings[0].to_s(false))
+    assert_equal('Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false))
+    assert_equal('Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false))
+    assert_equal('', template.render)
+  end
+
+  def test_warning_line_numbers
+    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
+    assert_equal('Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message)
+    assert_equal('Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message)
+    assert_equal('Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message)
+    assert_equal(3, template.warnings.size)
+    assert_equal([1, 2, 3], template.warnings.map(&:line_number))
+  end
+
  # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
  def test_exceptions_propagate
    assert_raises(Exception) do
@@ -156,34 +209,20 @@ class ErrorHandlingTest < Minitest::Test
  end

  def test_setting_default_exception_renderer
+    old_exception_renderer = Liquid::Template.default_exception_renderer
    exceptions = []
-    default_exception_renderer = ->(e) {
+    Liquid::Template.default_exception_renderer = ->(e) {
      exceptions << e
      ''
    }
-
-    env = Liquid::Environment.build(exception_renderer: default_exception_renderer)
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}', environment: env)
+    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}')

    output = template.render('errors' => ErrorDrop.new)

    assert_equal('This is a runtime error: ', output)
    assert_equal([Liquid::ArgumentError], template.errors.map(&:class))
-  end
-
-  def test_setting_exception_renderer_on_environment
-    exceptions = []
-    exception_renderer = ->(e) do
-      exceptions << e
-      ''
-    end
-
-    environment = Liquid::Environment.build(exception_renderer: exception_renderer)
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}', environment: environment)
-    output = template.render('errors' => ErrorDrop.new)
-
-    assert_equal('This is a runtime error: ', output)
-    assert_equal([Liquid::ArgumentError], template.errors.map(&:class))
+  ensure
+    Liquid::Template.default_exception_renderer = old_exception_renderer if old_exception_renderer
  end

  def test_exception_renderer_exposing_non_liquid_error
@@ -209,10 +248,16 @@ class ErrorHandlingTest < Minitest::Test
  end

  def test_included_template_name_with_line_numbers
-    environment = Liquid::Environment.build(file_system: TestFileSystem.new)
-    template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true, environment: environment)
-    page     = template.render('errors' => ErrorDrop.new)
+    old_file_system = Liquid::Template.file_system

+    begin
+      Liquid::Template.file_system = TestFileSystem.new
+
+      template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true)
+      page     = template.render('errors' => ErrorDrop.new)
+    ensure
+      Liquid::Template.file_system = old_file_system
+    end
    assert_equal("Argument error:\nLiquid error (product line 1): argument error", page)
    assert_equal("product", template.errors.first.template_name)
  end
@@ -224,81 +269,4 @@ class ErrorHandlingTest < Minitest::Test
    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}{% assign x = 3 %}{% endif %}{{ x }}").render
    assert_equal("0", output)
  end
-
-  def test_syntax_error_is_raised_with_template_name
-    file_system = StubFileSystem.new("snippet" => "1\n2\n{{ 1")
-
-    context = Liquid::Context.build(
-      registers: { file_system: file_system },
-    )
-
-    template = Template.parse(
-      '{% render "snippet" %}',
-      line_numbers: true,
-    )
-    template.name = "template/index"
-
-    assert_equal(
-      "Liquid syntax error (snippet line 3): Variable '{{' was not properly terminated with regexp: /\\}\\}/",
-      template.render(context),
-    )
-  end
-
-  def test_syntax_error_is_raised_with_template_name_from_template_factory
-    file_system = StubFileSystem.new("snippet" => "1\n2\n{{ 1")
-
-    context = Liquid::Context.build(
-      registers: {
-        file_system: file_system,
-        template_factory: StubTemplateFactory.new,
-      },
-    )
-
-    template = Template.parse(
-      '{% render "snippet" %}',
-      line_numbers: true,
-    )
-    template.name = "template/index"
-
-    assert_equal(
-      "Liquid syntax error (some/path/snippet line 3): Variable '{{' was not properly terminated with regexp: /\\}\\}/",
-      template.render(context),
-    )
-  end
-
-  def test_error_is_raised_during_parse_with_template_name
-    depth = Liquid::Block::MAX_DEPTH + 1
-    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
-
-    template = Template.parse("{% render 'snippet' %}", line_numbers: true)
-
-    context = Liquid::Context.build(
-      registers: {
-        file_system: StubFileSystem.new("snippet" => code),
-        template_factory: StubTemplateFactory.new,
-      },
-    )
-
-    assert_equal("Liquid error (some/path/snippet line 1): Nesting too deep", template.render(context))
-  end
-
-  def test_internal_error_is_raised_with_template_name
-    template = Template.new
-    template.parse(
-      "{% render 'snippet' %}",
-      line_numbers: true,
-    )
-    template.name = "template/index"
-
-    context = Liquid::Context.build(
-      registers: {
-        file_system: StubFileSystem.new({}),
-      },
-    )
-
-    assert_equal(
-      "Liquid error (template/index line 1): internal",
-      template.render(context),
-    )
-  end
 end
@@ -1,172 +1,46 @@
 # frozen_string_literal: true

 require 'test_helper'
-require 'lru_redux'

 class ExpressionTest < Minitest::Test
  def test_keyword_literals
-    assert_template_result("true", "{{ true }}")
-    assert_expression_result(true, "true")
+    assert_equal(true, parse_and_eval("true"))
+    assert_equal(true, parse_and_eval(" true "))
  end

  def test_string
-    assert_template_result("single quoted", "{{'single quoted'}}")
-    assert_template_result("double quoted", '{{"double quoted"}}')
-    assert_template_result("spaced", "{{ 'spaced' }}")
-    assert_template_result("spaced2", "{{ 'spaced2' }}")
-    assert_template_result("emoji🔥", "{{ 'emoji🔥' }}")
+    assert_equal("single quoted", parse_and_eval("'single quoted'"))
+    assert_equal("double quoted", parse_and_eval('"double quoted"'))
+    assert_equal("spaced", parse_and_eval(" 'spaced' "))
+    assert_equal("spaced2", parse_and_eval(' "spaced2" '))
  end

  def test_int
-    assert_template_result("456", "{{ 456 }}")
-    assert_expression_result(123, "123")
-    assert_expression_result(12, "012")
+    assert_equal(123, parse_and_eval("123"))
+    assert_equal(456, parse_and_eval(" 456 "))
+    assert_equal(12, parse_and_eval("012"))
  end

  def test_float
-    assert_template_result("-17.42", "{{ -17.42 }}")
-    assert_template_result("2.5", "{{ 2.5 }}")
-
-    assert_expression_result(1.5, "1.5")
-
-    # this is a unfortunate quirky behavior of Liquid
-    result = Expression.parse(".5")
-    assert_kind_of(Liquid::VariableLookup, result)
-
-    result = Expression.parse("-.5")
-    assert_kind_of(Liquid::VariableLookup, result)
+    assert_equal(1.5, parse_and_eval("1.5"))
+    assert_equal(2.5, parse_and_eval(" 2.5 "))
  end

  def test_range
-    assert_template_result("3..4", "{{ ( 3 .. 4 ) }}")
-    assert_expression_result(1..2, "(1..2)")
-
-    assert_match_syntax_error(
-      "Liquid syntax error (line 1): Invalid expression type 'false' in range expression",
-      "{{ (false..true) }}",
-    )
-    assert_match_syntax_error(
-      "Liquid syntax error (line 1): Invalid expression type '(1..2)' in range expression",
-      "{{ ((1..2)..3) }}",
-    )
-  end
-
-  def test_expression_cache
-    skip("Liquid-C does not support Expression caching") if defined?(Liquid::C) && Liquid::C.enabled
-
-    cache = {}
-    template = <<~LIQUID
-      {% assign x = 1 %}
-      {{ x }}
-      {% assign x = 2 %}
-      {{ x }}
-      {% assign y = 1 %}
-      {{ y }}
-    LIQUID
-
-    Liquid::Template.parse(template, expression_cache: cache).render
-
-    assert_equal(
-      ["1", "2", "x", "y"],
-      cache.to_a.map { _1[0] }.sort,
-    )
-  end
-
-  def test_expression_cache_with_true_boolean
-    skip("Liquid-C does not support Expression caching") if defined?(Liquid::C) && Liquid::C.enabled
-
-    template = <<~LIQUID
-      {% assign x = 1 %}
-      {{ x }}
-      {% assign x = 2 %}
-      {{ x }}
-      {% assign y = 1 %}
-      {{ y }}
-    LIQUID
-
-    parse_context = ParseContext.new(expression_cache: true)
-
-    Liquid::Template.parse(template, parse_context).render
-
-    cache = parse_context.instance_variable_get(:@expression_cache)
-
-    assert_equal(
-      ["1", "2", "x", "y"],
-      cache.to_a.map { _1[0] }.sort,
-    )
-  end
-
-  def test_expression_cache_with_lru_redux
-    skip("Liquid-C does not support Expression caching") if defined?(Liquid::C) && Liquid::C.enabled
-
-    cache = LruRedux::Cache.new(10)
-    template = <<~LIQUID
-      {% assign x = 1 %}
-      {{ x }}
-      {% assign x = 2 %}
-      {{ x }}
-      {% assign y = 1 %}
-      {{ y }}
-    LIQUID
-
-    Liquid::Template.parse(template, expression_cache: cache).render
-
-    assert_equal(
-      ["1", "2", "x", "y"],
-      cache.to_a.map { _1[0] }.sort,
-    )
-  end
-
-  def test_disable_expression_cache
-    skip("Liquid-C does not support Expression caching") if defined?(Liquid::C) && Liquid::C.enabled
-
-    template = <<~LIQUID
-      {% assign x = 1 %}
-      {{ x }}
-      {% assign x = 2 %}
-      {{ x }}
-      {% assign y = 1 %}
-      {{ y }}
-    LIQUID
-
-    parse_context = Liquid::ParseContext.new(expression_cache: false)
-    Liquid::Template.parse(template, parse_context).render
-    assert(parse_context.instance_variable_get(:@expression_cache).nil?)
-  end
-
-  def test_safe_parse_with_variable_lookup
-    parse_context = Liquid::ParseContext.new
-    parser = parse_context.new_parser('product.title')
-    result = Liquid::Expression.safe_parse(parser)
-
-    assert_instance_of(Liquid::VariableLookup, result)
-    assert_equal('product', result.name)
-    assert_equal(['title'], result.lookups)
-  end
-
-  def test_safe_parse_with_number
-    parse_context = Liquid::ParseContext.new
-    parser = parse_context.new_parser('42')
-    result = Liquid::Expression.safe_parse(parser)
-
-    assert_equal(42, result)
-  end
-
-  def test_safe_parse_raises_syntax_error_for_invalid_expression
-    parse_context = Liquid::ParseContext.new
-    parser = parse_context.new_parser('')
-
-    error = assert_raises(Liquid::SyntaxError) do
-      Liquid::Expression.safe_parse(parser)
-    end
-
-    assert_match(/is not a valid expression/, error.message)
+    assert_equal(1..2, parse_and_eval("(1..2)"))
+    assert_equal(3..4, parse_and_eval(" ( 3 .. 4 ) "))
  end

  private

-  def assert_expression_result(expect, markup, **assigns)
-    liquid = "{% if expect == #{markup} %}pass{% else %}got {{ #{markup} }}{% endif %}"
-    assert_template_result("pass", liquid, { "expect" => expect, **assigns })
+  def parse_and_eval(markup, **assigns)
+    if Liquid::Template.error_mode == :strict
+      p = Liquid::Parser.new(markup)
+      markup = p.expression
+      p.consume(:end_of_string)
+    end
+    expression = Liquid::Expression.parse(markup)
+    context = Liquid::Context.new(assigns)
+    context.evaluate(expression)
  end
 end
@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class FilterKwargTest < Minitest::Test
-  module KwargFilter
-    def html_tag(_tag, attributes)
-      attributes
-        .map { |key, value| "#{key}='#{value}'" }
-        .join(' ')
-    end
-  end
-
-  include Liquid
-
-  def test_can_parse_data_kwargs
-    with_global_filter(KwargFilter) do
-      assert_equal(
-        "data-src='src' data-widths='100, 200'",
-        Template.parse("{{ 'img' | html_tag: data-src: 'src', data-widths: '100, 200' }}").render(nil, nil),
-      )
-    end
-  end
-end
@@ -59,87 +59,84 @@ class FiltersTest < Minitest::Test
  end

  def test_size
-    assert_template_result("4", "{{var | size}}", { "var" => 'abcd' })
+    @context['var'] = 'abcd'
+    @context.add_filters(MoneyFilter)
+
+    assert_equal('4', Template.parse("{{var | size}}").render(@context))
  end

  def test_join
-    assert_template_result("1 2 3 4", "{{var | join}}", { "var" => [1, 2, 3, 4] })
+    @context['var'] = [1, 2, 3, 4]
+
+    assert_equal("1 2 3 4", Template.parse("{{var | join}}").render(@context))
  end

  def test_sort
-    assert_template_result("1 2 3 4", "{{numbers | sort | join}}", { "numbers" => [2, 1, 4, 3] })
-    assert_template_result(
-      "alphabetic as expected",
-      "{{words | sort | join}}",
-      { "words" => ['expected', 'as', 'alphabetic'] },
-    )
-    assert_template_result("3", "{{value | sort}}", { "value" => 3 })
-    assert_template_result('are flower', "{{arrays | sort | join}}", { 'arrays' => ['flower', 'are'] })
-    assert_template_result(
-      "Expected case sensitive",
-      "{{case_sensitive | sort | join}}",
-      { "case_sensitive" => ["sensitive", "Expected", "case"] },
-    )
+    @context['value']   = 3
+    @context['numbers'] = [2, 1, 4, 3]
+    @context['words']   = ['expected', 'as', 'alphabetic']
+    @context['arrays']  = ['flower', 'are']
+    @context['case_sensitive'] = ['sensitive', 'Expected', 'case']
+
+    assert_equal('1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context))
+    assert_equal('alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context))
+    assert_equal('3', Template.parse("{{value | sort}}").render(@context))
+    assert_equal('are flower', Template.parse("{{arrays | sort | join}}").render(@context))
+    assert_equal('Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context))
  end

  def test_sort_natural
+    @context['words']   = ['case', 'Assert', 'Insensitive']
+    @context['hashes']  = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
+    @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
+
    # Test strings
-    assert_template_result(
-      "Assert case Insensitive",
-      "{{words | sort_natural | join}}",
-      { "words" => ["case", "Assert", "Insensitive"] },
-    )
+    assert_equal('Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context))

    # Test hashes
-    assert_template_result(
-      "A b C",
-      "{{hashes | sort_natural: 'a' | map: 'a' | join}}",
-      { "hashes" => [{ "a" => "A" }, { "a" => "b" }, { "a" => "C" }] },
-    )
+    assert_equal('A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context))

    # Test objects
-    @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
    assert_equal('A b C', Template.parse("{{objects | sort_natural: 'a' | map: 'a' | join}}").render(@context))
  end

  def test_compact
+    @context['words']   = ['a', nil, 'b', nil, 'c']
+    @context['hashes']  = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
+    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
+
    # Test strings
-    assert_template_result(
-      "a b c",
-      "{{words | compact | join}}",
-      { "words" => ['a', nil, 'b', nil, 'c'] },
-    )
+    assert_equal('a b c', Template.parse("{{words | compact | join}}").render(@context))

    # Test hashes
-    assert_template_result(
-      "A C",
-      "{{hashes | compact: 'a' | map: 'a' | join}}",
-      { "hashes" => [{ "a" => "A" }, { "a" => nil }, { "a" => "C" }] },
-    )
+    assert_equal('A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context))

    # Test objects
-    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
    assert_equal('A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context))
  end

  def test_strip_html
-    assert_template_result("bla blub", "{{ var | strip_html }}", { "var" => "<b>bla blub</a>" })
+    @context['var'] = "<b>bla blub</a>"
+
+    assert_equal("bla blub", Template.parse("{{ var | strip_html }}").render(@context))
  end

  def test_strip_html_ignore_comments_with_html
-    assert_template_result(
-      "bla blub",
-      "{{ var | strip_html }}",
-      { "var" => "<!-- split and some <ul> tag --><b>bla blub</a>" },
-    )
+    @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
+
+    assert_equal("bla blub", Template.parse("{{ var | strip_html }}").render(@context))
  end

  def test_capitalize
-    assert_template_result("Blub", "{{ var | capitalize }}", { "var" => "blub" })
+    @context['var'] = "blub"
+
+    assert_equal("Blub", Template.parse("{{ var | capitalize }}").render(@context))
  end

  def test_nonexistent_filter_is_ignored
-    assert_template_result("1000", "{{ var | xyzzy }}", { "var" => 1000 })
+    @context['var'] = 1000
+
+    assert_equal('1000', Template.parse("{{ var | xyzzy }}").render(@context))
  end

  def test_filter_with_keyword_arguments
@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class HashRenderingTest < Minitest::Test
-  def test_render_empty_hash
-    assert_template_result("{}", "{{ my_hash }}", { "my_hash" => {} })
-  end
-
-  def test_render_hash_with_string_keys_and_values
-    assert_template_result("{\"key1\"=>\"value1\", \"key2\"=>\"value2\"}", "{{ my_hash }}", { "my_hash" => { "key1" => "value1", "key2" => "value2" } })
-  end
-
-  def test_render_hash_with_symbol_keys_and_integer_values
-    assert_template_result("{:key1=>1, :key2=>2}", "{{ my_hash }}", { "my_hash" => { key1: 1, key2: 2 } })
-  end
-
-  def test_render_nested_hash
-    assert_template_result("{\"outer\"=>{\"inner\"=>\"value\"}}", "{{ my_hash }}", { "my_hash" => { "outer" => { "inner" => "value" } } })
-  end
-
-  def test_render_hash_with_array_values
-    assert_template_result("{\"numbers\"=>[1, 2, 3]}", "{{ my_hash }}", { "my_hash" => { "numbers" => [1, 2, 3] } })
-  end
-
-  def test_render_recursive_hash
-    recursive_hash = { "self" => {} }
-    recursive_hash["self"]["self"] = recursive_hash
-    assert_template_result("{\"self\"=>{\"self\"=>{...}}}", "{{ my_hash }}", { "my_hash" => recursive_hash })
-  end
-
-  def test_hash_with_downcase_filter
-    assert_template_result("{\"key\"=>\"value\", \"anotherkey\"=>\"anothervalue\"}", "{{ my_hash | downcase }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_hash_with_upcase_filter
-    assert_template_result("{\"KEY\"=>\"VALUE\", \"ANOTHERKEY\"=>\"ANOTHERVALUE\"}", "{{ my_hash | upcase }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_hash_with_strip_filter
-    assert_template_result("{\"Key\"=>\"Value\", \"AnotherKey\"=>\"AnotherValue\"}", "{{ my_hash | strip }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_hash_with_escape_filter
-    assert_template_result("{&quot;Key&quot;=&gt;&quot;Value&quot;, &quot;AnotherKey&quot;=&gt;&quot;AnotherValue&quot;}", "{{ my_hash | escape }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_hash_with_url_encode_filter
-    assert_template_result("%7B%22Key%22%3D%3E%22Value%22%2C+%22AnotherKey%22%3D%3E%22AnotherValue%22%7D", "{{ my_hash | url_encode }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_hash_with_strip_html_filter
-    assert_template_result("{\"Key\"=>\"Value\", \"AnotherKey\"=>\"AnotherValue\"}", "{{ my_hash | strip_html }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_hash_with_truncate__20_filter
-    assert_template_result("{\"Key\"=>\"Value\", ...", "{{ my_hash | truncate: 20 }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_hash_with_replace___key____replaced_key__filter
-    assert_template_result("{\"Key\"=>\"Value\", \"AnotherKey\"=>\"AnotherValue\"}", "{{ my_hash | replace: 'key', 'replaced_key' }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_hash_with_append____appended_text__filter
-    assert_template_result("{\"Key\"=>\"Value\", \"AnotherKey\"=>\"AnotherValue\"} appended text", "{{ my_hash | append: ' appended text' }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_hash_with_prepend___prepended_text___filter
-    assert_template_result("prepended text {\"Key\"=>\"Value\", \"AnotherKey\"=>\"AnotherValue\"}", "{{ my_hash | prepend: 'prepended text ' }}", { "my_hash" => { "Key" => "Value", "AnotherKey" => "AnotherValue" } })
-  end
-
-  def test_render_hash_with_array_values_empty
-    assert_template_result("{\"numbers\"=>[]}", "{{ my_hash }}", { "my_hash" => { "numbers" => [] } })
-  end
-
-  def test_render_hash_with_array_values_hash
-    assert_template_result("{\"numbers\"=>[{:foo=>42}]}", "{{ my_hash }}", { "my_hash" => { "numbers" => [{ foo: 42 }] } })
-  end
-
-  def test_join_filter_with_hash
-    array = [{ "key1" => "value1" }, { "key2" => "value2" }]
-    glue = { "lol" => "wut" }
-    assert_template_result("{\"key1\"=>\"value1\"}{\"lol\"=>\"wut\"}{\"key2\"=>\"value2\"}", "{{ my_array | join: glue }}", { "my_array" => array, "glue" => glue })
-  end
-
-  def test_render_hash_with_hash_key
-    assert_template_result("{{\"foo\"=>\"bar\"}=>42}", "{{ my_hash }}", { "my_hash" => { Hash["foo" => "bar"] => 42 } })
-  end
-
-  def test_rendering_hash_with_custom_to_s_method_uses_custom_to_s
-    assert_template_result("kewl", "{{ my_hash }}", { "my_hash" => HashWithCustomToS.new })
-  end
-
-  def test_rendering_hash_without_custom_to_s_uses_default_inspect
-    my_hash = HashWithoutCustomToS.new
-    my_hash[:foo] = :bar
-
-    assert_template_result("{:foo=>:bar}", "{{ my_hash }}", { "my_hash" => my_hash })
-  end
-end
@@ -33,25 +33,31 @@ class OutputTest < Minitest::Test

  def setup
    @assigns = {
+      'best_cars' => 'bmw',
      'car' => { 'bmw' => 'good', 'gm' => 'bad' },
    }
  end

  def test_variable
-    assert_template_result(" bmw ", " {{best_cars}} ", { "best_cars" => "bmw" })
+    text = %( {{best_cars}} )
+
+    expected = %( bmw )
+    assert_equal(expected, Template.parse(text).render!(@assigns))
  end

  def test_variable_traversing_with_two_brackets
-    source = "{{ site.data.menu[include.menu][include.locale] }}"
-    assert_template_result("it works!", source, {
+    text = %({{ site.data.menu[include.menu][include.locale] }})
+    assert_equal("it works!", Template.parse(text).render!(
      "site" => { "data" => { "menu" => { "foo" => { "bar" => "it works!" } } } },
-      "include" => { "menu" => "foo", "locale" => "bar" },
-    })
+      "include" => { "menu" => "foo", "locale" => "bar" }
+    ))
  end

  def test_variable_traversing
-    source = " {{car.bmw}} {{car.gm}} {{car.bmw}} "
-    assert_template_result(" good bad good ", source, @assigns)
+    text = %( {{car.bmw}} {{car.gm}} {{car.bmw}} )
+
+    expected = %( good bad good )
+    assert_equal(expected, Template.parse(text).render!(@assigns))
  end

  def test_variable_piping
@@ -104,11 +110,10 @@ class OutputTest < Minitest::Test
  end

  def test_multiple_pipings
-    assigns = { 'best_cars' => 'bmw' }
    text     = %( {{ best_cars | cite_funny | paragraph }} )
    expected = %( <p>LOL: bmw</p> )

-    assert_equal(expected, Template.parse(text).render!(assigns, filters: [FunnyFilter]))
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
  end

  def test_link_to
@@ -31,25 +31,58 @@ class ParsingQuirksTest < Minitest::Test
  def test_error_on_empty_filter
    assert(Template.parse("{{test}}"))

-    assert_raises(Liquid::SyntaxError) { Template.parse("{{|test}}") }
-    assert_raises(Liquid::SyntaxError) { Template.parse("{{test |a|b|}}") }
+    with_error_mode(:lax) do
+      assert(Template.parse("{{|test}}"))
+    end
+
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) { Template.parse("{{|test}}") }
+      assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
+    end
  end

  def test_meaningless_parens_error
-    assert_raises(SyntaxError) do
-      markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-      Template.parse("{% if #{markup} %} YES {% endif %}")
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+        Template.parse("{% if #{markup} %} YES {% endif %}")
+      end
    end
  end

  def test_unexpected_characters_syntax_error
-    assert_raises(SyntaxError) do
-      markup = "true && false"
-      Template.parse("{% if #{markup} %} YES {% endif %}")
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        markup = "true && false"
+        Template.parse("{% if #{markup} %} YES {% endif %}")
+      end
+      assert_raises(SyntaxError) do
+        markup = "false || true"
+        Template.parse("{% if #{markup} %} YES {% endif %}")
+      end
    end
-    assert_raises(SyntaxError) do
+  end
+
+  def test_no_error_on_lax_empty_filter
+    assert(Template.parse("{{test |a|b|}}", error_mode: :lax))
+    assert(Template.parse("{{test}}", error_mode: :lax))
+    assert(Template.parse("{{|test|}}", error_mode: :lax))
+  end
+
+  def test_meaningless_parens_lax
+    with_error_mode(:lax) do
+      assigns = { 'b' => 'bar', 'c' => 'baz' }
+      markup  = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
+    end
+  end
+
+  def test_unexpected_characters_silently_eat_logic_lax
+    with_error_mode(:lax) do
+      markup = "true && false"
+      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
      markup = "false || true"
-      Template.parse("{% if #{markup} %} YES {% endif %}")
+      assert_template_result('', "{% if #{markup} %} YES {% endif %}")
    end
  end

@@ -59,6 +92,32 @@ class ParsingQuirksTest < Minitest::Test
    end
  end

+  def test_unanchored_filter_arguments
+    with_error_mode(:lax) do
+      assert_template_result('hi', "{{ 'hi there' | split$$$:' ' | first }}")
+
+      assert_template_result('x', "{{ 'X' | downcase) }}")
+
+      # After the messed up quotes a filter without parameters (reverse) should work
+      # but one with parameters (remove) shouldn't be detected.
+      assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
+      assert_template_result('hi ', "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
+    end
+  end
+
+  def test_invalid_variables_work
+    with_error_mode(:lax) do
+      assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
+      assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
+    end
+  end
+
+  def test_extra_dots_in_ranges
+    with_error_mode(:lax) do
+      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
+    end
+  end
+
  def test_blank_variable_markup
    assert_template_result('', "{{}}")
  end
@@ -70,6 +129,6 @@ class ParsingQuirksTest < Minitest::Test
  end

  def test_contains_in_id
-    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', { 'containsallshipments' => true })
+    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
  end
 end # ParsingQuirksTest
@@ -3,27 +3,6 @@
 require 'test_helper'

 class ProfilerTest < Minitest::Test
-  class TestDrop < Liquid::Drop
-    def initialize(value)
-      super()
-      @value = value
-    end
-
-    def to_s
-      artificial_execution_time
-
-      @value
-    end
-
-    private
-
-    # Monotonic clock precision fluctuate based on the operating system
-    # By introducing a small sleep we ensure ourselves to register a non zero unit of time
-    def artificial_execution_time
-      sleep(Process.clock_getres(Process::CLOCK_MONOTONIC))
-    end
-  end
-
  include Liquid

  class ProfilingFileSystem
@@ -33,7 +12,7 @@ class ProfilerTest < Minitest::Test
  end

  def setup
-    Liquid::Environment.default.file_system = ProfilingFileSystem.new
+    Liquid::Template.file_system = ProfilingFileSystem.new
  end

  def test_template_allows_flagging_profiling
@@ -219,22 +198,16 @@ class ProfilerTest < Minitest::Test

  def test_profiling_supports_self_time
    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
-    collection = [
-      TestDrop.new("one"),
-      TestDrop.new("two"),
-    ]
-    output = t.render!("collection" => collection)
-    assert_equal(" one  two ", output)
-
+    t.render!("collection" => ["one", "two"])
    leaf = t.profiler[0].children[0]
-    assert_operator(leaf.self_time, :>, 0.0)
+
+    assert_operator(leaf.self_time, :>, 0)
  end

  def test_profiling_supports_total_time
-    t = Template.parse("{% if true %} {{ test }} {% endif %}", profile: true)
-    output = t.render!("test" => TestDrop.new("one"))
-    assert_equal(" one ", output)
+    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true)
+    t.render!

-    assert_operator(t.profiler[0].total_time, :>, 0.0)
+    assert_operator(t.profiler[0].total_time, :>, 0)
  end
 end
@@ -59,7 +59,7 @@ class SecurityTest < Minitest::Test

    GC.start

-    assert_equal([], Symbol.all_symbols - current_symbols)
+    assert_equal([], (Symbol.all_symbols - current_symbols))
  end

  def test_does_not_add_drop_methods_to_symbol_table
@@ -70,7 +70,7 @@ class SecurityTest < Minitest::Test
    assert_equal("", Template.parse("{{ drop.custom_method_2 }}", assigns).render!)
    assert_equal("", Template.parse("{{ drop.custom_method_3 }}", assigns).render!)

-    assert_equal([], Symbol.all_symbols - current_symbols)
+    assert_equal([], (Symbol.all_symbols - current_symbols))
  end

  def test_max_depth_nested_blocks_does_not_raise_exception
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Christophe Naud-Dulude	02b6be4025	Potential fix	2021-11-30 14:10:34 -05:00
Christophe Naud-Dulude	f3638b3eb4	Test parsing of Liquid code in comments	2021-11-30 11:56:49 -05:00