Use tokenizer-quoted-strings liquid-c branch.

Allow variable and tag end characters to be quoted.
2026-01-02 08:15:41 +03:00 · 2015-07-13 22:03:16 -04:00 · 2015-07-13 13:19:56 -04:00
130 changed files with 1888 additions and 5396 deletions
--- a/.github/probots.yml
+++ b/.github/probots.yml
@@ -1,2 +0,0 @@
-enabled:
-  - cla
--- a/.gitignore
+++ b/.gitignore
@@ -4,8 +4,6 @@
 pkg
 *.rbc
 .rvmrc
-.idea
 .ruby-version
 Gemfile.lock
 .bundle
-.byebug_history
--- a/.rubocop.shopify.yml
+++ b/.rubocop.shopify.yml
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,10 +1,123 @@
-inherit_from:
-  - .rubocop.shopify.yml
+inherit_from: ./.rubocop_todo.yml

-require: rubocop-performance
+AllCops:
+  Exclude:
+    - 'performance/shopify/*'
+    - 'pkg/**'

-Performance:
-  Enabled: true
+Metrics/BlockNesting:
+  Max: 3
+  Exclude:
+    - '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/WordArray:
+  Enabled: false

-Metrics/LineLength:
-  Enabled: false
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -0,0 +1,72 @@
+# This configuration was generated by `rubocop --auto-gen-config`
+# on 2015-06-08 18:16:16 +0000 using RuboCop version 0.32.0.
+# 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: 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.
+Style/ClosingParenthesisIndentation:
+  Enabled: false
+
+# Offense count: 3
+# Configuration parameters: MinBodyLength.
+Style/GuardClause:
+  Enabled: false
+
+# Offense count: 4
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+Style/MethodName:
+  Enabled: false
+
+# Offense count: 1
+Style/MultilineBlockChain:
+  Enabled: false
+
+# Offense count: 2
+# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
+Style/Next:
+  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
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,30 +1,20 @@
 language: ruby

 rvm:
-  - 2.4
-  - 2.5
-  - 2.6
-  - 2.7
+  - 2.0
+  - 2.1
+  - 2.2
  - ruby-head
  - jruby-head
-  - truffleruby
+#  - rbx-2

 sudo: false

-addons:
-  apt:
-    packages:
-    - libgmp3-dev
-
 matrix:
  allow_failures:
-    - rvm: ruby-head
    - rvm: jruby-head

-install:
-  - bundle install
-
-script: bundle exec rake
+script: "bundle exec rake"

 notifications:
  disable: true
--- a/CONTRIBUTING.md
+++ b/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 that 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 that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
-* Code that does not include tests
-* Code that breaks existing tests
+* Code which introduces considerable performance degrations
+* Code which touches performance critical parts of Liquid and comes without benchmarks
+* Features which are not important for most people (we want to keep the core Liquid code small and tidy)
+* Features which can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
+* Code which comes without 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
-* Make sure all tests pass (`bundle exec rake`)
+* If it makes sense, add tests for your code and run a performance benchmark
+* 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.

--- a/24
+++ b/24
@@ -1,26 +1,14 @@
-# frozen_string_literal: true
-
 source 'https://rubygems.org'
-git_source(:github) do |repo_name|
-  "https://github.com/#{repo_name}.git"
-end

 gemspec
-
-group :benchmark, :test do
-  gem 'benchmark-ips'
-  gem 'memory_profiler'
-
-  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
-    gem 'stackprof'
-  end
-end
+gem 'stackprof', platforms: :mri_21

 group :test do
-  gem 'rubocop', '~> 0.74.0', require: false
-  gem 'rubocop-performance', require: false
+  gem 'spy', '0.4.1'
+  gem 'benchmark-ips'
+  gem 'rubocop', '>=0.32.0'

-  platform :mri, :truffleruby do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: '7ba926791ef8411984d0f3e41c6353fd716041c6'
+  platform :mri do
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: '11d38237d9f491588a58c83dc3d364a7d0d1d55b'
  end
 end
--- a/History.md
+++ b/History.md
@@ -1,69 +1,8 @@
 # Liquid Change Log

-## 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
+## 4.0.0 / not yet released / branch "master"

 ### 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]
-* Add global_filter to apply a filter to all output (#610) [Loren Hale]
 * Add compact filter (#600) [Carson Reinke]
 * Rename deprecated "has_key?" and "has_interrupt?" methods (#593) [Florian Weingarten]
 * Include template name with line numbers in render errors (574) [Dylan Thacker-Smith]
@@ -73,18 +12,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)
-* Liquid::Template.register_filter raises when the module overrides registered public methods as private or protected (#705) [Gaurav Chande]
+* Remove support for `liquid_methods`

 ### Fixed
-
-* Fix variable names being detected as an operator when starting with contains (#788) [Michael Angell]
-* Fix include tag used with strict_variables (#828) [QuickPay]
-* Fix map filter when value is a Proc (#672) [Guillaume Malette]
-* Fix truncate filter when value is not a string (#672) [Guillaume Malette]
-* Fix behaviour of escape filter when input is nil (#665) [Tanel Jakobsoo]
-* Fix sort filter behaviour with empty array input (#652) [Marcel Cary]
-* Fix test failure under certain timezones (#631) [Dylan Thacker-Smith]
 * Fix bug in uniq filter (#595) [Florian Weingarten]
 * Fix bug when "blank" and "empty" are used as variable names (#592) [Florian Weingarten]
 * Fix condition parse order in strict mode (#569) [Justin Li]
@@ -96,15 +26,7 @@
 * Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li]
 * Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li]

-## 3.0.5 / 2015-07-23 / branch "3-0-stable"
-
-* Fix test failure under certain timezones [Dylan Thacker-Smith]
-
-## 3.0.4 / 2015-07-17
-
-* Fix chained access to multi-dimensional hashes [Florian Weingarten]
-
-## 3.0.3 / 2015-05-28
+## 3.0.3 / 2015-05-28 / branch "3-0-stable"

 * Fix condition parse order in strict mode (#569) [Justin Li]

@@ -152,15 +74,7 @@
 * Make map filter work on enumerable drops (#233) [Florian Weingarten]
 * Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten]

-## 2.6.3 / 2015-07-23 / branch "2-6-stable"
-
-* Fix test failure under certain timezones [Dylan Thacker-Smith]
-
-## 2.6.2 / 2015-01-23
-
-* Remove duplicate hash key [Parker Moore]
-
-## 2.6.1 / 2014-01-10
+## 2.6.1 / 2014-01-10 / branch "2-6-stable"

 Security fix, cherry-picked from master (4e14a65):
 * Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
@@ -274,7 +188,7 @@ Yanked from rubygems, as it contained too many changes that broke compatibility.
 * Fixed bad error reporting when a filter called a method which doesn't exist. Liquid told you that it couldn't find the filter which was obviously misleading [Tobias Luetke]
 * Removed count helper from standard lib. use size [Tobias Luetke]
 * Fixed bug with string filter parameters failing to tolerate commas in strings. [Paul Hammond]
-* Improved filter parameters. Filter parameters are now context sensitive; Types are resolved according to the rules of the context. Multiple parameters are now separated by the Liquid::ARGUMENT_SEPARATOR: , by default [Paul Hammond]
+* Improved filter parameters. Filter parameters are now context sensitive; Types are resolved according to the rules of the context. Multiple parameters are now separated by the Liquid::ArgumentSeparator: , by default [Paul Hammond]
    {{ 'Typo' | link_to: 'http://typo.leetsoft.com', 'Typo - a modern weblog engine' }}
 * Added Liquid::Drop. A base class which you can use for exporting proxy objects to liquid which can acquire more data when used in liquid. [Tobias Luetke]

--- a/0
+++ b/0
--- a/README.md
+++ b/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,34 +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
-```
--- a/58
+++ b/58
@@ -1,33 +1,29 @@
-# frozen_string_literal: true
-
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
-require 'liquid/version'
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "liquid/version"

-task(default: %i[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.test_files = FileList['test/{integration,unit}/**/*_test.rb']
  t.verbose = false
 end

-desc('run test suite with warn error mode')
+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'
-    RuboCop::RakeTask.new
-  end
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
 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
@@ -36,9 +32,8 @@ task :test do
  Rake::Task['base_test'].reenable
  Rake::Task['base_test'].invoke

-  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
-
-    ENV['LIQUID_C'] = '1'
+  if RUBY_ENGINE == 'ruby'
+    ENV['LIQUID-C'] = '1'

    ENV['LIQUID_PARSER_MODE'] = 'lax'
    Rake::Task['base_test'].reenable
@@ -50,9 +45,9 @@ task :test do
  end
 end

-task(gem: :build)
+task gem: :build
 task :build do
-  system 'gem build liquid.gemspec'
+  system "gem build liquid.gemspec"
 end

 task install: :build do
@@ -61,45 +56,38 @@ end

 task release: :build do
  system "git tag -a v#{Liquid::VERSION} -m 'Tagging #{Liquid::VERSION}'"
-  system 'git push --tags'
+  system "git push --tags"
  system "gem push liquid-#{Liquid::VERSION}.gem"
  system "rm liquid-#{Liquid::VERSION}.gem"
 end

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

-  desc 'Run the liquid benchmark with strict parsing'
+  desc "Run the liquid benchmark with strict parsing"
  task :strict do
-    ruby './performance/benchmark.rb strict'
+    ruby "./performance/benchmark.rb strict"
  end
 end

 namespace :profile do
-  desc 'Run the liquid profile/performance coverage'
+  desc "Run the liquid profile/performance coverage"
  task :run do
-    ruby './performance/profile.rb'
+    ruby "./performance/profile.rb"
  end

-  desc 'Run the liquid profile/performance coverage with strict parsing'
+  desc "Run the liquid profile/performance coverage with strict parsing"
  task :strict do
-    ruby './performance/profile.rb strict'
+    ruby "./performance/profile.rb strict"
  end
 end

-namespace :memory_profile do
-  desc 'Run memory profiler'
-  task :run do
-    ruby './performance/memory_profile.rb'
-  end
-end
-
-desc('Run example')
+desc "Run example"
 task :example do
-  ruby '-w -d -Ilib example/server/server.rb'
+  ruby "-w -d -Ilib example/server/server.rb"
 end

 task :console do
--- a/circle.yml
+++ b/circle.yml
@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: ruby-2.0
--- a/example/server/example_servlet.rb
+++ b/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)
@@ -30,17 +28,17 @@ class Servlet < LiquidServlet
  private

  def products_list
-    [{ 'name' => 'Arbor Draft', 'price' => 39_900, 'description' => 'the *arbor draft* is a excellent product' },
-     { 'name' => 'Arbor Element', 'price' => 40_000, 'description' => 'the *arbor element* rocks for freestyling' },
-     { 'name' => 'Arbor Diamond', 'price' => 59_900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }]
+    [{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
+     { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
+     { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }]
  end

  def more_products_list
-    [{ 'name' => 'Arbor Catalyst', 'price' => 39_900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-     { 'name' => 'Arbor Fish', 'price' => 40_000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
+    [{ 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
+     { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
  end

  def description
-    'List of Products ~ This is a list of products with price and description.'
+    "List of Products ~ This is a list of products with price and description."
  end
 end
--- a/example/server/liquid_servlet.rb
+++ b/example/server/liquid_servlet.rb
@@ -1,28 +1,23 @@
-# frozen_string_literal: true
-
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
-  def get(req, res)
+  def do_GET(req, res)
    handle(:get, req, res)
  end

-  def post(req, res)
+  def do_POST(req, res)
    handle(:post, req, res)
  end

-  alias_method :do_GET, :get
-  alias_method :do_POST, :post
-
  private

-  def handle(_type, req, res)
+  def handle(type, req, res)
    @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['Content-Type'] = "text/html"
    @response.status = 200
    @response.body = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
  end
--- a/example/server/server.rb
+++ b/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
--- a/lib/liquid.rb
+++ b/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
@@ -22,38 +20,35 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 module Liquid
-  FILTER_SEPARATOR = /\|/.freeze
-  ARGUMENT_SEPARATOR = ','
-  FILTER_ARGUMENT_SEPARATOR = ':'
-  VARIABLE_ATTRIBUTE_SEPARATOR = '.'
-  WHITESPACE_CONTROL = '-'
-  TAG_START = /\{\%/.freeze
-  TAG_END = /\%\}/.freeze
-  VARIABLE_SIGNATURE = /\(?[\w\-\.\[\]]\)?/.freeze
-  VARIABLE_SEGMENT = /[\w\-]/.freeze
-  VARIABLE_START = /\{\{/.freeze
-  VARIABLE_END = /\}\}/.freeze
-  VARIABLE_INCOMPLETE_END = /\}\}?/.freeze
-  QUOTED_STRING = /"[^"]*"|'[^']*'/.freeze
-  QUOTED_FRAGMENT = /#{QUOTED_STRING}|(?:[^\s,\|'"]|#{QUOTED_STRING})+/o.freeze
-  TAG_ATTRIBUTES = /(\w+)\s*\:\s*(#{QUOTED_FRAGMENT})/o.freeze
-  ANY_STARTING_TAG = /#{TAG_START}|#{VARIABLE_START}/o.freeze
-  PARTIAL_TEMPLATE_PARSER = /#{TAG_START}.*?#{TAG_END}|#{VARIABLE_START}.*?#{VARIABLE_INCOMPLETE_END}/om.freeze
-  TEMPLATE_PARSER = /(#{PARTIAL_TEMPLATE_PARSER}|#{ANY_STARTING_TAG})/om.freeze
-  VARIABLE_PARSER = /\[[^\]]+\]|#{VARIABLE_SEGMENT}+\??/o.freeze
+  FilterSeparator             = /\|/
+  ArgumentSeparator           = ','.freeze
+  FilterArgumentSeparator     = ':'.freeze
+  VariableAttributeSeparator  = '.'.freeze
+  TagStart                    = /\{\%/
+  TagEnd                      = /\%\}/
+  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
+  VariableSegment             = /[\w\-]/
+  VariableStart               = /\{\{/
+  VariableEnd                 = /\}\}/
+  VariableIncompleteEnd       = /\}\}?/
+  QuotedString                = /"[^"]*"|'[^']*'/
+  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
+  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
+  AnyStartingTag              = /\{\{|\{\%/
+  tag_contents                = /(?:#{QuotedString}|.)*?/m
+  PartialTemplateParser       = /#{TagStart}#{tag_contents}#{TagEnd}|#{VariableStart}#{tag_contents}#{VariableIncompleteEnd}/om
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o

  singleton_class.send(:attr_accessor, :cache_classes)
  self.cache_classes = true
 end

-require 'liquid/version'
-require 'liquid/parse_tree_visitor'
+require "liquid/version"
 require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
 require 'liquid/drop'
-require 'liquid/tablerowloop_drop'
-require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
--- a/lib/liquid/block.rb
+++ b/lib/liquid/block.rb
@@ -1,9 +1,5 @@
-# frozen_string_literal: true
-
 module Liquid
  class Block < Tag
-    MAX_DEPTH = 100
-
    def initialize(tag_name, markup, options)
      super
      @blank = true
@@ -15,7 +11,6 @@ module Liquid
      end
    end

-    # For backwards compatibility
    def render(context)
      @body.render(context)
    end
@@ -29,16 +24,16 @@ module Liquid
    end

    def unknown_tag(tag, _params, _tokens)
-      if tag == 'else'
-        raise SyntaxError, parse_context.locale.t('errors.syntax.unexpected_else',
-                                                  block_name: block_name)
-      elsif tag.start_with?('end')
-        raise SyntaxError, parse_context.locale.t('errors.syntax.invalid_delimiter',
-                                                  tag: tag,
-                                                  block_name: block_name,
-                                                  block_delimiter: block_delimiter)
+      case tag
+      when 'else'.freeze
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_else".freeze,
+          block_name: block_name))
+      when 'end'.freeze
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
+          block_name: block_name,
+          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

@@ -53,22 +48,17 @@ module Liquid
    protected

    def parse_body(body, tokens)
-      raise StackLevelError, 'Nesting too deep' if parse_context.depth >= MAX_DEPTH
+      body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
+        @blank &&= body.blank?

-      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
-          raise SyntaxError, parse_context.locale.t('errors.syntax.tag_never_closed', block_name: block_name) unless end_tag_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)
+        return false if end_tag_name == block_delimiter
+        unless end_tag_name
+          raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
        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
--- a/lib/liquid/block_body.rb
+++ b/lib/liquid/block_body.rb
@@ -1,12 +1,9 @@
-# frozen_string_literal: true
-
 module Liquid
  class BlockBody
-    FULL_TOKEN = /\A#{TAG_START}#{WHITESPACE_CONTROL}?\s*(\w+)\s*(.*?)#{WHITESPACE_CONTROL}?#{TAG_END}\z/om.freeze
-    CONTENT_OF_VARIABLE = /\A#{VARIABLE_START}#{WHITESPACE_CONTROL}?(.*?)#{WHITESPACE_CONTROL}?#{VARIABLE_END}\z/om.freeze
-    WHITESPACE_OR_NOTHING = /\A\s*\z/.freeze
-    TAG_START = '{%'
-    VAR_START = '{{'
+    FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
+    TAGSTART = "{%".freeze
+    VARSTART = "{{".freeze

    attr_reader :nodelist

@@ -17,34 +14,33 @@ module Liquid

    def parse(tokenizer, parse_context)
      parse_context.line_number = tokenizer.line_number
-      while (token = tokenizer.shift)
-        next if token.empty?
-
-        case
-        when token.start_with?(TAG_START)
-          whitespace_handler(token, parse_context)
-          raise_missing_tag_terminator(token, parse_context) unless token =~ FULL_TOKEN
-          tag_name = Regexp.last_match(1)
-          markup = Regexp.last_match(2)
-          # fetch the tag from registered blocks
-          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
+      while token = tokenizer.shift
+        unless token.empty?
+          case
+          when token.start_with?(TAGSTART)
+            if token =~ FullToken
+              tag_name = $1
+              markup = $2
+              # fetch the tag from registered blocks
+              if tag = registered_tags[tag_name]
+                new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
+                @blank &&= new_tag.blank?
+                @nodelist << new_tag
+              else
+                # end parsing if we reach an unknown tag and let the caller decide
+                # determine how to proceed
+                return yield tag_name, markup
+              end
+            else
+              raise_missing_tag_terminator(token, parse_context)
+            end
+          when token.start_with?(VARSTART)
+            @nodelist << create_variable(token, parse_context)
+            @blank = false
+          else
+            @nodelist << token
+            @blank &&= !!(token =~ /\A\s*\z/)
          end
-
-          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-          @blank &&= new_tag.blank?
-          @nodelist << new_tag
-        when token.start_with?(VAR_START)
-          whitespace_handler(token, parse_context)
-          @nodelist << create_variable(token, parse_context)
-          @blank = false
-        else
-          token.lstrip! if parse_context.trim_whitespace
-          parse_context.trim_whitespace = false
-          @nodelist << token
-          @blank &&= token.match?(WHITESPACE_OR_NOTHING)
        end
        parse_context.line_number = tokenizer.line_number
      end
@@ -52,75 +48,57 @@ module Liquid
      yield nil, nil
    end

-    def whitespace_handler(token, parse_context)
-      if token[2] == WHITESPACE_CONTROL
-        previous_token = @nodelist.last
-        previous_token.rstrip! if previous_token.is_a?(String)
-      end
-      parse_context.trim_whitespace = (token[-3] == WHITESPACE_CONTROL)
-    end
-
    def blank?
      @blank
    end

    def render(context)
-      render_to_output_buffer(context, +'')
-    end
-
-    def render_to_output_buffer(context, output)
+      output = []
      context.resource_limits.render_score += @nodelist.length

-      idx = 0
-      while (node = @nodelist[idx])
-        previous_output_size = output.bytesize
+      @nodelist.each do |token|
+        # Break out if we have any unhanded interrupts.
+        break if context.interrupt?

-        case node
-        when String
-          output << node
-        when Variable
-          render_node(context, output, node)
-        when Block
-          render_node(context, node.blank? ? +'' : output, node)
-          break if context.interrupt? # might have happened in a for-block
-        when Continue, Break
+        begin
          # 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 %}
-          context.push_interrupt(node.interrupt)
-          break
-        else # Other non-Block tags
-          render_node(context, output, node)
-          break if context.interrupt? # might have happened through an include
-        end
-        idx += 1
+          if token.is_a?(Continue) || token.is_a?(Break)
+            context.push_interrupt(token.interrupt)
+            break
+          end

-        raise_if_resource_limits_reached(context, output.bytesize - previous_output_size)
+          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)
-      node.render_to_output_buffer(context, output)
-    rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
-      context.handle_error(e, node.line_number)
-    rescue ::StandardError => e
-      line_number = node.is_a?(String) ? nil : node.line_number
-      output << context.handle_error(e, line_number)
-    end
+    def render_node(node, context)
+      node_output = (node.respond_to?(:render) ? node.render(context) : node)
+      node_output = node_output.is_a?(Array) ? node_output.join : node_output.to_s

-    def raise_if_resource_limits_reached(context, length)
-      context.resource_limits.render_length += length
-      return unless context.resource_limits.reached?
-
-      raise MemoryError, 'Memory limits exceeded'
+      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)
-      token.scan(CONTENT_OF_VARIABLE) do |content|
+      token.scan(ContentOfVariable) do |content|
        markup = content.first
        return Variable.new(markup, parse_context)
      end
@@ -128,11 +106,11 @@ module Liquid
    end

    def raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t('errors.syntax.tag_termination', token: token, tag_end: TAG_END.inspect)
+      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_termination".freeze, token: token, tag_end: TagEnd.inspect))
    end

    def raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t('errors.syntax.variable_termination', token: token, tag_end: VARIABLE_END.inspect)
+      raise SyntaxError.new(parse_context.locale.t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect))
    end

    def registered_tags
--- a/lib/liquid/condition.rb
+++ b/lib/liquid/condition.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Container for liquid nodes which conveniently wraps decision making logic
  #
@@ -9,56 +7,50 @@ module Liquid
  #   c.evaluate #=> true
  #
  class Condition #:nodoc:
-    @operators = {
-      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
-      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<' => :<,
-      '>' => :>,
-      '>=' => :>=,
-      '<=' => :<=,
-      'contains' => lambda do |_cond, left, right|
+    @@operators = {
+      '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<'.freeze  => :<,
+      '>'.freeze  => :>,
+      '>='.freeze => :>=,
+      '<='.freeze => :<=,
+      '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,
+      end
    }

-    class << self
-      attr_accessor :operators
+    def self.operators
+      @@operators
    end

-    attr_reader :attachment, :child_condition
+    attr_reader :attachment
    attr_accessor :left, :operator, :right

    def initialize(left = nil, operator = nil, right = nil)
      @left = left
      @operator = operator
      @right = right
-      @child_relation = nil
+      @child_relation  = nil
      @child_condition = nil
    end

    def evaluate(context = Context.new)
-      condition = self
-      result = nil
-      loop do
-        result = interpret_condition(condition.left, condition.right, condition.operator, context)
+      result = interpret_condition(left, right, operator, context)

-        case condition.child_relation
-        when :or
-          break if result
-        when :and
-          break unless result
-        else
-          break
-        end
-        condition = condition.child_condition
+      case @child_relation
+      when :or
+        result || @child_condition.evaluate(context)
+      when :and
+        result && @child_condition.evaluate(context)
+      else
+        result
      end
-      result
    end

    def or(condition)
@@ -80,13 +72,9 @@ 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)
@@ -118,27 +106,18 @@ module Liquid
      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
--- a/lib/liquid/context.rb
+++ b/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
  #
@@ -15,7 +13,7 @@ module Liquid
  #   context['bob']  #=> nil  class Context
  class Context
    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

    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
      @environments     = [environments].flatten
@@ -23,18 +21,17 @@ module Liquid
      @registers        = registers
      @errors           = []
      @partial          = false
-      @strict_variables = false
      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
      squash_instance_assigns_with_environments

      @this_stack_used = false

-      self.exception_renderer = Template.default_exception_renderer
-      self.exception_renderer = ->(_e) { raise } if rethrow_errors
+      if rethrow_errors
+        self.exception_handler = ->(e) { raise }
+      end

      @interrupts = []
      @filters = []
-      @global_filter = nil
    end

    def warnings
@@ -55,10 +52,6 @@ module Liquid
      @strainer = nil
    end

-    def apply_global_filter(obj)
-      global_filter.nil? ? obj : global_filter.call(obj)
-    end
-
    # are there any not handled interrupts?
    def interrupt?
      !@interrupts.empty?
@@ -75,11 +68,30 @@ module Liquid
    end

    def handle_error(e, line_number = nil)
-      e = internal_error unless e.is_a?(Liquid::Error)
-      e.template_name ||= template_name
-      e.line_number ||= line_number
+      if e.is_a?(Liquid::Error)
+        e.template_name ||= template_name
+        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)
@@ -89,7 +101,7 @@ module Liquid
    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
    def push(new_scope = {})
      @scopes.unshift(new_scope)
-      raise StackLevelError, 'Nesting too deep' if @scopes.length > Block::MAX_DEPTH
+      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
    end

    # Merge a hash of variables in the current local scope
@@ -100,7 +112,6 @@ module Liquid
    # Pop from the stack. use <tt>Context#stack</tt> instead
    def pop
      raise ContextError if @scopes.size == 1
-
      @scopes.shift
    end

@@ -161,7 +172,7 @@ 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) }
@@ -171,10 +182,8 @@ module Liquid

      if scope.nil?
        @environments.each do |e|
-          variable = lookup_and_evaluate(e, key, raise_on_not_found: raise_on_not_found)
-          # When lookup returned a value OR there is no value but the lookup also did not raise
-          # then it is the value we are looking for.
-          if !variable.nil? || @strict_variables && raise_on_not_found
+          variable = lookup_and_evaluate(e, key)
+          unless variable.nil?
            scope = e
            break
          end
@@ -182,7 +191,7 @@ module Liquid
      end

      scope ||= @environments.last || @scopes.last
-      variable ||= lookup_and_evaluate(scope, key, raise_on_not_found: raise_on_not_found)
+      variable ||= lookup_and_evaluate(scope, key)

      variable = variable.to_liquid
      variable.context = self if variable.respond_to?(:context=)
@@ -190,13 +199,9 @@ module Liquid
      variable
    end

-    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
-      raise Liquid::UndefinedVariable, "undefined variable #{key}" if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
-
-      value = obj[key]
-
-      if value.is_a?(Proc) && obj.respond_to?(:[]=)
-        obj[key] = value.arity == 0 ? value.call : value.call(self)
+    def lookup_and_evaluate(obj, key)
+      if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
+        obj[key] = (value.arity == 0) ? value.call : value.call(self)
      else
        value
      end
@@ -204,13 +209,6 @@ module Liquid

    private

-    def internal_error
-      # raise and catch to set backtrace and cause on exception
-      raise Liquid::InternalError, 'internal'
-    rescue Liquid::InternalError => e
-      e
-    end
-
    def squash_instance_assigns_with_environments
      @scopes.last.each_key do |k|
        @environments.each do |env|
--- a/lib/liquid/document.rb
+++ b/lib/liquid/document.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class Document < BlockBody
    def self.parse(tokens, parse_context)
@@ -9,7 +7,7 @@ module Liquid
    end

    def parse(tokens, parse_context)
-      super do |end_tag_name, _end_tag_params|
+      super do |end_tag_name, end_tag_params|
        unknown_tag(end_tag_name, parse_context) if end_tag_name
      end
    rescue SyntaxError => e
@@ -19,10 +17,10 @@ module Liquid

    def unknown_tag(tag, parse_context)
      case tag
-      when 'else', 'end'
-        raise SyntaxError, parse_context.locale.t('errors.syntax.unexpected_outer_tag', tag: tag)
+      when 'else'.freeze, 'end'.freeze
+        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
  end
--- a/lib/liquid/drop.rb
+++ b/lib/liquid/drop.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'set'

 module Liquid
@@ -20,24 +18,24 @@ module Liquid
  #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
  #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
  #
-  # Your drop can either implement the methods sans any parameters
-  # or implement the liquid_method_missing(name) method which is a catch all.
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
+  # catch all.
  class Drop
    attr_writer :context

-    # Catch all for the method
-    def liquid_method_missing(method)
-      return nil unless @context&.strict_variables
+    EMPTY_STRING = ''.freeze

-      raise Liquid::UndefinedDropMethod, "undefined method #{method}"
+    # Catch all for the method
+    def before_method(_method)
+      nil
    end

    # called by liquid to invoke a drop
    def invoke_drop(method_or_key)
-      if self.class.invokable?(method_or_key)
+      if method_or_key && method_or_key != EMPTY_STRING && self.class.invokable?(method_or_key)
        send(method_or_key)
      else
-        liquid_method_missing(method_or_key)
+        before_method(method_or_key)
      end
    end

@@ -65,17 +63,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 -= %i[sort count first min max include?]
+          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
--- a/lib/liquid/errors.rb
+++ b/lib/liquid/errors.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class Error < ::StandardError
    attr_accessor :line_number
@@ -7,35 +5,43 @@ module Liquid
    attr_accessor :markup_context

    def to_s(with_prefix = true)
-      str = +''
+      str = ""
      str << message_prefix if with_prefix
      str << super()

      if markup_context
-        str << ' '
+        str << " "
        str << markup_context
      end

      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 << if is_a?(SyntaxError)
-        'Liquid syntax error'
+      str = ""
+      if is_a?(SyntaxError)
+        str << "Liquid syntax error"
      else
-        'Liquid error'
+        str << "Liquid error"
      end

      if line_number
-        str << ' ('
-        str << template_name << ' ' if template_name
-        str << 'line ' << line_number.to_s << ')'
+        str << " ("
+        str << template_name << " " if template_name
+        str << "line " << line_number.to_s << ")"
      end

-      str << ': '
+      str << ": "
      str
    end
  end
@@ -50,9 +56,4 @@ module Liquid
  MemoryError = Class.new(Error)
  ZeroDivisionError = Class.new(Error)
  FloatDomainError = Class.new(Error)
-  UndefinedVariable = Class.new(Error)
-  UndefinedDropMethod = Class.new(Error)
-  UndefinedFilter = Class.new(Error)
-  MethodOverrideError = Class.new(Error)
-  InternalError = Class.new(Error)
 end
--- a/lib/liquid/expression.rb
+++ b/lib/liquid/expression.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class Expression
    class MethodLiteral
@@ -16,32 +14,28 @@ module Liquid
    end

    LITERALS = {
-      nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
-      'true' => true,
-      'false' => false,
-      'blank' => MethodLiteral.new(:blank?, '').freeze,
-      'empty' => MethodLiteral.new(:empty?, '').freeze
-    }.freeze
-
-    SINGLE_QUOTED_STRING = /\A'(.*)'\z/m.freeze
-    DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m.freeze
-    INTEGERS_REGEX       = /\A(-?\d+)\z/.freeze
-    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/.freeze
-    RANGES_REGEX         = /\A\((\S+)\.\.(\S+)\)\z/.freeze
+      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
+      'true'.freeze  => true,
+      'false'.freeze => false,
+      'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
+      'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
+    }

    def self.parse(markup)
      if LITERALS.key?(markup)
        LITERALS[markup]
      else
        case markup
-        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
+        when /\A'(.*)'\z/m # Single quoted strings
+          $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
--- a/lib/liquid/extensions.rb
+++ b/lib/liquid/extensions.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'time'
 require 'date'

@@ -9,56 +7,44 @@ class String # :nodoc:
  end
 end

-class Symbol # :nodoc:
-  def to_liquid
-    to_s
-  end
-end
-
-class Array # :nodoc:
+class Array  # :nodoc:
  def to_liquid
    self
  end
 end

-class Hash # :nodoc:
+class Hash  # :nodoc:
  def to_liquid
    self
  end
 end

-class Numeric # :nodoc:
+class Numeric  # :nodoc:
  def to_liquid
    self
  end
 end

-class Range # :nodoc:
+class Time  # :nodoc:
  def to_liquid
    self
  end
 end

-class Time # :nodoc:
+class DateTime < Date  # :nodoc:
  def to_liquid
    self
  end
 end

-class DateTime < Date # :nodoc:
-  def to_liquid
-    self
-  end
-end
-
-class Date # :nodoc:
+class Date  # :nodoc:
  def to_liquid
    self
  end
 end

 class TrueClass
-  def to_liquid # :nodoc:
+  def to_liquid  # :nodoc:
    self
  end
 end
--- a/lib/liquid/file_system.rb
+++ b/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,14 +8,14 @@ module Liquid
  #
  # Example:
  #
-  #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
-  #   liquid = Liquid::Template.parse(template)
+  # Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+  # liquid = Liquid::Template.parse(template)
  #
  # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
  class BlankFileSystem
    # Called by Liquid to retrieve a template file
    def read_template_file(_template_path)
-      raise FileSystemError, 'This liquid context does not allow includes.'
+      raise FileSystemError, "This liquid context does not allow includes."
    end
  end

@@ -28,10 +26,10 @@ module Liquid
  #
  # Example:
  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path")
+  # file_system = Liquid::LocalFileSystem.new("/some/path")
  #
-  #   file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
-  #   file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
+  # file_system.full_path("mypartial")       # => "/some/path/_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,14 +37,14 @@ 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
      @pattern = pattern
    end
@@ -59,15 +57,15 @@ module Liquid
    end

    def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ %r{\A[^./][a-zA-Z0-9_/]+\z}
+      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
--- a/lib/liquid/forloop_drop.rb
+++ b/lib/liquid/forloop_drop.rb
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class ForloopDrop < Drop
-    def initialize(name, length, parentloop)
-      @name = name
-      @length = length
-      @parentloop = parentloop
-      @index = 0
-    end
-
-    attr_reader :name, :length, :parentloop
-
-    def index
-      @index + 1
-    end
-
-    def index0
-      @index
-    end
-
-    def rindex
-      @length - @index
-    end
-
-    def rindex0
-      @length - @index - 1
-    end
-
-    def first
-      @index == 0
-    end
-
-    def last
-      @index == @length - 1
-    end
-
-    protected
-
-    def increment!
-      @index += 1
-    end
-  end
-end
--- a/lib/liquid/i18n.rb
+++ b/lib/liquid/i18n.rb
@@ -1,10 +1,8 @@
-# frozen_string_literal: true
-
 require 'yaml'

 module Liquid
  class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), 'locales', 'en.yml')
+    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")

    TranslationError = Class.new(StandardError)

@@ -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|
-        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
+      name.split('.'.freeze).reduce(locale) do |level, cur|
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
      end
    end
  end
--- a/lib/liquid/interrupts.rb
+++ b/lib/liquid/interrupts.rb
@@ -1,18 +1,16 @@
-# 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

  # Interrupt that is thrown whenever a {% break %} is called.
-  class BreakInterrupt < RuntimeError; end
+  class BreakInterrupt < Interrupt; end

  # Interrupt that is thrown whenever a {% continue %} is called.
-  class ContinueInterrupt < RuntimeError; end
+  class ContinueInterrupt < Interrupt; end
 end
--- a/lib/liquid/legacy.rb
+++ b/lib/liquid/legacy.rb
@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  FilterSeparator = FILTER_SEPARATOR
-  ArgumentSeparator = ARGUMENT_SEPARATOR
-  FilterArgumentSeparator = FILTER_ARGUMENT_SEPARATOR
-  VariableAttributeSeparator = VARIABLE_ATTRIBUTE_SEPARATOR
-  WhitespaceControl = WHITESPACE_CONTROL
-  TagStart = TAG_START
-  TagEnd = TAG_END
-  VariableSignature = VARIABLE_SIGNATURE
-  VariableSegment = VARIABLE_SEGMENT
-  VariableStart = VARIABLE_START
-  VariableEnd = VARIABLE_END
-  VariableIncompleteEnd = VARIABLE_INCOMPLETE_END
-  QuotedString = QUOTED_STRING
-  QuotedFragment = QUOTED_FRAGMENT
-  TagAttributes = TAG_ATTRIBUTES
-  AnyStartingTag = ANY_STARTING_TAG
-  PartialTemplateParser = PARTIAL_TEMPLATE_PARSER
-  TemplateParser = TEMPLATE_PARSER
-  VariableParser = VARIABLE_PARSER
-
-  class BlockBody
-    FullToken = FULL_TOKEN
-    ContentOfVariable = CONTENT_OF_VARIABLE
-    WhitespaceOrNothing = WHITESPACE_OR_NOTHING
-    TAGSTART = TAG_START
-    VARSTART = VAR_START
-  end
-
-  class Assign < Tag
-    Syntax = SYNTAX
-  end
-
-  class Capture < Block
-    Syntax = SYNTAX
-  end
-
-  class Case < Block
-    Syntax     = SYNTAX
-    WhenSyntax = WHEN_SYNTAX
-  end
-
-  class Cycle < Tag
-    SimpleSyntax = SIMPLE_SYNTAX
-    NamedSyntax  = NAMED_SYNTAX
-  end
-
-  class For < Block
-    Syntax = SYNTAX
-  end
-
-  class If < Block
-    Syntax = SYNTAX
-    ExpressionsAndOperators = EXPRESSIONS_AND_OPERATORS
-  end
-
-  class Include < Tag
-    Syntax = SYNTAX
-  end
-
-  class Raw < Block
-    Syntax = SYNTAX
-    FullTokenPossiblyInvalid = FULL_TOKEN_POSSIBLY_INVALID
-  end
-
-  class TableRow < Block
-    Syntax = SYNTAX
-  end
-
-  class Variable
-    FilterMarkupRegex = FILTER_MARKUP_REGEX
-    FilterParser = FILTER_PARSER
-    FilterArgsRegex = FILTER_ARGS_REGEX
-    JustTagAttributes = JUST_TAG_ATTRIBUTES
-    MarkupWithQuotedFragment = MARKUP_WITH_QUOTED_FRAGMENT
-  end
-end
--- a/lib/liquid/lexer.rb
+++ b/lib/liquid/lexer.rb
@@ -1,48 +1,44 @@
-# frozen_string_literal: true
-
-require 'strscan'
+require "strscan"
 module Liquid
  class Lexer
    SPECIALS = {
-      '|' => :pipe,
-      '.' => :dot,
-      ':' => :colon,
-      ',' => :comma,
-      '[' => :open_square,
-      ']' => :close_square,
-      '(' => :open_round,
-      ')' => :close_round,
-      '?' => :question,
-      '-' => :dash,
-    }.freeze
-    IDENTIFIER = /[a-zA-Z_][\w-]*\??/.freeze
-    SINGLE_STRING_LITERAL = /'[^\']*'/.freeze
-    DOUBLE_STRING_LITERAL = /"[^\"]*"/.freeze
-    NUMBER_LITERAL = /-?\d+(\.\d+)?/.freeze
-    DOTDOT = /\.\./.freeze
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/.freeze
-    WHITESPACE_OR_NOTHING = /\s*/.freeze
+      '|'.freeze => :pipe,
+      '.'.freeze => :dot,
+      ':'.freeze => :colon,
+      ','.freeze => :comma,
+      '['.freeze => :open_square,
+      ']'.freeze => :close_square,
+      '('.freeze => :open_round,
+      ')'.freeze => :close_round,
+      '?'.freeze => :question,
+      '-'.freeze => :dash
+    }
+    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
+    SINGLE_STRING_LITERAL = /'[^\']*'/
+    DOUBLE_STRING_LITERAL = /"[^\"]*"/
+    NUMBER_LITERAL = /-?\d+(\.\d+)?/
+    DOTDOT = /\.\./
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/

    def initialize(input)
-      @ss = StringScanner.new(input)
+      @ss = StringScanner.new(input.rstrip)
    end

    def tokenize
      @output = []

      until @ss.eos?
-        @ss.skip(WHITESPACE_OR_NOTHING)
-        break if @ss.eos?
-
-        tok = if (t = @ss.scan(COMPARISON_OPERATOR)) then [:comparison, t]
-        elsif (t = @ss.scan(SINGLE_STRING_LITERAL)) then [:string, t]
-        elsif (t = @ss.scan(DOUBLE_STRING_LITERAL)) then [:string, t]
-        elsif (t = @ss.scan(NUMBER_LITERAL)) then [:number, t]
-        elsif (t = @ss.scan(IDENTIFIER)) then [:id, t]
-        elsif (t = @ss.scan(DOTDOT)) then [:dotdot, t]
+        @ss.skip(/\s*/)
+        tok = case
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
        else
          c = @ss.getch
-          if (s = SPECIALS[c])
+          if s = SPECIALS[c]
            [s, c]
          else
            raise SyntaxError, "Unexpected character #{c}"
--- a/lib/liquid/locales/en.yml
+++ b/lib/liquid/locales/en.yml
@@ -14,7 +14,7 @@
      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}"
@@ -22,5 +22,3 @@
      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"
-    argument:
-      include: "Argument error in tag 'include' - Illegal template name"
--- a/lib/liquid/parse_context.rb
+++ b/lib/liquid/parse_context.rb
@@ -1,15 +1,12 @@
-# frozen_string_literal: true
-
 module Liquid
  class ParseContext
-    attr_accessor :locale, :line_number, :trim_whitespace, :depth
-    attr_reader :partial, :warnings, :error_mode
+    attr_accessor :partial, :locale, :line_number
+    attr_reader :warnings, :error_mode

    def initialize(options = {})
      @template_options = options ? options.dup : {}
      @locale = @template_options[:locale] ||= I18n.new
      @warnings = []
-      self.depth = 0
      self.partial = false
    end

@@ -21,6 +18,7 @@ module Liquid
      @partial = value
      @options = value ? partial_options : @template_options
      @error_mode = @options[:error_mode] || Template.error_mode
+      value
    end

    def partial_options
@@ -29,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
--- a/lib/liquid/parse_tree_visitor.rb
+++ b/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
--- a/lib/liquid/parser.rb
+++ b/lib/liquid/parser.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class Parser
    def initialize(input)
@@ -14,8 +12,9 @@ module Liquid

    def consume(type = nil)
      token = @tokens[@p]
-      raise SyntaxError, "Expected #{type} but found #{@tokens[@p].first}" if type && token[0] != type
-
+      if type && token[0] != type
+        raise SyntaxError, "Expected #{type} but found #{@tokens[@p].first}"
+      end
      @p += 1
      token[1]
    end
@@ -26,7 +25,6 @@ module Liquid
    def consume?(type)
      token = @tokens[@p]
      return false unless token && token[0] == type
-
      @p += 1
      token[1]
    end
@@ -36,7 +34,6 @@ module Liquid
      token = @tokens[@p]
      return false unless token && token[0] == :id
      return false unless token[1] == str
-
      @p += 1
      token[1]
    end
@@ -44,18 +41,14 @@ module Liquid
    def look(type, ahead = 0)
      tok = @tokens[@p + ahead]
      return false unless tok
-
      tok[0] == type
    end

-    SINGLE_TOKEN_EXPRESSION_TYPES = %i[string number].freeze
-    private_constant :SINGLE_TOKEN_EXPRESSION_TYPES
-
    def expression
      token = @tokens[@p]
      if token[0] == :id
        variable_signature
-      elsif SINGLE_TOKEN_EXPRESSION_TYPES.include?(token[0])
+      elsif [:string, :number].include? token[0]
        consume
      elsif token.first == :open_round
        consume
@@ -70,9 +63,11 @@ module Liquid
    end

    def argument
-      str = +''
+      str = ""
      # might be a keyword argument (identifier: expression)
-      str << consume << consume << ' ' if look(:id) && look(:colon, 1)
+      if look(:id) && look(:colon, 1)
+        str << consume << consume << ' '.freeze
+      end

      str << expression
      str
@@ -80,7 +75,7 @@ module Liquid

    def variable_signature
      str = consume(:id)
-      while look(:open_square)
+      if look(:open_square)
        str << consume
        str << expression
        str << consume(:close_square)
--- a/lib/liquid/parser_switching.rb
+++ b/lib/liquid/parser_switching.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  module ParserSwitching
    def parse_with_selected_parser(markup)
--- a/lib/liquid/profiler.rb
+++ b/lib/liquid/profiler.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'liquid/profiler/hooks'

 module Liquid
@@ -99,9 +97,9 @@ module Liquid
    end

    def initialize
-      @partial_stack = ['<root>']
+      @partial_stack = ["<root>"]

-      @root_timing = Timing.new('', current_partial)
+      @root_timing = Timing.new("", current_partial)
      @timing_stack = [@root_timing]

      @render_start_at = Time.now
--- a/lib/liquid/profiler/hooks.rb
+++ b/lib/liquid/profiler/hooks.rb
@@ -1,10 +1,8 @@
-# frozen_string_literal: true
-
 module Liquid
  class BlockBody
-    def render_node_with_profiling(context, output, node)
+    def render_node_with_profiling(node, context)
      Profiler.profile_node_render(node) do
-        render_node_without_profiling(context, output, node)
+        render_node_without_profiling(node, context)
      end
    end

@@ -13,13 +11,13 @@ module Liquid
  end

  class Include < Tag
-    def render_to_output_buffer_with_profiling(context, output)
+    def render_with_profiling(context)
      Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        render_to_output_buffer_without_profiling(context, output)
+        render_without_profiling(context)
      end
    end

-    alias_method :render_to_output_buffer_without_profiling, :render_to_output_buffer
-    alias_method :render_to_output_buffer, :render_to_output_buffer_with_profiling
+    alias_method :render_without_profiling, :render
+    alias_method :render, :render_with_profiling
  end
 end
--- a/lib/liquid/range_lookup.rb
+++ b/lib/liquid/range_lookup.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class RangeLookup
    def self.parse(start_markup, end_markup)
--- a/lib/liquid/resource_limits.rb
+++ b/lib/liquid/resource_limits.rb
@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
  class ResourceLimits
    attr_accessor :render_length, :render_score, :assign_score,
-                  :render_length_limit, :render_score_limit, :assign_score_limit
+      :render_length_limit, :render_score_limit, :assign_score_limit

    def initialize(limits)
      @render_length_limit = limits[:render_length_limit]
--- a/lib/liquid/standardfilters.rb
+++ b/lib/liquid/standardfilters.rb
@@ -1,24 +1,16 @@
-# frozen_string_literal: true
-
 require 'cgi'
 require 'bigdecimal'

 module Liquid
  module StandardFilters
    HTML_ESCAPE = {
-      '&' => '&amp;',
-      '>' => '&gt;',
-      '<' => '&lt;',
-      '"' => '&quot;',
-      "'" => '&#39;',
-    }.freeze
-    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/.freeze
-    STRIP_HTML_BLOCKS = Regexp.union(
-      %r{<script.*?</script>}m,
-      /<!--.*?-->/m,
-      %r{<style.*?</style>}m
-    )
-    STRIP_HTML_TAGS = /<.*?>/m.freeze
+      '&'.freeze => '&amp;'.freeze,
+      '>'.freeze => '&gt;'.freeze,
+      '<'.freeze => '&lt;'.freeze,
+      '"'.freeze => '&quot;'.freeze,
+      "'".freeze => '&#39;'.freeze
+    }
+    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/

    # 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).untaint unless input.nil?
+      CGI.escapeHTML(input).untaint
    end
    alias_method :h, :escape

@@ -50,16 +42,7 @@ module Liquid
    end

    def url_encode(input)
-      CGI.escape(input.to_s) unless input.nil?
-    end
-
-    def url_decode(input)
-      return if input.nil?
-
-      result = CGI.unescape(input.to_s)
-      raise Liquid::ArgumentError, "invalid byte sequence in #{result.encoding}" unless result.valid_encoding?
-
-      result
+      CGI.escape(input) rescue input
    end

    def slice(input, offset, length = nil)
@@ -74,25 +57,21 @@ 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)
-      truncate_string_str = truncate_string.to_s
-      l = length - truncate_string_str.length
+      l = length - truncate_string.length
      l = 0 if l < 0
-      input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
+      input.length > length ? input[0...l] + truncate_string : input
    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)
      l = words - 1
      l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(' ').concat(truncate_string.to_s) : input
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
    end

    # Split input string into an array of substrings separated by given pattern.
@@ -101,7 +80,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)
@@ -117,19 +96,17 @@ module Liquid
    end

    def strip_html(input)
-      empty = ''
-      result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
-      result.gsub!(STRIP_HTML_TAGS, empty)
-      result
+      empty = ''.freeze
+      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
    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).join(glue)
    end

@@ -137,19 +114,12 @@ module Liquid
    # provide optional property with which to sort an array of hashes or drops
    def sort(input, property = nil)
      ary = InputIterator.new(input)
-
-      return [] if ary.empty?
-
      if property.nil?
-        ary.sort do |a, b|
-          nil_safe_compare(a, b)
-        end
-      elsif ary.all? { |el| el.respond_to?(:[]) }
-        begin
-          ary.sort { |a, b| nil_safe_compare(a[property], b[property]) }
-        rescue TypeError
-          raise_property_error(property)
-        end
+        ary.sort
+      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
+        ary.sort { |a, b| a[property] <=> b[property] }
+      elsif ary.first.respond_to?(property)
+        ary.sort { |a, b| a.send(property) <=> b.send(property) }
      end
    end

@@ -158,40 +128,12 @@ module Liquid
    def sort_natural(input, property = nil)
      ary = InputIterator.new(input)

-      return [] if ary.empty?
-
      if property.nil?
-        ary.sort do |a, b|
-          nil_safe_casecmp(a, b)
-        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)
-
-      if ary.empty?
-        []
-      elsif ary.first.respond_to?(:[]) && target_value.nil?
-        begin
-          ary.select { |item| item[property] }
-        rescue TypeError
-          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
+        ary.sort { |a, b| a.casecmp(b) }
+      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
+        ary.sort { |a, b| a[property].casecmp(b[property]) }
+      elsif ary.first.respond_to?(property)
+        ary.sort { |a, b| a.send(property).casecmp(b.send(property)) }
      end
    end

@@ -202,14 +144,8 @@ module Liquid

      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] }
-        rescue TypeError
-          raise_property_error(property)
-        end
+        ary.uniq{ |a| a[property] }
      end
    end

@@ -224,15 +160,12 @@ module Liquid
      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
+          e[property]
        end
      end
-    rescue TypeError
-      raise_property_error(property)
    end

    # Remove nils within an array
@@ -242,35 +175,31 @@ module Liquid

      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? }
-        rescue TypeError
-          raise_property_error(property)
-        end
+        ary.reject{ |a| a[property].nil? }
+      elsif ary.first.respond_to?(property)
+        ary.reject { |a| a.send(property).nil? }
      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
@@ -279,8 +208,6 @@ module Liquid
    end

    def concat(input, array)
-      raise ArgumentError, 'concat filter requires an array argument' unless array.respond_to?(:to_ary)
-
      InputIterator.new(input).concat(array)
    end

@@ -291,7 +218,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
@@ -328,7 +255,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
@@ -351,12 +278,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, :+)
@@ -406,57 +327,18 @@ module Liquid
      raise Liquid::FloatDomainError, e.message
    end

-    def at_least(input, n)
-      min_value = Utils.to_number(n)
-
-      result = Utils.to_number(input)
-      result = min_value if min_value > result
-      result.is_a?(BigDecimal) ? result.to_f : result
-    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
-
-    def default(input, default_value = '')
-      if !input || input.respond_to?(:empty?) && input.empty?
-        default_value
-      else
-        input
-      end
+    def default(input, default_value = "".freeze)
+      is_blank = input.respond_to?(:empty?) ? input.empty? : !input
+      is_blank ? default_value : input
    end

    private

-    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

@@ -473,11 +355,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
@@ -492,11 +374,6 @@ module Liquid
        to_a.compact
      end

-      def empty?
-        @input.each { return false }
-        true
-      end
-
      def each
        @input.each do |e|
          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
--- a/lib/liquid/strainer.rb
+++ b/lib/liquid/strainer.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'set'

 module Liquid
@@ -9,12 +7,12 @@ module Liquid
  # 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
+    @@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 = Strainer.global_strainer.filter_methods.dup
+    @@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
@@ -24,27 +22,19 @@ module Liquid
    end

    class << self
-      attr_accessor :strainer_class_cache, :global_strainer
      attr_reader :filter_methods
    end

    def self.add_filter(filter)
-      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
-
-      unless 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(', ')}"
-        else
-          send(:include, filter)
-          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
-        end
+      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)
-      @strainer_class_cache.clear
-      @global_strainer.add_filter(filter)
+      @@global_strainer.add_filter(filter)
    end

    def self.invokable?(method)
@@ -52,19 +42,17 @@ module Liquid
    end

    def self.create(context, filters = [])
-      @strainer_class_cache[filters].new(context)
+      @@strainer_class_cache[filters].new(context)
    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
+      raise Liquid::ArgumentError.new(e.message)
    end
  end
 end
--- a/lib/liquid/tablerowloop_drop.rb
+++ b/lib/liquid/tablerowloop_drop.rb
@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class TablerowloopDrop < Drop
-    def initialize(length, cols)
-      @length = length
-      @row = 1
-      @col = 1
-      @cols = cols
-      @index = 0
-    end
-
-    attr_reader :length, :col, :row
-
-    def index
-      @index + 1
-    end
-
-    def index0
-      @index
-    end
-
-    def col0
-      @col - 1
-    end
-
-    def rindex
-      @length - @index
-    end
-
-    def rindex0
-      @length - @index - 1
-    end
-
-    def first
-      @index == 0
-    end
-
-    def last
-      @index == @length - 1
-    end
-
-    def col_first
-      @col == 1
-    end
-
-    def col_last
-      @col == @cols
-    end
-
-    protected
-
-    def increment!
-      @index += 1
-
-      if @col == @cols
-        @col = 1
-        @row += 1
-      else
-        @col += 1
-      end
-    end
-  end
-end
--- a/lib/liquid/tag.rb
+++ b/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
@@ -23,7 +21,8 @@ module Liquid
      @line_number = parse_context.line_number
    end

-    def parse(_tokens); end
+    def parse(_tokens)
+    end

    def raw
      "#{@tag_name} #{@markup}"
@@ -34,15 +33,7 @@ module Liquid
    end

    def render(_context)
-      ''
-    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
+      ''.freeze
    end

    def blank?
--- a/lib/liquid/tags/assign.rb
+++ b/lib/liquid/tags/assign.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Assign sets a variable in your template.
  #
@@ -10,52 +8,32 @@ module Liquid
  #  {{ foo }}
  #
  class Assign < Tag
-    SYNTAX = /(#{VARIABLE_SIGNATURE}+)\s*=\s*(.*)\s*/om.freeze
-
-    attr_reader :to, :from
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om

    def initialize(tag_name, markup, options)
      super
-      if markup =~ SYNTAX
-        @to = Regexp.last_match(1)
-        @from = Variable.new(Regexp.last_match(2), options)
+      if markup =~ Syntax
+        @to = $1
+        @from = Variable.new($2, options)
      else
-        raise SyntaxError, options[:locale].t('errors.syntax.assign')
+        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.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) || val.instance_of?(Hash)
-        sum = 1
-        # Uses #each to avoid extra allocations.
-        val.each { |child| sum += assign_score_of(child) }
-        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
--- a/lib/liquid/tags/break.rb
+++ b/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.
  #
@@ -16,5 +14,5 @@ module Liquid
    end
  end

-  Template.register_tag('break', Break)
+  Template.register_tag('break'.freeze, Break)
 end
--- a/lib/liquid/tags/capture.rb
+++ b/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.
  #
@@ -13,23 +11,22 @@ module Liquid
  # in a sidebar or footer.
  #
  class Capture < Block
-    SYNTAX = /(#{VARIABLE_SIGNATURE}+)/o.freeze
+    Syntax = /(#{VariableSignature}+)/o

    def initialize(tag_name, markup, options)
      super
-      if markup =~ SYNTAX
-        @to = Regexp.last_match(1)
+      if markup =~ Syntax
+        @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)
-      previous_output_size = output.bytesize
-      super
+    def render(context)
+      output = super
      context.scopes.last[@to] = output
-      context.resource_limits.assign_score += (output.bytesize - previous_output_size)
-      output
+      context.resource_limits.assign_score += output.length
+      ''.freeze
    end

    def blank?
@@ -37,5 +34,5 @@ module Liquid
    end
  end

-  Template.register_tag('capture', Capture)
+  Template.register_tag('capture'.freeze, Capture)
 end
--- a/lib/liquid/tags/case.rb
+++ b/lib/liquid/tags/case.rb
@@ -1,26 +1,24 @@
-# frozen_string_literal: true
-
 module Liquid
  class Case < Block
-    SYNTAX = /(#{QUOTED_FRAGMENT})/o.freeze
-    WHEN_SYNTAX = /(#{QUOTED_FRAGMENT})(?:(?:\s+or\s+|\s*\,\s*)(#{QUOTED_FRAGMENT}.*))?/om.freeze
-
-    attr_reader :blocks, :left
+    Syntax     = /(#{QuotedFragment})/o
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om

    def initialize(tag_name, markup, options)
      super
      @blocks = []

-      if markup =~ SYNTAX
-        @left = Expression.parse(Regexp.last_match(1))
+      if markup =~ Syntax
+        @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 = BlockBody.new
-      body = @blocks.last.attachment while parse_body(body, tokens)
+      while parse_body(body, tokens)
+        body = @blocks.last.attachment
+      end
    end

    def nodelist
@@ -29,30 +27,30 @@ 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)
      context.stack do
        execute_else_block = true

+        output = ''
        @blocks.each do |block|
          if block.else?
-            block.attachment.render_to_output_buffer(context, output) if execute_else_block
+            return block.attachment.render(context) if execute_else_block
          elsif block.evaluate(context)
            execute_else_block = false
-            block.attachment.render_to_output_buffer(context, output)
+            output << block.attachment.render(context)
          end
        end
+        output
      end
-
-      output
    end

    private
@@ -61,30 +59,28 @@ module Liquid
      body = BlockBody.new

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

-        markup = Regexp.last_match(2)
+        markup = $2

-        block = Condition.new(@left, '==', Expression.parse(Regexp.last_match(1)))
+        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
        block.attach(body)
        @blocks << block
      end
    end

    def record_else_condition(markup)
-      raise SyntaxError, options[:locale].t('errors.syntax.case_invalid_else') unless markup.strip.empty?
+      unless markup.strip.empty?
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
+      end

      block = ElseCondition.new
      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
--- a/lib/liquid/tags/comment.rb
+++ b/lib/liquid/tags/comment.rb
@@ -1,17 +1,16 @@
-# frozen_string_literal: true
-
 module Liquid
  class Comment < Block
-    def render_to_output_buffer(_context, output)
-      output
+    def render(_context)
+      ''.freeze
    end

-    def unknown_tag(_tag, _markup, _tokens); end
+    def unknown_tag(_tag, _markup, _tokens)
+    end

    def blank?
      true
    end
  end

-  Template.register_tag('comment', Comment)
+  Template.register_tag('comment'.freeze, Comment)
 end
--- a/lib/liquid/tags/continue.rb
+++ b/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.
  #
@@ -16,5 +14,5 @@ module Liquid
    end
  end

-  Template.register_tag('continue', Continue)
+  Template.register_tag('continue'.freeze, Continue)
 end
--- a/lib/liquid/tags/cycle.rb
+++ b/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.
  #
@@ -14,64 +12,45 @@ module Liquid
  #    <div class="green"> Item five</div>
  #
  class Cycle < Tag
-    SIMPLE_SYNTAX = /\A#{QUOTED_FRAGMENT}+/o.freeze
-    NAMED_SYNTAX  = /\A(#{QUOTED_FRAGMENT})\s*\:\s*(.*)/om.freeze
-
-    attr_reader :variables
+    SimpleSyntax = /\A#{QuotedFragment}+/o
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om

    def initialize(tag_name, markup, options)
      super
      case markup
-      when NAMED_SYNTAX
-        @variables = variables_from_string(Regexp.last_match(2))
-        @name = Expression.parse(Regexp.last_match(1))
-      when SIMPLE_SYNTAX
+      when NamedSyntax
+        @variables = variables_from_string($2)
+        @name = Expression.parse($1)
+      when SimpleSyntax
        @variables = variables_from_string(markup)
        @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)
-      context.registers[:cycle] ||= {}
+    def render(context)
+      context.registers[:cycle] ||= Hash.new(0)

      context.stack do
        key = context.evaluate(@name)
-        iteration = context.registers[:cycle][key].to_i
-
-        val = context.evaluate(@variables[iteration])
-
-        if val.is_a?(Array)
-          val = val.join
-        elsif !val.is_a?(String)
-          val = val.to_s
-        end
-
-        output << val
-
+        iteration = context.registers[:cycle][key]
+        result = context.evaluate(@variables[iteration])
        iteration += 1
-        iteration  = 0 if iteration >= @variables.size
+        iteration  = 0  if iteration >= @variables.size
        context.registers[:cycle][key] = iteration
+        result
      end
-
-      output
    end

    private

    def variables_from_string(markup)
      markup.split(',').collect do |var|
-        var =~ /\s*(#{QUOTED_FRAGMENT})\s*/o
-        Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
+        var =~ /\s*(#{QuotedFragment})\s*/o
+        $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)
--- a/lib/liquid/tags/decrement.rb
+++ b/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
-      output
+      value.to_s
    end
  end

-  Template.register_tag('decrement', Decrement)
+  Template.register_tag('decrement'.freeze, Decrement)
 end
--- a/lib/liquid/tags/for.rb
+++ b/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:
  #
@@ -46,21 +44,16 @@ module Liquid
  # forloop.parentloop:: Provides access to the parent loop, if present.
  #
  class For < Block
-    SYNTAX = /\A(#{VARIABLE_SEGMENT}+)\s+in\s+(#{QUOTED_FRAGMENT}+)\s*(reversed)?/o.freeze
-
-    attr_reader :collection_name, :variable_name, :limit, :from
+    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o

    def initialize(tag_name, markup, options)
      super
-      @from = @limit = nil
      parse_with_selected_parser(markup)
      @for_block = BlockBody.new
-      @else_block = nil
    end

    def parse(tokens)
      return unless parse_body(@for_block, tokens)
-
      parse_body(@else_block, tokens)
    end

@@ -69,55 +62,106 @@ module Liquid
    end

    def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'
-
+      return super unless tag == 'else'.freeze
      @else_block = BlockBody.new
    end

-    def render_to_output_buffer(context, output)
-      segment = collection_segment(context)
+    def render(context)
+      for_offsets = context.registers[:for] ||= Hash.new(0)
+      for_stack = context.registers[:for_stack] ||= []

-      if segment.empty?
-        render_else(context, output)
+      parent_loop = for_stack.last
+      for_stack.push(nil)
+
+      collection = context.evaluate(@collection_name)
+      collection = collection.to_a if collection.is_a?(Range)
+
+      from = if @from == :continue
+        for_offsets[@name].to_i
      else
-        render_segment(context, output, segment)
+        context.evaluate(@from).to_i
      end

-      output
+      limit = context.evaluate(@limit)
+      to    = limit ? limit.to_i + from : nil
+
+      segment = Utils.slice_collection(collection, from, to)
+
+      return render_else(context) if segment.empty?
+
+      segment.reverse! if @reversed
+
+      result = ''
+
+      length = segment.length
+
+      # Store our progress through the collection for the continue flag
+      for_offsets[@name] = from + segment.length
+
+      context.stack do
+        segment.each_with_index do |item, index|
+          context[@variable_name] = item
+          loop_vars = {
+            'name'.freeze       => @name,
+            'length'.freeze     => length,
+            'index'.freeze      => index + 1,
+            'index0'.freeze     => index,
+            'rindex'.freeze     => length - index,
+            'rindex0'.freeze    => length - index - 1,
+            'first'.freeze      => (index == 0),
+            'last'.freeze       => (index == length - 1),
+            'parentloop'.freeze => parent_loop
+          }
+
+          context['forloop'.freeze] = loop_vars
+          for_stack[-1] = loop_vars
+
+          result << @for_block.render(context)
+
+          # Handle any interrupts if they exist.
+          if context.interrupt?
+            interrupt = context.pop_interrupt
+            break if interrupt.is_a? BreakInterrupt
+            next if interrupt.is_a? ContinueInterrupt
+          end
+        end
+      end
+
+      result
+    ensure
+      for_stack.pop
    end

    protected

    def lax_parse(markup)
-      if markup =~ SYNTAX
-        @variable_name = Regexp.last_match(1)
-        collection_name = Regexp.last_match(2)
-        @reversed = !!Regexp.last_match(3)
+      if markup =~ Syntax
+        @variable_name = $1
+        collection_name = $2
+        @reversed = !!$3
        @name = "#{@variable_name}-#{collection_name}"
        @collection_name = Expression.parse(collection_name)
-        markup.scan(TAG_ATTRIBUTES) do |key, value|
+        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
      @name = "#{@variable_name}-#{collection_name}"
      @collection_name = Expression.parse(collection_name)
-      @reversed = p.id?('reversed')
+      @reversed = p.id?('reversed'.freeze)

      while p.look(:id) && p.look(:colon, 1)
-        unless (attribute = p.id?('limit') || p.id?('offset'))
-          raise SyntaxError, options[:locale].t('errors.syntax.for_invalid_attribute')
+        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
        end
-
        p.consume
        set_attribute(attribute, p.expression)
      end
@@ -126,97 +170,23 @@ module Liquid

    private

-    def collection_segment(context)
-      offsets = context.registers[:for] ||= {}
-
-      from = if @from == :continue
-        offsets[@name].to_i
-      else
-        from_value = context.evaluate(@from)
-        if from_value.nil?
-          0
-        else
-          Utils.to_integer(from_value)
-        end
-      end
-
-      collection = context.evaluate(@collection_name)
-      collection = collection.to_a if collection.is_a?(Range)
-
-      limit_value = context.evaluate(@limit)
-      to = if limit_value.nil?
-        nil
-      else
-        Utils.to_integer(limit_value) + from
-      end
-
-      segment = Utils.slice_collection(collection, from, to)
-      segment.reverse! if @reversed
-
-      offsets[@name] = from + segment.length
-
-      segment
-    end
-
-    def render_segment(context, output, segment)
-      for_stack = context.registers[:for_stack] ||= []
-      length = segment.length
-
-      context.stack do
-        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
-
-        for_stack.push(loop_vars)
-
-        begin
-          context['forloop'] = loop_vars
-
-          segment.each do |item|
-            context[@variable_name] = item
-            @for_block.render_to_output_buffer(context, output)
-            loop_vars.send(:increment!)
-
-            # Handle any interrupts if they exist.
-            next unless context.interrupt?
-
-            interrupt = context.pop_interrupt
-            break if interrupt.is_a?(BreakInterrupt)
-            next if interrupt.is_a?(ContinueInterrupt)
-          end
-        ensure
-          for_stack.pop
-        end
-      end
-
-      output
-    end
-
    def set_attribute(key, expr)
      case key
-      when 'offset'
-        @from = if expr == 'continue'
+      when 'offset'.freeze
+        @from = if expr == 'continue'.freeze
          :continue
        else
          Expression.parse(expr)
        end
-      when 'limit'
+      when 'limit'.freeze
        @limit = Expression.parse(expr)
      end
    end

-    def render_else(context, output)
-      if @else_block
-        @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
+    def render_else(context)
+      @else_block ? @else_block.render(context) : ''.freeze
    end
  end

-  Template.register_tag('for', For)
+  Template.register_tag('for'.freeze, For)
 end
--- a/lib/liquid/tags/if.rb
+++ b/lib/liquid/tags/if.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # If is the conditional block
  #
@@ -12,20 +10,14 @@ module Liquid
  #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
  #
  class If < Block
-    SYNTAX = /(#{QUOTED_FRAGMENT})\s*([=!<>a-z_]+)?\s*(#{QUOTED_FRAGMENT})?/o.freeze
-    EXPRESSIONS_AND_OPERATORS = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QUOTED_FRAGMENT}|\S+)\s*)+)/o.freeze
-    BOOLEAN_OPERATORS = %w[and or].freeze
-
-    attr_reader :blocks
+    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)

    def initialize(tag_name, markup, options)
      super
      @blocks = []
-      push_block('if', markup)
-    end
-
-    def nodelist
-      @blocks.map(&:attachment)
+      push_block('if'.freeze, markup)
    end

    def parse(tokens)
@@ -33,28 +25,33 @@ module Liquid
      end
    end

+    def nodelist
+      @blocks.map(&:attachment)
+    end
+
    def unknown_tag(tag, markup, tokens)
-      if %w[elsif else].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)
      context.stack do
        @blocks.each do |block|
-          return block.attachment.render_to_output_buffer(context, output) if block.evaluate(context)
+          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)
@@ -65,19 +62,18 @@ module Liquid
    end

    def lax_parse(markup)
-      expressions = markup.scan(EXPRESSIONS_AND_OPERATORS)
-      raise SyntaxError, options[:locale].t('errors.syntax.if') unless expressions.pop =~ SYNTAX
+      expressions = markup.scan(ExpressionsAndOperators)
+      raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax

-      condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(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
-
-        new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(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 expressions.pop.to_s =~ Syntax

+        new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
        new_condition.send(operator, condition)
        condition = new_condition
      end
@@ -87,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
-      while (op = (p.id?('and') || p.id?('or')))
-        child_condition = parse_comparison(p)
-        condition.send(op, child_condition)
-        condition = child_condition
+      if op = (p.id?('and'.freeze) || p.id?('or'.freeze))
+        condition.send(op, parse_binary_comparison(p))
      end
-      first_condition
+      condition
    end

    def parse_comparison(p)
      a = Expression.parse(p.expression)
-      if (op = p.consume?(:comparison))
+      if op = p.consume?(:comparison)
        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
--- a/lib/liquid/tags/ifchanged.rb
+++ b/lib/liquid/tags/ifchanged.rb
@@ -1,21 +1,18 @@
-# frozen_string_literal: true
-
 module Liquid
  class Ifchanged < Block
-    def render_to_output_buffer(context, output)
+    def render(context)
      context.stack do
-        block_output = +''
-        super(context, block_output)
+        output = super

-        if block_output != context.registers[:ifchanged]
-          context.registers[:ifchanged] = block_output
-          output << block_output
+        if output != context.registers[:ifchanged]
+          context.registers[:ifchanged] = output
+          output
+        else
+          ''.freeze
        end
      end
-
-      output
    end
  end

-  Template.register_tag('ifchanged', Ifchanged)
+  Template.register_tag('ifchanged'.freeze, Ifchanged)
 end
--- a/lib/liquid/tags/include.rb
+++ b/lib/liquid/tags/include.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Include allows templates to relate with other templates
  #
@@ -16,44 +14,42 @@ module Liquid
  #   {% include 'product' for products %}
  #
  class Include < Tag
-    SYNTAX = /(#{QUOTED_FRAGMENT}+)(\s+(?:with|for)\s+(#{QUOTED_FRAGMENT}+))?/o.freeze
-
-    attr_reader :template_name_expr, :variable_name_expr, :attributes
+    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o

    def initialize(tag_name, markup, options)
      super

-      if markup =~ SYNTAX
+      if markup =~ Syntax

-        template_name = Regexp.last_match(1)
-        variable_name = Regexp.last_match(3)
+        template_name = $1
+        variable_name = $3

        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
        @template_name_expr = Expression.parse(template_name)
        @attributes = {}

-        markup.scan(TAG_ATTRIBUTES) do |key, value|
+        markup.scan(TagAttributes) do |key, 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 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)
-      context_variable_name = template_name.split('/').last
+
+      context_variable_name = template_name.split('/'.freeze).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
@@ -67,21 +63,19 @@ module Liquid
          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
      end
-
-      output
    end

    private
@@ -92,10 +86,9 @@ module Liquid
    def load_cached_partial(template_name, context)
      cached_partials = context.registers[:cached_partials] || {}

-      if (cached = cached_partials[template_name])
+      if cached = cached_partials[template_name]
        return cached
      end
-
      source = read_template_from_file_system(context)
      begin
        parse_context.partial = true
@@ -113,16 +106,7 @@ module Liquid

      file_system.read_template_file(context.evaluate(@template_name_expr))
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.template_name_expr,
-          @node.variable_name_expr,
-        ] + @node.attributes.values
-      end
-    end
  end

-  Template.register_tag('include', Include)
+  Template.register_tag('include'.freeze, Include)
 end
--- a/lib/liquid/tags/increment.rb
+++ b/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,13 +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
-      output << value.to_s
-      output
+      value.to_s
    end
  end

-  Template.register_tag('increment', Increment)
+  Template.register_tag('increment'.freeze, Increment)
 end
--- a/lib/liquid/tags/raw.rb
+++ b/lib/liquid/tags/raw.rb
@@ -1,32 +1,31 @@
-# frozen_string_literal: true
-
 module Liquid
  class Raw < Block
-    SYNTAX = /\A\s*\z/.freeze
-    FULL_TOKEN_POSSIBLY_INVALID = /\A(.*)#{TAG_START}\s*(\w+)\s*(.*)?#{TAG_END}\z/om.freeze
+    Syntax = /\A\s*\z/
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om

    def initialize(tag_name, markup, parse_context)
      super

-      ensure_valid_markup(tag_name, markup, parse_context)
+      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 = +''
-      while (token = tokens.shift)
-        if token =~ FULL_TOKEN_POSSIBLY_INVALID
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != ''
-          return if block_delimiter == Regexp.last_match(2)
+      @body = ''
+      while token = tokens.shift
+        if token =~ FullTokenPossiblyInvalid
+          @body << $1 if $1 != "".freeze
+          return if block_delimiter == $2
        end
        @body << token unless token.empty?
      end

-      raise SyntaxError, parse_context.locale.t('errors.syntax.tag_never_closed', block_name: 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)
-      output << @body
-      output
+    def render(_context)
+      @body
    end

    def nodelist
@@ -36,13 +35,7 @@ module Liquid
    def blank?
      @body.empty?
    end
-
-    protected
-
-    def ensure_valid_markup(tag_name, markup, parse_context)
-      raise SyntaxError, parse_context.locale.t('errors.syntax.tag_unexpected_args', tag: tag_name) unless markup =~ SYNTAX
-    end
  end

-  Template.register_tag('raw', Raw)
+  Template.register_tag('raw'.freeze, Raw)
 end
--- a/lib/liquid/tags/table_row.rb
+++ b/lib/liquid/tags/table_row.rb
@@ -1,65 +1,69 @@
-# frozen_string_literal: true
-
 module Liquid
  class TableRow < Block
-    SYNTAX = /(\w+)\s+in\s+(#{QUOTED_FRAGMENT}+)/o.freeze
-
-    attr_reader :variable_name, :collection_name, :attributes
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o

    def initialize(tag_name, markup, options)
      super
-      if markup =~ SYNTAX
-        @variable_name = Regexp.last_match(1)
-        @collection_name = Expression.parse(Regexp.last_match(2))
+      if markup =~ Syntax
+        @variable_name = $1
+        @collection_name = Expression.parse($2)
        @attributes = {}
-        markup.scan(TAG_ATTRIBUTES) do |key, value|
+        markup.scan(TagAttributes) do |key, 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)
-      (collection = context.evaluate(@collection_name)) || (return '')
+    def render(context)
+      collection = context.evaluate(@collection_name) or return ''.freeze

-      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
-      to = @attributes.key?('limit') ? from + context.evaluate(@attributes['limit']).to_i : nil
+      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
+      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
+      cols = context.evaluate(@attributes['cols'.freeze]).to_i

-      output << "<tr class=\"row1\">\n"
+      row = 1
+      col = 0
+
+      result = "<tr class=\"row1\">\n"
      context.stack do
-        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
-        context['tablerowloop'] = tablerowloop
-
-        collection.each do |item|
+        collection.each_with_index do |item, index|
          context[@variable_name] = item
+          context['tablerowloop'.freeze] = {
+            'length'.freeze    => length,
+            'index'.freeze     => index + 1,
+            'index0'.freeze    => index,
+            'col'.freeze       => col + 1,
+            'col0'.freeze      => col,
+            'rindex'.freeze    => length - index,
+            'rindex0'.freeze   => length - index - 1,
+            'first'.freeze     => (index == 0),
+            'last'.freeze      => (index == length - 1),
+            'col_first'.freeze => (col == 0),
+            'col_last'.freeze  => (col == cols - 1)
+          }

-          output << "<td class=\"col#{tablerowloop.col}\">"
-          super
-          output << '</td>'
+          col += 1

-          output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">" if tablerowloop.col_last && !tablerowloop.last
+          result << "<td class=\"col#{col}\">" << super << '</td>'

-          tablerowloop.send(:increment!)
+          if col == cols && (index != length - 1)
+            col  = 0
+            row += 1
+            result << "</tr>\n<tr class=\"row#{row}\">"
+          end
        end
      end
-
-      output << "</tr>\n"
-      output
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        super + @node.attributes.values + [@node.collection_name]
-      end
+      result << "</tr>\n"
+      result
    end
  end

-  Template.register_tag('tablerow', TableRow)
+  Template.register_tag('tablerow'.freeze, TableRow)
 end
--- a/lib/liquid/tags/unless.rb
+++ b/lib/liquid/tags/unless.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require_relative 'if'

 module Liquid
@@ -8,21 +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)
      context.stack do
        # First condition is interpreted backwards ( if not )
        first_block = @blocks.first
-        return first_block.attachment.render_to_output_buffer(context, output) unless first_block.evaluate(context)
+        unless first_block.evaluate(context)
+          return first_block.attachment.render(context)
+        end

        # After the first condition unless works just like if
        @blocks[1..-1].each do |block|
-          return block.attachment.render_to_output_buffer(context, output) if block.evaluate(context)
+          if block.evaluate(context)
+            return block.attachment.render(context)
+          end
        end
-      end

-      output
+        ''.freeze
+      end
    end
  end

-  Template.register_tag('unless', Unless)
+  Template.register_tag('unless'.freeze, Unless)
 end
--- a/lib/liquid/template.rb
+++ b/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,17 +16,11 @@ module Liquid
    attr_accessor :root
    attr_reader :resource_limits, :warnings

-    @file_system = BlankFileSystem.new
-
-    class << self
-      attr_accessor :file_system
-    end
+    @@file_system = BlankFileSystem.new

    class TagRegistry
-      include Enumerable
-
      def initialize
-        @tags = {}
+        @tags  = {}
        @cache = {}
      end

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

@@ -75,9 +63,12 @@ module Liquid
      # :error raises an error when tainted output is used
      attr_writer :taint_mode

-      attr_accessor :default_exception_renderer
-      Template.default_exception_renderer = lambda do |exception|
-        exception
+      def file_system
+        @@file_system
+      end
+
+      def file_system=(obj)
+        @@file_system = obj
      end

      def register_tag(name, klass)
@@ -89,11 +80,11 @@ module Liquid
      end

      def error_mode
-        @error_mode ||= :lax
+        @error_mode || :lax
      end

      def taint_mode
-        @taint_mode ||= :lax
+        @taint_mode || :lax
      end

      # Pass a module with filter methods which should be available
@@ -116,7 +107,6 @@ module Liquid
    end

    def initialize
-      @rethrow_errors = false
      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
    end

@@ -163,13 +153,15 @@ 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

-        c.exception_renderer = ->(_e) { raise } if @rethrow_errors
+        if @rethrow_errors
+          c.exception_handler = ->(e) { raise }
+        end

        c
      when Liquid::Drop
@@ -180,20 +172,27 @@ module Liquid
      when nil
        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
      else
-        raise ArgumentError, 'Expected Hash or Liquid::Context as parameter'
+        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
      end

-      output = nil
-
      case args.last
      when Hash
        options = args.pop
-        output = options[:output] if options[:output]

-        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
+        if options[:registers].is_a?(Hash)
+          registers.merge!(options[:registers])
+        end

-        apply_options_to_context(context, options)
-      when Module, Array
+        if options[:filters]
+          context.add_filters(options[:filters])
+        end
+
+        if options[:exception_handler]
+          context.exception_handler = options[:exception_handler]
+        end
+      when Module
+        context.add_filters(args.pop)
+      when Array
        context.add_filters(args.pop)
      end

@@ -203,9 +202,10 @@ module Liquid
      begin
        # render the nodelist.
        # for performance reasons we get an array back here. join will make a string out of it.
-        with_profiling(context) do
-          @root.render_to_output_buffer(context, output || +'')
+        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
@@ -218,10 +218,6 @@ module Liquid
      render(*args)
    end

-    def render_to_output_buffer(context, output)
-      render(context, output: output)
-    end
-
    private

    def tokenize(source)
@@ -244,13 +240,5 @@ module Liquid
        yield
      end
    end
-
-    def apply_options_to_context(context, options)
-      context.add_filters(options[:filters]) if options[:filters]
-      context.global_filter = options[:global_filter] if options[:global_filter]
-      context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-      context.strict_variables = options[:strict_variables] if options[:strict_variables]
-      context.strict_filters = options[:strict_filters] if options[:strict_filters]
-    end
  end
 end
--- a/lib/liquid/tokenizer.rb
+++ b/lib/liquid/tokenizer.rb
@@ -1,12 +1,10 @@
-# frozen_string_literal: true
-
 module Liquid
  class Tokenizer
    attr_reader :line_number

    def initialize(source, line_numbers = false)
      @source = source
-      @line_number = line_numbers ? 1 : nil
+      @line_number = 1 if line_numbers
      @tokens = tokenize
    end

@@ -22,10 +20,10 @@ module Liquid
      @source = @source.source if @source.respond_to?(:source)
      return [] if @source.to_s.empty?

-      tokens = @source.split(TEMPLATE_PARSER)
+      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
--- a/lib/liquid/utils.rb
+++ b/lib/liquid/utils.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  module Utils
    def self.slice_collection(collection, from, to)
@@ -21,9 +19,13 @@ module Liquid
      return [] unless collection.respond_to?(:each)

      collection.each do |item|
-        break if to && to <= index
+        if to && to <= index
+          break
+        end

-        segments << item if from <= index
+        if from <= index
+          segments << item
+        end

        index += 1
      end
@@ -33,29 +35,24 @@ module Liquid

    def self.to_integer(num)
      return num if num.is_a?(Integer)
-
      num = num.to_s
      begin
        Integer(num)
      rescue ::ArgumentError
-        raise Liquid::ArgumentError, 'invalid integer'
+        raise Liquid::ArgumentError, "invalid integer"
      end
    end

    def self.to_number(obj)
      case obj
      when Float
-        BigDecimal(obj.to_s)
+        BigDecimal.new(obj.to_s)
      when Numeric
        obj
      when String
-        obj.strip =~ /\A-?\d+\.\d+\z/ ? BigDecimal(obj) : obj.to_i
+        (obj.strip =~ /\A\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
      else
-        if obj.respond_to?(:to_number)
-          obj.to_number
-        else
-          0
-        end
+        0
      end
    end

@@ -64,19 +61,18 @@ module Liquid

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

      case obj
-      when 'now', 'today'
+      when 'now'.freeze, 'today'.freeze
        Time.now
      when /\A\d+\z/, Integer
        Time.at(obj.to_i)
      when String
        Time.parse(obj)
      end
-    rescue ::ArgumentError
+    rescue ArgumentError
      nil
    end
  end
--- a/lib/liquid/variable.rb
+++ b/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,16 +10,10 @@ module Liquid
  #   {{ user | link }}
  #
  class Variable
-    FILTER_MARKUP_REGEX = /#{FILTER_SEPARATOR}\s*(.*)/om.freeze
-    FILTER_PARSER = /(?:\s+|#{QUOTED_FRAGMENT}|#{ARGUMENT_SEPARATOR})+/o.freeze
-    FILTER_ARGS_REGEX = /(?:#{FILTER_ARGUMENT_SEPARATOR}|#{ARGUMENT_SEPARATOR})\s*((?:\w+\s*\:\s*)?#{QUOTED_FRAGMENT})/o.freeze
-    JUST_TAG_ATTRIBUTES = /\A#{TAG_ATTRIBUTES}\z/o.freeze
-    MARKUP_WITH_QUOTED_FRAGMENT = /(#{QUOTED_FRAGMENT})(.*)/om.freeze
-
+    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
    attr_accessor :filters, :name, :line_number
    attr_reader :parse_context
    alias_method :options, :parse_context
-
    include ParserSwitching

    def initialize(markup, parse_context)
@@ -43,18 +35,17 @@ module Liquid

    def lax_parse(markup)
      @filters = []
-      return unless markup =~ MARKUP_WITH_QUOTED_FRAGMENT
+      return unless markup =~ /(#{QuotedFragment})(.*)/om

-      name_markup = Regexp.last_match(1)
-      filter_markup = Regexp.last_match(2)
+      name_markup = $1
+      filter_markup = $2
      @name = Expression.parse(name_markup)
-      if filter_markup =~ FILTER_MARKUP_REGEX
-        filters = Regexp.last_match(1).scan(FILTER_PARSER)
+      if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
+        filters = $1.scan(FilterParser)
        filters.each do |f|
          next unless f =~ /\w+/
-
          filtername = Regexp.last_match(0)
-          filterargs = f.scan(FILTER_ARGS_REGEX).flatten
+          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
          @filters << parse_filter_expressions(filtername, filterargs)
        end
      end
@@ -82,49 +73,31 @@ module Liquid
    end

    def render(context)
-      obj = @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
+      @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
        context.invoke(filter_name, output, *filter_args)
-      end
-
-      obj = context.apply_global_filter(obj)
-      taint_check(context, obj)
-      obj
-    end
-
-    def render_to_output_buffer(context, output)
-      obj = render(context)
-
-      if obj.is_a?(Array)
-        output << obj.join
-      elsif obj.nil?
-      else
-        output << obj.to_s
-      end
-
-      output
+      end.tap{ |obj| taint_check(context, obj) }
    end

    private

    def parse_filter_expressions(filter_name, unparsed_args)
      filter_args = []
-      keyword_args = nil
+      keyword_args = {}
      unparsed_args.each do |a|
-        if (matches = a.match(JUST_TAG_ATTRIBUTES))
-          keyword_args ||= {}
+        if matches = a.match(/\A#{TagAttributes}\z/o)
          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|
@@ -139,7 +112,7 @@ module Liquid
      return unless obj.tainted?
      return if Template.taint_mode == :lax

-      @markup =~ QUOTED_FRAGMENT
+      @markup =~ QuotedFragment
      name = Regexp.last_match(0)

      error = TaintedError.new("variable '#{name}' is tainted and was not escaped")
@@ -153,11 +126,5 @@ module Liquid
        raise error
      end
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.name] + @node.filters.flatten
-      end
-    end
  end
 end
--- a/lib/liquid/variable_lookup.rb
+++ b/lib/liquid/variable_lookup.rb
@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
  class VariableLookup
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m.freeze
-    COMMAND_METHODS = %w[size first last].freeze
+    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
+    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]

    attr_reader :name, :lookups

@@ -12,10 +10,12 @@ module Liquid
    end

    def initialize(markup)
-      lookups = markup.scan(VARIABLE_PARSER)
+      lookups = markup.scan(VariableParser)

      name = lookups.shift
-      name = Expression.parse(Regexp.last_match(1)) if name =~ SQUARE_BRACKETED
+      if name =~ SQUARE_BRACKETED
+        name = Expression.parse($1)
+      end
      @name = name

      @lookups = lookups
@@ -24,7 +24,7 @@ module Liquid
      @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
@@ -41,8 +41,8 @@ module Liquid
        # If object is a hash- or array-like object we look for the
        # presence of the key and if its available we return it
        if object.respond_to?(:[]) &&
-           ((object.respond_to?(:key?) && object.key?(key)) ||
-            (object.respond_to?(:fetch) && key.is_a?(Integer)))
+            ((object.respond_to?(:key?) && object.key?(key)) ||
+             (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)
@@ -55,12 +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
-          # raise an exception if `strict_variables` option is set to true
+          # keywords either. The only thing we got left is to return nil
        else
-          return nil unless context.strict_variables
-
-          raise Liquid::UndefinedVariable, "undefined variable #{key}"
+          return nil
        end

        # If we are dealing with a drop here we have to
@@ -79,11 +76,5 @@ module Liquid
    def state
      [@name, @lookups, @command_flags]
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        @node.lookups
-      end
-    end
  end
 end
--- a/lib/liquid/version.rb
+++ b/lib/liquid/version.rb
@@ -1,5 +1,4 @@
-# frozen_string_literal: true
-
+# encoding: utf-8
 module Liquid
-  VERSION = '4.0.3'
+  VERSION = "4.0.0.alpha"
 end
--- a/liquid.gemspec
+++ b/liquid.gemspec
@@ -1,31 +1,29 @@
-# frozen_string_literal: true
+# encoding: utf-8
+lib = File.expand_path('../lib/', __FILE__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)

-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'liquid/version'
+require "liquid/version"

 Gem::Specification.new do |s|
-  s.name        = 'liquid'
+  s.name        = "liquid"
  s.version     = Liquid::VERSION
  s.platform    = Gem::Platform::RUBY
-  s.summary     = 'A secure, non-evaling end user template engine with aesthetic markup.'
-  s.authors     = ['Tobias Lütke']
-  s.email       = ['tobi@leetsoft.com']
-  s.homepage    = 'http://www.liquidmarkup.org'
-  s.license     = 'MIT'
+  s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
+  s.authors     = ["Tobias Lütke"]
+  s.email       = ["tobi@leetsoft.com"]
+  s.homepage    = "http://www.liquidmarkup.org"
+  s.license     = "MIT"
  # s.description = "A secure, non-evaling end user template engine with aesthetic markup."

-  s.required_ruby_version     = '>= 2.4.0'
-  s.required_rubygems_version = '>= 1.3.7'
+  s.required_rubygems_version = ">= 1.3.7"

-  s.test_files  = Dir.glob('{test}/**/*')
-  s.files       = Dir.glob('{lib}/**/*') + %w[LICENSE README.md]
+  s.test_files  = Dir.glob("{test}/**/*")
+  s.files       = Dir.glob("{lib}/**/*") + %w(MIT-LICENSE README.md)

-  s.extra_rdoc_files = ['History.md', 'README.md']
+  s.extra_rdoc_files  = ["History.md", "README.md"]

-  s.require_path = 'lib'
+  s.require_path = "lib"

-  s.add_development_dependency('minitest')
-  s.add_development_dependency('rake', '~> 11.3')
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
 end
--- a/performance/benchmark.rb
+++ b/performance/benchmark.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'benchmark/ips'
 require_relative 'theme_runner'

@@ -7,14 +5,13 @@ 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
  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
  puts

-  x.report('parse:') { profiler.compile }
-  x.report('render:') { profiler.render }
-  x.report('parse & render:') { profiler.run }
+  x.report("parse:") { profiler.compile }
+  x.report("parse & run:") { profiler.run }
 end
--- a/performance/memory_profile.rb
+++ b/performance/memory_profile.rb
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'benchmark/ips'
-require 'memory_profiler'
-require_relative 'theme_runner'
-
-def profile(phase, &block)
-  puts
-  puts "#{phase}:"
-  puts
-
-  report = MemoryProfiler.report(&block)
-
-  report.pretty_print(
-    color_output: true,
-    scale_bytes: true,
-    detailed_report: true
-  )
-end
-
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
-
-profiler = ThemeRunner.new
-
-profile('Parsing') { profiler.compile }
-profile('Rendering') { profiler.render }
--- a/performance/profile.rb
+++ b/performance/profile.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'stackprof'
 require_relative 'theme_runner'

@@ -7,7 +5,7 @@ Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run

-%i[cpu object].each do |profile_type|
+[:cpu, :object].each do |profile_type|
  puts "Profiling in #{profile_type} mode..."
  results = StackProf.run(mode: profile_type) do
    200.times do
@@ -15,12 +13,12 @@ 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
  end

  StackProf::Report.new(results).print_text(false, 20)
-  File.write(ENV['FILENAME'] + '.' + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
+  File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
 end
--- a/performance/shopify/comment_form.rb
+++ b/performance/shopify/comment_form.rb
@@ -1,20 +1,18 @@
-# frozen_string_literal: true
-
 class CommentForm < Liquid::Block
-  SYNTAX = /(#{Liquid::VARIABLE_SIGNATURE}+)/.freeze
+  Syntax = /(#{Liquid::VariableSignature}+)/

  def initialize(tag_name, markup, options)
    super

-    if markup =~ SYNTAX
-      @variable_name = Regexp.last_match(1)
+    if markup =~ Syntax
+      @variable_name = $1
      @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'],
-        'body' => context['comment.body'],
+        'email'  => context['comment.email'],
+        'body'   => context['comment.body']
      }
-
-      output << wrap_in_form(article, render_all(@nodelist, context, output))
-      output
+      wrap_in_form(article, render_all(@nodelist, context))
    end
  end

--- a/performance/shopify/database.rb
+++ b/performance/shopify/database.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'yaml'

 module Database
@@ -18,11 +16,8 @@ module Database
      end

      # key the tables by handles, as this is how liquid expects it.
-      db = db.each_with_object({}) do |(key, values), assigns|
-        assigns[key] = values.each_with_object({}) do |v, h|
-          h[v['handle']] = v
-          h
-        end
+      db = db.inject({}) do |assigns, (key, values)|
+        assigns[key] = values.inject({}) { |h, v| h[v['handle']] = v; h; }
        assigns
      end

@@ -34,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'] },
-        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum + item['quantity'] },
-        'items' => db['line_items'].values,
+        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
+        'item_count'  => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
+        'items'       => db['line_items'].values
      }

      db
@@ -45,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
--- a/performance/shopify/json_filter.rb
+++ b/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
--- a/performance/shopify/liquid.rb
+++ b/performance/shopify/liquid.rb
@@ -1,6 +1,4 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift(__dir__ + '/../../lib')
+$:.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('form', CommentForm)
+Liquid::Template.register_tag 'paginate', Paginate
+Liquid::Template.register_tag 'form', CommentForm

-Liquid::Template.register_filter(JsonFilter)
-Liquid::Template.register_filter(MoneyFilter)
-Liquid::Template.register_filter(WeightFilter)
-Liquid::Template.register_filter(ShopFilter)
-Liquid::Template.register_filter(TagFilter)
+Liquid::Template.register_filter JsonFilter
+Liquid::Template.register_filter MoneyFilter
+Liquid::Template.register_filter WeightFilter
+Liquid::Template.register_filter ShopFilter
+Liquid::Template.register_filter TagFilter
--- a/performance/shopify/money_filter.rb
+++ b/performance/shopify/money_filter.rb
@@ -1,16 +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
--- a/performance/shopify/paginate.rb
+++ b/performance/shopify/paginate.rb
@@ -1,51 +1,49 @@
-# frozen_string_literal: true
-
 class Paginate < Liquid::Block
-  SYNTAX = /(#{Liquid::QUOTED_FRAGMENT})\s*(by\s*(\d+))?/.freeze
+  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/

  def initialize(tag_name, markup, options)
    super

-    if markup =~ SYNTAX
-      @collection_name = Regexp.last_match(1)
-      @page_size = if Regexp.last_match(2)
-        Regexp.last_match(3).to_i
+    if markup =~ Syntax
+      @collection_name = $1
+      @page_size = if $2
+        $3.to_i
      else
        20
      end

      @attributes = { 'window_size' => 3 }
-      markup.scan(Liquid::TAG_ATTRIBUTES) do |key, value|
+      markup.scan(Liquid::TagAttributes) do |key, value|
        @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,
-        'current_page' => 5,
-        'current_offset' => @page_size * 5,
+        'page_size'      => @page_size,
+        'current_page'   => 5,
+        'current_offset' => @page_size * 5
      }

      context['paginate'] = pagination

-      collection_size = context[@collection_name].size
+      collection_size  = context[@collection_name].size

-      raise ArgumentError, "Cannot paginate array '#{@collection_name}'. Not found." if collection_size.nil?
+      raise ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection_size.nil?

      page_count = (collection_size.to_f / @page_size.to_f).to_f.ceil + 1

      pagination['items']      = collection_size
      pagination['pages']      = page_count - 1
-      pagination['previous']   = link('&laquo; Previous', current_page - 1)  unless current_page <= 1
+      pagination['previous']   = link('&laquo; Previous', current_page - 1)  unless 1 >= current_page
      pagination['next']       = link('Next &raquo;', current_page + 1)      unless page_count <= current_page + 1
      pagination['parts']      = []

@@ -61,7 +59,6 @@ class Paginate < Liquid::Block
            pagination['parts'] << link(page, page)
          elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size']
            next if hellip_break
-
            pagination['parts'] << no_link('&hellip;')
            hellip_break = true
            next
@@ -88,6 +85,6 @@ class Paginate < Liquid::Block
  end

  def current_url
-    '/collections/frontpage'
+    "/collections/frontpage"
  end
 end
--- a/performance/shopify/shop_filter.rb
+++ b/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}"
@@ -17,15 +15,15 @@ module ShopFilter
    %(<script src="#{url}" type="text/javascript"></script>)
  end

-  def stylesheet_tag(url, media = 'all')
+  def stylesheet_tag(url, media = "all")
    %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
  end

-  def link_to(link, url, title = '')
+  def link_to(link, url, title = "")
    %(<a href="#{url}" title="#{title}">#{link}</a>)
  end

-  def img_tag(url, alt = '')
+  def img_tag(url, alt = "")
    %(<img src="#{url}" alt="#{alt}" />)
  end

@@ -54,13 +52,15 @@ module ShopFilter
  end

  def product_img_url(url, style = 'small')
-    raise ArgumentError, 'filter "size" can only be called on product images' 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'
      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
@@ -70,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|
-      html << if part['is_link']
-        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+    for part in paginate['parts']
+
+      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']
--- a/performance/shopify/tag_filter.rb
+++ b/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
--- a/performance/shopify/weight_filter.rb
+++ b/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)
--- a/performance/theme_runner.rb
+++ b/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,100 +21,53 @@ class ThemeRunner
    end
  end

-  # Initialize a new liquid ThemeRunner instance
-  # Will load all templates into memory, do this now so that we don't profile IO.
+  # Load all templates into memory, do this now so that
+  # 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|
-      Liquid::Template.new.parse(test_hash[:liquid])
-      Liquid::Template.new.parse(test_hash[:layout])
+    # Dup assigns because will make some changes to them
+
+    @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 compile_and_render(template, layout, assigns, page_template, template_file)
-    compiled_test = compile_test(template, layout, assigns, page_template, template_file)
-    assigns['content_for_layout'] = compiled_test[:tmpl].render!(assigns)
-    compiled_test[:layout].render!(assigns) if layout
-  end
-
-  def compile_all_tests
-    @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)
-      { tmpl: parsed_template, assigns: assigns, layout: parsed_layout }
-    else
-      { tmpl: parsed_template, assigns: assigns }
-    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
+
+    content_for_layout = tmpl.parse(template).render!(assigns)
+
+    if layout
+      assigns['content_for_layout'] = content_for_layout
+      tmpl.parse(layout).render!(assigns)
+    else
+      content_for_layout
+    end
  end
 end
--- a/test/integration/assign_test.rb
+++ b/test/integration/assign_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class AssignTest < Minitest::Test
@@ -12,29 +10,29 @@ class AssignTest < Minitest::Test
    END_TEMPLATE
    template = Template.parse(template_source)
    rendered = template.render!
-    assert_equal 'Print this-thing', rendered.strip
+    assert_equal "Print this-thing", rendered.strip
  end

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

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

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

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

  def test_assign_uses_error_mode
--- a/test/integration/blank_test.rb
+++ b/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)
-    output << ' '
-    output
+  def render(*args)
+    " "
  end
+
+  Liquid::Template.register_tag('foobar', FoobarTag)
 end

 class BlankTestFileSystem
@@ -32,78 +31,76 @@ 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 %}'))
-    end
+    assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
  end

  def test_loops_are_blank
-    assert_template_result('', wrap_in_for(' '))
+    assert_template_result("", wrap_in_for(" "))
  end

  def test_if_else_are_blank
-    assert_template_result('', '{% if true %} {% elsif false %} {% else %} {% endif %}')
+    assert_template_result("", "{% if true %} {% elsif false %} {% else %} {% endif %}")
  end

  def test_unless_is_blank
-    assert_template_result('', wrap('{% unless true %} {% endunless %}'))
+    assert_template_result("", wrap("{% unless true %} {% endunless %}"))
  end

  def test_mark_as_blank_only_during_parsing
-    assert_template_result(' ' * (N + 1), wrap(' {% if false %} this never happens, but still, this block is not blank {% endif %}'))
+    assert_template_result(" " * (N + 1), wrap(" {% if false %} this never happens, but still, this block is not blank {% endif %}"))
  end

  def test_comments_are_blank
-    assert_template_result('', wrap(' {% comment %} whatever {% endcomment %} '))
+    assert_template_result("", wrap(" {% comment %} whatever {% endcomment %} "))
  end

  def test_captures_are_blank
-    assert_template_result('', wrap(' {% capture foo %} whatever {% endcapture %} '))
+    assert_template_result("", wrap(" {% capture foo %} whatever {% endcapture %} "))
  end

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

  def test_assigns_are_blank
-    assert_template_result('', wrap(' {% assign foo = "bar" %} '))
+    assert_template_result("", wrap(' {% assign foo = "bar" %} '))
  end

  def test_whitespace_is_blank
-    assert_template_result('', wrap(' '))
-    assert_template_result('', wrap("\t"))
+    assert_template_result("", wrap(" "))
+    assert_template_result("", wrap("\t"))
  end

  def test_whitespace_is_not_blank_if_other_stuff_is_present
-    body = '     x '
+    body = "     x "
    assert_template_result(body * (N + 1), wrap(body))
  end

  def test_increment_is_not_blank
-    assert_template_result(' 0' * 2 * (N + 1), wrap('{% assign foo = 0 %} {% increment foo %} {% decrement foo %}'))
+    assert_template_result(" 0" * 2 * (N + 1), wrap("{% assign foo = 0 %} {% increment foo %} {% decrement foo %}"))
  end

  def test_cycle_is_not_blank
-    assert_template_result('  ' * ((N + 1) / 2) + ' ', wrap("{% cycle ' ', ' ' %}"))
+    assert_template_result("  " * ((N + 1) / 2) + " ", wrap("{% cycle ' ', ' ' %}"))
  end

  def test_raw_is_not_blank
-    assert_template_result('  ' * (N + 1), wrap(' {% raw %} {% endraw %}'))
+    assert_template_result("  " * (N + 1), wrap(" {% raw %} {% endraw %}"))
  end

  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 '   ' * (N + 1), wrap(" {% include ' ' %} ")
+    assert_template_result "foobar" * (N + 1), wrap("{% include 'foobar' %}")
+    assert_template_result " foobar " * (N + 1), wrap("{% include ' foobar ' %}")
+    assert_template_result "   " * (N + 1), wrap(" {% include ' ' %} ")
  end

  def test_case_is_blank
-    assert_template_result('', wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
-    assert_template_result('', wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
-    assert_template_result('   x  ' * (N + 1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
+    assert_template_result("", wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
+    assert_template_result("", wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
+    assert_template_result("   x  " * (N + 1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
  end
 end
--- a/test/integration/block_test.rb
+++ b/test/integration/block_test.rb
@@ -1,14 +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
-end
--- a/test/integration/capture_test.rb
+++ b/test/integration/capture_test.rb
@@ -1,12 +1,10 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class CaptureTest < Minitest::Test
  include Liquid

  def test_captures_block_content_in_variable
-    assert_template_result('test string', "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
+    assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
  end

  def test_capture_with_hyphen_in_variable_name
@@ -16,7 +14,7 @@ class CaptureTest < Minitest::Test
    END_TEMPLATE
    template = Template.parse(template_source)
    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
@@ -32,7 +30,7 @@ class CaptureTest < Minitest::Test
    END_TEMPLATE
    template = Template.parse(template_source)
    rendered = template.render!
-    assert_equal 'test-string', rendered.gsub(/\s/, '')
+    assert_equal "test-string", rendered.gsub(/\s/, '')
  end

  def test_assigning_from_capture
@@ -47,6 +45,6 @@ class CaptureTest < Minitest::Test
    END_TEMPLATE
    template = Template.parse(template_source)
    rendered = template.render!
-    assert_equal '3-3', rendered.gsub(/\s/, '')
+    assert_equal "3-3", rendered.gsub(/\s/, '')
  end
 end # CaptureTest
--- a/test/integration/context_test.rb
+++ b/test/integration/context_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class ContextTest < Minitest::Test
--- a/test/integration/document_test.rb
+++ b/test/integration/document_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class DocumentTest < Minitest::Test
@@ -7,14 +5,14 @@ class DocumentTest < Minitest::Test

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

  def test_unknown_tag
    exc = assert_raises(SyntaxError) do
-      Template.parse('{% foo %}')
+      Template.parse("{% foo %}")
    end
    assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
  end
--- a/test/integration/drop_test.rb
+++ b/test/integration/drop_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class ContextDrop < Liquid::Drop
@@ -15,7 +13,7 @@ class ContextDrop < Liquid::Drop
    @context['forloop.index']
  end

-  def liquid_method_missing(method)
+  def before_method(method)
    @context[method]
  end
 end
@@ -23,7 +21,7 @@ end
 class ProductDrop < Liquid::Drop
  class TextDrop < Liquid::Drop
    def array
-      %w[text1 text2]
+      ['text1', 'text2']
    end

    def text
@@ -32,8 +30,8 @@ class ProductDrop < Liquid::Drop
  end

  class CatchallDrop < Liquid::Drop
-    def liquid_method_missing(method)
-      +'catchall_method: ' << method.to_s
+    def before_method(method)
+      'method: ' << method.to_s
    end
  end

@@ -50,18 +48,18 @@ class ProductDrop < Liquid::Drop
  end

  def user_input
-    (+'foo').taint
+    "foo".taint
  end

  protected

  def callmenot
-    'protected'
+    "protected"
  end
 end

 class EnumerableDrop < Liquid::Drop
-  def liquid_method_missing(method)
+  def before_method(method)
    method
  end

@@ -95,7 +93,7 @@ end
 class RealEnumerableDrop < Liquid::Drop
  include Enumerable

-  def liquid_method_missing(method)
+  def before_method(method)
    method
  end

@@ -141,17 +139,17 @@ class DropsTest < Minitest::Test
  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.pretty_inspect }}').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: "pretty_inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal '', Liquid::Template.parse('{{ product | map: "whatever" }}').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.whatever }}").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: "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 | map: "to_liquid" | map: "texts" | map: "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)
  end

  def test_text_drop
@@ -159,14 +157,14 @@ class DropsTest < Minitest::Test
    assert_equal ' text1 ', output
  end

-  def test_catchall_unknown_method
+  def test_unknown_method
    output = Liquid::Template.parse(' {{ product.catchall.unknown }} ').render!('product' => ProductDrop.new)
-    assert_equal ' catchall_method: unknown ', output
+    assert_equal ' method: unknown ', output
  end

-  def test_catchall_integer_argument_drop
+  def test_integer_argument_drop
    output = Liquid::Template.parse(' {{ product.catchall[8] }} ').render!('product' => ProductDrop.new)
-    assert_equal ' catchall_method: 8 ', output
+    assert_equal ' method: 8 ', output
  end

  def test_text_array_drop
@@ -175,12 +173,12 @@ class DropsTest < Minitest::Test
  end

  def test_context_drop
-    output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => 'carrot')
+    output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
    assert_equal ' carrot ', output
  end

  def test_nested_context_drop
-    output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => 'monkey')
+    output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
    assert_equal ' monkey ', output
  end

@@ -190,7 +188,7 @@ class DropsTest < Minitest::Test
  end

  def test_object_methods_not_allowed
-    %i[dup clone singleton_class eval class_eval inspect].each do |method|
+    [:dup, :clone, :singleton_class, :eval, :class_eval, :inspect].each do |method|
      output = Liquid::Template.parse(" {{ product.#{method} }} ").render!('product' => ProductDrop.new)
      assert_equal '  ', output
    end
@@ -203,9 +201,9 @@ class DropsTest < Minitest::Test
  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 '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 '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 '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
@@ -233,8 +231,8 @@ class DropsTest < Minitest::Test
    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
-    %w[select each map cycle].each do |method|
+  def test_enumerable_drop_will_invoke_before_method_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' => RealEnumerableDrop.new)
@@ -243,20 +241,20 @@ class DropsTest < Minitest::Test
  end

  def test_some_enumerable_methods_still_get_invoked
-    %i[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' => EnumerableDrop.new)
-      assert_equal '3', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
+    [ :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' => 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)

-    %i[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' => EnumerableDrop.new)
-      assert_equal '1', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
+    [ :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' => EnumerableDrop.new)
+      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
    end
  end

@@ -269,7 +267,7 @@ class DropsTest < Minitest::Test
  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)
  end
 end # DropsTest
--- a/test/integration/error_handling_test.rb
+++ b/test/integration/error_handling_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class ErrorHandlingTest < Minitest::Test
@@ -85,32 +83,18 @@ class ErrorHandlingTest < Minitest::Test

  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)
-  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)
+    assert_match /Liquid syntax error \(line 4\)/, err.message
  end

  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
@@ -121,11 +105,12 @@ class ErrorHandlingTest < Minitest::Test

        bla
            ',
-                                      error_mode: :warn,
-                                      line_numbers: true)
+      error_mode: :warn,
+      line_numbers: true
+                                     )

    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
@@ -137,8 +122,9 @@ class ErrorHandlingTest < Minitest::Test

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

    assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
@@ -155,7 +141,8 @@ class ErrorHandlingTest < Minitest::Test

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

    assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
@@ -199,51 +186,27 @@ class ErrorHandlingTest < Minitest::Test
    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)
-
-    output = template.render('errors' => ErrorDrop.new)
-
+    handler = ->(e) { e.is_a?(Liquid::Error) ? e : InternalError.new('internal') }
+    output = template.render({ 'errors' => ErrorDrop.new }, exception_handler: handler)
    assert_equal 'This is a runtime error: Liquid error (line 1): internal', output
-    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 = lambda { |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 = lambda { |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
+    assert_equal [InternalError], template.errors.map(&:class)
  end

  class TestFileSystem
-    def read_template_file(_template_path)
-      '{{ errors.argument_error }}'
+    def read_template_file(template_path)
+      "{{ errors.argument_error }}"
    end
  end

@@ -258,6 +221,6 @@ class ErrorHandlingTest < Minitest::Test
      Liquid::Template.file_system = old_file_system
    end
    assert_equal "Argument error:\nLiquid error (product line 1): argument error", page
-    assert_equal 'product', template.errors.first.template_name
+    assert_equal "product", template.errors.first.template_name
  end
 end
--- a/test/integration/filter_test.rb
+++ b/test/integration/filter_test.rb
@@ -1,26 +1,24 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 module MoneyFilter
  def money(input)
-    format(' %d$ ', input)
+    sprintf(' %d$ ', input)
  end

  def money_with_underscore(input)
-    format(' %d$ ', input)
+    sprintf(' %d$ ', input)
  end
 end

 module CanadianMoneyFilter
  def money(input)
-    format(' %d$ CAD ', input)
+    sprintf(' %d$ CAD ', input)
  end
 end

 module SubstituteFilter
  def substitute(input, params = {})
-    input.gsub(/%\{(\w+)\}/) { |_match| params[Regexp.last_match(1)] }
+    input.gsub(/%\{(\w+)\}/) { |match| params[$1] }
  end
 end

@@ -28,8 +26,8 @@ class FiltersTest < Minitest::Test
  include Liquid

  module OverrideObjectMethodFilter
-    def tap(_input)
-      'tap overridden'
+    def tap(input)
+      "tap overridden"
    end
  end

@@ -41,13 +39,13 @@ class FiltersTest < Minitest::Test
    @context['var'] = 1000
    @context.add_filters(MoneyFilter)

-    assert_equal ' 1000$ ', Template.parse('{{var | money}}').render(@context)
+    assert_equal ' 1000$ ', Template.parse("{{var | money}}").render(@context)
  end

  def test_underscore_in_filter_name
    @context['var'] = 1000
    @context.add_filters(MoneyFilter)
-    assert_equal ' 1000$ ', Template.parse('{{var | money_with_underscore}}').render(@context)
+    assert_equal ' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context)
  end

  def test_second_filter_overwrites_first
@@ -55,43 +53,43 @@ class FiltersTest < Minitest::Test
    @context.add_filters(MoneyFilter)
    @context.add_filters(CanadianMoneyFilter)

-    assert_equal ' 1000$ CAD ', Template.parse('{{var | money}}').render(@context)
+    assert_equal ' 1000$ CAD ', Template.parse("{{var | money}}").render(@context)
  end

  def test_size
    @context['var'] = 'abcd'
    @context.add_filters(MoneyFilter)

-    assert_equal '4', Template.parse('{{var | size}}').render(@context)
+    assert_equal '4', Template.parse("{{var | size}}").render(@context)
  end

  def test_join
    @context['var'] = [1, 2, 3, 4]

-    assert_equal '1 2 3 4', Template.parse('{{var | join}}').render(@context)
+    assert_equal "1 2 3 4", Template.parse("{{var | join}}").render(@context)
  end

  def test_sort
    @context['value'] = 3
    @context['numbers'] = [2, 1, 4, 3]
-    @context['words'] = %w[expected as alphabetic]
-    @context['arrays'] = %w[flower are]
-    @context['case_sensitive'] = %w[sensitive Expected case]
+    @context['words'] = ['expected', 'as', 'alphabetic']
+    @context['arrays'] = ['flower', 'are']
+    @context['case_sensitive'] = ['sensitive', 'Expected', 'case']

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

  def test_sort_natural
-    @context['words'] = %w[case Assert Insensitive]
+    @context['words'] = ['case', 'Assert', 'Insensitive']
    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
    @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]

    # Test strings
-    assert_equal 'Assert case Insensitive', Template.parse('{{words | sort_natural | join}}').render(@context)
+    assert_equal 'Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context)

    # Test hashes
    assert_equal 'A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context)
@@ -106,7 +104,7 @@ class FiltersTest < Minitest::Test
    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]

    # Test strings
-    assert_equal 'a b c', Template.parse('{{words | compact | join}}').render(@context)
+    assert_equal 'a b c', Template.parse("{{words | compact | join}}").render(@context)

    # Test hashes
    assert_equal 'A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context)
@@ -116,27 +114,27 @@ class FiltersTest < Minitest::Test
  end

  def test_strip_html
-    @context['var'] = '<b>bla blub</a>'
+    @context['var'] = "<b>bla blub</a>"

-    assert_equal 'bla blub', Template.parse('{{ var | strip_html }}').render(@context)
+    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
  end

  def test_strip_html_ignore_comments_with_html
-    @context['var'] = '<!-- split and some <ul> tag --><b>bla blub</a>'
+    @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"

-    assert_equal 'bla blub', Template.parse('{{ var | strip_html }}').render(@context)
+    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
  end

  def test_capitalize
-    @context['var'] = 'blub'
+    @context['var'] = "blub"

-    assert_equal 'Blub', Template.parse('{{ var | capitalize }}').render(@context)
+    assert_equal "Blub", Template.parse("{{ var | capitalize }}").render(@context)
  end

  def test_nonexistent_filter_is_ignored
    @context['var'] = 1000

-    assert_equal '1000', Template.parse('{{ var | xyzzy }}').render(@context)
+    assert_equal '1000', Template.parse("{{ var | xyzzy }}").render(@context)
  end

  def test_filter_with_keyword_arguments
@@ -148,10 +146,10 @@ class FiltersTest < Minitest::Test
  end

  def test_override_object_method_in_filter
-    assert_equal 'tap overridden', Template.parse('{{var | tap}}').render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])
+    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])

    # tap still treated as a non-existent filter
-    assert_equal '1000', Template.parse('{{var | tap}}').render!('var' => 1000)
+    assert_equal "1000", Template.parse("{{var | tap}}").render!({ 'var' => 1000 })
  end
 end

@@ -160,15 +158,15 @@ class FiltersInTemplate < Minitest::Test

  def test_local_global
    with_global_filter(MoneyFilter) do
-      assert_equal ' 1000$ ', Template.parse('{{1000 | money}}').render!(nil, nil)
-      assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, filters: CanadianMoneyFilter)
-      assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, filters: [CanadianMoneyFilter])
+      assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: CanadianMoneyFilter)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: [CanadianMoneyFilter])
    end
  end

  def test_local_filter_with_deprecated_syntax
-    assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, CanadianMoneyFilter)
-    assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, [CanadianMoneyFilter])
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
  end
 end # FiltersTest

--- a/test/integration/hash_ordering_test.rb
+++ b/test/integration/hash_ordering_test.rb
@@ -1,25 +1,23 @@
-# frozen_string_literal: true
-
 require 'test_helper'

+module MoneyFilter
+  def money(input)
+    sprintf(' %d$ ', input)
+  end
+end
+
+module CanadianMoneyFilter
+  def money(input)
+    sprintf(' %d$ CAD ', input)
+  end
+end
+
 class HashOrderingTest < Minitest::Test
-  module MoneyFilter
-    def money(input)
-      format(' %d$ ', input)
-    end
-  end
-
-  module CanadianMoneyFilter
-    def money(input)
-      format(' %d$ CAD ', input)
-    end
-  end
-
  include Liquid

  def test_global_register_order
    with_global_filter(MoneyFilter, CanadianMoneyFilter) do
-      assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render(nil, nil)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
    end
  end
 end
--- a/test/integration/legacy_test.rb
+++ b/test/integration/legacy_test.rb
@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'liquid/legacy'
-
-class FiltersTest < Minitest::Test
-  include Liquid
-
-  def test_constants
-    assert_equal Liquid::FilterSeparator, Liquid::FILTER_SEPARATOR
-    assert_equal Liquid::BlockBody::ContentOfVariable, Liquid::BlockBody::CONTENT_OF_VARIABLE
-  end
-end
--- a/test/integration/output_test.rb
+++ b/test/integration/output_test.rb
@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 module FunnyFilter
-  def make_funny(_input)
+  def make_funny(input)
    'LOL'
  end

@@ -11,11 +9,11 @@ module FunnyFilter
    "LOL: #{input}"
  end

-  def add_smiley(input, smiley = ':-)')
+  def add_smiley(input, smiley = ":-)")
    "#{input} #{smiley}"
  end

-  def add_tag(input, tag = 'p', id = 'foo')
+  def add_tag(input, tag = "p", id = "foo")
    %(<#{tag} id="#{id}">#{input}</#{tag}>)
  end

@@ -34,7 +32,7 @@ class OutputTest < Minitest::Test
  def setup
    @assigns = {
      'best_cars' => 'bmw',
-      'car' => { 'bmw' => 'good', 'gm' => 'bad' },
+      'car' => { 'bmw' => 'good', 'gm' => 'bad' }
    }
  end

@@ -45,14 +43,6 @@ class OutputTest < Minitest::Test
    assert_equal expected, Template.parse(text).render!(@assigns)
  end

-  def test_variable_traversing_with_two_brackets
-    text = %({{ site.data.menu[include.menu][include.locale] }})
-    assert_equal 'it works!', Template.parse(text).render!(
-      'site' => { 'data' => { 'menu' => { 'foo' => { 'bar' => 'it works!' } } } },
-      'include' => { 'menu' => 'foo', 'locale' => 'bar' }
-    )
-  end
-
  def test_variable_traversing
    text = %( {{car.bmw}} {{car.gm}} {{car.bmw}} )

--- a/test/integration/parse_tree_visitor_test.rb
+++ b/test/integration/parse_tree_visitor_test.rb
@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ParseTreeVisitorTest < Minitest::Test
-  include Liquid
-
-  def test_variable
-    assert_equal(
-      ['test'],
-      visit(%({{ test }}))
-    )
-  end
-
-  def test_varible_with_filter
-    assert_equal(
-      %w[test infilter],
-      visit(%({{ test | split: infilter }}))
-    )
-  end
-
-  def test_dynamic_variable
-    assert_equal(
-      %w[test inlookup],
-      visit(%({{ test[inlookup] }}))
-    )
-  end
-
-  def test_if_condition
-    assert_equal(
-      ['test'],
-      visit(%({% if test %}{% endif %}))
-    )
-  end
-
-  def test_complex_if_condition
-    assert_equal(
-      ['test'],
-      visit(%({% if 1 == 1 and 2 == test %}{% endif %}))
-    )
-  end
-
-  def test_if_body
-    assert_equal(
-      ['test'],
-      visit(%({% if 1 == 1 %}{{ test }}{% endif %}))
-    )
-  end
-
-  def test_unless_condition
-    assert_equal(
-      ['test'],
-      visit(%({% unless test %}{% endunless %}))
-    )
-  end
-
-  def test_complex_unless_condition
-    assert_equal(
-      ['test'],
-      visit(%({% unless 1 == 1 and 2 == test %}{% endunless %}))
-    )
-  end
-
-  def test_unless_body
-    assert_equal(
-      ['test'],
-      visit(%({% unless 1 == 1 %}{{ test }}{% endunless %}))
-    )
-  end
-
-  def test_elsif_condition
-    assert_equal(
-      ['test'],
-      visit(%({% if 1 == 1 %}{% elsif test %}{% endif %}))
-    )
-  end
-
-  def test_complex_elsif_condition
-    assert_equal(
-      ['test'],
-      visit(%({% if 1 == 1 %}{% elsif 1 == 1 and 2 == test %}{% endif %}))
-    )
-  end
-
-  def test_elsif_body
-    assert_equal(
-      ['test'],
-      visit(%({% if 1 == 1 %}{% elsif 2 == 2 %}{{ test }}{% endif %}))
-    )
-  end
-
-  def test_else_body
-    assert_equal(
-      ['test'],
-      visit(%({% if 1 == 1 %}{% else %}{{ test }}{% endif %}))
-    )
-  end
-
-  def test_case_left
-    assert_equal(
-      ['test'],
-      visit(%({% case test %}{% endcase %}))
-    )
-  end
-
-  def test_case_condition
-    assert_equal(
-      ['test'],
-      visit(%({% case 1 %}{% when test %}{% endcase %}))
-    )
-  end
-
-  def test_case_when_body
-    assert_equal(
-      ['test'],
-      visit(%({% case 1 %}{% when 2 %}{{ test }}{% endcase %}))
-    )
-  end
-
-  def test_case_else_body
-    assert_equal(
-      ['test'],
-      visit(%({% case 1 %}{% else %}{{ test }}{% endcase %}))
-    )
-  end
-
-  def test_for_in
-    assert_equal(
-      ['test'],
-      visit(%({% for x in test %}{% endfor %}))
-    )
-  end
-
-  def test_for_limit
-    assert_equal(
-      ['test'],
-      visit(%({% for x in (1..5) limit: test %}{% endfor %}))
-    )
-  end
-
-  def test_for_offset
-    assert_equal(
-      ['test'],
-      visit(%({% for x in (1..5) offset: test %}{% endfor %}))
-    )
-  end
-
-  def test_for_body
-    assert_equal(
-      ['test'],
-      visit(%({% for x in (1..5) %}{{ test }}{% endfor %}))
-    )
-  end
-
-  def test_tablerow_in
-    assert_equal(
-      ['test'],
-      visit(%({% tablerow x in test %}{% endtablerow %}))
-    )
-  end
-
-  def test_tablerow_limit
-    assert_equal(
-      ['test'],
-      visit(%({% tablerow x in (1..5) limit: test %}{% endtablerow %}))
-    )
-  end
-
-  def test_tablerow_offset
-    assert_equal(
-      ['test'],
-      visit(%({% tablerow x in (1..5) offset: test %}{% endtablerow %}))
-    )
-  end
-
-  def test_tablerow_body
-    assert_equal(
-      ['test'],
-      visit(%({% tablerow x in (1..5) %}{{ test }}{% endtablerow %}))
-    )
-  end
-
-  def test_cycle
-    assert_equal(
-      ['test'],
-      visit(%({% cycle test %}))
-    )
-  end
-
-  def test_assign
-    assert_equal(
-      ['test'],
-      visit(%({% assign x = test %}))
-    )
-  end
-
-  def test_capture
-    assert_equal(
-      ['test'],
-      visit(%({% capture x %}{{ test }}{% endcapture %}))
-    )
-  end
-
-  def test_include
-    assert_equal(
-      ['test'],
-      visit(%({% include test %}))
-    )
-  end
-
-  def test_include_with
-    assert_equal(
-      ['test'],
-      visit(%({% include "hai" with test %}))
-    )
-  end
-
-  def test_include_for
-    assert_equal(
-      ['test'],
-      visit(%({% include "hai" for test %}))
-    )
-  end
-
-  def test_preserve_tree_structure
-    assert_equal(
-      [[nil, [
-        [nil, [[nil, [['other', []]]]]],
-        ['test', []],
-        ['xs', []],
-      ]]],
-      traversal(%({% for x in xs offset: test %}{{ other }}{% endfor %})).visit
-    )
-  end
-
-  private
-
-  def traversal(template)
-    ParseTreeVisitor
-      .for(Template.parse(template).root)
-      .add_callback_for(VariableLookup, &:name)
-  end
-
-  def visit(template)
-    traversal(template).visit.flatten.compact
-  end
-end
--- a/test/integration/parsing_quirks_test.rb
+++ b/test/integration/parsing_quirks_test.rb
@@ -1,43 +1,41 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class ParsingQuirksTest < Minitest::Test
  include Liquid

  def test_parsing_css
-    text = ' div { font-weight: bold; } '
+    text = " div { font-weight: bold; } "
    assert_equal text, Template.parse(text).render!
  end

  def test_raise_on_single_close_bracet
    assert_raises(SyntaxError) do
-      Template.parse('text {{method} oh nos!')
+      Template.parse("text {{method} oh nos!")
    end
  end

  def test_raise_on_label_and_no_close_bracets
    assert_raises(SyntaxError) do
-      Template.parse('TEST {{ ')
+      Template.parse("TEST {{ ")
    end
  end

  def test_raise_on_label_and_no_close_bracets_percent
    assert_raises(SyntaxError) do
-      Template.parse('TEST {% ')
+      Template.parse("TEST {% ")
    end
  end

  def test_error_on_empty_filter
-    assert Template.parse('{{test}}')
+    assert Template.parse("{{test}}")

    with_error_mode(:lax) do
-      assert Template.parse('{{|test}}')
+      assert Template.parse("{{|test}}")
    end

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

@@ -53,20 +51,20 @@ class ParsingQuirksTest < Minitest::Test
  def test_unexpected_characters_syntax_error
    with_error_mode(:strict) do
      assert_raises(SyntaxError) do
-        markup = 'true && false'
+        markup = "true && false"
        Template.parse("{% if #{markup} %} YES {% endif %}")
      end
      assert_raises(SyntaxError) do
-        markup = 'false || true'
+        markup = "false || true"
        Template.parse("{% if #{markup} %} YES {% endif %}")
      end
    end
  end

  def test_no_error_on_lax_empty_filter
-    assert Template.parse('{{test |a|b|}}', error_mode: :lax)
-    assert Template.parse('{{test}}', error_mode: :lax)
-    assert Template.parse('{{|test|}}', error_mode: :lax)
+    assert Template.parse("{{test |a|b|}}", error_mode: :lax)
+    assert Template.parse("{{test}}", error_mode: :lax)
+    assert Template.parse("{{|test|}}", error_mode: :lax)
  end

  def test_meaningless_parens_lax
@@ -79,9 +77,9 @@ class ParsingQuirksTest < Minitest::Test

  def test_unexpected_characters_silently_eat_logic_lax
    with_error_mode(:lax) do
-      markup = 'true && false'
+      markup = "true && false"
      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
-      markup = 'false || true'
+      markup = "false || true"
      assert_template_result('', "{% if #{markup} %} YES {% endif %}")
    end
  end
@@ -101,7 +99,7 @@ class ParsingQuirksTest < Minitest::Test
      # After the messed up quotes a filter without parameters (reverse) should work
      # but one with parameters (remove) shouldn't be detected.
      assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
-      assert_template_result('hi ', "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
+      assert_template_result('hi ',  "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
    end
  end

@@ -114,11 +112,7 @@ class ParsingQuirksTest < Minitest::Test

  def test_extra_dots_in_ranges
    with_error_mode(:lax) do
-      assert_template_result('12345', '{% for i in (1...5) %}{{ i }}{% endfor %}')
+      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
    end
  end
-
-  def test_contains_in_id
-    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
-  end
 end # ParsingQuirksTest
--- a/test/integration/render_profiling_test.rb
+++ b/test/integration/render_profiling_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class RenderProfilingTest < Minitest::Test
@@ -74,7 +72,7 @@ class RenderProfilingTest < Minitest::Test
    t = Template.parse("{% include 'a_template' %}", profile: true)
    t.render!

-    assert t.profiler.total_render_time >= 0, 'Total render time was not calculated'
+    assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
  end

  def test_profiling_uses_include_to_mark_children
@@ -91,7 +89,7 @@ class RenderProfilingTest < Minitest::Test

    include_node = t.profiler[1]
    include_node.children.each do |child|
-      assert_equal 'a_template', child.partial
+      assert_equal "a_template", child.partial
    end
  end

@@ -101,12 +99,12 @@ class RenderProfilingTest < Minitest::Test

    a_template = t.profiler[1]
    a_template.children.each do |child|
-      assert_equal 'a_template', child.partial
+      assert_equal "a_template", child.partial
    end

    b_template = t.profiler[2]
    b_template.children.each do |child|
-      assert_equal 'b_template', child.partial
+      assert_equal "b_template", child.partial
    end
  end

@@ -116,12 +114,12 @@ class RenderProfilingTest < Minitest::Test

    a_template1 = t.profiler[1]
    a_template1.children.each do |child|
-      assert_equal 'a_template', child.partial
+      assert_equal "a_template", child.partial
    end

    a_template2 = t.profiler[2]
    a_template2.children.each do |child|
-      assert_equal 'a_template', child.partial
+      assert_equal "a_template", child.partial
    end
  end

@@ -130,7 +128,7 @@ class RenderProfilingTest < Minitest::Test
    t.render!

    timing_count = 0
-    t.profiler.each do |_timing|
+    t.profiler.each do |timing|
      timing_count += 1
    end

@@ -138,7 +136,7 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_profiling_marks_children_of_if_blocks
-    t = Template.parse('{% if true %} {% increment test %} {{ test }} {% endif %}', profile: true)
+    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true)
    t.render!

    assert_equal 1, t.profiler.length
@@ -146,8 +144,8 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_profiling_marks_children_of_for_blocks
-    t = Template.parse('{% for item in collection %} {{ item }} {% endfor %}', profile: true)
-    t.render!('collection' => %w[one two])
+    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
+    t.render!({ "collection" => ["one", "two"] })

    assert_equal 1, t.profiler.length
    # Will profile each invocation of the for block
--- a/test/integration/security_test.rb
+++ b/test/integration/security_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 module SecurityFilter
@@ -11,10 +9,6 @@ end
 class SecurityTest < Minitest::Test
  include Liquid

-  def setup
-    @assigns = {}
-  end
-
  def test_no_instance_eval
    text = %( {{ '1+1' | instance_eval }} )
    expected = %( 1+1 )
@@ -59,24 +53,10 @@ class SecurityTest < Minitest::Test
    current_symbols = Symbol.all_symbols

    assigns = { 'drop' => Drop.new }
-    assert_equal '', Template.parse('{{ drop.custom_method_1 }}', assigns).render!
-    assert_equal '', Template.parse('{{ drop.custom_method_2 }}', assigns).render!
-    assert_equal '', Template.parse('{{ drop.custom_method_3 }}', assigns).render!
+    assert_equal "", Template.parse("{{ drop.custom_method_1 }}", assigns).render!
+    assert_equal "", Template.parse("{{ drop.custom_method_2 }}", assigns).render!
+    assert_equal "", Template.parse("{{ drop.custom_method_3 }}", assigns).render!

    assert_equal [], (Symbol.all_symbols - current_symbols)
  end
-
-  def test_max_depth_nested_blocks_does_not_raise_exception
-    depth = Liquid::Block::MAX_DEPTH
-    code = '{% if true %}' * depth + 'rendered' + '{% endif %}' * depth
-    assert_equal 'rendered', Template.parse(code).render!
-  end
-
-  def test_more_than_max_depth_nested_blocks_raises_exception
-    depth = Liquid::Block::MAX_DEPTH + 1
-    code = '{% if true %}' * depth + 'rendered' + '{% endif %}' * depth
-    assert_raises(Liquid::StackLevelError) do
-      Template.parse(code).render!
-    end
-  end
 end # SecurityTest
--- a/test/integration/standard_filter_test.rb
+++ b/test/integration/standard_filter_test.rb
@@ -1,4 +1,4 @@
-# frozen_string_literal: true
+# encoding: utf-8

 require 'test_helper'

@@ -17,7 +17,7 @@ class TestThing
    "woot: #{@foo}"
  end

-  def [](_whatever)
+  def [](whatever)
    to_s
  end

@@ -29,7 +29,7 @@ end

 class TestDrop < Liquid::Drop
  def test
-    'testfoo'
+    "testfoo"
  end
 end

@@ -37,17 +37,7 @@ class TestEnumerable < Liquid::Drop
  include Enumerable

  def each(&block)
-    [{ 'foo' => 1, 'bar' => 2 }, { 'foo' => 2, 'bar' => 1 }, { 'foo' => 3, 'bar' => 3 }].each(&block)
-  end
-end
-
-class NumberLikeThing < Liquid::Drop
-  def initialize(amount)
-    @amount = amount
-  end
-
-  def to_number
-    @amount
+    [ { "foo" => 1, "bar" => 2 }, { "foo" => 2, "bar" => 1 }, { "foo" => 3, "bar" => 3 } ].each(&block)
  end
 end

@@ -65,12 +55,12 @@ class StandardFiltersTest < Minitest::Test
  end

  def test_downcase
-    assert_equal 'testing', @filters.downcase('Testing')
+    assert_equal 'testing', @filters.downcase("Testing")
    assert_equal '', @filters.downcase(nil)
  end

  def test_upcase
-    assert_equal 'TESTING', @filters.upcase('Testing')
+    assert_equal 'TESTING', @filters.upcase("Testing")
    assert_equal '', @filters.upcase(nil)
  end

@@ -91,22 +81,22 @@ class StandardFiltersTest < Minitest::Test
      @filters.slice('foobar', nil)
    end
    assert_raises(Liquid::ArgumentError) do
-      @filters.slice('foobar', 0, '')
+      @filters.slice('foobar', 0, "")
    end
  end

  def test_slice_on_arrays
    input = 'foobar'.split(//)
-    assert_equal %w[o o b], @filters.slice(input, 1, 3)
-    assert_equal %w[o o b a r], @filters.slice(input, 1, 1000)
-    assert_equal %w[], @filters.slice(input, 1, 0)
-    assert_equal %w[o], @filters.slice(input, 1, 1)
-    assert_equal %w[b a r], @filters.slice(input, 3, 3)
-    assert_equal %w[a r], @filters.slice(input, -2, 2)
-    assert_equal %w[a r], @filters.slice(input, -2, 1000)
-    assert_equal %w[r], @filters.slice(input, -1)
-    assert_equal %w[], @filters.slice(input, 100, 10)
-    assert_equal %w[], @filters.slice(input, -100, 10)
+    assert_equal %w(o o b), @filters.slice(input, 1, 3)
+    assert_equal %w(o o b a r), @filters.slice(input, 1, 1000)
+    assert_equal %w(), @filters.slice(input, 1, 0)
+    assert_equal %w(o), @filters.slice(input, 1, 1)
+    assert_equal %w(b a r), @filters.slice(input, 3, 3)
+    assert_equal %w(a r), @filters.slice(input, -2, 2)
+    assert_equal %w(a r), @filters.slice(input, -2, 1000)
+    assert_equal %w(r), @filters.slice(input, -1)
+    assert_equal %w(), @filters.slice(input, 100, 10)
+    assert_equal %w(), @filters.slice(input, -100, 10)
  end

  def test_truncate
@@ -114,30 +104,21 @@ class StandardFiltersTest < Minitest::Test
    assert_equal '1234567890', @filters.truncate('1234567890', 20)
    assert_equal '...', @filters.truncate('1234567890', 0)
    assert_equal '1234567890', @filters.truncate('1234567890')
-    assert_equal '测试...', @filters.truncate('测试测试测试测试', 5)
-    assert_equal '12341', @filters.truncate('1234567890', 5, 1)
+    assert_equal "测试...", @filters.truncate("测试测试测试测试", 5)
  end

  def test_split
-    assert_equal %w[12 34], @filters.split('12~34', '~')
+    assert_equal ['12', '34'], @filters.split('12~34', '~')
    assert_equal ['A? ', ' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
    assert_equal ['A?Z'], @filters.split('A?Z', '~')
+    # Regexp works although Liquid does not support.
+    assert_equal ['A', 'Z'], @filters.split('AxZ', /x/)
    assert_equal [], @filters.split(nil, ' ')
-    assert_equal %w[A Z], @filters.split('A1Z', 1)
  end

  def test_escape
    assert_equal '&lt;strong&gt;', @filters.escape('<strong>')
-    assert_equal '1', @filters.escape(1)
-    assert_equal '2001-02-03', @filters.escape(Date.new(2001, 2, 3))
-    assert_nil @filters.escape(nil)
-  end
-
-  def test_h
    assert_equal '&lt;strong&gt;', @filters.h('<strong>')
-    assert_equal '1', @filters.h(1)
-    assert_equal '2001-02-03', @filters.h(Date.new(2001, 2, 3))
-    assert_nil @filters.h(nil)
  end

  def test_escape_once
@@ -146,22 +127,7 @@ class StandardFiltersTest < Minitest::Test

  def test_url_encode
    assert_equal 'foo%2B1%40example.com', @filters.url_encode('foo+1@example.com')
-    assert_equal '1', @filters.url_encode(1)
-    assert_equal '2001-02-03', @filters.url_encode(Date.new(2001, 2, 3))
-    assert_nil @filters.url_encode(nil)
-  end
-
-  def test_url_decode
-    assert_equal 'foo bar', @filters.url_decode('foo+bar')
-    assert_equal 'foo bar', @filters.url_decode('foo%20bar')
-    assert_equal 'foo+1@example.com', @filters.url_decode('foo%2B1%40example.com')
-    assert_equal '1', @filters.url_decode(1)
-    assert_equal '2001-02-03', @filters.url_decode(Date.new(2001, 2, 3))
-    assert_nil @filters.url_decode(nil)
-    exception = assert_raises Liquid::ArgumentError do
-      @filters.url_decode('%ff')
-    end
-    assert_equal 'Liquid error: invalid byte sequence in UTF-8', exception.message
+    assert_equal nil, @filters.url_encode(nil)
  end

  def test_truncatewords
@@ -169,191 +135,48 @@ class StandardFiltersTest < Minitest::Test
    assert_equal 'one two...', @filters.truncatewords('one two three', 2)
    assert_equal 'one two three', @filters.truncatewords('one two three')
    assert_equal 'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...', @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
-    assert_equal '测试测试测试测试', @filters.truncatewords('测试测试测试测试', 5)
-    assert_equal 'one two1', @filters.truncatewords('one two three', 2, 1)
+    assert_equal "测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5)
  end

  def test_strip_html
-    assert_equal 'test', @filters.strip_html('<div>test</div>')
+    assert_equal 'test', @filters.strip_html("<div>test</div>")
    assert_equal 'test', @filters.strip_html("<div id='test'>test</div>")
    assert_equal '', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>")
    assert_equal '', @filters.strip_html("<style type='text/css'>foo bar</style>")
    assert_equal 'test', @filters.strip_html("<div\nclass='multiline'>test</div>")
    assert_equal 'test', @filters.strip_html("<!-- foo bar \n test -->test")
    assert_equal '', @filters.strip_html(nil)
-
-    # Quirk of the existing implementation
-    assert_equal 'foo;', @filters.strip_html('<<<script </script>script>foo;</script>')
  end

  def test_join
    assert_equal '1 2 3 4', @filters.join([1, 2, 3, 4])
    assert_equal '1 - 2 - 3 - 4', @filters.join([1, 2, 3, 4], ' - ')
-    assert_equal '1121314', @filters.join([1, 2, 3, 4], 1)
  end

  def test_sort
    assert_equal [1, 2, 3, 4], @filters.sort([4, 3, 2, 1])
-    assert_equal [{ 'a' => 1 }, { 'a' => 2 }, { 'a' => 3 }, { 'a' => 4 }], @filters.sort([{ 'a' => 4 }, { 'a' => 3 }, { 'a' => 1 }, { 'a' => 2 }], 'a')
-  end
-
-  def test_sort_with_nils
-    assert_equal [1, 2, 3, 4, nil], @filters.sort([nil, 4, 3, 2, 1])
-    assert_equal [{ 'a' => 1 }, { 'a' => 2 }, { 'a' => 3 }, { 'a' => 4 }, {}], @filters.sort([{ 'a' => 4 }, { 'a' => 3 }, {}, { 'a' => 1 }, { 'a' => 2 }], 'a')
-  end
-
-  def test_sort_when_property_is_sometimes_missing_puts_nils_last
-    input = [
-      { 'price' => 4, 'handle' => 'alpha' },
-      { 'handle' => 'beta' },
-      { 'price' => 1, 'handle' => 'gamma' },
-      { 'handle' => 'delta' },
-      { 'price' => 2, 'handle' => 'epsilon' },
-    ]
-    expectation = [
-      { 'price' => 1, 'handle' => 'gamma' },
-      { 'price' => 2, 'handle' => 'epsilon' },
-      { 'price' => 4, 'handle' => 'alpha' },
-      { 'handle' => 'delta' },
-      { 'handle' => 'beta' },
-    ]
-    assert_equal expectation, @filters.sort(input, 'price')
-  end
-
-  def test_sort_natural
-    assert_equal %w[a B c D], @filters.sort_natural(%w[c D a B])
-    assert_equal [{ 'a' => 'a' }, { 'a' => 'B' }, { 'a' => 'c' }, { 'a' => 'D' }], @filters.sort_natural([{ 'a' => 'D' }, { 'a' => 'c' }, { 'a' => 'a' }, { 'a' => 'B' }], 'a')
-  end
-
-  def test_sort_natural_with_nils
-    assert_equal ['a', 'B', 'c', 'D', nil], @filters.sort_natural([nil, 'c', 'D', 'a', 'B'])
-    assert_equal [{ 'a' => 'a' }, { 'a' => 'B' }, { 'a' => 'c' }, { 'a' => 'D' }, {}], @filters.sort_natural([{ 'a' => 'D' }, { 'a' => 'c' }, {}, { 'a' => 'a' }, { 'a' => 'B' }], 'a')
-  end
-
-  def test_sort_natural_when_property_is_sometimes_missing_puts_nils_last
-    input = [
-      { 'price' => '4', 'handle' => 'alpha' },
-      { 'handle' => 'beta' },
-      { 'price' => '1', 'handle' => 'gamma' },
-      { 'handle' => 'delta' },
-      { 'price' => 2, 'handle' => 'epsilon' },
-    ]
-    expectation = [
-      { 'price' => '1', 'handle' => 'gamma' },
-      { 'price' => 2, 'handle' => 'epsilon' },
-      { 'price' => '4', 'handle' => 'alpha' },
-      { 'handle' => 'delta' },
-      { 'handle' => 'beta' },
-    ]
-    assert_equal expectation, @filters.sort_natural(input, 'price')
-  end
-
-  def test_sort_natural_case_check
-    input = [
-      { 'key' => 'X' },
-      { 'key' => 'Y' },
-      { 'key' => 'Z' },
-      { 'fake' => 't' },
-      { 'key' => 'a' },
-      { 'key' => 'b' },
-      { 'key' => 'c' },
-    ]
-    expectation = [
-      { 'key' => 'a' },
-      { 'key' => 'b' },
-      { 'key' => 'c' },
-      { 'key' => 'X' },
-      { 'key' => 'Y' },
-      { 'key' => 'Z' },
-      { 'fake' => 't' },
-    ]
-    assert_equal expectation, @filters.sort_natural(input, 'key')
-    assert_equal %w[a b c X Y Z], @filters.sort_natural(%w[X Y Z a b c])
-  end
-
-  def test_sort_empty_array
-    assert_equal [], @filters.sort([], 'a')
-  end
-
-  def test_sort_invalid_property
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-
-    assert_raises Liquid::ArgumentError do
-      @filters.sort(foo, 'bar')
-    end
-  end
-
-  def test_sort_natural_empty_array
-    assert_equal [], @filters.sort_natural([], 'a')
-  end
-
-  def test_sort_natural_invalid_property
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-
-    assert_raises Liquid::ArgumentError do
-      @filters.sort_natural(foo, 'bar')
-    end
+    assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], @filters.sort([{ "a" => 4 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
  end

  def test_legacy_sort_hash
-    assert_equal [{ a: 1, b: 2 }], @filters.sort(a: 1, b: 2)
+    assert_equal [{ a: 1, b: 2 }], @filters.sort({ a: 1, b: 2 })
  end

  def test_numerical_vs_lexicographical_sort
    assert_equal [2, 10], @filters.sort([10, 2])
-    assert_equal [{ 'a' => 2 }, { 'a' => 10 }], @filters.sort([{ 'a' => 10 }, { 'a' => 2 }], 'a')
-    assert_equal %w[10 2], @filters.sort(%w[10 2])
-    assert_equal [{ 'a' => '10' }, { 'a' => '2' }], @filters.sort([{ 'a' => '10' }, { 'a' => '2' }], 'a')
+    assert_equal [{ "a" => 2 }, { "a" => 10 }], @filters.sort([{ "a" => 10 }, { "a" => 2 }], "a")
+    assert_equal ["10", "2"], @filters.sort(["10", "2"])
+    assert_equal [{ "a" => "10" }, { "a" => "2" }], @filters.sort([{ "a" => "10" }, { "a" => "2" }], "a")
  end

  def test_uniq
-    assert_equal ['foo'], @filters.uniq('foo')
+    assert_equal ["foo"], @filters.uniq("foo")
    assert_equal [1, 3, 2, 4], @filters.uniq([1, 1, 3, 2, 3, 1, 4, 3, 2, 1])
-    assert_equal [{ 'a' => 1 }, { 'a' => 3 }, { 'a' => 2 }], @filters.uniq([{ 'a' => 1 }, { 'a' => 3 }, { 'a' => 1 }, { 'a' => 2 }], 'a')
+    assert_equal [{ "a" => 1 }, { "a" => 3 }, { "a" => 2 }], @filters.uniq([{ "a" => 1 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
    testdrop = TestDrop.new
    assert_equal [testdrop], @filters.uniq([testdrop, TestDrop.new], 'test')
  end

-  def test_uniq_empty_array
-    assert_equal [], @filters.uniq([], 'a')
-  end
-
-  def test_uniq_invalid_property
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-
-    assert_raises Liquid::ArgumentError do
-      @filters.uniq(foo, 'bar')
-    end
-  end
-
-  def test_compact_empty_array
-    assert_equal [], @filters.compact([], 'a')
-  end
-
-  def test_compact_invalid_property
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-
-    assert_raises Liquid::ArgumentError do
-      @filters.compact(foo, 'bar')
-    end
-  end
-
  def test_reverse
    assert_equal [4, 3, 2, 1], @filters.reverse([1, 2, 3, 4])
  end
@@ -363,87 +186,51 @@ class StandardFiltersTest < Minitest::Test
  end

  def test_map
-    assert_equal [1, 2, 3, 4], @filters.map([{ 'a' => 1 }, { 'a' => 2 }, { 'a' => 3 }, { 'a' => 4 }], 'a')
+    assert_equal [1, 2, 3, 4], @filters.map([{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], 'a')
    assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
-                           'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }]
+      'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }]
  end

  def test_map_doesnt_call_arbitrary_stuff
-    assert_template_result '', '{{ "foo" | map: "__id__" }}'
-    assert_template_result '', '{{ "foo" | map: "inspect" }}'
+    assert_template_result "", '{{ "foo" | map: "__id__" }}'
+    assert_template_result "", '{{ "foo" | map: "inspect" }}'
  end

  def test_map_calls_to_liquid
    t = TestThing.new
-    assert_template_result 'woot: 1', '{{ foo | map: "whatever" }}', 'foo' => [t]
+    assert_template_result "woot: 1", '{{ foo | map: "whatever" }}', "foo" => [t]
  end

  def test_map_on_hashes
-    assert_template_result '4217', '{{ thing | map: "foo" | map: "bar" }}',
-                           'thing' => { 'foo' => [{ 'bar' => 42 }, { 'bar' => 17 }] }
+    assert_template_result "4217", '{{ thing | map: "foo" | map: "bar" }}',
+      "thing" => { "foo" => [ { "bar" => 42 }, { "bar" => 17 } ] }
  end

  def test_legacy_map_on_hashes_with_dynamic_key
    template = "{% assign key = 'foo' %}{{ thing | map: key | map: 'bar' }}"
-    hash = { 'foo' => { 'bar' => 42 } }
-    assert_template_result '42', template, 'thing' => hash
+    hash = { "foo" => { "bar" => 42 } }
+    assert_template_result "42", template, "thing" => hash
  end

  def test_sort_calls_to_liquid
    t = TestThing.new
-    Liquid::Template.parse('{{ foo | sort: "whatever" }}').render('foo' => [t])
-    assert t.foo.positive?
+    Liquid::Template.parse('{{ foo | sort: "whatever" }}').render("foo" => [t])
+    assert t.foo > 0
  end

  def test_map_over_proc
    drop = TestDrop.new
-    p = proc { drop }
+    p = proc{ drop }
    templ = '{{ procs | map: "test" }}'
-    assert_template_result 'testfoo', templ, 'procs' => [p]
-  end
-
-  def test_map_over_drops_returning_procs
-    drops = [
-      {
-        'proc' => -> { 'foo' },
-      },
-      {
-        'proc' => -> { 'bar' },
-      },
-    ]
-    templ = '{{ drops | map: "proc" }}'
-    assert_template_result 'foobar', templ, 'drops' => drops
+    assert_template_result "testfoo", templ, "procs" => [p]
  end

  def test_map_works_on_enumerables
-    assert_template_result '123', '{{ foo | map: "foo" }}', 'foo' => TestEnumerable.new
-  end
-
-  def test_map_returns_empty_on_2d_input_array
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-
-    assert_raises Liquid::ArgumentError do
-      @filters.map(foo, 'bar')
-    end
-  end
-
-  def test_map_returns_empty_with_no_property
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-    assert_raises Liquid::ArgumentError do
-      @filters.map(foo, nil)
-    end
+    assert_template_result "123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new
  end

  def test_sort_works_on_enumerables
-    assert_template_result '213', '{{ foo | sort: "bar" | map: "foo" }}', 'foo' => TestEnumerable.new
+    assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new
  end

  def test_first_and_last_call_to_liquid
@@ -451,46 +238,40 @@ class StandardFiltersTest < Minitest::Test
    assert_template_result 'foobar', '{{ foo | last }}', 'foo' => [ThingWithToLiquid.new]
  end

-  def test_truncate_calls_to_liquid
-    assert_template_result 'wo...', '{{ foo | truncate: 5 }}', 'foo' => TestThing.new
-  end
-
  def test_date
-    assert_equal 'May', @filters.date(Time.parse('2006-05-05 10:00:00'), '%B')
-    assert_equal 'June', @filters.date(Time.parse('2006-06-05 10:00:00'), '%B')
-    assert_equal 'July', @filters.date(Time.parse('2006-07-05 10:00:00'), '%B')
+    assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
+    assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")
+    assert_equal 'July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B")

-    assert_equal 'May', @filters.date('2006-05-05 10:00:00', '%B')
-    assert_equal 'June', @filters.date('2006-06-05 10:00:00', '%B')
-    assert_equal 'July', @filters.date('2006-07-05 10:00:00', '%B')
+    assert_equal 'May', @filters.date("2006-05-05 10:00:00", "%B")
+    assert_equal 'June', @filters.date("2006-06-05 10:00:00", "%B")
+    assert_equal 'July', @filters.date("2006-07-05 10:00:00", "%B")

-    assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', '')
-    assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', '')
-    assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', '')
-    assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', nil)
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil)

-    assert_equal '07/05/2006', @filters.date('2006-07-05 10:00:00', '%m/%d/%Y')
+    assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")

-    assert_equal '07/16/2004', @filters.date('Fri Jul 16 01:00:00 2004', '%m/%d/%Y')
-    assert_equal Date.today.year.to_s, @filters.date('now', '%Y')
-    assert_equal Date.today.year.to_s, @filters.date('today', '%Y')
-    assert_equal Date.today.year.to_s, @filters.date('Today', '%Y')
+    assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
+    assert_equal "#{Date.today.year}", @filters.date('now', '%Y')
+    assert_equal "#{Date.today.year}", @filters.date('today', '%Y')
+    assert_equal "#{Date.today.year}", @filters.date('Today', '%Y')

-    assert_nil @filters.date(nil, '%B')
+    assert_equal nil, @filters.date(nil, "%B")

-    assert_equal '', @filters.date('', '%B')
+    assert_equal '', @filters.date('', "%B")

-    with_timezone('UTC') do
-      assert_equal '07/05/2006', @filters.date(1_152_098_955, '%m/%d/%Y')
-      assert_equal '07/05/2006', @filters.date('1152098955', '%m/%d/%Y')
-    end
+    assert_equal "07/05/2006", @filters.date(1152098955, "%m/%d/%Y")
+    assert_equal "07/05/2006", @filters.date("1152098955", "%m/%d/%Y")
  end

  def test_first_last
    assert_equal 1, @filters.first([1, 2, 3])
    assert_equal 3, @filters.last([1, 2, 3])
-    assert_nil @filters.first([])
-    assert_nil @filters.last([])
+    assert_equal nil, @filters.first([])
+    assert_equal nil, @filters.last([])
  end

  def test_replace
@@ -502,10 +283,10 @@ class StandardFiltersTest < Minitest::Test
  end

  def test_remove
-    assert_equal '   ', @filters.remove('a a a a', 'a')
-    assert_equal '   ', @filters.remove('1 1 1 1', 1)
-    assert_equal 'a a a', @filters.remove_first('a a a a', 'a ')
-    assert_equal ' 1 1 1', @filters.remove_first('1 1 1 1', 1)
+    assert_equal '   ', @filters.remove("a a a a", 'a')
+    assert_equal '   ', @filters.remove("1 1 1 1", 1)
+    assert_equal 'a a a', @filters.remove_first("a a a a", 'a ')
+    assert_equal ' 1 1 1', @filters.remove_first("1 1 1 1", 1)
    assert_template_result 'a a a', "{{ 'a a a a' | remove_first: 'a ' }}"
  end

@@ -514,148 +295,97 @@ class StandardFiltersTest < Minitest::Test
  end

  def test_strip
-    assert_template_result 'ab c', '{{ source | strip }}', 'source' => ' ab c  '
-    assert_template_result 'ab c', '{{ source | strip }}', 'source' => " \tab c  \n \t"
+    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " ab c  "
+    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " \tab c  \n \t"
  end

  def test_lstrip
-    assert_template_result 'ab c  ', '{{ source | lstrip }}', 'source' => ' ab c  '
-    assert_template_result "ab c  \n \t", '{{ source | lstrip }}', 'source' => " \tab c  \n \t"
+    assert_template_result 'ab c  ', "{{ source | lstrip }}", 'source' => " ab c  "
+    assert_template_result "ab c  \n \t", "{{ source | lstrip }}", 'source' => " \tab c  \n \t"
  end

  def test_rstrip
-    assert_template_result ' ab c', '{{ source | rstrip }}', 'source' => ' ab c  '
-    assert_template_result " \tab c", '{{ source | rstrip }}', 'source' => " \tab c  \n \t"
+    assert_template_result " ab c", "{{ source | rstrip }}", 'source' => " ab c  "
+    assert_template_result " \tab c", "{{ source | rstrip }}", 'source' => " \tab c  \n \t"
  end

  def test_strip_newlines
-    assert_template_result 'abc', '{{ source | strip_newlines }}', 'source' => "a\nb\nc"
-    assert_template_result 'abc', '{{ source | strip_newlines }}', 'source' => "a\r\nb\nc"
+    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc"
+    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc"
  end

  def test_newlines_to_br
-    assert_template_result "a<br />\nb<br />\nc", '{{ source | newline_to_br }}', 'source' => "a\nb\nc"
+    assert_template_result "a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc"
  end

  def test_plus
-    assert_template_result '2', '{{ 1 | plus:1 }}'
-    assert_template_result '2.0', "{{ '1' | plus:'1.0' }}"
-
-    assert_template_result '5', "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3)
+    assert_template_result "2", "{{ 1 | plus:1 }}"
+    assert_template_result "2.0", "{{ '1' | plus:'1.0' }}"
  end

  def test_minus
-    assert_template_result '4', '{{ input | minus:operand }}', 'input' => 5, 'operand' => 1
-    assert_template_result '2.3', "{{ '4.3' | minus:'2' }}"
-
-    assert_template_result '5', "{{ price | minus:'2' }}", 'price' => NumberLikeThing.new(7)
-  end
-
-  def test_abs
-    assert_template_result '17', '{{ 17 | abs }}'
-    assert_template_result '17', '{{ -17 | abs }}'
-    assert_template_result '17', "{{ '17' | abs }}"
-    assert_template_result '17', "{{ '-17' | abs }}"
-    assert_template_result '0', '{{ 0 | abs }}'
-    assert_template_result '0', "{{ '0' | abs }}"
-    assert_template_result '17.42', '{{ 17.42 | abs }}'
-    assert_template_result '17.42', '{{ -17.42 | abs }}'
-    assert_template_result '17.42', "{{ '17.42' | abs }}"
-    assert_template_result '17.42', "{{ '-17.42' | abs }}"
+    assert_template_result "4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1
+    assert_template_result "2.3", "{{ '4.3' | minus:'2' }}"
  end

  def test_times
-    assert_template_result '12', '{{ 3 | times:4 }}'
-    assert_template_result '0', "{{ 'foo' | times:4 }}"
-    assert_template_result '6', "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
-    assert_template_result '7.25', '{{ 0.0725 | times:100 }}'
-    assert_template_result '-7.25', '{{ "-0.0725" | times:100 }}'
-    assert_template_result '7.25', '{{ "-0.0725" | times: -100 }}'
-    assert_template_result '4', '{{ price | times:2 }}', 'price' => NumberLikeThing.new(2)
+    assert_template_result "12", "{{ 3 | times:4 }}"
+    assert_template_result "0", "{{ 'foo' | times:4 }}"
+
+    assert_template_result "6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
+
+    assert_template_result "7.25", "{{ 0.0725 | times:100 }}"
  end

  def test_divided_by
-    assert_template_result '4', '{{ 12 | divided_by:3 }}'
-    assert_template_result '4', '{{ 14 | divided_by:3 }}'
+    assert_template_result "4", "{{ 12 | divided_by:3 }}"
+    assert_template_result "4", "{{ 14 | divided_by:3 }}"

-    assert_template_result '5', '{{ 15 | divided_by:3 }}'
-    assert_equal 'Liquid error: divided by 0', Template.parse('{{ 5 | divided_by:0 }}').render
+    assert_template_result "5", "{{ 15 | divided_by:3 }}"
+    assert_equal "Liquid error: divided by 0", Template.parse("{{ 5 | divided_by:0 }}").render

-    assert_template_result '0.5', '{{ 2.0 | divided_by:4 }}'
+    assert_template_result "0.5", "{{ 2.0 | divided_by:4 }}"
    assert_raises(Liquid::ZeroDivisionError) do
-      assert_template_result '4', '{{ 1 | modulo: 0 }}'
+      assert_template_result "4", "{{ 1 | modulo: 0 }}"
    end
-
-    assert_template_result '5', '{{ price | divided_by:2 }}', 'price' => NumberLikeThing.new(10)
  end

  def test_modulo
-    assert_template_result '1', '{{ 3 | modulo:2 }}'
+    assert_template_result "1", "{{ 3 | modulo:2 }}"
    assert_raises(Liquid::ZeroDivisionError) do
-      assert_template_result '4', '{{ 1 | modulo: 0 }}'
+      assert_template_result "4", "{{ 1 | modulo: 0 }}"
    end
-
-    assert_template_result '1', '{{ price | modulo:2 }}', 'price' => NumberLikeThing.new(3)
  end

  def test_round
-    assert_template_result '5', '{{ input | round }}', 'input' => 4.6
-    assert_template_result '4', "{{ '4.3' | round }}"
-    assert_template_result '4.56', '{{ input | round: 2 }}', 'input' => 4.5612
+    assert_template_result "5", "{{ input | round }}", 'input' => 4.6
+    assert_template_result "4", "{{ '4.3' | round }}"
+    assert_template_result "4.56", "{{ input | round: 2 }}", 'input' => 4.5612
    assert_raises(Liquid::FloatDomainError) do
-      assert_template_result '4', '{{ 1.0 | divided_by: 0.0 | round }}'
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | round }}"
    end
-
-    assert_template_result '5', '{{ price | round }}', 'price' => NumberLikeThing.new(4.6)
-    assert_template_result '4', '{{ price | round }}', 'price' => NumberLikeThing.new(4.3)
  end

  def test_ceil
-    assert_template_result '5', '{{ input | ceil }}', 'input' => 4.6
-    assert_template_result '5', "{{ '4.3' | ceil }}"
+    assert_template_result "5", "{{ input | ceil }}", 'input' => 4.6
+    assert_template_result "5", "{{ '4.3' | ceil }}"
    assert_raises(Liquid::FloatDomainError) do
-      assert_template_result '4', '{{ 1.0 | divided_by: 0.0 | ceil }}'
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | ceil }}"
    end
-
-    assert_template_result '5', '{{ price | ceil }}', 'price' => NumberLikeThing.new(4.6)
  end

  def test_floor
-    assert_template_result '4', '{{ input | floor }}', 'input' => 4.6
-    assert_template_result '4', "{{ '4.3' | floor }}"
+    assert_template_result "4", "{{ input | floor }}", 'input' => 4.6
+    assert_template_result "4", "{{ '4.3' | floor }}"
    assert_raises(Liquid::FloatDomainError) do
-      assert_template_result '4', '{{ 1.0 | divided_by: 0.0 | floor }}'
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | floor }}"
    end
-
-    assert_template_result '5', '{{ price | floor }}', 'price' => NumberLikeThing.new(5.4)
-  end
-
-  def test_at_most
-    assert_template_result '4', '{{ 5 | at_most:4 }}'
-    assert_template_result '5', '{{ 5 | at_most:5 }}'
-    assert_template_result '5', '{{ 5 | at_most:6 }}'
-
-    assert_template_result '4.5', '{{ 4.5 | at_most:5 }}'
-    assert_template_result '5', '{{ width | at_most:5 }}', 'width' => NumberLikeThing.new(6)
-    assert_template_result '4', '{{ width | at_most:5 }}', 'width' => NumberLikeThing.new(4)
-    assert_template_result '4', '{{ 5 | at_most: width }}', 'width' => NumberLikeThing.new(4)
-  end
-
-  def test_at_least
-    assert_template_result '5', '{{ 5 | at_least:4 }}'
-    assert_template_result '5', '{{ 5 | at_least:5 }}'
-    assert_template_result '6', '{{ 5 | at_least:6 }}'
-
-    assert_template_result '5', '{{ 4.5 | at_least:5 }}'
-    assert_template_result '6', '{{ width | at_least:5 }}', 'width' => NumberLikeThing.new(6)
-    assert_template_result '5', '{{ width | at_least:5 }}', 'width' => NumberLikeThing.new(4)
-    assert_template_result '6', '{{ 5 | at_least: width }}', 'width' => NumberLikeThing.new(6)
  end

  def test_append
    assigns = { 'a' => 'bc', 'b' => 'd' }
    assert_template_result('bcd', "{{ a | append: 'd'}}", assigns)
-    assert_template_result('bcd', '{{ a | append: b}}', assigns)
+    assert_template_result('bcd', "{{ a | append: b}}", assigns)
  end

  def test_concat
@@ -663,7 +393,8 @@ class StandardFiltersTest < Minitest::Test
    assert_equal [1, 2, 'a'],  @filters.concat([1, 2], ['a'])
    assert_equal [1, 2, 10],   @filters.concat([1, 2], [10])

-    assert_raises(Liquid::ArgumentError, 'concat filter requires an array argument') do
+    assert_raises(TypeError) do
+      # no implicit conversion of Fixnum into Array
      @filters.concat([1, 2], 10)
    end
  end
@@ -671,106 +402,19 @@ class StandardFiltersTest < Minitest::Test
  def test_prepend
    assigns = { 'a' => 'bc', 'b' => 'a' }
    assert_template_result('abc', "{{ a | prepend: 'a'}}", assigns)
-    assert_template_result('abc', '{{ a | prepend: b}}', assigns)
+    assert_template_result('abc', "{{ a | prepend: b}}", assigns)
  end

  def test_default
-    assert_equal 'foo', @filters.default('foo', 'bar')
-    assert_equal 'bar', @filters.default(nil, 'bar')
-    assert_equal 'bar', @filters.default('', 'bar')
-    assert_equal 'bar', @filters.default(false, 'bar')
-    assert_equal 'bar', @filters.default([], 'bar')
-    assert_equal 'bar', @filters.default({}, 'bar')
+    assert_equal "foo", @filters.default("foo", "bar")
+    assert_equal "bar", @filters.default(nil, "bar")
+    assert_equal "bar", @filters.default("", "bar")
+    assert_equal "bar", @filters.default(false, "bar")
+    assert_equal "bar", @filters.default([], "bar")
+    assert_equal "bar", @filters.default({}, "bar")
  end

  def test_cannot_access_private_methods
    assert_template_result('a', "{{ 'a' | to_number }}")
  end
-
-  def test_date_raises_nothing
-    assert_template_result('', "{{ '' | date: '%D' }}")
-    assert_template_result('abc', "{{ 'abc' | date: '%D' }}")
-  end
-
-  def test_where
-    input = [
-      { 'handle' => 'alpha', 'ok' => true },
-      { 'handle' => 'beta', 'ok' => false },
-      { 'handle' => 'gamma', 'ok' => false },
-      { 'handle' => 'delta', 'ok' => true },
-    ]
-
-    expectation = [
-      { 'handle' => 'alpha', 'ok' => true },
-      { 'handle' => 'delta', 'ok' => true },
-    ]
-
-    assert_equal expectation, @filters.where(input, 'ok', true)
-    assert_equal expectation, @filters.where(input, 'ok')
-  end
-
-  def test_where_no_key_set
-    input = [
-      { 'handle' => 'alpha', 'ok' => true },
-      { 'handle' => 'beta' },
-      { 'handle' => 'gamma' },
-      { 'handle' => 'delta', 'ok' => true },
-    ]
-
-    expectation = [
-      { 'handle' => 'alpha', 'ok' => true },
-      { 'handle' => 'delta', 'ok' => true },
-    ]
-
-    assert_equal expectation, @filters.where(input, 'ok', true)
-    assert_equal expectation, @filters.where(input, 'ok')
-  end
-
-  def test_where_non_array_map_input
-    assert_equal [{ 'a' => 'ok' }], @filters.where({ 'a' => 'ok' }, 'a', 'ok')
-    assert_equal [], @filters.where({ 'a' => 'not ok' }, 'a', 'ok')
-  end
-
-  def test_where_indexable_but_non_map_value
-    assert_raises(Liquid::ArgumentError) { @filters.where(1, 'ok', true) }
-    assert_raises(Liquid::ArgumentError) { @filters.where(1, 'ok') }
-  end
-
-  def test_where_non_boolean_value
-    input = [
-      { 'message' => 'Bonjour!', 'language' => 'French' },
-      { 'message' => 'Hello!', 'language' => 'English' },
-      { 'message' => 'Hallo!', 'language' => 'German' },
-    ]
-
-    assert_equal [{ 'message' => 'Bonjour!', 'language' => 'French' }], @filters.where(input, 'language', 'French')
-    assert_equal [{ 'message' => 'Hallo!', 'language' => 'German' }], @filters.where(input, 'language', 'German')
-    assert_equal [{ 'message' => 'Hello!', 'language' => 'English' }], @filters.where(input, 'language', 'English')
-  end
-
-  def test_where_array_of_only_unindexable_values
-    assert_nil @filters.where([nil], 'ok', true)
-    assert_nil @filters.where([nil], 'ok')
-  end
-
-  def test_where_no_target_value
-    input = [
-      { 'foo' => false },
-      { 'foo' => true },
-      { 'foo' => 'for sure' },
-      { 'bar' => true },
-    ]
-
-    assert_equal [{ 'foo' => true }, { 'foo' => 'for sure' }], @filters.where(input, 'foo')
-  end
-
-  private
-
-  def with_timezone(tz)
-    old_tz = ENV['TZ']
-    ENV['TZ'] = tz
-    yield
-  ensure
-    ENV['TZ'] = old_tz
-  end
 end # StandardFiltersTest
--- a/test/integration/tags/assign_tag_test.rb
+++ b/test/integration/tags/assign_tag_test.rb
@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class AssignTagTest < Minitest::Test
+  include Liquid
+
+  def test_assign
+    assert_template_result('monkey', "{% assign foo = 'monkey' %}{{ foo }}")
+  end
+
+  def test_string_with_end_tag
+    assert_template_result("{% quoted %}", "{% assign string = '{% quoted %}' %}{{ string }}")
+  end
+end
--- a/test/integration/tags/break_tag_test.rb
+++ b/test/integration/tags/break_tag_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class BreakTagTest < Minitest::Test
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dylan Thacker-Smith	6a9a7ae8d2	Use tokenizer-quoted-strings liquid-c branch.	2015-07-13 22:03:16 -04:00
Dylan Thacker-Smith	4a12fee1f5	Allow variable and tag end characters to be quoted.	2015-07-13 13:19:56 -04:00