Install latest bundler on travis

2026-01-02 16:25:42 +03:00 · 2016-03-21 11:36:50 -04:00
106 changed files with 1008 additions and 4518 deletions
--- a/.github/probots.yml
+++ b/.github/probots.yml
@@ -1,2 +0,0 @@
-enabled:
-  - cla
--- a/.gitignore
+++ b/.gitignore
@@ -7,4 +7,3 @@ pkg
 .ruby-version
 Gemfile.lock
 .bundle
-.byebug_history
--- a/.rubocop-https---shopify-github-io-ruby-style-guide-rubocop-yml
+++ b/.rubocop-https---shopify-github-io-ruby-style-guide-rubocop-yml
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,16 +1,125 @@
-inherit_from:
-  - https://shopify.github.io/ruby-style-guide/rubocop.yml
-  - .rubocop_todo.yml
-
-require: rubocop-performance
-
-Performance:
-  Enabled: true
+inherit_from: ./.rubocop_todo.yml

 AllCops:
  Exclude:
-    - 'vendor/bundle/**/*'
-      
-Naming/MethodName:
+    - 'performance/shopify/*'
+    - 'pkg/**'
+
+Metrics/BlockNesting:
+  Max: 3
  Exclude:
-    - 'example/server/liquid_servlet.rb'
+    - 'lib/liquid/block_body.rb'
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Lint/AssignmentInCondition:
+  Enabled: false
+
+Lint/AmbiguousOperator:
+  Enabled: false
+
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+Lint/ParenthesesAsGroupedExpression:
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+Lint/EndAlignment:
+  AlignWith: variable
+
+Lint/UnusedMethodArgument:
+  Enabled: false
+
+Style/SingleLineBlockParams:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+
+Style/AndOr:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/SpaceInsideBrackets:
+  Enabled: false
+
+Style/SpaceBeforeBlockBraces:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/TrailingComma:
+  Enabled: false
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+Style/FormatString:
+  Enabled: false
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: false
+
+Style/DeprecatedHashMethods:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/SymbolLiteral:
+  Enabled: false
+
+Performance/Count:
+  Enabled: false
+
+Style/ConstantName:
+  Enabled: false
+
+Style/CaseIndentation:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/TrivialAccessors:
+  AllowPredicates: true
+
+Style/WordArray:
+  Enabled: false
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -1,101 +1,72 @@
-# This configuration was generated by
-# `rubocop --auto-gen-config`
-# on 2019-09-11 06:34:25 +1000 using RuboCop version 0.74.0.
+# 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: 2
-Lint/AmbiguousOperator:
-  Exclude:
-    - 'test/unit/condition_unit_test.rb'
+# Offense count: 5
+Lint/NestedMethodDefinition:
+  Enabled: false

-# Offense count: 21
-# Configuration parameters: AllowSafeAssignment.
-Lint/AssignmentInCondition:
-  Exclude:
-    - 'lib/liquid/block_body.rb'
-    - 'lib/liquid/lexer.rb'
-    - 'lib/liquid/standardfilters.rb'
-    - 'lib/liquid/tags/for.rb'
-    - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/tags/raw.rb'
-    - 'lib/liquid/variable.rb'
-    - 'performance/profile.rb'
-    - 'test/test_helper.rb'
-    - 'test/unit/tokenizer_unit_test.rb'
+# Offense count: 53
+Metrics/AbcSize:
+  Max: 58

-# Offense count: 2
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: runtime_error, standard_error
-Lint/InheritException:
-  Exclude:
-    - 'lib/liquid/interrupts.rb'
+# Offense count: 12
+Metrics/CyclomaticComplexity:
+  Max: 15

-# Offense count: 2
-Lint/UselessAssignment:
-  Exclude:
-    - 'performance/shopify/database.rb'
-
-# Offense count: 1
-# Configuration parameters: CheckForMethodsWithNoSideEffects.
-Lint/Void:
-  Exclude:
-    - 'lib/liquid/parse_context.rb'
-
-# Offense count: 98
-# Cop supports --auto-correct.
-# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
-# URISchemes: http, https
+# Offense count: 553
+# Configuration parameters: AllowURI, URISchemes.
 Metrics/LineLength:
  Max: 294

-# Offense count: 44
-Naming/ConstantName:
-  Exclude:
-    - 'lib/liquid.rb'
-    - 'lib/liquid/block_body.rb'
-    - 'lib/liquid/tags/assign.rb'
-    - 'lib/liquid/tags/capture.rb'
-    - 'lib/liquid/tags/case.rb'
-    - 'lib/liquid/tags/cycle.rb'
-    - 'lib/liquid/tags/for.rb'
-    - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/tags/include.rb'
-    - 'lib/liquid/tags/raw.rb'
-    - 'lib/liquid/tags/table_row.rb'
-    - 'lib/liquid/variable.rb'
-    - 'performance/shopify/comment_form.rb'
-    - 'performance/shopify/paginate.rb'
-    - 'test/integration/tags/include_tag_test.rb'
+# Offense count: 77
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Max: 46

-# Offense count: 5
-Style/ClassVars:
-  Exclude:
-    - 'lib/liquid/condition.rb'
-    - 'lib/liquid/strainer.rb'
-    - 'lib/liquid/template.rb'
+# Offense count: 6
+Metrics/PerceivedComplexity:
+  Max: 13

 # Offense count: 1
-# Configuration parameters: AllowCoercion.
-Style/DateTime:
-  Exclude:
-    - 'test/unit/context_unit_test.rb'
-
-# Offense count: 119
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: always, never
-Style/FrozenStringLiteralComment:
+Style/AccessorMethodName:
  Enabled: false

-# Offense count: 9
+# 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:
-  Exclude:
-    - 'test/integration/error_handling_test.rb'
-    - 'test/integration/template_test.rb'
-    - 'test/unit/context_unit_test.rb'
+  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,29 @@
 language: ruby
-cache: bundler

 rvm:
-  - 2.4
-  - 2.5
-  - &latest_ruby 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:
-  include:
-    - rvm: *latest_ruby
-      script: bundle exec rake memory_profile:run
-      name: Profiling Memory Usage
  allow_failures:
-    - rvm: ruby-head
    - rvm: jruby-head
-    - rvm: truffleruby

-branches:
-  only:
-    - master
-    - gh-pages
-    - /.*-stable/
+before_install:
+  - gem update --system
+  - gem install bundler --pre
+
+script: "bundle exec rake"

 notifications:
  disable: true
--- a/23
+++ b/23
@@ -1,25 +1,14 @@
 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'
-  gem 'terminal-table'
-
-  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.34.2'

-  platform :mri, :truffleruby do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
+  platform :mri do
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: '2570693d8d03faa0df9160ec74348a7149436df3'
  end
 end
--- a/History.md
+++ b/History.md
@@ -1,64 +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]
@@ -73,13 +17,10 @@
 * Add concat filter to concatenate arrays (#429) [Diogo Beato]
 * Ruby 1.9 support dropped (#491) [Justin Li]
 * Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith]
-* Remove `liquid_methods` (See https://github.com/Shopify/liquid/pull/568 for replacement)
+* Remove support for `liquid_methods`
 * Liquid::Template.register_filter raises when the module overrides registered public methods as private or protected (#705) [Gaurav Chande]

 ### Fixed
-
-* Fix variable names being detected as an operator when starting with contains (#788) [Michael Angell]
-* Fix include tag used with strict_variables (#828) [QuickPay]
 * Fix map filter when value is a Proc (#672) [Guillaume Malette]
 * Fix truncate filter when value is not a string (#672) [Guillaume Malette]
 * Fix behaviour of escape filter when input is nil (#665) [Tanel Jakobsoo]
--- 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.

@@ -106,9 +104,3 @@ template = Liquid::Template.parse("{{x}} {{y}}")
 template.render!({ 'x' => 1}, { strict_variables: true })
 #=> Liquid::UndefinedVariable: Liquid error: undefined variable y
 ```
-
-### Usage tracking
-
-To help track usages of a feature or code path in production, we have released opt-in usage tracking. To enable this, we provide an empty `Liquid:: Usage.increment` method which you can customize to your needs. The feature is well suited to https://github.com/Shopify/statsd-instrument. However, the choice of implementation is up to you.
-
-Once you have enabled usage tracking, we recommend reporting any events through Github Issues that your system may be logging. It is highly likely this event has been added to consider deprecating or improving code specific to this event, so please raise any concerns.
--- a/31
+++ b/31
@@ -1,31 +1,29 @@
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"

-task(default: [:test, :rubocop])
+task default: [:rubocop, :test]

-desc('run test suite with default parser')
+desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
  t.libs << '.' << 'lib' << 'test'
  t.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
@@ -34,8 +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
@@ -47,7 +45,7 @@ task :test do
  end
 end

-task(gem: :build)
+task gem: :build
 task :build do
  system "gem build liquid.gemspec"
 end
@@ -87,14 +85,7 @@ namespace :profile do
  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"
 end
--- 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,6 +1,6 @@
 module ProductsFilter
  def price(integer)
-    format("$%.2d USD", integer / 100.0)
+    sprintf("$%.2d USD", integer / 100.0)
  end

  def prettyprint(text)
--- a/example/server/liquid_servlet.rb
+++ b/example/server/liquid_servlet.rb
@@ -9,12 +9,12 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet

  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"
--- a/example/server/server.rb
+++ b/example/server/server.rb
@@ -8,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
@@ -24,7 +24,6 @@ module Liquid
  ArgumentSeparator           = ','.freeze
  FilterArgumentSeparator     = ':'.freeze
  VariableAttributeSeparator  = '.'.freeze
-  WhitespaceControl           = '-'.freeze
  TagStart                    = /\{\%/
  TagEnd                      = /\%\}/
  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -35,7 +34,7 @@ module Liquid
  QuotedString                = /"[^"]*"|'[^']*'/
  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
-  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
+  AnyStartingTag              = /\{\{|\{\%/
  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
@@ -45,7 +44,6 @@ module Liquid
 end

 require "liquid/version"
-require 'liquid/parse_tree_visitor'
 require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
@@ -74,8 +72,6 @@ require 'liquid/condition'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'
-require 'liquid/partial_cache'
-require 'liquid/usage'

 # Load all the tags of the standard library
 #
--- a/lib/liquid/block.rb
+++ b/lib/liquid/block.rb
@@ -1,7 +1,5 @@
 module Liquid
  class Block < Tag
-    MAX_DEPTH = 100
-
    def initialize(tag_name, markup, options)
      super
      @blank = true
@@ -13,7 +11,6 @@ module Liquid
      end
    end

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

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

@@ -51,25 +48,17 @@ module Liquid
    protected

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

-          return false if end_tag_name == block_delimiter
-          unless end_tag_name
-            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name)
-          end
-
-          # 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,9 +1,7 @@
 module Liquid
  class BlockBody
-    LiquidTagToken = /\A\s*(\w+)\s*(.*?)\z/o
-    FullToken = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
-    WhitespaceOrNothing = /\A\s*\z/
+    FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
    TAGSTART = "{%".freeze
    VARSTART = "{{".freeze

@@ -14,34 +12,35 @@ module Liquid
      @blank = true
    end

-    def parse(tokenizer, parse_context, &block)
+    def parse(tokenizer, parse_context)
      parse_context.line_number = tokenizer.line_number
-
-      if tokenizer.for_liquid_tag
-        parse_for_liquid_tag(tokenizer, parse_context, &block)
-      else
-        parse_for_document(tokenizer, parse_context, &block)
-      end
-    end
-
-    private def parse_for_liquid_tag(tokenizer, parse_context)
      while token = tokenizer.shift
-        unless token.empty? || token =~ WhitespaceOrNothing
-          unless token =~ LiquidTagToken
-            # line isn't empty but didn't match tag syntax, yield and let the
-            # caller raise a syntax error
-            return yield token, token
+        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
-          tag_name = Regexp.last_match(1)
-          markup = Regexp.last_match(2)
-          unless tag = registered_tags[tag_name]
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
-            return yield tag_name, markup
-          end
-          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-          @blank &&= new_tag.blank?
-          @nodelist << new_tag
        end
        parse_context.line_number = tokenizer.line_number
      end
@@ -49,121 +48,56 @@ module Liquid
      yield nil, nil
    end

-    private def parse_for_document(tokenizer, parse_context, &block)
-      while token = tokenizer.shift
-        next if token.empty?
-        case
-        when token.start_with?(TAGSTART)
-          whitespace_handler(token, parse_context)
-          unless token =~ FullToken
-            raise_missing_tag_terminator(token, parse_context)
-          end
-          tag_name = Regexp.last_match(2)
-          markup = Regexp.last_match(4)
-
-          if parse_context.line_number
-            # newlines inside the tag should increase the line number,
-            # particularly important for multiline {% liquid %} tags
-            parse_context.line_number += Regexp.last_match(1).count("\n".freeze) + Regexp.last_match(3).count("\n".freeze)
-          end
-
-          if tag_name == 'liquid'.freeze
-            liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
-            next parse_for_liquid_tag(liquid_tag_tokenizer, parse_context, &block)
-          end
-
-          unless tag = registered_tags[tag_name]
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
-            return yield tag_name, markup
-          end
-          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-          @blank &&= new_tag.blank?
-          @nodelist << new_tag
-        when token.start_with?(VARSTART)
-          whitespace_handler(token, parse_context)
-          @nodelist << create_variable(token, parse_context)
-          @blank = false
-        else
-          if parse_context.trim_whitespace
-            token.lstrip!
-          end
-          parse_context.trim_whitespace = false
-          @nodelist << token
-          @blank &&= !!(token =~ WhitespaceOrNothing)
-        end
-        parse_context.line_number = tokenizer.line_number
-      end
-
-      yield nil, nil
-    end
-
-    def whitespace_handler(token, parse_context)
-      if token[2] == WhitespaceControl
-        previous_token = @nodelist.last
-        if previous_token.is_a?(String)
-          previous_token.rstrip!
-        end
-      end
-      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
-    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 UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
+          context.handle_error(e, token.line_number)
+          output << nil
+        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".freeze
+      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)
@@ -175,11 +109,11 @@ module Liquid
    end

    def raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination".freeze, token: token, tag_end: TagEnd.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".freeze, token: token, tag_end: VariableEnd.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
@@ -11,52 +11,46 @@ module Liquid
      '=='.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  => :>,
      '>='.freeze => :>=,
      '<='.freeze => :<=,
-      'contains'.freeze => lambda do |_cond, left, right|
+      'contains'.freeze => lambda do |cond, left, right|
        if left && right && left.respond_to?(:include?)
          right = right.to_s if left.is_a?(String)
          left.include?(right)
        else
          false
        end
-      end,
+      end
    }

    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)
@@ -81,10 +75,6 @@ module Liquid
      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
    end

-    protected
-
-    attr_reader :child_relation
-
    private

    def equal_variables(left, right)
@@ -116,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
@@ -12,35 +12,28 @@ module Liquid
  #
  #   context['bob']  #=> nil  class Context
  class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
-    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_accessor :exception_handler, :template_name, :partial, :global_filter, :strict_variables, :strict_filters

-    # rubocop:disable Metrics/ParameterLists
-    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_registers: {}, static_environments: {})
-      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_registers, static_environments)
-    end
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
+      @environments     = [environments].flatten
+      @scopes           = [(outer_scope || {})]
+      @registers        = registers
+      @errors           = []
+      @partial          = false
+      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+      squash_instance_assigns_with_environments

-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_registers = {}, static_environments = {})
-      @environments        = environments.is_a?(Array) ? environments : [environments]
-      @static_environments = [static_environments].flat_map(&:freeze).freeze
-      @scopes              = [(outer_scope || {})]
-      @registers           = registers
-      @static_registers    = static_registers.freeze
-      @errors              = []
-      @partial             = false
-      @strict_variables    = false
-      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
-      @base_scope_depth    = 0
-      @interrupts          = []
-      @filters             = []
-      @global_filter       = nil
+      @this_stack_used = false

-      self.exception_renderer = Template.default_exception_renderer
      if rethrow_errors
-        self.exception_renderer = ->(_e) { raise }
+        self.exception_handler = ->(e) { raise }
      end
+
+      @interrupts = []
+      @filters = []
+      @global_filter = nil
    end
-    # rubocop:enable Metrics/ParameterLists

    def warnings
      @warnings ||= []
@@ -80,11 +73,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)
@@ -94,7 +106,7 @@ module Liquid
    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
    def push(new_scope = {})
      @scopes.unshift(new_scope)
-      check_overflow
+      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
    end

    # Merge a hash of variables in the current local scope
@@ -116,30 +128,19 @@ module Liquid
    #   end
    #
    #   context['var]  #=> nil
-    def stack(new_scope = {})
-      push(new_scope)
+    def stack(new_scope = nil)
+      old_stack_used = @this_stack_used
+      if new_scope
+        push(new_scope)
+        @this_stack_used = true
+      else
+        @this_stack_used = false
+      end
+
      yield
    ensure
-      pop
-    end
-
-    # Creates a new context inheriting resource limits, filters, environment etc.,
-    # but with an isolated scope.
-    def new_isolated_subcontext
-      check_overflow
-
-      Context.build(
-        resource_limits: resource_limits,
-        static_environments: static_environments,
-        static_registers: static_registers
-      ).tap do |subcontext|
-        subcontext.base_scope_depth = base_scope_depth + 1
-        subcontext.exception_renderer = exception_renderer
-        subcontext.filters = @filters
-        subcontext.strainer = nil
-        subcontext.errors = errors
-        subcontext.warnings = warnings
-      end
+      pop if @this_stack_used
+      @this_stack_used = old_stack_used
    end

    def clear_instance_assigns
@@ -148,6 +149,10 @@ module Liquid

    # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
    def []=(key, value)
+      unless @this_stack_used
+        @this_stack_used = true
+        push({})
+      end
      @scopes[0][key] = value
    end

@@ -172,74 +177,58 @@ module Liquid
    end

    # Fetches an object starting at the local scope and then moving up the hierachy
-    def find_variable(key, raise_on_not_found: true)
+    def find_variable(key)
      # This was changed from find() to find_index() because this is a very hot
      # path and find_index() is optimized in MRI to reduce object allocation
      index = @scopes.find_index { |s| s.key?(key) }
+      scope = @scopes[index] if index

-      variable = if index
-        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
-      else
-        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
+      variable = nil
+
+      if scope.nil?
+        @environments.each do |e|
+          variable = lookup_and_evaluate(e, key)
+          unless variable.nil?
+            scope = e
+            break
+          end
+        end
      end

+      scope ||= @environments.last || @scopes.last
+      variable ||= lookup_and_evaluate(scope, key)
+
      variable = variable.to_liquid
      variable.context = self if variable.respond_to?(:context=)

      variable
    end

-    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
-      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
+    def lookup_and_evaluate(obj, key)
+      if @strict_variables && obj.respond_to?(:key?) && !obj.key?(key)
        raise Liquid::UndefinedVariable, "undefined variable #{key}"
      end

      value = obj[key]

      if value.is_a?(Proc) && obj.respond_to?(:[]=)
-        obj[key] = value.arity == 0 ? value.call : value.call(self)
+        obj[key] = (value.arity == 0) ? value.call : value.call(self)
      else
        value
      end
    end

-    protected
-
-    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
-
    private

-    attr_reader :base_scope_depth
-
-    def try_variable_find_in_environments(key, raise_on_not_found:)
-      @environments.each do |environment|
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
+    def squash_instance_assigns_with_environments
+      @scopes.last.each_key do |k|
+        @environments.each do |env|
+          if env.key?(k)
+            scopes.last[k] = lookup_and_evaluate(env, k)
+            break
+          end
        end
      end
-      @static_environments.each do |environment|
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
-        end
-      end
-      nil
-    end
-
-    def check_overflow
-      raise StackLevelError, "Nesting too deep".freeze if overflow?
-    end
-
-    def overflow?
-      base_scope_depth + @scopes.length > Block::MAX_DEPTH
-    end
-
-    def internal_error
-      # raise and catch to set backtrace and cause on exception
-      raise Liquid::InternalError, 'internal'
-    rescue Liquid::InternalError => exc
-      exc
-    end
+    end # squash_instance_assigns_with_environments
  end # Context
 end # Liquid
--- a/lib/liquid/document.rb
+++ b/lib/liquid/document.rb
@@ -7,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
@@ -18,9 +18,9 @@ module Liquid
    def unknown_tag(tag, parse_context)
      case tag
      when 'else'.freeze, 'end'.freeze
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag)
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag))
      else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag".freeze, 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
@@ -25,7 +25,7 @@ module Liquid

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

@@ -62,17 +62,16 @@ module Liquid
    end

    def self.invokable_methods
-      @invokable_methods ||= begin
+      unless @invokable_methods
        blacklist = Liquid::Drop.public_instance_methods + [:each]
-
        if include?(Enumerable)
          blacklist += Enumerable.public_instance_methods
          blacklist -= [:sort, :count, :first, :min, :max, :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
@@ -17,14 +17,22 @@ module Liquid
      str
    end

+    def self.render(e)
+      if e.is_a?(Liquid::Error)
+        e.to_s
+      else
+        "Liquid error: #{e}"
+      end
+    end
+
    private

    def message_prefix
      str = ""
-      str << if is_a?(SyntaxError)
-        "Liquid syntax error"
+      if is_a?(SyntaxError)
+        str << "Liquid syntax error"
      else
-        "Liquid error"
+        str << "Liquid error"
      end

      if line_number
@@ -52,5 +60,4 @@ module Liquid
  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
@@ -15,31 +15,27 @@ module Liquid

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

    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
@@ -7,12 +7,6 @@ class String # :nodoc:
  end
 end

-class Symbol # :nodoc:
-  def to_liquid
-    to_s
-  end
-end
-
 class Array # :nodoc:
  def to_liquid
    self
@@ -31,12 +25,6 @@ class Numeric # :nodoc:
  end
 end

-class Range # :nodoc:
-  def to_liquid
-    self
-  end
-end
-
 class Time # :nodoc:
  def to_liquid
    self
--- a/lib/liquid/file_system.rb
+++ b/lib/liquid/file_system.rb
@@ -8,8 +8,8 @@ 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
@@ -26,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.
@@ -37,9 +37,9 @@ 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
@@ -57,7 +57,7 @@ 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?('/'.freeze)
        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
--- a/lib/liquid/i18n.rb
+++ b/lib/liquid/i18n.rb
@@ -26,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('.'.freeze).reduce(locale) do |level, cur|
-        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
      end
    end
  end
--- a/lib/liquid/lexer.rb
+++ b/lib/liquid/lexer.rb
@@ -11,32 +11,31 @@ module Liquid
      '('.freeze => :open_round,
      ')'.freeze => :close_round,
      '?'.freeze => :question,
-      '-'.freeze => :dash,
-    }.freeze
+      '-'.freeze => :dash
+    }
    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
    SINGLE_STRING_LITERAL = /'[^\']*'/
    DOUBLE_STRING_LITERAL = /"[^\"]*"/
    NUMBER_LITERAL = /-?\d+(\.\d+)?/
    DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/
-    WHITESPACE_OR_NOTHING = /\s*/
+    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]
--- 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,6 +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"
-      render: "Syntax error in tag 'render' - Template name must be a quoted string"
-    argument:
-      include: "Argument error in tag 'include' - Illegal template name"
--- a/lib/liquid/parse_context.rb
+++ b/lib/liquid/parse_context.rb
@@ -1,13 +1,12 @@
 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

@@ -28,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
@@ -44,14 +44,11 @@ module Liquid
      tok[0] == type
    end

-    SINGLE_TOKEN_EXPRESSION_TYPES = [: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
--- a/lib/liquid/partial_cache.rb
+++ b/lib/liquid/partial_cache.rb
@@ -1,18 +0,0 @@
-module Liquid
-  class PartialCache
-    def self.load(template_name, context:, parse_context:)
-      cached_partials = (context.registers[:cached_partials] ||= {})
-      cached = cached_partials[template_name]
-      return cached if cached
-
-      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
-      source = file_system.read_template_file(template_name)
-      parse_context.partial = true
-
-      partial = Liquid::Template.parse(source, parse_context)
-      cached_partials[template_name] = partial
-    ensure
-      parse_context.partial = false
-    end
-  end
-end
--- a/lib/liquid/profiler/hooks.rb
+++ b/lib/liquid/profiler/hooks.rb
@@ -1,8 +1,8 @@
 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

@@ -11,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/standardfilters.rb
+++ b/lib/liquid/standardfilters.rb
@@ -8,15 +8,9 @@ module Liquid
      '>'.freeze => '&gt;'.freeze,
      '<'.freeze => '&lt;'.freeze,
      '"'.freeze => '&quot;'.freeze,
-      "'".freeze => '&#39;'.freeze,
-    }.freeze
+      "'".freeze => '&#39;'.freeze
+    }
    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
-    STRIP_HTML_BLOCKS = Regexp.union(
-      %r{<script.*?</script>}m,
-      /<!--.*?-->/m,
-      %r{<style.*?</style>}m
-    )
-    STRIP_HTML_TAGS = /<.*?>/m

    # Return the size of an array or of an string
    def size(input)
@@ -39,7 +33,7 @@ module Liquid
    end

    def escape(input)
-      CGI.escapeHTML(input.to_s).untaint unless input.nil?
+      CGI.escapeHTML(input).untaint unless input.nil?
    end
    alias_method :h, :escape

@@ -48,16 +42,11 @@ module Liquid
    end

    def url_encode(input)
-      CGI.escape(input.to_s) unless input.nil?
+      CGI.escape(input) unless input.nil?
    end

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

    def slice(input, offset, length = nil)
@@ -76,10 +65,9 @@ module Liquid
      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_str.length > length ? input_str[0...l] + truncate_string : input_str
    end

    def truncatewords(input, words = 15, truncate_string = "...".freeze)
@@ -88,7 +76,7 @@ module Liquid
      words = Utils.to_integer(words)
      l = words - 1
      l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ".freeze).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.
@@ -97,7 +85,7 @@ module Liquid
    #   <div class="summary">{{ post | split '//' | first }}</div>
    #
    def split(input, pattern)
-      input.to_s.split(pattern.to_s)
+      input.to_s.split(pattern)
    end

    def strip(input)
@@ -114,9 +102,7 @@ module Liquid

    def strip_html(input)
      empty = ''.freeze
-      result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
-      result.gsub!(STRIP_HTML_TAGS, empty)
-      result
+      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
@@ -133,19 +119,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.empty? # The next two cases assume a non-empty array.
+        []
+      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
+        ary.sort { |a, b| a[property] <=> b[property] }
      end
    end

@@ -154,40 +133,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?
+        ary.sort { |a, b| a.casecmp(b) }
+      elsif ary.empty? # The next two cases assume a non-empty array.
        []
-      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
+      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
+        ary.sort { |a, b| a[property].casecmp(b[property]) }
      end
    end

@@ -201,11 +152,7 @@ module Liquid
      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

@@ -227,8 +174,6 @@ module Liquid
          r.is_a?(Proc) ? r.call : r
        end
      end
-    rescue TypeError
-      raise_property_error(property)
    end

    # Remove nils within an array
@@ -241,11 +186,7 @@ module Liquid
      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? }
      end
    end

@@ -275,9 +216,6 @@ module Liquid
    end

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

@@ -348,12 +286,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, :+)
@@ -403,25 +335,8 @@ 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 = ''.freeze)
      if !input || input.respond_to?(:empty?) && input.empty?
-        Usage.increment("default_filter_received_false_value") if input == false # See https://github.com/Shopify/liquid/issues/1127
        default_value
      else
        input
@@ -430,31 +345,11 @@ module Liquid

    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

@@ -471,11 +366,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
--- a/lib/liquid/strainer.rb
+++ b/lib/liquid/strainer.rb
@@ -27,7 +27,7 @@ module Liquid

    def self.add_filter(filter)
      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
-      unless include?(filter)
+      unless self.class.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(', ')}"
@@ -39,7 +39,6 @@ module Liquid
    end

    def self.global_filter(filter)
-      @@strainer_class_cache.clear
      @@global_strainer.add_filter(filter)
    end

@@ -54,7 +53,7 @@ module Liquid
    def invoke(method, *args)
      if self.class.invokable?(method)
        send(method, *args)
-      elsif @context&.strict_filters
+      elsif @context && @context.strict_filters
        raise Liquid::UndefinedFilter, "undefined filter #{method}"
      else
        args.first
--- a/lib/liquid/tag.rb
+++ b/lib/liquid/tag.rb
@@ -5,8 +5,8 @@ module Liquid
    include ParserSwitching

    class << self
-      def parse(tag_name, markup, tokenizer, parse_context)
-        tag = new(tag_name, markup, parse_context)
+      def parse(tag_name, markup, tokenizer, options)
+        tag = new(tag_name, markup, options)
        tag.parse(tokenizer)
        tag
      end
@@ -36,14 +36,6 @@ module Liquid
      ''.freeze
    end

-    # For backwards compatibility with custom tags. In a future release, the semantics
-    # of the `render_to_output_buffer` method will become the default and the `render`
-    # method will be removed.
-    def render_to_output_buffer(context, output)
-      output << render(context)
-      output
-    end
-
    def blank?
      false
    end
--- a/lib/liquid/tags/assign.rb
+++ b/lib/liquid/tags/assign.rb
@@ -10,27 +10,21 @@ module Liquid
  class Assign < Tag
    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om

-    def self.syntax_error_translation_key
-      "errors.syntax.assign".freeze
-    end
-
-    attr_reader :to, :from
-
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @to = Regexp.last_match(1)
-        @from = Variable.new(Regexp.last_match(2), options)
+        @to = $1
+        @from = Variable.new($2, options)
      else
-        raise SyntaxError, options[:locale].t(self.class.syntax_error_translation_key)
+        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
+      ''.freeze
    end

    def blank?
@@ -41,7 +35,7 @@ module Liquid

    def assign_score_of(val)
      if val.instance_of?(String)
-        val.bytesize
+        val.length
      elsif val.instance_of?(Array) || val.instance_of?(Hash)
        sum = 1
        # Uses #each to avoid extra allocations.
@@ -51,12 +45,6 @@ module Liquid
        1
      end
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.from]
-      end
-    end
  end

  Template.register_tag('assign'.freeze, Assign)
--- a/lib/liquid/tags/capture.rb
+++ b/lib/liquid/tags/capture.rb
@@ -16,18 +16,17 @@ module Liquid
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @to = Regexp.last_match(1)
+        @to = $1
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.capture")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
      end
    end

-    def render_to_output_buffer(context, output)
-      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?
--- a/lib/liquid/tags/case.rb
+++ b/lib/liquid/tags/case.rb
@@ -3,22 +3,22 @@ module Liquid
    Syntax     = /(#{QuotedFragment})/o
    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om

-    attr_reader :blocks, :left
-
    def initialize(tag_name, markup, options)
      super
      @blocks = []

      if markup =~ Syntax
-        @left = Expression.parse(Regexp.last_match(1))
+        @left = Expression.parse($1)
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.case".freeze)
+        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
@@ -36,19 +36,21 @@ module Liquid
      end
    end

-    def render_to_output_buffer(context, output)
-      execute_else_block = true
+    def render(context)
+      context.stack do
+        execute_else_block = true

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

    private
@@ -58,12 +60,12 @@ module Liquid

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

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

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

    def record_else_condition(markup)
      unless markup.strip.empty?
-        raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else".freeze)
+        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'.freeze, Case)
--- a/lib/liquid/tags/comment.rb
+++ b/lib/liquid/tags/comment.rb
@@ -1,7 +1,7 @@
 module Liquid
  class Comment < Block
-    def render_to_output_buffer(_context, output)
-      output
+    def render(_context)
+      ''.freeze
    end

    def unknown_tag(_tag, _markup, _tokens)
--- a/lib/liquid/tags/cycle.rb
+++ b/lib/liquid/tags/cycle.rb
@@ -15,43 +15,32 @@ module Liquid
    SimpleSyntax = /\A#{QuotedFragment}+/o
    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om

-    attr_reader :variables
-
    def initialize(tag_name, markup, options)
      super
      case markup
      when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
-        @name = Expression.parse(Regexp.last_match(1))
+        @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".freeze)
+        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)

-      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
+      context.stack do
+        key = context.evaluate(@name)
+        iteration = context.registers[:cycle][key]
+        result = context.evaluate(@variables[iteration])
+        iteration += 1
+        iteration  = 0 if iteration >= @variables.size
+        context.registers[:cycle][key] = iteration
+        result
      end
-
-      output << val
-
-      iteration += 1
-      iteration  = 0 if iteration >= @variables.size
-      context.registers[:cycle][key] = iteration
-
-      output
    end

    private
@@ -59,15 +48,9 @@ module Liquid
    def variables_from_string(markup)
      markup.split(',').collect do |var|
        var =~ /\s*(#{QuotedFragment})\s*/o
-        Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
+        $1 ? Expression.parse($1) : nil
      end.compact
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        Array(@node.variables)
-      end
-    end
  end

  Template.register_tag('cycle', Cycle)
--- a/lib/liquid/tags/decrement.rb
+++ b/lib/liquid/tags/decrement.rb
@@ -23,12 +23,11 @@ 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

--- a/lib/liquid/tags/echo.rb
+++ b/lib/liquid/tags/echo.rb
@@ -1,24 +0,0 @@
-module Liquid
-  # Echo outputs an expression
-  #
-  #   {% echo monkey %}
-  #   {% echo user.name %}
-  #
-  # This is identical to variable output syntax, like {{ foo }}, but works
-  # inside {% liquid %} tags. The full syntax is supported, including filters:
-  #
-  #   {% echo user | link %}
-  #
-  class Echo < Tag
-    def initialize(tag_name, markup, parse_context)
-      super
-      @variable = Variable.new(markup, parse_context)
-    end
-
-    def render(context)
-      @variable.render_to_output_buffer(context, '')
-    end
-  end
-
-  Template.register_tag('echo'.freeze, Echo)
-end
--- a/lib/liquid/tags/for.rb
+++ b/lib/liquid/tags/for.rb
@@ -23,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,14 +46,10 @@ module Liquid
  class For < Block
    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o

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

    def parse(tokens)
@@ -70,39 +66,37 @@ module Liquid
      @else_block = BlockBody.new
    end

-    def render_to_output_buffer(context, output)
+    def render(context)
      segment = collection_segment(context)

      if segment.empty?
-        render_else(context, output)
+        render_else(context)
      else
-        render_segment(context, output, segment)
+        render_segment(context, segment)
      end
-
-      output
    end

    protected

    def lax_parse(markup)
      if markup =~ Syntax
-        @variable_name = Regexp.last_match(1)
-        collection_name = Regexp.last_match(2)
-        @reversed = !!Regexp.last_match(3)
+        @variable_name = $1
+        collection_name = $2
+        @reversed = !!$3
        @name = "#{@variable_name}-#{collection_name}"
        @collection_name = Expression.parse(collection_name)
        markup.scan(TagAttributes) do |key, value|
          set_attribute(key, value)
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.for".freeze)
+        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".freeze) unless p.id?('in'.freeze)
+      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)
@@ -110,7 +104,7 @@ module Liquid

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

    def collection_segment(context)
-      offsets = context.registers[:for] ||= {}
+      offsets = context.registers[:for] ||= Hash.new(0)

      from = if @from == :continue
        offsets[@name].to_i
      else
-        from_value = context.evaluate(@from)
-        if from_value.nil?
-          0
-        else
-          Utils.to_integer(from_value)
-        end
+        context.evaluate(@from).to_i
      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
+      limit = context.evaluate(@limit)
+      to = limit ? limit.to_i + from : nil

      segment = Utils.slice_collection(collection, from, to)
      segment.reverse! if @reversed
@@ -152,10 +137,12 @@ module Liquid
      segment
    end

-    def render_segment(context, output, segment)
+    def render_segment(context, segment)
      for_stack = context.registers[:for_stack] ||= []
      length = segment.length

+      result = ''
+
      context.stack do
        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])

@@ -164,23 +151,24 @@ module Liquid
        begin
          context['forloop'.freeze] = loop_vars

-          segment.each do |item|
+          segment.each_with_index do |item, index|
            context[@variable_name] = item
-            @for_block.render_to_output_buffer(context, output)
+            result << @for_block.render(context)
            loop_vars.send(:increment!)

            # Handle any interrupts if they exist.
-            next unless context.interrupt?
-            interrupt = context.pop_interrupt
-            break if interrupt.is_a?(BreakInterrupt)
-            next if interrupt.is_a?(ContinueInterrupt)
+            if context.interrupt?
+              interrupt = context.pop_interrupt
+              break if interrupt.is_a? BreakInterrupt
+              next if interrupt.is_a? ContinueInterrupt
+            end
          end
        ensure
          for_stack.pop
        end
      end

-      output
+      result
    end

    def set_attribute(key, expr)
@@ -196,18 +184,8 @@ module Liquid
      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

--- a/lib/liquid/tags/if.rb
+++ b/lib/liquid/tags/if.rb
@@ -12,9 +12,7 @@ module Liquid
  class If < Block
    Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS = %w(and or).freeze
-
-    attr_reader :blocks
+    BOOLEAN_OPERATORS = %w(and or)

    def initialize(tag_name, markup, options)
      super
@@ -22,15 +20,15 @@ module Liquid
      push_block('if'.freeze, markup)
    end

-    def nodelist
-      @blocks.map(&:attachment)
-    end
-
    def parse(tokens)
      while parse_body(@blocks.last.attachment, tokens)
      end
    end

+    def nodelist
+      @blocks.map(&:attachment)
+    end
+
    def unknown_tag(tag, markup, tokens)
      if ['elsif'.freeze, 'else'.freeze].include?(tag)
        push_block(tag, markup)
@@ -39,14 +37,15 @@ module Liquid
      end
    end

-    def render_to_output_buffer(context, output)
-      @blocks.each do |block|
-        if block.evaluate(context)
-          return block.attachment.render_to_output_buffer(context, output)
+    def render(context)
+      context.stack do
+        @blocks.each do |block|
+          if block.evaluate(context)
+            return block.attachment.render(context)
+          end
        end
+        ''.freeze
      end
-
-      output
    end

    private
@@ -64,17 +63,17 @@ module Liquid

    def lax_parse(markup)
      expressions = markup.scan(ExpressionsAndOperators)
-      raise SyntaxError, options[:locale].t("errors.syntax.if".freeze) unless expressions.pop =~ Syntax
+      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".freeze) unless expressions.pop.to_s =~ Syntax
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax

-        new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
-        raise SyntaxError, options[:locale].t("errors.syntax.if".freeze) unless BOOLEAN_OPERATORS.include?(operator)
+        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
@@ -84,20 +83,17 @@ 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'.freeze) || p.id?('or'.freeze))
-        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)
@@ -109,12 +105,6 @@ module Liquid
        Condition.new(a)
      end
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        @node.blocks
-      end
-    end
  end

  Template.register_tag('if'.freeze, If)
--- a/lib/liquid/tags/ifchanged.rb
+++ b/lib/liquid/tags/ifchanged.rb
@@ -1,15 +1,16 @@
 module Liquid
  class Ifchanged < Block
-    def render_to_output_buffer(context, output)
-      block_output = ''
-      super(context, block_output)
+    def render(context)
+      context.stack do
+        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

--- a/lib/liquid/tags/include.rb
+++ b/lib/liquid/tags/include.rb
@@ -16,15 +16,13 @@ module Liquid
  class Include < Tag
    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o

-    attr_reader :template_name_expr, :variable_name_expr, :attributes
-
    def initialize(tag_name, markup, options)
      super

      if markup =~ Syntax

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

        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
        @template_name_expr = Expression.parse(template_name)
@@ -35,29 +33,23 @@ module Liquid
        end

      else
-        raise SyntaxError, options[:locale].t("errors.syntax.include".freeze)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
      end
    end

    def parse(_tokens)
    end

-    def render_to_output_buffer(context, output)
+    def render(context)
      template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
-
-      partial = PartialCache.load(
-        template_name,
-        context: context,
-        parse_context: parse_context
-      )
+      partial = load_cached_partial(template_name, context)

      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
@@ -71,33 +63,48 @@ 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
+
    alias_method :parse_context, :options
    private :parse_context

-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.template_name_expr,
-          @node.variable_name_expr,
-        ] + @node.attributes.values
+    def load_cached_partial(template_name, context)
+      cached_partials = context.registers[:cached_partials] || {}
+
+      if cached = cached_partials[template_name]
+        return cached
      end
+      source = read_template_from_file_system(context)
+      begin
+        parse_context.partial = true
+        partial = Liquid::Template.parse(source, parse_context)
+      ensure
+        parse_context.partial = false
+      end
+      cached_partials[template_name] = partial
+      context.registers[:cached_partials] = cached_partials
+      partial
+    end
+
+    def read_template_from_file_system(context)
+      file_system = context.registers[:file_system] || Liquid::Template.file_system
+
+      file_system.read_template_file(context.evaluate(@template_name_expr))
    end
  end

--- a/lib/liquid/tags/increment.rb
+++ b/lib/liquid/tags/increment.rb
@@ -20,12 +20,10 @@ 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

--- a/lib/liquid/tags/raw.rb
+++ b/lib/liquid/tags/raw.rb
@@ -6,25 +6,26 @@ module Liquid
    def initialize(tag_name, markup, parse_context)
      super

-      ensure_valid_markup(tag_name, markup, parse_context)
+      unless markup =~ Syntax
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name))
+      end
    end

    def parse(tokens)
      @body = ''
      while token = tokens.shift
        if token =~ FullTokenPossiblyInvalid
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != "".freeze
-          return if block_delimiter == Regexp.last_match(2)
+          @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".freeze, 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
@@ -34,14 +35,6 @@ module Liquid
    def blank?
      @body.empty?
    end
-
-    protected
-
-    def ensure_valid_markup(tag_name, markup, parse_context)
-      unless markup =~ Syntax
-        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name)
-      end
-    end
  end

  Template.register_tag('raw'.freeze, Raw)
--- a/lib/liquid/tags/render.rb
+++ b/lib/liquid/tags/render.rb
@@ -1,54 +0,0 @@
-module Liquid
-  class Render < Tag
-    SYNTAX = /(#{QuotedString})#{QuotedFragment}*/o
-
-    attr_reader :template_name_expr, :attributes
-
-    def initialize(tag_name, markup, options)
-      super
-
-      raise SyntaxError, options[:locale].t("errors.syntax.render".freeze) unless markup =~ SYNTAX
-
-      template_name = Regexp.last_match(1)
-
-      @template_name_expr = Expression.parse(template_name)
-
-      @attributes = {}
-      markup.scan(TagAttributes) do |key, value|
-        @attributes[key] = Expression.parse(value)
-      end
-    end
-
-    def render_to_output_buffer(context, output)
-      # Though we evaluate this here we will only ever parse it as a string literal.
-      template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
-
-      partial = PartialCache.load(
-        template_name,
-        context: context,
-        parse_context: parse_context
-      )
-
-      inner_context = context.new_isolated_subcontext
-      inner_context.template_name = template_name
-      inner_context.partial = true
-      @attributes.each do |key, value|
-        inner_context[key] = context.evaluate(value)
-      end
-      partial.render_to_output_buffer(inner_context, output)
-
-      output
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.template_name_expr,
-        ] + @node.attributes.values
-      end
-    end
-  end
-
-  Template.register_tag('render'.freeze, Render)
-end
--- a/lib/liquid/tags/table_row.rb
+++ b/lib/liquid/tags/table_row.rb
@@ -2,24 +2,22 @@ module Liquid
  class TableRow < Block
    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o

-    attr_reader :variable_name, :collection_name, :attributes
-
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @variable_name = Regexp.last_match(1)
-        @collection_name = Expression.parse(Regexp.last_match(2))
+        @variable_name = $1
+        @collection_name = Expression.parse($2)
        @attributes = {}
        markup.scan(TagAttributes) do |key, value|
          @attributes[key] = Expression.parse(value)
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.table_row".freeze)
+        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 ''.freeze)
+    def render(context)
+      collection = context.evaluate(@collection_name) or return ''.freeze

      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
@@ -30,34 +28,25 @@ module Liquid

      cols = context.evaluate(@attributes['cols'.freeze]).to_i

-      output << "<tr class=\"row1\">\n"
+      result = "<tr class=\"row1\">\n"
      context.stack do
        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
        context['tablerowloop'.freeze] = tablerowloop

-        collection.each do |item|
+        collection.each_with_index do |item, index|
          context[@variable_name] = item

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

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

          tablerowloop.send(:increment!)
        end
      end
-
-      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

--- a/lib/liquid/tags/unless.rb
+++ b/lib/liquid/tags/unless.rb
@@ -6,21 +6,23 @@ module Liquid
  #   {% unless x < 0 %} x is greater than zero {% endunless %}
  #
  class Unless < If
-    def render_to_output_buffer(context, output)
-      # First condition is interpreted backwards ( if not )
-      first_block = @blocks.first
-      unless first_block.evaluate(context)
-        return first_block.attachment.render_to_output_buffer(context, output)
-      end
-
-      # After the first condition unless works just like if
-      @blocks[1..-1].each do |block|
-        if block.evaluate(context)
-          return block.attachment.render_to_output_buffer(context, output)
+    def render(context)
+      context.stack do
+        # First condition is interpreted backwards ( if not )
+        first_block = @blocks.first
+        unless first_block.evaluate(context)
+          return first_block.attachment.render(context)
        end
-      end

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

--- a/lib/liquid/template.rb
+++ b/lib/liquid/template.rb
@@ -19,10 +19,8 @@ module Liquid
    @@file_system = BlankFileSystem.new

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

@@ -43,14 +41,10 @@ module Liquid
        @cache.delete(tag_name)
      end

-      def each(&block)
-        @tags.each(&block)
-      end
-
      private

      def lookup_class(name)
-        Object.const_get(name)
+        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
      end
    end

@@ -69,11 +63,6 @@ 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
-      end
-
      def file_system
        @@file_system
      end
@@ -91,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
@@ -118,7 +107,6 @@ module Liquid
    end

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

@@ -143,12 +131,7 @@ module Liquid
    end

    def instance_assigns
-      @instance_assigns ||= []
-    end
-
-    def new_outer_scope
-      @instance_assigns.unshift(last = {})
-      last
+      @instance_assigns ||= {}
    end

    def errors
@@ -177,27 +160,24 @@ module Liquid
        c = args.shift

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

        c
      when Liquid::Drop
        drop = args.shift
-        drop.context = Context.new([drop, assigns].concat(instance_assigns), new_outer_scope, registers, @rethrow_errors, @resource_limits)
+        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
      when Hash
-        Context.new([args.shift, assigns].concat(instance_assigns), new_outer_scope, registers, @rethrow_errors, @resource_limits)
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
      when nil
-        Context.new([assigns].concat(instance_assigns), new_outer_scope, registers, @rethrow_errors, @resource_limits)
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
      else
        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
      end

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

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

@@ -212,9 +192,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
@@ -227,10 +208,6 @@ module Liquid
      render(*args)
    end

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

    def tokenize(source)
@@ -257,7 +234,7 @@ module Liquid
    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.exception_handler = options[:exception_handler] if options[:exception_handler]
      context.strict_variables = options[:strict_variables] if options[:strict_variables]
      context.strict_filters = options[:strict_filters] if options[:strict_filters]
    end
--- a/lib/liquid/tokenizer.rb
+++ b/lib/liquid/tokenizer.rb
@@ -1,35 +1,29 @@
 module Liquid
  class Tokenizer
-    attr_reader :line_number, :for_liquid_tag
+    attr_reader :line_number

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

    def shift
-      (token = @tokens.shift) || return
-
-      if @line_number
-        @line_number += @for_liquid_tag ? 1 : token.count("\n")
-      end
-
+      token = @tokens.shift
+      @line_number += token.count("\n") if @line_number && token
      token
    end

    private

    def tokenize
+      @source = @source.source if @source.respond_to?(:source)
      return [] if @source.to_s.empty?

-      return @source.split("\n") if @for_liquid_tag
-
      tokens = @source.split(TemplateParser)

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

      tokens
    end
--- a/lib/liquid/usage.rb
+++ b/lib/liquid/usage.rb
@@ -1,6 +0,0 @@
-module Liquid
-  module Usage
-    def self.increment(name)
-    end
-  end
-end
--- a/lib/liquid/utils.rb
+++ b/lib/liquid/utils.rb
@@ -46,17 +46,13 @@ module Liquid
    def self.to_number(obj)
      case obj
      when Float
-        BigDecimal(obj.to_s)
+        BigDecimal.new(obj.to_s)
      when Numeric
        obj
      when String
-        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

--- a/lib/liquid/variable.rb
+++ b/lib/liquid/variable.rb
@@ -10,16 +10,10 @@ module Liquid
  #   {{ user | link }}
  #
  class Variable
-    FilterMarkupRegex = /#{FilterSeparator}\s*(.*)/om
    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    FilterArgsRegex = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
-    JustTagAttributes = /\A#{TagAttributes}\z/o
-    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
-
    attr_accessor :filters, :name, :line_number
    attr_reader :parse_context
    alias_method :options, :parse_context
-
    include ParserSwitching

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

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

-      name_markup = Regexp.last_match(1)
-      filter_markup = Regexp.last_match(2)
+      name_markup = $1
+      filter_markup = $2
      @name = Expression.parse(name_markup)
-      if filter_markup =~ FilterMarkupRegex
-        filters = Regexp.last_match(1).scan(FilterParser)
+      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(FilterArgsRegex).flatten
+          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
          @filters << parse_filter_expressions(filtername, filterargs)
        end
      end
@@ -85,43 +79,31 @@ module Liquid
      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
-
    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(JustTagAttributes)
-          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|
@@ -150,11 +132,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,7 +1,7 @@
 module Liquid
  class VariableLookup
    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze].freeze
+    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]

    attr_reader :name, :lookups

@@ -14,7 +14,7 @@ module Liquid

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

@@ -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
@@ -78,11 +78,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 @@
 # encoding: utf-8
-
 module Liquid
-  VERSION = "4.0.3".freeze
+  VERSION = "4.0.0.rc1"
 end
--- a/liquid.gemspec
+++ b/liquid.gemspec
@@ -1,7 +1,6 @@
 # encoding: utf-8
-
 lib = File.expand_path('../lib/', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)

 require "liquid/version"

@@ -16,7 +15,6 @@ Gem::Specification.new do |s|
  s.license     = "MIT"
  # s.description = "A secure, non-evaling end user template engine with aesthetic markup."

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

  s.test_files  = Dir.glob("{test}/**/*")
@@ -26,6 +24,6 @@ Gem::Specification.new do |s|

  s.require_path = "lib"

-  s.add_development_dependency('rake', '~> 11.3')
-  s.add_development_dependency('minitest')
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
 end
--- a/performance/benchmark.rb
+++ b/performance/benchmark.rb
@@ -5,7 +5,7 @@ Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new

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

  puts
@@ -13,6 +13,5 @@ Benchmark.ips do |x|
  puts

  x.report("parse:") { profiler.compile }
-  x.report("render:") { profiler.render }
-  x.report("parse & render:") { profiler.run }
+  x.report("parse & run:") { profiler.run }
 end
--- a/performance/memory_profile.rb
+++ b/performance/memory_profile.rb
@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'benchmark/ips'
-require 'memory_profiler'
-require 'terminal-table'
-require_relative 'theme_runner'
-
-class Profiler
-  LOG_LABEL   = "Profiling: ".rjust(14).freeze
-  REPORTS_DIR = File.expand_path('.memprof', __dir__).freeze
-
-  def self.run
-    puts
-    yield new
-  end
-
-  def initialize
-    @allocated = []
-    @retained  = []
-    @headings  = []
-  end
-
-  def profile(phase, &block)
-    print LOG_LABEL
-    print "#{phase}.. ".ljust(10)
-    report = MemoryProfiler.report(&block)
-    puts 'Done.'
-    @headings  << phase.capitalize
-    @allocated << "#{report.scale_bytes(report.total_allocated_memsize)} (#{report.total_allocated} objects)"
-    @retained  << "#{report.scale_bytes(report.total_retained_memsize)} (#{report.total_retained} objects)"
-
-    return if ENV['CI']
-
-    require 'fileutils'
-    report_file = File.join(REPORTS_DIR, "#{sanitize(phase)}.txt")
-    FileUtils.mkdir_p(REPORTS_DIR)
-    report.pretty_print(to_file: report_file, scale_bytes: true)
-  end
-
-  def tabulate
-    table = Terminal::Table.new(headings: @headings.unshift('Phase')) do |t|
-      t << @allocated.unshift('Total allocated')
-      t << @retained.unshift('Total retained')
-    end
-
-    puts
-    puts table
-    puts "\nDetailed report(s) saved to #{REPORTS_DIR}/" unless ENV['CI']
-  end
-
-  def sanitize(string)
-    string.downcase.gsub(/[\W]/, '-').squeeze('-')
-  end
-end
-
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
-
-runner = ThemeRunner.new
-Profiler.run do |x|
-  x.profile('parse') { runner.compile }
-  x.profile('render') { runner.render }
-  x.tabulate
-end
--- a/performance/shopify/comment_form.rb
+++ b/performance/shopify/comment_form.rb
@@ -5,14 +5,14 @@ class CommentForm < Liquid::Block
    super

    if markup =~ Syntax
-      @variable_name = Regexp.last_match(1)
+      @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
@@ -20,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
@@ -16,10 +16,9 @@ module Database
      end

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

      # Some standard direct accessors so that the specialized templates
@@ -31,8 +30,8 @@ module Database

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

      db
@@ -41,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
@@ -2,6 +2,6 @@ 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,4 +1,4 @@
-$LOAD_PATH.unshift(__dir__ + '/../../lib')
+$:.unshift __dir__ + '/../../lib'
 require_relative '../../lib/liquid'

 require_relative 'comment_form'
@@ -9,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,12 +1,12 @@
 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,13 +1,13 @@
 class Paginate < Liquid::Block
-  Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/

  def initialize(tag_name, markup, options)
    super

    if markup =~ Syntax
-      @collection_name = Regexp.last_match(1)
-      @page_size = if Regexp.last_match(2)
-        Regexp.last_match(3).to_i
+      @collection_name = $1
+      @page_size = if $2
+        $3.to_i
      else
        20
      end
@@ -17,27 +17,27 @@ class Paginate < Liquid::Block
        @attributes[key] = value
      end
    else
-      raise SyntaxError, "Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number"
+      raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
    end
  end

-  def render_to_output_buffer(context, output)
+  def render(context)
    @context = context

    context.stack do
-      current_page = context['current_page'].to_i
+      current_page  = context['current_page'].to_i

      pagination = {
-        'page_size' => @page_size,
-        '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

--- a/performance/shopify/shop_filter.rb
+++ b/performance/shopify/shop_filter.rb
@@ -52,7 +52,7 @@ module ShopFilter
  end

  def product_img_url(url, style = 'small')
-    unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
+    unless url =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
      raise ArgumentError, 'filter "size" can only be called on product images'
    end

@@ -60,7 +60,7 @@ module ShopFilter
    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
@@ -13,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,6 +1,6 @@
 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
@@ -21,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/blank_test.rb
+++ b/test/integration/blank_test.rb
@@ -1,10 +1,11 @@
 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
@@ -30,9 +31,7 @@ class BlankTest < Minitest::Test
  end

  def test_new_tags_are_not_blank_by_default
-    with_custom_tag('foobar', FoobarTag) do
-      assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
-    end
+    assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
  end

  def test_loops_are_blank
--- a/test/integration/block_test.rb
+++ b/test/integration/block_test.rb
@@ -1,12 +0,0 @@
-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/drop_test.rb
+++ b/test/integration/drop_test.rb
@@ -201,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
@@ -241,7 +241,7 @@ class DropsTest < Minitest::Test
  end

  def test_some_enumerable_methods_still_get_invoked
-    [:count, :max].each do |method|
+    [ :count, :max ].each do |method|
      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
@@ -250,7 +250,7 @@ class DropsTest < Minitest::Test

    assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new)

-    [:min, :first].each do |method|
+    [ :min, :first ].each do |method|
      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
--- a/test/integration/error_handling_test.rb
+++ b/test/integration/error_handling_test.rb
@@ -83,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
@@ -120,7 +106,8 @@ class ErrorHandlingTest < Minitest::Test
        bla
            ',
      error_mode: :warn,
-      line_numbers: true)
+      line_numbers: true
+                                     )

    assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
      template.warnings.map(&:message)
@@ -136,7 +123,8 @@ class ErrorHandlingTest < Minitest::Test
          bla
                ',
        error_mode: :strict,
-        line_numbers: true)
+        line_numbers: true
+                            )
    end

    assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
@@ -153,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
@@ -197,44 +186,26 @@ 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 = ->(e) { exceptions << e; '' }
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}')
-
-    output = template.render('errors' => ErrorDrop.new)
-
-    assert_equal 'This is a runtime error: ', output
-    assert_equal [Liquid::ArgumentError], template.errors.map(&:class)
-  ensure
-    Liquid::Template.default_exception_renderer = old_exception_renderer if old_exception_renderer
-  end
-
-  def test_exception_renderer_exposing_non_liquid_error
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
-    exceptions = []
-    handler = ->(e) { exceptions << e; e.cause }
-
-    output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler)
-
-    assert_equal 'This is a runtime error: runtime error', output
-    assert_equal [Liquid::InternalError], exceptions.map(&:class)
-    assert_equal exceptions, template.errors
-    assert_equal '#<RuntimeError: runtime error>', exceptions.first.cause.inspect
+    assert_equal [InternalError], template.errors.map(&:class)
  end

  class TestFileSystem
-    def read_template_file(_template_path)
+    def read_template_file(template_path)
      "{{ errors.argument_error }}"
    end
  end
--- a/test/integration/filter_test.rb
+++ b/test/integration/filter_test.rb
@@ -2,23 +2,23 @@ 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

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

  module OverrideObjectMethodFilter
-    def tap(_input)
+    def tap(input)
      "tap overridden"
    end
  end
@@ -149,7 +149,7 @@ class FiltersTest < Minitest::Test
    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

--- a/test/integration/hash_ordering_test.rb
+++ b/test/integration/hash_ordering_test.rb
@@ -1,18 +1,18 @@
 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
--- a/test/integration/output_test.rb
+++ b/test/integration/output_test.rb
@@ -1,7 +1,7 @@
 require 'test_helper'

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

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

--- 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(
-      ["test", "infilter"],
-      visit(%({{ test | split: infilter }}))
-    )
-  end
-
-  def test_dynamic_variable
-    assert_equal(
-      ["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
@@ -99,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

@@ -115,8 +115,4 @@ class ParsingQuirksTest < Minitest::Test
      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
@@ -128,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

@@ -145,7 +145,7 @@ class RenderProfilingTest < Minitest::Test

  def test_profiling_marks_children_of_for_blocks
    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
-    t.render!("collection" => ["one", "two"])
+    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
@@ -9,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 )
@@ -63,18 +59,4 @@ class SecurityTest < Minitest::Test

    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
@@ -17,7 +17,7 @@ class TestThing
    "woot: #{@foo}"
  end

-  def [](_whatever)
+  def [](whatever)
    to_s
  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

@@ -115,29 +105,21 @@ class StandardFiltersTest < Minitest::Test
    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)
  end

  def test_split
    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 ['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 nil, @filters.escape(nil)
    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 +128,14 @@ 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)
+    assert_equal 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_decode(nil)
  end

  def test_truncatewords
@@ -170,7 +144,6 @@ class StandardFiltersTest < Minitest::Test
    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)
  end

  def test_strip_html
@@ -181,15 +154,11 @@ class StandardFiltersTest < Minitest::Test
    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
@@ -197,114 +166,16 @@ class StandardFiltersTest < Minitest::Test
    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 ["a", "B", "c", "D"], @filters.sort_natural(["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 ["a", "b", "c", "X", "Y", "Z"], @filters.sort_natural(["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
-  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
@@ -326,34 +197,10 @@ class StandardFiltersTest < Minitest::Test
    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
@@ -380,7 +227,7 @@ class StandardFiltersTest < Minitest::Test

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

  def test_legacy_map_on_hashes_with_dynamic_key
@@ -397,7 +244,7 @@ class StandardFiltersTest < Minitest::Test

  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
@@ -405,10 +252,10 @@ class StandardFiltersTest < Minitest::Test
  def test_map_over_drops_returning_procs
    drops = [
      {
-        "proc" => -> { "foo" },
+        "proc" => ->{ "foo" },
      },
      {
-        "proc" => -> { "bar" },
+        "proc" => ->{ "bar" },
      },
    ]
    templ = '{{ drops | map: "proc" }}'
@@ -419,29 +266,6 @@ class StandardFiltersTest < Minitest::Test
    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
-  end
-
  def test_sort_works_on_enumerables
    assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new
  end
@@ -472,11 +296,11 @@ class StandardFiltersTest < Minitest::Test
    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 "#{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")

@@ -489,8 +313,8 @@ class StandardFiltersTest < Minitest::Test
  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
@@ -540,38 +364,20 @@ class StandardFiltersTest < Minitest::Test
  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)
  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 }}"
  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)
  end

  def test_divided_by
@@ -585,8 +391,6 @@ class StandardFiltersTest < Minitest::Test
    assert_raises(Liquid::ZeroDivisionError) do
      assert_template_result "4", "{{ 1 | modulo: 0 }}"
    end
-
-    assert_template_result "5", "{{ price | divided_by:2 }}", 'price' => NumberLikeThing.new(10)
  end

  def test_modulo
@@ -594,8 +398,6 @@ class StandardFiltersTest < Minitest::Test
    assert_raises(Liquid::ZeroDivisionError) do
      assert_template_result "4", "{{ 1 | modulo: 0 }}"
    end
-
-    assert_template_result "1", "{{ price | modulo:2 }}", 'price' => NumberLikeThing.new(3)
  end

  def test_round
@@ -605,9 +407,6 @@ class StandardFiltersTest < Minitest::Test
    assert_raises(Liquid::FloatDomainError) do
      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
@@ -616,8 +415,6 @@ class StandardFiltersTest < Minitest::Test
    assert_raises(Liquid::FloatDomainError) do
      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
@@ -626,30 +423,6 @@ class StandardFiltersTest < Minitest::Test
    assert_raises(Liquid::FloatDomainError) do
      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
@@ -663,7 +436,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
@@ -692,78 +466,6 @@ class StandardFiltersTest < Minitest::Test
    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)
--- a/test/integration/tags/echo_test.rb
+++ b/test/integration/tags/echo_test.rb
@@ -1,11 +0,0 @@
-require 'test_helper'
-
-class EchoTest < Minitest::Test
-  include Liquid
-
-  def test_echo_outputs_its_input
-    assert_template_result('BAR', <<~LIQUID, 'variable-name' => 'bar')
-      {%- echo variable-name | upcase -%}
-    LIQUID
-  end
-end
--- a/test/integration/tags/for_tag_test.rb
+++ b/test/integration/tags/for_tag_test.rb
@@ -23,16 +23,16 @@ class ForTagTest < Minitest::Test
  yo

 HERE
-    template = <<~HERE
-      {%for item in array%}
-        yo
-      {%endfor%}
-    HERE
+    template = <<HERE
+{%for item in array%}
+  yo
+{%endfor%}
+HERE
    assert_template_result(expected, template, 'array' => [1, 2, 3])
  end

  def test_for_reversed
-    assigns = { 'array' => [1, 2, 3] }
+    assigns = { 'array' => [ 1, 2, 3] }
    assert_template_result('321', '{%for item in array reversed %}{{item}}{%endfor%}', assigns)
  end

@@ -103,34 +103,6 @@ HERE
    assert_template_result('3456', '{%for i in array limit: 4 offset: 2 %}{{ i }}{%endfor%}', assigns)
  end

-  def test_limiting_with_invalid_limit
-    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
-    template = <<-MKUP
-      {% for i in array limit: true offset: 1 %}
-        {{ i }}
-      {% endfor %}
-    MKUP
-
-    exception = assert_raises(Liquid::ArgumentError) do
-      Template.parse(template).render!(assigns)
-    end
-    assert_equal("Liquid error: invalid integer", exception.message)
-  end
-
-  def test_limiting_with_invalid_offset
-    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
-    template = <<-MKUP
-      {% for i in array limit: 1 offset: true %}
-        {{ i }}
-      {% endfor %}
-    MKUP
-
-    exception = assert_raises(Liquid::ArgumentError) do
-      Template.parse(template).render!(assigns)
-    end
-    assert_equal("Liquid error: invalid integer", exception.message)
-  end
-
  def test_dynamic_variable_limiting
    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
    assigns['limit'] = 2
@@ -187,7 +159,7 @@ HERE
    assert_template_result(expected, markup, assigns)
  end

-  def test_pause_resume_big_limit
+  def test_pause_resume_BIG_limit
    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
    markup = <<-MKUP
      {%for i in array.items limit:3 %}{{i}}{%endfor%}
@@ -206,7 +178,7 @@ HERE
    assert_template_result(expected, markup, assigns)
  end

-  def test_pause_resume_big_offset
+  def test_pause_resume_BIG_offset
    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
    markup = '{%for i in array.items limit:3 %}{{i}}{%endfor%}
      next
--- a/test/integration/tags/if_else_tag_test.rb
+++ b/test/integration/tags/if_else_tag_test.rb
@@ -132,7 +132,7 @@ class IfElseTagTest < Minitest::Test
  end

  def test_syntax_error_no_variable
-    assert_raises(SyntaxError) { assert_template_result('', '{% if jerry == 1 %}') }
+    assert_raises(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}') }
  end

  def test_syntax_error_no_expression
--- a/test/integration/tags/include_tag_test.rb
+++ b/test/integration/tags/include_tag_test.rb
@@ -30,9 +30,6 @@ class TestFileSystem
    when 'assignments'
      "{% assign foo = 'bar' %}"

-    when 'break'
-      "{% break %}"
-
    else
      template_path
    end
@@ -40,14 +37,14 @@ class TestFileSystem
 end

 class OtherFileSystem
-  def read_template_file(_template_path)
+  def read_template_file(template_path)
    'from OtherFileSystem'
  end
 end

 class CountingFileSystem
  attr_reader :count
-  def read_template_file(_template_path)
+  def read_template_file(template_path)
    @count ||= 0
    @count += 1
    'from CountingFileSystem'
@@ -59,16 +56,15 @@ class CustomInclude < Liquid::Tag

  def initialize(tag_name, markup, tokens)
    markup =~ Syntax
-    @template_name = Regexp.last_match(1)
+    @template_name = $1
    super
  end

  def parse(tokens)
  end

-  def render_to_output_buffer(_context, output)
-    output << @template_name[1..-2]
-    output
+  def render(context)
+    @template_name[1..-2]
  end
 end

@@ -86,7 +82,7 @@ class IncludeTagTest < Minitest::Test

  def test_include_tag_with
    assert_template_result "Product: Draft 151cm ",
-      "{% include 'product' with products[0] %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }]
+      "{% include 'product' with products[0] %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
  end

  def test_include_tag_with_default_name
@@ -96,7 +92,7 @@ class IncludeTagTest < Minitest::Test

  def test_include_tag_for
    assert_template_result "Product: Draft 151cm Product: Element 155cm ",
-      "{% include 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }]
+      "{% include 'product' for products %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
  end

  def test_include_tag_with_local_variables
@@ -134,14 +130,14 @@ class IncludeTagTest < Minitest::Test

  def test_recursively_included_template_does_not_produce_endless_loop
    infinite_file_system = Class.new do
-      def read_template_file(_template_path)
+      def read_template_file(template_path)
        "-{% include 'loop' %}"
      end
    end

    Liquid::Template.file_system = infinite_file_system.new

-    assert_raises(Liquid::StackLevelError) do
+    assert_raises(Liquid::StackLevelError, SystemStackError) do
      Template.parse("{% include 'loop' %}").render!
    end
  end
@@ -221,17 +217,6 @@ class IncludeTagTest < Minitest::Test
    end
  end

-  def test_render_raise_argument_error_when_template_is_undefined
-    assert_raises(Liquid::ArgumentError) do
-      template = Liquid::Template.parse('{% include undefined_variable %}')
-      template.render!
-    end
-    assert_raises(Liquid::ArgumentError) do
-      template = Liquid::Template.parse('{% include nil %}')
-      template.render!
-    end
-  end
-
  def test_including_via_variable_value
    assert_template_result "from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}"

@@ -239,16 +224,4 @@ class IncludeTagTest < Minitest::Test

    assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => { 'title' => 'Draft 151cm' }
  end
-
-  def test_including_with_strict_variables
-    template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn)
-    template.render(nil, strict_variables: true)
-
-    assert_equal [], template.errors
-  end
-
-  def test_break_through_include
-    assert_template_result "1", "{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}"
-    assert_template_result "1", "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}"
-  end
 end # IncludeTagTest
--- a/test/integration/tags/increment_tag_test.rb
+++ b/test/integration/tags/increment_tag_test.rb
@@ -13,11 +13,11 @@ class IncrementTagTest < Minitest::Test
  end

  def test_dec
-    assert_template_result('9', '{%decrement port %}', 'port' => 10)
+    assert_template_result('9', '{%decrement port %}', { 'port' => 10 })
    assert_template_result('-1 -2', '{%decrement port %} {%decrement port%}', {})
    assert_template_result('1 5 2 2 5',
      '{%increment port %} {%increment starboard%} ' \
      '{%increment port %} {%decrement port%} ' \
-      '{%decrement starboard %}', 'port' => 1, 'starboard' => 5)
+      '{%decrement starboard %}', { 'port' => 1, 'starboard' => 5 })
  end
 end
--- a/test/integration/tags/liquid_tag_test.rb
+++ b/test/integration/tags/liquid_tag_test.rb
@@ -1,104 +0,0 @@
-require 'test_helper'
-
-class LiquidTagTest < Minitest::Test
-  include Liquid
-
-  def test_liquid_tag
-    assert_template_result('1 2 3', <<~LIQUID, 'array' => [1, 2, 3])
-      {%- liquid
-        echo array | join: " "
-      -%}
-    LIQUID
-
-    assert_template_result('1 2 3', <<~LIQUID, 'array' => [1, 2, 3])
-      {%- liquid
-        for value in array
-          echo value
-          unless forloop.last
-            echo " "
-          endunless
-        endfor
-      -%}
-    LIQUID
-
-    assert_template_result('4 8 12 6', <<~LIQUID, 'array' => [1, 2, 3])
-      {%- liquid
-        for value in array
-          assign double_value = value | times: 2
-          echo double_value | times: 2
-          unless forloop.last
-            echo " "
-          endunless
-        endfor
-
-        echo " "
-        echo double_value
-      -%}
-    LIQUID
-
-    assert_template_result('abc', <<~LIQUID)
-      {%- liquid echo "a" -%}
-      b
-      {%- liquid echo "c" -%}
-    LIQUID
-  end
-
-  def test_liquid_tag_errors
-    assert_match_syntax_error("syntax error (line 1): Unknown tag 'error'", <<~LIQUID)
-      {%- liquid error no such tag -%}
-    LIQUID
-
-    assert_match_syntax_error("syntax error (line 7): Unknown tag 'error'", <<~LIQUID)
-      {{ test }}
-
-      {%-
-      liquid
-        for value in array
-
-          error no such tag
-        endfor
-      -%}
-    LIQUID
-
-    assert_match_syntax_error("syntax error (line 2): Unknown tag '!!! the guards are vigilant'", <<~LIQUID)
-      {%- liquid
-        !!! the guards are vigilant
-      -%}
-    LIQUID
-
-    assert_match_syntax_error("syntax error (line 4): 'for' tag was never closed", <<~LIQUID)
-      {%- liquid
-        for value in array
-          echo 'forgot to close the for tag'
-      -%}
-    LIQUID
-  end
-
-  def test_line_number_is_correct_after_a_blank_token
-    assert_match_syntax_error("syntax error (line 3): Unknown tag 'error'", "{% liquid echo ''\n\n error %}")
-    assert_match_syntax_error("syntax error (line 3): Unknown tag 'error'", "{% liquid echo ''\n  \n error %}")
-  end
-
-  def test_cannot_open_blocks_living_past_a_liquid_tag
-    assert_match_syntax_error("syntax error (line 3): 'if' tag was never closed", <<~LIQUID)
-      {%- liquid
-        if true
-      -%}
-      {%- endif -%}
-    LIQUID
-  end
-
-  def test_quirk_can_close_blocks_created_before_a_liquid_tag
-    assert_template_result("42", <<~LIQUID)
-      {%- if true -%}
-      42
-      {%- liquid endif -%}
-    LIQUID
-  end
-
-  def test_liquid_tag_in_raw
-    assert_template_result("{% liquid echo 'test' %}\n", <<~LIQUID)
-      {% raw %}{% liquid echo 'test' %}{% endraw %}
-    LIQUID
-  end
-end
--- a/test/integration/tags/raw_tag_test.rb
+++ b/test/integration/tags/raw_tag_test.rb
@@ -24,8 +24,8 @@ class RawTagTest < Minitest::Test
  end

  def test_invalid_raw
-    assert_match_syntax_error(/tag was never closed/, '{% raw %} foo')
-    assert_match_syntax_error(/Valid syntax/, '{% raw } foo {% endraw %}')
-    assert_match_syntax_error(/Valid syntax/, '{% raw } foo %}{% endraw %}')
+    assert_match_syntax_error /tag was never closed/, '{% raw %} foo'
+    assert_match_syntax_error /Valid syntax/, '{% raw } foo {% endraw %}'
+    assert_match_syntax_error /Valid syntax/, '{% raw } foo %}{% endraw %}'
  end
 end
--- a/test/integration/tags/render_tag_test.rb
+++ b/test/integration/tags/render_tag_test.rb
@@ -1,149 +0,0 @@
-require 'test_helper'
-
-class RenderTagTest < Minitest::Test
-  include Liquid
-
-  def test_render_with_no_arguments
-    Liquid::Template.file_system = StubFileSystem.new('source' => 'rendered content')
-    assert_template_result 'rendered content', '{% render "source" %}'
-  end
-
-  def test_render_tag_looks_for_file_system_in_registers_first
-    file_system = StubFileSystem.new('pick_a_source' => 'from register file system')
-    assert_equal 'from register file system',
-      Template.parse('{% render "pick_a_source" %}').render!({}, registers: { file_system: file_system })
-  end
-
-  def test_render_passes_named_arguments_into_inner_scope
-    Liquid::Template.file_system = StubFileSystem.new('product' => '{{ inner_product.title }}')
-    assert_template_result 'My Product', '{% render "product", inner_product: outer_product %}',
-      'outer_product' => { 'title' => 'My Product' }
-  end
-
-  def test_render_accepts_literals_as_arguments
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ price }}')
-    assert_template_result '123', '{% render "snippet", price: 123 %}'
-  end
-
-  def test_render_accepts_multiple_named_arguments
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ one }} {{ two }}')
-    assert_template_result '1 2', '{% render "snippet", one: 1, two: 2 %}'
-  end
-
-  def test_render_does_not_inherit_parent_scope_variables
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ outer_variable }}')
-    assert_template_result '', '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}'
-  end
-
-  def test_render_does_not_inherit_variable_with_same_name_as_snippet
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ snippet }}')
-    assert_template_result '', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}"
-  end
-
-  def test_render_sets_the_correct_template_name_for_errors
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
-
-    with_taint_mode :error do
-      template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
-      context = Context.new('unsafe' => (+'unsafe').tap(&:taint))
-      template.render(context)
-
-      assert_equal [Liquid::TaintedError], template.errors.map(&:class)
-      assert_equal 'snippet', template.errors.first.template_name
-    end
-  end
-
-  def test_render_sets_the_correct_template_name_for_warnings
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
-
-    with_taint_mode :warn do
-      template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
-      context = Context.new('unsafe' => (+'unsafe').tap(&:taint))
-      template.render(context)
-
-      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
-      assert_equal 'snippet', context.warnings.first.template_name
-    end
-  end
-
-  def test_render_does_not_mutate_parent_scope
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{% assign inner = 1 %}')
-    assert_template_result '', "{% render 'snippet' %}{{ inner }}"
-  end
-
-  def test_nested_render_tag
-    Liquid::Template.file_system = StubFileSystem.new(
-      'one' => "one {% render 'two' %}",
-      'two' => 'two'
-    )
-    assert_template_result 'one two', "{% render 'one' %}"
-  end
-
-  def test_recursively_rendered_template_does_not_produce_endless_loop
-    Liquid::Template.file_system = StubFileSystem.new('loop' => '{% render "loop" %}')
-
-    assert_raises Liquid::StackLevelError do
-      Template.parse('{% render "loop" %}').render!
-    end
-  end
-
-  def test_includes_and_renders_count_towards_the_same_recursion_limit
-    Liquid::Template.file_system = StubFileSystem.new(
-      'loop_render' => '{% render "loop_include" %}',
-      'loop_include' => '{% include "loop_render" %}'
-    )
-
-    assert_raises Liquid::StackLevelError  do
-      Template.parse('{% render "loop_include" %}').render!
-    end
-  end
-
-  def test_dynamically_choosen_templates_are_not_allowed
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'should not be rendered')
-
-    assert_raises Liquid::SyntaxError do
-      Liquid::Template.parse("{% assign name = 'snippet' %}{% render name %}")
-    end
-  end
-
-  def test_include_tag_caches_second_read_of_same_partial
-    file_system = StubFileSystem.new('snippet' => 'echo')
-    assert_equal 'echoecho',
-      Template.parse('{% render "snippet" %}{% render "snippet" %}')
-      .render!({}, registers: { file_system: file_system })
-    assert_equal 1, file_system.file_read_count
-  end
-
-  def test_render_tag_doesnt_cache_partials_across_renders
-    file_system = StubFileSystem.new('snippet' => 'my message')
-
-    assert_equal 'my message',
-      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system })
-    assert_equal 1, file_system.file_read_count
-
-    assert_equal 'my message',
-      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system })
-    assert_equal 2, file_system.file_read_count
-  end
-
-  def test_render_tag_within_if_statement
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'my message')
-    assert_template_result 'my message', '{% if true %}{% render "snippet" %}{% endif %}'
-  end
-
-  def test_break_through_render
-    Liquid::Template.file_system = StubFileSystem.new('break' => '{% break %}')
-    assert_template_result '1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}'
-    assert_template_result '112233', '{% for i in (1..3) %}{{ i }}{% render "break" %}{{ i }}{% endfor %}'
-  end
-
-  def test_increment_is_isolated_between_renders
-    Liquid::Template.file_system = StubFileSystem.new('incr' => '{% increment %}')
-    assert_template_result '010', '{% increment %}{% increment %}{% render "incr" %}'
-  end
-
-  def test_decrement_is_isolated_between_renders
-    Liquid::Template.file_system = StubFileSystem.new('decr' => '{% decrement %}')
-    assert_template_result '-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}'
-  end
-end
--- a/test/integration/tags/standard_tag_test.rb
+++ b/test/integration/tags/standard_tag_test.rb
@@ -69,7 +69,7 @@ class StandardTagTest < Minitest::Test
    assert_raises(SyntaxError) do
      assert_template_result('content foo content foo ',
        '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
-        'var' => 'content')
+        { 'var' => 'content' })
    end
  end

@@ -183,32 +183,32 @@ class StandardTagTest < Minitest::Test

  def test_case_when_or
    code = '{% case condition %}{% when 1 or 2 or 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 2)
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 3)
-    assert_template_result(' its 4 ', code, 'condition' => 4)
-    assert_template_result('', code, 'condition' => 5)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
+    assert_template_result(' its 4 ', code, { 'condition' => 4 })
+    assert_template_result('', code, { 'condition' => 5 })

    code = '{% case condition %}{% when 1 or "string" or null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 'string')
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => nil)
-    assert_template_result('', code, 'condition' => 'something else')
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
+    assert_template_result('', code, { 'condition' => 'something else' })
  end

  def test_case_when_comma
    code = '{% case condition %}{% when 1, 2, 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 2)
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 3)
-    assert_template_result(' its 4 ', code, 'condition' => 4)
-    assert_template_result('', code, 'condition' => 5)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
+    assert_template_result(' its 4 ', code, { 'condition' => 4 })
+    assert_template_result('', code, { 'condition' => 5 })

    code = '{% case condition %}{% when 1, "string", null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 'string')
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => nil)
-    assert_template_result('', code, 'condition' => 'something else')
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
+    assert_template_result('', code, { 'condition' => 'something else' })
  end

  def test_assign
@@ -283,10 +283,10 @@ class StandardTagTest < Minitest::Test
  end

  def test_ifchanged
-    assigns = { 'array' => [1, 1, 2, 2, 3, 3] }
+    assigns = { 'array' => [ 1, 1, 2, 2, 3, 3] }
    assert_template_result('123', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)

-    assigns = { 'array' => [1, 1, 1, 1] }
+    assigns = { 'array' => [ 1, 1, 1, 1] }
    assert_template_result('1', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)
  end

--- a/test/integration/template_test.rb
+++ b/test/integration/template_test.rb
@@ -42,18 +42,6 @@ class TemplateTest < Minitest::Test
    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
  end

-  def test_instance_assigns_persist_on_same_template_object_between_many_parses
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns second', t.parse("{% assign foo = 'from instance assigns second' %}{{ foo }}").render!
-    assert_equal 'from instance assigns second', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns second', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns second', t.parse("{{ foo }}").render!
-  end
-
  def test_warnings_is_not_exponential_time
    str = "false"
    100.times do
@@ -70,14 +58,6 @@ class TemplateTest < Minitest::Test
    assert_equal 'foofoo', t.render!
  end

-  def test_instance_assigns_persist_on_same_template_parsing_between_many_renders
-    t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
-    assert_equal 'foo', t.render!
-    assert_equal 'foofoo', t.render!
-    assert_equal 'foofoo', t.render!
-    assert_equal 'foofoo', t.render!
-  end
-
  def test_custom_assigns_do_not_persist_on_same_template
    t = Template.new
    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
@@ -159,16 +139,6 @@ class TemplateTest < Minitest::Test
    refute_nil t.resource_limits.assign_score
  end

-  def test_resource_limits_assign_score_counts_bytes_not_characters
-    t = Template.parse("{% assign foo = 'すごい' %}")
-    t.render
-    assert_equal 9, t.resource_limits.assign_score
-
-    t = Template.parse("{% capture foo %}すごい{% endcapture %}")
-    t.render
-    assert_equal 9, t.resource_limits.assign_score
-  end
-
  def test_resource_limits_assign_score_nested
    t = Template.parse("{% assign foo = 'aaaa' | reverse %}")

@@ -217,14 +187,6 @@ class TemplateTest < Minitest::Test
    assert_equal "ababab", t.render
  end

-  def test_render_length_uses_number_of_bytes_not_characters
-    t = Template.parse("{% if true %}すごい{% endif %}")
-    t.resource_limits.render_length_limit = 10
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    t.resource_limits.render_length_limit = 18
-    assert_equal "すごい", t.render
-  end
-
  def test_default_resource_limits_unaffected_by_render_with_context
    context = Context.new
    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
@@ -244,7 +206,7 @@ class TemplateTest < Minitest::Test
  end

  def test_render_bang_force_rethrow_errors_on_passed_context
-    context = Context.new('drop' => ErroneousDrop.new)
+    context = Context.new({ 'drop' => ErroneousDrop.new })
    t = Template.new.parse('{{ drop.bad_method }}')

    e = assert_raises RuntimeError do
@@ -253,20 +215,16 @@ class TemplateTest < Minitest::Test
    assert_equal 'ruby error in drop', e.message
  end

-  def test_exception_renderer_that_returns_string
+  def test_exception_handler_doesnt_reraise_if_it_returns_false
    exception = nil
-    handler = ->(e) { exception = e; '<!-- error -->' }
-
-    output = Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: handler)
-
+    Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; false })
    assert exception.is_a?(Liquid::ZeroDivisionError)
-    assert_equal '<!-- error -->', output
  end

-  def test_exception_renderer_that_raises
+  def test_exception_handler_does_reraise_if_it_returns_true
    exception = nil
    assert_raises(Liquid::ZeroDivisionError) do
-      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: ->(e) { exception = e; raise })
+      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; true })
    end
    assert exception.is_a?(Liquid::ZeroDivisionError)
  end
@@ -287,7 +245,7 @@ class TemplateTest < Minitest::Test

  def test_undefined_variables
    t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
-    result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, strict_variables: true)
+    result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })

    assert_equal '33  32  ', result
    assert_equal 3, t.errors.count
@@ -299,27 +257,18 @@ class TemplateTest < Minitest::Test
    assert_equal 'Liquid error: undefined variable d', t.errors[2].message
  end

-  def test_nil_value_does_not_raise
-    Liquid::Template.error_mode = :strict
-    t = Template.parse("some{{x}}thing")
-    result = t.render!({ 'x' => nil }, strict_variables: true)
-
-    assert_equal 0, t.errors.count
-    assert_equal 'something', result
-  end
-
  def test_undefined_variables_raise
    t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")

    assert_raises UndefinedVariable do
-      t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, strict_variables: true)
+      t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })
    end
  end

  def test_undefined_drop_methods
    d = DropWithUndefinedMethod.new
    t = Template.new.parse('{{ foo }} {{ woot }}')
-    result = t.render(d, strict_variables: true)
+    result = t.render(d, { strict_variables: true })

    assert_equal 'foo ', result
    assert_equal 1, t.errors.count
@@ -331,7 +280,7 @@ class TemplateTest < Minitest::Test
    t = Template.new.parse('{{ foo }} {{ woot }}')

    assert_raises UndefinedDropMethod do
-      t.render!(d, strict_variables: true)
+      t.render!(d, { strict_variables: true })
    end
  end

@@ -342,7 +291,7 @@ class TemplateTest < Minitest::Test
        "-#{v}-"
      end
    end
-    result = t.render({ 'a' => 123, 'x' => 'foo' }, filters: [filters], strict_filters: true)
+    result = t.render({ 'a' => 123, 'x' => 'foo' }, { filters: [filters], strict_filters: true })

    assert_equal '123 ', result
    assert_equal 1, t.errors.count
@@ -354,17 +303,7 @@ class TemplateTest < Minitest::Test
    t = Template.parse("{{x | somefilter1 | upcase | somefilter2}}")

    assert_raises UndefinedFilter do
-      t.render!({ 'x' => 'foo' }, strict_filters: true)
+      t.render!({ 'x' => 'foo' }, { strict_filters: true })
    end
  end
-
-  def test_using_range_literal_works_as_expected
-    t = Template.parse("{% assign foo = (x..y) %}{{ foo }}")
-    result = t.render('x' => 1, 'y' => 5)
-    assert_equal '1..5', result
-
-    t = Template.parse("{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}")
-    result = t.render('x' => 1, 'y' => 5)
-    assert_equal '12345', result
-  end
 end
--- a/test/integration/trim_mode_test.rb
+++ b/test/integration/trim_mode_test.rb
@@ -1,529 +0,0 @@
-require 'test_helper'
-
-class TrimModeTest < Minitest::Test
-  include Liquid
-
-  # Make sure the trim isn't applied to standard output
-  def test_standard_output
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {{ 'John' }}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-          John
-        </p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_variable_output_with_multiple_blank_lines
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-
-
-          {{- 'John' -}}
-
-
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>John</p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_tag_output_with_multiple_blank_lines
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-
-
-          {%- if true -%}
-          yes
-          {%- endif -%}
-
-
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>yes</p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  # Make sure the trim isn't applied to standard tags
-  def test_standard_tags
-    whitespace = '          '
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {% if true %}
-          yes
-          {% endif %}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<~END_EXPECTED
-            <div>
-              <p>
-      #{whitespace}
-                yes
-      #{whitespace}
-              </p>
-            </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {% if false %}
-          no
-          {% endif %}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<~END_EXPECTED
-            <div>
-              <p>
-      #{whitespace}
-              </p>
-            </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  # Make sure the trim isn't too agressive
-  def test_no_trim_output
-    text = '<p>{{- \'John\' -}}</p>'
-    expected = '<p>John</p>'
-    assert_template_result(expected, text)
-  end
-
-  # Make sure the trim isn't too agressive
-  def test_no_trim_tags
-    text = '<p>{%- if true -%}yes{%- endif -%}</p>'
-    expected = '<p>yes</p>'
-    assert_template_result(expected, text)
-
-    text = '<p>{%- if false -%}no{%- endif -%}</p>'
-    expected = '<p></p>'
-    assert_template_result(expected, text)
-  end
-
-  def test_single_line_outer_tag
-    text = '<p> {%- if true %} yes {% endif -%} </p>'
-    expected = '<p> yes </p>'
-    assert_template_result(expected, text)
-
-    text = '<p> {%- if false %} no {% endif -%} </p>'
-    expected = '<p></p>'
-    assert_template_result(expected, text)
-  end
-
-  def test_single_line_inner_tag
-    text = '<p> {% if true -%} yes {%- endif %} </p>'
-    expected = '<p> yes </p>'
-    assert_template_result(expected, text)
-
-    text = '<p> {% if false -%} no {%- endif %} </p>'
-    expected = '<p>  </p>'
-    assert_template_result(expected, text)
-  end
-
-  def test_single_line_post_tag
-    text = '<p> {% if true -%} yes {% endif -%} </p>'
-    expected = '<p> yes </p>'
-    assert_template_result(expected, text)
-
-    text = '<p> {% if false -%} no {% endif -%} </p>'
-    expected = '<p> </p>'
-    assert_template_result(expected, text)
-  end
-
-  def test_single_line_pre_tag
-    text = '<p> {%- if true %} yes {%- endif %} </p>'
-    expected = '<p> yes </p>'
-    assert_template_result(expected, text)
-
-    text = '<p> {%- if false %} no {%- endif %} </p>'
-    expected = '<p> </p>'
-    assert_template_result(expected, text)
-  end
-
-  def test_pre_trim_output
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {{- 'John' }}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>John
-        </p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_pre_trim_tags
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {%- if true %}
-          yes
-          {%- endif %}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-          yes
-        </p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {%- if false %}
-          no
-          {%- endif %}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-        </p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_post_trim_output
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {{ 'John' -}}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-          John</p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_post_trim_tags
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {% if true -%}
-          yes
-          {% endif -%}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-          yes
-          </p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {% if false -%}
-          no
-          {% endif -%}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-          </p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_pre_and_post_trim_tags
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {%- if true %}
-          yes
-          {% endif -%}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-          yes
-          </p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {%- if false %}
-          no
-          {% endif -%}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p></p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_post_and_pre_trim_tags
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {% if true -%}
-          yes
-          {%- endif %}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>
-          yes
-        </p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-
-    whitespace = '          '
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {% if false -%}
-          no
-          {%- endif %}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<~END_EXPECTED
-            <div>
-              <p>
-      #{whitespace}
-              </p>
-            </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_trim_output
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {{- 'John' -}}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>John</p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_trim_tags
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {%- if true -%}
-          yes
-          {%- endif -%}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>yes</p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {%- if false -%}
-          no
-          {%- endif -%}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p></p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_whitespace_trim_output
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {{- 'John' -}},
-          {{- '30' -}}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>John,30</p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_whitespace_trim_tags
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {%- if true -%}
-          yes
-          {%- endif -%}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>yes</p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {%- if false -%}
-          no
-          {%- endif -%}
-        </p>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p></p>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_complex_trim_output
-    text = <<-END_TEMPLATE
-      <div>
-        <p>
-          {{- 'John' -}}
-          {{- '30' -}}
-        </p>
-        <b>
-          {{ 'John' -}}
-          {{- '30' }}
-        </b>
-        <i>
-          {{- 'John' }}
-          {{ '30' -}}
-        </i>
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div>
-        <p>John30</p>
-        <b>
-          John30
-        </b>
-        <i>John
-          30</i>
-      </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_complex_trim
-    text = <<-END_TEMPLATE
-      <div>
-        {%- if true -%}
-          {%- if true -%}
-            <p>
-              {{- 'John' -}}
-            </p>
-          {%- endif -%}
-        {%- endif -%}
-      </div>
-    END_TEMPLATE
-    expected = <<-END_EXPECTED
-      <div><p>John</p></div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-
-  def test_right_trim_followed_by_tag
-    assert_template_result('ab c', '{{ "a" -}}{{ "b" }} c')
-  end
-
-  def test_raw_output
-    whitespace = '        '
-    text = <<-END_TEMPLATE
-      <div>
-        {% raw %}
-          {%- if true -%}
-            <p>
-              {{- 'John' -}}
-            </p>
-          {%- endif -%}
-        {% endraw %}
-      </div>
-    END_TEMPLATE
-    expected = <<~END_EXPECTED
-            <div>
-      #{whitespace}
-                {%- if true -%}
-                  <p>
-                    {{- 'John' -}}
-                  </p>
-                {%- endif -%}
-      #{whitespace}
-            </div>
-    END_EXPECTED
-    assert_template_result(expected, text)
-  end
-end # TrimModeTest
--- a/test/integration/variable_test.rb
+++ b/test/integration/variable_test.rb
@@ -76,7 +76,7 @@ class VariableTest < Minitest::Test

  def test_hash_with_default_proc
    template = Template.parse(%(Hello {{ test }}))
-    assigns = Hash.new { |_h, k| raise "Unknown variable '#{k}'" }
+    assigns = Hash.new { |h, k| raise "Unknown variable '#{k}'" }
    assigns['test'] = 'Tobi'
    assert_equal 'Hello Tobi', template.render!(assigns)
    assigns.delete('test')
@@ -89,8 +89,4 @@ class VariableTest < Minitest::Test
  def test_multiline_variable
    assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
  end
-
-  def test_render_symbol
-    assert_template_result 'bar', '{{ foo }}', 'foo' => :bar
-  end
 end
--- a/test/test_helper.rb
+++ b/test/test_helper.rb
@@ -2,6 +2,7 @@

 ENV["MT_NO_EXPECTATIONS"] = "1"
 require 'minitest/autorun'
+require 'spy/integration'

 $LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
 require 'liquid.rb'
@@ -14,7 +15,7 @@ if env_mode = ENV['LIQUID_PARSER_MODE']
 end
 Liquid::Template.error_mode = mode

-if ENV['LIQUID_C'] == '1'
+if ENV['LIQUID-C'] == '1'
  puts "-- LIQUID C"
  require 'liquid/c'
 end
@@ -37,18 +38,18 @@ module Minitest
    include Liquid

    def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template, line_numbers: true).render!(assigns), message
+      assert_equal expected, Template.parse(template).render!(assigns), message
    end

    def assert_template_result_matches(expected, template, assigns = {}, message = nil)
-      return assert_template_result(expected, template, assigns, message) unless expected.is_a?(Regexp)
+      return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp

-      assert_match expected, Template.parse(template, line_numbers: true).render!(assigns), message
+      assert_match expected, Template.parse(template).render!(assigns), message
    end

    def assert_match_syntax_error(match, template, assigns = {})
      exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template, line_numbers: true).render(assigns)
+        Template.parse(template).render(assigns)
      end
      assert_match match, exception.message
    end
@@ -84,13 +85,6 @@ module Minitest
    ensure
      Liquid::Template.error_mode = old_mode
    end
-
-    def with_custom_tag(tag_name, tag_class)
-      Liquid::Template.register_tag(tag_name, tag_class)
-      yield
-    ensure
-      Liquid::Template.tags.delete(tag_name)
-    end
  end
 end

@@ -121,17 +115,3 @@ class ErrorDrop < Liquid::Drop
    raise Exception, 'exception'
  end
 end
-
-class StubFileSystem
-  attr_reader :file_read_count
-
-  def initialize(values)
-    @file_read_count = 0
-    @values = values
-  end
-
-  def read_template_file(template_path)
-    @file_read_count += 1
-    @values.fetch(template_path)
-  end
-end
--- a/test/unit/block_unit_test.rb
+++ b/test/unit/block_unit_test.rb
@@ -44,47 +44,8 @@ class BlockUnitTest < Minitest::Test
  end

  def test_with_custom_tag
-    with_custom_tag('testtag', Block) do
-      assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
-    end
-  end
-
-  def test_custom_block_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
-    klass1 = Class.new(Block) do
-      def render(*)
-        'hello'
-      end
-    end
-
-    with_custom_tag('blabla', klass1) do
-      template = Liquid::Template.parse("{% blabla %} bla {% endblabla %}")
-
-      assert_equal 'hello', template.render
-
-      buf = ''
-      output = template.render({}, output: buf)
-      assert_equal 'hello', output
-      assert_equal 'hello', buf
-      assert_equal buf.object_id, output.object_id
-    end
-
-    klass2 = Class.new(klass1) do
-      def render(*)
-        'foo' + super + 'bar'
-      end
-    end
-
-    with_custom_tag('blabla', klass2) do
-      template = Liquid::Template.parse("{% blabla %} foo {% endblabla %}")
-
-      assert_equal 'foohellobar', template.render
-
-      buf = ''
-      output = template.render({}, output: buf)
-      assert_equal 'foohellobar', output
-      assert_equal 'foohellobar', buf
-      assert_equal buf.object_id, output.object_id
-    end
+    Liquid::Template.register_tag("testtag", Block)
+    assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
  end

  private
--- a/test/unit/condition_unit_test.rb
+++ b/test/unit/condition_unit_test.rb
@@ -3,54 +3,50 @@ require 'test_helper'
 class ConditionUnitTest < Minitest::Test
  include Liquid

-  def setup
-    @context = Liquid::Context.new
-  end
-
  def test_basic_condition
    assert_equal false, Condition.new(1, '==', 2).evaluate
    assert_equal true,  Condition.new(1, '==', 1).evaluate
  end

  def test_default_operators_evalute_true
-    assert_evaluates_true 1, '==', 1
-    assert_evaluates_true 1, '!=', 2
-    assert_evaluates_true 1, '<>', 2
-    assert_evaluates_true 1, '<', 2
-    assert_evaluates_true 2, '>', 1
-    assert_evaluates_true 1, '>=', 1
-    assert_evaluates_true 2, '>=', 1
-    assert_evaluates_true 1, '<=', 2
-    assert_evaluates_true 1, '<=', 1
+    assert_evalutes_true 1, '==', 1
+    assert_evalutes_true 1, '!=', 2
+    assert_evalutes_true 1, '<>', 2
+    assert_evalutes_true 1, '<', 2
+    assert_evalutes_true 2, '>', 1
+    assert_evalutes_true 1, '>=', 1
+    assert_evalutes_true 2, '>=', 1
+    assert_evalutes_true 1, '<=', 2
+    assert_evalutes_true 1, '<=', 1
    # negative numbers
-    assert_evaluates_true 1, '>', -1
-    assert_evaluates_true -1, '<', 1
-    assert_evaluates_true 1.0, '>', -1.0
-    assert_evaluates_true -1.0, '<', 1.0
+    assert_evalutes_true 1, '>', -1
+    assert_evalutes_true -1, '<', 1
+    assert_evalutes_true 1.0, '>', -1.0
+    assert_evalutes_true -1.0, '<', 1.0
  end

  def test_default_operators_evalute_false
-    assert_evaluates_false 1, '==', 2
-    assert_evaluates_false 1, '!=', 1
-    assert_evaluates_false 1, '<>', 1
-    assert_evaluates_false 1, '<', 0
-    assert_evaluates_false 2, '>', 4
-    assert_evaluates_false 1, '>=', 3
-    assert_evaluates_false 2, '>=', 4
-    assert_evaluates_false 1, '<=', 0
-    assert_evaluates_false 1, '<=', 0
+    assert_evalutes_false 1, '==', 2
+    assert_evalutes_false 1, '!=', 1
+    assert_evalutes_false 1, '<>', 1
+    assert_evalutes_false 1, '<', 0
+    assert_evalutes_false 2, '>', 4
+    assert_evalutes_false 1, '>=', 3
+    assert_evalutes_false 2, '>=', 4
+    assert_evalutes_false 1, '<=', 0
+    assert_evalutes_false 1, '<=', 0
  end

  def test_contains_works_on_strings
-    assert_evaluates_true 'bob', 'contains', 'o'
-    assert_evaluates_true 'bob', 'contains', 'b'
-    assert_evaluates_true 'bob', 'contains', 'bo'
-    assert_evaluates_true 'bob', 'contains', 'ob'
-    assert_evaluates_true 'bob', 'contains', 'bob'
+    assert_evalutes_true 'bob', 'contains', 'o'
+    assert_evalutes_true 'bob', 'contains', 'b'
+    assert_evalutes_true 'bob', 'contains', 'bo'
+    assert_evalutes_true 'bob', 'contains', 'ob'
+    assert_evalutes_true 'bob', 'contains', 'bob'

-    assert_evaluates_false 'bob', 'contains', 'bob2'
-    assert_evaluates_false 'bob', 'contains', 'a'
-    assert_evaluates_false 'bob', 'contains', '---'
+    assert_evalutes_false 'bob', 'contains', 'bob2'
+    assert_evalutes_false 'bob', 'contains', 'a'
+    assert_evalutes_false 'bob', 'contains', '---'
  end

  def test_invalid_comparation_operator
@@ -64,42 +60,34 @@ class ConditionUnitTest < Minitest::Test
    assert_evaluates_argument_error '1', '<=', 0
  end

-  def test_hash_compare_backwards_compatibility
-    assert_nil Condition.new({}, '>', 2).evaluate
-    assert_nil Condition.new(2, '>', {}).evaluate
-    assert_equal false, Condition.new({}, '==', 2).evaluate
-    assert_equal true, Condition.new({ 'a' => 1 }, '==', 'a' => 1).evaluate
-    assert_equal true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate
-  end
-
  def test_contains_works_on_arrays
    @context = Liquid::Context.new
    @context['array'] = [1, 2, 3, 4, 5]
    array_expr = VariableLookup.new("array")

-    assert_evaluates_false array_expr, 'contains', 0
-    assert_evaluates_true array_expr, 'contains', 1
-    assert_evaluates_true array_expr, 'contains', 2
-    assert_evaluates_true array_expr, 'contains', 3
-    assert_evaluates_true array_expr, 'contains', 4
-    assert_evaluates_true array_expr, 'contains', 5
-    assert_evaluates_false array_expr, 'contains', 6
-    assert_evaluates_false array_expr, 'contains', "1"
+    assert_evalutes_false array_expr, 'contains', 0
+    assert_evalutes_true array_expr, 'contains', 1
+    assert_evalutes_true array_expr, 'contains', 2
+    assert_evalutes_true array_expr, 'contains', 3
+    assert_evalutes_true array_expr, 'contains', 4
+    assert_evalutes_true array_expr, 'contains', 5
+    assert_evalutes_false array_expr, 'contains', 6
+    assert_evalutes_false array_expr, 'contains', "1"
  end

  def test_contains_returns_false_for_nil_operands
    @context = Liquid::Context.new
-    assert_evaluates_false VariableLookup.new('not_assigned'), 'contains', '0'
-    assert_evaluates_false 0, 'contains', VariableLookup.new('not_assigned')
+    assert_evalutes_false VariableLookup.new('not_assigned'), 'contains', '0'
+    assert_evalutes_false 0, 'contains', VariableLookup.new('not_assigned')
  end

  def test_contains_return_false_on_wrong_data_type
-    assert_evaluates_false 1, 'contains', 0
+    assert_evalutes_false 1, 'contains', 0
  end

  def test_contains_with_string_left_operand_coerces_right_operand_to_string
-    assert_evaluates_true ' 1 ', 'contains', 1
-    assert_evaluates_false ' 1 ', 'contains', 2
+    assert_evalutes_true ' 1 ', 'contains', 1
+    assert_evalutes_false ' 1 ', 'contains', 2
  end

  def test_or_condition
@@ -107,11 +95,11 @@ class ConditionUnitTest < Minitest::Test

    assert_equal false, condition.evaluate

-    condition.or(Condition.new(2, '==', 1))
+    condition.or Condition.new(2, '==', 1)

    assert_equal false, condition.evaluate

-    condition.or(Condition.new(1, '==', 1))
+    condition.or Condition.new(1, '==', 1)

    assert_equal true, condition.evaluate
  end
@@ -121,46 +109,46 @@ class ConditionUnitTest < Minitest::Test

    assert_equal true, condition.evaluate

-    condition.and(Condition.new(2, '==', 2))
+    condition.and Condition.new(2, '==', 2)

    assert_equal true, condition.evaluate

-    condition.and(Condition.new(2, '==', 1))
+    condition.and Condition.new(2, '==', 1)

    assert_equal false, condition.evaluate
  end

  def test_should_allow_custom_proc_operator
-    Condition.operators['starts_with'] = proc { |_cond, left, right| left =~ /^#{right}/ }
+    Condition.operators['starts_with'] = proc { |cond, left, right| left =~ %r{^#{right}} }

-    assert_evaluates_true 'bob', 'starts_with', 'b'
-    assert_evaluates_false 'bob', 'starts_with', 'o'
+    assert_evalutes_true 'bob', 'starts_with', 'b'
+    assert_evalutes_false 'bob', 'starts_with', 'o'
  ensure
-    Condition.operators.delete('starts_with')
+    Condition.operators.delete 'starts_with'
  end

  def test_left_or_right_may_contain_operators
    @context = Liquid::Context.new
    @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"

-    assert_evaluates_true VariableLookup.new("one"), '==', VariableLookup.new("another")
+    assert_evalutes_true VariableLookup.new("one"), '==', VariableLookup.new("another")
  end

  private

-  def assert_evaluates_true(left, op, right)
-    assert Condition.new(left, op, right).evaluate(@context),
+  def assert_evalutes_true(left, op, right)
+    assert Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
      "Evaluated false: #{left} #{op} #{right}"
  end

-  def assert_evaluates_false(left, op, right)
-    assert !Condition.new(left, op, right).evaluate(@context),
+  def assert_evalutes_false(left, op, right)
+    assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
      "Evaluated true: #{left} #{op} #{right}"
  end

  def assert_evaluates_argument_error(left, op, right)
    assert_raises(Liquid::ArgumentError) do
-      Condition.new(left, op, right).evaluate(@context)
+      Condition.new(left, op, right).evaluate(@context || Liquid::Context.new)
    end
  end
 end # ConditionTest
--- a/test/unit/context_unit_test.rb
+++ b/test/unit/context_unit_test.rb
@@ -70,6 +70,10 @@ class ContextUnitTest < Minitest::Test
    @context = Liquid::Context.new
  end

+  def teardown
+    Spy.teardown
+  end
+
  def test_variables
    @context['string'] = 'string'
    assert_equal 'string', @context['string']
@@ -94,12 +98,12 @@ class ContextUnitTest < Minitest::Test
    assert_equal false, @context['bool']

    @context['nil'] = nil
-    assert_nil @context['nil']
-    assert_nil @context['nil']
+    assert_equal nil, @context['nil']
+    assert_equal nil, @context['nil']
  end

  def test_variables_not_existing
-    assert_nil @context['does_not_exist']
+    assert_equal nil, @context['does_not_exist']
  end

  def test_scoping
@@ -181,7 +185,7 @@ class ContextUnitTest < Minitest::Test
    @context['test'] = 'test'
    assert_equal 'test', @context['test']
    @context.pop
-    assert_nil @context['test']
+    assert_equal nil, @context['test']
  end

  def test_hierachical_data
@@ -206,9 +210,9 @@ class ContextUnitTest < Minitest::Test
  end

  def test_merge
-    @context.merge("test" => "test")
+    @context.merge({ "test" => "test" })
    assert_equal 'test', @context['test']
-    @context.merge("test" => "newvalue", "foo" => "bar")
+    @context.merge({ "test" => "newvalue", "foo" => "bar" })
    assert_equal 'newvalue', @context['test']
    assert_equal 'bar', @context['foo']
  end
@@ -235,10 +239,10 @@ class ContextUnitTest < Minitest::Test

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

    assert_equal '003366', @context['colors.Blue[0]']
@@ -263,7 +267,7 @@ class ContextUnitTest < Minitest::Test

  def test_access_hashes_with_hash_notation
    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
-    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
+    @context['product'] = { 'variants' => [ { 'title' => 'draft151cm' }, { 'title' => 'element151cm' } ] }

    assert_equal 5, @context['products["count"]']
    assert_equal 'deepsnow', @context['products["tags"][0]']
@@ -296,12 +300,12 @@ class ContextUnitTest < Minitest::Test
    @context['hash'] = { 'first' => 'Hello' }

    assert_equal 1, @context['array.first']
-    assert_nil @context['array["first"]']
+    assert_equal nil, @context['array["first"]']
    assert_equal 'Hello', @context['hash["first"]']
  end

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

    assert_equal 'draft151cm', @context['product.variants[0].title']
    assert_equal 'element151cm', @context['product.variants[1].title']
@@ -446,14 +450,18 @@ class ContextUnitTest < Minitest::Test
    assert_equal @context, @context['category'].context
  end

-  def test_interrupt_avoids_object_allocations
-    assert_no_object_allocations do
-      @context.interrupt?
-    end
+  def test_use_empty_instead_of_any_in_interrupt_handling_to_avoid_lots_of_unnecessary_object_allocations
+    mock_any = Spy.on_instance_method(Array, :any?)
+    mock_empty = Spy.on_instance_method(Array, :empty?)
+
+    @context.interrupt?
+
+    refute mock_any.has_been_called?
+    assert mock_empty.has_been_called?
  end

  def test_context_initialization_with_a_proc_in_environment
-    contx = Context.new([test: ->(c) { c['poutine'] }], test: :foo)
+    contx = Context.new([test: ->(c) { c['poutine'] }], { test: :foo })

    assert contx
    assert_nil contx['poutine']
@@ -468,90 +476,8 @@ class ContextUnitTest < Minitest::Test
    assert_equal 'hi filtered', context.apply_global_filter('hi')
  end

-  def test_static_environments_are_read_with_lower_priority_than_environments
-    context = Context.build(
-      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
-      environments: { 'shadowed' => 'dynamic' }
-    )
-
-    assert_equal 'dynamic', context['shadowed']
-    assert_equal 'static', context['unshadowed']
-  end
-
  def test_apply_global_filter_when_no_global_filter_exist
    context = Context.new
    assert_equal 'hi', context.apply_global_filter('hi')
  end
-
-  def test_new_isolated_subcontext_does_not_inherit_variables
-    super_context = Context.new
-    super_context['my_variable'] = 'some value'
-    subcontext = super_context.new_isolated_subcontext
-
-    assert_nil subcontext['my_variable']
-  end
-
-  def test_new_isolated_subcontext_inherits_static_environment
-    super_context = Context.build(static_environments: { 'my_environment_value' => 'my value' })
-    subcontext = super_context.new_isolated_subcontext
-
-    assert_equal 'my value', subcontext['my_environment_value']
-  end
-
-  def test_new_isolated_subcontext_inherits_resource_limits
-    resource_limits = ResourceLimits.new({})
-    super_context = Context.new({}, {}, {}, false, resource_limits)
-    subcontext = super_context.new_isolated_subcontext
-    assert_equal resource_limits, subcontext.resource_limits
-  end
-
-  def test_new_isolated_subcontext_inherits_exception_renderer
-    super_context = Context.new
-    super_context.exception_renderer = ->(_e) { 'my exception message' }
-    subcontext = super_context.new_isolated_subcontext
-    assert_equal 'my exception message', subcontext.handle_error(Liquid::Error.new)
-  end
-
-  def test_new_isolated_subcontext_does_not_inherit_non_static_registers
-    registers = {
-      my_register: :my_value,
-    }
-    super_context = Context.new({}, {}, registers)
-    subcontext = super_context.new_isolated_subcontext
-    assert_nil subcontext.registers[:my_register]
-  end
-
-  def test_new_isolated_subcontext_inherits_static_registers
-    super_context = Context.build(static_registers: { my_register: :my_value })
-    subcontext = super_context.new_isolated_subcontext
-    assert_equal :my_value, subcontext.static_registers[:my_register]
-  end
-
-  def test_new_isolated_subcontext_inherits_filters
-    my_filter = Module.new do
-      def my_filter(*)
-        'my filter result'
-      end
-    end
-
-    super_context = Context.new
-    super_context.add_filters([my_filter])
-    subcontext = super_context.new_isolated_subcontext
-    template = Template.parse('{{ 123 | my_filter }}')
-    assert_equal 'my filter result', template.render(subcontext)
-  end
-
-  private
-
-  def assert_no_object_allocations
-    unless RUBY_ENGINE == 'ruby'
-      skip "stackprof needed to count object allocations"
-    end
-    require 'stackprof'
-
-    profile = StackProf.run(mode: :object) do
-      yield
-    end
-    assert_equal 0, profile[:samples]
-  end
 end # ContextTest
--- a/Show More
+++ b/Show More