Force #to_liquid call in InputIterator#each

.github/probots.yml

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

.github/workflows/liquid.yml

@@ -1,40 +0,0 @@
-name: Liquid
-on: [push, pull_request]
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        entry:
-          - { ruby: 2.5, allowed-failure: false }
-          - { ruby: 2.6, allowed-failure: false }
-          - { ruby: 2.7, allowed-failure: false }
-          - { ruby: ruby-head, allowed-failure: true }
-    name: test (${{ matrix.entry.ruby }})
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.entry.ruby }}
-      - uses: actions/cache@v1
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
-          restore-keys: ${{ runner.os }}-gems-
-      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
-      - run: bundle exec rake
-        continue-on-error: ${{ matrix.entry.allowed-failure }}
-  memory_profile:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 2.7
-      - uses: actions/cache@v1
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
-          restore-keys: ${{ runner.os }}-gems-
-      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
-      - run: bundle exec rake memory_profile:run

.gitignore

@@ -7,4 +7,3 @@ pkg
 .ruby-version
 Gemfile.lock
 .bundle
-.byebug_history

.rubocop.yml

@@ -1,18 +1,125 @@
-inherit_from:
+inherit_from: ./.rubocop_todo.yml
-  - 'https://shopify.github.io/ruby-style-guide/rubocop.yml'
-  - .rubocop_todo.yml
-
-require: rubocop-performance
-
-Performance:
-  Enabled: true
 
 AllCops:
-  TargetRubyVersion: 2.4
-  NewCops: disable
   Exclude:
-    - 'vendor/bundle/**/*'
+    - 'performance/shopify/*'
+    - 'pkg/**'
 
-Naming/MethodName:
+Metrics/BlockNesting:
+  Max: 3
   Exclude:
-    - 'example/server/liquid_servlet.rb'
+    - 'lib/liquid/block_body.rb'
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Lint/AssignmentInCondition:
+  Enabled: false
+
+Lint/AmbiguousOperator:
+  Enabled: false
+
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+Lint/ParenthesesAsGroupedExpression:
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+Lint/EndAlignment:
+  AlignWith: variable
+
+Lint/UnusedMethodArgument:
+  Enabled: false
+
+Style/SingleLineBlockParams:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+
+Style/AndOr:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/SpaceInsideBrackets:
+  Enabled: false
+
+Style/SpaceBeforeBlockBraces:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/TrailingComma:
+  Enabled: false
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+Style/FormatString:
+  Enabled: false
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: false
+
+Style/DeprecatedHashMethods:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/SymbolLiteral:
+  Enabled: false
+
+Performance/Count:
+  Enabled: false
+
+Style/ConstantName:
+  Enabled: false
+
+Style/CaseIndentation:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/TrivialAccessors:
+  AllowPredicates: true
+
+Style/WordArray:
+  Enabled: false

.rubocop_todo.yml

@@ -1,57 +1,72 @@
-# This configuration was generated by
+# This configuration was generated by `rubocop --auto-gen-config`
-# `rubocop --auto-gen-config`
+# on 2015-06-08 18:16:16 +0000 using RuboCop version 0.32.0.
-# on 2020-12-11 18:53:41 UTC using RuboCop version 1.6.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 2
+# Offense count: 5
+Lint/NestedMethodDefinition:
+  Enabled: false
+
+# Offense count: 53
+Metrics/AbcSize:
+  Max: 58
+
+# Offense count: 12
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+# Offense count: 553
+# Configuration parameters: AllowURI, URISchemes.
+Metrics/LineLength:
+  Max: 294
+
+# Offense count: 77
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Max: 46
+
+# Offense count: 6
+Metrics/PerceivedComplexity:
+  Max: 13
+
+# Offense count: 1
+Style/AccessorMethodName:
+  Enabled: false
+
+# Offense count: 1
 # Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
+Style/ClosingParenthesisIndentation:
-# SupportedStyles: runtime_error, standard_error
+  Enabled: false
-Lint/InheritException:
-  Exclude:
-    - 'lib/liquid/interrupts.rb'
 
-# Offense count: 113
+# Offense count: 3
-# Cop supports --auto-correct.
+# Configuration parameters: MinBodyLength.
-# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+Style/GuardClause:
-# URISchemes: http, https
+  Enabled: false
-Layout/LineLength:
-  Max: 260
 
-# Offense count: 8
+# Offense count: 4
-Lint/MissingSuper:
+# Configuration parameters: EnforcedStyle, SupportedStyles.
-  Exclude:
+Style/MethodName:
-    - 'lib/liquid/forloop_drop.rb'
+  Enabled: false
-    - '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: 43
+# Offense count: 1
-Naming/ConstantName:
+Style/MultilineBlockChain:
-  Exclude:
+  Enabled: false
-    - '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: 2
-Style/ClassVars:
+# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
-  Exclude:
+Style/Next:
-    - 'lib/liquid/condition.rb'
+  Enabled: false
+
+# Offense count: 7
+# Cop supports --auto-correct.
+# Configuration parameters: AllowAsExpressionSeparator.
+Style/Semicolon:
+  Enabled: false
+
+# Offense count: 1
+# Cop supports --auto-correct.
+# Configuration parameters: MaxLineLength.
+Style/WhileUntilModifier:
+  Enabled: false

.travis.yml

@@ -0,0 +1,25 @@
+language: ruby
+
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - ruby-head
+  - jruby-head
+#  - rbx-2
+
+sudo: false
+
+addons:
+  apt:
+    packages:
+    - libgmp3-dev
+
+matrix:
+  allow_failures:
+    - rvm: jruby-head
+
+script: "bundle exec rake"
+
+notifications:
+  disable: true

CONTRIBUTING.md

@@ -4,22 +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
 
 ## 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
 
 ## Workflow
 
 * Fork the Liquid repository
 * Create a new branch in your fork
-* If it makes sense, add tests for your code and/or run a performance benchmark
+* If it makes sense, add tests for your code and run a performance benchmark
-* Make sure all tests pass (`bundle exec rake`)
+* Make sure all tests pass
 * 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.
 

Gemfile

@@ -1,27 +1,14 @@
-# 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
-group :benchmark, :test do
-  gem 'benchmark-ips'
-  gem 'memory_profiler'
-  gem 'terminal-table'
-
-  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
-    gem 'stackprof'
-  end
-end
 
 group :test do
-  gem 'rubocop', '~> 1.4', require: false
+  gem 'spy', '0.4.1'
-  gem 'rubocop-performance', require: false
+  gem 'benchmark-ips'
+  gem 'rubocop', '0.34.2'
 
-  platform :mri, :truffleruby do
+  platform :mri do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: '2570693d8d03faa0df9160ec74348a7149436df3'
   end
 end

History.md

@@ -1,98 +1,8 @@
 # Liquid Change Log
 
-## 5.0.0 / 2021-01-06
+## 4.0.0 / not yet released / branch "master"
-
-### 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]
-
-## 4.0.2 / 2019-03-08
 
 ### Changed
-* 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]
@@ -106,13 +16,9 @@
 * 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)
+* Remove support for `liquid_methods`
-* 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]

README.md

@@ -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.
 
@@ -75,40 +73,3 @@ This is useful for doing things like enabling strict mode only in the theme edit
 
 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
-```
-
-### 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.

Rakefile

@@ -1,39 +1,29 @@
-# 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: [:rubocop, :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
-  if RUBY_ENGINE == 'ruby'
+  require 'rubocop/rake_task'
-    require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
-    RuboCop::RakeTask.new
-  end
 end
 
-desc('runs test suite with both strict and lax parsers')
+desc 'runs test suite with both strict and lax parsers'
 task :test do
   ENV['LIQUID_PARSER_MODE'] = 'lax'
   Rake::Task['base_test'].invoke
@@ -42,20 +32,20 @@ task :test do
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
-  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
+  if RUBY_ENGINE == 'ruby'
-    ENV['LIQUID_C'] = '1'
+    ENV['LIQUID-C'] = '1'
 
     ENV['LIQUID_PARSER_MODE'] = 'lax'
-    Rake::Task['integration_test'].reenable
+    Rake::Task['base_test'].reenable
-    Rake::Task['integration_test'].invoke
+    Rake::Task['base_test'].invoke
 
     ENV['LIQUID_PARSER_MODE'] = 'strict'
-    Rake::Task['integration_test'].reenable
+    Rake::Task['base_test'].reenable
-    Rake::Task['integration_test'].invoke
+    Rake::Task['base_test'].invoke
   end
 end
 
-task(gem: :build)
+task gem: :build
 task :build do
   system "gem build liquid.gemspec"
 end
@@ -95,14 +85,7 @@ namespace :profile do
   end
 end
 
-namespace :memory_profile do
+desc "Run example"
-  desc "Run memory profiler"
-  task :run do
-    ruby "./performance/memory_profile.rb"
-  end
-end
-
-desc("Run example")
 task :example do
   ruby "-w -d -Ilib example/server/server.rb"
 end

circle.yml

@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: ruby-2.0

example/server/example_servlet.rb

@@ -1,8 +1,6 @@
-# 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)

example/server/liquid_servlet.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
   def do_GET(req, res)
     handle(:get, req, res)
@@ -11,17 +9,17 @@ 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)

example/server/server.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'webrick'
 require 'rexml/document'
 
@@ -10,5 +8,5 @@ require_relative 'example_servlet'
 # Setup webrick
 server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
 server.mount('/', Servlet)
-trap("INT") { server.shutdown }
+trap("INT"){ server.shutdown }
 server.start

lib/liquid.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # Copyright (c) 2005 Tobias Luetke
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -23,10 +21,9 @@
 
 module Liquid
   FilterSeparator             = /\|/
-  ArgumentSeparator           = ','
+  ArgumentSeparator           = ','.freeze
-  FilterArgumentSeparator     = ':'
+  FilterArgumentSeparator     = ':'.freeze
-  VariableAttributeSeparator  = '.'
+  VariableAttributeSeparator  = '.'.freeze
-  WhitespaceControl           = '-'
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -37,19 +34,16 @@ module Liquid
   QuotedString                = /"[^"]*"|'[^']*'/
   QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
-  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
+  AnyStartingTag              = /\{\{|\{\%/
   PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
   TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
 
-  RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
-
   singleton_class.send(:attr_accessor, :cache_classes)
   self.cache_classes = true
 end
 
 require "liquid/version"
-require 'liquid/parse_tree_visitor'
 require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
@@ -59,14 +53,11 @@ require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer_factory'
+require 'liquid/strainer'
-require 'liquid/strainer_template'
 require 'liquid/expression'
 require 'liquid/context'
 require 'liquid/parser_switching'
 require 'liquid/tag'
-require 'liquid/tag/disabler'
-require 'liquid/tag/disableable'
 require 'liquid/block'
 require 'liquid/block_body'
 require 'liquid/document'
@@ -81,11 +72,6 @@ require 'liquid/condition'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'
-require 'liquid/partial_cache'
-require 'liquid/usage'
-require 'liquid/register'
-require 'liquid/static_registers'
-require 'liquid/template_factory'
 
 # Load all the tags of the standard library
 #

lib/liquid/block.rb

@@ -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)
       end
-      @body.freeze
     end
 
-    # For backwards compatibility
     def render(context)
       @body.render(context)
     end
@@ -29,29 +23,20 @@ module Liquid
       @body.nodelist
     end
 
-    def unknown_tag(tag_name, _markup, _tokenizer)
+    def unknown_tag(tag, _params, _tokens)
-      Block.raise_unknown_tag(tag_name, block_name, block_delimiter, parse_context)
+      case tag
-    end
+      when 'else'.freeze
-
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_else".freeze,
-    # @api private
+          block_name: block_name))
-    def self.raise_unknown_tag(tag, block_name, block_delimiter, parse_context)
+      when 'end'.freeze
-      if tag == 'else'
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
-        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)
+          block_delimiter: block_delimiter))
       else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
       end
     end
 
-    def raise_tag_never_closed(block_name)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
-    end
-
     def block_name
       @tag_name
     end
@@ -60,32 +45,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, parse_context) 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(parse_context.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

lib/liquid/block_body.rb

@@ -1,58 +1,46 @@
-# frozen_string_literal: true
-
-require 'English'
-
 module Liquid
   class BlockBody
-    LiquidTagToken      = /\A\s*([\w#]+)\s*(.*?)\z/o
+    FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
-    ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
+    TAGSTART = "{%".freeze
-    WhitespaceOrNothing = /\A\s*\z/
+    VARSTART = "{{".freeze
-    TAGSTART            = "{%"
-    VARSTART            = "{{"
 
     attr_reader :nodelist
 
     def initialize
       @nodelist = []
-      @blank    = true
+      @blank = true
     end
 
-    def parse(tokenizer, parse_context, &block)
+    def parse(tokenizer, parse_context)
-      raise FrozenError, "can't modify frozen Liquid::BlockBody" if frozen?
-
       parse_context.line_number = tokenizer.line_number
-
+      while token = tokenizer.shift
-      if tokenizer.for_liquid_tag
+        unless token.empty?
-        parse_for_liquid_tag(tokenizer, parse_context, &block)
+          case
-      else
+          when token.start_with?(TAGSTART)
-        parse_for_document(tokenizer, parse_context, &block)
+            if token =~ FullToken
-      end
+              tag_name = $1
-    end
+              markup = $2
-
+              # fetch the tag from registered blocks
-    def freeze
+              if tag = registered_tags[tag_name]
-      @nodelist.freeze
+                new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-      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 =~ 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, parse_context)
-            return yield token, token
+            end
+          when token.start_with?(VARSTART)
+            @nodelist << create_variable(token, parse_context)
+            @blank = false
+          else
+            @nodelist << token
+            @blank &&= !!(token =~ /\A\s*\z/)
           end
-          tag_name = Regexp.last_match(1)
-          markup   = Regexp.last_match(2)
-          unless (tag = registered_tags[tag_name])
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
-            return yield tag_name, markup
-          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
@@ -60,174 +48,53 @@ module Liquid
       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)
-        unless blank_tag # conditional for backwards compatibility
-          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 parse_for_document(tokenizer, parse_context)
-      while (token = tokenizer.shift)
-        next if token.empty?
-        case
-        when token.start_with?(TAGSTART)
-          whitespace_handler(token, parse_context)
-          unless token =~ FullToken
-            BlockBody.raise_missing_tag_terminator(token, parse_context)
-          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 = registered_tags[tag_name])
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
-            return yield tag_name, markup
-          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 =~ 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`)
-    # with a blank body.
-    #
-    # For example, in a conditional assignment like the following
-    #
-    # ```
-    # {% 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
+      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.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) || token.is_a?(Break)
-        end
+            context.push_interrupt(token.interrupt)
-        idx += 1
+            break
+          end
 
-        context.resource_limits.increment_write_score(output)
+          node_output = render_node(token, context)
+
+          unless token.is_a?(Block) && token.blank?
+            output << node_output
+          end
+        rescue MemoryError => e
+          raise e
+        rescue ::StandardError => e
+          output << context.handle_error(e, token.line_number)
+        end
       end
 
-      output
+      output.join
     end
 
     private
 
-    def render_node(context, output, node)
+    def render_node(node, context)
-      BlockBody.render_node(context, output, node)
+      node_output = (node.respond_to?(:render) ? node.render(context) : node)
+      node_output = node_output.is_a?(Array) ? node_output.join : node_output.to_s
+
+      context.resource_limits.render_length += node_output.length
+      if context.resource_limits.reached?
+        raise MemoryError.new("Memory limits exceeded".freeze)
+      end
+      node_output
     end
 
     def create_variable(token, parse_context)
@@ -235,17 +102,15 @@ module Liquid
         markup = content.first
         return Variable.new(markup, parse_context)
       end
-      BlockBody.raise_missing_variable_terminator(token, parse_context)
+      raise_missing_variable_terminator(token, parse_context)
     end
 
-    # @deprecated Use {.raise_missing_tag_terminator} instead
     def raise_missing_tag_terminator(token, parse_context)
-      BlockBody.raise_missing_tag_terminator(token, parse_context)
+      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_termination".freeze, token: token, tag_end: TagEnd.inspect))
     end
 
-    # @deprecated Use {.raise_missing_variable_terminator} instead
     def raise_missing_variable_terminator(token, parse_context)
-      BlockBody.raise_missing_variable_terminator(token, parse_context)
+      raise SyntaxError.new(parse_context.locale.t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect))
     end
 
     def registered_tags

lib/liquid/condition.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Container for liquid nodes which conveniently wraps decision making logic
   #
@@ -10,83 +8,58 @@ module Liquid
   #
   class Condition #:nodoc:
     @@operators = {
-      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
-      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<' => :<,
+      '<'.freeze  => :<,
-      '>' => :>,
+      '>'.freeze  => :>,
-      '>=' => :>=,
+      '>='.freeze => :>=,
-      '<=' => :<=,
+      '<='.freeze => :<=,
-      'contains' => lambda do |_cond, left, right|
+      'contains'.freeze => lambda do |cond, left, right|
         if left && right && left.respond_to?(:include?)
           right = right.to_s if left.is_a?(String)
           left.include?(right)
         else
           false
         end
-      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)
+    attr_reader :attachment
-      @@method_literals[markup] || parse_context.parse_expression(markup)
-    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 = 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 result
+        result || @child_condition.evaluate(context)
-        when :and
+      when :and
-          break unless 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
 
@@ -99,17 +72,13 @@ 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?(Liquid::Expression::MethodLiteral)
         if right.respond_to?(left.method_name)
           return right.send(left.method_name)
         else
@@ -117,7 +86,7 @@ module Liquid
         end
       end
 
-      if right.is_a?(MethodLiteral)
+      if right.is_a?(Liquid::Expression::MethodLiteral)
         if left.respond_to?(right.method_name)
           return left.send(right.method_name)
         else
@@ -134,30 +103,21 @@ module Liquid
       # return this as the result.
       return context.evaluate(left) if op.nil?
 
-      left  = context.evaluate(left)
+      left = context.evaluate(left)
       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) && 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
     end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.left, @node.right,
-          @node.child_condition, @node.attachment
-        ].compact
-      end
-    end
   end
 
   class ElseCondition < Condition

lib/liquid/context.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Context keeps the variable stack and resolves variables, as well as keywords
   #
@@ -14,49 +12,35 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
-    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
+    attr_accessor :exception_handler, :template_name, :partial, :global_filter
 
-    # rubocop:disable Metrics/ParameterLists
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-    def self.build(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, &block)
+      @scopes           = [(outer_scope || {})]
-    end
+      @registers        = registers
+      @errors           = []
+      @partial          = false
+      @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 = {})
+      @this_stack_used = false
-      @environments = [environments]
-      @environments.flatten!
 
-      @static_environments = [static_environments].flat_map(&:freeze).freeze
-      @scopes              = [(outer_scope || {})]
-      @registers           = registers
-      @errors              = []
-      @partial             = false
-      @strict_variables    = false
-      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
-      @base_scope_depth    = 0
-      @interrupts          = []
-      @filters             = []
-      @global_filter       = nil
-      @disabled_tags       = {}
-
-      self.exception_renderer = Template.default_exception_renderer
       if rethrow_errors
-        self.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
+        self.exception_handler = ->(e) { raise }
       end
 
-      yield self if block_given?
+      @interrupts = []
-
+      @filters = []
-      # Do this last, since it could result in this object being passed to a Proc in the environment
+      @global_filter = nil
-      squash_instance_assigns_with_environments
     end
-    # rubocop:enable Metrics/ParameterLists
 
     def warnings
       @warnings ||= []
     end
 
     def strainer
-      @strainer ||= StrainerFactory.create(self, @filters)
+      @strainer ||= Strainer.create(self, @filters)
     end
 
     # Adds filters to this context.
@@ -89,11 +73,30 @@ module Liquid
     end
 
     def handle_error(e, line_number = nil)
-      e = internal_error unless e.is_a?(Liquid::Error)
+      if e.is_a?(Liquid::Error)
-      e.template_name ||= template_name
+        e.template_name ||= template_name
-      e.line_number   ||= line_number
+        e.line_number ||= line_number
+      end
+
+      output = nil
+
+      if exception_handler
+        result = exception_handler.call(e)
+        case result
+        when Exception
+          e = result
+          if e.is_a?(Liquid::Error)
+            e.template_name ||= template_name
+            e.line_number ||= line_number
+          end
+        when String
+          output = result
+        else
+          raise if result
+        end
+      end
       errors.push(e)
-      exception_renderer.call(e).to_s
+      output || Liquid::Error.render(e)
     end
 
     def invoke(method, *args)
@@ -103,7 +106,7 @@ module Liquid
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     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
@@ -125,31 +128,19 @@ module Liquid
     #   end
     #
     #   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(
-        resource_limits: resource_limits,
-        static_environments: static_environments,
-        registers: StaticRegisters.new(registers)
-      ).tap do |subcontext|
-        subcontext.base_scope_depth   = base_scope_depth + 1
-        subcontext.exception_renderer = exception_renderer
-        subcontext.filters  = @filters
-        subcontext.strainer = nil
-        subcontext.errors   = errors
-        subcontext.warnings = warnings
-        subcontext.disabled_tags = @disabled_tags
-      end
     end
 
     def clear_instance_assigns
@@ -158,6 +149,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
 
@@ -182,91 +177,43 @@ 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) }
+      scope = @scopes[index] if index
 
-      variable = if index
+      variable = nil
-        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
+
-      else
+      if scope.nil?
-        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
+        @environments.each do |e|
+          variable = lookup_and_evaluate(e, key)
+          unless variable.nil?
+            scope = e
+            break
+          end
+        end
       end
 
-      variable         = variable.to_liquid
+      scope ||= @environments.last || @scopes.last
+      variable ||= lookup_and_evaluate(scope, key)
+
+      variable = variable.to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
       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
 
-    attr_reader :base_scope_depth
-
-    def try_variable_find_in_environments(key, raise_on_not_found:)
-      @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
-      @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|

lib/liquid/document.rb

@@ -1,64 +1,26 @@
-# frozen_string_literal: true
-
 module Liquid
-  class Document
+  class Document < BlockBody
     def self.parse(tokens, parse_context)
-      doc = new(parse_context)
+      doc = new
       doc.parse(tokens, parse_context)
       doc
     end
 
-    attr_reader :parse_context, :body
+    def parse(tokens, parse_context)
-
+      super do |end_tag_name, end_tag_params|
-    def initialize(parse_context)
+        unknown_tag(end_tag_name, parse_context) 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, parse_context)
       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(parse_context.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(parse_context.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

lib/liquid/drop.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'set'
 
 module Liquid
@@ -26,9 +24,8 @@ module Liquid
     attr_writer :context
 
     # Catch all for the method
-    def liquid_method_missing(method)
+    def liquid_method_missing(_method)
-      return nil unless @context&.strict_variables
+      nil
-      raise Liquid::UndefinedDropMethod, "undefined method #{method}"
     end
 
     # called by liquid to invoke a drop
@@ -64,17 +61,16 @@ module Liquid
     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

lib/liquid/errors.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class Error < ::StandardError
     attr_accessor :line_number
@@ -7,7 +5,7 @@ module Liquid
     attr_accessor :markup_context
 
     def to_s(with_prefix = true)
-      str = +""
+      str = ""
       str << message_prefix if with_prefix
       str << super()
 
@@ -19,14 +17,22 @@ module Liquid
       str
     end
 
+    def self.render(e)
+      if e.is_a?(Liquid::Error)
+        e.to_s
+      else
+        "Liquid error: #{e}"
+      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
@@ -40,19 +46,14 @@ module Liquid
     end
   end
 
-  ArgumentError       = Class.new(Error)
+  ArgumentError = Class.new(Error)
-  ContextError        = Class.new(Error)
+  ContextError = Class.new(Error)
-  FileSystemError     = Class.new(Error)
+  FileSystemError = Class.new(Error)
-  StandardError       = Class.new(Error)
+  StandardError = Class.new(Error)
-  SyntaxError         = Class.new(Error)
+  SyntaxError = Class.new(Error)
-  StackLevelError     = Class.new(Error)
+  StackLevelError = Class.new(Error)
-  MemoryError         = Class.new(Error)
+  TaintedError = Class.new(Error)
-  ZeroDivisionError   = Class.new(Error)
+  MemoryError = Class.new(Error)
-  FloatDomainError    = Class.new(Error)
+  ZeroDivisionError = Class.new(Error)
-  UndefinedVariable   = Class.new(Error)
+  FloatDomainError = Class.new(Error)
-  UndefinedDropMethod = Class.new(Error)
-  UndefinedFilter     = Class.new(Error)
-  MethodOverrideError = Class.new(Error)
-  DisabledError       = Class.new(Error)
-  InternalError       = Class.new(Error)
 end

lib/liquid/expression.rb

@@ -1,40 +1,41 @@
-# frozen_string_literal: true
-
 module Liquid
   class Expression
+    class MethodLiteral
+      attr_reader :method_name, :to_s
+
+      def initialize(method_name, to_s)
+        @method_name = method_name
+        @to_s = to_s
+      end
+
+      def to_liquid
+        to_s
+      end
+    end
+
     LITERALS = {
-      nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
+      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'true' => true,
+      'true'.freeze  => true,
-      'false' => false,
+      'false'.freeze => false,
-      'blank' => '',
+      'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
-      'empty' => ''
+      'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
-    }.freeze
+    }
-
-    SINGLE_QUOTED_STRING = /\A\s*'(.*)'\s*\z/m
-    DOUBLE_QUOTED_STRING = /\A\s*"(.*)"\s*\z/m
-    INTEGERS_REGEX       = /\A\s*(-?\d+)\s*\z/
-    FLOATS_REGEX         = /\A\s*(-?\d[\d\.]+)\s*\z/
-
-    # Use an atomic group (?>...) to avoid pathological backtracing from
-    # malicious input as described in https://github.com/Shopify/liquid/issues/1357
-    RANGES_REGEX         = /\A\s*\(\s*(?>(\S+)\s*\.\.)\s*(\S+)\s*\)\s*\z/
 
     def self.parse(markup)
-      case markup
+      if LITERALS.key?(markup)
-      when nil
+        LITERALS[markup]
-        nil
-      when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
-        Regexp.last_match(1)
-      when INTEGERS_REGEX
-        Regexp.last_match(1).to_i
-      when RANGES_REGEX
-        RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2))
-      when FLOATS_REGEX
-        Regexp.last_match(1).to_f
       else
-        markup = markup.strip
+        case markup
-        if LITERALS.key?(markup)
+        when /\A'(.*)'\z/m # Single quoted strings
-          LITERALS[markup]
+          $1
+        when /\A"(.*)"\z/m # Double quoted strings
+          $1
+        when /\A(-?\d+)\z/ # Integer and floats
+          $1.to_i
+        when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
+          RangeLookup.parse($1, $2)
+        when /\A(-?\d[\d\.]+)\z/ # Floats
+          $1.to_f
         else
           VariableLookup.parse(markup)
         end

lib/liquid/extensions.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'time'
 require 'date'
 
@@ -9,12 +7,6 @@ class String # :nodoc:
   end
 end
 
-class Symbol # :nodoc:
-  def to_liquid
-    to_s
-  end
-end
-
 class Array # :nodoc:
   def to_liquid
     self
@@ -33,12 +25,6 @@ class Numeric # :nodoc:
   end
 end
 
-class Range # :nodoc:
-  def to_liquid
-    self
-  end
-end
-
 class Time # :nodoc:
   def to_liquid
     self
@@ -74,3 +60,9 @@ class NilClass
     self
   end
 end
+
+class Proc
+  def to_liquid # :nodoc:
+    self
+  end
+end

lib/liquid/file_system.rb

@@ -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,8 +8,8 @@ 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
@@ -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,15 +37,15 @@ 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
 
@@ -59,15 +57,15 @@ module Liquid
     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

lib/liquid/forloop_drop.rb

@@ -1,20 +1,13 @@
-# frozen_string_literal: true
-
 module Liquid
   class ForloopDrop < Drop
     def initialize(name, length, parentloop)
-      @name       = name
+      @name = name
-      @length     = length
+      @length = length
       @parentloop = parentloop
-      @index      = 0
+      @index = 0
     end
 
-    attr_reader :length, :parentloop
+    attr_reader :name, :length, :parentloop
-
-    def name
-      Usage.increment('forloop_drop_name')
-      @name
-    end
 
     def index
       @index + 1

lib/liquid/i18n.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'yaml'
 
 module Liquid
@@ -28,13 +26,13 @@ module Liquid
     def interpolate(name, vars)
       name.gsub(/%\{(\w+)\}/) do
         # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        (vars[Regexp.last_match(1).to_sym]).to_s
+        "#{vars[$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

lib/liquid/interrupts.rb

@@ -1,12 +1,10 @@
-# 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)
-      @message = message || "interrupt"
+      @message = message || "interrupt".freeze
     end
   end
 

lib/liquid/lexer.rb

@@ -1,53 +1,44 @@
-# frozen_string_literal: true
-
 require "strscan"
 module Liquid
   class Lexer
     SPECIALS = {
-      '|' => :pipe,
+      '|'.freeze => :pipe,
-      '.' => :dot,
+      '.'.freeze => :dot,
-      ':' => :colon,
+      ':'.freeze => :colon,
-      ',' => :comma,
+      ','.freeze => :comma,
-      '[' => :open_square,
+      '['.freeze => :open_square,
-      ']' => :close_square,
+      ']'.freeze => :close_square,
-      '(' => :open_round,
+      '('.freeze => :open_round,
-      ')' => :close_round,
+      ')'.freeze => :close_round,
-      '?' => :question,
+      '?'.freeze => :question,
-      '-' => :dash,
+      '-'.freeze => :dash
-    }.freeze
+    }
-    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
+    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
     SINGLE_STRING_LITERAL = /'[^\']*'/
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
-    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
+    NUMBER_LITERAL = /-?\d+(\.\d+)?/
-    DOTDOT                = /\.\./
+    DOTDOT = /\.\./
-    COMPARISON_OPERATOR   = /==|!=|<>|<=?|>=?|contains(?=\s)/
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
-    WHITESPACE_OR_NOTHING = /\s*/
 
     def initialize(input)
-      @ss = StringScanner.new(input)
+      @ss = StringScanner.new(input.rstrip)
     end
 
     def tokenize
       @output = []
 
       until @ss.eos?
-        @ss.skip(WHITESPACE_OR_NOTHING)
+        @ss.skip(/\s*/)
-        break if @ss.eos?
+        tok = case
-        tok      = if (t = @ss.scan(COMPARISON_OPERATOR))
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
-          [:comparison, t]
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
-        elsif (t = @ss.scan(SINGLE_STRING_LITERAL))
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
-          [:string, t]
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
-        elsif (t = @ss.scan(DOUBLE_STRING_LITERAL))
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
-          [:string, t]
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
-        elsif (t = @ss.scan(NUMBER_LITERAL))
-          [:number, t]
-        elsif (t = @ss.scan(IDENTIFIER))
-          [:id, t]
-        elsif (t = @ss.scan(DOTDOT))
-          [:dotdot, t]
         else
-          c     = @ss.getch
+          c = @ss.getch
-          if (s = SPECIALS[c])
+          if s = SPECIALS[c]
             [s, c]
           else
             raise SyntaxError, "Unexpected character #{c}"

lib/liquid/locales/en.yml

@@ -14,15 +14,11 @@
       if: "Syntax Error in tag 'if' - Valid syntax: if [expression]"
       include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
       unknown_tag: "Unknown tag '%{tag}'"
-      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}"
       unexpected_else: "%{block_name} tag does not expect 'else' tag"
       unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
       tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
       variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
       tag_never_closed: "'%{block_name}' tag was never closed"
+      meta_syntax_error: "Liquid syntax error: #{e.message}"
       table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
-      render: "Syntax error in tag 'render' - Template name must be a quoted string"
-    argument:
-      include: "Argument error in tag 'include' - Illegal template name"
-    disabled:
-      tag: "usage is not allowed in this context"

lib/liquid/parse_context.rb

@@ -1,17 +1,12 @@
-# frozen_string_literal: true
-
 module Liquid
   class ParseContext
-    attr_accessor :locale, :line_number, :trim_whitespace, :depth
+    attr_accessor :partial, :locale, :line_number
-    attr_reader :partial, :warnings, :error_mode
+    attr_reader :warnings, :error_mode
 
     def initialize(options = {})
       @template_options = options ? options.dup : {}
-
+      @locale = @template_options[:locale] ||= I18n.new
-      @locale   = @template_options[:locale] ||= I18n.new
       @warnings = []
-
-      self.depth   = 0
       self.partial = false
     end
 
@@ -19,23 +14,11 @@ module Liquid
       @options[option_key]
     end
 
-    def new_block_body
-      Liquid::BlockBody.new
-    end
-
-    def new_tokenizer(markup, start_line_number: nil, for_liquid_tag: false)
-      Tokenizer.new(markup, line_number: start_line_number, for_liquid_tag: for_liquid_tag)
-    end
-
-    def parse_expression(markup)
-      Expression.parse(markup)
-    end
-
     def partial=(value)
       @partial = value
       @options = value ? partial_options : @template_options
-
       @error_mode = @options[:error_mode] || Template.error_mode
+      value
     end
 
     def partial_options
@@ -44,7 +27,7 @@ module Liquid
         if dont_pass == true
           { locale: locale }
         elsif dont_pass.is_a?(Array)
-          @template_options.reject { |k, _v| dont_pass.include?(k) }
+          @template_options.reject { |k, v| dont_pass.include?(k) }
         else
           @template_options
         end

lib/liquid/parse_tree_visitor.rb

@@ -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) : []
-    end
-  end
-end

lib/liquid/parser.rb

@@ -1,11 +1,9 @@
-# frozen_string_literal: true
-
 module Liquid
   class Parser
     def initialize(input)
-      l       = Lexer.new(input)
+      l = Lexer.new(input)
       @tokens = l.tokenize
-      @p      = 0 # pointer to current location
+      @p = 0 # pointer to current location
     end
 
     def jump(point)
@@ -48,18 +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
-        str = consume
-        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)
@@ -72,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
+      while 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

lib/liquid/parser_switching.rb

@@ -1,29 +1,15 @@
-# frozen_string_literal: true
-
 module Liquid
   module ParserSwitching
-    def strict_parse_with_error_mode_fallback(markup)
-      strict_parse_with_error_context(markup)
-    rescue SyntaxError => e
-      case parse_context.error_mode
-      when :strict
-        raise
-      when :warn
-        parse_context.warnings << e
-      end
-      lax_parse(markup)
-    end
-
     def parse_with_selected_parser(markup)
       case parse_context.error_mode
       when :strict then strict_parse_with_error_context(markup)
       when :lax    then lax_parse(markup)
       when :warn
         begin
-          strict_parse_with_error_context(markup)
+          return strict_parse_with_error_context(markup)
         rescue SyntaxError => e
           parse_context.warnings << e
-          lax_parse(markup)
+          return lax_parse(markup)
         end
       end
     end
@@ -33,7 +19,7 @@ module Liquid
     def strict_parse_with_error_context(markup)
       strict_parse(markup)
     rescue SyntaxError => e
-      e.line_number    = line_number
+      e.line_number = line_number
       e.markup_context = markup_context(markup)
       raise e
     end

lib/liquid/partial_cache.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class PartialCache
-    def self.load(template_name, context:, parse_context:)
-      cached_partials = (context.registers[:cached_partials] ||= {})
-      cached = cached_partials[template_name]
-      return cached if cached
-
-      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
-      source      = file_system.read_template_file(template_name)
-
-      parse_context.partial = true
-
-      template_factory = (context.registers[:template_factory] ||= Liquid::TemplateFactory.new)
-      template = template_factory.for(template_name)
-
-      partial = template.parse(source, parse_context)
-      cached_partials[template_name] = partial
-    ensure
-      parse_context.partial = false
-    end
-  end
-end

lib/liquid/profiler.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'liquid/profiler/hooks'
 
 module Liquid
@@ -25,7 +23,7 @@ module Liquid
   #     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 +44,115 @@ 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(node, partial)
-        @code = code
+        @code        = node.respond_to?(:raw) ? node.raw : node
-        @template_name = template_name
+        @partial     = partial
-        @line_number = line_number
+        @line_number = node.respond_to?(:line_number) ? node.line_number : nil
-        @children = []
+        @children    = []
       end
 
-      def self_time
+      def self.start(node, partial)
-        @self_time ||= begin
+        new(node, partial).tap(&:start)
-          total_children_time = 0.0
+      end
-          @children.each do |child|
+
-            total_children_time += child.total_time
+      def start
-          end
+        @start_time = Time.now
-          @total_time - total_children_time
+      end
-        end
+
+      def finish
+        @end_time = Time.now
+      end
+
+      def render_time
+        @end_time - @start_time
       end
     end
 
-    attr_reader :total_time
+    def self.profile_node_render(node)
-    alias_method :total_render_time, :total_time
+      if Profiler.current_profile && node.respond_to?(:render)
+        Profiler.current_profile.start_node(node)
+        output = yield
+        Profiler.current_profile.end_node(node)
+        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_node(node)
-      timing = Timing.new(code: code, template_name: template_name, line_number: line_number)
+      @timing_stack.push(Timing.start(node, 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_node(_node)
+      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

lib/liquid/profiler/hooks.rb

@@ -1,35 +1,23 @@
-# frozen_string_literal: true
-
 module Liquid
-  module BlockBodyProfilingHook
+  class BlockBody
-    def render_node(context, output, node)
+    def render_node_with_profiling(node, context)
-      if (profiler = context.profiler)
+      Profiler.profile_node_render(node) do
-        profiler.profile_node(context.template_name, code: node.raw, line_number: node.line_number) do
+        render_node_without_profiling(node, context)
-          super
-        end
-      else
-        super
       end
     end
-  end
-  BlockBody.prepend(BlockBodyProfilingHook)
 
-  module DocumentProfilingHook
+    alias_method :render_node_without_profiling, :render_node
-    def render_to_output_buffer(context, output)
+    alias_method :render_node, :render_node_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_expr).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

lib/liquid/range_lookup.rb

@@ -1,10 +1,8 @@
-# frozen_string_literal: true
-
 module Liquid
   class RangeLookup
     def self.parse(start_markup, end_markup)
       start_obj = Expression.parse(start_markup)
-      end_obj   = Expression.parse(end_markup)
+      end_obj = Expression.parse(end_markup)
       if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
         new(start_obj, end_obj)
       else
@@ -14,12 +12,12 @@ module Liquid
 
     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))
-      end_int   = to_integer(context.evaluate(@end_obj))
+      end_int = to_integer(context.evaluate(@end_obj))
       start_int..end_int
     end
 

lib/liquid/register.rb

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

lib/liquid/resource_limits.rb

@@ -1,62 +1,23 @@
-# frozen_string_literal: true
-
 module Liquid
   class ResourceLimits
-    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
+    attr_accessor :render_length, :render_score, :assign_score,
-    attr_reader :render_score, :assign_score
+      :render_length_limit, :render_score_limit, :assign_score_limit
 
     def initialize(limits)
       @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]
       reset
     end
 
-    def increment_render_score(amount)
-      @render_score += amount
-      raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
-    end
-
-    def increment_assign_score(amount)
-      @assign_score += amount
-      raise_limits_reached if @assign_score_limit && @assign_score > @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
-    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

lib/liquid/standardfilters.rb

@@ -1,24 +1,16 @@
-# frozen_string_literal: true
-
 require 'cgi'
 require 'bigdecimal'
 
 module Liquid
   module StandardFilters
     HTML_ESCAPE = {
-      '&' => '&',
+      '&'.freeze => '&'.freeze,
-      '>' => '>',
+      '>'.freeze => '>'.freeze,
-      '<' => '&lt;',
+      '<'.freeze => '&lt;'.freeze,
-      '"' => '&quot;',
+      '"'.freeze => '&quot;'.freeze,
-      "'" => '&#39;',
+      "'".freeze => '&#39;'.freeze
-    }.freeze
+    }
     HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
-    STRIP_HTML_BLOCKS       = Regexp.union(
-      %r{<script.*?</script>}m,
-      /<!--.*?-->/m,
-      %r{<style.*?</style>}m
-    )
-    STRIP_HTML_TAGS = /<.*?>/m
 
     # Return the size of an array or of an string
     def size(input)
@@ -41,7 +33,7 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input.to_s) unless input.nil?
+      CGI.escapeHTML(input).untaint unless input.nil?
     end
     alias_method :h, :escape
 
@@ -50,16 +42,11 @@ module Liquid
     end
 
     def url_encode(input)
-      CGI.escape(input.to_s) unless input.nil?
+      CGI.escape(input) unless input.nil?
     end
 
     def url_decode(input)
-      return if input.nil?
+      CGI.unescape(input) unless input.nil?
-
-      result = CGI.unescape(input.to_s)
-      raise Liquid::ArgumentError, "invalid byte sequence in #{result.encoding}" unless result.valid_encoding?
-
-      result
     end
 
     def slice(input, offset, length = nil)
@@ -74,28 +61,22 @@ module Liquid
     end
 
     # Truncate a string down to x characters
-    def truncate(input, length = 50, truncate_string = "...")
+    def truncate(input, length = 50, truncate_string = "...".freeze)
       return if input.nil?
       input_str = input.to_s
-      length    = Utils.to_integer(length)
+      length = Utils.to_integer(length)
-
+      l = length - truncate_string.length
-      truncate_string_str = truncate_string.to_s
-
-      l = length - truncate_string_str.length
       l = 0 if l < 0
-
+      input_str.length > length ? input_str[0...l] + truncate_string : input_str
-      input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
     end
 
-    def truncatewords(input, words = 15, truncate_string = "...")
+    def truncatewords(input, words = 15, truncate_string = "...".freeze)
       return if input.nil?
       wordlist = input.to_s.split
-      words    = Utils.to_integer(words)
+      words = Utils.to_integer(words)
-
       l = words - 1
       l = 0 if l < 0
-
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
-      wordlist.length > l ? wordlist[0..l].join(" ").concat(truncate_string.to_s) : input
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -104,7 +85,7 @@ module Liquid
     #   <div class="summary">{{ post | split '//' | first }}</div>
     #
     def split(input, pattern)
-      input.to_s.split(pattern.to_s)
+      input.to_s.split(pattern)
     end
 
     def strip(input)
@@ -120,160 +101,119 @@ module Liquid
     end
 
     def strip_html(input)
-      empty  = ''
+      empty = ''.freeze
-      result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
+      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
-      result.gsub!(STRIP_HTML_TAGS, empty)
-      result
     end
 
     # Remove all newlines from the string
     def strip_newlines(input)
-      input.to_s.gsub(/\r?\n/, '')
+      input.to_s.gsub(/\r?\n/, ''.freeze)
     end
 
     # Join elements of the array with certain character between them
-    def join(input, glue = ' ')
+    def join(input, glue = ' '.freeze)
-      InputIterator.new(input, context).join(glue)
+      InputIterator.new(input).join(glue)
     end
 
     # Sort elements of the array
     # provide optional property with which to sort an array of hashes or drops
     def sort(input, property = nil)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)
-
-      return [] if ary.empty?
-
       if property.nil?
-        ary.sort do |a, b|
+        ary.sort
-          nil_safe_compare(a, b)
+      elsif ary.empty? # The next two cases assume a non-empty array.
-        end
+        []
-      elsif ary.all? { |el| el.respond_to?(:[]) }
+      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        begin
+        ary.sort { |a, b| a[property] <=> b[property] }
-          ary.sort { |a, b| nil_safe_compare(a[property], b[property]) }
+      elsif ary.first.respond_to?(property)
-        rescue TypeError
+        ary.sort { |a, b| a.send(property) <=> b.send(property) }
-          raise_property_error(property)
-        end
       end
     end
 
     # Sort elements of an array ignoring case if strings
     # provide optional property with which to sort an array of hashes or drops
     def sort_natural(input, property = nil)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)
-
-      return [] if ary.empty?
 
       if property.nil?
-        ary.sort do |a, b|
+        ary.sort { |a, b| a.casecmp(b) }
-          nil_safe_casecmp(a, b)
+      elsif ary.empty? # The next two cases assume a non-empty array.
-        end
-      elsif ary.all? { |el| el.respond_to?(:[]) }
-        begin
-          ary.sort { |a, b| nil_safe_casecmp(a[property], b[property]) }
-        rescue TypeError
-          raise_property_error(property)
-        end
-      end
-    end
-
-    # Filter the elements of an array to those with a certain property value.
-    # By default the target is any truthy value.
-    def where(input, property, target_value = nil)
-      ary = InputIterator.new(input, context)
-
-      if ary.empty?
         []
-      elsif ary.first.respond_to?(:[]) && target_value.nil?
+      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        begin
+        ary.sort { |a, b| a[property].casecmp(b[property]) }
-          ary.select { |item| item[property] }
+      elsif ary.first.respond_to?(property)
-        rescue TypeError
+        ary.sort { |a, b| a.send(property).casecmp(b.send(property)) }
-          raise_property_error(property)
-        end
-      elsif ary.first.respond_to?(:[])
-        begin
-          ary.select { |item| item[property] == target_value }
-        rescue TypeError
-          raise_property_error(property)
-        end
       end
     end
 
     # Remove duplicate elements from an array
     # provide optional property with which to determine uniqueness
     def uniq(input, property = nil)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)
 
       if property.nil?
         ary.uniq
       elsif ary.empty? # The next two cases assume a non-empty array.
         []
       elsif ary.first.respond_to?(:[])
-        begin
+        ary.uniq{ |a| a[property] }
-          ary.uniq { |a| a[property] }
-        rescue TypeError
-          raise_property_error(property)
-        end
       end
     end
 
     # Reverse the elements of an array
     def reverse(input)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)
       ary.reverse
     end
 
     # map/collect on a given property
     def map(input, property)
-      InputIterator.new(input, context).map do |e|
+      InputIterator.new(input).map do |e|
         e = e.call if e.is_a?(Proc)
 
-        if property == "to_liquid"
+        if property == "to_liquid".freeze
           e
         elsif e.respond_to?(:[])
           r = e[property]
           r.is_a?(Proc) ? r.call : r
         end
       end
-    rescue TypeError
-      raise_property_error(property)
     end
 
     # Remove nils within an array
     # provide optional property with which to check for nil
     def compact(input, property = nil)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)
 
       if property.nil?
         ary.compact
       elsif ary.empty? # The next two cases assume a non-empty array.
         []
       elsif ary.first.respond_to?(:[])
-        begin
+        ary.reject{ |a| a[property].nil? }
-          ary.reject { |a| a[property].nil? }
+      elsif ary.first.respond_to?(property)
-        rescue TypeError
+        ary.reject { |a| a.send(property).nil? }
-          raise_property_error(property)
-        end
       end
     end
 
     # Replace occurrences of a string with another
-    def replace(input, string, replacement = '')
+    def replace(input, string, replacement = ''.freeze)
       input.to_s.gsub(string.to_s, replacement.to_s)
     end
 
     # Replace the first occurrences of a string with another
-    def replace_first(input, string, replacement = '')
+    def replace_first(input, string, replacement = ''.freeze)
       input.to_s.sub(string.to_s, replacement.to_s)
     end
 
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string.to_s, '')
+      input.to_s.gsub(string.to_s, ''.freeze)
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string.to_s, '')
+      input.to_s.sub(string.to_s, ''.freeze)
     end
 
     # add one string to another
@@ -282,10 +222,7 @@ module Liquid
     end
 
     def concat(input, array)
-      unless array.respond_to?(:to_ary)
+      InputIterator.new(input).concat(array)
-        raise ArgumentError, "concat filter requires an array argument"
-      end
-      InputIterator.new(input, context).concat(array)
     end
 
     # prepend a string to another
@@ -295,7 +232,7 @@ module Liquid
 
     # Add <br /> tags in front of all newlines in input string
     def newline_to_br(input)
-      input.to_s.gsub(/\n/, "<br />\n")
+      input.to_s.gsub(/\n/, "<br />\n".freeze)
     end
 
     # Reformat a date using Ruby's core Time#strftime( string ) -> string
@@ -332,7 +269,7 @@ module Liquid
     def date(input, format)
       return input if format.to_s.empty?
 
-      return input unless (date = Utils.to_date(input))
+      return input unless date = Utils.to_date(input)
 
       date.strftime(format.to_s)
     end
@@ -355,12 +292,6 @@ module Liquid
       array.last if array.respond_to?(:last)
     end
 
-    # absolute value
-    def abs(input)
-      result = Utils.to_number(input).abs
-      result.is_a?(BigDecimal) ? result.to_f : result
-    end
-
     # addition
     def plus(input, operand)
       apply_operation(input, operand, :+)
@@ -410,73 +341,26 @@ module Liquid
       raise Liquid::FloatDomainError, e.message
     end
 
-    def at_least(input, n)
+    def default(input, default_value = ''.freeze)
-      min_value = Utils.to_number(n)
+      if !input || input.respond_to?(:empty?) && input.empty?
-
+        default_value
-      result = Utils.to_number(input)
+      else
-      result = min_value if min_value > result
+        input
-      result.is_a?(BigDecimal) ? result.to_f : result
+      end
-    end
-
-    def at_most(input, n)
-      max_value = Utils.to_number(n)
-
-      result = Utils.to_number(input)
-      result = max_value if max_value < result
-      result.is_a?(BigDecimal) ? result.to_f : result
-    end
-
-    # Set a default value when the input is nil, false or empty
-    #
-    # Example:
-    #    {{ product.title | default: "No Title" }}
-    #
-    # Use `allow_false` when an input should only be tested against nil or empty and not false.
-    #
-    # Example:
-    #    {{ product.title | default: "No Title", allow_false: true }}
-    #
-    def default(input, default_value = '', options = {})
-      options = {} unless options.is_a?(Hash)
-      false_check = options['allow_false'] ? input.nil? : !input
-      false_check || (input.respond_to?(:empty?) && input.empty?) ? default_value : input
     end
 
     private
 
-    attr_reader :context
-
-    def raise_property_error(property)
-      raise Liquid::ArgumentError, "cannot select the property '#{property}'"
-    end
-
     def apply_operation(input, operand, operation)
       result = Utils.to_number(input).send(operation, Utils.to_number(operand))
       result.is_a?(BigDecimal) ? result.to_f : result
     end
 
-    def nil_safe_compare(a, b)
-      if !a.nil? && !b.nil?
-        a <=> b
-      else
-        a.nil? ? 1 : -1
-      end
-    end
-
-    def nil_safe_casecmp(a, b)
-      if !a.nil? && !b.nil?
-        a.to_s.casecmp(b.to_s)
-      else
-        a.nil? ? 1 : -1
-      end
-    end
-
     class InputIterator
       include Enumerable
 
-      def initialize(input, context)
+      def initialize(input)
-        @context = context
+        @input = if input.is_a?(Array)
-        @input   = if input.is_a?(Array)
           input.flatten
         elsif input.is_a?(Hash)
           [input]
@@ -488,11 +372,11 @@ module Liquid
       end
 
       def join(glue)
-        to_a.join(glue.to_s)
+        to_a.join(glue)
       end
 
       def concat(args)
-        to_a.concat(args)
+        to_a.concat args
       end
 
       def reverse
@@ -514,8 +398,7 @@ module Liquid
 
       def each
         @input.each do |e|
-          e.context = @context if e.respond_to?(:context=)
+          yield(e.to_liquid)
-          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
         end
       end
     end

lib/liquid/static_registers.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class StaticRegisters
-    attr_reader :static
-
-    def initialize(registers = {})
-      @static    = registers.is_a?(StaticRegisters) ? registers.static : registers
-      @registers = {}
-    end
-
-    def []=(key, value)
-      @registers[key] = value
-    end
-
-    def [](key)
-      if @registers.key?(key)
-        @registers[key]
-      else
-        @static[key]
-      end
-    end
-
-    def delete(key)
-      @registers.delete(key)
-    end
-
-    UNDEFINED = Object.new
-
-    def fetch(key, default = UNDEFINED, &block)
-      if @registers.key?(key)
-        @registers.fetch(key)
-      elsif default != UNDEFINED
-        @static.fetch(key, default, &block)
-      else
-        @static.fetch(key, &block)
-      end
-    end
-
-    def key?(key)
-      @registers.key?(key) || @static.key?(key)
-    end
-  end
-end

lib/liquid/strainer.rb

@@ -0,0 +1,58 @@
+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
+
+    class << self
+      attr_reader :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)
+        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, e.message, e.backtrace
+    end
+  end
+end

lib/liquid/strainer_factory.rb

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

lib/liquid/strainer_template.rb

@@ -1,53 +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
-
-      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

lib/liquid/tablerowloop_drop.rb

@@ -1,13 +1,11 @@
-# frozen_string_literal: true
-
 module Liquid
   class TablerowloopDrop < Drop
     def initialize(length, cols)
       @length = length
-      @row    = 1
+      @row = 1
-      @col    = 1
+      @col = 1
-      @cols   = cols
+      @cols = cols
-      @index  = 0
+      @index = 0
     end
 
     attr_reader :length, :col, :row

lib/liquid/tag.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class Tag
     attr_reader :nodelist, :tag_name, :line_number, :parse_context
@@ -7,26 +5,20 @@ module Liquid
     include ParserSwitching
 
     class << self
-      def parse(tag_name, markup, tokenizer, parse_context)
+      def parse(tag_name, markup, tokenizer, options)
-        tag = new(tag_name, markup, parse_context)
+        tag = new(tag_name, markup, options)
         tag.parse(tokenizer)
         tag
       end
 
-      def disable_tags(*tag_names)
-        @disabled_tags ||= []
-        @disabled_tags.concat(tag_names)
-        prepend(Disabler)
-      end
-
       private :new
     end
 
     def initialize(tag_name, markup, parse_context)
-      @tag_name      = tag_name
+      @tag_name   = tag_name
-      @markup        = markup
+      @markup     = markup
       @parse_context = parse_context
-      @line_number   = parse_context.line_number
+      @line_number = parse_context.line_number
     end
 
     def parse(_tokens)
@@ -41,25 +33,11 @@ module Liquid
     end
 
     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)
-      output << render(context)
-      output
     end
 
     def blank?
       false
     end
-
-    private
-
-    def parse_expression(markup)
-      parse_context.parse_expression(markup)
-    end
   end
 end

lib/liquid/tag/disableable.rb

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

lib/liquid/tag/disabler.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Tag
-    module Disabler
-      module ClassMethods
-        attr_reader :disabled_tags
-      end
-
-      def self.prepended(base)
-        base.extend(ClassMethods)
-      end
-
-      def render_to_output_buffer(context, output)
-        context.with_disabled_tags(self.class.disabled_tags) do
-          super
-        end
-      end
-    end
-  end
-end

lib/liquid/tags/assign.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Assign sets a variable in your template.
   #
@@ -12,62 +10,30 @@ module Liquid
   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
       if markup =~ Syntax
-        @to   = Regexp.last_match(1)
+        @to = $1
-        @from = Variable.new(Regexp.last_match(2), parse_context)
+        @from = Variable.new($2, options)
       else
-        self.class.raise_syntax_error(parse_context)
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
       end
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
       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', Assign)
+  Template.register_tag('assign'.freeze, Assign)
 end

lib/liquid/tags/break.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Break tag to be used to break out of a for loop.
   #
@@ -11,13 +9,10 @@ module Liquid
   #    {% endfor %}
   #
   class Break < Tag
-    INTERRUPT = BreakInterrupt.new.freeze
+    def interrupt
-
+      BreakInterrupt.new
-    def render_to_output_buffer(context, output)
-      context.push_interrupt(INTERRUPT)
-      output
     end
   end
 
-  Template.register_tag('break', Break)
+  Template.register_tag('break'.freeze, Break)
 end

lib/liquid/tags/capture.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
@@ -18,18 +16,17 @@ module Liquid
     def initialize(tag_name, markup, options)
       super
       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 render_to_output_buffer(context, output)
+    def render(context)
-      context.resource_limits.with_capture do
+      output = super
-        capture_output = render(context)
+      context.scopes.last[@to] = output
-        context.scopes.last[@to] = capture_output
+      context.resource_limits.assign_score += output.length
-      end
+      ''.freeze
-      output
     end
 
     def blank?
@@ -37,5 +34,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('capture', Capture)
+  Template.register_tag('capture'.freeze, Capture)
 end

lib/liquid/tags/case.rb

@@ -1,34 +1,24 @@
-# frozen_string_literal: true
-
 module Liquid
   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 = []
 
       if markup =~ Syntax
-        @left = parse_expression(Regexp.last_match(1))
+        @left = Expression.parse($1)
       else
-        raise SyntaxError, options[:locale].t("errors.syntax.case")
+        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 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
@@ -37,43 +27,45 @@ 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?
-        elsif block.evaluate(context)
+            return block.attachment.render(context) if execute_else_block
-          execute_else_block = false
+          elsif block.evaluate(context)
-          block.attachment.render_to_output_buffer(context, output)
+            execute_else_block = false
+            output << block.attachment.render(context)
+          end
         end
+        output
       end
-
-      output
     end
 
     private
 
     def record_when_condition(markup)
-      body = new_body
+      body = BlockBody.new
 
       while markup
         unless 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
@@ -81,20 +73,14 @@ module Liquid
 
     def record_else_condition(markup)
       unless 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', Case)
+  Template.register_tag('case'.freeze, Case)
 end

lib/liquid/tags/comment.rb

@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
   class Comment < Block
-    def render_to_output_buffer(_context, output)
+    def render(_context)
-      output
+      ''.freeze
     end
 
     def unknown_tag(_tag, _markup, _tokens)
@@ -14,5 +12,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('comment', Comment)
+  Template.register_tag('comment'.freeze, Comment)
 end

lib/liquid/tags/continue.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Continue tag to be used to break out of a for loop.
   #
@@ -11,13 +9,10 @@ module Liquid
   #    {% 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', Continue)
+  Template.register_tag('continue'.freeze, Continue)
 end

lib/liquid/tags/cycle.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
   #
@@ -17,43 +15,32 @@ module Liquid
     SimpleSyntax = /\A#{QuotedFragment}+/o
     NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
 
-    attr_reader :variables
-
     def initialize(tag_name, markup, options)
       super
       case markup
       when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
+        @variables = variables_from_string($2)
-        @name      = parse_expression(Regexp.last_match(1))
+        @name = Expression.parse($1)
       when SimpleSyntax
         @variables = variables_from_string(markup)
-        @name      = @variables.to_s
+        @name = @variables.to_s
       else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
       end
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
-      context.registers[:cycle] ||= {}
+      context.registers[:cycle] ||= Hash.new(0)
 
-      key       = context.evaluate(@name)
+      context.stack do
-      iteration = context.registers[:cycle][key].to_i
+        key = context.evaluate(@name)
-
+        iteration = context.registers[:cycle][key]
-      val = context.evaluate(@variables[iteration])
+        result = context.evaluate(@variables[iteration])
-
+        iteration += 1
-      if val.is_a?(Array)
+        iteration  = 0 if iteration >= @variables.size
-        val = val.join
+        context.registers[:cycle][key] = iteration
-      elsif !val.is_a?(String)
+        result
-        val = val.to_s
       end
-
-      output << val
-
-      iteration += 1
-      iteration = 0 if iteration >= @variables.size
-
-      context.registers[:cycle][key] = iteration
-      output
     end
 
     private
@@ -61,15 +48,9 @@ module Liquid
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        Regexp.last_match(1) ? parse_expression(Regexp.last_match(1)) : nil
+        $1 ? Expression.parse($1) : nil
       end.compact
     end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        Array(@node.variables)
-      end
-    end
   end
 
   Template.register_tag('cycle', Cycle)

lib/liquid/tags/decrement.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # decrement is used in a place where one needs to insert a counter
   #     into a template, and needs the counter to survive across
@@ -25,14 +23,13 @@ module Liquid
       @variable = markup.strip
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
       value = context.environments.first[@variable] ||= 0
       value -= 1
       context.environments.first[@variable] = value
-      output << value.to_s
+      value.to_s
-      output
     end
   end
 
-  Template.register_tag('decrement', Decrement)
+  Template.register_tag('decrement'.freeze, Decrement)
 end

lib/liquid/tags/echo.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # Echo outputs an expression
-  #
-  #   {% echo monkey %}
-  #   {% echo user.name %}
-  #
-  # This is identical to variable output syntax, like {{ foo }}, but works
-  # inside {% liquid %} tags. The full syntax is supported, including filters:
-  #
-  #   {% echo user | link %}
-  #
-  class Echo < Tag
-    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
-  end
-
-  Template.register_tag('echo', Echo)
-end

lib/liquid/tags/for.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # "For" iterates over an array or collection.
   # Several useful variables are available to you within the loop.
@@ -25,7 +23,7 @@ module Liquid
   #      {{ item.name }}
   #    {% end %}
   #
-  #  To reverse the for loop simply use {% for item in collection reversed %} (note that the flag's spelling is different to the filter `reverse`)
+  #  To reverse the for loop simply use {% for item in collection reversed %}
   #
   # == Available variables:
   #
@@ -48,26 +46,15 @@ module Liquid
   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)
+      return unless parse_body(@for_block, tokens)
-        parse_body(@else_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
@@ -75,53 +62,49 @@ 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)
 
       if segment.empty?
-        render_else(context, output)
+        render_else(context)
       else
-        render_segment(context, output, segment)
+        render_segment(context, segment)
       end
-
-      output
     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 = 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
-      collection_name  = p.expression
+      @name = "#{@variable_name}-#{collection_name}"
-      @collection_name = parse_expression(collection_name)
+      @collection_name = Expression.parse(collection_name)
-
+      @reversed = p.id?('reversed'.freeze)
-      @name     = "#{@variable_name}-#{collection_name}"
-      @reversed = p.id?('reversed')
 
       while p.look(:id) && p.look(:colon, 1)
-        unless (attribute = p.id?('limit') || p.id?('offset'))
+        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
-          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
         end
         p.consume
         set_attribute(attribute, p.expression)
@@ -132,28 +115,19 @@ module Liquid
     private
 
     def collection_segment(context)
-      offsets = context.registers[:for] ||= {}
+      offsets = context.registers[:for] ||= Hash.new(0)
 
       from = if @from == :continue
         offsets[@name].to_i
       else
-        from_value = context.evaluate(@from)
+        context.evaluate(@from).to_i
-        if from_value.nil?
-          0
-        else
-          Utils.to_integer(from_value)
-        end
       end
 
       collection = context.evaluate(@collection_name)
       collection = collection.to_a if collection.is_a?(Range)
 
-      limit_value = context.evaluate(@limit)
+      limit = context.evaluate(@limit)
-      to = if limit_value.nil?
+      to = limit ? limit.to_i + from : nil
-        nil
-      else
-        Utils.to_integer(limit_value) + from
-      end
 
       segment = Utils.slice_collection(collection, from, to)
       segment.reverse! if @reversed
@@ -163,9 +137,11 @@ module Liquid
       segment
     end
 
-    def render_segment(context, output, segment)
+    def render_segment(context, segment)
       for_stack = context.registers[:for_stack] ||= []
-      length    = segment.length
+      length = segment.length
+
+      result = ''
 
       context.stack do
         loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
@@ -173,55 +149,45 @@ module Liquid
         for_stack.push(loop_vars)
 
         begin
-          context['forloop'] = loop_vars
+          context['forloop'.freeze] = loop_vars
 
-          segment.each do |item|
+          segment.each_with_index do |item, index|
             context[@variable_name] = item
-            @for_block.render_to_output_buffer(context, output)
+            result << @for_block.render(context)
             loop_vars.send(:increment!)
 
             # Handle any interrupts if they exist.
-            next unless context.interrupt?
+            if context.interrupt?
-            interrupt = context.pop_interrupt
+              interrupt = context.pop_interrupt
-            break if interrupt.is_a?(BreakInterrupt)
+              break if interrupt.is_a? BreakInterrupt
-            next if interrupt.is_a?(ContinueInterrupt)
+              next if interrupt.is_a? ContinueInterrupt
+            end
           end
         ensure
           for_stack.pop
         end
       end
 
-      output
+      result
     end
 
     def set_attribute(key, expr)
       case key
-      when 'offset'
+      when 'offset'.freeze
-        @from = if expr == 'continue'
+        @from = if expr == 'continue'.freeze
-          Usage.increment('for_offset_continue')
           :continue
         else
-          parse_expression(expr)
+          Expression.parse(expr)
         end
-      when 'limit'
+      when 'limit'.freeze
-        @limit = parse_expression(expr)
+        @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 children
-        (super + [@node.limit, @node.from, @node.collection_name]).compact
-      end
     end
   end
 
-  Template.register_tag('for', For)
+  Template.register_tag('for'.freeze, For)
 end

lib/liquid/tags/if.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # If is the conditional block
   #
@@ -12,82 +10,70 @@ module Liquid
   #    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 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
-        if block.evaluate(context)
+        @blocks.each do |block|
-          return block.attachment.render_to_output_buffer(context, output)
+          if block.evaluate(context)
+            return block.attachment.render(context)
+          end
         end
+        ''.freeze
       end
-
-      output
     end
 
     private
 
     def push_block(tag, markup)
-      block = if tag == 'else'
+      block = if tag == 'else'.freeze
         ElseCondition.new
       else
         parse_with_selected_parser(markup)
       end
 
       @blocks.push(block)
-      block.attach(new_body)
+      block.attach(BlockBody.new)
-    end
-
-    def parse_expression(markup)
-      Condition.parse_expression(parse_context, markup)
     end
 
     def lax_parse(markup)
       expressions = markup.scan(ExpressionsAndOperators)
-      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
+      raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
 
-      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+      condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
 
       until expressions.empty?
         operator = expressions.pop.to_s.strip
 
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
 
-        new_condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+        new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
         new_condition.send(operator, condition)
         condition = new_condition
       end
@@ -97,38 +83,29 @@ module Liquid
 
     def strict_parse(markup)
       p = Parser.new(markup)
-      condition = parse_binary_comparisons(p)
+      condition = parse_binary_comparison(p)
       p.consume(:end_of_string)
       condition
     end
 
-    def parse_binary_comparisons(p)
+    def parse_binary_comparison(p)
       condition = parse_comparison(p)
-      first_condition = condition
+      if op = (p.id?('and'.freeze) || p.id?('or'.freeze))
-      while (op = (p.id?('and') || p.id?('or')))
+        condition.send(op, parse_binary_comparison(p))
-        child_condition = parse_comparison(p)
-        condition.send(op, child_condition)
-        condition = child_condition
       end
-      first_condition
+      condition
     end
 
     def parse_comparison(p)
-      a = parse_expression(p.expression)
+      a = Expression.parse(p.expression)
-      if (op = p.consume?(:comparison))
+      if op = p.consume?(:comparison)
-        b = parse_expression(p.expression)
+        b = Expression.parse(p.expression)
         Condition.new(a, op, b)
       else
         Condition.new(a)
       end
     end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        @node.blocks
-      end
-    end
   end
 
-  Template.register_tag('if', If)
+  Template.register_tag('if'.freeze, If)
 end

lib/liquid/tags/ifchanged.rb

@@ -1,19 +1,18 @@
-# frozen_string_literal: true
-
 module Liquid
   class Ifchanged < Block
-    def render_to_output_buffer(context, output)
+    def render(context)
-      block_output = +''
+      context.stack do
-      super(context, block_output)
+        output = super
 
-      if block_output != context.registers[:ifchanged]
+        if output != context.registers[:ifchanged]
-        context.registers[:ifchanged] = block_output
+          context.registers[:ifchanged] = output
-        output << block_output
+          output
+        else
+          ''.freeze
+        end
       end
-
-      output
     end
   end
 
-  Template.register_tag('ifchanged', Ifchanged)
+  Template.register_tag('ifchanged'.freeze, Ifchanged)
 end

lib/liquid/tags/include.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Include allows templates to relate with other templates
   #
@@ -16,96 +14,99 @@ module Liquid
   #   {% include 'product' for products %}
   #
   class Include < Tag
-    prepend Tag::Disableable
+    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
-
-    SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
-    Syntax = SYNTAX
-
-    attr_reader :template_name_expr, :variable_name_expr, :attributes
 
     def initialize(tag_name, markup, options)
       super
 
-      if markup =~ SYNTAX
+      if markup =~ Syntax
 
-        template_name = Regexp.last_match(1)
+        template_name = $1
-        variable_name = Regexp.last_match(3)
+        variable_name = $3
 
-        @alias_name         = Regexp.last_match(5)
+        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
-        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+        @template_name_expr = Expression.parse(template_name)
-        @template_name_expr = parse_expression(template_name)
+        @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.include")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
       end
     end
 
     def parse(_tokens)
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
       template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
+      partial = load_cached_partial(template_name, context)
 
-      partial = PartialCache.load(
+      context_variable_name = template_name.split('/'.freeze).last
-        template_name,
-        context: context,
-        parse_context: parse_context
-      )
-
-      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)
+        context.find_variable(template_name)
       end
 
       old_template_name = context.template_name
-      old_partial       = context.partial
+      old_partial = context.partial
       begin
         context.template_name = template_name
-        context.partial       = true
+        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|
+            variable.collect do |var|
               context[context_variable_name] = var
-              partial.render_to_output_buffer(context, output)
+              partial.render(context)
             end
           else
             context[context_variable_name] = variable
-            partial.render_to_output_buffer(context, output)
+            partial.render(context)
           end
         end
       ensure
         context.template_name = old_template_name
-        context.partial       = old_partial
+        context.partial = old_partial
       end
-
-      output
     end
 
+    private
+
     alias_method :parse_context, :options
     private :parse_context
 
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+    def load_cached_partial(template_name, context)
-      def children
+      cached_partials = context.registers[:cached_partials] || {}
-        [
+
-          @node.template_name_expr,
+      if cached = cached_partials[template_name]
-          @node.variable_name_expr,
+        return cached
-        ] + @node.attributes.values
       end
+      source = read_template_from_file_system(context)
+      begin
+        parse_context.partial = true
+        partial = Liquid::Template.parse(source, parse_context)
+      ensure
+        parse_context.partial = false
+      end
+      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_expr))
     end
   end
 
-  Template.register_tag('include', Include)
+  Template.register_tag('include'.freeze, Include)
 end

lib/liquid/tags/increment.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # increment is used in a place where one needs to insert a counter
   #     into a template, and needs the counter to survive across
@@ -22,14 +20,12 @@ module Liquid
       @variable = markup.strip
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
       value = context.environments.first[@variable] ||= 0
       context.environments.first[@variable] = value + 1
-
+      value.to_s
-      output << value.to_s
-      output
     end
   end
 
-  Template.register_tag('increment', Increment)
+  Template.register_tag('increment'.freeze, Increment)
 end

lib/liquid/tags/inline_comment.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class InlineComment < Tag
-    def blank?
-      true
-    end
-
-    def render_to_output_buffer(_context, _output)
-    end
-  end
-
-  Template.register_tag('--', InlineComment)
-end
-

lib/liquid/tags/raw.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class Raw < Block
     Syntax = /\A\s*\z/
@@ -8,25 +6,26 @@ module Liquid
     def initialize(tag_name, markup, parse_context)
       super
 
-      ensure_valid_markup(tag_name, markup, parse_context)
+      unless markup =~ Syntax
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name))
+      end
     end
 
     def parse(tokens)
-      @body = +''
+      @body = ''
-      while (token = tokens.shift)
+      while token = tokens.shift
-        if token =~ FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
+        if token =~ FullTokenPossiblyInvalid
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
+          @body << $1 if $1 != "".freeze
-          return
+          return if block_delimiter == $2
         end
         @body << token unless token.empty?
       end
 
-      raise_tag_never_closed(block_name)
+      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
     end
 
-    def render_to_output_buffer(_context, output)
+    def render(_context)
-      output << @body
+      @body
-      output
     end
 
     def nodelist
@@ -36,15 +35,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', Raw)
+  Template.register_tag('raw'.freeze, Raw)
 end

lib/liquid/tags/render.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Render < Tag
-    FOR = 'for'
-    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
-
-    disable_tags "include"
-
-    attr_reader :template_name_expr, :attributes
-
-    def initialize(tag_name, markup, options)
-      super
-
-      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
-
-      template_name = Regexp.last_match(1)
-      with_or_for = Regexp.last_match(3)
-      variable_name = Regexp.last_match(4)
-
-      @alias_name = Regexp.last_match(6)
-      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
-      @template_name_expr = parse_expression(template_name)
-      @for = (with_or_for == FOR)
-
-      @attributes = {}
-      markup.scan(TagAttributes) do |key, value|
-        @attributes[key] = parse_expression(value)
-      end
-    end
-
-    def render_to_output_buffer(context, output)
-      render_tag(context, output)
-    end
-
-    def render_tag(context, output)
-      # Though we evaluate this here we will only ever parse it as a string literal.
-      template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
-
-      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 = template_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 @for && variable.respond_to?(:each) && variable.respond_to?(:count)
-        forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
-        variable.each { |var| render_partial_func.call(var, forloop) }
-      else
-        render_partial_func.call(variable, nil)
-      end
-
-      output
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.template_name_expr,
-        ] + @node.attributes.values
-      end
-    end
-  end
-
-  Template.register_tag('render', Render)
-end

lib/liquid/tags/table_row.rb

@@ -1,66 +1,54 @@
-# frozen_string_literal: true
-
 module Liquid
   class TableRow < Block
     Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
 
-    attr_reader :variable_name, :collection_name, :attributes
-
     def initialize(tag_name, markup, options)
       super
       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') ? context.evaluate(@attributes['offset']).to_i : 0
+      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
-      to   = @attributes.key?('limit')  ? from + context.evaluate(@attributes['limit']).to_i : nil
+      to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
 
       collection = Utils.slice_collection(collection, from, to)
-      length     = collection.length
 
-      cols = context.evaluate(@attributes['cols']).to_i
+      length = collection.length
 
-      output << "<tr class=\"row1\">\n"
+      cols = context.evaluate(@attributes['cols'.freeze]).to_i
+
+      result = "<tr class=\"row1\">\n"
       context.stack do
         tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
-        context['tablerowloop'] = tablerowloop
+        context['tablerowloop'.freeze] = tablerowloop
 
-        collection.each do |item|
+        collection.each_with_index do |item, index|
           context[@variable_name] = item
 
-          output << "<td class=\"col#{tablerowloop.col}\">"
+          result << "<td class=\"col#{tablerowloop.col}\">" << super << '</td>'
-          super
-          output << '</td>'
 
           if tablerowloop.col_last && !tablerowloop.last
-            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
+            result << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
           end
 
           tablerowloop.send(:increment!)
         end
       end
-
+      result << "</tr>\n"
-      output << "</tr>\n"
+      result
-      output
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        super + @node.attributes.values + [@node.collection_name]
-      end
     end
   end
 
-  Template.register_tag('tablerow', TableRow)
+  Template.register_tag('tablerow'.freeze, TableRow)
 end

lib/liquid/tags/unless.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require_relative 'if'
 
 module Liquid
@@ -8,23 +6,25 @@ module Liquid
   #   {% unless x < 0 %} x is greater than zero {% endunless %}
   #
   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
+        # First condition is interpreted backwards ( if not )
-      unless first_block.evaluate(context)
+        first_block = @blocks.first
-        return first_block.attachment.render_to_output_buffer(context, output)
+        unless first_block.evaluate(context)
-      end
+          return first_block.attachment.render(context)
-
-      # After the first condition unless works just like if
-      @blocks[1..-1].each do |block|
-        if block.evaluate(context)
-          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', Unless)
+  Template.register_tag('unless'.freeze, Unless)
 end

lib/liquid/template.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Templates are central to liquid.
   # Interpretating templates is a two step process. First you compile the
@@ -18,9 +16,9 @@ module Liquid
     attr_accessor :root
     attr_reader :resource_limits, :warnings
 
-    class TagRegistry
+    @@file_system = BlankFileSystem.new
-      include Enumerable
 
+    class TagRegistry
       def initialize
         @tags  = {}
         @cache = {}
@@ -43,14 +41,10 @@ module Liquid
         @cache.delete(tag_name)
       end
 
-      def each(&block)
-        @tags.each(&block)
-      end
-
       private
 
       def lookup_class(name)
-        Object.const_get(name)
+        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
       end
     end
 
@@ -61,54 +55,70 @@ module Liquid
       # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
       # :warn is the default and will give deprecation warnings when invalid syntax is used.
       # :strict will enforce correct syntax.
-      attr_accessor :error_mode
+      attr_writer :error_mode
-      Template.error_mode = :lax
 
-      attr_accessor :default_exception_renderer
+      # Sets how strict the taint checker should be.
-      Template.default_exception_renderer = lambda do |exception|
+      # :lax is the default, and ignores the taint flag completely
-        exception
+      # :warn adds a warning, but does not interrupt the rendering
+      # :error raises an error when tainted output is used
+      attr_writer :taint_mode
+
+      def file_system
+        @@file_system
       end
 
-      attr_accessor :file_system
+      def file_system=(obj)
-      Template.file_system = BlankFileSystem.new
+        @@file_system = obj
-
+      end
-      attr_accessor :tags
-      Template.tags = TagRegistry.new
-      private :tags=
 
       def register_tag(name, klass)
         tags[name.to_s] = 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)
-        StrainerFactory.add_global_filter(mod)
+        Strainer.global_filter(mod)
       end
 
-      attr_accessor :default_resource_limits
+      def default_resource_limits
-      Template.default_resource_limits = {}
+        @default_resource_limits ||= {}
-      private :default_resource_limits=
+      end
 
       # creates a new <tt>Template</tt> object from liquid source code
       # To enable profiling, pass in <tt>profile: true</tt> as an option.
       # See Liquid::Profiler for more information
       def parse(source, options = {})
-        new.parse(source, options)
+        template = Template.new
+        template.parse(source, options)
       end
     end
 
     def initialize
-      @rethrow_errors  = false
+      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
-      @resource_limits = ResourceLimits.new(Template.default_resource_limits)
     end
 
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, options = {})
-      parse_context = configure_options(options)
+      @options = options
-      tokenizer     = parse_context.new_tokenizer(source, start_line_number: @line_numbers && 1)
+      @profiling = options[:profile]
-      @root         = Document.parse(tokenizer, parse_context)
+      @line_numbers = options[:line_numbers] || @profiling
+      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
+      @root = Document.parse(tokenize(source), parse_context)
+      @warnings = parse_context.warnings
       self
     end
 
@@ -143,19 +153,19 @@ 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) { raise }
         end
 
         c
       when Liquid::Drop
-        drop         = args.shift
+        drop = args.shift
         drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when Hash
         Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
@@ -165,20 +175,18 @@ module Liquid
         raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
       end
 
-      output = nil
-
-      context_register = context.registers.is_a?(StaticRegisters) ? context.registers.static : context.registers
-
       case args.last
       when Hash
         options = args.pop
-        output  = options[:output] if options[:output]
 
-        options[:registers]&.each do |key, register|
+        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
-          context_register[key] = register
+
-        end
+        context.add_filters(options[:filters]) if options[:filters]
+
+        context.global_filter = options[:global_filter] if options[:global_filter]
+
+        context.exception_handler = options[:exception_handler] if options[:exception_handler]
 
-        apply_options_to_context(context, options)
       when Module, Array
         context.add_filters(args.pop)
       end
@@ -186,13 +194,13 @@ module Liquid
       # Retrying a render resets resource usage
       context.resource_limits.reset
 
-      if @profiling && context.profiler.nil?
-        @profiler = context.profiler = Liquid::Profiler.new
-      end
-
       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(context) do
+          @root.render(context)
+        end
+        result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
         context.handle_error(e)
       ensure
@@ -205,31 +213,27 @@ module Liquid
       render(*args)
     end
 
-    def render_to_output_buffer(context, output)
-      render(context, output: output)
-    end
-
     private
 
-    def configure_options(options)
+    def tokenize(source)
-      if (profiling = options[:profile])
+      Tokenizer.new(source, @line_numbers)
-        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
-      end
-
-      @options      = options
-      @profiling    = profiling
-      @line_numbers = options[:line_numbers] || @profiling
-      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
-      @warnings     = parse_context.warnings
-      parse_context
     end
 
-    def apply_options_to_context(context, options)
+    def with_profiling(context)
-      context.add_filters(options[:filters]) if options[:filters]
+      if @profiling && !context.partial
-      context.global_filter      = options[:global_filter] if options[:global_filter]
+        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
-      context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
+
-      context.strict_variables   = options[:strict_variables] if options[:strict_variables]
+        @profiler = Profiler.new
-      context.strict_filters     = options[:strict_filters] if options[:strict_filters]
+        @profiler.start
+
+        begin
+          yield
+        ensure
+          @profiler.stop
+        end
+      else
+        yield
+      end
     end
   end
 end

lib/liquid/template_factory.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class TemplateFactory
-    def for(_template_name)
-      Liquid::Template.new
-    end
-  end
-end

lib/liquid/tokenizer.rb

@@ -1,37 +1,29 @@
-# frozen_string_literal: true
-
 module Liquid
   class Tokenizer
-    attr_reader :line_number, :for_liquid_tag
+    attr_reader :line_number
 
-    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
+    def initialize(source, line_numbers = false)
-      @source         = source
+      @source = source
-      @line_number    = line_number || (line_numbers ? 1 : nil)
+      @line_number = 1 if line_numbers
-      @for_liquid_tag = for_liquid_tag
+      @tokens = tokenize
-      @tokens         = tokenize
     end
 
     def shift
-      (token = @tokens.shift) || return
+      token = @tokens.shift
-
+      @line_number += token.count("\n") if @line_number && token
-      if @line_number
-        @line_number += @for_liquid_tag ? 1 : token.count("\n")
-      end
-
       token
     end
 
     private
 
     def tokenize
+      @source = @source.source if @source.respond_to?(:source)
       return [] if @source.to_s.empty?
 
-      return @source.split("\n") if @for_liquid_tag
-
       tokens = @source.split(TemplateParser)
 
       # removes the rogue empty element at the beginning of the array
-      tokens.shift if tokens[0]&.empty?
+      tokens.shift if tokens[0] && tokens[0].empty?
 
       tokens
     end

lib/liquid/usage.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Usage
-    def self.increment(name)
-    end
-  end
-end

lib/liquid/utils.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   module Utils
     def self.slice_collection(collection, from, to)
@@ -12,7 +10,7 @@ module Liquid
 
     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)
@@ -48,17 +46,13 @@ module Liquid
     def self.to_number(obj)
       case obj
       when Float
-        BigDecimal(obj.to_s)
+        BigDecimal.new(obj.to_s)
       when Numeric
         obj
       when String
-        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+        (obj.strip =~ /\A\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
       else
-        if obj.respond_to?(:to_number)
+        0
-          obj.to_number
-        else
-          0
-        end
       end
     end
 
@@ -71,7 +65,7 @@ module Liquid
       end
 
       case obj
-      when 'now', 'today'
+      when 'now'.freeze, 'today'.freeze
         Time.now
       when /\A\d+\z/, Integer
         Time.at(obj.to_i)

lib/liquid/variable.rb

@@ -1,5 +1,3 @@
-# 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,25 +10,19 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterMarkupRegex        = /#{FilterSeparator}\s*(.*)/om
+    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    FilterParser             = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    FilterArgsRegex          = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
-    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)
-      @markup        = markup
+      @markup  = markup
-      @name          = nil
+      @name    = nil
       @parse_context = parse_context
-      @line_number   = parse_context.line_number
+      @line_number = parse_context.line_number
 
-      strict_parse_with_error_mode_fallback(markup)
+      parse_with_selected_parser(markup)
     end
 
     def raw
@@ -43,17 +35,17 @@ module Liquid
 
     def lax_parse(markup)
       @filters = []
-      return unless markup =~ MarkupWithQuotedFragment
+      return unless markup =~ /(#{QuotedFragment})(.*)/om
 
-      name_markup   = Regexp.last_match(1)
+      name_markup = $1
-      filter_markup = Regexp.last_match(2)
+      filter_markup = $2
-      @name         = Expression.parse(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|
           next unless f =~ /\w+/
           filtername = Regexp.last_match(0)
-          filterargs = f.scan(FilterArgsRegex).flatten
+          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
           @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
@@ -63,8 +55,6 @@ module Liquid
       @filters = []
       p = Parser.new(markup)
 
-      return if p.look(:end_of_string)
-
       @name = Expression.parse(p.expression)
       while p.consume?(:pipe)
         filtername = p.consume(:id)
@@ -83,57 +73,37 @@ module Liquid
     end
 
     def render(context)
-      obj = context.evaluate(@name)
+      obj = @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)
+        context.invoke(filter_name, output, *filter_args)
       end
 
-      context.apply_global_filter(obj)
+      obj = context.apply_global_filter(obj)
-    end
 
-    def render_to_output_buffer(context, output)
+      taint_check(context, obj)
-      obj = render(context)
 
-      if obj.is_a?(Array)
+      obj
-        output << obj.join
-      elsif obj.nil?
-      else
-        output << obj.to_s
-      end
-
-      output
-    end
-
-    def disabled?(_context)
-      false
-    end
-
-    def disabled_tags
-      []
     end
 
     private
 
     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])
         else
           filter_args << Expression.parse(a)
         end
       end
       result = [filter_name, filter_args]
-      result << keyword_args if keyword_args
+      result << keyword_args unless keyword_args.empty?
       result
     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|
@@ -144,9 +114,22 @@ module Liquid
       parsed_args
     end
 
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+    def taint_check(context, obj)
-      def children
+      return unless obj.tainted?
-        [@node.name] + @node.filters.flatten
+      return if Template.taint_mode == :lax
+
+      @markup =~ QuotedFragment
+      name = Regexp.last_match(0)
+
+      error = TaintedError.new("variable '#{name}' is tainted and was not escaped")
+      error.line_number = line_number
+      error.template_name = context.template_name
+
+      case Template.taint_mode
+      when :warn
+        context.warnings << error
+      when :error
+        raise error
       end
     end
   end

lib/liquid/variable_lookup.rb

@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
   class VariableLookup
     SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS  = ['size', 'first', 'last'].freeze
+    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
 
     attr_reader :name, :lookups
 
@@ -16,17 +14,17 @@ module Liquid
 
       name = lookups.shift
       if name =~ SQUARE_BRACKETED
-        name = Expression.parse(Regexp.last_match(1))
+        name = Expression.parse($1)
       end
       @name = name
 
-      @lookups       = lookups
+      @lookups = lookups
       @command_flags = 0
 
       @lookups.each_index do |i|
         lookup = lookups[i]
         if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse(Regexp.last_match(1))
+          lookups[i] = Expression.parse($1)
         elsif COMMAND_METHODS.include?(lookup)
           @command_flags |= 1 << i
         end
@@ -34,7 +32,7 @@ module Liquid
     end
 
     def evaluate(context)
-      name   = context.evaluate(@name)
+      name = context.evaluate(@name)
       object = context.find_variable(name)
 
       @lookups.each_index do |i|
@@ -47,7 +45,7 @@ module Liquid
              (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
@@ -57,11 +55,9 @@ module Liquid
           object = object.send(key).to_liquid
 
           # 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
@@ -80,11 +76,5 @@ module Liquid
     def state
       [@name, @lookups, @command_flags]
     end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        @node.lookups
-      end
-    end
   end
 end

lib/liquid/version.rb

@@ -1,6 +1,4 @@
 # encoding: utf-8
-# frozen_string_literal: true
-
 module Liquid
-  VERSION = "5.0.0"
+  VERSION = "4.0.0.rc1"
 end

liquid.gemspec

@@ -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)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
 
 require "liquid/version"
 
@@ -17,11 +15,8 @@ Gem::Specification.new do |s|
   s.license     = "MIT"
   # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
-  s.required_ruby_version     = ">= 2.5.0"
   s.required_rubygems_version = ">= 1.3.7"
 
-  s.metadata['allowed_push_host'] = 'https://rubygems.org'
-
   s.test_files  = Dir.glob("{test}/**/*")
   s.files       = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
 
@@ -29,6 +24,6 @@ Gem::Specification.new do |s|
 
   s.require_path = "lib"
 
-  s.add_development_dependency('rake', '~> 13.0')
+  s.add_development_dependency 'rake'
-  s.add_development_dependency('minitest')
+  s.add_development_dependency 'minitest'
 end

performance/benchmark.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'benchmark/ips'
 require_relative 'theme_runner'
 
@@ -7,7 +5,7 @@ Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 
 Benchmark.ips do |x|
-  x.time   = 10
+  x.time = 60
   x.warmup = 5
 
   puts
@@ -15,6 +13,5 @@ Benchmark.ips do |x|
   puts
 
   x.report("parse:") { profiler.compile }
-  x.report("render:") { profiler.render }
+  x.report("parse & run:") { profiler.run }
-  x.report("parse & render:") { profiler.run }
 end

performance/memory_profile.rb

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

performance/profile.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'stackprof'
 require_relative 'theme_runner'
 
@@ -15,7 +13,7 @@ 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

performance/shopify/comment_form.rb

@@ -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,12 +20,10 @@ 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
 

performance/shopify/database.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'yaml'
 
 module Database
@@ -18,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
@@ -32,9 +29,9 @@ 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
@@ -43,6 +40,6 @@ module Database
 end
 
 if __FILE__ == $PROGRAM_NAME
-  p(Database.tables['collections']['frontpage'].keys)
+  p Database.tables['collections']['frontpage'].keys
   # p Database.tables['blog']['articles']
 end

performance/shopify/json_filter.rb

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

performance/shopify/liquid.rb

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

performance/shopify/money_filter.rb

@@ -1,14 +1,12 @@
-# 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

performance/shopify/paginate.rb

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

performance/shopify/shop_filter.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module ShopFilter
   def asset_url(input)
     "/files/1/[shop_id]/[shop_id]/assets/#{input}"
@@ -31,7 +29,7 @@ module ShopFilter
 
   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 +37,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,15 +52,15 @@ 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
@@ -72,14 +70,16 @@ module ShopFilter
     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']

performance/shopify/tag_filter.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module TagFilter
   def link_to_tag(label, tag)
     "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
@@ -15,11 +13,11 @@ 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

performance/shopify/weight_filter.rb

@@ -1,8 +1,6 @@
-# frozen_string_literal: true
-
 module WeightFilter
   def weight(grams)
-    format("%.2f", grams / 1000)
+    sprintf("%.2f", grams / 1000)
   end
 
   def weight_with_unit(grams)

performance/theme_runner.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # This profiler run simulates Shopify.
 # We are looking in the tests directory for liquid files and render them within the designated layout file.
 # We will also export a substantial database to liquid which the templates can render values of.
@@ -23,104 +21,53 @@ class ThemeRunner
     end
   end
 
-  # Initialize a new liquid ThemeRunner instance
+  # Load all templates into memory, do this now so that
-  # Will load all templates into memory, do this now so that we don't profile IO.
+  # we don't profile IO.
   def initialize
     @tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
       next if File.basename(test) == 'theme.liquid'
 
       theme_path = File.dirname(test) + '/theme.liquid'
-      {
-        liquid: File.read(test),
-        layout: (File.file?(theme_path) ? File.read(theme_path) : nil),
-        template_name: test,
-      }
-    end.compact
 
-    compile_all_tests
+      [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
+    end.compact
   end
 
-  # `compile` will test just the compilation portion of liquid without any templates
   def compile
-    @tests.each do |test_hash|
+    # Dup assigns because will make some changes to them
-      Liquid::Template.new.parse(test_hash[:liquid])
+
-      Liquid::Template.new.parse(test_hash[:layout])
+    @tests.each do |liquid, layout, template_name|
+      tmpl = Liquid::Template.new
+      tmpl.parse(liquid)
+      tmpl = Liquid::Template.new
+      tmpl.parse(layout)
     end
   end
 
-  # `run` is called to benchmark rendering and compiling at the same time
   def run
-    each_test do |liquid, layout, assigns, page_template, template_name|
+    # Dup assigns because will make some changes to them
+    assigns = Database.tables.dup
+
+    @tests.each do |liquid, layout, template_name|
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
+      page_template = File.basename(template_name, File.extname(template_name))
       compile_and_render(liquid, layout, assigns, page_template, template_name)
     end
   end
 
-  # `render` is called to benchmark just the render portion of liquid
-  def render
-    @compiled_tests.each do |test|
-      tmpl    = test[:tmpl]
-      assigns = test[:assigns]
-      layout  = test[:layout]
-
-      if layout
-        assigns['content_for_layout'] = tmpl.render!(assigns)
-        layout.render!(assigns)
-      else
-        tmpl.render!(assigns)
-      end
-    end
-  end
-
-  private
-
-  def render_layout(template, layout, assigns)
-    assigns['content_for_layout'] = template.render!(assigns)
-    layout&.render!(assigns)
-  end
-
   def compile_and_render(template, layout, assigns, page_template, template_file)
-    compiled_test = compile_test(template, layout, assigns, page_template, template_file)
+    tmpl = Liquid::Template.new
-    render_layout(compiled_test[:tmpl], compiled_test[:layout], compiled_test[:assigns])
+    tmpl.assigns['page_title'] = 'Page title'
-  end
+    tmpl.assigns['template'] = page_template
+    tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
 
-  def compile_all_tests
+    content_for_layout = tmpl.parse(template).render!(assigns)
-    @compiled_tests = []
-    each_test do |liquid, layout, assigns, page_template, template_name|
-      @compiled_tests << compile_test(liquid, layout, assigns, page_template, template_name)
-    end
-    @compiled_tests
-  end
-
-  def compile_test(template, layout, assigns, page_template, template_file)
-    tmpl            = init_template(page_template, template_file)
-    parsed_template = tmpl.parse(template).dup
 
     if layout
-      parsed_layout = tmpl.parse(layout)
+      assigns['content_for_layout'] = content_for_layout
-      { tmpl: parsed_template, assigns: assigns, layout: parsed_layout }
+      tmpl.parse(layout).render!(assigns)
     else
-      { tmpl: parsed_template, assigns: assigns }
+      content_for_layout
     end
   end
-
-  # utility method with similar functionality needed in `compile_all_tests` and `run`
-  def each_test
-    # Dup assigns because will make some changes to them
-    assigns = Database.tables.dup
-
-    @tests.each do |test_hash|
-      # Compute page_template outside of profiler run, uninteresting to profiler
-      page_template = File.basename(test_hash[:template_name], File.extname(test_hash[:template_name]))
-      yield(test_hash[:liquid], test_hash[:layout], assigns, page_template, test_hash[:template_name])
-    end
-  end
-
-  # set up a new Liquid::Template object for use in `compile_and_render` and `compile_test`
-  def init_template(page_template, template_file)
-    tmpl                         = Liquid::Template.new
-    tmpl.assigns['page_title']   = 'Page title'
-    tmpl.assigns['template']     = page_template
-    tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
-    tmpl
-  end
 end

test/integration/assign_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class AssignTest < Minitest::Test
@@ -10,9 +8,9 @@ class AssignTest < Minitest::Test
     {% assign this-thing = 'Print this-thing' %}
     {{ this-thing }}
     END_TEMPLATE
-    template        = Template.parse(template_source)
+    template = Template.parse(template_source)
-    rendered        = template.render!
+    rendered = template.render!
-    assert_equal("Print this-thing", rendered.strip)
+    assert_equal "Print this-thing", rendered.strip
   end
 
   def test_assigned_variable
@@ -44,74 +42,7 @@ class AssignTest < Minitest::Test
       end
     end
     with_error_mode(:lax) do
-      assert(Template.parse("{% assign foo = ('X' | downcase) %}"))
+      assert Template.parse("{% assign foo = ('X' | downcase) %}")
     end
   end
-
+end # AssignTest
-  def test_expression_with_whitespace_in_square_brackets
-    source = "{% assign r = a[ 'b' ] %}{{ r }}"
-    assert_template_result('result', source, 'a' => { 'b' => 'result' })
-  end
-
-  def test_assign_score_exceeding_resource_limit
-    t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
-    t.resource_limits.assign_score_limit = 1
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
-
-    t.resource_limits.assign_score_limit = 2
-    assert_equal("", t.render!)
-    refute_nil(t.resource_limits.assign_score)
-  end
-
-  def test_assign_score_exceeding_limit_from_composite_object
-    t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
-
-    t.resource_limits.assign_score_limit = 3
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
-
-    t.resource_limits.assign_score_limit = 5
-    assert_equal("", t.render!)
-  end
-
-  def test_assign_score_of_int
-    assert_equal(1, assign_score_of(123))
-  end
-
-  def test_assign_score_of_string_counts_bytes
-    assert_equal(3, assign_score_of('123'))
-    assert_equal(5, assign_score_of('12345'))
-    assert_equal(9, assign_score_of('すごい'))
-  end
-
-  def test_assign_score_of_array
-    assert_equal(1, assign_score_of([]))
-    assert_equal(2, assign_score_of([123]))
-    assert_equal(6, assign_score_of([123, 'abcd']))
-  end
-
-  def test_assign_score_of_hash
-    assert_equal(1, assign_score_of({}))
-    assert_equal(5, assign_score_of('int' => 123))
-    assert_equal(12, assign_score_of('int' => 123, 'str' => 'abcd'))
-  end
-
-  private
-
-  class ObjectWrapperDrop < Liquid::Drop
-    def initialize(obj)
-      @obj = obj
-    end
-
-    def value
-      @obj
-    end
-  end
-
-  def assign_score_of(obj)
-    context = Liquid::Context.new('drop' => ObjectWrapperDrop.new(obj))
-    Liquid::Template.parse('{% assign obj = drop.value %}').render!(context)
-    context.resource_limits.assign_score
-  end
-end

test/integration/blank_test.rb

@@ -1,12 +1,11 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class FoobarTag < Liquid::Tag
-  def render_to_output_buffer(_context, output)
+  def render(*args)
-    output << ' '
+    " "
-    output
   end
+
+  Liquid::Template.register_tag('foobar', FoobarTag)
 end
 
 class BlankTestFileSystem
@@ -32,9 +31,7 @@ class BlankTest < Minitest::Test
   end
 
   def test_new_tags_are_not_blank_by_default
-    with_custom_tag('foobar', FoobarTag) do
+    assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
-      assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
-    end
   end
 
   def test_loops_are_blank
@@ -96,9 +93,9 @@ class BlankTest < Minitest::Test
 
   def test_include_is_blank
     Liquid::Template.file_system = BlankTestFileSystem.new
-    assert_template_result("foobar" * (N + 1), wrap("{% include 'foobar' %}"))
+    assert_template_result "foobar" * (N + 1), wrap("{% include 'foobar' %}")
-    assert_template_result(" foobar " * (N + 1), wrap("{% include ' foobar ' %}"))
+    assert_template_result " foobar " * (N + 1), wrap("{% include ' foobar ' %}")
-    assert_template_result("   " * (N + 1), wrap(" {% include ' ' %} "))
+    assert_template_result "   " * (N + 1), wrap(" {% include ' ' %} ")
   end
 
   def test_case_is_blank

test/integration/block_test.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BlockTest < Minitest::Test
-  include Liquid
-
-  def test_unexpected_end_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% if true %}{% endunless %}")
-    end
-    assert_equal(exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif")
-  end
-
-  def test_with_custom_tag
-    with_custom_tag('testtag', Block) do
-      assert(Liquid::Template.parse("{% testtag %} {% endtesttag %}"))
-    end
-  end
-
-  def test_custom_block_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
-    klass1 = Class.new(Block) do
-      def render(*)
-        'hello'
-      end
-    end
-
-    with_custom_tag('blabla', klass1) do
-      template = Liquid::Template.parse("{% blabla %} bla {% endblabla %}")
-
-      assert_equal('hello', template.render)
-
-      buf    = +''
-      output = template.render({}, output: buf)
-      assert_equal('hello', output)
-      assert_equal('hello', buf)
-      assert_equal(buf.object_id, output.object_id)
-    end
-
-    klass2 = Class.new(klass1) do
-      def render(*)
-        'foo' + super + 'bar'
-      end
-    end
-
-    with_custom_tag('blabla', klass2) do
-      template = Liquid::Template.parse("{% blabla %} foo {% endblabla %}")
-
-      assert_equal('foohellobar', template.render)
-
-      buf    = +''
-      output = template.render({}, output: buf)
-      assert_equal('foohellobar', output)
-      assert_equal('foohellobar', buf)
-      assert_equal(buf.object_id, output.object_id)
-    end
-  end
-end

test/integration/capture_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class CaptureTest < Minitest::Test
@@ -14,9 +12,9 @@ class CaptureTest < Minitest::Test
     {% capture this-thing %}Print this-thing{% endcapture %}
     {{ this-thing }}
     END_TEMPLATE
-    template        = Template.parse(template_source)
+    template = Template.parse(template_source)
-    rendered        = template.render!
+    rendered = template.render!
-    assert_equal("Print this-thing", rendered.strip)
+    assert_equal "Print this-thing", rendered.strip
   end
 
   def test_capture_to_variable_from_outer_scope_if_existing
@@ -30,9 +28,9 @@ class CaptureTest < Minitest::Test
     {% endif %}
     {{var}}
     END_TEMPLATE
-    template        = Template.parse(template_source)
+    template = Template.parse(template_source)
-    rendered        = template.render!
+    rendered = template.render!
-    assert_equal("test-string", rendered.gsub(/\s/, ''))
+    assert_equal "test-string", rendered.gsub(/\s/, '')
   end
 
   def test_assigning_from_capture
@@ -45,14 +43,8 @@ class CaptureTest < Minitest::Test
     {% endfor %}
     {{ first }}-{{ second }}
     END_TEMPLATE
-    template        = Template.parse(template_source)
+    template = Template.parse(template_source)
-    rendered        = template.render!
+    rendered = template.render!
-    assert_equal("3-3", rendered.gsub(/\s/, ''))
+    assert_equal "3-3", rendered.gsub(/\s/, '')
   end
-
+end # CaptureTest
-  def test_increment_assign_score_by_bytes_not_characters
-    t = Template.parse("{% capture foo %}すごい{% endcapture %}")
-    t.render!
-    assert_equal(9, t.resource_limits.assign_score)
-  end
-end

test/integration/context_test.rb

@@ -1,597 +1,8 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
-class HundredCentes
-  def to_liquid
-    100
-  end
-end
-
-class CentsDrop < Liquid::Drop
-  def amount
-    HundredCentes.new
-  end
-
-  def non_zero?
-    true
-  end
-end
-
-class ContextSensitiveDrop < Liquid::Drop
-  def test
-    @context['test']
-  end
-end
-
-class Category < Liquid::Drop
-  attr_accessor :name
-
-  def initialize(name)
-    @name = name
-  end
-
-  def to_liquid
-    CategoryDrop.new(self)
-  end
-end
-
-class CategoryDrop
-  attr_accessor :category, :context
-  def initialize(category)
-    @category = category
-  end
-end
-
-class CounterDrop < Liquid::Drop
-  def count
-    @count ||= 0
-    @count  += 1
-  end
-end
-
-class ArrayLike
-  def fetch(index)
-  end
-
-  def [](index)
-    @counts        ||= []
-    @counts[index] ||= 0
-    @counts[index]  += 1
-  end
-
-  def to_liquid
-    self
-  end
-end
-
 class ContextTest < Minitest::Test
   include Liquid
 
-  def setup
-    @context = Liquid::Context.new
-  end
-
-  def test_variables
-    @context['string'] = 'string'
-    assert_equal('string', @context['string'])
-
-    @context['num'] = 5
-    assert_equal(5, @context['num'])
-
-    @context['time'] = Time.parse('2006-06-06 12:00:00')
-    assert_equal(Time.parse('2006-06-06 12:00:00'), @context['time'])
-
-    @context['date'] = Date.today
-    assert_equal(Date.today, @context['date'])
-
-    now = Time.now
-    @context['datetime'] = now
-    assert_equal(now, @context['datetime'])
-
-    @context['bool'] = true
-    assert_equal(true, @context['bool'])
-
-    @context['bool'] = false
-    assert_equal(false, @context['bool'])
-
-    @context['nil'] = nil
-    assert_nil(@context['nil'])
-    assert_nil(@context['nil'])
-  end
-
-  def test_variables_not_existing
-    assert_nil(@context['does_not_exist'])
-  end
-
-  def test_scoping
-    @context.push
-    @context.pop
-
-    assert_raises(Liquid::ContextError) do
-      @context.pop
-    end
-
-    assert_raises(Liquid::ContextError) do
-      @context.push
-      @context.pop
-      @context.pop
-    end
-  end
-
-  def test_length_query
-    @context['numbers'] = [1, 2, 3, 4]
-
-    assert_equal(4, @context['numbers.size'])
-
-    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
-
-    assert_equal(4, @context['numbers.size'])
-
-    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
-
-    assert_equal(1000, @context['numbers.size'])
-  end
-
-  def test_hyphenated_variable
-    @context['oh-my'] = 'godz'
-    assert_equal('godz', @context['oh-my'])
-  end
-
-  def test_add_filter
-    filter = Module.new do
-      def hi(output)
-        output + ' hi!'
-      end
-    end
-
-    context = Context.new
-    context.add_filters(filter)
-    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
-
-    context = Context.new
-    assert_equal('hi?', context.invoke(:hi, 'hi?'))
-
-    context.add_filters(filter)
-    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
-  end
-
-  def test_only_intended_filters_make_it_there
-    filter = Module.new do
-      def hi(output)
-        output + ' hi!'
-      end
-    end
-
-    context = Context.new
-    assert_equal("Wookie", context.invoke("hi", "Wookie"))
-
-    context.add_filters(filter)
-    assert_equal("Wookie hi!", context.invoke("hi", "Wookie"))
-  end
-
-  def test_add_item_in_outer_scope
-    @context['test'] = 'test'
-    @context.push
-    assert_equal('test', @context['test'])
-    @context.pop
-    assert_equal('test', @context['test'])
-  end
-
-  def test_add_item_in_inner_scope
-    @context.push
-    @context['test'] = 'test'
-    assert_equal('test', @context['test'])
-    @context.pop
-    assert_nil(@context['test'])
-  end
-
-  def test_hierachical_data
-    @context['hash'] = { "name" => 'tobi' }
-    assert_equal('tobi', @context['hash.name'])
-    assert_equal('tobi', @context['hash["name"]'])
-  end
-
-  def test_keywords
-    assert_equal(true, @context['true'])
-    assert_equal(false, @context['false'])
-  end
-
-  def test_digits
-    assert_equal(100, @context['100'])
-    assert_equal(100.00, @context['100.00'])
-  end
-
-  def test_strings
-    assert_equal("hello!", @context['"hello!"'])
-    assert_equal("hello!", @context["'hello!'"])
-  end
-
-  def test_merge
-    @context.merge("test" => "test")
-    assert_equal('test', @context['test'])
-    @context.merge("test" => "newvalue", "foo" => "bar")
-    assert_equal('newvalue', @context['test'])
-    assert_equal('bar', @context['foo'])
-  end
-
-  def test_array_notation
-    @context['test'] = [1, 2, 3, 4, 5]
-
-    assert_equal(1, @context['test[0]'])
-    assert_equal(2, @context['test[1]'])
-    assert_equal(3, @context['test[2]'])
-    assert_equal(4, @context['test[3]'])
-    assert_equal(5, @context['test[4]'])
-  end
-
-  def test_recoursive_array_notation
-    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
-
-    assert_equal(1, @context['test.test[0]'])
-
-    @context['test'] = [{ 'test' => 'worked' }]
-
-    assert_equal('worked', @context['test[0].test'])
-  end
-
-  def test_hash_to_array_transition
-    @context['colors'] = {
-      'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
-      'Green' => ['003300', '336633', '669966', '99CC99'],
-      'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
-      'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
-    }
-
-    assert_equal('003366', @context['colors.Blue[0]'])
-    assert_equal('FF9999', @context['colors.Red[3]'])
-  end
-
-  def test_try_first
-    @context['test'] = [1, 2, 3, 4, 5]
-
-    assert_equal(1, @context['test.first'])
-    assert_equal(5, @context['test.last'])
-
-    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
-
-    assert_equal(1, @context['test.test.first'])
-    assert_equal(5, @context['test.test.last'])
-
-    @context['test'] = [1]
-    assert_equal(1, @context['test.first'])
-    assert_equal(1, @context['test.last'])
-  end
-
-  def test_access_hashes_with_hash_notation
-    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
-    @context['product']  = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
-
-    assert_equal(5, @context['products["count"]'])
-    assert_equal('deepsnow', @context['products["tags"][0]'])
-    assert_equal('deepsnow', @context['products["tags"].first'])
-    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
-    assert_equal('element151cm', @context['product["variants"][1]["title"]'])
-    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
-    assert_equal('element151cm', @context['product["variants"].last["title"]'])
-  end
-
-  def test_access_variable_with_hash_notation
-    @context['foo'] = 'baz'
-    @context['bar'] = 'foo'
-
-    assert_equal('baz', @context['["foo"]'])
-    assert_equal('baz', @context['[bar]'])
-  end
-
-  def test_access_hashes_with_hash_access_variables
-    @context['var']      = 'tags'
-    @context['nested']   = { 'var' => 'tags' }
-    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
-
-    assert_equal('deepsnow', @context['products[var].first'])
-    assert_equal('freestyle', @context['products[nested.var].last'])
-  end
-
-  def test_hash_notation_only_for_hash_access
-    @context['array'] = [1, 2, 3, 4, 5]
-    @context['hash']  = { 'first' => 'Hello' }
-
-    assert_equal(1, @context['array.first'])
-    assert_nil(@context['array["first"]'])
-    assert_equal('Hello', @context['hash["first"]'])
-  end
-
-  def test_first_can_appear_in_middle_of_callchain
-    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
-
-    assert_equal('draft151cm', @context['product.variants[0].title'])
-    assert_equal('element151cm', @context['product.variants[1].title'])
-    assert_equal('draft151cm', @context['product.variants.first.title'])
-    assert_equal('element151cm', @context['product.variants.last.title'])
-  end
-
-  def test_cents
-    @context.merge("cents" => HundredCentes.new)
-    assert_equal(100, @context['cents'])
-  end
-
-  def test_nested_cents
-    @context.merge("cents" => { 'amount' => HundredCentes.new })
-    assert_equal(100, @context['cents.amount'])
-
-    @context.merge("cents" => { 'cents' => { 'amount' => HundredCentes.new } })
-    assert_equal(100, @context['cents.cents.amount'])
-  end
-
-  def test_cents_through_drop
-    @context.merge("cents" => CentsDrop.new)
-    assert_equal(100, @context['cents.amount'])
-  end
-
-  def test_nested_cents_through_drop
-    @context.merge("vars" => { "cents" => CentsDrop.new })
-    assert_equal(100, @context['vars.cents.amount'])
-  end
-
-  def test_drop_methods_with_question_marks
-    @context.merge("cents" => CentsDrop.new)
-    assert(@context['cents.non_zero?'])
-  end
-
-  def test_context_from_within_drop
-    @context.merge("test" => '123', "vars" => ContextSensitiveDrop.new)
-    assert_equal('123', @context['vars.test'])
-  end
-
-  def test_nested_context_from_within_drop
-    @context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
-    assert_equal('123', @context['vars.local.test'])
-  end
-
-  def test_ranges
-    @context.merge("test" => '5')
-    assert_equal((1..5), @context['(1..5)'])
-    assert_equal((1..5), @context['(1..test)'])
-    assert_equal((5..5), @context['(test..test)'])
-  end
-
-  def test_cents_through_drop_nestedly
-    @context.merge("cents" => { "cents" => CentsDrop.new })
-    assert_equal(100, @context['cents.cents.amount'])
-
-    @context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
-    assert_equal(100, @context['cents.cents.cents.amount'])
-  end
-
-  def test_drop_with_variable_called_only_once
-    @context['counter'] = CounterDrop.new
-
-    assert_equal(1, @context['counter.count'])
-    assert_equal(2, @context['counter.count'])
-    assert_equal(3, @context['counter.count'])
-  end
-
-  def test_drop_with_key_called_only_once
-    @context['counter'] = CounterDrop.new
-
-    assert_equal(1, @context['counter["count"]'])
-    assert_equal(2, @context['counter["count"]'])
-    assert_equal(3, @context['counter["count"]'])
-  end
-
-  def test_proc_as_variable
-    @context['dynamic'] = proc { 'Hello' }
-
-    assert_equal('Hello', @context['dynamic'])
-  end
-
-  def test_lambda_as_variable
-    @context['dynamic'] = proc { 'Hello' }
-
-    assert_equal('Hello', @context['dynamic'])
-  end
-
-  def test_nested_lambda_as_variable
-    @context['dynamic'] = { "lambda" => proc { 'Hello' } }
-
-    assert_equal('Hello', @context['dynamic.lambda'])
-  end
-
-  def test_array_containing_lambda_as_variable
-    @context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
-
-    assert_equal('Hello', @context['dynamic[2]'])
-  end
-
-  def test_lambda_is_called_once
-    @context['callcount'] = proc {
-      @global ||= 0
-      @global  += 1
-      @global.to_s
-    }
-
-    assert_equal('1', @context['callcount'])
-    assert_equal('1', @context['callcount'])
-    assert_equal('1', @context['callcount'])
-
-    @global = nil
-  end
-
-  def test_nested_lambda_is_called_once
-    @context['callcount'] = { "lambda" => proc {
-                                            @global ||= 0
-                                            @global  += 1
-                                            @global.to_s
-                                          } }
-
-    assert_equal('1', @context['callcount.lambda'])
-    assert_equal('1', @context['callcount.lambda'])
-    assert_equal('1', @context['callcount.lambda'])
-
-    @global = nil
-  end
-
-  def test_lambda_in_array_is_called_once
-    @context['callcount'] = [1, 2, proc {
-                                     @global ||= 0
-                                     @global  += 1
-                                     @global.to_s
-                                   }, 4, 5]
-
-    assert_equal('1', @context['callcount[2]'])
-    assert_equal('1', @context['callcount[2]'])
-    assert_equal('1', @context['callcount[2]'])
-
-    @global = nil
-  end
-
-  def test_access_to_context_from_proc
-    @context.registers[:magic] = 345392
-
-    @context['magic'] = proc { @context.registers[:magic] }
-
-    assert_equal(345392, @context['magic'])
-  end
-
-  def test_to_liquid_and_context_at_first_level
-    @context['category'] = Category.new("foobar")
-    assert_kind_of(CategoryDrop, @context['category'])
-    assert_equal(@context, @context['category'].context)
-  end
-
-  def test_interrupt_avoids_object_allocations
-    assert_no_object_allocations do
-      @context.interrupt?
-    end
-  end
-
-  def test_context_initialization_with_a_proc_in_environment
-    contx = Context.new([test: ->(c) { c['poutine'] }], test: :foo)
-
-    assert(contx)
-    assert_nil(contx['poutine'])
-  end
-
-  def test_apply_global_filter
-    global_filter_proc = ->(output) { "#{output} filtered" }
-
-    context = Context.new
-    context.global_filter = global_filter_proc
-
-    assert_equal('hi filtered', context.apply_global_filter('hi'))
-  end
-
-  def test_static_environments_are_read_with_lower_priority_than_environments
-    context = Context.build(
-      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
-      environments: { 'shadowed' => 'dynamic' }
-    )
-
-    assert_equal('dynamic', context['shadowed'])
-    assert_equal('static', context['unshadowed'])
-  end
-
-  def test_apply_global_filter_when_no_global_filter_exist
-    context = Context.new
-    assert_equal('hi', context.apply_global_filter('hi'))
-  end
-
-  def test_new_isolated_subcontext_does_not_inherit_variables
-    super_context = Context.new
-    super_context['my_variable'] = 'some value'
-    subcontext = super_context.new_isolated_subcontext
-
-    assert_nil(subcontext['my_variable'])
-  end
-
-  def test_new_isolated_subcontext_inherits_static_environment
-    super_context = Context.build(static_environments: { 'my_environment_value' => 'my value' })
-    subcontext    = super_context.new_isolated_subcontext
-
-    assert_equal('my value', subcontext['my_environment_value'])
-  end
-
-  def test_new_isolated_subcontext_inherits_resource_limits
-    resource_limits = ResourceLimits.new({})
-    super_context   = Context.new({}, {}, {}, false, resource_limits)
-    subcontext      = super_context.new_isolated_subcontext
-    assert_equal(resource_limits, subcontext.resource_limits)
-  end
-
-  def test_new_isolated_subcontext_inherits_exception_renderer
-    super_context = Context.new
-    super_context.exception_renderer = ->(_e) { 'my exception message' }
-    subcontext = super_context.new_isolated_subcontext
-    assert_equal('my exception message', subcontext.handle_error(Liquid::Error.new))
-  end
-
-  def test_new_isolated_subcontext_does_not_inherit_non_static_registers
-    registers = {
-      my_register: :my_value,
-    }
-    super_context = Context.new({}, {}, StaticRegisters.new(registers))
-    super_context.registers[:my_register] = :my_alt_value
-    subcontext                            = super_context.new_isolated_subcontext
-    assert_equal(:my_value, subcontext.registers[:my_register])
-  end
-
-  def test_new_isolated_subcontext_inherits_static_registers
-    super_context = Context.build(registers: { my_register: :my_value })
-    subcontext    = super_context.new_isolated_subcontext
-    assert_equal(:my_value, subcontext.registers[:my_register])
-  end
-
-  def test_new_isolated_subcontext_registers_do_not_pollute_context
-    super_context                      = Context.build(registers: { my_register: :my_value })
-    subcontext                         = super_context.new_isolated_subcontext
-    subcontext.registers[:my_register] = :my_alt_value
-    assert_equal(:my_value, super_context.registers[:my_register])
-  end
-
-  def test_new_isolated_subcontext_inherits_filters
-    my_filter = Module.new do
-      def my_filter(*)
-        'my filter result'
-      end
-    end
-
-    super_context = Context.new
-    super_context.add_filters([my_filter])
-    subcontext    = super_context.new_isolated_subcontext
-    template      = Template.parse('{{ 123 | my_filter }}')
-    assert_equal('my filter result', template.render(subcontext))
-  end
-
-  def test_disables_tag_specified
-    context = Context.new
-    context.with_disabled_tags(%w(foo bar)) do
-      assert_equal(true, context.tag_disabled?("foo"))
-      assert_equal(true, context.tag_disabled?("bar"))
-      assert_equal(false, context.tag_disabled?("unknown"))
-    end
-  end
-
-  def test_disables_nested_tags
-    context = Context.new
-    context.with_disabled_tags(["foo"]) do
-      context.with_disabled_tags(["foo"]) do
-        assert_equal(true, context.tag_disabled?("foo"))
-        assert_equal(false, context.tag_disabled?("bar"))
-      end
-      context.with_disabled_tags(["bar"]) do
-        assert_equal(true, context.tag_disabled?("foo"))
-        assert_equal(true, context.tag_disabled?("bar"))
-        context.with_disabled_tags(["foo"]) do
-          assert_equal(true, context.tag_disabled?("foo"))
-          assert_equal(true, context.tag_disabled?("bar"))
-        end
-      end
-      assert_equal(true, context.tag_disabled?("foo"))
-      assert_equal(false, context.tag_disabled?("bar"))
-    end
-  end
-
   def test_override_global_filter
     global = Module.new do
       def notice(output)
@@ -606,30 +17,16 @@ class ContextTest < Minitest::Test
     end
 
     with_global_filter(global) do
-      assert_equal('Global test', Template.parse("{{'test' | notice }}").render!)
+      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
-      assert_equal('Local test', Template.parse("{{'test' | notice }}").render!({}, filters: [local]))
+      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, filters: [local])
     end
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_mode(:strict) do
+    with_error_mode :strict do
       context = Context.new
       context.key?('unknown')
-      assert_empty(context.errors)
+      assert_empty context.errors
     end
   end
-
+end
-  private
-
-  def assert_no_object_allocations
-    unless RUBY_ENGINE == 'ruby'
-      skip("stackprof needed to count object allocations")
-    end
-    require 'stackprof'
-
-    profile = StackProf.run(mode: :object) do
-      yield
-    end
-    assert_equal(0, profile[:samples])
-  end
-end # ContextTest

test/integration/document_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class DocumentTest < Minitest::Test
@@ -9,13 +7,13 @@ class DocumentTest < Minitest::Test
     exc = assert_raises(SyntaxError) do
       Template.parse("{% else %}")
     end
-    assert_equal(exc.message, "Liquid syntax error: Unexpected outer 'else' tag")
+    assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
   end
 
   def test_unknown_tag
     exc = assert_raises(SyntaxError) do
       Template.parse("{% foo %}")
     end
-    assert_equal(exc.message, "Liquid syntax error: Unknown tag 'foo'")
+    assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
   end
 end

test/integration/drop_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class ContextDrop < Liquid::Drop
@@ -33,7 +31,7 @@ class ProductDrop < Liquid::Drop
 
   class CatchallDrop < Liquid::Drop
     def liquid_method_missing(method)
-      "catchall_method: #{method}"
+      'catchall_method: ' << method.to_s
     end
   end
 
@@ -49,6 +47,10 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
+  def user_input
+    "foo".taint
+  end
+
   protected
 
   def callmenot
@@ -107,151 +109,165 @@ class DropsTest < Minitest::Test
 
   def test_product_drop
     tpl = Liquid::Template.parse('  ')
-    assert_equal('  ', tpl.render!('product' => ProductDrop.new))
+    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
+  end
+
+  def test_rendering_raises_on_tainted_attr
+    with_taint_mode(:error) do
+      tpl = Liquid::Template.parse('{{ product.user_input }}')
+      assert_raises TaintedError do
+        tpl.render!('product' => ProductDrop.new)
+      end
+    end
+  end
+
+  def test_rendering_warns_on_tainted_attr
+    with_taint_mode(:warn) do
+      tpl = Liquid::Template.parse('{{ product.user_input }}')
+      context = Context.new('product' => ProductDrop.new)
+      tpl.render!(context)
+      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
+      assert_equal "variable 'product.user_input' is tainted and was not escaped", context.warnings.first.to_s(false)
+    end
+  end
+
+  def test_rendering_doesnt_raise_on_escaped_tainted_attr
+    with_taint_mode(:error) do
+      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
+      tpl.render!('product' => ProductDrop.new)
+    end
   end
 
   def test_drop_does_only_respond_to_whitelisted_methods
-    assert_equal("", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new))
+    assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new)
-    assert_equal("", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new))
+    assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new)
-    assert_equal("", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new))
+    assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new)
-    assert_equal("", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new))
+    assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal("", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new))
+    assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal("", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new))
+    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new)
   end
 
   def test_drops_respond_to_to_liquid
-    assert_equal("text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new))
+    assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new)
-    assert_equal("text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new))
+    assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new)
   end
 
   def test_text_drop
     output = Liquid::Template.parse(' {{ product.texts.text }} ').render!('product' => ProductDrop.new)
-    assert_equal(' text1 ', output)
+    assert_equal ' text1 ', output
   end
 
   def test_catchall_unknown_method
     output = Liquid::Template.parse(' {{ product.catchall.unknown }} ').render!('product' => ProductDrop.new)
-    assert_equal(' catchall_method: unknown ', output)
+    assert_equal ' catchall_method: unknown ', output
   end
 
   def test_catchall_integer_argument_drop
     output = Liquid::Template.parse(' {{ product.catchall[8] }} ').render!('product' => ProductDrop.new)
-    assert_equal(' catchall_method: 8 ', output)
+    assert_equal ' catchall_method: 8 ', output
   end
 
   def test_text_array_drop
     output = Liquid::Template.parse('{% for text in product.texts.array %} {{text}} {% endfor %}').render!('product' => ProductDrop.new)
-    assert_equal(' text1  text2 ', output)
+    assert_equal ' text1  text2 ', output
   end
 
   def test_context_drop
     output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
-    assert_equal(' carrot ', output)
+    assert_equal ' carrot ', output
-  end
-
-  def test_context_drop_array_with_map
-    output = Liquid::Template.parse(' {{ contexts | map: "bar" }} ').render!('contexts' => [ContextDrop.new, ContextDrop.new], 'bar' => "carrot")
-    assert_equal(' carrotcarrot ', output)
   end
 
   def test_nested_context_drop
     output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
-    assert_equal(' monkey ', output)
+    assert_equal ' monkey ', output
   end
 
   def test_protected
     output = Liquid::Template.parse(' {{ product.callmenot }} ').render!('product' => ProductDrop.new)
-    assert_equal('  ', output)
+    assert_equal '  ', output
   end
 
   def test_object_methods_not_allowed
     [:dup, :clone, :singleton_class, :eval, :class_eval, :inspect].each do |method|
       output = Liquid::Template.parse(" {{ product.#{method} }} ").render!('product' => ProductDrop.new)
-      assert_equal('  ', output)
+      assert_equal '  ', output
     end
   end
 
   def test_scope
-    assert_equal('1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new))
+    assert_equal '1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new)
-    assert_equal('2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal('3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
   end
 
   def test_scope_though_proc
-    assert_equal('1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }))
+    assert_equal '1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] })
-    assert_equal('2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1]))
+    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
-    assert_equal('3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1]))
+    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
   end
 
   def test_scope_with_assigns
-    assert_equal('variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new))
+    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new)
-    assert_equal('variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal('test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new))
+    assert_equal 'test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new)
-    assert_equal('test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new))
+    assert_equal 'test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new)
   end
 
   def test_scope_from_tags
-    assert_equal('1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal '1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal('12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal '12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal('123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
   end
 
   def test_access_context_from_drop
-    assert_equal('123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3]))
+    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3])
   end
 
   def test_enumerable_drop
-    assert_equal('123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new))
+    assert_equal '123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new)
   end
 
   def test_enumerable_drop_size
-    assert_equal('3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new))
+    assert_equal '3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new)
   end
 
   def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names
     ["select", "each", "map", "cycle"].each do |method|
-      assert_equal(method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new))
+      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal(method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new))
+      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
-      assert_equal(method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new))
+      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal(method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new))
+      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
     end
   end
 
   def test_some_enumerable_methods_still_get_invoked
-    [:count, :max].each do |method|
+    [ :count, :max ].each do |method|
-      assert_equal("3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new))
+      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal("3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new))
+      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal("3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new))
+      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal("3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new))
+      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
     end
 
-    assert_equal("yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new))
+    assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new)
 
-    [:min, :first].each do |method|
+    [ :min, :first ].each do |method|
-      assert_equal("1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new))
+      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal("1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new))
+      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal("1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new))
+      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal("1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new))
+      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
     end
   end
 
   def test_empty_string_value_access
-    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => ''))
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => '')
   end
 
   def test_nil_value_access
-    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil))
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil)
   end
 
   def test_default_to_s_on_drops
-    assert_equal('ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new))
+    assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new)
-    assert_equal('EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new))
+    assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new)
-  end
-
-  def test_invokable_methods
-    assert_equal(%w(to_liquid catchall context texts).to_set, ProductDrop.invokable_methods)
-    assert_equal(%w(to_liquid scopes_as_array loop_pos scopes).to_set, ContextDrop.invokable_methods)
-    assert_equal(%w(to_liquid size max min first count).to_set, EnumerableDrop.invokable_methods)
-    assert_equal(%w(to_liquid max min sort count first).to_set, RealEnumerableDrop.invokable_methods)
   end
 end # DropsTest

test/integration/error_handling_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class ErrorHandlingTest < Minitest::Test
@@ -35,31 +33,31 @@ class ErrorHandlingTest < Minitest::Test
     TEXT
 
     output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
-    assert_equal(expected, output)
+    assert_equal expected, output
   end
 
   def test_standard_error
     template = Liquid::Template.parse(' {{ errors.standard_error }} ')
-    assert_equal(' Liquid error: standard error ', template.render('errors' => ErrorDrop.new))
+    assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
 
-    assert_equal(1, template.errors.size)
+    assert_equal 1, template.errors.size
-    assert_equal(StandardError, template.errors.first.class)
+    assert_equal StandardError, template.errors.first.class
   end
 
   def test_syntax
     template = Liquid::Template.parse(' {{ errors.syntax_error }} ')
-    assert_equal(' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new))
+    assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
 
-    assert_equal(1, template.errors.size)
+    assert_equal 1, template.errors.size
-    assert_equal(SyntaxError, template.errors.first.class)
+    assert_equal SyntaxError, template.errors.first.class
   end
 
   def test_argument
     template = Liquid::Template.parse(' {{ errors.argument_error }} ')
-    assert_equal(' Liquid error: argument error ', template.render('errors' => ErrorDrop.new))
+    assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
 
-    assert_equal(1, template.errors.size)
+    assert_equal 1, template.errors.size
-    assert_equal(ArgumentError, template.errors.first.class)
+    assert_equal ArgumentError, template.errors.first.class
   end
 
   def test_missing_endtag_parse_time_error
@@ -78,39 +76,25 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_lax_unrecognized_operator
     template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
-    assert_equal(' Liquid error: Unknown operator =! ', template.render)
+    assert_equal ' Liquid error: Unknown operator =! ', template.render
-    assert_equal(1, template.errors.size)
+    assert_equal 1, template.errors.size
-    assert_equal(Liquid::ArgumentError, template.errors.first.class)
+    assert_equal Liquid::ArgumentError, template.errors.first.class
   end
 
   def test_with_line_numbers_adds_numbers_to_parser_errors
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
+      Liquid::Template.parse(%q(
           foobar
 
           {% "cat" | foobar %}
 
           bla
-        ',
+        ),
-        line_numbers: true)
+        line_numbers: true
+      )
     end
 
-    assert_match(/Liquid syntax error \(line 4\)/, err.message)
+    assert_match /Liquid syntax error \(line 4\)/, err.message
-  end
-
-  def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
-          foobar
-
-          {%- "cat" | foobar -%}
-
-          bla
-        ',
-        line_numbers: true)
-    end
-
-    assert_match(/Liquid syntax error \(line 4\)/, err.message)
   end
 
   def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
@@ -122,10 +106,11 @@ class ErrorHandlingTest < Minitest::Test
         bla
             ',
       error_mode: :warn,
-      line_numbers: true)
+      line_numbers: true
+                                     )
 
-    assert_equal(['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
+    assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
-      template.warnings.map(&:message))
+      template.warnings.map(&:message)
   end
 
   def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
@@ -138,10 +123,11 @@ class ErrorHandlingTest < Minitest::Test
           bla
                 ',
         error_mode: :strict,
-        line_numbers: true)
+        line_numbers: true
+                            )
     end
 
-    assert_equal('Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message)
+    assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
   end
 
   def test_syntax_errors_in_nested_blocks_have_correct_line_number
@@ -155,94 +141,71 @@ class ErrorHandlingTest < Minitest::Test
 
           bla
                 ',
-        line_numbers: true)
+        line_numbers: true
+                            )
     end
 
-    assert_equal("Liquid syntax error (line 5): Unknown tag 'foo'", err.message)
+    assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
   end
 
   def test_strict_error_messages
     err = assert_raises(SyntaxError) do
       Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
     end
-    assert_equal('Liquid syntax error: Unexpected character = in "1 =! 2"', err.message)
+    assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
 
     err = assert_raises(SyntaxError) do
       Liquid::Template.parse('{{%%%}}', error_mode: :strict)
     end
-    assert_equal('Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message)
+    assert_equal 'Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message
   end
 
   def test_warnings
     template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
-    assert_equal(3, template.warnings.size)
+    assert_equal 3, template.warnings.size
-    assert_equal('Unexpected character ~ in "~~~"', template.warnings[0].to_s(false))
+    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
-    assert_equal('Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false))
+    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
-    assert_equal('Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false))
+    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
-    assert_equal('', template.render)
+    assert_equal '', template.render
   end
 
   def test_warning_line_numbers
     template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
-    assert_equal('Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message)
+    assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
-    assert_equal('Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message)
+    assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
-    assert_equal('Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message)
+    assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
-    assert_equal(3, template.warnings.size)
+    assert_equal 3, template.warnings.size
-    assert_equal([1, 2, 3], template.warnings.map(&:line_number))
+    assert_equal [1, 2, 3], template.warnings.map(&:line_number)
   end
 
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
   def test_exceptions_propagate
-    assert_raises(Exception) do
+    assert_raises Exception do
       template = Liquid::Template.parse('{{ errors.exception }}')
       template.render('errors' => ErrorDrop.new)
     end
   end
 
-  def test_default_exception_renderer_with_internal_error
+  def test_exception_handler_with_string_result
+    template = Liquid::Template.parse('This is an argument error: {{ errors.argument_error }}')
+    output = template.render({ 'errors' => ErrorDrop.new }, exception_handler: ->(e) { '' })
+    assert_equal 'This is an argument error: ', output
+    assert_equal [ArgumentError], template.errors.map(&:class)
+  end
+
+  class InternalError < Liquid::Error
+  end
+
+  def test_exception_handler_with_exception_result
     template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
-
+    handler = ->(e) { e.is_a?(Liquid::Error) ? e : InternalError.new('internal') }
-    output = template.render('errors' => ErrorDrop.new)
+    output = template.render({ 'errors' => ErrorDrop.new }, exception_handler: handler)
-
+    assert_equal 'This is a runtime error: Liquid error (line 1): internal', output
-    assert_equal('This is a runtime error: Liquid error (line 1): internal', output)
+    assert_equal [InternalError], template.errors.map(&:class)
-    assert_equal([Liquid::InternalError], template.errors.map(&:class))
-  end
-
-  def test_setting_default_exception_renderer
-    old_exception_renderer = Liquid::Template.default_exception_renderer
-    exceptions = []
-    Liquid::Template.default_exception_renderer = ->(e) {
-      exceptions << e
-      ''
-    }
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}')
-
-    output = template.render('errors' => ErrorDrop.new)
-
-    assert_equal('This is a runtime error: ', output)
-    assert_equal([Liquid::ArgumentError], template.errors.map(&:class))
-  ensure
-    Liquid::Template.default_exception_renderer = old_exception_renderer if old_exception_renderer
-  end
-
-  def test_exception_renderer_exposing_non_liquid_error
-    template   = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
-    exceptions = []
-    handler    = ->(e) {
-      exceptions << e
-      e.cause
-    }
-
-    output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler)
-
-    assert_equal('This is a runtime error: runtime error', output)
-    assert_equal([Liquid::InternalError], exceptions.map(&:class))
-    assert_equal(exceptions, template.errors)
-    assert_equal('#<RuntimeError: runtime error>', exceptions.first.cause.inspect)
   end
 
   class TestFileSystem
-    def read_template_file(_template_path)
+    def read_template_file(template_path)
       "{{ errors.argument_error }}"
     end
   end
@@ -252,21 +215,12 @@ class ErrorHandlingTest < Minitest::Test
 
     begin
       Liquid::Template.file_system = TestFileSystem.new
-
       template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true)
-      page     = template.render('errors' => ErrorDrop.new)
+      page = template.render('errors' => ErrorDrop.new)
     ensure
       Liquid::Template.file_system = old_file_system
     end
-    assert_equal("Argument error:\nLiquid error (product line 1): argument error", page)
+    assert_equal "Argument error:\nLiquid error (product line 1): argument error", page
-    assert_equal("product", template.errors.first.template_name)
+    assert_equal "product", template.errors.first.template_name
-  end
-
-  def test_bug_compatible_silencing_of_errors_in_blank_nodes
-    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}not blank{% assign x = 3 %}{% endif %}{{ x }}").render
-    assert_equal("Liquid error: comparison of Integer with String failed0", output)
-
-    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}{% assign x = 3 %}{% endif %}{{ x }}").render
-    assert_equal("0", output)
   end
 end