Also dump object distribution

Lazy init context errors and interrupts to prevent excess allocation
Reuse filters array during variable parsing
2026-09-30 23:55:12 -07:00 · 2015-05-06 10:45:20 -04:00 · 2015-05-05 23:40:52 -04:00 · 2015-05-05 23:30:05 -04:00 · 2015-05-05 23:21:28 -04:00 · 2015-05-05 23:02:08 -04:00
181 changed files with 4470 additions and 16956 deletions
@@ -1,6 +0,0 @@
 version: 2
 updates:
  - package-ecosystem: github-actions
    directory: "/"
    schedule:
      interval: weekly
@@ -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,73 +0,0 @@
 name: Liquid
 on: [push]
 env:
  BUNDLE_JOBS: 4
  BUNDLE_RETRY: 3
 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" }
          - { ruby: truffleruby, allowed-failure: false }
          # Head can have failures due to being in development
          - { ruby: head, allowed-failure: true }
          - {
              ruby: head,
              allowed-failure: true,
              rubyopt: "--enable-frozen-string-literal",
            }
          - { ruby: head, allowed-failure: true, rubyopt: "--yjit" }
          - { ruby: head, allowed-failure: true, rubyopt: "--zjit" }
    name: Test Ruby ${{ matrix.entry.ruby }} ${{ matrix.entry.rubyopt }} --${{ matrix.entry.allowed-failure && 'allowed-failure' || 'strict' }}
    steps:
      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
        with:
          ruby-version: ${{ matrix.entry.ruby }}
          bundler-cache: true
          bundler: latest
      - run: bundle exec rake
        continue-on-error: ${{ matrix.entry.allowed-failure }}
        env:
          RUBYOPT: ${{ matrix.entry.rubyopt }}
  spec:
    runs-on: ubuntu-latest
    env:
      BUNDLE_WITH: spec
    steps:
      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
        with:
          bundler-cache: true
          bundler: latest
      - name: Run liquid-spec for all adapters
        run: |
          for adapter in spec/*.rb; do
            echo "=== Running $adapter ==="
            bundle exec liquid-spec run "$adapter" --no-max-failures
          done
  memory_profile:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
        with:
          bundler-cache: true
      - run: bundle exec rake memory_profile:run
@@ -4,6 +4,5 @@
 pkg
 *.rbc
 .rvmrc
-.bundle
+.ruby-version
 .byebug_history
 Gemfile.lock
@@ -1,28 +0,0 @@
 inherit_gem:
  rubocop-shopify: rubocop.yml
 inherit_from:
  - .rubocop_todo.yml
 require: rubocop-performance
 Performance:
  Enabled: true
 AllCops:
  NewCops: disable
  SuggestExtensions: false
  Exclude:
    - 'vendor/bundle/**/*'
 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'
@@ -1,189 +0,0 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
 # on 2022-05-18 19:25:47 UTC using RuboCop version 1.29.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 # Offense count: 1
 # This cop supports safe auto-correction (--auto-correct).
 # Configuration parameters: TreatCommentsAsGroupSeparators, ConsiderPunctuation, Include.
 # Include: **/*.gemspec
 Gemspec/OrderedDependencies:
  Exclude:
    - 'liquid.gemspec'
 # Offense count: 6
 # This cop supports safe auto-correction (--auto-correct).
 Layout/ClosingHeredocIndentation:
  Exclude:
    - 'test/integration/tags/for_tag_test.rb'
 # Offense count: 34
 # This cop supports safe auto-correction (--auto-correct).
 Layout/EmptyLineAfterGuardClause:
  Exclude:
    - 'lib/liquid/block.rb'
    - 'lib/liquid/block_body.rb'
    - 'lib/liquid/context.rb'
    - 'lib/liquid/drop.rb'
    - 'lib/liquid/lexer.rb'
    - 'lib/liquid/parser.rb'
    - 'lib/liquid/profiler/hooks.rb'
    - 'lib/liquid/standardfilters.rb'
    - 'lib/liquid/tags/for.rb'
    - 'lib/liquid/tags/if.rb'
    - 'lib/liquid/utils.rb'
    - 'lib/liquid/variable.rb'
    - 'lib/liquid/variable_lookup.rb'
    - 'performance/shopify/money_filter.rb'
    - 'performance/shopify/paginate.rb'
 # Offense count: 8
 # This cop supports safe auto-correction (--auto-correct).
 # Configuration parameters: AllowAliasSyntax, AllowedMethods.
 # AllowedMethods: alias_method, public, protected, private
 Layout/EmptyLinesAroundAttributeAccessor:
  Exclude:
    - 'lib/liquid/template.rb'
    - 'test/integration/filter_test.rb'
    - 'test/integration/tags/include_tag_test.rb'
    - 'test/unit/strainer_template_unit_test.rb'
 # Offense count: 17
 # This cop supports safe auto-correction (--auto-correct).
 # Configuration parameters: EnforcedStyle, IndentationWidth.
 # SupportedStyles: aligned, indented
 Layout/LineEndStringConcatenationIndentation:
  Exclude:
    - 'test/integration/tags/for_tag_test.rb'
    - 'test/integration/tags/increment_tag_test.rb'
 # Offense count: 1
 # This cop supports safe auto-correction (--auto-correct).
 # Configuration parameters: EnforcedStyle, IndentationWidth.
 # SupportedStyles: aligned, indented
 Layout/MultilineOperationIndentation:
  Exclude:
    - 'lib/liquid/expression.rb'
 # Offense count: 9
 Lint/MissingSuper:
  Exclude:
    - 'lib/liquid/forloop_drop.rb'
    - 'lib/liquid/tablerowloop_drop.rb'
    - 'test/integration/assign_test.rb'
    - 'test/integration/context_test.rb'
    - 'test/integration/filter_test.rb'
    - 'test/integration/standard_filter_test.rb'
    - 'test/integration/tags/for_tag_test.rb'
    - 'test/integration/tags/table_row_test.rb'
 # Offense count: 44
 Naming/ConstantName:
  Exclude:
    - 'lib/liquid.rb'
    - 'lib/liquid/block_body.rb'
    - 'lib/liquid/tags/assign.rb'
    - 'lib/liquid/tags/capture.rb'
    - 'lib/liquid/tags/case.rb'
    - 'lib/liquid/tags/cycle.rb'
    - 'lib/liquid/tags/for.rb'
    - 'lib/liquid/tags/if.rb'
    - 'lib/liquid/tags/raw.rb'
    - 'lib/liquid/tags/table_row.rb'
    - 'lib/liquid/variable.rb'
    - 'performance/shopify/comment_form.rb'
    - '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 @@
 4.0.2
@@ -0,0 +1,20 @@
 language: ruby
 rvm:
  - 2.0
  - 2.1
  - 2.2
  - ruby-head
  - jruby-head
  - rbx-2
 sudo: false
 matrix:
  allow_failures:
    - rvm: jruby-head
 script: "rake test"
 notifications:
  disable: true
@@ -4,33 +4,23 @@
 * Bugfixes
 * Performance improvements
-* Features that are likely to be useful to the majority of Liquid users
+* Features which are likely to be useful to the majority of Liquid users
 * Documentation updates that are concise and likely to be useful to the majority of Liquid users
 ## Things we won't merge
-* Code that introduces considerable performance degrations
+* Code which introduces considerable performance degrations
-* Code that touches performance-critical parts of Liquid and comes without benchmarks
+* Code which touches performance critical parts of Liquid and comes without benchmarks
-* Features that are not important for most people (we want to keep the core Liquid code small and tidy)
+* Features which are not important for most people (we want to keep the core Liquid code small and tidy)
-* Features that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
+* Features which can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
-* Code that does not include tests
+* Code which comes without tests
-* Code that breaks existing tests
+* Code which breaks existing tests
 * Documentation changes that are verbose, incorrect or not important to most people (we want to keep it simple and easy to understand)
 ## Workflow
 * [Sign the CLA](https://cla.shopify.com/) if you haven't already
 * Fork the Liquid repository
 * Create a new branch in your fork
-  * For updating [Liquid documentation](https://shopify.github.io/liquid/), create it from `gh-pages` branch. (You can skip tests.)
+* If it makes sense, add tests for your code and run a performance benchmark
-* If it makes sense, add tests for your code and/or run a performance benchmark
+* Make sure all tests pass
 * Make sure all tests pass (`bundle exec rake`)
 * Create a pull request
-
+* In the description, ping one of [@boourns](https://github.com/boourns), [@fw42](https://github.com/fw42), [@camilo](https://github.com/camilo), [@dylanahsmith](https://github.com/dylanahsmith), or [@arthurnn](https://github.com/arthurnn) and ask for a code review.
 ## 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)
@@ -1,38 +1,10 @@
 # frozen_string_literal: true
 source 'https://rubygems.org'
 git_source(:github) do |repo_name|
  "https://github.com/#{repo_name}.git"
 end
 gemspec
-
+gem 'stackprof', platforms: :mri_21
-gem "base64"
+gem 'allocation_tracer', platforms: :mri_21
 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 'spy', '0.4.1'
-  gem 'rubocop', '~> 1.82.0'
+  gem 'benchmark-ips'
  gem 'rubocop-shopify', '~> 2.18.0', require: false
  gem 'rubocop-performance', require: false
 end
 group :spec do
  # Includes the range resource-limit specs from https://github.com/Shopify/liquid-spec/pull/165.
  gem 'liquid-spec', github: 'Shopify/liquid-spec', ref: '84bf25e0edbca5f7e530574788b0f875ab331f50'
  gem 'activesupport', require: false
 end
@@ -1,307 +1,23 @@
 # Liquid Change Log
-## 5.14.0
+## 4.0.0 / not yet released / branch "master"
 * Avoid materializing integer ranges in `for` and `tablerow` loops, and account for each visited range item [Ian Ker-Seymer]
 ## 5.13.0
 * Add TruffleRuby in CI [Benoit Daloze]
 * Skip slow test raising many exceptions on non-CRuby [Benoit Daloze]
 * Reject bare-bracket syntax in strict2 and introduce `self` keyword by [Alok Swamy]
 * Add strict2_parse to assign and capture tags by [Alok Swamy]
 * Add strict2_parse to increment and decrement tags by [Alok Swamy]
 * Update liquid-spec adapters for `missing_features` [Ian Ker-Seymer]
 * Prevent `SelfDrop` context mutation across render boundaries [Guilherme Carreiro]
 * Fix `SelfDrop` equality [Guilherme Carreiro]
 * Let environment `self` shadow `SelfDrop` [Ian Ker-Seymer]
 ## 5.11.0
 * Revert the Inline Snippets tag (#2001), treat its inclusion in the latest Liquid release as a bug, and allow for feedback on RFC#1916 to better support Liquid developers [Guilherme Carreiro]
 * Rename the `:rigid` error mode to `:strict2` and display a warning when users attempt to use the `:rigid` mode [Guilherme Carreiro]
 ## 5.10.0
 * Introduce support for Inline Snippets [Julia Boutin]
 ## 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)
+* Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li, pushrax]
-
+* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith, dylanahsmith]
-## 5.3.0 2022-03-22
+* Add concat filter to concatenate arrays (#429) [Diogo Beato, dvbeato]
-
+* Ruby 1.9 support dropped (#491) [Justin Li, pushrax]
-### Fixes
+* Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith, sunblaze]
 * 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
 * Add `base64_encode`, `base64_decode`, `base64_url_safe_encode`, and `base64_url_safe_decode` filters (#1450) [Daniel Insley]
 * Introduce `to_liquid_value` in `Liquid::Drop` (#1441) [Michael Go]
 ### Fixes
 * Fix support for using a String subclass for the liquid source (#1421) [Dylan Thacker-Smith]
 * Add `ParseTreeVisitor` to `RangeLookup` (#1470) [CP Clermont]
 * Translate `RangeError` to `Liquid::Error` for `truncatewords` with large int (#1431) [Dylan Thacker-Smith]
 ## 5.0.1 / 2021-03-24
 ### Fixes
 * Add ParseTreeVisitor to Echo tag (#1414) [CP Clermont]
 * Test with ruby 3.0 as the latest ruby version (#1398) [Dylan Thacker-Smith]
 * Handle carriage return in newlines_to_br (#1391) [Unending]
 ### Performance Improvements
 * Use split limit in truncatewords (#1361) [Dylan Thacker-Smith]
 ## 5.0.0 / 2021-01-06
 ### Features
 * Add new `{% render %}` tag (#1122) [Samuel Doiron]
 * Add support for `as` in `{% render %}` and `{% include %}` (#1181) [Mike Angell]
 * Add `{% liquid %}` and `{% echo %}` tags (#1086) [Justin Li]
 * Add [usage tracking](README.md#usage-tracking) [Mike Angell]
 * Add `Tag.disable_tags` for disabling tags that prepend `Tag::Disableable` at render time (#1162, #1274, #1275) [Mike Angell]
 * Support using a profiler for multiple renders (#1365, #1366) [Dylan Thacker-Smith]
 ### Fixes
 * Fix catastrophic backtracking in `RANGES_REGEX` regular expression (#1357) [Dylan Thacker-Smith]
 * Make sure the for tag's limit and offset are integers (#1094) [David Cornu]
 * Invokable methods for enumerable reject include (#1151) [Thierry Joyal]
 * Allow `default` filter to handle `false` as value (#1144) [Mike Angell]
 * Fix render length resource limit so it doesn't multiply nested output (#1285) [Dylan Thacker-Smith]
 * Fix duplication of text in raw tags (#1304) [Peter Zhu]
 * Fix strict parsing of find variable with a name expression (#1317) [Dylan Thacker-Smith]
 * Use monotonic time to measure durations in Liquid::Profiler (#1362) [Dylan Thacker-Smith]
 ### Breaking Changes
 * Require Ruby >= 2.5 (#1131, #1310) [Mike Angell, Dylan Thacker-Smith]
 * Remove support for taint checking (#1268) [Dylan Thacker-Smith]
 * Split Strainer class into StrainerFactory and StrainerTemplate (#1208) [Thierry Joyal]
 * Remove handling of a nil context in the Strainer class (#1218) [Thierry Joyal]
 * Handle `BlockBody#blank?` at parse time (#1287) [Dylan Thacker-Smith]
 * Pass the tag markup and tokenizer to `Document#unknown_tag` (#1290) [Dylan Thacker-Smith]
 * And several internal changes
 ### Performance Improvements
 * Reduce allocations (#1073, #1091, #1115, #1099, #1117, #1141, #1322, #1341) [Richard Monette, Florian Weingarten, Ashwin Maroli]
 * Improve resources limits performance (#1093, #1323) [Florian Weingarten, Dylan Thacker-Smith]
 ## 4.0.3 / 2019-03-12
 ### Fixed
-* Fix break and continue tags inside included templates in loops (#1072) [Justin Li]
+* Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten, fw42]
 * Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds, kreynolds]
 * Disallow filters with no variable in strict mode (#475) [Justin Li, pushrax]
 * Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li, pushrax]
 * Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li, pushrax]
-## 4.0.2 / 2019-03-08
+## 3.0.2 / 2015-04-24 / branch "3-0-stable"
-### Changed
+* Expose VariableLookup private members (#551) [Justin Li, pushrax]
 * Add `where` filter (#1026) [Samuel Doiron]
 * Add `ParseTreeVisitor` to iterate the Liquid AST (#1025) [Stephen Paul Weber]
 * Improve `strip_html` performance (#1032) [printercu]
 ### Fixed
 * Add error checking for invalid combinations of inputs to sort, sort_natural, where, uniq, map, compact filters (#1059) [Garland Zhang]
 * Validate the character encoding in url_decode (#1070) [Clayton Smith]
 ## 4.0.1 / 2018-10-09
 ### Changed
 * Add benchmark group in Gemfile (#855) [Jerry Liu]
 * Allow benchmarks to benchmark render by itself (#851) [Jerry Liu]
 * Avoid calling `line_number` on String node when rescuing a render error. (#860) [Dylan Thacker-Smith]
 * Avoid duck typing to detect whether to call render on a node. [Dylan Thacker-Smith]
 * Clarify spelling of `reversed` on `for` block tag (#843) [Mark Crossfield]
 * Replace recursion with loop to avoid potential stack overflow from malicious input (#891, #892) [Dylan Thacker-Smith]
 * Limit block tag nesting to 100 (#894) [Dylan Thacker-Smith]
 * Replace `assert_equal nil` with `assert_nil` (#895) [Dylan Thacker-Smith]
 * Remove Spy Gem (#896) [Dylan Thacker-Smith]
 * Add `collection_name` and `variable_name` reader to `For` block (#909)
 * Symbols render as strings (#920) [Justin Li]
 * Remove default value from Hash objects (#932) [Maxime Bedard]
 * Remove one level of nesting (#944) [Dylan Thacker-Smith]
 * Update Rubocop version (#952) [Justin Li]
 * Add `at_least` and `at_most` filters (#954, #958) [Nithin Bekal]
 * Add a regression test for a liquid-c trim mode bug (#972) [Dylan Thacker-Smith]
 * Use https rather than git protocol to fetch liquid-c [Dylan Thacker-Smith]
 * Add tests against Ruby 2.4 (#963) and 2.5 (#981)
 * Replace RegExp literals with constants (#988) [Ashwin Maroli]
 * Replace unnecessary `#each_with_index` with `#each` (#992) [Ashwin Maroli]
 * Improve the unexpected end delimiter message for block tags. (#1003) [Dylan Thacker-Smith]
 * Refactor and optimize rendering (#1005) [Christopher Aue]
 * Add installation instruction (#1006) [Ben Gift]
 * Remove Circle CI (#1010)
 * Rename deprecated `BigDecimal.new` to `BigDecimal` (#1024) [Koichi ITO]
 * Rename deprecated Rubocop name (#1027) [Justin Li]
 ### Fixed
 * Handle `join` filter on non String joiners (#857) [Richard Monette]
 * Fix duplicate inclusion condition logic error of `Liquid::Strainer.add_filter` method (#861)
 * Fix `escape`, `url_encode`, `url_decode` not handling non-string values (#898) [Thierry Joyal]
 * Fix raise when variable is defined but nil when using `strict_variables` [Pascal Betz]
 * Fix `sort` and `sort_natural` to handle arrays with nils (#930) [Eric Chan]
 ## 4.0.0 / 2016-12-14 / branch "4-0-stable"
 ### Changed
 * Render an opaque internal error by default for non-Liquid::Error (#835) [Dylan Thacker-Smith]
 * Ruby 2.0 support dropped (#832) [Dylan Thacker-Smith]
 * Add to_number Drop method to allow custom drops to work with number filters (#731)
 * Add strict_variables and strict_filters options to detect undefined references (#691)
 * Improve loop performance (#681) [Florian Weingarten]
 * Rename Drop method `before_method` to `liquid_method_missing` (#661) [Thierry Joyal]
 * Add url_decode filter to invert url_encode (#645) [Larry Archer]
 * Add global_filter to apply a filter to all output (#610) [Loren Hale]
 * Add compact filter (#600) [Carson Reinke]
 * Rename deprecated "has_key?" and "has_interrupt?" methods (#593) [Florian Weingarten]
 * Include template name with line numbers in render errors (574) [Dylan Thacker-Smith]
 * Add sort_natural filter (#554) [Martin Hanzel]
 * Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li]
 * Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith]
 * Add concat filter to concatenate arrays (#429) [Diogo Beato]
 * Ruby 1.9 support dropped (#491) [Justin Li]
 * Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith]
 * Remove `liquid_methods` (See https://github.com/Shopify/liquid/pull/568 for replacement)
 * Liquid::Template.register_filter raises when the module overrides registered public methods as private or protected (#705) [Gaurav Chande]
 ### Fixed
 * Fix variable names being detected as an operator when starting with contains (#788) [Michael Angell]
 * Fix include tag used with strict_variables (#828) [QuickPay]
 * Fix map filter when value is a Proc (#672) [Guillaume Malette]
 * Fix truncate filter when value is not a string (#672) [Guillaume Malette]
 * Fix behaviour of escape filter when input is nil (#665) [Tanel Jakobsoo]
 * Fix sort filter behaviour with empty array input (#652) [Marcel Cary]
 * Fix test failure under certain timezones (#631) [Dylan Thacker-Smith]
 * Fix bug in uniq filter (#595) [Florian Weingarten]
 * Fix bug when "blank" and "empty" are used as variable names (#592) [Florian Weingarten]
 * Fix condition parse order in strict mode (#569) [Justin Li]
 * Fix naming of the "context variable" when dynamically including a template (#559) [Justin Li]
 * Gracefully accept empty strings in the date filter (#555) [Loren Hale]
 * Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten]
 * Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds]
 * Disallow filters with no variable in strict mode (#475) [Justin Li]
 * Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li]
 * Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li]
 ## 3.0.5 / 2015-07-23 / branch "3-0-stable"
 * Fix test failure under certain timezones [Dylan Thacker-Smith]
 ## 3.0.4 / 2015-07-17
 * Fix chained access to multi-dimensional hashes [Florian Weingarten]
 ## 3.0.3 / 2015-05-28
 * Fix condition parse order in strict mode (#569) [Justin Li]
 ## 3.0.2 / 2015-04-24
 * Expose VariableLookup private members (#551) [Justin Li]
 * Documentation fixes
 ## 3.0.1 / 2015-01-23
@@ -310,52 +26,44 @@ Please reference the GitHub release for more information.
 ## 3.0.0 / 2014-11-12
-* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith]
+* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith, dylanahsmith]
 * Fixed condition with wrong data types (#423) [Bogdan Gusiev]
-* Add url_encode to standard filters (#421) [Derrick Reimer]
+* Add url_encode to standard filters (#421) [Derrick Reimer, djreimer]
-* Add uniq to standard filters [Florian Weingarten]
+* Add uniq to standard filters [Florian Weingarten, fw42]
-* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, Florian Weingarten]
+* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
-* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge]
+* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
-* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge]
+* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 
-* Properly set context rethrow_errors on render! #349 [Thierry Joyal]
+* Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
-* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten]
+* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten, fw42]
-* Remove ActionView template handler [Dylan Thacker-Smith]
+* Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
-* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten]
+* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten, fw42]
-* Allow newlines in tags and variables (#324) [Dylan Thacker-Smith]
+* Allow newlines in tags and variables (#324) [Dylan Thacker-Smith, dylanahsmith]
-* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith]
+* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith, dylanahsmith]
-* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev]
+* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
-* Add a to_s default for liquid drops (#306) [Adam Doeler]
+* Add a to_s default for liquid drops (#306) [Adam Doeler, releod]
-* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten]
+* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten, fw42]
-* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones]
+* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones, dntj]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
+* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten]
+* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten, fw42]
-* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi]
+* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi, agladkyi]
-* Allow drops to optimize loading a slice of elements (#282) [Tom Burns]
+* Allow drops to optimize loading a slice of elements (#282) [Tom Burns, boourns]
-* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink]
+* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink, joost]
-* Add a class cache to avoid runtime extend calls (#249) [James Tucker]
+* Add a class cache to avoid runtime extend calls (#249) [James Tucker, raggi]
-* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten]
+* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten, fw42]
-* Add default filter to standard filters (#267) [Derrick Reimer]
+* Add default filter to standard filters (#267) [Derrick Reimer, djreimer]
-* Add optional strict parsing and warn parsing (#235) [Tristan Hume]
+* Add optional strict parsing and warn parsing (#235) [Tristan Hume, trishume]
 * Add I18n syntax error translation (#241) [Simon Hørup Eskildsen, Sirupsen]
-* Make sort filter work on enumerable drops (#239) [Florian Weingarten]
+* Make sort filter work on enumerable drops (#239) [Florian Weingarten, fw42]
-* Fix clashing method names in enumerable drops (#238) [Florian Weingarten]
+* Fix clashing method names in enumerable drops (#238) [Florian Weingarten, fw42]
-* Make map filter work on enumerable drops (#233) [Florian Weingarten]
+* Make map filter work on enumerable drops (#233) [Florian Weingarten, fw42]
-* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten]
+* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
-## 2.6.3 / 2015-07-23 / branch "2-6-stable"
+## 2.6.1 / 2014-01-10 / branch "2-6-stable"
 * Fix test failure under certain timezones [Dylan Thacker-Smith]
 ## 2.6.2 / 2015-01-23
 * Remove duplicate hash key [Parker Moore]
 ## 2.6.1 / 2014-01-10
 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
+* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
 ## 2.6.0 / 2013-11-25
@@ -363,37 +71,37 @@ IMPORTANT: Liquid 2.6 is going to be the last version of Liquid which maintains
 The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are likely to break on Ruby 1.8.
 * Bugfix for #106: fix example servlet [gnowoel]
-* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss]
+* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss, joliss]
-* Bugfix for #114: strip_html filter supports style tags [James Allardice]
+* Bugfix for #114: strip_html filter supports style tags [James Allardice, jamesallardice]
-* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup]
+* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup, ndwebgroup]
-* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten]
+* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten, fw42]
-* Bugfix for #204: 'raw' parsing bug [Florian Weingarten]
+* Bugfix for #204: 'raw' parsing bug [Florian Weingarten, fw42]
-* Bugfix for #150: 'for' parsing bug [Peter Schröder]
+* Bugfix for #150: 'for' parsing bug [Peter Schröder, phoet]
-* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder]
+* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder, phoet]
-* Bugfix for #174, "can't convert Fixnum into String" for "replace" [jsw0528]
+* Bugfix for #174, "can't convert Fixnum into String" for "replace" [wǒ_is神仙, jsw0528]
-* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep]
+* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep, darkhelmet]
-* Resource limits [Florian Weingarten]
+* Resource limits [Florian Weingarten, fw42]
-* Add reverse filter [Jay Strybis]
+* Add reverse filter [Jay Strybis, unreal]
 * Add utf-8 support
-* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos]
+* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos, astathopoulos]
-* Cache tokenized partial templates [Tom Burns]
+* Cache tokenized partial templates [Tom Burns, boourns]
-* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer]
+* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer, stomar]
-* Better documentation for 'include' tag (closes #163) [Peter Schröder]
+* Better documentation for 'include' tag (closes #163) [Peter Schröder, phoet]
-* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves]
+* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves, arthurnn]
 ## 2.5.5 / 2014-01-10 / branch "2-5-stable"
 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
+* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
 ## 2.5.4 / 2013-11-11
-* Fix "can't convert Fixnum into String" for "replace" (#173), [jsw0528]
+* Fix "can't convert Fixnum into String" for "replace" (#173), [wǒ_is神仙, jsw0528]
 ## 2.5.3 / 2013-10-09
-* #232, #234, #237: Fix map filter bugs [Florian Weingarten]
+* #232, #234, #237: Fix map filter bugs [Florian Weingarten, fw42]
 ## 2.5.2 / 2013-09-03 / deleted
@@ -401,7 +109,7 @@ Yanked from rubygems, as it contained too many changes that broke compatibility.
 ## 2.5.1 / 2013-07-24
-* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten]
+* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten, fw42]
 ## 2.5.0 / 2013-03-06
@@ -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/)
@@ -42,8 +42,6 @@ Liquid is a template engine which was written with very specific requirements:
 ## How to use Liquid
 Install Liquid by adding `gem 'liquid'` to your gemfile.
 Liquid supports a very simple API based around the Liquid::Template class.
 For standard use you can just pass it the content of a file and call render with a parameters hash.
@@ -52,112 +50,26 @@ For standard use you can just pass it the content of a file and call render with
@template.render('name' => 'tobi')                # => "hi tobi"
 ```
 ### Concept of Environments
 In Liquid, a "Environment" is a scoped environment that encapsulates custom tags, filters, and other configurations. This allows you to define and isolate different sets of functionality for different contexts, avoiding global overrides that can lead to conflicts and unexpected behavior.
 By using environments, you can:
 1. **Encapsulate Logic**: Keep the logic for different parts of your application separate.
 2. **Avoid Conflicts**: Prevent custom tags and filters from clashing with each other.
 3. **Improve Maintainability**: Make it easier to manage and understand the scope of customizations.
 4. **Enhance Security**: Limit the availability of certain tags and filters to specific contexts.
 We encourage the use of Environments over globally overriding things because it promotes better software design principles such as modularity, encapsulation, and separation of concerns.
 Here's an example of how you can define and use Environments in Liquid:
 ```ruby
 user_environment = Liquid::Environment.build do |environment|
  environment.register_tag("renderobj", RenderObjTag)
 end
 Liquid::Template.parse(<<~LIQUID, environment: user_environment)
  {% renderobj src: "path/to/model.obj" %}
 LIQUID
 ```
 In this example, `RenderObjTag` is a custom tag that is only available within the `user_environment`.
 Similarly, you can define another environment for a different context, such as email templates:
 ```ruby
 email_environment = Liquid::Environment.build do |environment|
  environment.register_tag("unsubscribe_footer", UnsubscribeFooter)
 end
 Liquid::Template.parse(<<~LIQUID, environment: email_environment)
  {% unsubscribe_footer %}
 LIQUID
 ```
 By using Environments, you ensure that custom tags and filters are only available in the contexts where they are needed, making your Liquid templates more robust and easier to manage. For smaller projects, a global environment is available via `Liquid::Environment.default`.
 ### Error Modes
 Setting the error mode of Liquid lets you specify how strictly you want your templates to be interpreted.
 Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
-it very hard to debug and can lead to unexpected behaviour.
+it very hard to debug and can lead to unexpected behaviour. 
-Liquid also comes with different parsers that can be used when editing templates to give better error messages
+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
-Liquid::Environment.default.error_mode = :strict2 # Raises a SyntaxError when invalid syntax is used in all tags
+Liquid::Template.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
-Liquid::Environment.default.error_mode = :strict  # Raises a SyntaxError when invalid syntax is used in some tags
+Liquid::Template.error_mode = :warn # Adds errors to template.errors but continues as normal
-Liquid::Environment.default.error_mode = :warn    # Adds strict errors to template.errors but continues as normal
+Liquid::Template.error_mode = :lax # The default mode, accepts almost anything.
 Liquid::Environment.default.error_mode = :lax     # The default mode, accepts almost anything.
 ```
 If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
 ```ruby
-Liquid::Template.parse(source, error_mode: :strict)
+Liquid::Template.parse(source, :error_mode => :strict)
 ```
 This is useful for doing things like enabling strict mode only in the theme editor.
 It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
 It is also recommended that you use it in the template editors of existing apps to give editors better error messages.
 ### Undefined variables and filters
 By default, the renderer doesn't raise or in any other way notify you if some variables or filters are missing, i.e. not passed to the `render` method.
 You can improve this situation by passing `strict_variables: true` and/or `strict_filters: true` options to the `render` method.
 When one of these options is set to true, all errors about undefined variables and undefined filters will be stored in `errors` array of a `Liquid::Template` instance.
 Here are some examples:
 ```ruby
 template = Liquid::Template.parse("{{x}} {{y}} {{z.a}} {{z.b}}")
 template.render({ 'x' => 1, 'z' => { 'a' => 2 } }, { strict_variables: true })
 #=> '1  2 ' # when a variable is undefined, it's rendered as nil
 template.errors
 #=> [#<Liquid::UndefinedVariable: Liquid error: undefined variable y>, #<Liquid::UndefinedVariable: Liquid error: undefined variable b>]
 ```
 ```ruby
 template = Liquid::Template.parse("{{x | filter1 | upcase}}")
 template.render({ 'x' => 'foo' }, { strict_filters: true })
 #=> '' # when at least one filter in the filter chain is undefined, a whole expression is rendered as nil
 template.errors
 #=> [#<Liquid::UndefinedFilter: Liquid error: undefined filter filter1>]
 ```
 If you want to raise on a first exception instead of pushing all of them in `errors`, you can use `render!` method:
 ```ruby
 template = Liquid::Template.parse("{{x}} {{y}}")
 template.render!({ 'x' => 1}, { strict_variables: true })
 #=> Liquid::UndefinedVariable: Liquid error: undefined variable y
 ```
 ### Resource limits
 `render_score_limit` and `cumulative_render_score_limit` account for each item visited by
 integer-range `for` and `tablerow` loops, including loops with empty bodies. This bounds range
 iteration work when a score limit is configured; `render_length_limit` only bounds generated
 output and does not by itself limit CPU work for output-free loops.
 ### Usage tracking
 To help track usages of a feature or code path in production, we have released opt-in usage tracking. To enable this, we provide an empty `Liquid:: Usage.increment` method which you can customize to your needs. The feature is well suited to https://github.com/Shopify/statsd-instrument. However, the choice of implementation is up to you.
 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.
@@ -1,76 +1,42 @@
 # frozen_string_literal: true
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"
-task(default: [:test, :rubocop])
+task :default => 'test'
-desc('run test suite with default parser')
+desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
-  t.libs << 'lib' << 'test'
+  t.libs << '.' << 'lib' << 'test'
  t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
-  t.verbose    = false
+  t.verbose = false
 end
-Rake::TestTask.new(:integration_test) do |t|
+desc 'run test suite with warn error mode'
  t.libs << 'lib' << 'test'
  t.test_files = FileList['test/integration/**/*_test.rb']
  t.verbose    = false
 end
 desc('run test suite with warn error mode')
 task :warn_test do
  ENV['LIQUID_PARSER_MODE'] = 'warn'
  Rake::Task['base_test'].invoke
 end
-task :rubocop do
+desc 'runs test suite with both strict and lax parsers'
  if RUBY_ENGINE == 'ruby'
    require 'rubocop/rake_task'
    RuboCop::RakeTask.new
  end
 end
 desc('runs test suite with lax, strict, and strict2 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
  ENV['LIQUID_PARSER_MODE'] = 'strict2'
  Rake::Task['base_test'].reenable
  Rake::Task['base_test'].invoke
  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
    ENV['LIQUID_PARSER_MODE'] = 'lax'
    Rake::Task['integration_test'].reenable
    Rake::Task['integration_test'].invoke
    ENV['LIQUID_PARSER_MODE'] = 'strict'
    Rake::Task['integration_test'].reenable
    Rake::Task['integration_test'].invoke
    ENV['LIQUID_PARSER_MODE'] = 'strict2'
    Rake::Task['integration_test'].reenable
    Rake::Task['integration_test'].invoke
  end
 end
-task(gem: :build)
+task :gem => :build
 task :build do
  system "gem build liquid.gemspec"
 end
-task install: :build do
+task :install => :build do
  system "gem install liquid-#{Liquid::VERSION}.gem"
 end
-task release: :build do
+task :release => :build do
  system "git tag -a v#{Liquid::VERSION} -m 'Tagging #{Liquid::VERSION}'"
  system "git push --tags"
  system "gem push liquid-#{Liquid::VERSION}.gem"
@@ -78,8 +44,9 @@ task release: :build do
 end
 namespace :benchmark do
  desc "Run the liquid benchmark with lax parsing"
-  task :lax do
+  task :run do
    ruby "./performance/benchmark.rb lax"
  end
@@ -87,41 +54,11 @@ namespace :benchmark do
  task :strict do
    ruby "./performance/benchmark.rb strict"
  end
  desc "Run the liquid benchmark with strict2 parsing"
  task :strict2 do
    ruby "./performance/benchmark.rb strict2"
  end
  desc "Run the liquid benchmark with lax, strict, and strict2 parsing"
  task run: [:lax, :strict, :strict2]
  desc "Run unit benchmarks"
  namespace :unit do
    task :all do
      Dir["./performance/unit/*_benchmark.rb"].each do |file|
        puts "🧪 Running #{file}"
        ruby file
      end
    end
    task :lexer do
      Dir["./performance/unit/lexer_benchmark.rb"].each do |file|
        puts "🧪 Running #{file}"
        ruby file
      end
    end
    task :expression do
      Dir["./performance/unit/expression_benchmark.rb"].each do |file|
        puts "🧪 Running #{file}"
        ruby file
      end
    end
  end
 end
 namespace :profile do
  desc "Run the liquid profile/performance coverage"
  task :run do
    ruby "./performance/profile.rb"
@@ -131,28 +68,24 @@ namespace :profile do
  task :strict do
    ruby "./performance/profile.rb strict"
  end
 end
-namespace :memory_profile do
+namespace :memory do
-  desc "Run memory profiler"
+
  desc "Run the liquid memory tracer"
  task :run do
-    ruby "./performance/memory_profile.rb"
+    ruby "./performance/memory.rb"
  end
  desc "Run the liquid memory tracer with strict parsing"
  task :strict do
    ruby "./performance/memory.rb strict"
  end
 end
-desc("Run example")
+desc "Run example"
 task :example do
  ruby "-w -d -Ilib example/server/server.rb"
 end
 task :console do
  exec 'irb -I lib -r liquid'
 end
 desc('run liquid-spec suite across all adapters')
 task :spec do
  Dir['./spec/*.rb'].sort.each do |adapter|
    puts "=== Running #{adapter} ==="
    sh 'bundle', 'exec', 'liquid-spec', 'run', adapter, '--no-max-failures'
  end
 end
@@ -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)
@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 module ProductsFilter
  def price(integer)
-    format("$%.2d USD", integer / 100.0)
+    sprintf("$%.2d USD", integer / 100.0)
  end
  def prettyprint(text)
-    text.gsub(/\*(.*)\*/, '<b>\1</b>')
+    text.gsub( /\*(.*)\*/, '<b>\1</b>' )
  end
  def count(array)
@@ -19,32 +17,30 @@ module ProductsFilter
 end
 class Servlet < LiquidServlet
  def index
    { 'date' => Time.now }
  end
  def products
-    { 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true }
+    { 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
  end
  private
  def products_list
-    [
+    [{'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
-      { '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 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 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 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 Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }
    ]
  end
  def description
    "List of Products ~ This is a list of products with price and description."
  end
 end
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
  def do_GET(req, res)
    handle(:get, req, res)
  end
@@ -11,20 +10,20 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
  private
-  def handle(_type, req, res)
+  def handle(type, req, res)
-    @request  = req
+    @request = req
    @response = res
    @request.path_info =~ /(\w+)\z/
-    @action  = Regexp.last_match(1) || 'index'
+    @action = $1 || 'index'
    @assigns = send(@action) if respond_to?(@action)
    @response['Content-Type'] = "text/html"
    @response.status = 200
-    @response.body   = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
+    @response.body = Liquid::Template.parse(read_template).render(@assigns, :filters => [ProductsFilter])
  end
  def read_template(filename = @action)
-    File.read("#{__dir__}/templates/#{filename}.liquid")
+    File.read( File.dirname(__FILE__) + "/templates/#{filename}.liquid" )
  end
 end
@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 require 'webrick'
 require 'rexml/document'
-require_relative '../../lib/liquid'
+DIR = File.expand_path(File.dirname(__FILE__))
-require_relative 'liquid_servlet'
+
-require_relative 'example_servlet'
+require DIR + '/../../lib/liquid'
 require DIR + '/liquid_servlet'
 require DIR + '/example_servlet'
 # Setup webrick
-server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
+server = WEBrick::HTTPServer.new( :Port => ARGV[1] || 3000 )
 server.mount('/', Servlet)
-trap("INT") { server.shutdown }
+trap("INT"){ server.shutdown }
 server.start
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 # Copyright (c) 2005 Tobias Luetke
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -21,17 +19,13 @@
 # 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           = ','
+  ArgumentSeparator           = ','.freeze
-  FilterArgumentSeparator     = ':'
+  FilterArgumentSeparator     = ':'.freeze
-  VariableAttributeSeparator  = '.'
+  VariableAttributeSeparator  = '.'.freeze
  WhitespaceControl           = '-'
  TagStart                    = /\{\%/
  TagEnd                      = /\%\}/
  TagName                     = /#|\w+/
  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
  VariableSegment             = /[\w\-]/
  VariableStart               = /\{\{/
@@ -39,55 +33,44 @@ 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
+  AnyStartingTag              = /\{\{|\{\%/
  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
-  VariableParser              = /\[(?>[^\[\]]+|\g<0>)*\]|#{VariableSegment}+\??/o
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
-  RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
+  singleton_class.send(:attr_accessor, :cache_classes)
-  HAS_STRING_SCANNER_SCAN_BYTE = StringScanner.instance_methods.include?(:scan_byte)
+  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'
 require 'liquid/drop'
 require 'liquid/self_drop'
 require 'liquid/tablerowloop_drop'
 require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer_template'
+require 'liquid/strainer'
 require 'liquid/expression'
 require 'liquid/context'
 require 'liquid/parser_switching'
 require 'liquid/tag'
 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/range_slice'
+require 'liquid/module_ex'
 require 'liquid/utils'
-require 'liquid/tokenizer'
+require 'liquid/token'
-require 'liquid/parse_context'
+
-require 'liquid/partial_cache'
+# Load all the tags of the standard library
-require 'liquid/usage'
+#
-require 'liquid/registers'
+Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
 require 'liquid/template_factory'
@@ -1,22 +1,16 @@
 # frozen_string_literal: true
 module Liquid
  class Block < Tag
    MAX_DEPTH = 100
    def initialize(tag_name, markup, options)
      super
      @blank = true
    end
    def parse(tokens)
-      @body = new_body
+      @body = BlockBody.new
-      while parse_body(@body, tokens)
+      while more = parse_body(@body, tokens)
      end
      @body.freeze
    end
    # For backwards compatibility
    def render(context)
      @body.render(context)
    end
@@ -29,31 +23,30 @@ module Liquid
      @body.nodelist
    end
-    def unknown_tag(tag_name, _markup, _tokenizer)
+    # warnings of this block and all sub-tags
-      Block.raise_unknown_tag(tag_name, block_name, block_delimiter, parse_context)
+    def warnings
-    end
+      all_warnings = []
      all_warnings.concat(@warnings) if @warnings
-    # @api private
+      (nodelist || []).each do |node|
-    def self.raise_unknown_tag(tag, block_name, block_delimiter, parse_context)
+        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
      if tag == 'else'
        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",
          tag: tag,
          block_name: block_name,
          block_delimiter: block_delimiter,
        )
      else
        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
      end
      all_warnings
    end
-    def raise_tag_never_closed(block_name)
+    def unknown_tag(tag, params, tokens)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
+      case tag
      when 'else'.freeze
        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
                                                 :block_name => block_name))
      when 'end'.freeze
        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter".freeze,
                                                 :block_name => block_name,
                                                 :block_delimiter => block_delimiter))
      else
        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
      end
    end
    def block_name
@@ -64,32 +57,20 @@ module Liquid
      @block_delimiter ||= "end#{block_name}"
    end
-    private
+    protected
    # @api public
    def new_body
      parse_context.new_block_body
    end
    # @api public
    def parse_body(body, tokens)
-      if parse_context.depth >= MAX_DEPTH
+      body.parse(tokens, options) do |end_tag_name, end_tag_params|
-        raise StackLevelError, "Nesting too deep"
+        @blank &&= body.blank?
      end
      parse_context.depth += 1
      begin
        body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
          @blank &&= body.blank?
-          return false if end_tag_name == block_delimiter
+        return false if end_tag_name == block_delimiter
-          raise_tag_never_closed(block_name) unless end_tag_name
+        unless end_tag_name
-
+          raise SyntaxError.new(@options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
          # this tag is not registered with the system
          # pass it to the current block for special handling or error reporting
          unknown_tag(end_tag_name, end_tag_params, tokens)
        end
-      ensure
+
-        parse_context.depth -= 1
+        # this tag is not registered with the system
        # pass it to the current block for special handling or error reporting
        unknown_tag(end_tag_name, end_tag_params, tokens)
      end
      true
@@ -1,275 +1,132 @@
 # frozen_string_literal: true
 require 'English'
 module Liquid
  class BlockBody
-    LiquidTagToken      = /\A\s*(#{TagName})\s*(.*?)\z/o
+    FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(#{TagName})(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*)?#{WhitespaceControl}?#{TagEnd}\z/om
+    TAGSTART = "{%".freeze
-    ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
+    VARSTART = "{{".freeze
    WhitespaceOrNothing = /\A\s*\z/
    TAGSTART            = "{%"
    VARSTART            = "{{"
    attr_reader :nodelist
    def initialize
      @nodelist = []
-      @blank    = true
+      @blank = true
    end
-    def parse(tokenizer, parse_context, &block)
+    def parse(tokens, options)
-      raise FrozenError, "can't modify frozen Liquid::BlockBody" if frozen?
+      while token = tokens.shift
-
+        begin
-      parse_context.line_number = tokenizer.line_number
+          unless token.empty?
-
+            case
-      if tokenizer.for_liquid_tag
+            when token.start_with?(TAGSTART)
-        parse_for_liquid_tag(tokenizer, parse_context, &block)
+              if token =~ FullToken
-      else
+                tag_name = $1
-        parse_for_document(tokenizer, parse_context, &block)
+                markup = $2
-      end
+                # fetch the tag from registered blocks
-    end
+                if tag = Template.tags[tag_name]
-
+                  markup = token.child(markup) if token.is_a?(Token)
-    def freeze
+                  new_tag = tag.parse(tag_name, markup, tokens, options)
-      @nodelist.freeze
+                  new_tag.line_number = token.line_number if token.is_a?(Token)
-      super
+                  @blank &&= new_tag.blank?
-    end
+                  @nodelist << new_tag
-
+                else
-    private def parse_for_liquid_tag(tokenizer, parse_context)
+                  # end parsing if we reach an unknown tag and let the caller decide
-      while (token = tokenizer.shift)
+                  # determine how to proceed
-        unless token.empty? || token.match?(WhitespaceOrNothing)
+                  return yield tag_name, markup
-          unless token =~ LiquidTagToken
+                end
-            # line isn't empty but didn't match tag syntax, yield and let the
+              else
-            # caller raise a syntax error
+                raise_missing_tag_terminator(token, options)
-            return yield token, token
+              end
            when token.start_with?(VARSTART)
              new_var = create_variable(token, options)
              new_var.line_number = token.line_number if token.is_a?(Token)
              @nodelist << new_var
              @blank = false
            else
              @nodelist << token
              @blank &&= !!(token =~ /\A\s*\z/)
            end
          end
-          tag_name = Regexp.last_match(1)
+        rescue SyntaxError => e
-          markup   = Regexp.last_match(2)
+          e.set_line_number_from_token(token)
-
+          raise
          if tag_name == 'liquid'
            parse_context.line_number -= 1
            next parse_liquid_tag(markup, parse_context)
          end
          unless (tag = parse_context.environment.tag_for_name(tag_name))
            # end parsing if we reach an unknown tag and let the caller decide
            # determine how to proceed
            return yield tag_name, markup
          end
          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
          @blank &&= new_tag.blank?
          @nodelist << new_tag
        end
        parse_context.line_number = tokenizer.line_number
      end
      yield nil, nil
    end
    # @api private
    def self.unknown_tag_in_liquid_tag(tag, parse_context)
      Block.raise_unknown_tag(tag, 'liquid', '%}', parse_context)
    end
    # @api private
    def self.raise_missing_tag_terminator(token, parse_context)
      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
    end
    # @api private
    def self.raise_missing_variable_terminator(token, parse_context)
      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
    end
    # @api private
    def self.render_node(context, output, node)
      node.render_to_output_buffer(context, output)
    rescue => exc
      blank_tag = !node.instance_of?(Variable) && node.blank?
      rescue_render_node(context, output, node.line_number, exc, blank_tag)
    end
    # @api private
    def self.rescue_render_node(context, output, line_number, exc, blank_tag)
      case exc
      when MemoryError
        raise
      when UndefinedVariable, UndefinedDropMethod, UndefinedFilter
        context.handle_error(exc, line_number)
      else
        error_message = context.handle_error(exc, line_number)
        error_mode = context.registers.static[:template_error_mode]
        suppress_error_text = blank_tag && error_mode != :strict2 && error_mode != :rigid
        unless suppress_error_text # blank-tag suppression is kept for backwards compatibility outside strict2
          output << error_message
        end
      end
    end
    private def parse_liquid_tag(markup, parse_context)
      liquid_tag_tokenizer = parse_context.new_tokenizer(
        markup, start_line_number: parse_context.line_number, for_liquid_tag: true
      )
      parse_for_liquid_tag(liquid_tag_tokenizer, parse_context) do |end_tag_name, _end_tag_markup|
        if end_tag_name
          BlockBody.unknown_tag_in_liquid_tag(end_tag_name, parse_context)
        end
      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)
      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)
          end
          tag_name = Regexp.last_match(2)
          markup   = Regexp.last_match(4)
          if parse_context.line_number
            # newlines inside the tag should increase the line number,
            # particularly important for multiline {% liquid %} tags
            parse_context.line_number += Regexp.last_match(1).count("\n") + Regexp.last_match(3).count("\n")
          end
          if tag_name == 'liquid'
            parse_liquid_tag(markup, parse_context)
            next
          end
          unless (tag = parse_context.environment.tag_for_name(tag_name))
            # end parsing if we reach an unknown tag and let the caller decide
            # determine how to proceed
            return yield tag_name, markup
          end
          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
          @blank &&= new_tag.blank?
          @nodelist << new_tag
        when token.start_with?(VARSTART)
          whitespace_handler(token, parse_context)
          @nodelist << create_variable(token, parse_context)
          @blank = false
        else
          if parse_context.trim_whitespace
            token.lstrip!
          end
          parse_context.trim_whitespace = false
          @nodelist << token
          @blank &&= token.match?(WhitespaceOrNothing)
        end
        parse_context.line_number = tokenizer.line_number
      end
      yield nil, nil
    end
    def whitespace_handler(token, parse_context)
      if token[2] == WhitespaceControl
        previous_token = @nodelist.last
        if previous_token.is_a?(String)
          first_byte = previous_token.getbyte(0)
          previous_token.rstrip!
          if previous_token.empty? && parse_context[:bug_compatible_whitespace_trimming] && first_byte
            previous_token << first_byte
          end
        end
      end
      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
    end
    def blank?
      @blank
    end
-    # Remove blank strings in the block body for a control flow tag (e.g. `if`, `for`, `case`, `unless`)
+    def warnings
-    # with a blank body.
+      all_warnings = []
-    #
+      nodelist.each do |node|
-    # For example, in a conditional assignment like the following
+        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
-    #
+      end
-    # ```
+      all_warnings
    # {% if size > max_size %}
    #   {% assign size = max_size %}
    # {% endif %}
    # ```
    #
    # we assume the intention wasn't to output the blank spaces in the `if` tag's block body, so this method
    # will remove them to reduce the render output size.
    #
    # Note that it is now preferred to use the `liquid` tag for this use case.
    def remove_blank_strings
      raise "remove_blank_strings only support being called on a blank block body" unless @blank
      @nodelist.reject! { |node| node.instance_of?(String) }
    end
    def render(context)
-      render_to_output_buffer(context, +'')
+      @output ||= []
-    end
+      @output.clear
      context.resource_limits.render_score += @nodelist.length
-    def render_to_output_buffer(context, output)
+      @nodelist.each do |token|
-      freeze unless frozen?
+        # Break out if we have any unhanded interrupts.
        break if context.has_interrupt?
-      context.resource_limits.increment_render_score(@nodelist.length)
+        begin
      idx = 0
      while (node = @nodelist[idx])
        if node.instance_of?(String)
          output << node
        else
          render_node(context, output, node)
          # If we get an Interrupt that means the block must stop processing. An
          # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}. These tags may also occur through Block or Include tags.
+          # or {% continue %}
-          break if context.interrupt? # might have happened in a for-block
+          if token.is_a?(Continue) or token.is_a?(Break)
-        end
+            context.push_interrupt(token.interrupt)
-        idx += 1
+            break
          end
-        context.resource_limits.increment_write_score(output)
+          token_output = render_token(token, context)
          unless token.is_a?(Block) && token.blank?
            @output << token_output
          end
        rescue MemoryError => e
          raise e
        rescue ::StandardError => e
          @output << context.handle_error(e, token)
        end
      end
-      output
+      @output.join
    end
    private
-    def render_node(context, output, node)
+    def render_token(token, context)
-      BlockBody.render_node(context, output, node)
+      token_output = (token.respond_to?(:render) ? token.render(context) : token)
-    end
+      token_str = token_output.is_a?(Array) ? token_output.join : token_output.to_s
-    def create_variable(token, parse_context)
+      context.resource_limits.render_length += token_str.length
-      if token.end_with?("}}")
+      if context.resource_limits.reached?
-        i = 2
+        raise MemoryError.new("Memory limits exceeded".freeze)
        i = 3 if token[i] == "-"
        parse_end = token.length - 3
        parse_end -= 1 if token[parse_end] == "-"
        markup_end = parse_end - i + 1
        markup = markup_end <= 0 ? "" : token.slice(i, markup_end)
        return Variable.new(markup, parse_context)
      end
-
+      token_str
      BlockBody.raise_missing_variable_terminator(token, parse_context)
    end
-    # @deprecated Use {.raise_missing_tag_terminator} instead
+    def create_variable(token, options)
-    def raise_missing_tag_terminator(token, parse_context)
+      token.scan(ContentOfVariable) do |content|
-      BlockBody.raise_missing_tag_terminator(token, parse_context)
+        markup = token.is_a?(Token) ? token.child(content.first) : content.first
        return Variable.new(markup, options)
      end
      raise_missing_variable_terminator(token, options)
    end
-    # @deprecated Use {.raise_missing_variable_terminator} instead
+    def raise_missing_tag_terminator(token, options)
-    def raise_missing_variable_terminator(token, parse_context)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
-      BlockBody.raise_missing_variable_terminator(token, parse_context)
+    end
    def raise_missing_variable_terminator(token, options)
      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
    end
  end
 end
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 module Liquid
  # Container for liquid nodes which conveniently wraps decision making logic
  #
@@ -8,88 +6,55 @@ module Liquid
  #   c = Condition.new(1, '==', 1)
  #   c.evaluate #=> true
  #
-  class Condition # :nodoc:
+  class Condition #:nodoc:
    @@operators = {
-      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<' => :<,
+      '<'.freeze  => :<,
-      '>' => :>,
+      '>'.freeze  => :>,
-      '>=' => :>=,
+      '>='.freeze => :>=,
-      '<=' => :<=,
+      '<='.freeze => :<=,
-      'contains' => lambda do |_cond, left, right|
+      'contains'.freeze => lambda { |cond, left, right|
-        if left && right && left.respond_to?(:include?)
+        left && right && left.respond_to?(:include?) ? left.include?(right) : false
-          right = right.to_s if left.is_a?(String)
+      }
          left.include?(right)
        else
          false
        end
      rescue Encoding::CompatibilityError
        # "✅".b.include?("✅") raises Encoding::CompatibilityError despite being materially equal
        left.b.include?(right.b)
      end,
    }
    class MethodLiteral
      attr_reader :method_name, :to_s
      def initialize(method_name, to_s)
        @method_name = method_name
        @to_s = to_s
      end
    end
    @@method_literals = {
      'blank' => MethodLiteral.new(:blank?, '').freeze,
      'empty' => MethodLiteral.new(:empty?, '').freeze,
    }
    def self.operators
      @@operators
    end
-    def self.parse_expression(parse_context, markup, safe: false)
+    attr_reader :attachment
      @@method_literals[markup] || parse_context.parse_expression(markup, safe: safe)
    end
    attr_reader :attachment, :child_condition
    attr_accessor :left, :operator, :right
    def initialize(left = nil, operator = nil, right = nil)
-      @left     = left
+      @left = left
      @operator = operator
-      @right    = right
+      @right = right
      @child_relation  = nil
      @child_condition = nil
    end
-    def evaluate(context = deprecated_default_context)
+    def evaluate(context = Context.new)
-      condition = self
+      result = interpret_condition(left, right, operator, context)
      result = nil
      loop do
        result = interpret_condition(condition.left, condition.right, condition.operator, context)
-        case condition.child_relation
+      case @child_relation
-        when :or
+      when :or
-          break if Liquid::Utils.to_liquid_value(result)
+        result || @child_condition.evaluate(context)
-        when :and
+      when :and
-          break unless Liquid::Utils.to_liquid_value(result)
+        result && @child_condition.evaluate(context)
-        else
+      else
-          break
+        result
        end
        condition = condition.child_condition
      end
      result
    end
    def or(condition)
-      @child_relation  = :or
+      @child_relation = :or
      @child_condition = condition
    end
    def and(condition)
-      @child_relation  = :and
+      @child_relation = :and
      @child_condition = condition
    end
@@ -102,125 +67,65 @@ module Liquid
    end
    def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
    end
    protected
    attr_reader :child_relation
    private
    def equal_variables(left, right)
-      if left.is_a?(MethodLiteral)
+      if left.is_a?(Symbol)
-        return call_method_literal(left, right)
+        if right.respond_to?(left)
          return right.send(left.to_s)
        else
          return nil
        end
      end
-      if right.is_a?(MethodLiteral)
+      if right.is_a?(Symbol)
-        return call_method_literal(right, left)
+        if left.respond_to?(right)
          return left.send(right.to_s)
        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
      # return this as the result.
-      return context.evaluate(left) if op.nil?
+      return context.evaluate(left) if op == nil
-      left  = Liquid::Utils.to_liquid_value(context.evaluate(left))
+      left = context.evaluate(left)
-      right = Liquid::Utils.to_liquid_value(context.evaluate(right))
+      right = context.evaluate(right)
-      operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
+      operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))
      if operation.respond_to?(:call)
        operation.call(self, left, right)
-      elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
+      elsif left.respond_to?(operation) and right.respond_to?(operation)
        begin
          left.send(operation, right)
        rescue ::ArgumentError => e
-          raise Liquid::ArgumentError, e.message
+          raise Liquid::ArgumentError.new(e.message)
        end
-      end
+      else
-    end
+        nil
    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
        ].compact
      end
    end
  end
  class ElseCondition < Condition
    def else?
      true
    end
-    def evaluate(_context)
+    def evaluate(context)
      true
    end
  end
 end
@@ -1,8 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  module Const
    EMPTY_HASH = {}.freeze
    EMPTY_ARRAY = [].freeze
  end
 end
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Context keeps the variable stack and resolves variables, as well as keywords
  #
  #   context['variable'] = 'testing'
@@ -14,58 +13,32 @@ module Liquid
  #
  #   context['bob']  #=> nil  class Context
  class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
+    attr_reader :scopes, :registers, :environments, :resource_limits
-    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters, :environment
+    attr_accessor :exception_handler
-    # rubocop:disable Metrics/ParameterLists
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-    def self.build(environment: Environment.default, environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {}, &block)
+      @environments     = [environments].flatten
-      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments, environment, &block)
+      @scopes           = [(outer_scope || {})]
-    end
+      @registers        = registers
      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
      squash_instance_assigns_with_environments
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {}, environment = Environment.default)
+      @this_stack_used = false
      @environment = environment
      @environments = [environments]
      @environments.flatten!
      @static_environments = [static_environments].flatten(1).freeze
      @scopes              = [outer_scope || {}]
      @registers           = registers.is_a?(Registers) ? registers : Registers.new(registers)
      @errors              = []
      @partial             = false
      @strict_variables    = false
      @resource_limits     = resource_limits || ResourceLimits.new(environment.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
      if rethrow_errors
-        self.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
+        self.exception_handler = ->(e) { true }
      end
-      yield self if block_given?
+      @interrupts = nil
-
+      @filters = []
      # Do this last, since it could result in this object being passed to a Proc in the environment
      squash_instance_assigns_with_environments
    end
    # rubocop:enable Metrics/ParameterLists
-    def warnings
+    def errors
-      @warnings ||= []
+      @errors ||= []
    end
    def strainer
-      @strainer ||= @environment.create_strainer(self, @filters)
+      @strainer ||= Strainer.create(self, @filters)
    end
    # Adds filters to this context.
@@ -78,31 +51,30 @@ module Liquid
      @strainer = nil
    end
    def apply_global_filter(obj)
      global_filter.nil? ? obj : global_filter.call(obj)
    end
    # are there any not handled interrupts?
-    def interrupt?
+    def has_interrupt?
-      !@interrupts.empty?
+      @interrupts && !@interrupts.empty?
    end
    # push an interrupt to the stack. this interrupt is considered not handled.
    def push_interrupt(e)
-      @interrupts.push(e)
+      (@interrupts ||= []).push(e)
    end
    # pop an interrupt from the stack
    def pop_interrupt
-      @interrupts.pop
+      @interrupts.pop if @interrupts
    end
-    def handle_error(e, line_number = nil)
+
-      e = internal_error unless e.is_a?(Liquid::Error)
+    def handle_error(e, token=nil)
-      e.template_name ||= template_name
+      if e.is_a?(Liquid::Error)
-      e.line_number   ||= line_number
+        e.set_line_number_from_token(token)
      end
      errors.push(e)
-      exception_renderer.call(e).to_s
+      raise if exception_handler && exception_handler.call(e)
      Liquid::Error.render(e)
    end
    def invoke(method, *args)
@@ -110,9 +82,9 @@ module Liquid
    end
    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
-    def push(new_scope = {})
+    def push(new_scope={})
      @scopes.unshift(new_scope)
-      check_overflow
+      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
    end
    # Merge a hash of variables in the current local scope
@@ -133,33 +105,20 @@ module Liquid
    #      context['var'] = 'hi'
    #   end
    #
-    #   context['var']  #=> nil
+    #   context['var]  #=> nil
-    def stack(new_scope = {})
+    def stack(new_scope=nil)
-      push(new_scope)
+      old_stack_used = @this_stack_used
      if new_scope
        push(new_scope)
        @this_stack_used = true
      else
        @this_stack_used = false
      end
      yield
    ensure
-      pop
+      pop if @this_stack_used
-    end
+      @this_stack_used = old_stack_used
    # Creates a new context inheriting resource limits, filters, environment etc.,
    # but with an isolated scope.
    def new_isolated_subcontext
      check_overflow
      self.class.build(
        environment: @environment,
        resource_limits: resource_limits,
        static_environments: static_environments,
        registers: Registers.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
    def clear_instance_assigns
@@ -168,6 +127,10 @@ module Liquid
    # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
    def []=(key, value)
      unless @this_stack_used
        @this_stack_used = true
        push({})
      end
      @scopes[0][key] = value
    end
@@ -180,20 +143,11 @@ module Liquid
    # Example:
    #   products == empty #=> products.empty?
    def [](expression)
-      evaluate(Expression.parse(expression, @string_scanner))
+      evaluate(Expression.parse(expression))
    end
-    def key?(key)
+    def has_key?(key)
-      find_variable(key, raise_on_not_found: false) != nil
+      self[key] != nil
    end
    # Checks whether a variable is defined in any scope, including nil-valued keys.
    # Unlike #key?, this uses Hash#key? so that variables explicitly set to nil
    # are still considered defined.
    def variable_defined?(key)
      @scopes.any? { |s| s.key?(key) } ||
        @environments.any? { |e| e.key?(key) } ||
        @static_environments.any? { |e| e.key?(key) }
    end
    def evaluate(object)
@@ -201,113 +155,52 @@ module Liquid
    end
    # Fetches an object starting at the local scope and then moving up the hierachy
-    def find_variable(key, raise_on_not_found: true)
+    def find_variable(key)
      # This was changed from find() to find_index() because this is a very hot
      # path and find_index() is optimized in MRI to reduce object allocation
-      index = @scopes.find_index { |s| s.key?(key) }
+      index = @scopes.find_index { |s| s.has_key?(key) }
      scope = @scopes[index] if index
-      fallback_to_self_drop = key == Expression::SELF && index.nil?
+      variable = nil
-      variable = if index
+      if scope.nil?
-        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
+        @environments.each do |e|
-      else
+          variable = lookup_and_evaluate(e, key)
-        try_variable_find_in_environments(
+          unless variable.nil?
-          key,
+            scope = e
-          raise_on_not_found: raise_on_not_found && !fallback_to_self_drop,
+            break
-        )
+          end
        end
      end
-      # `self` resolves to a SelfDrop (enabling `self['var']` lookups),
+      scope     ||= @environments.last || @scopes.last
-      # but only after the normal environment lookup doesn't find a value.
+      variable  ||= lookup_and_evaluate(scope, key)
      return @self_drop ||= SelfDrop.new(self) if fallback_to_self_drop && variable.nil?
-      # 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
+      return variable
      liquid_variable.context = self if variable != liquid_variable && liquid_variable.respond_to?(:context=)
      liquid_variable
    end
-    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
+    def lookup_and_evaluate(obj, key)
-      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
+      if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
-        raise Liquid::UndefinedVariable, "undefined variable #{key}"
+        obj[key] = (value.arity == 0) ? value.call : value.call(self)
      end
      value = obj[key]
      if value.is_a?(Proc) && obj.respond_to?(:[]=)
        obj[key] = value.arity == 0 ? value.call : value.call(self)
      else
        value
      end
    end
    def with_disabled_tags(tag_names)
      tag_names.each do |name|
        @disabled_tags[name] = @disabled_tags.fetch(name, 0) + 1
      end
      yield
    ensure
      tag_names.each do |name|
        @disabled_tags[name] -= 1
      end
    end
    def tag_disabled?(tag_name)
      @disabled_tags.fetch(tag_name, 0) > 0
    end
    protected
    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags
    private
-
+      def squash_instance_assigns_with_environments
-    attr_reader :base_scope_depth
+        @scopes.last.each_key do |k|
-
+          @environments.each do |env|
-    def try_variable_find_in_environments(key, raise_on_not_found:)
+            if env.has_key?(k)
-      @environments.each do |environment|
+              scopes.last[k] = lookup_and_evaluate(env, k)
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+              break
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
+            end
          return found_variable
        end
      end
      @static_environments.each do |environment|
        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
        if !found_variable.nil? || @strict_variables && raise_on_not_found
          return found_variable
        end
      end
      nil
    end
    def check_overflow
      raise StackLevelError, "Nesting too deep" if overflow?
    end
    def overflow?
      base_scope_depth + @scopes.length > Block::MAX_DEPTH
    end
    def internal_error
      # raise and catch to set backtrace and cause on exception
      raise Liquid::InternalError, 'internal'
    rescue Liquid::InternalError => exc
      exc
    end
    def squash_instance_assigns_with_environments
      @scopes.last.each_key do |k|
        @environments.each do |env|
          if env.key?(k)
            scopes.last[k] = lookup_and_evaluate(env, k)
            break
          end
        end
-      end
+      end # squash_instance_assigns_with_environments
    end # squash_instance_assigns_with_environments
  end # Context
 end # Liquid
@@ -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
@@ -1,64 +1,23 @@
 # frozen_string_literal: true
 module Liquid
-  class Document
+  class Document < BlockBody
-    def self.parse(tokens, parse_context)
+    def self.parse(tokens, options)
-      doc = new(parse_context)
+      doc = new
-      doc.parse(tokens, parse_context)
+      doc.parse(tokens, options)
      doc
    end
-    attr_reader :parse_context, :body
+    def parse(tokens, options)
-
+      super do |end_tag_name, end_tag_params|
-    def initialize(parse_context)
+        unknown_tag(end_tag_name, options) if end_tag_name
      @parse_context = parse_context
      @body = new_body
    end
    def nodelist
      @body.nodelist
    end
    def parse(tokenizer, parse_context)
      while parse_body(tokenizer)
      end
      @body.freeze
    rescue SyntaxError => e
      e.line_number ||= parse_context.line_number
      raise
    end
-    def unknown_tag(tag, _markup, _tokenizer)
+    def unknown_tag(tag, options)
      case tag
-      when 'else', 'end'
+      when 'else'.freeze, 'end'.freeze
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag", tag: tag)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_outer_tag".freeze, :tag => tag))
      else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
      end
    end
    def render_to_output_buffer(context, output)
      @body.render_to_output_buffer(context, output)
    end
    def render(context)
      render_to_output_buffer(context, +'')
    end
    private
    def new_body
      parse_context.new_block_body
    end
    def parse_body(tokenizer)
      @body.parse(tokenizer, parse_context) do |unknown_tag_name, unknown_tag_markup|
        if unknown_tag_name
          unknown_tag(unknown_tag_name, unknown_tag_markup, tokenizer)
          true
        else
          false
        end
      end
    end
  end
@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 require 'set'
 module Liquid
  # A drop in liquid is a class which allows you to export DOM like things to liquid.
  # Methods of drops are callable.
  # The main use for liquid drops is to implement lazy loaded objects.
@@ -20,31 +19,28 @@ module Liquid
  #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
  #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
  #
-  # Your drop can either implement the methods sans any parameters
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
-  # or implement the liquid_method_missing(name) method which is a catch all.
+  # catch all.
  class Drop
    attr_writer :context
-    def initialize
+    EMPTY_STRING = ''.freeze
      @context = nil
    end
    # Catch all for the method
-    def liquid_method_missing(method)
+    def before_method(method)
-      return unless @context&.strict_variables
+      nil
      raise Liquid::UndefinedDropMethod, "undefined method #{method}"
    end
    # called by liquid to invoke a drop
    def invoke_drop(method_or_key)
-      if self.class.invokable?(method_or_key)
+      if method_or_key && method_or_key != EMPTY_STRING && self.class.invokable?(method_or_key)
        send(method_or_key)
      else
-        liquid_method_missing(method_or_key)
+        before_method(method_or_key)
      end
    end
-    def key?(_name)
+    def has_key?(name)
      true
    end
@@ -60,25 +56,26 @@ module Liquid
      self.class.name
    end
-    alias_method :[], :invoke_drop
+    alias :[] :invoke_drop
    private
    # Check for method existence without invoking respond_to?, which creates symbols
    def self.invokable?(method_name)
-      invokable_methods.include?(method_name.to_s)
+      self.invokable_methods.include?(method_name.to_s)
    end
    def self.invokable_methods
-      @invokable_methods ||= begin
+      unless @invokable_methods
        blacklist = Liquid::Drop.public_instance_methods + [:each]
        if include?(Enumerable)
          blacklist += Enumerable.public_instance_methods
-          blacklist -= [:sort, :count, :first, :min, :max]
+          blacklist -= [:sort, :count, :first, :min, :max, :include?]
        end
        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
-        Set.new(whitelist.map(&:to_s))
+        @invokable_methods = Set.new(whitelist.map(&:to_s))
      end
      @invokable_methods
    end
  end
 end
@@ -1,159 +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 default error mode for all templates. This can be overridden on a
    # per-template basis.
    attr_accessor :error_mode
    # The tags that are available to use in the template.
    attr_accessor :tags
    # The strainer template which is used to store filters that are available to
    # use in templates.
    attr_accessor :strainer_template
    # The exception renderer that is used to render exceptions that are raised
    # when rendering a template
    attr_accessor :exception_renderer
    # The default file system that is used to load templates from.
    attr_accessor :file_system
    # The default resource limits that are used to limit the resources that a
    # template can consume.
    attr_accessor :default_resource_limits
    class << self
      # Creates a new environment instance.
      #
      # @param tags [Hash] The tags that are available to use in
      #  the template.
      # @param file_system The default file system that is used
      #  to load templates from.
      # @param error_mode [Symbol] The default error mode for all templates
      #  (either :strict2, :strict, :warn, or :lax).
      # @param exception_renderer [Proc] The exception renderer that is used to
      #   render exceptions.
      # @yieldparam environment [Environment] The environment instance that is being built.
      # @return [Environment] The new environment instance.
      def build(tags: nil, file_system: nil, error_mode: nil, exception_renderer: nil)
        ret = new
        ret.tags = tags if tags
        ret.file_system = file_system if file_system
        ret.error_mode = error_mode if error_mode
        ret.exception_renderer = exception_renderer if exception_renderer
        yield ret if block_given?
        ret.freeze
      end
      # Returns the default environment instance.
      #
      # @return [Environment] The default environment instance.
      def default
        @default ||= new
      end
      # Sets the default environment instance for the duration of the block
      #
      # @param environment [Environment] The environment instance to use as the default for the
      #   duration of the block.
      # @yield
      # @return [Object] The return value of the block.
      def dangerously_override(environment)
        original_default = @default
        @default = environment
        yield
      ensure
        @default = original_default
      end
    end
    # Initializes a new environment instance.
    # @api private
    def initialize
      @tags = Tags::STANDARD_TAGS.dup
      @error_mode = :lax
      @strainer_template = Class.new(StrainerTemplate).tap do |klass|
        klass.add_filter(StandardFilters)
      end
      @exception_renderer = ->(exception) { exception }
      @file_system = BlankFileSystem.new
      @default_resource_limits = Const::EMPTY_HASH
      @strainer_template_class_cache = {}
    end
    # Registers a new tag with the environment.
    #
    # @param name [String] The name of the tag.
    # @param klass [Liquid::Tag] The class that implements the tag.
    # @return [void]
    def register_tag(name, klass)
      @tags[name] = klass
    end
    # Registers a new filter with the environment.
    #
    # @param filter [Module] The module that contains the filter methods.
    # @return [void]
    def register_filter(filter)
      @strainer_template_class_cache.clear
      @strainer_template.add_filter(filter)
    end
    # Registers multiple filters with this environment.
    #
    # @param filters [Array<Module>] The modules that contain the filter methods.
    # @return [self]
    def register_filters(filters)
      @strainer_template_class_cache.clear
      filters.each { |f| @strainer_template.add_filter(f) }
      self
    end
    # Creates a new strainer instance with the given filters, caching the result
    # for faster lookup.
    #
    # @param context [Liquid::Context] The context that the strainer will be
    #   used in.
    # @param filters [Array<Module>] The filters that the strainer will have
    #   access to.
    # @return [Liquid::Strainer] The new strainer instance.
    def create_strainer(context, filters = Const::EMPTY_ARRAY)
      return @strainer_template.new(context) if filters.empty?
      strainer_template = @strainer_template_class_cache[filters] ||= begin
        klass = Class.new(@strainer_template)
        filters.each { |f| klass.add_filter(f) }
        klass
      end
      strainer_template.new(context)
    end
    # Returns the names of all the filter methods that are available to use in
    # the strainer template.
    #
    # @return [Array<String>] The names of all the filter methods.
    def filter_method_names
      @strainer_template.filter_method_names
    end
    # Returns the tag class for the given tag name.
    #
    # @param name [String] The name of the tag.
    # @return [Liquid::Tag] The tag class.
    def tag_for_name(name)
      @tags[name]
    end
    def freeze
      @tags.freeze
      # TODO: freeze the tags, currently this is not possible because of liquid-c
      # @strainer_template.freeze
      super
    end
  end
 end
@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 module Liquid
  class Error < ::StandardError
    attr_accessor :line_number
    attr_accessor :template_name
    attr_accessor :markup_context
-    def to_s(with_prefix = true)
+    def to_s(with_prefix=true)
-      str = +""
+      str = ""
      str << message_prefix if with_prefix
      str << super()
@@ -19,20 +16,32 @@ module Liquid
      str
    end
    def set_line_number_from_token(token)
      return unless token.respond_to?(:line_number)
      return if self.line_number
      self.line_number = token.line_number
    end
    def self.render(e)
      if e.is_a?(Liquid::Error)
        e.to_s
      else
        "Liquid error: #{e.to_s}"
      end
    end
    private
    def message_prefix
-      str = +""
+      str = ""
-      str << if is_a?(SyntaxError)
+      if is_a?(SyntaxError)
-        "Liquid syntax error"
+        str << "Liquid syntax error"
      else
-        "Liquid error"
+        str << "Liquid error"
      end
      if line_number
-        str << " ("
+        str << " (line #{line_number})"
        str << template_name << " " if template_name
        str << "line " << line_number.to_s << ")"
      end
      str << ": "
@@ -40,20 +49,12 @@ module Liquid
    end
  end
-  ArgumentError         = Class.new(Error)
+  class ArgumentError < Error; end
-  ContextError          = Class.new(Error)
+  class ContextError < Error; end
-  FileSystemError       = Class.new(Error)
+  class FileSystemError < Error; end
-  StandardError         = Class.new(Error)
+  class StandardError < Error; end
-  SyntaxError           = Class.new(Error)
+  class SyntaxError < Error; end
-  StackLevelError       = Class.new(Error)
+  class StackLevelError < Error; end
-  MemoryError           = Class.new(Error)
+  class TaintedError < Error; end
-  ZeroDivisionError     = Class.new(Error)
+  class MemoryError < Error; end
  FloatDomainError      = Class.new(Error)
  UndefinedVariable     = Class.new(Error)
  UndefinedDropMethod   = Class.new(Error)
  UndefinedFilter       = Class.new(Error)
  MethodOverrideError   = Class.new(Error)
  DisabledError         = Class.new(Error)
  InternalError         = Class.new(Error)
  TemplateEncodingError = Class.new(Error)
 end
@@ -1,130 +1,33 @@
 # frozen_string_literal: true
 module Liquid
  class Expression
    SELF = 'self'
    LITERALS = {
-      nil => nil,
+      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'nil' => nil,
+      'true'.freeze  => true,
-      'null' => nil,
+      'false'.freeze => false,
-      '' => nil,
+      'blank'.freeze => :blank?,
-      'true' => true,
+      'empty'.freeze => :empty?
-      'false' => false,
+    }
      'blank' => '',
      'empty' => '',
      # in lax mode, minus sign can be a VariableLookup
      # For simplicity and performace, we treat it like a literal
      '-' => VariableLookup.parse("-", nil).freeze,
    }.freeze
-    DOT = ".".ord
+    def self.parse(markup)
-    ZERO = "0".ord
+      if LITERALS.key?(markup)
-    NINE = "9".ord
+        LITERALS[markup]
-    DASH = "-".ord
+      else
    # 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/
    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
        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
+        when /\A'(.*)'\z/m # Single quoted strings
-          return Integer(markup, 10)
+          $1
-        when FLOAT_REGEX
+        when /\A"(.*)"\z/m # Double quoted strings
-          return markup.to_f
+          $1
-        end
+        when /\A(-?\d+)\z/ # Integer and floats
-
+          $1.to_i
-        ss.string = markup
+        when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
-        # the first byte must be a digit or  a dash
+          RangeLookup.parse($1, $2)
-        byte = ss.scan_byte
+        when /\A(-?\d[\d\.]+)\z/ # Floats
-
+          $1.to_f
        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."
+          VariableLookup.parse(markup)
          markup.byteslice(0, first_dot_pos).to_f
        end
      end
    end
  end
 end
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 require 'time'
 require 'date'
@@ -9,56 +7,44 @@ class String # :nodoc:
  end
 end
-class Symbol # :nodoc:
+class Array  # :nodoc:
  def to_liquid
    to_s
  end
 end
 class Array # :nodoc:
  def to_liquid
    self
  end
 end
-class Hash # :nodoc:
+class Hash  # :nodoc:
  def to_liquid
    self
  end
 end
-class Numeric # :nodoc:
+class Numeric  # :nodoc:
  def to_liquid
    self
  end
 end
-class Range # :nodoc:
+class Time  # :nodoc:
  def to_liquid
    self
  end
 end
-class Time # :nodoc:
+class DateTime < Date  # :nodoc:
  def to_liquid
    self
  end
 end
-class DateTime < Date # :nodoc:
+class Date  # :nodoc:
  def to_liquid
    self
  end
 end
 class Date # :nodoc:
  def to_liquid
    self
  end
 end
 class TrueClass
-  def to_liquid # :nodoc:
+  def to_liquid  # :nodoc:
    self
  end
 end
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 module Liquid
  # A Liquid file system is a way to let your templates retrieve other templates for use with the include tag.
  #
@@ -10,13 +8,13 @@ module Liquid
  #
  # Example:
  #
-  #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+  # Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
-  #   liquid = Liquid::Template.parse(template)
+  # liquid = Liquid::Template.parse(template)
  #
  # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
  class BlankFileSystem
    # Called by Liquid to retrieve a template file
-    def read_template_file(_template_path)
+    def read_template_file(template_path)
      raise FileSystemError, "This liquid context does not allow includes."
    end
  end
@@ -28,10 +26,10 @@ module Liquid
  #
  # Example:
  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path")
+  # file_system = Liquid::LocalFileSystem.new("/some/path")
  #
-  #   file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
+  # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
-  #   file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
+  # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
  #
  # Optionally in the second argument you can specify a custom pattern for template filenames.
  # The Kernel::sprintf format specification is used.
@@ -39,35 +37,35 @@ module Liquid
  #
  # Example:
  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
+  # file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
  #
-  #   file_system.full_path("index") # => "/some/path/index.html"
+  # file_system.full_path("index") # => "/some/path/index.html"
  #
  class LocalFileSystem
    attr_accessor :root
-    def initialize(root, pattern = "_%s.liquid")
+    def initialize(root, pattern = "_%s.liquid".freeze)
-      @root    = root
+      @root = root
      @pattern = pattern
    end
    def read_template_file(template_path)
      full_path = full_path(template_path)
-      raise FileSystemError, "No such template '#{template_path}'" unless File.exist?(full_path)
+      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
      File.read(full_path)
    end
    def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless %r{\A[^./][a-zA-Z0-9_/]+\z}.match?(template_path)
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
-      full_path = if template_path.include?('/')
+      full_path = if template_path.include?('/'.freeze)
        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
      else
        File.join(root, @pattern % template_path)
      end
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path).start_with?(File.expand_path(root))
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /\A#{File.expand_path(root)}/
      full_path
    end
@@ -1,89 +0,0 @@
 # 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
      @length     = length
      @parentloop = parentloop
      @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
    # @liquid_public_docs
    # @liquid_name parentloop
    # @liquid_summary
    #   The parent `forloop` object.
    # @liquid_description
    #   If the current `for` loop isn't nested inside another `for` loop, then `nil` is returned.
    # @liquid_return [forloop]
    attr_reader :parentloop
    attr_reader :name
    # @liquid_public_docs
    # @liquid_summary
    #   The 1-based index of the current iteration.
    # @liquid_return [number]
    def index
      @index + 1
    end
    # @liquid_public_docs
    # @liquid_summary
    #   The 0-based index of the current iteration.
    # @liquid_return [number]
    def index0
      @index
    end
    # @liquid_public_docs
    # @liquid_summary
    #   The 1-based index of the current iteration, in reverse order.
    # @liquid_return [number]
    def rindex
      @length - @index
    end
    # @liquid_public_docs
    # @liquid_summary
    #   The 0-based index of the current iteration, in reverse order.
    # @liquid_return [number]
    def rindex0
      @length - @index - 1
    end
    # @liquid_public_docs
    # @liquid_summary
    #   Returns `true` if the current iteration is the first. Returns `false` if not.
    # @liquid_return [boolean]
    def first
      @index == 0
    end
    # @liquid_public_docs
    # @liquid_summary
    #   Returns `true` if the current iteration is the last. Returns `false` if not.
    # @liquid_return [boolean]
    def last
      @index == @length - 1
    end
    protected
    def increment!
      @index += 1
    end
  end
 end
@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 require 'yaml'
 module Liquid
  class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
+    DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")
-    TranslationError = Class.new(StandardError)
+    class TranslationError < StandardError
    end
    attr_reader :path
@@ -24,17 +23,16 @@ module Liquid
    end
    private
    def interpolate(name, vars)
-      name.gsub(/%\{(\w+)\}/) do
+      name.gsub(/%\{(\w+)\}/) {
        # 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[$1.to_sym]}"
-      end
+      }
    end
    def deep_fetch_translation(name)
-      name.split('.').reduce(locale) do |level, cur|
+      name.split('.'.freeze).reduce(locale) do |level, cur|
-        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
      end
    end
  end
@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 module Liquid
  # An interrupt is any command that breaks processing of a block (ex: a for loop).
  class Interrupt
    attr_reader :message
-    def initialize(message = nil)
+    def initialize(message=nil)
-      @message = message || "interrupt"
+      @message = message || "interrupt".freeze
    end
  end
@@ -1,179 +1,53 @@
-# frozen_string_literal: true
+require "strscan"
 module Liquid
  class Lexer
-    CLOSE_ROUND = [:close_round, ")"].freeze
+    SPECIALS = {
-    CLOSE_SQUARE = [:close_square, "]"].freeze
+      '|'.freeze => :pipe,
-    COLON = [:colon, ":"].freeze
+      '.'.freeze => :dot,
-    COMMA = [:comma, ","].freeze
+      ':'.freeze => :colon,
-    COMPARISION_NOT_EQUAL = [:comparison, "!="].freeze
+      ','.freeze => :comma,
-    COMPARISON_CONTAINS = [:comparison, "contains"].freeze
+      '['.freeze => :open_square,
-    COMPARISON_EQUAL = [:comparison, "=="].freeze
+      ']'.freeze => :close_square,
-    COMPARISON_GREATER_THAN = [:comparison, ">"].freeze
+      '('.freeze => :open_round,
-    COMPARISON_GREATER_THAN_OR_EQUAL = [:comparison, ">="].freeze
+      ')'.freeze => :close_round,
-    COMPARISON_LESS_THAN = [:comparison, "<"].freeze
+      '?'.freeze => :question,
-    COMPARISON_LESS_THAN_OR_EQUAL = [:comparison, "<="].freeze
+      '-'.freeze => :dash
-    COMPARISON_NOT_EQUAL_ALT = [:comparison, "<>"].freeze
+    }
-    DASH = [:dash, "-"].freeze
+    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
    DOT = [:dot, "."].freeze
    DOTDOT = [:dotdot, ".."].freeze
    DOT_ORD = ".".ord
    DOUBLE_STRING_LITERAL = /"[^\"]*"/
    EOS = [:end_of_string].freeze
    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
    OPEN_ROUND = [:open_round, "("].freeze
    OPEN_SQUARE = [:open_square, "["].freeze
    PIPE = [:pipe, "|"].freeze
    QUESTION = [:question, "?"].freeze
    RUBY_WHITESPACE = [" ", "\t", "\r", "\n", "\f"].freeze
    SINGLE_STRING_LITERAL = /'[^\']*'/
-    WHITESPACE_OR_NOTHING = /\s*/
+    DOUBLE_STRING_LITERAL = /"[^\"]*"/
    NUMBER_LITERAL = /-?\d+(\.\d+)?/
    DOTDOT = /\.\./
    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
-    SINGLE_COMPARISON_TOKENS = [].tap do |table|
+    def initialize(input)
-      table["<".ord] = COMPARISON_LESS_THAN
+      @ss = StringScanner.new(input.rstrip)
      table[">".ord] = COMPARISON_GREATER_THAN
      table.freeze
    end
-    TWO_CHARS_COMPARISON_JUMP_TABLE = [].tap do |table|
+    def tokenize
-      table["=".ord] = [].tap do |sub_table|
+      @output = []
        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
-    COMPARISON_JUMP_TABLE = [].tap do |table|
+      while !@ss.eos?
-      table["<".ord] = [].tap do |sub_table|
+        @ss.skip(/\s*/)
-        sub_table["=".ord] = COMPARISON_LESS_THAN_OR_EQUAL
+        tok = case
-        sub_table[">".ord] = COMPARISON_NOT_EQUAL_ALT
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
-        sub_table.freeze
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
-      end
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
-      table[">".ord] = [].tap do |sub_table|
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
-        sub_table["=".ord] = COMPARISON_GREATER_THAN_OR_EQUAL
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
-        sub_table.freeze
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
-      end
+        else
-      table.freeze
+          c = @ss.getch
-    end
+          if s = SPECIALS[c]
-
+            [s,c]
    NEXT_MATCHER_JUMP_TABLE = [].tap do |table|
      "a".upto("z") do |c|
        table[c.ord] = [:id, IDENTIFIER].freeze
        table[c.upcase.ord] = [:id, IDENTIFIER].freeze
      end
      table["_".ord] = [:id, IDENTIFIER].freeze
      "0".upto("9") do |c|
        table[c.ord] = [:number, NUMBER_LITERAL].freeze
      end
      table["-".ord] = [:number, NUMBER_LITERAL].freeze
      table["'".ord] = [:string, SINGLE_STRING_LITERAL].freeze
      table["\"".ord] = [:string, DOUBLE_STRING_LITERAL].freeze
      table.freeze
    end
    SPECIAL_TABLE = [].tap do |table|
      table["|".ord] = PIPE
      table[".".ord] = DOT
      table[":".ord] = COLON
      table[",".ord] = COMMA
      table["[".ord] = OPEN_SQUARE
      table["]".ord] = CLOSE_SQUARE
      table["(".ord] = OPEN_ROUND
      table[")".ord] = CLOSE_ROUND
      table["?".ord] = QUESTION
      table["-".ord] = DASH
    end
    NUMBER_TABLE = [].tap do |table|
      "0".upto("9") do |c|
        table[c.ord] = true
      end
      table.freeze
    end
    # rubocop:disable Metrics/BlockNesting
    class << self
      def tokenize(ss)
        output = []
        until ss.eos?
          ss.skip(WHITESPACE_OR_NOTHING)
          break if ss.eos?
          start_pos = ss.pos
          peeked = ss.peek_byte
          if (special = SPECIAL_TABLE[peeked])
            ss.scan_byte
            # Special case for ".."
            if special == DOT && ss.peek_byte == DOT_ORD
              ss.scan_byte
              output << DOTDOT
            elsif special == DASH
              # Special case for negative numbers
              if (peeked_byte = ss.peek_byte) && NUMBER_TABLE[peeked_byte]
                ss.pos -= 1
                output << [:number, ss.scan(NUMBER_LITERAL)]
              else
                output << special
              end
            else
              output << special
            end
          elsif (sub_table = TWO_CHARS_COMPARISON_JUMP_TABLE[peeked])
            ss.scan_byte
            if (peeked_byte = ss.peek_byte) && (found = sub_table[peeked_byte])
              output << found
              ss.scan_byte
            else
              raise_syntax_error(start_pos, ss)
            end
          elsif (sub_table = COMPARISON_JUMP_TABLE[peeked])
            ss.scan_byte
            if (peeked_byte = ss.peek_byte) && (found = sub_table[peeked_byte])
              output << found
              ss.scan_byte
            else
              output << SINGLE_COMPARISON_TOKENS[peeked]
            end
          else
-            type, pattern = NEXT_MATCHER_JUMP_TABLE[peeked]
+            raise SyntaxError, "Unexpected character #{c}"
            if type && (t = ss.scan(pattern))
              # Special case for "contains"
              output << if type == :id && t == "contains" && output.last&.first != :dot
                COMPARISON_CONTAINS
              else
                [type, t]
              end
            else
              raise_syntax_error(start_pos, ss)
            end
          end
        end
-        # rubocop:enable Metrics/BlockNesting
+        @output << tok
        output << EOS
      rescue ::ArgumentError => e
        if e.message == "invalid byte sequence in #{ss.string.encoding}"
          raise SyntaxError, "Invalid byte sequence in #{ss.string.encoding}"
        else
          raise
        end
      end
-      def raise_syntax_error(start_pos, ss)
+      @output << [:end_of_string]
        ss.pos = start_pos
        # the character could be a UTF-8 character, use getch to get all the bytes
        raise SyntaxError, "Unexpected character #{ss.getch}"
      end
    end
  end
 end
@@ -1,33 +1,23 @@
 ---
  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_delimiter: "'end' 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}"
-    argument:
+      tag_never_closed: "'%{block_name}' tag was never closed"
-      include: "Argument error in tag 'include' - Illegal template name"
+      meta_syntax_error: "Liquid syntax error: #{e.message}"
-    disabled:
+      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
      tag: "usage is not allowed in this context"
@@ -0,0 +1,64 @@
 # Copyright 2007 by Domizio Demichelis
 # This library is free software. It may be used, redistributed and/or modified
 # under the same terms as Ruby itself
 #
 # This extension is used in order to expose the object of the implementing class
 # to liquid as it were a Drop. It also limits the liquid-callable methods of the instance
 # to the allowed method passed with the liquid_methods call
 # Example:
 #
 #   class SomeClass
 #     liquid_methods :an_allowed_method
 #
 #     def an_allowed_method
 #       'this comes from an allowed method'
 #     end
 #
 #     def unallowed_method
 #       'this will never be an output'
 #     end
 #   end
 #
 # if you want to extend the drop to other methods you can defines more methods
 # in the class <YourClass>::LiquidDropClass
 #
 #   class SomeClass::LiquidDropClass
 #     def another_allowed_method
 #       'and this from another allowed method'
 #     end
 #   end
 #
 #
 # usage:
 #   @something = SomeClass.new
 #
 # template:
 #   {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
 #
 # output:
 #   'this comes from an allowed method and this from another allowed method'
 #
 # You can also chain associations, by adding the liquid_method call in the
 # association models.
 #
 class Module
  def liquid_methods(*allowed_methods)
    drop_class = eval "class #{self.to_s}::LiquidDropClass < Liquid::Drop; self; end"
    define_method :to_liquid do
      drop_class.new(self)
    end
    drop_class.class_eval do
      def initialize(object)
        @object = object
      end
      allowed_methods.each do |sym|
        define_method sym do
          @object.send sym
        end
      end
    end
  end
 end
@@ -1,92 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class ParseContext
    attr_accessor :locale, :line_number, :trim_whitespace, :depth
    attr_reader :partial, :warnings, :error_mode, :environment
    def initialize(options = Const::EMPTY_HASH)
      @environment = options.fetch(:environment, Environment.default)
      @template_options = options ? options.dup : {}
      @locale   = @template_options[:locale] ||= I18n.new
      @warnings = []
      # constructing new StringScanner in Lexer, Tokenizer, etc is expensive
      # This StringScanner will be shared by all of them
      @string_scanner = StringScanner.new("")
      @expression_cache = if options[:expression_cache].nil?
        {}
      elsif options[:expression_cache].respond_to?(:[]) && options[:expression_cache].respond_to?(:[]=)
        options[:expression_cache]
      elsif options[:expression_cache]
        {}
      end
      self.depth   = 0
      self.partial = false
    end
    def [](option_key)
      @options[option_key]
    end
    def new_block_body
      Liquid::BlockBody.new
    end
    def new_parser(input)
      @string_scanner.string = input
      Parser.new(@string_scanner, reject_bare_brackets: @error_mode == :strict2 || @error_mode == :rigid)
    end
    def new_tokenizer(source, start_line_number: nil, for_liquid_tag: false)
      Tokenizer.new(
        source: source,
        string_scanner: @string_scanner,
        line_number: start_line_number,
        for_liquid_tag: for_liquid_tag,
      )
    end
    def safe_parse_expression(parser)
      Expression.safe_parse(parser, @string_scanner, @expression_cache)
    end
    def parse_expression(markup, safe: false)
      if !safe && @error_mode == :strict2
        # parse_expression is a widely used API. To maintain backward
        # compatibility while raising awareness about strict2 parser standards,
        # the safe flag supports API users make a deliberate decision.
        #
        # In strict2 mode, markup MUST come from a string returned by the parser
        # (e.g., parser.expression). We're not calling the parser here to
        # prevent redundant parser overhead.
        raise Liquid::InternalError, "unsafe parse_expression cannot be used in strict2 mode"
      end
      Expression.parse(markup, @string_scanner, @expression_cache)
    end
    def partial=(value)
      @partial = value
      @options = value ? partial_options : @template_options
      @error_mode = @options[:error_mode] || @environment.error_mode
    end
    def partial_options
      @partial_options ||= begin
        dont_pass = @template_options[:include_options_blacklist]
        if dont_pass == true
          { locale: locale }
        elsif dont_pass.is_a?(Array)
          @template_options.reject { |k, _v| dont_pass.include?(k) }
        else
          @template_options
        end
      end
    end
  end
 end
@@ -1,42 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class ParseTreeVisitor
    def self.for(node, callbacks = Hash.new(proc {}))
      if defined?(node.class::ParseTreeVisitor)
        node.class::ParseTreeVisitor
      else
        self
      end.new(node, callbacks)
    end
    def initialize(node, callbacks)
      @node      = node
      @callbacks = callbacks
    end
    def add_callback_for(*classes, &block)
      callback = block
      callback = ->(node, _) { yield node } if block.arity.abs == 1
      callback = ->(_, _) { yield } if block.arity.zero?
      classes.each { |klass| @callbacks[klass] = callback }
      self
    end
    def visit(context = nil)
      children.map do |node|
        item, new_context = @callbacks[node.class].call(node, context)
        [
          item,
          ParseTreeVisitor.for(node, @callbacks).visit(new_context || context),
        ]
      end
    end
    protected
    def children
      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : Const::EMPTY_ARRAY
    end
  end
 end
@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 module Liquid
  class Parser
-    def initialize(input, reject_bare_brackets: false)
+    def initialize(input)
-      ss = input.is_a?(StringScanner) ? input : StringScanner.new(input)
+      l = Lexer.new(input)
-      @tokens = Lexer.tokenize(ss)
+      @tokens = l.tokenize
-      @p      = 0 # pointer to current location
+      @p = 0 # pointer to current location
      @reject_bare_brackets = reject_bare_brackets
    end
    def jump(point)
@@ -49,21 +46,11 @@ module Liquid
    def expression
      token = @tokens[@p]
-      case token[0]
+      if token[0] == :id
-      when :id
+        variable_signature
-        str = consume
+      elsif [:string, :number].include? token[0]
        str << variable_lookups
      when :open_square
        if @reject_bare_brackets
          raise SyntaxError, "Bare bracket access is not allowed. Use #{Expression::SELF}['...'] instead"
        end
        str = consume.dup
        str << expression
        str << consume(:close_square)
        str << variable_lookups
      when :string, :number
        consume
-      when :open_round
+      elsif token.first == :open_round
        consume
        first = expression
        consume(:dotdot)
@@ -76,29 +63,26 @@ module Liquid
    end
    def argument
-      str = +""
+      str = ""
      # might be a keyword argument (identifier: expression)
      if look(:id) && look(:colon, 1)
-        str << consume << consume << ' '
+        str << consume << consume << ' '.freeze
      end
      str << expression
      str
    end
-    def variable_lookups
+    def variable_signature
-      str = +""
+      str = consume(:id)
-      loop do
+      if look(:open_square)
-        if look(:open_square)
+        str << consume
-          str << consume
+        str << expression
-          str << expression
+        str << consume(:close_square)
-          str << consume(:close_square)
+      end
-        elsif look(:dot)
+      if look(:dot)
-          str << consume
+        str << consume
-          str << consume(:id)
+        str << variable_signature
        else
          break
        end
      end
      str
    end
@@ -1,72 +1,25 @@
 # frozen_string_literal: true
 module Liquid
  module ParserSwitching
    # Do not use this.
    #
    # It's basically doing the same thing the {#parse_with_selected_parser},
    # except this will try the strict parser regardless of the error mode,
    # and fall back to the lax parser if the error mode is lax or warn,
    # except when in strict2 mode where it uses the strict2 parser.
    #
    # @deprecated Use {#parse_with_selected_parser} instead.
    def strict_parse_with_error_mode_fallback(markup)
      return strict2_parse_with_error_context(markup) if strict2_mode?
      strict_parse_with_error_context(markup)
    rescue SyntaxError => e
      case parse_context.error_mode
      when :rigid
        rigid_warn
        raise
      when :strict2
        raise
      when :strict
        raise
      when :warn
        parse_context.warnings << e
      end
      lax_parse(markup)
    end
    def parse_with_selected_parser(markup)
-      case parse_context.error_mode
+      case @options[:error_mode] || Template.error_mode
-      when :rigid   then rigid_warn && strict2_parse_with_error_context(markup)
+      when :strict then strict_parse_with_error_context(markup)
-      when :strict2 then strict2_parse_with_error_context(markup)
+      when :lax    then lax_parse(markup)
      when :strict  then strict_parse_with_error_context(markup)
      when :lax     then lax_parse(markup)
      when :warn
        begin
-          strict2_parse_with_error_context(markup)
+          return strict_parse_with_error_context(markup)
        rescue SyntaxError => e
-          parse_context.warnings << e
+          e.set_line_number_from_token(markup)
-          lax_parse(markup)
+          @warnings ||= []
          @warnings << e
          return lax_parse(markup)
        end
      end
    end
    def strict2_mode?
      parse_context.error_mode == :strict2 || parse_context.error_mode == :rigid
    end
    private
    def rigid_warn
      Deprecations.warn(':rigid', ':strict2')
    end
    def strict2_parse_with_error_context(markup)
      strict2_parse(markup)
    rescue SyntaxError => e
      e.line_number    = line_number
      e.markup_context = markup_context(markup)
      raise e
    end
    def strict_parse_with_error_context(markup)
      strict_parse(markup)
    rescue SyntaxError => e
      e.line_number    = line_number
      e.markup_context = markup_context(markup)
      raise e
    end
@@ -1,33 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class PartialCache
    def self.load(template_name, context:, parse_context:)
      cached_partials = context.registers[:cached_partials]
      cache_key = "#{template_name}:#{parse_context.error_mode}"
      cached = cached_partials[cache_key]
      return cached if cached
      file_system = context.registers[:file_system]
      source      = file_system.read_template_file(template_name)
      parse_context.partial = true
      template_factory = context.registers[:template_factory]
      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
    ensure
      parse_context.partial = false
    end
  end
 end
@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 require 'liquid/profiler/hooks'
 module Liquid
  # Profiler enables support for profiling template rendering to help track down performance issues.
  #
  # To enable profiling, first require 'liquid/profiler'.
@@ -21,11 +20,11 @@ module Liquid
  # inside of <tt>{% include %}</tt> tags.
  #
  #   profile.each do |node|
-  #     # Access to the node itself
+  #     # Access to the token itself
  #     node.code
  #
  #     # Which template and line number of this node.
-  #     # The top-level template name is `nil` by default, but can be set in the Liquid::Context before rendering.
+  #     # If top level, this will be "<root>".
  #     node.partial
  #     node.line_number
  #
@@ -46,94 +45,118 @@ module Liquid
    include Enumerable
    class Timing
-      attr_reader :code, :template_name, :line_number, :children
+      attr_reader :code, :partial, :line_number, :children
      attr_accessor :total_time
      alias_method :render_time, :total_time
      alias_method :partial, :template_name
-      def initialize(code: nil, template_name: nil, line_number: nil)
+      def initialize(token, partial)
-        @code = code
+        @code        = token.respond_to?(:raw) ? token.raw : token
-        @template_name = template_name
+        @partial     = partial
-        @line_number = line_number
+        @line_number = token.respond_to?(:line_number) ? token.line_number : nil
-        @children = []
+        @children    = []
      end
-      def self_time
+      def self.start(token, partial)
-        @self_time ||= begin
+        new(token, partial).tap do |t|
-          total_children_time = 0.0
+          t.start
          @children.each do |child|
            total_children_time += child.total_time
          end
          @total_time - total_children_time
        end
      end
      def start
        @start_time = Time.now
      end
      def finish
        @end_time = Time.now
      end
      def render_time
        @end_time - @start_time
      end
    end
-    attr_reader :total_time
+    def self.profile_token_render(token)
-    alias_method :total_render_time, :total_time
+      if Profiler.current_profile && token.respond_to?(:render)
        Profiler.current_profile.start_token(token)
        output = yield
        Profiler.current_profile.end_token(token)
        output
      else
        yield
      end
    end
    def self.profile_children(template_name)
      if Profiler.current_profile
        Profiler.current_profile.push_partial(template_name)
        output = yield
        Profiler.current_profile.pop_partial
        output
      else
        yield
      end
    end
    def self.current_profile
      Thread.current[:liquid_profiler]
    end
    def initialize
-      @root_children = []
+      @partial_stack = ["<root>"]
-      @current_children = nil
+
-      @total_time = 0.0
+      @root_timing = Timing.new("", current_partial)
      @timing_stack = [@root_timing]
      @render_start_at = Time.now
      @render_end_at = @render_start_at
    end
-    def profile(template_name, &block)
+    def start
-      # nested renders are done from a tag that already has a timing node
+      Thread.current[:liquid_profiler] = self
-      return yield if @current_children
+      @render_start_at = Time.now
      root_children = @root_children
      render_idx = root_children.length
      begin
        @current_children = root_children
        profile_node(template_name, &block)
      ensure
        @current_children = nil
        if (timing = root_children[render_idx])
          @total_time += timing.total_time
        end
      end
    end
-    def children
+    def stop
-      children = @root_children
+      Thread.current[:liquid_profiler] = nil
-      if children.length == 1
+      @render_end_at = Time.now
-        children.first.children
+    end
-      else
+
-        children
+    def total_render_time
-      end
+      @render_end_at - @render_start_at
    end
    def each(&block)
-      children.each(&block)
+      @root_timing.children.each(&block)
    end
    def [](idx)
-      children[idx]
+      @root_timing.children[idx]
    end
    def length
-      children.length
+      @root_timing.children.length
    end
-    def profile_node(template_name, code: nil, line_number: nil)
+    def start_token(token)
-      timing = Timing.new(code: code, template_name: template_name, line_number: line_number)
+      @timing_stack.push(Timing.start(token, current_partial))
      parent_children = @current_children
      start_time = monotonic_time
      begin
        @current_children = timing.children
        yield
      ensure
        @current_children = parent_children
        timing.total_time = monotonic_time - start_time
        parent_children << timing
      end
    end
-    private
+    def end_token(token)
      timing = @timing_stack.pop
      timing.finish
-    def monotonic_time
+      @timing_stack.last.children << timing
      Process.clock_gettime(Process::CLOCK_MONOTONIC)
    end
    def current_partial
      @partial_stack.last
    end
    def push_partial(partial_name)
      @partial_stack.push(partial_name)
    end
    def pop_partial
      @partial_stack.pop
    end
  end
 end
@@ -1,35 +1,23 @@
 # frozen_string_literal: true
 module Liquid
-  module BlockBodyProfilingHook
+  class BlockBody
-    def render_node(context, output, node)
+    def render_token_with_profiling(token, context)
-      if (profiler = context.profiler)
+      Profiler.profile_token_render(token) do
-        profiler.profile_node(context.template_name, code: node.raw, line_number: node.line_number) do
+        render_token_without_profiling(token, context)
          super
        end
      else
        super
      end
    end
  end
  BlockBody.prepend(BlockBodyProfilingHook)
-  module DocumentProfilingHook
+    alias_method :render_token_without_profiling, :render_token
-    def render_to_output_buffer(context, output)
+    alias_method :render_token, :render_token_with_profiling
-      return super unless context.profiler
+  end
-      context.profiler.profile(context.template_name) { super }
+
  class Include < Tag
    def render_with_profiling(context)
      Profiler.profile_children(context.evaluate(@template_name).to_s) do
        render_without_profiling(context)
      end
    end
  end
  Document.prepend(DocumentProfilingHook)
-  module ContextProfilingHook
+    alias_method :render_without_profiling, :render
-    attr_accessor :profiler
+    alias_method :render, :render_with_profiling
    def new_isolated_subcontext
      new_context = super
      new_context.profiler = profiler
      new_context
    end
  end
  Context.prepend(ContextProfilingHook)
 end
@@ -1,57 +1,22 @@
 # frozen_string_literal: true
 module Liquid
  class RangeLookup
-    def self.parse(start_markup, end_markup, string_scanner, cache = nil)
+    def self.parse(start_markup, end_markup)
-      start_obj = Expression.parse(start_markup, string_scanner, cache)
+      start_obj = Expression.parse(start_markup)
-      end_obj   = Expression.parse(end_markup, string_scanner, cache)
+      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
          start_obj.to_i..end_obj.to_i
        rescue NoMethodError
          invalid_expr = start_markup unless start_obj.respond_to?(:to_i)
          invalid_expr ||= end_markup unless end_obj.respond_to?(:to_i)
          if invalid_expr
            raise Liquid::SyntaxError, "Invalid expression type '#{invalid_expr}' in range expression"
          end
          raise
        end
      end
    end
    attr_reader :start_obj, :end_obj
    def initialize(start_obj, end_obj)
      @start_obj = start_obj
-      @end_obj   = end_obj
+      @end_obj = end_obj
    end
    def evaluate(context)
-      start_int = to_integer(context.evaluate(@start_obj))
+      context.evaluate(@start_obj).to_i..context.evaluate(@end_obj).to_i
      end_int   = to_integer(context.evaluate(@end_obj))
      start_int..end_int
    end
    private
    def to_integer(input)
      case input
      when Integer
        input
      when NilClass, String
        input.to_i
      else
        Utils.to_integer(input)
      end
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [@node.start_obj, @node.end_obj]
      end
    end
  end
 end
@@ -1,44 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class RangeSlice
    attr_reader :length
    def initialize(range, from, to, resource_limits)
      range_length = range.end - range.begin
      range_length += 1 unless range.exclude_end?
      range_length = 0 if range_length.negative?
      start = [from, 0].max
      finish = [to || range_length, range_length].min
      @first = range.begin + start
      @length = [finish - start, 0].max
      @direction = 1
      @resource_limits = resource_limits
    end
    def empty?
      @length.zero?
    end
    def each
      return enum_for(:each) unless block_given?
      value = @first
      @length.times do
        @resource_limits.increment_render_score(1)
        yield value
        value += @direction
      end
    end
    def reverse!
      unless empty?
        @first += @direction * (@length - 1)
        @direction = -@direction
      end
      self
    end
  end
 end
@@ -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
@@ -1,79 +1,23 @@
 # frozen_string_literal: true
 module Liquid
  class ResourceLimits
-    attr_accessor :render_length_limit,
+    attr_accessor :render_length, :render_score, :assign_score,
-      :render_score_limit,
+                  :render_length_limit, :render_score_limit, :assign_score_limit
      :assign_score_limit,
      :cumulative_render_score_limit,
      :cumulative_assign_score_limit
    attr_reader :render_score,
      :assign_score,
      :cumulative_render_score,
      :cumulative_assign_score
    def initialize(limits)
-      @render_length_limit           = limits[:render_length_limit]
+      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit            = limits[:render_score_limit]
+      @render_score_limit = limits[:render_score_limit]
-      @assign_score_limit            = limits[:assign_score_limit]
+      @assign_score_limit = limits[:assign_score_limit]
      @cumulative_render_score_limit = limits[:cumulative_render_score_limit]
      @cumulative_assign_score_limit = limits[:cumulative_assign_score_limit]
      @cumulative_render_score = 0
      @cumulative_assign_score = 0
      reset
    end
    def increment_render_score(amount)
      @render_score += amount
      @cumulative_render_score += amount
      raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
    end
    def increment_assign_score(amount)
      @assign_score += amount
      @cumulative_assign_score += amount
      raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_assign_score_limit
    end
    # update either render_length or assign_score based on whether or not the writes are captured
    def increment_write_score(output)
      if (last_captured = @last_capture_length)
        captured = output.bytesize
        increment = captured - last_captured
        @last_capture_length = captured
        increment_assign_score(increment)
      elsif @render_length_limit && output.bytesize > @render_length_limit
        raise_limits_reached
      end
    end
    def raise_limits_reached
      @reached_limit = true
      raise MemoryError, "Memory limits exceeded"
    end
    def reached?
-      @reached_limit
+      (@render_length_limit && @render_length > @render_length_limit) ||
      (@render_score_limit  && @render_score  > @render_score_limit ) ||
      (@assign_score_limit  && @assign_score  > @assign_score_limit )
    end
    def reset
-      @reached_limit = false
+      @render_length = @render_score = @assign_score = 0
      @last_capture_length = nil
      @render_score = @assign_score = 0
      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_assign_score_limit
    end
    def with_capture
      old_capture_length = @last_capture_length
      begin
        @last_capture_length = 0
        yield
      ensure
        @last_capture_length = old_capture_length
      end
    end
  end
 end
@@ -1,54 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  # @liquid_public_docs
  # @liquid_type object
  # @liquid_name self
  # @liquid_summary
  #   Provides access to variables through the current scope chain.
  # @liquid_description
  #   The `self` object resolves variables through the normal lookup hierarchy
  #   (local > file > global) without exposing filters, interrupts, errors,
  #   or other context internals. It's used when bare bracket notation
  #   (`['variable']`) needs to be replaced with an explicit variable lookup.
  #
  #   If `self` is explicitly assigned as a local variable (e.g. `{% assign self = 'value' %}`),
  #   then the local value takes precedence over the `self` object.
  # @liquid_access global
  class SelfDrop < Drop
    def initialize(self_context)
      super()
      @self_context = self_context
    end
    def [](key)
      @self_context.find_variable(key)
    rescue UndefinedVariable
      nil
    end
    def key?(key)
      @self_context.variable_defined?(key)
    end
    def to_liquid
      self
    end
    def ==(other)
      other.is_a?(SelfDrop) && other.self_context.equal?(@self_context)
    end
    alias_method :eql?, :==
    def hash
      @self_context.object_id.hash
    end
    protected
    attr_reader :self_context
    undef context=
  end
 end
@@ -0,0 +1,59 @@
 require 'set'
 module Liquid
  # Strainer is the parent class for the filters system.
  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
  #
  # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
  # Context#add_filters or Template.register_filter
  class Strainer #:nodoc:
    @@global_strainer = Class.new(Strainer) do
      @filter_methods = Set.new
    end
    @@strainer_class_cache = Hash.new do |hash, filters|
      hash[filters] = Class.new(@@global_strainer) do
        @filter_methods = @@global_strainer.filter_methods.dup
        filters.each { |f| add_filter(f) }
      end
    end
    def initialize(context)
      @context = context
    end
    def self.filter_methods
      @filter_methods
    end
    def self.add_filter(filter)
      raise ArgumentError, "Expected module but got: #{f.class}" unless filter.is_a?(Module)
      unless self.class.include?(filter)
        self.send(:include, filter)
        @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
      end
    end
    def self.global_filter(filter)
      @@global_strainer.add_filter(filter)
    end
    def self.invokable?(method)
      @filter_methods.include?(method.to_s)
    end
    def self.create(context, filters = [])
      @@strainer_class_cache[filters].new(context)
    end
    def invoke(method, *args)
      if self.class.invokable?(method)
        send(method, *args)
      else
        args.first
      end
    rescue ::ArgumentError => e
      raise Liquid::ArgumentError.new(e.message)
    end
  end
 end
@@ -1,62 +0,0 @@
 # frozen_string_literal: true
 require 'set'
 module Liquid
  # StrainerTemplate is the computed class for the filters system.
  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
  #
  # The Strainer only allows method calls defined in filters given to it via StrainerFactory.add_global_filter,
  # Context#add_filters or Template.register_filter
  class StrainerTemplate
    def initialize(context)
      @context = context
    end
    class << self
      def add_filter(filter)
        return if include?(filter)
        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
        if invokable_non_public_methods.any?
          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
        end
        include(filter)
        filter_methods.merge(filter.public_instance_methods.map(&:to_s))
      end
      def invokable?(method)
        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
        @filter_methods ||= Set.new
      end
    end
    def invoke(method, *args)
      if self.class.invokable?(method)
        send(method, *args)
      elsif @context.strict_filters
        raise Liquid::UndefinedFilter, "undefined filter #{method}"
      else
        args.first
      end
    rescue ::ArgumentError => e
      raise Liquid::ArgumentError, e.message, e.backtrace
    end
  end
 end
@@ -1,121 +0,0 @@
 # 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
      @row    = 1
      @col    = 1
      @cols   = cols
      @index  = 0
    end
    # @liquid_public_docs
    # @liquid_summary
    #   The total number of iterations in the loop.
    # @liquid_return [number]
    attr_reader :length
    # @liquid_public_docs
    # @liquid_summary
    #   The 1-based index of the current column.
    # @liquid_return [number]
    attr_reader :col
    # @liquid_public_docs
    # @liquid_summary
    #   The 1-based index of current row.
    # @liquid_return [number]
    attr_reader :row
    # @liquid_public_docs
    # @liquid_summary
    #   The 1-based index of the current iteration.
    # @liquid_return [number]
    def index
      @index + 1
    end
    # @liquid_public_docs
    # @liquid_summary
    #   The 0-based index of the current iteration.
    # @liquid_return [number]
    def index0
      @index
    end
    # @liquid_public_docs
    # @liquid_summary
    #   The 0-based index of the current column.
    # @liquid_return [number]
    def col0
      @col - 1
    end
    # @liquid_public_docs
    # @liquid_summary
    #   The 1-based index of the current iteration, in reverse order.
    # @liquid_return [number]
    def rindex
      @length - @index
    end
    # @liquid_public_docs
    # @liquid_summary
    #   The 0-based index of the current iteration, in reverse order.
    # @liquid_return [number]
    def rindex0
      @length - @index - 1
    end
    # @liquid_public_docs
    # @liquid_summary
    #   Returns `true` if the current iteration is the first. Returns `false` if not.
    # @liquid_return [boolean]
    def first
      @index == 0
    end
    # @liquid_public_docs
    # @liquid_summary
    #   Returns `true` if the current iteration is the last. Returns `false` if not.
    # @liquid_return [boolean]
    def last
      @index == @length - 1
    end
    # @liquid_public_docs
    # @liquid_summary
    #   Returns `true` if the current column is the first in the row. Returns `false` if not.
    # @liquid_return [boolean]
    def col_first
      @col == 1
    end
    # @liquid_public_docs
    # @liquid_summary
    #   Returns `true` if the current column is the last in the row. Returns `false` if not.
    # @liquid_return [boolean]
    def col_last
      @col == @cols
    end
    protected
    def increment!
      @index += 1
      if @col == @cols
        @col = 1
        @row += 1
      else
        @col += 1
      end
    end
  end
 end
@@ -1,44 +1,26 @@
 # 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
+    attr_accessor :options, :line_number
-    alias_method :options, :parse_context
+    attr_reader :nodelist, :warnings
    include ParserSwitching
    class << self
-      def parse(tag_name, markup, tokenizer, parse_context)
+      def parse(tag_name, markup, tokens, options)
-        tag = new(tag_name, markup, parse_context)
+        tag = new(tag_name, markup, options)
-        tag.parse(tokenizer)
+        tag.parse(tokens)
        tag
      end
      def disable_tags(*tag_names)
        tag_names += disabled_tags
        define_singleton_method(:disabled_tags) { tag_names }
        prepend(Disabler)
      end
      private :new
      protected
      def disabled_tags
        []
      end
    end
-    def initialize(tag_name, markup, parse_context)
+    def initialize(tag_name, markup, options)
-      @tag_name      = tag_name
+      @tag_name   = tag_name
-      @markup        = markup
+      @markup     = markup
-      @parse_context = parse_context
+      @options    = options
      @line_number   = parse_context.line_number
    end
-    def parse(_tokens)
+    def parse(tokens)
    end
    def raw
@@ -49,31 +31,12 @@ module Liquid
      self.class.name.downcase
    end
-    def render(_context)
+    def render(context)
-      ''
+      ''.freeze
    end
    # For backwards compatibility with custom tags. In a future release, the semantics
    # 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
    end
    def blank?
      false
    end
    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)
    end
  end
 end
@@ -1,22 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class Tag
    module Disableable
      def render_to_output_buffer(context, output)
        if context.tag_disabled?(tag_name)
          output << disabled_error(context)
          return
        end
        super
      end
      def disabled_error(context)
        # raise then rescue the exception so that the Context#exception_renderer can re-raise it
        raise DisabledError, "#{tag_name} #{parse_context[:locale].t('errors.disabled.tag')}"
      rescue DisabledError => exc
        context.handle_error(exc, line_number)
      end
    end
  end
 end
@@ -1,13 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class Tag
    module Disabler
      def render_to_output_buffer(context, output)
        context.with_disabled_tags(self.class.disabled_tags) do
          super
        end
      end
    end
  end
 end
@@ -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,104 +1,41 @@
 # 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.
  #
  #   > Caution:
  #   > Predefined Liquid objects can be overridden by variables with the same name.
  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
  # @liquid_syntax
  #   {% assign variable_name = value %}
  # @liquid_syntax_keyword variable_name The name of the variable being created.
  # @liquid_syntax_keyword value The value you want to assign to the variable.
  class Assign < Tag
    include ParserSwitching
  # Assign sets a variable in your template.
  #
  #   {% assign foo = 'monkey' %}
  #
  # You can then use the variable later in the page.
  #
  #  {{ foo }}
  #
  class Assign < Tag
    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
-    # @api private
+    def initialize(tag_name, markup, options)
    def self.raise_syntax_error(parse_context)
      raise Liquid::SyntaxError, parse_context.locale.t('errors.syntax.assign')
    end
    attr_reader :to, :from
    def initialize(tag_name, markup, parse_context)
      super
      parse_with_selected_parser(markup)
    end
    def lax_parse(markup)
      if markup =~ Syntax
-        @to   = Regexp.last_match(1)
+        @to = $1
-        @from = Variable.new(Regexp.last_match(2), parse_context)
+        @from = Variable.new($2,options)
        @from.line_number = line_number
      else
-        self.class.raise_syntax_error(parse_context)
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
      end
    end
-    def strict_parse(markup)
+    def render(context)
      lax_parse(markup)
    end
    def strict2_parse(markup)
      unless markup =~ Syntax
        self.class.raise_syntax_error(parse_context)
      end
      lhs = Regexp.last_match(1).strip
      rhs = Regexp.last_match(2)
      p = @parse_context.new_parser(lhs)
      @to = p.consume(:id)
      p.consume(:end_of_string)
      @from = Variable.new(rhs, parse_context)
    end
    def render_to_output_buffer(context, output)
      val = @from.render(context)
      context.scopes.last[@to] = val
-      context.resource_limits.increment_assign_score(assign_score_of(val))
+
-      output
+      inc = val.instance_of?(String) || val.instance_of?(Array) || val.instance_of?(Hash) ? val.length : 1
      context.resource_limits.assign_score += inc
      ''.freeze
    end
    def blank?
      true
    end
    private
    def assign_score_of(val)
      if val.instance_of?(String)
        val.bytesize
      elsif val.instance_of?(Array)
        sum = 1
        # Uses #each to avoid extra allocations.
        val.each { |child| sum += assign_score_of(child) }
        sum
      elsif val.instance_of?(Hash)
        sum = 1
        val.each do |key, entry_value|
          sum += assign_score_of(key)
          sum += assign_score_of(entry_value)
        end
        sum
      else
        1
      end
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [@node.from]
      end
    end
  end
  Template.register_tag('assign'.freeze, Assign)
 end
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Break tag to be used to break out of a for loop.
  #
  # == Basic Usage:
@@ -10,20 +9,13 @@ 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
-    def render_to_output_buffer(context, output)
+    def interrupt
-      context.push_interrupt(INTERRUPT)
+      BreakInterrupt.new
      output
    end
  end
  Template.register_tag('break'.freeze, Break)
 end
@@ -1,64 +1,38 @@
 # frozen_string_literal: true
 module Liquid
-  # @liquid_public_docs
+  # Capture stores the result of a block into a variable without rendering it inplace.
  # @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.
  #
-  #   > Caution:
+  #   {% capture heading %}
-  #   > Predefined Liquid objects can be overridden by variables with the same name.
+  #     Monkeys!
  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
  # @liquid_syntax
  #   {% capture variable %}
  #     value
  #   {% endcapture %}
-  # @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
    include ParserSwitching
    Syntax = /(#{VariableSignature}+)/o
    attr_reader :to
    def initialize(tag_name, markup, options)
      super
      parse_with_selected_parser(markup)
    end
    def lax_parse(markup)
      if markup =~ Syntax
-        @to = Regexp.last_match(1)
+        @to = $1
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.capture")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
      end
    end
-    def strict_parse(markup)
+    def render(context)
-      lax_parse(markup)
+      output = super
-    end
+      context.scopes.last[@to] = output
-
+      context.resource_limits.assign_score += output.length
-    def strict2_parse(markup)
+      ''.freeze
      p = @parse_context.new_parser(markup.strip)
      @to = p.consume(:id)
      p.consume(:end_of_string)
    end
    def render_to_output_buffer(context, output)
      context.resource_limits.with_capture do
        capture_output = render(context)
        context.scopes.last[@to] = capture_output
      end
      output
    end
    def blank?
      true
    end
  end
  Template.register_tag('capture'.freeze, Capture)
 end
@@ -1,50 +1,24 @@
 # 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 = Expression.parse($1)
      else
        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
      end
    end
    def parse(tokens)
-      body = case_body = new_body
+      body = BlockBody.new
-      body = @blocks.last.attachment while parse_body(body, tokens)
+      while more = parse_body(body, tokens)
-      @blocks.reverse_each do |condition|
+        body = @blocks.last.attachment
        body = condition.attachment
        unless body.frozen?
          body.remove_blank_strings if blank?
          body.freeze
        end
      end
      case_body.freeze
    end
    def nodelist
@@ -53,110 +27,60 @@ module Liquid
    def unknown_tag(tag, markup, tokens)
      case tag
-      when 'when'
+      when 'when'.freeze
        record_when_condition(markup)
-      when 'else'
+      when 'else'.freeze
        record_else_condition(markup)
      else
        super
      end
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      execute_else_block = true
+      context.stack do
        execute_else_block = true
-      @blocks.each do |block|
+        output = ''
-        if block.else?
+        @blocks.each do |block|
-          block.attachment.render_to_output_buffer(context, output) if execute_else_block
+          if block.else?
-          next
+            return block.attachment.render(context) if execute_else_block
-        end
+          elsif block.evaluate(context)
-
+            execute_else_block = false
-        result = Liquid::Utils.to_liquid_value(
+            output << block.attachment.render(context)
-          block.evaluate(context),
+          end
        )
        if result
          execute_else_block = false
          block.attachment.render_to_output_buffer(context, output)
        end
        output
      end
      output
    end
    private
    def strict2_parse(markup)
      parser = @parse_context.new_parser(markup)
      @left = safe_parse_expression(parser)
      parser.consume(:end_of_string)
    end
    def strict_parse(markup)
      lax_parse(markup)
    end
    def lax_parse(markup)
      if markup =~ Syntax
        @left = parse_expression(Regexp.last_match(1))
      else
        raise SyntaxError, options[:locale].t("errors.syntax.case")
      end
    end
    def record_when_condition(markup)
-      body = new_body
+      body = BlockBody.new
      if strict2_mode?
        parse_strict2_when(markup, body)
      else
        parse_lax_when(markup, body)
      end
    end
    def parse_strict2_when(markup, body)
      parser = @parse_context.new_parser(markup)
      loop do
        expr = Condition.parse_expression(parse_context, parser.expression, safe: true)
        block = Condition.new(@left, '==', expr)
        block.attach(body)
        @blocks << block
        break unless parser.id?('or') || parser.consume?(:comma)
      end
      parser.consume(:end_of_string)
    end
    def parse_lax_when(markup, body)
      while markup
-        unless markup =~ WhenSyntax
+        if not markup =~ WhenSyntax
-          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
        end
-        markup = Regexp.last_match(2)
+        markup = $2
-        block = Condition.new(@left, '==', Condition.parse_expression(parse_context, Regexp.last_match(1)))
+        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
        block.attach(body)
        @blocks << block
      end
    end
    def record_else_condition(markup)
-      unless markup.strip.empty?
+      if not markup.strip.empty?
-        raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
      end
      block = ElseCondition.new
-      block.attach(new_body)
+      block.attach(BlockBody.new)
      @blocks << block
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [@node.left] + @node.blocks
      end
    end
  end
  Template.register_tag('case'.freeze, Case)
 end
@@ -1,88 +1,16 @@
 # frozen_string_literal: true
 module Liquid
  # @liquid_public_docs
  # @liquid_type tag
  # @liquid_category syntax
  # @liquid_name comment
  # @liquid_summary
  #   Prevents an expression from being rendered or output.
  # @liquid_description
  #   Any text inside `comment` tags won't be output, and any Liquid code will be parsed, but not executed.
  # @liquid_syntax
  #   {% comment %}
  #     content
  #   {% endcomment %}
  # @liquid_syntax_keyword content The content of the comment.
  class Comment < Block
-    def render_to_output_buffer(_context, output)
+    def render(context)
-      output
+      ''.freeze
    end
-    def unknown_tag(_tag, _markup, _tokens)
+    def unknown_tag(tag, markup, tokens)
    end
    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'.freeze, Comment)
 end
@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 module Liquid
-  # @liquid_public_docs
+  # Continue tag to be used to break out of a for loop.
-  # @liquid_type tag
+  #
-  # @liquid_category iteration
+  # == Basic Usage:
-  # @liquid_name continue
+  #    {% for item in collection %}
-  # @liquid_summary
+  #      {% if item.condition %}
-  #   Causes a [`for` loop](/docs/api/liquid/tags/for) to skip to the next iteration.
+  #        {% continue %}
-  # @liquid_syntax
+  #      {% endif %}
-  #   {% continue %}
+  #    {% endfor %}
  #
  class Continue < Tag
-    INTERRUPT = ContinueInterrupt.new.freeze
+    def interrupt
-
+      ContinueInterrupt.new
    def render_to_output_buffer(context, output)
      context.push_interrupt(INTERRUPT)
      output
    end
  end
  Template.register_tag('continue'.freeze, Continue)
 end
@@ -1,140 +1,57 @@
 # frozen_string_literal: true
 module Liquid
-  # @liquid_public_docs
+  # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
-  # @liquid_type tag
+  #
-  # @liquid_category iteration
+  #   {% for item in items %}
-  # @liquid_name cycle
+  #     <div class="{% cycle 'red', 'green', 'blue' %}"> {{ item }} </div>
-  # @liquid_summary
+  #   {% end %}
-  #   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
+  #    <div class="red"> Item one </div>
-  #   The `cycle` tag must be used inside a `for` loop.
+  #    <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
    SimpleSyntax = /\A#{QuotedFragment}+/o
    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
    UNNAMED_CYCLE_PATTERN = /\w+:0x\h{8}/
    attr_reader :variables
    def initialize(tag_name, markup, options)
      super
-      parse_with_selected_parser(markup)
+      case markup
-    end
+      when NamedSyntax
-
+        @variables = variables_from_string($2)
-    def named?
+        @name = Expression.parse($1)
-      @is_named
+      when SimpleSyntax
-    end
+        @variables = variables_from_string(markup)
-
+        @name = @variables.to_s
-    def render_to_output_buffer(context, output)
+      else
-      context.registers[:cycle] ||= {}
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
      key       = context.evaluate(@name)
      iteration = context.registers[:cycle][key].to_i
      val = context.evaluate(@variables[iteration])
      if val.is_a?(Array)
        val = val.join
      elsif !val.is_a?(String)
        val = val.to_s
      end
    end
-      output << val
+    def render(context)
      context.registers[:cycle] ||= Hash.new(0)
-      iteration += 1
+      context.stack do
-      iteration = 0 if iteration >= @variables.size
+        key = context.evaluate(@name)
-
+        iteration = context.registers[:cycle][key]
-      context.registers[:cycle][key] = iteration
+        result = context.evaluate(@variables[iteration])
-      output
+        iteration += 1
        iteration  = 0  if iteration >= @variables.size
        context.registers[:cycle][key] = iteration
        result
      end
    end
    private
    # cycle [name:] expression(, expression)*
    def strict2_parse(markup)
      p = @parse_context.new_parser(markup)
      @variables = []
      raise SyntaxError, options[:locale].t("errors.syntax.cycle") if p.look(:end_of_string)
      first_expression = safe_parse_expression(p)
      if p.look(:colon)
        # cycle name: expr1, expr2, ...
        @name = first_expression
        @is_named = true
        p.consume(:colon)
        # After the colon, parse the first variable (required for named cycles)
        @variables << maybe_dup_lookup(safe_parse_expression(p))
      else
        # cycle expr1, expr2, ...
        @variables << maybe_dup_lookup(first_expression)
      end
      # Parse remaining comma-separated expressions
      while p.consume?(:comma)
        break if p.look(:end_of_string)
        @variables << maybe_dup_lookup(safe_parse_expression(p))
      end
      p.consume(:end_of_string)
      unless @is_named
        @name = @variables.to_s
        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
      end
    end
    def strict_parse(markup)
      lax_parse(markup)
    end
    def lax_parse(markup)
      case markup
      when NamedSyntax
        @variables = variables_from_string(Regexp.last_match(2))
        @name      = parse_expression(Regexp.last_match(1))
        @is_named = true
      when SimpleSyntax
        @variables = variables_from_string(markup)
        @name      = @variables.to_s
        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
      else
        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
      end
    end
    def variables_from_string(markup)
      markup.split(',').collect do |var|
        var =~ /\s*(#{QuotedFragment})\s*/o
-        next unless Regexp.last_match(1)
+        $1 ? Expression.parse($1) : nil
        var = parse_expression(Regexp.last_match(1))
        maybe_dup_lookup(var)
      end.compact
    end
    # For backwards compatibility, whenever a lookup is used in an unnamed cycle,
    # we make it so that the @variables.to_s produces different strings for cycles
    # called with the same arguments (since @variables.to_s is used as the cycle counter key)
    # This makes it so {% cycle a, b %} and {% cycle a, b %} have independent counters even if a and b share value.
    # This is not true for literal values, {% cycle "a", "b" %} and {% cycle "a", "b" %} share the same counter.
    # I was really scratching my head about this one, but migrating away from this would be more headache
    # than it's worth. So we're keeping this quirk for now.
    def maybe_dup_lookup(var)
      var.is_a?(VariableLookup) ? var.dup : var
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        Array(@node.variables)
      end
    end
  end
  Template.register_tag('cycle', Cycle)
 end
@@ -1,58 +1,38 @@
 # frozen_string_literal: true
 module Liquid
-  # @liquid_public_docs
+
-  # @liquid_type tag
+  # decrement is used in a place where one needs to insert a counter
-  # @liquid_category variable
+  #     into a template, and needs the counter to survive across
-  # @liquid_name decrement
+  #     multiple instantiations of the template.
-  # @liquid_summary
+  #     NOTE: decrement is a pre-decrement, --i,
-  #   Creates a new variable, with a default value of -1, that's decreased by 1 with each subsequent call.
+  #           while increment is post:      i++.
  #
-  #   > Caution:
+  #     (To achieve the survival, the application must keep the context)
-  #   > 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.
+  #     if the variable does not exist, it is created with value 0.
-  # @liquid_description
+
-  #   Variables that are declared with `decrement` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
+  #   Hello: {% decrement variable %}
-  #   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.
+  # gives you:
  #
  #    Hello: -1
  #    Hello: -2
  #    Hello: -3
  #
  #   Similarly, variables that are created with `decrement` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
  #   and [`capture`](/docs/api/liquid/tags/capture). However, `decrement` and [`increment`](/docs/api/liquid/tags/increment) share
  #   variables.
  # @liquid_syntax
  #   {% decrement variable_name %}
  # @liquid_syntax_keyword variable_name The name of the variable being decremented.
  class Decrement < Tag
    include ParserSwitching
    attr_reader :variable_name
    def initialize(tag_name, markup, options)
      super
-      parse_with_selected_parser(markup)
+      @variable = markup.strip
    end
-    def lax_parse(markup)
+    def render(context)
-      @variable_name = markup.strip
+      value = context.environments.first[@variable] ||= 0
      value = value - 1
      context.environments.first[@variable] = value
      value.to_s
    end
-    def strict_parse(markup)
+    private
      lax_parse(markup)
    end
    def strict2_parse(markup)
      p = @parse_context.new_parser(markup.strip)
      @variable_name = p.consume(:id)
      p.consume(:end_of_string)
    end
    def render_to_output_buffer(context, output)
      counter_environment = context.environments.first
      value = counter_environment[@variable_name] || 0
      value -= 1
      counter_environment[@variable_name] = value
      output << value.to_s
      output
    end
  end
  Template.register_tag('decrement'.freeze, 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 +0,0 @@
 # 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).
  #
  #   > 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)
      super
      @variable = Variable.new(markup, parse_context)
    end
    def render(context)
      @variable.render_to_output_buffer(context, +'')
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [@node.variable]
      end
    end
  end
 end
@@ -1,52 +1,62 @@
 # frozen_string_literal: true
 module Liquid
-  # @liquid_public_docs
+
-  # @liquid_type tag
+  # "For" iterates over an array or collection.
-  # @liquid_category iteration
+  # Several useful variables are available to you within the loop.
-  # @liquid_name for
+  #
-  # @liquid_summary
+  # == Basic usage:
-  #   Renders an expression for every item in an array.
+  #    {% for item in collection %}
-  # @liquid_description
+  #      {{ forloop.index }}: {{ item.name }}
-  #   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
+  #    {% endfor %}
-  #   [`paginate` tag](/docs/api/liquid/tags/paginate) to split the items over multiple pages.
+  #
  # == 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 %}
  #
  # == 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)
      super
      @from = @limit = nil
      parse_with_selected_parser(markup)
-      @for_block = new_body
+      @for_block = BlockBody.new
      @else_block = nil
    end
    def parse(tokens)
-      if parse_body(@for_block, tokens)
+      if more = parse_body(@for_block, tokens)
        parse_body(@else_block, tokens)
      end
      if blank?
        @else_block&.remove_blank_strings
        @for_block.remove_blank_strings
      end
      @else_block&.freeze
      @for_block.freeze
    end
    def nodelist
@@ -54,156 +64,130 @@ module Liquid
    end
    def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'
+      return super unless tag == 'else'.freeze
-      @else_block = new_body
+      @else_block = BlockBody.new
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      segment = collection_segment(context)
+      context.registers[:for] ||= Hash.new(0)
-      if segment.empty?
+      collection = context.evaluate(@collection_name)
-        render_else(context, output)
+      collection = collection.to_a if collection.is_a?(Range)
      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
      return render_else(context) unless iterable?(collection)
      from = if @from == :continue
        context.registers[:for][@name].to_i
      else
-        render_segment(context, output, segment)
+        context.evaluate(@from).to_i
      end
-      output
+      limit = context.evaluate(@limit)
      to    = limit ? limit.to_i + from : nil
      segment = Utils.slice_collection(collection, from, to)
      return render_else(context) if segment.empty?
      segment.reverse! if @reversed
      result = ''
      length = segment.length
      # Store our progress through the collection for the continue flag
      context.registers[:for][@name] = from + segment.length
      parent_loop = context['forloop'.freeze]
      context.stack do
        segment.each_with_index do |item, index|
          context[@variable_name] = item
          context['forloop'.freeze] = {
            'name'.freeze       => @name,
            'length'.freeze     => length,
            'index'.freeze      => index + 1,
            'index0'.freeze     => index,
            'rindex'.freeze     => length - index,
            'rindex0'.freeze    => length - index - 1,
            'first'.freeze      => (index == 0),
            'last'.freeze       => (index == length - 1),
            'parentloop'.freeze => parent_loop
          }
          result << @for_block.render(context)
          # Handle any interrupts if they exist.
          if context.has_interrupt?
            interrupt = context.pop_interrupt
            break if interrupt.is_a? BreakInterrupt
            next if interrupt.is_a? ContinueInterrupt
          end
        end
      end
      result
    end
    protected
    def lax_parse(markup)
      if markup =~ Syntax
-        @variable_name   = Regexp.last_match(1)
+        @variable_name = $1
-        collection_name  = Regexp.last_match(2)
+        collection_name = $2
-        @reversed        = !!Regexp.last_match(3)
+        @reversed = $3
-        @name            = "#{@variable_name}-#{collection_name}"
+        @name = "#{@variable_name}-#{collection_name}"
-        @collection_name = parse_expression(collection_name)
+        @collection_name = Expression.parse(collection_name)
        markup.scan(TagAttributes) do |key, value|
          set_attribute(key, value)
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.for")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
      end
    end
    def strict_parse(markup)
-      p = @parse_context.new_parser(markup)
+      p = Parser.new(markup)
      @variable_name = p.consume(:id)
-      raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze))  unless p.id?('in'.freeze)
      collection_name = p.expression
      @name = "#{@variable_name}-#{collection_name}"
      @collection_name = Expression.parse(collection_name)
      @reversed = p.id?('reversed'.freeze)
-      collection_name  = p.expression
+      while p.look(:id) && p.look(:colon, 1)
-      @collection_name = parse_expression(collection_name, safe: true)
+        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
-
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
      @name     = "#{@variable_name}-#{collection_name}"
      @reversed = p.id?('reversed')
      while p.look(:comma) || p.look(:id)
        p.consume?(:comma)
        unless (attribute = p.id?('limit') || p.id?('offset'))
          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
        end
-        p.consume(:colon)
+        p.consume
-        set_attribute(attribute, p.expression, safe: true)
+        set_attribute(attribute, p.expression)
      end
      p.consume(:end_of_string)
    end
    private
-    def strict2_parse(markup)
+    def set_attribute(key, expr)
      strict_parse(markup)
    end
    def collection_segment(context)
      offsets = context.registers[:for] ||= {}
      from = if @from == :continue
        offsets[@name].to_i
      else
        from_value = context.evaluate(@from)
        if from_value.nil?
          0
        else
          Utils.to_integer(from_value)
        end
      end
      collection = context.evaluate(@collection_name)
      limit_value = context.evaluate(@limit)
      to = if limit_value.nil?
        nil
      else
        Utils.to_integer(limit_value) + from
      end
      segment = Utils.slice_collection_for_iteration(
        collection, from, to, context.resource_limits, use_range_to_a: true
      )
      segment.reverse! if @reversed
      offsets[@name] = from + segment.length
      segment
    end
    def render_segment(context, output, segment)
      for_stack = context.registers[:for_stack] ||= []
      length    = segment.length
      context.stack do
        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
        for_stack.push(loop_vars)
        begin
          context['forloop'] = loop_vars
          segment.each do |item|
            context[@variable_name] = item
            @for_block.render_to_output_buffer(context, output)
            loop_vars.send(:increment!)
            # Handle any interrupts if they exist.
            next unless context.interrupt?
            interrupt = context.pop_interrupt
            break if interrupt.is_a?(BreakInterrupt)
            next if interrupt.is_a?(ContinueInterrupt)
          end
        ensure
          for_stack.pop
        end
      end
      output
    end
    def set_attribute(key, expr, safe: false)
      case key
-      when 'offset'
+      when 'offset'.freeze
-        @from = if expr == 'continue'
+        @from = if expr == 'continue'.freeze
          :continue
        else
-          parse_expression(expr, safe: safe)
+          Expression.parse(expr)
        end
-      when 'limit'
+      when 'limit'.freeze
-        @limit = parse_expression(expr, safe: safe)
+        @limit = Expression.parse(expr)
      end
    end
-    def render_else(context, output)
+    def render_else(context)
-      if @else_block
+      @else_block ? @else_block.render(context) : ''.freeze
        @else_block.render_to_output_buffer(context, output)
      else
        output
      end
    end
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+    def iterable?(collection)
-      def children
+      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
        (super + [@node.limit, @node.from, @node.collection_name]).compact
      end
    end
  end
  Template.register_tag('for'.freeze, For)
 end
@@ -1,142 +1,111 @@
 # frozen_string_literal: true
 module Liquid
-  # @liquid_public_docs
+  # If is the conditional block
-  # @liquid_type tag
+  #
-  # @liquid_category conditional
+  #   {% if user.admin %}
-  # @liquid_name if
+  #     Admin user!
-  # @liquid_summary
+  #   {% else %}
-  #   Renders an expression if a specific condition is `true`.
+  #     Not admin user
  # @liquid_syntax
  #   {% if condition %}
  #     expression
  #   {% 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
+    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
+    BOOLEAN_OPERATORS = %w(and or)
    attr_reader :blocks
    def initialize(tag_name, markup, options)
      super
      @blocks = []
-      push_block('if', markup)
+      push_block('if'.freeze, markup)
    end
    def parse(tokens)
      while more = parse_body(@blocks.last.attachment, tokens)
      end
    end
    def nodelist
      @blocks.map(&:attachment)
    end
    def parse(tokens)
      while parse_body(@blocks.last.attachment, tokens)
      end
      @blocks.reverse_each do |block|
        block.attachment.remove_blank_strings if blank?
        block.attachment.freeze
      end
    end
    ELSE_TAG_NAMES = ['elsif', 'else'].freeze
    private_constant :ELSE_TAG_NAMES
    def unknown_tag(tag, markup, tokens)
-      if ELSE_TAG_NAMES.include?(tag)
+      if ['elsif'.freeze, 'else'.freeze].include?(tag)
        push_block(tag, markup)
      else
        super
      end
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      @blocks.each do |block|
+      context.stack do
-        result = Liquid::Utils.to_liquid_value(
+        @blocks.each do |block|
-          block.evaluate(context),
+          if block.evaluate(context)
-        )
+            return block.attachment.render(context)
-
+          end
        if result
          return block.attachment.render_to_output_buffer(context, output)
        end
        ''.freeze
      end
      output
    end
    private
-    def strict2_parse(markup)
+      def push_block(tag, markup)
-      strict_parse(markup)
+        block = if tag == 'else'.freeze
-    end
+          ElseCondition.new
        else
          parse_with_selected_parser(markup)
        end
-    def push_block(tag, markup)
+        @blocks.push(block)
-      block = if tag == 'else'
+        block.attach(BlockBody.new)
        ElseCondition.new
      else
        parse_with_selected_parser(markup)
      end
-      @blocks.push(block)
+      def lax_parse(markup)
-      block.attach(new_body)
+        expressions = markup.scan(ExpressionsAndOperators)
-    end
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
-    def parse_expression(markup, safe: false)
+        condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
      Condition.parse_expression(parse_context, markup, safe: safe)
    end
-    def lax_parse(markup)
+        while not expressions.empty?
-      expressions = markup.scan(ExpressionsAndOperators)
+          operator = expressions.pop.to_s.strip
      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)))
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
-      until expressions.empty?
+          new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
-        operator = expressions.pop.to_s.strip
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
          new_condition.send(operator, condition)
          condition = new_condition
        end
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
+        condition
        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
+      def strict_parse(markup)
-    end
+        p = Parser.new(markup)
-    def strict_parse(markup)
+        condition = parse_comparison(p)
      p = @parse_context.new_parser(markup)
      condition = parse_binary_comparisons(p)
      p.consume(:end_of_string)
      condition
    end
-    def parse_binary_comparisons(p)
+        while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
-      condition = parse_comparison(p)
+          new_cond = parse_comparison(p)
-      first_condition = condition
+          new_cond.send(op, condition)
-      while (op = p.id?('and') || p.id?('or'))
+          condition = new_cond
-        child_condition = parse_comparison(p)
+        end
-        condition.send(op, child_condition)
+        p.consume(:end_of_string)
-        condition = child_condition
+
        condition
      end
      first_condition
    end
-    def parse_comparison(p)
+      def parse_comparison(p)
-      a = parse_expression(p.expression, safe: true)
+        a = Expression.parse(p.expression)
-      if (op = p.consume?(:comparison))
+        if op = p.consume?(:comparison)
-        b = parse_expression(p.expression, safe: true)
+          b = Expression.parse(p.expression)
-        Condition.new(a, op, b)
+          Condition.new(a, op, b)
-      else
+        else
-        Condition.new(a)
+          Condition.new(a)
        end
      end
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        @node.blocks
      end
    end
  end
  Template.register_tag('if'.freeze, If)
 end
@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 module Liquid
  class Ifchanged < Block
    def render_to_output_buffer(context, output)
      block_output = +''
      super(context, block_output)
-      if block_output != context.registers[:ifchanged]
+    def render(context)
-        context.registers[:ifchanged] = block_output
+      context.stack do
-        output << block_output
+
        output = super
        if output != context.registers[:ifchanged]
          context.registers[:ifchanged] = output
          output
        else
          ''.freeze
        end
      end
      output
    end
  end
  Template.register_tag('ifchanged'.freeze, Ifchanged)
 end
@@ -1,148 +1,99 @@
 # frozen_string_literal: true
 module Liquid
-  # @liquid_public_docs
+
-  # @liquid_type tag
+  # Include allows templates to relate with other templates
-  # @liquid_category theme
+  #
-  # @liquid_name include
+  # Simply include another template:
-  # @liquid_summary
+  #
-  #   Renders a [snippet](/themes/architecture/snippets).
+  #   {% include 'product' %}
-  # @liquid_description
+  #
-  #   Inside the snippet, you can access and alter variables that are [created](/docs/api/liquid/tags/variable-tags) outside of the
+  # Include a template with a local variable:
-  #   snippet.
+  #
-  # @liquid_syntax
+  #   {% include 'product' with products[0] %}
-  #   {% include 'filename' %}
+  #
-  # @liquid_syntax_keyword filename The name of the snippet to render, without the `.liquid` extension.
+  # Include a template for a collection:
-  # @liquid_deprecated
+  #
-  #   Deprecated because the way that variables are handled reduces performance and makes code harder to both read and maintain.
+  #   {% 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}+))?/o
    FOR = 'for'
    SYNTAX = /(#{QuotedFragment}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
    Syntax = SYNTAX
    attr_reader :template_name_expr, :variable_name_expr, :attributes
    def initialize(tag_name, markup, options)
      super
      parse_with_selected_parser(markup)
    end
-    def parse(_tokens)
+      if markup =~ Syntax
    end
-    def render_to_output_buffer(context, output)
+        template_name = $1
-      template_name = context.evaluate(@template_name_expr)
+        variable_name = $3
      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name.is_a?(String)
-      partial = PartialCache.load(
+        @variable_name = Expression.parse(variable_name || template_name[1..-2])
-        template_name,
+        @context_variable_name = template_name[1..-2].split('/'.freeze).last
-        context: context,
+        @template_name = Expression.parse(template_name)
-        parse_context: parse_context,
+        @attributes    = {}
      )
      context_variable_name = @alias_name || template_name.split('/').last
      variable = if @variable_name_expr
        context.evaluate(@variable_name_expr)
      else
        context.find_variable(template_name, raise_on_not_found: false)
      end
      old_template_name = context.template_name
      old_partial       = context.partial
      begin
        context.template_name = partial.name
        context.partial = true
        context.stack do
          @attributes.each do |key, value|
            context[key] = context.evaluate(value)
          end
          if variable.is_a?(Array)
            variable.each do |var|
              context[context_variable_name] = var
              partial.render_to_output_buffer(context, output)
            end
          else
            context[context_variable_name] = variable
            partial.render_to_output_buffer(context, output)
          end
        end
      ensure
        context.template_name = old_template_name
        context.partial       = old_partial
      end
      output
    end
    alias_method :parse_context, :options
    private :parse_context
    def for_loop?
      @is_for_loop
    end
    def strict2_parse(markup)
      p = @parse_context.new_parser(markup)
      @template_name_expr = safe_parse_expression(p)
      with_or_for         = p.id?("for") || p.id?("with")
      @variable_name_expr = safe_parse_expression(p) if with_or_for
      @alias_name         = p.consume(:id) if p.id?("as")
      @is_for_loop        = (with_or_for == FOR)
      p.consume?(:comma)
      @attributes = {}
      while p.look(:id)
        key = p.consume
        p.consume(:colon)
        @attributes[key] = safe_parse_expression(p)
        p.consume?(:comma)
      end
      p.consume(:end_of_string)
    end
    def strict_parse(markup)
      lax_parse(markup)
    end
    def lax_parse(markup)
      if markup =~ SYNTAX
        template_name = Regexp.last_match(1)
        with_or_for   = Regexp.last_match(3)
        variable_name = Regexp.last_match(4)
        @alias_name         = Regexp.last_match(6)
        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
        @template_name_expr = parse_expression(template_name)
        @is_for_loop        = (with_or_for == FOR)
        @attributes         = {}
        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = parse_expression(value)
+          @attributes[key] = Expression.parse(value)
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.include")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
      end
    end
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+    def parse(tokens)
-      def children
+    end
-        [
+
-          @node.template_name_expr,
+    def render(context)
-          @node.variable_name_expr,
+      partial = load_cached_partial(context)
-        ] + @node.attributes.values
+      variable = context.evaluate(@variable_name)
      context.stack do
        @attributes.each do |key, value|
          context[key] = context.evaluate(value)
        end
        if variable.is_a?(Array)
          variable.collect do |var|
            context[@context_variable_name] = var
            partial.render(context)
          end
        else
          context[@context_variable_name] = variable
          partial.render(context)
        end
      end
    end
    private
      def load_cached_partial(context)
        cached_partials = context.registers[:cached_partials] || {}
        template_name = context.evaluate(@template_name)
        if cached = cached_partials[template_name]
          return cached
        end
        source = read_template_from_file_system(context)
        partial = Liquid::Template.parse(source, pass_options)
        cached_partials[template_name] = partial
        context.registers[:cached_partials] = cached_partials
        partial
      end
      def read_template_from_file_system(context)
        file_system = context.registers[:file_system] || Liquid::Template.file_system
        file_system.read_template_file(context.evaluate(@template_name))
      end
      def pass_options
        dont_pass = @options[:include_options_blacklist]
        return {locale: @options[:locale]} if dont_pass == true
        opts = @options.merge(included: true, include_options_blacklist: false)
        if dont_pass.is_a?(Array)
          dont_pass.each {|o| opts.delete(o)}
        end
        opts
      end
  end
  Template.register_tag('include'.freeze, Include)
 end
@@ -1,58 +1,31 @@
 # frozen_string_literal: true
 module Liquid
-  # @liquid_public_docs
+  # increment is used in a place where one needs to insert a counter
-  # @liquid_type tag
+  #     into a template, and needs the counter to survive across
-  # @liquid_category variable
+  #     multiple instantiations of the template.
-  # @liquid_name increment
+  #     (To achieve the survival, the application must keep the context)
  # @liquid_summary
  #   Creates a new variable, with a default value of 0, that's increased by 1 with each subsequent call.
  #
-  #   > Caution:
+  #     if the variable does not exist, it is created with value 0.
-  #   > 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.
+  #   Hello: {% increment variable %}
-  # @liquid_description
+  #
-  #   Variables that are declared with `increment` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
+  # gives you:
-  #   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.
+  #    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
    include ParserSwitching
    attr_reader :variable_name
    def initialize(tag_name, markup, options)
      super
-      parse_with_selected_parser(markup)
+      @variable = markup.strip
    end
-    def lax_parse(markup)
+    def render(context)
-      @variable_name = markup.strip
+      value = context.environments.first[@variable] ||= 0
-    end
+      context.environments.first[@variable] = value + 1
-
+      value.to_s
    def strict_parse(markup)
      lax_parse(markup)
    end
    def strict2_parse(markup)
      p = @parse_context.new_parser(markup.strip)
      @variable_name = p.consume(:id)
      p.consume(:end_of_string)
    end
    def render_to_output_buffer(context, output)
      counter_environment = context.environments.first
      value = counter_environment[@variable_name] || 0
      counter_environment[@variable_name] = value + 1
      output << value.to_s
      output
    end
  end
  Template.register_tag('increment'.freeze, 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,43 +1,20 @@
 # 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
      ensure_valid_markup(tag_name, markup, parse_context)
    end
    def parse(tokens)
-      @body = +''
+      @body = ''
-      while (token = tokens.shift)
+      while token = tokens.shift
-        if token =~ BlockBody::FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
+        if token =~ FullTokenPossiblyInvalid
-          parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
+          @body << $1 if $1 != "".freeze
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
+          return if block_delimiter == $2
          return
        end
-        @body << token unless token.empty?
+        @body << token if not token.empty?
      end
      raise_tag_never_closed(block_name)
    end
-    def render_to_output_buffer(_context, output)
+    def render(context)
-      output << @body
+      @body
      output
    end
    def nodelist
@@ -47,13 +24,7 @@ module Liquid
    def blank?
      @body.empty?
    end
    protected
    def ensure_valid_markup(tag_name, markup, parse_context)
      unless Syntax.match?(markup)
        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args", tag: tag_name)
      end
    end
  end
  Template.register_tag('raw'.freeze, Raw)
 end
@@ -1,145 +0,0 @@
 # 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
    def initialize(tag_name, markup, options)
      super
      parse_with_selected_parser(markup)
    end
    def for_loop?
      @is_for_loop
    end
    def render_to_output_buffer(context, output)
      render_tag(context, output)
    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)
      partial = PartialCache.load(
        template_name,
        context: 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.partial       = true
        inner_context['forloop']    = forloop if forloop
        @attributes.each do |key, value|
          inner_context[key] = context.evaluate(value)
        end
        inner_context[context_variable_name] = var unless var.nil?
        partial.render_to_output_buffer(inner_context, output)
        forloop&.send(:increment!)
      }
      variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
      if @is_for_loop && variable.respond_to?(:each) && variable.respond_to?(:count)
        forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
        variable.each { |var| render_partial_func.call(var, forloop) }
      else
        render_partial_func.call(variable, nil)
      end
      output
    end
    # render (string) (with|for expression)? (as id)? (key: value)*
    def strict2_parse(markup)
      p = @parse_context.new_parser(markup)
      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
      with_or_for         = p.id?("for") || p.id?("with")
      @variable_name_expr = safe_parse_expression(p) if with_or_for
      @alias_name         = p.consume(:id) if p.id?("as")
      @is_for_loop        = (with_or_for == FOR)
      p.consume?(:comma)
      @attributes = {}
      while p.look(:id)
        key = p.consume
        p.consume(:colon)
        @attributes[key] = safe_parse_expression(p)
        p.consume?(:comma)
      end
      p.consume(:end_of_string)
    end
    def strict2_template_name(p)
      p.consume(:string)
    end
    def strict_parse(markup)
      lax_parse(markup)
    end
    def lax_parse(markup)
      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
      template_name = Regexp.last_match(1)
      with_or_for = Regexp.last_match(3)
      variable_name = Regexp.last_match(4)
      @alias_name = Regexp.last_match(6)
      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
      @template_name_expr = parse_expression(template_name)
      @is_for_loop = (with_or_for == FOR)
      @attributes = {}
      markup.scan(TagAttributes) do |key, value|
        @attributes[key] = parse_expression(value)
      end
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [
          @node.template_name_expr,
          @node.variable_name_expr,
        ] + @node.attributes.values
      end
    end
  end
 end
@@ -1,141 +1,72 @@
 # frozen_string_literal: true
 module Liquid
  # @liquid_public_docs
  # @liquid_type tag
  # @liquid_category iteration
  # @liquid_name tablerow
  # @liquid_summary
  #   Generates HTML table rows for every item in an array.
  # @liquid_description
  #   The `tablerow` tag must be wrapped in HTML `<table>` and `</table>` tags.
  #
  #   > Tip:
  #   > Every `tablerow` loop has an associated [`tablerowloop` object](/docs/api/liquid/objects/tablerowloop) with information about the loop.
  # @liquid_syntax
  #   {% tablerow variable in array %}
  #     expression
  #   {% endtablerow %}
  # @liquid_syntax_keyword variable The current item in the array.
  # @liquid_syntax_keyword array The array to iterate over.
  # @liquid_syntax_keyword expression The expression to render.
  # @liquid_optional_param cols: [number] The number of columns that the table should have.
  # @liquid_optional_param limit: [number] The number of iterations to perform.
  # @liquid_optional_param offset: [number] The 1-based index to start iterating at.
  # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
  class TableRow < Block
    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
    ALLOWED_ATTRIBUTES = ['cols', 'limit', 'offset', 'range'].freeze
    attr_reader :variable_name, :collection_name, :attributes
    def initialize(tag_name, markup, options)
      super
      parse_with_selected_parser(markup)
    end
    def strict2_parse(markup)
      p = @parse_context.new_parser(markup)
      @variable_name = p.consume(:id)
      unless p.id?("in")
        raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in")
      end
      @collection_name = safe_parse_expression(p)
      p.consume?(:comma)
      @attributes = {}
      while p.look(:id)
        key = p.consume
        unless ALLOWED_ATTRIBUTES.include?(key)
          raise SyntaxError, options[:locale].t("errors.syntax.table_row_invalid_attribute", attribute: key)
        end
        p.consume(:colon)
        @attributes[key] = safe_parse_expression(p)
        p.consume?(:comma)
      end
      p.consume(:end_of_string)
    end
    def strict_parse(markup)
      lax_parse(markup)
    end
    def lax_parse(markup)
      if markup =~ Syntax
-        @variable_name   = Regexp.last_match(1)
+        @variable_name = $1
-        @collection_name = parse_expression(Regexp.last_match(2))
+        @collection_name = Expression.parse($2)
-        @attributes      = {}
+        @attributes = {}
        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = parse_expression(value)
+          @attributes[key] = Expression.parse(value)
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.table_row")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
      end
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      (collection = context.evaluate(@collection_name)) || (return '')
+      collection = context.evaluate(@collection_name) or return ''.freeze
-      from = @attributes.key?('offset') ? to_integer(context.evaluate(@attributes['offset'])) : 0
+      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
-      to = @attributes.key?('limit') ? from + to_integer(context.evaluate(@attributes['limit'])) : nil
+      to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
-      collection = Utils.slice_collection_for_iteration(collection, from, to, context.resource_limits, allow_endless: true)
+      collection = Utils.slice_collection(collection, from, to)
      length     = collection.length
-      cols = @attributes.key?('cols') ? to_integer(context.evaluate(@attributes['cols'])) : length
+      length = collection.length
-      output << "<tr class=\"row1\">\n"
+      cols = context.evaluate(@attributes['cols'.freeze]).to_i
-      context.resource_limits.increment_write_score(output)
+
      row = 1
      col = 0
      result = "<tr class=\"row1\">\n"
      context.stack do
        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
        context['tablerowloop'] = tablerowloop
-        collection.each do |item|
+        collection.each_with_index do |item, index|
          context[@variable_name] = item
          context['tablerowloop'.freeze] = {
            'length'.freeze    => length,
            'index'.freeze     => index + 1,
            'index0'.freeze    => index,
            'col'.freeze       => col + 1,
            'col0'.freeze      => col,
            'rindex'.freeze    => length - index,
            'rindex0'.freeze   => length - index - 1,
            'first'.freeze     => (index == 0),
            'last'.freeze      => (index == length - 1),
            'col_first'.freeze => (col == 0),
            'col_last'.freeze  => (col == cols - 1)
          }
          output << "<td class=\"col#{tablerowloop.col}\">"
          super
          output << '</td>'
          context.resource_limits.increment_write_score(output)
-          # Handle any interrupts if they exist.
+          col += 1
-          if context.interrupt?
+
-            interrupt = context.pop_interrupt
+          result << "<td class=\"col#{col}\">" << super << '</td>'
-            break if interrupt.is_a?(BreakInterrupt)
+
          if col == cols and (index != length - 1)
            col  = 0
            row += 1
            result << "</tr>\n<tr class=\"row#{row}\">"
          end
          if tablerowloop.col_last && !tablerowloop.last
            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
            context.resource_limits.increment_write_score(output)
          end
          tablerowloop.send(:increment!)
        end
      end
-
+      result << "</tr>\n"
-      output << "</tr>\n"
+      result
      context.resource_limits.increment_write_score(output)
      output
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        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'.freeze, TableRow)
 end
@@ -1,47 +1,31 @@
-# frozen_string_literal: true
+require File.dirname(__FILE__) + '/if'
 require_relative 'if'
 module Liquid
-  # @liquid_public_docs
+  # Unless is a conditional just like 'if' but works on the inverse logic.
-  # @liquid_type tag
+  #
-  # @liquid_category conditional
+  #   {% unless x < 0 %} x is greater than zero {% endunless %}
-  # @liquid_name unless
+  #
  # @liquid_summary
  #   Renders an expression unless a specific condition is `true`.
  # @liquid_description
  #   > Tip:
  #   > Similar to the [`if` tag](/docs/api/liquid/tags/if), you can use `elsif` to add more conditions to an `unless` tag.
  # @liquid_syntax
  #   {% unless condition %}
  #     expression
  #   {% endunless %}
  # @liquid_syntax_keyword condition The condition to evaluate.
  # @liquid_syntax_keyword expression The expression to render unless the condition is met.
  class Unless < If
-    def render_to_output_buffer(context, output)
+    def render(context)
-      # First condition is interpreted backwards ( if not )
+      context.stack do
      first_block = @blocks.first
      result = Liquid::Utils.to_liquid_value(
        first_block.evaluate(context),
      )
-      unless result
+        # First condition is interpreted backwards ( if not )
-        return first_block.attachment.render_to_output_buffer(context, output)
+        first_block = @blocks.first
-      end
+        unless first_block.evaluate(context)
-
+          return first_block.attachment.render(context)
      # After the first condition unless works just like if
      @blocks[1..-1].each do |block|
        result = Liquid::Utils.to_liquid_value(
          block.evaluate(context),
        )
        if result
          return block.attachment.render_to_output_buffer(context, output)
        end
      end
-      output
+        # After the first condition unless works just like if
        @blocks[1..-1].each do |block|
          if block.evaluate(context)
            return block.attachment.render(context)
          end
        end
        ''.freeze
      end
    end
  end
  Template.register_tag('unless'.freeze, Unless)
 end
@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 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,8 +14,44 @@ module Liquid
  #   template.render('user_name' => 'bob')
  #
  class Template
-    attr_accessor :root, :name
+    DEFAULT_OPTIONS = {
-    attr_reader :resource_limits, :warnings
+      :locale => I18n.new
    }
    attr_accessor :root
    attr_reader :resource_limits
    @@file_system = BlankFileSystem.new
    class TagRegistry
      def initialize
        @tags  = {}
        @cache = {}
      end
      def [](tag_name)
        return nil unless @tags.has_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
      private
      def lookup_class(name)
        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
      end
    end
    attr_reader :profiler
@@ -24,90 +59,78 @@ module Liquid
      # Sets how strict the parser should be.
      # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
      # :warn is the default and will give deprecation warnings when invalid syntax is used.
-      # :strict enforces correct syntax for most tags
+      # :strict will enforce correct syntax.
-      # :strict2 enforces correct syntax for all tags
+      attr_writer :error_mode
      def error_mode=(mode)
        Deprecations.warn("Template.error_mode=", "Environment#error_mode=")
        Environment.default.error_mode = mode
      end
-      def error_mode
+      # Sets how strict the taint checker should be.
-        Environment.default.error_mode
+      # :lax is the default, and ignores the taint flag completely
-      end
+      # :warn adds a warning, but does not interrupt the rendering
-
+      # :error raises an error when tainted output is used
-      def default_exception_renderer=(renderer)
+      attr_writer :taint_mode
        Deprecations.warn("Template.default_exception_renderer=", "Environment#exception_renderer=")
        Environment.default.exception_renderer = renderer
      end
      def default_exception_renderer
        Environment.default.exception_renderer
      end
      def file_system=(file_system)
        Deprecations.warn("Template.file_system=", "Environment#file_system=")
        Environment.default.file_system = file_system
      end
      def file_system
-        Environment.default.file_system
+        @@file_system
      end
-      def tags
+      def file_system=(obj)
-        Environment.default.tags
+        @@file_system = obj
      end
      def register_tag(name, klass)
-        Deprecations.warn("Template.register_tag", "Environment#register_tag")
+        tags[name.to_s] = klass
-        Environment.default.register_tag(name, klass)
+      end
      def tags
        @tags ||= TagRegistry.new
      end
      def error_mode
        @error_mode || :lax
      end
      def taint_mode
        @taint_mode || :lax
      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")
+        Strainer.global_filter(mod)
        Environment.default.register_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
+        @default_resource_limits ||= {}
      end
      # creates a new <tt>Template</tt> object from liquid source code
      # To enable profiling, pass in <tt>profile: true</tt> as an option.
      # See Liquid::Profiler for more information
      def parse(source, options = {})
-        environment = options[:environment] || Environment.default
+        template = Template.new
-        new(environment: environment).parse(source, options)
+        template.parse(source, options)
      end
    end
-    def initialize(environment: Environment.default)
+    def initialize
-      @environment = environment
+      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
      @rethrow_errors  = false
      @resource_limits = ResourceLimits.new(environment.default_resource_limits)
    end
    # Parse source code.
    # Returns self for easy chaining
    def parse(source, options = {})
-      parse_context = configure_options(options)
+      @options = options
-      source = source.to_s.to_str
+      @profiling = options[:profile]
-
+      @line_numbers = options[:line_numbers] || @profiling
-      unless source.valid_encoding?
+      @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
-        raise TemplateEncodingError, parse_context.locale.t("errors.syntax.invalid_template_encoding")
+      @warnings = nil
      end
      tokenizer     = parse_context.new_tokenizer(source, start_line_number: @line_numbers && 1)
      @root         = Document.parse(tokenizer, parse_context)
      self
    end
    def warnings
      return [] unless @root
      @warnings ||= @root.warnings
    end
    def registers
      @registers ||= {}
    end
@@ -139,70 +162,62 @@ module Liquid
    #    filters and tags and might be useful to integrate liquid more with its host application
    #
    def render(*args)
-      return '' if @root.nil?
+      return ''.freeze if @root.nil?
      context = case args.first
      when Liquid::Context
        c = args.shift
        if @rethrow_errors
-          c.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
+          c.exception_handler = ->(e) { true }
        end
        c
      when Liquid::Drop
        drop = args.shift
-        c    = 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)
        drop.context = c if drop.respond_to?(:context=)
        c
      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
      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|
+        if options[:registers].is_a?(Hash)
-          static_registers[key] = register
+          self.registers.merge!(options[:registers])
        end
-        apply_options_to_context(context, options)
+        if options[:filters]
-      when Module, Array
+          context.add_filters(options[:filters])
        end
        if options[:exception_handler]
          context.exception_handler = options[:exception_handler]
        end
      when Module
        context.add_filters(args.pop)
      when Array
        context.add_filters(args.pop)
      end
      # Retrying a render resets resource usage
      context.resource_limits.reset
      if @profiling && context.profiler.nil?
        @profiler = context.profiler = Liquid::Profiler.new
      end
      context.template_name ||= name
      previous_error_mode = context.registers.static[:template_error_mode]
      context.registers.static[:template_error_mode] = @error_mode
      begin
        # render the nodelist.
-        @root.render_to_output_buffer(context, output || +'')
+        # for performance reasons we get an array back here. join will make a string out of it.
        result = with_profiling do
          @root.render(context)
        end
        result.respond_to?(:join) ? result.join : result
      rescue Liquid::MemoryError => e
        context.handle_error(e)
      ensure
        if previous_error_mode
          context.registers.static[:template_error_mode] = previous_error_mode
        else
          context.registers.static.delete(:template_error_mode)
        end
        @errors = context.errors
      end
    end
@@ -212,38 +227,47 @@ module Liquid
      render(*args)
    end
    def render_to_output_buffer(context, output)
      render(context, output: output)
    end
    private
-    def configure_options(options)
+    # Uses the <tt>Liquid::TemplateParser</tt> regexp to tokenize the passed source
-      if (profiling = options[:profile])
+    def tokenize(source)
-        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
+      source = source.source if source.respond_to?(:source)
-      end
+      return [] if source.to_s.empty?
-      @options      = options
+      tokens = calculate_line_numbers(source.split(TemplateParser))
      @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
-      @warnings = parse_context.warnings
+      # removes the rogue empty element at the beginning of the array
-      @error_mode = parse_context.error_mode
+      tokens.shift if tokens[0] and tokens[0].empty?
-      parse_context
+
      tokens
    end
-    def apply_options_to_context(context, options)
+    def calculate_line_numbers(raw_tokens)
-      context.add_filters(options[:filters]) if options[:filters]
+      return raw_tokens unless @line_numbers
-      context.global_filter      = options[:global_filter] if options[:global_filter]
+
-      context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
+      current_line = 1
-      context.strict_variables   = options[:strict_variables] if options[:strict_variables]
+      raw_tokens.map do |token|
-      context.strict_filters     = options[:strict_filters] if options[:strict_filters]
+        Token.new(token, current_line).tap do
          current_line += token.count("\n")
        end
      end
    end
    def with_profiling
      if @profiling && !@options[:included]
        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
        @profiler = Profiler.new
        @profiler.start
        begin
          yield
        ensure
          @profiler.stop
        end
      else
        yield
      end
    end
  end
 end
@@ -1,9 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class TemplateFactory
    def for(_template_name)
      Liquid::Template.new
    end
  end
 end
@@ -0,0 +1,18 @@
 module Liquid
  class Token < String
    attr_reader :line_number
    def initialize(content, line_number)
      super(content)
      @line_number = line_number
    end
    def raw
      "<raw>"
    end
    def child(string)
      Token.new(string, @line_number)
    end
  end
 end
@@ -1,161 +0,0 @@
 # 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)
      @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
    end
    def shift
      token = @tokens[@offset]
      return unless token
      @offset += 1
      if @line_number
        @line_number += @for_liquid_tag ? 1 : token.count("\n")
      end
      token
    end
    private
    def tokenize
      if @for_liquid_tag
        @tokens = @source.split("\n")
      else
        @tokens << shift_normal until @ss.eos?
      end
      @source = nil
      @ss = nil
    end
    def shift_normal
      token = next_token
      return unless token
      token
    end
    def next_token
      # possible states: :text, :tag, :variable
      byte_a = @ss.peek_byte
      if byte_a == OPEN_CURLEY
        @ss.scan_byte
        byte_b = @ss.peek_byte
        if byte_b == PERCENTAGE
          @ss.scan_byte
          return next_tag_token
        elsif byte_b == OPEN_CURLEY
          @ss.scan_byte
          return next_variable_token
        end
        @ss.pos -= 1
      end
      next_text_token
    end
    def next_text_token
      start = @ss.pos
      unless @ss.skip_until(TAG_OR_VARIABLE_START)
        token = @ss.rest
        @ss.terminate
        return token
      end
      pos = @ss.pos -= 2
      @source.byteslice(start, pos - start)
    rescue ::ArgumentError => e
      if e.message == "invalid byte sequence in #{@ss.string.encoding}"
        raise SyntaxError, "Invalid byte sequence in #{@ss.string.encoding}"
      else
        raise
      end
    end
    def next_variable_token
      start = @ss.pos - 2
      byte_a = byte_b = @ss.scan_byte
      while byte_b
        byte_a = @ss.scan_byte while byte_a && byte_a != CLOSE_CURLEY && byte_a != OPEN_CURLEY
        break unless byte_a
        if @ss.eos?
          return byte_a == CLOSE_CURLEY ? @source.byteslice(start, @ss.pos - start) : "{{"
        end
        byte_b = @ss.scan_byte
        if byte_a == CLOSE_CURLEY
          if byte_b == CLOSE_CURLEY
            return @source.byteslice(start, @ss.pos - start)
          elsif byte_b != CLOSE_CURLEY
            @ss.pos -= 1
            return @source.byteslice(start, @ss.pos - start)
          end
        elsif byte_a == OPEN_CURLEY && byte_b == PERCENTAGE
          return next_tag_token_with_start(start)
        end
        byte_a = byte_b
      end
      "{{"
    end
    def next_tag_token
      start = @ss.pos - 2
      if (len = @ss.skip_until(TAG_END))
        @source.byteslice(start, len + 2)
      else
        "{%"
      end
    end
    def next_tag_token_with_start(start)
      @ss.skip_until(TAG_END)
      @source.byteslice(start, @ss.pos - start)
    end
  end
 end
@@ -1,8 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  module Usage
    def self.increment(name)
    end
  end
 end
@@ -1,49 +1,27 @@
 # frozen_string_literal: true
 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)
+      if (from != 0 || to != nil) && collection.respond_to?(:load_slice)
        collection.load_slice(from, to)
      else
        slice_collection_using_each(collection, from, to)
      end
    end
-    # This is intentionally separate from slice_collection, whose Array-returning
+    def self.non_blank_string?(collection)
-    # behavior is used outside of the iteration tags.
+      collection.is_a?(String) && collection != ''.freeze
    def self.slice_collection_for_iteration(
      collection, from, to, resource_limits, allow_endless: false, use_range_to_a: false
    )
      if integer_range?(collection)
        RangeSlice.new(collection, from, to, resource_limits)
      elsif collection.is_a?(Range)
        if use_range_to_a && range_method_overridden?(collection, :to_a)
          # For historically honored custom Range#to_a. Charge the resulting
          # selection before buffering it, just as for a custom #each.
          slice_collection_for_iteration_using_each(collection.to_a, from, to, resource_limits)
        else
          slice_range_using_each(collection, from, to, resource_limits, allow_endless: allow_endless)
        end
      else
        slice_collection(collection, from, to)
      end
    end
    def self.slice_collection_using_each(collection, from, to)
      segments = []
-      index    = 0
+      index = 0
      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
-      if collection.is_a?(String)
+      return [collection] if non_blank_string?(collection)
        return collection.empty? ? [] : [collection]
      end
      return [] unless collection.respond_to?(:each)
      collection.each do |item|
        if to && to <= index
          break
        end
@@ -57,207 +35,5 @@ module Liquid
      segments
    end
    # Arithmetic slicing must not bypass a Range subclass's custom #each.
    def self.integer_range?(collection)
      collection.instance_of?(Range) && collection.begin.is_a?(Integer) && collection.end.is_a?(Integer)
    end
    private_class_method :integer_range?
    # Preserve support for Ruby-supplied string ranges and custom Range#each.
    # Their selected length cannot be inferred from integer bounds, but the tags
    # need it before rendering for loop metadata, continuation offsets, and columns.
    # Buffer the selection so we do not have to replay a potentially custom iterator.
    def self.slice_range_using_each(collection, from, to, resource_limits, allow_endless:)
      # TableRow historically accepted an endless subclass when its custom #each
      # was finite, while For historically raised through Range#to_a.
      if collection.end.nil? && !(allow_endless && (!to.nil? || range_method_overridden?(collection, :each)))
        raise RangeError, "cannot convert endless range to an array"
      end
      if collection.begin.nil? && !range_method_overridden?(collection, :each)
        raise TypeError, "can't iterate from NilClass"
      end
      slice_collection_for_iteration_using_each(collection, from, to, resource_limits)
    end
    private_class_method :slice_range_using_each
    # Custom Range#each can make a nominally beginless range finite; standard
    # beginless ranges were rejected before reaching this budgeted traversal.
    def self.slice_collection_for_iteration_using_each(collection, from, to, resource_limits)
      return [] if to && to <= from
      segments = []
      index = 0
      collection.each do |item|
        break if to && to <= index
        # Charge preparation, including skipped offsets, before buffering; checking
        # only while rendering the buffered values would leave this work unbudgeted.
        resource_limits.increment_render_score(1)
        segments << item if from <= index
        index += 1
      end
      segments
    end
    private_class_method :slice_collection_for_iteration_using_each
    def self.range_method_overridden?(collection, method_name)
      collection.method(method_name).owner != Range.instance_method(method_name).owner
    end
    private_class_method :range_method_overridden?
    def self.to_integer(num)
      return num if num.is_a?(Integer)
      num = num.to_s
      begin
        Integer(num)
      rescue ::ArgumentError
        raise Liquid::ArgumentError, "invalid integer"
      end
    end
    def self.to_number(obj)
      case obj
      when Float
        BigDecimal(obj.to_s)
      when Numeric
        obj
      when String
        DECIMAL_REGEX.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
      else
        if obj.respond_to?(:to_number)
          obj.to_number
        else
          0
        end
      end
    end
    def self.to_date(obj)
      return obj if obj.respond_to?(:strftime)
      if obj.is_a?(String)
        return if obj.empty?
        obj = obj.downcase
      end
      case obj
      when 'now', 'today'
        Time.now
      when UNIX_TIMESTAMP_REGEX, Integer
        Time.at(obj.to_i)
      when String
        Time.parse(obj)
      end
    rescue ::ArgumentError
      nil
    end
    def self.to_liquid_value(obj)
      # Enable "obj" to represent itself as a primitive value like integer, string, or boolean
      return obj.to_liquid_value if obj.respond_to?(:to_liquid_value)
      # 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
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Holds variables. Variables are only loaded "just in time"
  # and are not evaluated as part of the render stage
  #
@@ -12,189 +11,97 @@ module Liquid
  #   {{ user | link }}
  #
  class Variable
-    FilterMarkupRegex        = /#{FilterSeparator}\s*(.*)/om
+    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    FilterParser             = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    attr_accessor :filters, :name, :warnings
-    FilterArgsRegex          = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
+    attr_accessor :line_number
    JustTagAttributes        = /\A#{TagAttributes}\z/o
    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
    attr_accessor :filters, :name, :line_number
    attr_reader :parse_context
    alias_method :options, :parse_context
    include ParserSwitching
-    def initialize(markup, parse_context)
+    def initialize(markup, options = {})
-      @markup        = markup
+      @markup  = markup
-      @name          = nil
+      @name    = nil
-      @parse_context = parse_context
+      @options = options || {}
      @line_number   = parse_context.line_number
-      strict_parse_with_error_mode_fallback(markup)
+      parse_with_selected_parser(markup)
    end
    def raw
      @markup
    end
    def ==(other)
      self.class == other.class && name == other.name && filters == other.filters
    end
    def markup_context(markup)
      "in \"{{#{markup}}}\""
    end
    def lax_parse(markup)
-      @filters = []
+      @filters ||= []
-      return unless markup =~ MarkupWithQuotedFragment
+      @filters.clear
-
+      if markup =~ /(#{QuotedFragment})(.*)/om
-      name_markup   = Regexp.last_match(1)
+        name_markup = $1
-      filter_markup = Regexp.last_match(2)
+        filter_markup = $2
-      @name         = parse_context.parse_expression(name_markup)
+        @name = Expression.parse(name_markup)
-      if filter_markup =~ FilterMarkupRegex
+        if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
-        filters = Regexp.last_match(1).scan(FilterParser)
+          filters = $1.scan(FilterParser)
-        filters.each do |f|
+          filters.each do |f|
-          next unless f =~ /\w+/
+            if f =~ /\w+/
-          filtername = Regexp.last_match(0)
+              filtername = Regexp.last_match(0)
-          filterargs = f.scan(FilterArgsRegex).flatten
+              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-          @filters << lax_parse_filter_expressions(filtername, filterargs)
+              @filters << parse_filter_expressions(filtername, filterargs)
            end
          end
        end
      end
    end
    def strict_parse(markup)
-      @filters = []
+      @filters ||= []
-      p = @parse_context.new_parser(markup)
+      @filters.clear
      p = Parser.new(markup)
-      return if p.look(:end_of_string)
+      @name = Expression.parse(p.expression)
      @name = parse_context.safe_parse_expression(p)
      while p.consume?(:pipe)
        filtername = p.consume(:id)
-        filterargs = p.consume?(:colon) ? parse_filterargs(p) : Const::EMPTY_ARRAY
+        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
-        @filters << lax_parse_filter_expressions(filtername, filterargs)
+        @filters << parse_filter_expressions(filtername, filterargs)
      end
      p.consume(:end_of_string)
    end
    def strict2_parse(markup)
      @filters = []
      p = @parse_context.new_parser(markup)
      return if p.look(:end_of_string)
      @name = parse_context.safe_parse_expression(p)
      @filters << strict2_parse_filter_expressions(p) while p.consume?(:pipe)
      p.consume(:end_of_string)
    end
    def parse_filterargs(p)
      # first argument
      filterargs = [p.argument]
      # followed by comma separated others
-      filterargs << p.argument while p.consume?(:comma)
+      while p.consume?(:comma)
        filterargs << p.argument
      end
      filterargs
    end
    def render(context)
-      obj = context.evaluate(@name)
+      @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
      @filters.each do |filter_name, filter_args, filter_kwargs|
        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        obj = context.invoke(filter_name, obj, *filter_args)
+        output = context.invoke(filter_name, output, *filter_args)
-      end
+      end.tap{ |obj| taint_check(obj) }
      context.apply_global_filter(obj)
    end
    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
      else
        output << Liquid::Utils.to_s(obj)
      end
    end
    def disabled?(_context)
      false
    end
    def disabled_tags
      []
    end
    private
-    def lax_parse_filter_expressions(filter_name, unparsed_args)
+    def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args  = []
+      filter_args = []
-      keyword_args = nil
+      keyword_args = {}
      unparsed_args.each do |a|
-        if (matches = a.match(JustTagAttributes))
+        if matches = a.match(/\A#{TagAttributes}\z/o)
-          keyword_args           ||= {}
+          keyword_args[matches[1]] = Expression.parse(matches[2])
          keyword_args[matches[1]] = parse_context.parse_expression(matches[2])
        else
-          filter_args << parse_context.parse_expression(a)
+          filter_args << Expression.parse(a)
        end
      end
      result = [filter_name, filter_args]
      result << keyword_args if keyword_args
      result
    end
    # Surprisingly, positional and keyword arguments can be mixed.
    #
    # filter = filtername [":" filterargs?]
    # filterargs = argument ("," argument)*
    # argument = (positional_argument | keyword_argument)
    # positional_argument = expression
    # keyword_argument = id ":" expression
    def strict2_parse_filter_expressions(p)
      filtername = p.consume(:id)
      filter_args = []
      keyword_args = {}
      if p.consume?(:colon)
        # Parse first argument (no leading comma)
        argument(p, filter_args, keyword_args) unless end_of_arguments?(p)
        # Parse remaining arguments (with leading commas) and optional trailing comma
        argument(p, filter_args, keyword_args) while p.consume?(:comma) && !end_of_arguments?(p)
      end
      result = [filtername, filter_args]
      result << keyword_args unless keyword_args.empty?
      result
    end
    def argument(p, positional_arguments, keyword_arguments)
      if p.look(:id) && p.look(:colon, 1)
        key = p.consume(:id)
        p.consume(:colon)
        value = parse_context.safe_parse_expression(p)
        keyword_arguments[key] = value
      else
        positional_arguments << parse_context.safe_parse_expression(p)
      end
    end
    def end_of_arguments?(p)
      p.look(:pipe) || p.look(:end_of_string)
    end
    def evaluate_filter_expressions(context, filter_args, filter_kwargs)
-      parsed_args = filter_args.map { |expr| context.evaluate(expr) }
+      parsed_args = filter_args.map{ |expr| context.evaluate(expr) }
      if filter_kwargs
        parsed_kwargs = {}
        filter_kwargs.each do |key, expr|
@@ -205,9 +112,17 @@ module Liquid
      parsed_args
    end
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+    def taint_check(obj)
-      def children
+      if obj.tainted?
-        [@node.name] + @node.filters.flatten
+        @markup =~ QuotedFragment
        name = Regexp.last_match(0)
        case Template.taint_mode
        when :warn
          @warnings ||= []
          @warnings << "variable '#{name}' is tainted and was not escaped"
        when :error
          raise TaintedError, "Error - variable '#{name}' is tainted and was not escaped"
        end
      end
    end
  end
@@ -1,86 +1,62 @@
 # frozen_string_literal: true
 module Liquid
  class VariableLookup
-    COMMAND_METHODS = ['size', 'first', 'last'].freeze
+    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
    attr_reader :name, :lookups
-    def self.parse(markup, string_scanner = StringScanner.new(""), cache = nil)
+    def self.parse(markup)
-      new(markup, string_scanner, cache)
+      new(markup)
    end
-    def initialize(markup, string_scanner = StringScanner.new(""), cache = nil)
+    def initialize(markup)
-      lookups = markup.scan(VariableParser)
+      @lookups = markup.scan(VariableParser)
-      name = lookups.shift
+      name = @lookups.shift
-      if name&.start_with?('[') && name&.end_with?(']')
+      if name =~ SQUARE_BRACKETED
-        name = Expression.parse(
+        name = Expression.parse($1)
          name[1..-2],
          string_scanner,
          cache,
        )
      end
      @name = name
      @lookups       = lookups
      @command_flags = 0
      @lookups.each_index do |i|
-        lookup = lookups[i]
+        lookup = @lookups[i]
-        if lookup&.start_with?('[') && lookup&.end_with?(']')
+        if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse(
+          @lookups[i] = Expression.parse($1)
            lookup[1..-2],
            string_scanner,
            cache,
          )
        elsif COMMAND_METHODS.include?(lookup)
          @command_flags |= 1 << i
        end
      end
    end
    def lookup_command?(lookup_index)
      @command_flags & (1 << lookup_index) != 0
    end
    def evaluate(context)
-      name   = context.evaluate(@name)
+      name = context.evaluate(@name)
      object = context.find_variable(name)
      @lookups.each_index do |i|
        key = context.evaluate(@lookups[i])
        # Cast "key" to its liquid value to enable it to act as a primitive value
        key = Liquid::Utils.to_liquid_value(key)
        # If object is a hash- or array-like object we look for the
        # presence of the key and if its available we return it
        if object.respond_to?(:[]) &&
-            ((object.respond_to?(:key?) && object.key?(key)) ||
+          ((object.respond_to?(:has_key?) && object.has_key?(key)) ||
-             (object.respond_to?(:fetch) && key.is_a?(Integer)))
+           (object.respond_to?(:fetch) && key.is_a?(Integer)))
          # if its a proc we will replace the entry with the proc
-          res    = context.lookup_and_evaluate(object, key)
+          res = context.lookup_and_evaluate(object, key)
          object = res.to_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
+          # keywords either. The only thing we got left is to return nil
          # raise an exception if `strict_variables` option is set to true
        else
-          return nil unless context.strict_variables
+          return nil
          raise Liquid::UndefinedVariable, "undefined variable #{key}"
        end
        # If we are dealing with a drop here we have to
@@ -91,7 +67,7 @@ module Liquid
    end
    def ==(other)
-      self.class == other.class && state == other.state
+      self.class == other.class && self.state == other.state
    end
    protected
@@ -99,11 +75,5 @@ module Liquid
    def state
      [@name, @lookups, @command_flags]
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        @node.lookups
      end
    end
  end
 end
@@ -1,6 +1,4 @@
 # encoding: utf-8
 # frozen_string_literal: true
 module Liquid
-  VERSION = "5.14.0"
+  VERSION = "4.0.0.alpha"
 end
@@ -1,8 +1,6 @@
 # encoding: utf-8
 # frozen_string_literal: true
 lib = File.expand_path('../lib/', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$:.unshift lib unless $:.include?(lib)
 require "liquid/version"
@@ -13,24 +11,19 @@ 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.description = "A secure, non-evaling end user template engine with aesthetic markup."
  s.required_ruby_version     = ">= 3.0.0"
  s.required_rubygems_version = ">= 1.3.7"
-  s.metadata['allowed_push_host'] = 'https://rubygems.org'
+  s.test_files  = Dir.glob("{test}/**/*")
  s.files       = Dir.glob("{lib}/**/*") + %w(MIT-LICENSE README.md)
-  s.files = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
+  s.extra_rdoc_files  = ["History.md", "README.md"]
  s.extra_rdoc_files = ["History.md", "README.md"]
  s.require_path = "lib"
-  s.add_dependency("strscan", ">= 3.1.1")
+  s.add_development_dependency 'rake'
-  s.add_dependency("bigdecimal")
+  s.add_development_dependency 'minitest'
  s.add_development_dependency('rake', '~> 13.0')
  s.add_development_dependency('minitest')
 end
@@ -1,25 +1,17 @@
 # frozen_string_literal: true
 require 'benchmark/ips'
-require_relative 'theme_runner'
+require File.dirname(__FILE__) + '/theme_runner'
 RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
 Liquid::Environment.default.error_mode = ARGV.first.to_sym if ARGV.first
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 Benchmark.ips do |x|
-  x.time   = 20
+  x.time = 60
-  x.warmup = 10
+  x.warmup = 5
  puts
  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
  puts
-  phase = ENV["PHASE"] || "all"
+  x.report("parse:") { profiler.compile }
-
+  x.report("parse & run:") { profiler.run }
  x.report("tokenize:") { profiler.tokenize } if phase == "all" || phase == "tokenize"
  x.report("parse:") { profiler.compile } if phase == "all" || phase == "parse"
  x.report("render:") { profiler.render } if phase == "all" || phase == "render"
  x.report("parse & render:") { profiler.run } if phase == "all" || phase == "run"
 end
@@ -0,0 +1,19 @@
 at_exit do
  p 'Objects distribution:'
  require 'pp'
  pp ObjectSpace.count_objects
 end
 require 'allocation_tracer' rescue fail("install allocation_tracer extension/gem")
 require File.dirname(__FILE__) + '/theme_runner'
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 require 'allocation_tracer/trace'
 puts "Profiling memory usage..."
 200.times do
  profiler.run
 end
@@ -1,63 +0,0 @@
 # frozen_string_literal: true
 require 'benchmark/ips'
 require 'memory_profiler'
 require 'terminal-table'
 require_relative 'theme_runner'
 class Profiler
  LOG_LABEL   = "Profiling: ".rjust(14).freeze
  REPORTS_DIR = File.expand_path('.memprof', __dir__).freeze
  def self.run
    puts
    yield new
  end
  def initialize
    @allocated = []
    @retained  = []
    @headings  = []
  end
  def profile(phase, &block)
    print(LOG_LABEL)
    print("#{phase}.. ".ljust(10))
    report = MemoryProfiler.report(&block)
    puts 'Done.'
    @headings  << phase.capitalize
    @allocated << "#{report.scale_bytes(report.total_allocated_memsize)} (#{report.total_allocated} objects)"
    @retained  << "#{report.scale_bytes(report.total_retained_memsize)} (#{report.total_retained} objects)"
    return if ENV['CI']
    require 'fileutils'
    report_file = File.join(REPORTS_DIR, "#{sanitize(phase)}.txt")
    FileUtils.mkdir_p(REPORTS_DIR)
    report.pretty_print(to_file: report_file, scale_bytes: true)
  end
  def tabulate
    table = Terminal::Table.new(headings: @headings.unshift('Phase')) do |t|
      t << @allocated.unshift('Total allocated')
      t << @retained.unshift('Total retained')
    end
    puts
    puts table
    puts "\nDetailed report(s) saved to #{REPORTS_DIR}/" unless ENV['CI']
  end
  def sanitize(string)
    string.downcase.gsub(/[\W]/, '-').squeeze('-')
  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 }
  x.profile('render') { runner.render }
  x.tabulate
 end
@@ -1,21 +1,19 @@
-# frozen_string_literal: true
+require 'stackprof' rescue fail("install stackprof extension/gem")
-
+require File.dirname(__FILE__) + '/theme_runner'
 require 'stackprof'
 require_relative 'theme_runner'
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run
 [:cpu, :object].each do |profile_type|
-  puts "Profiling in #{profile_type} mode..."
+  puts "Profiling in #{profile_type.to_s} mode..."
  results = StackProf.run(mode: profile_type) do
    200.times do
      profiler.run
    end
  end
-  if profile_type == :cpu && (graph_filename = ENV['GRAPH_FILENAME'])
+  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
    File.open(graph_filename, 'w') do |f|
      StackProf::Report.new(results).print_graphviz(nil, f)
    end
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 class CommentForm < Liquid::Block
  Syntax = /(#{Liquid::VariableSignature}+)/
@@ -7,14 +5,14 @@ class CommentForm < Liquid::Block
    super
    if markup =~ Syntax
-      @variable_name = Regexp.last_match(1)
+      @variable_name = $1
-      @attributes    = {}
+      @attributes = {}
    else
-      raise SyntaxError, "Syntax Error in 'comment_form' - Valid syntax: comment_form [article]"
+      raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
    end
  end
-  def render_to_output_buffer(context, output)
+  def render(context)
    article = context[@variable_name]
    context.stack do
@@ -22,16 +20,14 @@ class CommentForm < Liquid::Block
        'posted_successfully?' => context.registers[:posted_successfully],
        'errors' => context['comment.errors'],
        'author' => context['comment.author'],
-        'email' => context['comment.email'],
+        'email'  => context['comment.email'],
-        'body' => context['comment.body'],
+        'body'   => context['comment.body']
      }
-
+      wrap_in_form(article, render_all(@nodelist, context))
      output << wrap_in_form(article, render_all(@nodelist, context, output))
      output
    end
  end
  def wrap_in_form(article, input)
-    %(<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>)
+    %Q{<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>}
  end
 end
@@ -1,21 +1,11 @@
 # frozen_string_literal: true
 require 'yaml'
 module Database
  DATABASE_FILE_PATH = "#{__dir__}/vision.database.yml"
  # Load the standard vision toolkit database and re-arrage it to be simply exportable
  # to liquid as assigns. All this is based on Shopify
  def self.tables
    @tables ||= begin
-      db =
+      db = YAML.load_file(File.dirname(__FILE__) + '/vision.database.yml')
        if YAML.respond_to?(:unsafe_load_file) # Only Psych 4+ can use unsafe_load_file
          # unsafe_load_file is needed for YAML references
          YAML.unsafe_load_file(DATABASE_FILE_PATH)
        else
          YAML.load_file(DATABASE_FILE_PATH)
        end
      # From vision source
      db['products'].each do |product|
@@ -26,10 +16,9 @@ module Database
      end
      # key the tables by handles, as this is how liquid expects it.
-      db = db.each_with_object({}) do |(key, values), assigns|
+      db = db.inject({}) do |assigns, (key, values)|
-        assigns[key] = values.each_with_object({}) do |v, h|
+        assigns[key] = values.inject({}) { |h, v| h[v['handle']] = v; h; }
-          h[v['handle']] = v
+        assigns
        end
      end
      # Some standard direct accessors so that the specialized templates
@@ -40,12 +29,17 @@ module Database
      db['article']    = db['blog']['articles'].first
      db['cart']       = {
-        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum + item['line_price'] * item['quantity'] },
+        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
-        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum + item['quantity'] },
+        'item_count'  => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
-        'items' => db['line_items'].values,
+        'items'       => db['line_items'].values
      }
      db
    end
  end
 end
 if __FILE__ == $0
  p Database.tables['collections']['frontpage'].keys
  #p Database.tables['blog']['articles']
 end
@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 require 'json'
 module JsonFilter
  def json(object)
-    JSON.dump(object.reject { |k, _v| k == "collections" })
+    JSON.dump(object.reject {|k,v| k == "collections" })
  end
 end
@@ -1,22 +1,19 @@
-# frozen_string_literal: true
+$:.unshift File.dirname(__FILE__) + '/../../lib'
 require File.dirname(__FILE__) + '/../../lib/liquid'
-$LOAD_PATH.unshift(__dir__ + '/../../lib')
+require File.dirname(__FILE__) + '/comment_form'
-require_relative '../../lib/liquid'
+require File.dirname(__FILE__) + '/paginate'
 require File.dirname(__FILE__) + '/json_filter'
 require File.dirname(__FILE__) + '/money_filter'
 require File.dirname(__FILE__) + '/shop_filter'
 require File.dirname(__FILE__) + '/tag_filter'
 require File.dirname(__FILE__) + '/weight_filter'
-require_relative 'comment_form'
+Liquid::Template.register_tag 'paginate', Paginate
-require_relative 'paginate'
+Liquid::Template.register_tag 'form', CommentForm
 require_relative 'json_filter'
 require_relative 'money_filter'
 require_relative 'shop_filter'
 require_relative 'tag_filter'
 require_relative 'weight_filter'
-default_environment = Liquid::Environment.default
+Liquid::Template.register_filter JsonFilter
-default_environment.register_tag('paginate', Paginate)
+Liquid::Template.register_filter MoneyFilter
-default_environment.register_tag('form', CommentForm)
+Liquid::Template.register_filter WeightFilter
-
+Liquid::Template.register_filter ShopFilter
-default_environment.register_filter(JsonFilter)
+Liquid::Template.register_filter TagFilter
 default_environment.register_filter(MoneyFilter)
 default_environment.register_filter(WeightFilter)
 default_environment.register_filter(ShopFilter)
 default_environment.register_filter(TagFilter)
@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 module MoneyFilter
  def money_with_currency(money)
    return '' if money.nil?
-    format("$ %.2f USD", money / 100.0)
+    sprintf("$ %.2f USD", money/100.0)
  end
  def money(money)
    return '' if money.nil?
-    format("$ %.2f", money / 100.0)
+    sprintf("$ %.2f", money/100.0)
  end
  private
@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 class Paginate < Liquid::Block
-  Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
  def initialize(tag_name, markup, options)
    super
    if markup =~ Syntax
-      @collection_name = Regexp.last_match(1)
+      @collection_name = $1
-      @page_size       = if Regexp.last_match(2)
+      @page_size = if $2
-        Regexp.last_match(3).to_i
+        $3.to_i
      else
        20
      end
@@ -19,47 +17,48 @@ class Paginate < Liquid::Block
        @attributes[key] = value
      end
    else
-      raise SyntaxError, "Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number"
+      raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
    end
  end
-  def render_to_output_buffer(context, output)
+  def render(context)
    @context = context
    context.stack do
-      current_page = context['current_page'].to_i
+      current_page  = context['current_page'].to_i
      pagination = {
-        'page_size' => @page_size,
+        'page_size'      => @page_size,
-        'current_page' => 5,
+        'current_page'   => 5,
-        'current_offset' => @page_size * 5,
+        'current_offset' => @page_size * 5
      }
      context['paginate'] = pagination
-      collection_size = context[@collection_name].size
+      collection_size  = context[@collection_name].size
-      raise ArgumentError, "Cannot paginate array '#{@collection_name}'. Not found." if collection_size.nil?
+      raise ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection_size.nil?
      page_count = (collection_size.to_f / @page_size.to_f).to_f.ceil + 1
      pagination['items']      = collection_size
-      pagination['pages']      = page_count - 1
+      pagination['pages']      = page_count -1
-      pagination['previous']   = link('&laquo; Previous', current_page - 1)  if 1 < current_page
+      pagination['previous']   = link('&laquo; Previous', current_page-1 )  unless 1 >= current_page
-      pagination['next']       = link('Next &raquo;', current_page + 1)      if page_count > current_page + 1
+      pagination['next']       = link('Next &raquo;', current_page+1 )      unless page_count <= current_page+1
      pagination['parts']      = []
      hellip_break = false
      if page_count > 2
-        1.upto(page_count - 1) do |page|
+        1.upto(page_count-1) do |page|
          if current_page == page
            pagination['parts'] << no_link(page)
          elsif page == 1
            pagination['parts'] << link(page, page)
-          elsif page == page_count - 1
+          elsif page == page_count -1
            pagination['parts'] << link(page, page)
-          elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size']
+          elsif page <= current_page - @attributes['window_size'] or page >= current_page + @attributes['window_size']
            next if hellip_break
            pagination['parts'] << no_link('&hellip;')
            hellip_break = true
@@ -79,11 +78,11 @@ class Paginate < Liquid::Block
  private
  def no_link(title)
-    { 'title' => title, 'is_link' => false }
+    { 'title' => title, 'is_link' => false}
  end
  def link(title, page)
-    { 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true }
+    { 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true}
  end
  def current_url
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module ShopFilter
  def asset_url(input)
    "/files/1/[shop_id]/[shop_id]/assets/#{input}"
  end
@@ -17,21 +16,21 @@ module ShopFilter
    %(<script src="#{url}" type="text/javascript"></script>)
  end
-  def stylesheet_tag(url, media = "all")
+  def stylesheet_tag(url, media="all")
    %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
  end
-  def link_to(link, url, title = "")
+  def link_to(link, url, title="")
-    %(<a href="#{url}" title="#{title}">#{link}</a>)
+    %|<a href="#{url}" title="#{title}">#{link}</a>|
  end
-  def img_tag(url, alt = "")
+  def img_tag(url, alt="")
-    %(<img src="#{url}" alt="#{alt}" />)
+    %|<img src="#{url}" alt="#{alt}" />|
  end
  def link_to_vendor(vendor)
    if vendor
-      link_to(vendor, url_for_vendor(vendor), vendor)
+      link_to vendor, url_for_vendor(vendor), vendor
    else
      'Unknown Vendor'
    end
@@ -39,7 +38,7 @@ module ShopFilter
  def link_to_type(type)
    if type
-      link_to(type, url_for_type(type), type)
+      link_to type, url_for_type(type), type
    else
      'Unknown Vendor'
    end
@@ -54,32 +53,36 @@ module ShopFilter
  end
  def product_img_url(url, style = 'small')
-    unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
+
    unless url =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
      raise ArgumentError, 'filter "size" can only be called on product images'
    end
    case style
    when 'original'
-      '/files/shops/random_number/' + url
+      return '/files/shops/random_number/' + url
    when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
+      "/files/shops/random_number/products/#{$1}_#{style}.#{$2}"
    else
      raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '
    end
  end
  def default_pagination(paginate)
    html = []
    html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
-    paginate['parts'].each do |part|
+    for part in paginate['parts']
-      html << if part['is_link']
+
-        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+      if part['is_link']
        html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
      elsif part['title'].to_i == paginate['current_page'].to_i
-        %(<span class="page current">#{part['title']}</span>)
+        html << %(<span class="page current">#{part['title']}</span>)
      else
-        %(<span class="deco">#{part['title']}</span>)
+        html << %(<span class="deco">#{part['title']}</span>)
      end
    end
    html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
@@ -103,4 +106,5 @@ module ShopFilter
    result.gsub!(/\A-+/, '') if result[0] == '-'
    result
  end
 end
@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 module TagFilter
  def link_to_tag(label, tag)
    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
  end
-  def highlight_active_tag(tag, css_class = 'active')
+  def highlight_active_tag(tag, css_class='active')
    if @context['current_tags'].include?(tag)
      "<span class=\"#{css_class}\">#{tag}</span>"
    else
@@ -15,11 +14,12 @@ module TagFilter
  def link_to_add_tag(label, tag)
    tags = (@context['current_tags'] + [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
  end
  def link_to_remove_tag(label, tag)
    tags = (@context['current_tags'] - [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
  end
 end
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Lourens Naudé	e853bf5b84	Also dump object distribution	2015-05-06 10:45:20 -04:00
Lourens Naudé	27248f1eb1	Lazy init context errors and interrupts to prevent excess allocation	2015-05-05 23:40:52 -04:00
Lourens Naudé	174839fbef	Reuse filters array during variable parsing	2015-05-05 23:30:05 -04:00
Lourens Naudé	01a86728f2	Remove needless intermediate local var in VariableLookup#initialize	2015-05-05 23:21:28 -04:00
Lourens Naudé	0e38f88b58	Recycle the array buffer in BlockBody#render	2015-05-05 23:02:08 -04:00
Lourens Naudé	5a48edae6a	Introduce support for memory usage profiles	2015-05-05 23:00:28 -04:00